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 "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
  35 struct _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
  62 static unsigned int read_little_endian (unsigned char *buf,
  63     unsigned int length);
  64
  65 static 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
  75 aubio_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 #if 0
 193   if ( bitspersample != 16 ) {
 194     AUBIO_ERR("source_wavread: can not process %dbit file %s\n",
 195         bitspersample, s->path);
 196     goto beach;
 197   }
 198 #endif
 199
 200   if ( byterate * 8 != sr * channels * bitspersample ) {
 201     AUBIO_ERR("source_wavread: Failed opening %s (wrong byterate)\n", s->path);
 202     goto beach;
 203   }
 204
 205   if ( blockalign * 8 != channels * bitspersample ) {
 206     AUBIO_ERR("source_wavread: Failed opening %s (wrong blockalign)\n", s->path);
 207     goto beach;
 208   }
 209
 210   s->input_samplerate = sr;
 211   s->input_channels = channels;
 212
 213 #if 0
 214   AUBIO_DBG("channels %d\n", channels);
 215   AUBIO_DBG("sr %d\n", sr);
 216   AUBIO_DBG("byterate %d\n", byterate);
 217   AUBIO_DBG("blockalign %d\n", blockalign);
 218   AUBIO_DBG("bitspersample %d\n", bitspersample);
 219
 220   AUBIO_DBG("found %d channels in %s\n", s->input_channels, s->path);
 221   AUBIO_DBG("found %d samplerate in %s\n", s->input_samplerate, s->path);
 222 #endif
 223
 224   if (samplerate == 0) {
 225     s->samplerate = s->input_samplerate;
 226   } else if (samplerate != s->input_samplerate) {
 227     AUBIO_ERR("source_wavread: can not resample %s from %d to %dHz\n",
 228         s->path, s->input_samplerate, samplerate);
 229     goto beach;
 230   }
 231
 232   // Subchunk2ID
 233   bytes_read += fread(buf, 1, 4, s->fid);
 234   buf[4] = '\0';
 235   while ( strcmp((const char *)buf, "data") != 0 ) {
 236     if (feof(s->fid) || ferror(s->fid)) {
 237       AUBIO_ERR("source_wavread: no data RIFF header found in %s\n", s->path);
 238       goto beach;
 239     }
 240     bytes_junk = fread(buf, 1, 4, s->fid);
 241     buf[4] = '\0';
 242     bytes_junk += read_little_endian(buf, 4);
 243     if (fseek(s->fid, bytes_read + bytes_junk, SEEK_SET) != 0) {
 244       AUBIO_ERR("source_wavread: could not seek past unknown chunk in %s (%s)\n",
 245           s->path, strerror(errno));
 246       goto beach;
 247     }
 248     bytes_read += bytes_junk;
 249     bytes_expected += bytes_junk+ 4;
 250     bytes_read += fread(buf, 1, 4, s->fid);
 251     buf[4] = '\0';
 252   }
 253
 254   // Subchunk2Size
 255   bytes_read += fread(buf, 1, 4, s->fid);
 256   duration = read_little_endian(buf, 4) / blockalign;
 257
 258   //data_size = buf[0] + (buf[1] << 8) + (buf[2] << 16) + (buf[3] << 24);
 259   //AUBIO_MSG("found %d frames in %s\n", 8 * data_size / bitspersample / channels, s->path);
 260
 261   // check the total number of bytes read is correct
 262   if ( bytes_read != bytes_expected ) {
 263 #ifndef HAVE_WIN_HACKS
 264     AUBIO_ERR("source_wavread: short read (%zd instead of %zd) in %s\n",
 265         bytes_read, bytes_expected, s->path);
 266 #else // mingw does not know about %zd...
 267     AUBIO_ERR("source_wavread: short read (%d instead of %d) in %s\n",
 268         (int)bytes_read, (int)bytes_expected, s->path);
 269 #endif
 270     goto beach;
 271   }
 272   s->seek_start = bytes_read;
 273
 274   s->output = new_fmat(s->input_channels, AUBIO_WAVREAD_BUFSIZE);
 275   s->blockalign= blockalign;
 276   s->bitspersample = bitspersample;
 277
 278   s->duration = duration;
 279
 280   s->short_output = (unsigned char *)calloc(s->blockalign, AUBIO_WAVREAD_BUFSIZE);
 281   s->read_index = 0;
 282   s->read_samples = 0;
 283   s->eof = 0;
 284
 285   return s;
 286
 287 beach:
 288   //AUBIO_ERR("source_wavread: can not read %s at samplerate %dHz with a hop_size of %d\n",
 289   //    s->path, s->samplerate, s->hop_size);
 290   del_aubio_source_wavread(s);
 291   return NULL;
 292 }
 293
 294 void aubio_source_wavread_readframe(aubio_source_wavread_t *s, uint_t *wavread_read);
 295
 296 void aubio_source_wavread_readframe(aubio_source_wavread_t *s, uint_t *wavread_read) {
 297   unsigned char *short_ptr = s->short_output;
 298   if (s->fid == NULL) {
 299     fmat_zeros(s->output);
 300     *wavread_read = 0;
 301     return;
 302   }
 303   size_t read = fread(short_ptr, s->blockalign, AUBIO_WAVREAD_BUFSIZE, s->fid);
 304   uint_t i, j, b, bitspersample = s->bitspersample;
 305   uint_t wrap_at = (1 << ( bitspersample - 1 ) );
 306   uint_t wrap_with = (1 << bitspersample);
 307   smpl_t scaler = 1. / wrap_at;
 308   int signed_val = 0;
 309   unsigned int unsigned_val = 0;
 310
 311   for (j = 0; j < read; j++) {
 312     for (i = 0; i < s->input_channels; i++) {
 313       unsigned_val = 0;
 314       for (b = 0; b < bitspersample; b+=8 ) {
 315         unsigned_val += *(short_ptr) << b;
 316         short_ptr++;
 317       }
 318       signed_val = unsigned_val;
 319       // FIXME why does 8 bit conversion maps [0;255] to [-128;127]
 320       // instead of [0;127] to [0;127] and [128;255] to [-128;-1]
 321       if (bitspersample == 8) signed_val -= wrap_at;
 322       else if (unsigned_val >= wrap_at) signed_val = unsigned_val - wrap_with;
 323       s->output->data[i][j] = signed_val * scaler;
 324     }
 325   }
 326
 327   *wavread_read = read;
 328
 329   if (read == 0) s->eof = 1;
 330 }
 331
 332 void aubio_source_wavread_do(aubio_source_wavread_t * s, fvec_t * read_data, uint_t * read){
 333   uint_t i, j;
 334   uint_t end = 0;
 335   uint_t total_wrote = 0;
 336   while (total_wrote < s->hop_size) {
 337     end = MIN(s->read_samples - s->read_index, s->hop_size - total_wrote);
 338     for (i = 0; i < end; i++) {
 339       read_data->data[i + total_wrote] = 0;
 340       for (j = 0; j < s->input_channels; j++ ) {
 341         read_data->data[i + total_wrote] += s->output->data[j][i + s->read_index];
 342       }
 343       read_data->data[i + total_wrote] /= (smpl_t)(s->input_channels);
 344     }
 345     total_wrote += end;
 346     if (total_wrote < s->hop_size) {
 347       uint_t wavread_read = 0;
 348       aubio_source_wavread_readframe(s, &wavread_read);
 349       s->read_samples = wavread_read;
 350       s->read_index = 0;
 351       if (s->eof) {
 352         break;
 353       }
 354     } else {
 355       s->read_index += end;
 356     }
 357   }
 358   if (total_wrote < s->hop_size) {
 359     for (i = end; i < s->hop_size; i++) {
 360       read_data->data[i] = 0.;
 361     }
 362   }
 363   *read = total_wrote;
 364 }
 365
 366 void aubio_source_wavread_do_multi(aubio_source_wavread_t * s, fmat_t * read_data, uint_t * read){
 367   uint_t i,j;
 368   uint_t end = 0;
 369   uint_t total_wrote = 0;
 370   while (total_wrote < s->hop_size) {
 371     end = MIN(s->read_samples - s->read_index, s->hop_size - total_wrote);
 372     for (j = 0; j < read_data->height; j++) {
 373       for (i = 0; i < end; i++) {
 374         read_data->data[j][i + total_wrote] = s->output->data[j][i];
 375       }
 376     }
 377     total_wrote += end;
 378     if (total_wrote < s->hop_size) {
 379       uint_t wavread_read = 0;
 380       aubio_source_wavread_readframe(s, &wavread_read);
 381       s->read_samples = wavread_read;
 382       s->read_index = 0;
 383       if (s->eof) {
 384         break;
 385       }
 386     } else {
 387       s->read_index += end;
 388     }
 389   }
 390   if (total_wrote < s->hop_size) {
 391     for (j = 0; j < read_data->height; j++) {
 392       for (i = end; i < s->hop_size; i++) {
 393         read_data->data[j][i] = 0.;
 394       }
 395     }
 396   }
 397   *read = total_wrote;
 398 }
 399
 400 uint_t aubio_source_wavread_get_samplerate(aubio_source_wavread_t * s) {
 401   return s->samplerate;
 402 }
 403
 404 uint_t aubio_source_wavread_get_channels(aubio_source_wavread_t * s) {
 405   return s->input_channels;
 406 }
 407
 408 uint_t aubio_source_wavread_seek (aubio_source_wavread_t * s, uint_t pos) {
 409   uint_t ret = 0;
 410   if ((sint_t)pos < 0) {
 411     AUBIO_ERR("source_wavread: could not seek %s at %d (seeking position should be >= 0)\n", s->path, pos);
 412     return AUBIO_FAIL;
 413   }
 414   ret = fseek(s->fid, s->seek_start + pos * s->blockalign, SEEK_SET);
 415   if (ret != 0) {
 416     AUBIO_ERR("source_wavread: could not seek %s at %d (%s)\n", s->path, pos, strerror(errno));
 417     return AUBIO_FAIL;
 418   }
 419   // reset some values
 420   s->eof = 0;
 421   s->read_index = 0;
 422   return AUBIO_OK;
 423 }
 424
 425 uint_t aubio_source_wavread_get_duration (const aubio_source_wavread_t * s) {
 426   if (s && s->duration) {
 427     return s->duration;
 428   }
 429   return 0;
 430 }
 431
 432 uint_t aubio_source_wavread_close (aubio_source_wavread_t * s) {
 433   if (!s->fid) {
 434     return AUBIO_FAIL;
 435   }
 436   if (fclose(s->fid)) {
 437     AUBIO_ERR("source_wavread: could not close %s (%s)\n", s->path, strerror(errno));
 438     return AUBIO_FAIL;
 439   }
 440   s->fid = NULL;
 441   return AUBIO_OK;
 442 }
 443
 444 void del_aubio_source_wavread(aubio_source_wavread_t * s) {
 445   if (!s) return;
 446   aubio_source_wavread_close(s);
 447   if (s->short_output) AUBIO_FREE(s->short_output);
 448   if (s->output) del_fmat(s->output);
 449   if (s->path) AUBIO_FREE(s->path);
 450   AUBIO_FREE(s);
 451 }
 452
 453 #endif /* HAVE_WAVREAD */