syn_driver.c File Reference

Go to the source code of this file.

Macros
#define	AU_EQPOW_MID_IDX   64
#define	AU_EQPOW_MAX_IDX   127

Functions
void	au_driver_init (AuSynDriver *driver, ALConfig *config)
void	au_driver_release (void)
Acmd *	alAudioFrame (Acmd *cmdList, s32 *cmdLen, s16 *outBuf, s32 outLen)
void	au_use_global_volume (void)
void	au_set_global_volume (s16 volume)
s16	au_get_global_volume (void)
void	au_set_stereo_enabled (b8 enabled)
void	au_bus_set_volume (u8 busID, u16 value)
u16	au_bus_get_volume (u8 busID)
void	au_bus_set_effect (u8 busID, u8 effectType)
void	au_bus_set_fx_params (u8 busID, s16 delayIndex, s16 paramID, s32 value)
void	au_pvoice_set_bus (u8 voiceIdx, s8 busID)
void	au_syn_stop_voice (u8 voiceIdx)
void	au_syn_start_voice (u8 voiceIdx)
void	au_syn_start_voice_params (u8 voiceIdx, u8 busID, Instrument *instrument, f32 pitchRatio, s16 vol, u8 pan, u8 fxMix, s32 delta)
void	au_syn_set_wavetable (u8 voiceIdx, Instrument *instrument)
void	au_syn_set_pitch (u8 voiceIdx, f32 pitch)
void	au_syn_set_mixer_params (u8 voiceIdx, s16 volume, s32 delta, u8 pan, u8 fxMix)
void	au_syn_set_pan_fxmix (u8 voiceIdx, u8 pan, u8 fxMix)
void	au_syn_set_volume_delta (u8 voiceIdx, s16 vol, s32 delta)
void	au_syn_set_pan (u8 voiceIdx, u8 pan)
void	au_syn_set_fxmix (u8 voiceIdx, u8 fxMix)
s32	au_syn_get_playing (u8 voiceIdx)
s32	au_syn_get_bus (u8 voiceIdx)
f32	au_syn_get_pitch (u8 voiceIdx)
u8	au_syn_get_pan (u8 voiceIdx)
s16	au_syn_get_dryamt (u8 voiceIdx)
s16	au_syn_get_wetamt (u8 voiceIdx)
s32	au_syn_get_volume_left (u8 voiceIdx)
s32	au_syn_get_volume_right (u8 voiceIdx)
void	au_set_delay_time (s32 numFrames)
void	au_delay_left_channel (u8 busID)
void	au_delay_right_channel (u8 busID)
void	au_disable_channel_delay (void)
void	au_init_delay_channel (s16 channel)
void	alHeapInit (ALHeap *hp, u8 *base, s32 len)
void *	alHeapAlloc (ALHeap *heap, s32 count, s32 size)
void	alCopy (void *src, void *dst, s32 size)

Variables
BSS s16 *	AuDelayBufferMain
BSS s16 *	AuDelayBufferAux
BSS s32	AuDelayCounter
BSS u8	AuDelayedBusID
BSS s16	AuDelayedChannel
BSS s32	AuDelayCount
AuSynDriver *	gActiveSynDriverPtr = NULL
AuSynDriver *	gSynDriverPtr = NULL
u8	AuUseGlobalVolume = FALSE
u16	AuGlobalVolume = AU_MAX_VOLUME_16
u8	AuSynStereoDirty = FALSE
s16	AuEqPower [128]

Macro Definition Documentation

AU_EQPOW_MID_IDX

#define AU_EQPOW_MID_IDX   64

Definition at line 22 of file syn_driver.c.

Referenced by au_syn_get_volume_left(), au_syn_get_volume_right(), au_syn_set_fxmix(), au_syn_set_mixer_params(), au_syn_set_pan(), au_syn_set_pan_fxmix(), au_syn_set_volume_delta(), and au_syn_start_voice_params().

AU_EQPOW_MAX_IDX

#define AU_EQPOW_MAX_IDX   127

Definition at line 23 of file syn_driver.c.

Referenced by au_syn_get_volume_right(), au_syn_set_fxmix(), au_syn_set_mixer_params(), au_syn_set_pan(), au_syn_set_pan_fxmix(), au_syn_set_volume_delta(), and au_syn_start_voice_params().

Function Documentation

au_driver_init()

void au_driver_init	(	AuSynDriver *	driver,
		ALConfig *	config )

Definition at line 25 of file syn_driver.c.

                                                           {
    ALHeap* heap = config->heap;
    s32 i;
 
    if (gActiveSynDriverPtr != NULL) {
        return;
    }
 
    driver->num_pvoice = config->num_pvoice;
    driver->num_bus = config->num_bus;
    driver->curSamples = 0;
    driver->unused_04 = 0;
    driver->outputRate = config->outputRate;
    driver->dmaNew = config->dmaNew;
 
    gActiveSynDriverPtr = driver;
    gSynDriverPtr = driver;
    AuUseGlobalVolume = FALSE;
    AuGlobalVolume = AU_MAX_VOLUME_16;
    AuSynStereoDirty = TRUE;
 
    gSynDriverPtr->pvoices = alHeapAlloc(heap, config->num_pvoice, sizeof(*gSynDriverPtr->pvoices));
 
    // this is inlined alN_PVoiceNew
    for (i = 0; i < config->num_pvoice; i++) {
        AuPVoice* voice = &gSynDriverPtr->pvoices[i];
        voice->decoder.state = alHeapAlloc(heap, 1, sizeof(*voice->decoder.state));
        voice->decoder.lstate = alHeapAlloc(heap, 1, sizeof(*voice->decoder.lstate));
        voice->decoder.dmaFunc = gSynDriverPtr->dmaNew(&voice->decoder.dmaState);
        voice->decoder.lastsam = 0;
        voice->decoder.first = 1;
        voice->decoder.memin = (s32)NULL;
        voice->resampler.state = alHeapAlloc(heap, 1, sizeof(*voice->resampler.state));
        voice->resampler.delta = 0;
        voice->resampler.first = TRUE;
        voice->resampler.ratio = 1.0f;
        voice->envMixer.state = alHeapAlloc(heap, 1, sizeof(*voice->envMixer.state));
        voice->envMixer.dirty = TRUE;
        voice->envMixer.motion = AL_STOPPED;
        voice->envMixer.volume = 1;
        voice->envMixer.ltgt = 1;
        voice->envMixer.rtgt = 1;
        voice->envMixer.cvolL = 1;
        voice->envMixer.cvolR = 1;
        voice->envMixer.dryamt = 0;
        voice->envMixer.wetamt = 0;
        voice->envMixer.lratm = 1;
        voice->envMixer.lratl = 0;
        voice->envMixer.rratm = 1;
        voice->envMixer.rratl = 0;
        voice->envMixer.delta = 0;
        voice->envMixer.segEnd = 0;
        voice->envMixer.pan = 64;
        voice->unused_74 = 0;
        voice->next = NULL;
        voice->busID = FX_BUS_BGMA_MAIN;
        voice->index = i;
    }
 
    gSynDriverPtr->fxBus = alHeapAlloc(heap, config->num_bus, sizeof(*gSynDriverPtr->fxBus));
 
    for (i = 0; i < config->num_bus; i++) {
        AuFxBus* fxBus = &gSynDriverPtr->fxBus[i];
        fxBus->head = NULL;
        fxBus->tail = NULL;
        fxBus->gain = 0x7FFF;
        fxBus->curEffectType = AU_FX_NONE;
        fxBus->fxL = alHeapAlloc(heap, 1, sizeof(*fxBus->fxL));
        fxBus->fxR = alHeapAlloc(heap, 1, sizeof(*fxBus->fxR));
        au_fx_create(fxBus->fxL, fxBus->curEffectType, heap);
        au_fx_create(fxBus->fxR, fxBus->curEffectType, heap);
    }
 
    gSynDriverPtr->dryAccumBuffer = alHeapAlloc(heap, 2 * AUDIO_SAMPLES, 2);
    gSynDriverPtr->wetAccumBuffer = alHeapAlloc(heap, 2 * AUDIO_SAMPLES, 2);
    AuDelayedBusID = 0;
    AuDelayedChannel = AU_DELAY_CHANNEL_NONE;
    AuDelayCount = 4;
 
    AuDelayBufferMain = alHeapAlloc(heap, 4 * AUDIO_SAMPLES, 2);
    AuDelayBufferAux = alHeapAlloc(heap, 4 * AUDIO_SAMPLES, 2);
    for (i = 0; i < 4 * AUDIO_SAMPLES; i++) {
        AuDelayBufferAux[i] = AuDelayBufferMain[i] = 0;
    }
 
    gSynDriverPtr->heap = heap;
}

Referenced by create_audio_system().

au_driver_release()

void au_driver_release

(

void

)

Definition at line 113 of file syn_driver.c.

                             {
    if (gActiveSynDriverPtr != NULL) {
        gActiveSynDriverPtr = NULL;
    }
}

alAudioFrame()

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

Definition at line 119 of file syn_driver.c.

                                                                        {
    Acmd* cmdListPos = cmdList;
    s16* bufPos = outBuf;
    AuPVoice* pvoice;
    AuFxBus* fxBus;
    s16 mainOut;
    s16 auxOut;
    s32 busID;
    b32 firstBus;
 
    // sanity check: ensure audio system is initialized
    if (gActiveSynDriverPtr == NULL) {
        *cmdLen = 0;
        return cmdListPos;
    }
 
    au_update_clients_for_video_frame();
 
    // reapply panning if dirty
    if (AuSynStereoDirty) {
        for (busID = 0; busID < gSynDriverPtr->num_pvoice; busID++) {
            pvoice = &gSynDriverPtr->pvoices[busID];
            if (pvoice->envMixer.motion == AL_PLAYING) {
                au_syn_set_pan(busID, pvoice->envMixer.pan);
            }
        }
        AuSynStereoDirty = FALSE;
    }
 
    // process blocks of AUDIO_SAMPLES until outLen is consumed
    while (outLen > 0) {
        au_update_clients_for_audio_frame();
 
        // organize all voices by which FX bus they send to
        for (busID = 0; busID < gSynDriverPtr->num_pvoice; busID++) {
            pvoice = &gSynDriverPtr->pvoices[busID];
 
            if ((pvoice->busID != 0xFF) && (pvoice->busID < gSynDriverPtr->num_bus)) {
                fxBus = &gSynDriverPtr->fxBus[pvoice->busID];
                if (fxBus->tail != NULL) {
                    fxBus->tail->next = pvoice;
                } else {
                    fxBus->head = pvoice;
                }
                fxBus->tail = pvoice;
            }
        }
 
        // render each effects bus
        firstBus = TRUE;
        for (busID = 0; busID < gSynDriverPtr->num_bus; busID++) {
            fxBus = &gSynDriverPtr->fxBus[busID];
            if (fxBus->head != NULL) {
                // clear all main and aux outputs (each is 2 * AUDIO_SAMPLES long, starting at N_AL_MAIN_L_OUT)
                aClearBuffer(cmdListPos++, N_AL_MAIN_L_OUT, 8 * AUDIO_SAMPLES);
 
                // render all voices for this bus
                // these will implicitly accumulate dry to N_AL_MAIN_*_OUT and wet to N_AL_AUX_*_OUT
                if (fxBus->head != NULL) {
                    AuPVoice* next;
                    do {
                        cmdListPos = au_pull_voice(fxBus->head, cmdListPos);
                        next = fxBus->head->next;
                        fxBus->head->next = NULL;
                        fxBus->head = next;
                    } while (next != NULL);
                    fxBus->tail = NULL;
                }
 
                // process fx for this bus
                if (fxBus->curEffectType != AU_FX_NONE) {
                    cmdListPos = au_pull_fx(fxBus->fxL, cmdListPos, N_AL_AUX_L_OUT, N_AL_TEMP_0);
                    cmdListPos = au_pull_fx(fxBus->fxR, cmdListPos, N_AL_AUX_R_OUT, N_AL_TEMP_0);
                }
 
                // apply channel delay
                if (busID == AuDelayedBusID) {
                    mainOut = -1;
                    switch (AuDelayedChannel) {
                        case AU_DELAY_CHANNEL_LEFT:
                            mainOut = N_AL_MAIN_L_OUT;
                            auxOut = N_AL_AUX_L_OUT;
                            break;
                        case AU_DELAY_CHANNEL_RIGHT:
                            mainOut = N_AL_MAIN_R_OUT;
                            auxOut = N_AL_AUX_R_OUT;
                            break;
                    }
                    if (mainOut != -1) {
                        n_aSaveBuffer(cmdListPos++, 2 * AUDIO_SAMPLES, mainOut, osVirtualToPhysical(AuDelayBufferMain + (AuDelayCounter % AuDelayCount) * AUDIO_SAMPLES));
                        n_aLoadBuffer(cmdListPos++, 2 * AUDIO_SAMPLES, mainOut, osVirtualToPhysical(AuDelayBufferMain + ((AuDelayCounter + 1) % AuDelayCount) * AUDIO_SAMPLES));
                        n_aSaveBuffer(cmdListPos++, 2 * AUDIO_SAMPLES, auxOut, osVirtualToPhysical(AuDelayBufferAux + (AuDelayCounter % AuDelayCount) * AUDIO_SAMPLES));
                        n_aLoadBuffer(cmdListPos++, 2 * AUDIO_SAMPLES, auxOut, osVirtualToPhysical(AuDelayBufferAux + ((AuDelayCounter + 1) % AuDelayCount) * AUDIO_SAMPLES));
                    }
                }
 
                // wet mix down for this bus
                if (firstBus) {
                    // clear accumulation buffer if first bus with output
                    aClearBuffer(cmdListPos++, N_AL_TEMP_0, 4 * AUDIO_SAMPLES);
                } else {
                    // load accumulation buffer from DRAM
                    n_aLoadBuffer(cmdListPos++, 4 * AUDIO_SAMPLES, N_AL_TEMP_0, osVirtualToPhysical(gSynDriverPtr->wetAccumBuffer));
                }
                aMix(cmdListPos++, 0, fxBus->gain, N_AL_AUX_L_OUT, N_AL_TEMP_0);
                aMix(cmdListPos++, 0, fxBus->gain, N_AL_AUX_R_OUT, N_AL_TEMP_1);
                // save accumulation buffer to DRAM
                n_aSaveBuffer(cmdListPos++, 4 * AUDIO_SAMPLES, N_AL_TEMP_0, osVirtualToPhysical(gSynDriverPtr->wetAccumBuffer));
 
                // dry mix down for this bus
                if (firstBus) {
                    // clear accumulation buffer if first bus with output
                    aClearBuffer(cmdListPos++, N_AL_TEMP_0, 4 * AUDIO_SAMPLES);
                    firstBus = FALSE;
                } else {
                    // load accumulation buffer from DRAM
                    n_aLoadBuffer(cmdListPos++, 4 * AUDIO_SAMPLES, N_AL_TEMP_0, osVirtualToPhysical(gSynDriverPtr->dryAccumBuffer));
                }
                aMix(cmdListPos++, 0, fxBus->gain, N_AL_MAIN_L_OUT, N_AL_TEMP_0);
                aMix(cmdListPos++, 0, fxBus->gain, N_AL_MAIN_R_OUT, N_AL_TEMP_1);
                // save accumulation buffer to DRAM
                n_aSaveBuffer(cmdListPos++, 4 * AUDIO_SAMPLES, N_AL_TEMP_0, osVirtualToPhysical(gSynDriverPtr->dryAccumBuffer));
            }
        }
 
        // final output mix stage
        aDMEMMove(cmdListPos++, 0, N_AL_MAIN_L_OUT, 4 * AUDIO_SAMPLES);
        n_aLoadBuffer(cmdListPos++, 4 * AUDIO_SAMPLES, N_AL_AUX_L_OUT, osVirtualToPhysical(gSynDriverPtr->wetAccumBuffer));
        aMix(cmdListPos++, 0, 0x7FFF, N_AL_AUX_L_OUT, N_AL_MAIN_L_OUT);
        aMix(cmdListPos++, 0, 0x7FFF, N_AL_AUX_R_OUT, N_AL_MAIN_R_OUT);
 
        // global volume control (used to fade out during console reset)
        if (AuUseGlobalVolume) {
            u16 vol;
            aDMEMMove(cmdListPos++, N_AL_MAIN_L_OUT, 0, 4 * AUDIO_SAMPLES);
            aClearBuffer(cmdListPos++, N_AL_MAIN_L_OUT, 4 * AUDIO_SAMPLES);
            vol = AuGlobalVolume;
            aMix(cmdListPos++, 0, vol, 0, N_AL_MAIN_L_OUT);
            aMix(cmdListPos++, 0, vol, 2 * AUDIO_SAMPLES, N_AL_MAIN_R_OUT);
        }
 
        outLen -= AUDIO_SAMPLES;
        n_aInterleave(cmdListPos++);
        n_aSaveBuffer(cmdListPos++, 4 * AUDIO_SAMPLES, 0, bufPos);
        bufPos += 2 * AUDIO_SAMPLES;
        AuDelayCounter++;
        gSynDriverPtr->curSamples += AUDIO_SAMPLES;
    }
    *cmdLen = (cmdListPos - cmdList);
 
    return cmdListPos;
}

Referenced by nuAuMgr().

au_use_global_volume()

void au_use_global_volume

(

void

)

Definition at line 272 of file syn_driver.c.

                                {
    AuUseGlobalVolume = TRUE;
}

Referenced by nuAuPreNMIProc().

au_set_global_volume()

void au_set_global_volume

(

s16

volume

)

Definition at line 276 of file syn_driver.c.

                                      {
    AuGlobalVolume = volume;
}

Referenced by nuAuPreNMIProc().

au_get_global_volume()

s16 au_get_global_volume

(

void

)

Definition at line 280 of file syn_driver.c.

                               {
    return AuGlobalVolume;
}

Referenced by nuAuPreNMIProc().

au_set_stereo_enabled()

void au_set_stereo_enabled

(

b8

enabled

)

Definition at line 284 of file syn_driver.c.

                                       {
    AuSynUseStereo = enabled;
    AuSynStereoDirty = TRUE;
}

Referenced by snd_set_mono(), and snd_set_stereo().

au_bus_set_volume()

void au_bus_set_volume	(	u8	busID,
		u16	value )

Definition at line 289 of file syn_driver.c.

                                            {
    AuFxBus* fxBus = &gSynDriverPtr->fxBus[busID];
 
    fxBus->gain = value & 0x7FFF;
}

Referenced by au_fade_set_volume().

au_bus_get_volume()

u16 au_bus_get_volume

(

u8

busID

)

Definition at line 295 of file syn_driver.c.

                                {
    AuFxBus* fxBus = &gSynDriverPtr->fxBus[busID];
 
    return fxBus->gain;
}

au_bus_set_effect()

void au_bus_set_effect	(	u8	busID,
		u8	effectType )

Definition at line 301 of file syn_driver.c.

                                                {
    AuFxBus* fxBus = &gSynDriverPtr->fxBus[busID];
 
    fxBus->curEffectType = effectType;
    au_fx_load_preset(fxBus->fxL, effectType);
    au_fx_load_preset(fxBus->fxR, effectType);
}

Referenced by au_syn_begin_audio_frame().

au_bus_set_fx_params()

void au_bus_set_fx_params	(	u8	busID,
		s16	delayIndex,
		s16	paramID,
		s32	value )

Definition at line 309 of file syn_driver.c.

                                                                            {
    AuFxBus* fxBus = &gSynDriverPtr->fxBus[busID];
 
    au_fx_param_hdl(fxBus->fxL, delayIndex, paramID, value);
    au_fx_param_hdl(fxBus->fxR, delayIndex, paramID, value);
}

au_pvoice_set_bus()

void au_pvoice_set_bus	(	u8	voiceIdx,
		s8	busID )

Definition at line 316 of file syn_driver.c.

                                              {
    AuPVoice* pvoice = &gSynDriverPtr->pvoices[voiceIdx];
 
    pvoice->busID = busID;
}

Referenced by au_engine_init().

au_syn_stop_voice()

void au_syn_stop_voice

(

u8

voiceIdx

)

Definition at line 323 of file syn_driver.c.

                                    {
    AuPVoice* pvoice = &gSynDriverPtr->pvoices[voiceIdx];
    AuLoadFilter* decoder = &pvoice->decoder;
 
    pvoice->envMixer.motion = AL_STOPPED;
    pvoice->envMixer.dirty = TRUE;
    pvoice->envMixer.volume = 1;
    pvoice->resampler.delta = 0;
    pvoice->resampler.first = 1;
    decoder->lastsam = 0;
    decoder->first = TRUE;
    decoder->sample = 0;
    if (decoder->instrument != NULL) {
        decoder->memin = (s32)decoder->instrument->wavData;
        if (decoder->instrument->type == AL_ADPCM_WAVE) {
            if (decoder->instrument->loopEnd != 0){
                decoder->loop.count = decoder->instrument->loopCount;
            }
        } else if (decoder->instrument->type == AL_RAW16_WAVE) {
            if (decoder->instrument->loopEnd != 0){
                decoder->loop.count = decoder->instrument->loopCount;
            }
        }
    }
}

Referenced by au_flush_finished_voices(), and au_syn_begin_audio_frame().

au_syn_start_voice()

void au_syn_start_voice

(

u8

voiceIdx

)

Definition at line 350 of file syn_driver.c.

                                     {
    AuPVoice* pvoice = (AuPVoice*)&gSynDriverPtr->pvoices[voiceIdx];
 
    pvoice->envMixer.motion = AL_PLAYING;
}

au_syn_start_voice_params()

void au_syn_start_voice_params	(	u8	voiceIdx,
		u8	busID,
		Instrument *	instrument,
		f32	pitchRatio,
		s16	vol,
		u8	pan,
		u8	fxMix,
		s32	delta )

Definition at line 357 of file syn_driver.c.

                                                                                                                                    {
    AuPVoice* pvoice = &gSynDriverPtr->pvoices[voiceIdx];
    AuLoadFilter* decoder = &pvoice->decoder;
    AuEnvMixer* envMixer = &pvoice->envMixer;
    AuResampler* resampler = &pvoice->resampler;
 
    pvoice->busID = busID;
    decoder->instrument = instrument;
 
    pvoice->decoder.memin = (s32)decoder->instrument->wavData;
    pvoice->decoder.sample = 0;
 
    switch (decoder->instrument->type) {
        case AL_ADPCM_WAVE:
            decoder->instrument->wavDataLength = (decoder->instrument->wavDataLength / ADPCMFBYTES) * ADPCMFBYTES;
            pvoice->decoder.bookSize = decoder->instrument->codebookSize;
            if (decoder->instrument->loopEnd != 0) {
                decoder->loop.start = decoder->instrument->loopStart;
                decoder->loop.end = decoder->instrument->loopEnd;
                decoder->loop.count = decoder->instrument->loopCount;
                alCopy(decoder->instrument->loopState, decoder->lstate, sizeof(ADPCM_STATE));
            } else {
                decoder->loop.count = 0;
                decoder->loop.end = 0;
                decoder->loop.start = 0;
            }
            break;
        case AL_RAW16_WAVE:
            if (decoder->instrument->loopEnd != 0) {
                decoder->loop.start = decoder->instrument->loopStart;
                decoder->loop.end = decoder->instrument->loopEnd;
                decoder->loop.count = decoder->instrument->loopCount;
            } else {
                decoder->loop.count = 0;
                decoder->loop.end = 0;
                decoder->loop.start = 0;
            }
            break;
    }
 
    envMixer->motion = AL_PLAYING;
    envMixer->dirty = TRUE;
    envMixer->delta = 0;
    envMixer->segEnd = delta;
    envMixer->pan = pan;
    envMixer->volume = SQ(vol) >> 0xF;
    envMixer->dryamt = AuEqPower[fxMix];
    envMixer->wetamt = AuEqPower[AU_EQPOW_MAX_IDX - fxMix];
    if (envMixer->segEnd != 0) {
        envMixer->cvolL = 1;
        envMixer->cvolR = 1;
    } else {
        if (!AuSynUseStereo) {
            envMixer->cvolL = (envMixer->volume * AuEqPower[AU_EQPOW_MID_IDX]) >> 0xF;
            envMixer->cvolR = (envMixer->volume * AuEqPower[AU_EQPOW_MID_IDX]) >> 0xF;
        } else {
            envMixer->cvolL = (envMixer->volume * AuEqPower[envMixer->pan]) >> 0xF;
            envMixer->cvolR = (envMixer->volume * AuEqPower[AU_EQPOW_MAX_IDX - envMixer->pan]) >> 0xF;
        }
    }
    resampler->ratio = pitchRatio;
}

Referenced by au_syn_begin_audio_frame().

au_syn_set_wavetable()

void au_syn_set_wavetable	(	u8	voiceIdx,
		Instrument *	instrument )

Definition at line 420 of file syn_driver.c.

                                                               {
    AuPVoice* pvoice = &gSynDriverPtr->pvoices[voiceIdx];
    AuLoadFilter* decoder = &pvoice->decoder;
 
    pvoice->decoder.instrument = instrument;
    pvoice->decoder.memin = (s32)decoder->instrument->wavData;
    pvoice->decoder.sample = 0;
 
    switch (decoder->instrument->type) {
        case AL_ADPCM_WAVE:
            decoder->instrument->wavDataLength = (decoder->instrument->wavDataLength / ADPCMFBYTES) * ADPCMFBYTES;
            pvoice->decoder.bookSize = decoder->instrument->codebookSize;
            if (decoder->instrument->loopEnd != 0) {
                pvoice->decoder.loop.start = decoder->instrument->loopStart;
                pvoice->decoder.loop.end = decoder->instrument->loopEnd;
                pvoice->decoder.loop.count = decoder->instrument->loopCount;
                alCopy(decoder->instrument->loopState, pvoice->decoder.lstate, sizeof(ADPCM_STATE));
            } else {
                pvoice->decoder.loop.count = 0;
                pvoice->decoder.loop.end = 0;
                pvoice->decoder.loop.start = 0;
            }
            break;
        case AL_RAW16_WAVE:
            if (decoder->instrument->loopEnd != 0) {
                pvoice->decoder.loop.start = decoder->instrument->loopStart;
                pvoice->decoder.loop.end = decoder->instrument->loopEnd;
                pvoice->decoder.loop.count = decoder->instrument->loopCount;
            } else {
                pvoice->decoder.loop.count = 0;
                pvoice->decoder.loop.end = 0;
                pvoice->decoder.loop.start = 0;
            }
            break;
    }
}

Referenced by au_engine_init().

au_syn_set_pitch()

void au_syn_set_pitch	(	u8	voiceIdx,
		f32	pitch )

Definition at line 458 of file syn_driver.c.

                                              {
    AuPVoice* pvoice = &gSynDriverPtr->pvoices[voiceIdx];
 
    pvoice->resampler.ratio = pitch;
}

Referenced by au_syn_begin_audio_frame().

au_syn_set_mixer_params()

void au_syn_set_mixer_params	(	u8	voiceIdx,
		s16	volume,
		s32	delta,
		u8	pan,
		u8	fxMix )

Definition at line 464 of file syn_driver.c.

                                                                                   {
    AuPVoice* pvoice = &gSynDriverPtr->pvoices[voiceIdx];
    AuEnvMixer* envMixer = &pvoice->envMixer;
 
    if (envMixer->delta >= envMixer->segEnd) {
        envMixer->delta = envMixer->segEnd;
        if (!AuSynUseStereo) {
            envMixer->cvolL = (envMixer->volume * AuEqPower[AU_EQPOW_MID_IDX]) >> 0xF;
            envMixer->cvolR = (envMixer->volume * AuEqPower[AU_EQPOW_MID_IDX]) >> 0xF;
        } else {
            envMixer->cvolL = (envMixer->volume * AuEqPower[envMixer->pan]) >> 0xF;
            envMixer->cvolR = (envMixer->volume * AuEqPower[AU_EQPOW_MAX_IDX - envMixer->pan]) >> 0xF;
        }
    } else {
        envMixer->cvolL = _getVol(envMixer->cvolL, envMixer->delta, envMixer->lratm, envMixer->lratl);
        envMixer->cvolR = _getVol(envMixer->cvolR, envMixer->delta, envMixer->rratm, envMixer->rratl);
    }
    if (envMixer->cvolL == 0) {
        envMixer->cvolL = 1;
    }
    if (envMixer->cvolR == 0) {
        envMixer->cvolR = 1;
    }
 
    envMixer->delta = 0;
    envMixer->segEnd = delta;
    envMixer->pan = pan;
    envMixer->volume = SQ(volume) >> 0xF;
    envMixer->dryamt = AuEqPower[fxMix];
    envMixer->wetamt = AuEqPower[AU_EQPOW_MAX_IDX - fxMix];
    envMixer->dirty = TRUE;
}

Referenced by au_syn_begin_audio_frame().

au_syn_set_pan_fxmix()

void au_syn_set_pan_fxmix	(	u8	voiceIdx,
		u8	pan,
		u8	fxMix )

Definition at line 497 of file syn_driver.c.

                                                         {
    AuPVoice* pvoice = &gSynDriverPtr->pvoices[voiceIdx];
    AuEnvMixer* envMixer = &pvoice->envMixer;
 
    if (envMixer->delta >= envMixer->segEnd) {
        envMixer->delta = envMixer->segEnd;
        if (!AuSynUseStereo) {
            envMixer->cvolL = (envMixer->volume * AuEqPower[AU_EQPOW_MID_IDX]) >> 0xF;
            envMixer->cvolR = (envMixer->volume * AuEqPower[AU_EQPOW_MID_IDX]) >> 0xF;
        } else {
            envMixer->cvolL = (envMixer->volume * AuEqPower[envMixer->pan]) >> 0xF;
            envMixer->cvolR = (envMixer->volume * AuEqPower[AU_EQPOW_MAX_IDX - envMixer->pan]) >> 0xF;
        }
    } else {
        envMixer->cvolL = _getVol(envMixer->cvolL, envMixer->delta, envMixer->lratm, envMixer->lratl);
        envMixer->cvolR = _getVol(envMixer->cvolR, envMixer->delta, envMixer->rratm, envMixer->rratl);
    }
    if (envMixer->cvolL == 0) {
        envMixer->cvolL = 1;
    }
    if (envMixer->cvolR == 0) {
        envMixer->cvolR = 1;
    }
 
    envMixer->pan = pan;
    envMixer->dryamt = AuEqPower[fxMix];
    envMixer->wetamt = AuEqPower[AU_EQPOW_MAX_IDX - fxMix];
    envMixer->dirty = TRUE;
}

Referenced by au_syn_begin_audio_frame().

au_syn_set_volume_delta()

void au_syn_set_volume_delta	(	u8	voiceIdx,
		s16	vol,
		s32	delta )

Definition at line 527 of file syn_driver.c.

                                                              {
    AuPVoice* pvoice = &gSynDriverPtr->pvoices[voiceIdx];
    AuEnvMixer* envMixer = &pvoice->envMixer;
 
    if (envMixer->delta >= envMixer->segEnd) {
        envMixer->delta = envMixer->segEnd;
        if (!AuSynUseStereo) {
            envMixer->cvolL = (envMixer->volume * AuEqPower[AU_EQPOW_MID_IDX]) >> 0xF;
            envMixer->cvolR = (envMixer->volume * AuEqPower[AU_EQPOW_MID_IDX]) >> 0xF;
        } else {
            envMixer->cvolL = (envMixer->volume * AuEqPower[envMixer->pan]) >> 0xF;
            envMixer->cvolR = (envMixer->volume * AuEqPower[AU_EQPOW_MAX_IDX - envMixer->pan]) >> 0xF;
        }
    } else {
        envMixer->cvolL = _getVol(envMixer->cvolL, envMixer->delta, envMixer->lratm, envMixer->lratl);
        envMixer->cvolR = _getVol(envMixer->cvolR, envMixer->delta, envMixer->rratm, envMixer->rratl);
    }
    if (envMixer->cvolL == 0) {
        envMixer->cvolL = 1;
    }
    if (envMixer->cvolR == 0) {
        envMixer->cvolR = 1;
    }
 
    envMixer->volume = SQ(vol) >> 0xF;
    envMixer->delta = 0;
    envMixer->segEnd = delta;
    envMixer->dirty = TRUE;
}

Referenced by au_reset_nonfree_voice(), and au_reset_voice().

au_syn_set_pan()

void au_syn_set_pan	(	u8	voiceIdx,
		u8	pan )

Definition at line 557 of file syn_driver.c.

                                         {
    AuPVoice* pvoice = &gSynDriverPtr->pvoices[voiceIdx];
    AuEnvMixer* envMixer = &pvoice->envMixer;
 
    if (envMixer->delta >= envMixer->segEnd) {
        envMixer->delta = envMixer->segEnd;
        if (!AuSynUseStereo) {
            envMixer->cvolL = (envMixer->volume * AuEqPower[AU_EQPOW_MID_IDX]) >> 0xF;
            envMixer->cvolR = (envMixer->volume * AuEqPower[AU_EQPOW_MID_IDX]) >> 0xF;
        } else {
            envMixer->cvolL = (envMixer->volume * AuEqPower[envMixer->pan]) >> 0xF;
            envMixer->cvolR = (envMixer->volume * AuEqPower[AU_EQPOW_MAX_IDX - envMixer->pan]) >> 0xF;
        }
    } else {
        envMixer->cvolL = _getVol(envMixer->cvolL, envMixer->delta, envMixer->lratm, envMixer->lratl);
        envMixer->cvolR = _getVol(envMixer->cvolR, envMixer->delta, envMixer->rratm, envMixer->rratl);
    }
    if (envMixer->cvolL == 0) {
        envMixer->cvolL = 1;
    }
    if (envMixer->cvolR == 0) {
        envMixer->cvolR = 1;
    }
 
    envMixer->pan = pan;
    envMixer->dirty = TRUE;
}

Referenced by alAudioFrame().

au_syn_set_fxmix()

void au_syn_set_fxmix	(	u8	voiceIdx,
		u8	fxMix )

Definition at line 585 of file syn_driver.c.

                                             {
    AuPVoice* pvoice = &gSynDriverPtr->pvoices[voiceIdx];
    AuEnvMixer* envMixer = &pvoice->envMixer;
 
    if (envMixer->delta >= envMixer->segEnd) {
        envMixer->delta = envMixer->segEnd;
        if (!AuSynUseStereo) {
            envMixer->cvolL = (envMixer->volume * AuEqPower[AU_EQPOW_MID_IDX]) >> 0xF;
            envMixer->cvolR = (envMixer->volume * AuEqPower[AU_EQPOW_MID_IDX]) >> 0xF;
        } else {
            envMixer->cvolL = (envMixer->volume * AuEqPower[envMixer->pan]) >> 0xF;
            envMixer->cvolR = (envMixer->volume * AuEqPower[AU_EQPOW_MAX_IDX - envMixer->pan]) >> 0xF;
        }
    } else {
        envMixer->cvolL = _getVol(envMixer->cvolL, envMixer->delta, envMixer->lratm, envMixer->lratl);
        envMixer->cvolR = _getVol(envMixer->cvolR, envMixer->delta, envMixer->rratm, envMixer->rratl);
    }
    if (envMixer->cvolL == 0) {
        envMixer->cvolL = 1;
    }
    if (envMixer->cvolR == 0) {
        envMixer->cvolR = 1;
    }
 
    envMixer->dryamt = AuEqPower[fxMix];
    envMixer->wetamt = AuEqPower[AU_EQPOW_MAX_IDX - fxMix];
    envMixer->dirty = TRUE;
}

au_syn_get_playing()

s32 au_syn_get_playing

(

u8

voiceIdx

)

Definition at line 614 of file syn_driver.c.

                                    {
    AuPVoice* pvoice = &gSynDriverPtr->pvoices[voiceIdx];
 
    return pvoice->envMixer.motion;
}

au_syn_get_bus()

s32 au_syn_get_bus

(

u8

voiceIdx

)

Definition at line 620 of file syn_driver.c.

                                {
    AuPVoice* pvoice =  &gSynDriverPtr->pvoices[voiceIdx];
 
    return pvoice->busID;
}

au_syn_get_pitch()

f32 au_syn_get_pitch

(

u8

voiceIdx

)

Definition at line 626 of file syn_driver.c.

                                  {
    AuPVoice* pvoice =  &gSynDriverPtr->pvoices[voiceIdx];
 
    return pvoice->resampler.ratio;
}

au_syn_get_pan()

u8 au_syn_get_pan

(

u8

voiceIdx

)

Definition at line 632 of file syn_driver.c.

                               {
    AuPVoice* pvoice =  &gSynDriverPtr->pvoices[voiceIdx];
 
    return pvoice->envMixer.pan;
}

au_syn_get_dryamt()

s16 au_syn_get_dryamt

(

u8

voiceIdx

)

Definition at line 638 of file syn_driver.c.

                                   {
    AuPVoice* pvoice =  &gSynDriverPtr->pvoices[voiceIdx];
 
    return pvoice->envMixer.dryamt;
}

au_syn_get_wetamt()

s16 au_syn_get_wetamt

(

u8

voiceIdx

)

Definition at line 644 of file syn_driver.c.

                                   {
    AuPVoice* pvoice =  &gSynDriverPtr->pvoices[voiceIdx];
 
    return pvoice->envMixer.wetamt;
}

au_syn_get_volume_left()

s32 au_syn_get_volume_left

(

u8

voiceIdx

)

Definition at line 650 of file syn_driver.c.

                                        {
    AuPVoice* pvoice = &gSynDriverPtr->pvoices[voiceIdx];
    AuEnvMixer* envmixer = &pvoice->envMixer;
    u32 retVal;
 
    if (envmixer->delta >= envmixer->segEnd) {
        if (!AuSynUseStereo) {
            retVal = (envmixer->volume * AuEqPower[AU_EQPOW_MID_IDX] * 2) >> 0x10;
        } else {
            retVal = (envmixer->volume * AuEqPower[envmixer->pan] * 2) >> 0x10;
        }
    } else {
        retVal = _getVol(envmixer->cvolL, envmixer->delta, envmixer->lratm, envmixer->lratl);
    }
    return retVal;
}

au_syn_get_volume_right()

s32 au_syn_get_volume_right

(

u8

voiceIdx

)

Definition at line 667 of file syn_driver.c.

                                         {
    AuPVoice* pvoice = &gSynDriverPtr->pvoices[voiceIdx];
    AuEnvMixer* envmixer = &pvoice->envMixer;
    u32 retVal;
 
    if (envmixer->delta >= envmixer->segEnd) {
        if (!AuSynUseStereo) {
            retVal = (envmixer->volume * AuEqPower[AU_EQPOW_MID_IDX] * 2) >> 0x10;
        } else {
            retVal = (envmixer->volume * AuEqPower[AU_EQPOW_MAX_IDX - envmixer->pan] * 2) >> 0x10;
        }
    } else {
        retVal = _getVol(envmixer->cvolL, envmixer->delta, envmixer->lratm, envmixer->lratl);
    }
    return retVal;
}

au_set_delay_time()

void au_set_delay_time

(

s32

numFrames

)

Definition at line 684 of file syn_driver.c.

                                      {
    if (numFrames < 2) {
        AuDelayCount = 0;
        AuDelayedChannel = AU_DELAY_CHANNEL_NONE;
    }
 
    AuDelayCount = numFrames;
    if (numFrames > 4) {
        AuDelayCount = 4;
    }
}

Referenced by au_syn_begin_audio_frame().

au_delay_left_channel()

void au_delay_left_channel

(

u8

busID

)

Definition at line 696 of file syn_driver.c.

                                     {
    s32* mainBuf = (s32*)AuDelayBufferMain;
    s32* auxBuf = (s32*)AuDelayBufferAux;
    s32 i;
 
    for (i = 0; i < 2 * AUDIO_SAMPLES; i++) {
        *mainBuf++ = 0;
        *auxBuf++ = 0;
    }
 
    AuDelayedBusID = busID;
    AuDelayedChannel = AU_DELAY_CHANNEL_LEFT;
    AuDelayCounter = 0;
}

Referenced by au_syn_begin_audio_frame().

au_delay_right_channel()

void au_delay_right_channel

(

u8

busID

)

Definition at line 711 of file syn_driver.c.

                                      {
    s32* mainBuf = (s32*)AuDelayBufferMain;
    s32* auxBuf = (s32*)AuDelayBufferAux;
    s32 i;
 
    for (i = 0; i < 2 * AUDIO_SAMPLES; i++) {
        *mainBuf++ = 0;
        *auxBuf++ = 0;
    }
 
    AuDelayedBusID = busID;
    AuDelayedChannel = AU_DELAY_CHANNEL_RIGHT;
    AuDelayCounter = 0;
}

Referenced by au_syn_begin_audio_frame().

au_disable_channel_delay()

void au_disable_channel_delay

(

void

)

Definition at line 726 of file syn_driver.c.

                                    {
    AuDelayedBusID = 0;
    AuDelayedChannel = AU_DELAY_CHANNEL_NONE;
    AuDelayCounter = 0;
}

Referenced by au_syn_begin_audio_frame().

au_init_delay_channel()

void au_init_delay_channel

(

s16

channel

)

Definition at line 732 of file syn_driver.c.

                                        {
    s32* mainBuf = (s32*)AuDelayBufferMain;
    s32* auxBuf = (s32*)AuDelayBufferAux;
    s32 i;
 
    for (i = 0; i < 2 * AUDIO_SAMPLES; i++) {
        *mainBuf++ = 0;
        *auxBuf++ = 0;
    }
 
    AuDelayedBusID = 0;
    AuDelayedChannel = channel;
    AuDelayCounter = 0;
}

Referenced by au_engine_init().

alHeapInit()

void alHeapInit	(	ALHeap *	hp,
		u8 *	base,
		s32	len )

Definition at line 747 of file syn_driver.c.

                                               {
    u32 i;
    s32 alignBytes = 0x10 - ((s32)base & 0xF);
 
    if (alignBytes != 0x10) {
        hp->base = base + alignBytes;
    } else {
        hp->base = base;
    }
    hp->len = len;
    hp->count = 0;
    hp->cur = hp->base;
 
    for (i = 0; i < (u32)(hp->len) >> 2; i++) {
        ((u32*)hp->base)[i] = 0;
    }
}

Referenced by create_audio_system().

alHeapAlloc()

void * alHeapAlloc	(	ALHeap *	heap,
		s32	count,
		s32	size )

Definition at line 765 of file syn_driver.c.

                                                     {
    void* ret = NULL;
    u8* newCur = &heap->cur[ALIGN16(count * size)];
 
    if (&heap->base[heap->len] >= newCur) {
        ret = heap->cur;
        heap->cur = newCur;
    }
 
    return ret;
}

Referenced by au_driver_init(), au_engine_init(), au_filter_create(), au_fx_create(), au_load_BK_to_bank(), au_load_INIT(), au_load_static_BK_to_bank(), and create_audio_system().

alCopy()

void alCopy	(	void *	src,
		void *	dst,
		s32	size )

Definition at line 777 of file syn_driver.c.

                                            {
    s32 i;
    u8* srcIt = src;
    u8* dstIt = dst;
 
    for (i = 0; i < size; i++) {
        *dstIt++ = *srcIt++;
    }
}

Referenced by au_syn_set_wavetable(), and au_syn_start_voice_params().

Variable Documentation

AuDelayBufferMain

BSS s16* AuDelayBufferMain

Definition at line 7 of file syn_driver.c.

Referenced by alAudioFrame(), au_delay_left_channel(), au_delay_right_channel(), au_driver_init(), and au_init_delay_channel().

AuDelayBufferAux

BSS s16* AuDelayBufferAux

Definition at line 8 of file syn_driver.c.

Referenced by alAudioFrame(), au_delay_left_channel(), au_delay_right_channel(), au_driver_init(), and au_init_delay_channel().

AuDelayCounter

BSS s32 AuDelayCounter

Definition at line 9 of file syn_driver.c.

Referenced by alAudioFrame(), au_delay_left_channel(), au_delay_right_channel(), au_disable_channel_delay(), and au_init_delay_channel().

AuDelayedBusID

BSS u8 AuDelayedBusID

Definition at line 10 of file syn_driver.c.

Referenced by alAudioFrame(), au_delay_left_channel(), au_delay_right_channel(), au_disable_channel_delay(), au_driver_init(), and au_init_delay_channel().

AuDelayedChannel

BSS s16 AuDelayedChannel

Definition at line 11 of file syn_driver.c.

Referenced by alAudioFrame(), au_delay_left_channel(), au_delay_right_channel(), au_disable_channel_delay(), au_driver_init(), au_init_delay_channel(), and au_set_delay_time().

AuDelayCount

BSS s32 AuDelayCount

Definition at line 12 of file syn_driver.c.

Referenced by alAudioFrame(), au_driver_init(), and au_set_delay_time().

gActiveSynDriverPtr

AuSynDriver* gActiveSynDriverPtr = NULL

Definition at line 14 of file syn_driver.c.

Referenced by alAudioFrame(), au_driver_init(), au_driver_release(), au_fx_load_preset(), and au_fx_param_hdl().

gSynDriverPtr

AuSynDriver* gSynDriverPtr = NULL

Definition at line 15 of file syn_driver.c.

Referenced by alAudioFrame(), au_bus_get_volume(), au_bus_set_effect(), au_bus_set_fx_params(), au_bus_set_volume(), au_driver_init(), au_engine_init(), au_load_BK_to_bank(), au_load_static_BK_to_bank(), au_pvoice_set_bus(), au_syn_get_bus(), au_syn_get_dryamt(), au_syn_get_pan(), au_syn_get_pitch(), au_syn_get_playing(), au_syn_get_volume_left(), au_syn_get_volume_right(), au_syn_get_wetamt(), au_syn_set_fxmix(), au_syn_set_mixer_params(), au_syn_set_pan(), au_syn_set_pan_fxmix(), au_syn_set_pitch(), au_syn_set_volume_delta(), au_syn_set_wavetable(), au_syn_start_voice(), au_syn_start_voice_params(), and au_syn_stop_voice().

AuUseGlobalVolume

u8 AuUseGlobalVolume = FALSE

Definition at line 16 of file syn_driver.c.

Referenced by alAudioFrame(), au_driver_init(), and au_use_global_volume().

AuGlobalVolume

u16 AuGlobalVolume = AU_MAX_VOLUME_16

Definition at line 17 of file syn_driver.c.

Referenced by alAudioFrame(), au_driver_init(), au_get_global_volume(), and au_set_global_volume().

AuSynStereoDirty

u8 AuSynStereoDirty = FALSE

Definition at line 18 of file syn_driver.c.

Referenced by alAudioFrame(), au_driver_init(), and au_set_stereo_enabled().

AuEqPower

s16 AuEqPower[128]

extern

Definition at line 10 of file pull_voice.c.

                                  {
    32767, 32764, 32757, 32744, 32727, 32704, 32677, 32644,
    32607, 32564, 32517, 32464, 32407, 32344, 32277, 32205,
    32127, 32045, 31958, 31866, 31770, 31668, 31561, 31450,
    31334, 31213, 31087, 30957, 30822, 30682, 30537, 30388,
    30234, 30075, 29912, 29744, 29572, 29395, 29214, 29028,
    28838, 28643, 28444, 28241, 28033, 27821, 27605, 27385,
    27160, 26931, 26698, 26461, 26220, 25975, 25726, 25473,
    25216, 24956, 24691, 24423, 24151, 23875, 23596, 23313,
    23026, 22736, 22442, 22145, 21845, 21541, 21234, 20924,
    20610, 20294, 19974, 19651, 19325, 18997, 18665, 18331,
    17993, 17653, 17310, 16965, 16617, 16266, 15913, 15558,
    15200, 14840, 14477, 14113, 13746, 13377, 13006, 12633,
    12258, 11881, 11503, 11122, 10740, 10357, 9971,  9584,
    9196,  8806,  8415,  8023,  7630,  7235,  6839,  6442,
    6044,  5646,  5246,  4845,  4444,  4042,  3640,  3237,
    2833,  2429,  2025,  1620,  1216,  810,   405,   0
};

Referenced by au_pull_voice(), au_syn_get_volume_left(), au_syn_get_volume_right(), au_syn_set_fxmix(), au_syn_set_mixer_params(), au_syn_set_pan(), au_syn_set_pan_fxmix(), au_syn_set_volume_delta(), and au_syn_start_voice_params().