e01847f8cab10512296c3d00d6dc78e1380fe7a6
[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 "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
36 struct _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
61 unsigned int read_little_endian (unsigned char *buf, unsigned int length);
62 unsigned 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
70 aubio_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
241 beach:
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
248 void aubio_source_wavread_readframe(aubio_source_wavread_t *s, uint_t *wavread_read);
249
250 void 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
281 void 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
315 void 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
349 uint_t aubio_source_wavread_get_samplerate(aubio_source_wavread_t * s) {
350   return s->samplerate;
351 }
352
353 uint_t aubio_source_wavread_get_channels(aubio_source_wavread_t * s) {
354   return s->input_channels;
355 }
356
357 uint_t aubio_source_wavread_seek (aubio_source_wavread_t * s, uint_t pos) {
358   uint_t ret = 0;
359   if ((sint_t)pos < 0) {
360     return AUBIO_FAIL;
361   }
362   ret = fseek(s->fid, s->seek_start + pos * s->blockalign, SEEK_SET);
363   if (ret != 0) {
364     AUBIO_ERR("source_wavread: could not seek %s at %d (%s)\n", s->path, pos, strerror(errno));
365     return AUBIO_FAIL;
366   }
367   // reset some values
368   s->eof = 0;
369   s->read_index = 0;
370   return AUBIO_OK;
371 }
372
373 uint_t aubio_source_wavread_close (aubio_source_wavread_t * s) {
374   if (!s->fid) {
375     return AUBIO_FAIL;
376   }
377   if (fclose(s->fid)) {
378     AUBIO_ERR("source_wavread: could not close %s (%s)\n", s->path, strerror(errno));
379     return AUBIO_FAIL;
380   }
381   s->fid = NULL;
382   return AUBIO_OK;
383 }
384
385 void del_aubio_source_wavread(aubio_source_wavread_t * s) {
386   if (!s) return;
387   aubio_source_wavread_close(s);
388   if (s->short_output) AUBIO_FREE(s->short_output);
389   if (s->output) del_fmat(s->output);
390   AUBIO_FREE(s);
391 }
392
393 #endif /* HAVE_WAVREAD */