diff --git a/README.md b/README.md index 7c7b4680..f4f0bf7f 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -# banjo (94.9890%) +# banjo (95.3216%) diff --git a/decompressed.us.v10.yaml b/decompressed.us.v10.yaml index e4a86265..07095198 100644 --- a/decompressed.us.v10.yaml +++ b/decompressed.us.v10.yaml @@ -197,7 +197,7 @@ segments: - [0xF38E50, c, done/audio/n_synsetfxmix] #DONE - [0xF38EE0, c, done/audio/n_synstopvoice] #DONE - [0xF38F50, c, done/audio/n_synfreevoice] #DONE - - [0xF38FF0, c, audio/n_csplayer] + - [0xF38FF0, c, done/audio/n_csplayer] #DONE - [0xF3A460, c, done/audio/cspsetbank] #DONE - [0xF3A4A0, c, done/audio/cspstop] #DONE - [0xF3A4D0, c, done/audio/n_csq] #DONE @@ -424,7 +424,7 @@ segments: - [0xF53B70, .rodata, code_1BE90] - [0xF53BA0, .rodata, code_1D5D0] - [0xF53C00, .rodata, done/audio/n_synthesizer] - - [0xF53C10, bin, data_3A9C0] # .rodata, audio/n_csplayer] + - [0xF53C10, .rodata, done/audio/n_csplayer] - [0xF53F80, .rodata, done/audio/n_reverb] - [0xF53FB0, .rodata, done/audio/n_drvrNew] - [0xF53FD0, .rodata, done/audio/n_env] diff --git a/progress/progress_core1.svg b/progress/progress_core1.svg index 53ca86ce..4d328fc0 100644 --- a/progress/progress_core1.svg +++ b/progress/progress_core1.svg @@ -9,7 +9,7 @@ - + @@ -17,7 +17,7 @@ core1 - 90.4597% - 90.4597% + 92.7510% + 92.7510% \ No newline at end of file diff --git a/progress/progress_total.svg b/progress/progress_total.svg index c82c502a..f534bd11 100644 --- a/progress/progress_total.svg +++ b/progress/progress_total.svg @@ -9,7 +9,7 @@ - + @@ -17,7 +17,7 @@ Banjo-Kazooie (us.v10) - 94.9890% - 94.9890% + 95.3216% + 95.3216% \ No newline at end of file diff --git a/src/core1/audio/n_csplayer.c b/src/core1/audio/n_csplayer.c deleted file mode 100644 index d8347220..00000000 --- a/src/core1/audio/n_csplayer.c +++ /dev/null @@ -1,20 +0,0 @@ -#include -#include "functions.h" -#include "variables.h" - - -#pragma GLOBAL_ASM("asm/nonmatchings/core1/audio/n_csplayer/func_8025D7C0.s") - -#pragma GLOBAL_ASM("asm/nonmatchings/core1/audio/n_csplayer/func_8025D830.s") - -#pragma GLOBAL_ASM("asm/nonmatchings/core1/audio/n_csplayer/func_8025D838.s") - -#pragma GLOBAL_ASM("asm/nonmatchings/core1/audio/n_csplayer/func_8025D840.s") - -#pragma GLOBAL_ASM("asm/nonmatchings/core1/audio/n_csplayer/func_8025DA30.s") - -#pragma GLOBAL_ASM("asm/nonmatchings/core1/audio/n_csplayer/func_8025E430.s") - -#pragma GLOBAL_ASM("asm/nonmatchings/core1/audio/n_csplayer/__n_CSPVoiceHandler.s") - -#pragma GLOBAL_ASM("asm/nonmatchings/core1/audio/n_csplayer/n_alCSPNew.s") diff --git a/src/core1/done/audio/n_csplayer.c b/src/core1/done/audio/n_csplayer.c index 0b004d99..40d5cbd8 100644 --- a/src/core1/done/audio/n_csplayer.c +++ b/src/core1/done/audio/n_csplayer.c @@ -1,33 +1,75 @@ #include +#include "functions.h" +#include "variables.h" + #include "n_synth.h" -#include - #include "seqp.h" -#include "n_cseqp.h" -#include "cseq.h" +#include "file_and_line.h" -#ifndef assert -#define assert(s) -#endif +extern void func_8033F000(const char *, const char *, int); +void n_alSynSetVol( N_ALVoice *v, s16 volume, ALMicroTime t); +s16 __n_vsVol(ALVoiceState *voice, ALSeqPlayer *seqp); +ALVoiceState *__n_lookupVoice(ALSeqPlayer *, u8, u8); +ALVoiceState *__n_mapVoice(ALSeqPlayer *, u8, u8, u8); +ALSound *__n_lookupSoundQuick(ALSeqPlayer *, u8, u8, u8); +void __n_seqpReleaseVoice(ALSeqPlayer *seqp, ALVoice *voice, ALMicroTime deltaTime); + +/*==================================================================== + * csplayer.c + * + * Copyright 1995, 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. + *====================================================================*/ + +/* + * Notes: + * + * Controller Numbers: + * 1 Modulation + * 7 Volume + * 10 Pan + * 11 Expression + * 64 Sustain + * 121 Reset All Controllers + * 123 All Notes Off + * + * Registered Parameters + * 0 Pitch Bend Sensitivity + * 1 Fine Tuning + * 2 Coarse Tuning + */ +void func_8025D7C0(ALCSPlayer *seqp); static ALMicroTime __n_CSPVoiceHandler(void *node); -static void __n_CSPHandleNextSeqEvent(N_ALCSPlayer *seqp); -static void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event); -static void __n_CSPHandleMetaMsg(N_ALCSPlayer *seqp, N_ALEvent *event); -static void __n_CSPRepostEvent(ALEventQueue *evtq, N_ALEventListItem *item); -static void __n_setUsptFromTempo(N_ALCSPlayer *seqp, ALCSeq *target, f32 tempo); /* sct 1/8/96 */ +static void __CSPHandleNextSeqEvent(ALCSPlayer *seqp); +static void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, ALEvent *event); +static void __CSPHandleMetaMsg(ALCSPlayer *seqp, ALEvent *event); +static void __CSPRepostEvent(ALEventQueue *evtq, ALEventListItem *item); +static void __setUsptFromTempo(ALCSPlayer *seqp, f32 tempo); /* sct 1/8/96 */ /* * Sequence Player public functions */ -/*done*/ void n_alCSPNew(N_ALCSPlayer *seqp, ALSeqpConfig *c) { s32 i; - N_ALEventListItem *items; - N_ALVoiceState *vs; - N_ALVoiceState *voices; + ALEventListItem *items; + ALVoiceState *vs; + ALVoiceState *voices; ALHeap *hp = c->heap; @@ -37,7 +79,7 @@ void n_alCSPNew(N_ALCSPlayer *seqp, ALSeqpConfig *c) seqp->bank = 0; seqp->target = NULL; seqp->drvr = n_syn; - seqp->chanMask = 0xffff; + seqp->chanMask = -1; seqp->uspt = 488; seqp->nextDelta = 0; seqp->state = AL_STOPPED; @@ -93,114 +135,115 @@ void n_alCSPNew(N_ALCSPlayer *seqp, ALSeqpConfig *c) *************************************************************/ static ALMicroTime __n_CSPVoiceHandler(void *node) { - N_ALCSPlayer *seqp = (N_ALCSPlayer *) node; - N_ALEvent evt; + ALCSPlayer *seqp = (ALCSPlayer *) node; + ALEvent evt; ALVoice *voice; ALMicroTime delta; ALVoiceState *vs; void *oscState; f32 oscValue; u8 chan; + do { switch (seqp->nextEvent.type) { - case (AL_SEQ_REF_EVT): - __n_CSPHandleNextSeqEvent(seqp); - break; + case (AL_SEQ_REF_EVT): + __CSPHandleNextSeqEvent(seqp); + break; - case (AL_SEQP_API_EVT): - evt.type = AL_SEQP_API_EVT; - alEvtqPostEvent(&seqp->evtq, (ALEvent *)&evt, seqp->frameTime); - break; + case (AL_SEQP_API_EVT): + evt.type = AL_SEQP_API_EVT; + alEvtqPostEvent(&seqp->evtq, (ALEvent *)&evt, seqp->frameTime); + break; - case (AL_NOTE_END_EVT): - voice = seqp->nextEvent.msg.note.voice; + case (AL_NOTE_END_EVT): + voice = seqp->nextEvent.msg.note.voice; - n_alSynStopVoice(voice); - n_alSynFreeVoice(voice); - vs = (ALVoiceState *)voice->clientPrivate; - if(vs->flags) - __n_seqpStopOsc((ALSeqPlayer*)seqp,vs); - __n_unmapVoice((ALSeqPlayer*)seqp, voice); - break; + n_alSynStopVoice(voice); + n_alSynFreeVoice(voice); + vs = (ALVoiceState *)voice->clientPrivate; + if(vs->flags) + __n_seqpStopOsc((ALSeqPlayer*)seqp,vs); + __n_unmapVoice((ALSeqPlayer*)seqp, voice); + break; - case (AL_SEQP_ENV_EVT): - voice = seqp->nextEvent.msg.vol.voice; - vs = (ALVoiceState *)voice->clientPrivate; + case (AL_SEQP_ENV_EVT): + voice = seqp->nextEvent.msg.vol.voice; + vs = (ALVoiceState *)voice->clientPrivate; - if(vs->envPhase == AL_PHASE_ATTACK) - vs->envPhase = AL_PHASE_DECAY; + if(vs->envPhase == AL_PHASE_ATTACK) + vs->envPhase = AL_PHASE_DECAY; - delta = seqp->nextEvent.msg.vol.delta; - vs->envEndTime = seqp->curTime + delta; - vs->envGain = seqp->nextEvent.msg.vol.vol; - n_alSynSetVol(voice, __n_vsVol(vs, (ALSeqPlayer*)seqp), delta); - break; - - case (AL_TREM_OSC_EVT): - vs = seqp->nextEvent.msg.osc.vs; - oscState = seqp->nextEvent.msg.osc.oscState; - delta = (*seqp->updateOsc)(oscState,&oscValue); - vs->tremelo = (u8)oscValue; - n_alSynSetVol(&vs->voice, __n_vsVol(vs,(ALSeqPlayer*)seqp), - __n_vsDelta(vs,seqp->curTime)); - evt.type = AL_TREM_OSC_EVT; - evt.msg.osc.vs = vs; - evt.msg.osc.oscState = oscState; - alEvtqPostEvent(&seqp->evtq, &evt, delta); - break; - - case (AL_VIB_OSC_EVT): - vs = seqp->nextEvent.msg.osc.vs; - oscState = seqp->nextEvent.msg.osc.oscState; - chan = seqp->nextEvent.msg.osc.chan; - delta = (*seqp->updateOsc)(oscState,&oscValue); - vs->vibrato = oscValue; - n_alSynSetPitch(&vs->voice, vs->pitch * vs->vibrato - * seqp->chanState[chan].pitchBend); - evt.type = AL_VIB_OSC_EVT; - evt.msg.osc.vs = vs; - evt.msg.osc.oscState = oscState; - evt.msg.osc.chan = chan; - alEvtqPostEvent(&seqp->evtq, &evt, delta); - break; + delta = seqp->nextEvent.msg.vol.delta; + vs->envEndTime = seqp->curTime + delta; + vs->envGain = seqp->nextEvent.msg.vol.vol; + n_alSynSetVol(voice, __n_vsVol(vs, (ALSeqPlayer*)seqp), delta); + break; + + case (AL_TREM_OSC_EVT): + vs = seqp->nextEvent.msg.osc.vs; + oscState = seqp->nextEvent.msg.osc.oscState; + delta = (*seqp->updateOsc)(oscState,&oscValue); + vs->tremelo = (u8)oscValue; + n_alSynSetVol(&vs->voice, __n_vsVol(vs,(ALSeqPlayer*)seqp), + __n_vsDelta(vs,seqp->curTime)); + evt.type = AL_TREM_OSC_EVT; + evt.msg.osc.vs = vs; + evt.msg.osc.oscState = oscState; + alEvtqPostEvent(&seqp->evtq, &evt, delta); + break; + + case (AL_VIB_OSC_EVT): + vs = seqp->nextEvent.msg.osc.vs; + oscState = seqp->nextEvent.msg.osc.oscState; + chan = seqp->nextEvent.msg.osc.chan; + delta = (*seqp->updateOsc)(oscState,&oscValue); + vs->vibrato = oscValue; + n_alSynSetPitch(&vs->voice, vs->pitch * vs->vibrato + * seqp->chanState[chan].pitchBend); + evt.type = AL_VIB_OSC_EVT; + evt.msg.osc.vs = vs; + evt.msg.osc.oscState = oscState; + evt.msg.osc.chan = chan; + alEvtqPostEvent(&seqp->evtq, &evt, delta); + break; - case (AL_SEQP_MIDI_EVT): - case (AL_CSP_NOTEOFF_EVT): /* nextEvent is a note off midi message */ - __n_CSPHandleMIDIMsg(seqp, &seqp->nextEvent); - break; + case (AL_SEQP_MIDI_EVT): + case (AL_CSP_NOTEOFF_EVT): /* nextEvent is a note off midi message */ + __n_CSPHandleMIDIMsg(seqp, &seqp->nextEvent); + break; - case (AL_SEQP_META_EVT): - __n_CSPHandleMetaMsg(seqp, &seqp->nextEvent); - break; + case (AL_SEQP_META_EVT): + __CSPHandleMetaMsg(seqp, &seqp->nextEvent); + break; - case (AL_SEQP_VOL_EVT): - seqp->vol = seqp->nextEvent.msg.spvol.vol; - for (vs = seqp->vAllocHead; vs != 0; vs = vs->next) - { - n_alSynSetVol(&vs->voice, - __n_vsVol(vs, (ALSeqPlayer*)seqp), - __n_vsDelta(vs, seqp->curTime)); - } - break; + case (AL_SEQP_VOL_EVT): + seqp->vol = seqp->nextEvent.msg.spvol.vol; + for (vs = seqp->vAllocHead; vs != 0; vs = vs->next) + { + n_alSynSetVol(&vs->voice, + __n_vsVol(vs, (ALSeqPlayer*)seqp), + __n_vsDelta(vs, seqp->curTime)); + } + break; - case (AL_SEQP_PLAY_EVT): - if (seqp->state != AL_PLAYING) - { - seqp->state = AL_PLAYING; - func_80250650(); - __n_CSPPostNextSeqEvent(seqp); /* seqp must be AL_PLAYING before we call this routine. */ - } - break; + case (AL_SEQP_PLAY_EVT): + if (seqp->state != AL_PLAYING) + { + seqp->state = AL_PLAYING; + func_80250650(); + func_8025D7C0(seqp); /* seqp must be AL_PLAYING before we call this routine. */ + } + break; - case (AL_SEQP_STOP_EVT): - if ( seqp->state == AL_STOPPING ) - { - for (vs = seqp->vAllocHead; vs != 0; vs = seqp->vAllocHead) - { - #ifdef _DEBUG - __osError(ERR_ALCSPVNOTFREE, 2, vs->channel, vs->key); - #endif + case (AL_SEQP_STOP_EVT): + if ( seqp->state == AL_STOPPING ) + { + for (vs = seqp->vAllocHead; vs != 0; vs = seqp->vAllocHead) + { +#ifdef _DEBUG + __osError(ERR_ALCSPVNOTFREE, 2, vs->channel, vs->key); +#endif n_alSynStopVoice(&vs->voice); n_alSynFreeVoice(&vs->voice); if(vs->flags) @@ -220,71 +263,68 @@ static ALMicroTime __n_CSPVoiceHandler(void *node) } break; - case (AL_SEQP_STOPPING_EVT): - if (seqp->state == AL_PLAYING) - { - /* sct 12/29/95 - Remove events associated with the - * stopping sequence. For compact sequence player, - * also remove all queued note off events since they - * are not contained in a compact sequence but are - * generated in response to note ons. Note that - * flushing AL_SEQP_MIDI_EVTs may flush events that - * were posted after the call to alSeqpStop, so the - * application must queue these events either when - * the player is fully stopped, or when it is - * playing. */ - alEvtqFlushType(&seqp->evtq, AL_SEQ_REF_EVT); - alEvtqFlushType(&seqp->evtq, AL_CSP_NOTEOFF_EVT); - alEvtqFlushType(&seqp->evtq, AL_SEQP_MIDI_EVT); + case (AL_SEQP_STOPPING_EVT): + if (seqp->state == AL_PLAYING) + { + /* sct 12/29/95 - Remove events associated with the + * stopping sequence. For compact sequence player, + * also remove all queued note off events since they + * are not contained in a compact sequence but are + * generated in response to note ons. Note that + * flushing AL_SEQP_MIDI_EVTs may flush events that + * were posted after the call to alSeqpStop, so the + * application must queue these events either when + * the player is fully stopped, or when it is + * playing. */ + alEvtqFlushType(&seqp->evtq, AL_SEQ_REF_EVT); + alEvtqFlushType(&seqp->evtq, AL_CSP_NOTEOFF_EVT); + alEvtqFlushType(&seqp->evtq, AL_SEQP_MIDI_EVT); - /* sct 1/3/96 - Check to see which voices need to be - killed and release them. */ - /* Unkilled voices should have note end events - occurring prior to KILL_TIME. */ - for (vs = seqp->vAllocHead; vs != 0; vs = vs->next) - { - if (__n_voiceNeedsNoteKill ((ALSeqPlayer*)seqp, &vs->voice, KILL_TIME)) - __n_seqpReleaseVoice((ALSeqPlayer*)seqp, &vs->voice, KILL_TIME); - } + /* sct 1/3/96 - Check to see which voices need to be + killed and release them. */ + /* Unkilled voices should have note end events + occurring prior to KILL_TIME. */ + for (vs = seqp->vAllocHead; vs != 0; vs = vs->next) + { + if (__n_voiceNeedsNoteKill ((ALSeqPlayer*)seqp, &vs->voice, KILL_TIME)) + __n_seqpReleaseVoice((ALSeqPlayer*)seqp, &vs->voice, KILL_TIME); + } - seqp->state = AL_STOPPING; - evt.type = AL_SEQP_STOP_EVT; - alEvtqPostEvent(&seqp->evtq, &evt, AL_EVTQ_END); - } - break; + seqp->state = AL_STOPPING; + evt.type = AL_SEQP_STOP_EVT; + alEvtqPostEvent(&seqp->evtq, &evt, AL_EVTQ_END); + } + break; - case (AL_SEQP_PRIORITY_EVT): - chan = seqp->nextEvent.msg.sppriority.chan; - seqp->chanState[chan].priority = seqp->nextEvent.msg.sppriority.priority; - break; + case (AL_SEQP_PRIORITY_EVT): + chan = seqp->nextEvent.msg.sppriority.chan; + seqp->chanState[chan].priority = seqp->nextEvent.msg.sppriority.priority; + break; - case (AL_SEQP_SEQ_EVT): - //assert(seqp->state != AL_PLAYING); /* Must be done playing to change sequences. */ - ((seqp->state != AL_PLAYING)?((void)0):func_8033F000("seqp->state != AL_PLAYING","n_csplayer.c", 272)); + case (AL_SEQP_SEQ_EVT): + matching_assert(seqp->state != AL_PLAYING, n_csplayer.c, 0x110);/* Must be done playing to change sequences. */ + + seqp->target = seqp->nextEvent.msg.spseq.seq; + seqp->chanMask = 0xffff; + // __setUsptFromTempo (seqp, 500000.0); + if (seqp->bank) + __n_initFromBank((ALSeqPlayer *)seqp, seqp->bank); + break; - seqp->target = seqp->nextEvent.msg.spseq.seq; - seqp->chanMask = 0xFFFF; - if (seqp->bank) - __n_initFromBank((ALSeqPlayer *)seqp, seqp->bank); - break; + case (AL_SEQP_BANK_EVT): + matching_assert(seqp->state == AL_STOPPED, n_csplayer.c, 0x11b); + seqp->bank = seqp->nextEvent.msg.spbank.bank; + __n_initFromBank((ALSeqPlayer *)seqp, seqp->bank); + break; - case (AL_SEQP_BANK_EVT): - //assert(seqp->state == AL_STOPPED); /* Must be fully stopped to change banks. */ - ((seqp->state == AL_STOPPED)?((void)0):func_8033F000("seqp->state == AL_STOPPED","n_csplayer.c", 283)); - - seqp->bank = seqp->nextEvent.msg.spbank.bank; - __n_initFromBank((ALSeqPlayer *)seqp, seqp->bank); - break; - - /* sct 11/6/95 - these events should now be handled by __n_CSPHandleNextSeqEvent */ - case (AL_SEQ_END_EVT): - case (AL_TEMPO_EVT): - case (AL_SEQ_MIDI_EVT): - //assert(FALSE); - ((FALSE)?((void)0):func_8033F000("FALSE","n_csplayer.c", 296)); - break; - } - seqp->nextDelta = alEvtqNextEvent(&seqp->evtq, &seqp->nextEvent); + /* sct 11/6/95 - these events should now be handled by __CSPHandleNextSeqEvent */ + case (AL_SEQ_END_EVT): + case (AL_TEMPO_EVT): + case (AL_SEQ_MIDI_EVT): + matching_assert(FALSE, n_csplayer.c, 0x128); + break; + } + seqp->nextDelta = alEvtqNextEvent(&seqp->evtq, &seqp->nextEvent); } while (seqp->nextDelta == 0); @@ -304,8 +344,7 @@ static ALMicroTime __n_CSPVoiceHandler(void *node) is no target sequence. sct 11/7/95 */ -/*DONE*/ -void __n_CSPPostNextSeqEvent(N_ALCSPlayer *seqp) +void func_8025D7C0(ALCSPlayer *seqp) { ALEvent evt; s32 deltaTicks; @@ -330,7 +369,7 @@ void __n_CSPPostNextSeqEvent(N_ALCSPlayer *seqp) sct 11/7/95 */ static void -__n_CSPHandleNextSeqEvent(N_ALCSPlayer *seqp) +__CSPHandleNextSeqEvent(ALCSPlayer *seqp) { ALEvent evt; @@ -338,19 +377,19 @@ __n_CSPHandleNextSeqEvent(N_ALCSPlayer *seqp) if (seqp->target == NULL) return; - alCSeqNextEvent(seqp->target, &evt); + n_alCSeqNextEvent(seqp->target, &evt); switch (evt.type) { case AL_SEQ_MIDI_EVT: - __n_CSPHandleMIDIMsg(seqp, &evt); - __n_CSPPostNextSeqEvent(seqp); - break; + __n_CSPHandleMIDIMsg(seqp, &evt); + func_8025D7C0(seqp); + break; case AL_TEMPO_EVT: - __n_CSPHandleMetaMsg(seqp, &evt); - __n_CSPPostNextSeqEvent(seqp); - break; + __CSPHandleMetaMsg(seqp, &evt); + func_8025D7C0(seqp); + break; case AL_SEQ_END_EVT: seqp->state = AL_STOPPING; @@ -361,67 +400,60 @@ __n_CSPHandleNextSeqEvent(N_ALCSPlayer *seqp) case AL_TRACK_END: case AL_CSP_LOOPSTART: case AL_CSP_LOOPEND: - __n_CSPPostNextSeqEvent(seqp); + func_8025D7C0(seqp); break; default: - //assert(FALSE); /* Sequence event type not supported. */ - ((FALSE)?((void)0):func_8033F000("FALSE","n_csplayer.c", 353)); - break; + matching_assert(FALSE, n_csplayer.c, 0x161); /* Sequence event type not supported. */ } } - -static void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event) +static void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, ALEvent *event) { N_ALVoice *voice; N_ALVoiceState *vs; s32 status; u8 chan; - u8 key; - u8 vel; u8 byte1; - u8 byte2; + u8 new_var; + u8 byte2; ALMIDIEvent *midi = &event->msg.midi; s16 vol; - N_ALEvent evt; - ALMicroTime deltaTime; N_ALVoiceState *vstate; + ALEvent evt; + ALMicroTime deltaTime; ALPan pan; ALFxRef fxref; - + status = midi->status & AL_MIDI_StatusMask; + new_var = midi->byte1; chan = midi->status & AL_MIDI_ChannelMask; - byte1 = key = midi->byte1; - byte2 = vel = midi->byte2; - - if(status == AL_MIDI_ChannelModeSelect){ - if(byte1 == 0x7E){ - seqp->chanMask &= ~(1 << byte2); - vstate = seqp->vAllocHead; - while(vs){ - if(vstate->channel == byte2){ - __n_seqpReleaseVoice(seqp, &vstate->voice.node.next, vstate->sound->envelope->releaseTime); - } - vs = vs->next; - } - return; - }else if(byte1 == 0x7F){ - seqp->chanMask |= (1 << byte2); - return; - } + byte1 = new_var; + byte2 = midi->byte2; + if(status == AL_MIDI_ControlChange){ + if(byte1 == 0x7E) { + N_ALVoiceState *vstate2; + // vs = seqp->vAllocHead; + seqp->chanMask &= ~(1 << byte2); + + //vs NOT being initialied seems weird + for (vstate2 = seqp->vAllocHead; vs != 0; vs = vs->next) + { + if (vstate2->channel == byte2) + __n_seqpReleaseVoice((ALSeqPlayer*)seqp, &vstate2->voice, vstate2->sound->envelope->releaseTime); + } + return; + } else if(byte1 == 0x7F){ + seqp->chanMask |= 1 << byte2; + return; + } } - - if(!((seqp->chanMask & (1 << chan)) || status != AL_MIDI_NoteOn)) - return; - - //L8025DB08 + if ((!((1 << chan) & seqp->chanMask) && (status == 0x90))) return; switch (status) { case (AL_MIDI_NoteOn): - - if (vel != 0) /* a real note on */ + if (byte2 != 0) /* a real note on */ { ALVoiceConfig config; ALSound *sound; @@ -431,28 +463,29 @@ static void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event) void *oscState; ALInstrument *inst; - /* If we're not playing, don't process note ons. */ - if (seqp->state != AL_PLAYING) - break; + /* If we're not playing, don't process note ons. */ + if (seqp->state != AL_PLAYING) + break; - sound = __n_lookupSoundQuick((ALSeqPlayer*)seqp, key, vel, chan); + sound = __n_lookupSoundQuick((ALSeqPlayer*)seqp, byte1, byte2, chan); ALFlagFailIf(!sound, seqp->debugFlags & NO_SOUND_ERR_MASK, - ERR_ALSEQP_NO_SOUND); + ERR_ALSEQP_NO_SOUND); config.priority = seqp->chanState[chan].priority; config.fxBus = 0; config.unityPitch = 0; - vstate = __n_mapVoice((ALSeqPlayer*)seqp, key, vel, chan); + vstate = __n_mapVoice((ALSeqPlayer*)seqp, byte1, byte2, chan); ALFlagFailIf(!vstate, seqp->debugFlags & NO_VOICE_ERR_MASK, - ERR_ALSEQP_NO_VOICE ); + ERR_ALSEQP_NO_VOICE ); voice = &vstate->voice; + n_alSynAllocVoice(voice, &config); /* - * set up the voice state structure - */ + * set up the voice state structure + */ vstate->sound = sound; vstate->envPhase = AL_PHASE_ATTACK; if (seqp->chanState[chan].sustain > AL_SUSTAIN) @@ -460,7 +493,7 @@ static void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event) else vstate->phase = AL_PHASE_NOTEON; - cents = (key - sound->keyMap->keyBase) * 100 + cents = (byte1 - sound->keyMap->keyBase) * 100 + sound->keyMap->detune; vstate->pitch = alCents2Ratio(cents); @@ -469,8 +502,8 @@ static void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event) sound->envelope->attackTime; /* - * setup tremelo and vibrato if active - */ + * setup tremelo and vibrato if active + */ vstate->flags = 0; inst = seqp->chanState[chan].instrument; @@ -480,7 +513,7 @@ static void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event) if(seqp->initOsc) { deltaTime = (*seqp->initOsc)(&oscState,&oscValue,inst->tremType, - inst->tremRate,inst->tremDepth,inst->tremDelay); + inst->tremRate,inst->tremDepth,inst->tremDelay); if(deltaTime) /* a deltaTime of zero means don't run osc */ { @@ -500,7 +533,7 @@ static void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event) if(seqp->initOsc) { deltaTime = (*seqp->initOsc)(&oscState,&oscValue,inst->vibType, - inst->vibRate,inst->vibDepth,inst->vibDelay); + inst->vibRate,inst->vibDepth,inst->vibDelay); if(deltaTime) /* a deltaTime of zero means don't run osc. */ { @@ -516,8 +549,8 @@ static void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event) vstate->vibrato = oscValue; /* will default if not changed by initOsc */ /* - * calculate the note on parameters - */ + * calculate the note on parameters + */ pitch = vstate->pitch * seqp->chanState[chan].pitchBend * vstate->vibrato; fxmix = seqp->chanState[chan].fxmix; @@ -526,10 +559,10 @@ static void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event) deltaTime = sound->envelope->attackTime; n_alSynStartVoiceParams(voice, sound->wavetable, - pitch, vol, pan, fxmix, deltaTime); + pitch, vol, pan, fxmix, deltaTime); /* - * set up callbacks for envelope - */ + * set up callbacks for envelope + */ evt.type = AL_SEQP_ENV_EVT; evt.msg.vol.voice = voice; evt.msg.vol.vol = sound->envelope->decayVolume; @@ -540,11 +573,11 @@ static void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event) if(midi->duration) { /* - * set up note off evt. if no duration don't do this - */ + * set up note off evt. if no duration don't do this + */ evt.type = AL_CSP_NOTEOFF_EVT; evt.msg.midi.status = chan | AL_MIDI_NoteOff; - evt.msg.midi.byte1 = key; + evt.msg.midi.byte1 = byte1; evt.msg.midi.byte2 = 0; /* not needed ? */ deltaTime = seqp->uspt * midi->duration; @@ -556,15 +589,15 @@ static void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event) } /* - * NOTE: intentional fall-through for note on with zero - * velocity (Should never happen with compact midi sequence, - * but could happen with real time midi.) - */ + * NOTE: intentional fall-through for note on with zero + * velocity (Should never happen with compact midi sequence, + * but could happen with real time midi.) + */ case (AL_MIDI_NoteOff): - vstate = __n_lookupVoice((ALSeqPlayer*)seqp, key, chan); + vstate = __n_lookupVoice((ALSeqPlayer*)seqp, byte1, chan); ALFlagFailIf(!vstate, seqp->debugFlags & NOTE_OFF_ERR_MASK, - ERR_ALSEQP_OFF_VOICE ); + ERR_ALSEQP_OFF_VOICE ); if (vstate->phase == AL_PHASE_SUSTAIN) vstate->phase = AL_PHASE_SUSTREL; @@ -572,18 +605,18 @@ static void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event) { vstate->phase = AL_PHASE_RELEASE; __n_seqpReleaseVoice((ALSeqPlayer*)seqp, &vstate->voice, - vstate->sound->envelope->releaseTime); + vstate->sound->envelope->releaseTime); } break; case (AL_MIDI_PolyKeyPressure): /* - * Aftertouch per key (hardwired to volume). Note that - * aftertouch affects only notes that are already - * sounding. - */ - vstate = __n_lookupVoice((ALSeqPlayer*)seqp, key, chan); + * Aftertouch per key (hardwired to volume). Note that + * aftertouch affects only notes that are already + * sounding. + */ + vstate = __n_lookupVoice((ALSeqPlayer*)seqp, byte1, chan); ALFailIf(!vstate, ERR_ALSEQP_POLY_VOICE ); vstate->velocity = byte2; @@ -594,10 +627,10 @@ static void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event) case (AL_MIDI_ChannelPressure): /* - * Aftertouch per channel (hardwired to volume). Note that - * aftertouch affects only notes that are already - * sounding. - */ + * Aftertouch per channel (hardwired to volume). Note that + * aftertouch affects only notes that are already + * sounding. + */ for (vs = seqp->vAllocHead; vs != 0; vs = vs->next) { if (vs->channel == chan) { vs->velocity = byte1; @@ -635,6 +668,7 @@ static void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event) } } break; + case (0x7D): seqp->chanState[chan].unkA = byte2; for (vs = seqp->vAllocHead; vs != 0; vs = vs->next) @@ -648,7 +682,7 @@ static void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event) } break; case (AL_MIDI_PRIORITY_CTRL): - /* leave current voices where they are */ + /* leave current voices where they are */ seqp->chanState[chan].priority = byte2; break; case (AL_MIDI_SUSTAIN_CTRL): @@ -660,16 +694,16 @@ static void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event) if ( byte2 > AL_SUSTAIN ) { /* - * sustain pedal down - */ + * sustain pedal down + */ if (vs->phase == AL_PHASE_NOTEON) vs->phase = AL_PHASE_SUSTAIN; } else { /* - * sustain pedal up - */ + * sustain pedal up + */ if (vs->phase == AL_PHASE_SUSTAIN) vs->phase = AL_PHASE_NOTEON; @@ -677,8 +711,8 @@ static void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event) { vs->phase = AL_PHASE_RELEASE; __n_seqpReleaseVoice((ALSeqPlayer*)seqp, - &vs->voice, - vs->sound->envelope->releaseTime); + &vs->voice, + vs->sound->envelope->releaseTime); } } } @@ -692,39 +726,52 @@ static void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event) n_alSynSetFXMix(&vs->voice, byte2); } break; - case (0x6A): - case (0x6B): - case (0x6C): - case (0x6D): - case (0x6E): - case (0x6F): - case (0x70): - case (0x71): - case (0x72): - case (0x73): - case (0x74): - case (0x75): - case (0x76): - case (0x77): - func_80250104(seqp->target,key, chan); + case 0x6A: /* switch 2 */ + case 0x6B: /* switch 2 */ + case 0x6C: /* switch 2 */ + case 0x6D: /* switch 2 */ + case 0x6E: /* switch 2 */ + case 0x6F: /* switch 2 */ + case 0x70: /* switch 2 */ + case 0x71: /* switch 2 */ + case 0x72: /* switch 2 */ + case 0x73: /* switch 2 */ + case 0x74: /* switch 2 */ + case 0x75: /* switch 2 */ + case 0x76: /* switch 2 */ + case 0x77: /* switch 2 */ + func_80250104(seqp->target, byte1, chan); break; +/* case (AL_MIDI_FX_CTRL_0): + case (AL_MIDI_FX_CTRL_1): + case (AL_MIDI_FX_CTRL_2): + case (AL_MIDI_FX_CTRL_3): + case (AL_MIDI_FX_CTRL_4): + case (AL_MIDI_FX_CTRL_5): + case (AL_MIDI_FX_CTRL_6): + case (AL_MIDI_FX_CTRL_7): + fxref = alSynGetFXRef(seqp->drvr, 0, 0); + if (fxref) + alSynSetFXParam(seqp->drvr, fxref, (s16)byte1, (void *)byte2); + break; + case (AL_MIDI_FX3_CTRL): */ default: break; } break; case (AL_MIDI_ProgramChange): - /* sct 1/16/96 - We must have a valid bank in order to process the program change. */ - //assert(seqp->bank != NULL); - ((seqp->bank != NULL)?((void)0):func_8033F000("seqp->bank != NULL", "n_csplayer.c", 715)); - if (key < seqp->bank->instCount) + /* sct 1/16/96 - We must have a valid bank in order to process the program change. */ + matching_assert(seqp->bank != NULL, n_csplayer.c, 0x2cb); + + if (byte1 < seqp->bank->instCount) { - ALInstrument *inst = seqp->bank->instArray[key]; + ALInstrument *inst = seqp->bank->instArray[byte1]; __n_setInstChanState((ALSeqPlayer*)seqp, inst, chan); /* sct 11/6/95 */ } else { #ifdef _DEBUG - __osError(ERR_ALSEQPINVALIDPROG, 2, key, seqp->bank->instCount); + __osError(ERR_ALSEQPINVALIDPROG, 2, byte1, seqp->bank->instCount); #endif } break; @@ -747,7 +794,7 @@ static void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event) for (vs = seqp->vAllocHead; vs != 0; vs = vs->next) if (vs->channel == chan) n_alSynSetPitch(&vs->voice, - vs->pitch * bendRatio * vs->vibrato); + vs->pitch * bendRatio * vs->vibrato); } break; @@ -760,8 +807,7 @@ static void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event) } } -/*Done*/ -static void __n_CSPHandleMetaMsg(N_ALCSPlayer *seqp, N_ALEvent *event) +static void __CSPHandleMetaMsg(ALCSPlayer *seqp, ALEvent *event) { ALTempoEvent *tevt = &event->msg.tempo; ALEvent evt; @@ -778,7 +824,7 @@ static void __n_CSPHandleMetaMsg(N_ALCSPlayer *seqp, N_ALEvent *event) { oldUspt = seqp->uspt; tempo = (tevt->byte1 << 16) | (tevt->byte2 << 8) | (tevt->byte3 << 0); - __n_setUsptFromTempo (seqp, seqp->target, (f32)tempo); /* sct 1/8/96 */ + __setUsptFromTempo (seqp, (f32)tempo); /* sct 1/8/96 */ thisNode = (ALEventListItem*)seqp->evtq.allocList.next; while(thisNode) @@ -814,18 +860,18 @@ static void __n_CSPHandleMetaMsg(N_ALCSPlayer *seqp, N_ALEvent *event) nextNode = (ALEventListItem*)thisNode->node.next; ticks = thisNode->delta/oldUspt; thisNode->delta = ticks * seqp->uspt; - __n_CSPRepostEvent(&seqp->evtq,thisNode); + __CSPRepostEvent(&seqp->evtq,thisNode); thisNode = nextNode; } } } } -/*Done*/ -static void __n_CSPRepostEvent(ALEventQueue *evtq, N_ALEventListItem *item) + +static void __CSPRepostEvent(ALEventQueue *evtq, ALEventListItem *item) { OSIntMask mask; ALLink *node; - N_ALEventListItem *nextItem; + ALEventListItem *nextItem; mask = osSetIntMask(OS_IM_NONE); @@ -838,7 +884,7 @@ static void __n_CSPRepostEvent(ALEventQueue *evtq, N_ALEventListItem *item) } else { - nextItem = (N_ALEventListItem *)node->next; + nextItem = (ALEventListItem *)node->next; if (item->delta < nextItem->delta) { nextItem->delta -= item->delta; @@ -860,11 +906,10 @@ static void __n_CSPRepostEvent(ALEventQueue *evtq, N_ALEventListItem *item) Compact sequence player needs its own version of this routine since the ALCSeq's qnpt field is at a different offset. */ -/* DONE */ -static void __n_setUsptFromTempo(N_ALCSPlayer *seqp, ALCSeq *target, f32 tempo) +static void __setUsptFromTempo (ALCSPlayer *seqp, f32 tempo) { - if (target) - seqp->uspt = (s32)((f32)tempo * target->qnpt); + if (seqp->target) + seqp->uspt = (s32)((f32)tempo * seqp->target->qnpt); else seqp->uspt = 488; /* This is the initial value set by alSeqpNew. */ }