2e230_len_2190.c File Reference

Go to the source code of this file.

Macros
#define	TUNE_SCALING_ARR_AMPLIFY_FINE   0
#define	TUNE_SCALING_ARR_AMPLIFY_COARSE   128
#define	TUNE_SCALING_ARR_ATTENUATE_FINE   160
#define	TUNE_SCALING_ARR_ATTENUATE_COARSE   288
#define	SBN_LOOKUP(i, fmt, e)   (au_fetch_SBN_file(globals->mseqFileList[AmbientSoundIDtoMSEQFileIndex[i]], fmt, &e))
#define	AL_HEADER_SIG_BK   0x424B
#define	AL_HEADER_SIG_CR   0x4352
#define	AL_HEADER_SIG_DR   0x4452
#define	AL_HEADER_SIG_SR   0x5352

Enumerations
enum	BKParseState {   BK_READ_DONE = 0 , BK_READ_FETCH_HEADER = 11 , BK_READ_FETCH_DATA = 21 , BK_READ_SWIZZLE = 31 ,   BK_READ_PROCESS_CR = 101 , BK_READ_SWIZZLE_CR = 111 , BK_READ_PROCESS_DR = 201 , BK_READ_UNK_DR = 211 ,   BK_READ_PROCESS_SR = 301 , BK_READ_UNK_SR = 311 }

Functions
void	func_80052E30 (u8 index)
void	au_engine_init (s32 outputRate)
void	au_update_clients_2 (void)
void	au_update_players_main (void)
void	au_syn_update (AuGlobals *globals)
void	au_reset_nonfree_voice (AuVoice *voice, u8 index)
void	au_reset_voice (AuVoice *voice, u8 voiceIdx)
f32	au_compute_pitch_ratio (s32 pitch)
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 busId, u16 volume, s32 busVolume)
void	func_80053AC8 (Fade *fade)
void	au_fade_set_vol_scale (Fade *fade, s16 value)
void	func_80053B04 (Fade *fade, u32 arg1, s32 target)
void	func_80053BA8 (Fade *fade)
Instrument *	au_get_instrument (AuGlobals *globals, u32 bank, u32 patch, EnvelopeData *envData)
void	au_get_bgm_player_and_file (u32 playerIndex, BGMHeader **outFile, BGMPlayer **outPlayer)
void	au_get_bgm_player (u32 playerIndex, BGMPlayer **outPlayer)
AuResult	au_load_song_files (u32 songID, BGMHeader *bgmFile, BGMPlayer *player)
AuResult	func_80053E58 (s32 songID, BGMHeader *bgmFile)
BGMPlayer *	func_80053F64 (s32 arg0)
AuResult	au_ambient_load (u32 ambSoundID)
BGMPlayer *	func_80054248 (u8 arg0)
void	au_load_INIT (AuGlobals *arg0, s32 romAddr, ALHeap *heap)
AuResult	au_fetch_SBN_file (u32 fileIdx, AuFileFormat format, SBNFileEntry *outEntry)
void	au_load_PER (AuGlobals *globals, s32 romAddr)
void	au_load_PRG (AuGlobals *arg0, s32 romAddr)
s32	snd_load_BGM (s32 arg0)
InstrumentGroup *	au_get_BK_instruments (s32 bankGroup, u32 bankIndex)
SoundBank *	au_load_BK_to_bank (s32 bkFileOffset, SoundBank *bank, s32 bankIndex, s32 bankGroup)
void	au_swizzle_BK_instruments (s32 bkFileOffset, SoundBank *bank, InstrumentGroup instruments, u32 instrumentCount, u8 arg4)
s32 *	func_80054AA0 (s32 *bkFileOffset, void *vaddr, s32 bankIndex, s32 bankGroup)
s32	snd_load_BK (s32 bkFileOffset, s32 bankIndex)
void	func_80054C84 (s32 bankIndex, s32 bankGroup)
void	func_80054CE0 (s32 arg0, u32 idx)
s32	func_80054D74 (s32 arg0, s32 arg1)
void	func_80054DA8 (u32 bMonoSound)
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)

Variables
AuCallback	BeginSoundUpdateCallback
BGMPlayer *	gBGMPlayerA
BGMPlayer *	gBGMPlayerB
BGMPlayer *	gBGMPlayerC
SoundManager *	gSoundManager
AuGlobals *	gSoundGlobals
AmbienceManager *	gAuAmbienceManager
u16	D_80078530 [9]
u8	EnvelopePressDefault []
u8	EnvelopeReleaseDefault []
f32	AlTuneScaling []

Macro Definition Documentation

TUNE_SCALING_ARR_AMPLIFY_FINE

#define TUNE_SCALING_ARR_AMPLIFY_FINE   0

Definition at line 376 of file 2e230_len_2190.c.

Referenced by au_compute_pitch_ratio().

TUNE_SCALING_ARR_AMPLIFY_COARSE

#define TUNE_SCALING_ARR_AMPLIFY_COARSE   128

Definition at line 377 of file 2e230_len_2190.c.

Referenced by au_compute_pitch_ratio().

TUNE_SCALING_ARR_ATTENUATE_FINE

#define TUNE_SCALING_ARR_ATTENUATE_FINE   160

Definition at line 378 of file 2e230_len_2190.c.

Referenced by au_compute_pitch_ratio().

TUNE_SCALING_ARR_ATTENUATE_COARSE

#define TUNE_SCALING_ARR_ATTENUATE_COARSE   288

Definition at line 379 of file 2e230_len_2190.c.

Referenced by au_compute_pitch_ratio().

SBN_LOOKUP

#define SBN_LOOKUP	(		i,
			fmt,
			e )   (au_fetch_SBN_file(globals->mseqFileList[AmbientSoundIDtoMSEQFileIndex[i]], fmt, &e))

Definition at line 636 of file 2e230_len_2190.c.

Referenced by au_ambient_load().

AL_HEADER_SIG_BK

#define AL_HEADER_SIG_BK   0x424B

Definition at line 906 of file 2e230_len_2190.c.

Referenced by au_load_BK_to_bank(), and func_80054AA0().

AL_HEADER_SIG_CR

#define AL_HEADER_SIG_CR   0x4352

Definition at line 907 of file 2e230_len_2190.c.

Referenced by au_load_BK_to_bank(), and func_80054AA0().

AL_HEADER_SIG_DR

#define AL_HEADER_SIG_DR   0x4452

Definition at line 908 of file 2e230_len_2190.c.

Referenced by au_load_BK_to_bank().

AL_HEADER_SIG_SR

#define AL_HEADER_SIG_SR   0x5352

Definition at line 909 of file 2e230_len_2190.c.

Referenced by au_load_BK_to_bank().

Enumeration Type Documentation

BKParseState

enum BKParseState

Enumerator
BK_READ_DONE
BK_READ_FETCH_HEADER
BK_READ_FETCH_DATA
BK_READ_SWIZZLE
BK_READ_PROCESS_CR
BK_READ_SWIZZLE_CR
BK_READ_PROCESS_DR
BK_READ_UNK_DR
BK_READ_PROCESS_SR
BK_READ_UNK_SR

Definition at line 893 of file 2e230_len_2190.c.

                  {
    BK_READ_DONE          = 0,
    BK_READ_FETCH_HEADER  = 11,
    BK_READ_FETCH_DATA    = 21,
    BK_READ_SWIZZLE       = 31,
    BK_READ_PROCESS_CR    = 101,
    BK_READ_SWIZZLE_CR    = 111,
    BK_READ_PROCESS_DR    = 201,
    BK_READ_UNK_DR        = 211,
    BK_READ_PROCESS_SR    = 301,
    BK_READ_UNK_SR        = 311,
};

Function Documentation

func_80052E30()

void func_80052E30

(

u8

index

)

Definition at line 18 of file 2e230_len_2190.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 25 of file 2e230_len_2190.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->unk_globals_6C); i++) {
        globals->unk_globals_6C[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, 64 * sizeof(BGMInstrumentInfo));
    globals->musicEventQueue = alHeapAlloc(alHeap, 1, 16 * sizeof(MusicEventTrigger));
    globals->outputRate = outputRate;
    au_reset_instrument(globals->defaultInstrument);
    au_reset_drum_entry(&globals->defaultDrumEntry);
    au_reset_instrument_entry(&globals->defaultPRGEntry);
    bgm_clear_music_events();
 
    globals->audioThreadCallbacks[0] = NULL;
    globals->audioThreadCallbacks[1] = NULL;
 
    for (i = 0; i < ARRAY_COUNT(globals->unk_globals_6C); i++) {
        globals->unk_globals_6C[i].unk_4 = 0;
        globals->unk_globals_6C[i].unk_5 = 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, 0);
        au_syn_set_wavetable(i, globals->defaultInstrument);
        voice = &globals->voices[i];
        voice->instrument = NULL;
        voice->pitchRatio = 0;
        voice->p_volume = -1;
        voice->pan = 0xFF;
        voice->reverb = 0xFF;
        voice->busId = 0;
        voice->stopPending = FALSE;
        voice->syncFlags = 0;
        voice->clientPriority = AU_PRIORITY_FREE;
        voice->priority = AU_PRIORITY_FREE;
    }
 
    au_load_INIT(globals, audio_ROM_START, alHeap);
 
    for (i = 0; i < ARRAY_COUNT(globals->banks); i++) {
        globals->banks[i] = alHeapAlloc(alHeap, 1, 0x840);
    }
 
    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_amb_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->mseqFileList[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->mseqFileList[1], AU_FMT_PER, &fileEntry) == AU_RESULT_OK) {
        au_load_PER(globals, fileEntry.offset);
    }
    if (au_fetch_SBN_file(globals->mseqFileList[2], AU_FMT_PRG, &fileEntry) == AU_RESULT_OK) {
        au_load_PRG(globals, fileEntry.offset);
    }
 
    globals->instrumentGroups[0] = globals->instrumentGroup1;
    globals->instrumentGroups[1] = globals->instrumentGroup2;
    globals->instrumentGroups[2] = globals->instrumentGroupX;
    globals->instrumentGroups[3] = globals->instrumentGroup3;
    globals->instrumentGroups[4] = globals->instrumentGroup4;
    globals->instrumentGroups[5] = globals->instrumentGroup5;
    globals->instrumentGroups[6] = globals->instrumentGroup6;
    globals->instrumentGroups[7] = globals->instrumentGroup1;
    globals->channelDelaySide = 0;
    globals->channelDelayTime = 0;
    globals->channelDelayBusId = 0;
    globals->channelDelayPending = 0;
 
    au_delay_channel(0);
    func_80055050(alHeap);
}

Referenced by create_audio_system().

au_update_clients_2()

void au_update_clients_2

(

void

)

Definition at line 191 of file 2e230_len_2190.c.

                               {
    AuGlobals* globals = gSoundGlobals;
    SoundManager* sfxManager = gSoundManager;
    AmbienceManager* ambManager = gAuAmbienceManager;
    BGMPlayer* bgmPlayer;
 
    au_syn_update(globals);
 
    ambManager->nextUpdateCounter -= ambManager->nextUpdateStep;
    if (ambManager->nextUpdateCounter <= 0) {
        ambManager->nextUpdateCounter += ambManager->nextUpdateInterval;
        au_amb_manager_update(ambManager);
    }
 
    if (sfxManager->fadeInfo.fadeTime != 0) {
        au_fade_update(&sfxManager->fadeInfo);
        au_fade_set_volume(sfxManager->busId, sfxManager->fadeInfo.curVolume.u16, sfxManager->busVolume);
    }
 
    sfxManager->nextUpdateCounter -= sfxManager->nextUpdateStep;
    if (sfxManager->nextUpdateCounter <= 0) {
        sfxManager->nextUpdateCounter += sfxManager->nextUpdateInterval;
        sfxManager->unk_BA = au_sfx_manager_update(sfxManager);
    }
 
    // update gBGMPlayerB
    if (!PreventBGMPlayerUpdate) {
        bgmPlayer = gBGMPlayerB;
        if (bgmPlayer->fadeInfo.fadeTime != 0) {
            au_bgm_update_fade(bgmPlayer);
        }
        if (bgmPlayer->songName != 0) {
            bgmPlayer->songPlayingCounter++;
        }
 
        bgmPlayer->nextUpdateCounter -= bgmPlayer->nextUpdateStep;
        if (bgmPlayer->nextUpdateCounter <= 0) {
            bgmPlayer->nextUpdateCounter += bgmPlayer->nextUpdateInterval;
            bgmPlayer->unk_5C = au_bgm_player_update_main(bgmPlayer);
        }
    }
 
    if (!PreventBGMPlayerUpdate) {
        if (globals->unk_80 != 0) {
            func_8004DFD4(globals);
        }
        bgmPlayer = gBGMPlayerA;
        if (bgmPlayer->fadeInfo.volScaleTime != 0) {
            func_80053BA8(&bgmPlayer->fadeInfo);
            if (bgmPlayer->fadeInfo.fadeTime == 0) {
                func_8004E444(bgmPlayer);
            } else {
                au_bgm_update_fade(bgmPlayer);
            }
        } else if (bgmPlayer->fadeInfo.fadeTime != 0) {
            au_bgm_update_fade(bgmPlayer);
        }
        if (bgmPlayer->songName != 0) {
            bgmPlayer->songPlayingCounter++;
        }
 
        bgmPlayer->nextUpdateCounter -= bgmPlayer->nextUpdateStep;
        if (bgmPlayer->nextUpdateCounter <= 0) {
            bgmPlayer->nextUpdateCounter += bgmPlayer->nextUpdateInterval;
            bgmPlayer->unk_5C = au_bgm_player_update_main(bgmPlayer);
        }
    }
    au_update_voices(globals);
}

Referenced by alAudioFrame().

au_update_players_main()

void au_update_players_main

(

void

)

Definition at line 261 of file 2e230_len_2190.c.

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

Referenced by alAudioFrame().

au_syn_update()

void au_syn_update

(

AuGlobals *

globals

)

Definition at line 283 of file 2e230_len_2190.c.

                                       {
    u32 i;
 
    if (globals->unk_130C == 2) {
        globals->unk_130C = 1;
        au_disable_channel_delay();
    }
 
    if (globals->channelDelayPending && (globals->unk_130C == 0)) {
        switch (globals->channelDelaySide) {
            case 1:
                au_set_delay_time(globals->channelDelayTime);
                au_delay_left_channel(globals->channelDelayBusId);
                globals->channelDelayPending = FALSE;
                break;
            case 2:
                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;
        }
    }
 
    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->stopPending) {
            au_syn_stop_voice(i);
            voice->stopPending = 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->p_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->p_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_2().

au_reset_nonfree_voice()

void au_reset_nonfree_voice	(	AuVoice *	voice,
		u8	index )

Definition at line 358 of file 2e230_len_2190.c.

                                                      {
    if (voice->priority != AU_PRIORITY_FREE) {
        voice->cmdPtr = NULL;
        voice->stopPending = 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 368 of file 2e230_len_2190.c.

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

Referenced by au_amb_player_stop(), au_amb_player_update(), au_amb_restore_voices(), au_bgm_player_update_playing(), au_BGMCmd_FC_Jump(), and func_80050900().

au_compute_pitch_ratio()

f32 au_compute_pitch_ratio

(

s32

pitch

)

Definition at line 381 of file 2e230_len_2190.c.

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

Referenced by au_amb_player_update(), au_amb_restore_voices(), and au_bgm_player_update_playing().

au_fade_init()

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

Definition at line 392 of file 2e230_len_2190.c.

                                                                      {
    fade->curVolume.s32 = startValue * 0x10000;
    fade->targetVolume = endValue;
 
    if (time != 0) {
        fade->fadeTime = (time * 1000) / AU_5750;
        fade->fadeStep = (endValue * 0x10000 - fade->curVolume.s32) / fade->fadeTime;
    } else {
        fade->fadeTime = 1;
        fade->fadeStep = 0;
    }
 
    fade->onCompleteCallback = NULL;
}

Referenced by au_bgm_dispatch_player_event(), au_sfx_init(), and func_8004DFD4().

au_fade_clear()

void au_fade_clear

(

Fade *

fade

)

Definition at line 407 of file 2e230_len_2190.c.

                               {
    fade->fadeTime = 0;
    fade->fadeStep = 0;
    fade->onCompleteCallback = NULL;
}

au_fade_update()

void au_fade_update

(

Fade *

fade

)

Definition at line 413 of file 2e230_len_2190.c.

                                {
    fade->fadeTime--;
 
    if ((fade->fadeTime << 0x10) != 0) {
        fade->curVolume.s32 += fade->fadeStep;
    } else {
        fade->curVolume.s32 = fade->targetVolume << 0x10;
        if (fade->onCompleteCallback != NULL) {
            fade->onCompleteCallback();
            fade->fadeStep = 0;
            fade->onCompleteCallback = NULL;
        }
    }
}

Referenced by au_update_clients_2().

au_fade_set_volume()

void au_fade_set_volume	(	u8	busId,
		u16	volume,
		s32	busVolume )

Definition at line 428 of file 2e230_len_2190.c.

                                                             {
    au_bus_set_volume(busId, (u32)(volume * busVolume) >> 15);
}

Referenced by au_sfx_init(), au_update_clients_2(), and func_8004E444().

func_80053AC8()

void func_80053AC8

(

Fade *

fade

)

Definition at line 432 of file 2e230_len_2190.c.

                               {
    if (fade->fadeTime == 0) {
        fade->fadeTime = 1;
        fade->fadeStep = 0;
        fade->targetVolume = fade->curVolume.u16;
    }
}

Referenced by func_80054CE0().

au_fade_set_vol_scale()

void au_fade_set_vol_scale	(	Fade *	fade,
		s16	value )

Definition at line 440 of file 2e230_len_2190.c.

                                                  {
    fade->volScale.s32 = value << 16;
    fade->targetVolScale = value;
    fade->volScaleTime = 0;
    fade->volScaleStep = 0;
}

Referenced by au_bgm_player_init().

func_80053B04()

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

Definition at line 447 of file 2e230_len_2190.c.

                                                     {
    s16 time;
    s32 delta;
 
    if (arg1 >= 250 && arg1 <= 100000) {
        time = (s32)(arg1 * 1000) / AU_5750;
        delta = (target << 16) - fade->volScale.s32;
 
        fade->targetVolScale = target;
        fade->volScaleTime = time;
        fade->volScaleStep = delta / time;
    } else {
        fade->volScaleTime = 0;
        fade->volScaleStep = 0;
    }
}

Referenced by func_8004E0F4().

func_80053BA8()

void func_80053BA8

(

Fade *

fade

)

Definition at line 464 of file 2e230_len_2190.c.

                               {
    fade->volScaleTime--;
 
    if (fade->volScaleTime != 0) {
        fade->volScale.s32 += fade->volScaleStep;
    } else {
        fade->volScaleStep = 0;
        fade->volScale.s32 = fade->targetVolScale << 16;
    }
}

Referenced by au_update_clients_2().

au_get_instrument()

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

Definition at line 476 of file 2e230_len_2190.c.

                                                                                              {
    Instrument* instrument = (*globals->instrumentGroups[(bank & 0x70) >> 4])[patch];
    EnvelopePreset* preset = instrument->envelopes;
    u32 envelopeIdx = bank & 3;
 
    if (envelopeIdx < preset->count) {
        envData->cmdListPress = AU_FILE_RELATIVE(preset, preset->offsets[envelopeIdx].offsetPress);
        envData->cmdListRelease = AU_FILE_RELATIVE(preset, preset->offsets[envelopeIdx].offsetRelease);
    } else {
        envData->cmdListPress = EnvelopePressDefault;
        envData->cmdListRelease = &EnvelopePressDefault[4]; //EnvelopeReleaseDefault;
    }
    return instrument;
}

Referenced by au_amb_player_update(), au_bgm_player_update_playing(), au_BGMCmd_E8_TrackOverridePatch(), and au_BGMCmd_F5_TrackVoice().

au_get_bgm_player_and_file()

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

Definition at line 491 of file 2e230_len_2190.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 au_song_load().

au_get_bgm_player()

void au_get_bgm_player	(	u32	playerIndex,
		BGMPlayer **	outPlayer )

Definition at line 514 of file 2e230_len_2190.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	songID,
		BGMHeader *	bgmFile,
		BGMPlayer *	player )

Definition at line 531 of file 2e230_len_2190.c.

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

Referenced by au_song_load().

func_80053E58()

AuResult func_80053E58	(	s32	songID,
		BGMHeader *	bgmFile )

Definition at line 593 of file 2e230_len_2190.c.

                                                       {
    AuResult status;
    SBNFileEntry fileEntry;
    SBNFileEntry sbnEntry;
    SBNFileEntry* bkFileEntry;
    AuGlobals* soundData;
    InitSongEntry* songInfo;
    s32 i;
    u16 bkFileIndex;
 
    soundData = gSoundGlobals;
    songInfo = &soundData->songList[songID];
    status =  au_fetch_SBN_file(songInfo[0].bgmFileIndex, AU_FMT_BGM, &sbnEntry);
    if (status == AU_RESULT_OK) {
        au_read_rom(sbnEntry.offset, bgmFile, sbnEntry.data & 0xFFFFFF);
 
        for (i = 0; i < ARRAY_COUNT(songInfo->bkFileIndex); i++) {
            bkFileIndex = songInfo->bkFileIndex[i];
            if (bkFileIndex != 0) {
                bkFileEntry = &soundData->sbnFileList[bkFileIndex];
 
                fileEntry.offset = (bkFileEntry->offset & 0xFFFFFF) + soundData->baseRomOffset;
                fileEntry.data = bkFileEntry->data;
 
                if ((fileEntry.data >> 0x18) == AU_FMT_BK) {
                    snd_load_BK(fileEntry.offset, i);
                } else {
                    status = AU_ERROR_SBN_FORMAT_MISMATCH;
                }
            }
        }
    }
 
    return status;
}

Referenced by func_8004DE2C().

func_80053F64()

BGMPlayer * func_80053F64

(

s32

arg0

)

Definition at line 629 of file 2e230_len_2190.c.

                                   {
    if (arg0 == 0) {
        return gSoundGlobals->unk_globals_6C[0].bgmPlayer;
    }
    return NULL;
}

Referenced by func_8004DCB8(), and func_8004DE2C().

au_ambient_load()

AuResult au_ambient_load

(

u32

ambSoundID

)

Definition at line 638 of file 2e230_len_2190.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 && SBN_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_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_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_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_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_LOOKUP(ambSoundID + 4, AU_FMT_BK, fileEntry) == AU_RESULT_OK) {
                            snd_load_BK(fileEntry.offset, 2);
                        }
                    }
                }
            }
        }
    }
 
    return AU_RESULT_OK;
}

Referenced by snd_load_ambient().

func_80054248()

BGMPlayer * func_80054248

(

u8

arg0

)

Definition at line 698 of file 2e230_len_2190.c.

                                  {
    switch (arg0) {
        case 1:
            return gBGMPlayerA;
        case 2:
            return gBGMPlayerB;
        case 4:
            return (BGMPlayer*)gSoundManager; // TODO: why return pointer to SoundManager?
        default:
            return NULL;
    }
}

Referenced by func_8004DE2C().

au_load_INIT()

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

Definition at line 711 of file 2e230_len_2190.c.

                                                              {
    SBNHeader sbnHeader;
    INITHeader initHeader;
    SBNFileEntry* entry;
    s32 tableSize, initBase, size;
    s32 tblAddr, shortsAddr;
    s32* data;
    s32 numEntries;
    s32 tblOffset, shortsOffset;
    s32* romPtr = &arg0->baseRomOffset;
 
    au_read_rom(romAddr, &sbnHeader, sizeof(sbnHeader));
    numEntries = sbnHeader.numEntries;
    arg0->baseRomOffset = romAddr;
    tableSize = numEntries * sizeof(SBNFileEntry);
    arg0->fileListLength = sbnHeader.numEntries;
    arg0->sbnFileList = alHeapAlloc(heap, 1, tableSize);
    au_read_rom(arg0->baseRomOffset + sbnHeader.tableOffset, arg0->sbnFileList, tableSize);
 
    entry = arg0->sbnFileList;
    while (sbnHeader.numEntries--) {
        if ((entry->offset & 0xFFFFFF) == 0) {
            break;
        }
 
        size = entry->data;
        entry->data = (size + 0xF) & ~0xF;
        entry++;
    }
 
    if (sbnHeader.INIToffset != 0) {
        initBase = *romPtr + sbnHeader.INIToffset;
        au_read_rom(initBase, &initHeader, sizeof(initHeader));
 
        tblOffset = initHeader.tblOffset;
        size = (initHeader.tblSize + 0xF) & 0xFFF0;
        tblAddr = initBase + tblOffset;
        arg0->songList = alHeapAlloc(heap, 1, size);
        au_read_rom(tblAddr, arg0->songList, size);
 
        shortsOffset = initHeader.shortsOffset;
        size = (initHeader.shortsSize + 0xF) & 0xFFF0;
        shortsAddr = initBase + shortsOffset;
        arg0->mseqFileList = alHeapAlloc(heap, 1, size);
        au_read_rom(shortsAddr, arg0->mseqFileList, size);
 
        arg0->bkFileListOffset = initBase + initHeader.entriesOffset;
        arg0->bkListLength = (initHeader.entriesSize + 0xF) & 0xFFF0;
        arg0->songListLength = initHeader.tblSize / sizeof(InitSongEntry) - 1;
    }
}

Referenced by au_engine_init().

au_fetch_SBN_file()

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

Definition at line 763 of file 2e230_len_2190.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 func_80053E58().

au_load_PER()

void au_load_PER	(	AuGlobals *	globals,
		s32	romAddr )

Definition at line 785 of file 2e230_len_2190.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 804 of file 2e230_len_2190.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 > 0x200) {
        size = 0x200;
    }
    au_read_rom(dataRomAddr, arg0->dataPRG, size);
    numItems = size / sizeof(BGMInstrumentInfo);
    numItemsLeft = 0x40 - numItems;
    if (numItemsLeft > 0) {
        end = &arg0->dataPRG[numItems];
        au_copy_words(&arg0->defaultPRGEntry, end, sizeof(BGMInstrumentInfo));
        au_copy_words(end, end + sizeof(BGMInstrumentInfo), numItemsLeft * sizeof(BGMInstrumentInfo) - sizeof(BGMInstrumentInfo));
    }
}

Referenced by au_engine_init().

snd_load_BGM()

s32 snd_load_BGM

(

s32

arg0

)

Definition at line 828 of file 2e230_len_2190.c.

                           {
    AuGlobals* globals = gSoundGlobals;
    InitSongEntry* song = globals->songList;
    s32 ret = 0;
    s32 i;
 
    while (TRUE) {
        if (song->bgmFileIndex == 0xFFFF) {
            return ret;
        }
 
        if (song->bgmFileIndex == arg0) {
            for (i = 0; i < ARRAY_COUNT(song->bkFileIndex); i++) {
                u16 bkFileIndex = song->bkFileIndex[i];
                if (bkFileIndex != 0) {
                    SBNFileEntry* bkFileEntry = &globals->sbnFileList[bkFileIndex];
                    SBNFileEntry fileEntry;
 
                    fileEntry.offset = (bkFileEntry->offset & 0xFFFFFF) + globals->baseRomOffset;
                    fileEntry.data = bkFileEntry->data;
                    if ((fileEntry.data >> 0x18) == 0x30) {
                        snd_load_BK(fileEntry.offset, i);
                    } else {
                        ret = 0x66;
                    }
                }
            }
 
            return ret;
        }
        song++;
    }
}

au_get_BK_instruments()

InstrumentGroup * au_get_BK_instruments	(	s32	bankGroup,
		u32	bankIndex )

Definition at line 862 of file 2e230_len_2190.c.

                                                                     {
    InstrumentGroup* ret = NULL;
    AuGlobals* temp = gSoundGlobals;
 
    // TODO fake match - this multiplying the bankIndex by 16 and then dividing it right after is dumb
    bankIndex *= 16;
 
    switch (bankGroup) {
        case 1:
            ret = &temp->instrumentGroup1[bankIndex / 16];
            break;
        case 2:
            ret = &temp->instrumentGroup2[bankIndex / 16];
            break;
        case 4:
            ret = &temp->instrumentGroup4[bankIndex / 16];
            break;
        case 5:
            ret = &temp->instrumentGroup5[bankIndex / 16];
            break;
        case 6:
            ret = &temp->instrumentGroup6[bankIndex / 16];
            break;
        case 3:
            ret = &temp->instrumentGroup3[bankIndex / 16];
            break;
    }
 
    return ret;
}

Referenced by au_load_BK_to_bank(), func_80054AA0(), and func_80054C84().

au_load_BK_to_bank()

SoundBank * au_load_BK_to_bank	(	s32	bkFileOffset,
		SoundBank *	bank,
		s32	bankIndex,
		s32	bankGroup )

Definition at line 911 of file 2e230_len_2190.c.

                                                                                               {
    ALHeap* heap = gSynDriverPtr->heap;
    BKHeader bkHeader;
    BKHeader* header = &bkHeader;
    u16 keepReading;
    u16 readState;
    InstrumentGroup* group;
    Instrument** inst;
    s32 instrumentCount;
    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->instrumetsSize)
                    + ALIGN16_(header->unkSizeA)
                    + ALIGN16_(header->predictorsSize)
                    + ALIGN16_(header->unkSizeB)
                    + sizeof(*header);
                if (bank == NULL) {
                    bank = alHeapAlloc(heap, 1, size);
                }
                au_read_rom(bkFileOffset, bank, size);
 
                group = au_get_BK_instruments(bankGroup, 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(bank, 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, bank, *group, 16, 1);
                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 bank;
}

Referenced by au_load_BK_headers(), and snd_load_BK().

au_swizzle_BK_instruments()

void au_swizzle_BK_instruments	(	s32	bkFileOffset,
		SoundBank *	bank,
		InstrumentGroup	instruments,
		u32	instrumentCount,
		u8	arg4 )

Definition at line 1003 of file 2e230_len_2190.c.

                                                                                                                             {
    Instrument* defaultInstrument = gSoundGlobals->defaultInstrument;
    SoundBank* sb = bank;
    f32 outputRate = gSoundGlobals->outputRate;
    s32 i;
 
    if (sb->swizzled == 0) {
        for (i = 0; i < instrumentCount; i++) {
            Instrument* instrument = instruments[i];
 
            if (instrument != NULL) {
                if (instrument->base != 0) {
                    instrument->base += bkFileOffset;
                }
                if (instrument->loopPredictor != NULL) {
                    instrument->loopPredictor = AU_FILE_RELATIVE(bank, instrument->loopPredictor);
                }
                if (instrument->predictor != NULL) {
                    instrument->predictor = AU_FILE_RELATIVE(bank, instrument->predictor);
                }
                if (instrument->envelopes != NULL) {
                    instrument->envelopes = AU_FILE_RELATIVE(bank, instrument->envelopes);
                }
                instrument->unk_25 = arg4;
                instrument->pitchRatio = instrument->outputRate / outputRate;
            } else {
                instruments[i] = defaultInstrument;
            }
        }
        sb->swizzled = 1;
    }
}

Referenced by au_load_BK_to_bank(), and func_80054AA0().

func_80054AA0()

s32 * func_80054AA0	(	s32 *	bkFileOffset,
		void *	vaddr,
		s32	bankIndex,
		s32	bankGroup )

Definition at line 1036 of file 2e230_len_2190.c.

                                                                                 {
    ALHeap* heap = gSynDriverPtr->heap;
    BKHeader localHeader;
    void* fileData = vaddr;
    BKHeader* header = &localHeader;
    InstrumentGroup* group;
    Instrument* instruments;
    Instrument** inst;
    u32 instrCount;
    u32 readState;
    s32 keepReading;
 
    u32 i;
    s32 swizzleArg;
    swizzleArg = 0;
    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(*bkFileOffset, &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 (fileData == NULL) {
                    fileData = alHeapAlloc(heap, 1, header->size);
                }
                au_read_rom(*bkFileOffset, fileData, header->size);
 
                instrCount = 0;
                group = au_get_BK_instruments(bankGroup, bankIndex);
                inst = (*group);
                for(i = 0; i < ARRAY_COUNT(header->instruments); inst++, i++) {
                    u16 instOffset = header->instruments[i];
                    if(instOffset != 0) {
                        instrCount++;
                        *inst = AU_FILE_RELATIVE(fileData, instOffset);
                    } else {
                        *inst =  NULL;
                    }
                }
 
                if (instrCount != 0) {
                    readState = BK_READ_SWIZZLE;
                } else {
                    keepReading = FALSE;
                }
                break;
            case BK_READ_SWIZZLE:
                au_swizzle_BK_instruments((s32)fileData, fileData, *group, 0x10U, swizzleArg);
                readState = BK_READ_DONE;
                break;
            default:
                keepReading = FALSE;
                break;
        }
    }
    return fileData;
}

snd_load_BK()

s32 snd_load_BK	(	s32	bkFileOffset,
		s32	bankIndex )

Definition at line 1109 of file 2e230_len_2190.c.

                                                 {
    au_load_BK_to_bank(bkFileOffset, gSoundGlobals->banks[bankIndex], bankIndex, 1);
    return 0;
}

Referenced by au_ambient_load(), au_load_song_files(), func_80053E58(), and snd_load_BGM().

func_80054C84()

void func_80054C84	(	s32	bankIndex,
		s32	bankGroup )

Definition at line 1114 of file 2e230_len_2190.c.

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

func_80054CE0()

void func_80054CE0	(	s32	arg0,
		u32	idx )

Definition at line 1126 of file 2e230_len_2190.c.

                                      {
    if (idx < ARRAY_COUNT(D_80078530)) {
        s32 temp_s0 = D_80078530[idx];
        if (arg0 & 1) {
            gBGMPlayerA->busVolume = temp_s0;
            func_80053AC8(&gBGMPlayerA->fadeInfo);
            gBGMPlayerB->busVolume = temp_s0;
            func_80053AC8(&gBGMPlayerB->fadeInfo);
        }
        if (arg0 & 0x10) {
            gSoundManager->busVolume = temp_s0;
            func_80053AC8(&gSoundManager->fadeInfo);
        }
    }
}

Referenced by func_800561A4(), and func_800561C4().

func_80054D74()

s32 func_80054D74	(	s32	arg0,
		s32	arg1 )

Definition at line 1142 of file 2e230_len_2190.c.

                                      {
    if (arg0 & 0x10) {
        return au_sfx_set_reverb_type(gSoundManager, arg1);
    }
    return 0;
}

Referenced by func_800561E4().

func_80054DA8()

void func_80054DA8

(

u32

bMonoSound

)

Definition at line 1149 of file 2e230_len_2190.c.

                                   {
    if (bMonoSound % 2 == 1) {
        // mono sound
        if (gSoundGlobals->unk_130C == 0) {
            gSoundGlobals->unk_130C = 2;
        }
    } else {
        // stereo sound
        if (gSoundGlobals->unk_130C != 0) {
            gSoundGlobals->channelDelayPending = 1;
            gSoundGlobals->unk_130C = 0;
        }
    }
}

Referenced by audio_set_mono(), and audio_set_stereo().

au_read_rom()

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

Definition at line 1166 of file 2e230_len_2190.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(), func_80053E58(), and func_80054AA0().

au_memset()

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

Definition at line 1183 of file 2e230_len_2190.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_amb_manager_init(), and au_amb_play_sequence().

au_copy_bytes()

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

Definition at line 1222 of file 2e230_len_2190.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 1230 of file 2e230_len_2190.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_load_PER(), au_load_PRG(), func_8004DCB8(), and func_8004DFD4().

Variable Documentation

BeginSoundUpdateCallback

AuCallback BeginSoundUpdateCallback

Definition at line 4 of file 2e230_len_2190.c.

Referenced by au_update_players_main().

gBGMPlayerA

BGMPlayer* gBGMPlayerA

Definition at line 5 of file 2e230_len_2190.c.

Referenced by au_bgm_get_player_with_song_name(), au_bgm_stop_all(), au_engine_init(), au_get_bgm_player(), au_get_bgm_player_and_file(), au_update_clients_2(), au_update_players_main(), func_80054248(), func_80054CE0(), func_8005513C(), and snd_song_get_playing_info().

gBGMPlayerB

BGMPlayer* gBGMPlayerB

Definition at line 6 of file 2e230_len_2190.c.

Referenced by au_bgm_get_player_with_song_name(), au_bgm_stop_all(), au_engine_init(), au_get_bgm_player(), au_get_bgm_player_and_file(), au_update_clients_2(), au_update_players_main(), func_80054248(), func_80054CE0(), func_8005513C(), and snd_song_get_playing_info().

gBGMPlayerC

BGMPlayer* gBGMPlayerC

Definition at line 7 of file 2e230_len_2190.c.

Referenced by au_engine_init().

gSoundManager

SoundManager* gSoundManager

Definition at line 8 of file 2e230_len_2190.c.

Referenced by au_engine_init(), au_update_clients_2(), au_update_players_main(), disable_sounds(), enable_sounds(), func_80054248(), func_80054CE0(), func_80054D74(), snd_adjust_sound(), snd_adjust_sound_with_shift(), snd_reset(), snd_start_sound(), snd_start_sound_raw(), snd_start_sound_with_shift(), and snd_stop_sound().

gSoundGlobals

AuGlobals* gSoundGlobals

Definition at line 9 of file 2e230_len_2190.c.

Referenced by au_ambient_load(), au_engine_init(), au_fetch_SBN_file(), au_get_bgm_player_and_file(), au_get_BK_instruments(), au_load_song_files(), au_register_callback(), au_swizzle_BK_instruments(), au_update_clients_2(), au_update_players_main(), bgm_clear_music_events(), bgm_flush_music_events(), bgm_poll_music_events(), bgm_trigger_music_event(), func_80052E30(), func_80053E58(), func_80053F64(), func_80054C84(), func_80054DA8(), snd_load_BGM(), snd_load_BK(), and snd_song_get_playing_info().

gAuAmbienceManager

AmbienceManager* gAuAmbienceManager

Definition at line 10 of file 2e230_len_2190.c.

Referenced by au_amb_check_player_index(), au_amb_is_stopped(), au_amb_load_tracks_fade(), au_amb_pause(), au_amb_resume(), au_amb_set_disabled(), au_amb_set_volume(), au_amb_start(), au_amb_stop_quick(), au_amb_stop_slow(), au_ambient_load(), au_engine_init(), and au_update_clients_2().

D_80078530

u16 D_80078530[9]

extern

Definition at line 289 of file sfx_player.c.

                   {
    0x0000, 0x0200, 0x0800, 0x1200, 0x2000, 0x3200, 0x4800, 0x6200, 0x8000
};

Referenced by func_80054CE0().

EnvelopePressDefault

u8 EnvelopePressDefault[]

extern

Definition at line 299 of file sfx_player.c.

                            {
    ENV_TIME_280MS, 127,
    ENV_CMD_END, 0
};

Referenced by au_get_instrument().

EnvelopeReleaseDefault

u8 EnvelopeReleaseDefault[]

extern

Definition at line 304 of file sfx_player.c.

                              {
    ENV_TIME_550MS, 0,
    ENV_CMD_END, 0
};

AlTuneScaling

f32 AlTuneScaling[]

extern

Definition at line 360 of file sfx_player.c.

                      {
    // TUNE_SCALING_ARR_AMPLIFY_FINE
    1.00000000f, 1.00057781f, 1.00115597f, 1.00173450f, 1.00231326f, 1.00289237f, 1.00347185f, 1.00405169f,
    1.00463188f, 1.00521231f, 1.00579309f, 1.00637424f, 1.00695574f, 1.00753760f, 1.00811982f, 1.00870228f,
    1.00928509f, 1.00986826f, 1.01045179f, 1.01103568f, 1.01161981f, 1.01220429f, 1.01278913f, 1.01337433f,
    1.01395988f, 1.01454580f, 1.01513207f, 1.01571858f, 1.01630545f, 1.01689267f, 1.01748025f, 1.01806819f,
    1.01865649f, 1.01924503f, 1.01983392f, 1.02042317f, 1.02101278f, 1.02160275f, 1.02219307f, 1.02278376f,
    1.02337468f, 1.02396595f, 1.02455759f, 1.02514958f, 1.02574193f, 1.02633464f, 1.02692771f, 1.02752113f,
    1.02811480f, 1.02870882f, 1.02930319f, 1.02989793f, 1.03049302f, 1.03108847f, 1.03168428f, 1.03228045f,
    1.03287685f, 1.03347361f, 1.03407073f, 1.03466821f, 1.03526604f, 1.03586423f, 1.03646278f, 1.03706169f,
    1.03766096f, 1.03826058f, 1.03886044f, 1.03946066f, 1.04006124f, 1.04066217f, 1.04126346f, 1.04186511f,
    1.04246712f, 1.04306948f, 1.04367220f, 1.04427528f, 1.04487872f, 1.04548252f, 1.04608655f, 1.04669094f,
    1.04729569f, 1.04790080f, 1.04850626f, 1.04911208f, 1.04971826f, 1.05032480f, 1.05093169f, 1.05153894f,
    1.05214655f, 1.05275452f, 1.05336285f, 1.05397153f, 1.05458057f, 1.05518997f, 1.05579972f, 1.05640972f,
    1.05702007f, 1.05763078f, 1.05824184f, 1.05885327f, 1.05946505f, 1.06007719f, 1.06068969f, 1.06130254f,
    1.06191576f, 1.06252933f, 1.06314325f, 1.06375754f, 1.06437218f, 1.06498718f, 1.06560254f, 1.06621826f,
    1.06683433f, 1.06745076f, 1.06806755f, 1.06868470f, 1.06930220f, 1.06992006f, 1.07053828f, 1.07115686f,
    1.07177579f, 1.07239509f, 1.07301474f, 1.07363474f, 1.07425511f, 1.07487583f, 1.07549691f, 1.07611835f,
    // TUNE_SCALING_ARR_AMPLIFY_COARSE
    1.00000000f, 1.07674015f, 1.15936935f, 1.24833953f, 1.34413731f, 1.44728661f, 1.55835164f, 1.67793977f,
    1.80670512f, 1.94535196f, 2.09463859f, 2.25538135f, 2.42845964f, 2.61482000f, 2.81548166f, 3.03154206f,
    3.26418304f, 3.51467681f, 3.78439355f, 4.07480860f, 4.38750982f, 4.72420788f, 5.08674431f, 5.47710180f,
    5.89741516f, 6.34998369f, 6.83728218f, 7.36197615f, 7.92693520f, 8.53524971f, 9.19024563f, 9.89550686f,
    // TUNE_SCALING_ARR_ATTENUATE_FINE
    1.00000000f, 0.99942255f, 0.99884546f, 0.99826866f, 0.99769223f, 0.99711609f, 0.99654031f, 0.99596488f,
    0.99538976f, 0.99481499f, 0.99424052f, 0.99366641f, 0.99309260f, 0.99251914f, 0.99194598f, 0.99137318f,
    0.99080074f, 0.99022859f, 0.98965681f, 0.98908532f, 0.98851418f, 0.98794335f, 0.98737288f, 0.98680270f,
    0.98623288f, 0.98566335f, 0.98509419f, 0.98452532f, 0.98395681f, 0.98338860f, 0.98282075f, 0.98225319f,
    0.98168600f, 0.98111910f, 0.98055255f, 0.97998631f, 0.97942042f, 0.97885484f, 0.97828960f, 0.97772467f,
    0.97716010f, 0.97659582f, 0.97603190f, 0.97546828f, 0.97490501f, 0.97434205f, 0.97377944f, 0.97321713f,
    0.97265512f, 0.97209346f, 0.97153211f, 0.97097111f, 0.97041041f, 0.96985006f, 0.96929002f, 0.96873033f,
    0.96817094f, 0.96761185f, 0.96705312f, 0.96649468f, 0.96593660f, 0.96537882f, 0.96482134f, 0.96426421f,
    0.96370739f, 0.96315092f, 0.96259475f, 0.96203887f, 0.96148336f, 0.96092814f, 0.96037328f, 0.95981872f,
    0.95926446f, 0.95871055f, 0.95815694f, 0.95760363f, 0.95705068f, 0.95649803f, 0.95594567f, 0.95539367f,
    0.95484197f, 0.95429057f, 0.95373952f, 0.95318878f, 0.95263839f, 0.95208830f, 0.95153850f, 0.95098901f,
    0.95043987f, 0.94989103f, 0.94934249f, 0.94879431f, 0.94824642f, 0.94769883f, 0.94715160f, 0.94660467f,
    0.94605803f, 0.94551176f, 0.94496578f, 0.94442010f, 0.94387472f, 0.94332969f, 0.94278497f, 0.94224054f,
    0.94169647f, 0.94115269f, 0.94060922f, 0.94006604f, 0.93952322f, 0.93898070f, 0.93843848f, 0.93789655f,
    0.93735498f, 0.93681371f, 0.93627274f, 0.93573207f, 0.93519175f, 0.93465173f, 0.93411201f, 0.93357259f,
    0.93303353f, 0.93249476f, 0.93195629f, 0.93141812f, 0.93088025f, 0.93034273f, 0.92980552f, 0.92926860f,
    // TUNE_SCALING_ARR_ATTENUATE_COARSE
    1.00000000f, 0.92873198f, 0.86254311f, 0.80107135f, 0.74398059f, 0.69095856f, 0.64171529f, 0.59598154f,
    0.55350709f, 0.51405972f, 0.47742370f, 0.44339865f, 0.41179851f, 0.38245043f, 0.35519394f, 0.32987997f,
    0.30637008f, 0.28453568f, 0.26425737f, 0.24542427f, 0.22793336f, 0.21168900f, 0.19660234f, 0.18259089f,
    0.16957800f, 0.15749252f, 0.14626834f, 0.13584408f, 0.12616274f, 0.11717137f, 0.10882080f, 0.10106535f,
    0.09386262f, 0.08717322f, 0.08096056f, 0.07519066f, 0.06983197f, 0.06485518f, 0.06023308f, 0.05594039f,
    0.05195362f, 0.04825099f, 0.04481224f, 0.04161856f, 0.03865249f, 0.03589780f, 0.03333944f, 0.03096340f,
    0.02875670f, 0.02670727f, 0.02480390f, 0.02303617f, 0.02139443f, 0.01986969f, 0.01845361f, 0.01713846f,
    0.01591704f, 0.01478266f, 0.01372913f, 0.01275068f, 0.01184197f, 0.01099801f, 0.01021421f, 0.00948626f,
    0.00881019f, 0.00818231f, 0.00759917f, 0.00705759f, 0.00655461f, 0.00608748f, 0.00565364f, 0.00525071f,
    0.00487650f, 0.00452897f, 0.00420620f, 0.00390643f, 0.00362802f, 0.00336946f, 0.00312933f, 0.00290631f,
    0.00269918f, 0.00250681f, 0.00232816f, 0.00216224f, 0.00200814f, 0.00186502f, 0.00173211f, 0.00160866f,
    0.00149402f, 0.00138754f, 0.00128865f, 0.00119681f, 0.00111152f, 0.00103230f, 0.00095873f, 0.00089041f,
    0.00082695f, 0.00076801f, 0.00071328f, 0.00066244f, 0.00061523f, 0.00057139f, 0.00053067f, 0.00049285f,
    0.00045772f, 0.00042510f, 0.00039480f, 0.00036667f, 0.00034054f, 0.00031627f, 0.00029373f, 0.00027279f,
    0.00025335f, 0.00023530f, 0.00021853f, 0.00020295f, 0.00018849f, 0.00017506f, 0.00016258f, 0.00015099f,
    0.00014023f, 0.00013024f, 0.00012096f, 0.00011234f, 0.00010433f, 0.00009689f, 0.00008999f, 0.00008358f
};

Referenced by au_compute_pitch_ratio().