path: root/src/libultra/audio/libaudio.h

#ifndef __LIB_AUDIO__
#define __LIB_AUDIO__

#include "ultra64/ultratypes.h"

#include "libaudio_abi.h"

/***********************************************************************
 * misc defines
 ***********************************************************************/

#define AL_FX_BUFFER_SIZE 8192
#define AL_FRAME_INIT -1
#define AL_USEC_PER_FRAME 16000
#define AL_MAX_PRIORITY 127
#define AL_GAIN_CHANGE_TIME 1000

typedef s32 ALMicroTime;
typedef u8 ALPan;

#define AL_PAN_CENTER 64
#define AL_PAN_LEFT 0
#define AL_PAN_RIGHT 127
#define AL_VOL_FULL 127
#define AL_KEY_MIN 0
#define AL_KEY_MAX 127
#define AL_DEFAULT_FXMIX 0
#define AL_SUSTAIN 63

/***********************************************************************
 * Audio Library global routines
 ***********************************************************************/
typedef struct ALLink_s {
    struct ALLink_s* next;
    struct ALLink_s* prev;
} ALLink;

void alUnlink(ALLink* ln);
void alLink(ALLink* ln, ALLink* to);

typedef s32 (*ALDMAproc)(s32 addr, s32 len, void* state);
typedef ALDMAproc (*ALDMANew)(void* state);

void alCopy(void* src, void* dest, s32 len);

typedef struct {
    u8* base;
    u8* cur;
    s32 len;
    s32 count;
} ALHeap;

#define AL_HEAP_DEBUG 1
#define AL_HEAP_MAGIC 0x20736A73 // ' sjs'
#define AL_HEAP_INIT  0

void alHeapInit(ALHeap* hp, u8* base, s32 len);
void* alHeapDBAlloc(u8* file, s32 line, ALHeap* hp, s32 num, s32 size);
s32 alHeapCheck(ALHeap* hp);

#define alHeapAlloc(hp, elem ,size) alHeapDBAlloc(0, 0,(hp),(elem),(size))

/***********************************************************************
 * FX Stuff
 ***********************************************************************/
#define AL_FX_NONE      0
#define AL_FX_SMALLROOM 1
#define AL_FX_BIGROOM   2
#define AL_FX_CHORUS    3
#define AL_FX_FLANGE    4
#define AL_FX_ECHO      5
#define AL_FX_CUSTOM    6

typedef u8 ALFxId;
typedef void* ALFxRef;

/***********************************************************************
 * data structures for sound banks
 ***********************************************************************/

#define AL_BANK_VERSION 0x4231 // 'B1'

// Possible wavetable types
enum {
    AL_ADPCM_WAVE = 0,
    AL_RAW16_WAVE
};

typedef struct {
    s32 order;
    s32 npredictors;
    s16 book[1]; // Actually variable size. Must be 8-byte aligned
} ALADPCMBook;

typedef struct {
    u32 start;
    u32 end;
    u32 count;
    ADPCM_STATE state;
} ALADPCMloop;

typedef struct {
    u32 start;
    u32 end;
    u32 count;
} ALRawLoop;

typedef struct {
    ALMicroTime attackTime;
    ALMicroTime decayTime;
    ALMicroTime releaseTime;
    u8 attackVolume;
    u8 decayVolume;
} ALEnvelope;

typedef struct {
    u8 velocityMin;
    u8 velocityMax;
    u8 keyMin;
    u8 keyMax;
    u8 keyBase;
    s8 detune;
} ALKeyMap;

typedef struct {
    ALADPCMloop* loop;
    ALADPCMBook* book;
} ALADPCMWaveInfo;

typedef struct {
    ALRawLoop* loop;
} ALRAWWaveInfo;

typedef struct ALWaveTable_s {
    u8* base;   // ptr to start of wave data
    s32 len;    // length of data in bytes
    u8 type;    // compression type
    u8 flags;   // offset/address flags
    union {
        ALADPCMWaveInfo adpcmWave;
        ALRAWWaveInfo rawWave;
    } waveInfo;
} ALWaveTable;

typedef struct ALSound_s {
    ALEnvelope* envelope;
    ALKeyMap* keyMap;
    ALWaveTable* wavetable; // offset to wavetable struct
    ALPan samplePan;
    u8 sampleVolume;
    u8 flags;
} ALSound;

typedef struct {
    u8 volume;      // overall volume for this instrument
    ALPan pan;      // 0 = hard left, 127 = hard right
    u8 priority;    // voice priority for this instrument
    u8 flags;
    u8 tremType;    // the type of tremelo osc. to use
    u8 tremRate;    // the rate of the tremelo osc.
    u8 tremDepth;   // the depth of the tremelo osc
    u8 tremDelay;   // the delay for the tremelo osc
    u8 vibType;     // the type of tremelo osc. to use
    u8 vibRate;     // the rate of the tremelo osc.
    u8 vibDepth;    // the depth of the tremelo osc
    u8 vibDelay;    // the delay for the tremelo osc
    s16 bendRange;  // pitch bend range in cents
    s16 soundCount; // number of sounds in this array
    ALSound* soundArray[1];
} ALInstrument;

typedef struct ALBank_s {
    s16 instCount;              // number of programs in this bank
    u8 flags;
    u8 pad;
    s32 sampleRate;             // e.g. 44100, 22050, etc...
    ALInstrument* percussion;   // default percussion for GM
    ALInstrument* instArray[1]; // ARRAY of instruments
} ALBank;

typedef struct {          // Note: sizeof won't be correct
    s16     revision;     // format revision of this file
    s16     bankCount;    // number of banks
    ALBank* bankArray[1]; // ARRAY of bank offsets
} ALBankFile;

void alBnkfNew(ALBankFile* f, u8* table);

/***********************************************************************
 * Sequence Files
 ***********************************************************************/
#define AL_SEQBANK_VERSION 'S1'

typedef struct {
    u8* offset;
    s32 len;
} ALSeqData;

typedef struct {           // Note: sizeof won't be correct
    s16 revision;          // format revision of this file
    s16 seqCount;          // number of sequences
    ALSeqData seqArray[1]; // ARRAY of sequence info
} ALSeqFile;

void alSeqFileNew(ALSeqFile* f, u8* base);

/***********************************************************************
 * Synthesis driver stuff
 ***********************************************************************/
typedef ALMicroTime (*ALVoiceHandler)(void*);

typedef struct {
    s32 maxVVoices; // obsolete
    s32 maxPVoices;
    s32 maxUpdates;
    s32 maxFXbusses;
    void* dmaproc;
    ALHeap* heap;
    s32 outputRate; // output sample rate
    ALFxId fxType;
    s32* params;
} ALSynConfig;

typedef struct ALPlayer_s {
    struct ALPlayer_s* next;
    void* clientData;       // storage for client callback
    ALVoiceHandler handler; // voice handler for player
    ALMicroTime callTime;   // usec requested callback
    s32 samplesLeft;        // usec remaining to callback
} ALPlayer;

typedef struct ALVoice_s {
    ALLink node;
    struct PVoice_s* pvoice;
    ALWaveTable* table;
    void* clientPrivate;
    s16 state;
    s16 priority;
    s16 fxBus;
    s16 unityPitch;
} ALVoice;

typedef struct ALVoiceConfig_s {
    s16 priority;  // voice priority
    s16 fxBus;     // bus assignment
    u8 unityPitch; // unity pitch flag
} ALVoiceConfig;

typedef struct {
    ALPlayer* head;     // client list head
    ALLink pFreeList;   // list of free physical voices
    ALLink pAllocList;  // list of allocated physical voices
    ALLink pLameList;   // list of voices ready to be freed
    s32 paramSamples;
    s32 curSamples;     // samples from start of game
    ALDMANew dma;
    ALHeap* heap;

    struct ALParam_s* paramList;

    struct ALMainBus_s* mainBus;
    struct ALAuxBus_s* auxBus;        // ptr to array of aux bus structs
    struct ALFilter_s* outputFilter;  // last filter in the filter chain

    s32 numPVoices;
    s32 maxAuxBusses;
    s32 outputRate;     // output sample rate
    s32 maxOutSamples;  // Maximum samples rsp can generate at one time at output rate
} ALSynth;

void alSynNew(ALSynth* drvr, ALSynConfig* c);
void alSynDelete(ALSynth* drvr);

void alSynAddPlayer(ALSynth* s, ALPlayer* client);
void alSynRemovePlayer(ALSynth* s, ALPlayer* client);

s32 alSynAllocVoice(ALSynth* s, ALVoice* v, ALVoiceConfig* vc);
void alSynFreeVoice(ALSynth* s, ALVoice* voice);

void alSynStartVoice(ALSynth* s, ALVoice* voice, ALWaveTable* w);
void alSynStartVoiceParams(ALSynth* s, ALVoice* voice, ALWaveTable* w, f32 pitch, s16 vol, ALPan pan, u8 fxmix, ALMicroTime t);
void alSynStopVoice(ALSynth* s, ALVoice* voice);

void alSynSetVol(ALSynth* s, ALVoice* v, s16 vol, ALMicroTime delta);
void alSynSetPitch(ALSynth* s, ALVoice* voice, f32 ratio);
void alSynSetPan(ALSynth* s, ALVoice* voice, ALPan pan);
void alSynSetFXMix(ALSynth* s, ALVoice* voice, u8 fxmix);
void alSynSetPriority(ALSynth* s, ALVoice* voice, s16 priority);
s16 alSynGetPriority(ALSynth* s, ALVoice* voice);

ALFxRef* alSynAllocFX(ALSynth* s, s16 bus, ALSynConfig* c, ALHeap* hp);
ALFxRef alSynGetFXRef(ALSynth* s, s16 bus, s16 index);
void alSynFreeFX(ALSynth* s, ALFxRef* fx);
void alSynSetFXParam(ALSynth* s, ALFxRef fx, s16 paramID, void* param);

/***********************************************************************
 * Audio Library (AL) stuff
 ***********************************************************************/
typedef struct {
    ALSynth drvr;
} ALGlobals;

extern ALGlobals* alGlobals;

void alInit(ALGlobals* g, ALSynConfig* c);
void alClose(ALGlobals* glob);

Acmd* alAudioFrame(Acmd* cmdList, s32* cmdLen, s16* outBuf, s32 outLen);

/***********************************************************************
 * Sequence Player stuff
 ***********************************************************************/

/**
 * Play states
 */
#define AL_STOPPED  0
#define AL_PLAYING  1
#define AL_STOPPING 2

#define AL_DEFAULT_PRIORITY 5
#define AL_DEFAULT_VOICE    0
#define AL_MAX_CHANNELS     16

/**
 * Audio Library event type definitions
 */
enum ALMsg {
    AL_SEQ_REF_EVT, // Reference to a pending event in the sequence.
    AL_SEQ_MIDI_EVT,
    AL_SEQP_MIDI_EVT,
    AL_TEMPO_EVT,
    AL_SEQ_END_EVT,
    AL_NOTE_END_EVT,
    AL_SEQP_ENV_EVT,
    AL_SEQP_META_EVT,
    AL_SEQP_PROG_EVT,
    AL_SEQP_API_EVT,
    AL_SEQP_VOL_EVT,
    AL_SEQP_LOOP_EVT,
    AL_SEQP_PRIORITY_EVT,
    AL_SEQP_SEQ_EVT,
    AL_SEQP_BANK_EVT,
    AL_SEQP_PLAY_EVT,
    AL_SEQP_STOP_EVT,
    AL_SEQP_STOPPING_EVT,
    AL_TRACK_END,
    AL_CSP_LOOPSTART,
    AL_CSP_LOOPEND,
    AL_CSP_NOTEOFF_EVT,
    AL_TREM_OSC_EVT,
    AL_VIB_OSC_EVT
};

/**
 * Midi event definitions
 */
#define AL_EVTQ_END 0x7FFFFFFF

enum AL_MIDIstatus {
    // For distinguishing channel number from status
    AL_MIDI_ChannelMask = 0x0F,
    AL_MIDI_StatusMask  = 0xF0,

    // Channel voice messages
    AL_MIDI_ChannelVoice        = 0x80,
    AL_MIDI_NoteOff             = 0x80,
    AL_MIDI_NoteOn              = 0x90,
    AL_MIDI_PolyKeyPressure     = 0xA0,
    AL_MIDI_ControlChange       = 0xB0,
    AL_MIDI_ChannelModeSelect   = 0xB0,
    AL_MIDI_ProgramChange       = 0xC0,
    AL_MIDI_ChannelPressure     = 0xD0,
    AL_MIDI_PitchBendChange     = 0xE0,

    // System messages
    AL_MIDI_SysEx                   = 0xF0, // System Exclusive
    // System common
    AL_MIDI_SystemCommon            = 0xF1,
    AL_MIDI_TimeCodeQuarterFrame    = 0xF1,
    AL_MIDI_SongPositionPointer     = 0xF2,
    AL_MIDI_SongSelect              = 0xF3,
    AL_MIDI_Undefined1              = 0xF4,
    AL_MIDI_Undefined2              = 0xF5,
    AL_MIDI_TuneRequest             = 0xF6,
    AL_MIDI_EOX                     = 0xF7, // End of System Exclusive

    // System real time
    AL_MIDI_SystemRealTime  = 0xF8,
    AL_MIDI_TimingClock     = 0xF8,
    AL_MIDI_Undefined3      = 0xF9,
    AL_MIDI_Start           = 0xFA,
    AL_MIDI_Continue        = 0xFB,
    AL_MIDI_Stop            = 0xFC,
    AL_MIDI_Undefined4      = 0xFD,
    AL_MIDI_ActiveSensing   = 0xFE,
    AL_MIDI_SystemReset     = 0xFF,
    AL_MIDI_Meta            = 0xFF  // MIDI Files only
};

enum AL_MIDIctrl {
    AL_MIDI_VOLUME_CTRL   = 0x07,
    AL_MIDI_PAN_CTRL      = 0x0A,
    AL_MIDI_PRIORITY_CTRL = 0x10, // use general purpose controller for priority
    AL_MIDI_FX_CTRL_0     = 0x14,
    AL_MIDI_FX_CTRL_1     = 0x15,
    AL_MIDI_FX_CTRL_2     = 0x16,
    AL_MIDI_FX_CTRL_3     = 0x17,
    AL_MIDI_FX_CTRL_4     = 0x18,
    AL_MIDI_FX_CTRL_5     = 0x19,
    AL_MIDI_FX_CTRL_6     = 0x1A,
    AL_MIDI_FX_CTRL_7     = 0x1B,
    AL_MIDI_FX_CTRL_8     = 0x1C,
    AL_MIDI_FX_CTRL_9     = 0x1D,
    AL_MIDI_SUSTAIN_CTRL  = 0x40,
    AL_MIDI_FX1_CTRL      = 0x5B,
    AL_MIDI_FX3_CTRL      = 0x5D
};

enum AL_MIDImeta {
    AL_MIDI_META_TEMPO = 0x51,
    AL_MIDI_META_EOT   = 0x2F
};


#define AL_CMIDI_BLOCK_CODE          0xFE
#define AL_CMIDI_LOOPSTART_CODE      0x2E
#define AL_CMIDI_LOOPEND_CODE        0x2D

#define AL_CMIDI_CNTRL_LOOPSTART     102
#define AL_CMIDI_CNTRL_LOOPEND       103
#define AL_CMIDI_CNTRL_LOOPCOUNT_SM  104
#define AL_CMIDI_CNTRL_LOOPCOUNT_BIG 105

typedef struct {
    u8* curPtr;     // ptr to the next event
    s32 lastTicks;  // sequence clock ticks (used by alSeqSetLoc)
    s32 curTicks;   // sequence clock ticks of next event (used by loop end test)
    s16 lastStatus; // the last status msg
} ALSeqMarker;

typedef struct {
    s32 ticks; // MIDI, Tempo and End events must start with ticks
    u8 status;
    u8 byte1;
    u8 byte2;
    u32 duration;
} ALMIDIEvent;

typedef struct {
    s32 ticks;
    u8 status;
    u8 type;
    u8 len;
    u8 byte1;
    u8 byte2;
    u8 byte3;
} ALTempoEvent;

typedef struct {
    s32 ticks;
    u8 status;
    u8 type;
    u8 len;
} ALEndEvent;

typedef struct {
    struct ALVoice_s* voice;
} ALNoteEvent;

typedef struct {
    struct ALVoice_s* voice;
    ALMicroTime delta;
    u8 vol;
} ALVolumeEvent;

typedef struct {
    s16 vol;
} ALSeqpVolEvent;

typedef struct {
    ALSeqMarker* start;
    ALSeqMarker* end;
    s32 count;
} ALSeqpLoopEvent;

typedef struct {
    u8 chan;
    u8 priority;
} ALSeqpPriorityEvent;

typedef struct {
    void* seq; // pointer to a seq (could be an ALSeq or an ALCSeq).
} ALSeqpSeqEvent;

typedef struct {
    ALBank* bank;
} ALSeqpBankEvent;

typedef struct {
    struct ALVoiceState_s* vs;
    void* oscState;
    u8 chan;
} ALOscEvent;

typedef struct {
    s16 type;
    union {
        ALMIDIEvent midi;
        ALTempoEvent tempo;
        ALEndEvent end;
        ALNoteEvent note;
        ALVolumeEvent vol;
        ALSeqpLoopEvent loop;
        ALSeqpVolEvent spvol;
        ALSeqpPriorityEvent sppriority;
        ALSeqpSeqEvent spseq;
        ALSeqpBankEvent spbank;
        ALOscEvent osc;
    } msg;
} ALEvent;

typedef struct {
    ALLink node;
    ALMicroTime delta;
    ALEvent evt;
} ALEventListItem;

typedef struct {
    ALLink freeList;
    ALLink allocList;
    s32 eventCount;
} ALEventQueue;

void alEvtqNew(ALEventQueue* evtq, ALEventListItem* items, s32 itemCount);
ALMicroTime alEvtqNextEvent(ALEventQueue* evtq, ALEvent* evt);
void alEvtqPostEvent(ALEventQueue* evtq, ALEvent* evt, ALMicroTime delta);
void alEvtqFlush(ALEventQueue* evtq);
void alEvtqFlushType(ALEventQueue* evtq, s16 type);

#define AL_PHASE_ATTACK  0
#define AL_PHASE_NOTEON  0
#define AL_PHASE_DECAY   1
#define AL_PHASE_SUSTAIN 2
#define AL_PHASE_RELEASE 3
#define AL_PHASE_SUSTREL 4

typedef struct ALVoiceState_s {
    struct ALVoiceState_s* next; // MUST be first
    ALVoice voice;
    ALSound* sound;
    ALMicroTime envEndTime; // time of envelope segment end
    f32 pitch;              // currect pitch ratio
    f32 vibrato;            // current value of the vibrato
    u8 envGain;             // current envelope gain
    u8 channel;             // channel assignment
    u8 key;                 // note on key number
    u8 velocity;            // note on velocity
    u8 envPhase;            // what envelope phase
    u8 phase;
    u8 tremelo;             // current value of the tremelo
    u8 flags;               // bit 0 tremelo flag, bit 1 vibrato flag
} ALVoiceState;

typedef struct {
    ALInstrument* instrument; // instrument assigned to this chan
    s16 bendRange;            // pitch bend range in cents
    ALFxId fxId;              // type of fx assigned to this chan
    ALPan pan;                // overall pan for this chan
    u8 priority;              // priority for this chan
    u8 vol;                   // current volume for this chan
    u8 fxmix;                 // current fx mix for this chan
    u8 sustain;               // current sustain pedal state
    f32 pitchBend;            // current pitch bend val in cents
} ALChanState;

typedef struct ALSeq_s {
    u8* base;       // ptr to start of sequence file
    u8* trackStart; // ptr to first MIDI event
    u8* curPtr;     // ptr to next event to read
    s32 lastTicks;  // MIDI ticks for last event
    s32 len;        // length of sequence in bytes
    f32 qnpt;       // qrter notes / tick (1/division)
    s16 division;   // ticks per quarter note
    s16 lastStatus; // for running status
} ALSeq;

typedef struct {
    u32 trackOffset[16];
    u32 division;
} ALCMidiHdr;

typedef struct ALCSeq_s {
    ALCMidiHdr* base;       // ptr to start of sequence file
    u32 validTracks;        // set of flags, showing valid tracks
    f32 qnpt;               // qrter notes / tick (1/division)
    u32 lastTicks;          // keep track of ticks incase app wants
    u32 lastDeltaTicks;     // number of delta ticks of last event
    u32 deltaFlag;          // flag: set if delta's not subtracted
    u8* curLoc[16];         // ptr to current track location, may point to next event, or may point to a backup code
    u8* curBUPtr[16];       // ptr to next event if in backup mode
    u8 curBULen[16];        // if > 0, then in backup mode
    u8 lastStatus[16];      // for running status
    u32 evtDeltaTicks[16];  // delta time to next event
} ALCSeq;

typedef struct {
    u32 validTracks;
    s32 lastTicks;
    u32 lastDeltaTicks;
    u8* curLoc[16];
    u8* curBUPtr[16];
    u8 curBULen[16];
    u8 lastStatus[16];
    u32 evtDeltaTicks[16];
} ALCSeqMarker;

#define NO_SOUND_ERR_MASK (1 << 0)
#define NOTE_OFF_ERR_MASK (1 << 1)
#define NO_VOICE_ERR_MASK (1 << 2)

typedef struct {
    s32 maxVoices;  // max number of voices to alloc
    s32 maxEvents;  // max internal events to support
    u8 maxChannels; // max MIDI channels to support (16)
    u8 debugFlags;  // control which error get reported
    ALHeap* heap;   // ptr to initialized heap
    void* initOsc;
    void* updateOsc;
    void* stopOsc;
} ALSeqpConfig;

typedef ALMicroTime (*ALOscInit)(void** oscState, f32* initVal, u8 oscType, u8 oscRate, u8 oscDepth, u8 oscDelay);
typedef ALMicroTime (*ALOscUpdate)(void* oscState, f32* updateVal);
typedef void (*ALOscStop)(void* oscState);

typedef struct {
    ALPlayer node;  // note: must be first in structure
    ALSynth* drvr;  // reference to the client driver
    ALSeq* target;  // current sequence
    ALMicroTime curTime;
    ALBank* bank;   // current ALBank
    s32 uspt;       // microseconds per tick
    s32 nextDelta;  // microseconds to next callback
    s32 state;
    u16 chanMask;   // active channels
    s16 vol;        // overall sequence volume
    u8 maxChannels; // number of MIDI channels
    u8 debugFlags;  // control which error get reported
    ALEvent nextEvent;
    ALEventQueue evtq;
    ALMicroTime frameTime;
    ALChanState* chanState;   // 16 channels for MIDI
    ALVoiceState* vAllocHead; // list head for allocated voices
    ALVoiceState* vAllocTail; // list tail for allocated voices
    ALVoiceState* vFreeList;  // list of free voice state structs
    ALOscInit initOsc;
    ALOscUpdate updateOsc;
    ALOscStop stopOsc;
    ALSeqMarker* loopStart;
    ALSeqMarker* loopEnd;
    s32 loopCount;  // -1 = loop forever, 0 = no loop
} ALSeqPlayer;

typedef struct {
    ALPlayer node;      // note: must be first in structure
    ALSynth* drvr;      // reference to the client driver
    ALCSeq* target;     // current sequence
    ALMicroTime curTime;
    ALBank* bank;       // current ALBank
    s32 uspt;           // microseconds per tick
    s32 nextDelta;      // microseconds to next callback
    s32 state;
    u16 chanMask;       // active channels
    s16 vol;            // overall sequence volume
    u8 maxChannels;     // number of MIDI channels
    u8 debugFlags;      // control which error get reported
    ALEvent nextEvent;
    ALEventQueue evtq;
    ALMicroTime frameTime;
    ALChanState* chanState;     // 16 channels for MIDI
    ALVoiceState* vAllocHead;   // list head for allocated voices
    ALVoiceState* vAllocTail;   // list tail for allocated voices
    ALVoiceState* vFreeList;    // list of free voice state structs
    ALOscInit initOsc;
    ALOscUpdate updateOsc;
    ALOscStop stopOsc;
} ALCSPlayer;

// Sequence data representation routines

void alSeqNew(ALSeq* seq, u8* ptr, s32 len);
void alSeqNextEvent(ALSeq* seq, ALEvent* event);
s32 alSeqGetTicks(ALSeq* seq);
f32 alSeqTicksToSec(ALSeq* seq, s32 ticks, u32 tempo);
u32 alSeqSecToTicks(ALSeq* seq, f32 sec, u32 tempo);
void alSeqNewMarker(ALSeq* seq, ALSeqMarker* m, u32 ticks);
void alSeqSetLoc(ALSeq* seq, ALSeqMarker* marker);
void alSeqGetLoc(ALSeq* seq, ALSeqMarker* marker);

// Compact Sequence data representation routines

void alCSeqNew(ALCSeq* seq, u8* ptr);
void alCSeqNextEvent(ALCSeq* seq,ALEvent* evt);
s32 alCSeqGetTicks(ALCSeq* seq);
f32 alCSeqTicksToSec(ALCSeq* seq, s32 ticks, u32 tempo);
u32 alCSeqSecToTicks(ALCSeq* seq, f32 sec, u32 tempo);
void alCSeqNewMarker(ALCSeq* seq, ALCSeqMarker* m, u32 ticks);
void alCSeqSetLoc(ALCSeq* seq, ALCSeqMarker* marker);
void alCSeqGetLoc(ALCSeq* seq, ALCSeqMarker* marker);

// Sequence Player routines

f32 alCents2Ratio(s32 cents);

void alSeqpNew(ALSeqPlayer* seqp, ALSeqpConfig* config);
void alSeqpDelete(ALSeqPlayer* seqp);
void alSeqpSetSeq(ALSeqPlayer* seqp, ALSeq* seq);
ALSeq* alSeqpGetSeq(ALSeqPlayer* seqp);
void alSeqpPlay(ALSeqPlayer* seqp);
void alSeqpStop(ALSeqPlayer* seqp);
s32 alSeqpGetState(ALSeqPlayer* seqp);
void alSeqpSetBank(ALSeqPlayer* seqp, ALBank* b);
void alSeqpSetTempo(ALSeqPlayer* seqp, s32 tempo);
s32 alSeqpGetTempo(ALSeqPlayer* seqp);
s16 alSeqpGetVol(ALSeqPlayer* seqp); // Master volume control
void alSeqpSetVol(ALSeqPlayer* seqp, s16 vol);
void alSeqpLoop(ALSeqPlayer* seqp, ALSeqMarker* start, ALSeqMarker* end, s32 count);

void alSeqpSetChlProgram(ALSeqPlayer* seqp, u8 chan, u8 prog);
s32 alSeqpGetChlProgram(ALSeqPlayer* seqp, u8 chan);
void alSeqpSetChlFXMix(ALSeqPlayer* seqp, u8 chan, u8 fxmix);
u8 alSeqpGetChlFXMix(ALSeqPlayer* seqp, u8 chan);
void alSeqpSetChlVol(ALSeqPlayer* seqp, u8 chan, u8 vol);
u8 alSeqpGetChlVol(ALSeqPlayer* seqp, u8 chan);
void alSeqpSetChlPan(ALSeqPlayer* seqp, u8 chan, ALPan pan);
ALPan alSeqpGetChlPan(ALSeqPlayer* seqp, u8 chan);
void alSeqpSetChlPriority(ALSeqPlayer* seqp, u8 chan, u8 priority);
u8 alSeqpGetChlPriority(ALSeqPlayer* seqp, u8 chan);
void alSeqpSendMidi(ALSeqPlayer* seqp, s32 ticks, u8 status, u8 byte1, u8 byte2);

// Maintain backwards compatibility with old routine names.

#define alSeqpSetProgram         alSeqpSetChlProgram
#define alSeqpGetProgram         alSeqpGetChlProgram
#define alSeqpSetFXMix           alSeqpSetChlFXMix
#define alSeqpGetFXMix           alSeqpGetChlFXMix
#define alSeqpSetPan             alSeqpSetChlPan
#define alSeqpGetPan             alSeqpGetChlPan
#define alSeqpSetChannelPriority alSeqpSetChlPriority
#define alSeqpGetChannelPriority alSeqpGetChlPriority

// Compressed Sequence Player routines

void alCSPNew(ALCSPlayer* seqp, ALSeqpConfig* config);
void alCSPDelete(ALCSPlayer* seqp);
void alCSPSetSeq(ALCSPlayer* seqp, ALCSeq* seq);
ALCSeq* alCSPGetSeq(ALCSPlayer* seqp);
void alCSPPlay(ALCSPlayer* seqp);
void alCSPStop(ALCSPlayer* seqp);
s32 alCSPGetState(ALCSPlayer* seqp);
void alCSPSetBank(ALCSPlayer* seqp, ALBank* b);
void alCSPSetTempo(ALCSPlayer* seqp, s32 tempo);
s32 alCSPGetTempo(ALCSPlayer* seqp);
s16 alCSPGetVol(ALCSPlayer* seqp);
void alCSPSetVol(ALCSPlayer* seqp, s16 vol);

void alCSPSetChlProgram(ALCSPlayer* seqp, u8 chan, u8 prog);
s32 alCSPGetChlProgram(ALCSPlayer* seqp, u8 chan);
void alCSPSetChlFXMix(ALCSPlayer* seqp, u8 chan, u8 fxmix);
u8 alCSPGetChlFXMix(ALCSPlayer* seqp, u8 chan);
void alCSPSetChlPan(ALCSPlayer* seqp, u8 chan, ALPan pan);
ALPan alCSPGetChlPan(ALCSPlayer* seqp, u8 chan);
void alCSPSetChlVol(ALCSPlayer* seqp, u8 chan, u8 vol);
u8 alCSPGetChlVol(ALCSPlayer* seqp, u8 chan);
void alCSPSetChlPriority(ALCSPlayer* seqp, u8 chan, u8 priority);
u8 alCSPGetChlPriority(ALCSPlayer* seqp, u8 chan);
void alCSPSendMidi(ALCSPlayer* seqp, s32 ticks, u8 status, u8 byte1, u8 byte2);

// Maintain backwards compatibility with old routine names.

#define alCSPSetProgram         alCSPSetChlProgram
#define alCSPGetProgram         alCSPGetChlProgram
#define alCSPSetFXMix           alCSPSetChlFXMix
#define alCSPGetFXMix           alCSPGetChlFXMix
#define alCSPSetPan             alCSPSetChlPan
#define alCSPGetPan             alCSPGetChlPan
#define alCSPSetChannelPriority alCSPSetChlPriority
#define alCSPGetChannelPriority alCSPGetChlPriority



/***********************************************************************
 * Sound Player stuff
 ***********************************************************************/

typedef struct {
    s32 maxSounds;
    s32 maxEvents;
    ALHeap* heap;
} ALSndpConfig;

typedef struct {
    ALPlayer node; // note: must be first in structure
    ALEventQueue evtq;
    ALEvent nextEvent;
    ALSynth* drvr; // reference to the client driver
    s32 target;
    void* sndState;
    s32 maxSounds;
    ALMicroTime frameTime;
    ALMicroTime nextDelta; // microseconds to next callback
    ALMicroTime curTime;
} ALSndPlayer;

typedef s16 ALSndId;

void alSndpNew(ALSndPlayer* sndp, ALSndpConfig* c);
void alSndpDelete(ALSndPlayer* sndp);

ALSndId alSndpAllocate(ALSndPlayer* sndp, ALSound* sound);
void alSndpDeallocate(ALSndPlayer* sndp, ALSndId id);

void alSndpSetSound(ALSndPlayer* sndp, ALSndId id);
ALSndId alSndpGetSound(ALSndPlayer* sndp);

void alSndpPlay(ALSndPlayer* sndp);
void alSndpPlayAt(ALSndPlayer* sndp, ALMicroTime delta);
void alSndpStop(ALSndPlayer* sndp);

void alSndpSetVol(ALSndPlayer* sndp, s16 vol);
void alSndpSetPitch(ALSndPlayer* sndp, f32 pitch);
void alSndpSetPan(ALSndPlayer* sndp, ALPan pan);
void alSndpSetPriority(ALSndPlayer* sndp, ALSndId id, u8 priority);

void alSndpSetFXMix(ALSndPlayer* sndp, u8 mix);
s32 alSndpGetState(ALSndPlayer* sndp);

#endif