2 Copyright (C) 2014 Paul Brossier <piem@aubio.org>
4 This file is part of aubio.
6 aubio is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 aubio is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with aubio. If not, see <http://www.gnu.org/licenses/>.
21 #include "aubio_priv.h"
28 #include "source_wavread.h"
30 #define AUBIO_WAVREAD_BUFSIZE 1024
32 //#define SHORT_TO_FLOAT(x) (smpl_t)(x * 3.0517578125e-05)
34 struct _aubio_source_wavread_t {
39 // some data about the file
41 uint_t input_samplerate;
42 uint_t input_channels;
57 unsigned char *short_output;
61 static unsigned int read_little_endian (unsigned char *buf,
64 static unsigned int read_little_endian (unsigned char *buf,
68 for (i = 0; i < length; i++) {
69 ret += buf[i] << (i * 8);
74 aubio_source_wavread_t * new_aubio_source_wavread(const char_t * path, uint_t samplerate, uint_t hop_size) {
75 aubio_source_wavread_t * s = AUBIO_NEW(aubio_source_wavread_t);
76 size_t bytes_read = 0, bytes_junk = 0, bytes_expected = 44;
77 unsigned char buf[5] = "\0";
78 unsigned int format, channels, sr, byterate, blockalign, duration, bitspersample;//, data_size;
81 AUBIO_ERR("source_wavread: Aborted opening null path\n");
84 if ((sint_t)samplerate < 0) {
85 AUBIO_ERR("source_wavread: Can not open %s with samplerate %d\n", path, samplerate);
88 if ((sint_t)hop_size <= 0) {
89 AUBIO_ERR("source_wavread: Can not open %s with hop_size %d\n", path, hop_size);
93 s->path = AUBIO_ARRAY(char_t, strnlen(path, PATH_MAX) + 1);
94 strncpy(s->path, path, strnlen(path, PATH_MAX) + 1);
96 s->samplerate = samplerate;
97 s->hop_size = hop_size;
99 s->fid = fopen((const char *)path, "rb");
101 AUBIO_STRERR("source_wavread: Failed opening %s (%s)\n", s->path, errorstr);
106 bytes_read += fread(buf, 1, 4, s->fid);
108 if ( strcmp((const char *)buf, "RIFF") != 0 ) {
109 AUBIO_ERR("source_wavread: Failed opening %s (could not find RIFF header)\n", s->path);
114 bytes_read += fread(buf, 1, 4, s->fid);
117 bytes_read += fread(buf, 1, 4, s->fid);
119 if ( strcmp((const char *)buf, "WAVE") != 0 ) {
120 AUBIO_ERR("source_wavread: Failed opening %s (wrong format in RIFF header)\n", s->path);
125 bytes_read += fread(buf, 1, 4, s->fid);
128 // check if we have a JUNK Chunk
129 if ( strcmp((const char *)buf, "JUNK") == 0 ) {
130 bytes_junk = fread(buf, 1, 4, s->fid);
132 bytes_junk += read_little_endian(buf, 4);
133 if (fseek(s->fid, bytes_read + bytes_junk, SEEK_SET) != 0) {
134 AUBIO_STRERR("source_wavread: Failed opening %s (could not seek past JUNK Chunk: %s)\n",
138 bytes_read += bytes_junk;
139 bytes_expected += bytes_junk + 4;
140 // now really read the fmt chunk
141 bytes_read += fread(buf, 1, 4, s->fid);
146 if ( strcmp((const char *)buf, "fmt ") != 0 ) {
147 AUBIO_ERR("source_wavread: Failed opening %s (could not find 'fmt ' in RIFF header)\n", s->path);
152 bytes_read += fread(buf, 1, 4, s->fid);
153 format = read_little_endian(buf, 4);
154 if ( format != 16 ) {
155 // TODO accept format 18
156 AUBIO_ERR("source_wavread: Failed opening %s (not encoded with PCM)\n", s->path);
159 if ( buf[1] || buf[2] | buf[3] ) {
160 AUBIO_ERR("source_wavread: Failed opening %s (Subchunk1Size should be 0)\n", s->path);
165 bytes_read += fread(buf, 1, 2, s->fid);
166 if ( buf[0] != 1 || buf[1] != 0) {
167 AUBIO_ERR("source_wavread: Failed opening %s (AudioFormat should be PCM)\n", s->path);
172 bytes_read += fread(buf, 1, 2, s->fid);
173 channels = read_little_endian(buf, 2);
176 bytes_read += fread(buf, 1, 4, s->fid);
177 sr = read_little_endian(buf, 4);
180 bytes_read += fread(buf, 1, 4, s->fid);
181 byterate = read_little_endian(buf, 4);
184 bytes_read += fread(buf, 1, 2, s->fid);
185 blockalign = read_little_endian(buf, 2);
188 bytes_read += fread(buf, 1, 2, s->fid);
189 bitspersample = read_little_endian(buf, 2);
191 if ( channels == 0 ) {
192 AUBIO_ERR("source_wavread: Failed opening %s (number of channels can not be 0)\n", s->path);
196 if ( (sint_t)sr <= 0 ) {
197 AUBIO_ERR("source_wavread: Failed opening %s (samplerate can not be <= 0)\n", s->path);
201 if ( byterate == 0 ) {
202 AUBIO_ERR("source_wavread: Failed opening %s (byterate can not be 0)\n", s->path);
206 if ( bitspersample == 0 ) {
207 AUBIO_ERR("source_wavread: Failed opening %s (bitspersample can not be 0)\n", s->path);
211 if ( bitspersample != 16 ) {
212 AUBIO_ERR("source_wavread: can not process %dbit file %s\n",
213 bitspersample, s->path);
218 if ( byterate * 8 != sr * channels * bitspersample ) {
219 AUBIO_ERR("source_wavread: Failed opening %s (wrong byterate)\n", s->path);
223 if ( blockalign * 8 != channels * bitspersample ) {
224 AUBIO_ERR("source_wavread: Failed opening %s (wrong blockalign)\n", s->path);
228 s->input_samplerate = sr;
229 s->input_channels = channels;
232 AUBIO_DBG("channels %d\n", channels);
233 AUBIO_DBG("sr %d\n", sr);
234 AUBIO_DBG("byterate %d\n", byterate);
235 AUBIO_DBG("blockalign %d\n", blockalign);
236 AUBIO_DBG("bitspersample %d\n", bitspersample);
238 AUBIO_DBG("found %d channels in %s\n", s->input_channels, s->path);
239 AUBIO_DBG("found %d samplerate in %s\n", s->input_samplerate, s->path);
242 if (samplerate == 0) {
243 s->samplerate = s->input_samplerate;
244 } else if (samplerate != s->input_samplerate) {
245 AUBIO_ERR("source_wavread: can not resample %s from %d to %dHz\n",
246 s->path, s->input_samplerate, samplerate);
251 bytes_read += fread(buf, 1, 4, s->fid);
253 while ( strcmp((const char *)buf, "data") != 0 ) {
254 if (feof(s->fid) || ferror(s->fid)) {
255 AUBIO_ERR("source_wavread: no data RIFF header found in %s\n", s->path);
258 bytes_junk = fread(buf, 1, 4, s->fid);
260 bytes_junk += read_little_endian(buf, 4);
261 if (fseek(s->fid, bytes_read + bytes_junk, SEEK_SET) != 0) {
262 AUBIO_STRERR("source_wavread: could not seek past unknown chunk in %s (%s)\n",
266 bytes_read += bytes_junk;
267 bytes_expected += bytes_junk+ 4;
268 bytes_read += fread(buf, 1, 4, s->fid);
273 bytes_read += fread(buf, 1, 4, s->fid);
274 duration = read_little_endian(buf, 4) / blockalign;
276 //data_size = buf[0] + (buf[1] << 8) + (buf[2] << 16) + (buf[3] << 24);
277 //AUBIO_MSG("found %d frames in %s\n", 8 * data_size / bitspersample / channels, s->path);
279 // check the total number of bytes read is correct
280 if ( bytes_read != bytes_expected ) {
281 #ifndef HAVE_WIN_HACKS
282 AUBIO_ERR("source_wavread: short read (%zd instead of %zd) in %s\n",
283 bytes_read, bytes_expected, s->path);
284 #else // mingw does not know about %zd...
285 AUBIO_ERR("source_wavread: short read (%d instead of %d) in %s\n",
286 (int)bytes_read, (int)bytes_expected, s->path);
290 s->seek_start = bytes_read;
292 s->output = new_fmat(s->input_channels, AUBIO_WAVREAD_BUFSIZE);
293 s->blockalign= blockalign;
294 s->bitspersample = bitspersample;
296 s->duration = duration;
298 s->short_output = (unsigned char *)calloc(s->blockalign, AUBIO_WAVREAD_BUFSIZE);
306 //AUBIO_ERR("source_wavread: can not read %s at samplerate %dHz with a hop_size of %d\n",
307 // s->path, s->samplerate, s->hop_size);
308 del_aubio_source_wavread(s);
312 void aubio_source_wavread_readframe(aubio_source_wavread_t *s, uint_t *wavread_read);
314 void aubio_source_wavread_readframe(aubio_source_wavread_t *s, uint_t *wavread_read) {
315 unsigned char *short_ptr = s->short_output;
316 size_t read = fread(short_ptr, s->blockalign, AUBIO_WAVREAD_BUFSIZE, s->fid);
317 uint_t i, j, b, bitspersample = s->bitspersample;
318 uint_t wrap_at = (1 << ( bitspersample - 1 ) );
319 uint_t wrap_with = (1 << bitspersample);
320 smpl_t scaler = 1. / wrap_at;
322 unsigned int unsigned_val = 0;
324 for (j = 0; j < read; j++) {
325 for (i = 0; i < s->input_channels; i++) {
327 for (b = 0; b < bitspersample; b+=8 ) {
328 unsigned_val += *(short_ptr) << b;
331 signed_val = unsigned_val;
332 // FIXME why does 8 bit conversion maps [0;255] to [-128;127]
333 // instead of [0;127] to [0;127] and [128;255] to [-128;-1]
334 if (bitspersample == 8) signed_val -= wrap_at;
335 else if (unsigned_val >= wrap_at) signed_val = unsigned_val - wrap_with;
336 s->output->data[i][j] = signed_val * scaler;
340 *wavread_read = read;
342 if (read == 0) s->eof = 1;
345 void aubio_source_wavread_do(aubio_source_wavread_t * s, fvec_t * read_data, uint_t * read){
348 uint_t total_wrote = 0;
349 uint_t length = aubio_source_validate_input_length("source_wavread", s->path,
350 s->hop_size, read_data->length);
351 if (s->fid == NULL) {
352 AUBIO_ERR("source_wavread: could not read from %s (file not opened)\n",
356 while (total_wrote < length) {
357 end = MIN(s->read_samples - s->read_index, length - total_wrote);
358 for (i = 0; i < end; i++) {
359 read_data->data[i + total_wrote] = 0;
360 for (j = 0; j < s->input_channels; j++ ) {
361 read_data->data[i + total_wrote] += s->output->data[j][i + s->read_index];
363 read_data->data[i + total_wrote] /= (smpl_t)(s->input_channels);
366 if (total_wrote < length) {
367 uint_t wavread_read = 0;
368 aubio_source_wavread_readframe(s, &wavread_read);
369 s->read_samples = wavread_read;
375 s->read_index += end;
379 aubio_source_pad_output (read_data, total_wrote);
384 void aubio_source_wavread_do_multi(aubio_source_wavread_t * s, fmat_t * read_data, uint_t * read){
387 uint_t total_wrote = 0;
388 uint_t length = aubio_source_validate_input_length("source_wavread", s->path,
389 s->hop_size, read_data->length);
390 uint_t channels = aubio_source_validate_input_channels("source_wavread",
391 s->path, s->input_channels, read_data->height);
392 if (s->fid == NULL) {
393 AUBIO_ERR("source_wavread: could not read from %s (file not opened)\n",
397 while (total_wrote < length) {
398 end = MIN(s->read_samples - s->read_index, length - total_wrote);
399 for (j = 0; j < channels; j++) {
400 for (i = 0; i < end; i++) {
401 read_data->data[j][i + total_wrote] = s->output->data[j][i];
405 if (total_wrote < length) {
406 uint_t wavread_read = 0;
407 aubio_source_wavread_readframe(s, &wavread_read);
408 s->read_samples = wavread_read;
414 s->read_index += end;
418 aubio_source_pad_multi_output(read_data, s->input_channels, total_wrote);
423 uint_t aubio_source_wavread_get_samplerate(aubio_source_wavread_t * s) {
424 return s->samplerate;
427 uint_t aubio_source_wavread_get_channels(aubio_source_wavread_t * s) {
428 return s->input_channels;
431 uint_t aubio_source_wavread_seek (aubio_source_wavread_t * s, uint_t pos) {
433 if (s->fid == NULL) {
434 AUBIO_ERR("source_wavread: could not seek %s (file not opened?)\n", s->path, pos);
437 if ((sint_t)pos < 0) {
438 AUBIO_ERR("source_wavread: could not seek %s at %d (seeking position should be >= 0)\n", s->path, pos);
441 ret = fseek(s->fid, s->seek_start + pos * s->blockalign, SEEK_SET);
443 AUBIO_STRERR("source_wavread: could not seek %s at %d (%s)\n", s->path, pos, errorstr);
452 uint_t aubio_source_wavread_get_duration (const aubio_source_wavread_t * s) {
453 if (s && s->duration) {
459 uint_t aubio_source_wavread_close (aubio_source_wavread_t * s) {
460 if (s->fid == NULL) {
463 if (fclose(s->fid)) {
464 AUBIO_STRERR("source_wavread: could not close %s (%s)\n", s->path, errorstr);
471 void del_aubio_source_wavread(aubio_source_wavread_t * s) {
473 aubio_source_wavread_close(s);
474 if (s->short_output) AUBIO_FREE(s->short_output);
475 if (s->output) del_fmat(s->output);
476 if (s->path) AUBIO_FREE(s->path);
480 #endif /* HAVE_WAVREAD */