engine.c File Reference

Go to the source code of this file.

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

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

Functions
void	au_release_voice (u8 index)
void	au_engine_init (s32 outputRate)
void	au_update_clients_for_audio_frame (void)
	Called exactly once per audio frame (every 5.75ms at 32kHz).
void	au_update_clients_for_video_frame (void)
	this is called once per video frame update (50 or 60 times per second)
void	au_syn_begin_audio_frame (AuGlobals *globals)
void	au_reset_nonfree_voice (AuVoice *voice, u8 index)
void	au_reset_voice (AuVoice *voice, u8 voiceIdx)
f32	au_compute_pitch_ratio (s32 tuning)
	Converts a linear pitch value (in cents) into a frequency ratio suitable for adjusting playback speed.
void	au_fade_init (Fade *fade, s32 time, s32 startValue, s32 endValue)
void	au_fade_clear (Fade *fade)
void	au_fade_update (Fade *fade)
void	au_fade_set_volume (u8 busID, u16 volume, s32 busVolume)
void	au_fade_flush (Fade *fade)
void	au_fade_set_envelope (Fade *fade, s16 value)
void	au_fade_calc_envelope (Fade *fade, u32 duration, s32 target)
void	au_fade_update_envelope (Fade *fade)
Instrument *	au_get_instrument (AuGlobals *globals, BankSetIndex bank, s32 patch, EnvelopeData *envData)
	Note that bank is supplied as BankSetIndex and not BankSet, which means it will be used to perform a raw access into AuGlobals::bankSets.
void	au_get_bgm_player_and_file (u32 playerIndex, BGMHeader **outFile, BGMPlayer **outPlayer)
void	au_get_bgm_player (u32 playerIndex, BGMPlayer **outPlayer)
AuResult	au_load_song_files (u32 songID, BGMHeader *bgmFile, BGMPlayer *player)
AuResult	au_reload_song_files (s32 songID, BGMHeader *bgmFile)
BGMPlayer *	au_get_snapshot_by_index (s32 index)
AuResult	au_ambient_load (u32 ambSoundID)
BGMPlayer *	au_get_client_by_priority (u8 priority)
void	au_load_INIT (AuGlobals *globals, s32 romAddr, ALHeap *heap)
AuResult	au_fetch_SBN_file (u32 fileIdx, AuFileFormat format, SBNFileEntry *outEntry)
void	au_load_PER (AuGlobals *globals, s32 romAddr)
void	au_load_PRG (AuGlobals *globals, s32 romAddr)
s32	au_load_BGM (s32 arg0)
InstrumentBank *	au_get_BK_instruments (BankSet bankSet, u32 bankIndex)
BKFileBuffer *	au_load_BK_to_bank (s32 bkFileOffset, BKFileBuffer *bkFile, s32 bankIndex, BankSet bankSet)
	Loads an instrument bank file from ROM, allocates memory if needed, and sets up instrument pointers.
void	au_swizzle_BK_instruments (s32 bkFileOffset, BKFileBuffer *file, InstrumentBank instruments, u32 instrumentCount, u8 useDma)
	Fixes up (swizzles) instrument pointers in a loaded bank, converting file-relative offsets to valid RAM pointers.
BKFileBuffer *	au_load_static_BK_to_bank (s32 *inAddr, void *outAddr, s32 bankIndex, BankSet bankSet)
	UNUSED Loads an instrument bank file from ROM to a given buffer (allocates if needed), and sets up instrument pointers.
s32	au_load_aux_bank (s32 bkFileOffset, s32 bankIndex)
void	au_clear_instrument_group (s32 bankIndex, BankSet bankSet)
	unused. resets all instruments in (bankIndex, bankSet) to default
void	au_set_bus_volume_level (s32 soundTypeFlags, u32 volPreset)
s32	au_set_reverb_type (s32 soundTypeFlags, s32 reverbType)
void	au_sync_channel_delay_enabled (u32 bMonoSound)
void	au_read_rom (s32 romAddr, void *buffer, u32 size)
void	au_memset (void *dst, s32 size, u8 value)
void	au_copy_bytes (s8 *src, s8 *dest, s32 size)
void	au_copy_words (void *src, void *dst, s32 size)

Variables
AuCallback	BeginSoundUpdateCallback
BGMPlayer *	gBGMPlayerA
BGMPlayer *	gBGMPlayerB
BGMPlayer *	gBGMPlayerC
SoundManager *	gSoundManager
AuGlobals *	gSoundGlobals
AmbienceManager *	gAuAmbienceManager
u16	PerceptualVolumeLevels [9]
	Volume steps use squared values so each level represents linear power increase, matching loudness perception.
u8	EnvelopePressDefault []
u8	EnvelopeReleaseDefault []
f32	AlTuneScaling []

Macro Definition Documentation

SBN_ROM_OFFSET

#define SBN_ROM_OFFSET   0xF00000

Definition at line 30 of file engine.c.

Referenced by au_engine_init().

TUNE_SCALING_ARR_AMPLIFY_FINE

#define TUNE_SCALING_ARR_AMPLIFY_FINE   0

Definition at line 405 of file engine.c.

Referenced by au_compute_pitch_ratio().

TUNE_SCALING_ARR_AMPLIFY_COARSE

#define TUNE_SCALING_ARR_AMPLIFY_COARSE   128

Definition at line 406 of file engine.c.

Referenced by au_compute_pitch_ratio().

TUNE_SCALING_ARR_ATTENUATE_FINE

#define TUNE_SCALING_ARR_ATTENUATE_FINE   160

Definition at line 407 of file engine.c.

Referenced by au_compute_pitch_ratio().

TUNE_SCALING_ARR_ATTENUATE_COARSE

#define TUNE_SCALING_ARR_ATTENUATE_COARSE   288

Definition at line 408 of file engine.c.

Referenced by au_compute_pitch_ratio().

SBN_EXTRA_LOOKUP

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

Definition at line 663 of file engine.c.

Referenced by au_ambient_load().

AL_HEADER_SIG_BK

#define AL_HEADER_SIG_BK   0x424B

Definition at line 938 of file engine.c.

Referenced by au_load_BK_to_bank(), and au_load_static_BK_to_bank().

AL_HEADER_SIG_CR

#define AL_HEADER_SIG_CR   0x4352

Definition at line 939 of file engine.c.

Referenced by au_load_BK_to_bank(), and au_load_static_BK_to_bank().

AL_HEADER_SIG_DR

#define AL_HEADER_SIG_DR   0x4452

Definition at line 940 of file engine.c.

Referenced by au_load_BK_to_bank().

AL_HEADER_SIG_SR

#define AL_HEADER_SIG_SR   0x5352

Definition at line 941 of file engine.c.

Referenced by au_load_BK_to_bank().

Enumeration Type Documentation

BKParseState

enum BKParseState

Enumerator
BK_READ_DONE
BK_READ_FETCH_HEADER
BK_READ_FETCH_DATA
BK_READ_SWIZZLE
BK_READ_PROCESS_CR
BK_READ_SWIZZLE_CR
BK_READ_PROCESS_DR
BK_READ_UNK_DR
BK_READ_PROCESS_SR
BK_READ_UNK_SR

Definition at line 925 of file engine.c.

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

Function Documentation

au_release_voice()

void au_release_voice

(

u8

index

)

Definition at line 33 of file engine.c.

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

Referenced by au_pull_voice().

au_engine_init()

void au_engine_init

(

s32

outputRate

)

Definition at line 40 of file engine.c.

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

Referenced by create_audio_system().

au_update_clients_for_audio_frame()

void au_update_clients_for_audio_frame

(

void

)

Called exactly once per audio frame (every 5.75ms at 32kHz).

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

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

Definition at line 214 of file engine.c.

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

Referenced by alAudioFrame().

au_update_clients_for_video_frame()

void au_update_clients_for_video_frame

(

void

)

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

Definition at line 290 of file engine.c.

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

Referenced by alAudioFrame().

au_syn_begin_audio_frame()

void au_syn_begin_audio_frame

(

AuGlobals *

globals

)

Definition at line 312 of file engine.c.

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

Referenced by au_update_clients_for_audio_frame().

au_reset_nonfree_voice()

void au_reset_nonfree_voice	(	AuVoice *	voice,
		u8	index )

Definition at line 388 of file engine.c.

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

au_reset_voice()

void au_reset_voice	(	AuVoice *	voice,
		u8	voiceIdx )

Definition at line 397 of file engine.c.

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

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

au_compute_pitch_ratio()

f32 au_compute_pitch_ratio

(

s32

tuning

)

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

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

Parameters

tuning

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

Returns

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

Definition at line 410 of file engine.c.

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

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

au_fade_init()

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

Definition at line 421 of file engine.c.

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

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

au_fade_clear()

void au_fade_clear

(

Fade *

fade

)

Definition at line 436 of file engine.c.

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

au_fade_update()

void au_fade_update

(

Fade *

fade

)

Definition at line 442 of file engine.c.

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

Referenced by au_update_clients_for_audio_frame().

au_fade_set_volume()

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

Definition at line 457 of file engine.c.

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

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

au_fade_flush()

void au_fade_flush

(

Fade *

fade

)

Definition at line 461 of file engine.c.

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

Referenced by au_set_bus_volume_level().

au_fade_set_envelope()

void au_fade_set_envelope	(	Fade *	fade,
		s16	value )

Definition at line 469 of file engine.c.

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

Referenced by au_bgm_player_init().

au_fade_calc_envelope()

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

Definition at line 476 of file engine.c.

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

Referenced by au_bgm_adjust_volume().

au_fade_update_envelope()

void au_fade_update_envelope

(

Fade *

fade

)

Definition at line 493 of file engine.c.

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

Referenced by au_update_clients_for_audio_frame().

au_get_instrument()

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

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

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

Definition at line 506 of file engine.c.

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

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

au_get_bgm_player_and_file()

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

Definition at line 522 of file engine.c.

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

Referenced by snd_song_load().

au_get_bgm_player()

void au_get_bgm_player	(	u32	playerIndex,
		BGMPlayer **	outPlayer )

Definition at line 545 of file engine.c.

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

au_load_song_files()

AuResult au_load_song_files	(	u32	songID,
		BGMHeader *	bgmFile,
		BGMPlayer *	player )

Definition at line 562 of file engine.c.

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

Referenced by snd_song_load().

au_reload_song_files()

AuResult au_reload_song_files	(	s32	songID,
		BGMHeader *	bgmFile )

Definition at line 618 of file engine.c.

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

Referenced by au_bgm_process_resume().

au_get_snapshot_by_index()

BGMPlayer * au_get_snapshot_by_index

(

s32

index

)

Definition at line 656 of file engine.c.

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

Referenced by au_bgm_process_resume(), and au_bgm_process_suspend().

au_ambient_load()

AuResult au_ambient_load

(

u32

ambSoundID

)

Definition at line 665 of file engine.c.

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

Referenced by snd_load_ambient().

au_get_client_by_priority()

BGMPlayer * au_get_client_by_priority

(

u8

priority

)

Definition at line 732 of file engine.c.

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

Referenced by au_bgm_process_resume().

au_load_INIT()

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

Definition at line 745 of file engine.c.

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

Referenced by au_engine_init().

au_fetch_SBN_file()

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

Definition at line 795 of file engine.c.

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

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

au_load_PER()

void au_load_PER	(	AuGlobals *	globals,
		s32	romAddr )

Definition at line 817 of file engine.c.

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

Referenced by au_engine_init().

au_load_PRG()

void au_load_PRG	(	AuGlobals *	globals,
		s32	romAddr )

Definition at line 836 of file engine.c.

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

Referenced by au_engine_init().

au_load_BGM()

s32 au_load_BGM

(

s32

arg0

)

Definition at line 860 of file engine.c.

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

au_get_BK_instruments()

InstrumentBank * au_get_BK_instruments	(	BankSet	bankSet,
		u32	bankIndex )

Definition at line 894 of file engine.c.

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

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

au_load_BK_to_bank()

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

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

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

Definition at line 946 of file engine.c.

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

Referenced by au_load_aux_bank(), and au_load_BK_headers().

au_swizzle_BK_instruments()

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

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

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

Definition at line 1041 of file engine.c.

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

Referenced by au_load_BK_to_bank(), and au_load_static_BK_to_bank().

au_load_static_BK_to_bank()

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

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

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

Definition at line 1078 of file engine.c.

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

au_load_aux_bank()

s32 au_load_aux_bank	(	s32	bkFileOffset,
		s32	bankIndex )

Definition at line 1148 of file engine.c.

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

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

au_clear_instrument_group()

void au_clear_instrument_group	(	s32	bankIndex,
		BankSet	bankSet )

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

Definition at line 1154 of file engine.c.

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

au_set_bus_volume_level()

void au_set_bus_volume_level	(	s32	soundTypeFlags,
		u32	volPreset )

Definition at line 1167 of file engine.c.

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

Referenced by snd_set_bgm_volume(), and snd_set_sfx_volume().

au_set_reverb_type()

s32 au_set_reverb_type	(	s32	soundTypeFlags,
		s32	reverbType )

Definition at line 1183 of file engine.c.

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

Referenced by snd_set_sfx_reverb_type().

au_sync_channel_delay_enabled()

void au_sync_channel_delay_enabled

(

u32

bMonoSound

)

Definition at line 1190 of file engine.c.

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

Referenced by snd_set_mono(), and snd_set_stereo().

au_read_rom()

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

Definition at line 1207 of file engine.c.

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

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

au_memset()

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

Definition at line 1224 of file engine.c.

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

Referenced by au_mseq_manager_init(), and au_mseq_play_sequence().

au_copy_bytes()

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

Definition at line 1263 of file engine.c.

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

au_copy_words()

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

Definition at line 1271 of file engine.c.

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

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

Variable Documentation

BeginSoundUpdateCallback

AuCallback BeginSoundUpdateCallback

Definition at line 5 of file engine.c.

Referenced by au_update_clients_for_video_frame().

gBGMPlayerA

BGMPlayer* gBGMPlayerA

Definition at line 6 of file engine.c.

Referenced by au_bgm_get_player_with_song_name(), au_bgm_stop_all(), au_engine_init(), au_get_bgm_player(), au_get_bgm_player_and_file(), au_get_client_by_priority(), au_set_bus_volume_level(), au_update_clients_for_audio_frame(), au_update_clients_for_video_frame(), snd_bgm_enqueue_legacy_command(), and snd_song_get_playing_info().

gBGMPlayerB

BGMPlayer* gBGMPlayerB

Definition at line 7 of file engine.c.

Referenced by au_bgm_get_player_with_song_name(), au_bgm_stop_all(), au_engine_init(), au_get_bgm_player(), au_get_bgm_player_and_file(), au_get_client_by_priority(), au_set_bus_volume_level(), au_update_clients_for_audio_frame(), au_update_clients_for_video_frame(), snd_bgm_enqueue_legacy_command(), and snd_song_get_playing_info().

gBGMPlayerC

BGMPlayer* gBGMPlayerC

Definition at line 8 of file engine.c.

Referenced by au_engine_init().

gSoundManager

SoundManager* gSoundManager

Definition at line 9 of file engine.c.

Referenced by au_engine_init(), au_get_client_by_priority(), au_set_bus_volume_level(), au_set_reverb_type(), au_update_clients_for_audio_frame(), au_update_clients_for_video_frame(), snd_adjust_sound(), snd_adjust_sound_with_shift(), snd_disable_sfx(), snd_enable_sfx(), snd_reset(), snd_start_sound(), snd_start_sound_raw(), snd_start_sound_with_shift(), and snd_stop_sound().

gSoundGlobals

AuGlobals* gSoundGlobals

Definition at line 10 of file engine.c.

Referenced by au_ambient_load(), au_clear_instrument_group(), au_engine_init(), au_fetch_SBN_file(), au_get_bgm_player_and_file(), au_get_BK_instruments(), au_get_snapshot_by_index(), au_load_aux_bank(), au_load_BGM(), au_load_song_files(), au_release_voice(), au_reload_song_files(), au_swizzle_BK_instruments(), au_sync_channel_delay_enabled(), au_update_clients_for_audio_frame(), au_update_clients_for_video_frame(), snd_register_callback(), snd_song_clear_music_events(), snd_song_flush_music_events(), snd_song_get_playing_info(), snd_song_poll_music_events(), and snd_song_trigger_music_event().

gAuAmbienceManager

AmbienceManager* gAuAmbienceManager

Definition at line 11 of file engine.c.

Referenced by au_ambient_load(), au_engine_init(), au_mseq_check_player_index(), au_mseq_check_stopped(), au_mseq_load_tracks_fade(), au_mseq_pause(), au_mseq_resume(), au_mseq_set_disabled(), au_mseq_set_volume(), au_mseq_start(), au_mseq_stop_quick(), au_mseq_stop_slow(), and au_update_clients_for_audio_frame().

PerceptualVolumeLevels

u16 PerceptualVolumeLevels[9]

extern

Volume steps use squared values so each level represents linear power increase, matching loudness perception.

This makes each step sound evenly spaced.

Definition at line 299 of file sfx_player.c.

                               {
    [VOL_LEVEL_MUTE] 0, // 0.0 %
    [VOL_LEVEL_1] AU_MAX_BUS_VOLUME * SQ(0.125), //  1.5625 %
    [VOL_LEVEL_2] AU_MAX_BUS_VOLUME * SQ(0.250), //  6.25 %
    [VOL_LEVEL_3] AU_MAX_BUS_VOLUME * SQ(0.375), // 14.0625 %
    [VOL_LEVEL_4] AU_MAX_BUS_VOLUME * SQ(0.500), // 25.0 %
    [VOL_LEVEL_5] AU_MAX_BUS_VOLUME * SQ(0.625), // 39.0625 %
    [VOL_LEVEL_6] AU_MAX_BUS_VOLUME * SQ(0.750), // 56.25 %
    [VOL_LEVEL_7] AU_MAX_BUS_VOLUME * SQ(0.875), // 76.5625 %
    [VOL_LEVEL_FULL] AU_MAX_BUS_VOLUME, // 100.0 %
};

Referenced by au_set_bus_volume_level().

EnvelopePressDefault

u8 EnvelopePressDefault[]

extern

Definition at line 317 of file sfx_player.c.

                            {
    ENV_TIME_280MS, 127,
    ENV_CMD_END, 0
};

Referenced by au_get_instrument().

EnvelopeReleaseDefault

u8 EnvelopeReleaseDefault[]

extern

Definition at line 322 of file sfx_player.c.

                              {
    ENV_TIME_550MS, 0,
    ENV_CMD_END, 0
};

AlTuneScaling

f32 AlTuneScaling[]

extern

Definition at line 378 of file sfx_player.c.

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

Referenced by au_compute_pitch_ratio().