WaAIFF.h

Go to the documentation of this file.

/*
 * This file is part of the Wave Arts VQE library.
 * Copyright (C) 2011 Wave Arts, Inc. (http://wavearts.com)
 *
 * VQE is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * VQE is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * A copy of the GNU General Public License is included with VQE,
 * and can be found online at <http://www.gnu.org/licenses/>.
 *
 * If you'd like to distribute a closed-source product which uses VQE,
 * you must obtain a commercial VQE license from Wave Arts.
 */
#ifndef _WAAIFF_H
#define _WAAIFF_H

#include <stdio.h>
#include "convert.h"

#ifndef TRUE
#define FALSE 0
#define TRUE (!FALSE)
#endif

#ifndef BOOL
typedef int BOOL;
#endif

//
// MacOS specific file type
//
#if macintosh
#define AIFF_MACOS_TYPE         'AIFF'
#define AIFF_MACOS_CREATOR      'Sd2a'
#endif

//
// Types for AIFF structure elements. All types are mapped to
// character arrays, to guarantee (?) proper structure size and simplify
// conversion. If the compiler forces character arrays to be longword
// aligned, then the structures below will not work, but word alignment
// is OK, because all elements in the AIFF spec are word aligned.
//
typedef char AiffExtended[10];
typedef char AiffLong[4];
typedef char AiffShort[2];
typedef char AiffId[4];

//
// AIFF IDs as strings that can be passed to functions to compare
// and copy IDs. This is the only truly portable way to do it.
//
#define AIFF_TYPE       "AIFF"
#define AIFC_TYPE       "AIFC"
#define FORM_ID         "FORM"
#define FVER_ID         "FVER"
#define COMM_ID         "COMM"
#define SSND_ID         "SSND"
#define MARK_ID         "MARK"
#define INST_ID         "INST"
#define APPL_ID         "APPL"
#define NAME_ID         "NAME"
#define AUTH_ID         "AUTH"
#define COPY_ID         "(c) "
#define ANNO_ID         "ANNO"
#define COMT_ID         "COMT"
#define NONE_ID         "NONE"
#define SAXL_ID         "SAXL"
#define MIDI_ID         "MIDI"
#define AESD_ID         "AESD"

//
// These structures model the actual chunk and form headers
// that are written to the file.
//
typedef struct {
        AiffId          id;
        AiffLong        size;
} CkHdr;                /* 8 bytes */

typedef struct {
        CkHdr           ck;
        AiffId          formType;
} FormHdr;              /* 12 bytes */

//
// Chunk data structures *do not* contain leading chunk header,
// unlike previous versions of this code. All type names ending
// in "Data" are stored within a chunk.
//
typedef struct {
        AiffShort               numChannels;
        AiffLong                numSampleFrames;
        AiffShort               sampleSize;
        AiffExtended    sampleRate;
} CommonData;   /* 18 bytes */

//#define numSampleFramesOffset sizeof(AiffShort)       // offset to numSampleFrames

//
// Universal form of non-portable structure above.
//
typedef struct {
        short   numChannels;
        int             numSampleFrames;
        short   sampleSize;
        double  sampleRate;
} UnivCommonData;

typedef struct {
        AiffLong        offset;
        AiffLong        blockSize;
} SoundData;

typedef struct {
        int offset;
        int blockSize;
} UnivSoundData;

typedef struct {
        AiffLong        timestamp;
} FormatVersionData;

typedef AiffShort MarkerId;

typedef struct {
        MarkerId        id;
        AiffLong        position;
} WaMarker;

typedef struct {
        AiffShort       numMarkers;
} WaMarkerData;

typedef struct {
        AiffLong        timeStamp;
        MarkerId        marker;
        AiffShort       count;
} WaComment;

typedef struct {
        AiffShort       numComments;
} CommentsData;

#ifndef macintosh       
#define NoLooping                               0
#define ForwardLooping                  1
#define ForwardBackwardLooping  2
#endif
        
typedef struct {
        AiffShort       playMode;
        AiffShort       beginMark;
        AiffShort       endMark;
} Loop;                 /* 6 bytes */

typedef struct {
        char            baseNote;
        char            detune;
        char            lowNote;
        char            highNote;
        char            lowVelocity;
        char            highVelocity;
        AiffShort       gain;
        Loop            sustainLoop;
        Loop            releaseLoop;
} InstrumentData;

typedef struct {
        AiffId  appSig;
} ApplData;


//===============================================================
// AIFF interface, modeled directly after Windows MMIO interface.
//

//
// Error type
//
typedef int AIFFRESULT;

//
// Error codes
//
#define AIFFERR_NOERROR                         0
#define AIFFERR_BASE                256
#define AIFFERR_FILENOTFOUND        (AIFFERR_BASE + 1)  /* file not found */
#define AIFFERR_OUTOFMEMORY         (AIFFERR_BASE + 2)  /* out of memory */
#define AIFFERR_CANNOTOPEN          (AIFFERR_BASE + 3)  /* cannot open */
#define AIFFERR_CANNOTCLOSE         (AIFFERR_BASE + 4)  /* cannot close */
#define AIFFERR_CANNOTREAD          (AIFFERR_BASE + 5)  /* cannot read */
#define AIFFERR_CANNOTWRITE         (AIFFERR_BASE + 6)  /* cannot write */
#define AIFFERR_CANNOTSEEK          (AIFFERR_BASE + 7)  /* cannot seek */
#define AIFFERR_CANNOTEXPAND        (AIFFERR_BASE + 8)  /* cannot expand file */
#define AIFFERR_CHUNKNOTFOUND       (AIFFERR_BASE + 9)  /* chunk not found */
#define AIFFERR_UNBUFFERED          (AIFFERR_BASE + 10) /*  */
#define AIFFERR_PATHNOTFOUND        (AIFFERR_BASE + 11) /* path incorrect */
#define AIFFERR_ACCESSDENIED        (AIFFERR_BASE + 12) /* file was protected */
#define AIFFERR_SHARINGVIOLATION    (AIFFERR_BASE + 13) /* file in use */
#define AIFFERR_NETWORKERROR        (AIFFERR_BASE + 14) /* network not responding */
#define AIFFERR_TOOMANYOPENFILES    (AIFFERR_BASE + 15) /* no more file handles  */
#define AIFFERR_INVALIDFILE         (AIFFERR_BASE + 16) /* default error file error */

//
// The HAiff pointer corresponds to the HMMIO Windows Multimedia file I/O
// handle. This API is modeled after MMIO API.
//
typedef struct {
        FILE *fp;                       // file pointer
        int openFlags;          // flags set up with aiffOpen
        ConvertTab *cvt;        // conversion function table
} Aiff, *HAiff;

// flags for aiffOpen()
#define AIFF_OPEN_READ  0x01
#define AIFF_OPEN_WRITE 0x02

//
// This structure refers to a chunk or form header, and is used
// by Descend() and Ascend(). The structure remembers the offset of
// the chunk length field so it can be set later, after data is written.
//
typedef struct {
        AiffId  id;
        long    size;
        AiffId  formType;
        long    dataOffset;
        long    flags;
} CkInfo;

// ckInfo flags
#define CKINFO_DIRTY    0x01    // chunk length needs to be updated
#define CKINFO_FORM             0x02    // chunk is a FORM type

// aiffCreateChunk flags
#define AIFF_CREATE_FORM        0x01    // create FORM chunk

// aiffDescend flags
#define AIFF_FIND_CHUNK         0x01    // find specified chunk
#define AIFF_FIND_FORM          0x02    // find FORM chunk

//
// Silly thing analogous to MMIOINFO struct, here used only
// to return an error from aiffOpen().
//
typedef struct {
        AIFFRESULT      error;
} AiffInfo;

#ifdef  __cplusplus
extern "C" {
#endif

//
// Function prototypes
//
AIFFRESULT aiffAscend(HAiff haiff, CkInfo *pCkInfo, int flags);
AIFFRESULT aiffClose(HAiff haiff);
AIFFRESULT aiffCreateChunk(HAiff haiff, CkInfo *pCkInfo, int flags);
AIFFRESULT aiffDescend(HAiff haiff, CkInfo *pCkInfo, CkInfo *pCkParentInfo, int flags);
AIFFRESULT aiffFlush(HAiff haiff);
HAiff aiffOpen(char *fileName, AiffInfo *info, int flags);
long aiffRead(HAiff haiff, char *buf, long numBytes);
long aiffTell(HAiff haiff);
AIFFRESULT aiffSeek(HAiff haiff, long offset, int origin);
long aiffWrite(HAiff haiff, char *buf, long numBytes);

//
// Shortcut for writing a simple chunk header and data. Can't be
// used for FORM type. Data must already be in proper format.
//
AIFFRESULT aiffWriteChunk(HAiff haiff, AiffId id, char *data, long numBytes);

void aiffCopyId(AiffId src, AiffId dest);
BOOL aiffIdEqual(AiffId a, AiffId b);
char *aiffErrorStr(AIFFRESULT aiffError);

#ifdef  __cplusplus
}
#endif

#endif