public.h File Reference

Go to the source code of this file.

Functions
void	snd_notify_engine_ready (ALHeap *heap)
void	snd_legacy_sound_dispatch (u32 id)
	Unused Seems to be an early function that accepts a command to play any kind of audio asset,.
void	snd_bgm_enqueue_legacy_command (u32 cmd)
	Unused Part of an unused system for inter-thread communication with a BGM player using commands.
void	snd_start_sound (s32 soundID, u8 volume, u8 pan)
void	snd_start_sound_with_shift (s32 soundID, u8 volume, u8 pan, s16 pitchShift)
void	snd_adjust_sound (s32 soundID, u8 volume, u8 pan)
void	snd_adjust_sound_with_shift (s32 soundID, u8 volume, u8 pan, s16 pitchShift)
void	snd_stop_sound (s32 soundID)
void	snd_reset (void)
void	snd_start_sound_raw (s32 soundID, s16 volume, s16 pitchShift, s32 pan)
AuResult	snd_load_ambient (s32 arg0)
AuResult	snd_ambient_play (s32 arg0, s32 arg1)
AuResult	snd_ambient_stop_quick (s32 arg0)
AuResult	snd_ambient_stop_slow (s32 arg0, s32 arg1)
AuResult	snd_ambient_pause (s32 arg0, s32 arg1)
AuResult	snd_ambient_resume (s32 arg0, s32 arg1)
AuResult	snd_ambient_is_stopped (s32 arg0)
AuResult	snd_ambient_fade_out (s32 arg0, s32 arg1)
AuResult	snd_ambient_set_volume (s32 arg0, s32 arg1, s32 arg2)
AuResult	snd_ambient_disable (s32 arg0)
AuResult	snd_ambient_enable (s32 arg0)
void	snd_ambient_radio_setup (s32 arg0)
AuResult	snd_ambient_radio_stop (s32 arg0)
AuResult	snd_ambient_radio_select (s32 arg0)
AuResult	snd_song_load (s32 songID, s32 playerIndex)
	return value may be either an AuResult error code OR a valid songName
AuResult	snd_song_request_play_default (s32 songName)
	Unused – snd_song_request_play but always uses BGM_VARIATION_0.
AuResult	snd_song_request_play (s32 songName, s32 variation)
	Called from bgm_control to start playing a particular song + variation.
AuResult	snd_song_stop (s32 songName)
void	snd_song_stop_all (void)
AuResult	snd_song_is_playing (s32 songName)
AuResult	snd_song_request_fade_in (s32 songName, s32 variation, s32 fadeInTime, s32 startVolume, s32 endVolume)
	Called from bgm_control to fade in a particular song + variation.
AuResult	snd_song_request_fade_in_default (s32 songName, s32 fadeInTime, s32 startVolume, s32 endVolume)
	Unused.
AuResult	snd_song_request_fade_out (s32 songName, s32 fadeTime, AuCallback callback)
AuResult	snd_song_push_stop (s32 songName)
AuResult	snd_song_request_pop (s32 songName)
AuResult	snd_song_request_snapshot (s32 songName)
AuResult	snd_song_request_push_fade_out (s32 songName, s32 fadeTime)
AuResult	snd_song_request_pause (s32 songName)
AuResult	snd_song_request_unpause (s32 songName)
AuResult	snd_song_set_volume_quiet (s32 songName)
AuResult	snd_song_set_volume_full (s32 songName)
AuResult	snd_song_set_linked_mode (s32 songName, b32 mode)
AuResult	snd_song_set_playback_rate (s32 songName, f32 arg1)
void	snd_song_poll_music_events (u32 **arg0, s32 *arg1)
void	snd_song_flush_music_events (void)
void	snd_song_trigger_music_event (s32 playerID, s32 trackIndex, s32 eventInfo)
void	snd_song_clear_music_events (void)
void	snd_set_stereo (void)
void	snd_set_mono (void)
void	snd_set_bgm_volume (VolumeLevels volume)
void	snd_set_sfx_volume (VolumeLevels volume)
void	snd_set_sfx_reverb_type (s32 arg0)
void	snd_enable_sfx (void)
void	snd_disable_sfx (void)
AuResult	bgm_set_track_volumes (s32 playerIndex, s16 trackVolSet)
AuResult	bgm_clear_track_volumes (s32 playerIndex, s16 trackVolSet)
AuResult	bgm_set_linked_mode (s32 playerIndex, b16 mode)
void	bgm_quiet_max_volume (void)
void	bgm_reset_max_volume (void)
void	bgm_reset_volume (void)
s32	bgm_init_music_players (void)
s32	bgm_set_song (s32 playerIndex, s32 songID, s32 variation, s32 fadeOutTime, s16 volume)
void	bgm_set_battle_song (s32, s32)
void	bgm_push_battle_song (void)
s32	bgm_adjust_proximity (s32 playerIndex, s32 arg1, s16 arg2)
b32	bgm_fade_in_song (s32 playerIndex, s32 songID, s32 variation, s32 fadeInTime, s16 arg4, s16 arg5)
void	bgm_update_music_control (void)
b32	bgm_is_any_song_playing (void)
void	bgm_reset_sequence_players (void)
void	bgm_pop_song (void)
void	bgm_push_song (s32 songID, s32 variation)
void	bgm_pop_battle_song (void)
void	sfx_reset_door_sounds (void)
void	sfx_clear_sounds (void)
void	sfx_clear_env_sounds (s16 playSounds)
void	sfx_update_env_sound_params (void)
void	sfx_set_reverb_mode (s32 arg0)
s32	sfx_get_reverb_mode (void)
void	sfx_stop_env_sounds (void)
void	sfx_play_sound_looping (s32 soundID, u8 volume, u8 pan, s16 pitchShift)
void	sfx_register_looping_sound_at_position (s32 soundID, s32 flags, f32 x, f32 y, f32 z)
s32	sfx_adjust_env_sound_pos (s32 soundID, s32 sourceFlags, f32 x, f32 y, f32 z)
void	sfx_stop_tracking_env_sound_pos (s32 soundID, s32 keepPlaying)
void	sfx_play_sound_with_params (s32 soundID, u8 volume, u8 pan, s16 pitchShift)
void	sfx_adjust_env_sound_params (s32 soundID, u8 volume, u8 pan, s16 pitchShift)
void	sfx_stop_sound (s32 soundID)
void	sfx_play_sound (s32 soundID)
void	sfx_play_sound_at_player (s32 soundID, s32 arg1)
void	sfx_play_sound_at_npc (s32 soundID, s32 arg1, s32 npcID)
void	sfx_play_sound_at_position (s32 soundID, s32 flags, f32 posX, f32 posY, f32 posZ)
void	sfx_get_spatialized_sound_params (f32 x, f32 y, f32 z, s16 *volume, s16 *pan, s32 flags)
void	sfx_compute_spatialized_sound_params_ignore_depth (f32 x, f32 y, f32 z, s16 *volume, s16 *pan)
void	sfx_compute_spatialized_sound_params_with_depth (f32 x, f32 y, f32 z, s16 *volume, s16 *pan)
void	sfx_compute_spatialized_sound_params_full (f32 x, f32 y, f32 z, s16 *volume, s16 *pan, s32 flags)

Function Documentation

snd_notify_engine_ready()

void snd_notify_engine_ready

(

ALHeap *

heap

)

Definition at line 108 of file snd_interface.c.

                                           {
    SoundEngineReady = 1;
    PreventBGMPlayerUpdate = FALSE;
}

Referenced by au_engine_init().

snd_legacy_sound_dispatch()

void snd_legacy_sound_dispatch

(

u32

id

)

Unused Seems to be an early function that accepts a command to play any kind of audio asset,.

Definition at line 116 of file snd_interface.c.

                                       {
    u16 ready = SoundEngineReady;
    u32 type = id & 0xF;
 
    if (ready == 1) {
        switch (type) {
            case 2:
            case 3:
                break;
            case 4:
                snd_start_sound_with_shift(id >> 4, 0, 0, 0);
                break;
            case 1:
                if (type == 1) {
                    s32 filename = snd_song_load((id >> 4) & 0xFF, 0);
 
                    if (filename > ASCII_TO_U32('0', ' ', ' ', '\0')) {
                        snd_song_request_play(filename, (id >> 0xC) & 3);
                    }
                }
                break;
        }
    }
}

snd_bgm_enqueue_legacy_command()

void snd_bgm_enqueue_legacy_command

(

u32

cmd

)

Unused 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 159 of file snd_interface.c.

                                             {
    BGMPlayer* player = NULL;
    u32 playerID = cmd & 0xF;
 
    if (playerID == 0) {
        return;
    } else if (playerID == 1) {
        player = gBGMPlayerA;
    } else if (playerID == 2) {
        player = gBGMPlayerB;
    }
 
    if (player != NULL) {
        u32 pos;
 
        if (player->cmdBufPending < ARRAY_COUNT(player->cmdBufData)) {
            pos = player->cmdBufWritePos;
 
            player->cmdBufData[pos] = cmd >> 4;
 
            pos++;
            if (pos >= 8) {
                pos = 0;
            }
            player->cmdBufWritePos = pos;
 
            player->cmdBufPending++;
        } else {
            pos = player->cmdBufOverflows + 1;
 
            if (pos > 99) {
                pos = 99;
            }
            player->cmdBufOverflows = pos;
        }
    }
}

snd_start_sound()

void snd_start_sound	(	s32	soundID,
		u8	volume,
		u8	pan )

Definition at line 197 of file snd_interface.c.

                                                     {
    SoundManager* soundManager = gSoundManager;
    s16 vol = volume << 8;
 
    if (vol != 0) {
        vol |= 0xFF;
    }
 
    if (pan > AU_PAN_MAX) {
        pan = AU_PAN_MAX;
    }
 
    au_sfx_enqueue_event(soundManager, soundID, vol, 0, pan);
}

snd_start_sound_with_shift()

void snd_start_sound_with_shift	(	s32	soundID,
		u8	volume,
		u8	pan,
		s16	pitchShift )

Definition at line 212 of file snd_interface.c.

                                                                                {
    SoundManager* soundManager = gSoundManager;
    s16 vol = volume << 8;
 
    if (vol != 0) {
        vol |= 0xFF;
    }
 
    if (pan > AU_PAN_MAX) {
        pan = AU_PAN_MAX;
    }
 
    if (pitchShift > 2 * AU_OCTAVE_CENTS) {
        pitchShift = 2 * AU_OCTAVE_CENTS;
    } else if (pitchShift < -2 * AU_OCTAVE_CENTS) {
        pitchShift = -2 * AU_OCTAVE_CENTS;
    }
 
    au_sfx_enqueue_event(soundManager, soundID, vol, pitchShift, pan);
}

Referenced by sfx_clear_env_sounds(), sfx_play_sound_looping(), sfx_play_sound_with_params(), and snd_legacy_sound_dispatch().

snd_adjust_sound()

void snd_adjust_sound	(	s32	soundID,
		u8	volume,
		u8	pan )

Definition at line 233 of file snd_interface.c.

                                                      {
    SoundManager* soundManager = gSoundManager;
    s16 vol = volume << 8;
 
    if (vol != 0) {
        vol |= 0xFF;
    }
 
    if (pan > AU_PAN_MAX) {
        pan = AU_PAN_MAX;
    }
 
    au_sfx_enqueue_event(soundManager, soundID | SOUND_ID_ADJUST, vol, 0, pan);
}

snd_adjust_sound_with_shift()

void snd_adjust_sound_with_shift	(	s32	soundID,
		u8	volume,
		u8	pan,
		s16	pitchShift )

Definition at line 248 of file snd_interface.c.

                                                                                 {
    SoundManager* soundManager = gSoundManager;
    s16 vol = volume << 8;
 
    if (vol != 0) {
        vol |= 0xFF;
    }
 
    if (pan > AU_PAN_MAX) {
        pan = AU_PAN_MAX;
    }
 
    if (pitchShift > 2 * AU_OCTAVE_CENTS) {
        pitchShift = 2 * AU_OCTAVE_CENTS;
    } else if (pitchShift < -2 * AU_OCTAVE_CENTS) {
        pitchShift = -2 * AU_OCTAVE_CENTS;
    }
 
    au_sfx_enqueue_event(soundManager, soundID | SOUND_ID_ADJUST, vol, pitchShift, pan);
}

Referenced by sfx_adjust_env_sound_params(), and sfx_update_env_sound_params().

snd_stop_sound()

void snd_stop_sound

(

s32

soundID

)

Definition at line 269 of file snd_interface.c.

                                 {
    SoundManager* soundManager = gSoundManager;
 
    au_sfx_enqueue_event(soundManager, soundID | SOUND_ID_STOP, 0, 0, 0);
}

Referenced by action_update_sliding(), sfx_stop_env_sounds(), sfx_stop_sound(), and sfx_stop_tracking_env_sound_pos().

snd_reset()

void snd_reset

(

void

)

Definition at line 275 of file snd_interface.c.

                     {
    gSoundManager->resetPending = 1;
}

snd_start_sound_raw()

void snd_start_sound_raw	(	s32	soundID,
		s16	volume,
		s16	pitchShift,
		s32	pan )

Definition at line 279 of file snd_interface.c.

                                                                           {
    SoundManager* soundManager = gSoundManager;
 
    au_sfx_enqueue_event(soundManager, soundID, volume, pitchShift, pan);
}

snd_load_ambient()

AuResult snd_load_ambient

(

s32

arg0

)

Definition at line 285 of file snd_interface.c.

                                          {
    return au_ambient_load(ambSoundID);
}

Referenced by update_ambient_sounds().

snd_ambient_play()

AuResult snd_ambient_play	(	s32	arg0,
		s32	arg1 )

Definition at line 289 of file snd_interface.c.

                                                     {
    AuResult status = au_mseq_check_player_index(index);
 
    if (status != AU_RESULT_OK) {
        return status;
    }
    return au_mseq_start(index, fadeInTime);
}

Referenced by snd_ambient_radio_setup(), and update_ambient_sounds().

snd_ambient_stop_quick()

AuResult snd_ambient_stop_quick

(

s32

arg0

)

Definition at line 298 of file snd_interface.c.

                                           {
    AuResult status = au_mseq_check_player_index(index);
 
    if (status == AU_RESULT_OK) {
        au_mseq_stop_quick(index);
    }
 
    return status;
}

Referenced by play_ambient_sounds(), snd_ambient_radio_stop(), and update_ambient_sounds().

snd_ambient_stop_slow()

AuResult snd_ambient_stop_slow	(	s32	arg0,
		s32	arg1 )

Definition at line 308 of file snd_interface.c.

                                                           {
    AuResult status = au_mseq_check_player_index(index);
 
    if (status == AU_RESULT_OK) {
        au_mseq_stop_slow(index, fadeOutTime);
    }
 
    return status;
}

Referenced by snd_ambient_radio_stop(), and update_ambient_sounds().

snd_ambient_pause()

AuResult snd_ambient_pause	(	s32	arg0,
		s32	arg1 )

Definition at line 318 of file snd_interface.c.

                                                       {
    AuResult status = au_mseq_check_player_index(index);
 
    if (status == AU_RESULT_OK) {
        au_mseq_pause(index, fadeOutTime);
    }
 
    return status;
}

Referenced by bgm_push_battle_song().

snd_ambient_resume()

AuResult snd_ambient_resume	(	s32	arg0,
		s32	arg1 )

Definition at line 328 of file snd_interface.c.

                                                       {
    AuResult status = au_mseq_check_player_index(index);
 
    if (status == AU_RESULT_OK) {
        au_mseq_resume(index, fadeInTime);
    }
 
    return status;
}

Referenced by bgm_pop_battle_song().

snd_ambient_is_stopped()

AuResult snd_ambient_is_stopped

(

s32

arg0

)

Definition at line 338 of file snd_interface.c.

                                           {
    AuResult status = au_mseq_check_player_index(index);
 
    if (status != AU_RESULT_OK) {
        return status;
    }
    return au_mseq_check_stopped(index);
}

Referenced by update_ambient_sounds().

snd_ambient_fade_out()

AuResult snd_ambient_fade_out	(	s32	arg0,
		s32	arg1 )

Definition at line 347 of file snd_interface.c.

                                                   {
    AuResult status = au_mseq_check_player_index(index);
 
    if (status == AU_RESULT_OK) {
        au_mseq_load_tracks_fade(index, arg1);
    }
 
    return status;
}

snd_ambient_set_volume()

AuResult snd_ambient_set_volume	(	s32	arg0,
		s32	arg1,
		s32	arg2 )

Definition at line 357 of file snd_interface.c.

                                                                 {
    AuResult status = au_mseq_check_player_index(index);
 
    if (status == AU_RESULT_OK) {
        au_mseq_set_volume(index, time, volume);
    }
 
    return status;
}

snd_ambient_disable()

AuResult snd_ambient_disable

(

s32

arg0

)

Definition at line 367 of file snd_interface.c.

                                        {
    AuResult status = au_mseq_check_player_index(index);
 
    if (status == AU_RESULT_OK) {
        au_mseq_set_disabled(index, TRUE);
    }
 
    return status;
}

Referenced by snd_ambient_radio_select().

snd_ambient_enable()

AuResult snd_ambient_enable

(

s32

arg0

)

Definition at line 377 of file snd_interface.c.

                                       {
    AuResult status  = au_mseq_check_player_index(index);
 
    if (status == AU_RESULT_OK) {
        au_mseq_set_disabled(index, FALSE);
    }
 
    return status;
}

Referenced by snd_ambient_radio_select().

snd_ambient_radio_setup()

void snd_ambient_radio_setup

(

s32

arg0

)

Definition at line 387 of file snd_interface.c.

                                        {
    s32 radioChannels = 4;
    u32 i;
 
    AmbienceRadioChannel = 0xFF;
 
    for (i = 0; i < radioChannels; i++) {
        if (snd_ambient_play(i, 0) != AU_RESULT_OK) {
            return;
        }
    }
 
    snd_ambient_radio_select(index);
}

snd_ambient_radio_stop()

AuResult snd_ambient_radio_stop

(

s32

arg0

)

Definition at line 402 of file snd_interface.c.

                                          {
    AuResult status = AU_RESULT_OK;
    s32 radioChannels = 4;
    u32 i;
 
    for (i = 0; i < radioChannels; i++) {
        if (i == AmbienceRadioChannel) {
            status = snd_ambient_stop_slow(i, time);
        } else {
            status = snd_ambient_stop_quick(i);
        }
        if (status != AU_RESULT_OK) {
            break;
        }
    }
    return status;
}

snd_ambient_radio_select()

AuResult snd_ambient_radio_select

(

s32

arg0

)

Definition at line 420 of file snd_interface.c.

                                             {
    AuResult status = AU_RESULT_OK;
    s32 radioChannels = 4;
 
    if (index != AmbienceRadioChannel) {
        u32 i;
 
        for (i = 0; i < radioChannels; i++) {
            if (i == index) {
                status = snd_ambient_enable(i);
            } else {
                status = snd_ambient_disable(i); // mute
            }
 
            if (status != AU_RESULT_OK) {
                break;
            }
        }
 
        if (status == AU_RESULT_OK) {
            AmbienceRadioChannel = index;
        }
    }
 
    return status;
}

Referenced by snd_ambient_radio_setup().

snd_song_load()

AuResult snd_song_load	(	s32	songID,
		s32	playerIndex )

return value may be either an AuResult error code OR a valid songName

Definition at line 447 of file snd_interface.c.

                                                    {
    BGMHeader* bgmFile;
    BGMPlayer* player;
 
    au_get_bgm_player_and_file(playerIndex, &bgmFile, &player);
 
    if (bgmFile != NULL) {
        return au_load_song_files(songID, bgmFile, player);
    } else {
        return AU_ERROR_NULL_SONG_NAME;
    }
}

Referenced by bgm_update_music_control(), and snd_legacy_sound_dispatch().

snd_song_request_play_default()

AuResult snd_song_request_play_default

(

s32

songName

)

Unused – snd_song_request_play but always uses BGM_VARIATION_0.

Definition at line 461 of file snd_interface.c.

                                                     {
    AuResult status;
    SongStartRequest s;
 
    PreventBGMPlayerUpdate = TRUE;
    s.songName = songName;
    s.duration = 0;
    s.startVolume = AU_MAX_VOLUME_8;
    s.finalVolume = AU_MAX_VOLUME_8;
    s.variation = BGM_VARIATION_0;
    s.unused_14 = 0;
    status = au_bgm_process_init_song(&s);
    PreventBGMPlayerUpdate = FALSE;
 
    return status;
}

snd_song_request_play()

AuResult snd_song_request_play	(	s32	songName,
		s32	variation )

Called from bgm_control to start playing a particular song + variation.

Definition at line 479 of file snd_interface.c.

                                                            {
    AuResult status;
    SongStartRequest s;
 
    PreventBGMPlayerUpdate = TRUE;
    s.songName = songName;
    s.duration = 0;
    s.startVolume = AU_MAX_VOLUME_8;
    s.finalVolume = AU_MAX_VOLUME_8;
    s.variation = variation;
    s.unused_14 = 0;
    status = au_bgm_process_init_song(&s);
    PreventBGMPlayerUpdate = FALSE;
 
    return status;
}

Referenced by bgm_update_music_control(), and snd_legacy_sound_dispatch().

snd_song_stop()

AuResult snd_song_stop

(

s32

songName

)

Definition at line 496 of file snd_interface.c.

                                     {
    return au_bgm_stop_song(songName);
}

Referenced by _bgm_set_song(), bgm_fade_in_song(), and bgm_update_music_control().

snd_song_stop_all()

void snd_song_stop_all

(

void

)

Definition at line 500 of file snd_interface.c.

                             {
    au_bgm_stop_all();
}

snd_song_is_playing()

AuResult snd_song_is_playing

(

s32

songName

)

Definition at line 504 of file snd_interface.c.

                                           {
    return au_bgm_is_song_playing(songName);
}

Referenced by bgm_is_any_song_playing(), and bgm_update_music_control().

snd_song_request_fade_in()

AuResult snd_song_request_fade_in	(	s32	songName,
		s32	variation,
		s32	fadeInTime,
		s32	startVolume,
		s32	endVolume )

Called from bgm_control to fade in a particular song + variation.

Definition at line 509 of file snd_interface.c.

                                                                                                               {
    AuResult status;
    SongStartRequest s;
 
    PreventBGMPlayerUpdate = TRUE;
    s.songName = songName;
    s.duration = fadeInTime;
    s.startVolume = startVolume;
    s.finalVolume = endVolume;
    s.variation = variation;
    s.unused_14 = 0;
    status = au_bgm_process_init_song(&s);
    PreventBGMPlayerUpdate = FALSE;
 
    return status;
}

Referenced by bgm_update_music_control().

snd_song_request_fade_in_default()

AuResult snd_song_request_fade_in_default	(	s32	songName,
		s32	fadeInTime,
		s32	startVolume,
		s32	endVolume )

Unused.

Definition at line 527 of file snd_interface.c.

                                                                                                        {
    AuResult status;
    SongStartRequest s;
 
    PreventBGMPlayerUpdate = TRUE;
    s.songName = songName;
    s.duration = fadeInTime;
    s.startVolume = startVolume;
    s.finalVolume = endVolume;
    s.variation = 0;
    s.unused_14 = 0;
    status = au_bgm_process_init_song(&s);
    PreventBGMPlayerUpdate = FALSE;
 
    return status;
}

snd_song_request_fade_out()

AuResult snd_song_request_fade_out	(	s32	songName,
		s32	fadeTime,
		AuCallback	callback )

Definition at line 544 of file snd_interface.c.

                                                                                    {
    SongFadeOutRequest s;
 
    s.songName = songName;
    s.duration = fadeTime;
    s.unused_08 = 0;
    s.finalVolume = 0;
    s.doneCallback = callback;
    s.onPush = FALSE;
 
    return au_bgm_process_fade_out(&s);
}

Referenced by bgm_update_music_control().

snd_song_push_stop()

AuResult snd_song_push_stop

(

s32

songName

)

Definition at line 557 of file snd_interface.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, FALSE); // force stop
}

Referenced by bgm_update_music_control().

snd_song_request_pop()

AuResult snd_song_request_pop

(

s32

songName

)

Definition at line 570 of file snd_interface.c.

                                            {
    AuResult status;
    SongResumeRequest s;
 
    PreventBGMPlayerUpdate = TRUE;
    s.songName = songName;
    s.duration = 2000;
    s.startVolume = 1;
    s.finalVolume = AU_MAX_VOLUME_8;
    s.index = BGM_SNAPSHOT_0;
    s.pauseMode = FALSE;
    status = au_bgm_process_resume(&s);
    PreventBGMPlayerUpdate = FALSE;
 
    return status;
}

Referenced by bgm_update_music_control().

snd_song_request_snapshot()

AuResult snd_song_request_snapshot

(

s32

songName

)

Definition at line 587 of file snd_interface.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, TRUE); // no stop
}

Referenced by _bgm_set_song().

snd_song_request_push_fade_out()

AuResult snd_song_request_push_fade_out	(	s32	songName,
		s32	fadeTime )

Definition at line 600 of file snd_interface.c.

                                                                    {
    SongFadeOutRequest s;
 
    s.songName = songName;
    s.duration = fadeTime;
    s.unused_08 = 0;
    s.finalVolume = 0;
    s.doneCallback = NULL;
    s.onPush = TRUE;
 
    return au_bgm_process_fade_out(&s);
}

Referenced by bgm_update_music_control().

snd_song_request_pause()

AuResult snd_song_request_pause

(

s32

songName

)

Definition at line 613 of file snd_interface.c.

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

snd_song_request_unpause()

AuResult snd_song_request_unpause

(

s32

songName

)

Definition at line 626 of file snd_interface.c.

                                                {
    SongResumeRequest s;
 
    s.songName = songName;
    s.duration = 0;
    s.startVolume = 0;
    s.finalVolume = 0;
    s.index = BGM_SNAPSHOT_0;
    s.pauseMode = TRUE;
 
    return au_bgm_process_resume(&s);
}

snd_song_set_volume_quiet()

AuResult snd_song_set_volume_quiet

(

s32

songName

)

Definition at line 639 of file snd_interface.c.

                                                 {
    SongStartRequest s;
 
    s.songName = songName;
    s.duration = 500;
    s.finalVolume = 0.25001 * AU_MAX_VOLUME_16;
 
    return au_bgm_adjust_volume(&s);
}

snd_song_set_volume_full()

AuResult snd_song_set_volume_full

(

s32

songName

)

Definition at line 649 of file snd_interface.c.

                                                {
    SongStartRequest s;
 
    s.songName = songName;
    s.duration = 500;
    s.finalVolume = AU_MAX_VOLUME_16;
 
    return au_bgm_adjust_volume(&s);
}

snd_song_set_linked_mode()

AuResult snd_song_set_linked_mode	(	s32	songName,
		b32	mode )

Definition at line 659 of file snd_interface.c.

                                                          {
    SongSwapLinkedRequest s;
 
    s.songName = songName;
    s.enabled = mode;
 
    return au_bgm_set_linked_tracks(&s);
}

Referenced by bgm_set_linked_mode().

snd_song_set_playback_rate()

AuResult snd_song_set_playback_rate	(	s32	songName,
		f32	arg1 )

Definition at line 689 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_set_playback_rate(bgmPlayer, rate);
    }
 
    return status;
}

snd_song_poll_music_events()

void snd_song_poll_music_events	(	u32 **	arg0,
		s32 *	arg1 )

Definition at line 832 of file snd_interface.c.

                                                                             {
    AuGlobals* globals = gSoundGlobals;
 
    *musicEvents = globals->musicEventQueue;
    *count = globals->musicEventQueueCount;
}

snd_song_flush_music_events()

void snd_song_flush_music_events

(

void

)

Definition at line 839 of file snd_interface.c.

                                       {
    gSoundGlobals->flushMusicEventQueue = TRUE;
}

snd_song_trigger_music_event()

void snd_song_trigger_music_event	(	s32	playerID,
		s32	trackIndex,
		s32	eventInfo )

Definition at line 843 of file snd_interface.c.

                                                                               {
    AuGlobals* globals = gSoundGlobals;
 
    if (globals->musicEventQueueCount < MUS_QUEUE_SIZE) {
        *globals->musicEventQueuePos++ = ((playerID << 28) + ((trackIndex & 0xF) << 24) + eventInfo);
        globals->musicEventQueueCount++;
    }
}

Referenced by au_BGMCmd_FD_EventTrigger().

snd_song_clear_music_events()

void snd_song_clear_music_events

(

void

)

Definition at line 852 of file snd_interface.c.

                                       {
    AuGlobals* globals = gSoundGlobals;
    s32* buf = globals->musicEventQueue;
    s32 i = 15;
 
    do {
        *buf++ = 0;
    } while (i-- != 0);
 
    globals->musicEventQueueCount = 0;
    globals->flushMusicEventQueue = FALSE;
    globals->musicEventQueuePos = globals->musicEventQueue;
}

Referenced by au_engine_init(), and au_update_clients_for_video_frame().

snd_set_stereo()

void snd_set_stereo

(

void

)

Definition at line 872 of file snd_interface.c.

                          {
    au_set_stereo_enabled(TRUE);
    au_sync_channel_delay_enabled(0);
}

Referenced by filemenu_main_handle_input(), and state_step_startup().

snd_set_mono()

void snd_set_mono

(

void

)

Definition at line 877 of file snd_interface.c.

                        {
    au_set_stereo_enabled(FALSE);
    au_sync_channel_delay_enabled(1);
}

Referenced by filemenu_main_handle_input(), and state_step_startup().

snd_set_bgm_volume()

void snd_set_bgm_volume

(

VolumeLevels

volume

)

Definition at line 882 of file snd_interface.c.

                                             {
    au_set_bus_volume_level(AUDIO_TYPE_BGM, volume);
}

Referenced by bgm_reset_sequence_players(), and bgm_update_volume().

snd_set_sfx_volume()

void snd_set_sfx_volume

(

VolumeLevels

volume

)

Definition at line 886 of file snd_interface.c.

                                             {
    au_set_bus_volume_level(AUDIO_TYPE_SFX, volume);
}

snd_set_sfx_reverb_type()

void snd_set_sfx_reverb_type

(

s32

arg0

)

Definition at line 890 of file snd_interface.c.

                                             {
    au_set_reverb_type(AUDIO_TYPE_SFX, reverbType);
}

Referenced by sfx_set_reverb_mode().

snd_enable_sfx()

void snd_enable_sfx

(

void

)

Definition at line 894 of file snd_interface.c.

                          {
    au_sfx_set_state(gSoundManager, SND_MANAGER_STATE_ENABLED);
}

Referenced by state_step_demo().

snd_disable_sfx()

void snd_disable_sfx

(

void

)

Definition at line 898 of file snd_interface.c.

                           {
    au_sfx_set_state(gSoundManager, SND_MANAGER_STATE_DISABLED);
}

Referenced by state_init_demo().

bgm_set_track_volumes()

AuResult bgm_set_track_volumes	(	s32	playerIndex,
		s16	trackVolSet )

Definition at line 294 of file bgm_control.c.

                                                                 {
    MusicControlData* music = &gMusicControlData[playerIndex];
 
    if (!(music->flags & MUSIC_FLAG_PLAYING)) {
        return AU_RESULT_OK;
    }
 
    return snd_song_set_track_volumes(music->songName, trackVolSet);
}

bgm_clear_track_volumes()

AuResult bgm_clear_track_volumes	(	s32	playerIndex,
		s16	trackVolSet )

Definition at line 304 of file bgm_control.c.

                                                                   {
    MusicControlData* music = &gMusicControlData[playerIndex];
 
    if (!(music->flags & MUSIC_FLAG_PLAYING)) {
        return AU_RESULT_OK;
    }
 
    return snd_song_clear_track_volumes(music->songName, trackVolSet);
}

bgm_set_linked_mode()

AuResult bgm_set_linked_mode	(	s32	playerIndex,
		b16	mode )

Definition at line 314 of file bgm_control.c.

                                                        {
    MusicControlData* music = &gMusicControlData[playerIndex];
 
    if (!(music->flags & MUSIC_FLAG_PLAYING)) {
        return AU_RESULT_OK;
    }
 
    return snd_song_set_linked_mode(music->songName, mode);
}

bgm_quiet_max_volume()

void bgm_quiet_max_volume

(

void

)

Definition at line 331 of file bgm_control.c.

                                {
    MusicMaxVolume = VOL_LEVEL_4;
}

Referenced by state_step_pause().

bgm_reset_max_volume()

void bgm_reset_max_volume

(

void

)

Definition at line 335 of file bgm_control.c.

                                {
    MusicMaxVolume = VOL_LEVEL_FULL;
}

Referenced by state_step_unpause().

bgm_reset_volume()

void bgm_reset_volume

(

void

)

Definition at line 77 of file bgm_control.c.

                            {
    MusicTargetVolume = VOL_LEVEL_FULL;
    MusicMaxVolume = VOL_LEVEL_FULL;
}

Referenced by state_step_startup().

bgm_init_music_players()

s32 bgm_init_music_players

(

void

)

Definition at line 324 of file bgm_control.c.

                                 {
    bgm_set_song(0, AU_SONG_NONE, 0, 250, VOL_LEVEL_FULL);
    bgm_set_song(1, AU_SONG_NONE, 0, 250, VOL_LEVEL_FULL);
 
    return 1;
}

Referenced by state_step_startup().

bgm_set_song()

s32 bgm_set_song	(	s32	playerIndex,
		s32	songID,
		s32	variation,
		s32	fadeOutTime,
		s16	volume )

Definition at line 230 of file bgm_control.c.

                                                                                          {
    gMusicControlData[playerIndex].flags &= ~MUSIC_FLAG_POPPING;
 
    return _bgm_set_song(playerIndex, songID, variation, fadeOutTime, volume);
}

Referenced by bgm_init_music_players(), bgm_push_battle_song(), bgm_push_song(), btl_state_update_celebration(), btl_state_update_defeat(), btl_state_update_end_training_battle(), btl_state_update_run_away(), btl_state_update_victory(), state_init_exit_file_select(), state_init_title_screen(), and state_step_title_screen().

bgm_set_battle_song()

void bgm_set_battle_song	(	s32	songID,
		s32	variation )

Definition at line 431 of file bgm_control.c.

                                                    {
    MusicControlData* music = gMusicControlData;
 
    music->battleSongID = songID;
    music->battleVariation = variation;
}

Referenced by update_encounters_pre_battle().

bgm_push_battle_song()

void bgm_push_battle_song

(

void

)

Definition at line 416 of file bgm_control.c.

                                {
    MusicControlData* music = gMusicControlData;
 
    if (gGameStatusPtr->demoState == DEMO_STATE_NONE) {
        if (!(gOverrideFlags & GLOBAL_OVERRIDES_DONT_RESUME_SONG_AFTER_BATTLE)) {
            snd_ambient_pause(0, 250);
            music->savedSongID = music->requestedSongID;
            music->savedVariation = music->variation;
            music->savedSongName = music->songName;
            music->flags |= MUSIC_FLAG_PUSHING;
            bgm_set_song(0, music->battleSongID, music->battleVariation, 500, VOL_LEVEL_FULL);
        }
    }
}

Referenced by update_encounters_pre_battle().

bgm_adjust_proximity()

s32 bgm_adjust_proximity	(	s32	playerIndex,
		s32	arg1,
		s16	arg2 )

Definition at line 269 of file bgm_control.c.

                                                              {
    MusicControlData* music = &gMusicControlData[playerIndex];
 
    if (!(music->flags & MUSIC_FLAG_PLAYING)) {
        return FALSE;
    }
 
    if (!(music->flags & MUSIC_FLAG_ENABLE_PROX_MIX)) {
        return FALSE;
    }
 
    switch (state) {
        case MUSIC_PROXIMITY_FAR:
            snd_song_set_proximity_mix_far(music->songName, mix);
            break;
        case MUSIC_PROXIMITY_NEAR:
            snd_song_set_proximity_mix_near(music->songName, mix);
            break;
        case MUSIC_PROXIMITY_FULL:
            snd_song_set_proximity_mix_full(music->songName, mix);
            break;
    }
    return TRUE;
}

bgm_fade_in_song()

b32 bgm_fade_in_song	(	s32	playerIndex,
		s32	songID,
		s32	variation,
		s32	fadeInTime,
		s16	arg4,
		s16	arg5 )

Definition at line 236 of file bgm_control.c.

                                                                                                                         {
    MusicControlData* music;
    s32 mapSongVariation;
 
    if (gGameStatusPtr->demoState) {
        return TRUE;
    }
 
    music = &gMusicControlData[playerIndex];
 
    if (!gGameStatusPtr->musicEnabled) {
        snd_song_stop(music->songName);
        music->flags &= ~MUSIC_FLAG_PLAYING;
        return TRUE;
    }
 
    mapSongVariation = bgm_get_map_default_variation(songID);
    if (mapSongVariation >= 0) {
        variation = mapSongVariation;
    }
 
    music->fadeInTime = fadeInTime;
    music->fadeStartVolume = fadeStartVolume;
    music->fadeEndVolume = fadeEndVolume;
    music->requestedSongID = songID;
    music->variation = variation;
    music->flags |= MUSIC_FLAG_FADE_IN_NEXT;
    music->state = MUSIC_STATE_STOP_CURRENT;
    music->flags &= ~MUSIC_FLAG_ENABLE_PROX_MIX;
 
    return TRUE;
}

bgm_update_music_control()

void bgm_update_music_control

(

void

)

Bug

this is called even if we are trying to fade in, immediately overriding any fade parameters

Definition at line 83 of file bgm_control.c.

                                    {
    MusicControlData* music = gMusicControlData;
    s32 i = 0;
    s16 stateFadeOut = MUSIC_STATE_AWAIT_FADEOUT;
    s16 pushedFlag = MUSIC_FLAG_PUSHING;
    s32 flags;
 
    for (i; i < ARRAY_COUNT(gMusicControlData); i++, music++) {
        switch (music->state) {
            case MUSIC_STATE_IDLE:
                break;
            case MUSIC_STATE_STOP_CURRENT:
                if (music->flags & MUSIC_FLAG_PLAYING) {
                    if (music->fadeOutTime < 250) {
                        if (!(music->flags & MUSIC_FLAG_PUSHING)) {
                            if (snd_song_stop(music->songName) == AU_RESULT_OK) {
                                music->state = stateFadeOut;
                            }
                        } else {
                            if (snd_song_push_stop(music->songName) == AU_RESULT_OK) {
                                music->state = stateFadeOut;
                            }
                        }
                    } else if (!(music->flags & MUSIC_FLAG_PUSHING)) {
                        if (snd_song_request_fade_out(music->songName, music->fadeOutTime, NULL) == AU_RESULT_OK) {
                            music->state = stateFadeOut;
                        }
                    } else {
                        if (snd_song_request_push_fade_out(music->songName, 250) == AU_RESULT_OK) {
                            music->state = stateFadeOut;
                        }
                    }
                } else {
                    if (music->flags & MUSIC_FLAG_PUSHING) {
                        // nothing was playing in this case, so remember to skip the next pop
                        music->flags |= MUSIC_FLAG_IGNORE_POP;
                    }
                    music->flags &= ~pushedFlag;
                    music->state = MUSIC_STATE_PLAY_NEXT;
                }
                break;
            case MUSIC_STATE_AWAIT_FADEOUT:
                flags = music->flags;
                music->flags &= ~pushedFlag;
                if (flags & MUSIC_FLAG_PLAYING) {
                    if (snd_song_is_playing(music->songName) == AU_RESULT_OK) {
                        music->flags &= ~MUSIC_FLAG_PLAYING;
                        music->state = MUSIC_STATE_DELAY_2;
                    }
                } else {
                    music->state = MUSIC_STATE_PLAY_NEXT;
                }
                break;
            case MUSIC_STATE_DELAY_2:
                music->state = MUSIC_STATE_DELAY_1;
                break;
            case MUSIC_STATE_DELAY_1:
                music->state = MUSIC_STATE_PLAY_NEXT;
                break;
            case MUSIC_STATE_PLAY_NEXT:
                if (!(music->flags & MUSIC_FLAG_POPPING)) {
                    if (music->requestedSongID <= AU_SONG_NONE) {
                        // new song is AU_SONG_NONE, play nothing
                        music->state = MUSIC_STATE_IDLE;
                    } else {
                        music->songName = snd_song_load(music->requestedSongID, i);
                        // snd_song_lond may return either songName or an AuResult error code.
                        // since song names are 4-character big-endian identifiers packed into an s32, we require
                        // the upper half of the return value to be nonzero for songs which loaded without error.
                        // this reserves return values from 0 to 0xFFFF for AuResult codes.
                        if (music->songName > 0xFFFFU) {
                            if ((music->flags & MUSIC_FLAG_FADE_IN_NEXT)) {
                                snd_song_request_fade_in(music->songName, music->variation,
                                    music->fadeInTime, music->fadeStartVolume, music->fadeEndVolume);
                                music->flags &= ~MUSIC_FLAG_FADE_IN_NEXT;
                            } else {
                                // if we aren't fading in, just start at the default volume level
                                bgm_set_target_volume(MusicDefaultVolume);
                            }
                            if (snd_song_request_play(music->songName, music->variation) == AU_RESULT_OK) {
                                music->flags |= MUSIC_FLAG_PLAYING;
                                music->state = MUSIC_STATE_IDLE;
                            }
                        }
                    }
                } else {
                    if (music->flags & MUSIC_FLAG_IGNORE_POP) {
                        music->state = MUSIC_STATE_IDLE;
                        music->flags &= ~(MUSIC_FLAG_IGNORE_POP | MUSIC_FLAG_POPPING);
                    } else if (snd_song_request_pop(music->savedSongName) == AU_RESULT_OK) {
                        music->requestedSongID = music->savedSongID;
                        music->variation = music->savedVariation;
                        music->songName = music->savedSongName;
                        music->state = MUSIC_STATE_IDLE;
                        music->flags |= MUSIC_FLAG_PLAYING;
                        music->flags &= ~MUSIC_FLAG_POPPING;
                    }
                }
                break;
        }
    }
    bgm_update_volume();
}

bgm_is_any_song_playing()

b32 bgm_is_any_song_playing

(

void

)

Definition at line 367 of file bgm_control.c.

                                  {
    MusicControlData* music = gMusicControlData;
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(gMusicControlData); i++, music++) {
        if (music->flags & MUSIC_FLAG_PLAYING) {
            if (snd_song_is_playing(music->songName)) {
                return TRUE;
            }
        }
    }
    return FALSE;
}

bgm_reset_sequence_players()

void bgm_reset_sequence_players

(

void

)

Definition at line 64 of file bgm_control.c.

                                      {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(gMusicControlData); i++) {
        gMusicControlData[i] = BlankMusicControlData;
    }
 
    MusicTargetVolume = VOL_LEVEL_FULL;
    MusicMaxVolume = VOL_LEVEL_FULL;
    MusicCurrentVolume = VOL_LEVEL_FULL;
    snd_set_bgm_volume(VOL_LEVEL_FULL);
}

bgm_pop_song()

void bgm_pop_song

(

void

)

Definition at line 381 of file bgm_control.c.

                        {
    MusicControlData* music = gMusicControlData;
 
    if (gGameStatusPtr->demoState == DEMO_STATE_NONE) {
        music->flags |= MUSIC_FLAG_POPPING;
        _bgm_set_song(0, music->savedSongID, music->savedVariation, 0, VOL_LEVEL_FULL);
    }
}

bgm_push_song()

void bgm_push_song	(	s32	songID,
		s32	variation )

Definition at line 390 of file bgm_control.c.

                                              {
    MusicControlData* music = gMusicControlData;
 
    if (gGameStatusPtr->demoState == DEMO_STATE_NONE) {
        music->savedSongID = music->requestedSongID;
        music->savedVariation = music->variation;
        music->savedSongName = music->songName;
        music->flags |= MUSIC_FLAG_PUSHING;
        bgm_set_song(0, songID, variation, 500, VOL_LEVEL_FULL);
    }
}

bgm_pop_battle_song()

void bgm_pop_battle_song

(

void

)

Definition at line 402 of file bgm_control.c.

                               {
    MusicControlData* music = gMusicControlData;
 
    if (gGameStatusPtr->demoState == DEMO_STATE_NONE) {
        if (gOverrideFlags & GLOBAL_OVERRIDES_DONT_RESUME_SONG_AFTER_BATTLE) {
            gOverrideFlags &= ~GLOBAL_OVERRIDES_DONT_RESUME_SONG_AFTER_BATTLE;
        } else {
            music->flags |= MUSIC_FLAG_POPPING;
            _bgm_set_song(0, music->savedSongID, music->savedVariation, 0, VOL_LEVEL_FULL);
            snd_ambient_resume(0, 250);
        }
    }
}

sfx_reset_door_sounds()

void sfx_reset_door_sounds

(

void

)

Definition at line 299 of file sfx_control.c.

                                 {
    gCurrentDoorSounds = DOOR_SOUNDS_BASIC;
    gCurrentRoomDoorSounds = DOOR_SOUNDS_BASIC;
}

Referenced by load_map_by_IDs(), and sfx_clear_sounds().

sfx_clear_sounds()

void sfx_clear_sounds

(

void

)

Definition at line 304 of file sfx_control.c.

                            {
    bzero(&wEnvSounds, sizeof(wEnvSounds));
    bzero(&bEnvSounds, sizeof(bEnvSounds));
    gCurrentEnvSounds = wEnvSounds;
    sfx_set_reverb_mode(0);
    sfx_reset_door_sounds();
}

Referenced by load_engine_data(), and state_step_startup().

sfx_clear_env_sounds()

void sfx_clear_env_sounds

(

s16

playSounds

)

Definition at line 313 of file sfx_control.c.

                                          {
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        gCurrentEnvSounds = wEnvSounds;
    } else {
        gCurrentEnvSounds = bEnvSounds;
    }
 
    if (playSounds) {
        SoundInstance* sound = gCurrentEnvSounds;
        s32 i;
 
        for (i = 0; i < MAX_SOUND_INSTANCES; i++, sound++) {
            if (sound->flags & SOUND_INSTANCE_FLAG_ACTIVE) {
                snd_start_sound_with_shift(sound->soundID, sound->volume, sound->pan, sound->pitchShift);
            }
        }
    } else {
        bzero(gCurrentEnvSounds, MAX_SOUND_INSTANCES * sizeof(SoundInstance));
    }
}

Referenced by load_map_by_IDs(), state_step_battle(), state_step_end_battle(), state_step_pause(), and state_step_unpause().

sfx_update_env_sound_params()

void sfx_update_env_sound_params

(

void

)

Definition at line 334 of file sfx_control.c.

                                       {
    SoundInstance* sound = gCurrentEnvSounds;
    u16 volume;
    u16 pan;
    s32 i;
 
    for (i = 0; i < MAX_SOUND_INSTANCES; i++, sound++) {
        if (sound->flags & SOUND_INSTANCE_FLAG_ACTIVE) {
            if (sound->flags & SOUND_INSTANCE_FLAG_POSITION_CHANGED) {
                sfx_get_spatialized_sound_params(sound->pos.x, sound->pos.y, sound->pos.z, &volume, &pan, sound->sourceFlags);
                sound->volume = volume;
                sound->pan = pan;
            }
            snd_adjust_sound_with_shift(sound->soundID, sound->volume, sound->pan, sound->pitchShift);
        }
    }
}

Referenced by step_game_loop().

sfx_set_reverb_mode()

void sfx_set_reverb_mode

(

s32

arg0

)

Definition at line 352 of file sfx_control.c.

                                   {
    snd_set_sfx_reverb_type(mode);
    SfxReverbMode = mode;
}

Referenced by load_map_by_IDs(), sfx_clear_sounds(), state_init_title_screen(), state_step_pause(), and state_step_unpause().

sfx_get_reverb_mode()

s32 sfx_get_reverb_mode

(

void

)

Definition at line 357 of file sfx_control.c.

                              {
    return SfxReverbMode;
}

Referenced by state_step_pause().

sfx_stop_env_sounds()

void sfx_stop_env_sounds

(

void

)

Definition at line 361 of file sfx_control.c.

                               {
    SoundInstance* sound;
    s32 i;
 
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        gCurrentEnvSounds = wEnvSounds;
    } else {
        gCurrentEnvSounds = bEnvSounds;
    }
 
    sound = gCurrentEnvSounds;
    for (i = 0; i < MAX_SOUND_INSTANCES; i++, sound++) {
        if (sound->flags & SOUND_INSTANCE_FLAG_ACTIVE) {
            snd_stop_sound(sound->soundID);
        }
    }
}

Referenced by load_map_by_IDs(), state_step_battle(), state_step_end_battle(), state_step_pause(), and step_game_loop().

sfx_play_sound_looping()

void sfx_play_sound_looping	(	s32	soundID,
		u8	volume,
		u8	pan,
		s16	pitchShift )

Definition at line 392 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)) {
            break;
        }
    }
 
    sound->pan = pan;
    sound->soundID = soundID;
    sound->volume = volume;
    sound->pitchShift = pitchShift;
    sound->flags |= SOUND_INSTANCE_FLAG_ACTIVE;
 
    snd_start_sound_with_shift(soundID, volume, pan, pitchShift);
}

Referenced by sfx_play_sound_with_params().

sfx_register_looping_sound_at_position()

void sfx_register_looping_sound_at_position	(	s32	soundID,
		s32	flags,
		f32	x,
		f32	y,
		f32	z )

Definition at line 411 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)) {
            break;
        }
    }
 
    sound->sourceFlags = flags;
    sound->pos.x = x;
    sound->pos.y = y;
    sound->pos.z = z;
    sound->soundID = soundID;
    sound->flags |= SOUND_INSTANCE_FLAG_ACTIVE | SOUND_INSTANCE_FLAG_POSITION_CHANGED;
 
    sfx_play_sound_at_position(soundID, flags, x, y, z);
}

Referenced by sfx_play_sound_at_position().

sfx_adjust_env_sound_pos()

s32 sfx_adjust_env_sound_pos	(	s32	soundID,
		s32	sourceFlags,
		f32	x,
		f32	y,
		f32	z )

Definition at line 431 of file sfx_control.c.

                                                                                {
    SoundInstance* sound = sfx_get_env_sound_instance(soundID);
 
    if (sound == NULL) {
        return FALSE;
    }
 
    sound->sourceFlags = sourceFlags;
    sound->pos.x = x;
    sound->pos.y = y;
    sound->pos.z = z;
    sound->soundID = soundID;
    sound->flags |= SOUND_INSTANCE_FLAG_ACTIVE | SOUND_INSTANCE_FLAG_POSITION_CHANGED;
    return TRUE;
}

Referenced by SentinelAI_Descend().

sfx_stop_tracking_env_sound_pos()

void sfx_stop_tracking_env_sound_pos	(	s32	soundID,
		s32	keepPlaying )

Definition at line 447 of file sfx_control.c.

                                                                   {
    SoundInstance* sound = sfx_get_env_sound_instance(soundID);
 
    if (sound != NULL) {
        sound->flags &= ~(SOUND_INSTANCE_FLAG_ACTIVE | SOUND_INSTANCE_FLAG_POSITION_CHANGED);
        if (!keepPlaying) {
            snd_stop_sound(sound->soundID);
        }
    }
}

Referenced by func_802BB34C_E2DC7C(), and sfx_stop_sound().

sfx_play_sound_with_params()

void sfx_play_sound_with_params	(	s32	soundID,
		u8	volume,
		u8	pan,
		s16	pitchShift )

Definition at line 458 of file sfx_control.c.

                                                                                {
    AlternatingSoundSet* alternatingSet;
 
    if (gGameStatusPtr->demoState) {
        return;
    }
 
    if (soundID & SOUND_ID_TYPE_FLAG) {
        s32 soundIndex = soundID & 0xFF;
        s32 soundType = (soundID & SOUND_ID_TYPE_MASK) >> 0x1C;
        switch (soundType) {
            case SOUND_TYPE_LOOPING:
                sfx_play_sound_looping(LoopingSounds[soundIndex], volume, pan, pitchShift);
                return;
            case SOUND_TYPE_EXIT_DOOR:
                soundID = OpenCloseSounds[gCurrentDoorSounds][soundIndex];
                break;
            case SOUND_TYPE_ROOM_DOOR:
                soundID = OpenCloseSounds[gCurrentRoomDoorSounds][soundIndex];
                break;
            case SOUND_TYPE_ALTERNATING:
                alternatingSet = &AlternatingSounds[soundIndex];
                if (alternatingSet->curIndex >= alternatingSet->soundCount) {
                    alternatingSet->curIndex = 0;
                }
                soundID = alternatingSet->sounds[alternatingSet->curIndex++];
                break;
        }
    }
    snd_start_sound_with_shift(soundID, volume, pan, pitchShift);
}

Referenced by _update_message(), msg_copy_to_print_buffer(), msg_play_speech_sound(), sfx_play_sound(), sfx_play_sound_at_position(), update(), and update_riding_physics().

sfx_adjust_env_sound_params()

void sfx_adjust_env_sound_params	(	s32	soundID,
		u8	volume,
		u8	pan,
		s16	pitchShift )

Definition at line 490 of file sfx_control.c.

                                                                                 {
    SoundInstance* sound;
 
    if (soundID & SOUND_ID_TYPE_FLAG) {
        sound = sfx_get_env_sound_instance(LoopingSounds[soundID & 0xFFFF]);
        if (sound != NULL) {
            sound->volume = volume;
            sound->pan = pan;
            sound->pitchShift = pitchShift;
        }
    } else {
        snd_adjust_sound_with_shift(soundID, volume, pan, pitchShift);
    }
}

Referenced by update().

sfx_stop_sound()

void sfx_stop_sound

(

s32

soundID

)

Definition at line 505 of file sfx_control.c.

                                 {
    s32 sound = soundID;
 
    if (sound & SOUND_ID_TYPE_FLAG) {
        sfx_stop_tracking_env_sound_pos(LoopingSounds[sound & 0xFFFF], FALSE);
    } else {
        snd_stop_sound(sound);
    }
}

Referenced by action_update_spin(), free(), phys_update_action_state(), pre_battle(), pre_battle(), SentinelAI_LosePlayerInit(), set_action_state(), update(), and update_encounters_pre_battle().

sfx_play_sound()

void sfx_play_sound

(

s32

soundID

)

Definition at line 515 of file sfx_control.c.

                                 {
    sfx_play_sound_with_params(soundID, 0, 0, 0);
}

Referenced by _use_partner_ability(), btl_main_menu_update(), btl_state_update_celebration(), btl_state_update_defeat(), btl_state_update_partner_menu(), btl_state_update_partner_move(), btl_state_update_player_menu(), btl_state_update_player_move(), btl_state_update_run_away(), btl_state_update_select_target(), btl_submenu_moves_update(), btl_submenu_strats_update(), btl_update_ko_status(), calc_player_damage_enemy(), can_open_world_menu(), check_input_open_menus(), check_input_status_bar(), coin_counter_draw_content(), entity_BlueWarpPipe_enter_pipe_init(), entity_Chest_begin_opening(), entity_CymbalPlant_idle(), entity_HeartBlockContent__anim_heal(), entity_HiddenPanel_flip_over(), entity_Padlock_idle(), entity_SaveBlock_show_result_message(), entity_StarBoxLauncher_launch(), entity_WoodenCrate_idle(), filemenu_choose_name_handle_input(), filemenu_main_handle_input(), filemenu_yesno_handle_input(), func_802BB34C_E2DC7C(), func_802BC3E4_E2ED14(), hud_element_update(), inflict_partner_ko(), partner_use_ability(), pause_badges_handle_input(), pause_handle_input(), pause_init(), pause_items_handle_input(), pause_map_handle_input(), pause_partners_handle_input(), pause_spirits_handle_input(), pause_stats_handle_input(), pause_tabs_handle_input(), pause_tutorial_input(), popup_menu_update(), remove_player_buffs(), should_cancel_open_world_menu(), show_popup_menu(), state_step_title_screen(), step_entity_commandlist(), update(), update_encounters_neutral(), update_item_entity_pickup(), update_status_bar(), update_status_damage(), and update_water_block().

sfx_play_sound_at_player()

void sfx_play_sound_at_player	(	s32	soundID,
		s32	arg1 )

Definition at line 519 of file sfx_control.c.

                                                      {
    PlayerStatus* playerStatus = &gPlayerStatus;
 
    sfx_play_sound_at_position(soundID, flags, playerStatus->pos.x, playerStatus->pos.y, playerStatus->pos.z);
}

Referenced by action_hammer_end_swing(), action_hammer_play_hit_fx(), action_update_hammer(), action_update_hit_lava(), action_update_jump(), action_update_land(), action_update_parasol(), action_update_peach_land(), action_update_sliding(), action_update_spin(), action_update_spin_jump(), action_update_tornado_jump(), action_update_use_munchlesia(), action_update_use_tweester(), appendGfx_pulse_stone_icon(), ispy_notification_update(), phys_player_land(), player_jump(), and try_player_footstep_sounds().

sfx_play_sound_at_npc()

void sfx_play_sound_at_npc	(	s32	soundID,
		s32	arg1,
		s32	npcID )

Definition at line 525 of file sfx_control.c.

                                                              {
    Npc* npc = get_npc_safe(npcID);
 
    if (npc != NULL) {
        sfx_play_sound_at_position(soundID, flags, npc->pos.x, npc->pos.y, npc->pos.z);
    }
}

Referenced by update_riding_physics().

sfx_play_sound_at_position()

void sfx_play_sound_at_position	(	s32	soundID,
		s32	flags,
		f32	posX,
		f32	posY,
		f32	posZ )

Definition at line 533 of file sfx_control.c.

                                                                                      {
    if ((soundID & (SOUND_ID_TYPE_FLAG | SOUND_ID_TYPE_MASK)) == (SOUND_ID_TYPE_FLAG | SOUND_TYPE_LOOPING)) {
        s32 id = LoopingSounds[soundID & 0xFFFF];
 
        sfx_register_looping_sound_at_position(id, flags, posX, posY, posZ);
    } else {
        s16 volume;
        s16 pan;
 
        sfx_get_spatialized_sound_params(posX, posY, posZ, &volume, &pan, flags);
        if (volume >= 0) {
            sfx_play_sound_with_params(soundID, volume, pan, 0);
        }
    }
}

sfx_get_spatialized_sound_params()

void sfx_get_spatialized_sound_params	(	f32	x,
		f32	y,
		f32	z,
		s16 *	volume,
		s16 *	pan,
		s32	flags )

Definition at line 549 of file sfx_control.c.

                                                                                             {
    u32 paramFlags;
    u32 spaceMode;
 
    paramFlags = flags & SOUND_SPACE_PARAMS_MASK;
 
    do {
        spaceMode = flags & SOUND_SPACE_MODE_MASK;
    } while (0); // required to match
 
    switch (spaceMode) {
        case SOUND_SPACE_DEFAULT:
            sfx_compute_spatialized_sound_params_ignore_depth(x, y, z, volume, pan);
            break;
        case SOUND_SPACE_WITH_DEPTH:
            sfx_compute_spatialized_sound_params_with_depth(x, y, z, volume, pan);
            break;
        case SOUND_SPACE_FULL:
            sfx_compute_spatialized_sound_params_full(x, y, z, volume, pan, paramFlags);
            break;
    }
 
    if (paramFlags & SOUND_PARAM_MUTE) {
        *volume = 0;
    } else if (paramFlags & SOUND_PARAM_QUIET) {
        if (*volume < 80) {
            *volume = 80;
        }
    } else if (paramFlags & SOUND_PARAM_MORE_QUIET) {
        if (*volume < 60) {
            *volume = 60;
        }
    } else if (paramFlags & SOUND_PARAM_MOST_QUIET) {
        if (*volume < 40) {
            *volume = 40;
        }
    }
 
    if (*pan < 1) {
        *pan = 1;
    }
    if (*pan > AU_PAN_MAX) {
        *pan = AU_PAN_MAX;
    }
}

Referenced by sfx_play_sound_at_position(), and sfx_update_env_sound_params().

sfx_compute_spatialized_sound_params_ignore_depth()

void sfx_compute_spatialized_sound_params_ignore_depth	(	f32	x,
		f32	y,
		f32	z,
		s16 *	volume,
		s16 *	pan )

Definition at line 595 of file sfx_control.c.

                                                                                                   {
    s32 screenX, screenY, screenZ;
 
    get_screen_coords(gCurrentCameraID, x, y, z, &screenX, &screenY, &screenZ);
 
    if (screenX > 3000 || screenX < -3000 || screenY > 3000 || screenY < -3000) {
        *volume = 1;
        *pan = 0;
        return;
    }
 
    *volume = 127;
    if (screenX < 0) {
        *volume = (screenX * 0.3f) + 127.0f;
        screenX = 0;
    }
    if (screenX > SCREEN_WIDTH) {
        *volume = 127.0f - ((screenX - SCREEN_WIDTH) * 0.3f);
        screenX = SCREEN_WIDTH;
    }
 
    if (*volume < 1) {
        *volume = 1;
    }
 
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        // 25/75 at screen edge
        *pan = (screenX * 0.2f) + 32.0f;
    } else {
        f32 temp_f20 = ((screenX * 127.0) / SCREEN_WIDTH) - 64.0;
        *pan = (s32) (temp_f20 * sin_rad(DEG_TO_RAD(fabs(temp_f20) * 90.0 / 64.0))) + 64;
    }
}

Referenced by sfx_get_spatialized_sound_params().

sfx_compute_spatialized_sound_params_with_depth()

void sfx_compute_spatialized_sound_params_with_depth	(	f32	x,
		f32	y,
		f32	z,
		s16 *	volume,
		s16 *	pan )

Definition at line 629 of file sfx_control.c.

                                                                                                 {
    Camera* camera = &gCameras[gCurrentCameraID];
    s32 screenX, screenY, screenZ;
    f32 depth;
 
    get_screen_coords(gCurrentCameraID, x, y, z, &screenX, &screenY, &screenZ);
 
    if (screenX > 3000 || screenX < -3000 || screenY > 3000 || screenY < -3000) {
        *volume = 1;
        *pan = 0;
        return;
    }
 
    *volume = 127;
    if (screenX < 0) {
        *volume = (screenX * 0.3f) + 127.0f;
        screenX = 0;
    }
    if (camera->viewportW < screenX) {
        *volume = 127.0f - ((screenX - camera->viewportW) * 0.3f);
        screenX = camera->viewportW;
    }
 
    depth = fabsf(5000 - screenZ);
    if (depth > 1000.0f) {
        depth = 1000.0f;
    }
 
    *volume = *volume * (1500.0f - depth) * 0.001f;
    if (*volume > 127) {
        *volume = 127;
    }
    if (*volume < 1) {
        *volume = 1;
    }
 
    *pan = ((screenX * 64.0f) / camera->viewportW) + 32.0f;
}

Referenced by sfx_get_spatialized_sound_params().

sfx_compute_spatialized_sound_params_full()

void sfx_compute_spatialized_sound_params_full	(	f32	x,
		f32	y,
		f32	z,
		s16 *	volume,
		s16 *	pan,
		s32	flags )

Definition at line 217 of file sfx_control.c.

                                                                                                      {
    s32 screenX, screenY, screenZ;
    f32 volAmtOffsetX, volAmtDeltaY, volAmtDepth;
    f32 offsetX, offsetY, depth;
    f32 volTemp, panTemp;
    s32 phi_v0;
 
    get_screen_coords(gCurrentCameraID, x, y, z, &screenX, &screenY, &screenZ);
 
    if (screenX > 5000 || screenX < -5000 || screenY > 5000 || screenY < -5000) {
        *volume = -1;
        *pan = 0;
        return;
    }
 
    if (flags & SOUND_PARAM_CLIP_OFFSCREEN_ANY) {
        if (screenX < -30 || screenX > SCREEN_WIDTH + 30 || screenY < -30 || screenY > SCREEN_HEIGHT + 30) {
            *volume = -1;
            *pan = 0;
            return;
        }
    } else if (flags & SOUND_PARAM_CLIP_OFFSCREEN_X) {
        if (screenX < -30 || screenX > SCREEN_WIDTH + 30) {
            *volume = -1;
            *pan = 0;
            return;
        }
    } else if (flags & SOUND_PARAM_CLIP_OFFSCREEN_Y) {
        if (screenY < -30 || screenY > SCREEN_HEIGHT + 30) {
            *volume = -1;
            *pan = 0;
            return;
        }
    }
 
    offsetX = abs((SCREEN_WIDTH / 2) - screenX) - 145;
    if (offsetX < 0.0) {
        offsetX = 0.0f;
    }
 
    volAmtOffsetX = update_lerp(EASING_LINEAR, 1.0f, 0.0f, offsetX, 200);
    if (volAmtOffsetX < 0.0) {
        volAmtOffsetX = 0.0f;
    }
 
    offsetY = abs((SCREEN_HEIGHT / 2) - screenY) - 105;
    if (offsetY < 0.0) {
        offsetY = 0.0f;
    }
 
    volAmtDeltaY = update_lerp(EASING_LINEAR, 1.0f, 0.0f, offsetY, 130);
    if (volAmtDeltaY < 0.0) {
        volAmtDeltaY = 0.0f;
    }
 
    depth = screenZ - 5550.0;
    if (depth < 0.0) {
        depth = 0.0f;
    }
 
    volAmtDepth = update_lerp(EASING_LINEAR, 1.0f, 0.0f, depth, 250);
    if (volAmtDepth < 0.0) {
        volAmtDepth = 0.0f;
    }
 
    volTemp = (volAmtOffsetX * volAmtDeltaY * volAmtDepth) * 127.0;
    if (volTemp < 15.0) {
        volTemp = 15.0f;
    } else if (volTemp > 127.0) {
        volTemp = 127.0f;
    }
    *volume = volTemp;
 
    panTemp = (((f32) screenX - (SCREEN_WIDTH / 2.0)) / 3.6) + 64.0;
    if (panTemp < 1.0) {
        panTemp = 1.0f;
    } else if (panTemp > 127.0) {
        panTemp = 127.0f;
    }
    *pan = panTemp;
}

Referenced by sfx_get_spatialized_sound_params().