source: src/io/source_wavread.c @ c952f42

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

src/io/source_wavread.c: cast size_t to int to avoid warning on win64

  • Property mode set to 100644
File size: 10.9 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        bytes_read, bytes_expected, s->path);
223#else // mingw does not know about %zd...
224    AUBIO_ERR("source_wavread: short read (%d instead of %d) in %s\n",
225        (int)bytes_read, (int)bytes_expected, s->path);
226#endif
227    goto beach;
228  }
229  s->seek_start = bytes_read;
230
231  s->output = new_fmat(s->input_channels, AUBIO_WAVREAD_BUFSIZE);
232  s->blockalign= blockalign;
233  s->bitspersample = bitspersample;
234
235  s->short_output = (unsigned char *)calloc(s->blockalign, AUBIO_WAVREAD_BUFSIZE);
236  s->read_index = 0;
237  s->read_samples = 0;
238  s->eof = 0;
239
240  return s;
241
242beach:
243  //AUBIO_ERR("source_wavread: can not read %s at samplerate %dHz with a hop_size of %d\n",
244  //    s->path, s->samplerate, s->hop_size);
245  del_aubio_source_wavread(s);
246  return NULL;
247}
248
249void aubio_source_wavread_readframe(aubio_source_wavread_t *s, uint_t *wavread_read);
250
251void aubio_source_wavread_readframe(aubio_source_wavread_t *s, uint_t *wavread_read) {
252  unsigned char *short_ptr = s->short_output;
253  size_t read = fread(short_ptr, s->blockalign, AUBIO_WAVREAD_BUFSIZE, s->fid);
254  uint_t i, j, b, bitspersample = s->bitspersample;
255  uint_t wrap_at = (1 << ( bitspersample - 1 ) );
256  uint_t wrap_with = (1 << bitspersample);
257  smpl_t scaler = 1. / wrap_at;
258  int signed_val = 0;
259  unsigned int unsigned_val = 0;
260
261  for (j = 0; j < read; j++) {
262    for (i = 0; i < s->input_channels; i++) {
263      unsigned_val = 0;
264      for (b = 0; b < bitspersample; b+=8 ) {
265        unsigned_val += *(short_ptr) << b;
266        short_ptr++;
267      }
268      signed_val = unsigned_val;
269      // FIXME why does 8 bit conversion maps [0;255] to [-128;127]
270      // instead of [0;127] to [0;127] and [128;255] to [-128;-1]
271      if (bitspersample == 8) signed_val -= wrap_at;
272      else if (unsigned_val >= wrap_at) signed_val = unsigned_val - wrap_with;
273      s->output->data[i][j] = signed_val * scaler;
274    }
275  }
276
277  *wavread_read = read;
278
279  if (read == 0) s->eof = 1;
280}
281
282void aubio_source_wavread_do(aubio_source_wavread_t * s, fvec_t * read_data, uint_t * read){
283  uint_t i, j;
284  uint_t end = 0;
285  uint_t total_wrote = 0;
286  while (total_wrote < s->hop_size) {
287    end = MIN(s->read_samples - s->read_index, s->hop_size - total_wrote);
288    for (i = 0; i < end; i++) {
289      read_data->data[i + total_wrote] = 0;
290      for (j = 0; j < s->input_channels; j++ ) {
291        read_data->data[i + total_wrote] += s->output->data[j][i + s->read_index];
292      }
293      read_data->data[i + total_wrote] /= (smpl_t)(s->input_channels);
294    }
295    total_wrote += end;
296    if (total_wrote < s->hop_size) {
297      uint_t wavread_read = 0;
298      aubio_source_wavread_readframe(s, &wavread_read);
299      s->read_samples = wavread_read;
300      s->read_index = 0;
301      if (s->eof) {
302        break;
303      }
304    } else {
305      s->read_index += end;
306    }
307  }
308  if (total_wrote < s->hop_size) {
309    for (i = end; i < s->hop_size; i++) {
310      read_data->data[i] = 0.;
311    }
312  }
313  *read = total_wrote;
314}
315
316void aubio_source_wavread_do_multi(aubio_source_wavread_t * s, fmat_t * read_data, uint_t * read){
317  uint_t i,j;
318  uint_t end = 0;
319  uint_t total_wrote = 0;
320  while (total_wrote < s->hop_size) {
321    end = MIN(s->read_samples - s->read_index, s->hop_size - total_wrote);
322    for (j = 0; j < read_data->height; j++) {
323      for (i = 0; i < end; i++) {
324        read_data->data[j][i + total_wrote] = s->output->data[j][i];
325      }
326    }
327    total_wrote += end;
328    if (total_wrote < s->hop_size) {
329      uint_t wavread_read = 0;
330      aubio_source_wavread_readframe(s, &wavread_read);
331      s->read_samples = wavread_read;
332      s->read_index = 0;
333      if (s->eof) {
334        break;
335      }
336    } else {
337      s->read_index += end;
338    }
339  }
340  if (total_wrote < s->hop_size) {
341    for (j = 0; j < read_data->height; j++) {
342      for (i = end; i < s->hop_size; i++) {
343        read_data->data[j][i] = 0.;
344      }
345    }
346  }
347  *read = total_wrote;
348}
349
350uint_t aubio_source_wavread_get_samplerate(aubio_source_wavread_t * s) {
351  return s->samplerate;
352}
353
354uint_t aubio_source_wavread_get_channels(aubio_source_wavread_t * s) {
355  return s->input_channels;
356}
357
358uint_t aubio_source_wavread_seek (aubio_source_wavread_t * s, uint_t pos) {
359  uint_t ret = 0;
360  if ((sint_t)pos < 0) {
361    return AUBIO_FAIL;
362  }
363  ret = fseek(s->fid, s->seek_start + pos * s->blockalign, SEEK_SET);
364  if (ret != 0) {
365    AUBIO_ERR("source_wavread: could not seek %s at %d (%s)\n", s->path, pos, strerror(errno));
366    return AUBIO_FAIL;
367  }
368  // reset some values
369  s->eof = 0;
370  s->read_index = 0;
371  return AUBIO_OK;
372}
373
374uint_t aubio_source_wavread_close (aubio_source_wavread_t * s) {
375  if (!s->fid) {
376    return AUBIO_FAIL;
377  }
378  if (fclose(s->fid)) {
379    AUBIO_ERR("source_wavread: could not close %s (%s)\n", s->path, strerror(errno));
380    return AUBIO_FAIL;
381  }
382  s->fid = NULL;
383  return AUBIO_OK;
384}
385
386void del_aubio_source_wavread(aubio_source_wavread_t * s) {
387  if (!s) return;
388  aubio_source_wavread_close(s);
389  if (s->short_output) AUBIO_FREE(s->short_output);
390  if (s->output) del_fmat(s->output);
391  AUBIO_FREE(s);
392}
393
394#endif /* HAVE_WAVREAD */
Note: See TracBrowser for help on using the repository browser.