libaudiofile/aiffwrite.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         aiffwrite.c
  24
  25         This file contains routines for writing AIFF and AIFF-C format
  26         sound files.
  27 */
  28
  29 #ifdef HAVE_CONFIG_H
  30 #include <config.h>
  31 #endif
  32
  33 #include <assert.h>
  34 #include <stdint.h>
  35 #include <stdlib.h>
  36 #include <string.h>
  37
  38 #include "extended.h"
  39 #include "afinternal.h"
  40 #include "audiofile.h"
  41 #include "aiff.h"
  42 #include "byteorder.h"
  43 #include "util.h"
  44 #include "setup.h"
  45
  46 status _af_aiff_update (AFfilehandle file);
  47
  48 static status WriteCOMM (AFfilehandle file);
  49 static status WriteSSND (AFfilehandle file);
  50 static status WriteMARK (AFfilehandle file);
  51 static status WriteINST (AFfilehandle file);
  52 static status WriteFVER (AFfilehandle file);
  53 static status WriteAESD (AFfilehandle file);
  54 static status WriteMiscellaneous (AFfilehandle file);
  55
  56 static _AIFFInfo *aiffinfo_new (void)
  57 {
  58         _AIFFInfo       *aiff = _af_malloc(sizeof (_AIFFInfo));
  59
  60         aiff->miscellaneousPosition = 0;
  61         aiff->FVER_offset = 0;
  62         aiff->COMM_offset = 0;
  63         aiff->MARK_offset = 0;
  64         aiff->INST_offset = 0;
  65         aiff->AESD_offset = 0;
  66         aiff->SSND_offset = 0;
  67
  68         return aiff;
  69 }
  70
  71 status _af_aiff_write_init (AFfilesetup setup, AFfilehandle file)
  72 {
  73         uint32_t        fileSize = 0;
  74
  75         assert(file);
  76         assert(file->fileFormat == AF_FILE_AIFF ||
  77                 file->fileFormat == AF_FILE_AIFFC);
  78
  79         if (_af_filesetup_make_handle(setup, file) == AF_FAIL)
  80                 return AF_FAIL;
  81
  82         file->formatSpecific = aiffinfo_new();
  83
  84         af_fwrite("FORM", 4, 1, file->fh);
  85         af_write_uint32_be(&fileSize, file->fh);
  86
  87         if (file->fileFormat == AF_FILE_AIFF)
  88                 af_fwrite("AIFF", 4, 1, file->fh);
  89         else if (file->fileFormat == AF_FILE_AIFFC)
  90                 af_fwrite("AIFC", 4, 1, file->fh);
  91
  92         if (file->fileFormat == AF_FILE_AIFFC)
  93                 WriteFVER(file);
  94
  95         WriteCOMM(file);
  96         WriteMARK(file);
  97         WriteINST(file);
  98         WriteAESD(file);
  99         WriteMiscellaneous(file);
 100         WriteSSND(file);
 101
 102         return AF_SUCCEED;
 103 }
 104
 105 status _af_aiff_update (AFfilehandle file)
 106 {
 107         _Track          *track;
 108         uint32_t        length;
 109
 110         assert(file);
 111
 112         track = _af_filehandle_get_track(file, AF_DEFAULT_TRACK);
 113
 114 #ifdef DEBUG
 115         printf("_af_aiff_update called.\n");
 116 #endif
 117
 118         /* Get the length of the file. */
 119         length = af_flength(file->fh);
 120         length -= 8;
 121
 122         /* Set the length of the FORM chunk. */
 123         af_fseek(file->fh, 4, SEEK_SET);
 124         af_write_uint32_be(&length, file->fh);
 125
 126         if (file->fileFormat == AF_FILE_AIFFC)
 127                 WriteFVER(file);
 128
 129         WriteCOMM(file);
 130         WriteMARK(file);
 131         WriteINST(file);
 132         WriteAESD(file);
 133         WriteMiscellaneous(file);
 134         WriteSSND(file);
 135
 136         return AF_SUCCEED;
 137 }
 138
 139 static status WriteCOMM (const AFfilehandle file)
 140 {
 141         _Track          *track;
 142         uint32_t        chunkSize;
 143         _AIFFInfo       *aiff;
 144         bool            isAIFFC;
 145
 146         uint16_t        sb;
 147         uint32_t        lb;
 148         unsigned char   eb[10];
 149
 150         uint8_t         compressionTag[4];
 151         /* Pascal strings can occupy only 255 bytes (+ a size byte). */
 152         char            compressionName[256];
 153
 154         isAIFFC = file->fileFormat == AF_FILE_AIFFC;
 155
 156         aiff = file->formatSpecific;
 157
 158         /*
 159                 If COMM_offset hasn't been set yet, set it to the
 160                 current offset.
 161         */
 162         if (aiff->COMM_offset == 0)
 163                 aiff->COMM_offset = af_ftell(file->fh);
 164         else
 165                 af_fseek(file->fh, aiff->COMM_offset, SEEK_SET);
 166
 167         track = _af_filehandle_get_track(file, AF_DEFAULT_TRACK);
 168
 169         if (isAIFFC)
 170         {
 171                 if (track->f.compressionType == AF_COMPRESSION_NONE)
 172                 {
 173                         if (track->f.sampleFormat == AF_SAMPFMT_TWOSCOMP)
 174                         {
 175                                 memcpy(compressionTag, "NONE", 4);
 176                                 strcpy(compressionName, "not compressed");
 177                         }
 178                         else if (track->f.sampleFormat == AF_SAMPFMT_FLOAT)
 179                         {
 180                                 memcpy(compressionTag, "fl32", 4);
 181                                 strcpy(compressionName, "32-bit Floating Point");
 182                         }
 183                         else if (track->f.sampleFormat == AF_SAMPFMT_DOUBLE)
 184                         {
 185                                 memcpy(compressionTag, "fl64", 4);
 186                                 strcpy(compressionName, "64-bit Floating Point");
 187                         }
 188                         /*
 189                                 We disallow unsigned sample data for
 190                                 AIFF files in _af_aiff_complete_setup,
 191                                 so the next condition should never be
 192                                 satisfied.
 193                         */
 194                         else if (track->f.sampleFormat == AF_SAMPFMT_UNSIGNED)
 195                         {
 196                                 _af_error(AF_BAD_SAMPFMT,
 197                                         "AIFF/AIFF-C format does not support unsigned data");
 198                                 assert(0);
 199                                 return AF_FAIL;
 200                         }
 201                 }
 202                 else if (track->f.compressionType == AF_COMPRESSION_G711_ULAW)
 203                 {
 204                         memcpy(compressionTag, "ulaw", 4);
 205                         strcpy(compressionName, "CCITT G.711 u-law");
 206                 }
 207                 else if (track->f.compressionType == AF_COMPRESSION_G711_ALAW)
 208                 {
 209                         memcpy(compressionTag, "alaw", 4);
 210                         strcpy(compressionName, "CCITT G.711 A-law");
 211                 }
 212         }
 213
 214         af_fwrite("COMM", 4, 1, file->fh);
 215
 216         /*
 217                 For AIFF-C files, the length of the COMM chunk is 22
 218                 plus the length of the compression name plus the size
 219                 byte.  If the length of the data is an odd number of
 220                 bytes, add a zero pad byte at the end, but don't
 221                 include the pad byte in the chunk's size.
 222         */
 223         if (isAIFFC)
 224                 chunkSize = 22 + strlen(compressionName) + 1;
 225         else
 226                 chunkSize = 18;
 227         af_write_uint32_be(&chunkSize, file->fh);
 228
 229         /* number of channels, 2 bytes */
 230         sb = track->f.channelCount;
 231         af_write_uint16_be(&sb, file->fh);
 232
 233         /* number of sample frames, 4 bytes */
 234         lb = track->totalfframes;
 235         af_write_uint32_be(&lb, file->fh);
 236
 237         /* sample size, 2 bytes */
 238         sb = track->f.sampleWidth;
 239         af_write_uint16_be(&sb, file->fh);
 240
 241         /* sample rate, 10 bytes */
 242         _af_convert_to_ieee_extended(track->f.sampleRate, eb);
 243         af_fwrite(eb, 10, 1, file->fh);
 244
 245         if (file->fileFormat == AF_FILE_AIFFC)
 246         {
 247                 af_fwrite(compressionTag, 4, 1, file->fh);
 248
 249                 af_write_pstring(compressionName, file->fh);
 250         }
 251
 252         return AF_SUCCEED;
 253 }
 254
 255 /*
 256         The AESD chunk contains information pertinent to audio recording
 257         devices.
 258 */
 259 static status WriteAESD (const AFfilehandle file)
 260 {
 261         _Track          *track;
 262         uint32_t        size = 24;
 263         _AIFFInfo       *aiff;
 264
 265         assert(file);
 266
 267         aiff = file->formatSpecific;
 268
 269         track = _af_filehandle_get_track(file, AF_DEFAULT_TRACK);
 270
 271         if (!track->hasAESData)
 272                 return AF_SUCCEED;
 273
 274         if (aiff->AESD_offset == 0)
 275                 aiff->AESD_offset = af_ftell(file->fh);
 276         else
 277                 af_fseek(file->fh, aiff->AESD_offset, SEEK_SET);
 278
 279         if (af_fwrite("AESD", 4, 1, file->fh) < 1)
 280                 return AF_FAIL;
 281
 282         if (af_write_uint32_be(&size, file->fh) == AF_FAIL)
 283                 return AF_FAIL;
 284
 285         if (af_fwrite(track->aesData, 24, 1, file->fh) < 1)
 286                 return AF_FAIL;
 287
 288         return AF_SUCCEED;
 289 }
 290
 291 static status WriteSSND (AFfilehandle file)
 292 {
 293         _Track          *track;
 294         uint32_t        chunkSize, zero = 0;
 295         _AIFFInfo       *aiff;
 296
 297         assert(file);
 298         assert(file->fh);
 299
 300         aiff = file->formatSpecific;
 301
 302         track = _af_filehandle_get_track(file, AF_DEFAULT_TRACK);
 303
 304         if (aiff->SSND_offset == 0)
 305                 aiff->SSND_offset = af_ftell(file->fh);
 306         else
 307                 af_fseek(file->fh, aiff->SSND_offset, SEEK_SET);
 308
 309         chunkSize = (int) _af_format_frame_size(&track->f, false) *
 310                 track->totalfframes + 8;
 311
 312         af_fwrite("SSND", 4, 1, file->fh);
 313         af_write_uint32_be(&chunkSize, file->fh);
 314
 315         /* data offset */
 316         af_write_uint32_be(&zero, file->fh);
 317         /* block size */
 318         af_write_uint32_be(&zero, file->fh);
 319
 320         if (track->fpos_first_frame == 0)
 321                 track->fpos_first_frame = af_ftell(file->fh);
 322
 323         return AF_SUCCEED;
 324 }
 325
 326 static status WriteINST (AFfilehandle file)
 327 {
 328         uint32_t        length;
 329         struct _INST    instrumentdata;
 330
 331         length = 20;
 332
 333         instrumentdata.sustainLoopPlayMode =
 334                 afGetLoopMode(file, AF_DEFAULT_INST, 1);
 335         instrumentdata.sustainLoopBegin =
 336                 afGetLoopStart(file, AF_DEFAULT_INST, 1);
 337         instrumentdata.sustainLoopEnd =
 338                 afGetLoopEnd(file, AF_DEFAULT_INST, 1);
 339
 340         instrumentdata.releaseLoopPlayMode =
 341                 afGetLoopMode(file, AF_DEFAULT_INST, 2);
 342         instrumentdata.releaseLoopBegin =
 343                 afGetLoopStart(file, AF_DEFAULT_INST, 2);
 344         instrumentdata.releaseLoopEnd =
 345                 afGetLoopEnd(file, AF_DEFAULT_INST, 2);
 346
 347         af_fwrite("INST", 4, 1, file->fh);
 348         af_write_uint32_be(&length, file->fh);
 349
 350         instrumentdata.baseNote =
 351                 afGetInstParamLong(file, AF_DEFAULT_INST, AF_INST_MIDI_BASENOTE);
 352         af_write_uint8(&instrumentdata.baseNote, file->fh);
 353         instrumentdata.detune =
 354                 afGetInstParamLong(file, AF_DEFAULT_INST, AF_INST_NUMCENTS_DETUNE);
 355         af_write_uint8(&instrumentdata.detune, file->fh);
 356         instrumentdata.lowNote =
 357                 afGetInstParamLong(file, AF_DEFAULT_INST, AF_INST_MIDI_LONOTE);
 358         af_write_uint8(&instrumentdata.lowNote, file->fh);
 359         instrumentdata.highNote =
 360                 afGetInstParamLong(file, AF_DEFAULT_INST, AF_INST_MIDI_HINOTE);
 361         af_write_uint8(&instrumentdata.highNote, file->fh);
 362         instrumentdata.lowVelocity =
 363                 afGetInstParamLong(file, AF_DEFAULT_INST, AF_INST_MIDI_LOVELOCITY);
 364         af_write_uint8(&instrumentdata.lowVelocity, file->fh);
 365         instrumentdata.highVelocity =
 366                 afGetInstParamLong(file, AF_DEFAULT_INST, AF_INST_MIDI_HIVELOCITY);
 367         af_write_uint8(&instrumentdata.highVelocity, file->fh);
 368
 369         instrumentdata.gain =
 370                 afGetInstParamLong(file, AF_DEFAULT_INST, AF_INST_NUMDBS_GAIN);
 371         af_write_uint16_be(&instrumentdata.gain, file->fh);
 372
 373         af_write_uint16_be(&instrumentdata.sustainLoopPlayMode, file->fh);
 374         af_write_uint16_be(&instrumentdata.sustainLoopBegin, file->fh);
 375         af_write_uint16_be(&instrumentdata.sustainLoopEnd, file->fh);
 376
 377         af_write_uint16_be(&instrumentdata.releaseLoopPlayMode, file->fh);
 378         af_write_uint16_be(&instrumentdata.releaseLoopBegin, file->fh);
 379         af_write_uint16_be(&instrumentdata.releaseLoopEnd, file->fh);
 380
 381         return AF_SUCCEED;
 382 }
 383
 384 static status WriteMARK (AFfilehandle file)
 385 {
 386         AFfileoffset    chunkStartPosition, chunkEndPosition;
 387         uint32_t        length = 0;
 388         uint16_t        numMarkers;
 389         int             i, *markids;
 390         _AIFFInfo       *aiff;
 391
 392         assert(file);
 393
 394         numMarkers = afGetMarkIDs(file, AF_DEFAULT_TRACK, NULL);
 395         if (numMarkers == 0)
 396                 return AF_SUCCEED;
 397
 398         aiff = file->formatSpecific;
 399
 400         if (aiff->MARK_offset == 0)
 401                 aiff->MARK_offset = af_ftell(file->fh);
 402         else
 403                 af_fseek(file->fh, aiff->MARK_offset, SEEK_SET);
 404
 405         af_fwrite("MARK", 4, 1, file->fh);
 406         af_write_uint32_be(&length, file->fh);
 407
 408         chunkStartPosition = af_ftell(file->fh);
 409
 410         markids = _af_calloc(numMarkers, sizeof (int));
 411         assert(markids);
 412         afGetMarkIDs(file, AF_DEFAULT_TRACK, markids);
 413
 414         af_write_uint16_be(&numMarkers, file->fh);
 415
 416         for (i=0; i<numMarkers; i++)
 417         {
 418                 uint8_t         namelength, zero = 0;
 419                 uint16_t        id;
 420                 uint32_t        position;
 421                 char            *name;
 422
 423                 id = markids[i];
 424                 position = afGetMarkPosition(file, AF_DEFAULT_TRACK, markids[i]);
 425
 426                 af_write_uint16_be(&id, file->fh);
 427                 af_write_uint32_be(&position, file->fh);
 428
 429                 name = afGetMarkName(file, AF_DEFAULT_TRACK, markids[i]);
 430                 assert(name);
 431
 432                 /* Write the name as a Pascal-style string. */
 433                 af_write_pstring(name, file->fh);
 434         }
 435
 436         free(markids);
 437
 438         chunkEndPosition = af_ftell(file->fh);
 439         length = chunkEndPosition - chunkStartPosition;
 440
 441 #ifdef DEBUG
 442         printf(" end: %d\n", chunkEndPosition);
 443         printf(" length: %d\n", length);
 444 #endif
 445
 446         af_fseek(file->fh, chunkStartPosition - 4, SEEK_SET);
 447
 448         af_write_uint32_be(&length, file->fh);
 449         af_fseek(file->fh, chunkEndPosition, SEEK_SET);
 450
 451         return AF_SUCCEED;
 452 }
 453
 454 /*
 455         The FVER chunk, if present, is always the first chunk in the file.
 456 */
 457 static status WriteFVER (AFfilehandle file)
 458 {
 459         uint32_t        chunkSize, timeStamp;
 460         _AIFFInfo       *aiff;
 461
 462         assert(file->fileFormat == AF_FILE_AIFFC);
 463
 464         aiff = file->formatSpecific;
 465
 466         if (aiff->FVER_offset == 0)
 467                 aiff->FVER_offset = af_ftell(file->fh);
 468         else
 469                 af_fseek(file->fh, aiff->FVER_offset, SEEK_SET);
 470
 471         af_fwrite("FVER", 4, 1, file->fh);
 472
 473         chunkSize = 4;
 474         af_write_uint32_be(&chunkSize, file->fh);
 475
 476         timeStamp = AIFC_VERSION_1;
 477         af_write_uint32_be(&timeStamp, file->fh);
 478
 479         return AF_SUCCEED;
 480 }
 481
 482 /*
 483         WriteMiscellaneous writes all the miscellaneous data chunks in a
 484         file handle structure to an AIFF or AIFF-C file.
 485 */
 486 static status WriteMiscellaneous (AFfilehandle file)
 487 {
 488         _AIFFInfo       *aiff;
 489         int             i;
 490
 491         aiff = (_AIFFInfo *) file->formatSpecific;
 492
 493         if (aiff->miscellaneousPosition == 0)
 494                 aiff->miscellaneousPosition = af_ftell(file->fh);
 495         else
 496                 af_fseek(file->fh, aiff->miscellaneousPosition, SEEK_SET);
 497
 498         for (i=0; i<file->miscellaneousCount; i++)
 499         {
 500                 _Miscellaneous  *misc = &file->miscellaneous[i];
 501                 uint32_t        chunkType, chunkSize;
 502                 uint8_t         padByte = 0;
 503
 504 #ifdef DEBUG
 505                 printf("WriteMiscellaneous: %d, type %d\n", i, misc->type);
 506 #endif
 507
 508                 switch (misc->type)
 509                 {
 510                         case AF_MISC_NAME:
 511                                 memcpy(&chunkType, "NAME", 4); break;
 512                         case AF_MISC_AUTH:
 513                                 memcpy(&chunkType, "AUTH", 4); break;
 514                         case AF_MISC_COPY:
 515                                 memcpy(&chunkType, "(c) ", 4); break;
 516                         case AF_MISC_ANNO:
 517                                 memcpy(&chunkType, "ANNO", 4); break;
 518                         case AF_MISC_MIDI:
 519                                 memcpy(&chunkType, "MIDI", 4); break;
 520                         case AF_MISC_APPL:
 521                                 memcpy(&chunkType, "APPL", 4); break;
 522                 }
 523
 524
 525                 af_fwrite(&chunkType, 4, 1, file->fh);
 526
 527                 chunkSize = misc->size;
 528                 af_write_uint32_be(&chunkSize, file->fh);
 529                 /*
 530                         Write the miscellaneous buffer and then a pad byte
 531                         if necessary.  If the buffer is null, skip the space
 532                         for now.
 533                 */
 534                 if (misc->buffer != NULL)
 535                         af_fwrite(misc->buffer, misc->size, 1, file->fh);
 536                 else
 537                         af_fseek(file->fh, misc->size, SEEK_CUR);
 538
 539                 if (misc->size % 2 != 0)
 540                         af_write_uint8(&padByte, file->fh);
 541         }
 542
 543         return AF_SUCCEED;
 544 }