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