source: src/io/source_wavread.c @ 69bc171

feature/autosinkfeature/cnnfeature/cnn_orgfeature/constantqfeature/crepefeature/crepe_orgfeature/pitchshiftfeature/pydocstringsfeature/timestretchfix/ffmpeg5pitchshiftsamplertimestretchyinfft+
Last change on this file since 69bc171 was 69bc171, checked in by Paul Brossier <piem@piem.org>, 10 years ago

src/io/source_wavread.c: sync error message

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