core.h File Reference

Go to the source code of this file.

Functions
void	create_audio_system (void)
void	nuAuMgr (void *arg)
s32	nuAuDmaCallBack (s32 addr, s32 len, void *state, u8 useDma)
	DMA callback for audio sample streaming; manages a DMA buffer cache.
void	au_release_voice (u8 index)
void	au_engine_init (s32 outputRate)
void	au_update_clients_for_video_frame (void)
	this is called once per video frame update (50 or 60 times per second)
void	au_update_clients_for_audio_frame (void)
	this is called per audio frame generated by alAudioFrame (every 184 audio samples) there will be multiuple of these per video frame
void	au_syn_begin_audio_frame (AuGlobals *globals)
void	au_reset_nonfree_voice (AuVoice *arg0, u8 arg1)
void	au_reset_voice (AuVoice *voice, u8 voiceIdx)
f32	au_compute_pitch_ratio (s32 tuning)
	Converts a linear pitch value (in cents) into a frequency ratio suitable for adjusting playback speed.
void	au_fade_init (Fade *fade, s32 time, s32 startValue, s32 endValue)
void	au_fade_clear (Fade *fade)
void	au_fade_update (Fade *fade)
void	au_fade_set_volume (u8 arg0, u16 arg1, s32 arg2)
void	au_fade_flush (Fade *fade)
void	au_fade_set_envelope (Fade *fade, s16 value)
void	au_fade_calc_envelope (Fade *fade, u32 arg1, s32 target)
void	au_fade_update_envelope (Fade *fade)
Instrument *	au_get_instrument (AuGlobals *globals, BankSetIndex bank, s32 patch, EnvelopeData *arg3)
	Note that bank is supplied as BankSetIndex and not BankSet, which means it will be used to perform a raw access into AuGlobals::bankSets.
void	au_get_bgm_player_and_file (u32 playerIndex, BGMHeader **outCurrentTrackData, BGMPlayer **outPlayer)
void	au_get_bgm_player (u32 playerIndex, BGMPlayer **outPlayer)
AuResult	au_load_song_files (u32 arg0, BGMHeader *arg1, BGMPlayer *arg2)
AuResult	au_reload_song_files (s32 songID, BGMHeader *arg1)
BGMPlayer *	au_get_snapshot_by_index (s32 index)
AuResult	au_ambient_load (u32 arg0)
BGMPlayer *	au_get_client_by_priority (u8 arg0)
void	au_load_INIT (AuGlobals *arg0, s32 romAddr, ALHeap *heap)
AuResult	au_fetch_SBN_file (u32 fileIdx, AuFileFormat format, SBNFileEntry *arg2)
void	au_load_PER (AuGlobals *globals, s32 romAddr)
void	au_load_PRG (AuGlobals *arg0, s32 romAddr)
InstrumentBank *	au_get_BK_instruments (BankSet bankSet, u32 bankIndex)
BKFileBuffer *	au_load_BK_to_bank (s32 bkFileOffset, BKFileBuffer *bkFile, s32 bankIndex, BankSet bankSet)
	Loads an instrument bank file from ROM, allocates memory if needed, and sets up instrument pointers.
void	au_swizzle_BK_instruments (s32 bkFileOffset, BKFileBuffer *bkFile, InstrumentBank instruments, u32 instrumentCount, u8 arg4)
	Fixes up (swizzles) instrument pointers in a loaded bank, converting file-relative offsets to valid RAM pointers.
BKFileBuffer *	au_load_static_BK_to_bank (s32 *bkFileOffset, void *vaddr, s32 bankIndex, BankSet bankSet)
	UNUSED Loads an instrument bank file from ROM to a given buffer (allocates if needed), and sets up instrument pointers.
s32	au_load_aux_bank (s32 bkFileOffset, s32 bankIndex)
void	au_clear_instrument_group (s32 bankIndex, BankSet bankSet)
	unused. resets all instruments in (bankIndex, bankSet) to default
void	au_set_bus_volume_level (s32 arg0, u32 idx)
s32	au_set_reverb_type (s32 arg0, s32 arg1)
void	au_sync_channel_delay_enabled (u32 arg0)
void	au_read_rom (s32 romAddr, void *buffer, u32 size)
void	au_memset (void *dst, s32 size, u8 value)
void	au_copy_bytes (s8 *src, s8 *dest, s32 size)
void	au_copy_words (void *src, void *dst, s32 size)
void	au_driver_init (AuSynDriver *driver, ALConfig *config)
void	au_driver_release (void)
void	au_use_global_volume (void)
void	au_set_global_volume (s16 arg0)
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 effectID)
void	au_bus_set_fx_params (u8 busID, s16 arg1, s16 arg2, s32 arg3)
void	au_pvoice_set_bus (u8 voiceIdx, s8 busID)
void	au_syn_stop_voice (u8 voiceIdx)
void	au_syn_start_voice (u8 index)
void	au_syn_start_voice_params (u8 index, u8 reverbType, Instrument *table, f32 pitch, s16 vol, u8 pan, u8 fxMix, s32 delta)
void	au_syn_set_wavetable (u8 voiceIdx, Instrument *table)
void	au_syn_set_pitch (u8 voiceIdx, f32 pitchRatio)
void	au_syn_set_mixer_params (u8 voiceIdx, s16 volume, s32 arg2, u8 arg3, u8 arg4)
void	au_syn_set_pan_fxmix (u8 voiceIdx, u8 arg1, u8 arg2)
void	au_syn_set_volume_delta (u8 voiceIdx, s16 arg1, s32 arg2)
void	au_syn_set_pan (u8 voiceIdx, u8 pan)
void	au_syn_set_fxmix (u8 voiceIdx, u8 dryAmt)
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 arg0)
void	au_delay_left_channel (u8 arg0)
void	au_delay_right_channel (u8 arg0)
void	au_disable_channel_delay (void)
void	au_init_delay_channel (s16 arg0)
void *	alHeapAlloc (ALHeap *heap, s32 count, s32 size)
void	au_flush_finished_voices (AuGlobals *globals)
	(UNUSED) Immediately flush all voices which have finished playing.
void	au_init_voices (AuGlobals *globals)
	Initializes all voices in the audio system.
void	au_update_voices (AuGlobals *globals)
	Main envelope system update, called once per frame.
void	au_voice_after_volume_change (AuVoice *voice)
	Applies volume update after a client-side volume change.
s32	au_voice_get_delta (s32 usecs)
	Converts envelope step duration from microseconds to num samples delta.
void	au_voice_start (AuVoice *voice, EnvelopeData *envData)
	Starts a new voice with the given envelope data.
u8	au_voice_step (AuVoice *voice)
	Parses and executes envelope commands until a time interval is found.
void	au_voice_set_vol_changed (AuVoice *voice)
	(UNUSED) Force recalculation of voice envelope volume during next update.
Acmd *	au_pull_voice (AuPVoice *pvoice, Acmd *cmdBufPos)
void	au_fx_create (AuFX *fx, u8 mode, ALHeap *heap)
void	au_filter_create (AuFilter *filter, ALHeap *heap)
void	au_filter_init (AuFilter *filter, s16 arg1, s16 arg2, s16 fc)
void	au_fx_load_preset (AuFX *fx, u8 effectType)
Acmd *	au_pull_fx (AuFX *fx, Acmd *cmdBusPos, s16, s16)
	Applies a chain of delay-line based effects to audio and mixes into output.
s32	au_fx_param_hdl (AuFX *fx, s16 index, s16 paramID, s32 value)

Function Documentation

create_audio_system()

void create_audio_system

(

void

)

Definition at line 37 of file system.c.

                               {
    u32 i;
    u32 outputRate, frameSize;
    ALConfig config;
 
    nuAuTaskStop = NU_AU_TASK_RUN;
    nuAuPreNMI = 0;
    alHeapInit(&nuAuHeap, AuHeapBase, AUDIO_HEAP_SIZE);
    config.num_pvoice = 24;
    config.num_bus = 4;
    outputRate = osAiSetFrequency(HARDWARE_OUTPUT_RATE);
    frameSize = (nusched.retraceCount * outputRate + (VIDEO_FRAMES_PER_SECOND - 1)) / VIDEO_FRAMES_PER_SECOND;
    config.outputRate = outputRate;
    config.unused_0C = 0;
    config.heap = &nuAuHeap;
    config.dmaNew = nuAuDmaNew;
    AlFrameSize = ((frameSize / AUDIO_SAMPLES) + 1) * AUDIO_SAMPLES;
    AlMinFrameSize = AlFrameSize - AUDIO_MAX_SAMPLES;
 
    for (i = 0; i < ARRAY_COUNT(AlCmdListBuffers); i++) {
        AlCmdListBuffers[i] = alHeapAlloc(config.heap, 1, AUDIO_COMMAND_LIST_BUFFER_SIZE);
    }
 
    for (i = 0; i < ARRAY_COUNT(nuAuTasks); i++) {
        nuAuTasks[i].next = NULL;
        nuAuTasks[i].msg = 0;
        nuAuTasks[i].list.t.type = M_AUDTASK;
#if VERSION_IQUE
        nuAuTasks[i].list.t.ucode_boot = (u64*) rspbootTextStart;
        nuAuTasks[i].list.t.ucode_boot_size = (u32) rspbootTextEnd - (u32) rspbootTextStart;
#else
        nuAuTasks[i].list.t.ucode_boot = (u64*) rspbootUcodeBuffer;
        nuAuTasks[i].list.t.ucode_boot_size = 0x100;
#endif
        nuAuTasks[i].list.t.ucode = n_aspMain_text_bin;
        nuAuTasks[i].list.t.ucode_data = n_aspMain_data_bin;
        nuAuTasks[i].list.t.ucode_data_size = SP_UCODE_DATA_SIZE;
        nuAuTasks[i].list.t.dram_stack = NULL;
        nuAuTasks[i].list.t.dram_stack_size = 0;
        nuAuTasks[i].list.t.output_buff = NULL;
        nuAuTasks[i].list.t.output_buff_size = 0;
        nuAuTasks[i].list.t.yield_data_ptr = NULL;
        nuAuTasks[i].list.t.yield_data_size = 0;
    }
 
    for (i = 0; i < ARRAY_COUNT(D_800A3628); i++) {
        D_800A3628[i] = alHeapAlloc(config.heap, 1, AlFrameSize * 4);
    }
 
    nuAuDmaBufList[0].node.next = nuAuDmaBufList[0].node.prev = NULL;
    for (i = 0; i < ARRAY_COUNT(nuAuDmaBufList) - 1; i++) {
        alLink(&nuAuDmaBufList[i+1].node, &nuAuDmaBufList[i].node);
        nuAuDmaBufList[i].ptr = alHeapAlloc(config.heap, 1, 0x500);
    }
    nuAuDmaBufList[i].ptr = alHeapAlloc(config.heap, 1, 0x500);
 
    osCreateMesgQueue(&nuAuDmaMesgQ, nuAuDmaMesgBuf, 50);
    nuAuPreNMIFunc = nuAuPreNMIProc;
    au_driver_init(&auSynDriver, &config);
    au_engine_init(config.outputRate);
    osCreateThread(&nuAuMgrThread, THREAD_ID_AUDIO, nuAuMgr, NULL, &AuStack[NU_AU_STACK_SIZE / sizeof(u64)], NU_AU_MGR_THREAD_PRI);
    osStartThread(&nuAuMgrThread);
}

Referenced by create_audio_system_obfuscated().

nuAuMgr()

void nuAuMgr

(

void *

arg

)

Definition at line 108 of file system.c.

                        {
    NUScClient auClient;
    OSMesgQueue auMesgQ;
    OSMesg auMsgBuf[NU_AU_MESG_MAX];
    OSMesgQueue auRtnMesgQ;
    OSMesg auRtnMesgBuf;
    NUScMsg* mesg_type;
    s32 cmdList_len;
    Acmd* cmdListAfter_ptr;
    s32 cmdListIndex;
    s32 bufferIndex;
    s32 sampleSize;
    Acmd* cmdListBuf;
    u8* bufferPtr;
    s32 samples;
    s32 cond;
 
    osCreateMesgQueue(&auMesgQ, auMsgBuf, NU_AU_MESG_MAX);
    osCreateMesgQueue(&auRtnMesgQ, &auRtnMesgBuf, 1);
    nuScAddClient(&auClient, &auMesgQ, NU_SC_RETRACE_MSG | NU_SC_PRENMI_MSG);
 
    cmdList_len = 0;
    cmdListIndex = 0;
    bufferIndex = 0;
    samples = 0;
    cmdListBuf = AlCmdListBuffers[0];
    bufferPtr = D_800A3628[0];
    while (TRUE) {
        osRecvMesg(&auMesgQ, (OSMesg*)&mesg_type, OS_MESG_BLOCK);
        switch (*mesg_type) {
            case NU_SC_RETRACE_MSG:
                if (cmdList_len != 0 && nuAuTaskStop == NU_AU_TASK_RUN) {
                    nuAuTasks[cmdListIndex].msgQ = &auRtnMesgQ;
                    nuAuTasks[cmdListIndex].list.t.data_ptr = (u64*)cmdListBuf;
                    nuAuTasks[cmdListIndex].list.t.data_size = (cmdListAfter_ptr - cmdListBuf) * sizeof(Acmd);
                    profiler_rsp_started(PROFILER_RSP_AUDIO);
                    osSendMesg(&nusched.audioRequestMQ, &nuAuTasks[cmdListIndex], OS_MESG_BLOCK);
                    profiler_rsp_completed(PROFILER_RSP_AUDIO);
                    nuAuCleanDMABuffers();
                    osRecvMesg(&auRtnMesgQ, NULL, 1);
                    if (++bufferIndex == 3) {
                        bufferIndex = 0;
                    }
                    if (++cmdListIndex == 3) {
                        cmdListIndex = 0;
                    }
                }
                profiler_audio_started(); // XXX: is this the right place?
                if (osAiGetStatus() & AI_STATUS_FIFO_FULL) {
                    cond = FALSE;
                    profiler_audio_completed();
                    continue;
                }
                sampleSize = osAiGetLength() >> 2;
                if (cmdList_len != 0 && nuAuTaskStop == NU_AU_TASK_RUN) {
                    osAiSetNextBuffer(bufferPtr, samples * 4);
                    cmdListBuf = AlCmdListBuffers[cmdListIndex];
                    bufferPtr = D_800A3628[bufferIndex];
                }
                if (sampleSize < AUDIO_MAX_SAMPLES || cond) {
                    samples = AlFrameSize;
                    cond = FALSE;
                } else {
                    samples = AlMinFrameSize;
                    cond = TRUE;
                }
                cmdListAfter_ptr = alAudioFrame(cmdListBuf, &cmdList_len, (s16*)osVirtualToPhysical(bufferPtr), samples);
                if (nuAuPreNMIFunc != 0 && nuAuPreNMI != 0) {
                    nuAuPreNMIFunc(NU_SC_RETRACE_MSG, nuAuPreNMI);
                    nuAuPreNMI++;
                }
 
                break;
            case NU_SC_PRENMI_MSG:
                if (nuAuPreNMIFunc) {
                    nuAuPreNMIFunc(NU_SC_PRENMI_MSG, nuAuPreNMI);
                }
                nuAuPreNMI++;
                break;
        }
    }
 
    profiler_audio_completed();
}

Referenced by create_audio_system().

nuAuDmaCallBack()

s32 nuAuDmaCallBack	(	s32	addr,
		s32	len,
		void *	state,
		u8	useDma )

DMA callback for audio sample streaming; manages a DMA buffer cache.

Definition at line 194 of file system.c.

                                                               {
    NUDMABuffer* dmaPtr;
    NUDMABuffer* freeBuffer;
    OSIoMesg* mesg;
    s32 delta;
    u32 startAddr;
    s32 addrEnd, buffEnd;
    NUDMABuffer* lastDmaPtr;
 
    if (!useDma) {
        return osVirtualToPhysical((void*)addr);
    }
 
    lastDmaPtr = NULL;
    dmaPtr = nuAuDmaState.firstUsed;
    addrEnd = addr + len;
 
    while (dmaPtr != NULL) {
        startAddr = dmaPtr->startAddr;
        buffEnd = dmaPtr->startAddr + 0x500;
        if (addr >= startAddr && buffEnd >= addrEnd) {
            dmaPtr->frameCnt = nuAuFrameCounter;
            freeBuffer = (NUDMABuffer*)(dmaPtr->ptr + addr - dmaPtr->startAddr);
            return osVirtualToPhysical(freeBuffer);
        } else if (addr < startAddr) {
            break;
        }
        lastDmaPtr = dmaPtr;
        dmaPtr = (NUDMABuffer*)dmaPtr->node.next;
    }
 
    dmaPtr = nuAuDmaState.firstFree;
    if (dmaPtr == NULL) {
        return osVirtualToPhysical(nuAuDmaState.firstUsed);
    }
 
    nuAuDmaState.firstFree = (NUDMABuffer*)dmaPtr->node.next;
    alUnlink(&dmaPtr->node);
 
    if (lastDmaPtr != NULL) {
        alLink(&dmaPtr->node, &lastDmaPtr->node);
    } else if (nuAuDmaState.firstUsed != NULL){
        lastDmaPtr = nuAuDmaState.firstUsed;
        nuAuDmaState.firstUsed = dmaPtr;
        dmaPtr->node.next = &lastDmaPtr->node;
        dmaPtr->node.prev = NULL;
        lastDmaPtr->node.prev = &dmaPtr->node;
    } else {
        nuAuDmaState.firstUsed = dmaPtr;
        dmaPtr->node.next = NULL;
        dmaPtr->node.prev = NULL;
    }
 
    freeBuffer = (NUDMABuffer*)dmaPtr->ptr;
    delta = addr & 1;
    addr -= delta;
    dmaPtr->startAddr = addr;
    dmaPtr->frameCnt = nuAuFrameCounter;
 
    mesg = &nuAuDmaIOMesgBuf[nuAuDmaNext++];
    mesg->hdr.pri = OS_MESG_PRI_NORMAL;
    mesg->hdr.retQueue = &nuAuDmaMesgQ;
    mesg->dramAddr = freeBuffer;
    mesg->devAddr = addr;
    mesg->size = 0x500;
    osEPiStartDma(nuPiCartHandle, mesg, 0);
    return osVirtualToPhysical(freeBuffer) + delta;
}

Referenced by nuAuDmaNew().

au_release_voice()

void au_release_voice

(

u8

index

)

Definition at line 29 of file engine.c.

                                {
    AuVoice* voice = &gSoundGlobals->voices[index];
 
    voice->cmdPtr = NULL;
    voice->priority = AU_PRIORITY_FREE;
}

Referenced by au_pull_voice().

au_engine_init()

void au_engine_init

(

s32

outputRate

)

Definition at line 36 of file engine.c.

                                    {
    AuGlobals* globals;
    ALHeap* alHeap;
    SBNFileEntry fileEntry;
    s32* dummyTrackData;
    u8 effects[4];
    u32 i;
 
    alHeap = gSynDriverPtr->heap;
    gSoundGlobals = alHeapAlloc(alHeap, 1, sizeof(*gSoundGlobals));
 
    gBGMPlayerA = alHeapAlloc(alHeap, 1, sizeof(*gBGMPlayerA));
    gBGMPlayerB = alHeapAlloc(alHeap, 1, sizeof(*gBGMPlayerB));
    gBGMPlayerC = alHeapAlloc(alHeap, 1, sizeof(*gBGMPlayerC));
    gSoundManager = alHeapAlloc(alHeap, 1, sizeof(*gSoundManager));
    gAuAmbienceManager = alHeapAlloc(alHeap, 1, sizeof(*gAuAmbienceManager));
    gBGMPlayerA->soundManager = gSoundManager;
    gAuAmbienceManager->globals = gSoundGlobals;
 
    globals = gSoundGlobals;
    dummyTrackData = alHeapAlloc(alHeap, 1, 0x8000);
    globals->dataBGM[0] = (BGMHeader*) &dummyTrackData[0];
    globals->dataBGM[1] = (BGMHeader*) &dummyTrackData[0x1400];
    globals->dataMSEQ[0] = (MSEQHeader*) &dummyTrackData[0x1C00];
    globals->dataMSEQ[1] = (MSEQHeader*) &dummyTrackData[0x1400];
 
    for (i = 0; i < ARRAY_COUNT(globals->snapshots); i++) {
        globals->snapshots[i].bgmPlayer = alHeapAlloc(alHeap, 1, sizeof(BGMPlayer));
    }
 
    globals->dataSEF = alHeapAlloc(alHeap, 1, 0x5200);
    globals->defaultInstrument = alHeapAlloc(alHeap, 1, sizeof(Instrument));
    globals->dataPER = alHeapAlloc(alHeap, 1, 6 * sizeof(PEREntry));
    globals->dataPRG = alHeapAlloc(alHeap, 1, PRG_MAX_COUNT * sizeof(BGMInstrumentInfo));
    globals->musicEventQueue = alHeapAlloc(alHeap, 1, MUS_QUEUE_SIZE * sizeof(MusicEventTrigger));
    globals->outputRate = outputRate;
    au_reset_instrument(globals->defaultInstrument);
    au_reset_drum_entry(&globals->defaultDrumEntry);
    au_reset_instrument_entry(&globals->defaultPRGEntry);
    snd_song_clear_music_events();
 
    globals->audioThreadCallbacks[0] = NULL;
    globals->audioThreadCallbacks[1] = NULL;
 
    for (i = 0; i < ARRAY_COUNT(globals->snapshots); i++) {
        globals->snapshots[i].assigned = 0;
        globals->snapshots[i].priority = 0;
    }
 
    for (i = 0; i < ARRAY_COUNT(globals->effectChanges); i++) {
        globals->effectChanges[i].type = AU_FX_NONE;
        globals->effectChanges[i].changed = FALSE;
    }
 
    for (i = 0; i < ARRAY_COUNT(globals->voices); i++) {
        AuVoice* voice;
        au_pvoice_set_bus(i, FX_BUS_BGMA_MAIN);
        au_syn_set_wavetable(i, globals->defaultInstrument);
        voice = &globals->voices[i];
        voice->instrument = NULL;
        voice->pitchRatio = 0;
        voice->volume = -1;
        voice->pan = 0xFF;
        voice->reverb = 0xFF;
        voice->busID = 0;
        voice->donePending = FALSE;
        voice->syncFlags = 0;
        voice->clientPriority = AU_PRIORITY_FREE;
        voice->priority = AU_PRIORITY_FREE;
    }
 
    au_load_INIT(globals, SBN_ROM_OFFSET, alHeap);
 
    for (i = 0; i < ARRAY_COUNT(globals->auxBanks); i++) {
        globals->auxBanks[i] = alHeapAlloc(alHeap, 1, sizeof(BKFileBuffer));
    }
 
    au_bgm_player_init(gBGMPlayerA, AU_PRIORITY_BGM_PLAYER_MAIN, FX_BUS_BGMA_MAIN, globals);
    effects[0] = FX_BUS_BGMA_MAIN;
    effects[1] = FX_BUS_BGMA_AUX;
    effects[2] = -1;
    effects[3] = -1;
    au_bgm_set_effect_indices(gBGMPlayerA, effects);
 
    au_bgm_player_init(gBGMPlayerB, AU_PRIORITY_BGM_PLAYER_AUX, FX_BUS_BGMB, globals);
    effects[0] = FX_BUS_BGMB;
    effects[1] = -1;
    effects[2] = -1;
    effects[3] = -1;
    au_bgm_set_effect_indices(gBGMPlayerB, effects);
 
    au_sfx_init(gSoundManager, AU_PRIORITY_SFX_MANAGER, FX_BUS_SOUND, globals, 16);
    au_mseq_manager_init(gAuAmbienceManager, AU_PRIORITY_MSEQ_MANAGER, FX_BUS_SOUND, globals);
    au_init_voices(globals);
    au_load_BK_headers(globals, alHeap);
    if (au_fetch_SBN_file(globals->extraFileList[0], AU_FMT_SEF, &fileEntry) == AU_RESULT_OK) {
        au_read_rom(fileEntry.offset, globals->dataSEF, fileEntry.data & 0xFFFFFF);
    }
    au_sfx_load_groups_from_SEF(gSoundManager);
    if (au_fetch_SBN_file(globals->extraFileList[1], AU_FMT_PER, &fileEntry) == AU_RESULT_OK) {
        au_load_PER(globals, fileEntry.offset);
    }
    if (au_fetch_SBN_file(globals->extraFileList[2], AU_FMT_PRG, &fileEntry) == AU_RESULT_OK) {
        au_load_PRG(globals, fileEntry.offset);
    }
 
    globals->bankSets[BANK_SET_IDX_0] = globals->auxBankSet;
    globals->bankSets[BANK_SET_IDX_1] = globals->bankSet2;
    globals->bankSets[BANK_SET_IDX_2] = globals->defaultBankSet;
    globals->bankSets[BANK_SET_IDX_3] = globals->musicBankSet;
    globals->bankSets[BANK_SET_IDX_4] = globals->bankSet4;
    globals->bankSets[BANK_SET_IDX_5] = globals->bankSet5;
    globals->bankSets[BANK_SET_IDX_6] = globals->bankSet6;
    globals->bankSets[BANK_SET_IDX_7] = globals->auxBankSet;
 
    globals->channelDelaySide = AU_DELAY_CHANNEL_NONE;
    globals->channelDelayTime = 0;
    globals->channelDelayBusID = 0;
    globals->channelDelayPending = FALSE;
 
    au_init_delay_channel(0);
    snd_notify_engine_ready(alHeap);
}

Referenced by create_audio_system().

au_update_clients_for_video_frame()

void au_update_clients_for_video_frame

(

void

)

this is called once per video frame update (50 or 60 times per second)

Definition at line 286 of file engine.c.

                                             {
    AuGlobals* globals = gSoundGlobals;
    BGMPlayer* player = gBGMPlayerA;
    SoundManager* manager = gSoundManager;
 
    if (globals->flushMusicEventQueue) {
        snd_song_clear_music_events();
    }
 
    BeginSoundUpdateCallback = globals->audioThreadCallbacks[0];
    if (BeginSoundUpdateCallback != NULL) {
        BeginSoundUpdateCallback();
    }
 
    au_bgm_begin_video_frame(player);
 
    player = gBGMPlayerB;
    au_bgm_begin_video_frame(player);
 
    au_sfx_begin_video_frame(manager);
}

Referenced by alAudioFrame().

au_update_clients_for_audio_frame()

void au_update_clients_for_audio_frame

(

void

)

this is called per audio frame generated by alAudioFrame (every 184 audio samples) there will be multiuple of these per video frame

this is called per audio frame generated by alAudioFrame (every 184 audio samples) there will be multiuple of these per video frame

Updates MSEQ, SFX, and BGM players for the current audio frame.

Definition at line 210 of file engine.c.

                                             {
    AuGlobals* globals = gSoundGlobals;
    SoundManager* sfxManager = gSoundManager;
    AmbienceManager* ambManager = gAuAmbienceManager;
    BGMPlayer* bgmPlayer;
 
    au_syn_begin_audio_frame(globals);
 
    // Update ambience manager every other frame
    ambManager->nextUpdateCounter -= ambManager->nextUpdateStep;
    if (ambManager->nextUpdateCounter <= 0) {
        ambManager->nextUpdateCounter += ambManager->nextUpdateInterval;
        au_mseq_manager_audio_frame_update(ambManager);
    }
 
     // Update volume fade for SFX bus
    if (sfxManager->fadeInfo.baseTicks != 0) {
        au_fade_update(&sfxManager->fadeInfo);
        au_fade_set_volume(sfxManager->busID, sfxManager->fadeInfo.baseVolume >> 16, sfxManager->busVolume);
    }
 
    // Periodic SFX manager update
    sfxManager->nextUpdateCounter -= sfxManager->nextUpdateStep;
    if (sfxManager->nextUpdateCounter <= 0) {
        sfxManager->nextUpdateCounter += sfxManager->nextUpdateInterval;
        sfxManager->prevUpdateResult = au_sfx_manager_audio_frame_update(sfxManager);
    }
 
    // Update gBGMPlayerB
    if (!PreventBGMPlayerUpdate) {
        bgmPlayer = gBGMPlayerB;
        if (bgmPlayer->fadeInfo.baseTicks != 0) {
            au_bgm_update_fade(bgmPlayer);
        }
        if (bgmPlayer->songName != 0) {
            bgmPlayer->songPlayingCounter++;
        }
 
        bgmPlayer->nextUpdateCounter -= bgmPlayer->nextUpdateStep;
        if (bgmPlayer->nextUpdateCounter <= 0) {
            bgmPlayer->nextUpdateCounter += bgmPlayer->tickUpdateInterval;
            bgmPlayer->prevUpdateResult = au_bgm_player_audio_frame_update(bgmPlayer);
        }
    }
 
    // Update gBGMPlayerA
    if (!PreventBGMPlayerUpdate) {
        if (globals->resumeRequested) {
            au_bgm_restore_copied_player(globals);
        }
        bgmPlayer = gBGMPlayerA;
        if (bgmPlayer->fadeInfo.envelopeTicks != 0) {
            au_fade_update_envelope(&bgmPlayer->fadeInfo);
            if (bgmPlayer->fadeInfo.baseTicks == 0) {
                au_bgm_update_bus_volumes(bgmPlayer);
            } else {
                au_bgm_update_fade(bgmPlayer);
            }
        } else if (bgmPlayer->fadeInfo.baseTicks != 0) {
            au_bgm_update_fade(bgmPlayer);
        }
        if (bgmPlayer->songName != 0) {
            bgmPlayer->songPlayingCounter++;
        }
 
        bgmPlayer->nextUpdateCounter -= bgmPlayer->nextUpdateStep;
        if (bgmPlayer->nextUpdateCounter <= 0) {
            bgmPlayer->nextUpdateCounter += bgmPlayer->tickUpdateInterval;
            bgmPlayer->prevUpdateResult = au_bgm_player_audio_frame_update(bgmPlayer);
        }
    }
 
    // With all clients updated, now update all voices
    au_update_voices(globals);
}

Referenced by alAudioFrame().

au_syn_begin_audio_frame()

void au_syn_begin_audio_frame

(

AuGlobals *

globals

)

Definition at line 308 of file engine.c.

                                                  {
    u32 i;
 
    if (globals->channelDelayState == AU_DELAY_STATE_REQUEST_OFF) {
        globals->channelDelayState = AU_DELAY_STATE_OFF;
        au_disable_channel_delay();
    }
 
    if (globals->channelDelayPending && (globals->channelDelayState == AU_DELAY_STATE_ON)) {
        switch (globals->channelDelaySide) {
            case AU_DELAY_CHANNEL_LEFT:
                au_set_delay_time(globals->channelDelayTime);
                au_delay_left_channel(globals->channelDelayBusID);
                globals->channelDelayPending = FALSE;
                break;
            case AU_DELAY_CHANNEL_RIGHT:
                au_set_delay_time(globals->channelDelayTime);
                au_delay_right_channel(globals->channelDelayBusID);
                globals->channelDelayPending = FALSE;
                break;
            default:
                au_disable_channel_delay();
                globals->channelDelayPending = FALSE;
                break;
        }
    }
 
    // handle effect bus changes
    if (globals->effectChanges[FX_BUS_BGMA_MAIN].changed) {
        au_bus_set_effect(FX_BUS_BGMA_MAIN, globals->effectChanges[FX_BUS_BGMA_MAIN].type);
        globals->effectChanges[FX_BUS_BGMA_MAIN].changed = FALSE;
    }
    if (globals->effectChanges[FX_BUS_SOUND].changed) {
        au_bus_set_effect(FX_BUS_SOUND, globals->effectChanges[FX_BUS_SOUND].type);
        globals->effectChanges[FX_BUS_SOUND].changed = FALSE;
 
    } if (globals->effectChanges[FX_BUS_BGMB].changed) {
        au_bus_set_effect(FX_BUS_BGMB, globals->effectChanges[FX_BUS_BGMB].type);
        globals->effectChanges[FX_BUS_BGMB].changed = FALSE;
    }
    if (globals->effectChanges[FX_BUS_BGMA_AUX].changed) {
        au_bus_set_effect(FX_BUS_BGMA_AUX, globals->effectChanges[FX_BUS_BGMA_AUX].type);
        globals->effectChanges[FX_BUS_BGMA_AUX].changed = FALSE;
    }
 
    for (i = 0; i < ARRAY_COUNT(globals->voices); i++) {
        AuVoice* voice = &globals->voices[i];
        u8 voiceUpdateFlags = voice->syncFlags;
 
        if (voice->donePending) {
            au_syn_stop_voice(i);
            voice->donePending = FALSE;
            voice->cmdPtr = NULL;
            voice->priority = AU_PRIORITY_FREE;
        }
 
        if (voiceUpdateFlags & AU_VOICE_SYNC_FLAG_ALL) {
            au_voice_start(voice, &voice->envelope);
            au_syn_start_voice_params(i, voice->busID, voice->instrument, voice->pitchRatio, voice->volume, voice->pan, voice->reverb, voice->delta);
            // priority may be AU_PRIORITY_FREE if this voice was stolen and reset
            voice->priority = voice->clientPriority;
        } else {
            if (voiceUpdateFlags & AU_VOICE_SYNC_FLAG_PITCH) {
                au_syn_set_pitch(i, voice->pitchRatio);
            }
 
            if (voiceUpdateFlags & AU_VOICE_SYNC_FLAG_PARAMS) {
                au_syn_set_mixer_params(i, voice->volume, voice->delta, voice->pan, voice->reverb);
            } else if (voiceUpdateFlags & AU_VOICE_SYNC_FLAG_PAN_FXMIX) {
                au_syn_set_pan_fxmix(i, voice->pan, voice->reverb);
            }
        }
        voice->syncFlags = 0;
    }
}

Referenced by au_update_clients_for_audio_frame().

au_reset_nonfree_voice()

void au_reset_nonfree_voice	(	AuVoice *	arg0,
		u8	arg1 )

Definition at line 384 of file engine.c.

                                                      {
    if (voice->priority != AU_PRIORITY_FREE) {
        voice->cmdPtr = NULL;
        voice->donePending = TRUE;
        voice->syncFlags = 0;
        au_syn_set_volume_delta(index, 0, AUDIO_SAMPLES);
    }
}

au_reset_voice()

void au_reset_voice	(	AuVoice *	voice,
		u8	voiceIdx )

Definition at line 393 of file engine.c.

                                                 {
    voice->cmdPtr = NULL;
    voice->donePending = TRUE;
    voice->syncFlags = 0;
    au_syn_set_volume_delta(voiceIdx, 0, AUDIO_SAMPLES);
}

Referenced by au_bgm_player_update_playing(), au_bgm_reset_all_voices(), au_BGMCmd_FC_Branch(), au_mseq_player_stop(), au_mseq_player_update(), and au_mseq_restore_voices().

au_compute_pitch_ratio()

f32 au_compute_pitch_ratio

(

s32

tuning

)

Converts a linear pitch value (in cents) into a frequency ratio suitable for adjusting playback speed.

This function computes the playback rate corresponding to a pitch shift (up or down) in cents. Positive values increase pitch (higher frequency), and negative values decrease it. Recall 100 cents = 1 semitone, and therefore 1200 cents = 1 octave.

Parameters

tuning

The pitch offset in cents, from +4095 (~ 40.95 semitones up) to -16383 (~ 163.83 semitones down)

Returns

Floating point output rate multiplier. Multiply this with the base sample rate to apply the pitch.

Definition at line 406 of file engine.c.

                                       {
    if (tuning >= 0) {
        return AlTuneScaling[(tuning & 0x7F) + TUNE_SCALING_ARR_AMPLIFY_FINE]
            * AlTuneScaling[((tuning & 0xF80) >> 7) + TUNE_SCALING_ARR_AMPLIFY_COARSE];
    } else {
        tuning = -tuning;
        return AlTuneScaling[(tuning & 0x7F) + TUNE_SCALING_ARR_ATTENUATE_FINE]
            * AlTuneScaling[((tuning & 0x3F80) >> 7) + TUNE_SCALING_ARR_ATTENUATE_COARSE];
    }
}

Referenced by au_bgm_player_update_playing(), au_mseq_player_update(), and au_mseq_restore_voices().

au_fade_init()

void au_fade_init	(	Fade *	fade,
		s32	time,
		s32	startValue,
		s32	endValue )

Definition at line 417 of file engine.c.

                                                                      {
    fade->baseVolume = startValue << 16;
    fade->baseTarget = endValue;
 
    if (time != 0) {
        fade->baseTicks = (time * 1000) / AU_FRAME_USEC;
        fade->baseStep = ((endValue << 16) - fade->baseVolume) / fade->baseTicks;
    } else {
        fade->baseTicks = 1;
        fade->baseStep = 0;
    }
 
    fade->onCompleteCallback = NULL;
}

Referenced by au_bgm_process_init_song(), au_bgm_restore_copied_player(), and au_sfx_init().

au_fade_clear()

void au_fade_clear

(

Fade *

fade

)

Definition at line 432 of file engine.c.

                               {
    fade->baseTicks = 0;
    fade->baseStep = 0;
    fade->onCompleteCallback = NULL;
}

au_fade_update()

void au_fade_update

(

Fade *

fade

)

Definition at line 438 of file engine.c.

                                {
    fade->baseTicks--;
 
    if ((fade->baseTicks << 16) != 0) {
        fade->baseVolume += fade->baseStep;
    } else {
        fade->baseVolume = fade->baseTarget << 16;
        if (fade->onCompleteCallback != NULL) {
            fade->onCompleteCallback();
            fade->baseStep = 0;
            fade->onCompleteCallback = NULL;
        }
    }
}

Referenced by au_update_clients_for_audio_frame().

au_fade_set_volume()

void au_fade_set_volume	(	u8	arg0,
		u16	arg1,
		s32	arg2 )

Definition at line 453 of file engine.c.

                                                             {
    au_bus_set_volume(busID, (u32)(volume * busVolume) / AU_MAX_BUS_VOLUME);
}

Referenced by au_bgm_update_bus_volumes(), au_sfx_init(), and au_update_clients_for_audio_frame().

au_fade_flush()

void au_fade_flush

(

Fade *

fade

)

Definition at line 457 of file engine.c.

                               {
    if (fade->baseTicks == 0) {
        fade->baseTicks = 1;
        fade->baseStep = 0;
        fade->baseTarget = ((u32)fade->baseVolume >> 16);
    }
}

Referenced by au_set_bus_volume_level().

au_fade_set_envelope()

void au_fade_set_envelope	(	Fade *	fade,
		s16	value )

Definition at line 465 of file engine.c.

                                                 {
    fade->envelopeVolume = value << 16;
    fade->envelopeTarget = value;
    fade->envelopeTicks = 0;
    fade->envelopeStep = 0;
}

Referenced by au_bgm_player_init().

au_fade_calc_envelope()

void au_fade_calc_envelope	(	Fade *	fade,
		u32	arg1,
		s32	target )

Definition at line 472 of file engine.c.

                                                                 {
    s16 ticks;
    s32 delta;
 
    if (duration >= 250 && duration <= 100000) {
        ticks = (s32)(duration * 1000) / AU_FRAME_USEC;
        delta = (target << 16) - fade->envelopeVolume;
 
        fade->envelopeTarget = target;
        fade->envelopeTicks = ticks;
        fade->envelopeStep = delta / ticks;
    } else {
        fade->envelopeTicks = 0;
        fade->envelopeStep = 0;
    }
}

Referenced by au_bgm_adjust_volume().

au_fade_update_envelope()

void au_fade_update_envelope

(

Fade *

fade

)

Definition at line 489 of file engine.c.

                                         {
    fade->envelopeTicks--;
 
    if (fade->envelopeTicks != 0) {
        fade->envelopeVolume += fade->envelopeStep;
    } else {
        fade->envelopeStep = 0;
        fade->envelopeVolume = fade->envelopeTarget << 16;
    }
}

Referenced by au_update_clients_for_audio_frame().

au_get_instrument()

Instrument * au_get_instrument	(	AuGlobals *	globals,
		BankSetIndex	bank,
		s32	patch,
		EnvelopeData *	envData )

Note that bank is supplied as BankSetIndex and not BankSet, which means it will be used to perform a raw access into AuGlobals::bankSets.

This does not affect values above 3, but 1 and 2 differ.

Definition at line 502 of file engine.c.

                                                                                                       {
    // note that patch here can be up to 255, selecting from a maximum of 16 instruments and 16 banks per group
    Instrument* instrument = (*globals->bankSets[(bank & 0x70) >> 4])[patch];
    EnvelopePreset* envelope = instrument->envelopes;
    u32 envelopeIdx = bank & 3;
 
    if (envelopeIdx < envelope->count) {
        envData->cmdListPress = AU_FILE_RELATIVE(envelope, envelope->offsets[envelopeIdx].offsetPress);
        envData->cmdListRelease = AU_FILE_RELATIVE(envelope, envelope->offsets[envelopeIdx].offsetRelease);
    } else {
        envData->cmdListPress = EnvelopePressDefault;
        envData->cmdListRelease = &EnvelopePressDefault[4]; //EnvelopeReleaseDefault;
    }
    return instrument;
}

Referenced by au_bgm_player_update_playing(), au_BGMCmd_E8_TrackOverridePatch(), au_BGMCmd_F5_UseInstrument(), and au_mseq_player_update().

au_get_bgm_player_and_file()

void au_get_bgm_player_and_file	(	u32	playerIndex,
		BGMHeader **	outCurrentTrackData,
		BGMPlayer **	outPlayer )

Definition at line 518 of file engine.c.

                                                                                             {
    AuGlobals* globals = gSoundGlobals;
 
    switch (playerIndex) {
        case 0:
            *outFile = globals->dataBGM[0];
            *outPlayer = gBGMPlayerA;
            break;
        case 1:
            *outFile = globals->dataBGM[1];
            *outPlayer = gBGMPlayerB;
            break;
        case 2:
            *outFile = globals->dataBGM[0];
            *outPlayer = gBGMPlayerA;
            break;
        default:
            *outFile = NULL;
            *outPlayer = NULL;
            break;
    }
}

Referenced by snd_song_load().

au_get_bgm_player()

void au_get_bgm_player	(	u32	playerIndex,
		BGMPlayer **	outPlayer )

Definition at line 541 of file engine.c.

                                                               {
    switch (playerIndex) {
        case 0:
            *outPlayer = gBGMPlayerA;
            break;
        case 1:
            *outPlayer = gBGMPlayerB;
            break;
        case 2:
            *outPlayer = gBGMPlayerA;
            break;
        default:
            *outPlayer = NULL;
            break;
    }
}

au_load_song_files()

AuResult au_load_song_files	(	u32	arg0,
		BGMHeader *	arg1,
		BGMPlayer *	arg2 )

Definition at line 558 of file engine.c.

                                                                               {
    AuResult status;
    SBNFileEntry fileEntry;
    SBNFileEntry fileEntry2;
    SBNFileEntry* bkFileEntry;
    AuGlobals* globals = gSoundGlobals;
    InitSongEntry* songInfo;
    s32 i;
    u16 bkFileIndex;
    s32 bgmFileIndex;
    u32 data;
    u32 offset;
    BGMPlayer* playerCopy;
    BGMHeader* fileCopy;
    s32 cond;
 
    // needed to match
    cond = songID < globals->songListLength;
    playerCopy = player;
    fileCopy = bgmFile;
 
    if (cond) {
        songInfo = &globals->songList[songID];
        status = au_fetch_SBN_file(songInfo->bgmFileIndex, AU_FMT_BGM, &fileEntry);
        if (status != AU_RESULT_OK) {
            return status;
        }
 
        if (au_bgm_player_is_active(playerCopy)) {
            return AU_ERROR_201;
        }
 
        au_read_rom(fileEntry.offset, fileCopy, fileEntry.data & 0xFFFFFF);
 
        for (i = 0; i < ARRAY_COUNT(songInfo->bkFileIndex); i++) {
            bkFileIndex = songInfo->bkFileIndex[i];
            if (bkFileIndex != 0) {
                bkFileEntry = &globals->sbnFileList[bkFileIndex];
 
                offset = (bkFileEntry->offset & 0xFFFFFF) + globals->baseRomOffset;
                fileEntry2.offset = offset;
 
                data = bkFileEntry->data;
                fileEntry2.data = data;
 
                if ((data >> 0x18) == AU_FMT_BK) {
                    au_load_aux_bank(offset, i);
                }
            }
        }
        bgmFileIndex = songInfo->bgmFileIndex;
        playerCopy->songID = songID;
        playerCopy->bgmFile = bgmFile;
        playerCopy->bgmFileIndex = bgmFileIndex;
        return fileCopy->name;
    } else {
        return AU_ERROR_151;
    }
}

Referenced by snd_song_load().

au_reload_song_files()

AuResult au_reload_song_files	(	s32	songID,
		BGMHeader *	arg1 )

Definition at line 618 of file engine.c.

                                                              {
    AuResult status;
    SBNFileEntry fileEntry;
    SBNFileEntry sbnEntry;
    SBNFileEntry* bkFileEntry;
    AuGlobals* globals;
    InitSongEntry* songInfo;
    s32 i;
    u16 bkFileIndex;
 
    globals = gSoundGlobals;
    songInfo = &globals->songList[songID];
    status = au_fetch_SBN_file(songInfo->bgmFileIndex, AU_FMT_BGM, &sbnEntry);
    if (status == AU_RESULT_OK) {
        // load BGM file
        au_read_rom(sbnEntry.offset, bgmFile, sbnEntry.data & 0xFFFFFF);
 
        // load any auxiliary banks required by this BGM
        for (i = 0; i < ARRAY_COUNT(songInfo->bkFileIndex); i++) {
            bkFileIndex = songInfo->bkFileIndex[i];
            if (bkFileIndex != 0) {
                bkFileEntry = &globals->sbnFileList[bkFileIndex];
 
                fileEntry.offset = (bkFileEntry->offset & 0xFFFFFF) + globals->baseRomOffset;
                fileEntry.data = bkFileEntry->data;
 
                if ((fileEntry.data >> 0x18) == AU_FMT_BK) {
                    au_load_aux_bank(fileEntry.offset, i);
                } else {
                    status = AU_ERROR_SBN_FORMAT_MISMATCH;
                }
            }
        }
    }
 
    return status;
}

Referenced by au_bgm_process_resume().

au_get_snapshot_by_index()

BGMPlayer * au_get_snapshot_by_index

(

s32

index

)

Definition at line 656 of file engine.c.

                                               {
    if (index == BGM_SNAPSHOT_0) {
        return gSoundGlobals->snapshots[BGM_SNAPSHOT_0].bgmPlayer;
    }
    return NULL;
}

Referenced by au_bgm_process_resume(), and au_bgm_process_suspend().

au_ambient_load()

AuResult au_ambient_load

(

u32

arg0

)

Definition at line 665 of file engine.c.

                                         {
    AmbienceManager* manager;
    SBNFileEntry fileEntry;
    AuGlobals* globals;
    MSEQHeader* mseqFile;
    u32 i;
 
    globals = gSoundGlobals;
    manager = gAuAmbienceManager;
    if (ambSoundID < AMBIENT_RADIO) {
        if (manager->players[0].mseqName == 0) {
            if (SBN_EXTRA_LOOKUP(ambSoundID, AU_FMT_MSEQ, fileEntry) == AU_RESULT_OK) {
                au_read_rom(fileEntry.offset, globals->dataMSEQ[0], fileEntry.data & 0xFFFFFF);
                manager->mseqFiles[0] = globals->dataMSEQ[0];
                for (i = 1; i < ARRAY_COUNT(manager->mseqFiles); i++) {
                    manager->mseqFiles[i] = NULL;
                }
                manager->numActivePlayers = 1;
            }
        }
    } else if (ambSoundID == AMBIENT_RADIO
            && manager->players[0].mseqName == 0
            && manager->players[1].mseqName == 0
            && manager->players[2].mseqName == 0
    ) {
        manager->numActivePlayers = 0;
        for (i = 0; i < ARRAY_COUNT(manager->mseqFiles); i++) {
            manager->mseqFiles[i] = NULL;
        }
 
        mseqFile = globals->dataMSEQ[1];
        if (SBN_EXTRA_LOOKUP(ambSoundID, AU_FMT_MSEQ, fileEntry) == AU_RESULT_OK) {
            au_read_rom(fileEntry.offset, mseqFile, fileEntry.data & 0xFFFFFF);
            manager->mseqFiles[0] = mseqFile;
 
            mseqFile = AU_FILE_RELATIVE(mseqFile, (fileEntry.data + 0x40) & 0xFFFFFF);
            if (SBN_EXTRA_LOOKUP(ambSoundID + 1, AU_FMT_MSEQ, fileEntry) == AU_RESULT_OK) {
                au_read_rom(fileEntry.offset, mseqFile, fileEntry.data & 0xFFFFFF);
                manager->mseqFiles[1] = mseqFile;
 
                mseqFile = AU_FILE_RELATIVE(mseqFile, (fileEntry.data + 0x40) & 0xFFFFFF);
                if (SBN_EXTRA_LOOKUP(ambSoundID + 2, AU_FMT_MSEQ, fileEntry) == AU_RESULT_OK) {
                    au_read_rom(fileEntry.offset, mseqFile, fileEntry.data & 0xFFFFFF);
                    manager->mseqFiles[2] = mseqFile;
 
                    mseqFile = AU_FILE_RELATIVE(mseqFile, (fileEntry.data + 0x40) & 0xFFFFFF);
                    if (SBN_EXTRA_LOOKUP(ambSoundID + 3, AU_FMT_MSEQ, fileEntry) == AU_RESULT_OK) {
                        au_read_rom(fileEntry.offset, mseqFile, fileEntry.data & 0xFFFFFF);
                        manager->mseqFiles[3] = mseqFile;
 
                        manager->numActivePlayers = 4;
                        if (SBN_EXTRA_LOOKUP(ambSoundID + 4, AU_FMT_BK, fileEntry) == AU_RESULT_OK) {
                            // @bug perhaps meant to be 3?
                            // the index here corresponds to an entry in gSoundGlobals->banks
                            // 0-2 are used for the extra banks which may be loaded for BGM files
                            // there exists an unused 4th entry this could plausibly be intended for
                            au_load_aux_bank(fileEntry.offset, 2);
                        }
                    }
                }
            }
        }
    }
 
    return AU_RESULT_OK;
}

Referenced by snd_load_ambient().

au_get_client_by_priority()

BGMPlayer * au_get_client_by_priority

(

u8

arg0

)

Definition at line 732 of file engine.c.

                                                  {
    switch (priority) {
        case AU_PRIORITY_BGM_PLAYER_MAIN:
            return gBGMPlayerA;
        case AU_PRIORITY_BGM_PLAYER_AUX:
            return gBGMPlayerB;
        case AU_PRIORITY_SFX_MANAGER:
            return (BGMPlayer*)gSoundManager; // TODO: why return pointer to SoundManager?
        default:
            return NULL;
    }
}

Referenced by au_bgm_process_resume().

au_load_INIT()

void au_load_INIT	(	AuGlobals *	arg0,
		s32	romAddr,
		ALHeap *	heap )

Definition at line 745 of file engine.c.

                                                                 {
    SBNHeader sbnHeader;
    INITHeader initHeader;
    SBNFileEntry* entry;
    s32 fileListSize, initBase, size;
    s32 songListOffset, mseqListOffset;
    s32* data;
    s32 numEntries;
    s32* romPtr = &globals->baseRomOffset;
 
    au_read_rom(romAddr, &sbnHeader, sizeof(sbnHeader));
    numEntries = sbnHeader.numEntries;
    fileListSize = numEntries * sizeof(SBNFileEntry);
    globals->baseRomOffset = romAddr;
    globals->fileListLength = sbnHeader.numEntries;
    globals->sbnFileList = alHeapAlloc(heap, 1, fileListSize);
    au_read_rom(globals->baseRomOffset + sbnHeader.fileListOffset, globals->sbnFileList, fileListSize);
 
    entry = globals->sbnFileList;
    while (sbnHeader.numEntries--) {
        if ((entry->offset & 0xFFFFFF) == 0) {
            break;
        }
 
        // 16-byte align size
        size = entry->data;
        entry->data = (entry->data + 0xF) & ~0xF;
        entry++;
    }
 
    if (sbnHeader.INIToffset != 0) {
        initBase = *romPtr + sbnHeader.INIToffset;
        au_read_rom(initBase, &initHeader, sizeof(initHeader));
 
        songListOffset = initBase + initHeader.songListOffset;
        size = ALIGN16_(initHeader.songListSize);
        globals->songList = alHeapAlloc(heap, 1, size);
        au_read_rom(songListOffset, globals->songList, size);
 
        mseqListOffset = initBase + initHeader.mseqListOffset;
        size = ALIGN16_(initHeader.mseqListSize);
        globals->extraFileList = alHeapAlloc(heap, 1, size);
        au_read_rom(mseqListOffset, globals->extraFileList, size);
 
        globals->bkFileListOffset = initBase + initHeader.bankListOffset;
        globals->bkListLength = ALIGN16_(initHeader.bankListSize);
 
        globals->songListLength = initHeader.songListSize / sizeof(InitSongEntry) - 1;
    }
}

Referenced by au_engine_init().

au_fetch_SBN_file()

AuResult au_fetch_SBN_file	(	u32	fileIdx,
		AuFileFormat	format,
		SBNFileEntry *	arg2 )

Definition at line 796 of file engine.c.

                                                                                     {
    SBNFileEntry fileEntry;
    s32 status = AU_RESULT_OK;
 
    if (fileIdx < gSoundGlobals->fileListLength) {
        SBNFileEntry* entry = &gSoundGlobals->sbnFileList[fileIdx];
        s32 offset = (entry->offset & 0xFFFFFF) + gSoundGlobals->baseRomOffset;
 
        fileEntry.offset = offset;
        fileEntry.data = entry->data;
        if ((fileEntry.data >> 0x18) == format) {
            outEntry->offset = offset;
            outEntry->data = fileEntry.data;
        } else {
            status = AU_ERROR_SBN_FORMAT_MISMATCH;
        }
    } else {
        status = AU_ERROR_SBN_INDEX_OUT_OF_RANGE;
    }
    return status;
}

Referenced by au_engine_init(), au_load_BK_headers(), au_load_song_files(), and au_reload_song_files().

au_load_PER()

void au_load_PER	(	AuGlobals *	globals,
		s32	romAddr )

Definition at line 818 of file engine.c.

                                                  {
    PERHeader header;
    u32 size;
    s32 numItemsLeft;
    s32 numItems;
    void* end;
 
    au_read_rom(romAddr, &header, sizeof(header));
    size = header.mdata.size - sizeof(header);
    au_read_rom(romAddr + sizeof(header), globals->dataPER, size);
    numItems = size / sizeof(PEREntry);
    numItemsLeft = 6 - numItems;
    if (numItemsLeft > 0) {
        end = &globals->dataPER[numItems];
        au_copy_words(&globals->defaultDrumEntry, end, sizeof(BGMDrumInfo));
        au_copy_words(end, end + sizeof(BGMDrumInfo), numItemsLeft * sizeof(PEREntry) - sizeof(BGMDrumInfo));
    }
}

Referenced by au_engine_init().

au_load_PRG()

void au_load_PRG	(	AuGlobals *	arg0,
		s32	romAddr )

Definition at line 837 of file engine.c.

                                                  {
    PERHeader header;
    u32 size;
    s32 numItemsLeft;
    s32 numItems;
    s32 dataRomAddr;
    void* end;
 
    au_read_rom(romAddr, &header, sizeof(header));
    dataRomAddr = romAddr + sizeof(header);
    size = header.mdata.size - sizeof(header);
    if (size > PRG_MAX_COUNT * sizeof(BGMInstrumentInfo)) {
        size = PRG_MAX_COUNT * sizeof(BGMInstrumentInfo);
    }
    au_read_rom(dataRomAddr, globals->dataPRG, size);
    numItems = size / sizeof(BGMInstrumentInfo);
    numItemsLeft = PRG_MAX_COUNT - numItems;
    if (numItemsLeft > 0) {
        end = &globals->dataPRG[numItems];
        au_copy_words(&globals->defaultPRGEntry, end, sizeof(BGMInstrumentInfo));
        au_copy_words(end, end + sizeof(BGMInstrumentInfo), numItemsLeft * sizeof(BGMInstrumentInfo) - sizeof(BGMInstrumentInfo));
    }
}

Referenced by au_engine_init().

au_get_BK_instruments()

InstrumentBank * au_get_BK_instruments	(	BankSet	bankSet,
		u32	bankIndex )

Definition at line 895 of file engine.c.

                                                                      {
    InstrumentBank* ret = NULL;
    AuGlobals* globals = gSoundGlobals;
 
    // TODO fake match - this multiplying the bankIndex by 16 and then dividing it right after is dumb
    bankIndex *= 16;
 
    switch (bankSet) {
        case BANK_SET_AUX:
            ret = &globals->auxBankSet[bankIndex / 16];
            break;
        case BANK_SET_2:
            ret = &globals->bankSet2[bankIndex / 16];
            break;
        case BANK_SET_4:
            ret = &globals->bankSet4[bankIndex / 16];
            break;
        case BANK_SET_5:
            ret = &globals->bankSet5[bankIndex / 16];
            break;
        case BANK_SET_6:
            ret = &globals->bankSet6[bankIndex / 16];
            break;
        case BANK_SET_MUSIC:
            ret = &globals->musicBankSet[bankIndex / 16];
            break;
    }
 
    return ret;
}

Referenced by au_clear_instrument_group(), au_load_BK_to_bank(), and au_load_static_BK_to_bank().

au_load_BK_to_bank()

BKFileBuffer * au_load_BK_to_bank	(	s32	bkFileOffset,
		BKFileBuffer *	bkFile,
		s32	bankIndex,
		BankSet	bankSet )

Loads an instrument bank file from ROM, allocates memory if needed, and sets up instrument pointers.

Instruments in the bank will be configured to use DMA streaming for sample/codebook data. This is the standard loader for streamed instrument banks.

Definition at line 947 of file engine.c.

                                                                                                         {
    ALHeap* heap = gSynDriverPtr->heap;
    BKHeader localHeader;
    BKHeader* header = &localHeader;
    InstrumentBank* group;
    Instrument** inst;
    s32 instrumentCount;
    u16 keepReading;
    u16 readState;
    s32 size;
    u32 i;
 
    au_read_rom(bkFileOffset, header, sizeof(*header));
    readState = BK_READ_FETCH_HEADER;
    keepReading = TRUE;
 
    while (keepReading) {
        switch (readState) {
            case BK_READ_DONE:
                keepReading = FALSE;
                break;
            case BK_READ_FETCH_HEADER:
                if (header->signature != AL_HEADER_SIG_BK) {
                    keepReading = FALSE;
                } else if (header->size == 0) {
                    keepReading = FALSE;
                } else {
                    readState = BK_READ_FETCH_DATA;
                }
                break;
            case BK_READ_FETCH_DATA:
                if (header->format == AL_HEADER_SIG_CR) {
                    readState = BK_READ_PROCESS_CR;
                } else if (header->format == AL_HEADER_SIG_DR) {
                    readState = BK_READ_PROCESS_DR;
                } else if (header->format == AL_HEADER_SIG_SR) {
                    readState = BK_READ_PROCESS_SR;
                } else {
                    keepReading = FALSE;
                }
                break;
 
            case BK_READ_PROCESS_CR:
                size = ALIGN16_(header->instrumetsLength)
                    + ALIGN16_(header->loopStatesLength)
                    + ALIGN16_(header->predictorsLength)
                    + ALIGN16_(header->envelopesLength)
                    + sizeof(*header);
                if (bkFile == NULL) {
                    bkFile = alHeapAlloc(heap, 1, size);
                }
                au_read_rom(bkFileOffset, bkFile, size);
 
                group = au_get_BK_instruments(bankSet, bankIndex);
                inst = (*group);
                instrumentCount = 0;
 
                for (i = 0; i < ARRAY_COUNT(header->instruments); inst++, i++) {
                    u16 instOffset = header->instruments[i];
                    if (instOffset != 0) {
                        instrumentCount++;
                        *inst = AU_FILE_RELATIVE(bkFile, instOffset);
                    } else {
                        *inst = NULL;
                    }
                }
 
                if (instrumentCount != 0) {
                    readState = BK_READ_SWIZZLE_CR;
                } else {
                    keepReading = FALSE;
                }
                break;
            case BK_READ_SWIZZLE_CR:
                au_swizzle_BK_instruments(bkFileOffset, bkFile, *group, 16, TRUE);
                readState = BK_READ_DONE;
                break;
 
            // inferred states
            case BK_READ_PROCESS_DR:
            case BK_READ_UNK_DR:
            case BK_READ_PROCESS_SR:
            case BK_READ_UNK_SR:
            default:
                keepReading = FALSE;
                break;
        }
    }
 
    return bkFile;
}

Referenced by au_load_aux_bank(), and au_load_BK_headers().

au_swizzle_BK_instruments()

void au_swizzle_BK_instruments	(	s32	bkFileOffset,
		BKFileBuffer *	file,
		InstrumentBank	instruments,
		u32	instrumentCount,
		u8	useDma )

Fixes up (swizzles) instrument pointers in a loaded bank, converting file-relative offsets to valid RAM pointers.

Sets whether each instrument uses DMA streaming or not, and updates pitch ratios to match output rate. Replaces NULL instruments with a default instrument to ensure all loaded patches point to valid data.

Definition at line 1042 of file engine.c.

                                                                                                                                 {
    Instrument* defaultInstrument = gSoundGlobals->defaultInstrument;
    BKHeader* header = &file->header;
    f32 outputRate = gSoundGlobals->outputRate;
    s32 i;
 
    if (!header->swizzled) {
        for (i = 0; i < instrumentCount; i++) {
            Instrument* instrument = instruments[i];
 
            if (instrument != NULL) {
                if (instrument->wavData != 0) {
                    instrument->wavData += bkFileOffset;
                }
                if (instrument->loopState != NULL) {
                    instrument->loopState = AU_FILE_RELATIVE(file, instrument->loopState);
                }
                if (instrument->predictor != NULL) {
                    instrument->predictor = AU_FILE_RELATIVE(file, instrument->predictor);
                }
                if (instrument->envelopes != NULL) {
                    instrument->envelopes = AU_FILE_RELATIVE(file, instrument->envelopes);
                }
                instrument->useDma = useDma;
                instrument->pitchRatio = instrument->sampleRate / outputRate;
            } else {
                instruments[i] = defaultInstrument;
            }
        }
        header->swizzled = TRUE;
    }
}

Referenced by au_load_BK_to_bank(), and au_load_static_BK_to_bank().

au_load_static_BK_to_bank()

BKFileBuffer * au_load_static_BK_to_bank	(	s32 *	inAddr,
		void *	outAddr,
		s32	bankIndex,
		BankSet	bankSet )

UNUSED Loads an instrument bank file from ROM to a given buffer (allocates if needed), and sets up instrument pointers.

Instruments are configured to always bypass DMA: sample and codebook data is assumed to be already present in RAM. Use this only for banks whose sample data is guaranteed to be preloaded, not for standard streaming.

Definition at line 1079 of file engine.c.

                                                                                                    {
    ALHeap* heap = gSynDriverPtr->heap;
    BKFileBuffer* bkFile = outAddr;
    BKHeader localHeader;
    BKHeader* header = &localHeader;
    InstrumentBank* group;
    Instrument* instruments;
    Instrument** inst;
    s32 instrumentCount;
    u32 keepReading;
    u32 readState;
    u32 i;
    s32 useDma = FALSE;
 
    readState = BK_READ_FETCH_HEADER;
    keepReading = TRUE;
 
    while (keepReading) {
        switch (readState) {
            case BK_READ_DONE:
                keepReading = FALSE;
                break;
            case BK_READ_FETCH_HEADER:
                au_read_rom(*inAddr, &localHeader, sizeof(localHeader));
                if (header->signature != AL_HEADER_SIG_BK) {
                    keepReading = FALSE;
                } else if (header->size == 0) {
                    keepReading = FALSE;
                } else if (header->format != AL_HEADER_SIG_CR) {
                    keepReading = FALSE;
                } else {
                    readState = BK_READ_FETCH_DATA;
                }
                break;
            case BK_READ_FETCH_DATA:
                if (bkFile == NULL) {
                    bkFile = alHeapAlloc(heap, 1, header->size);
                }
                au_read_rom(*inAddr, bkFile, header->size);
 
                instrumentCount = 0;
                group = au_get_BK_instruments(bankSet, bankIndex);
                inst = (*group);
                for (i = 0; i < ARRAY_COUNT(header->instruments); inst++, i++) {
                    u16 instOffset = header->instruments[i];
                    if (instOffset != 0) {
                        instrumentCount++;
                        *inst = AU_FILE_RELATIVE(bkFile, instOffset);
                    } else {
                        *inst =  NULL;
                    }
                }
 
                if (instrumentCount != 0) {
                    readState = BK_READ_SWIZZLE;
                } else {
                    keepReading = FALSE;
                }
                break;
            case BK_READ_SWIZZLE:
                au_swizzle_BK_instruments((s32)bkFile, bkFile, *group, 16, useDma);
                readState = BK_READ_DONE;
                break;
            default:
                keepReading = FALSE;
                break;
        }
    }
    return bkFile;
}

au_load_aux_bank()

s32 au_load_aux_bank	(	s32	bkFileOffset,
		s32	bankIndex )

Definition at line 1150 of file engine.c.

                                                      {
    au_load_BK_to_bank(bkFileOffset, gSoundGlobals->auxBanks[bankIndex], bankIndex, BANK_SET_AUX);
    return AU_RESULT_OK;
}

Referenced by au_ambient_load(), au_load_BGM(), au_load_song_files(), and au_reload_song_files().

au_clear_instrument_group()

void au_clear_instrument_group	(	s32	bankIndex,
		BankSet	bankSet )

unused. resets all instruments in (bankIndex, bankSet) to default

Definition at line 1156 of file engine.c.

                                                               {
    Instrument* instrument = gSoundGlobals->defaultInstrument;
    InstrumentBank* group =  au_get_BK_instruments(bankSet, bankIndex);
    Instrument** ptr = *group;
    u32 i;
 
    if (group != NULL) {
        for (i = 0; i < ARRAY_COUNT(*group); i++) {
            *ptr++ = instrument;
        }
    }
}

au_set_bus_volume_level()

void au_set_bus_volume_level	(	s32	arg0,
		u32	idx )

Definition at line 1169 of file engine.c.

                                                                {
    if (volPreset < ARRAY_COUNT(PerceptualVolumeLevels)) {
        s32 vol = PerceptualVolumeLevels[volPreset];
        if (soundTypeFlags & AUDIO_TYPE_BGM) {
            gBGMPlayerA->busVolume = vol;
            au_fade_flush(&gBGMPlayerA->fadeInfo);
            gBGMPlayerB->busVolume = vol;
            au_fade_flush(&gBGMPlayerB->fadeInfo);
        }
        if (soundTypeFlags & AUDIO_TYPE_SFX) {
            gSoundManager->busVolume = vol;
            au_fade_flush(&gSoundManager->fadeInfo);
        }
    }
}

Referenced by snd_set_bgm_volume(), and snd_set_sfx_volume().

au_set_reverb_type()

s32 au_set_reverb_type	(	s32	arg0,
		s32	arg1 )

Definition at line 1185 of file engine.c.

                                                           {
    if (soundTypeFlags & AUDIO_TYPE_SFX) {
        return au_sfx_set_reverb_type(gSoundManager, reverbType);
    }
    return 0;
}

Referenced by snd_set_sfx_reverb_type().

au_sync_channel_delay_enabled()

void au_sync_channel_delay_enabled

(

u32

arg0

)

Definition at line 1192 of file engine.c.

                                                   {
    if (bMonoSound % 2 == 1) {
        // mono sound
        if (gSoundGlobals->channelDelayState == AU_DELAY_STATE_ON) {
            gSoundGlobals->channelDelayState = AU_DELAY_STATE_REQUEST_OFF;
        }
    } else {
        // stereo sound
        if (gSoundGlobals->channelDelayState != AU_DELAY_STATE_ON) {
            gSoundGlobals->channelDelayPending = TRUE;
            gSoundGlobals->channelDelayState = AU_DELAY_STATE_ON;
        }
    }
}

Referenced by snd_set_mono(), and snd_set_stereo().

au_read_rom()

void au_read_rom	(	s32	romAddr,
		void *	buffer,
		u32	size )

Definition at line 1209 of file engine.c.

                                                      {
    s32 nchunks = size / 0x2000;
    s32 offset = 0;
 
    if (nchunks != 0) {
        while (nchunks--) {
            nuPiReadRom(romAddr + offset, buffer + offset, 0x2000);
            offset += 0x2000;
        }
    }
 
    size %= 0x2000;
    if (size != 0) {
        nuPiReadRom(romAddr + offset, buffer + offset, size);
    }
}

Referenced by au_ambient_load(), au_engine_init(), au_load_BK_headers(), au_load_BK_to_bank(), au_load_INIT(), au_load_PER(), au_load_PRG(), au_load_song_files(), au_load_static_BK_to_bank(), and au_reload_song_files().

au_memset()

void au_memset	(	void *	dst,
		s32	size,
		u8	value )

Definition at line 1226 of file engine.c.

                                              {
    s32 count;
    s32 intValue;
 
    if (size == 0) {
        return;
    }
 
    if (size < 1024) {
        while (size--) {
            *(u8*)dst++ = value;
        }
    } else {
        count = (u32)dst & 0x3;
        if (count != 0) {
            count = 4 - count;
            size -= count;
            while (count--) {
                *(u8*)dst++ = value;
            }
        }
 
        count = size >> 2;
        intValue = (value << 8) + value;
        intValue = (intValue << 16) + intValue;
        while (count--) {
            *(u32*)dst = intValue;
            dst += 4;
        }
 
        count = size & 3;
        if (count != 0) {
            while (count--) {
                *(u8*)dst++ = value;
            }
        }
    }
}

Referenced by au_mseq_manager_init(), and au_mseq_play_sequence().

au_copy_bytes()

void au_copy_bytes	(	s8 *	src,
		s8 *	dest,
		s32	size )

Definition at line 1265 of file engine.c.

                                                {
    if (size > 0) {
        while (size-- != 0) {
            *dest++ = *src++;
        }
    }
}

au_copy_words()

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

Definition at line 1273 of file engine.c.

                                                   {
    size /= 4;
 
    if (size > 0) {
        if (!(((s32) src | (s32) dst) & 3)) {
            s32* srcIt = src;
            s32* dstIt = dst;
 
            size--;
            do {
                *dstIt++ = *srcIt++;
            } while (size-- != 0);
        }
    }
}

Referenced by au_bgm_process_suspend(), au_bgm_restore_copied_player(), au_load_PER(), and au_load_PRG().

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;
    }
}

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

arg0

)

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	effectID )

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	arg1,
		s16	arg2,
		s32	arg3 )

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

index

)

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	index,
		u8	reverbType,
		Instrument *	table,
		f32	pitch,
		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 *	table )

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	pitchRatio )

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	arg2,
		u8	arg3,
		u8	arg4 )

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	arg1,
		u8	arg2 )

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	arg1,
		s32	arg2 )

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	dryAmt )

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

arg0

)

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

arg0

)

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

arg0

)

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

arg0

)

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().

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().

au_flush_finished_voices()

void au_flush_finished_voices

(

AuGlobals *

globals

)

(UNUSED) Immediately flush all voices which have finished playing.

These are normally released automatically during the start of each audio frame.

Definition at line 4 of file voice.c.

                                                  {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(globals->voices); i++) {
        AuVoice* voice = &globals->voices[i];
 
        if (voice->donePending) {
            au_syn_stop_voice(i);
            voice->donePending = FALSE;
            voice->cmdPtr = NULL;
            voice->priority = AU_PRIORITY_FREE;
        }
    }
}

au_init_voices()

void au_init_voices

(

AuGlobals *

globals

)

Initializes all voices in the audio system.

Sets default values and clears previous envelope state.

Definition at line 19 of file voice.c.

                                        {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(globals->voices); i++) {
        AuVoice* voice = &globals->voices[i];
 
        voice->cmdPtr = NULL;
        voice->unused_20 = 0;
        voice->envDuration = 0;
        voice->envTimeLeft = 0;
        voice->envIntervalIndex = 0;
        voice->unused_3C = 0;
        voice->envelopeFlags = 0;
        voice->isRelativeRelease = FALSE;
        voice->envRelativeStart = ENV_VOL_MAX;
    }
}

Referenced by au_engine_init().

au_update_voices()

void au_update_voices

(

AuGlobals *

globals

)

Main envelope system update, called once per frame.

Progresses envelope state for all active voices.

Definition at line 37 of file voice.c.

                                          {
    AuVoice* voice;
    s16 current;
    s8 temp;
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(globals->voices); i++) {
        voice = &globals->voices[i];
 
        // skip inactive voices
        if (voice->cmdPtr == NULL) {
            continue;
        }
 
        if (voice->envelopeFlags & AU_VOICE_ENV_FLAG_HANDLED_VOL_CHANGE) {
            // client volume changed on previous frame
            au_voice_after_volume_change(voice);
            continue;
        }
 
        if (voice->envelopeFlags & AU_VOICE_ENV_FLAG_KEY_RELEASED) {
            // client released the key
            voice->envelopeFlags &= ~AU_VOICE_ENV_FLAG_KEY_RELEASED;
            voice->envelopeFlags |= AU_VOICE_ENV_FLAG_RELEASING;
            voice->cmdPtr = (u8*)voice->envelope.cmdListRelease;
 
            // the key can be released before the press envelope is complete
            if (voice->envTimeLeft > AU_FRAME_USEC) {
                // get interpolated "current" value
                voice->envInitial += (s32) (voice->envDelta * (f32) (voice->envDuration - voice->envTimeLeft));
            } else {
                voice->envInitial = voice->envTarget;
            }
 
            // read the first interval of the release envelope
            voice->envIntervalIndex = *voice->cmdPtr++;
            temp = *voice->cmdPtr;
            if (*(s8*)voice->cmdPtr++ < 0) {
                // in this case release volumes are relative to last press volume
                temp &= 0x7F;
                voice->isRelativeRelease = TRUE;
                voice->envRelativeStart = voice->envInitial;
            }
            voice->envTarget = temp;
            voice->envTimeLeft = AuEnvelopeIntervals[voice->envIntervalIndex];
            voice->envDuration = voice->envTimeLeft;
 
            if (voice->envelopeFlags & AU_VOICE_ENV_FLAG_VOL_CHANGED) {
                voice->envelopeFlags &= ~AU_VOICE_ENV_FLAG_VOL_CHANGED;
                if (voice->envTimeLeft > AU_FRAME_USEC) {
                    voice->envTimeLeft -= AU_FRAME_USEC;
                    voice->envelopeFlags |= AU_VOICE_ENV_FLAG_HANDLED_VOL_CHANGE;
                    current = voice->envInitial + (s32) (voice->envDelta * (voice->envDuration - voice->envTimeLeft));
                } else {
                    current = voice->envTarget;
                }
                voice->delta = AUDIO_SAMPLES;
            } else {
                voice->delta = au_voice_get_delta(voice->envDuration);
                current = voice->envTarget;
            }
            voice->volume = VOL_MULT_4(current, voice->clientVolume, voice->envRelativeStart, voice->envScale);
            voice->syncFlags |= AU_VOICE_SYNC_FLAG_PARAMS;
        } else {
            if (voice->envTimeLeft == -1) {
                // keep current volume, this is 'sustain' phase
                if (voice->envelopeFlags & AU_VOICE_ENV_FLAG_VOL_CHANGED) {
                    voice->envelopeFlags &= ~AU_VOICE_ENV_FLAG_VOL_CHANGED;
                    voice->volume = VOL_MULT_4(voice->envInitial, voice->clientVolume, voice->envRelativeStart, voice->envScale);
                    voice->syncFlags |= AU_VOICE_SYNC_FLAG_PARAMS;
                }
            } else {
                voice->envTimeLeft -= AU_FRAME_USEC;
                if (voice->envTimeLeft <= 0) {
                    if (*voice->cmdPtr == ENV_CMD_END) {
                        if (voice->envelopeFlags & AU_VOICE_ENV_FLAG_RELEASING) {
                            // if we reached the end after key release, stop the voice completely
                            voice->envelopeFlags = 0;
                            voice->cmdPtr = NULL;
                            voice->donePending = TRUE;
                        } else {
                            // we reached the end of press cmdlist, keep the last volume until the key is released
                            voice->envTimeLeft = -1;
                            voice->envDuration = -1;
                            voice->envIntervalIndex = ENV_TIME_300MS; // doesn't seem to affect anything
                            voice->delta = AUDIO_SAMPLES;
                            voice->envDelta = 0.0f;
                            voice->envInitial = voice->envTarget;
                        }
                    } else {
                        // get next envelope point
                        voice->envIntervalIndex = au_voice_step(voice);
                        voice->envInitial = voice->envTarget;
                        voice->envTarget = (*voice->cmdPtr++) & 0x7F;
                        voice->envTimeLeft = AuEnvelopeIntervals[voice->envIntervalIndex];
                        voice->envDuration = voice->envTimeLeft;
                        if (voice->envDuration != 0) {
                            voice->envDelta = ((f32) voice->envTarget - (f32) voice->envInitial) / (f32) voice->envDuration;
                        } else {
                            voice->envDelta = 0.0f;
                        }
                        if (voice->envelopeFlags & AU_VOICE_ENV_FLAG_VOL_CHANGED) {
                            voice->envelopeFlags &= ~AU_VOICE_ENV_FLAG_VOL_CHANGED;
                            if (voice->envTimeLeft > AU_FRAME_USEC) {
                                voice->envTimeLeft -= AU_FRAME_USEC;
                                voice->envelopeFlags |= AU_VOICE_ENV_FLAG_HANDLED_VOL_CHANGE;
                                current = voice->envInitial + (s32) (voice->envDelta * (voice->envDuration - voice->envTimeLeft));
                            } else {
                                current = voice->envTarget;
                            }
                            voice->delta = AUDIO_SAMPLES;
                        } else {
                            voice->delta = au_voice_get_delta(voice->envDuration);
                            current = voice->envTarget;
                        }
                        voice->volume = VOL_MULT_4(current, voice->clientVolume, voice->envRelativeStart, voice->envScale);
                        voice->syncFlags |= AU_VOICE_SYNC_FLAG_PARAMS;
                    }
                } else {
                    // we are between two envelope points, do nothing, just handle client volume change
                    if (voice->envelopeFlags & AU_VOICE_ENV_FLAG_VOL_CHANGED) {
                        voice->envelopeFlags &= ~AU_VOICE_ENV_FLAG_VOL_CHANGED;
                        if (voice->envTimeLeft > AU_FRAME_USEC) {
                            voice->envTimeLeft -= AU_FRAME_USEC;
                            voice->envelopeFlags |= AU_VOICE_ENV_FLAG_HANDLED_VOL_CHANGE;
                            current = voice->envInitial + (s32) (voice->envDelta * (voice->envDuration - voice->envTimeLeft));
                        } else {
                            current = voice->envTarget;
                        }
                        voice->delta = AUDIO_SAMPLES;
                        voice->volume = VOL_MULT_4(current, voice->clientVolume, voice->envRelativeStart, voice->envScale);
                        voice->syncFlags |= AU_VOICE_SYNC_FLAG_PARAMS;
                    }
                }
            }
        }
    }
}

Referenced by au_update_clients_for_audio_frame().

au_voice_after_volume_change()

void au_voice_after_volume_change

(

AuVoice *

voice

)

Applies volume update after a client-side volume change.

This is deferred to avoid modifying envelope state mid-step.

Definition at line 176 of file voice.c.

                                                  {
    voice->volume = VOL_MULT_4(voice->envTarget, voice->clientVolume, voice->envRelativeStart, voice->envScale);
    voice->delta = au_voice_get_delta(voice->envTimeLeft);
    voice->envelopeFlags &= ~AU_VOICE_ENV_FLAG_HANDLED_VOL_CHANGE;
    voice->syncFlags |= AU_VOICE_SYNC_FLAG_PARAMS;
}

Referenced by au_update_voices().

au_voice_get_delta()

s32 au_voice_get_delta

(

s32

usecs

)

Converts envelope step duration from microseconds to num samples delta.

Uses AU_FRAME_USEC as the base time slice, returning the number of audio samples corresponding to the provided duration.

Parameters

msecs

Time duration in microseconds.

Returns

Number of samples that should pass in this interval.

Definition at line 183 of file voice.c.

                                  {
    return (usecs / AU_FRAME_USEC) * AUDIO_SAMPLES;
}

Referenced by au_update_voices(), au_voice_after_volume_change(), and au_voice_start().

au_voice_start()

void au_voice_start	(	AuVoice *	voice,
		EnvelopeData *	envData )

Starts a new voice with the given envelope data.

Initializes envelope state and prepares the press phase for playback.

Parameters

voice	Pointer to the voice being started.
envData	Envelope command lists (press and release) to use.

Definition at line 187 of file voice.c.

                                                           {
    s32 intervalIndex;
 
    voice->envelope.cmdListPress = envData->cmdListPress;
    voice->cmdPtr = voice->envelope.cmdListPress;
    voice->envelope.cmdListRelease = envData->cmdListRelease;
    voice->envScale = ENV_VOL_MAX;
    voice->loopStart = NULL;
 
    intervalIndex = au_voice_step(voice);
    voice->envelopeFlags = 0;
    voice->envInitial = 0;
    voice->envTarget = *voice->cmdPtr++;
    voice->envIntervalIndex = intervalIndex;
    voice->envDuration = AuEnvelopeIntervals[intervalIndex];
    voice->envTimeLeft = voice->envDuration;
 
    voice->volume = VOL_MULT_3(voice->envTarget, voice->clientVolume, voice->envScale);
    voice->delta = au_voice_get_delta(voice->envDuration);
    if (voice->envDuration != 0) {
        voice->envDelta = ((f32) voice->envTarget - (f32) voice->envInitial) / voice->envDuration;
    } else {
        voice->envDelta = 0.0f;
    }
    voice->isRelativeRelease = FALSE;
    voice->envRelativeStart = ENV_VOL_MAX;
}

Referenced by au_syn_begin_audio_frame().

au_voice_step()

u8 au_voice_step

(

AuVoice *

voice

)

Parses and executes envelope commands until a time interval is found.

Commands include setting multipliers, loop control, etc.

Definition at line 215 of file voice.c.

                                 {
    u32 op;
    u8 arg;
 
    while (TRUE) {
        if ((s8)(op = *voice->cmdPtr++) >= 0) {
            break;
        }
        switch ((u8)op) {
            case ENV_CMD_SET_SCALE:
                arg = *voice->cmdPtr++;
                if (arg > ENV_VOL_MAX) {
                    arg = ENV_VOL_MAX;
                }
                voice->envScale = arg;
                break;
            case ENV_CMD_ADD_SCALE:
                voice->envScale += (s8) *voice->cmdPtr++;
                if (voice->envScale > ENV_VOL_MAX) {
                    voice->envScale = ENV_VOL_MAX;
                } else if (voice->envScale < 0) {
                    voice->envScale = 0;
                }
                break;
            case ENV_CMD_START_LOOP:
                voice->loopCounter = *voice->cmdPtr++; // 0 = infinite loop
                voice->loopStart = voice->cmdPtr;
                break;
            case ENV_CMD_END_LOOP:
                voice->cmdPtr++;
                if (voice->loopCounter == 0 || --voice->loopCounter != 0) {
                    voice->cmdPtr = voice->loopStart;
                }
                break;
            default:
                // unknown command, skip argument
                voice->cmdPtr++;
                break;
        }
    }
    return op;
}

Referenced by au_update_voices(), and au_voice_start().

au_voice_set_vol_changed()

void au_voice_set_vol_changed

(

AuVoice *

voice

)

(UNUSED) Force recalculation of voice envelope volume during next update.

Definition at line 258 of file voice.c.

                                              {
    voice->envelopeFlags |= AU_VOICE_ENV_FLAG_VOL_CHANGED;
}

au_pull_voice()

Acmd * au_pull_voice	(	AuPVoice *	pvoice,
		Acmd *	cmdBufPos )

Definition at line 33 of file pull_voice.c.

                                                       {
    Acmd* ptr = cmdBufPos;
    AuLoadFilter* decoder;
    AuResampler* resampler;
    AuEnvMixer* envMixer;
    s16 inp;
    f32 finCount;
    s16 outp;
    s32 startZero;
    s32 outCount;
    s32 incr;
 
    envMixer = &pvoice->envMixer;
    resampler = &pvoice->resampler;
    decoder = &pvoice->decoder;
 
    // return if voice is not playing
    if (envMixer->motion != AL_PLAYING) {
        return ptr;
    }
 
    // buffer to store decoded (or raw) samples before mixing
    outp = N_AL_DECODER_OUT;
 
    if (resampler->ratio > MAX_RATIO) {
        resampler->ratio = MAX_RATIO;
    }
 
    // convert pitch ratio to fixed-point resampling increment
    resampler->ratio = (s32)(resampler->ratio * UNITY_PITCH);
    resampler->ratio = resampler->ratio / UNITY_PITCH;
 
    // determine how many output samples are needed for this frame
    finCount = resampler->delta + resampler->ratio * (f32)AUDIO_SAMPLES;
    outCount = (s32) finCount;
    resampler->delta = finCount - (f32) outCount;
 
    if (outCount != 0) {
        if (decoder->instrument->type == AL_ADPCM_WAVE) {
            s32 nSam;
            s32 nbytes;
            s32 nframes;
            s32 op;
            s32 tsam;
            s32 nLeft;
            s32 bEnd;
            s32 nOver;
            s32 overFlow;
            s32 decoded = FALSE;
            s32 looped = FALSE;
            inp = N_AL_DECODER_IN;
 
            // load ADPCM predictor
            aLoadADPCM(ptr++, decoder->bookSize, K0_TO_PHYS(decoder->instrument->predictor));
 
            // will loop be triggered during this frame? if so, only process up to loop end
            looped = (decoder->loop.end < outCount + decoder->sample) && (decoder->loop.count != 0);
 
            if (looped) {
                nSam = decoder->loop.end - decoder->sample;
            } else {
                nSam = outCount;
            }
 
            if (decoder->lastsam != 0) {
                nLeft = ADPCMFSIZE - decoder->lastsam;
            } else {
                nLeft = 0;
            }
 
            tsam = nSam - nLeft;
            if (tsam < 0) {
                tsam = 0;
            }
 
            nframes = (tsam + ADPCMFSIZE - 1) >> LFSAMPLES;
            nbytes = nframes * ADPCMFBYTES;
 
            if (looped) {
                ptr = _decodeChunk(ptr, decoder, tsam, nbytes, outp, inp, decoder->first);
                if (decoder->lastsam != 0) {
                    outp += (decoder->lastsam << 1);
                } else {
                    outp += (ADPCMFSIZE << 1);
                }
 
                decoder->lastsam = decoder->loop.start & 0xF;
                decoder->memin = (s32)decoder->instrument->wavData + ADPCMFBYTES * ((s32)(decoder->loop.start >> LFSAMPLES) + 1);
                decoder->sample = decoder->loop.start;
 
                // continue decoding looped portion if needed
                bEnd = outp;
                while (outCount > nSam) {
                    outCount -= nSam;
                    op = (bEnd + ((nframes + 1) << (LFSAMPLES + 1)) + 16) & ~0x1F;
                    bEnd += nSam << 1;
                    if (decoder->loop.count != -1 && decoder->loop.count != 0) {
                        decoder->loop.count--;
                    }
                    nSam = MIN(outCount, decoder->loop.end - decoder->loop.start);
                    tsam = nSam - ADPCMFSIZE + decoder->lastsam;
                    if (tsam < 0) {
                        tsam = 0;
                    }
                    nframes = (tsam + ADPCMFSIZE - 1) >> LFSAMPLES;
                    nbytes = nframes * ADPCMFBYTES;
                    ptr = _decodeChunk(ptr, decoder, tsam, nbytes, op, inp, decoder->first | A_LOOP);
                    aDMEMMove(ptr++, op + (decoder->lastsam << 1), bEnd, nSam << 1);
                }
                decoder->lastsam = (outCount + decoder->lastsam) & 0xF;
                decoder->sample += outCount;
                decoder->memin += ADPCMFBYTES * nframes;
            } else {
                nSam = nframes << LFSAMPLES;
                overFlow = decoder->memin + nbytes - ((s32)decoder->instrument->wavData + decoder->instrument->wavDataLength);
 
                if (overFlow <= 0) {
                    overFlow = 0;
                } else {
                    envMixer->motion = AL_STOPPED;
                }
                nOver = (overFlow / ADPCMFBYTES) << LFSAMPLES;
                if (nOver > nSam + nLeft) {
                    nOver = nSam + nLeft;
                }
                nbytes -= overFlow;
                if (nOver - (nOver & 0xF) < outCount) {
                    decoded = TRUE;
                    ptr = _decodeChunk(ptr, decoder, nSam - nOver, nbytes, outp, inp, decoder->first);
                    if (decoder->lastsam != 0) {
                        outp += decoder->lastsam << 1;
                    } else {
                        outp += ADPCMFSIZE << 1;
                    }
                    decoder->lastsam = (outCount + decoder->lastsam) & 0xF;
                    decoder->sample += outCount;
                    decoder->memin += ADPCMFBYTES * nframes;
                } else {
                    decoder->lastsam = 0;
                    decoder->memin += ADPCMFBYTES * nframes;
                }
 
                if (nOver != 0) {
                    decoder->lastsam = 0;
                    if (decoded) {
                        startZero = (nLeft + nSam - nOver) << 1;
                    } else {
                        startZero = 0;
                    }
                    aClearBuffer(ptr++, startZero + outp, nOver << 1);
                }
            }
        } else {
            s32 nSam;
            s32 nbytes;
            s32 op;
            s32 dramAlign;
            s32 dramLoc;
            s32 dmemAlign;
            s32 overFlow;
            if (decoder->loop.end < outCount + decoder->sample && decoder->loop.count != 0) {
                nSam = decoder->loop.end - decoder->sample;
                nbytes = nSam << 1;
                if (nSam > 0) {
                    dramLoc = decoder->dmaFunc(decoder->memin, nbytes, decoder->dmaState, decoder->instrument->useDma);
                    dramAlign = dramLoc & 7;
                    nbytes += dramAlign;
                    n_aLoadBuffer(ptr++, nbytes + 8 - (nbytes & 7), outp, dramLoc - dramAlign);
                } else {
                    dramAlign = 0;
                }
                outp += dramAlign;
                decoder->memin = (s32)decoder->instrument->wavData + (decoder->loop.start << 1);
                decoder->sample = decoder->loop.start;
                op = outp;
                while (outCount > nSam){
                    op += nSam << 1;
                    outCount -= nSam;
                    if (decoder->loop.count != -1 && decoder->loop.count != 0) {
                        decoder->loop.count--;
                    }
                    nSam = MIN(outCount, decoder->loop.end - decoder->loop.start);
                    nbytes = nSam << 1;
                    dramLoc = decoder->dmaFunc(decoder->memin, nbytes, decoder->dmaState, decoder->instrument->useDma);
                    dramAlign = dramLoc & 7;
                    nbytes += dramAlign;
                    if ((op & 7) != 0) {
                        dmemAlign = 8 - (op & 7);
                    } else {
                        dmemAlign = 0;
                    }
                    n_aLoadBuffer(ptr++, nbytes + 8 - (nbytes & 7), op + dmemAlign, dramLoc - dramAlign);
 
                    if (dramAlign != 0 || dmemAlign != 0) {
                        aDMEMMove(ptr++, op + dramAlign + dmemAlign, op, nSam * 2);
                    }
                }
                decoder->sample += outCount;
                decoder->memin += outCount << 1;
            } else {
                nbytes = outCount << 1;
                overFlow = decoder->memin + nbytes - ((s32)decoder->instrument->wavData + decoder->instrument->wavDataLength);
                if (overFlow <= 0) {
                    overFlow = 0;
                } else {
                    envMixer->motion = AL_STOPPED;
                }
                if (nbytes < overFlow) {
                    overFlow = nbytes;
                }
                if (overFlow < nbytes) {
                    if (outCount > 0) {
                        nbytes -= overFlow;
                        dramLoc = decoder->dmaFunc(decoder->memin, nbytes, decoder->dmaState, decoder->instrument->useDma);
                        dramAlign = dramLoc & 7;
                        nbytes += dramAlign;
                        n_aLoadBuffer(ptr++, nbytes + 8 - (nbytes & 7), outp, dramLoc - dramAlign);
                    } else {
                        dramAlign = 0;
                    }
                    outp += dramAlign;
                    decoder->sample += outCount;
                    decoder->memin += outCount << 1;
                } else {
                    decoder->memin += outCount << 1;
                }
 
                if (overFlow != 0) {
                    startZero = (outCount << 1) - overFlow;
                    if (startZero < 0) {
                        startZero = 0;
                    }
                    aClearBuffer(ptr++, startZero + outp, overFlow);
                }
            }
        }
    }
 
    // resample audio from source buffer to output buffer
    incr = (s32)(resampler->ratio * UNITY_PITCH);
    n_aResample(ptr++, osVirtualToPhysical(resampler->state), resampler->first, incr, outp, 0);
    resampler->first = FALSE;
 
    // set up envelope mixing
    if (envMixer->dirty) {
        envMixer->dirty = FALSE;
        if (!AuSynUseStereo) {
            envMixer->ltgt = (envMixer->volume * AuEqPower[AUEQPOWER_LENGTH / 2]) >> 15;
            envMixer->rtgt = (envMixer->volume * AuEqPower[AUEQPOWER_LENGTH / 2]) >> 15;
        } else {
            envMixer->ltgt = (envMixer->volume * AuEqPower[envMixer->pan]) >> 15;
            envMixer->rtgt = (envMixer->volume * AuEqPower[AUEQPOWER_LENGTH - envMixer->pan - 1]) >> 15;
        }
        envMixer->lratm = _getRate(envMixer->cvolL, envMixer->ltgt, envMixer->segEnd, &envMixer->lratl);
        envMixer->rratm = _getRate(envMixer->cvolR, envMixer->rtgt, envMixer->segEnd, &envMixer->rratl);
        n_aSetVolume(ptr++, A_RATE, envMixer->ltgt, envMixer->lratm, envMixer->lratl);
        n_aSetVolume(ptr++, A_VOL | A_LEFT, envMixer->cvolL, envMixer->dryamt, envMixer->wetamt);
        n_aSetVolume(ptr++, A_VOL | A_RIGHT, envMixer->rtgt, envMixer->rratm, envMixer->rratl);
        n_aEnvMixer(ptr++, A_INIT, envMixer->cvolR, osVirtualToPhysical(envMixer->state));
    } else {
        n_aEnvMixer(ptr++, A_CONTINUE, 0, osVirtualToPhysical(envMixer->state));
    }
 
    // advance envelope segment
    envMixer->delta += AUDIO_SAMPLES;
    if (envMixer->segEnd < envMixer->delta) {
        envMixer->delta = envMixer->segEnd;
    }
 
    // if stopped, reset state
    if (envMixer->motion == AL_STOPPED) {
        envMixer->dirty = TRUE;
        envMixer->volume = 1;
        resampler->delta = 0.0f;
        resampler->first = TRUE;
        decoder->lastsam = 0;
        decoder->first = 1;
        decoder->sample = 0;
        decoder->memin = (s32) decoder->instrument->wavData;
        decoder->loop.count = decoder->instrument->loopCount;
        au_release_voice(pvoice->index);
    }
    return ptr;
}

Referenced by alAudioFrame().

au_fx_create()

void au_fx_create	(	AuFX *	fx,
		u8	effectType,
		ALHeap *	heap )

Parameters

effectType

from enum AuEffectType

Definition at line 138 of file reverb.c.

                                                         {
    AuDelay* delay;
    u16 i;
 
    // allocate space for 4 AuDelay
    fx->delays = alHeapAlloc(heap, AU_FX_MAX_TAPS, sizeof(AuDelay));
    fx->base = alHeapAlloc(heap, AU_FX_LENGTH, sizeof(s16));
 
    for (i = 0; i < AU_FX_MAX_TAPS; i++) {
        delay = &fx->delays[i];
        delay->resamplerTemplate = alHeapAlloc(heap, 1, sizeof(AuResampler));
        delay->resamplerTemplate->state = alHeapAlloc(heap, 1, sizeof(RESAMPLE_STATE));
        delay->lowpassTemplate = alHeapAlloc(heap, 1, sizeof(AuLowPass));
        delay->lowpassTemplate->fstate = alHeapAlloc(heap, 1, sizeof(POLEF_STATE));
    }
 
    au_fx_load_preset(fx, effectType);
}

Referenced by au_driver_init().

au_filter_create()

void au_filter_create	(	AuFilter *	filter,
		ALHeap *	heap )

Definition at line 158 of file reverb.c.

                                                      {
    filter->base = alHeapAlloc(heap, AU_FILTER_LENGTH, sizeof(s16));
    filter->lowpassTemplate = alHeapAlloc(heap, 1, sizeof(AuLowPass));
    filter->lowpassTemplate->fstate = alHeapAlloc(heap, 1, sizeof(POLEF_STATE));
    au_filter_init(filter, 0, 0, 0x5000);
}

au_filter_init()

void au_filter_init	(	AuFilter *	filter,
		s16	arg1,
		s16	arg2,
		s16	fc )

Definition at line 166 of file reverb.c.

                                                                      {
    filter->unused_06 = arg1;
    filter->unused_08 = arg2;
 
    if (cutoff != 0) {
        filter->activeLowpass = filter->lowpassTemplate;
        filter->activeLowpass->fc = cutoff;
        _init_lpfilter(filter->activeLowpass);
        return;
    }
 
    filter->activeLowpass = NULL;
}

Referenced by au_filter_create().

au_fx_load_preset()

void au_fx_load_preset	(	AuFX *	fx,
		u8	effectType )

Definition at line 181 of file reverb.c.

                                                {
    s32* params;
    s32* clr;
    s32 i, j;
    clr = (s32*)fx->base;
 
    switch (effectType) {
        case AU_FX_SMALLROOM:
            params = SMALL_ROOM_PARAMS;
            break;
        case AU_FX_BIGROOM:
            params = BIG_ROOM_PARAMS;
            break;
        case AU_FX_ECHO:
            params = ECHO_PARAMS;
            break;
        case AU_FX_CHORUS:
            params = CHORUS_PARAMS;
            break;
        case AU_FX_FLANGE:
            params = FLANGE_PARAMS;
            break;
        case AU_FX_CUSTOM_0:
            params = AU_FX_CUSTOM_PARAMS[0];
            break;
        case AU_FX_CUSTOM_1:
            params = AU_FX_CUSTOM_PARAMS[1];
            break;
        case AU_FX_CUSTOM_2:
            params = AU_FX_CUSTOM_PARAMS[2];
            break;
        case AU_FX_CUSTOM_3:
            params = AU_FX_CUSTOM_PARAMS[3];
            break;
        case AU_FX_OTHER_BIGROOM:
            params = BIG_ROOM_PARAMS;
            break;
        default:
            params = NULL_PARAMS;
            break;
    }
 
    j = 0;
    fx->delayCount = params[j++];
    fx->length = params[j++] * AUDIO_SAMPLES;
    fx->input = fx->base;
 
    for (i = 0; i < AU_FX_LENGTH/2; i++) {
        *clr++ = 0;
    }
 
    for (i = 0; i < fx->delayCount; i++) {
        AuDelay* delay = &fx->delays[i];
        delay->input  = params[j++] * AUDIO_SAMPLES;
        delay->output = params[j++] * AUDIO_SAMPLES;
        delay->fbcoef = (u16) params[j++];
        delay->ffcoef = (u16) params[j++];
        delay->gain   = (u16) params[j++];
 
        if (params[j]) {
            delay->rsinc = (2.0 * (params[j++] / 1000.0f)) / gActiveSynDriverPtr->outputRate;
            delay->rsgain = ((f32)params[j++] / CONVERT) * (delay->output - delay->input);
            delay->rsval = 1.0f;
            delay->rsdelta = 0.0f;
            delay->activeResampler = delay->resamplerTemplate;
            delay->resamplerTemplate->delta = 0.0;
            delay->activeResampler->first = TRUE;
        } else {
            delay->activeResampler = NULL;
            j++;
            j++;
        }
 
        if (params[j]) {
            delay->activeLowpass = delay->lowpassTemplate;
            delay->activeLowpass->fc = params[j++];
            _init_lpfilter(delay->activeLowpass);
        } else {
            delay->activeLowpass = NULL;
            j++;
        }
    }
}

Referenced by au_bus_set_effect(), and au_fx_create().

au_pull_fx()

Acmd * au_pull_fx	(	AuFX *	fx,
		Acmd *	ptr,
		s16	wetDmem,
		s16	tempDmem )

Applies a chain of delay-line based effects to audio and mixes into output.

For each delay tap in the FX chain:

• Loads delay input/output from circular buffer.
• Applies optional modulation and resampling.
• Applies feedforward/feedback mixing.
• Applies optional lowpass filtering.
• Mixes result into wet output buffer.

Parameters

fx	Pointer to FX state (delay taps, buffers, etc.)
ptr	Pointer to the current audio command list position.
wetDmem	DMEM offset to mix wet output into.
tempDmem	Base DMEM offset for temporary working buffers.

Returns

Updated command list pointer.

Definition at line 281 of file reverb.c.

                                                                 {
    Acmd* cmdBufPos = ptr;
    s16 delayIdx;
 
    s16* inPtr;
    s16* outPtr;
 
    // DMEM temp buffer layout:
    s16 inputTapBuffer  = tempDmem;
    s16 outputTapBuffer = tempDmem + 2 * AUDIO_SAMPLES;
    s16 resampleBuffer  = tempDmem + 4 * AUDIO_SAMPLES;
 
    s16* prevOutPtr = 0;
    s16 outDmem = wetDmem;
 
    // save wet input from voice mixing into circular delay buffer
    n_aSaveBuffer(cmdBufPos++, 2 * AUDIO_SAMPLES, wetDmem, osVirtualToPhysical(fx->input));
 
    // clear the wet output buffer for this frame
    aClearBuffer(cmdBufPos++, wetDmem, 2 * AUDIO_SAMPLES);
 
    for (delayIdx = 0; delayIdx < fx->delayCount; delayIdx++) {
        AuDelay* delay = &fx->delays[delayIdx];
        f32 fUnityPitch = UNITY_PITCH;
 
        // calculate read positions for input and output taps, wrapping the circular buffer if necessary
        inPtr = &fx->input[-delay->input];
        if (inPtr < fx->base) {
            inPtr += fx->length;
        }
        outPtr = &fx->input[-delay->output];
        if (outPtr < fx->base) {
            outPtr += fx->length;
        }
 
        // if output is same as previous tap, reuse loaded data by swapping buffers
        if (inPtr == prevOutPtr) {
            SWAP16(inputTapBuffer, outputTapBuffer);
        } else {
            // load from input tap into buffer
            n_aLoadBuffer(cmdBufPos++, 2 * AUDIO_SAMPLES, inputTapBuffer, osVirtualToPhysical(inPtr));
        }
 
        if (delay->activeResampler) {
            // triangle wave modulation for chorus/flange
            s32 ratio;
            s32 length, count;
            f32 delta, fratio, fincount;
            s32 ramAlign;
            s16 tmp;
            s16* rsOutPtr;
 
            // modulate delay time (triangle wave)
            length = delay->output - delay->input;
            delta = updateTriangleModulation(delay, AUDIO_SAMPLES);
            delta /= length;
            delta = (s32)(delta * fUnityPitch);
            delta = delta / UNITY_PITCH;
 
            fratio = 1.0 - delta;
 
            // calculate fractional resampling count
            fincount = delay->activeResampler->delta + (fratio * AUDIO_SAMPLES);
            count = (s32) fincount;
            delay->activeResampler->delta = fincount - count;
 
            // prepare delay line for resampling (wrap if needed)
            rsOutPtr = &fx->input[-(delay->output - delay->rsdelta)];
            ramAlign = ((s32) rsOutPtr & 7) >> 1;
            rsOutPtr -= ramAlign;
            if (rsOutPtr < fx->base) {
                rsOutPtr += fx->length;
            }
 
            // load from delay line
            cmdBufPos = _loadDelayLineBuffer(fx, rsOutPtr, resampleBuffer, count + ramAlign, cmdBufPos);
 
            // process resampler
            ratio = fratio * fUnityPitch;
            tmp = outputTapBuffer >> 8;
            n_aResample(cmdBufPos++, osVirtualToPhysical(delay->activeResampler->state),
                delay->activeResampler->first, ratio, resampleBuffer + (ramAlign<<1), tmp);
            delay->activeResampler->first = FALSE;
            delay->rsdelta += count - AUDIO_SAMPLES;
        } else {
            // no resampling -- just load from output pointer
            n_aLoadBuffer(cmdBufPos++, 2 * AUDIO_SAMPLES, outputTapBuffer, osVirtualToPhysical(outPtr));
        }
 
        // feedforward: input -> output
        if (delay->ffcoef) {
            aMix(cmdBufPos++, 0, (u16)delay->ffcoef, inputTapBuffer, outputTapBuffer);
 
            // save output if no additional processing needed
            if (delay->activeResampler == NULL && delay->activeLowpass == NULL) {
                n_aSaveBuffer(cmdBufPos++, 2 * AUDIO_SAMPLES, outputTapBuffer, osVirtualToPhysical(outPtr));
            }
        }
 
        // feedback: output -> input
        if (delay->fbcoef) {
            aMix(cmdBufPos++, 0, (u16)delay->fbcoef, outputTapBuffer, inputTapBuffer);
            n_aSaveBuffer(cmdBufPos++, 2 * AUDIO_SAMPLES, inputTapBuffer, osVirtualToPhysical(inPtr));
        }
 
        // Save processed output back into delay line (if not resampled)
        if (delay->activeLowpass != NULL) {
            // modified _n_filterBuffer
            s16 alignedBuffer = outputTapBuffer >> 8;
            n_aLoadADPCM(cmdBufPos++, 32, osVirtualToPhysical(delay->activeLowpass->fccoef));
            n_aPoleFilter(cmdBufPos++, delay->activeLowpass->first, delay->activeLowpass->fgain, alignedBuffer, osVirtualToPhysical(delay->activeLowpass->fstate));
            delay->activeLowpass->first = 0;
        }
 
        // save output (if not already saved earlier)
        if (!delay->activeResampler) {
            n_aSaveBuffer(cmdBufPos++, 2 * AUDIO_SAMPLES, outputTapBuffer, osVirtualToPhysical(outPtr));
        }
 
        // mix input from this delay into wet output buffer
        if (delay->gain) {
            aMix(cmdBufPos++, 0, (u16)delay->gain, outputTapBuffer, outDmem);
        }
        prevOutPtr = &fx->input[delay->output];
    }
 
    // advance position in ring buffer
    fx->input += AUDIO_SAMPLES;
    if (fx->input >= &fx->base[fx->length]) {
        fx->input = fx->base;
    }
 
    return cmdBufPos;
}

Referenced by alAudioFrame().

au_fx_param_hdl()

s32 au_fx_param_hdl	(	AuFX *	fx,
		s16	index,
		s16	paramID,
		s32	value )

Definition at line 416 of file reverb.c.

                                                                 {
    switch (paramID) {
    case INPUT_PARAM:
        fx->delays[index].input = value & 0xFFFFFFF8;
        break;
    case OUTPUT_PARAM:
        fx->delays[index].output = value & 0xFFFFFFF8;
        break;
    case FFCOEF_PARAM:
        fx->delays[index].ffcoef = value;
        break;
    case FBCOEF_PARAM:
        fx->delays[index].fbcoef = value;
        break;
    case GAIN_PARAM:
        fx->delays[index].gain = value;
        break;
    case CHORUSRATE_PARAM:
        fx->delays[index].rsinc = (2.0 * (value / 1000.0f)) / gActiveSynDriverPtr->outputRate;
        break;
    case CHORUSDEPTH_PARAM:
        fx->delays[index].rsgain = ((f32)value / CONVERT) * (fx->delays[index].output - fx->delays[index].input);
        break;
    case LPFILT_PARAM:
        if (fx->delays[index].activeLowpass) {
            fx->delays[index].activeLowpass->fc = value;
            _init_lpfilter(fx->delays[index].activeLowpass);
        }
        break;
    }
    return 0;
}

Referenced by au_bus_set_fx_params().