/*==================================================================== * libaudio.h * * Copyright 1993, Silicon Graphics, Inc. * All Rights Reserved. * * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, * Inc.; the contents of this file may not be disclosed to third * parties, copied or duplicated in any form, in whole or in part, * without the prior written permission of Silicon Graphics, Inc. * * RESTRICTED RIGHTS LEGEND: * Use, duplication or disclosure by the Government is subject to * restrictions as set forth in subdivision (c)(1)(ii) of the Rights * in Technical Data and Computer Software clause at DFARS * 252.227-7013, and/or in similar or successor clauses in the FAR, * DOD or NASA FAR Supplement. Unpublished - rights reserved under the * Copyright Laws of the United States. *====================================================================*/ /************************************************************************** * * $Revision: 1.173 $ * $Date: 1997/12/01 12:42:21 $ * $Source: /hosts/gate3/exdisk2/cvs/N64OS/Master/cvsmdev2/PR/include/libaudio.h,v $ * **************************************************************************/ #ifndef __LIB_AUDIO__ #define __LIB_AUDIO__ #ifdef _LANGUAGE_C_PLUS_PLUS extern "C" { #endif #include #include /*********************************************************************** * misc defines ***********************************************************************/ #ifndef _EMULATOR # ifdef AUD_PROFILE #define PROFILE_AUD(num, cnt, max, min) \ { \ u32 currCnt = osGetCount(); \ currCnt -= lastCnt[cnt_index]; \ cnt_index--; \ cnt += currCnt; \ num++; \ \ if ( currCnt > max ) max = currCnt; \ if ( currCnt < min ) min = currCnt; \ } # endif /* AUD_PROFILE */ #endif /* EMULATOR */ #ifndef NULL #define NULL 0 #endif #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 /*********************************************************************** * Error handling ***********************************************************************/ #ifdef _DEBUG #define ALFailIf(condition, error) \ if (condition) { \ __osError(error, 0); \ return; } #else #define ALFailIf(condition, error) \ if (condition) { \ return; } #endif #ifdef _DEBUG #define ALFlagFailIf(condition, flag, error) \ if (condition) { \ if (flag) __osError(error, 0); \ return; } #else #define ALFlagFailIf(condition, flag, error) \ if (condition) { \ return; } #endif /*********************************************************************** * Audio Library global routines ***********************************************************************/ typedef struct ALLink_s { struct ALLink_s *next; struct ALLink_s *prev; } ALLink; void alUnlink(ALLink *element); void alLink(ALLink *element, ALLink *after); 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 #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); #ifdef _DEBUG #define alHeapAlloc(hp, elem ,size) alHeapDBAlloc((u8 *) __FILE__,__LINE__,(hp),(elem),(size)) #else #define alHeapAlloc(hp, elem ,size) alHeapDBAlloc(0, 0,(hp),(elem),(size)) #endif /*********************************************************************** * 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 *s, ALSynConfig *config); void alSynDelete(ALSynth *s); 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 *glob, 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 0x01 #define NOTE_OFF_ERR_MASK 0x02 #define NO_VOICE_ERR_MASK 0x04 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); #ifndef _FINALROM void alParseAbiCL(Acmd *cmdList, u32 nbytes); #endif #ifdef _LANGUAGE_C_PLUS_PLUS } #endif #endif /* !__LIB_AUDIO__ */