private.h File Reference

Go to the source code of this file.

Functions
void	au_load_BK_headers (AuGlobals *arg0, ALHeap *)
void	au_mseq_manager_init (AmbienceManager *arg0, s8 arg1, s8 reverbType, AuGlobals *arg3)
AuResult	au_mseq_check_player_index (u32 arg0)
void	au_mseq_load_tracks_fade (s32 arg0, s32 arg1)
void	au_mseq_set_disabled (s32 arg0, s32 arg1)
AuResult	au_mseq_start (s32 arg0, s32 arg1)
void	au_mseq_fade_setup (AmbiencePlayer *arg0)
void	au_mseq_pause (s32 arg0, s32 arg1)
void	au_mseq_resume (s32 arg0, s32 arg1)
void	au_mseq_stop_quick (s32 arg0)
void	au_mseq_stop_slow (s32 arg0, s32 arg1)
void	au_mseq_set_volume (s32 arg0, s32 arg1, s32 arg2)
AuResult	au_mseq_check_stopped (s32 arg0)
void	au_mseq_play_sequence (AmbienceManager *arg0, MSEQHeader *mseq, s32 index)
void	au_mseq_manager_audio_frame_update (AmbienceManager *arg0)
void	au_mseq_load_track_fade_info (AmbienceManager *manager, AmbiencePlayer *lambda)
void	au_mseq_player_update (AmbienceManager *manager, AmbiencePlayer *lambda)
u8	au_mseq_read_next (AmbiencePlayer *arg0)
void	au_mseq_player_stop (AmbienceManager *arg0, AmbiencePlayer *arg1)
void	au_mseq_save_voices (AmbienceManager *arg0, AmbiencePlayer *lambda)
void	au_mseq_restore_voices (AmbienceManager *manager, AmbiencePlayer *lambda)
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_begin_video_frame (SoundManager *manager)
s32	au_sfx_set_reverb_type (SoundManager *manager, s32 arg1)
void	au_sfx_set_state (SoundManager *manager, s32 arg1)
void	au_sfx_try_sound (SoundManager *manager, SoundRequest *request, SoundManagerCustomCmdList *)
s16	au_sfx_manager_audio_frame_update (SoundManager *manager)
void	au_bgm_begin_video_frame (BGMPlayer *player)
BGMPlayer *	au_bgm_get_player_with_song_name (s32 songString)
AuResult	au_bgm_process_init_song (SongStartRequest *event)
AuResult	au_bgm_stop_song (s32 songName)
void	au_bgm_stop_all (void)
AuResult	au_bgm_is_song_playing (s32 songName)
b32	au_bgm_player_is_active (BGMPlayer *player)
AuResult	au_bgm_process_fade_out (SongFadeOutRequest *s)
AuResult	au_bgm_complete_push (s32 songName)
AuResult	au_bgm_process_suspend (SongSuspendRequest *update, b32 skipStop)
AuResult	au_bgm_process_resume (SongResumeRequest *update)
void	au_bgm_restore_copied_player (AuGlobals *globals)
AuResult	au_bgm_adjust_volume (SongStartRequest *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	au_bgm_update_bus_volumes (BGMPlayer *arg0)
s32	au_bgm_player_audio_frame_update (BGMPlayer *player)
void	au_bgm_player_initialize (BGMPlayer *player)
void	au_bgm_clear_custom_note_press (BGMPlayer *player, s32 arg1)
void	au_bgm_set_tick_resolution (BGMPlayer *player, s32 sampleRate, u32 resolution)
void	au_bgm_player_read_composition (BGMPlayer *player)
void	au_bgm_end_composition_loop (BGMPlayer *player, u32 cmd)
void	au_bgm_load_phrase (BGMPlayer *player, u32 cmd)
void	au_bgm_player_update_stop (BGMPlayer *player)
void	au_bgm_player_update_playing (BGMPlayer *player)
	play next tick
void	au_BGMCmd_E0_MasterTempo (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_E1_MasterVolume (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_E2_MasterDetune (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_InstrumentVolume (BGMPlayer *arg0, BGMPlayerTrack *track)
void	au_BGMCmd_F6_InstrumentVolumeLerp (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_EA_InstrumentPan (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_EB_InstrumentReverb (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_EC_TrackVolume (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_ED_InstrumentCoarseTune (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_EE_InstrumentFineTune (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_EC_TrackDetune (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_F0_TrackTremolo (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_F1_TrackTremoloRate (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_F2_TrackTremoloDepth (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_F3_TrackTremoloStop (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_F4_SubTrackRandomPan (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_F5_UseInstrument (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_F7_ReverbType (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_Branch (BGMPlayer *player, BGMPlayerTrack *track)
void	au_BGMCmd_FF_Special (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	au_bgm_set_prox_mix_fade (BGMPlayer *player, BGMPlayerTrack *track, s32 target, s32 duration)
void	au_bgm_reset_all_voices (BGMPlayer *player)
AuResult	au_bgm_set_linked_tracks (SongSwapLinkedRequest *arg0)
void	snd_bgm_clear_legacy_commands (BGMPlayer *player)
	Part of an unused system for inter-thread communication with a BGM player using commands.
AuResult	snd_song_get_playing_info (s32 songName, BGMHeader **outTrackData, BGMPlayer **outPlayer)
AuResult	snd_song_set_detune (s32 songName, s32 arg1)
AuResult	snd_song_set_track_volumes (s32 songName, MusicTrackVols arg1)
AuResult	snd_song_clear_track_volumes (s32 songName, MusicTrackVols arg1)
AuResult	snd_song_set_track_vol_mute (s32 arg0, s32 arg1)
AuResult	snd_song_set_track_vol_quiet (s32 arg0, s32 arg1)
AuResult	snd_song_set_track_vol_full (s32 arg0, s32 arg1)
void	snd_song_set_proximity_mix_far (s32 songName, s32 mix)
void	snd_song_set_proximity_mix_near (s32 songName, s32 mix)
void	snd_song_set_proximity_mix_full (s32 songName, s32 mix)
SoundInstance *	sfx_get_env_sound_instance (s32 soundID)

Function Documentation

au_load_BK_headers()

void au_load_BK_headers	(	AuGlobals *	arg0,
		ALHeap *	heap )

Definition at line 4 of file load_banks.c.

                                                          {
    SBNFileEntry fileEntry;
    InitBankEntry buffer[INIT_BANK_BUFFER_SIZE];
    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].bankSet);
    }
}

Referenced by au_engine_init().

au_mseq_manager_init()

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

Definition at line 44 of file mseq_player.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 = AU_MAX_VOLUME_8 << 24;
    }
 
    manager->globals = globals;
    manager->nextUpdateStep = 1;
    manager->nextUpdateCounter = 2;
    manager->nextUpdateInterval = 2;
    manager->priority = priority;
    manager->busID = busID;
}

Referenced by au_engine_init().

au_mseq_check_player_index()

AuResult au_mseq_check_player_index

(

u32

arg0

)

Definition at line 65 of file mseq_player.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_fade_out(), snd_ambient_is_stopped(), snd_ambient_pause(), snd_ambient_play(), snd_ambient_resume(), snd_ambient_set_volume(), snd_ambient_stop_quick(), and snd_ambient_stop_slow().

au_mseq_load_tracks_fade()

void au_mseq_load_tracks_fade	(	s32	arg0,
		s32	arg1 )

Definition at line 73 of file mseq_player.c.

                                                  {
    gAuAmbienceManager->loadTracksFadeInfo = arg1;
}

Referenced by snd_ambient_fade_out().

au_mseq_set_disabled()

void au_mseq_set_disabled	(	s32	arg0,
		s32	arg1 )

Definition at line 77 of file mseq_player.c.

                                                  {
    AmbienceManager* manager = gAuAmbienceManager;
    AmbiencePlayer* player = &manager->players[index];
 
    if (!disable) {
        player->playState = MSEQ_PLAYER_PLAYING;
    } else {
        player->playState = MSEQ_PLAYER_STOPPING;
    }
}

Referenced by snd_ambient_disable(), and snd_ambient_enable().

au_mseq_start()

AuResult au_mseq_start	(	s32	arg0,
		s32	arg1 )

Definition at line 88 of file mseq_player.c.

                                            {
    AmbiencePlayer* player = &gAuAmbienceManager->players[index];
    MSEQHeader* mseq = gAuAmbienceManager->mseqFiles[index];
    AuResult status = AU_RESULT_OK;
 
    if (mseq != NULL) {
        if (player->mseqName == 0) {
            au_mseq_play_sequence(gAuAmbienceManager, mseq, index);
            if (time != 0) {
                player->fadeSettingsTime = time;
                player->fadeSettingsInitial = 0;
                player->fadeSettingsGoal = AU_MAX_VOLUME_8;
                player->fadeSettingsType = MSEQ_FADE_IN;
                au_mseq_fade_setup(player);
            }
        } else {
            status = AU_AMBIENCE_ERROR_PLAYER_BUSY;
        }
    } else {
        status = AU_AMBIENCE_ERROR_MSEQ_NOT_FOUND;
    }
    return status;
}

Referenced by snd_ambient_play().

au_mseq_fade_setup()

void au_mseq_fade_setup

(

AmbiencePlayer *

arg0

)

Definition at line 112 of file mseq_player.c.

                                                {
    u16 time = player->fadeSettingsTime;
 
    if (player->fadeSettingsInitial == 255) {
        player->fadeSettingsInitial = player->fadeVolume >> 24;
    }
 
    if (time >= SND_MIN_DURATION && time <= SND_MAX_DURATION) {
        player->fadeVolume = player->fadeSettingsInitial << 24;
        player->fadeGoal = player->fadeSettingsGoal;
 
        // converts a fade time in milliseconds to the number of player update ticks needed to complete the fade
        // the ambience manager updates every other audio frame, so given outputRate = 32000 and frameSize = 184,
        // update ticks needed = (32000 / 184) / 2, and then we divide by 1000 (since fade time has units of ms).
        // this reduces to 16/184, which is exactly 1.6 times 10/115
        // why this odd reduction was chosen unstead of 16/184 is unknown
        player->fadeTime = (u32)(time * 10) / 115;
        player->fadeStep = ((player->fadeSettingsGoal - player->fadeSettingsInitial) << 24) / ((s16)player->fadeTime & 0xFFFF);
    }
 
    player->fadeSettingsTime = 0;
    player->fadeSettingsInitial = 0;
    player->fadeSettingsGoal = 0;
}

Referenced by au_mseq_manager_audio_frame_update(), and au_mseq_start().

au_mseq_pause()

void au_mseq_pause	(	s32	arg0,
		s32	arg1 )

Definition at line 137 of file mseq_player.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 = MSEQ_FADE_OUT_PAUSING;
            return;
        }
        player->mode = MSEQ_MODE_PAUSING;
    }
}

Referenced by snd_ambient_pause().

au_mseq_resume()

void au_mseq_resume	(	s32	arg0,
		s32	arg1 )

Definition at line 152 of file mseq_player.c.

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

Referenced by snd_ambient_resume().

au_mseq_stop_quick()

void au_mseq_stop_quick

(

s32

arg0

)

Definition at line 168 of file mseq_player.c.

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

Referenced by snd_ambient_stop_quick().

au_mseq_stop_slow()

void au_mseq_stop_slow	(	s32	arg0,
		s32	arg1 )

Definition at line 183 of file mseq_player.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 = MSEQ_FADE_OUT;
    }
}

Referenced by snd_ambient_stop_slow().

au_mseq_set_volume()

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

Definition at line 198 of file mseq_player.c.

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

Referenced by snd_ambient_set_volume().

au_mseq_check_stopped()

AuResult au_mseq_check_stopped

(

s32

arg0

)

Definition at line 217 of file mseq_player.c.

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

Referenced by snd_ambient_is_stopped().

au_mseq_play_sequence()

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

Definition at line 230 of file mseq_player.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 = AU_MAX_VOLUME_8 << 24;
    player->fadeGoal = AU_MAX_VOLUME_8;
 
    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 = AU_MAX_VOLUME_32;
        track->pan = 64;
    }
    player->resetRequired = TRUE;
}

Referenced by au_mseq_start().

au_mseq_manager_audio_frame_update()

void au_mseq_manager_audio_frame_update

(

AmbienceManager *

arg0

)

Definition at line 266 of file mseq_player.c.

                                                                  {
    u32 i;
    s32 j;
 
    for (i = 0; i < ARRAY_COUNT(manager->voiceStates); i++) {
        AmbienceVoiceState* voiceState = &manager->voiceStates[i];
 
        // potential @bug, any voice which is not properly released via MSEQ_CMD_80_STOP_SOUND will eventaully
        // end and set its priority to AU_PRIORITY_FREE, where another client can steal it and begin using it
        // without it being considered 'free' by this AmbienceManager. this can be fixed by removing the check
        // for released == TRUE from the conditional
        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_mseq_load_track_fade_info(manager, player);
            }
 
            mode = player->mode;
            if (mode != MSEQ_MODE_PLAYING) {
                if (mode == MSEQ_MODE_PAUSING) {
                    player->mode = MSEQ_MODE_STOPPED;
                    au_mseq_save_voices(manager, player);
                    au_mseq_player_stop(manager, player);
                } else if (player->mode == MSEQ_MODE_RESUMING) {
                    player->mode = MSEQ_MODE_PLAYING;
                    if (player->fadeSettingsTime != 0) {
                        au_mseq_fade_setup(player);
                    }
                    au_mseq_restore_voices(manager, player);
                }
            } else {
                // case MSEQ_MODE_PLAYING
                if (player->fadeSettingsTime != 0) {
                    au_mseq_fade_setup(player);
                }
                if (player->playState == MSEQ_PLAYER_STOPPING) {
                    au_mseq_player_stop(manager, player);
                    player->playState = MSEQ_PLAYER_STOPPED;
                }
                au_mseq_player_update(manager, player);
            }
        }
    }
 
    manager->loadTracksFadeInfo = FALSE;
}

Referenced by au_update_clients_for_audio_frame().

au_mseq_load_track_fade_info()

void au_mseq_load_track_fade_info	(	AmbienceManager *	manager,
		AmbiencePlayer *	lambda )

Definition at line 321 of file mseq_player.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 << 16) / trackData->time;
                track->tuneLerp.goal = trackData->goal;
            } else if (trackData->type == 1) {
                track->volumeLerp.time = trackData->time;
                track->volumeLerp.step = (trackData->delta << 16) / trackData->time;
                track->volumeLerp.goal = trackData->goal;
            }
            trackData++;
        }
    }
}

Referenced by au_mseq_manager_audio_frame_update().

au_mseq_player_update()

void au_mseq_player_update	(	AmbienceManager *	manager,
		AmbiencePlayer *	lambda )

Definition at line 348 of file mseq_player.c.

                                                                             {
    u8 isVolumeChanged[16];
    u8 isPitchChanged[16];
    AuGlobals* globals;
    u8 fadeVolChanged;
    AmbienceVoiceState* voiceState;
    AuVoice* voice;
    BGMDrumInfo* drum;
    u32 trackIdx;
    s32 voiceSelector;
    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_mseq_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 << 24;
            if (player->fadeSettingsType == MSEQ_FADE_IN) {
                // do nothing
            } else if (player->fadeSettingsType == MSEQ_FADE_OUT) {
                player->mseqReadPos = BlankMseqData;
                player->delay = 1;
            } else if (player->fadeSettingsType == MSEQ_FADE_OUT_PAUSING) {
                player->mode = MSEQ_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 << 16;
            }
 
            voiceSelector = player->id.all + (trackIdx << 16);
            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) == voiceSelector) {
                    voice = &globals->voices[i];
                    if (voice->priority == manager->priority && trackIdx != TRACK_ID_DRUM) {
                        voice->pitchRatio = au_compute_pitch_ratio(voiceState->pitch + (track->tuneLerp.current >> 16)) * 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 << 16;
            }
 
            voiceSelector = player->id.all + (trackIdx << 16);
            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) == voiceSelector) {
                    voice = &globals->voices[i];
                    if (voice->priority == manager->priority) {
                        track = &player->tracks[voiceState->info.trackIndex];
                        voice->clientVolume = VOL_MULT_3(player->fadeVolume >> 24, track->volumeLerp.current >> 16, voiceState->volume);
                        voice->envelopeFlags |= AU_VOICE_ENV_FLAG_VOL_CHANGED;
                    }
                }
            }
        }
    }
 
    player->delay--;
    if (player->delay <= 0) {
        while (player->delay == 0) {
            op = au_mseq_read_next(player);
            if ((s8)op >= 0) {
                if (op == 0) {
                    // stop
                    player->mseqReadPos = NULL;
                    player->mseqName = 0;
                    au_mseq_player_stop(manager, player);
                    break;
                }
                if (op >= 0x78) {
                    // long delay
                    player->delay = ((op & 7) << 8) + au_mseq_read_next(player) + 0x78;
                } else {
                    //short delay
                    player->delay = op;
                }
                continue;
            }
 
            // op >= 0x80
            // op & 0xF0 : command
            // op & 0xF : track index
 
            arg1 = au_mseq_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 == MSEQ_PLAYER_PLAYING) {
                        voiceSelector = player->id.all + (trackIdx << 16) + (arg1 << 8);
                        for (i = player->firstVoiceIdx; i < player->lastVoiceIdx; i++) {
                            if (manager->voiceStates[i - player->firstVoiceIdx].info.all == voiceSelector) {
                                manager->voiceStates[i - player->firstVoiceIdx].info.released = TRUE;
                                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_mseq_read_next(player);
                    if (player->playState == MSEQ_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) {
                            // try stealing a voice from the current player (or one with the same 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) {
                            // try stealing a voice from a different player with a 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 << 16) + (arg1 << 8);
                            if (track->flags & MSEQ_TRACK_RESUMABLE) {
                                voiceState->isResumable = TRUE;
                            } else {
                                voiceState->isResumable = FALSE;
                            }
                            if (trackIdx != TRACK_ID_DRUM) {
                                if (track->flags & MSEQ_TRACK_RESUMABLE) {
                                    voiceState->isResumable = TRUE;
                                } else {
                                    voiceState->isResumable = FALSE;
                                }
 
                                voiceState->pitch = (arg1 & 0x7F) * 100 - track->instrument->keyBase;
                                voiceState->volume = arg2 & 0x7F;
                                voice->clientVolume = VOL_MULT_3(player->fadeVolume >> 24, track->volumeLerp.current >> 16, voiceState->volume);
                                voice->pitchRatio = au_compute_pitch_ratio(voiceState->pitch + (track->tuneLerp.current >> 16)) * 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 = VOL_MULT_2(arg2 & 0x7F, drum->volume);
                                voice->clientVolume = VOL_MULT_3(player->fadeVolume >> 24, track->volumeLerp.current >> 16, voiceState->volume);
                                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;
                        voiceSelector = player->id.all + (trackIdx << 16);
                        for (i = player->firstVoiceIdx; i < player->lastVoiceIdx; i++) {
                            voiceState = &manager->voiceStates[i - player->firstVoiceIdx];
                            if ((voiceState->info.all & 0xFFFF0000) == voiceSelector) {
                                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 << 24;
                        if (track->volumeLerp.current != 0) {
                            track->volumeLerp.current |= 0xFFFFFF;
                        }
                        voiceSelector = player->id.all + (trackIdx << 16);
                        for (i = player->firstVoiceIdx; i < player->lastVoiceIdx; i++) {
                            voiceState = &manager->voiceStates[i - player->firstVoiceIdx];
                            if ((voiceState->info.all & 0xFFFF0000) == voiceSelector) {
                                voice = &globals->voices[i];
                                if (voice->priority == manager->priority) {
                                    voice->clientVolume = VOL_MULT_3(player->fadeVolume >> 24, track->volumeLerp.current >> 16, voiceState->volume);
                                    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_mseq_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 |= MSEQ_TRACK_RESUMABLE;
                            }
                            break;
                    }
                    break;
                case MSEQ_CMD_C0_SET_INSTRUMENT:
                    // arg1: bank
                    // arg2: patch
                    arg2 = au_mseq_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 << 24) + (au_mseq_read_next(player) << 16);
                    voiceSelector = player->id.all + (trackIdx << 16);
                    for (i = player->firstVoiceIdx; i < player->lastVoiceIdx; i++) {
                        voiceState = &manager->voiceStates[i - player->firstVoiceIdx];
                        if ((voiceState->info.all & 0xFFFF0000) == voiceSelector) {
                            voice = &globals->voices[i];
                            if (voice->priority == manager->priority && trackIdx != TRACK_ID_DRUM) {
                                voice->pitchRatio = au_compute_pitch_ratio(voiceState->pitch + (track->tuneLerp.current >> 16)) * 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 = VOL_MULT_3(player->fadeVolume >> 24, track->volumeLerp.current >> 16, voiceState->volume);
                    voice->envelopeFlags |= AU_VOICE_ENV_FLAG_VOL_CHANGED;
                }
            }
        }
    }
}

Referenced by au_mseq_manager_audio_frame_update().

au_mseq_read_next()

u8 au_mseq_read_next

(

AmbiencePlayer *

arg0

)

Definition at line 698 of file mseq_player.c.

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

Referenced by au_mseq_player_update().

au_mseq_player_stop()

void au_mseq_player_stop	(	AmbienceManager *	arg0,
		AmbiencePlayer *	arg1 )

Definition at line 703 of file mseq_player.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_mseq_manager_audio_frame_update(), and au_mseq_player_update().

au_mseq_save_voices()

void au_mseq_save_voices	(	AmbienceManager *	arg0,
		AmbiencePlayer *	lambda )

Definition at line 720 of file mseq_player.c.

                                                                           {
    AmbienceSavedVoice* savedVoice = player->savedVoices;
    u32 numSaved = 0;
    s32 i;
 
    for (i = player->firstVoiceIdx; i < player->lastVoiceIdx; i++) {
        AmbienceVoiceState* voiceState = &manager->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_mseq_manager_audio_frame_update().

au_mseq_restore_voices()

void au_mseq_restore_voices	(	AmbienceManager *	manager,
		AmbiencePlayer *	lambda )

Definition at line 744 of file mseq_player.c.

                                                                              {
    AuGlobals* globals;
    AuVoice* voice;
    AmbienceSavedVoice* savedVoice;
    AmbienceVoiceState* voiceState;
    AmbienceTrack* track;
    u32 i, j;
 
    globals = manager->globals;
    if (player->playState == MSEQ_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 << 16) + (savedVoice->tune << 8);
                    voiceState->pitch = (savedVoice->tune & 0x7F) * 100 - track->instrument->keyBase;
                    voiceState->volume = savedVoice->volume & 0x7F;
                    voice->clientVolume = VOL_MULT_3(player->fadeVolume >> 24, track->volumeLerp.current >> 16, voiceState->volume);
                    voice->pitchRatio = au_compute_pitch_ratio(voiceState->pitch + (track->tuneLerp.current >> 16)) * 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_mseq_manager_audio_frame_update().

au_sfx_init()

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

Definition at line 466 of file sfx_player.c.

                                                                                                   {
    // odd choice of parameters, perhaps chosen for a very large LCM (67934687500)?
    // gives a pseudo-random sfx update pattern
    s32 c = 434782;
    u32 i;
 
    manager->globals = globals;
    manager->nextUpdateStep = 312500;
    manager->nextUpdateCounter = c;
    manager->nextUpdateInterval = c;
    manager->priority = priority;
    manager->busID = busID;
 
    if (minVoiceIdx > 16) {
        manager->firstVoice = 16;
    } else {
        manager->firstVoice = minVoiceIdx;
    }
 
    manager->busVolume = AU_MAX_BUS_VOLUME;
    manager->baseVolume = AU_MAX_BUS_VOLUME;
    manager->frameCounter = 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->cmdListOneShot[0] = 0; // will be set to bank
        player->cmdListOneShot[1] = 0; // will be set to patch
        player->cmdListOneShot[2] = 0; // will be set to volume
        player->cmdListOneShot[3] = AU_PAN_MID; // default pan
        player->cmdListOneShot[4] = 0; // reverb
        player->cmdListOneShot[5] = 0x80 + (DEFAULT_KEYBASE / 100); // default tune, higher bit is meaningless
        player->cmdListOneShot[6] = 0; // random pitch
        player->cmdListOneShot[7] = 0; // unused
    }
 
    for (i = 0; i < ARRAY_COUNT(manager->bgmSounds); i++) {
        manager->bgmSounds[i].raw = 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, AU_MAX_VOLUME_16, AU_MAX_VOLUME_16);
    au_fade_set_volume(manager->busID, manager->fadeInfo.baseVolume >> 16, 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 551 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 571 of file sfx_player.c.

                                               {
    s32 i;
 
    for (i = 0; i < SFX_QUEUE_SIZE; i++) {
        manager->soundQueue[i].soundID = SOUND_NONE;
        manager->soundQueue[i].toReplaceID = SOUND_NONE;
        manager->soundQueue[i].volume = 0;
        manager->soundQueue[i].pitchShift = 0;
        manager->soundQueue[i].pan = 0;
    }
 
    manager->unused_165 = 0;
    manager->sfxQueueWritePos = 0;
    manager->sfxQueueReadPos = 0;
    manager->unused_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 590 of file sfx_player.c.

                                                                                                  {
    // Determine the number of pending sound effects in the queue
    s32 pending = manager->sfxQueueWritePos - manager->sfxQueueReadPos;
    if (pending < 0) {
        pending += SFX_QUEUE_SIZE;
    }
 
    // Only enqueue if there's room in the buffer
    if (pending < SFX_QUEUE_SIZE) {
        u32 nextPos = manager->sfxQueueWritePos;
 
        manager->soundQueue[nextPos].soundID = soundID & (SOUND_ID_LOWER | SOUND_ID_STOP | SOUND_ID_ADJUST | SOUND_ID_TRIGGER_MASK);
        manager->soundQueue[nextPos].toReplaceID = (soundID & SOUND_ID_UPPER_MASK) >> 0x10;
        manager->soundQueue[nextPos].volume = volume;
        manager->soundQueue[nextPos].pitchShift = pitchShift;
        manager->soundQueue[nextPos].pan = pan;
 
        nextPos++;
        if (nextPos >= SFX_QUEUE_SIZE) {
            nextPos = 0;
        }
 
        manager->sfxQueueWritePos = nextPos;
    }
}

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

void au_sfx_begin_video_frame

(

SoundManager *

manager

)

Definition at line 618 of file sfx_player.c.

                                                     {
    SoundRequest newRequest;
    SoundRequest* request;
    u32 i, j, k;
    s32 pending;
 
    manager->frameCounter++;
    if (manager->resetPending) {
        au_sfx_reset_players(manager);
        manager->resetPending = FALSE;
    }
 
    // Process sound effects triggered by music via BGM_SPECIAL_TRIGGER_SOUND
    for (i = 0; i < ARRAY_COUNT(manager->bgmSounds); i++) {
        k = manager->bgmSounds[i].index;
        if (k == 0) {
            // do nothing
        } else if (k <= ARRAY_COUNT(MusicSounds)) {
            MusicTriggeredSound* triggered = &MusicSounds[k-1];
            u16 prereq = triggered->prereq;
            if (prereq != 0) {
                // try playing sound ONLY IF prereq sound is already playing
                for (j = 0; j < ARRAY_COUNT(manager->players); j++) {
                    if (manager->players[j].curSoundID == prereq) {
                        newRequest.soundID = triggered->sound;
                        newRequest.toReplaceID = SOUND_NONE;
                        newRequest.pitchShift = 0;
                        if ((triggered->flags & 1) && (manager->bgmSounds[i].volume != 0)) {
                            newRequest.volume = (manager->bgmSounds[i].volume << 8) + 0xFF;
                        } else {
                            newRequest.volume = 0;
                        }
                        newRequest.pan = 0;
                        au_sfx_try_sound(manager, &newRequest, NULL);
                        break;
                    }
                }
            } else {
                // no prereq defined, unconditionally play the sound
                newRequest.soundID = triggered->sound;
                newRequest.toReplaceID = SOUND_NONE;
                newRequest.volume = 0;
                newRequest.pitchShift = 0;
                newRequest.pan = 0;
                au_sfx_try_sound(manager, &newRequest, NULL);
            }
        }
        // clear the event
        manager->bgmSounds[i].raw = 0;
    }
 
    // Process sound effects triggered by SEF command 17
    for (i = 0; i < ARRAY_COUNT(manager->customCmdList); i++) {
        if (manager->customCmdList[i].data[0] != 0) {
            newRequest.soundID = 1;
            newRequest.toReplaceID = SOUND_NONE;
            newRequest.volume = 0;
            newRequest.pitchShift = 0;
            newRequest.pan = 0;
            au_sfx_try_sound(manager, &newRequest, &manager->customCmdList[i]);
        }
        manager->customCmdList[i].data[0] = 0;
    }
 
    // Determine the number of pending sound effects in the queue
    pending = manager->sfxQueueWritePos - manager->sfxQueueReadPos;
    if (pending < 0) {
        pending += SFX_QUEUE_SIZE;
    }
 
    // Process each pending sound effect in the queue
    j = manager->sfxQueueReadPos;
    if (pending > 0 && pending < SFX_QUEUE_SIZE) {
        for (i = 0; i < pending; i++) {
            request = &manager->soundQueue[j];
            if (request->soundID & SOUND_ID_LOWER) {
                if (request->soundID & SOUND_ID_STOP) {
                    au_sfx_stop_by_id(manager, request->soundID);
                } else if (!(request->soundID & (SOUND_ID_ADJUST | SOUND_ID_TRIGGER_MASK))) {
                    au_sfx_try_sound(manager, request, NULL);
                } else {
                    if (request->soundID & SOUND_ID_TRIGGER_MASK) {
                        au_sfx_set_triggers(manager, request->soundID);
                    }
                    if (request->soundID & SOUND_ID_ADJUST) {
                        au_sfx_set_modifiers(manager, request);
                    }
                }
            }
            request->soundID = SOUND_NONE;
 
            j++;
            if (j >= SFX_QUEUE_SIZE) {
                j = 0;
            }
        }
        manager->sfxQueueReadPos = manager->sfxQueueWritePos;
    }
}

Referenced by au_update_clients_for_video_frame().

au_sfx_set_reverb_type()

s32 au_sfx_set_reverb_type	(	SoundManager *	manager,
		s32	arg1 )

Definition at line 719 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_set_reverb_type(), and au_sfx_init().

au_sfx_set_state()

void au_sfx_set_state	(	SoundManager *	manager,
		s32	arg1 )

Definition at line 739 of file sfx_player.c.

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

Referenced by au_sfx_init(), snd_disable_sfx(), and snd_enable_sfx().

au_sfx_try_sound()

void au_sfx_try_sound	(	SoundManager *	manager,
		SoundRequest *	request,
		SoundManagerCustomCmdList *	customSEF )

Definition at line 747 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_POLY_TRACK trackCount--; if (trackCount <= 0 ) { break; } cmdList += 2;
 
    u32 soundIndex = (request->soundID - 1) & 0xFF;
    u16 soundIDLower = request->soundID & SOUND_ID_LOWER;
    u16 soundID = request->soundID;
 
    if (soundID & SOUND_ID_UNK) {
        // sound from extra section
        soundIndex = (request->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, request, 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, request, 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 (request->toReplaceID != SOUND_NONE) {
                        for (playerIndex = 0; playerIndex < 8; playerIndex++) {
                            player = &manager->players[playerIndex];
                            if (player->curSoundID == request->toReplaceID) {
                                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), request, 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), request, 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, request->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), request, priority, exclusiveID);
                                    NEXT_POLY_TRACK;
                                }
                            } else {
                                NEXT_POLY_TRACK;
                            }
 
                        }
 
                        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), request, priority, exclusiveID);
                                        NEXT_POLY_TRACK;
                                    }
                                    playerIndex--;
                                } else {
                                    NEXT_POLY_TRACK;
                                }
                            }
                        }
 
                        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), request, priority, exclusiveID);
                                        NEXT_POLY_TRACK;
                                    }
                                } else {
                                    NEXT_POLY_TRACK;
                                }
                            }
                        }
                    } 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), request, priority, exclusiveID);
                                }
                                cmdList += 2;
                            }
                        }
                    }
                }
            }
        }
    }
    #undef NEXT_POLY_TRACK
}

Referenced by au_sfx_begin_video_frame().

au_sfx_manager_audio_frame_update()

s16 au_sfx_manager_audio_frame_update

(

SoundManager *

manager

)

Definition at line 1139 of file sfx_player.c.

                                                             {
    SoundPlayer* player;
    AuVoice* voice;
    u32 startVoice;
    u8 end;
    u8 i;
 
    // update pseudorandom number with fast 'good enough' method
    manager->randomValue = (u16)manager->randomValue + (u16)manager->frameCounter;
 
    startVoice = manager->firstVoice;
    for (i = startVoice, end = startVoice + ARRAY_COUNT(manager->players); i < end; i++) {
        player = &manager->players[i - manager->firstVoice];
        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_MODE_MASK) {
                    case SFX_PARAM_MODE_BASIC:
                        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_COMPACT:
                        break;
                }
            } else {
                player->sefDataReadPos = NULL;
                player->curSoundID = SOUND_NONE;
                player->priority = 0;
            }
        }
    }
    return 0;
}

Referenced by au_update_clients_for_audio_frame().

au_bgm_begin_video_frame()

void au_bgm_begin_video_frame

(

BGMPlayer *

player

)

Definition at line 23 of file bgm_player.c.

                                                 {
    BGMHeader* bgmFile;
    BGMFileInfo* bgmData;
    s32 unkType;
    u32 compID;
    s32 compOffset;
    u32 value;
    s32 consumed;
    u8 var_a1;
    u8 pos;
    u32 i;
 
    compID = 0;
    unkType = -1;
    player->frameCounter++;
 
    if (player->cmdBufPending != 0) {
        if (player->cmdBufPending < ARRAY_COUNT(player->cmdBufData)) {
            pos = player->cmdBufReadPos;
            for (var_a1 = 0; var_a1 < player->cmdBufPending; var_a1++) {
                value = player->cmdBufData[pos];
                if (value != 0) {
                    if (value < 16) {
                        unkType = value & 3;
                        compID = value >> 2;
                    }
                    pos++;
                    if (pos >= ARRAY_COUNT(player->cmdBufData)) {
                        pos = 0;
                    }
                }
            }
            consumed = player->cmdBufWritePos - player->cmdBufReadPos;
            if (consumed < 0) {
                consumed += ARRAY_COUNT(player->cmdBufData);
            }
            player->cmdBufPending -= consumed;
            player->cmdBufReadPos = player->cmdBufWritePos;
        } else {
            player->cmdBufPending = 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_DEFAULT_UPDATE_STEP;
                    if (unkType == 2) {
                        bgmFile = player->globals->dataBGM[1];
                    } else {
                        bgmFile = player->globals->dataBGM[0];
                    }
                    player->bgmFile = bgmFile;
                    bgmData = &bgmFile->info;
                    au_bgm_set_tick_resolution(player, BGM_DEFAULT_UPDATE_STEP, BgmTicksRates[*(player->tickRatePtr) & 7]);
 
                    compOffset = bgmData->compositions[compID];
                    if (compOffset == 0) {
                        compOffset = bgmData->compositions[0];
                    }
                    player->compStartPos = AU_FILE_RELATIVE(bgmFile, compOffset << 2);
                    player->compReadPos = AU_FILE_RELATIVE(bgmFile, compOffset << 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_clients_for_video_frame().

au_bgm_get_player_with_song_name()

BGMPlayer * au_bgm_get_player_with_song_name

(

s32

songString

)

Definition at line 124 of file bgm_player.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_adjust_volume(), au_bgm_is_song_playing(), au_bgm_process_fade_out(), au_bgm_process_init_song(), au_bgm_process_resume(), au_bgm_process_suspend(), au_bgm_set_linked_tracks(), au_bgm_set_proximity_mix(), and au_bgm_stop_song().

au_bgm_process_init_song()

AuResult au_bgm_process_init_song

(

SongStartRequest *

event

)

Definition at line 135 of file bgm_player.c.

                                                             {
    BGMPlayer* player;
    BGMFileInfo* fileInfo;
    s32 songName;
    s32 variation;
    s32 duration;
    s32 volume0;
    s32 volume1;
    AuResult status;
    u32 i;
 
    status = AU_RESULT_OK;
    songName = request->songName;
    variation = request->variation;
 
    if (songName != 0) {
        player = au_bgm_get_player_with_song_name(songName);
        if (player != NULL) {
            fileInfo = &player->bgmFile->info;
            duration = request->duration;
            if (duration != 0) {
                if (duration > SND_MAX_DURATION) {
                    duration = SND_MAX_DURATION;
                } else if (duration < SND_MIN_DURATION) {
                    duration = SND_MIN_DURATION;
                }
            }
            volume0 = request->startVolume;
            if (volume0 > AU_MAX_VOLUME_8) {
                volume0 = AU_MAX_VOLUME_8;
            }
            if (volume0 != 0) {
                volume0 = AU_VOL_8_TO_16(volume0);
            }
            volume1 = request->finalVolume;
            if (volume1 > AU_MAX_VOLUME_8) {
                volume1 = AU_MAX_VOLUME_8;
            }
            if (volume1 != 0) {
                volume1 = AU_VOL_8_TO_16(volume1);
            } else {
                volume1 = AU_MAX_VOLUME_16;
            }
 
            au_fade_init(&player->fadeInfo, duration, volume0, volume1);
            player->fadeInfo.envelopeTarget = AU_MAX_VOLUME_16;
            player->fadeInfo.envelopeTicks = 1;
            au_bgm_set_tick_resolution(player, BGM_DEFAULT_UPDATE_STEP, BgmTicksRates[fileInfo->timingPreset & 7]);
 
            if (variation < BGM_VARIATION_0 || variation > BGM_VARIATION_3 || fileInfo->compositions[variation] == 0) {
                variation = BGM_VARIATION_0;
            }
            player->curVariation = variation;
 
            player->compStartPos = AU_FILE_RELATIVE(player->bgmFile, fileInfo->compositions[variation] << 2);
            player->compReadPos = player->compStartPos;
 
            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 snd_song_request_fade_in(), snd_song_request_fade_in_default(), snd_song_request_play(), and snd_song_request_play_default().

au_bgm_stop_song()

AuResult au_bgm_stop_song

(

s32

songName

)

Definition at line 227 of file bgm_player.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 snd_song_stop().

au_bgm_stop_all()

void au_bgm_stop_all

(

void

)

Definition at line 247 of file bgm_player.c.

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

Referenced by snd_song_stop_all().

au_bgm_is_song_playing()

AuResult au_bgm_is_song_playing

(

s32

songName

)

Definition at line 261 of file bgm_player.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 snd_song_is_playing().

au_bgm_player_is_active()

b32 au_bgm_player_is_active

(

BGMPlayer *

player

)

Definition at line 279 of file bgm_player.c.

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

Referenced by au_bgm_process_resume(), and au_load_song_files().

au_bgm_process_fade_out()

AuResult au_bgm_process_fade_out

(

SongFadeOutRequest *

s

)

Definition at line 287 of file bgm_player.c.

                                                              {
    AuResult status;
    BGMPlayer* player;
    u32 songName = request->songName;
    u32 duration = request->duration;
    s16 volume = request->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->paused) {
                            player->fadeInfo.baseTarget = volume;
                            player->fadeInfo.baseTicks = (duration * 1000) / AU_FRAME_USEC;
                            player->fadeInfo.baseStep = ((volume << 0x10) - player->fadeInfo.baseVolume) / player->fadeInfo.baseTicks;
                            player->fadeInfo.onCompleteCallback = request->doneCallback;
                            if (request->onPush == 1) {
                                player->pushSongName = 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 snd_song_request_fade_out(), and snd_song_request_push_fade_out().

au_bgm_complete_push()

AuResult au_bgm_complete_push

(

s32

songName

)

Definition at line 324 of file bgm_player.c.

                                            {
    SongSuspendRequest s;
 
    s.songName = songName;
    s.duration = 0;
    s.startVolume = 0;
    s.finalVolume = 0;
    s.index = BGM_SNAPSHOT_0;
    s.pauseMode = FALSE;
 
    return au_bgm_process_suspend(&s, 0); // force stop
}

Referenced by au_bgm_update_fade().

au_bgm_process_suspend()

AuResult au_bgm_process_suspend	(	SongSuspendRequest *	update,
		b32	skipStop )

Definition at line 337 of file bgm_player.c.

                                                                           {
    AuResult status;
    BGMPlayer* player;
    BGMPlayer* snapshot;
    s32 songName;
    s32 index;
    u32 i;
    u32 j;
 
    songName = request->songName;
    index = request->index;
    status = AU_RESULT_OK;
 
    if (songName != 0) {
        player = au_bgm_get_player_with_song_name(songName);
        if (player != NULL) {
            if (!request->pauseMode) {
                snapshot = au_get_snapshot_by_index(index);
                if (snapshot != NULL) {
                    if (songName == player->songName) {
                        if (!skipStop) {
                            for (i = 0; i < ARRAY_COUNT(player->tracks); i++) {
                                BGMPlayerTrack* track = &player->tracks[i];
                                if (track->bgmReadPos != NULL) {
                                    for (j = track->firstVoice; j < track->lastVoice; j++) {
                                        track->changed.all = 0;
                                    }
                                }
                            }
                        }
                        player->globals->snapshots[index].priority = player->priority;
                        player->globals->snapshots[index].assigned = 1;
                        player->pushSongName = 0;
                        au_copy_words(player, snapshot, sizeof(*player));
                        if (!skipStop) {
                            au_bgm_stop_player(player);
                        }
                    }
                } else {
                    status = AU_ERROR_INVALID_SONG_DURATION;
                }
            } else {
                if (songName == player->songName) {
                    if (player->masterState != BGM_PLAY_STATE_IDLE) {
                        player->paused = TRUE;
                        au_bgm_reset_all_voices(player);
                    }
                }
            }
        } else {
            status = AU_ERROR_SONG_NOT_PLAYING;
        }
    } else {
        status = AU_ERROR_NULL_SONG_NAME;
    }
    return status;
}

Referenced by au_bgm_complete_push(), snd_song_push_stop(), snd_song_request_pause(), and snd_song_request_snapshot().

au_bgm_process_resume()

AuResult au_bgm_process_resume

(

SongResumeRequest *

update

)

Definition at line 395 of file bgm_player.c.

                                                           {
    AuResult status;
    BGMPlayer* player;
    BGMPlayer* snapshot;
    s32 index;
    s32 songName;
    s32 volume0;
    s32 volume1;
    s32 duration;
 
    songName = request->songName;
    index = request->index;
    status = AU_RESULT_OK;
 
    if (songName != 0) {
        if (!request->pauseMode) {
            snapshot = au_get_snapshot_by_index(index);
            if (snapshot != NULL && snapshot->globals->snapshots[index].assigned == 1) {
                player = au_get_client_by_priority(snapshot->globals->snapshots[index].priority);
                if (player != NULL) {
                    if (!au_bgm_player_is_active(player)) {
                        status = au_reload_song_files(snapshot->songID, snapshot->bgmFile);
                        duration = request->duration;
                        if (duration != 0) {
                            if (duration > SND_MAX_DURATION) {
                                duration = SND_MAX_DURATION;
                            } else if (duration < SND_MIN_DURATION) {
                                duration = SND_MIN_DURATION;
                            }
                        }
                        volume0 = request->startVolume;
                        if (volume0 > AU_MAX_VOLUME_8) {
                            volume0 = AU_MAX_VOLUME_8;
                        }
                        if (volume0 != 0) {
                            volume0 = AU_VOL_8_TO_16(volume0);
                        }
                        volume1 = request->finalVolume;
                        if (volume1 > AU_MAX_VOLUME_8) {
                            volume1 = AU_MAX_VOLUME_8;
                        }
                        if (volume1 != 0) {
                            volume1 = AU_VOL_8_TO_16(volume1);
                        } else {
                            volume1 = AU_MAX_VOLUME_16;
                        }
                        player->globals->resumeCopyTo = player;
                        player->globals->resumeCopyFrom = snapshot;
                        player->globals->resumeSongName = songName;
                        player->globals->resumeFadeTime = duration;
                        player->globals->resumeFadeStart = volume0;
                        player->globals->resumeFadeEnd = volume1;
                        player->globals->resumeRequested = TRUE;
                    } else {
                        status = AU_ERROR_7;
                    }
                } else {
                    status = AU_ERROR_6;
                }
            } else {
               status = AU_ERROR_INVALID_SONG_DURATION;
            }
        } else {
            player = au_bgm_get_player_with_song_name(songName);
            if (player != NULL) {
                if (songName == player->songName) {
                    if (player->paused) {
                        player->paused = FALSE;
                    }
                }
            }
        }
    } else {
        status = AU_ERROR_NULL_SONG_NAME;
    }
    return status;
}

Referenced by snd_song_request_pop(), and snd_song_request_unpause().

au_bgm_restore_copied_player()

void au_bgm_restore_copied_player

(

AuGlobals *

globals

)

Definition at line 473 of file bgm_player.c.

                                                      {
    BGMPlayer* player;
    BGMPlayerTrack* track;
    SeqNote* note;
    u32 i;
    u32 j;
    s32 k;
 
    player = globals->resumeCopyTo;
    au_copy_words(globals->resumeCopyFrom, globals->resumeCopyTo, sizeof(*player));
    if (globals->resumeSongName == player->songName) {
        for (i = 0; i < ARRAY_COUNT(player->tracks); i++) {
            track = &player->tracks[i];
            if (track->bgmReadPos != NULL) {
                for (j = track->firstVoice; j < track->lastVoice; j++) {
                    note = &player->notes[j];
                    note->length = 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->resumeFadeTime, globals->resumeFadeStart, globals->resumeFadeEnd);
    }
    globals->resumeRequested = FALSE;
}

Referenced by au_update_clients_for_audio_frame().

au_bgm_adjust_volume()

AuResult au_bgm_adjust_volume

(

SongStartRequest *

update

)

Definition at line 505 of file bgm_player.c.

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

Referenced by snd_song_set_volume_full(), and snd_song_set_volume_quiet().

au_bgm_player_init()

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

Definition at line 523 of file bgm_player.c.

                                                                                        {
    s16 i;
 
    player->globals = globals;
    au_bgm_set_tick_resolution(player, BGM_DEFAULT_UPDATE_STEP, BGM_DEFAULT_TICKS_PER_BEAT);
    player->busVolume = AU_MAX_BUS_VOLUME;
    player->masterTempo = BGM_DEFAULT_TEMPO;
    player->masterVolume = AU_MAX_VOLUME_8 << 24;
    player->frameCounter = 0;
    player->songPlayingCounter = 0;
    player->songName = 0;
    player->pushSongName = 0;
    player->unk_58 = 0;
    player->unk_5A = 0;
    player->compReadPos = NULL;
    player->compStartPos = NULL;
    player->phraseStartPos = 0;
    player->masterTempoTicks = 0;
    player->masterTempoTarget = 0;
    player->masterTempoStep = 0;
    player->masterVolumeTicks = 0;
    player->masterVolumeTarget = 0;
    player->masterVolumeStep = 0;
    player->masterPitchShift = 0;
    player->detune = 0;
    player->paused = FALSE;
    player->trackVolsConfig = NULL;
    player->bFadeConfigSetsVolume = FALSE;
    player->masterState = BGM_PLAY_STATE_IDLE;
    player->priority = priority;
    player->busID = busID;
    *(s32*)player->compLoopCounters = 0;
    player->unused_222 = 0;
    player->conditionalLoopFlags = 0;
    player->playbackRate = 1.0f;
    player->polyphonyCounts[BGM_POLYPHONY_0] = 0;
    player->polyphonyCounts[BGM_POLYPHONY_1] = 1;
    player->polyphonyCounts[BGM_POLYPHONY_UNUSED_A] = 0;
    player->polyphonyCounts[BGM_POLYPHONY_UNUSED_B] = 0;
    player->polyphonyCounts[BGM_POLYPHONY_UNUSED_C] = 0;
    player->polyphonyCounts[BGM_POLYPHONY_2] = 2;
    player->polyphonyCounts[BGM_POLYPHONY_3] = 3;
    player->polyphonyCounts[BGM_POLYPHONY_4] = 4;
 
    for (i = 0; i < ARRAY_COUNT(player->tracks); i++) {
        BGMPlayerTrack* track = &player->tracks[i];
 
        track->insVolume = 0;
        track->delayTime = 0;
        track->insCoarseDetune = 0;
        track->insFineDetune = 0;
        track->insPan = 0;
        track->insReverb = 0;
        track->patch = 0;
        track->isDrumTrack = FALSE;
        track->volume = AU_MAX_VOLUME_8;
        track->pressOverride = 0;
 
        if (i < ARRAY_COUNT(player->cmdBufData)) {
            player->cmdBufData[i] = 0;
        }
    }
 
    for (i = 0; i < ARRAY_COUNT(player->notes); i++) {
        SeqNote* note = &player->notes[i];
 
        note->volume = 0;
        note->detune = 0;
        note->length = 0;
        note->randDetune = 0;
        note->velocity = 0;
        note->pendingTick = FALSE;
    }
 
    au_fade_set_envelope(&player->fadeInfo, AU_MAX_VOLUME_16);
    snd_bgm_clear_legacy_commands(player);
}

Referenced by au_engine_init().

au_bgm_set_effect_indices()

void au_bgm_set_effect_indices	(	BGMPlayer *	player,
		u8 *	list )

Definition at line 601 of file bgm_player.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 622 of file bgm_player.c.

                                           {
    player->fadeInfo.baseTicks--;
 
    if (player->fadeInfo.baseTicks != 0) {
        player->fadeInfo.baseVolume += player->fadeInfo.baseStep;
    } else {
        player->fadeInfo.baseVolume = player->fadeInfo.baseTarget << 16;
 
        if (player->fadeInfo.onCompleteCallback != NULL) {
            player->fadeInfo.onCompleteCallback();
        }
 
        // Was this fade tagged as a push?
        if (player->pushSongName != 0) {
            au_bgm_complete_push(player->pushSongName);
        } else if (player->fadeInfo.baseVolume == 0) {
            au_bgm_stop_player(player);
        }
    }
    au_bgm_update_bus_volumes(player);
}

Referenced by au_update_clients_for_audio_frame().

au_bgm_update_bus_volumes()

void au_bgm_update_bus_volumes

(

BGMPlayer *

arg0

)

Definition at line 644 of file bgm_player.c.

                                                  {
    u16 volume = (
            ((u32)player->fadeInfo.baseVolume >> 16) *
            ((u32)player->fadeInfo.envelopeVolume >> 16)
        ) >> 15;
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(player->effectIndices); i++) {
        s8 busID = player->effectIndices[i];
 
        if (busID < 0) {
            return;
        }
        au_fade_set_volume(busID, volume, player->busVolume);
    }
}

Referenced by au_bgm_update_fade(), and au_update_clients_for_audio_frame().

au_bgm_player_audio_frame_update()

s32 au_bgm_player_audio_frame_update

(

BGMPlayer *

player

)

Definition at line 661 of file bgm_player.c.

                                                        {
    u16 hasMore = TRUE;
    s32 retVal = FALSE;
 
    // update pseudorandom numbers with fast 'good enough' method
    player->randomValue1 = (player->randomValue1 & 0xFFFF) + (player->songPlayingCounter & 0xFFFF) + (player->frameCounter & 0xFFFF);
    player->randomValue2 = (player->randomValue2 & 0xFFFF) + ((player->songPlayingCounter << 4) & 0xFFFF) + ((player->frameCounter >> 4) & 0xFFFF);
    do {
        switch (player->masterState) {
            case BGM_PLAY_STATE_IDLE:
                hasMore = FALSE;
                break;
            case BGM_PLAY_STATE_ACTIVE:
                if (!player->paused) {
                    au_bgm_player_update_playing(player);
                    if (player->masterState == BGM_PLAY_STATE_ACTIVE) {
                        hasMore = FALSE;
                    }
                } else {
                    hasMore = FALSE;
                }
                break;
            case BGM_PLAY_STATE_FETCH:
                au_bgm_player_read_composition(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_for_audio_frame().

au_bgm_player_initialize()

void au_bgm_player_initialize

(

BGMPlayer *

player

)

Definition at line 702 of file bgm_player.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->insVolume = AU_MAX_VOLUME_16 << 16; // @bug? incorrect format for 8.24 fixed, should be (AU_MAX_VOLUME_8 << 24)
        track->insPan = 0x40;
        track->insReverb = 0;
        track->patch = 0;
        track->insCoarseDetune = 0;
        track->insFineDetune = 0;
        track->volume = AU_MAX_VOLUME_8;
        track->pressOverride = 0;
        track->proxVolume = AU_MAX_VOLUME_16 << 16;
        track->savedPos = NULL;
        track->prevReadPos = NULL;
        track->detourLength = 0;
        track->detune = 0;
        track->tremoloDepth = 0;
        track->tremoloDelay = 0;
        track->tremoloRate = 0;
        track->insVolumeStep = 0;
        track->insVolumeTarget = 0;
        track->insVolumeTicks = 0;
        track->proxVolumeStep = 0;
        track->proxVolumeTarget = 0;
        track->proxVolumeTicks = 0;
        track->proxMixSetChanged = FALSE;
        track->proxMixValChanged = FALSE;
        track->proxVol1 = 0;
        track->proxVol2 = 0;
        track->polyVoiceCount = 0;
        track->polyphonicIdx = 0;
        track->randomPanAmount = 0;
        track->isDrumTrack = FALSE;
        track->linkedTrackID = 0;
        track->muted = FALSE;
        track->busID = 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->randDetune = 0;
        note->velocity = 0;
        note->length = 0;
        note->tremoloDepth = 0;
    }
 
    au_bgm_reset_all_voices(player);
    player->playbackRate = 128.0f; // set to 1.0 later om...
    player->masterTempo = BGM_DEFAULT_TEMPO;
    player->masterTempoBPM = BGM_DEFAULT_BPM;
    player->unused_21E = 0x80;
    player->masterVolume = AU_MAX_VOLUME_8 << 24;
    player->pushSongName = 0;
    player->tickRatePtr = NULL;
    player->masterTempoTarget = 0;
    player->masterPitchShift = 0;
    player->detune = 0;
    player->masterVolumeTicks = 0;
    player->masterVolumeTarget = 0;
    player->masterVolumeStep = 0;
    player->proxMixValue = 0;
    player->proxMixID = 0;
    player->proxMixVolume = 0;
    player->compActiveLoopEndPos[3] = NULL;
    player->compActiveLoopEndPos[2] = NULL;
    player->compActiveLoopEndPos[1] = NULL;
    player->compActiveLoopEndPos[0] = NULL;
    *(s32*)player->compLoopCounters = 0;
    player->compLoopDepth = 0;
    player->unused_222 = 0;
    player->conditionalLoopFlags = 0;
    player->trackVolsConfig = NULL;
    player->bFadeConfigSetsVolume = FALSE;
    player->initLinkMute = TRUE;
    player->writingCustomEnvelope = 0;
    player->playbackRate = 1.0f;
 
    for (i = 0; i < ARRAY_COUNT(player->customEnvelopeWritePos); i++) {
        au_bgm_clear_custom_note_press(player, i);
    }
 
    for (i = 0; i < ARRAY_COUNT(player->effectValues); i++) {
        player->effectValues[i] = 0;
    }
 
    player->paused = FALSE;
    player->songPlayingCounter = 0;
    for (i = 0; i < ARRAY_COUNT(player->compLoopStartLabels); i++) {
        player->compLoopStartLabels[i] = player->compReadPos;
    }
 
    // find labels
    buf = player->compReadPos;
    keepReading = TRUE;
    while (keepReading) {
        cmd = *buf++;
        if (cmd == 0) {
            keepReading = FALSE;
        } else if ((cmd & 0xF0000000) == BGM_COMP_START_LOOP << 28) {
            player->compLoopStartLabels[cmd & 0x1F] = buf;
        }
    }
 
    player->masterState = BGM_PLAY_STATE_FETCH;
}

Referenced by au_bgm_player_audio_frame_update(), and au_bgm_process_init_song().

au_bgm_clear_custom_note_press()

void au_bgm_clear_custom_note_press	(	BGMPlayer *	player,
		s32	arg1 )

Definition at line 817 of file bgm_player.c.

                                                                  {
    s32 i;
    u16* pos = player->customPressEnvelopes[index];
    player->customEnvelopeWritePos[index] = 0;
 
    for (i = 0; i < 9; i++) {
        *pos++ = 0xFF00;
    }
}

Referenced by au_bgm_player_initialize(), and au_BGMCmd_FF_Special().

au_bgm_set_tick_resolution()

void au_bgm_set_tick_resolution	(	BGMPlayer *	player,
		s32	sampleRate,
		u32	resolution )

Definition at line 827 of file bgm_player.c.

                                                                                          {
    // compute how many audio frames before the next tick
    u32 mFramesPerTick = BGM_MFRAMES_PER_MINUTE / ticksPerBeat;
 
    // Clamp samples per tick to stay in a valid range
    if (mFramesPerTick > 500000) {
        mFramesPerTick = 500000;
    } else if (mFramesPerTick < 80000) {
        mFramesPerTick = 80000;
    }
 
    // Clamp to sample rate
    if (mFramesPerTick < mBeatsPerMinute) {
        mBeatsPerMinute = mFramesPerTick;
    }
 
    // breakdown of units:
    //
    //     tickUpdateInterval     /   nextUpdateStep   =  framesPerTick
    //
    //   1000 x frames    beat              min           frames
    //   ------------- x ------   x   ---------------  =  ------
    //       min          tick          1000 x beat        tick
 
    player->nextUpdateStep = mBeatsPerMinute;
    player->tickUpdateInterval = mFramesPerTick;
    player->nextUpdateCounter = mFramesPerTick;
 
    player->maxTempo = mFramesPerTick / BGM_UPDATE_SCALE;
}

Referenced by au_bgm_begin_video_frame(), au_bgm_player_init(), and au_bgm_process_init_song().

au_bgm_player_read_composition()

void au_bgm_player_read_composition

(

BGMPlayer *

player

)

Definition at line 859 of file bgm_player.c.

                                                       {
    u16 continueReading = TRUE;
    u32 cmd;
 
    player->masterTempoStep = 0;
    player->masterTempoTicks = 0;
 
    while (continueReading) {
        cmd = *player->compReadPos++;
        if (cmd == BGM_COMP_END) {
            player->masterState = BGM_PLAY_STATE_STOP;
            continueReading = FALSE;
        } else {
            switch (cmd >> 12) {
                case BGM_COMP_PLAY_PHRASE << 16:
                    au_bgm_load_phrase(player, cmd);
                    player->masterState = BGM_PLAY_STATE_ACTIVE;
                    continueReading = FALSE;
                    break;
                case BGM_COMP_START_LOOP << 16:
                    break;
                case BGM_COMP_WAIT << 16:
                    continueReading = FALSE;
                    break;
                case BGM_COMP_END_LOOP << 16:
                    au_bgm_end_composition_loop(player, cmd);
                    break;
                case BGM_COMP_END_COND_LOOP_FALSE << 16:
                    if (!(player->conditionalLoopFlags & 1)) {
                        au_bgm_end_composition_loop(player, cmd);
                    }
                    break;
                case BGM_COMP_END_COND_LOOP_TRUE << 16:
                    if (player->conditionalLoopFlags & 1) {
                        au_bgm_end_composition_loop(player, cmd);
                    }
                    break;
                default:
                    continueReading = FALSE;
                    break;
            }
        }
    }
}

Referenced by au_bgm_player_audio_frame_update().

au_bgm_end_composition_loop()

void au_bgm_end_composition_loop	(	BGMPlayer *	player,
		u32	cmd )

Definition at line 904 of file bgm_player.c.

                                                             {
    s32 labelIndex = cmd & 0x1F; // 01F (bits 0-4)
    s32 iterCount = (cmd >> 5) & 0x7F; // FE0 (bits 5-11)
    u32 depth;
 
    depth = player->compLoopDepth;
    if (player->compActiveLoopEndPos[depth] != NULL) {
        if (player->compActiveLoopEndPos[depth] == player->compReadPos) {
            if (player->compLoopCounters[depth] != 0) {
                player->compLoopCounters[depth]--;
                if ((player->compLoopCounters[depth]) == 0) {
                    player->compActiveLoopEndPos[depth] = NULL;
                    if (depth > 0) {
                        depth--;
                    }
                } else {
                    player->compReadPos = player->compLoopStartLabels[labelIndex];
                }
            } else {
                player->compReadPos = player->compLoopStartLabels[labelIndex];
            }
        } else if (depth < 4) {
            depth++;
            player->compActiveLoopEndPos[depth] = player->compReadPos;
            player->compLoopCounters[depth] = iterCount;
            player->compReadPos = player->compLoopStartLabels[labelIndex];
        }
    } else {
        player->compActiveLoopEndPos[depth] = player->compReadPos;
        player->compLoopCounters[depth] = iterCount;
        player->compReadPos = player->compLoopStartLabels[labelIndex];
    }
    player->compLoopDepth = depth;
}

Referenced by au_bgm_player_read_composition().

au_bgm_load_phrase()

void au_bgm_load_phrase	(	BGMPlayer *	player,
		u32	cmd )

Definition at line 939 of file bgm_player.c.

                                                    {
    BGMPlayerTrack* track;
    u32 trackInfo;
    s32* trackList;
    u32 linkedID;
    s32 count;
    s32 curVoice;
    s32 bFoundLinkedTrack;
    s32 i;
 
    curVoice = 0;
    bFoundLinkedTrack = FALSE;
    player->phraseStartPos = AU_FILE_RELATIVE(player->compStartPos, (cmd & 0xFFFF) << 2);
    trackList = player->phraseStartPos;
    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;
                linkedID = (trackInfo & (0xF << 9)) >> 9;
                track->linkedTrackID = 0;
                if (linkedID != 0) {
                    BGMPlayerTrack* linkedTrack = &player->tracks[linkedID - 1];
                    if ((linkedID - 1) < i) {
                        track->polyVoiceCount = linkedTrack->polyVoiceCount;
                        track->firstVoice = linkedTrack->firstVoice;
                        track->lastVoice = linkedTrack->lastVoice;
 
                        track->bgmReadPos = (track->bgmReadPos + (s32)player->phraseStartPos);
                        track->delayTime = 1;
 
                        track->linkedTrackID = linkedID;
                        if (player->initLinkMute) {
                            track->muted = TRUE;
                        }
                        bFoundLinkedTrack = TRUE;
                    } else {
                        track->bgmReadPos = NULL;
                    }
                } else {
                    count = player->polyphonyCounts[track->polyphonicIdx];
                    track->polyVoiceCount = count;
                    track->firstVoice = curVoice;
                    curVoice += count;
                    track->lastVoice = curVoice;
 
                    track->bgmReadPos = (track->bgmReadPos + (s32)player->phraseStartPos);
                    track->delayTime = 1;
                }
            } else {
                track->bgmReadPos = NULL;
            }
        }
    }
    player->totalVoices = curVoice;
    if (bFoundLinkedTrack) {
        player->initLinkMute = FALSE;
    }
}

Referenced by au_bgm_player_read_composition().

au_bgm_player_update_stop()

void au_bgm_player_update_stop

(

BGMPlayer *

player

)

Definition at line 1002 of file bgm_player.c.

                                                  {
    s32 i;
 
    player->paused = FALSE;
    player->songName = 0;
    player->pushSongName = 0;
    player->unk_58 = 0;
    player->unk_5A = 0;
    for (i = 0; i < ARRAY_COUNT(player->tracks); i++) {
        player->tracks[i].bgmReadPos = NULL;
    }
    au_bgm_reset_all_voices(player);
    player->masterState = BGM_PLAY_STATE_IDLE;
    player->nextUpdateStep = BGM_DEFAULT_UPDATE_STEP;
}

Referenced by au_bgm_player_audio_frame_update().

au_bgm_player_update_playing()

void au_bgm_player_update_playing

(

BGMPlayer *

player

)

play next tick

Definition at line 1027 of file bgm_player.c.

                                                     {
    s32 bVolumeFading;
    u8 sp1F;
    s16 notePitch;
    u8 bFinished;
 
    AuVoice* voice;
    BGMDrumInfo* drumInfo;
    BGMPlayerTrack* track;
    SeqNote* note;
    s32 var_a0;
    s32 temp;
    s32 tremoloDetune;
    s32 bAcquiredVoiceIdx;
    u8 opcode;
    u8 noteVelocity;
    s32 noteLength;
    u32 i;
    u8 voiceIdx;
    s32 temp2;
    bVolumeFading = FALSE;
    bFinished = FALSE;
 
    if (player->masterTempoTicks != 0) {
        player->masterTempoTicks--;
        if (player->masterTempoTicks == 0) {
            player->masterTempo = player->masterTempoTarget;
            player->masterTempoTarget = 0;
            player->masterTempoStep = 0;
        } else {
            player->masterTempo += player->masterTempoStep;
        }
        player->nextUpdateStep = BGM_TEMPO_TO_UPDATE_UNITS(player->masterTempo);
    }
    if (player->masterVolumeTicks != 0) {
        player->masterVolumeTicks--;
        if (player->masterVolumeTicks == 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_InstrumentVolumeLerp(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_InstrumentVolumeLerp(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 = TRUE;
            } else {
                track->changed.volume = FALSE;
            }
            if (track->insVolumeTicks != 0) {
                track->insVolumeTicks--;
                if (track->insVolumeTicks == 0) {
                    track->insVolume = track->insVolumeTarget;
                } else {
                    track->insVolume += track->insVolumeStep;
                }
                track->changed.volume = TRUE;
            }
            if (track->proxVolumeTicks != 0) {
                track->proxVolumeTicks--;
                if (track->proxVolumeTicks == 0) {
                    track->proxVolume = track->proxVolumeTarget << 16;
                } else {
                    track->proxVolume += track->proxVolumeStep;
                }
                track->changed.volume = TRUE;
            }
            track->delayTime--;
            if (track->delayTime <= 0) {
                sp1F = track->firstVoice;
                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->muted) {
                                // find first free voice
                                for (voiceIdx = sp1F; voiceIdx < track->lastVoice; voiceIdx++) {
                                    voice = &player->globals->voices[voiceIdx];
                                    sp1F++;
                                    if (voice->priority == AU_PRIORITY_FREE) {
                                        bAcquiredVoiceIdx = TRUE;
                                        break;
                                    }
                                }
 
                                if (!bAcquiredVoiceIdx) {
                                    if (track->polyphonicIdx >= BGM_POLYPHONY_2) {
                                        // try stealing a voice with lower priority
                                        for (voiceIdx = track->firstVoice; voiceIdx < track->lastVoice; 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->firstVoice; voiceIdx < track->lastVoice; voiceIdx++) {
                                                voice = &player->globals->voices[voiceIdx];
                                                if (voice->priority == player->priority) {
                                                    note = &player->notes[voiceIdx];
                                                    if (note->length == 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->firstVoice; voice_it < track->lastVoice; voice_it++) {
                                                curVoice = &player->globals->voices[voice_it];
                                                if (curVoice->priority == player->priority) {
                                                    curNote = &player->notes[voice_it];
                                                    if (!curNote->pendingTick && curNote->length < shortestLength) {
                                                        shortestLength = curNote->length;
                                                        voice = curVoice;
                                                        note = curNote;
                                                        voiceIdx = voice_it;
                                                        bAcquiredVoiceIdx = TRUE;
                                                    }
                                                }
                                            }
                                            if (bAcquiredVoiceIdx) {
                                                note->length = 0;
                                                au_reset_voice(voice, voiceIdx);
                                            }
                                        }
 
                                    } else {
                                        voiceIdx = track->firstVoice;
                                        voice = &player->globals->voices[voiceIdx];
                                        note = &player->notes[voiceIdx];
                                        note->length = 0;
                                        if (voice->priority <= player->priority) {
                                            au_reset_voice(voice, voiceIdx);
                                            bAcquiredVoiceIdx = TRUE;
                                        }
                                    }
                                }
                            }
                            if (bAcquiredVoiceIdx) {
                                note = &player->notes[voiceIdx];
                                note->tremoloDepth = 0;
                                if (noteVelocity > 0) {
                                    note->velocity = noteVelocity + 1;
                                } else {
                                    note->velocity = 0;
                                }
                                note->length = 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, drumInfo->bankPatch >> 8, drumInfo->bankPatch & 0xFF, &voice->envelope);
                                    if (drumInfo->randVolume != 0) {
                                        note->volume = note->velocity * au_bgm_get_random_vol(player->randomValue1, drumInfo->volume, drumInfo->randVolume);
                                    } else {
                                        note->volume = note->velocity * drumInfo->volume;
                                    }
                                    // combining formats: 7.24 * 7.24 * 15.16 * 7.0 * 15.0 --> 16.16
                                    // first step, shifting fractional factors by 21:
                                    // 7.24 * 7.24 * 15.16 --> 7.3 * 7.3 * 10.0 --> 24.6
                                    // shifting this down by 20 transforms 24.6 --> 10.0
                                    // now for the second step with whole:
                                    //  10.0 * 7.0 * 15.0 --> 32.0
                                    // and a final shift by 16 transforms 32.0 --> 16.16
                                    voice->clientVolume = ((
                                        ((player->masterVolume >> 21)       // 7.24 --> 7.3
                                        * (track->insVolume >> 21)     // 7.24 --> 7.3
                                        * (track->proxVolume >> 21)) >> 20) // 15.16 --> 10.0 (fractional part truncated?)
                                        * (track->volume * note->volume)) >> 16;
                                    note->detune =
                                        drumInfo->keyBase
                                        + track->insCoarseDetune
                                        + track->insFineDetune
                                        - note->ins->keyBase;
                                    temp = (note->detune + track->detune) + player->detune;
                                    if (drumInfo->randTune != 0) {
                                        note->randDetune = au_bgm_get_random_pitch(player->randomValue1, temp, drumInfo->randTune);
                                        temp = note->randDetune;
                                    }
                                    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 {
                                    // combining formats: 7.24 * 7.24 * 15.16 * 7.0 * 15.0 --> 16.16
                                    // first step, shifting fractional factors by 21:
                                    // 7.24 * 7.24 * 15.16 --> 7.3 * 7.3 * 10.0 --> 24.6
                                    // shifting this down by 20 transforms 24.6 --> 10.0
                                    // now for the second step with whole:
                                    //  10.0 * 7.0 * 7.0 --> 24.0
                                    // and a final shift by 9 transforms 24.0 --> 15.16
                                    voice->clientVolume = note->volume = ((
                                        ((player->masterVolume >> 21)       // 7.24 --> 7.3
                                        * (track->insVolume >> 21)     // 7.24 --> 7.3
                                        * (track->proxVolume >> 21)) >> 20) // 15.16 --> 10.0 (fractional part truncated?)
                                        * (track->volume * note->velocity)) >> 9;
                                    note->ins = track->instrument;
                                    note->detune =
                                        (notePitch * 100)
                                        + track->insCoarseDetune
                                        + player->masterPitchShift
                                        + track->insFineDetune
                                        - note->ins->keyBase;
                                    note->pitchRatio = au_compute_pitch_ratio(
                                        note->detune
                                        + track->detune
                                        + player->detune)
                                        * track->instrument->pitchRatio;
 
                                    if (track->randomPanAmount != 0) {
                                        voice->pan = au_bgm_get_random_pan(player, track->insPan, track->randomPanAmount);
                                    } else {
                                        voice->pan = track->insPan;
                                    }
                                    voice->reverb = track->insReverb;
 
                                    if (track->pressOverride != 0) {
                                        voice->envelope.cmdListPress = (u8*) player->customPressEnvelopes[track->pressOverride - 1];
                                    } else {
                                        voice->envelope.cmdListPress = track->envelope.cmdListPress;
                                    }
                                    voice->envelope.cmdListRelease = track->envelope.cmdListRelease;
                                }
                                voice->instrument = note->ins;
                                voice->pitchRatio = note->pitchRatio;
                                voice->busID = track->busID;
                                if (note->length > 1) {
                                    note->pendingTick = TRUE;
                                    note->tremoloDepth = track->tremoloDepth;
                                    note->tremoloPhase = 0;
                                    note->tremoloDelay = track->tremoloDelay;
                                    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->firstVoice; voiceIdx < track->lastVoice; voiceIdx++) {
                if (!track->muted) {
                    voice = &player->globals->voices[voiceIdx];
                    if (voice->priority == player->priority) {
                        note = &player->notes[voiceIdx];
                        if (!note->pendingTick) {
                            if (note->length > 0) {
                                note->length--;
                                if (note->length == 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->detune + note->randDetune) + track->detune) + 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) {
                                    // combining formats: 7.24 * 7.24 * 15.16 * 7.0 * 15.0 --> 16.16
                                    // first step, shifting fractional factors by 21:
                                    // 7.24 * 7.24 * 15.16 --> 7.3 * 7.3 * 10.0 --> 24.6
                                    // shifting this down by 20 transforms 24.6 --> 10.0
                                    // now for the second step with whole:
                                    //  10.0 * 7.0 * 15.0 --> 32.0
                                    // and a final shift by 16 transforms 32.0 --> 16.16
                                    voice->clientVolume = (
                                        ((((player->masterVolume >> 21)     // 7.24 --> 7.3
                                        * (track->insVolume >> 21))    // 7.24 --> 7.3
                                        * (track->proxVolume >> 21)) >> 20) // 15.16 --> 10.0 (fractional part truncated?)
                                        * (track->volume * note->volume)) >> 16;
                                    voice->envelopeFlags |= AU_VOICE_ENV_FLAG_VOL_CHANGED;
                                }
                            } else {
                                // Modulate pitch using a triange wave for tremolo effect
                                if (note->tremoloDepth != 0) {
                                    if (note->tremoloDelay != 0) {
                                        note->tremoloDelay--;
                                    } else {
                                        u8 quadrant;
                                        note->tremoloPhase += track->tremoloRate;
                                        opcode = (note->tremoloPhase << 2) + 3; // +3 just to fill lower 2 bits
 
                                        // Determine what part of the triangle wave we are in (using top 2 bits of u8)
                                        quadrant = note->tremoloPhase >> 6;
 
                                        // Invert the triangle for quadrants 1 and 3 (ugly code required to match)
                                        /* visualized: //// --> /\/\ */
                                        if ((quadrant == 1) || (quadrant == 3)) {
                                            u8 temp2 = ~opcode;
                                            tremoloDetune = temp2 + 1;
                                        } else {
                                            tremoloDetune = opcode;
                                        }
 
                                        // Scale by depth
                                        tremoloDetune = (tremoloDetune * track->tremoloDepth) >> 8;
 
                                        // Invert sign for the second half of triangle wave
                                        if ((quadrant == 2) || (quadrant == 3)) {
                                            tremoloDetune = -tremoloDetune;
                                        }
 
                                        // Apply pitch detune from tremolo
                                        note->pitchRatio = au_compute_pitch_ratio(tremoloDetune + ((note->detune + track->detune) + 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->detune + track->detune) + 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) {
                                    // combining formats: 7.24 * 7.24 * 15.16 * 7.0 * 15.0 --> 16.16
                                    // first step, shifting fractional factors by 21:
                                    // 7.24 * 7.24 * 15.16 --> 7.3 * 7.3 * 10.0 --> 24.6
                                    // shifting this down by 20 transforms 24.6 --> 10.0
                                    // now for the second step with whole:
                                    //  10.0 * 7.0 * 7.0 --> 24.0
                                    // and a final shift by 9 transforms 24.0 --> 15.16
                                    note->volume = ((
                                        (player->masterVolume >> 21)            // 7.24 --> 7.3
                                        * (track->insVolume >> 21)         // 7.24 --> 7.3
                                        * (track->proxVolume >> 21)) >> 20)
                                        * (track->volume * note->velocity) >> 9;
                                    voice->clientVolume = note->volume;
                                    voice->envelopeFlags |= AU_VOICE_ENV_FLAG_VOL_CHANGED;
                                    voice->pan = track->insPan;
                                    voice->reverb = track->insReverb;
                                } else if (track->changed.pan || track->changed.reverb) {
                                    voice->pan = track->insPan;
                                    voice->reverb = track->insReverb;
                                    voice->syncFlags |= AU_VOICE_SYNC_FLAG_PAN_FXMIX;
                                }
                            }
                        }
                        note->pendingTick = FALSE;
                    }
                }
            }
        }
    }
 
    if (bFinished) {
        player->masterState = BGM_PLAY_STATE_FETCH;
    }
}

Referenced by au_bgm_player_audio_frame_update().

au_BGMCmd_E0_MasterTempo()

void au_BGMCmd_E0_MasterTempo	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1508 of file bgm_player.c.

                                                                        {
    u32 bpm = player->seqCmdArgs.MasterTempo.value;
    s32 tempo;
 
    player->masterTempoBPM = bpm;
    tempo = au_bgm_bpm_to_tempo(player, bpm);
    player->masterTempo = tempo;
    player->nextUpdateStep = BGM_TEMPO_TO_UPDATE_UNITS(tempo);
    player->masterTempoTicks = 0;
    player->masterTempoTarget = 0;
    player->masterTempoStep = 0;
}

au_BGMCmd_E1_MasterVolume()

void au_BGMCmd_E1_MasterVolume	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1536 of file bgm_player.c.

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

au_BGMCmd_E2_MasterDetune()

void au_BGMCmd_E2_MasterDetune	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1551 of file bgm_player.c.

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

au_BGMCmd_E3()

void au_BGMCmd_E3	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1555 of file bgm_player.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 1560 of file bgm_player.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 au_bgm_restore_copied_player().

au_BGMCmd_E4_MasterTempoFade()

void au_BGMCmd_E4_MasterTempoFade	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1573 of file bgm_player.c.

                                                                            {
    s32 time = player->seqCmdArgs.MasterTempoFade.time;
    s32 tempo = au_bgm_bpm_to_tempo(player, player->seqCmdArgs.MasterTempoFade.value);
 
    if (time <= 0) {
        time = 1;
    }
 
    player->masterTempoTicks = 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 1586 of file bgm_player.c.

                                                                             {
    s32 time = player->seqCmdArgs.MasterVolumeFade.time;
    s8_24 volume = player->seqCmdArgs.MasterVolumeFade.value & 0x7F;
 
    if (volume != 0) {
        volume = volume << 24;
    }
 
    if (time <= 0) {
        time = 1;
    }
 
    player->masterVolumeTicks = 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 1603 of file bgm_player.c.

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

au_BGMCmd_E9_InstrumentVolume()

void au_BGMCmd_E9_InstrumentVolume	(	BGMPlayer *	arg0,
		BGMPlayerTrack *	track )

Definition at line 1608 of file bgm_player.c.

                                                                           {
    s8_24 volume = arg0->seqCmdArgs.InstrumentVolume.value & 0x7F;
 
    if (volume != 0) {
        volume = volume << 24;
    }
 
    track->insVolume = volume;
    track->changed.volume = TRUE;
}

Referenced by au_bgm_set_linked_tracks().

au_BGMCmd_F6_InstrumentVolumeLerp()

void au_BGMCmd_F6_InstrumentVolumeLerp	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1619 of file bgm_player.c.

                                                                                 {
    s32 time = player->seqCmdArgs.TrackVolumeFade.time;
    s8_24 volume = player->seqCmdArgs.TrackVolumeFade.value & 0x7F;
 
    if (volume != 0) {
        volume = volume << 24;
    }
 
    if (volume != track->insVolume) {
        if (time <= 0) {
            time = 1;
        }
 
        track->insVolumeTicks = time;
        track->insVolumeTarget = volume;
        track->insVolumeStep = (volume - track->insVolume) / time;
    }
}

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

au_BGMCmd_EA_InstrumentPan()

void au_BGMCmd_EA_InstrumentPan	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1638 of file bgm_player.c.

                                                                          {
    track->insPan = player->seqCmdArgs.InstrumentPan.value & 0x7F;
    track->randomPanAmount = 0;
    track->changed.pan = TRUE;
}

au_BGMCmd_EB_InstrumentReverb()

void au_BGMCmd_EB_InstrumentReverb	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1644 of file bgm_player.c.

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

au_BGMCmd_EC_TrackVolume()

void au_BGMCmd_EC_TrackVolume	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1649 of file bgm_player.c.

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

au_BGMCmd_ED_InstrumentCoarseTune()

void au_BGMCmd_ED_InstrumentCoarseTune	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1654 of file bgm_player.c.

                                                                                 {
    track->insCoarseDetune = player->seqCmdArgs.InstrumentCoarseTune.semitone * AU_SEMITONE_CENTS;
}

au_BGMCmd_EE_InstrumentFineTune()

void au_BGMCmd_EE_InstrumentFineTune	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1658 of file bgm_player.c.

                                                                               {
    track->insFineDetune = player->seqCmdArgs.InstrumentFineTune.cent;
}

au_BGMCmd_EC_TrackDetune()

void au_BGMCmd_EC_TrackDetune	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1662 of file bgm_player.c.

                                                                        {
    track->detune = player->seqCmdArgs.TrackDetune.cents;
    track->changed.tune = TRUE;
}

au_BGMCmd_F0_TrackTremolo()

void au_BGMCmd_F0_TrackTremolo	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1667 of file bgm_player.c.

                                                                         {
    track->tremoloDelay = player->seqCmdArgs.TrackTremolo.delay;
    track->tremoloRate = player->seqCmdArgs.TrackTremolo.speed;
    track->tremoloDepth = player->seqCmdArgs.TrackTremolo.depth;
}

au_BGMCmd_F1_TrackTremoloRate()

void au_BGMCmd_F1_TrackTremoloRate	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1673 of file bgm_player.c.

                                                                             {
    track->tremoloRate = player->seqCmdArgs.TrackTremoloRate.value;
}

au_BGMCmd_F2_TrackTremoloDepth()

void au_BGMCmd_F2_TrackTremoloDepth	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1677 of file bgm_player.c.

                                                                              {
    track->tremoloDepth = player->seqCmdArgs.TrackTremoloDepth.value;
}

au_BGMCmd_F3_TrackTremoloStop()

void au_BGMCmd_F3_TrackTremoloStop	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1681 of file bgm_player.c.

                                                                             {
    track->tremoloDepth = 0;
}

au_BGMCmd_F4_SubTrackRandomPan()

void au_BGMCmd_F4_SubTrackRandomPan	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1685 of file bgm_player.c.

                                                                              {
    track->insPan = player->seqCmdArgs.RandomPan.pan0 & 0x7F;
    track->randomPanAmount = player->seqCmdArgs.RandomPan.pan1 & 0x7F;
}

au_BGMCmd_F5_UseInstrument()

void au_BGMCmd_F5_UseInstrument	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1690 of file bgm_player.c.

                                                                          {
    BGMInstrumentInfo* instrument;
    s32 volume;
    u32 insIndex;
    u32 patch;
    u32 bank;
 
    insIndex = player->seqCmdArgs.UseInstrument.index;
    if (insIndex < BGM_MAX_INSTRUMNETS) {
        if (insIndex < player->bgmInstrumentCount) {
            instrument = &player->instrumentsInfo[insIndex];
        } else {
            instrument = &player->globals->defaultPRGEntry;
        }
    } else {
        insIndex -= BGM_MAX_INSTRUMNETS;
        if (insIndex < PRG_MAX_COUNT) {
            instrument = &player->globals->dataPRG[insIndex];
        } 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 <<= 24;
    }
    track->insVolume = volume;
    track->insPan = instrument->pan & 0x7F;
    track->insReverb = instrument->reverb & 0x7F;
    track->insCoarseDetune = instrument->coarseTune * AU_SEMITONE_CENTS;
    track->insFineDetune = instrument->fineTune;
    track->changed.all |= 0x10101; // volume, pan, and reverb
}

au_BGMCmd_F7_ReverbType()

void au_BGMCmd_F7_ReverbType	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1728 of file bgm_player.c.

                                                                       {
    u8 index = player->seqCmdArgs.ReverbType.index;
    s8 busID = player->effectIndices[index];
 
    if ((index < ARRAY_COUNT(player->effectIndices)) && (busID >= 0)) {
        track->busID = busID;
    } else {
        track->busID = player->busID;
    }
}

au_BGMCmd_FD_EventTrigger()

void au_BGMCmd_FD_EventTrigger	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1739 of file bgm_player.c.

                                                                         {
    snd_song_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 1744 of file bgm_player.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_Branch()

void au_BGMCmd_FC_Branch	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1753 of file bgm_player.c.

                                                                   {
    AuFilePos args;
    u32 i;
 
    // get jump table
    args = AU_FILE_RELATIVE(player->bgmFile, player->seqCmdArgs.Branch.offset);
    if (player->proxMixID < player->seqCmdArgs.Branch.tableCount) {
        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->proxMixSetChanged) {
        track->proxMixSetChanged = FALSE;
        track->proxVolume = 0;
        for (i = track->firstVoice; i < track->lastVoice; i++) {
            AuVoice* voice = &player->globals->voices[i];
            if ((voice->priority == player->priority) && (voice->cmdPtr != NULL)) {
                au_reset_voice(voice, i);
            }
        }
    }
    if (track->proxMixValChanged) {
        track->proxMixValChanged = FALSE;
        au_bgm_set_prox_mix_fade(player, track, player->proxMixVolume, 144);
    }
    // reset an odd subset of parameters
    track->insCoarseDetune = 0;
    track->insFineDetune = 0;
    track->pressOverride = 0;
    track->detune = 0;
    track->tremoloDepth = 0;
    track->insVolumeTicks = 0;
    track->randomPanAmount = 0;
    track->busID = player->busID;
}

au_BGMCmd_FF_Special()

void au_BGMCmd_FF_Special	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1792 of file bgm_player.c.

                                                                    {
    u32 writePos;
    u8 delaySide;
    u8 delayTime;
    u32 i;
 
    u32 type = player->seqCmdArgs.Special.type;
    u32 arg1 = player->seqCmdArgs.Special.arg1;
    u32 arg2 = player->seqCmdArgs.Special.arg2;
 
    switch (type) {
        case BGM_SPECIAL_SET_STEREO_DELAY:
            if ((arg1 < ARRAY_COUNT(player->effectIndices)) && ((s8)player->effectIndices[arg1] >= 0)) {
                player->globals->channelDelayBusID = player->effectIndices[arg1];
                if (arg2 != 0) {
                    delayTime = arg2 & 0xF;
                    delaySide = ((arg2 >> 4) & 1) + 1;
                    if ((player->globals->channelDelayTime != delayTime) || (player->globals->channelDelaySide != delaySide)) {
                        player->globals->channelDelayTime = delayTime;
                        player->globals->channelDelaySide = delaySide;
                        player->globals->channelDelayPending = TRUE;
                    }
                } else {
                    if (player->globals->channelDelaySide != AU_DELAY_CHANNEL_NONE) {
                        player->globals->channelDelaySide = AU_DELAY_CHANNEL_NONE;
                        player->globals->channelDelayPending = TRUE;
                    }
                }
            }
            break;
        case BGM_SPECIAL_SEEK_CUSTOM_ENV:
            if (arg1 - 1 < ARRAY_COUNT(player->customPressEnvelopes)) {
                player->writingCustomEnvelope = arg1;
                au_bgm_clear_custom_note_press(player, arg1 - 1);
            } else {
                player->writingCustomEnvelope = 0;
            }
            break;
        case BGM_SPECIAL_WRITE_CUSTOM_ENV:
            i = player->writingCustomEnvelope;
            if (i - 1 < ARRAY_COUNT(player->customPressEnvelopes)) {
                i--; // convert ID --> array index, needed to match
                writePos = player->customEnvelopeWritePos[i];
                if (writePos < ARRAY_COUNT(player->customPressEnvelopes[i]) - 1) {
                    if (arg1 >= ARRAY_COUNT(BgmCustomEnvLookup)) {
                        player->customPressEnvelopes[i][writePos] = (arg1 << 8) + arg2;
                    } else {
                        player->customPressEnvelopes[i][writePos] = (BgmCustomEnvLookup[arg1] << 8) + arg2;
                    }
                    player->customEnvelopeWritePos[i] = writePos + 1;
                }
            }
            break;
        case BGM_SPECIAL_USE_CUSTOM_ENV:
            if (arg1 <= ARRAY_COUNT(player->customPressEnvelopes)) {
                track->pressOverride = arg1;
            } else {
                track->pressOverride = 0;
            }
            break;
        case BGM_SPECIAL_TRIGGER_SOUND:
            if (player->soundManager != NULL) {
                for (i = 0; i < ARRAY_COUNT(player->soundManager->bgmSounds); i++) {
                    if ((player->soundManager->bgmSounds[i].index) == 0) {
                        player->soundManager->bgmSounds[i].index = arg1;
                        player->soundManager->bgmSounds[i].volume =
                            ((s32)(
                                ((u32)player->fadeInfo.baseVolume >> 16) *
                                ((u32)player->fadeInfo.envelopeVolume >> 16)
                            ) + AU_MAX_VOLUME_16) >> 0x17;
                        break;
                    }
                }
            }
            break;
        case BGM_SPECIAL_PROX_MIX_OVERRIDE:
            if (arg1 == 0) {
                if (track->proxMixValChanged) {
                    track->proxMixValChanged = FALSE;
                    for (i = 0; i < ARRAY_COUNT(player->tracks); i++) {
                        BGMPlayerTrack* otherTrack = &player->tracks[i];
                        if (player->proxMixVolume == AU_MAX_VOLUME_8) {
                            if (otherTrack->proxVol1 != 0) {
                                otherTrack->proxMixValChanged = FALSE;
                                au_bgm_set_prox_mix_fade(player, otherTrack, otherTrack->proxVol1, 72);
                            }
                        } else {
                            if (otherTrack->proxVol2 != 0) {
                                otherTrack->proxMixValChanged = FALSE;
                                au_bgm_set_prox_mix_fade(player, otherTrack, otherTrack->proxVol2, 72);
                            }
                        }
                    }
                }
            } else {
                track->proxVol1 = arg1;
                track->proxVol2 = arg2;
            }
            break;
    }
}

au_BGMCmd_NOP()

void au_BGMCmd_NOP	(	BGMPlayer *	player,
		BGMPlayerTrack *	track )

Definition at line 1894 of file bgm_player.c.

                                                             {
}

au_bgm_set_proximity_mix()

void au_bgm_set_proximity_mix	(	s32	songName,
		u32	mix )

Definition at line 1974 of file bgm_player.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->proxMixSetChanged = TRUE;
                }
                track->proxMixValChanged = TRUE;
            }
        }
    }
}

Referenced by snd_song_set_proximity_mix_far(), snd_song_set_proximity_mix_full(), and snd_song_set_proximity_mix_near().

au_bgm_set_playback_rate()

void au_bgm_set_playback_rate	(	BGMPlayer *	player,
		f32	arg1 )

Definition at line 2001 of file bgm_player.c.

                                                           {
    if (rate > 2.0) {
        rate = 2.0f;
    } else if (rate < 0.25) {
        rate = 0.25f;
    }
 
    player->playbackRate = rate;
    player->masterTempo = au_bgm_bpm_to_tempo(player, player->masterTempoBPM);
    player->nextUpdateStep = BGM_TEMPO_TO_UPDATE_UNITS(player->masterTempo);
    player->masterTempoTicks = 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 2016 of file bgm_player.c.

                                                             {
    if (detune > AU_OCTAVE_CENTS) {
        detune = AU_OCTAVE_CENTS;
    } else if (detune < -2 * AU_OCTAVE_CENTS) {
        detune = -2 * AU_OCTAVE_CENTS;
    }
 
    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 2026 of file bgm_player.c.

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

au_bgm_set_track_volumes()

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

Definition at line 2036 of file bgm_player.c.

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

Referenced by snd_song_clear_track_volumes(), and snd_song_set_track_volumes().

au_bgm_set_prox_mix_fade()

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

Definition at line 2041 of file bgm_player.c.

                                                                                                  {
    if (target != 0) {
        target = AU_VOL_8_TO_16(target);
    }
    if (duration <= 0) {
        duration = 1;
    } else if (duration > 1000) {
        duration = 1000;
    }
    if (target == track->proxVolume) {
        track->proxVolumeTicks = 0;
        return;
    }
    track->proxVolumeTicks = duration;
    track->proxVolumeTarget = target;
    track->proxVolumeStep = ((target << 0x10) - track->proxVolume) / duration;
}

Referenced by au_BGMCmd_FC_Branch(), and au_BGMCmd_FF_Special().

au_bgm_reset_all_voices()

void au_bgm_reset_all_voices

(

BGMPlayer *

player

)

Definition at line 2059 of file bgm_player.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 au_bgm_process_suspend().

au_bgm_set_linked_tracks()

AuResult au_bgm_set_linked_tracks

(

SongSwapLinkedRequest *

arg0

)

Definition at line 2070 of file bgm_player.c.

                                                                  {
    BGMPlayer* player;
    BGMPlayerTrack* track;
    BGMPlayerTrack* linkTrack;
    AuVoice* voice;
    s32 trackIdx;
    s32 voiceIdx;
    s8 oldVolume;
 
    s32 songName = request->songName;
    b32 enabled = request->enabled;
    AuResult status = AU_RESULT_OK;
 
    if (songName != 0) {
        player = au_bgm_get_player_with_song_name(songName);
        if (player != NULL) {
            for (trackIdx = 0; trackIdx < ARRAY_COUNT(player->tracks); trackIdx++) {
                track = &player->tracks[trackIdx];
                if (track->bgmReadPos != NULL) {
                    if (track->linkedTrackID != 0) {
                        linkTrack = &player->tracks[track->linkedTrackID - 1];
                        if (enabled) {
                            if (track->muted) {
                                track->muted = FALSE;
                                linkTrack->muted = TRUE;
                                // release all voices for linked track
                                for (voiceIdx = linkTrack->firstVoice; voiceIdx < linkTrack->lastVoice; voiceIdx++) {
                                    voice = &player->globals->voices[voiceIdx];
                                    if (voice->priority == player->priority) {
                                        voice->envelope.cmdListRelease = EnvelopeReleaseDefaultFast;
                                        voice->envelopeFlags |= AU_VOICE_ENV_FLAG_KEY_RELEASED;
                                    }
                                }
                                // fade in main track
                                oldVolume = track->insVolume >> 24;
                                au_BGMCmd_E9_InstrumentVolume(player, track);
                                player->seqCmdArgs.raw[0] = 0;
                                player->seqCmdArgs.TrackVolumeFade.time = 96;
                                player->seqCmdArgs.TrackVolumeFade.value = oldVolume;
                                au_BGMCmd_F6_InstrumentVolumeLerp(player, track);
                            }
                        } else {
                            if (!track->muted) {
                                track->muted = TRUE;
                                linkTrack->muted = FALSE;
                                // release all voices for main track
                                for (voiceIdx = track->firstVoice; voiceIdx < track->lastVoice; voiceIdx++) {
                                    voice = &player->globals->voices[voiceIdx];
                                    if (voice->priority == player->priority) {
                                        voice->envelope.cmdListRelease = EnvelopeReleaseDefaultFast;
                                        voice->envelopeFlags |= AU_VOICE_ENV_FLAG_KEY_RELEASED;
                                    }
                                }
                                // fade in linked track
                                oldVolume = linkTrack->insVolume >> 24;
                                au_BGMCmd_E9_InstrumentVolume(player, linkTrack);
                                player->seqCmdArgs.raw[0] = 0;
                                player->seqCmdArgs.TrackVolumeFade.time = 96;
                                player->seqCmdArgs.TrackVolumeFade.value = oldVolume;
                                au_BGMCmd_F6_InstrumentVolumeLerp(player, linkTrack);
                            }
                        }
                    }
                }
            }
        } else {
            status = AU_ERROR_SONG_NOT_PLAYING;
        }
    } else {
        status = AU_ERROR_NULL_SONG_NAME;
    }
 
    return status;
}

Referenced by snd_song_set_linked_mode().

snd_bgm_clear_legacy_commands()

void snd_bgm_clear_legacy_commands

(

BGMPlayer *

player

)

Part of an unused system for inter-thread communication with a BGM player using commands.

Use functions in bgm_control to manipualte gMusicControlData instead.

Definition at line 143 of file snd_interface.c.

                                                      {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(player->cmdBufData); i++) {
        player->cmdBufData[i] = 0;
    }
 
    player->cmdBufOverflows = 0;
    player->cmdBufWritePos = 0;
    player->cmdBufReadPos = 0;
    player->cmdBufPending = 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 669 of file snd_interface.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().

snd_song_set_detune()

AuResult snd_song_set_detune	(	s32	songName,
		s32	arg1 )

Definition at line 703 of file snd_interface.c.

                                                       {
    BGMPlayer* bgmPlayer;
    BGMHeader* bgmFile;
    AuResult status;
 
    status = snd_song_get_playing_info(songName, &bgmFile, &bgmPlayer);
 
    if (status == AU_RESULT_OK) {
        au_bgm_player_set_detune(bgmPlayer, detune);
    }
 
    return status;
}

snd_song_set_track_volumes()

AuResult snd_song_set_track_volumes	(	s32	songName,
		MusicTrackVols	arg1 )

Definition at line 717 of file snd_interface.c.

                                                                              {
    BGMPlayer* bgmPlayer;
    BGMHeader* bgmFile;
    AuResult status;
 
    status = snd_song_get_playing_info(songName, &bgmFile, &bgmPlayer);
 
    if (status == AU_RESULT_OK) {
        u8* trackVols = snd_song_get_track_volumes_set(trackVolSet);
 
        if (trackVols != NULL) {
            au_bgm_set_track_volumes(bgmPlayer, trackVols, TRUE);
        } else {
            status = AU_ERROR_11;
        }
    }
 
    return status;
}

Referenced by bgm_set_track_volumes().

snd_song_clear_track_volumes()

AuResult snd_song_clear_track_volumes	(	s32	songName,
		MusicTrackVols	arg1 )

Definition at line 737 of file snd_interface.c.

                                                                                {
    BGMPlayer* bgmPlayer;
    BGMHeader* bgmFile;
    AuResult status;
 
    status = snd_song_get_playing_info(songName, &bgmFile, &bgmPlayer);
 
    if (status == AU_RESULT_OK) {
        u8* trackVols = snd_song_get_track_volumes_set(trackVolSet);
 
        if (trackVols != NULL) {
            au_bgm_set_track_volumes(bgmPlayer, trackVols, FALSE);
        } else {
            status = AU_ERROR_11;
        }
    }
 
    return status;
}

Referenced by bgm_clear_track_volumes().

snd_song_set_track_vol_mute()

AuResult snd_song_set_track_vol_mute	(	s32	arg0,
		s32	arg1 )

Definition at line 808 of file snd_interface.c.

                                                                 {
    return snd_song_change_track_volume(songName, trackIdx, 0);
}

snd_song_set_track_vol_quiet()

AuResult snd_song_set_track_vol_quiet	(	s32	arg0,
		s32	arg1 )

Definition at line 812 of file snd_interface.c.

                                                                  {
    return snd_song_change_track_volume(songName, trackIdx, AU_MAX_VOLUME_8 / 2);
}

snd_song_set_track_vol_full()

AuResult snd_song_set_track_vol_full	(	s32	arg0,
		s32	arg1 )

Definition at line 816 of file snd_interface.c.

                                                                 {
    return snd_song_change_track_volume(songName, trackIdx, AU_MAX_VOLUME_8);
}

snd_song_set_proximity_mix_far()

void snd_song_set_proximity_mix_far	(	s32	songName,
		s32	mix )

Definition at line 820 of file snd_interface.c.

                                                           {
    au_bgm_set_proximity_mix(songName, (u8)mix);
}

Referenced by bgm_adjust_proximity().

snd_song_set_proximity_mix_near()

void snd_song_set_proximity_mix_near	(	s32	songName,
		s32	mix )

Definition at line 824 of file snd_interface.c.

                                                            {
    au_bgm_set_proximity_mix(songName, (u8)mix | ((s32)(0.69f * AU_MAX_VOLUME_8) << 24));
}

Referenced by bgm_adjust_proximity().

snd_song_set_proximity_mix_full()

void snd_song_set_proximity_mix_full	(	s32	songName,
		s32	mix )

Definition at line 828 of file snd_interface.c.

                                                            {
    au_bgm_set_proximity_mix(songName, (u8)mix | (AU_MAX_VOLUME_8 << 24));
}

Referenced by bgm_adjust_proximity().

sfx_get_env_sound_instance()

SoundInstance * sfx_get_env_sound_instance

(

s32

soundID

)

Definition at line 379 of file sfx_control.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 sfx_stop_tracking_env_sound_pos().