libaudiofile/wave.c

   1 /*
   2         Audio File Library
   3         Copyright (C) 1998-2000, Michael Pruett <michael@68k.org>
   4         Copyright (C) 2000-2001, Silicon Graphics, Inc.
   5
   6         This library is free software; you can redistribute it and/or
   7         modify it under the terms of the GNU Library General Public
   8         License as published by the Free Software Foundation; either
   9         version 2 of the License, or (at your option) any later version.
  10
  11         This library 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 GNU
  14         Library General Public License for more details.
  15
  16         You should have received a copy of the GNU Library General Public
  17         License along with this library; if not, write to the
  18         Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19         Boston, MA  02111-1307  USA.
  20 */
  21
  22 /*
  23         wave.c
  24
  25         This file contains code for parsing RIFF WAVE format sound files.
  26 */
  27
  28 #ifdef HAVE_CONFIG_H
  29 #include <config.h>
  30 #endif
  31
  32 #include <assert.h>
  33 #include <math.h>
  34 #include <stdint.h>
  35 #include <stdlib.h>
  36 #include <string.h>
  37
  38 #include "audiofile.h"
  39 #include "util.h"
  40 #include "afinternal.h"
  41 #include "byteorder.h"
  42 #include "wave.h"
  43 #include "track.h"
  44 #include "setup.h"
  45 #include "marker.h"
  46
  47 const int _af_wave_compression_types[_AF_WAVE_NUM_COMPTYPES] =
  48 {
  49         AF_COMPRESSION_G711_ULAW,
  50         AF_COMPRESSION_G711_ALAW
  51 };
  52
  53 const _InstParamInfo _af_wave_inst_params[_AF_WAVE_NUM_INSTPARAMS] =
  54 {
  55         { AF_INST_MIDI_BASENOTE, AU_PVTYPE_LONG, "MIDI base note", {60} },
  56         { AF_INST_NUMCENTS_DETUNE, AU_PVTYPE_LONG, "Detune in cents", {0} },
  57         { AF_INST_MIDI_LOVELOCITY, AU_PVTYPE_LONG, "Low velocity", {1} },
  58         { AF_INST_MIDI_HIVELOCITY, AU_PVTYPE_LONG, "High velocity", {127} },
  59         { AF_INST_MIDI_LONOTE, AU_PVTYPE_LONG, "Low note", {0} },
  60         { AF_INST_MIDI_HINOTE, AU_PVTYPE_LONG, "High note", {127} },
  61         { AF_INST_NUMDBS_GAIN, AU_PVTYPE_LONG, "Gain in dB", {0} }
  62 };
  63
  64 _AFfilesetup _af_wave_default_filesetup =
  65 {
  66         _AF_VALID_FILESETUP,    /* valid */
  67         AF_FILE_WAVE,           /* fileFormat */
  68         true,                   /* trackSet */
  69         true,                   /* instrumentSet */
  70         true,                   /* miscellaneousSet  */
  71         1,                      /* trackCount */
  72         NULL,                   /* tracks */
  73         0,                      /* instrumentCount */
  74         NULL,                   /* instruments */
  75         0,                      /* miscellaneousCount */
  76         NULL                    /* miscellaneous */
  77 };
  78
  79 static status ParseFrameCount (AFfilehandle filehandle, AFvirtualfile *fp,
  80         uint32_t id, size_t size)
  81 {
  82         uint32_t        totalFrames;
  83         _Track          *track;
  84
  85         track = _af_filehandle_get_track(filehandle, AF_DEFAULT_TRACK);
  86
  87         af_read_uint32_le(&totalFrames, fp);
  88
  89         track->totalfframes = totalFrames;
  90
  91         return AF_SUCCEED;
  92 }
  93
  94 static status ParseFormat (AFfilehandle filehandle, AFvirtualfile *fp,
  95         uint32_t id, size_t size)
  96 {
  97         _Track          *track;
  98         uint16_t        formatTag, channelCount;
  99         uint32_t        sampleRate, averageBytesPerSecond;
 100         uint16_t        blockAlign;
 101         _WAVEInfo       *wave;
 102
 103         assert(filehandle != NULL);
 104         assert(fp != NULL);
 105         assert(!memcmp(&id, "fmt ", 4));
 106
 107         track = _af_filehandle_get_track(filehandle, AF_DEFAULT_TRACK);
 108
 109         assert(filehandle->formatSpecific != NULL);
 110         wave = (_WAVEInfo *) filehandle->formatSpecific;
 111
 112         af_read_uint16_le(&formatTag, fp);
 113         af_read_uint16_le(&channelCount, fp);
 114         af_read_uint32_le(&sampleRate, fp);
 115         af_read_uint32_le(&averageBytesPerSecond, fp);
 116         af_read_uint16_le(&blockAlign, fp);
 117
 118         track->f.channelCount = channelCount;
 119         track->f.sampleRate = sampleRate;
 120         track->f.byteOrder = AF_BYTEORDER_LITTLEENDIAN;
 121
 122         /* Default to uncompressed audio data. */
 123         track->f.compressionType = AF_COMPRESSION_NONE;
 124
 125         switch (formatTag)
 126         {
 127                 case WAVE_FORMAT_PCM:
 128                 {
 129                         uint16_t        bitsPerSample;
 130
 131                         af_read_uint16_le(&bitsPerSample, fp);
 132
 133                         track->f.sampleWidth = bitsPerSample;
 134
 135                         if (bitsPerSample == 0 || bitsPerSample > 32)
 136                         {
 137                                 _af_error(AF_BAD_WIDTH,
 138                                         "bad sample width of %d bits",
 139                                         bitsPerSample);
 140                                 return AF_FAIL;
 141                         }
 142
 143                         if (bitsPerSample <= 8)
 144                                 track->f.sampleFormat = AF_SAMPFMT_UNSIGNED;
 145                         else
 146                                 track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
 147                 }
 148                 break;
 149
 150                 case WAVE_FORMAT_MULAW:
 151                 case IBM_FORMAT_MULAW:
 152                         track->f.sampleWidth = 16;
 153                         track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
 154                         track->f.compressionType = AF_COMPRESSION_G711_ULAW;
 155                         break;
 156
 157                 case WAVE_FORMAT_ALAW:
 158                 case IBM_FORMAT_ALAW:
 159                         track->f.sampleWidth = 16;
 160                         track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
 161                         track->f.compressionType = AF_COMPRESSION_G711_ALAW;
 162                         break;
 163
 164                 case WAVE_FORMAT_IEEE_FLOAT:
 165                 {
 166                         uint16_t        bitsPerSample;
 167
 168                         af_read_uint16_le(&bitsPerSample, fp);
 169
 170                         if (bitsPerSample == 64)
 171                         {
 172                                 track->f.sampleWidth = 64;
 173                                 track->f.sampleFormat = AF_SAMPFMT_DOUBLE;
 174                         }
 175                         else
 176                         {
 177                                 track->f.sampleWidth = 32;
 178                                 track->f.sampleFormat = AF_SAMPFMT_FLOAT;
 179                         }
 180                 }
 181                 break;
 182
 183                 case WAVE_FORMAT_ADPCM:
 184                 {
 185                         uint16_t        bitsPerSample, extraByteCount,
 186                                         samplesPerBlock, numCoefficients;
 187                         int             i;
 188                         AUpvlist        pv;
 189                         long            l;
 190                         void            *v;
 191
 192                         if (track->f.channelCount != 1 &&
 193                                 track->f.channelCount != 2)
 194                         {
 195                                 _af_error(AF_BAD_CHANNELS,
 196                                         "WAVE file with MS ADPCM compression "
 197                                         "must have 1 or 2 channels");
 198                         }
 199
 200                         af_read_uint16_le(&bitsPerSample, fp);
 201                         af_read_uint16_le(&extraByteCount, fp);
 202                         af_read_uint16_le(&samplesPerBlock, fp);
 203                         af_read_uint16_le(&numCoefficients, fp);
 204
 205                         /* numCoefficients should be at least 7. */
 206                         assert(numCoefficients >= 7 && numCoefficients <= 255);
 207
 208                         for (i=0; i<numCoefficients; i++)
 209                         {
 210                                 int16_t a0, a1;
 211
 212                                 af_read_uint16_le(&a0, fp);
 213                                 af_read_uint16_le(&a1, fp);
 214
 215                                 wave->msadpcmCoefficients[i][0] = a0;
 216                                 wave->msadpcmCoefficients[i][1] = a1;
 217                         }
 218
 219                         track->f.sampleWidth = 16;
 220                         track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
 221                         track->f.compressionType = AF_COMPRESSION_MS_ADPCM;
 222                         track->f.byteOrder = _AF_BYTEORDER_NATIVE;
 223
 224                         /* Create the parameter list. */
 225                         pv = AUpvnew(4);
 226                         AUpvsetparam(pv, 0, _AF_MS_ADPCM_NUM_COEFFICIENTS);
 227                         AUpvsetvaltype(pv, 0, AU_PVTYPE_LONG);
 228                         l = numCoefficients;
 229                         AUpvsetval(pv, 0, &l);
 230
 231                         AUpvsetparam(pv, 1, _AF_MS_ADPCM_COEFFICIENTS);
 232                         AUpvsetvaltype(pv, 1, AU_PVTYPE_PTR);
 233                         v = wave->msadpcmCoefficients;
 234                         AUpvsetval(pv, 1, &v);
 235
 236                         AUpvsetparam(pv, 2, _AF_FRAMES_PER_BLOCK);
 237                         AUpvsetvaltype(pv, 2, AU_PVTYPE_LONG);
 238                         l = samplesPerBlock;
 239                         AUpvsetval(pv, 2, &l);
 240
 241                         AUpvsetparam(pv, 3, _AF_BLOCK_SIZE);
 242                         AUpvsetvaltype(pv, 3, AU_PVTYPE_LONG);
 243                         l = blockAlign;
 244                         AUpvsetval(pv, 3, &l);
 245
 246                         track->f.compressionParams = pv;
 247                 }
 248                 break;
 249
 250                 case WAVE_FORMAT_DVI_ADPCM:
 251                 {
 252                         AUpvlist        pv;
 253                         long            l;
 254
 255                         uint16_t        bitsPerSample, extraByteCount,
 256                                         samplesPerBlock;
 257
 258                         af_read_uint16_le(&bitsPerSample, fp);
 259                         af_read_uint16_le(&extraByteCount, fp);
 260                         af_read_uint16_le(&samplesPerBlock, fp);
 261
 262                         if (bitsPerSample != 4)
 263                         {
 264                                 _af_error(AF_BAD_NOT_IMPLEMENTED,
 265                                         "IMA ADPCM compression supports only 4 bits per sample");
 266                         }
 267
 268                         int bytesPerBlock = (samplesPerBlock + 14) / 8 * 4 * channelCount;
 269                         if (bytesPerBlock > blockAlign || (samplesPerBlock % 8) != 1)
 270                         {
 271                                 _af_error(AF_BAD_CODEC_CONFIG,
 272                                         "Invalid samples per block for IMA ADPCM compression");
 273                         }
 274
 275                         track->f.sampleWidth = 16;
 276                         track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
 277                         track->f.compressionType = AF_COMPRESSION_IMA;
 278                         track->f.byteOrder = _AF_BYTEORDER_NATIVE;
 279
 280                         /* Create the parameter list. */
 281                         pv = AUpvnew(2);
 282                         AUpvsetparam(pv, 0, _AF_FRAMES_PER_BLOCK);
 283                         AUpvsetvaltype(pv, 0, AU_PVTYPE_LONG);
 284                         l = samplesPerBlock;
 285                         AUpvsetval(pv, 0, &l);
 286
 287                         AUpvsetparam(pv, 1, _AF_BLOCK_SIZE);
 288                         AUpvsetvaltype(pv, 1, AU_PVTYPE_LONG);
 289                         l = blockAlign;
 290                         AUpvsetval(pv, 1, &l);
 291
 292                         track->f.compressionParams = pv;
 293                 }
 294                 break;
 295
 296                 case WAVE_FORMAT_YAMAHA_ADPCM:
 297                 case WAVE_FORMAT_OKI_ADPCM:
 298                 case WAVE_FORMAT_CREATIVE_ADPCM:
 299                 case IBM_FORMAT_ADPCM:
 300                         _af_error(AF_BAD_NOT_IMPLEMENTED, "WAVE ADPCM data format 0x%x is not currently supported", formatTag);
 301                         return AF_FAIL;
 302                         break;
 303
 304                 case WAVE_FORMAT_MPEG:
 305                         _af_error(AF_BAD_NOT_IMPLEMENTED, "WAVE MPEG data format is not supported");
 306                         return AF_FAIL;
 307                         break;
 308
 309                 case WAVE_FORMAT_MPEGLAYER3:
 310                         _af_error(AF_BAD_NOT_IMPLEMENTED, "WAVE MPEG layer 3 data format is not supported");
 311                         return AF_FAIL;
 312                         break;
 313
 314                 default:
 315                         _af_error(AF_BAD_NOT_IMPLEMENTED, "WAVE file data format 0x%x not currently supported", formatTag);
 316                         return AF_FAIL;
 317                         break;
 318         }
 319
 320         _af_set_sample_format(&track->f, track->f.sampleFormat, track->f.sampleWidth);
 321
 322         return AF_SUCCEED;
 323 }
 324
 325 static status ParseData (AFfilehandle filehandle, AFvirtualfile *fp,
 326         uint32_t id, size_t size)
 327 {
 328         _Track  *track;
 329
 330         assert(filehandle != NULL);
 331         assert(fp != NULL);
 332         assert(!memcmp(&id, "data", 4));
 333
 334         track = _af_filehandle_get_track(filehandle, AF_DEFAULT_TRACK);
 335
 336         track->fpos_first_frame = af_ftell(fp);
 337         track->data_size = size;
 338
 339         return AF_SUCCEED;
 340 }
 341
 342 static status ParsePlayList (AFfilehandle filehandle, AFvirtualfile *fp,
 343         uint32_t id, size_t size)
 344 {
 345         _Instrument     *instrument;
 346         uint32_t        segmentCount;
 347         int             segment;
 348
 349         af_read_uint32_le(&segmentCount, fp);
 350
 351         if (segmentCount == 0)
 352         {
 353                 filehandle->instrumentCount = 0;
 354                 filehandle->instruments = NULL;
 355                 return AF_SUCCEED;
 356         }
 357
 358         for (segment=0; segment<segmentCount; segment++)
 359         {
 360                 uint32_t        startMarkID, loopLength, loopCount;
 361
 362                 af_read_uint32_le(&startMarkID, fp);
 363                 af_read_uint32_le(&loopLength, fp);
 364                 af_read_uint32_le(&loopCount, fp);
 365         }
 366
 367         return AF_SUCCEED;
 368 }
 369
 370 static status ParseCues (AFfilehandle filehandle, AFvirtualfile *fp,
 371         uint32_t id, size_t size)
 372 {
 373         _Track          *track;
 374         uint32_t        markerCount;
 375         int             i;
 376
 377         track = _af_filehandle_get_track(filehandle, AF_DEFAULT_TRACK);
 378
 379         af_read_uint32_le(&markerCount, fp);
 380         track->markerCount = markerCount;
 381
 382         if (markerCount == 0)
 383         {
 384                 track->markers = NULL;
 385                 return AF_SUCCEED;
 386         }
 387
 388         if ((track->markers = _af_marker_new(markerCount)) == NULL)
 389                 return AF_FAIL;
 390
 391         for (i=0; i<markerCount; i++)
 392         {
 393                 uint32_t        id, position, chunkid;
 394                 uint32_t        chunkByteOffset, blockByteOffset;
 395                 uint32_t        sampleFrameOffset;
 396                 _Marker         *marker = &track->markers[i];
 397
 398                 af_read_uint32_le(&id, fp);
 399                 af_read_uint32_le(&position, fp);
 400                 af_read_uint32_le(&chunkid, fp);
 401                 af_read_uint32_le(&chunkByteOffset, fp);
 402                 af_read_uint32_le(&blockByteOffset, fp);
 403
 404                 /*
 405                         sampleFrameOffset represents the position of
 406                         the mark in units of frames.
 407                 */
 408                 af_read_uint32_le(&sampleFrameOffset, fp);
 409
 410                 marker->id = id;
 411                 marker->position = sampleFrameOffset;
 412                 marker->name = _af_strdup("");
 413                 marker->comment = _af_strdup("");
 414         }
 415
 416         return AF_SUCCEED;
 417 }
 418
 419 /* Parse an adtl sub-chunk within a LIST chunk. */
 420 static status ParseADTLSubChunk (AFfilehandle filehandle, AFvirtualfile *fp,
 421         uint32_t id, size_t size)
 422 {
 423         _Track          *track;
 424         AFfileoffset    endPos=af_ftell(fp)+size;
 425
 426         track = _af_filehandle_get_track(filehandle, AF_DEFAULT_TRACK);
 427
 428         while (af_ftell(fp) < endPos)
 429         {
 430                 char            chunkID[4];
 431                 uint32_t        chunkSize;
 432
 433                 af_fread(chunkID, 4, 1, fp);
 434                 af_read_uint32_le(&chunkSize, fp);
 435
 436                 if (memcmp(chunkID, "labl", 4)==0 || memcmp(chunkID, "note", 4)==0)
 437                 {
 438                         _Marker *marker=NULL;
 439                         uint32_t id;
 440                         long length=chunkSize-4;
 441                         char *p=_af_malloc(length);
 442
 443                         af_read_uint32_le(&id, fp);
 444                         af_fread(p, length, 1, fp);
 445
 446                         marker = _af_marker_find_by_id(track, id);
 447
 448                         if (marker != NULL)
 449                         {
 450                                 if (memcmp(chunkID, "labl", 4)==0)
 451                                 {
 452                                         free(marker->name);
 453                                         marker->name = p;
 454                                 }
 455                                 else if (memcmp(chunkID, "note", 4)==0)
 456                                 {
 457                                         free(marker->comment);
 458                                         marker->comment = p;
 459                                 }
 460                                 else
 461                                         free(p);
 462                         }
 463                         else
 464                                 free(p);
 465
 466                         /*
 467                                 If chunkSize is odd, skip an extra byte
 468                                 at the end of the chunk.
 469                         */
 470                         if ((chunkSize % 2) != 0)
 471                                 af_fseek(fp, 1, SEEK_CUR);
 472                 }
 473                 else
 474                 {
 475                         /* If chunkSize is odd, skip an extra byte. */
 476                         af_fseek(fp, chunkSize + (chunkSize % 2), SEEK_CUR);
 477                 }
 478         }
 479         return AF_SUCCEED;
 480 }
 481
 482 /* Parse an INFO sub-chunk within a LIST chunk. */
 483 static status ParseINFOSubChunk (AFfilehandle filehandle, AFvirtualfile *fp,
 484         uint32_t id, size_t size)
 485 {
 486         AFfileoffset    endPos=af_ftell(fp)+size;
 487
 488         while (af_ftell(fp) < endPos)
 489         {
 490                 int             misctype = AF_MISC_UNRECOGNIZED;
 491                 uint32_t        miscid, miscsize;
 492
 493                 af_fread(&miscid, 4, 1, fp);
 494                 af_read_uint32_le(&miscsize, fp);
 495
 496                 if (memcmp(&miscid, "IART", 4) == 0)
 497                         misctype = AF_MISC_AUTH;
 498                 else if (memcmp(&miscid, "INAM", 4) == 0)
 499                         misctype = AF_MISC_NAME;
 500                 else if (memcmp(&miscid, "ICOP", 4) == 0)
 501                         misctype = AF_MISC_COPY;
 502                 else if (memcmp(&miscid, "ICMT", 4) == 0)
 503                         misctype = AF_MISC_ICMT;
 504                 else if (memcmp(&miscid, "ICRD", 4) == 0)
 505                         misctype = AF_MISC_ICRD;
 506                 else if (memcmp(&miscid, "ISFT", 4) == 0)
 507                         misctype = AF_MISC_ISFT;
 508
 509                 if (misctype != AF_MISC_UNRECOGNIZED)
 510                 {
 511                         char    *string = _af_malloc(miscsize);
 512
 513                         af_fread(string, miscsize, 1, fp);
 514
 515                         filehandle->miscellaneousCount++;
 516                         filehandle->miscellaneous = _af_realloc(filehandle->miscellaneous, sizeof (_Miscellaneous) * filehandle->miscellaneousCount);
 517
 518                         filehandle->miscellaneous[filehandle->miscellaneousCount-1].id = filehandle->miscellaneousCount;
 519                         filehandle->miscellaneous[filehandle->miscellaneousCount-1].type = misctype;
 520                         filehandle->miscellaneous[filehandle->miscellaneousCount-1].size = miscsize;
 521                         filehandle->miscellaneous[filehandle->miscellaneousCount-1].position = 0;
 522                         filehandle->miscellaneous[filehandle->miscellaneousCount-1].buffer = string;
 523                 }
 524                 else
 525                 {
 526                         af_fseek(fp, miscsize, SEEK_CUR);
 527                 }
 528
 529                 /* Make the current position an even number of bytes.  */
 530                 if (miscsize % 2 != 0)
 531                         af_fseek(fp, 1, SEEK_CUR);
 532         }
 533         return AF_SUCCEED;
 534 }
 535
 536 static status ParseList (AFfilehandle filehandle, AFvirtualfile *fp,
 537         uint32_t id, size_t size)
 538 {
 539         uint32_t        typeID;
 540
 541         af_fread(&typeID, 4, 1, fp);
 542         size-=4;
 543
 544         if (memcmp(&typeID, "adtl", 4) == 0)
 545         {
 546                 /* Handle adtl sub-chunks. */
 547                 return ParseADTLSubChunk(filehandle, fp, typeID, size);
 548         }
 549         else if (memcmp(&typeID, "INFO", 4) == 0)
 550         {
 551                 /* Handle INFO sub-chunks. */
 552                 return ParseINFOSubChunk(filehandle, fp, typeID, size);
 553         }
 554         else
 555         {
 556                 /* Skip unhandled sub-chunks. */
 557                 af_fseek(fp, size, SEEK_CUR);
 558                 return AF_SUCCEED;
 559         }
 560         return AF_SUCCEED;
 561 }
 562
 563 static status ParseInstrument (AFfilehandle filehandle, AFvirtualfile *fp,
 564         uint32_t id, size_t size)
 565 {
 566         uint8_t baseNote;
 567         int8_t  detune, gain;
 568         uint8_t lowNote, highNote, lowVelocity, highVelocity;
 569         uint8_t padByte;
 570
 571         af_read_uint8(&baseNote, fp);
 572         af_read_uint8(&detune, fp);
 573         af_read_uint8(&gain, fp);
 574         af_read_uint8(&lowNote, fp);
 575         af_read_uint8(&highNote, fp);
 576         af_read_uint8(&lowVelocity, fp);
 577         af_read_uint8(&highVelocity, fp);
 578         af_read_uint8(&padByte, fp);
 579
 580         return AF_SUCCEED;
 581 }
 582
 583 bool _af_wave_recognize (AFvirtualfile *fh)
 584 {
 585         uint8_t buffer[8];
 586
 587         af_fseek(fh, 0, SEEK_SET);
 588
 589         if (af_fread(buffer, 1, 8, fh) != 8 || memcmp(buffer, "RIFF", 4) != 0)
 590                 return false;
 591         if (af_fread(buffer, 1, 4, fh) != 4 || memcmp(buffer, "WAVE", 4) != 0)
 592                 return false;
 593
 594         return true;
 595 }
 596
 597 status _af_wave_read_init (AFfilesetup setup, AFfilehandle filehandle)
 598 {
 599         _Track          *track;
 600         uint32_t        type, size, formtype;
 601         uint32_t        index = 0;
 602         bool            hasFormat, hasData, hasCue, hasList, hasPlayList, hasFrameCount,
 603                         hasINST, hasINFO;
 604         _WAVEInfo       *wave = _af_malloc(sizeof (_WAVEInfo));
 605
 606         assert(filehandle != NULL);
 607         assert(filehandle->fh != NULL);
 608
 609         hasFormat = false;
 610         hasData = false;
 611         hasCue = false;
 612         hasList = false;
 613         hasPlayList = false;
 614         hasFrameCount = false;
 615         hasINST = false;
 616         hasINFO = false;
 617
 618         filehandle->formatSpecific = wave;
 619         filehandle->instruments = NULL;
 620         filehandle->instrumentCount = 0;
 621         filehandle->miscellaneous = NULL;
 622         filehandle->miscellaneousCount = 0;
 623
 624         track = _af_track_new();
 625         filehandle->tracks = track;
 626         filehandle->trackCount = 1;
 627
 628         af_fseek(filehandle->fh, 0, SEEK_SET);
 629
 630         af_fread(&type, 4, 1, filehandle->fh);
 631         af_read_uint32_le(&size, filehandle->fh);
 632         af_fread(&formtype, 4, 1, filehandle->fh);
 633
 634         assert(!memcmp(&type, "RIFF", 4));
 635         assert(!memcmp(&formtype, "WAVE", 4));
 636
 637 #ifdef DEBUG
 638         printf("size: %d\n", size);
 639 #endif
 640
 641         /* Include the offset of the form type. */
 642         index += 4;
 643
 644         while (index < size)
 645         {
 646                 uint32_t        chunkid = 0, chunksize = 0;
 647                 status          result;
 648
 649 #ifdef DEBUG
 650                 printf("index: %d\n", index);
 651 #endif
 652                 af_fread(&chunkid, 4, 1, filehandle->fh);
 653                 af_read_uint32_le(&chunksize, filehandle->fh);
 654
 655 #ifdef DEBUG
 656                 _af_printid(BENDIAN_TO_HOST_INT32(chunkid));
 657                 printf(" size: %d\n", chunksize);
 658 #endif
 659
 660                 if (memcmp(&chunkid, "fmt ", 4) == 0)
 661                 {
 662                         result = ParseFormat(filehandle, filehandle->fh, chunkid, chunksize);
 663                         if (result == AF_FAIL)
 664                                 return AF_FAIL;
 665
 666                         hasFormat = true;
 667                 }
 668                 else if (memcmp(&chunkid, "data", 4) == 0)
 669                 {
 670                         /* The format chunk must precede the data chunk. */
 671                         if (!hasFormat)
 672                         {
 673                                 _af_error(AF_BAD_HEADER, "missing format chunk in WAVE file");
 674                                 return AF_FAIL;
 675                         }
 676
 677                         result = ParseData(filehandle, filehandle->fh, chunkid, chunksize);
 678                         if (result == AF_FAIL)
 679                                 return AF_FAIL;
 680
 681                         hasData = true;
 682                 }
 683                 else if (memcmp(&chunkid, "inst", 4) == 0)
 684                 {
 685                         result = ParseInstrument(filehandle, filehandle->fh, chunkid, chunksize);
 686                         if (result == AF_FAIL)
 687                                 return AF_FAIL;
 688                 }
 689                 else if (memcmp(&chunkid, "fact", 4) == 0)
 690                 {
 691                         hasFrameCount = true;
 692                         result = ParseFrameCount(filehandle, filehandle->fh, chunkid, chunksize);
 693                         if (result == AF_FAIL)
 694                                 return AF_FAIL;
 695                 }
 696                 else if (memcmp(&chunkid, "cue ", 4) == 0)
 697                 {
 698                         hasCue = true;
 699                         result = ParseCues(filehandle, filehandle->fh, chunkid, chunksize);
 700                         if (result == AF_FAIL)
 701                                 return AF_FAIL;
 702                 }
 703                 else if (memcmp(&chunkid, "LIST", 4) == 0 || memcmp(&chunkid, "list", 4) == 0)
 704                 {
 705                         hasList = true;
 706                         result = ParseList(filehandle, filehandle->fh, chunkid, chunksize);
 707                         if (result == AF_FAIL)
 708                                 return AF_FAIL;
 709                 }
 710                 else if (memcmp(&chunkid, "INST", 4) == 0)
 711                 {
 712                         hasINST = true;
 713                         result = ParseInstrument(filehandle, filehandle->fh, chunkid, chunksize);
 714                         if (result == AF_FAIL)
 715                                 return AF_FAIL;
 716                 }
 717                 else if (memcmp(&chunkid, "plst", 4) == 0)
 718                 {
 719                         hasPlayList = true;
 720                         result = ParsePlayList(filehandle, filehandle->fh, chunkid, chunksize);
 721                         if (result == AF_FAIL)
 722                                 return AF_FAIL;
 723                 }
 724
 725                 index += chunksize + 8;
 726
 727                 /* All chunks must be aligned on an even number of bytes */
 728                 if ((index % 2) != 0)
 729                         index++;
 730
 731                 af_fseek(filehandle->fh, index + 8, SEEK_SET);
 732         }
 733
 734         /* The format chunk and the data chunk are required. */
 735         if (!hasFormat || !hasData)
 736         {
 737                 return AF_FAIL;
 738         }
 739
 740         /*
 741                 At this point we know that the file has a format chunk
 742                 and a data chunk, so we can assume that track->f and
 743                 track->data_size have been initialized.
 744         */
 745         if (!hasFrameCount)
 746         {
 747                 track->totalfframes = track->data_size /
 748                         (int) _af_format_frame_size(&track->f, false);
 749         }
 750
 751         if (track->f.compressionType != AF_COMPRESSION_NONE &&
 752                 (track->f.compressionType == AF_COMPRESSION_G711_ULAW ||
 753                 track->f.compressionType == AF_COMPRESSION_G711_ALAW))
 754         {
 755                 track->totalfframes = track->data_size / track->f.channelCount;
 756         }
 757
 758         /*
 759                 A return value of AF_SUCCEED indicates successful parsing.
 760         */
 761         return AF_SUCCEED;
 762 }
 763
 764 AFfilesetup _af_wave_complete_setup (AFfilesetup setup)
 765 {
 766         AFfilesetup     newsetup;
 767         _TrackSetup     *track;
 768
 769         if (setup->trackSet && setup->trackCount != 1)
 770         {
 771                 _af_error(AF_BAD_NUMTRACKS, "WAVE file must have 1 track");
 772                 return AF_NULL_FILESETUP;
 773         }
 774
 775         track = _af_filesetup_get_tracksetup(setup, AF_DEFAULT_TRACK);
 776
 777         if (track->sampleFormatSet)
 778         {
 779                 switch (track->f.sampleFormat)
 780                 {
 781                         case AF_SAMPFMT_FLOAT:
 782                                 if (track->sampleWidthSet &&
 783                                         track->f.sampleWidth != 32)
 784                                 {
 785                                         _af_error(AF_BAD_WIDTH,
 786                                                 "Warning: invalid sample width for floating-point WAVE file: %d (must be 32 bits)\n",
 787                                                 track->f.sampleWidth);
 788                                         _af_set_sample_format(&track->f, AF_SAMPFMT_FLOAT, 32);
 789                                 }
 790                                 break;
 791
 792                         case AF_SAMPFMT_DOUBLE:
 793                                 if (track->sampleWidthSet &&
 794                                         track->f.sampleWidth != 64)
 795                                 {
 796                                         _af_error(AF_BAD_WIDTH,
 797                                                 "Warning: invalid sample width for double-precision floating-point WAVE file: %d (must be 64 bits)\n",
 798                                                 track->f.sampleWidth);
 799                                         _af_set_sample_format(&track->f, AF_SAMPFMT_DOUBLE, 64);
 800                                 }
 801                                 break;
 802
 803                         case AF_SAMPFMT_UNSIGNED:
 804                                 if (track->sampleWidthSet)
 805                                 {
 806                                         if (track->f.sampleWidth < 1 || track->f.sampleWidth > 32)
 807                                         {
 808                                                 _af_error(AF_BAD_WIDTH, "invalid sample width for WAVE file: %d (must be 1-32 bits)\n", track->f.sampleWidth);
 809                                                 return AF_NULL_FILESETUP;
 810                                         }
 811                                         if (track->f.sampleWidth > 8)
 812                                         {
 813                                                 _af_error(AF_BAD_SAMPFMT, "WAVE integer data of more than 8 bits must be two's complement signed");
 814                                                 _af_set_sample_format(&track->f, AF_SAMPFMT_TWOSCOMP, track->f.sampleWidth);
 815                                         }
 816                                 }
 817                                 else
 818                                 /*
 819                                         If the sample width is not set but the user requests
 820                                         unsigned data, set the width to 8 bits.
 821                                 */
 822                                         _af_set_sample_format(&track->f, track->f.sampleFormat, 8);
 823                                 break;
 824
 825                         case AF_SAMPFMT_TWOSCOMP:
 826                                 if (track->sampleWidthSet)
 827                                 {
 828                                         if (track->f.sampleWidth < 1 || track->f.sampleWidth > 32)
 829                                         {
 830                                                 _af_error(AF_BAD_WIDTH, "invalid sample width %d for WAVE file (must be 1-32)", track->f.sampleWidth);
 831                                                 return AF_NULL_FILESETUP;
 832                                         }
 833                                         else if (track->f.sampleWidth <= 8)
 834                                         {
 835                                                 _af_error(AF_BAD_SAMPFMT, "Warning: WAVE format integer data of 1-8 bits must be unsigned; setting sample format to unsigned");
 836                                                 _af_set_sample_format(&track->f, AF_SAMPFMT_UNSIGNED, track->f.sampleWidth);
 837                                         }
 838                                 }
 839                                 else
 840                                 /*
 841                                         If no sample width was specified, we default to 16 bits
 842                                         for signed integer data.
 843                                 */
 844                                         _af_set_sample_format(&track->f, track->f.sampleFormat, 16);
 845                                 break;
 846                 }
 847         }
 848         /*
 849                 Otherwise set the sample format depending on the sample
 850                 width or set completely to default.
 851         */
 852         else
 853         {
 854                 if (!track->sampleWidthSet)
 855                 {
 856                         track->f.sampleWidth = 16;
 857                         track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
 858                 }
 859                 else
 860                 {
 861                         if (track->f.sampleWidth < 1 || track->f.sampleWidth > 32)
 862                         {
 863                                 _af_error(AF_BAD_WIDTH, "invalid sample width %d for WAVE file (must be 1-32)", track->f.sampleWidth);
 864                                 return AF_NULL_FILESETUP;
 865                         }
 866                         else if (track->f.sampleWidth > 8)
 867                                 /* Here track->f.sampleWidth is in {1..32}. */
 868                                 track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
 869                         else
 870                                 /* Here track->f.sampleWidth is in {1..8}. */
 871                                 track->f.sampleFormat = AF_SAMPFMT_UNSIGNED;
 872                 }
 873         }
 874
 875         if (track->f.compressionType != AF_COMPRESSION_NONE &&
 876                 track->f.compressionType != AF_COMPRESSION_G711_ULAW &&
 877                 track->f.compressionType != AF_COMPRESSION_G711_ALAW)
 878         {
 879                 _af_error(AF_BAD_NOT_IMPLEMENTED, "compression format not supported in WAVE format");
 880                 return AF_NULL_FILESETUP;
 881         }
 882
 883         if (track->byteOrderSet &&
 884                 track->f.byteOrder != AF_BYTEORDER_LITTLEENDIAN &&
 885                 track->f.compressionType == AF_COMPRESSION_NONE)
 886         {
 887                 _af_error(AF_BAD_BYTEORDER, "WAVE format only supports little-endian data");
 888                 return AF_NULL_FILESETUP;
 889         }
 890
 891         if (track->f.compressionType == AF_COMPRESSION_NONE)
 892                 track->f.byteOrder = AF_BYTEORDER_LITTLEENDIAN;
 893         else
 894                 track->f.byteOrder = AF_BYTEORDER_BIGENDIAN;
 895
 896         if (track->aesDataSet)
 897         {
 898                 _af_error(AF_BAD_FILESETUP, "WAVE files cannot have AES data");
 899                 return AF_NULL_FILESETUP;
 900         }
 901
 902         if (setup->instrumentSet)
 903         {
 904                 if (setup->instrumentCount > 1)
 905                 {
 906                         _af_error(AF_BAD_NUMINSTS, "WAVE files can have 0 or 1 instrument");
 907                         return AF_NULL_FILESETUP;
 908                 }
 909                 else if (setup->instrumentCount == 1)
 910                 {
 911                         if (setup->instruments[0].loopSet &&
 912                                 setup->instruments[0].loopCount > 0 &&
 913                                 (!track->markersSet || track->markerCount == 0))
 914                         {
 915                                 _af_error(AF_BAD_NUMMARKS, "WAVE files with loops must contain at least 1 marker");
 916                                 return AF_NULL_FILESETUP;
 917                         }
 918                 }
 919         }
 920
 921         /* Make sure the miscellaneous data is of an acceptable type. */
 922         if (setup->miscellaneousSet)
 923         {
 924                 int     i;
 925                 for (i=0; i<setup->miscellaneousCount; i++)
 926                 {
 927                         switch (setup->miscellaneous[i].type)
 928                         {
 929                                 case AF_MISC_COPY:
 930                                 case AF_MISC_AUTH:
 931                                 case AF_MISC_NAME:
 932                                 case AF_MISC_ICRD:
 933                                 case AF_MISC_ISFT:
 934                                 case AF_MISC_ICMT:
 935                                         break;
 936                                 default:
 937                                         _af_error(AF_BAD_MISCTYPE, "illegal miscellaneous type [%d] for WAVE file", setup->miscellaneous[i].type);
 938                                         return AF_NULL_FILESETUP;
 939                         }
 940                 }
 941         }
 942
 943         /*
 944                 Allocate an AFfilesetup and make all the unset fields correct.
 945         */
 946         newsetup = _af_filesetup_copy(setup, &_af_wave_default_filesetup, false);
 947
 948         /* Make sure we do not copy loops if they are not specified in setup. */
 949         if (setup->instrumentSet && setup->instrumentCount > 0 &&
 950                 setup->instruments[0].loopSet)
 951         {
 952                 free(newsetup->instruments[0].loops);
 953                 newsetup->instruments[0].loopCount = 0;
 954         }
 955
 956         return newsetup;
 957 }
 958
 959 bool _af_wave_instparam_valid (AFfilehandle filehandle, AUpvlist list, int i)
 960 {
 961         int     param, type, lval;
 962
 963         AUpvgetparam(list, i, &param);
 964         AUpvgetvaltype(list, i, &type);
 965         if (type != AU_PVTYPE_LONG)
 966                 return false;
 967
 968         AUpvgetval(list, i, &lval);
 969
 970         switch (param)
 971         {
 972                 case AF_INST_MIDI_BASENOTE:
 973                         return ((lval >= 0) && (lval <= 127));
 974
 975                 case AF_INST_NUMCENTS_DETUNE:
 976                         return ((lval >= -50) && (lval <= 50));
 977
 978                 case AF_INST_MIDI_LOVELOCITY:
 979                         return ((lval >= 1) && (lval <= 127));
 980
 981                 case AF_INST_MIDI_HIVELOCITY:
 982                         return ((lval >= 1) && (lval <= 127));
 983
 984                 case AF_INST_MIDI_LONOTE:
 985                         return ((lval >= 0) && (lval <= 127));
 986
 987                 case AF_INST_MIDI_HINOTE:
 988                         return ((lval >= 0) && (lval <= 127));
 989
 990                 case AF_INST_NUMDBS_GAIN:
 991                         return true;
 992
 993                 default:
 994                         return false;
 995         }
 996
 997         return true;
 998 }