private.h File Reference

Go to the source code of this file.

Functions
void	au_amb_manager_init (AmbienceManager *arg0, s8 arg1, s8 reverbType, AuGlobals *arg3)
AuResult	au_amb_check_player_index (u32 arg0)
void	au_amb_load_tracks_fade (s32 arg0, s32 arg1)
void	au_amb_set_disabled (s32 arg0, s32 arg1)
AuResult	au_amb_start (s32 arg0, s32 arg1)
void	au_amb_fade_setup (AmbiencePlayer *arg0)
void	au_amb_pause (s32 arg0, s32 arg1)
void	au_amb_resume (s32 arg0, s32 arg1)
void	au_amb_stop_quick (s32 arg0)
void	au_amb_stop_slow (s32 arg0, s32 arg1)
void	au_amb_set_volume (s32 arg0, s32 arg1, s32 arg2)
AuResult	au_amb_is_stopped (s32 arg0)
void	au_amb_play_sequence (AmbienceManager *arg0, MSEQHeader *mseq, s32 index)
void	au_amb_manager_update (AmbienceManager *arg0)
void	au_amb_load_track_fade_info (AmbienceManager *manager, AmbiencePlayer *lambda)
void	au_amb_player_update (AmbienceManager *manager, AmbiencePlayer *lambda)
u8	au_amb_read_next (AmbiencePlayer *arg0)
void	au_amb_player_stop (AmbienceManager *arg0, AmbiencePlayer *arg1)
void	au_amb_save_voices (AmbienceManager *arg0, AmbiencePlayer *lambda)
void	au_amb_restore_voices (AmbienceManager *manager, AmbiencePlayer *lambda)
void	au_update_stopped_voices (AuGlobals *globals)
void	au_init_voices (AuGlobals *globals)
void	au_update_voices (AuGlobals *globals)
void	au_voice_after_volume_change (AuVoice *arg0)
s32	au_voice_get_delta (s32 arg0)
void	au_voice_start (AuVoice *voice, EnvelopeData *arg1)
u8	au_voice_step (AuVoice *voice)
void	au_voice_set_vol_changed (AuVoice *arg0)
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 *arg0, u8 arg1)
void	au_reset_voice (AuVoice *arg0, u8 arg1)
f32	au_compute_pitch_ratio (s32 arg0)
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	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 *arg3)
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	func_80053E58 (s32 songID, BGMHeader *arg1)
BGMPlayer *	func_80053F64 (s32 arg0)
AuResult	au_ambient_load (u32 arg0)
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 *arg2)
void	au_load_PER (AuGlobals *globals, s32 romAddr)
void	au_load_PRG (AuGlobals *arg0, s32 romAddr)
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 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	create_audio_system (void)
void	nuAuMgr (void *arg)
s32	nuAuDmaCallBack (s32 addr, s32 len, void *state, u8 arg3)
void	au_load_BK_headers (AuGlobals *arg0, ALHeap *)
void	au_sfx_init (SoundManager *manager, u8 arg1, u8 arg2, AuGlobals *arg3, u8 arg4)
void	au_sfx_load_groups_from_SEF (SoundManager *sndMgr)
void	au_sfx_clear_queue (SoundManager *manager)
void	au_sfx_enqueue_event (SoundManager *manager, u32 soundID, s16 volume, s16 pitchShift, u8 pan)
void	au_sfx_update_main (SoundManager *manager)
s32	au_sfx_set_reverb_type (SoundManager *manager, s32 arg1)
void	au_sfx_set_state (SoundManager *manager, s32 arg1)
void	au_sfx_load_sound (SoundManager *manager, SoundSFXEntry *entry, SoundManagerCustomCmdList *)
s16	au_sfx_manager_update (SoundManager *manager)
void	au_bgm_update_main (BGMPlayer *player)
BGMPlayer *	au_bgm_get_player_with_song_name (s32 songString)
AuResult	au_bgm_dispatch_player_event (SongUpdateEvent *event)
AuResult	au_bgm_stop_song (s32 songName)
void	au_bgm_stop_all (void)
AuResult	au_bgm_is_song_playing (s32 songName)
s32	func_8004DB28 (BGMPlayer *player)
AuResult	func_8004DB4C (SongUpdateEvent *s)
AuResult	func_8004DC80 (s32 songName)
AuResult	func_8004DCB8 (SongUpdateEvent *update, s32 clearChanged)
AuResult	func_8004DE2C (SongUpdateEvent *update)
void	func_8004DFD4 (AuGlobals *globals)
AuResult	func_8004E0F4 (SongUpdateEvent *update)
void	au_bgm_player_init (BGMPlayer *player, s32 arg1, s32 arg2, AuGlobals *arg3)
void	au_bgm_set_effect_indices (BGMPlayer *player, u8 *list)
void	au_bgm_update_fade (BGMPlayer *player)
void	func_8004E444 (BGMPlayer *arg0)
s32	au_bgm_player_update_main (BGMPlayer *player)
void	au_bgm_player_initialize (BGMPlayer *player)
void	func_8004E844 (BGMPlayer *player, s32 arg1)
void	func_8004E880 (BGMPlayer *player, s32 sampleRate, s32 divisor)
void	au_bgm_player_read_segment (BGMPlayer *player)
void	au_bgm_end_segment_loop (BGMPlayer *player, u32 cmd)
void	au_bgm_load_subsegment (BGMPlayer *player, u32 cmd)
void	au_bgm_player_update_stop (BGMPlayer *player)
void	au_bgm_player_update_playing (BGMPlayer *player)
void	au_BGMCmd_E0_MasterTempo (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_E1_MasterVolume (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_E2_MasterPitchShift (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_E3 (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_E6_MasterEffect (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_E4_MasterTempoFade (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_E5_MasterVolumeFade (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_E8_TrackOverridePatch (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_E9_SubTrackVolume (BGMPlayer *arg0, BGMPlayerTrack *track)
void	au_BGMCmd_F6_TrackVolumeFade (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_EA_SubTrackPan (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_EB_SubTrackReverb (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_EC_SegTrackVolume (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_ED_SubTrackCoarseTune (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_EE_SubTrackFineTune (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_EF_SegTrackTune (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_F0_TrackTremolo (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_F1_TrackTremoloSpeed (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_F2_TrackTremoloTime (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_F3_TrackTremoloStop (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_F4 (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_F5_TrackVoice (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_F7_SubTrackReverbType (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_FD_EventTrigger (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_FE_Detour (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_FC_Jump (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_FF (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_NOP (BGMPlayer *player, BGMPlayerTrack *track)
void	au_bgm_set_proximity_mix (s32 songName, u32 mix)
void	au_bgm_set_playback_rate (BGMPlayer *player, f32 arg1)
void	au_bgm_player_set_detune (BGMPlayer *player, s32 arg1)
void	au_bgm_change_track_volume (BGMPlayer *player, s32 trackIdx, s16 arg2, u8 arg3)
void	au_bgm_set_track_volumes (BGMPlayer *player, u8 *arg1, s32 arg2)
void	func_80050888 (BGMPlayer *player, BGMPlayerTrack *track, s32 target, s32 duration)
void	func_80050900 (BGMPlayer *player)
AuResult	func_80050970 (SongUpdateEvent *arg0)
void	func_80055110 (BGMPlayer *player)
AuResult	snd_song_get_playing_info (s32 songName, BGMHeader **outTrackData, BGMPlayer **outPlayer)
void	au_register_callback (AuCallback arg0, s32 arg1)
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	func_80056D5C (u8 arg0)
void	au_bus_set_volume (u8 arg0, u16 arg1)
u16	au_bus_get_volume (u8 arg0, u16 arg1)
void	au_bus_set_effect (u8 arg0, u8 effectID)
void	au_bus_set_fx_params (u8 arg0, s16 arg1, s16 arg2, s32 arg3)
void	au_pvoice_set_bus (u8 arg0, s8 arg1)
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_delay_channel (s16 arg0)
void *	alHeapAlloc (ALHeap *heap, s32 arg1, s32 size)
Acmd *	au_pull_voice (AuPVoice *pvoice, Acmd *cmdBufPos)
void	func_80058E84 (AuFX *fx, u8 mode, ALHeap *heap)
void	func_80058F88 (AlUnkKappa *kappa, ALHeap *heap)
void	func_80059008 (AlUnkKappa *kappa, s16 arg1, s16 arg2, s16 fc)
void	func_8005904C (AuFX *fx, u8 effectType)
Acmd *	au_pull_fx (AuFX *fx, Acmd *cmdBusPos, s16, s16)
s32	au_fx_param_hdl (AuFX *fx, s16 index, s16 paramID, s32 value)
SoundInstance *	sfx_get_env_sound_instance (s32 soundID)

Function Documentation

au_amb_manager_init()

void au_amb_manager_init	(	AmbienceManager *	arg0,
		s8	arg1,
		s8	reverbType,
		AuGlobals *	arg3 )

Definition at line 39 of file 2BF90.c.

                                                                                              {
    AmbiencePlayer* player;
    s32 i;
 
    au_memset(manager, sizeof(*manager), 0);
 
    for (i = 0; i < ARRAY_COUNT(manager->players); i++) {
        player = &manager->players[i];
        player->id.playerIndex = i;
        player->delay = 1;
        player->fadeVolume = 0x7F000000;
    }
 
    manager->globals = globals;
    manager->nextUpdateStep = 1;
    manager->nextUpdateCounter = 2;
    manager->nextUpdateInterval = 2;
    manager->priority = priority;
    manager->busId = busId;
}

Referenced by au_engine_init().

au_amb_check_player_index()

AuResult au_amb_check_player_index

(

u32

arg0

)

Definition at line 60 of file 2BF90.c.

                                              {
    if (gAuAmbienceManager->numActivePlayers <= index) {
        return AU_AMBIENCE_ERROR_3;
    } else {
        return AU_RESULT_OK;
    }
}

Referenced by snd_ambient_disable(), snd_ambient_enable(), snd_ambient_is_stopped(), snd_ambient_mute(), snd_ambient_pause(), snd_ambient_play(), snd_ambient_resume(), snd_ambient_set_volume(), snd_ambient_stop_quick(), and snd_ambient_stop_slow().

au_amb_load_tracks_fade()

void au_amb_load_tracks_fade	(	s32	arg0,
		s32	arg1 )

Definition at line 68 of file 2BF90.c.

                                                 {
    gAuAmbienceManager->loadTracksFadeInfo = arg1;
}

Referenced by snd_ambient_mute().

au_amb_set_disabled()

void au_amb_set_disabled	(	s32	arg0,
		s32	arg1 )

Definition at line 72 of file 2BF90.c.

                                                 {
    AmbienceManager* manager = gAuAmbienceManager;
    AmbiencePlayer* ambPlayer = &manager->players[index];
 
    if (!disable) {
        ambPlayer->playState = AMB_PLAYER_PLAYING;
    } else {
        ambPlayer->playState = AMB_PLAYER_STOPPING;
    }
}

Referenced by snd_ambient_disable(), and snd_ambient_enable().

au_amb_start()

AuResult au_amb_start	(	s32	arg0,
		s32	arg1 )

Definition at line 83 of file 2BF90.c.

                                           {
    AmbiencePlayer* player = &gAuAmbienceManager->players[index];
    MSEQHeader* mseq = gAuAmbienceManager->mseqFiles[index];
    AuResult status = AU_RESULT_OK;
 
    if (mseq != NULL) {
        if (player->mseqName == 0) {
            au_amb_play_sequence(gAuAmbienceManager, mseq, index);
            if (time != 0) {
                player->fadeSettingsTime = time;
                player->fadeSettingsInitial = 0;
                player->fadeSettingsGoal = 127;
                player->fadeSettingsType = AMB_FADE_IN;
                au_amb_fade_setup(player);
            }
        } else {
            status = AU_AMBIENCE_ERROR_1;
        }
    } else {
        status = AU_AMBIENCE_ERROR_2;
    }
    return status;
}

Referenced by snd_ambient_play().

au_amb_fade_setup()

void au_amb_fade_setup

(

AmbiencePlayer *

arg0

)

Definition at line 107 of file 2BF90.c.

                                               {
    u16 time = player->fadeSettingsTime;
 
    if (player->fadeSettingsInitial == 255) {
        player->fadeSettingsInitial = player->fadeVolume >> 0x18;
    }
 
    if (time >= SND_MIN_DURATION && time <= SND_MAX_DURATION) {
        player->fadeVolume = player->fadeSettingsInitial << 0x18;
        player->fadeGoal = player->fadeSettingsGoal;
        player->fadeTime = (u32)(time * 10) / 115; // TODO figure out why is the ratio like this
        player->fadeStep = ((player->fadeSettingsGoal - player->fadeSettingsInitial) << 0x18) / ((s16)player->fadeTime & 0xFFFF);
    }
 
    player->fadeSettingsTime = 0;
    player->fadeSettingsInitial = 0;
    player->fadeSettingsGoal = 0;
}

Referenced by au_amb_manager_update(), and au_amb_start().

au_amb_pause()

void au_amb_pause	(	s32	arg0,
		s32	arg1 )

Definition at line 126 of file 2BF90.c.

                                       {
    AmbiencePlayer* player = &gAuAmbienceManager->players[index];
 
    if (player->mseqReadStart != NULL && player->mseqReadPos != NULL) {
        if (time != 0) {
            player->fadeSettingsInitial = 255;
            player->fadeSettingsTime = time;
            player->fadeSettingsGoal = 0;
            player->fadeSettingsType = AMB_FADE_OUT_PAUSING;
            return;
        }
        player->mode = AMB_MODE_PAUSING;
    }
}

Referenced by snd_ambient_pause().

au_amb_resume()

void au_amb_resume	(	s32	arg0,
		s32	arg1 )

Definition at line 141 of file 2BF90.c.

                                        {
    AmbiencePlayer* player = &gAuAmbienceManager->players[index];
 
    if (player->mseqReadStart != NULL && player->mseqReadPos != NULL) {
        player->mode = AMB_MODE_RESUMING;
        if (time != 0) {
            player->fadeSettingsTime = time;
        } else {
            player->fadeSettingsTime = SND_MIN_DURATION;
        }
        player->fadeSettingsInitial = 0;
        player->fadeSettingsGoal = SND_MAX_VOLUME_8;
        player->fadeSettingsType = AMB_FADE_IN;
    }
}

Referenced by snd_ambient_resume().

au_amb_stop_quick()

void au_amb_stop_quick

(

s32

arg0

)

Definition at line 157 of file 2BF90.c.

                                  {
    AmbiencePlayer* player = &gAuAmbienceManager->players[index];
 
    if (player->mseqReadStart != NULL && player->mseqReadPos != NULL) {
        if (player->mode != AMB_MODE_NORMAL) {
            player->mseqReadPos = NULL;
            player->mseqName = 0;
            player->mode = AMB_MODE_NORMAL;
            return;
        }
        player->mseqReadPos = BlankMseqData;
        player->delay = 1;
    }
}

Referenced by snd_ambient_stop_quick().

au_amb_stop_slow()

void au_amb_stop_slow	(	s32	arg0,
		s32	arg1 )

Definition at line 172 of file 2BF90.c.

                                           {
    AmbiencePlayer* player = &gAuAmbienceManager->players[index];
 
    if (player->mseqReadStart != NULL && player->mseqReadPos != NULL) {
        if (time != 0) {
            player->fadeSettingsTime = time;
        } else {
            player->fadeSettingsTime = SND_MIN_DURATION;
        }
        player->fadeSettingsInitial = 255;
        player->fadeSettingsGoal = 0;
        player->fadeSettingsType = AMB_FADE_OUT;
    }
}

Referenced by snd_ambient_stop_slow().

au_amb_set_volume()

void au_amb_set_volume	(	s32	arg0,
		s32	arg1,
		s32	arg2 )

Definition at line 187 of file 2BF90.c.

                                                        {
    AmbiencePlayer* player = &gAuAmbienceManager->players[index];
    if ((player->mseqReadStart != 0) && (player->mseqReadPos != 0)) {
        if (volume <= 0) {
            volume = 1;
        } else if (volume > SND_MAX_VOLUME_8) {
            volume = SND_MAX_VOLUME_8;
        }
        if (time != 0) {
            player->fadeSettingsTime = time;
        } else {
            player->fadeSettingsTime = SND_MIN_DURATION;
        }
        player->fadeSettingsInitial = 255;
        player->fadeSettingsGoal = volume;
        player->fadeSettingsType = AMB_FADE_IN;
    }
}

Referenced by snd_ambient_set_volume().

au_amb_is_stopped()

AuResult au_amb_is_stopped

(

s32

arg0

)

Definition at line 206 of file 2BF90.c.

                                      {
    AmbiencePlayer* player = &gAuAmbienceManager->players[index];
    AuResult status = AU_RESULT_OK;
 
    if (player->mseqReadStart != NULL && player->mseqReadPos != NULL) {
        status = AU_AMBIENCE_ERROR_1;
        if (player->mode != AMB_MODE_NORMAL) {
            status = AU_AMBIENCE_ERROR_2;
        }
    }
    return status;
}

Referenced by snd_ambient_is_stopped().

au_amb_play_sequence()

void au_amb_play_sequence	(	AmbienceManager *	arg0,
		MSEQHeader *	mseq,
		s32	index )

Definition at line 219 of file 2BF90.c.

                                                                                     {
    AmbiencePlayer* player;
    AmbienceTrack* track;
    AuFilePos readPos;
    s32 i;
 
    player = &manager->players[index];
    au_memset(player, sizeof(*player), 0);
 
    player->mseqFile = mseqFile;
    readPos = AU_FILE_RELATIVE(mseqFile->dataStart, mseqFile);
    player->id.playerIndex = index;
    player->mseqReadPos = readPos;
    player->loopStartPos[1] = readPos;
    player->loopStartPos[0] = readPos;
    player->mseqReadStart = readPos;
 
    player->delay = 1;
    player->fadeVolume = 0x7F000000;
    player->fadeGoal = 0x7F;
 
    player->mseqName = player->mseqFile->name;
    player->firstVoiceIdx = player->mseqFile->firstVoiceIdx;
    player->lastVoiceIdx = player->firstVoiceIdx + 16;
    if (player->lastVoiceIdx > 24) {
        player->lastVoiceIdx = 24;
    }
    for (i = 0; i < ARRAY_COUNT(player->tracks); i++) {
        track = &player->tracks[i];
        track->instrument = manager->globals->defaultInstrument;
        track->volumeLerp.current = 0x7FFFFFFF;
        track->pan = 64;
    }
    player->resetRequired = TRUE;
}

Referenced by au_amb_start().

au_amb_manager_update()

void au_amb_manager_update

(

AmbienceManager *

arg0

)

Definition at line 255 of file 2BF90.c.

                                                     {
    u32 i;
    s32 j;
 
    for (i = 0; i < ARRAY_COUNT(manager->voiceStates); i++) {
        AmbienceVoiceState* voiceState = &manager->voiceStates[i];
 
        if (voiceState->info.released == TRUE && manager->globals->voices[i].priority != manager->priority) {
            voiceState->info.all = 0;
        }
    }
 
    for (j = 0; j < ARRAY_COUNT(manager->players); j++) {
        AmbiencePlayer* player = &manager->players[j];
        s32 mode;
 
        if (player->mseqReadPos != NULL) {
            if (manager->loadTracksFadeInfo) {
                au_amb_load_track_fade_info(manager, player);
            }
 
            mode = player->mode;
            if (mode != AMB_MODE_NORMAL) {
                if (mode == AMB_MODE_PAUSING) {
                    player->mode = AMB_MODE_STOPPED;
                    au_amb_save_voices(manager, player);
                    au_amb_player_stop(manager, player);
                } else if (player->mode == AMB_MODE_RESUMING) {
                    player->mode = AMB_MODE_NORMAL;
                    if (player->fadeSettingsTime != 0) {
                        au_amb_fade_setup(player);
                    }
                    au_amb_restore_voices(manager, player);
                }
            } else {
                // case AMB_MODE_NORMAL
                if (player->fadeSettingsTime != 0) {
                    au_amb_fade_setup(player);
                }
                if (player->playState == AMB_PLAYER_STOPPING) {
                    au_amb_player_stop(manager, player);
                    player->playState = AMB_PLAYER_STOPPED;
                }
                au_amb_player_update(manager, player);
            }
        }
    }
 
    manager->loadTracksFadeInfo = FALSE;
}

Referenced by au_update_clients_2().

au_amb_load_track_fade_info()

void au_amb_load_track_fade_info	(	AmbienceManager *	manager,
		AmbiencePlayer *	lambda )

Definition at line 306 of file 2BF90.c.

                                                                                   {
    MSEQHeader* mseqFile;
    MSEQTrackData* trackData;
    AmbienceTrack* track;
    s32 offset;
    s32 count;
 
    mseqFile = player->mseqFile;
    count = mseqFile->trackSettingsCount;
    if (count != 0 && mseqFile->trackSettingsOffset != 0) {
        trackData = AU_FILE_RELATIVE(mseqFile->trackSettingsOffset, mseqFile);
        while (count--) {
            track = &player->tracks[trackData->trackIndex];
            if (trackData->type == 0) {
                track->tuneLerp.time = trackData->time;
                track->tuneLerp.step = (trackData->delta << 0x10) / trackData->time;
                track->tuneLerp.goal = trackData->goal;
            } else if (trackData->type == 1) {
                track->volumeLerp.time = trackData->time;
                track->volumeLerp.step = (trackData->delta << 0x10) / trackData->time;
                track->volumeLerp.goal = trackData->goal;
            }
            trackData++;
        }
    }
}

Referenced by au_amb_manager_update().

au_amb_player_update()

void au_amb_player_update	(	AmbienceManager *	manager,
		AmbiencePlayer *	lambda )

Definition at line 333 of file 2BF90.c.

                                                                            {
    u8 isVolumeChanged[16];
    u8 isPitchChanged[16];
    AuGlobals* globals;
    u8 fadeVolChanged;
    AmbienceVoiceState* voiceState;
    AuVoice* voice;
    BGMDrumInfo* drum;
    u32 trackIdx;
    s32 temp;
    s32 i;
    u16 bankPatch;
    u32 count;
    s32 loopId;
    u8 op, arg1, arg2;
    AmbienceTrack* track;
 
    globals = manager->globals;
    fadeVolChanged = FALSE;
    for (i = 0; i < 16U; i++) { // required to use unsigned literal
        isVolumeChanged[i] = FALSE;
        isPitchChanged[i] = FALSE;
    }
 
    if (player->resetRequired == TRUE) {
        au_amb_player_stop(manager, player);
        player->resetRequired = FALSE;
    }
 
    if (player->fadeTime != 0) {
        player->fadeVolume += player->fadeStep;
        player->fadeTime--;
        if (player->fadeTime == 0) {
            player->fadeVolume = player->fadeGoal << 0x18;
            if (player->fadeSettingsType == AMB_FADE_IN) {
                // do nothing
            } else if (player->fadeSettingsType == AMB_FADE_OUT) {
                player->mseqReadPos = BlankMseqData;
                player->delay = 1;
            } else if (player->fadeSettingsType == AMB_FADE_OUT_PAUSING) {
                player->mode = AMB_MODE_PAUSING;
            }
        }
        fadeVolChanged = TRUE;
    }
 
    // update pitch
    for (trackIdx = 0; trackIdx < ARRAY_COUNT(player->tracks); trackIdx++) {
        track = &player->tracks[trackIdx];
        if (track->tuneLerp.time != 0) {
            track->tuneLerp.time--;
            if (track->tuneLerp.time != 0) {
                track->tuneLerp.current += track->tuneLerp.step;
            } else {
                track->tuneLerp.current = track->tuneLerp.goal << 0x10;
            }
 
            temp = player->id.all + (trackIdx << 0x10);
            for (i = player->firstVoiceIdx; i < player->lastVoiceIdx; i++) {
                voiceState = &manager->voiceStates[i - player->firstVoiceIdx];
                // update all voices belonging to current track
                if ((voiceState->info.all & 0xFFFF0000) == temp) {
                    voice = &globals->voices[i];
                    if (voice->priority == manager->priority && trackIdx != TRACK_ID_DRUM) {
                        voice->pitchRatio = au_compute_pitch_ratio(voiceState->pitch + (track->tuneLerp.current >> 0x10)) * track->instrument->pitchRatio;
                        voice->syncFlags |= AU_VOICE_SYNC_FLAG_PITCH;
                        isPitchChanged[i - player->firstVoiceIdx] = TRUE;
                    }
                }
            }
        }
    }
 
    // update volume
    for (trackIdx = 0; trackIdx < ARRAY_COUNT(player->tracks); trackIdx++) {
        track = &player->tracks[trackIdx];
        if (track->volumeLerp.time != 0) {
            track->volumeLerp.time--;
            if (track->volumeLerp.time != 0) {
                track->volumeLerp.current += track->volumeLerp.step;
            } else {
                track->volumeLerp.current = track->volumeLerp.goal << 0x10;
            }
 
            temp = player->id.all + (trackIdx << 0x10);
            for (i = player->firstVoiceIdx; i < player->lastVoiceIdx; i++) {
                voiceState = &manager->voiceStates[i - player->firstVoiceIdx];
                // update all voices belonging to current track
                if ((voiceState->info.all & 0xFFFF0000) == temp) {
                    voice = &globals->voices[i];
                    if (voice->priority == manager->priority) {
                        track = &player->tracks[voiceState->info.trackIndex];
                        voice->clientVolume = ((player->fadeVolume >> 0x18) * (track->volumeLerp.current >> 0x10) * voiceState->volume) >> 0xE;
                        voice->envelopeFlags |= AU_VOICE_ENV_FLAG_VOL_CHANGED;
                    }
                }
            }
        }
    }
 
    player->delay--;
    if (player->delay <= 0) {
        while (player->delay == 0) {
            op = au_amb_read_next(player);
            if ((s8)op >= 0) {
                if (op == 0) {
                    // stop
                    player->mseqReadPos = NULL;
                    player->mseqName = 0;
                    au_amb_player_stop(manager, player);
                    break;
                }
                if (op >= 0x78) {
                    // long delay
                    player->delay = ((op & 7) << 8) + au_amb_read_next(player) + 0x78;
                } else {
                    //short delay
                    player->delay = op;
                }
                continue;
            }
 
            // op >= 0x80
            // op & 0xF0 : command
            // op & 0xF : track index
 
            arg1 = au_amb_read_next(player);
            trackIdx = op & 0xF;
            track = &player->tracks[trackIdx];
 
            switch (op & 0xF0) {
                case MSEQ_CMD_80_STOP_SOUND:
                    // arg1: sound index
                    if (player->playState == AMB_PLAYER_PLAYING) {
                        temp = player->id.all + (trackIdx << 0x10) + (arg1 << 8);
                        for (i = player->firstVoiceIdx; i < player->lastVoiceIdx; i++) {
                            if (manager->voiceStates[i - player->firstVoiceIdx].info.all == temp) {
                                manager->voiceStates[i - player->firstVoiceIdx].info.released = 1;
                                voice = &globals->voices[i];
                                if (voice->priority == manager->priority) {
                                    voice->envelopeFlags |= AU_VOICE_ENV_FLAG_KEY_RELEASED;
                                }
                            }
                        }
                    }
                    break;
                case MSEQ_CMD_90_PLAY_SOUND:
                    // arg1: pitch or drum sound id
                    // arg2: volume
                    arg2 = au_amb_read_next(player);
                    if (player->playState == AMB_PLAYER_PLAYING) {
                        // find free voice
                        for (i = player->firstVoiceIdx; i < player->lastVoiceIdx; i++) {
                            voice = &globals->voices[i];
                            if (voice->priority == AU_PRIORITY_FREE) {
                                break;
                            }
                        }
                        if (i >= player->lastVoiceIdx) {
                            // use another ambience voice
                            for (i = player->firstVoiceIdx; i < player->lastVoiceIdx; i++) {
                                voice = &globals->voices[i];
                                if (voice->priority == manager->priority) {
                                    au_reset_voice(voice, i);
                                    break;
                                }
                            }
                        }
                        if (i >= player->lastVoiceIdx) {
                            // try stealing voice with lower priority
                            for (i = player->firstVoiceIdx; i < player->lastVoiceIdx; i++) {
                                voice = &globals->voices[i];
                                if (voice->priority < manager->priority) {
                                    au_reset_voice(voice, i);
                                    break;
                                }
                            }
                        }
                        if (i < player->lastVoiceIdx) {
                            isVolumeChanged[i - player->firstVoiceIdx] = TRUE;
                            isPitchChanged[i - player->firstVoiceIdx] = TRUE;
                            voiceState = &manager->voiceStates[i - player->firstVoiceIdx];
                            // set playerIndex, trackIndex and tune
                            voiceState->info.all = player->id.all + (trackIdx << 0x10) + (arg1 << 8);
                            if (track->flags & 1) {
                                voiceState->isResumable = TRUE;
                            } else {
                                voiceState->isResumable = FALSE;
                            }
                            if (trackIdx != TRACK_ID_DRUM) {
                                if (track->flags & 1) {
                                    voiceState->isResumable = TRUE;
                                } else {
                                    voiceState->isResumable = FALSE;
                                }
 
                                voiceState->pitch = (arg1 & 0x7F) * 100 - track->instrument->keyBase;
                                voiceState->volume = arg2 & 0x7F;
                                voice->clientVolume = ((player->fadeVolume >> 0x18) * (track->volumeLerp.current >> 0x10) * voiceState->volume) >> 0xE;
                                voice->pitchRatio = au_compute_pitch_ratio(voiceState->pitch + (track->tuneLerp.current >> 0x10)) * track->instrument->pitchRatio;
                                voice->pan = track->pan;
                                voice->reverb = track->reverb;
                                voice->instrument = track->instrument;
                                voice->busId = manager->busId;
                                voice->envelope.cmdListPress = track->envelope.cmdListPress;
                                voice->envelope.cmdListRelease = track->envelope.cmdListRelease;
                            } else {
                                voiceState->isResumable = FALSE;
                                drum = &manager->globals->dataPER->drums[arg1 & 0x7F];
                                bankPatch = drum->bankPatch;
                                voice->instrument = au_get_instrument(manager->globals, bankPatch >> 8, bankPatch & 0xFF, &voice->envelope);
                                voiceState->pitch = drum->keyBase - voice->instrument->keyBase;
                                voiceState->volume = ((arg2 & 0x7F) * drum->volume) >> 7;
                                voice->clientVolume = ((player->fadeVolume >> 0x18) * (track->volumeLerp.current >> 0x10) * voiceState->volume) >> 0xE;
                                voice->pitchRatio = au_compute_pitch_ratio(voiceState->pitch) * voice->instrument->pitchRatio;
                                voice->pan = drum->pan;
                                voice->reverb = drum->reverb;
                                voice->busId = manager->busId;
                            }
                            voice->syncFlags = AU_VOICE_SYNC_FLAG_ALL;
                            voice->priority = manager->priority;
                            voice->clientPriority = voice->priority;
                        }
                    }
                    break;
                case MSEQ_CMD_A0_SET_VOLUME_PAN:
                    // higher bit: set pan (1) or volume (0)
                    // lower 7 bits: value
                    if (arg1 & 0x80) {
                        track->pan = arg1 & 0x7F;
                        temp = player->id.all + (trackIdx << 0x10);
                        for (i = player->firstVoiceIdx; i < player->lastVoiceIdx; i++) {
                            voiceState = &manager->voiceStates[i - player->firstVoiceIdx];
                            if ((voiceState->info.all & 0xFFFF0000) == temp) {
                                voice = &globals->voices[i];
                                if (voice->priority == manager->priority && trackIdx != TRACK_ID_DRUM) {
                                    voice->pan = track->pan;
                                    voice->syncFlags |= AU_VOICE_SYNC_FLAG_PAN_FXMIX;
                                }
                            }
                        }
                    } else {
                        track->volumeLerp.current = arg1 << 0x18;
                        if (track->volumeLerp.current != 0) {
                            track->volumeLerp.current |= 0xFFFFFF;
                        }
                        temp = player->id.all + (trackIdx << 0x10);
                        for (i = player->firstVoiceIdx; i < player->lastVoiceIdx; i++) {
                            voiceState = &manager->voiceStates[i - player->firstVoiceIdx];
                            if ((voiceState->info.all & 0xFFFF0000) == temp) {
                                voice = &globals->voices[i];
                                if (voice->priority == manager->priority) {
                                    voice->clientVolume = ((player->fadeVolume >> 0x18) * (track->volumeLerp.current >> 0x10) * voiceState->volume) >> 0xE;
                                    if (!isVolumeChanged[i - player->firstVoiceIdx]) {
                                        voice->envelopeFlags |= AU_VOICE_ENV_FLAG_VOL_CHANGED;
                                        isVolumeChanged[i - player->firstVoiceIdx] = TRUE;
                                    }
                                }
                            }
                        }
                    }
                    break;
                case MSEQ_CMD_B0_MULTI:
                    // arg1: sub command
                    // arg2: depends on sub command
                    arg2 = au_amb_read_next(player);
                    switch (arg1) {
                        case MSEQ_CMD_SUB_66_START_LOOP:
                            // arg2: loop id
                            player->loopStartPos[arg2 & 1] = player->mseqReadPos;
                            break;
                        case MSEQ_CMD_SUB_67_END_LOOP:
                            // arg2 lower bit: loop id
                            // (arg2 & 0x7C) >> 2: loop count
                            loopId = arg2 & 1;
                            count = (arg2 & 0x7C) >> 2;
                            if (count != 0) {
                                if (player->loopCount[loopId] != 0) {
                                    player->loopCount[loopId]--;
                                    // if it's the last iteration then don't jump to the loop start
                                    if (player->loopCount[loopId] != 0) {
                                        player->mseqReadPos = player->loopStartPos[loopId];
                                    }
                                } else {
                                    // first iteration, set loop counter
                                    player->mseqReadPos = player->loopStartPos[loopId];
                                    player->loopCount[loopId] = count;
                                }
                            } else {
                                // infinite loop
                                player->mseqReadPos = player->loopStartPos[loopId];
                                player->loopCount[loopId] = 0;
                            }
                            break;
                        case MSEQ_CMD_SUB_68_SET_REVERB:
                            track->reverb = arg2;
                            break;
                        case MSEQ_CMD_SUB_69_SET_RESUMABLE:
                            if (arg2 == 1) {
                                track->flags |= 1;
                            }
                            break;
                    }
                    break;
                case MSEQ_CMD_C0_SET_INSTRUMENT:
                    // arg1: bank
                    // arg2: patch
                    arg2 = au_amb_read_next(player);
                    if (trackIdx != TRACK_ID_DRUM) {
                        track->instrument = au_get_instrument(manager->globals, arg1, arg2, &track->envelope);
                    }
                    break;
                case MSEQ_CMD_E0_TUNING:
                    // arg1: coarse tune
                    // arg2: fine tune
                    track->tuneLerp.current = (arg1 << 0x18) + (au_amb_read_next(player) << 0x10);
                    temp = player->id.all + (trackIdx << 0x10);
                    for (i = player->firstVoiceIdx; i < player->lastVoiceIdx; i++) {
                        voiceState = &manager->voiceStates[i - player->firstVoiceIdx];
                        if ((voiceState->info.all & 0xFFFF0000) == temp) {
                            voice = &globals->voices[i];
                            if (voice->priority == manager->priority && trackIdx != TRACK_ID_DRUM) {
                                voice->pitchRatio = au_compute_pitch_ratio(voiceState->pitch + (track->tuneLerp.current >> 0x10)) * track->instrument->pitchRatio;
                                voice->syncFlags |= AU_VOICE_SYNC_FLAG_PITCH;
                                isPitchChanged[i - player->firstVoiceIdx] = 1;
                            }
                        }
                    }
                    break;
                case 0xF0: // required to match
                    break;
            }
        }
    }
    if (fadeVolChanged) {
        for (i = player->firstVoiceIdx; i < player->lastVoiceIdx; i++) {
            voiceState = &manager->voiceStates[i - player->firstVoiceIdx];
            // update all voices belonging to this player
            if ((voiceState->info.all & 0xFF000000) == player->id.all) {
                voice = &globals->voices[i];
                if (voice->priority == manager->priority && !isVolumeChanged[i - player->firstVoiceIdx]) {
                    track = &player->tracks[voiceState->info.trackIndex];
                    voice->clientVolume = ((player->fadeVolume >> 0x18) * (track->volumeLerp.current >> 0x10) * voiceState->volume) >> 0xE;
                    voice->envelopeFlags |= AU_VOICE_ENV_FLAG_VOL_CHANGED;
                }
            }
        }
    }
}

Referenced by au_amb_manager_update().

au_amb_read_next()

u8 au_amb_read_next

(

AmbiencePlayer *

arg0

)

Definition at line 683 of file 2BF90.c.

                                           {
    u8 value = *state->mseqReadPos++;
    return value;
}

Referenced by au_amb_player_update().

au_amb_player_stop()

void au_amb_player_stop	(	AmbienceManager *	arg0,
		AmbiencePlayer *	arg1 )

Definition at line 688 of file 2BF90.c.

                                                                          {
    AuVoice* voice;
    AmbienceVoiceState* voiceState;
    s32 i;
 
    for (i = player->firstVoiceIdx; i < player->lastVoiceIdx; i++) {
        voiceState = &manager->voiceStates[i - player->firstVoiceIdx];
        if (voiceState->info.playerIndex == player->id.playerIndex) {
            voice = &manager->globals->voices[i];
            if (voice->priority == manager->priority) {
                au_reset_voice(voice, i);
            }
            voiceState->info.all = 0;
        }
    }
}

Referenced by au_amb_manager_update(), and au_amb_player_update().

au_amb_save_voices()

void au_amb_save_voices	(	AmbienceManager *	arg0,
		AmbiencePlayer *	lambda )

Definition at line 705 of file 2BF90.c.

                                                                       {
    AmbienceSavedVoice* savedVoice = player->savedVoices;
    u32 numSaved = 0;
    s32 i;
 
    for (i = player->firstVoiceIdx; i < player->lastVoiceIdx; i++) {
        AmbienceVoiceState* voiceState = &arg0->voiceStates[i - player->firstVoiceIdx];
 
        if (!voiceState->isResumable) {
            continue;
        }
 
        savedVoice->trackIndex = voiceState->info.trackIndex;
        savedVoice->tune = voiceState->info.tune;
        savedVoice->volume = voiceState->volume;
 
        savedVoice++;
        numSaved++;
        if (numSaved >= ARRAY_COUNT(player->savedVoices)) {
            break;
        }
    }
}

Referenced by au_amb_manager_update().

au_amb_restore_voices()

void au_amb_restore_voices	(	AmbienceManager *	manager,
		AmbiencePlayer *	lambda )

Definition at line 729 of file 2BF90.c.

                                                                             {
    AuGlobals* globals;
    AuVoice* voice;
    AmbienceSavedVoice* savedVoice;
    AmbienceVoiceState* voiceState;
    AmbienceTrack* track;
    u32 i, j;
 
    globals = manager->globals;
    if (player->playState == AMB_PLAYER_PLAYING) {
        for (i = 0; i < ARRAY_COUNT(player->savedVoices); i++) {
            savedVoice = &player->savedVoices[i];
            if (savedVoice->tune != 0) {
                track = &player->tracks[savedVoice->trackIndex];
 
                // find first free voice
                for (j = player->firstVoiceIdx; j < player->lastVoiceIdx; j++) {
                    voice = &globals->voices[j];
                    if (voice->priority == AU_PRIORITY_FREE) {
                        break;
                    }
                }
 
                // try stealing a voice with lower priority
                if (j >= player->lastVoiceIdx) {
                    for (j = player->firstVoiceIdx; j < player->lastVoiceIdx; j++) {
                        voice = &globals->voices[j];
                        if (voice->priority < manager->priority) {
                            au_reset_voice(voice, j);
                            break;
                        }
                    }
                }
 
                if (j < player->lastVoiceIdx) {
                    voiceState = &manager->voiceStates[j - player->firstVoiceIdx];
                    voiceState->info.all = player->id.all + (savedVoice->trackIndex << 0x10) + (savedVoice->tune << 8);
                    voiceState->pitch = (savedVoice->tune & 0x7F) * 100 - track->instrument->keyBase;
                    voiceState->volume = savedVoice->volume & 0x7F;
                    voice->clientVolume = ((player->fadeVolume >> 0x18) * (track->volumeLerp.current >> 0x10) * voiceState->volume) >> 0xE;
                    voice->pitchRatio = au_compute_pitch_ratio(voiceState->pitch + (track->tuneLerp.current >> 0x10)) * track->instrument->pitchRatio;
                    voice->pan = track->pan;
                    voice->reverb = track->reverb;
                    voice->instrument = track->instrument;
                    voice->busId = manager->busId;
                    voice->envelope.cmdListPress = track->envelope.cmdListPress;
                    voice->envelope.cmdListRelease = track->envelope.cmdListRelease;
                    voice->syncFlags = AU_VOICE_SYNC_FLAG_ALL;
                    voice->priority = manager->priority;
                    voice->clientPriority = voice->priority;
                }
            }
            savedVoice->trackIndex = 0;
            savedVoice->tune = 0;
            savedVoice->volume = 0;
        }
    }
}

Referenced by au_amb_manager_update().

au_update_stopped_voices()

void au_update_stopped_voices

(

AuGlobals *

globals

)

Definition at line 4 of file 2d9a0_len_890.c.

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

au_init_voices()

void au_init_voices

(

AuGlobals *

globals

)

Definition at line 19 of file 2d9a0_len_890.c.

                                        {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(globals->voices); i++) {
        AuVoice* voice = &globals->voices[i];
 
        voice->cmdPtr = NULL;
        voice->unk_20 = 0;
        voice->volChangeTime = 0;
        voice->timeLeft = 0;
        voice->timeIntervalIndex = 0;
        voice->unk_3C = 0;
        voice->envelopeFlags = 0;
        voice->relativeReleaseVolumes = FALSE;
        voice->releaseVolumeMult = 0x80;
    }
}

Referenced by au_engine_init().

au_update_voices()

void au_update_voices

(

AuGlobals *

globals

)

Definition at line 37 of file 2d9a0_len_890.c.

                                          {
    AuVoice* voice;
    s8 var_a0;
    s16 currentAmp;
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(globals->voices); i++) {
        voice = &globals->voices[i];
        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_STOP;
            voice->cmdPtr = (u8*)voice->envelope.cmdListRelease;
 
            // the key can be released before press cmdlist processed completely, we must handle this case properly
            if (voice->timeLeft > AU_5750) {
                voice->initialAmp = voice->initialAmp + (s32) (voice->rate * (f32) (voice->volChangeTime - voice->timeLeft));
            } else {
                voice->initialAmp = voice->targetAmp;
            }
 
            voice->timeIntervalIndex = *voice->cmdPtr++;
            var_a0 = *voice->cmdPtr;
            if (*(s8*)voice->cmdPtr++ < 0) {
                // in this case release volumes are relative to last press volume
                var_a0 &= 0x7F;
                voice->relativeReleaseVolumes = TRUE;
                voice->releaseVolumeMult = voice->initialAmp;
            }
            voice->targetAmp = var_a0;
 
            voice->timeLeft = AuEnvelopeIntervals[voice->timeIntervalIndex];
            voice->volChangeTime = voice->timeLeft;
            if (voice->envelopeFlags & AU_VOICE_ENV_FLAG_VOL_CHANGED) {
                voice->envelopeFlags &= ~AU_VOICE_ENV_FLAG_VOL_CHANGED;
                if (voice->timeLeft > AU_5750) {
                    voice->timeLeft -= AU_5750;
                    voice->envelopeFlags |= AU_VOICE_ENV_FLAG_HANDLED_VOL_CHANGE;
                    currentAmp = voice->initialAmp + (s32) (voice->rate * (voice->volChangeTime - voice->timeLeft));
                } else {
                    currentAmp = voice->targetAmp;
                }
                voice->delta = AUDIO_SAMPLES;
            } else {
                voice->delta = au_voice_get_delta(voice->volChangeTime);
                currentAmp = voice->targetAmp;
            }
            voice->p_volume = (((currentAmp * voice->clientVolume * voice->releaseVolumeMult) >> 0xE) * voice->volMult) >> 7;
            voice->syncFlags |= AU_VOICE_SYNC_FLAG_PARAMS;
        } else {
            if (voice->timeLeft == -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->p_volume = (((voice->initialAmp * voice->clientVolume * voice->releaseVolumeMult) >> 0xE) * voice->volMult) >> 7;
                    voice->syncFlags |= AU_VOICE_SYNC_FLAG_PARAMS;
                }
            } else {
                voice->timeLeft -= AU_5750;
                if (voice->timeLeft <= 0) {
                    if (*voice->cmdPtr == ENV_CMD_END) {
                        if (voice->envelopeFlags & AU_VOICE_ENV_FLAG_STOP) {
                            // if we reached the end after key release, stop the voice completely
                            voice->envelopeFlags = 0;
                            voice->cmdPtr = NULL;
                            voice->stopPending = TRUE;
                        } else {
                            // we reached the end of press cmdlist, keep the last volume until the key is released
                            voice->timeLeft = -1;
                            voice->volChangeTime = -1;
                            voice->timeIntervalIndex = ENV_TIME_300MS; // doesn't seem to affect anything
                            voice->delta = AUDIO_SAMPLES;
                            voice->rate = 0.0f;
                            voice->initialAmp = voice->targetAmp;
                        }
                    } else {
                        // get next envelope point
                        voice->timeIntervalIndex = au_voice_step(voice);
                        voice->initialAmp = voice->targetAmp;
                        voice->targetAmp = (*voice->cmdPtr++) & 0x7F;
                        voice->timeLeft = AuEnvelopeIntervals[voice->timeIntervalIndex];
                        voice->volChangeTime = voice->timeLeft;
                        if (voice->volChangeTime != 0) {
                            voice->rate = ((f32) voice->targetAmp - (f32) voice->initialAmp) / (f32) voice->volChangeTime;
                        } else {
                            voice->rate = 0.0f;
                        }
                        if (voice->envelopeFlags & AU_VOICE_ENV_FLAG_VOL_CHANGED) {
                            voice->envelopeFlags &= ~AU_VOICE_ENV_FLAG_VOL_CHANGED;
                            if (voice->timeLeft > AU_5750) {
                                voice->timeLeft -= AU_5750;
                                voice->envelopeFlags |= AU_VOICE_ENV_FLAG_HANDLED_VOL_CHANGE;
                                currentAmp = voice->initialAmp + (s32) (voice->rate * (voice->volChangeTime - voice->timeLeft));
                            } else {
                                currentAmp = voice->targetAmp;
                            }
                            voice->delta = AUDIO_SAMPLES;
                        } else {
                            voice->delta = au_voice_get_delta(voice->volChangeTime);
                            currentAmp = voice->targetAmp;
                        }
                        voice->p_volume = (((currentAmp * voice->clientVolume * voice->releaseVolumeMult) >> 0xE) * voice->volMult) >> 7;
                        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->timeLeft > AU_5750) {
                            voice->timeLeft -= AU_5750;
                            voice->envelopeFlags |= AU_VOICE_ENV_FLAG_HANDLED_VOL_CHANGE;
                            currentAmp = voice->initialAmp + (s32) (voice->rate * (voice->volChangeTime - voice->timeLeft));
                        } else {
                            currentAmp = voice->targetAmp;
                        }
                        voice->delta = AUDIO_SAMPLES;
                        voice->p_volume = (((currentAmp * voice->clientVolume * voice->releaseVolumeMult) >> 0xE) * voice->volMult) >> 7;
                        voice->syncFlags |= AU_VOICE_SYNC_FLAG_PARAMS;
                    }
                }
            }
        }
    }
}

Referenced by au_update_clients_2().

au_voice_after_volume_change()

void au_voice_after_volume_change

(

AuVoice *

arg0

)

Definition at line 170 of file 2d9a0_len_890.c.

                                                  {
    voice->p_volume = (((voice->targetAmp * voice->clientVolume * voice->releaseVolumeMult) >> 14) * voice->volMult) >> 7;
    voice->delta = au_voice_get_delta(voice->timeLeft);
    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

arg0

)

Definition at line 177 of file 2d9a0_len_890.c.

                                  {
    return (msecs / AU_5750) * 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 *	arg1 )

Definition at line 181 of file 2d9a0_len_890.c.

                                                           {
    s32 intervalIndex;
 
    voice->envelope.cmdListPress = envData->cmdListPress;
    voice->cmdPtr = voice->envelope.cmdListPress;
    voice->envelope.cmdListRelease = envData->cmdListRelease;
    voice->volMult = 0x80;
    voice->loopStart = NULL;
 
    intervalIndex = au_voice_step(voice);
    voice->envelopeFlags = 0;
    voice->initialAmp = 0;
    voice->targetAmp = *voice->cmdPtr++;
    voice->timeIntervalIndex = intervalIndex;
    voice->volChangeTime = AuEnvelopeIntervals[intervalIndex];
    voice->timeLeft = voice->volChangeTime;
 
    voice->p_volume = (voice->targetAmp * voice->clientVolume * voice->volMult) >> 14;
    voice->delta = au_voice_get_delta(voice->volChangeTime);
    if (voice->volChangeTime != 0) {
        voice->rate = ((f32) voice->targetAmp - (f32) voice->initialAmp) / voice->volChangeTime;
    } else {
        voice->rate = 0.0f;
    }
    voice->relativeReleaseVolumes = FALSE;
    voice->releaseVolumeMult = 0x80;
}

Referenced by au_syn_update().

au_voice_step()

u8 au_voice_step

(

AuVoice *

voice

)

Definition at line 210 of file 2d9a0_len_890.c.

                                 {
    u32 op;
    u8 arg;
 
    while (TRUE) {
        if (((s8)(op = *voice->cmdPtr++)) >= 0) {
            break;
        }
        switch ((u8)op) {
            case ENV_CMD_SET_MULTIPLIER:
                arg = *voice->cmdPtr++;
                if (arg > 0x80) {
                    arg = 0x80;
                }
                voice->volMult = arg;
                break;
            case ENV_CMD_ADD_MULTIPLIER:
                voice->volMult += (s8) *voice->cmdPtr++;
                if (voice->volMult > 0x80) {
                    voice->volMult = 0x80;
                } else if (voice->volMult < 0) {
                    voice->volMult = 0;
                }
                break;
            case ENV_CMD_START_LOOP:
                voice->loopCounter = *voice->cmdPtr++; // 0 means 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:
                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 *

arg0

)

Definition at line 253 of file 2d9a0_len_890.c.

                                              {
    voice->envelopeFlags |= AU_VOICE_ENV_FLAG_VOL_CHANGED;
}

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

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

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

arg0

)

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

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 *	arg3 )

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 **	outCurrentTrackData,
		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	arg0,
		BGMHeader *	arg1,
		BGMPlayer *	arg2 )

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 *	arg1 )

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

arg0

)

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 *	arg2 )

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

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

arg0

)

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

create_audio_system()

void create_audio_system

(

void

)

Definition at line 39 of file 25f00_len_940.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(32000);
    frameSize = (nusched.retraceCount * outputRate + 59) / 60;
    config.outputRate = outputRate;
    config.unk_0C = 0;
    config.heap = &nuAuHeap;
    config.dmaNew = nuAuDmaNew;
    AlFrameSize = ((frameSize / AUDIO_SAMPLES) + 1) * AUDIO_SAMPLES;
    AlMinFrameSize = AlFrameSize - AUDIO_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, NU_MAIN_THREAD_ID, nuAuMgr, NULL, &AuStack[NU_AU_STACK_SIZE / sizeof(u64)], NU_AU_MGR_THREAD_PRI); //why main thread?
    osStartThread(&nuAuMgrThread);
}

nuAuMgr()

void nuAuMgr

(

void *

arg

)

Definition at line 110 of file 25f00_len_940.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_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	arg3 )

Definition at line 194 of file 25f00_len_940.c.

                                                             {
    NUDMABuffer* dmaPtr;
    NUDMABuffer* freeBuffer;
    OSIoMesg* mesg;
    s32 delta;
    u32 startAddr;
    s32 addrEnd, buffEnd;
    NUDMABuffer* lastDmaPtr;
 
    if (arg3 == 0) {
        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_load_BK_headers()

void au_load_BK_headers	(	AuGlobals *	arg0,
		ALHeap *	heap )

Definition at line 10 of file 303c0_len_3e10.c.

                                                          {
    SBNFileEntry fileEntry;
    BufferEntry buffer[80];
    s32 i;
 
    au_read_rom(globals->bkFileListOffset, &buffer, globals->bkListLength);
 
    for (i = 0; i < ARRAY_COUNT(buffer); i++) {
        if (buffer[i].fileIndex == 0xFFFF) {
            break;
        }
 
        au_fetch_SBN_file(buffer[i].fileIndex, AU_FMT_BK, &fileEntry);
        au_load_BK_to_bank(fileEntry.offset, NULL, buffer[i].bankIndex, buffer[i].bankGroup);
    }
}

Referenced by au_engine_init().

au_sfx_init()

void au_sfx_init	(	SoundManager *	manager,
		u8	arg1,
		u8	arg2,
		AuGlobals *	arg3,
		u8	arg4 )

Definition at line 423 of file sfx_player.c.

                                                                                                   {
    u32 i;
    s32 c = 434782;
 
    manager->globals = globals;
    manager->nextUpdateStep = 312500;
    manager->nextUpdateCounter = c;
    manager->nextUpdateInterval = c;
    manager->priority = priority;
    manager->busId = busId;
 
    if (minVoiceIdx > 16) {
        manager->sfxPlayerSelector = 16;
    } else {
        manager->sfxPlayerSelector = minVoiceIdx;
    }
 
    manager->busVolume = 0x8000;
    manager->baseVolume = 0x8000;
    manager->playCounter = 0;
    manager->randomValue = 0;
 
    for (i = 0; i < ARRAY_COUNT(manager->players); i++) {
        SoundPlayer* player = &manager->players[i];
 
        player->sefDataReadPos = NULL;
        player->sfxVolume = 0;
        player->delay = 0;
        player->playLength = 0;
        player->coarseTune = 0;
        player->fineTune = 0;
        player->sfxPan = 0;
        player->reverb = 0;
        player->instrumentIndex = 0;
        player->envelopePreset = 0;
        player->playVelocity = 0;
        player->exclusiveID = 0;
        player->cmdList_mode2[0] = 0;
        player->cmdList_mode2[1] = 0;
        player->cmdList_mode2[2] = 0;
        player->cmdList_mode2[3] = 64; // default pan
        player->cmdList_mode2[4] = 0;
        player->cmdList_mode2[5] = 0x80 + 48; // default tune, higher bit is meaningless
        player->cmdList_mode2[6] = 0;
        player->cmdList_mode2[7] = 0;
    }
 
    for (i = 0; i < ARRAY_COUNT(manager->bgmSounds); i++) {
        manager->bgmSounds[i].s32 = 0;
    }
 
    for (i = 0; i < ARRAY_COUNT(manager->customCmdList); i++) {
        manager->customCmdList[i].data[0] = 0;
    }
 
    manager->resetPending = FALSE;
    au_sfx_set_state(manager, SND_MANAGER_STATE_ENABLED);
    au_sfx_clear_queue(manager);
    au_fade_init(&manager->fadeInfo, 0, 0x7FFF, 0x7FFF);
    au_fade_set_volume(manager->busId, manager->fadeInfo.curVolume.u16, manager->busVolume);
    manager->lastCustomEffectIdx = 0xFF;
 
    manager->customReverbParams[0] = CUSTOM_SMALL_ROOM_PARAMS;
    manager->customReverbParams[1] = CUSTOM_ECHO_PARAMS_1;
    manager->customReverbParams[2] = CUSTOM_ECHO_PARAMS_2;
    manager->customReverbParams[3] = CUSTOM_ECHO_PARAMS_3;
    manager->customReverbParams[4] = CUSTOM_ECHO_PARAMS_3;
    manager->customReverbParams[5] = CUSTOM_ECHO_PARAMS_3;
    manager->customReverbParams[6] = CUSTOM_ECHO_PARAMS_3;
    manager->customReverbParams[7] = CUSTOM_ECHO_PARAMS_3;
 
    manager->customReverbAmounts[0] = 0x10;
    manager->customReverbAmounts[1] = 0x20;
    manager->customReverbAmounts[2] = 0x20;
    manager->customReverbAmounts[3] = 0x20;
    manager->customReverbAmounts[4] = 0x20;
    manager->customReverbAmounts[5] = 0x30;
    manager->customReverbAmounts[6] = 0x40;
    manager->customReverbAmounts[7] = 0x50;
 
    au_sfx_set_reverb_type(manager, 0);
}

Referenced by au_engine_init().

au_sfx_load_groups_from_SEF()

void au_sfx_load_groups_from_SEF

(

SoundManager *

sndMgr

)

Definition at line 506 of file sfx_player.c.

                                                        {
    SEFHeader* sefData = manager->globals->dataSEF;
    s32 sections = ARRAY_COUNT(sefData->sections);
    u32 i;
 
    manager->sefData = (u8*)sefData;
 
    for (i = 0; i < sections; i++) {
        if (sefData->sections[i] != 0) {
            manager->normalSounds[i] = AU_FILE_RELATIVE(sefData, sefData->sections[i]);
        }
    }
 
    if (sefData->hasExtraSection == 1) {
        if (sefData->section2000 != 0) {
            manager->extraSounds = AU_FILE_RELATIVE(sefData, sefData->section2000);
        }
    }
}

Referenced by au_engine_init().

au_sfx_clear_queue()

void au_sfx_clear_queue

(

SoundManager *

manager

)

Definition at line 526 of file sfx_player.c.

                                               {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(manager->soundQueue); i++) {
        manager->soundQueue[i].soundID = 0;
        manager->soundQueue[i].upperSoundID = 0;
        manager->soundQueue[i].volume = 0;
        manager->soundQueue[i].pitchShift = 0;
        manager->soundQueue[i].pan = 0;
    }
 
    manager->unk_165 = 0;
    manager->sfxQueueNextPos = 0;
    manager->sfxQueuePosOffset = 0;
    manager->unk_162 = 0;
}

Referenced by au_sfx_init().

au_sfx_enqueue_event()

void au_sfx_enqueue_event	(	SoundManager *	manager,
		u32	soundID,
		s16	volume,
		s16	pitchShift,
		u8	pan )

Definition at line 543 of file sfx_player.c.

                                                                                                  {
    u32 queuePos = manager->sfxQueueNextPos;
    s32 queueAmt = manager->sfxQueueNextPos - manager->sfxQueuePosOffset;
 
    if (queueAmt < 0) {
        queueAmt += 16;
    }
 
    if (queueAmt < 16) {
        u32 queueNextPos = queuePos;
 
        manager->soundQueue[queueNextPos].soundID = soundID & (SOUND_ID_LOWER | SOUND_ID_STOP | SOUND_ID_ADJUST | SOUND_ID_TRIGGER_MASK);
        manager->soundQueue[queueNextPos].upperSoundID = ((soundID >> 0x10) & 0x3FF);
        manager->soundQueue[queueNextPos].volume = volume;
        manager->soundQueue[queueNextPos].pitchShift = pitchShift;
        manager->soundQueue[queueNextPos].pan = pan;
 
        queueNextPos++;
        if (queueNextPos >= 16) {
            queueNextPos = 0;
        }
 
        manager->sfxQueueNextPos = queueNextPos;
    }
}

Referenced by snd_adjust_sound(), snd_adjust_sound_with_shift(), snd_start_sound(), snd_start_sound_raw(), snd_start_sound_with_shift(), and snd_stop_sound().

au_sfx_update_main()

void au_sfx_update_main

(

SoundManager *

manager

)

Definition at line 569 of file sfx_player.c.

                                               {
    SoundSFXEntry newEntry;
    SoundSFXEntry* sfxEntry;
    u32 i, j, k;
    s32 count;
 
    manager->playCounter++;
    if (manager->resetPending) {
        au_sfx_reset_players(manager);
        manager->resetPending = FALSE;
    }
 
    // sounds started by special seq command FF-05
    for (i = 0; i < ARRAY_COUNT(manager->bgmSounds); i++) {
        k = manager->bgmSounds[i].unk_0;
        if (k == 0) {
            // do nothing
        } else if (k < 2) {
            AlUnkGemini* unkData = &D_80078370[k-1];
            u16 sound2 = unkData->sound2;
            if (sound2 != 0) {
                for (j = 0; j < ARRAY_COUNT(manager->players); j++) {
                    if (manager->players[j].curSoundID == sound2) {
                        newEntry.soundID = unkData->sound1;
                        newEntry.upperSoundID = 0;
                        newEntry.pitchShift = 0;
                        if ((unkData->flags & 1) && (manager->bgmSounds[i].volume != 0)) {
                            newEntry.volume = (manager->bgmSounds[i].volume << 8) + 0xFF;
                        } else {
                            newEntry.volume = 0;
                        }
                        newEntry.pan = 0;
                        au_sfx_load_sound(manager, &newEntry, NULL);
                        break;
                    }
                }
            } else {
                newEntry.soundID = unkData->sound1;
                newEntry.upperSoundID = 0;
                newEntry.volume = 0;
                newEntry.pitchShift = 0;
                newEntry.pan = 0;
                au_sfx_load_sound(manager, &newEntry, NULL);
            }
        }
        manager->bgmSounds[i].s32 = 0;
    }
 
    // sounds started from sef command 17
    for (i = 0; i < ARRAY_COUNT(manager->customCmdList); i++) {
        if (manager->customCmdList[i].data[0] != 0) {
            newEntry.soundID = 1;
            newEntry.upperSoundID = 0;
            newEntry.volume = 0;
            newEntry.pitchShift = 0;
            newEntry.pan = 0;
            au_sfx_load_sound(manager, &newEntry, &manager->customCmdList[i]);
        }
        manager->customCmdList[i].data[0] = 0;
    }
 
    count = manager->sfxQueueNextPos - manager->sfxQueuePosOffset;
    if (count < 0) {
        count += ARRAY_COUNT(manager->soundQueue);
    }
    j = manager->sfxQueuePosOffset;
    if (count > 0 && count < ARRAY_COUNT(manager->soundQueue)) {
        for (i = 0; i < count; i++) {
            sfxEntry = &manager->soundQueue[j];
            if (sfxEntry->soundID & SOUND_ID_LOWER) {
                if (sfxEntry->soundID & SOUND_ID_STOP) {
                    au_sfx_stop_by_id(manager, sfxEntry->soundID);
                } else if (!(sfxEntry->soundID & (SOUND_ID_ADJUST | SOUND_ID_TRIGGER_MASK))) {
                    au_sfx_load_sound(manager, sfxEntry, NULL);
                } else {
                    if (sfxEntry->soundID & SOUND_ID_TRIGGER_MASK) {
                        au_sfx_set_triggers(manager, sfxEntry->soundID);
                    }
                    if (sfxEntry->soundID & SOUND_ID_ADJUST) {
                        au_sfx_set_modifiers(manager, sfxEntry);
                    }
                }
            }
            sfxEntry->soundID = SOUND_NONE;
 
            j++;
            if (j >= ARRAY_COUNT(manager->soundQueue)) {
                j = 0;
            }
        }
        manager->sfxQueuePosOffset = manager->sfxQueueNextPos;
    }
}

Referenced by au_update_players_main().

au_sfx_set_reverb_type()

s32 au_sfx_set_reverb_type	(	SoundManager *	manager,
		s32	arg1 )

Definition at line 664 of file sfx_player.c.

                                                            {
    s32 customIdx = (u8) arg1;
 
    if (customIdx != 0xF0) {
        if (customIdx < ARRAY_COUNT(manager->customReverbParams)) {
            if (manager->lastCustomEffectIdx != customIdx) {
                manager->lastCustomEffectIdx = customIdx;
                manager->globals->effectChanges[FX_BUS_SOUND].type = AU_FX_CUSTOM_0;
                manager->globals->effectChanges[FX_BUS_SOUND].changed = TRUE;
                AU_FX_CUSTOM_PARAMS[0] = manager->customReverbParams[customIdx];
            }
            manager->defaultReverbAmt = manager->customReverbAmounts[customIdx];
        } else {
            manager->lastCustomEffectIdx = 0xFF;
            manager->defaultReverbAmt = 0;
        }
    }
    return manager->lastCustomEffectIdx;
}

Referenced by au_sfx_init(), and func_80054D74().

au_sfx_set_state()

void au_sfx_set_state	(	SoundManager *	manager,
		s32	arg1 )

Definition at line 684 of file sfx_player.c.

                                                        {
    if (state == SND_MANAGER_STATE_ENABLED) {
        manager->state = SND_MANAGER_STATE_ENABLED;
    } else if (state == SND_MANAGER_STATE_DISABLED) {
        manager->state = SND_MANAGER_STATE_DISABLED;
    }
}

Referenced by au_sfx_init(), disable_sounds(), and enable_sounds().

au_sfx_load_sound()

void au_sfx_load_sound	(	SoundManager *	manager,
		SoundSFXEntry *	entry,
		SoundManagerCustomCmdList *	customSEF )

Definition at line 692 of file sfx_player.c.

                                                                                                          {
    SoundPlayer* player;
    s32 playerIndex;
    u16* cmdList;
    s32 trackCount;
    s32 foundPlayer = FALSE;
    u32 exclusiveID;
    s32 sectionIndex;
    u16 soundInfo;
    u32 priority, polyphonyMode, useSpecificPlayerMode;
    s32 v1;
    s32* normalSounds;
 
    #define NEXT_CMD trackCount--; if (trackCount <= 0 ) { break; } cmdList += 2;
 
    u32 soundIndex = (entry->soundID - 1) & 0xFF;
    u16 soundIDLower = entry->soundID & SOUND_ID_LOWER;
    u16 soundID = entry->soundID;
 
    if (soundID & SOUND_ID_UNK) {
        // sound from extra section
        soundIndex = (entry->soundID - 1) & SOUND_ID_UNK_INDEX_MASK;
        if (soundIndex < 0x140) {
            cmdList = (u16*)&manager->extraSounds[soundIndex];
            if (*cmdList != 0) {
                // check if any player is playing this sound
                for (playerIndex = 7; playerIndex >= 0; playerIndex--) {
                    player = &manager->players[playerIndex];
                    if (player->curSoundID == soundIDLower) {
                        foundPlayer = TRUE;
                        break;
                    }
                }
 
                if (!foundPlayer) {
                    //find free player
                    for (playerIndex = 7; playerIndex >= 0; playerIndex--) {
                        player = &manager->players[playerIndex];
                        if (player->sefDataReadPos == NULL) {
                            foundPlayer = TRUE;
                            break;
                        }
                    }
                }
 
                if (foundPlayer) {
                    au_sfx_play_sound(manager, player, (s8*)cmdList, entry, 0, 0);
                }
            }
        }
    } else {
        if (soundIndex >= 0xC0) {
            if (customSEF != NULL) {
                cmdList = (u16*)customSEF;
            } else {
                sectionIndex = ((soundIDLower - 1) >> 8) + 4;
                normalSounds = manager->normalSounds[sectionIndex];
                v1 = soundIndex - 0xC0;
                cmdList = (u16*)&manager->normalSounds[sectionIndex][v1];
            }
 
            if (*cmdList != 0) {
                // check if any player is playing this sound
                for (playerIndex = 7; playerIndex >= 0; playerIndex--) {
                    player = &manager->players[playerIndex];
                    if (player->curSoundID == soundIDLower) {
                        foundPlayer = TRUE;
                        break;
                    }
                }
 
                if (!foundPlayer) {
                    //find free player
                    for (playerIndex = 7; playerIndex >= 0; playerIndex--) {
                        player = &manager->players[playerIndex];
                        if (player->sefDataReadPos == NULL) {
                            foundPlayer = TRUE;
                            break;
                        }
                    }
                }
 
                if (foundPlayer) {
                    au_sfx_play_sound(manager, player, (u8*)cmdList, entry, 0, 0);
                }
            }
        } else {
            if (customSEF != NULL) {
                cmdList = (u16*)customSEF;
            } else {
                sectionIndex = ((soundID) >> 8) & 3;
                cmdList = (u16*)&manager->normalSounds[sectionIndex][soundIndex];
            }
 
            if (*cmdList != 0) {
                // read sound info chunk
                soundInfo = cmdList[1];
 
                priority = (soundInfo & 0x300) >> 8; // bits 8, 9
                polyphonyMode = (soundInfo & 0x60) >> 5; // bits 5, 6,
                useSpecificPlayerMode = soundInfo;
                useSpecificPlayerMode = (useSpecificPlayerMode & 0x80) >> 7; // bit 7
 
                if (polyphonyMode == 0) {
                    if (entry->upperSoundID != 0) {
                        for (playerIndex = 0; playerIndex < 8; playerIndex++) {
                            player = &manager->players[playerIndex];
                            if (player->curSoundID == entry->upperSoundID) {
                                foundPlayer = TRUE;
                                break;
                            }
                        }
                    }
 
                    if (useSpecificPlayerMode == 0) {
                        if (!foundPlayer) {
                            playerIndex = soundInfo & 0x7;
                            player = &manager->players[playerIndex];
                            if (player->sefDataReadPos == NULL || priority >= player->priority) {
                                au_sfx_play_sound(manager, player, AU_FILE_RELATIVE(manager->sefData, *cmdList), entry, priority, 0);
                            }
                            return;
                        }
                    }
 
                    if (!foundPlayer) {
                        // lower 4 bits of soundInfo: max playerIndex
                        // check if any player is playing this sound
                        for (playerIndex = soundInfo & 0x7; playerIndex >= 0; playerIndex--) {
                            player = &manager->players[playerIndex];
                            if (player->curSoundID == soundIDLower) {
                                foundPlayer = TRUE;
                                break;
                            }
                        }
                    }
 
                    if (!foundPlayer) {
                        // find free player
                        for (playerIndex = soundInfo & 0x7; playerIndex >= 0; playerIndex--) {
                            player = &manager->players[playerIndex];
                            if (player->sefDataReadPos == NULL) {
                                foundPlayer = TRUE;
                                break;
                            }
                        }
                    }
 
                    if (!foundPlayer) {
                        // if there is no free player try stealing one with lower priority
                        for (playerIndex = soundInfo & 0x7; playerIndex >= 0; playerIndex--) {
                            player = &manager->players[playerIndex];
                            if (player->priority < priority) {
                                foundPlayer = TRUE;
                                break;
                            }
                        }
                    }
 
                    if (!foundPlayer) {
                        playerIndex = soundInfo & 0x7;
                        player = &manager->players[playerIndex];
                        if (player->priority <= priority) {
                            foundPlayer = TRUE;
                        }
                    }
 
                    if (foundPlayer) {
                        au_sfx_play_sound(manager, player, AU_FILE_RELATIVE(manager->sefData, *cmdList), entry, priority, 0);
                    }
                } else {
                    cmdList = AU_FILE_RELATIVE(manager->sefData, *cmdList);
                    exclusiveID = (soundInfo & 0x1800) >> 11; // bits 11, 12
                    if (exclusiveID != 0) {
                        au_sfx_stop_by_exlusive_id(manager, exclusiveID);
                    } else {
                        au_sfx_stop_by_id(manager, entry->soundID);
                    }
 
                    trackCount = 2 << (polyphonyMode - 1); // 2 or 4 or 8
 
                    if (useSpecificPlayerMode != 0) {
                        for (playerIndex = 7; playerIndex >= 0; playerIndex--) {
                            if (*cmdList != 0) {
                                // first check the players that were stopped just now
                                player = &manager->players[playerIndex];
                                if (player->sefDataReadPos == BlankSEFData) {
                                    au_sfx_play_sound(manager, player, AU_FILE_RELATIVE(manager->sefData, *cmdList), entry, priority, exclusiveID);
                                    NEXT_CMD;
                                }
                            } else {
                                NEXT_CMD;
                            }
 
                        }
 
                        if (trackCount != 0) {
                            for (playerIndex = 7; playerIndex >= 0;){
                                if (*cmdList != 0) {
                                    // then check any free players
                                    player = &manager->players[playerIndex];
                                    if (player->sefDataReadPos == NULL) {
                                        au_sfx_play_sound(manager, player, AU_FILE_RELATIVE(manager->sefData, *cmdList), entry, priority, exclusiveID);
                                        NEXT_CMD;
                                    }
                                    playerIndex--;
                                } else {
                                    NEXT_CMD;
                                }
                            }
                        }
 
                        if (trackCount != 0) {
                            for (playerIndex = 7; playerIndex >= 0; playerIndex--) {
                                if (*cmdList != 0) {
                                    // then try to steal
                                    player = &manager->players[playerIndex];
                                    if (exclusiveID > player->exclusiveID && priority >= player->priority) {
                                        au_sfx_play_sound(manager, player, AU_FILE_RELATIVE(manager->sefData, *cmdList), entry, priority, exclusiveID);
                                        NEXT_CMD;
                                    }
                                } else {
                                    NEXT_CMD;
                                }
                            }
                        }
                    } else {
                        s32 i;
                        for (i = 0; i < trackCount; i++) {
                            if (*cmdList != 0) {
                                soundInfo = cmdList[1];
                                playerIndex = soundInfo & 7;
                                player = &manager->players[playerIndex];
                                priority = (soundInfo & 0x300) >> 8; // bits 8, 9
                                if (player->sefDataReadPos == NULL || priority >= player->priority) {
                                    au_sfx_play_sound(manager, player, AU_FILE_RELATIVE(manager->sefData, *cmdList), entry, priority, exclusiveID);
                                }
                                cmdList += 2;
                            }
                        }
                    }
                }
            }
        }
    }
    #undef NEXT_CMD
}

Referenced by au_sfx_update_main().

au_sfx_manager_update()

s16 au_sfx_manager_update

(

SoundManager *

manager

)

Definition at line 1080 of file sfx_player.c.

                                                 {
    SoundPlayer* player;
    AuVoice* voice;
    u32 start;
    u8 end;
    u8 i;
 
    // update pseudorandom number with fast 'good enough' method
    manager->randomValue = (u16)manager->randomValue + (u16)manager->playCounter;
 
    start = manager->sfxPlayerSelector;
    for (i = start, end = start + 8; i < end; i++) {
        player = &manager->players[i - manager->sfxPlayerSelector];
        if (player->sefDataReadPos != NULL) {
            voice = &manager->globals->voices[i];
            manager->curVoice = voice;
            if (voice->priority <= manager->priority) {
                manager->curVoiceIndex = i;
                switch (player->sfxParamsFlags & SFX_PARAM_FLAG_MODE) {
                    case SFX_PARAM_MODE_ADVANCED:
                        au_sfx_update_basic(manager, player, voice, i);
                        break;
                    case SFX_PARAM_MODE_SEQUENCE:
                        au_sfx_update_sequence(manager, player, voice, i);
                        break;
                    case SFX_PARAM_MODE_BASIC:
                        break;
                }
            } else {
                player->sefDataReadPos = NULL;
                player->curSoundID = 0;
                player->priority = 0;
            }
        }
    }
    return 0;
}

Referenced by au_update_clients_2().

au_bgm_update_main()

void au_bgm_update_main

(

BGMPlayer *

player

)

Definition at line 22 of file 28910_len_5090.c.

                                           {
    BGMHeader* bgmFile;
    BGMFileInfo* bgmData;
    s32 unkType;
    u32 segmentID;
    s32 segmentOffset;
    u32 value;
    s32 delta;
    u8 var_a1;
    u8 pos;
    u32 i;
 
    segmentID = 0;
    unkType = -1;
    player->updateCounter++;
 
    if (player->unk_258 != 0) {
        if (player->unk_258 < ARRAY_COUNT(player->unk_238)) {
            pos = player->unk_259;
            for (var_a1 = 0; var_a1 < player->unk_258; var_a1++) {
                value = player->unk_238[pos];
                if (value != 0) {
                    if (value < 16) {
                        unkType = value & 3;
                        segmentID = value >> 2;
                    }
                    pos++;
                    if (pos >= ARRAY_COUNT(player->unk_238)) {
                        pos = 0;
                    }
                }
            }
            delta = player->unk_25A - player->unk_259;
            if (delta < 0) {
                delta += ARRAY_COUNT(player->unk_238);
            }
            player->unk_258 -= delta;
            player->unk_259 = player->unk_25A;
        } else {
            player->unk_258 = 0;
        }
        if (unkType != -1) {
            if (unkType != 0) {
                if (unkType != player->unk_58) {
                    player->unk_58 = unkType & 0xFF;
                    player->unk_5A = unkType & 0xFF;
                    player->masterState = BGM_PLAY_STATE_INIT;
                    player->nextUpdateStep = BGM_SAMPLE_RATE;
                    if (unkType == 2) {
                        bgmFile = player->globals->dataBGM[1];
                    } else {
                        bgmFile = player->globals->dataBGM[0];
                    }
                    player->bgmFile = bgmFile;
                    bgmData = &bgmFile->info;
                    func_8004E880(player, BGM_SAMPLE_RATE, BgmDivisors[((u8*)player->unk_74)[0] & 7]); //TODO revise unk_74 typing
 
                    segmentOffset = bgmData->segments[segmentID];
                    if (segmentOffset == 0) {
                        segmentOffset = bgmData->segments[0];
                    }
                    player->segmentStartPos = AU_FILE_RELATIVE(bgmFile, segmentOffset << 2);
                    player->segmentReadPos = AU_FILE_RELATIVE(bgmFile, segmentOffset << 2);
 
                    if (bgmData->drums != 0) {
                        player->drumsInfo = AU_FILE_RELATIVE(player->bgmFile, bgmData->drums << 2);
                        player->bgmDrumCount = bgmData->drumCount;
                        for (i = 0; i < player->bgmDrumCount; i++) {
                            BGMDrumInfo* drum = &player->drumsInfo[i];
                            player->drums[i] = drum;
                        }
                        for (; i < ARRAY_COUNT(player->drums); i++) {
                            player->drums[i] = player->drums[0];
                        }
                    } else {
                        player->drumsInfo = NULL;
                        player->bgmDrumCount = 0;
                    }
 
                    if (bgmData->instruments != 0) {
                        player->instrumentsInfo = AU_FILE_RELATIVE(player->bgmFile, bgmData->instruments << 2);
                        player->bgmInstrumentCount = bgmData->instrumentCount;
                        return;
                    }
                    player->instrumentsInfo = NULL;
                    player->bgmInstrumentCount = 0;
                }
            } else {
                if (player->unk_58 != 0) {
                    player->masterState = BGM_PLAY_STATE_STOP;
                    player->nextUpdateCounter = 1;
                    player->nextUpdateStep = 1;
                } else {
                    au_bgm_stop_player(player);
                }
            }
        }
    }
}

Referenced by au_update_players_main().

au_bgm_get_player_with_song_name()

BGMPlayer * au_bgm_get_player_with_song_name

(

s32

songString

)

Definition at line 122 of file 28910_len_5090.c.

                                                            {
    if (songString != gBGMPlayerA->globals->dataBGM[0]->name) {
        if (songString == gBGMPlayerA->globals->dataBGM[1]->name) {
            return gBGMPlayerB;
        }
    } else {
        return gBGMPlayerA;
    }
    return NULL;
}

Referenced by au_bgm_dispatch_player_event(), au_bgm_is_song_playing(), au_bgm_set_proximity_mix(), au_bgm_stop_song(), func_8004DB4C(), func_8004DCB8(), func_8004DE2C(), func_8004E0F4(), and func_80050970().

au_bgm_dispatch_player_event()

AuResult au_bgm_dispatch_player_event

(

SongUpdateEvent *

event

)

Definition at line 133 of file 28910_len_5090.c.

                                                              {
    BGMPlayer* player;
    BGMFileInfo* fileInfo;
    s32 songName;
    s32 variation;
    s32 duration;
    s32 volume0;
    s32 volume1;
    AuResult status;
    u32 i;
 
    status = AU_RESULT_OK;
    songName = event->songName;
    variation = event->variation;
    if (songName != 0) {
        player = au_bgm_get_player_with_song_name(songName);
        if (player != NULL) {
            fileInfo = &player->bgmFile->info;
            duration = event->duration;
            if (duration != 0) {
                if (duration > SND_MAX_DURATION) {
                    duration = SND_MAX_DURATION;
                } else if (duration < SND_MIN_DURATION) {
                    duration = SND_MIN_DURATION;
                }
            }
            volume0 = event->startVolume;
            if (volume0 > 0x7F) {
                volume0 = 0x7F;
            }
            if (volume0 != 0) {
                volume0 = (volume0 << 8) | 0xFF;
            }
            volume1 = event->finalVolume;
            if (volume1 > 0x7F) {
                volume1 = 0x7F;
            }
            if (volume1 != 0) {
                volume1 = (volume1 << 8) | 0xFF;
            } else {
                volume1 = 0x7FFF;
            }
 
            au_fade_init(&player->fadeInfo, duration, volume0, volume1);
            player->fadeInfo.targetVolScale = 0x7FFF;
            player->fadeInfo.volScaleTime = 1;
            func_8004E880(player, BGM_SAMPLE_RATE, BgmDivisors[fileInfo->numSegments & 7]);
 
            if (variation < 0 || variation >= 4 || fileInfo->segments[variation] == 0) {
                variation = 0;
            }
            player->curSegmentID = variation;
 
            player->segmentStartPos = AU_FILE_RELATIVE(player->bgmFile, fileInfo->segments[variation] << 2);
            player->segmentReadPos = player->segmentStartPos;
 
            if (fileInfo->drums != 0) {
                player->drumsInfo = AU_FILE_RELATIVE(player->bgmFile, fileInfo->drums << 2);
                player->bgmDrumCount = fileInfo->drumCount;
 
                for (i = 0; i < player->bgmDrumCount; i++) {
                    BGMDrumInfo* drum = &player->drumsInfo[i];
                    player->drums[i] = drum;
                }
                for (; i < ARRAY_COUNT(player->drums); i++) {
                    player->drums[i] = player->drums[0];
                }
            } else {
                player->drumsInfo = NULL;
                player->bgmDrumCount = 0;
            }
            if (fileInfo->instruments != 0) {
                player->instrumentsInfo = AU_FILE_RELATIVE(player->bgmFile, fileInfo->instruments << 2);
                player->bgmInstrumentCount = fileInfo->instrumentCount;
            } else {
                player->instrumentsInfo = NULL;
                player->bgmInstrumentCount = 0;
            }
            player->songName = songName;
            au_bgm_player_initialize(player);
        } else {
            status = AU_ERROR_SONG_NOT_PLAYING;
        }
    } else {
        status = AU_ERROR_NULL_SONG_NAME;
    }
    return status;
}

Referenced by au_song_start(), au_song_start_variation(), snd_set_song_fade(), and snd_set_song_variation_fade().

au_bgm_stop_song()

AuResult au_bgm_stop_song

(

s32

songName

)

Definition at line 222 of file 28910_len_5090.c.

                                        {
    BGMPlayer* player;
    AuResult status = AU_RESULT_OK;
 
    if (songName != 0) {
        player = au_bgm_get_player_with_song_name(songName);
        if (player != NULL) {
            if (songName == player->songName) {
                au_bgm_stop_player(player);
            }
        } else {
            status = AU_ERROR_SONG_NOT_PLAYING;
        }
    } else {
        status = AU_ERROR_NULL_SONG_NAME;
    }
 
    return status;
}

Referenced by au_song_stop().

au_bgm_stop_all()

void au_bgm_stop_all

(

void

)

Definition at line 242 of file 28910_len_5090.c.

                           {
    au_bgm_stop_player(gBGMPlayerA);
    au_bgm_stop_player(gBGMPlayerB);
}

Referenced by au_stop_songs().

au_bgm_is_song_playing()

AuResult au_bgm_is_song_playing

(

s32

songName

)

Definition at line 256 of file 28910_len_5090.c.

                                              {
    BGMPlayer* player;
    AuResult result = AU_RESULT_OK;
 
    if (songName != 0) {
        player = au_bgm_get_player_with_song_name(songName);
        if (player != NULL) {
            result = (songName == player->songName);
        } else {
            result = AU_ERROR_SONG_NOT_PLAYING;
        }
    } else {
        result = AU_ERROR_NULL_SONG_NAME;
    }
 
    return result;
}

Referenced by au_song_is_playing().

func_8004DB28()

s32 func_8004DB28

(

BGMPlayer *

player

)

Definition at line 274 of file 28910_len_5090.c.

                                     {
    if (player->songName != NULL && player->masterState != 0) {
        return 1;
    } else {
        return 0;
    }
}

Referenced by au_load_song_files(), and func_8004DE2C().

func_8004DB4C()

AuResult func_8004DB4C

(

SongUpdateEvent *

s

)

Definition at line 282 of file 28910_len_5090.c.

                                           {
    AuResult status;
    BGMPlayer* player;
    u32 songName = s->songName;
    u32 duration = s->duration;
    s16 volume = s->finalVolume;
 
    status = AU_RESULT_OK;
    if (songName != 0) {
        if (duration >= SND_MIN_DURATION && duration <= SND_MAX_DURATION) {
            player = au_bgm_get_player_with_song_name(songName);
            if (player != NULL) {
                if (player->songName == songName) {
                    if (player->masterState != BGM_PLAY_STATE_IDLE) {
                        if (player->unk_220 == 0) {
                            player->fadeInfo.targetVolume = volume;
                            player->fadeInfo.fadeTime = (duration * 1000) / AU_5750;
                            player->fadeInfo.fadeStep = ((volume << 0x10) - player->fadeInfo.curVolume.s32) / player->fadeInfo.fadeTime;
                            player->fadeInfo.variation = s->variation;
                            if (s->unk14 == 1) {
                                player->fadeSongName = songName;
                            }
                        }
                    }
                }
            } else {
                status = AU_ERROR_SONG_NOT_PLAYING;
            }
        } else {
            status = AU_ERROR_INVALID_SONG_DURATION;
        }
    } else {
        status = AU_ERROR_NULL_SONG_NAME;
    }
    return status;
}

Referenced by func_80055BB8(), and snd_set_song_variation_fade_time().

func_8004DC80()

AuResult func_8004DC80

(

s32

songName

)

Definition at line 319 of file 28910_len_5090.c.

                                     {
    SongUpdateEvent s;
 
    s.songName = songName;
    s.duration = 0;
    s.startVolume = 0;
    s.finalVolume = 0;
    s.variation = 0;
    s.unk14 = 0;
    return func_8004DCB8(&s, 0);
}

Referenced by au_bgm_update_fade().

func_8004DCB8()

AuResult func_8004DCB8	(	SongUpdateEvent *	update,
		s32	clearChanged )

Definition at line 331 of file 28910_len_5090.c.

                                                                  {
    AuResult status;
    BGMPlayer* playerA;
    BGMPlayer* playerB;
    s32 songName;
    s32 variation;
    u32 i;
    u32 j;
 
    songName = update->songName;
    variation = update->variation;
    status = AU_RESULT_OK;
 
    if (songName != 0) {
        playerA = au_bgm_get_player_with_song_name(songName);
        if (playerA != NULL) {
            if (update->unk14 == 0) {
                playerB = func_80053F64(variation);
                if (playerB != NULL) {
                    if (songName == playerA->songName) {
                        if (!clearChanged) {
                            for (i = 0; i < ARRAY_COUNT(playerA->tracks); i++) {
                                BGMPlayerTrack* track = &playerA->tracks[i];
                                if (track->bgmReadPos != 0) {
                                    for (j = track->unk_52; j < track->unk_53; j++) {
                                        track->changed.all = 0;
                                    }
                                }
                            }
                        }
                        playerA->globals->unk_globals_6C[variation].unk_5 = playerA->priority;
                        playerA->globals->unk_globals_6C[variation].unk_4 = 1;
                        playerA->fadeSongName = 0;
                        au_copy_words(playerA, playerB, sizeof(*playerA));
                        if (clearChanged == 0) {
                            au_bgm_stop_player(playerA);
                        }
                    }
                } else {
                    status = AU_ERROR_INVALID_SONG_DURATION;
                }
            } else {
                if (songName == playerA->songName) {
                    if (playerA->masterState != BGM_PLAY_STATE_IDLE) {
                        playerA->unk_220 = 1;
                        func_80050900(playerA);
                    }
                }
            }
        } else {
            status = AU_ERROR_SONG_NOT_PLAYING;
        }
    } else {
        status = AU_ERROR_NULL_SONG_NAME;
    }
    return status;
}

Referenced by func_8004DC80(), func_80055AF0(), func_80055B80(), and func_80055BF0().

func_8004DE2C()

AuResult func_8004DE2C

(

SongUpdateEvent *

update

)

Definition at line 389 of file 28910_len_5090.c.

                                                {
    AuResult status;
    BGMPlayer* playerA;
    BGMPlayer* playerB;
    s32 variation;
    s32 songName;
    s32 volume0;
    s32 volume1;
    s32 duration;
 
    songName = update->songName;
    variation = update->variation;
    status = AU_RESULT_OK;
 
    if (songName != 0) {
        if (update->unk14 == 0) {
            playerA = func_80053F64(variation);
            if (playerA != NULL && playerA->globals->unk_globals_6C[variation].unk_4 == 1) {
                playerB = func_80054248(playerA->globals->unk_globals_6C[variation].unk_5);
                if (playerB != NULL) {
                    if (func_8004DB28(playerB) == 0) {
                        status = func_80053E58(playerA->songID, playerA->bgmFile);
                        duration = update->duration;
                        if (duration != 0) {
                            if (duration > SND_MAX_DURATION) {
                                duration = SND_MAX_DURATION;
                            } else if (duration < SND_MIN_DURATION) {
                                duration = SND_MIN_DURATION;
                            }
                        }
                        volume0 = update->startVolume;
                        if (volume0 > BGM_MAX_VOLUME) {
                            volume0 = BGM_MAX_VOLUME;
                        }
                        if (volume0 != 0) {
                            volume0 = (volume0 << 8) | 0xFF;
                        }
                        volume1 = update->finalVolume;
                        if (volume1 > BGM_MAX_VOLUME) {
                            volume1 = BGM_MAX_VOLUME;
                        }
                        if (volume1 != 0) {
                            volume1 = (volume1 << 8) | 0xFF;
                        } else {
                            volume1 = 0x7FFF;
                        }
                        playerB->globals->unk_74 = playerB;
                        playerB->globals->unk_78 = playerA;
                        playerB->globals->unkSongName = songName;
                        playerB->globals->unkFadeTime = duration;
                        playerB->globals->unkFadeStart = volume0;
                        playerB->globals->unkFadeEnd = volume1;
                        playerB->globals->unk_80 = 1;
                    } else {
                        status = AU_ERROR_7;
                    }
                } else {
                    status = AU_ERROR_6;
                }
            } else {
               status = AU_ERROR_INVALID_SONG_DURATION;
            }
        } else {
            playerB = au_bgm_get_player_with_song_name(songName);
            if (playerB != NULL) {
                if (songName == playerB->songName) {
                    if (playerB->unk_220 != 0) {
                        playerB->unk_220 = 0;
                    }
                }
            }
        }
    } else {
        status = AU_ERROR_NULL_SONG_NAME;
    }
    return status;
}

Referenced by func_80055B28(), and func_80055C2C().

func_8004DFD4()

void func_8004DFD4

(

AuGlobals *

globals

)

Definition at line 467 of file 28910_len_5090.c.

                                       {
    BGMPlayer* player;
    BGMPlayerTrack* track;
    SeqNote* note;
    u32 i;
    u32 j;
    s32 k;
 
    player = globals->unk_74;
    au_copy_words(globals->unk_78, globals->unk_74, sizeof(*player));
    if (globals->unkSongName == player->songName) {
        for (i = 0; i < ARRAY_COUNT(player->tracks); i++) {
            track = &player->tracks[i];
            if (track->bgmReadPos != NULL) {
                for (j = track->unk_52; j < track->unk_53; j++) {
                    note = &player->notes[j];
                    note->noteLength = 0;
                }
            }
        }
        for (k = 0; k < ARRAY_COUNT(player->effectIndices); k++) {
            if (player->effectIndices[k] != 0xFF) {
                player->seqCmdArgs.MasterEffect.index = player->effectIndices[k];
                player->seqCmdArgs.MasterEffect.value = player->effectValues[k];
                au_BGMCmd_E6_MasterEffect(player, track);
            }
        }
        au_fade_init(&player->fadeInfo, globals->unkFadeTime, globals->unkFadeStart, globals->unkFadeEnd);
    }
    globals->unk_80 = 0;
}

Referenced by au_update_clients_2().

func_8004E0F4()

AuResult func_8004E0F4

(

SongUpdateEvent *

update

)

Definition at line 499 of file 28910_len_5090.c.

                                                {
    BGMPlayer* player;
    AuResult status = AU_RESULT_OK;
 
    if (update->songName != 0) {
        player = au_bgm_get_player_with_song_name(update->songName);
        if (player != NULL) {
            func_80053B04(&player->fadeInfo, update->duration, update->finalVolume);
        }
        else {
            status = AU_ERROR_SONG_NOT_PLAYING;
        }
    } else {
        status = AU_ERROR_NULL_SONG_NAME;
    }
    return status;
}

Referenced by func_80055C64(), and func_80055C94().

au_bgm_player_init()

void au_bgm_player_init	(	BGMPlayer *	player,
		s32	arg1,
		s32	arg2,
		AuGlobals *	arg3 )

Definition at line 517 of file 28910_len_5090.c.

                                                                                        {
    s16 i;
 
    player->globals = globals;
    func_8004E880(player, BGM_SAMPLE_RATE, 48);
    player->busVolume = 0x8000;
    player->masterTempo = BGM_DEFAULT_TEMPO;
    player->masterVolume = 0x7F000000;
    player->updateCounter = 0;
    player->songPlayingCounter = 0;
    player->songName = 0;
    player->fadeSongName = 0;
    player->unk_58 = 0;
    player->unk_5A = 0;
    player->segmentReadPos = NULL;
    player->segmentStartPos = NULL;
    player->subSegmentStartPos = 0;
    player->masterTempoTime = 0;
    player->masterTempoTarget = 0;
    player->masterTempoStep = 0;
    player->masterVolumeTime = 0;
    player->masterVolumeTarget = 0;
    player->masterVolumeStep = 0;
    player->masterPitchShift = 0;
    player->detune = 0;
    player->unk_220 = 0;
    player->trackVolsConfig = NULL;
    player->bFadeConfigSetsVolume = FALSE;
    player->masterState = BGM_PLAY_STATE_IDLE;
    player->priority = priority;
    player->busId = busId;
    *(s32*)player->segLoopCounters = 0;
    player->unk_222 = 0;
    player->unk_223 = 0;
    player->playbackRate = 1.0f;
    player->unk_22A[0] = 0;
    player->unk_22A[1] = 1;
    player->unk_22A[2] = 0;
    player->unk_22A[3] = 0;
    player->unk_22A[4] = 0;
    player->unk_22A[5] = 2;
    player->unk_22A[6] = 3;
    player->unk_22A[7] = 4;
 
    for (i = 0; i < ARRAY_COUNT(player->tracks); i++) {
        BGMPlayerTrack* temp = &player->tracks[i];
 
        temp->subTrackVolume = 0;
        temp->delayTime = 0;
        temp->subTrackCoarseTune = 0;
        temp->subTrackFineTune = 0;
        temp->subTrackPan = 0;
        temp->subTrackReverb = 0;
        temp->patch = 0;
        temp->isDrumTrack = FALSE;
        temp->segTrackVolume = 0x7F;
        temp->unk_4C = 0;
 
        if (i < ARRAY_COUNT(player->unk_238)) {
            player->unk_238[i] = 0;
        }
    }
 
    for (i = 0; i < ARRAY_COUNT(player->notes); i++) {
        SeqNote* note = &player->notes[i];
 
        note->volume = 0;
        note->adjustedPitch = 0;
        note->noteLength = 0;
        note->unk_14 = 0;
        note->noteVelocity = 0;
        note->unk_note_17 = 0;
    }
 
    au_fade_set_vol_scale(&player->fadeInfo, 0x7FFF);
    func_80055110(player);
}

Referenced by au_engine_init().

au_bgm_set_effect_indices()

void au_bgm_set_effect_indices	(	BGMPlayer *	player,
		u8 *	list )

Definition at line 595 of file 28910_len_5090.c.

                                                            {
    s32 i;
    s32 remaining;
 
    for (i = 0; i < ARRAY_COUNT(player->effectIndices); i++) {
        s8 idx = *list++;
 
        if (idx < 0) {
            break;
        }
        player->effectIndices[i] = idx;
    }
 
    remaining = ARRAY_COUNT(player->effectIndices) - i;
    if (remaining > 0) {
        while (remaining-- != 0) {
            player->effectIndices[i++] = -1;
        }
    }
}

Referenced by au_engine_init().

au_bgm_update_fade()

void au_bgm_update_fade

(

BGMPlayer *

player

)

Definition at line 616 of file 28910_len_5090.c.

                                           {
    player->fadeInfo.fadeTime--;
 
    if (player->fadeInfo.fadeTime != 0) {
        player->fadeInfo.curVolume.s32 += player->fadeInfo.fadeStep;
    } else {
        player->fadeInfo.curVolume.s32 = player->fadeInfo.targetVolume << 16;
 
        if (player->fadeInfo.onCompleteCallback != NULL) {
            player->fadeInfo.onCompleteCallback();
        }
 
        if (player->fadeSongName != 0) {
            func_8004DC80(player->fadeSongName);
        } else if (player->fadeInfo.curVolume.s32 == 0) {
            au_bgm_stop_player(player);
        }
    }
    func_8004E444(player);
}

Referenced by au_update_clients_2().

func_8004E444()

void func_8004E444

(

BGMPlayer *

arg0

)

Definition at line 637 of file 28910_len_5090.c.

                                    {
    u16 mult = (arg0->fadeInfo.curVolume.u16 * arg0->fadeInfo.volScale.u16) >> 15;
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(arg0->effectIndices); i++) {
        s8 busId = arg0->effectIndices[i];
 
        if (busId < 0) {
            return;
        }
        au_fade_set_volume(busId, mult, arg0->busVolume);
    }
}

Referenced by au_bgm_update_fade(), and au_update_clients_2().

au_bgm_player_update_main()

s32 au_bgm_player_update_main

(

BGMPlayer *

player

)

Definition at line 651 of file 28910_len_5090.c.

                                                 {
    u16 hasMore = TRUE;
    s32 retVal = FALSE;
 
    // update pseudorandom numbers with fast 'good enough' method
    player->randomValue1 = (u16)player->randomValue1 + (u16)player->songPlayingCounter + (u16)player->updateCounter;
    player->randomValue2 = (u16)player->randomValue2 + ((player->songPlayingCounter << 4) & 0xFFFF) + ((player->updateCounter >> 4) & 0xFFFF);
    do {
        switch (player->masterState) {
        case BGM_PLAY_STATE_IDLE:
            hasMore = FALSE;
            break;
        case BGM_STATE_PLAY_SUBSEG:
            if (player->unk_220 == 0) {
                au_bgm_player_update_playing(player);
                if (player->masterState == BGM_STATE_PLAY_SUBSEG) {
                    hasMore = FALSE;
                }
            } else {
                hasMore = FALSE;
            }
            break;
        case BGM_PLAY_STATE_NEXT_SUBSEG:
            au_bgm_player_read_segment(player);
            break;
        case BGM_PLAY_STATE_INIT:
            au_bgm_player_initialize(player);
            hasMore = FALSE;
            break;
        case BGM_PLAY_STATE_STOP:
            au_bgm_player_update_stop(player);
            break;
        default:
            retVal = TRUE;
            hasMore = FALSE;
            break;
        }
    } while (hasMore);
    return retVal;
}

Referenced by au_update_clients_2().

au_bgm_player_initialize()

void au_bgm_player_initialize

(

BGMPlayer *

player

)

Definition at line 692 of file 28910_len_5090.c.

                                                 {
    s32* buf;
    s32 cmd;
    s32 keepReading;
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(player->tracks); i++) {
        BGMPlayerTrack* track = &player->tracks[i];
        track->instrument = NO_INSTRUMENT;
        track->subTrackVolume = 0x7FFF0000;
        track->subTrackPan = 0x40;
        track->subTrackReverb = 0;
        track->patch = 0;
        track->subTrackCoarseTune = 0;
        track->subTrackFineTune = 0;
        track->segTrackVolume = 0x7F;
        track->unk_4C = 0;
        track->unkVolume = 0x7FFF0000;
        track->savedPos = NULL;
        track->prevReadPos = NULL;
        track->detourLength = 0;
        track->segTrackTune = 0;
        track->trackTremoloTime = 0;
        track->trackTremoloAmount = 0;
        track->trackTremoloSpeed = 0;
        track->subTrackVolumeStep = 0;
        track->subTrackVolumeTarget = 0;
        track->subTrackVolumeTime = 0;
        track->unkVolumeStep = 0;
        track->unkVolumeTarget = 0;
        track->unkVolumeTime = 0;
        track->unk_4D = 0;
        track->unk_4E = 0;
        track->unk_4F = 0;
        track->unk_50 = 0;
        track->unk_51 = 0;
        track->polyphonicIdx = 0;
        track->unk_57 = 0;
        track->isDrumTrack = FALSE;
        track->parentTrackIdx = 0;
        track->unk_5A = 0;
        track->subtrackBusId = player->busId;
        track->index = i;
    }
 
    for (i = 0; i < ARRAY_COUNT(player->notes); i++) {
        SeqNote* note = &player->notes[i];
        note->ins = NO_INSTRUMENT;
        note->pitchRatio = 2.0f;
        note->unk_14 = 0;
        note->noteVelocity = 0;
        note->noteLength = 0;
        note->tremoloTime = 0;
    }
 
    func_80050900(player);
    player->playbackRate = 128.0f; // set to 1.0 later om...
    player->masterTempo = BGM_DEFAULT_TEMPO;
    player->masterTempoBPM = BGM_DEFAULT_TEMPO / 100;
    player->unk_21E = 0x80;
    player->masterVolume = 0x7F000000;
    player->fadeSongName = 0;
    player->unk_74 = 0;
    player->masterTempoTarget = 0;
    player->masterPitchShift = 0;
    player->detune = 0;
    player->masterVolumeTime = 0;
    player->masterVolumeTarget = 0;
    player->masterVolumeStep = 0;
    player->proxMixValue = 0;
    player->proxMixID = 0;
    player->proxMixVolume = 0;
    player->segActiveLoopEndPos[3] = NULL;
    player->segActiveLoopEndPos[2] = NULL;
    player->segActiveLoopEndPos[1] = NULL;
    player->segActiveLoopEndPos[0] = NULL;
    *(s32*)player->segLoopCounters = 0;
    player->segLoopDepth = 0;
    player->unk_222 = 0;
    player->unk_223 = 0;
    player->trackVolsConfig = NULL;
    player->bFadeConfigSetsVolume = FALSE;
    player->unk_233 = 1;
    player->unk_211 = 0;
    player->playbackRate = 1.0f;
 
    for (i = 0; i < ARRAY_COUNT(player->unk_212); i++) {
        func_8004E844(player, i);
    }
 
    for (i = 0; i < ARRAY_COUNT(player->effectValues); i++) {
        player->effectValues[i] = 0;
    }
 
    player->unk_220 = 0;
    player->songPlayingCounter = 0;
    for (i = 0; i < ARRAY_COUNT(player->segLoopStartLabels); i++) {
        player->segLoopStartLabels[i] = player->segmentReadPos;
    }
 
    // find labels
    buf = player->segmentReadPos;
    keepReading = TRUE;
    while (keepReading) {
        cmd = *buf++;
        if (cmd == 0) {
            keepReading = FALSE;
        } else if ((cmd & 0xF0000000) == BGM_SEGMENT_LABEL << 28) {
            player->segLoopStartLabels[cmd & 0x1F] = buf;
        }
    }
 
    player->masterState = BGM_PLAY_STATE_NEXT_SUBSEG;
}

Referenced by au_bgm_dispatch_player_event(), and au_bgm_player_update_main().

func_8004E844()

void func_8004E844	(	BGMPlayer *	player,
		s32	arg1 )

Definition at line 807 of file 28910_len_5090.c.

                                                {
    s32 i;
    u16* temp = player->unk_174[arg1];
    player->unk_212[arg1] = 0;
 
    for (i = 0; i < 9; i++) {
        *temp++ = 0xFF00;
    }
}

Referenced by au_bgm_player_initialize(), and au_BGMCmd_FF().

func_8004E880()

void func_8004E880	(	BGMPlayer *	player,
		s32	sampleRate,
		s32	divisor )

Definition at line 818 of file 28910_len_5090.c.

                                                                   {
    u32 A;
 
    A = 10434782 / (u32)divisor;
 
    if (A > 500000) {
        A = 500000;
    } else if (A < 80000) {
        A = 80000;
    }
    if (A < sampleRate) {
        sampleRate = A;
    }
    player->nextUpdateStep = sampleRate;
    player->nextUpdateInterval = A;
    player->nextUpdateCounter = A;
    player->maxTempo = A / 1000;
}

Referenced by au_bgm_dispatch_player_event(), au_bgm_player_init(), and au_bgm_update_main().

au_bgm_player_read_segment()

void au_bgm_player_read_segment

(

BGMPlayer *

player

)

Definition at line 838 of file 28910_len_5090.c.

                                                   {
    u16 continueReading = TRUE;
    u32 cmd;
 
    player->masterTempoStep = 0;
    player->masterTempoTime = 0;
    while (continueReading) {
        cmd = *player->segmentReadPos++;
        if (cmd == BGM_SEGMENT_END) {
            player->masterState = BGM_PLAY_STATE_STOP;
            continueReading = FALSE;
        } else {
            switch (cmd >> 12) {
                case BGM_SEGMENT_SUBSEG << 16:
                    au_bgm_load_subsegment(player, cmd);
                    player->masterState = BGM_STATE_PLAY_SUBSEG;
                    continueReading = FALSE;
                    break;
                case BGM_SEGMENT_START_LOOP << 16:
                    break;
                case BGM_SEGMENT_WAIT << 16:
                    continueReading = FALSE;
                    break;
                case BGM_SEGMENT_END_LOOP << 16:
                    au_bgm_end_segment_loop(player, cmd);
                    break;
                case BGM_SEGMENT_6 << 16:
                    if (!(player->unk_223 & 1)) {
                        au_bgm_end_segment_loop(player, cmd);
                    }
                    break;
                case BGM_SEGMENT_7 << 16:
                    if (player->unk_223 & 1) {
                        au_bgm_end_segment_loop(player, cmd);
                    }
                    break;
                default:
                    continueReading = FALSE;
                    break;
            }
        }
    }
}

Referenced by au_bgm_player_update_main().

au_bgm_end_segment_loop()

void au_bgm_end_segment_loop	(	BGMPlayer *	player,
		u32	cmd )

Definition at line 882 of file 28910_len_5090.c.

                                                         {
    s32 labelIndex = cmd & 0x1F; // 01F (bits 0-4)
    s32 iterCount = (cmd >> 5) & 0x7F; // FE0 (bits 5-11)
    u32 depth;
 
    depth = player->segLoopDepth;
    if (player->segActiveLoopEndPos[depth] != NULL) {
        if (player->segActiveLoopEndPos[depth] == player->segmentReadPos) {
            if (player->segLoopCounters[depth] != 0) {
                player->segLoopCounters[depth]--;
                if ((player->segLoopCounters[depth]) == 0) {
                    player->segActiveLoopEndPos[depth] = NULL;
                    if (depth > 0) {
                        depth--;
                    }
                } else {
                    player->segmentReadPos = player->segLoopStartLabels[labelIndex];
                }
            } else {
                player->segmentReadPos = player->segLoopStartLabels[labelIndex];
            }
        } else if (depth < 4) {
            depth++;
            player->segActiveLoopEndPos[depth] = player->segmentReadPos;
            player->segLoopCounters[depth] = iterCount;
            player->segmentReadPos = player->segLoopStartLabels[labelIndex];
        }
    } else {
        player->segActiveLoopEndPos[depth] = player->segmentReadPos;
        player->segLoopCounters[depth] = iterCount;
        player->segmentReadPos = player->segLoopStartLabels[labelIndex];
    }
    player->segLoopDepth = depth;
}

Referenced by au_bgm_player_read_segment().

au_bgm_load_subsegment()

void au_bgm_load_subsegment	(	BGMPlayer *	player,
		u32	cmd )

Definition at line 917 of file 28910_len_5090.c.

                                                        {
    BGMPlayerTrack* track;
    u32 trackInfo;
    s32* trackList;
    u32 parentIdx;
    s32 count;
    s32 nextRelativePos;
    s32 bUsesPolyphony;
    s32 i;
 
    nextRelativePos = 0;
    bUsesPolyphony = FALSE;
    player->subSegmentStartPos = AU_FILE_RELATIVE(player->segmentStartPos, (cmd & 0xFFFF) << 2);
    trackList = player->subSegmentStartPos;
    for (i = 0; i < ARRAY_COUNT(player->tracks); i++) {
        track = &player->tracks[i];
        trackInfo = *trackList++;
        track->bgmReadPos = (AuFilePos) (trackInfo >> 0x10);
        if (track->bgmReadPos != NULL) {
            if ((trackInfo & 0x100) == 0) {
                track->polyphonicIdx = (trackInfo & (0x7 << 0xD)) >> 0xD;
                track->isDrumTrack = (trackInfo >> 7) & 1;
                parentIdx = (trackInfo & (0xF << 9)) >> 9;
                track->parentTrackIdx = 0;
                if (parentIdx != 0) {
                    BGMPlayerTrack* parentTrack = &player->tracks[parentIdx - 1];
                    if ((parentIdx - 1) < i) {
                        track->unk_51 = parentTrack->unk_51;
                        track->unk_52 = parentTrack->unk_52;
                        track->unk_53 = parentTrack->unk_53;
 
                        track->bgmReadPos = (track->bgmReadPos + (s32)player->subSegmentStartPos);
                        track->delayTime = 1;
 
                        track->parentTrackIdx = parentIdx;
                        if (player->unk_233 != 0) {
                            track->unk_5A = 1;
                        }
                        bUsesPolyphony = TRUE;
                    } else {
                        track->bgmReadPos = NULL;
                    }
                } else {
                    count = player->unk_22A[track->polyphonicIdx];
                    track->unk_51 = count;
                    track->unk_52 = nextRelativePos;
                    nextRelativePos += count;
                    track->unk_53 = nextRelativePos;
 
                    track->bgmReadPos = (track->bgmReadPos + (s32)player->subSegmentStartPos);
                    track->delayTime = 1;
                }
            } else {
                track->bgmReadPos = NULL;
            }
        }
    }
    player->unk_21B = nextRelativePos; // last Voice?
    if (bUsesPolyphony) {
        player->unk_233 = 0;
    }
}

Referenced by au_bgm_player_read_segment().

au_bgm_player_update_stop()

void au_bgm_player_update_stop

(

BGMPlayer *

player

)

Definition at line 980 of file 28910_len_5090.c.

                                                  {
    s32 i;
 
    player->unk_220 = 0;
    player->songName = 0;
    player->fadeSongName = 0;
    player->unk_58 = 0;
    player->unk_5A = 0;
    for (i = 0; i < ARRAY_COUNT(player->tracks); i++) {
        player->tracks[i].bgmReadPos = NULL;
    }
    func_80050900(player);
    player->masterState = BGM_PLAY_STATE_IDLE;
    player->nextUpdateStep = BGM_SAMPLE_RATE;
}

Referenced by au_bgm_player_update_main().

au_bgm_player_update_playing()

void au_bgm_player_update_playing

(

BGMPlayer *

player

)

Definition at line 1004 of file 28910_len_5090.c.

                                                     {
    s32 bVolumeFading;
    u8 sp1F;
    s16 notePitch;
    u8 bFinished;
 
    AuVoice* voice;
    BGMDrumInfo* drumInfo;
    BGMPlayerTrack* track;
    SeqNote* note;
    s32 var_a0;
    s32 temp;
    s32 var_a1_5;
    s32 bAcquiredVoiceIdx;
    u8 opcode;
    u8 noteVelocity;
    s32 noteLength;
    u32 i;
    u8 voiceIdx;
    s32 temp2;
    bVolumeFading = FALSE;
    bFinished = FALSE;
 
    if (player->masterTempoTime != 0) {
        player->masterTempoTime--;
        if (player->masterTempoTime == 0) {
            player->masterTempo = player->masterTempoTarget;
            player->masterTempoTarget = 0;
            player->masterTempoStep = 0;
        } else {
            player->masterTempo += player->masterTempoStep;
        }
        player->nextUpdateStep = player->masterTempo * 10;
    }
    if (player->masterVolumeTime != 0) {
        player->masterVolumeTime--;
        if (player->masterVolumeTime == 0) {
            player->masterVolume = player->masterVolumeTarget;
            player->masterVolumeTarget = 0;
            player->masterVolumeStep = 0;
        } else {
            player->masterVolume += player->masterVolumeStep;
        }
        bVolumeFading = TRUE;
    }
    player->volumeChanged = FALSE;
    if (player->trackVolsConfig != NULL) {
        if (player->bFadeConfigSetsVolume) {
            // setting track volumes
            s32 lenLimit = 16;
            while (lenLimit-- != 0) {
                i = *player->trackVolsConfig++;
                if (i == 0) {
                    break;
                }
                track = &player->tracks[i - 1];
                player->seqCmdArgs.TrackVolumeFade.time = 48;
                player->seqCmdArgs.TrackVolumeFade.value = *(player->trackVolsConfig++);
                if (track->bgmReadPos != 0) {
                    au_BGMCmd_F6_TrackVolumeFade(player, track);
                }
            }
        }
        else {
            // clearing track volumes
            s32 lenLimit = 16;
            while (lenLimit-- != 0) {
                i = *player->trackVolsConfig++;
                if (i == 0) {
                    break;
                }
                track = &player->tracks[i - 1];
                player->seqCmdArgs.TrackVolumeFade.time = 48;
                player->trackVolsConfig++; // ignore arg
                player->seqCmdArgs.TrackVolumeFade.value = 0;
                if (track->bgmReadPos != 0) {
                    au_BGMCmd_F6_TrackVolumeFade(player, track);
                }
            }
        }
        player->trackVolsConfig = NULL;
        player->bFadeConfigSetsVolume = FALSE;
    }
    for (i = 0; i < ARRAY_COUNT(player->tracks); i++) {
        track = &player->tracks[i];
        if (track->bgmReadPos != NULL) {
            track->changed.all = 0;
            if (bVolumeFading || player->volumeChanged) {
                track->changed.volume = 1;
            } else {
                track->changed.volume = 0;
            }
            if (track->subTrackVolumeTime != 0) {
                track->subTrackVolumeTime--;
                if (track->subTrackVolumeTime == 0) {
                    track->subTrackVolume = track->subTrackVolumeTarget;
                } else {
                    track->subTrackVolume += track->subTrackVolumeStep;
                }
                track->changed.volume = 1;
            }
            if (track->unkVolumeTime != 0) {
                track->unkVolumeTime--;
                if (track->unkVolumeTime == 0) {
                    track->unkVolume = track->unkVolumeTarget << 0x10;
                } else {
                    track->unkVolume += track->unkVolumeStep;
                }
                track->changed.volume = 1;
            }
            track->delayTime--;
            if (track->delayTime <= 0) {
                sp1F = track->unk_52;
                while (track->delayTime == 0) {
                    opcode = *(track->bgmReadPos++);
                    POST_BGM_READ();
 
                    if (opcode < 0x80) {
                        if (opcode == 0) {
                            if (track->prevReadPos != 0) {
                                track->bgmReadPos = track->prevReadPos;
                                track->prevReadPos = 0;
                            } else {
                                bFinished = TRUE;
                                break;
                            }
                        } else {
                            if (opcode >= 0x78) {
                                // long delay
                                track->delayTime = (((opcode & 7) << 8) + *(track->bgmReadPos++)) + 0x78;
                                POST_BGM_READ();
 
                            } else {
                                // delay
                                track->delayTime = opcode;
                            }
                        }
                    } else {
                        // note
                        if (opcode < 0xD4) {
                            notePitch = (opcode & 0x7F);
                            noteVelocity = *(track->bgmReadPos++);
                            POST_BGM_READ();
                            noteLength = *(track->bgmReadPos++);
                            POST_BGM_READ();
                            if (!(noteLength < 0xC0)) {
                                noteLength = (((u8)noteLength & ~0xC0) << 8) + *(track->bgmReadPos++) + 0xC0;
                                POST_BGM_READ();
                            }
                            bAcquiredVoiceIdx = FALSE;
                            if (track->unk_5A == 0) {
                                // find first free voice
                                for (voiceIdx = sp1F; voiceIdx < track->unk_53; voiceIdx++) {
                                    voice = &player->globals->voices[voiceIdx];
                                    sp1F++;
                                    if (voice->priority == AU_PRIORITY_FREE) {
                                        bAcquiredVoiceIdx = TRUE;
                                        break;
                                    }
                                }
 
                                if (!bAcquiredVoiceIdx) {
                                    if (track->polyphonicIdx >= 5) { // 5 = AL_DEFAULT_PRIORITY?
                                        // try stealing a voice with lower priority
                                        for (voiceIdx = track->unk_52; voiceIdx < track->unk_53; voiceIdx++) {
                                            voice = &player->globals->voices[voiceIdx];
                                            if (voice->priority < player->priority) {
                                                au_reset_voice(voice, voiceIdx);
                                                bAcquiredVoiceIdx = TRUE;
                                                break;
                                            }
                                        }
                                        // try stealing a voice with equal priority and zero note length
                                        if (!bAcquiredVoiceIdx) {
                                            for (voiceIdx = track->unk_52; voiceIdx < track->unk_53; voiceIdx++) {
                                                voice = &player->globals->voices[voiceIdx];
                                                if (voice->priority == player->priority) {
                                                    note = &player->notes[voiceIdx];
                                                    if (note->noteLength == 0) {
                                                        au_reset_voice(voice, voiceIdx);
                                                        bAcquiredVoiceIdx = TRUE;
                                                        break;
                                                    }
                                                }
                                            }
                                        }
                                        // try stealing a voice with equal priority and lowest note length
                                        if (!bAcquiredVoiceIdx) {
                                            s32 shortestLength = 0xFFFF;
                                            u8 voice_it;
                                            AuVoice* curVoice;
                                            SeqNote* curNote;
                                            for (voice_it = track->unk_52; voice_it < track->unk_53; voice_it++) {
                                                curVoice = &player->globals->voices[voice_it];
                                                if (curVoice->priority == player->priority) {
                                                    curNote = &player->notes[voice_it];
                                                    if (curNote->unk_note_17 == 0 && curNote->noteLength < shortestLength) {
                                                        shortestLength = curNote->noteLength;
                                                        voice = curVoice;
                                                        note = curNote;
                                                        voiceIdx = voice_it;
                                                        bAcquiredVoiceIdx = TRUE;
                                                    }
                                                }
                                            }
                                            if (bAcquiredVoiceIdx) {
                                                note->noteLength = 0;
                                                au_reset_voice(voice, voiceIdx);
                                            }
                                        }
 
                                    } else {
                                        voiceIdx = track->unk_52;
                                        voice = &player->globals->voices[voiceIdx];
                                        note = &player->notes[voiceIdx];
                                        note->noteLength = 0;
                                        if (voice->priority <= player->priority) {
                                            au_reset_voice(voice, voiceIdx);
                                            bAcquiredVoiceIdx = TRUE;
                                        }
                                    }
                                }
                            }
                            if (bAcquiredVoiceIdx) {
                                note = &player->notes[voiceIdx];
                                note->tremoloTime = 0;
                                if (noteVelocity > 0) {
                                    note->noteVelocity = noteVelocity + 1;
                                } else {
                                    note->noteVelocity = 0;
                                }
                                note->noteLength = noteLength;
                                if (track->isDrumTrack) {
                                    if (notePitch < 72) { // = 6 * 12
                                        drumInfo = &player->globals->dataPER->drums[notePitch];
                                    } else {
                                        drumInfo = player->drums[notePitch - 72]; // = 6 * 12
                                    }
                                    note->ins = au_get_instrument(player->globals, (u16)drumInfo->bankPatch >> 8, (u16)drumInfo->bankPatch & 0xFF, &voice->envelope);
                                    if (drumInfo->randVolume != 0) {
                                        note->volume = note->noteVelocity * au_bgm_get_random_vol(player->randomValue1, drumInfo->volume, drumInfo->randVolume);
                                    } else {
                                        note->volume = note->noteVelocity * drumInfo->volume;
                                    }
                                    voice->clientVolume = ((
                                        ((player->masterVolume >> 0x15) * (track->subTrackVolume >> 0x15) * (track->unkVolume >> 0x15)) >> 0x14)
                                        * (track->segTrackVolume * note->volume)) >> 0x10;
                                    note->adjustedPitch =
                                        drumInfo->keyBase
                                        + track->subTrackCoarseTune
                                        + track->subTrackFineTune
                                        - note->ins->keyBase;
                                    temp = (note->adjustedPitch + track->segTrackTune) + player->detune;
                                    if (drumInfo->randTune != 0) {
                                        note->unk_14 = au_bgm_get_random_pitch(player->randomValue1, temp, drumInfo->randTune);
                                        temp = note->unk_14;
                                    }
                                    note->pitchRatio = au_compute_pitch_ratio(temp) * note->ins->pitchRatio;
                                    if (drumInfo->randPan != 0) {
                                        voice->pan = au_bgm_get_random_pan(player, drumInfo->pan, drumInfo->randPan);
                                    } else {
                                        voice->pan = drumInfo->pan;
                                    }
                                    if (drumInfo->randReverb != 0) {
                                        voice->reverb = au_bgm_get_random_reverb(player->randomValue1, drumInfo->reverb, drumInfo->randReverb);
                                    } else {
                                        voice->reverb = drumInfo->reverb;
                                    }
                                } else {
                                    note->volume = ((
                                        ((player->masterVolume >> 0x15) * (track->subTrackVolume >> 0x15) * (track->unkVolume >> 0x15)) >> 0x14)
                                        * (track->segTrackVolume * note->noteVelocity)) >> 9;
                                    voice->clientVolume = note->volume;
                                    note->ins = track->instrument;
                                    note->adjustedPitch =
                                        (notePitch * 100)
                                        + track->subTrackCoarseTune
                                        + player->masterPitchShift
                                        + track->subTrackFineTune
                                        - note->ins->keyBase;
                                    note->pitchRatio = au_compute_pitch_ratio(
                                        note->adjustedPitch
                                        + track->segTrackTune
                                        + player->detune)
                                        * track->instrument->pitchRatio;
 
                                    if (track->unk_57 != 0) {
                                        voice->pan = au_bgm_get_random_pan(player, track->subTrackPan, track->unk_57);
                                    } else {
                                        voice->pan = track->subTrackPan;
                                    }
                                    voice->reverb = track->subTrackReverb;
 
                                    if (track->unk_4C != 0) {
                                        voice->envelope.cmdListPress = (u8*) player->unk_174[track->unk_4C - 1]; //TODO ???
                                    } else {
                                        voice->envelope.cmdListPress = track->envelope.cmdListPress;
                                    }
                                    voice->envelope.cmdListRelease = track->envelope.cmdListRelease;
                                }
                                voice->instrument = note->ins;
                                voice->pitchRatio = note->pitchRatio;
                                voice->busId = track->subtrackBusId;
                                if (note->noteLength >= 2) {
                                    note->unk_note_17 = 1;
                                    note->tremoloTime = track->trackTremoloTime;
                                    note->unk_13 = 0;
                                    note->tremoloAmount = track->trackTremoloAmount;
                                    voice->syncFlags = AU_VOICE_SYNC_FLAG_ALL;
                                    voice->priority = player->priority;
                                    voice->clientPriority = voice->priority;
                                }
                            }
                        } else {
                            //TODO variable is nargs, but reusing temp is required to match
                            temp = SeqCmdArgCounts[opcode - 0xE0];
                            if (temp != 0) {
                                player->seqCmdArgs.raw[0] = *(track->bgmReadPos++);
                                POST_BGM_READ();
                            } else {
                                goto bgm_args_done;
                            }
                            if (temp > 1) {
                                player->seqCmdArgs.raw[1] = *(track->bgmReadPos++);
                                POST_BGM_READ();
                            } else {
                                goto bgm_args_done;
                            }
                            if (temp > 2) {
                                player->seqCmdArgs.raw[2] = *(track->bgmReadPos++);
                                POST_BGM_READ();
                            } else {
                                goto bgm_args_done;
                            }
                            if (temp > 3) {
                                player->seqCmdArgs.raw[3] = *(track->bgmReadPos++);
                                POST_BGM_READ();
                            }
                            bgm_args_done:
                            CurrentSeqCmdHandler = SeqCmdHandlers[opcode - 0xE0];
                            CurrentSeqCmdHandler(player, track);
                        }
                    }
                } // end while
            }
 
            for (voiceIdx = track->unk_52; voiceIdx < track->unk_53; voiceIdx++) {
                if (track->unk_5A == 0) {
                    voice = &player->globals->voices[voiceIdx];
                    if (voice->priority == player->priority) {
                        note = &player->notes[voiceIdx];
                        if (note->unk_note_17 == 0) {
                            if (note->noteLength > 0) {
                                note->noteLength--;
                                if (note->noteLength == 0) {
                                    voice->envelopeFlags |= AU_VOICE_ENV_FLAG_KEY_RELEASED;
                                }
                            }
                            if (track->isDrumTrack) {
                                if (track->changed.tune || (player->detune != 0)) {
                                    note->pitchRatio = au_compute_pitch_ratio(((note->adjustedPitch + note->unk_14) + track->segTrackTune) + player->detune) * note->ins->pitchRatio;
                                    if (voice->pitchRatio != note->pitchRatio) {
                                        voice->pitchRatio = note->pitchRatio;
                                        voice->syncFlags |= AU_VOICE_SYNC_FLAG_PITCH;
                                    }
                                }
                                if (track->changed.volume) {
                                    voice->clientVolume = (
                                        ((((player->masterVolume >> 0x15)
                                        * (track->subTrackVolume >> 0x15))
                                        * (track->unkVolume >> 0x15)) >> 0x14)
                                        * (track->segTrackVolume * note->volume)) >> 0x10;
                                    voice->envelopeFlags |= AU_VOICE_ENV_FLAG_VOL_CHANGED;
                                }
                            } else {
                                if (note->tremoloTime != 0) {
                                    if (note->tremoloAmount != 0) {
                                        note->tremoloAmount--;
                                    } else {
                                        u8 temp_a0_6;
                                        u8 temp_a2_4;
                                        note->unk_13 += track->trackTremoloSpeed;
                                        opcode = (note->unk_13 << 2) + 3;
                                        temp_a2_4 = note->unk_13 >> 6;
 
                                        if ((temp_a2_4 == 1) || (temp_a2_4 == 3)) {
                                            u8 temp2 = ~opcode;
                                            var_a1_5 = temp2 + 1;
                                        } else {
                                            var_a1_5 = opcode;
                                        }
 
                                        var_a1_5 = (var_a1_5 * track->trackTremoloTime) >> 8;
 
                                        if ((temp_a2_4 == 2) || (temp_a2_4 == 3)) {
                                            var_a1_5 = -var_a1_5;
                                        }
 
                                        note->pitchRatio = au_compute_pitch_ratio(var_a1_5 + ((note->adjustedPitch + track->segTrackTune) + player->detune)) * note->ins->pitchRatio;
                                        if (voice->pitchRatio != note->pitchRatio) {
                                            voice->pitchRatio = note->pitchRatio;
                                            voice->syncFlags |= AU_VOICE_SYNC_FLAG_PITCH;
                                        }
                                    }
                                } else if (track->changed.tune || (player->detune != 0)) {
 
                                    note->pitchRatio = au_compute_pitch_ratio((note->adjustedPitch + track->segTrackTune) + player->detune) * note->ins->pitchRatio;
                                    if (voice->pitchRatio != note->pitchRatio) {
                                        voice->pitchRatio = note->pitchRatio;
                                        voice->syncFlags |= AU_VOICE_SYNC_FLAG_PITCH;
                                    }
                                }
                                if (track->changed.volume) {
                                    s32 tempVolume = ((player->masterVolume >> 0x15) * (track->subTrackVolume >> 0x15) * (track->unkVolume >> 0x15)) >> 0x14;
                                    note->volume = (tempVolume * (track->segTrackVolume * note->noteVelocity)) >> 9;
                                    voice->clientVolume = note->volume;
                                    voice->envelopeFlags |= AU_VOICE_ENV_FLAG_VOL_CHANGED;
                                    voice->pan = track->subTrackPan;
                                    voice->reverb = track->subTrackReverb;
                                } else if (track->changed.pan || track->changed.reverb) {
                                    voice->pan = track->subTrackPan;
                                    voice->reverb = track->subTrackReverb;
                                    voice->syncFlags |= AU_VOICE_SYNC_FLAG_PAN_FXMIX;
                                }
                            }
                        }
                        note->unk_note_17 = 0;
                    }
                }
            }
        }
    }
 
    if (bFinished) {
        player->masterState = BGM_PLAY_STATE_NEXT_SUBSEG;
    }
}

Referenced by au_bgm_player_update_main().

au_BGMCmd_E0_MasterTempo()

void au_BGMCmd_E0_MasterTempo	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1444 of file 28910_len_5090.c.

                                                                        {
    u32 bpm = player->seqCmdArgs.MasterTempo.value;
    s32 tempo;
 
    player->masterTempoBPM = bpm;
    tempo = snd_bpm_to_tempo(player, bpm);
    player->masterTempo = tempo;
    player->nextUpdateStep = tempo * 10;
    player->masterTempoTime = 0;
    player->masterTempoTarget = 0;
    player->masterTempoStep = 0;
}

au_BGMCmd_E1_MasterVolume()

void au_BGMCmd_E1_MasterVolume	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1472 of file 28910_len_5090.c.

                                                                         {
    s32 volume = player->seqCmdArgs.MasterVolume.value & 0x7F;
 
    if (volume != 0) {
        volume = volume << 0x18;
    }
 
    player->masterVolume = volume;
    player->masterVolumeTime = 0;
    player->masterVolumeTarget = 0;
    player->masterVolumeStep = 0;
    player->volumeChanged = TRUE;
    track->changed.volume = TRUE;
}

au_BGMCmd_E2_MasterPitchShift()

void au_BGMCmd_E2_MasterPitchShift	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1487 of file 28910_len_5090.c.

                                                                             {
    player->masterPitchShift = (s8)player->seqCmdArgs.MasterPitchShift.cent * 100;
}

au_BGMCmd_E3()

void au_BGMCmd_E3	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1491 of file 28910_len_5090.c.

                                                            {
    player->globals->effectChanges[player->busId].type = player->seqCmdArgs.UnkCmdE3.effectType;
    player->globals->effectChanges[player->busId].changed = TRUE;
}

au_BGMCmd_E6_MasterEffect()

void au_BGMCmd_E6_MasterEffect	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1496 of file 28910_len_5090.c.

                                                                         {
    u8 index = player->seqCmdArgs.MasterEffect.index;
    u32 busId = player->effectIndices[index];
 
    if ((index < 4) && (busId < 0x80)) {
        if (player->globals->effectChanges[busId].type != player->seqCmdArgs.MasterEffect.value) {
            player->globals->effectChanges[busId].type = player->seqCmdArgs.MasterEffect.value;
            player->globals->effectChanges[busId].changed = TRUE;
        }
        player->effectValues[index] = player->seqCmdArgs.MasterEffect.value;
    }
}

Referenced by func_8004DFD4().

au_BGMCmd_E4_MasterTempoFade()

void au_BGMCmd_E4_MasterTempoFade	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1509 of file 28910_len_5090.c.

                                                                            {
    s32 time = player->seqCmdArgs.MasterTempoFade.time;
    s32 tempo = snd_bpm_to_tempo(player, player->seqCmdArgs.MasterTempoFade.value);
 
    if (time <= 0) {
        time = 1;
    }
 
    player->masterTempoTime = time;
    player->masterTempoTarget = tempo;
    player->masterTempoStep = (tempo - player->masterTempo) / time;
}

au_BGMCmd_E5_MasterVolumeFade()

void au_BGMCmd_E5_MasterVolumeFade	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1522 of file 28910_len_5090.c.

                                                                             {
    s32 time = player->seqCmdArgs.MasterVolumeFade.time;
    s32 volume = player->seqCmdArgs.MasterVolumeFade.value & 0x7F;
 
    if (volume != 0) {
        volume = volume << 0x18;
    }
 
    if (time <= 0) {
        time = 1;
    }
 
    player->masterVolumeTime = time;
    player->masterVolumeTarget = volume;
    player->masterVolumeStep = (volume - player->masterVolume) / time;
}

au_BGMCmd_E8_TrackOverridePatch()

void au_BGMCmd_E8_TrackOverridePatch	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1539 of file 28910_len_5090.c.

                                                                               {
    track->patch = player->seqCmdArgs.TrackOverridePatch.patch;
    track->instrument = au_get_instrument(player->globals, player->seqCmdArgs.TrackOverridePatch.bank, track->patch, &track->envelope);
}

au_BGMCmd_E9_SubTrackVolume()

void au_BGMCmd_E9_SubTrackVolume	(	BGMPlayer *	arg0,
		BGMPlayerTrack *	track )

Definition at line 1544 of file 28910_len_5090.c.

                                                                         {
    u32 volume = arg0->seqCmdArgs.SubTrackVolume.value & 0x7F;
 
    if (volume != 0) {
        volume = volume << 0x18;
    }
 
    track->subTrackVolume = volume;
    track->changed.volume = TRUE;
}

Referenced by func_80050970().

au_BGMCmd_F6_TrackVolumeFade()

void au_BGMCmd_F6_TrackVolumeFade	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1555 of file 28910_len_5090.c.

                                                                            {
    s32 time = player->seqCmdArgs.TrackVolumeFade.time;
    s32 volume = player->seqCmdArgs.TrackVolumeFade.value & 0x7F;
 
    if (volume != 0) {
        volume = volume << 0x18;
    }
 
    if (volume != track->subTrackVolume) {
        if (time <= 0) {
            time = 1;
        }
 
        track->subTrackVolumeTime = time;
        track->subTrackVolumeTarget = volume;
        track->subTrackVolumeStep = (volume - track->subTrackVolume) / time;
    }
}

Referenced by au_bgm_change_track_volume(), au_bgm_player_update_playing(), and func_80050970().

au_BGMCmd_EA_SubTrackPan()

void au_BGMCmd_EA_SubTrackPan	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1574 of file 28910_len_5090.c.

                                                                        {
    track->subTrackPan = player->seqCmdArgs.SubTrackPan.value & 0x7F;
    track->unk_57 = 0;
    track->changed.pan = TRUE;
}

au_BGMCmd_EB_SubTrackReverb()

void au_BGMCmd_EB_SubTrackReverb	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1580 of file 28910_len_5090.c.

                                                                           {
    track->subTrackReverb = player->seqCmdArgs.SubTrackReverb.value & 0x7F;
    track->changed.reverb = TRUE;
}

au_BGMCmd_EC_SegTrackVolume()

void au_BGMCmd_EC_SegTrackVolume	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1585 of file 28910_len_5090.c.

                                                                           {
    track->segTrackVolume = player->seqCmdArgs.SegTrackVolume.value & 0x7F;
    track->changed.volume = TRUE;
}

au_BGMCmd_ED_SubTrackCoarseTune()

void au_BGMCmd_ED_SubTrackCoarseTune	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1590 of file 28910_len_5090.c.

                                                                               {
    track->subTrackCoarseTune = (s8)player->seqCmdArgs.SubTrackCoarseTune.cent * 100;
}

au_BGMCmd_EE_SubTrackFineTune()

void au_BGMCmd_EE_SubTrackFineTune	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1594 of file 28910_len_5090.c.

                                                                             {
    track->subTrackFineTune = player->seqCmdArgs.SubTrackFineTune.value;
}

au_BGMCmd_EF_SegTrackTune()

void au_BGMCmd_EF_SegTrackTune	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1598 of file 28910_len_5090.c.

                                                                         {
    track->segTrackTune = player->seqCmdArgs.SegTrackTune.value;
    track->changed.tune = TRUE;
}

au_BGMCmd_F0_TrackTremolo()

void au_BGMCmd_F0_TrackTremolo	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1603 of file 28910_len_5090.c.

                                                                         {
    track->trackTremoloAmount = player->seqCmdArgs.TrackTremolo.amount;
    track->trackTremoloSpeed = player->seqCmdArgs.TrackTremolo.speed;
    track->trackTremoloTime = player->seqCmdArgs.TrackTremolo.time;
}

au_BGMCmd_F1_TrackTremoloSpeed()

void au_BGMCmd_F1_TrackTremoloSpeed	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1609 of file 28910_len_5090.c.

                                                                              {
    track->trackTremoloSpeed = player->seqCmdArgs.TrackTremoloSpeed.value;
}

au_BGMCmd_F2_TrackTremoloTime()

void au_BGMCmd_F2_TrackTremoloTime	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1613 of file 28910_len_5090.c.

                                                                             {
    track->trackTremoloTime = player->seqCmdArgs.TrackTremoloTime.time;
}

au_BGMCmd_F3_TrackTremoloStop()

void au_BGMCmd_F3_TrackTremoloStop	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1617 of file 28910_len_5090.c.

                                                                             {
    track->trackTremoloTime = 0;
}

au_BGMCmd_F4()

void au_BGMCmd_F4	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1621 of file 28910_len_5090.c.

                                                            {
    track->subTrackPan = player->seqCmdArgs.UnkCmdF4.pan0 & 0x7F;
    track->unk_57 = player->seqCmdArgs.UnkCmdF4.pan1 & 0x7F;
}

au_BGMCmd_F5_TrackVoice()

void au_BGMCmd_F5_TrackVoice	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1626 of file 28910_len_5090.c.

                                                                       {
    BGMInstrumentInfo* instrument;
    s32 volume;
    u32 voiceIndex;
    u32 patch;
    u32 bank;
 
    voiceIndex = player->seqCmdArgs.SetTrackVoice.index;
    if (voiceIndex < 0x80) {
        if (voiceIndex < player->bgmInstrumentCount) {
            instrument = &player->instrumentsInfo[voiceIndex];
        } else {
            instrument = &player->globals->defaultPRGEntry;
        }
    } else {
        voiceIndex -= 0x80;
        if (voiceIndex < 0x40) {
            instrument = &player->globals->dataPRG[voiceIndex];
        } else {
            instrument = &player->globals->defaultPRGEntry;
        }
    }
    bank = instrument->bankPatch >> 8;
    patch = (u8)instrument->bankPatch;
    volume = instrument->volume & 0x7F;
    track->patch = patch;
    track->instrument = au_get_instrument(player->globals, bank, patch, &track->envelope);
    if (volume != 0) {
        volume <<= 0x18;
    }
    track->subTrackVolume = volume;
    track->subTrackPan = instrument->pan & 0x7F;
    track->subTrackReverb = instrument->reverb & 0x7F;
    track->subTrackCoarseTune = instrument->coarseTune * 100;
    track->subTrackFineTune = instrument->fineTune;
    track->changed.all |= 0x10101;
}

au_BGMCmd_F7_SubTrackReverbType()

void au_BGMCmd_F7_SubTrackReverbType	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1664 of file 28910_len_5090.c.

                                                                               {
    u8 index = player->seqCmdArgs.SubTrackReverbType.index;
    s8 busId = player->effectIndices[index];
 
    if ((index < 4) && (busId >= 0)) {
        track->subtrackBusId = busId;
    } else {
        track->subtrackBusId = player->busId;
    }
}

au_BGMCmd_FD_EventTrigger()

void au_BGMCmd_FD_EventTrigger	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1675 of file 28910_len_5090.c.

                                                                         {
    bgm_trigger_music_event(player->priority, track->index, player->seqCmdArgs.EventTrigger.eventInfo >> 8);
}

au_BGMCmd_FE_Detour()

void au_BGMCmd_FE_Detour	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1680 of file 28910_len_5090.c.

                                                                   {
    AuFilePos readPos = AU_FILE_RELATIVE(player->bgmFile, player->seqCmdArgs.Detour.offset);
 
    track->detourLength = player->seqCmdArgs.Detour.length;
    track->savedPos = track->bgmReadPos;
    track->bgmReadPos = readPos;
}

au_BGMCmd_FC_Jump()

void au_BGMCmd_FC_Jump	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1689 of file 28910_len_5090.c.

                                                                 {
    AuFilePos args;
    u32 i;
 
    // get jump table
    args = AU_FILE_RELATIVE(player->bgmFile, player->seqCmdArgs.Jump.unk_00);
    if (player->proxMixID < player->seqCmdArgs.Jump.unk_02) {
        args += player->proxMixID * 3;
    }
    // read new position from jump table
    track->prevReadPos = track->bgmReadPos;
    track->bgmReadPos = AU_FILE_RELATIVE(player->bgmFile, (args[0] << 8) + args[1]);
    track->isDrumTrack = args[2];
 
    if (track->unk_4D != 0) {
        track->unk_4D = 0;
        track->unkVolume = 0;
        for (i = track->unk_52; i < track->unk_53; i++) {
            AuVoice* voice = &player->globals->voices[i];
            if ((voice->priority == player->priority) && (voice->cmdPtr != NULL)) {
                au_reset_voice(voice, i);
            }
        }
    }
    if (track->unk_4E != 0) {
        track->unk_4E = 0;
        func_80050888(player, track, player->proxMixVolume, 144);
    }
    track->subTrackCoarseTune = 0;
    track->subTrackFineTune = 0;
    track->unk_4C = 0;
    track->segTrackTune = 0;
    track->trackTremoloTime = 0;
    track->subTrackVolumeTime = 0;
    track->unk_57 = 0;
    track->subtrackBusId = player->busId;
}

au_BGMCmd_FF()

void au_BGMCmd_FF	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1727 of file 28910_len_5090.c.

                                                            {
    u32 i;
    u32 j;
    u8 temp_a1;
    u8 temp_a3;
 
    u32 arg0 = player->seqCmdArgs.UnkCmdFF.unk_00;
    u32 arg1 = player->seqCmdArgs.UnkCmdFF.unk_01;
    u32 arg2 = player->seqCmdArgs.UnkCmdFF.unk_02;
 
    switch (arg0) {
        case 1:
            if ((arg1 < ARRAY_COUNT(player->effectIndices)) && ((s8)player->effectIndices[arg1] >= 0)) {
                player->globals->channelDelayBusId = player->effectIndices[arg1];
                if (arg2 != 0) {
                    temp_a3 = arg2 & 0xF;
                    temp_a1 = ((arg2 >> 4) & 1) + 1;
                    if ((player->globals->channelDelayTime != temp_a3) || (player->globals->channelDelaySide != temp_a1)) {
                        player->globals->channelDelayTime = temp_a3;
                        player->globals->channelDelaySide = temp_a1;
                        player->globals->channelDelayPending = 1;
                    }
                } else {
                    if (player->globals->channelDelaySide != 0) {
                        player->globals->channelDelaySide = 0;
                        player->globals->channelDelayPending = 1;
                    }
                }
            }
            break;
        case 2:
            if (arg1 - 1 < 8) {
                player->unk_211 = arg1;
                func_8004E844(player, arg1 - 1);
            } else {
                player->unk_211 = 0;
            }
            break;
        case 3:
            i = player->unk_211;
            if (i - 1 < 8) {
                i = i - 1; // needed to match
                j = player->unk_212[i];
                if (j < 8) {
                    if (arg1 >= 40) {
                        player->unk_174[i][j] = (arg1 << 8) + arg2;
                    } else {
                        player->unk_174[i][j] = (D_80078558[arg1] << 8) + arg2;
                    }
                    player->unk_212[i] = j + 1;
                }
            }
            break;
        case 4:
            if (arg1 < 9) {
                track->unk_4C = arg1;
            } else {
                track->unk_4C = 0;
            }
            break;
        case 5:
            if (player->soundManager != NULL) {
                for (i = 0; i < ARRAY_COUNT(player->soundManager->bgmSounds); i++) {
                    if ((player->soundManager->bgmSounds[i].unk_0) == 0) {
                        player->soundManager->bgmSounds[i].unk_0 = arg1;
                        player->soundManager->bgmSounds[i].volume = ((player->fadeInfo.curVolume.u16 * player->fadeInfo.volScale.u16) + 0x7FFF) >> 0x17;
                        break;
                    }
                }
            }
            break;
        case 6:
            if (arg1 == 0) {
                if (track->unk_4E != 0) {
                    track->unk_4E = 0;
                    for (i = 0; i < ARRAY_COUNT(player->tracks); i++) {
                        BGMPlayerTrack* otherTrack = &player->tracks[i];
                        if (player->proxMixVolume == 0x7F) {
                            if (otherTrack->unk_4F != 0) {
                                otherTrack->unk_4E = 0;
                                func_80050888(player, otherTrack, otherTrack->unk_4F, 72);
                            }
                        } else {
                            if (otherTrack->unk_50 != 0) {
                                otherTrack->unk_4E = 0;
                                func_80050888(player, otherTrack, otherTrack->unk_50, 72);
                            }
                        }
                    }
                }
            } else {
                track->unk_4F = arg1;
                track->unk_50 = arg2;
            }
            break;
    }
}

au_BGMCmd_NOP()

void au_BGMCmd_NOP	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1825 of file 28910_len_5090.c.

                                                             {
}

au_bgm_set_proximity_mix()

void au_bgm_set_proximity_mix	(	s32	songName,
		u32	mix )

Definition at line 1905 of file 28910_len_5090.c.

                                                     {
    BGMPlayer* player;
    BGMPlayerTrack* track;
    s32 changed = FALSE;
    u8 mixID = mix & 0xFF;
    s32 i;
 
    if (songName != 0) {
        player = au_bgm_get_player_with_song_name(songName);
        if ((player != NULL) && (player->proxMixValue != mix)) {
            player->proxMixValue = mix;
            if (player->proxMixID != mixID) {
                player->proxMixID = mixID;
                changed = TRUE;
            }
            player->proxMixVolume = (mix >> 0x18) & 0x7F;
            for (i = 0; i < ARRAY_COUNT(player->tracks); i++) {
                track = &player->tracks[i];
                if (changed) {
                    track->unk_4D = 1;
                }
                track->unk_4E = 1;
            }
        }
    }
}

Referenced by bgm_set_proximity_mix_far(), bgm_set_proximity_mix_full(), and bgm_set_proximity_mix_near().

au_bgm_set_playback_rate()

void au_bgm_set_playback_rate	(	BGMPlayer *	player,
		f32	arg1 )

Definition at line 1932 of file 28910_len_5090.c.

                                                           {
    if (rate > 2.0) {
        rate = 2.0f;
    } else if (rate < 0.25) {
        rate = 0.25f;
    }
 
    player->playbackRate = rate;
    player->masterTempo = snd_bpm_to_tempo(player, player->masterTempoBPM);
    player->nextUpdateStep = player->masterTempo * 10;
    player->masterTempoTime = 0;
    player->masterTempoTarget = 0;
    player->masterTempoStep = 0;
}

Referenced by snd_song_set_playback_rate().

au_bgm_player_set_detune()

void au_bgm_player_set_detune	(	BGMPlayer *	player,
		s32	arg1 )

Definition at line 1947 of file 28910_len_5090.c.

                                                             {
    if (detune > 1200) {
        detune = 1200;
    } else if (detune < -2400) {
        detune = -2400;
    }
 
    player->detune = detune;
}

Referenced by snd_song_set_detune().

au_bgm_change_track_volume()

void au_bgm_change_track_volume	(	BGMPlayer *	player,
		s32	trackIdx,
		s16	arg2,
		u8	arg3 )

Definition at line 1957 of file 28910_len_5090.c.

                                                                                      {
    BGMPlayerTrack* track = &player->tracks[trackIdx];
 
    if (track->bgmReadPos != 0) {
        player->seqCmdArgs.TrackVolumeFade.time = time;
        player->seqCmdArgs.TrackVolumeFade.value = volume;
        au_BGMCmd_F6_TrackVolumeFade(player, track);
    }
}

au_bgm_set_track_volumes()

void au_bgm_set_track_volumes	(	BGMPlayer *	player,
		u8 *	arg1,
		s32	arg2 )

Definition at line 1967 of file 28910_len_5090.c.

                                                                          {
    player->trackVolsConfig = trackVols;
    player->bFadeConfigSetsVolume = mode;
}

Referenced by snd_song_clear_track_volumes(), and snd_song_set_track_volumes().

func_80050888()

void func_80050888	(	BGMPlayer *	player,
		BGMPlayerTrack *	track,
		s32	target,
		s32	duration )

Definition at line 1972 of file 28910_len_5090.c.

                                                                                       {
    if (target != 0) {
        target = (target << 8) | 0xFF;
    }
    if (duration <= 0) {
        duration = 1;
    } else if (duration > 1000) {
        duration = 1000;
    }
    if (target == track->unkVolume) {
        track->unkVolumeTime = 0;
        return;
    }
    track->unkVolumeTime = duration;
    track->unkVolumeTarget = target;
    track->unkVolumeStep = ((target << 0x10) - track->unkVolume) / duration;
}

Referenced by au_BGMCmd_FC_Jump(), and au_BGMCmd_FF().

func_80050900()

void func_80050900

(

BGMPlayer *

player

)

Definition at line 1990 of file 28910_len_5090.c.

                                      {
    u8 i;
 
    for (i = 0; i < ARRAY_COUNT(player->globals->voices); i++) {
        AuVoice* voice = &player->globals->voices[i];
        if (voice->priority == player->priority) {
            au_reset_voice(voice, i);
        }
    }
}

Referenced by au_bgm_player_initialize(), au_bgm_player_update_stop(), and func_8004DCB8().

func_80050970()

AuResult func_80050970

(

SongUpdateEvent *

arg0

)

Definition at line 2001 of file 28910_len_5090.c.

                                                {
    BGMPlayer* player;
    BGMPlayerTrack* track;
    BGMPlayerTrack* parentTrack;
    AuVoice* voice;
    s32 i;
    s32 j;
    s8 oldVolume;
 
    s32 songName = update->songName;
    s32 variation = update->variation;
    AuResult status = AU_RESULT_OK;
 
    if (songName != 0) {
        player = au_bgm_get_player_with_song_name(songName);
        if (player != NULL) {
            for (i = 0; i < ARRAY_COUNT(player->tracks); i++) {
                track = &player->tracks[i];
                if (track->bgmReadPos != NULL) {
                    if (track->parentTrackIdx != 0) {
                        parentTrack = &player->tracks[track->parentTrackIdx - 1];
                        if (variation != 0) {
                            if (track->unk_5A != 0) {
                                track->unk_5A = 0;
                                parentTrack->unk_5A = 1;
                                for (j = parentTrack->unk_52; j < parentTrack->unk_53; j++) {
                                    voice = &player->globals->voices[j];
                                    if (voice->priority == player->priority) {
                                        voice->envelope.cmdListRelease = EnvelopeReleaseDefaultFast;
                                        voice->envelopeFlags |= AU_VOICE_ENV_FLAG_KEY_RELEASED;
                                    }
                                }
                                oldVolume = track->subTrackVolume >> 24;
                                au_BGMCmd_E9_SubTrackVolume(player, track);
                                player->seqCmdArgs.raw[0] = 0;
                                player->seqCmdArgs.TrackVolumeFade.time = 96;
                                player->seqCmdArgs.TrackVolumeFade.value = oldVolume;
                                au_BGMCmd_F6_TrackVolumeFade(player, track);
                            }
                        } else {
                            if (track->unk_5A == 0) {
                                track->unk_5A = 1;
                                parentTrack->unk_5A = 0;
                                for (j = track->unk_52; j < track->unk_53; j++) {
                                    voice = &player->globals->voices[j];
                                    if (voice->priority == player->priority) {
                                        voice->envelope.cmdListRelease = EnvelopeReleaseDefaultFast;
                                        voice->envelopeFlags |= AU_VOICE_ENV_FLAG_KEY_RELEASED;
                                    }
                                }
                                oldVolume = parentTrack->subTrackVolume >> 24;
                                au_BGMCmd_E9_SubTrackVolume(player, parentTrack);
                                player->seqCmdArgs.raw[0] = 0;
                                player->seqCmdArgs.TrackVolumeFade.time = 96;
                                player->seqCmdArgs.TrackVolumeFade.value = oldVolume;
                                au_BGMCmd_F6_TrackVolumeFade(player, parentTrack);
                            }
                        }
                    }
                }
            }
        } else {
            status = AU_ERROR_SONG_NOT_PLAYING;
        }
    } else {
        status = AU_ERROR_NULL_SONG_NAME;
    }
 
    return status;
}

Referenced by snd_set_song_variation().

func_80055110()

void func_80055110

(

BGMPlayer *

player

)

Definition at line 133 of file 30450.c.

                                      {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(player->unk_238); i++) {
        player->unk_238[i] = 0;
    }
 
    player->unk_25B = 0;
    player->unk_25A = 0;
    player->unk_259 = 0;
    player->unk_258 = 0;
}

Referenced by au_bgm_player_init().

snd_song_get_playing_info()

AuResult snd_song_get_playing_info	(	s32	songName,
		BGMHeader **	outTrackData,
		BGMPlayer **	outPlayer )

Definition at line 636 of file 30450.c.

                                                                                             {
    AuResult status = AU_RESULT_OK;
    BGMHeader* bgmFile;
 
    bgmFile = gSoundGlobals->dataBGM[0];
    if (songName == bgmFile->name) {
        *outPlayer = gBGMPlayerA;
        *outFile = bgmFile;
    } else {
        bgmFile = gSoundGlobals->dataBGM[1];
        if (songName == bgmFile->name) {
            *outPlayer = gBGMPlayerB;
            *outFile = bgmFile;
        } else {
            status = AU_ERROR_1;
        }
    }
    return status;
}

Referenced by snd_song_clear_track_volumes(), snd_song_set_detune(), snd_song_set_playback_rate(), and snd_song_set_track_volumes().

au_register_callback()

void au_register_callback	(	AuCallback	arg0,
		s32	arg1 )

Definition at line 835 of file 30450.c.

                                                      {
    gSoundGlobals->audioThreadCallbacks[index] = func;
}

au_driver_init()

void au_driver_init	(	AuSynDriver *	driver,
		ALConfig *	config )

Definition at line 25 of file 31650.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->unk_04 = 0;
    driver->outputRate = config->outputRate;
    driver->dmaNew = config->dmaNew;
 
    gActiveSynDriverPtr = driver;
    gSynDriverPtr = driver;
    AuUseGlobalVolume = FALSE;
    AuGlobalVolume = 0x7FFF;
    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 = NULL;
        voice->resampler.state = alHeapAlloc(heap, 1, sizeof(*voice->resampler.state));
        voice->resampler.delta = 0;
        voice->resampler.first = 1;
        voice->resampler.ratio = 1.0f;
        voice->envMixer.state = alHeapAlloc(heap, 1, sizeof(*voice->envMixer.state));
        voice->envMixer.first = 1;
        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->unk_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));
        func_80058E84(fxBus->fxL, fxBus->curEffectType, heap);
        func_80058E84(fxBus->fxR, fxBus->curEffectType, heap);
    }
 
    gSynDriverPtr->savedMainOut = alHeapAlloc(heap, 2 * AUDIO_SAMPLES, 2);
    gSynDriverPtr->savedAuxOut = alHeapAlloc(heap, 2 * AUDIO_SAMPLES, 2);
    AuDelayedVoiceGroup = 0;
    AuDelayedChannel = 0;
    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 31650.c.

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

au_use_global_volume()

void au_use_global_volume

(

void

)

Definition at line 250 of file 31650.c.

                                {
    AuUseGlobalVolume = TRUE;
}

Referenced by nuAuPreNMIProc().

au_set_global_volume()

void au_set_global_volume

(

s16

arg0

)

Definition at line 254 of file 31650.c.

                                    {
    AuGlobalVolume = arg0;
}

Referenced by nuAuPreNMIProc().

au_get_global_volume()

s16 au_get_global_volume

(

void

)

Definition at line 258 of file 31650.c.

                               {
    return AuGlobalVolume;
}

Referenced by nuAuPreNMIProc().

func_80056D5C()

void func_80056D5C

(

u8

arg0

)

Definition at line 262 of file 31650.c.

                                    {
    AuSynUseStereo = bStereoSound;
    AuSynStereoDirty = TRUE;
}

Referenced by audio_set_mono(), and audio_set_stereo().

au_bus_set_volume()

void au_bus_set_volume	(	u8	arg0,
		u16	arg1 )

Definition at line 267 of file 31650.c.

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

Referenced by au_fade_set_volume().

au_bus_get_volume()

u16 au_bus_get_volume	(	u8	arg0,
		u16	arg1 )

Definition at line 273 of file 31650.c.

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

au_bus_set_effect()

void au_bus_set_effect	(	u8	arg0,
		u8	effectID )

Definition at line 279 of file 31650.c.

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

Referenced by au_syn_update().

au_bus_set_fx_params()

void au_bus_set_fx_params	(	u8	arg0,
		s16	arg1,
		s16	arg2,
		s32	arg3 )

Definition at line 287 of file 31650.c.

                                                                            {
    AuFxBus* fxBus = &gSynDriverPtr->fxBus[index];
 
    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	arg0,
		s8	arg1 )

Definition at line 294 of file 31650.c.

                                           {
    AuPVoice* pvoice = &gSynDriverPtr->pvoices[index];
 
    pvoice->busId = busId;
}

Referenced by au_engine_init().

au_syn_stop_voice()

void au_syn_stop_voice

(

u8

voiceIdx

)

Definition at line 301 of file 31650.c.

                                    {
    AuPVoice* pvoice = &gSynDriverPtr->pvoices[voiceIdx];
    AuLoadFilter* decoder = &pvoice->decoder;
 
    pvoice->envMixer.motion = AL_STOPPED;
    pvoice->envMixer.first = 1;
    pvoice->envMixer.volume = 1;
    pvoice->resampler.delta = 0;
    pvoice->resampler.first = 1;
    decoder->lastsam = 0;
    decoder->first = 1;
    decoder->sample = 0;
    if (decoder->instrument != NULL) {
        decoder->memin = (s32)decoder->instrument->base;
        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_syn_update(), and au_update_stopped_voices().

au_syn_start_voice()

void au_syn_start_voice

(

u8

index

)

Definition at line 328 of file 31650.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 335 of file 31650.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->base;
    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->dc_bookSize;
            if (decoder->instrument->loopEnd == 0) {
                decoder->loop.count = 0;
                decoder->loop.end = 0;
                decoder->loop.start = 0;
            } else {
                decoder->loop.start = decoder->instrument->loopStart;
                decoder->loop.end = decoder->instrument->loopEnd;
                decoder->loop.count = decoder->instrument->loopCount;
                alCopy(decoder->instrument->loopPredictor, decoder->lstate, sizeof(ADPCM_STATE));
            }
            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->first = 1;
    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 = pitch;
}

Referenced by au_syn_update().

au_syn_set_wavetable()

void au_syn_set_wavetable	(	u8	voiceIdx,
		Instrument *	table )

Definition at line 398 of file 31650.c.

                                                               {
    AuPVoice* pvoice = &gSynDriverPtr->pvoices[voiceIdx];
    AuLoadFilter* decoder = &pvoice->decoder;
 
    pvoice->decoder.instrument = instrument;
    pvoice->decoder.memin = (s32)decoder->instrument->base;
    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->dc_bookSize;
            if (decoder->instrument->loopEnd == 0) {
                pvoice->decoder.loop.count = 0;
                pvoice->decoder.loop.end = 0;
                pvoice->decoder.loop.start = 0;
            } else {
                pvoice->decoder.loop.start = decoder->instrument->loopStart;
                pvoice->decoder.loop.end = decoder->instrument->loopEnd;
                pvoice->decoder.loop.count = decoder->instrument->loopCount;
                alCopy(decoder->instrument->loopPredictor, pvoice->decoder.lstate, sizeof(ADPCM_STATE));
            }
            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 436 of file 31650.c.

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

Referenced by au_syn_update().

au_syn_set_mixer_params()

void au_syn_set_mixer_params	(	u8	voiceIdx,
		s16	volume,
		s32	arg2,
		u8	arg3,
		u8	arg4 )

Definition at line 442 of file 31650.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->first = 1;
}

Referenced by au_syn_update().

au_syn_set_pan_fxmix()

void au_syn_set_pan_fxmix	(	u8	voiceIdx,
		u8	arg1,
		u8	arg2 )

Definition at line 475 of file 31650.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->first = 1;
}

Referenced by au_syn_update().

au_syn_set_volume_delta()

void au_syn_set_volume_delta	(	u8	voiceIdx,
		s16	arg1,
		s32	arg2 )

Definition at line 505 of file 31650.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->first = 1;
}

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 535 of file 31650.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->first = 1;
}

Referenced by alAudioFrame().

au_syn_set_fxmix()

void au_syn_set_fxmix	(	u8	voiceIdx,
		u8	dryAmt )

Definition at line 563 of file 31650.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->first = 1;
}

au_syn_get_playing()

s32 au_syn_get_playing

(

u8

voiceIdx

)

Definition at line 592 of file 31650.c.

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

au_syn_get_bus()

s32 au_syn_get_bus

(

u8

voiceIdx

)

Definition at line 598 of file 31650.c.

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

au_syn_get_pitch()

f32 au_syn_get_pitch

(

u8

voiceIdx

)

Definition at line 604 of file 31650.c.

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

au_syn_get_pan()

u8 au_syn_get_pan

(

u8

voiceIdx

)

Definition at line 610 of file 31650.c.

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

au_syn_get_dryamt()

s16 au_syn_get_dryamt

(

u8

voiceIdx

)

Definition at line 616 of file 31650.c.

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

au_syn_get_wetamt()

s16 au_syn_get_wetamt

(

u8

voiceIdx

)

Definition at line 622 of file 31650.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 628 of file 31650.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 645 of file 31650.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 662 of file 31650.c.

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

Referenced by au_syn_update().

au_delay_left_channel()

void au_delay_left_channel

(

u8

arg0

)

Definition at line 674 of file 31650.c.

                                        {
    s32* phi_a1 = (s32*)AuDelayBufferMain;
    s32* phi_v1 = (s32*)AuDelayBufferAux;
    s32 i;
 
    for (i = 0; i < 2 * AUDIO_SAMPLES; i++) {
        *phi_a1++ = 0;
        *phi_v1++ = 0;
    }
 
    AuDelayedVoiceGroup = groupIdx;
    AuDelayedChannel = 1;
    AuDelayCounter = 0;
}

Referenced by au_syn_update().

au_delay_right_channel()

void au_delay_right_channel

(

u8

arg0

)

Definition at line 689 of file 31650.c.

                                         {
    s32* phi_a1 = (s32*)AuDelayBufferMain;
    s32* phi_v1 = (s32*)AuDelayBufferAux;
    s32 i;
 
    for (i = 0; i < 2 * AUDIO_SAMPLES; i++) {
        *phi_a1++ = 0;
        *phi_v1++ = 0;
    }
 
    AuDelayedVoiceGroup = groupIdx;
    AuDelayedChannel = 2;
    AuDelayCounter = 0;
}

Referenced by au_syn_update().

au_disable_channel_delay()

void au_disable_channel_delay

(

void

)

Definition at line 704 of file 31650.c.

                                    {
    AuDelayedVoiceGroup = 0;
    AuDelayedChannel = 0;
    AuDelayCounter = 0;
}

Referenced by au_syn_update().

au_delay_channel()

void au_delay_channel

(

s16

arg0

)

Definition at line 710 of file 31650.c.

                                {
    s32* phi_a1 = (s32*)AuDelayBufferMain;
    s32* phi_v1 = (s32*)AuDelayBufferAux;
    s32 i;
 
    for (i = 0; i < 2 * AUDIO_SAMPLES; i++) {
        *phi_a1++ = 0;
        *phi_v1++ = 0;
    }
 
    AuDelayedVoiceGroup = 0;
    AuDelayedChannel = arg0;
    AuDelayCounter = 0;
}

Referenced by au_engine_init().

alHeapAlloc()

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

Definition at line 743 of file 31650.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_load_BK_to_bank(), au_load_INIT(), create_audio_system(), func_80054AA0(), func_80058E84(), and func_80058F88().

au_pull_voice()

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

Definition at line 32 of file 33450.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;
 
    if (envMixer->motion != AL_PLAYING) {
        return ptr;
    }
    outp = N_AL_DECODER_OUT;
    if (resampler->ratio > MAX_RATIO) {
        resampler->ratio = MAX_RATIO;
    }
 
    resampler->ratio = (s32)(resampler->ratio * UNITY_PITCH);
    resampler->ratio = resampler->ratio / UNITY_PITCH;
    finCount = resampler->delta + resampler->ratio * (f32)184;
    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;
 
            aLoadADPCM(ptr++, decoder->bookSize, K0_TO_PHYS(decoder->instrument->predictor));
 
            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->base + ADPCMFBYTES * ((s32)(decoder->loop.start >> LFSAMPLES) + 1);
                decoder->sample = decoder->loop.start;
                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->base + 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->unk_25);
                    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->base + (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->unk_25);
                    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->base + 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->unk_25);
                        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);
                }
            }
        }
    }
    incr = (s32)(resampler->ratio * UNITY_PITCH);
    n_aResample(ptr++, osVirtualToPhysical(resampler->state), resampler->first, incr, outp, 0);
    resampler->first = 0;
 
    if (envMixer->first != 0) {
        envMixer->first = 0;
        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_LEFT  | A_VOL, envMixer->cvolL, envMixer->dryamt, envMixer->wetamt);
        n_aSetVolume(ptr++, A_RIGHT | A_VOL, 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));
    }
 
    envMixer->delta += AUDIO_SAMPLES;
    if (envMixer->segEnd < envMixer->delta) {
        envMixer->delta = envMixer->segEnd;
    }
    if (envMixer->motion == AL_STOPPED) {
        envMixer->first = 1;
        envMixer->volume = 1;
        resampler->delta = 0.0f;
        resampler->first = 1;
        decoder->lastsam = 0;
        decoder->first = 1;
        decoder->sample = 0;
        decoder->memin = (s32) decoder->instrument->base;
        decoder->loop.count = decoder->instrument->loopCount;
        func_80052E30(pvoice->index);
    }
    return ptr;
}

Referenced by alAudioFrame().

func_80058E84()

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

Parameters

effectType

from enum AuEffectType

Definition at line 137 of file reverb.c.

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

Referenced by au_driver_init().

func_80058F88()

void func_80058F88	(	AlUnkKappa *	kappa,
		ALHeap *	heap )

Definition at line 157 of file reverb.c.

                                                    {
    kappa->unk_00 = alHeapAlloc(heap, 0x1420, sizeof(s16));
    kappa->lowpass_10 = alHeapAlloc(heap, 1, sizeof(AuLowPass));
    kappa->lowpass_10->fstate = alHeapAlloc(heap, 1, sizeof(POLEF_STATE));
    func_80059008(kappa, 0, 0, 0x5000);
}

func_80059008()

void func_80059008	(	AlUnkKappa *	kappa,
		s16	arg1,
		s16	arg2,
		s16	fc )

Definition at line 165 of file reverb.c.

                                                                  {
    kappa->unk_06 = arg1;
    kappa->unk_08 = arg2;
 
    if (fc != 0) {
        kappa->lowpass_0C = kappa->lowpass_10;
        kappa->lowpass_0C->fc = fc;
        _init_lpfilter(kappa->lowpass_0C);
        return;
    }
 
    kappa->lowpass_0C = NULL;
}

Referenced by func_80058F88().

func_8005904C()

void func_8005904C	(	AuFX *	fx,
		u8	effectType )

Definition at line 180 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->resampler_28 = delay->resampler_2C;
            delay->resampler_2C->delta = 0.0;
            delay->resampler_28->first = 1;
        } else {
            delay->resampler_28 = NULL;
            j++;
            j++;
        }
 
        if (params[j]) {
            delay->lowpass_20 = delay->lowpass_24;
            delay->lowpass_20->fc = params[j++];
            _init_lpfilter(delay->lowpass_20);
        } else {
            delay->lowpass_20 = NULL;
            j++;
        }
    }
}

Referenced by au_bus_set_effect(), and func_80058E84().

au_pull_fx()

Acmd * au_pull_fx	(	AuFX *	fx,
		Acmd *	cmdBusPos,
		s16	outputBuf,
		s16	arg3 )

Definition at line 267 of file reverb.c.

                                                               {
    Acmd* cmdBufPos = ptr;
    s16 delayIdx;
 
    s16* inPtr;
    s16* outPtr;
 
    s16 buff1 = arg3 + N_AL_TEMP_0;
    s16 buff2 = arg3 + N_AL_TEMP_1;
    s16 rbuff = arg3 + N_AL_TEMP_2;
    s16* prevOutPtr = 0;
    s16 outputBufCopy = outputBuf;
 
    n_aSaveBuffer(cmdBufPos++, FIXED_SAMPLE<<1, outputBuf, osVirtualToPhysical(fx->input));
    aClearBuffer(cmdBufPos++, outputBuf, FIXED_SAMPLE<<1);
 
    for (delayIdx = 0; delayIdx < fx->delayCount; delayIdx++) {
        AuDelay* delay = &fx->delays[delayIdx];
        f32 fUnityPitch = UNITY_PITCH;
 
        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 (inPtr == prevOutPtr) {
            SWAP16(buff1, buff2);
        } else {
            n_aLoadBuffer(cmdBufPos++, FIXED_SAMPLE<<1, buff1, osVirtualToPhysical(inPtr));
        }
        if (delay->resampler_28) {
            // modified _n_loadOutputBuffer
            s32 ratio;
            s32 length, count;
            f32 delta, fratio, fincount;
            s32 ramAlign;
            s16 tmp;
            s16* rsOutPtr;
 
            length = delay->output - delay->input;
            delta = func_80059BD4(delay, AUDIO_SAMPLES);
            delta /= length;
            delta = (s32)(delta * fUnityPitch);
            delta = delta / UNITY_PITCH;
            fratio = 1.0 - delta;
            fincount = delay->resampler_28->delta + (fratio * AUDIO_SAMPLES);
            count = (s32) fincount;
            delay->resampler_28->delta = fincount - count;
 
            rsOutPtr = &fx->input[-(delay->output - delay->rsdelta)];
            ramAlign = ((s32) rsOutPtr & 7) >> 1;
 
            rsOutPtr -= ramAlign;
            if (rsOutPtr < fx->base) {
                rsOutPtr += fx->length;
            }
 
            cmdBufPos = _saveBuffer(fx, rsOutPtr, rbuff, count + ramAlign, cmdBufPos);
            ratio = fratio * fUnityPitch;
 
            tmp = buff2 >> 8;
            n_aResample(cmdBufPos++, osVirtualToPhysical(delay->resampler_28->state),
                delay->resampler_28->first, ratio, rbuff + (ramAlign<<1), tmp);
 
            delay->resampler_28->first = 0;
            delay->rsdelta += count - AUDIO_SAMPLES;
        } else {
            n_aLoadBuffer(cmdBufPos++, FIXED_SAMPLE<<1, buff2, osVirtualToPhysical(outPtr));
        }
        if (delay->ffcoef) {
            aMix(cmdBufPos++, 0, (u16)delay->ffcoef, buff1, buff2);
 
            if (delay->resampler_28 == NULL && delay->lowpass_20 == NULL) {
                n_aSaveBuffer(cmdBufPos++, FIXED_SAMPLE<<1, buff2, osVirtualToPhysical(outPtr));
            }
        }
        if (delay->fbcoef) {
            aMix(cmdBufPos++, 0, (u16)delay->fbcoef, buff2, buff1);
            n_aSaveBuffer(cmdBufPos++, FIXED_SAMPLE<<1, buff1, osVirtualToPhysical(inPtr));
        }
        if (delay->lowpass_20 != NULL) {
            // modified _n_filterBuffer
            s16 tmp = buff2 >> 8;
            n_aLoadADPCM(cmdBufPos++, 32, osVirtualToPhysical(delay->lowpass_20->fccoef));
            n_aPoleFilter(cmdBufPos++, delay->lowpass_20->first, delay->lowpass_20->fgain, tmp, osVirtualToPhysical(delay->lowpass_20->fstate));
            delay->lowpass_20->first = 0;
        }
        if (!delay->resampler_28) {
            n_aSaveBuffer(cmdBufPos++, FIXED_SAMPLE<<1, buff2, osVirtualToPhysical(outPtr));
        }
        if (delay->gain) {
            aMix(cmdBufPos++, 0, (u16)delay->gain, buff2, outputBufCopy);
        }
        prevOutPtr = &fx->input[delay->output];
    }
 
    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 384 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].lowpass_20) {
            fx->delays[index].lowpass_20->fc = value;
            _init_lpfilter(fx->delays[index].lowpass_20);
        }
        break;
    }
    return 0;
}

Referenced by au_bus_set_fx_params().

sfx_get_env_sound_instance()

SoundInstance * sfx_get_env_sound_instance

(

s32

soundID

)

Definition at line 379 of file sfx.c.

                                                       {
    SoundInstance* sound = gCurrentEnvSounds;
    s32 i;
 
    for (i = 0; i < MAX_SOUND_INSTANCES; i++, sound++) {
        if (sound->flags & SOUND_INSTANCE_FLAG_ACTIVE && sound->soundID == soundID) {
            return sound;
        }
    }
 
    return NULL;
}

Referenced by sfx_adjust_env_sound_params(), sfx_adjust_env_sound_pos(), and snd_stop_tracking_env_sound_pos().