0a777632f5d5d5a59343d43f6f5affcb404e3482
[aubio.git] / src / io / source_wavread.c
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 "ioutils.h"
28 #include "source_wavread.h"
29
30 #define AUBIO_WAVREAD_BUFSIZE 1024
31
32 #define SHORT_TO_FLOAT(x) (smpl_t)(x * 3.0517578125e-05)
33
34 struct _aubio_source_wavread_t {
35   uint_t hop_size;
36   uint_t samplerate;
37   uint_t channels;
38
39   // some data about the file
40   char_t *path;
41   uint_t input_samplerate;
42   uint_t input_channels;
43
44   // internal stuff
45   FILE *fid;
46
47   uint_t read_samples;
48   uint_t blockalign;
49   uint_t bitspersample;
50   uint_t read_index;
51   uint_t eof;
52
53   uint_t duration;
54
55   size_t seek_start;
56
57   unsigned char *short_output;
58   fmat_t *output;
59 };
60
61 static unsigned int read_little_endian (unsigned char *buf,
62     unsigned int length);
63
64 static unsigned int read_little_endian (unsigned char *buf,
65     unsigned int length)
66 {
67   uint_t i, ret = 0;
68   for (i = 0; i < length; i++) {
69     ret += buf[i] << (i * 8);
70   }
71   return ret;
72 }
73
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;
79
80   if (path == NULL) {
81     AUBIO_ERR("source_wavread: Aborted opening null path\n");
82     goto beach;
83   }
84   if ((sint_t)samplerate < 0) {
85     AUBIO_ERR("source_wavread: Can not open %s with samplerate %d\n", path, samplerate);
86     goto beach;
87   }
88   if ((sint_t)hop_size <= 0) {
89     AUBIO_ERR("source_wavread: Can not open %s with hop_size %d\n", path, hop_size);
90     goto beach;
91   }
92
93   s->path = AUBIO_ARRAY(char_t, strnlen(path, PATH_MAX) + 1);
94   strncpy(s->path, path, strnlen(path, PATH_MAX) + 1);
95
96   s->samplerate = samplerate;
97   s->hop_size = hop_size;
98
99   s->fid = fopen((const char *)path, "rb");
100   if (!s->fid) {
101     AUBIO_STRERR("source_wavread: Failed opening %s (%s)\n", s->path, errorstr);
102     goto beach;
103   }
104
105   // ChunkID
106   bytes_read += fread(buf, 1, 4, s->fid);
107   buf[4] = '\0';
108   if ( strcmp((const char *)buf, "RIFF") != 0 ) {
109     AUBIO_ERR("source_wavread: Failed opening %s (could not find RIFF header)\n", s->path);
110     goto beach;
111   }
112
113   // ChunkSize
114   bytes_read += fread(buf, 1, 4, s->fid);
115
116   // Format
117   bytes_read += fread(buf, 1, 4, s->fid);
118   buf[4] = '\0';
119   if ( strcmp((const char *)buf, "WAVE") != 0 ) {
120     AUBIO_ERR("source_wavread: Failed opening %s (wrong format in RIFF header)\n", s->path);
121     goto beach;
122   }
123
124   // Subchunk1ID
125   bytes_read += fread(buf, 1, 4, s->fid);
126   buf[4] = '\0';
127
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);
131     buf[4] = '\0';
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",
135           s->path, errorstr);
136       goto beach;
137     }
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);
142     buf[4] = '\0';
143   }
144
145   // get the fmt chunk
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);
148     goto beach;
149   }
150
151   // Subchunk1Size
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);
157     goto beach;
158   }
159   if ( buf[1] || buf[2] | buf[3] ) {
160     AUBIO_ERR("source_wavread: Failed opening %s (Subchunk1Size should be 0)\n", s->path);
161     goto beach;
162   }
163
164   // AudioFormat
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);
168     goto beach;
169   }
170
171   // NumChannels
172   bytes_read += fread(buf, 1, 2, s->fid);
173   channels = read_little_endian(buf, 2);
174
175   // SampleRate
176   bytes_read += fread(buf, 1, 4, s->fid);
177   sr = read_little_endian(buf, 4);
178
179   // ByteRate
180   bytes_read += fread(buf, 1, 4, s->fid);
181   byterate = read_little_endian(buf, 4);
182
183   // BlockAlign
184   bytes_read += fread(buf, 1, 2, s->fid);
185   blockalign = read_little_endian(buf, 2);
186
187   // BitsPerSample
188   bytes_read += fread(buf, 1, 2, s->fid);
189   bitspersample = read_little_endian(buf, 2);
190
191   if ( channels == 0 ) {
192     AUBIO_ERR("source_wavread: Failed opening %s (number of channels can not be 0)\n", s->path);
193     goto beach;
194   }
195
196   if ( (sint_t)sr <= 0 ) {
197     AUBIO_ERR("source_wavread: Failed opening %s (samplerate can not be <= 0)\n", s->path);
198     goto beach;
199   }
200
201   if ( byterate == 0 ) {
202     AUBIO_ERR("source_wavread: Failed opening %s (byterate can not be 0)\n", s->path);
203     goto beach;
204   }
205
206   if ( bitspersample == 0 ) {
207     AUBIO_ERR("source_wavread: Failed opening %s (bitspersample can not be 0)\n", s->path);
208     goto beach;
209   }
210 #if 0
211   if ( bitspersample != 16 ) {
212     AUBIO_ERR("source_wavread: can not process %dbit file %s\n",
213         bitspersample, s->path);
214     goto beach;
215   }
216 #endif
217
218   if ( byterate * 8 != sr * channels * bitspersample ) {
219     AUBIO_ERR("source_wavread: Failed opening %s (wrong byterate)\n", s->path);
220     goto beach;
221   }
222
223   if ( blockalign * 8 != channels * bitspersample ) {
224     AUBIO_ERR("source_wavread: Failed opening %s (wrong blockalign)\n", s->path);
225     goto beach;
226   }
227
228   s->input_samplerate = sr;
229   s->input_channels = channels;
230
231 #if 0
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);
237
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);
240 #endif
241
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);
247     goto beach;
248   }
249
250   // Subchunk2ID
251   bytes_read += fread(buf, 1, 4, s->fid);
252   buf[4] = '\0';
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);
256       goto beach;
257     }
258     bytes_junk = fread(buf, 1, 4, s->fid);
259     buf[4] = '\0';
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",
263           s->path, errorstr);
264       goto beach;
265     }
266     bytes_read += bytes_junk;
267     bytes_expected += bytes_junk+ 4;
268     bytes_read += fread(buf, 1, 4, s->fid);
269     buf[4] = '\0';
270   }
271
272   // Subchunk2Size
273   bytes_read += fread(buf, 1, 4, s->fid);
274   duration = read_little_endian(buf, 4) / blockalign;
275
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);
278
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);
287 #endif
288     goto beach;
289   }
290   s->seek_start = bytes_read;
291
292   s->output = new_fmat(s->input_channels, AUBIO_WAVREAD_BUFSIZE);
293   s->blockalign= blockalign;
294   s->bitspersample = bitspersample;
295
296   s->duration = duration;
297
298   s->short_output = (unsigned char *)calloc(s->blockalign, AUBIO_WAVREAD_BUFSIZE);
299   s->read_index = 0;
300   s->read_samples = 0;
301   s->eof = 0;
302
303   return s;
304
305 beach:
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);
309   return NULL;
310 }
311
312 void aubio_source_wavread_readframe(aubio_source_wavread_t *s, uint_t *wavread_read);
313
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;
321   int signed_val = 0;
322   unsigned int unsigned_val = 0;
323
324   for (j = 0; j < read; j++) {
325     for (i = 0; i < s->input_channels; i++) {
326       unsigned_val = 0;
327       for (b = 0; b < bitspersample; b+=8 ) {
328         unsigned_val += *(short_ptr) << b;
329         short_ptr++;
330       }
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;
337     }
338   }
339
340   *wavread_read = read;
341
342   if (read == 0) s->eof = 1;
343 }
344
345 void aubio_source_wavread_do(aubio_source_wavread_t * s, fvec_t * read_data, uint_t * read){
346   uint_t i, j;
347   uint_t end = 0;
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",
353         s->path);
354     return;
355   }
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];
362       }
363       read_data->data[i + total_wrote] /= (smpl_t)(s->input_channels);
364     }
365     total_wrote += end;
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;
370       s->read_index = 0;
371       if (s->eof) {
372         break;
373       }
374     } else {
375       s->read_index += end;
376     }
377   }
378
379   aubio_source_pad_output (read_data, total_wrote);
380
381   *read = total_wrote;
382 }
383
384 void aubio_source_wavread_do_multi(aubio_source_wavread_t * s, fmat_t * read_data, uint_t * read){
385   uint_t i,j;
386   uint_t end = 0;
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",
394         s->path);
395     return;
396   }
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];
402       }
403     }
404     total_wrote += end;
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;
409       s->read_index = 0;
410       if (s->eof) {
411         break;
412       }
413     } else {
414       s->read_index += end;
415     }
416   }
417
418   aubio_source_pad_multi_output(read_data, s->input_channels, total_wrote);
419
420   *read = total_wrote;
421 }
422
423 uint_t aubio_source_wavread_get_samplerate(aubio_source_wavread_t * s) {
424   return s->samplerate;
425 }
426
427 uint_t aubio_source_wavread_get_channels(aubio_source_wavread_t * s) {
428   return s->input_channels;
429 }
430
431 uint_t aubio_source_wavread_seek (aubio_source_wavread_t * s, uint_t pos) {
432   uint_t ret = 0;
433   if (s->fid == NULL) {
434     AUBIO_ERR("source_wavread: could not seek %s (file not opened?)\n", s->path, pos);
435     return AUBIO_FAIL;
436   }
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);
439     return AUBIO_FAIL;
440   }
441   ret = fseek(s->fid, s->seek_start + pos * s->blockalign, SEEK_SET);
442   if (ret != 0) {
443     AUBIO_STRERR("source_wavread: could not seek %s at %d (%s)\n", s->path, pos, errorstr);
444     return AUBIO_FAIL;
445   }
446   // reset some values
447   s->eof = 0;
448   s->read_index = 0;
449   return AUBIO_OK;
450 }
451
452 uint_t aubio_source_wavread_get_duration (const aubio_source_wavread_t * s) {
453   if (s && s->duration) {
454     return s->duration;
455   }
456   return 0;
457 }
458
459 uint_t aubio_source_wavread_close (aubio_source_wavread_t * s) {
460   if (s->fid == NULL) {
461     return AUBIO_OK;
462   }
463   if (fclose(s->fid)) {
464     AUBIO_STRERR("source_wavread: could not close %s (%s)\n", s->path, errorstr);
465     return AUBIO_FAIL;
466   }
467   s->fid = NULL;
468   return AUBIO_OK;
469 }
470
471 void del_aubio_source_wavread(aubio_source_wavread_t * s) {
472   AUBIO_ASSERT(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);
477   AUBIO_FREE(s);
478 }
479
480 #endif /* HAVE_WAVREAD */