source: src/io/source_wavread.c @ 9511547

feature/autosinkfeature/cnnfeature/cnn_orgfeature/constantqfeature/crepefeature/crepe_orgfeature/pitchshiftfeature/pydocstringsfeature/timestretchfix/ffmpeg5
Last change on this file since 9511547 was 99c7aa2, checked in by Paul Brossier <piem@piem.org>, 6 years ago

src/io/source_wavread.c: also exit if samplerate is negative (closes #188)

  • Property mode set to 100644
File size: 13.6 KB
Line 
1/*
2  Copyright (C) 2014 Paul Brossier <piem@aubio.org>
3
4  This file is part of aubio.
5
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.
10
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.
15
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/>.
18
19*/
20
21#include "aubio_priv.h"
22
23#ifdef HAVE_WAVREAD
24
25#include "fvec.h"
26#include "fmat.h"
27#include "source_wavread.h"
28
29#include <errno.h>
30
31#define AUBIO_WAVREAD_BUFSIZE 1024
32
33#define SHORT_TO_FLOAT(x) (smpl_t)(x * 3.0517578125e-05)
34
35struct _aubio_source_wavread_t {
36  uint_t hop_size;
37  uint_t samplerate;
38  uint_t channels;
39
40  // some data about the file
41  char_t *path;
42  uint_t input_samplerate;
43  uint_t input_channels;
44
45  // internal stuff
46  FILE *fid;
47
48  uint_t read_samples;
49  uint_t blockalign;
50  uint_t bitspersample;
51  uint_t read_index;
52  uint_t eof;
53
54  uint_t duration;
55
56  size_t seek_start;
57
58  unsigned char *short_output;
59  fmat_t *output;
60};
61
62static unsigned int read_little_endian (unsigned char *buf,
63    unsigned int length);
64
65static unsigned int read_little_endian (unsigned char *buf,
66    unsigned int length)
67{
68  uint_t i, ret = 0;
69  for (i = 0; i < length; i++) {
70    ret += buf[i] << (i * 8);
71  }
72  return ret;
73}
74
75aubio_source_wavread_t * new_aubio_source_wavread(const char_t * path, uint_t samplerate, uint_t hop_size) {
76  aubio_source_wavread_t * s = AUBIO_NEW(aubio_source_wavread_t);
77  size_t bytes_read = 0, bytes_junk = 0, bytes_expected = 44;
78  unsigned char buf[5] = "\0";
79  unsigned int format, channels, sr, byterate, blockalign, duration, bitspersample;//, data_size;
80
81  if (path == NULL) {
82    AUBIO_ERR("source_wavread: Aborted opening null path\n");
83    goto beach;
84  }
85  if ((sint_t)samplerate < 0) {
86    AUBIO_ERR("source_wavread: Can not open %s with samplerate %d\n", path, samplerate);
87    goto beach;
88  }
89  if ((sint_t)hop_size <= 0) {
90    AUBIO_ERR("source_wavread: Can not open %s with hop_size %d\n", path, hop_size);
91    goto beach;
92  }
93
94  if (s->path) AUBIO_FREE(s->path);
95  s->path = AUBIO_ARRAY(char_t, strnlen(path, PATH_MAX) + 1);
96  strncpy(s->path, path, strnlen(path, PATH_MAX) + 1);
97
98  s->samplerate = samplerate;
99  s->hop_size = hop_size;
100
101  s->fid = fopen((const char *)path, "rb");
102  if (!s->fid) {
103    AUBIO_ERR("source_wavread: Failed opening %s (System error: %s)\n", s->path, strerror(errno));
104    goto beach;
105  }
106
107  // ChunkID
108  bytes_read += fread(buf, 1, 4, s->fid);
109  buf[4] = '\0';
110  if ( strcmp((const char *)buf, "RIFF") != 0 ) {
111    AUBIO_ERR("source_wavread: Failed opening %s (could not find RIFF header)\n", s->path);
112    goto beach;
113  }
114
115  // ChunkSize
116  bytes_read += fread(buf, 1, 4, s->fid);
117
118  // Format
119  bytes_read += fread(buf, 1, 4, s->fid);
120  buf[4] = '\0';
121  if ( strcmp((const char *)buf, "WAVE") != 0 ) {
122    AUBIO_ERR("source_wavread: Failed opening %s (wrong format in RIFF header)\n", s->path);
123    goto beach;
124  }
125
126  // Subchunk1ID
127  bytes_read += fread(buf, 1, 4, s->fid);
128  buf[4] = '\0';
129
130  // check if we have a JUNK Chunk
131  if ( strcmp((const char *)buf, "JUNK") == 0 ) {
132    bytes_junk = fread(buf, 1, 4, s->fid);
133    buf[4] = '\0';
134    bytes_junk += read_little_endian(buf, 4);
135    if (fseek(s->fid, bytes_read + bytes_junk, SEEK_SET) != 0) {
136      AUBIO_ERR("source_wavread: Failed opening %s (could not seek past JUNK Chunk: %s)\n",
137          s->path, strerror(errno));
138      goto beach;
139    }
140    bytes_read += bytes_junk;
141    bytes_expected += bytes_junk + 4;
142    // now really read the fmt chunk
143    bytes_read += fread(buf, 1, 4, s->fid);
144    buf[4] = '\0';
145  }
146
147  // get the fmt chunk
148  if ( strcmp((const char *)buf, "fmt ") != 0 ) {
149    AUBIO_ERR("source_wavread: Failed opening %s (could not find 'fmt ' in RIFF header)\n", s->path);
150    goto beach;
151  }
152
153  // Subchunk1Size
154  bytes_read += fread(buf, 1, 4, s->fid);
155  format = read_little_endian(buf, 4);
156  if ( format != 16 ) {
157    // TODO accept format 18
158    AUBIO_ERR("source_wavread: Failed opening %s (not encoded with PCM)\n", s->path);
159    goto beach;
160  }
161  if ( buf[1] || buf[2] | buf[3] ) {
162    AUBIO_ERR("source_wavread: Failed opening %s (Subchunk1Size should be 0)\n", s->path);
163    goto beach;
164  }
165
166  // AudioFormat
167  bytes_read += fread(buf, 1, 2, s->fid);
168  if ( buf[0] != 1 || buf[1] != 0) {
169    AUBIO_ERR("source_wavread: Failed opening %s (AudioFormat should be PCM)\n", s->path);
170    goto beach;
171  }
172
173  // NumChannels
174  bytes_read += fread(buf, 1, 2, s->fid);
175  channels = read_little_endian(buf, 2);
176
177  // SampleRate
178  bytes_read += fread(buf, 1, 4, s->fid);
179  sr = read_little_endian(buf, 4);
180
181  // ByteRate
182  bytes_read += fread(buf, 1, 4, s->fid);
183  byterate = read_little_endian(buf, 4);
184
185  // BlockAlign
186  bytes_read += fread(buf, 1, 2, s->fid);
187  blockalign = read_little_endian(buf, 2);
188
189  // BitsPerSample
190  bytes_read += fread(buf, 1, 2, s->fid);
191  bitspersample = read_little_endian(buf, 2);
192
193  if ( channels == 0 ) {
194    AUBIO_ERR("source_wavread: Failed opening %s (number of channels can not be 0)\n", s->path);
195    goto beach;
196  }
197
198  if ( (sint_t)sr <= 0 ) {
199    AUBIO_ERR("source_wavread: Failed opening %s (samplerate can not be <= 0)\n", s->path);
200    goto beach;
201  }
202
203  if ( byterate == 0 ) {
204    AUBIO_ERR("source_wavread: Failed opening %s (byterate can not be 0)\n", s->path);
205    goto beach;
206  }
207
208  if ( bitspersample == 0 ) {
209    AUBIO_ERR("source_wavread: Failed opening %s (bitspersample can not be 0)\n", s->path);
210    goto beach;
211  }
212#if 0
213  if ( bitspersample != 16 ) {
214    AUBIO_ERR("source_wavread: can not process %dbit file %s\n",
215        bitspersample, s->path);
216    goto beach;
217  }
218#endif
219
220  if ( byterate * 8 != sr * channels * bitspersample ) {
221    AUBIO_ERR("source_wavread: Failed opening %s (wrong byterate)\n", s->path);
222    goto beach;
223  }
224
225  if ( blockalign * 8 != channels * bitspersample ) {
226    AUBIO_ERR("source_wavread: Failed opening %s (wrong blockalign)\n", s->path);
227    goto beach;
228  }
229
230  s->input_samplerate = sr;
231  s->input_channels = channels;
232
233#if 0
234  AUBIO_DBG("channels %d\n", channels);
235  AUBIO_DBG("sr %d\n", sr);
236  AUBIO_DBG("byterate %d\n", byterate);
237  AUBIO_DBG("blockalign %d\n", blockalign);
238  AUBIO_DBG("bitspersample %d\n", bitspersample);
239
240  AUBIO_DBG("found %d channels in %s\n", s->input_channels, s->path);
241  AUBIO_DBG("found %d samplerate in %s\n", s->input_samplerate, s->path);
242#endif
243
244  if (samplerate == 0) {
245    s->samplerate = s->input_samplerate;
246  } else if (samplerate != s->input_samplerate) {
247    AUBIO_ERR("source_wavread: can not resample %s from %d to %dHz\n",
248        s->path, s->input_samplerate, samplerate);
249    goto beach;
250  }
251
252  // Subchunk2ID
253  bytes_read += fread(buf, 1, 4, s->fid);
254  buf[4] = '\0';
255  while ( strcmp((const char *)buf, "data") != 0 ) {
256    if (feof(s->fid) || ferror(s->fid)) {
257      AUBIO_ERR("source_wavread: no data RIFF header found in %s\n", s->path);
258      goto beach;
259    }
260    bytes_junk = fread(buf, 1, 4, s->fid);
261    buf[4] = '\0';
262    bytes_junk += read_little_endian(buf, 4);
263    if (fseek(s->fid, bytes_read + bytes_junk, SEEK_SET) != 0) {
264      AUBIO_ERR("source_wavread: could not seek past unknown chunk in %s (%s)\n",
265          s->path, strerror(errno));
266      goto beach;
267    }
268    bytes_read += bytes_junk;
269    bytes_expected += bytes_junk+ 4;
270    bytes_read += fread(buf, 1, 4, s->fid);
271    buf[4] = '\0';
272  }
273
274  // Subchunk2Size
275  bytes_read += fread(buf, 1, 4, s->fid);
276  duration = read_little_endian(buf, 4) / blockalign;
277
278  //data_size = buf[0] + (buf[1] << 8) + (buf[2] << 16) + (buf[3] << 24);
279  //AUBIO_MSG("found %d frames in %s\n", 8 * data_size / bitspersample / channels, s->path);
280
281  // check the total number of bytes read is correct
282  if ( bytes_read != bytes_expected ) {
283#ifndef HAVE_WIN_HACKS
284    AUBIO_ERR("source_wavread: short read (%zd instead of %zd) in %s\n",
285        bytes_read, bytes_expected, s->path);
286#else // mingw does not know about %zd...
287    AUBIO_ERR("source_wavread: short read (%d instead of %d) in %s\n",
288        (int)bytes_read, (int)bytes_expected, s->path);
289#endif
290    goto beach;
291  }
292  s->seek_start = bytes_read;
293
294  s->output = new_fmat(s->input_channels, AUBIO_WAVREAD_BUFSIZE);
295  s->blockalign= blockalign;
296  s->bitspersample = bitspersample;
297
298  s->duration = duration;
299
300  s->short_output = (unsigned char *)calloc(s->blockalign, AUBIO_WAVREAD_BUFSIZE);
301  s->read_index = 0;
302  s->read_samples = 0;
303  s->eof = 0;
304
305  return s;
306
307beach:
308  //AUBIO_ERR("source_wavread: can not read %s at samplerate %dHz with a hop_size of %d\n",
309  //    s->path, s->samplerate, s->hop_size);
310  del_aubio_source_wavread(s);
311  return NULL;
312}
313
314void aubio_source_wavread_readframe(aubio_source_wavread_t *s, uint_t *wavread_read);
315
316void aubio_source_wavread_readframe(aubio_source_wavread_t *s, uint_t *wavread_read) {
317  unsigned char *short_ptr = s->short_output;
318  size_t read = fread(short_ptr, s->blockalign, AUBIO_WAVREAD_BUFSIZE, s->fid);
319  uint_t i, j, b, bitspersample = s->bitspersample;
320  uint_t wrap_at = (1 << ( bitspersample - 1 ) );
321  uint_t wrap_with = (1 << bitspersample);
322  smpl_t scaler = 1. / wrap_at;
323  int signed_val = 0;
324  unsigned int unsigned_val = 0;
325
326  for (j = 0; j < read; j++) {
327    for (i = 0; i < s->input_channels; i++) {
328      unsigned_val = 0;
329      for (b = 0; b < bitspersample; b+=8 ) {
330        unsigned_val += *(short_ptr) << b;
331        short_ptr++;
332      }
333      signed_val = unsigned_val;
334      // FIXME why does 8 bit conversion maps [0;255] to [-128;127]
335      // instead of [0;127] to [0;127] and [128;255] to [-128;-1]
336      if (bitspersample == 8) signed_val -= wrap_at;
337      else if (unsigned_val >= wrap_at) signed_val = unsigned_val - wrap_with;
338      s->output->data[i][j] = signed_val * scaler;
339    }
340  }
341
342  *wavread_read = read;
343
344  if (read == 0) s->eof = 1;
345}
346
347void aubio_source_wavread_do(aubio_source_wavread_t * s, fvec_t * read_data, uint_t * read){
348  uint_t i, j;
349  uint_t end = 0;
350  uint_t total_wrote = 0;
351  if (s->fid == NULL) {
352    AUBIO_ERR("source_wavread: could not read from %s (file not opened)\n",
353        s->path);
354    return;
355  }
356  while (total_wrote < s->hop_size) {
357    end = MIN(s->read_samples - s->read_index, s->hop_size - 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];
362      }
363      read_data->data[i + total_wrote] /= (smpl_t)(s->input_channels);
364    }
365    total_wrote += end;
366    if (total_wrote < s->hop_size) {
367      uint_t wavread_read = 0;
368      aubio_source_wavread_readframe(s, &wavread_read);
369      s->read_samples = wavread_read;
370      s->read_index = 0;
371      if (s->eof) {
372        break;
373      }
374    } else {
375      s->read_index += end;
376    }
377  }
378  if (total_wrote < s->hop_size) {
379    for (i = end; i < s->hop_size; i++) {
380      read_data->data[i] = 0.;
381    }
382  }
383  *read = total_wrote;
384}
385
386void aubio_source_wavread_do_multi(aubio_source_wavread_t * s, fmat_t * read_data, uint_t * read){
387  uint_t i,j;
388  uint_t end = 0;
389  uint_t total_wrote = 0;
390  if (s->fid == NULL) {
391    AUBIO_ERR("source_wavread: could not read from %s (file not opened)\n",
392        s->path);
393    return;
394  }
395  while (total_wrote < s->hop_size) {
396    end = MIN(s->read_samples - s->read_index, s->hop_size - total_wrote);
397    for (j = 0; j < read_data->height; j++) {
398      for (i = 0; i < end; i++) {
399        read_data->data[j][i + total_wrote] = s->output->data[j][i];
400      }
401    }
402    total_wrote += end;
403    if (total_wrote < s->hop_size) {
404      uint_t wavread_read = 0;
405      aubio_source_wavread_readframe(s, &wavread_read);
406      s->read_samples = wavread_read;
407      s->read_index = 0;
408      if (s->eof) {
409        break;
410      }
411    } else {
412      s->read_index += end;
413    }
414  }
415  if (total_wrote < s->hop_size) {
416    for (j = 0; j < read_data->height; j++) {
417      for (i = end; i < s->hop_size; i++) {
418        read_data->data[j][i] = 0.;
419      }
420    }
421  }
422  *read = total_wrote;
423}
424
425uint_t aubio_source_wavread_get_samplerate(aubio_source_wavread_t * s) {
426  return s->samplerate;
427}
428
429uint_t aubio_source_wavread_get_channels(aubio_source_wavread_t * s) {
430  return s->input_channels;
431}
432
433uint_t aubio_source_wavread_seek (aubio_source_wavread_t * s, uint_t pos) {
434  uint_t ret = 0;
435  if (s->fid == NULL) {
436    AUBIO_ERR("source_wavread: could not seek %s (file not opened?)\n", s->path, pos);
437    return AUBIO_FAIL;
438  }
439  if ((sint_t)pos < 0) {
440    AUBIO_ERR("source_wavread: could not seek %s at %d (seeking position should be >= 0)\n", s->path, pos);
441    return AUBIO_FAIL;
442  }
443  ret = fseek(s->fid, s->seek_start + pos * s->blockalign, SEEK_SET);
444  if (ret != 0) {
445    AUBIO_ERR("source_wavread: could not seek %s at %d (%s)\n", s->path, pos, strerror(errno));
446    return AUBIO_FAIL;
447  }
448  // reset some values
449  s->eof = 0;
450  s->read_index = 0;
451  return AUBIO_OK;
452}
453
454uint_t aubio_source_wavread_get_duration (const aubio_source_wavread_t * s) {
455  if (s && s->duration) {
456    return s->duration;
457  }
458  return 0;
459}
460
461uint_t aubio_source_wavread_close (aubio_source_wavread_t * s) {
462  if (s->fid == NULL) {
463    return AUBIO_OK;
464  }
465  if (fclose(s->fid)) {
466    AUBIO_ERR("source_wavread: could not close %s (%s)\n", s->path, strerror(errno));
467    return AUBIO_FAIL;
468  }
469  s->fid = NULL;
470  return AUBIO_OK;
471}
472
473void del_aubio_source_wavread(aubio_source_wavread_t * s) {
474  if (!s) return;
475  aubio_source_wavread_close(s);
476  if (s->short_output) AUBIO_FREE(s->short_output);
477  if (s->output) del_fmat(s->output);
478  if (s->path) AUBIO_FREE(s->path);
479  AUBIO_FREE(s);
480}
481
482#endif /* HAVE_WAVREAD */
Note: See TracBrowser for help on using the repository browser.