From 84d869675df19366c8c9e8a0c4ef9e5d6183db62 Mon Sep 17 00:00:00 2001 From: roeming Date: Thu, 3 Jul 2025 16:41:27 -0400 Subject: [PATCH 1/6] link audioconst --- configure.py | 30 ++++++++++++++------- include/jaudio_NES/audioconst.h | 28 +++++++++++++++++++ src/static/jaudio_NES/internal/audioconst.c | 10 +++++++ 3 files changed, 58 insertions(+), 10 deletions(-) create mode 100644 src/static/jaudio_NES/internal/audioconst.c diff --git a/configure.py b/configure.py index 47b8ff67..ac2f122b 100644 --- a/configure.py +++ b/configure.py @@ -356,7 +356,8 @@ config.libs = [ "progress_category": "library", "src_dir": "src/static", "objects": [ - Object(Matching, "libforest/emu64/emu64.c", extra_cflags=["-lang=c++", "-O4,p", "-inline auto"]), + Object(Matching, "libforest/emu64/emu64.c", + extra_cflags=["-lang=c++", "-O4,p", "-inline auto"]), Object(Matching, "libforest/osreport.c"), Object(Matching, "libforest/fault.c"), Object(Matching, "libforest/ReconfigBATs.c"), @@ -420,7 +421,9 @@ config.libs = [ Object(Matching, "libultra/gu/scale.c"), Object(Matching, "libultra/sendmesg.c"), Object(Matching, "libultra/setthreadpri.c"), - Object(Matching, "libultra/settimer.c", extra_cflags=["-O0", "-opt schedule", "-opt peep"]), # no clue why this file has these flags, but they're necessary + # no clue why this file has these flags, but they're necessary + Object(Matching, "libultra/settimer.c", + extra_cflags=["-O0", "-opt schedule", "-opt peep"]), Object(Matching, "libultra/shutdown.c"), Object(Matching, "libultra/gu/sins.c"), Object(Matching, "libultra/startthread.c"), @@ -562,7 +565,8 @@ config.libs = [ DolphinLib( "OdemuExi2", [ - Object(Matching, "dolphin/OdemuExi2/DebuggerDriver.c", extra_cflags=["-inline deferred"]), + Object(Matching, "dolphin/OdemuExi2/DebuggerDriver.c", + extra_cflags=["-inline deferred"]), ], ), DolphinLib( @@ -712,7 +716,8 @@ config.libs = [ "objects": [ Object(Matching, "jaudio_NES/game/audioheaders.c"), Object(Matching, "jaudio_NES/game/dummyprobe.c"), - Object(Matching, "jaudio_NES/game/emusound.c", extra_cflags=["-O4,s", "-fp_contract on", "-func_align 32", "-vector on"]), + Object(Matching, "jaudio_NES/game/emusound.c", + extra_cflags=["-O4,s", "-fp_contract on", "-func_align 32", "-vector on"]), Object(Matching, "jaudio_NES/game/game64.c"), Object(Matching, "jaudio_NES/game/kappa.c"), Object(Matching, "jaudio_NES/game/melody.c"), @@ -758,10 +763,11 @@ config.libs = [ Object(Matching, "jaudio_NES/internal/sub_sys.c"), Object(Matching, "jaudio_NES/internal/track.c"), Object(Matching, "jaudio_NES/internal/aramcall.c"), - Object(NonMatching, "jaudio_NES/internal/audioconst.c"), + Object(Matching, "jaudio_NES/internal/audioconst.c"), Object(NonMatching, "jaudio_NES/internal/audiotable.c"), Object(NonMatching, "jaudio_NES/internal/audiowork.c"), - Object(Matching, "jaudio_NES/internal/bankdrv.c", extra_cflags=["-pragma \"scheduling 7400\""]), + Object(Matching, "jaudio_NES/internal/bankdrv.c", + extra_cflags=["-pragma \"scheduling 7400\""]), Object(Matching, "jaudio_NES/internal/bankread.c"), Object(Matching, "jaudio_NES/internal/centcalc.c"), Object(Matching, "jaudio_NES/internal/channel.c"), @@ -773,13 +779,16 @@ config.libs = [ Object(Matching, "jaudio_NES/internal/dsp_GBAKey.c"), Object(Equivalent, "jaudio_NES/internal/dspdriver.c"), Object(Matching, "jaudio_NES/internal/dspinterface.c"), - Object(Matching, "jaudio_NES/internal/effect.c", extra_cflags=["-pragma \"scheduling 7400\""]), + Object(Matching, "jaudio_NES/internal/effect.c", + extra_cflags=["-pragma \"scheduling 7400\""]), Object(Matching, "jaudio_NES/internal/fat.c"), Object(Matching, "jaudio_NES/internal/fxinterface.c"), Object(Matching, "jaudio_NES/internal/heapctrl.c"), Object(Matching, "jaudio_NES/internal/ipldec.c"), - Object(Matching, "jaudio_NES/internal/ja_calc.c", extra_cflags=["-sym off"]), - Object(NonMatching, "jaudio_NES/internal/jammain_2.c", extra_cflags=["-sym on"]), + Object(Matching, "jaudio_NES/internal/ja_calc.c", + extra_cflags=["-sym off"]), + Object(NonMatching, "jaudio_NES/internal/jammain_2.c", + extra_cflags=["-sym on"]), Object(Matching, "jaudio_NES/internal/jamosc.c"), Object(NonMatching, "jaudio_NES/internal/memory.c"), Object(Matching, "jaudio_NES/internal/midplay.c"), @@ -788,7 +797,8 @@ config.libs = [ Object(NonMatching, "jaudio_NES/internal/rate.c"), Object(NonMatching, "jaudio_NES/internal/rspsim.c"), Object(Matching, "jaudio_NES/internal/seqsetup.c"), - Object(Equivalent, "jaudio_NES/internal/system.c", extra_cflags=["-pragma \"scheduling 7400\""]), + Object(Equivalent, "jaudio_NES/internal/system.c", + extra_cflags=["-pragma \"scheduling 7400\""]), Object(Matching, "jaudio_NES/internal/tables.c"), Object(Matching, "jaudio_NES/internal/waveread.c"), ], diff --git a/include/jaudio_NES/audioconst.h b/include/jaudio_NES/audioconst.h index d131aec1..a0949853 100644 --- a/include/jaudio_NES/audioconst.h +++ b/include/jaudio_NES/audioconst.h @@ -4,6 +4,34 @@ #include "types.h" #include "jaudio_NES/audiostruct.h" +extern fxconfig NA_HALL_DELAY; + +typedef struct _na_spec_config { + u32 _00; + u8 _04; + u8 _05; + u8 _06; + u8 _07; + u8 _08; + u8 _09; + u8 _0A; + u8 _0B; + fxconfig* _0C; + u16 _10; + u16 _12; + u16 _14; + u16 _16; + s32 _18; + s32 _1C; + s32 _20; + s32 _24; + s32 _28; + s32 _2C; + s32 _30; + s32 _34; +} na_spec_config; + +extern na_spec_config NA_SPEC_CONFIG[1]; typedef struct ALGlobalsConst_ { s8 maxChan; s16 timeBase; diff --git a/src/static/jaudio_NES/internal/audioconst.c b/src/static/jaudio_NES/internal/audioconst.c new file mode 100644 index 00000000..9b95db62 --- /dev/null +++ b/src/static/jaudio_NES/internal/audioconst.c @@ -0,0 +1,10 @@ +#include "jaudio_NES/audioconst.h" + +fxconfig NA_HALL_DELAY = { 1, 0x20, 0x4500, 0x14, 0x1100, 0x7fff, 0, 0, 0xff, 0, 0 }; + +na_spec_config NA_SPEC_CONFIG[1] = { { 0xbb80, 1, 0x18, 5, 0, 0, 1, 0, 0, &NA_HALL_DELAY, + 0x400, 0x200, 0x07fff, 0, 0x680, 0x4500, 0, 0x7800, 0x2300, 0 } }; + +ALGlobalsConst AGC = { + 0x18, 0x30, 0x70000, 0x38000, 0x28000, +}; From 1bd226dee13c6f831447de16a9328cb0d8e27e83 Mon Sep 17 00:00:00 2001 From: roeming Date: Thu, 3 Jul 2025 16:42:02 -0400 Subject: [PATCH 2/6] fix build --- include/jaudio_NES/audiostruct.h | 235 ++++++++++++++++--------------- 1 file changed, 125 insertions(+), 110 deletions(-) diff --git a/include/jaudio_NES/audiostruct.h b/include/jaudio_NES/audiostruct.h index 8dc8f80d..dd3b1bbb 100644 --- a/include/jaudio_NES/audiostruct.h +++ b/include/jaudio_NES/audiostruct.h @@ -450,11 +450,11 @@ typedef struct macro_ { typedef union subtrack_updates { struct { - /* 0x01 */ u8 frequency_scale : 1; - /* 0x01 */ u8 volume : 1; - /* 0x01 */ u8 pan : 1; - } flags; - /* 0x01 */ u8 as_byte; + /* 0x01 */ u8 frequency_scale : 1; + /* 0x01 */ u8 volume : 1; + /* 0x01 */ u8 pan : 1; + } flags; + /* 0x01 */ u8 as_byte; } subtrack_updates; /* SubTrack struct */ @@ -761,6 +761,7 @@ typedef struct SwHeap_ { /* TODO: this needs a better name, I don't see any functions which reference it */ /* sizeof(ALHeapEntry) == 0xC */ +#define HEAP_INVALID_INDEX (0xffffffff) typedef struct ALHeapEntry_ { /* 0x00 */ u8* addr; /* 0x04 */ size_t size; @@ -894,7 +895,7 @@ typedef struct AudioGlobals { /* 0x351C */ u8 wave_load_status[172]; /* 0x35C8 */ u8 bank_load_status[172]; /* 0x3674 */ u8 sequence_load_status[252]; - /* 0x3770 */ u8 reset_status; + /* 0x3770 */ volatile u8 reset_status; /* 0x3771 */ u8 spec_id; /* 0x3774 */ s32 audio_reset_fadeout_frames_left; /* 0x3778 */ f32* adsr_decay_table; @@ -972,10 +973,10 @@ typedef struct Ibnk_ InstBank; // C++ JAudio1 typedef enum JCSTATUS { - JCSTAT_Unk0 = 0, - JCSTAT_Unk1 = 1, - JCSTAT_Unk2 = 2, - JCSTAT_Unk6 = 6, + JCSTAT_Unk0 = 0, + JCSTAT_Unk1 = 1, + JCSTAT_Unk2 = 2, + JCSTAT_Unk6 = 6, } JCSTATUS; typedef struct dspch_ dspch_; // TODO: Figure out why there is another struct named `DSPChannel_` in syncstream.c. @@ -991,21 +992,21 @@ typedef BOOL (*DSPChannelCallback)(dspch_*, u32); * @brief TODO. */ struct dspch_ { - u8 buffer_idx; // _00 - u8 _01; // _01 - u8 _02; // _02 - u8 _03; // _03 - u16 _04; // _04 - u16 _06; // _06 - // u32 _08; // _08 - jc_* _08; // _08 - DSPChannelCallback _0C; // _0C + u8 buffer_idx; // _00 + u8 _01; // _01 + u8 _02; // _02 + u8 _03; // _03 + u16 _04; // _04 + u16 _06; // _06 + // u32 _08; // _08 + jc_* _08; // _08 + DSPChannelCallback _0C; // _0C - // DSPchannel_* _0C; // TODO: SMS says this exists, Pikmin 1 disagrees. + // DSPchannel_* _0C; // TODO: SMS says this exists, Pikmin 1 disagrees. }; typedef struct PanMatrix_ { - f32 values[3]; + f32 values[3]; } PanMatrix_; /** @@ -1014,41 +1015,41 @@ typedef struct PanMatrix_ { * @note Size: 0x74. */ struct jcs_ { - u32 chanCount; // _00, Number of channels in this system - u32 chanAllocCount; // _04, Total channel allocation counter - jc_* freeChannels; // _08, Linked list of free channels - jc_* activeChannels; // _0C, Linked list of active channels - jc_* releasingChannels; // _10, Linked list of releasing channels - jc_* waitingChannels; // _14, Linked list of channels waiting for DSP - f32 volume; // _18, Master volume (default 1.0) - f32 pitch; // _1C, Master pitch/cent adjustment (default 1.0) - f32 pan; // _20, Master pan position (default 0.5) - f32 fxmix; // _24, Effects mix level (default 0.0) - f32 dolby; // _28, Dolby surround level (default 0.0) + u32 chanCount; // _00, Number of channels in this system + u32 chanAllocCount; // _04, Total channel allocation counter + jc_* freeChannels; // _08, Linked list of free channels + jc_* activeChannels; // _0C, Linked list of active channels + jc_* releasingChannels; // _10, Linked list of releasing channels + jc_* waitingChannels; // _14, Linked list of channels waiting for DSP + f32 volume; // _18, Master volume (default 1.0) + f32 pitch; // _1C, Master pitch/cent adjustment (default 1.0) + f32 pan; // _20, Master pan position (default 0.5) + f32 fxmix; // _24, Effects mix level (default 0.0) + f32 dolby; // _28, Dolby surround level (default 0.0) - s16 firCoefficients[8]; // _2C, FIR filter coefficients (8 taps) - s16 iirCoefficients[4]; // _3C, IIR filter coefficients + s16 firCoefficients[8]; // _2C, FIR filter coefficients (8 taps) + s16 iirCoefficients[4]; // _3C, IIR filter coefficients - char _44[8]; // _44 - s16 distFilter; // _4C, Distance filter parameter (default 0) - u16 busConnect[6]; // _4E, Bus routing configuration for 6 outputs - u8 masterLevels[6]; // _5A - u8 maxDelay; // _60, Maximum delay setting (default 0) - u8 filterMode; // _61, Filter enable flags (bit 5=IIR, bits 0-4=FIR taps) - u8 panCalcTypes[3]; // _62, Pan calculation types (default [26,1,1]) - u32 channelPriority; // _68 - u16 releaseTime; // _6C, Release/fade time in samples (default 600) - int voiceStealingMode; // _70, Voice stealing enabled (0=off, 1=on) + char _44[8]; // _44 + s16 distFilter; // _4C, Distance filter parameter (default 0) + u16 busConnect[6]; // _4E, Bus routing configuration for 6 outputs + u8 masterLevels[6]; // _5A + u8 maxDelay; // _60, Maximum delay setting (default 0) + u8 filterMode; // _61, Filter enable flags (bit 5=IIR, bits 0-4=FIR taps) + u8 panCalcTypes[3]; // _62, Pan calculation types (default [26,1,1]) + u32 channelPriority; // _68 + u16 releaseTime; // _6C, Release/fade time in samples (default 600) + int voiceStealingMode; // _70, Voice stealing enabled (0=off, 1=on) }; // needed to match UpdateEffecterParam typedef union MixConfig { - u16 whole; - struct { - u8 upper; - u8 lower0 : 4; - u8 lower1 : 4; - } parts; + u16 whole; + struct { + u8 upper; + u8 lower0 : 4; + u8 lower1 : 4; + } parts; } MixConfig; typedef BOOL (*JCUpdateCallback)(jc_*, JCSTATUS); @@ -1057,71 +1058,85 @@ typedef BOOL (*JCUpdateCallback)(jc_*, JCSTATUS); * @brief TODO. */ struct jc_ { - u8 velocity; // _00 - u8 note; // _01 - u8 pauseFlag; // _02 - u8 toFlush; // _03 - jcs_* mMgr; // _04 - struct jc_** chanListHead; // _08 - u8 logicalChanType; // _0C, 0 = Wave, 1 = ??, 2 = Oscillator - Wave_* waveData; // _10 - u32 _14; // _14 - u32 _18; // _18 - u32 _1C; // _1C - dspch_* dspChannel; // _20 - void* mNext; // _24 - JCUpdateCallback updateCallback; // _28 - JCUpdateCallback pitchSweepUpdater; // _2C - s32 playId; // _30 - s32 savedPlayId; // _34 - struct Osc_* mOscillators[4]; // _38 - struct Oscbuf_ mOscBuffers[2]; // _48 - f32 _78; // _78 - char _7C[8]; // _7C - f32 _84; // _84 - char _88[4]; // _88 - f32 _8C; // _8C - f32 _90; // _90 - f32 _94; // _94 - u16 _98; // _98 - u16 _9A; // _9A - void* _9C; // _9C - char _A0[8]; // _A0 - f32 basePitch; // _A8 - f32 baseVolume; // _AC - f32 currentPitch; // _B0 - f32 currentVolume; // _B4 - u8 panCalcTypes[3]; // _B8 - PanMatrix_ panMatrices[4]; // _BC, 0 = Power distribution, 1 = Pan, 2 = Effects send (fxmix), 3 = Dolby surround - f32 pitchModifier; // _EC - f32 volumeModifier; // _F0 - f32 targetPitch; // _F4 - u16 finalPitch; // _F8 - u16 pitchSweepSteps; // _FA - jcs_* lastManager; // _FC - f32 managerPitch; // _100 - f32 managerVolume; // _104 - MixConfig busRouting[6]; // _108 - u16 mixerLevels[6]; // _114 - u32 channelPriority; // _120 - u16 releaseTime; // _124 - u16 channelId; // _126 - int soundId; // _128 - u8 polyphonyCounter; // _12C - char _12D[3]; // _12D - int _130; // _130 - int _134; // _134 - int _138; // _138 - int _13C; // _13C + u8 velocity; // _00 + u8 note; // _01 + u8 pauseFlag; // _02 + u8 toFlush; // _03 + jcs_* mMgr; // _04 + struct jc_** chanListHead; // _08 + u8 logicalChanType; // _0C, 0 = Wave, 1 = ??, 2 = Oscillator + Wave_* waveData; // _10 + u32 _14; // _14 + u32 _18; // _18 + u32 _1C; // _1C + dspch_* dspChannel; // _20 + void* mNext; // _24 + JCUpdateCallback updateCallback; // _28 + JCUpdateCallback pitchSweepUpdater; // _2C + s32 playId; // _30 + s32 savedPlayId; // _34 + struct Osc_* mOscillators[4]; // _38 + struct Oscbuf_ mOscBuffers[2]; // _48 + f32 _78; // _78 + char _7C[8]; // _7C + f32 _84; // _84 + char _88[4]; // _88 + f32 _8C; // _8C + f32 _90; // _90 + f32 _94; // _94 + u16 _98; // _98 + u16 _9A; // _9A + void* _9C; // _9C + char _A0[8]; // _A0 + f32 basePitch; // _A8 + f32 baseVolume; // _AC + f32 currentPitch; // _B0 + f32 currentVolume; // _B4 + u8 panCalcTypes[3]; // _B8 + PanMatrix_ panMatrices[4]; // _BC, 0 = Power distribution, 1 = Pan, 2 = Effects send (fxmix), 3 = Dolby surround + f32 pitchModifier; // _EC + f32 volumeModifier; // _F0 + f32 targetPitch; // _F4 + u16 finalPitch; // _F8 + u16 pitchSweepSteps; // _FA + jcs_* lastManager; // _FC + f32 managerPitch; // _100 + f32 managerVolume; // _104 + MixConfig busRouting[6]; // _108 + u16 mixerLevels[6]; // _114 + u32 channelPriority; // _120 + u16 releaseTime; // _124 + u16 channelId; // _126 + int soundId; // _128 + u8 polyphonyCounter; // _12C + char _12D[3]; // _12D + int _130; // _130 + int _134; // _134 + int _138; // _138 + int _13C; // _13C }; typedef struct Wavelookuptable_ { - // TODO + u8* sample; + u8* _04; + u32 _08; + u8 medium; } Wavelookuptable; -typedef struct fxconfig { - // TODO: members -} fxconfig_; +typedef struct fxconfig_ { + u8 downsample_rate; + u16 _02; + u16 decay_ratio; + u16 sub_delay; + u16 sub_volume; + u16 volume; + u16 leak_rtl; + u16 leak_ltl; + s8 mix_reverb_idx; + u16 mix_reverb_strength; + s16 _14; + s16 _16; +} fxconfig; #ifdef __cplusplus } From 523fed900510b5a579aa5225a24e0905bcbdb94f Mon Sep 17 00:00:00 2001 From: roeming Date: Thu, 3 Jul 2025 17:20:42 -0400 Subject: [PATCH 3/6] link audiotable --- config/GAFE01_00/symbols.txt | 2 +- configure.py | 30 +- src/static/jaudio_NES/internal/audiotable.c | 568 ++++++++++++++++++++ 3 files changed, 579 insertions(+), 21 deletions(-) create mode 100644 src/static/jaudio_NES/internal/audiotable.c diff --git a/config/GAFE01_00/symbols.txt b/config/GAFE01_00/symbols.txt index 004154ef..9764d232 100644 --- a/config/GAFE01_00/symbols.txt +++ b/config/GAFE01_00/symbols.txt @@ -3660,7 +3660,7 @@ LSF_TABLE = .data:0x800D1390; // type:object size:0x100 scope:global align:4 HSF_TABLE = .data:0x800D1490; // type:object size:0xF0 scope:global align:4 EL_FILTER = .data:0x800D1580; // type:object size:0x690 scope:global align:4 BP_FILTER = .data:0x800D1C10; // type:object size:0x690 scope:global align:4 -wm_sin = .data:0x800D22A0; // type:object size:0x200 scope:global align:4 +wm_sin = .data:0x800D22A0; // type:object size:0x200 scope:global align:4 noreloc WAVEMEM_TABLE = .data:0x800D24A0; // type:object size:0x24 scope:global align:4 PCENTTABLE = .data:0x800D24C4; // type:object size:0x400 scope:global align:4 PCENTTABLE2 = .data:0x800D28C4; // type:object size:0x400 scope:global align:4 diff --git a/configure.py b/configure.py index ac2f122b..0241db58 100644 --- a/configure.py +++ b/configure.py @@ -356,8 +356,7 @@ config.libs = [ "progress_category": "library", "src_dir": "src/static", "objects": [ - Object(Matching, "libforest/emu64/emu64.c", - extra_cflags=["-lang=c++", "-O4,p", "-inline auto"]), + Object(Matching, "libforest/emu64/emu64.c", extra_cflags=["-lang=c++", "-O4,p", "-inline auto"]), Object(Matching, "libforest/osreport.c"), Object(Matching, "libforest/fault.c"), Object(Matching, "libforest/ReconfigBATs.c"), @@ -421,9 +420,7 @@ config.libs = [ Object(Matching, "libultra/gu/scale.c"), Object(Matching, "libultra/sendmesg.c"), Object(Matching, "libultra/setthreadpri.c"), - # no clue why this file has these flags, but they're necessary - Object(Matching, "libultra/settimer.c", - extra_cflags=["-O0", "-opt schedule", "-opt peep"]), + Object(Matching, "libultra/settimer.c", extra_cflags=["-O0", "-opt schedule", "-opt peep"]), # no clue why this file has these flags, but they're necessary Object(Matching, "libultra/shutdown.c"), Object(Matching, "libultra/gu/sins.c"), Object(Matching, "libultra/startthread.c"), @@ -565,8 +562,7 @@ config.libs = [ DolphinLib( "OdemuExi2", [ - Object(Matching, "dolphin/OdemuExi2/DebuggerDriver.c", - extra_cflags=["-inline deferred"]), + Object(Matching, "dolphin/OdemuExi2/DebuggerDriver.c", extra_cflags=["-inline deferred"]), ], ), DolphinLib( @@ -716,8 +712,7 @@ config.libs = [ "objects": [ Object(Matching, "jaudio_NES/game/audioheaders.c"), Object(Matching, "jaudio_NES/game/dummyprobe.c"), - Object(Matching, "jaudio_NES/game/emusound.c", - extra_cflags=["-O4,s", "-fp_contract on", "-func_align 32", "-vector on"]), + Object(Matching, "jaudio_NES/game/emusound.c", extra_cflags=["-O4,s", "-fp_contract on", "-func_align 32", "-vector on"]), Object(Matching, "jaudio_NES/game/game64.c"), Object(Matching, "jaudio_NES/game/kappa.c"), Object(Matching, "jaudio_NES/game/melody.c"), @@ -764,10 +759,9 @@ config.libs = [ Object(Matching, "jaudio_NES/internal/track.c"), Object(Matching, "jaudio_NES/internal/aramcall.c"), Object(Matching, "jaudio_NES/internal/audioconst.c"), - Object(NonMatching, "jaudio_NES/internal/audiotable.c"), + Object(Matching, "jaudio_NES/internal/audiotable.c"), Object(NonMatching, "jaudio_NES/internal/audiowork.c"), - Object(Matching, "jaudio_NES/internal/bankdrv.c", - extra_cflags=["-pragma \"scheduling 7400\""]), + Object(Matching, "jaudio_NES/internal/bankdrv.c", extra_cflags=["-pragma \"scheduling 7400\""]), Object(Matching, "jaudio_NES/internal/bankread.c"), Object(Matching, "jaudio_NES/internal/centcalc.c"), Object(Matching, "jaudio_NES/internal/channel.c"), @@ -779,16 +773,13 @@ config.libs = [ Object(Matching, "jaudio_NES/internal/dsp_GBAKey.c"), Object(Equivalent, "jaudio_NES/internal/dspdriver.c"), Object(Matching, "jaudio_NES/internal/dspinterface.c"), - Object(Matching, "jaudio_NES/internal/effect.c", - extra_cflags=["-pragma \"scheduling 7400\""]), + Object(Matching, "jaudio_NES/internal/effect.c", extra_cflags=["-pragma \"scheduling 7400\""]), Object(Matching, "jaudio_NES/internal/fat.c"), Object(Matching, "jaudio_NES/internal/fxinterface.c"), Object(Matching, "jaudio_NES/internal/heapctrl.c"), Object(Matching, "jaudio_NES/internal/ipldec.c"), - Object(Matching, "jaudio_NES/internal/ja_calc.c", - extra_cflags=["-sym off"]), - Object(NonMatching, "jaudio_NES/internal/jammain_2.c", - extra_cflags=["-sym on"]), + Object(Matching, "jaudio_NES/internal/ja_calc.c", extra_cflags=["-sym off"]), + Object(NonMatching, "jaudio_NES/internal/jammain_2.c", extra_cflags=["-sym on"]), Object(Matching, "jaudio_NES/internal/jamosc.c"), Object(NonMatching, "jaudio_NES/internal/memory.c"), Object(Matching, "jaudio_NES/internal/midplay.c"), @@ -797,8 +788,7 @@ config.libs = [ Object(NonMatching, "jaudio_NES/internal/rate.c"), Object(NonMatching, "jaudio_NES/internal/rspsim.c"), Object(Matching, "jaudio_NES/internal/seqsetup.c"), - Object(Equivalent, "jaudio_NES/internal/system.c", - extra_cflags=["-pragma \"scheduling 7400\""]), + Object(Equivalent, "jaudio_NES/internal/system.c", extra_cflags=["-pragma \"scheduling 7400\""]), Object(Matching, "jaudio_NES/internal/tables.c"), Object(Matching, "jaudio_NES/internal/waveread.c"), ], diff --git a/src/static/jaudio_NES/internal/audiotable.c b/src/static/jaudio_NES/internal/audiotable.c new file mode 100644 index 00000000..2d942ca0 --- /dev/null +++ b/src/static/jaudio_NES/internal/audiotable.c @@ -0,0 +1,568 @@ +#include "jaudio_NES/audiotable.h" + +u8 VELOCONV_TABLE[] = { + 0x00, 0x01, 0x03, 0x04, 0x06, 0x08, 0x09, 0x0b, 0x0c, 0x0e, 0x0f, 0x10, 0x12, 0x13, 0x15, 0x16, 0x17, 0x18, 0x1a, + 0x1b, 0x1c, 0x1d, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, + 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x39, 0x39, 0x3a, 0x3b, 0x3c, 0x3c, 0x3d, 0x3e, + 0x3e, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x41, 0x41, 0x42, 0x43, 0x43, 0x44, + 0x45, 0x46, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, + 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x62, 0x63, 0x64, 0x65, 0x67, 0x68, 0x69, 0x6a, + 0x6c, 0x6d, 0x6f, 0x70, 0x71, 0x73, 0x74, 0x76, 0x77, 0x79, 0x7b, 0x7c, 0x7e, 0x7f, 0x81, 0x82, 0x84, 0x85, 0x87, + 0x89, 0x8a, 0x8c, 0x8d, 0x8f, 0x90, 0x91, 0x93, 0x94, 0x96, 0x97, 0x98, 0x99, 0x9b, 0x9c, 0x9d, 0x9e, 0xa0, 0xa1, + 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, + 0xb5, 0xb6, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xba, 0xbb, 0xbc, 0xbd, 0xbd, 0xbe, 0xbf, 0xbf, 0xc0, 0xc0, 0xc0, 0xc0, + 0xc0, 0xc0, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc2, 0xc2, 0xc3, 0xc4, 0xc4, 0xc5, 0xc6, 0xc7, 0xc7, 0xc8, 0xc9, + 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, + 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe3, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9, 0xea, 0xeb, 0xed, 0xee, 0xf0, 0xf1, 0xf2, + 0xf4, 0xf5, 0xf7, 0xf8, 0xfa, 0xfc, 0xfd, 0xff, 0x00, 0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0d, + 0x0e, 0x0f, 0x11, 0x12, 0x13, 0x15, 0x16, 0x17, 0x18, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x21, 0x22, 0x23, 0x24, + 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, + 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, 0x3c, 0x3d, 0x3d, 0x3e, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x40, 0x40, 0x40, + 0x40, 0x40, 0x41, 0x42, 0x42, 0x43, 0x44, 0x45, 0x45, 0x46, 0x47, 0x48, 0x49, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, + 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x60, 0x61, + 0x62, 0x63, 0x64, 0x65, 0x67, 0x68, 0x69, 0x6a, 0x6c, 0x6d, 0x6e, 0x70, 0x71, 0x72, 0x74, 0x75, 0x76, 0x78, 0x79, + 0x7b, 0x7c, 0x7e, 0x7f, 0x81, 0x82, 0x84, 0x85, 0x87, 0x88, 0x8a, 0x8b, 0x8c, 0x8e, 0x8f, 0x90, 0x92, 0x93, 0x94, + 0x96, 0x97, 0x98, 0x99, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, + 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, + 0xbb, 0xbc, 0xbd, 0xbe, 0xbe, 0xbf, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc2, 0xc3, 0xc3, + 0xc4, 0xc5, 0xc6, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, + 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe8, + 0xe9, 0xea, 0xeb, 0xed, 0xee, 0xef, 0xf1, 0xf2, 0xf3, 0xf5, 0xf6, 0xf7, 0xf9, 0xfa, 0xfc, 0xfd, 0xff, 0x00, 0x00, + 0x01, 0x02, 0x04, 0x05, 0x07, 0x08, 0x09, 0x0b, 0x0c, 0x0d, 0x0f, 0x10, 0x11, 0x12, 0x14, 0x15, 0x16, 0x17, 0x18, + 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2b, 0x2c, + 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x39, 0x3a, 0x3b, 0x3c, 0x3c, + 0x3d, 0x3e, 0x3f, 0x3f, 0x3f, 0x3f, 0x40, 0x40, 0x40, 0x40, 0x41, 0x42, 0x43, 0x43, 0x44, 0x45, 0x46, 0x46, 0x47, + 0x48, 0x49, 0x4a, 0x4b, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x54, 0x55, 0x56, 0x57, 0x58, + 0x59, 0x5a, 0x5b, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6d, 0x6e, + 0x6f, 0x70, 0x72, 0x73, 0x74, 0x76, 0x77, 0x78, 0x7a, 0x7b, 0x7d, 0x7e, 0x7f, 0x81, 0x82, 0x83, 0x85, 0x86, 0x88, + 0x89, 0x8a, 0x8c, 0x8d, 0x8e, 0x90, 0x91, 0x92, 0x93, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, + 0xa0, 0xa1, 0xa2, 0xa3, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, + 0xb3, 0xb4, 0xb5, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xba, 0xbb, 0xbc, 0xbd, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0, 0xc0, + 0xc0, 0xc1, 0xc1, 0xc1, 0xc1, 0xc2, 0xc3, 0xc4, 0xc4, 0xc5, 0xc6, 0xc7, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcc, + 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xde, 0xdf, + 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xee, 0xef, 0xf0, 0xf1, 0xf3, 0xf4, 0xf5, + 0xf7, 0xf8, 0xf9, 0xfb, 0xfc, 0xfe, 0xff, 0x00, 0x00, 0x01, 0x02, 0x04, 0x05, 0x06, 0x08, 0x09, 0x0a, 0x0b, 0x0d, + 0x0e, 0x0f, 0x10, 0x11, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, + 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x32, 0x33, 0x34, + 0x35, 0x36, 0x37, 0x38, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3c, 0x3d, 0x3e, 0x3f, 0x3f, 0x3f, 0x40, 0x40, 0x40, 0x41, + 0x42, 0x43, 0x43, 0x44, 0x45, 0x46, 0x47, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4d, 0x4e, 0x4f, 0x50, 0x51, + 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, + 0x65, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x74, 0x75, 0x76, 0x77, 0x79, 0x7a, 0x7b, + 0x7d, 0x7e, 0x7f, 0x81, 0x82, 0x83, 0x85, 0x86, 0x87, 0x89, 0x8a, 0x8b, 0x8c, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x94, + 0x95, 0x96, 0x97, 0x98, 0x99, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, + 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, + 0xba, 0xbb, 0xbc, 0xbd, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0, 0xc0, 0xc1, 0xc1, 0xc1, 0xc2, 0xc3, 0xc4, 0xc4, 0xc5, 0xc6, + 0xc7, 0xc8, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, + 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9, 0xea, 0xeb, + 0xec, 0xed, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf5, 0xf6, 0xf7, 0xf8, 0xfa, 0xfb, 0xfc, 0xfe, 0xff, 0x00, 0x00, 0x01, + 0x02, 0x03, 0x05, 0x06, 0x07, 0x08, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, + 0x18, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, + 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, + 0x3c, 0x3d, 0x3e, 0x3f, 0x3f, 0x40, 0x40, 0x41, 0x42, 0x43, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, + 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, + 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x70, 0x71, + 0x72, 0x73, 0x74, 0x75, 0x77, 0x78, 0x79, 0x7a, 0x7c, 0x7d, 0x7e, 0x7f, 0x81, 0x82, 0x83, 0x84, 0x86, 0x87, 0x88, + 0x89, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9b, 0x9c, 0x9d, 0x9e, + 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, + 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0, + 0xc1, 0xc1, 0xc2, 0xc3, 0xc4, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, + 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, + 0xe3, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf8, + 0xf9, 0xfa, 0xfb, 0xfd, 0xfe, 0xff, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, + 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, + 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, + 0x34, 0x35, 0x36, 0x37, 0x38, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3e, 0x3f, 0x40, 0x41, 0x41, 0x42, 0x43, + 0x44, 0x45, 0x46, 0x47, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x52, 0x53, 0x54, + 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x67, 0x68, + 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x7a, 0x7b, 0x7c, 0x7d, + 0x7e, 0x7f, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8f, 0x90, 0x91, 0x92, 0x93, + 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, + 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, + 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xbf, 0xc0, 0xc1, 0xc2, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc8, + 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, + 0xdb, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, + 0xef, 0xf0, 0xf1, 0xf2, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfb, 0xfc, 0xfd, 0xfe, 0xff, 0x00, 0x00, 0x01, 0x02, + 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, + 0x17, 0x18, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, + 0x2b, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, + 0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, + 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, + 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, + 0x74, 0x75, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, + 0x89, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9b, 0x9c, 0x9d, + 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xac, 0xad, 0xae, 0xaf, + 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc1, + 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, + 0xd4, 0xd5, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, + 0xe6, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf8, 0xf9, 0xfa, + 0xfb, 0xfc, 0xfd, 0xfe, 0xff, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, + 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, + 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, + 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, + 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x57, + 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, + 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, + 0x7f, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, + 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, + 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, + 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, + 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, + 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, + 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff, 0x00, 0x00, 0x01, 0x02, 0x03, + 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, + 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, + 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, + 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, + 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, + 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, + 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, + 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, + 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, + 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc1, 0xc2, + 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, + 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, + 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, + 0xfc, 0xfd, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, + 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1c, 0x1d, 0x1e, + 0x1f, 0x20, 0x21, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, + 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, + 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, + 0x5b, 0x5c, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, + 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x7f, + 0x81, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, + 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa4, 0xa5, + 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, + 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, + 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xdf, 0xe0, 0xe1, + 0xe2, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, + 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, + 0x04, 0x05, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, + 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, + 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, + 0x3d, 0x3e, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, + 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, + 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x77, + 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x7f, 0x81, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, + 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, + 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, + 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc2, 0xc3, 0xc4, + 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, + 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, + 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, + 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, + 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, + 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x30, 0x31, 0x32, + 0x33, 0x34, 0x35, 0x36, 0x37, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x48, 0x49, + 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, + 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, + 0x71, 0x72, 0x73, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x7f, 0x81, + 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8d, 0x8e, 0x8f, 0x90, 0x91, + 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, + 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, + 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, + 0xd0, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3, + 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf4, 0xf5, + 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfb, 0xfc, 0xfd, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x03, + 0x04, 0x05, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, + 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, + 0x28, 0x29, 0x2a, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x34, 0x35, 0x36, 0x37, 0x38, 0x3a, 0x3b, 0x3c, 0x3d, + 0x3f, 0x40, 0x42, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x55, + 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, + 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x77, 0x78, 0x79, + 0x7a, 0x7b, 0x7c, 0x7c, 0x7d, 0x7e, 0x7f, 0x7f, 0x81, 0x81, 0x82, 0x83, 0x84, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, + 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, + 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xad, 0xae, + 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xbb, 0xbc, 0xbd, 0xbe, 0xc0, 0xc1, 0xc3, 0xc4, 0xc5, + 0xc6, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, + 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, + 0xef, 0xf0, 0xf1, 0xf2, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfd, 0xfe, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0a, 0x0b, + 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, + 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x30, 0x31, 0x32, + 0x33, 0x34, 0x36, 0x37, 0x38, 0x3a, 0x3b, 0x3c, 0x3e, 0x3f, 0x40, 0x41, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4b, + 0x4c, 0x4d, 0x4e, 0x4f, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, + 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x6f, 0x70, 0x71, 0x72, + 0x73, 0x74, 0x75, 0x75, 0x76, 0x77, 0x78, 0x79, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7d, 0x7e, 0x7f, 0x7f, 0x81, 0x81, + 0x82, 0x83, 0x83, 0x84, 0x85, 0x86, 0x87, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, + 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, + 0xa4, 0xa5, 0xa6, 0xa7, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb7, 0xb8, 0xb9, + 0xbb, 0xbc, 0xbd, 0xbf, 0xc0, 0xc1, 0xc2, 0xc4, 0xc5, 0xc6, 0xc8, 0xc9, 0xca, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd2, + 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, + 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf6, 0xf7, + 0xf8, 0xf9, 0xfa, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 0x04, + 0x04, 0x05, 0x06, 0x07, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x12, 0x13, + 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x25, 0x26, 0x27, + 0x28, 0x29, 0x2a, 0x2b, 0x2d, 0x2e, 0x2f, 0x30, 0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x3a, 0x3b, 0x3c, 0x3e, 0x3f, + 0x40, 0x41, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4b, 0x4c, 0x4d, 0x4f, 0x50, 0x51, 0x52, 0x54, 0x55, 0x56, 0x57, + 0x58, 0x59, 0x5a, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, + 0x6c, 0x6d, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x74, 0x75, 0x76, 0x77, 0x78, 0x78, 0x79, 0x7a, 0x7b, + 0x7b, 0x7c, 0x7d, 0x7d, 0x7e, 0x7f, 0x7f, 0x81, 0x81, 0x82, 0x83, 0x83, 0x84, 0x85, 0x85, 0x86, 0x87, 0x88, 0x88, + 0x89, 0x8a, 0x8b, 0x8c, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, + 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xae, + 0xaf, 0xb0, 0xb1, 0xb3, 0xb4, 0xb5, 0xb7, 0xb8, 0xb9, 0xbb, 0xbc, 0xbd, 0xbf, 0xc0, 0xc1, 0xc2, 0xc4, 0xc5, 0xc6, + 0xc8, 0xc9, 0xca, 0xcc, 0xcd, 0xce, 0xd0, 0xd1, 0xd2, 0xd3, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdd, 0xde, + 0xdf, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xee, 0xef, 0xf0, + 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xfe, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x09, 0x09, 0x0a, 0x0b, + 0x0c, 0x0d, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, + 0x1d, 0x1e, 0x1f, 0x20, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2f, 0x30, 0x31, 0x33, + 0x34, 0x35, 0x37, 0x38, 0x3a, 0x3b, 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x44, 0x45, 0x47, 0x48, 0x4a, 0x4b, 0x4c, + 0x4e, 0x4f, 0x50, 0x52, 0x53, 0x54, 0x55, 0x56, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5f, 0x60, 0x61, 0x62, 0x63, + 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x72, 0x73, 0x74, + 0x75, 0x76, 0x76, 0x77, 0x78, 0x79, 0x79, 0x7a, 0x7b, 0x7c, 0x7c, 0x7d, 0x7e, 0x7e, 0x7f, 0x7f, 0x81, 0x81, 0x82, + 0x82, 0x83, 0x84, 0x84, 0x85, 0x86, 0x87, 0x87, 0x88, 0x89, 0x8a, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8e, 0x8f, 0x90, + 0x91, 0x92, 0x93, 0x94, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa3, + 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xb0, 0xb1, 0xb2, 0xb4, 0xb5, 0xb6, 0xb8, 0xb9, 0xbb, + 0xbc, 0xbe, 0xbf, 0xc0, 0xc1, 0xc2, 0xc3, 0xc5, 0xc6, 0xc8, 0xc9, 0xcb, 0xcc, 0xcd, 0xcf, 0xd0, 0xd1, 0xd3, 0xd4, + 0xd5, 0xd6, 0xd7, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, + 0xea, 0xeb, 0xec, 0xed, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, + 0xfa, 0xfa, 0xfb, 0xfc, 0xfd, 0xfd, 0xfe, 0xff, 0xff, 0x00, 0x00 +}; + +s16 LSF_TABLE[] = { 0x0, 0x0, 0x0, 0x7FFF, 0x0, 0x0, 0x0, 0x0, 0xF0E, 0x105C, 0x112E, 0x1175, + 0x112E, 0x105C, 0xF0E, 0xD58, 0xD57, 0x10DA, 0x1333, 0x1406, 0x1333, 0x10DA, 0xD57, 0x92F, + 0xA4C, 0x1151, 0x1682, 0x186C, 0x1682, 0x1151, 0xA4C, 0x351, 0x536, 0x1064, 0x19F6, 0x1DB9, + 0x19F6, 0x1064, 0x536, 0xFCDE, 0xFEF7, 0xD5D, 0x1C7C, 0x22F0, 0x1C7C, 0xD5D, 0xFEF7, 0xF8B9, + 0xF9EA, 0x811, 0x1BEA, 0x254A, 0x1BEA, 0x811, 0xF9EA, 0xF96E, 0xF6CF, 0x2D6, 0x1D11, 0x2B14, + 0x1D11, 0x2D6, 0xF6CF, 0xFD47, 0xF734, 0xFD4B, 0x1BD1, 0x2EBA, 0x1BD1, 0xFD4B, 0xF734, 0x29C, + 0xFAA3, 0xF8E5, 0x189B, 0x300A, 0x189B, 0xF8E5, 0xFAA3, 0x5CC, 0xFF2B, 0xF54C, 0x16D3, 0x3570, + 0x16D3, 0xF54C, 0xFF2B, 0x5D6, 0x3D4, 0xF3F7, 0x1313, 0x37CE, 0x1313, 0xF3F7, 0x3D4, 0x24E, + 0x6E9, 0xF463, 0xF1A, 0x3A85, 0xF1A, 0xF463, 0x6E9, 0xFDC8, 0x7E7, 0xF606, 0xB5F, 0x400D, + 0xB5F, 0xF606, 0x7E7, 0xFA91, 0x6E6, 0xF882, 0x7E0, 0x4D58, 0x7E0, 0xF882, 0x6E6, 0xF9E4, + 0x349, 0xFCAB, 0x35F, 0x68CD, 0x35F, 0xFCAB, 0x349, 0xFCCC }; + +s16 HSF_TABLE[] = { 0xFEDF, 0xFEDD, 0xFEDF, 0x7810, 0xFEDF, 0xFEDD, 0xFEDF, 0xFEDE, 0xFE30, 0xFE2D, 0xFE2D, 0x7342, + 0xFE2D, 0xFE2D, 0xFE30, 0xFE31, 0xFD6A, 0xFD62, 0xFD60, 0x6DC5, 0xFD60, 0xFD62, 0xFD6A, 0xFD70, + 0xFCB9, 0xFCA9, 0xFCA3, 0x68CE, 0xFCA3, 0xFCA9, 0xFCB9, 0xFCCA, 0xFC1C, 0xFC00, 0xFBF2, 0x6455, + 0xFBF2, 0xFC00, 0xFC1C, 0xFC3D, 0xFB60, 0xFB2C, 0xFB0E, 0x5ED0, 0xFB0E, 0xFB2C, 0xFB60, 0xFBA2, + 0xFAB3, 0xFA56, 0xFA1E, 0x5974, 0xFA1E, 0xFA56, 0xFAB3, 0xFB2A, 0xFA16, 0xF970, 0xF908, 0x53FA, + 0xF908, 0xF970, 0xFA16, 0xFAE5, 0xF9B3, 0xF8AB, 0xF800, 0x4FA6, 0xF800, 0xF8AB, 0xF9B3, 0xFAEE, + 0xF987, 0xF777, 0xF601, 0x49B5, 0xF601, 0xF777, 0xF987, 0xFBBB, 0xFA0C, 0xF6A5, 0xF3FA, 0x466E, + 0xF3FA, 0xF6A5, 0xFA0C, 0xFD1D, 0xFB1B, 0xF638, 0xF1DB, 0x44EA, 0xF1DB, 0xF638, 0xFB1B, 0xFE91, + 0xFDF3, 0xF6C1, 0xED84, 0x446D, 0xED84, 0xF6C1, 0xFDF3, 0x0, 0xFFDE, 0xF91E, 0xE9B6, 0x445F, + 0xE9B6, 0xF91E, 0xFFDE, 0xFEFE, 0xFCFC, 0xFFFD, 0xE4B7, 0x4358, 0xE4B7, 0xFFFD, 0xFCFC, 0xFFFD }; + +s16 EL_FILTER[] = { + 0xFFD5, 0xFD34, 0xFB4B, 0x6E32, 0xFB4B, 0xFD34, 0xFFD5, 0x275, 0xF9, 0xFC69, 0xF8E5, 0x6391, 0xF8E5, 0xFC69, + 0xF9, 0x515, 0x4F3, 0xFCDE, 0xF5A6, 0x50F2, 0xF5A6, 0xFCDE, 0x4F3, 0xA2B, 0x9C1, 0xFF2E, 0xF384, 0x44D1, + 0xF384, 0xFF2E, 0x9C1, 0xD0B, 0xD55, 0x2B2, 0xF2C7, 0x39A2, 0xF2C7, 0x2B2, 0xD55, 0xBDB, 0xF13, 0x6C6, + 0xF2A8, 0x31A0, 0xF2A8, 0x6C6, 0xF13, 0x7FA, 0xF12, 0xB5B, 0xF2AA, 0x2CFC, 0xF2AA, 0xB5B, 0xF12, 0x37A, + 0xD2E, 0x1062, 0xF2EF, 0x2A6B, 0xF2EF, 0x1062, 0xD2E, 0x50, 0x98E, 0x1591, 0xF3C6, 0x28F3, 0xF3C6, 0x1591, + 0x98E, 0x56, 0x4FB, 0x1A68, 0xF597, 0x27F1, 0xF597, 0x1A68, 0x4FB, 0x474, 0xFC, 0x1E62, 0xF8D4, 0x2726, + 0xF8D4, 0x1E62, 0xFC, 0xBC2, 0xFF9E, 0x20EB, 0xFE33, 0x264D, 0xFE33, 0x20EB, 0xFF9E, 0x137C, 0x2CF, 0x1CE0, + 0x5F8, 0x2009, 0x5F8, 0x1CE0, 0x2CF, 0x14A6, 0x9C3, 0x14EF, 0xE43, 0x1761, 0xE43, 0x14EF, 0x9C3, 0xEB1, + 0x2C7, 0xFF33, 0xFBFE, 0x6BD8, 0xFBFE, 0xFF33, 0x2C7, 0x4F7, 0x537, 0xFF94, 0xFA10, 0x6104, 0xFA10, 0xFF94, + 0x537, 0x7D3, 0x9EC, 0x1C7, 0xF7C8, 0x4D8D, 0xF7C8, 0x1C7, 0x9EC, 0xA98, 0xD4E, 0x512, 0xF6D5, 0x3F8A, + 0xF6D5, 0x512, 0xD4E, 0x95D, 0xF14, 0x911, 0xF678, 0x370E, 0xF678, 0x911, 0xF14, 0x594, 0xF12, 0xDB7, + 0xF679, 0x3258, 0xF679, 0xDB7, 0xF12, 0x103, 0xCB0, 0x1247, 0xF742, 0x2E53, 0xF742, 0x1247, 0xCB0, 0xFDC1, + 0x919, 0x1785, 0xF877, 0x2D3B, 0xF877, 0x1785, 0x919, 0xFD8E, 0x4C9, 0x1DBD, 0xFA8D, 0x2EBF, 0xFA8D, 0x1DBD, + 0x4C9, 0x14C, 0xAC, 0x2251, 0xFEA0, 0x2EFC, 0xFEA0, 0x2251, 0xAC, 0x847, 0xFF54, 0x2006, 0x473, 0x2878, + 0x473, 0x2006, 0xFF54, 0xD39, 0x1FF, 0x1B5E, 0xB0E, 0x21C9, 0xB0E, 0x1B5E, 0x1FF, 0xD5D, 0x7CB, 0x14C1, + 0x11F3, 0x1A91, 0x11F3, 0x14C1, 0x7CB, 0x86E, 0x4AC, 0x139, 0xFCD1, 0x6951, 0xFCD1, 0x139, 0x4AC, 0x482, + 0x768, 0x29A, 0xFB79, 0x5D0D, 0xFB79, 0x29A, 0x768, 0x5DC, 0xB76, 0x621, 0xF9F4, 0x4B99, 0xF9F4, 0x621, + 0xB76, 0x51C, 0xD87, 0xA71, 0xF959, 0x4182, 0xF959, 0xA71, 0xD87, 0x13C, 0xCC5, 0xEAD, 0xF9B8, 0x38FB, + 0xF9B8, 0xEAD, 0xCC5, 0xFC72, 0xA19, 0x1319, 0xFAAC, 0x340D, 0xFAAC, 0x1319, 0xA19, 0xF91D, 0x634, 0x1885, + 0xFC36, 0x3373, 0xFC36, 0x1885, 0x634, 0xF87E, 0x151, 0x1FB9, 0xFEF7, 0x3736, 0xFEF7, 0x1FB9, 0x151, 0xFB5E, + 0xFCE5, 0x2001, 0x372, 0x3157, 0x372, 0x2001, 0xFCE5, 0x187, 0xFBDE, 0x1C38, 0x854, 0x28FC, 0x854, 0x1C38, + 0xFBDE, 0x5A4, 0xFE09, 0x198C, 0xEDB, 0x253C, 0xEDB, 0x198C, 0xFE09, 0x605, 0x38A, 0x14CE, 0x167F, 0x20A6, + 0x167F, 0x14CE, 0x38A, 0x1A7, 0x512, 0x30D, 0xFDAB, 0x698A, 0xFDAB, 0x30D, 0x512, 0x188, 0x77A, 0x554, + 0xFCBE, 0x5F0E, 0xFCBE, 0x554, 0x77A, 0xCD, 0x9AA, 0x9DF, 0xFC09, 0x4DCC, 0xFC09, 0x9DF, 0x9AA, 0xFCCF, + 0x8E5, 0xE41, 0xFC5A, 0x4262, 0xFC5A, 0xE41, 0x8E5, 0xF7FE, 0x609, 0x1301, 0xFD5F, 0x3D13, 0xFD5F, 0x1301, + 0x609, 0xF46C, 0x16E, 0x18DB, 0xFF4B, 0x3D4D, 0xFF4B, 0x18DB, 0x16E, 0xF34C, 0xFC07, 0x1A4E, 0x263, 0x361E, + 0x263, 0x1A4E, 0xFC07, 0xF775, 0xF86F, 0x1964, 0x616, 0x2EE0, 0x616, 0x1964, 0xF86F, 0xFCFA, 0xF758, 0x1782, + 0xA9A, 0x29CA, 0xA9A, 0x1782, 0xF758, 0xAB, 0xF8FD, 0x14E0, 0x107D, 0x2688, 0x107D, 0x14E0, 0xF8FD, 0xB6, + 0xFD6D, 0x113B, 0x1854, 0x242C, 0x1854, 0x113B, 0xFD6D, 0xFC74, 0x3C8, 0x472, 0xFE9A, 0x6A5C, 0xFE9A, 0x472, + 0x3C8, 0xFDA1, 0x4E3, 0x736, 0xFE3B, 0x5F62, 0xFE3B, 0x736, 0x4E3, 0xFB22, 0x472, 0xC68, 0xFE64, 0x50E5, + 0xFE64, 0xC68, 0x472, 0xF5D7, 0x139, 0x11C6, 0xFF89, 0x4ADF, 0xFF89, 0x11C6, 0x139, 0xF1CF, 0xFC34, 0x1432, + 0x1A3, 0x3FA2, 0x1A3, 0x1432, 0xFC34, 0xF2E9, 0xF7B5, 0x146E, 0x442, 0x3570, 0x442, 0x146E, 0xF7B5, 0xF769, + 0xF49C, 0x13CA, 0x786, 0x2EF3, 0x786, 0x13CA, 0xF49C, 0xFC5F, 0xF37E, 0x123D, 0xBB3, 0x2AC9, 0xBB3, 0x123D, + 0xF37E, 0xFFB0, 0xF4C6, 0xF96, 0x1111, 0x27E6, 0x1111, 0xF96, 0xF4C6, 0xFFAC, 0xF86F, 0xBB9, 0x17DC, 0x2581, + 0x17DC, 0xBB9, 0xF86F, 0xFBD1, 0x136, 0x547, 0xFF9A, 0x6D2E, 0xFF9A, 0x547, 0x136, 0xFAF9, 0xA9, 0x876, + 0xFFC9, 0x6527, 0xFFC9, 0x876, 0xA9, 0xF7D8, 0xFD47, 0xD04, 0xFC, 0x532C, 0xFC, 0xD04, 0xFD47, 0xF4A3, + 0xF8CA, 0xF21, 0x2E3, 0x4392, 0x2E3, 0xF21, 0xF8CA, 0xF60B, 0xF4A8, 0xFC4, 0x55B, 0x3942, 0x55B, 0xFC4, + 0xF4A8, 0xFA33, 0xF1B7, 0xF48, 0x887, 0x32C7, 0x887, 0xF48, 0xF1B7, 0xFEFB, 0xF11A, 0xD39, 0xC34, 0x2D26, + 0xC34, 0xD39, 0xF11A, 0x231, 0xF231, 0xA77, 0x114C, 0x2A8A, 0x114C, 0xA77, 0xF231, 0x24D, 0xF504, 0x6B6, + 0x18A8, 0x2A1E, 0x18A8, 0x6B6, 0xF504, 0xFED5, 0xFE28, 0x523, 0xA4, 0x6C1D, 0xA4, 0x523, 0xFE28, 0xFB5F, + 0xFC1F, 0x799, 0x161, 0x6036, 0x161, 0x799, 0xFC1F, 0xF9F1, 0xF77B, 0xA92, 0x35C, 0x4DD4, 0x35C, 0xA92, + 0xF77B, 0xFABD, 0xF335, 0xBA3, 0x5F1, 0x41FF, 0x5F1, 0xBA3, 0xF335, 0xFEC1, 0xF0FE, 0xAA5, 0x8C8, 0x37A5, + 0x8C8, 0xAA5, 0xF0FE, 0x379, 0xF0A3, 0x88A, 0xC45, 0x3123, 0xC45, 0x88A, 0xF0A3, 0x681, 0xF1B0, 0x597, + 0x114C, 0x2EC3, 0x114C, 0x597, 0xF1B0, 0x6D3, 0xF433, 0x15A, 0x18FF, 0x2FB1, 0x18FF, 0x15A, 0xF433, 0x400, + 0xFBCD, 0x432, 0x1A1, 0x6A64, 0x1A1, 0x432, 0xFBCD, 0xFE75, 0xF8FA, 0x5F1, 0x2E5, 0x5F76, 0x2E5, 0x5F1, + 0xF8FA, 0xFF32, 0xF497, 0x738, 0x592, 0x4C74, 0x592, 0x738, 0xF497, 0x323, 0xF25D, 0x671, 0x879, 0x3F40, + 0x879, 0x671, 0xF25D, 0x7A2, 0xF1F0, 0x464, 0xC22, 0x382B, 0xC22, 0x464, 0xF1F0, 0xAA6, 0xF31C, 0x116, + 0x1165, 0x360A, 0x1165, 0x116, 0xF31C, 0xB33, 0xF716, 0xFC6C, 0x16AC, 0x31CC, 0x16AC, 0xFC6C, 0xF716, 0x7DC, + 0xFAE6, 0x2AA, 0x289, 0x690C, 0x289, 0x2AA, 0xFAE6, 0x257, 0xF861, 0x35A, 0x431, 0x5CEB, 0x431, 0x35A, + 0xF861, 0x4BE, 0xF56F, 0x2F3, 0x799, 0x4C31, 0x799, 0x2F3, 0xF56F, 0x992, 0xF4D7, 0xCF, 0xBB4, 0x43CA, + 0xBB4, 0xCF, 0xF4D7, 0xCD9, 0xF72B, 0xFD2E, 0x1005, 0x3C41, 0x1005, 0xFD2E, 0xF72B, 0xC65, 0xFB74, 0xF89D, + 0x14A7, 0x361D, 0x14A7, 0xF89D, 0xFB74, 0x8B3, 0xFBA1, 0xCA, 0x365, 0x6A00, 0x365, 0xCA, 0xFBA1, 0x4E1, + 0xF9F7, 0x6C, 0x598, 0x6023, 0x598, 0x6C, 0xF9F7, 0x7C0, 0xF975, 0xFE28, 0x9E1, 0x5075, 0x9E1, 0xFE28, + 0xF975, 0xAFE, 0xFBF0, 0xFA6E, 0xE4D, 0x45D5, 0xE4D, 0xFA6E, 0xFBF0, 0xA4A, 0x69, 0xF5BE, 0x1307, 0x3E48, + 0x1307, 0xF5BE, 0x69, 0x64F, 0xFDD6, 0xFEBF, 0x42F, 0x6C27, 0x42F, 0xFEBF, 0xFDD6, 0x4A1, 0xFDCE, 0xFD40, + 0x6CA, 0x6253, 0x6CA, 0xFD40, 0xFDCE, 0x631, 0x49, 0xF92B, 0xBE5, 0x5444, 0xBE5, 0xF92B, 0x49, 0x5B2, + 0x480, 0xF570, 0xF2C, 0x4243, 0xF2C, 0xF570, 0x480, 0x140, 0xDE, 0xFCDA, 0x4C5, 0x6CD6, 0x4C5, 0xFCDA, + 0xDE, 0x194, 0x278, 0xFA97, 0x774, 0x6082, 0x774, 0xFA97, 0x278, 0xD0, 0x645, 0xF6DD, 0xB18, 0x4807, + 0xB18, 0xF6DD, 0x645, 0xFD0C, 0x35D, 0xFBC7, 0x4C8, 0x6500, 0x4C8, 0xFBC7, 0x35D, 0xFDC0, 0x58E, 0xF989, + 0x70C, 0x557D, 0x70C, 0xF989, 0x58E, 0xFBA3, 0x1B2, 0xFE3B, 0x1D3, 0x73D4, 0x1D3, 0xFE3B, 0x1B2, 0xFE6B +}; + +s16 BP_FILTER[] = { + 0x2AF, 0xFDA, 0x19C7, 0x1D78, 0x19C7, 0xFDA, 0x2AF, 0xF61C, 0xFAE9, 0xAD9, 0x18C1, 0x1E41, 0x18C1, 0xAD9, + 0xFAE9, 0xEFA7, 0xF4C7, 0x560, 0x172B, 0x1ECE, 0x172B, 0x560, 0xF4C7, 0xEE58, 0xEFF4, 0x0, 0x1719, 0x2213, + 0x1719, 0x0, 0xEFF4, 0xF061, 0xEF77, 0xFACA, 0x147A, 0x2247, 0x147A, 0xFACA, 0xEF77, 0xF6BD, 0xF0D6, 0xF60D, + 0x12C8, 0x24AD, 0x12C8, 0xF60D, 0xF0D6, 0xFC7C, 0xF400, 0xF1AC, 0x1147, 0x28C6, 0x1147, 0xF1AC, 0xF400, 0x0, + 0xF886, 0xEDFF, 0xF6E, 0x2E2B, 0xF6E, 0xEDFF, 0xF886, 0x0, 0xFD5A, 0xEB95, 0xCE5, 0x3489, 0xCE5, 0xEB95, + 0xFD5A, 0xFC79, 0xF6, 0xEB7E, 0x93B, 0x3A0A, 0x93B, 0xEB7E, 0xF6, 0xF773, 0x1FD, 0xED34, 0x4EE, 0x4046, + 0x4EE, 0xED34, 0x1FD, 0xF3B9, 0x0, 0xEECC, 0x0, 0x4F8F, 0x0, 0xEECC, 0x0, 0xF1F9, 0xFB81, 0xF56D, + 0xFA8F, 0x4DF2, 0xFA8F, 0xF56D, 0xFB81, 0xF6FA, 0xF91B, 0xF880, 0xF822, 0x4D58, 0xF822, 0xF880, 0xF91B, 0xF9E2, + 0xF3CE, 0x542, 0x1558, 0x1BD5, 0x1558, 0x542, 0xF3CE, 0xE970, 0xEE2A, 0x0, 0x145B, 0x1D41, 0x145B, 0x0, + 0xEE2A, 0xE9A5, 0xECB3, 0xFB0F, 0x117A, 0x1C51, 0x117A, 0xFB0F, 0xECB3, 0xEFC5, 0xECBC, 0xF681, 0xFB5, 0x1D7D, + 0xFB5, 0xF681, 0xECBC, 0xF671, 0xEE61, 0xF1FD, 0xE5E, 0x205E, 0xE5E, 0xF1FD, 0xEE61, 0xFC61, 0xF1B4, 0xED99, + 0xCF2, 0x24B4, 0xCF2, 0xED99, 0xF1B4, 0x0, 0xF659, 0xE9CB, 0xB04, 0x2A3A, 0xB04, 0xE9CB, 0xF659, 0x0, + 0xFB43, 0xE733, 0x84B, 0x30AF, 0x84B, 0xE733, 0xFB43, 0xFC5F, 0xFEF0, 0xE64B, 0x4A5, 0x3812, 0x4A5, 0xE64B, + 0xFEF0, 0xF6E9, 0x0, 0xE731, 0x0, 0x40DC, 0x0, 0xE731, 0x0, 0xF27C, 0xFE03, 0xED34, 0xFB12, 0x4046, + 0xFB12, 0xED34, 0xFE03, 0xF3B9, 0xFA30, 0xF333, 0xF6A5, 0x4011, 0xF6A5, 0xF333, 0xFA30, 0xF803, 0xF81B, 0xF605, + 0xF4A2, 0x400D, 0xF4A2, 0xF605, 0xF81B, 0xFA90, 0xEB5F, 0xFB40, 0xFD6, 0x1929, 0xFD6, 0xFB40, 0xEB5F, 0xEB9B, + 0xEA89, 0xF6E6, 0xDE0, 0x1962, 0xDE0, 0xF6E6, 0xEA89, 0xF249, 0xEAFF, 0xF26E, 0xC86, 0x1B4F, 0xC86, 0xF26E, + 0xEAFF, 0xF985, 0xED0B, 0xEDAB, 0xB4D, 0x1ECF, 0xB4D, 0xEDAB, 0xED0B, 0x0, 0xF1C2, 0xEA2E, 0x935, 0x21AF, + 0x935, 0xEA2E, 0xF1C2, 0x3C5, 0xF6BB, 0xE614, 0x71D, 0x2794, 0x71D, 0xE614, 0xF6BB, 0x3CB, 0xFBC2, 0xE154, + 0x45B, 0x3172, 0x45B, 0xE154, 0xFBC2, 0x0, 0x0, 0xE00A, 0x0, 0x39F5, 0x0, 0xE00A, 0x0, 0xF9E3, + 0x110, 0xE64B, 0xFB5B, 0x3812, 0xFB5B, 0xE64B, 0x110, 0xF6EA, 0xFF0A, 0xEB7E, 0xF6C5, 0x3A0A, 0xF6C5, 0xEB7E, + 0xFF0A, 0xF773, 0xFB31, 0xF18B, 0xF2BF, 0x3A53, 0xF2BF, 0xF18B, 0xFB31, 0xFB63, 0xF918, 0xF462, 0xF0E7, 0x3A85, + 0xF0E7, 0xF462, 0xF918, 0xFDC7, 0xE938, 0xF2C1, 0xB84, 0x18A1, 0xB84, 0xF2C1, 0xE938, 0xF7BC, 0xEA2D, 0xEDD9, + 0xA51, 0x1B66, 0xA51, 0xEDD9, 0xEA2D, 0x0, 0xEEF3, 0xEAC6, 0x80F, 0x1C8A, 0x80F, 0xEAC6, 0xEEF3, 0x6C6, + 0xF424, 0xE715, 0x5FE, 0x200D, 0x5FE, 0xE715, 0xF424, 0xA64, 0xF9D8, 0xE25E, 0x394, 0x26C7, 0x394, 0xE25E, + 0xF9D8, 0xA7A, 0x0, 0xDC77, 0x0, 0x321F, 0x0, 0xDC77, 0x0, 0x6CC, 0x43E, 0xE154, 0xFBA5, 0x3172, + 0xFBA5, 0xE154, 0x43E, 0x0, 0x4BD, 0xE733, 0xF7B5, 0x30AF, 0xF7B5, 0xE733, 0x4BD, 0xFC5F, 0x2A6, 0xEB95, + 0xF31B, 0x3489, 0xF31B, 0xEB95, 0x2A6, 0xFC79, 0xFE6A, 0xF068, 0xEE03, 0x39A7, 0xEE03, 0xF068, 0xFE6A, 0x0, + 0xFC2D, 0xF3F5, 0xECEE, 0x37CF, 0xECEE, 0xF3F5, 0xFC2D, 0x24D, 0xED74, 0xEB39, 0x76E, 0x19CF, 0x76E, 0xEB39, + 0xED74, 0x8AA, 0xF2B6, 0xE7FC, 0x553, 0x1BBD, 0x553, 0xE7FC, 0xF2B6, 0xEFD, 0xF8C3, 0xE3B2, 0x313, 0x2043, + 0x313, 0xE3B2, 0xF8C3, 0x127D, 0x0, 0xDDB7, 0x0, 0x28BE, 0x0, 0xDDB7, 0x0, 0x12AE, 0x628, 0xE25E, + 0xFC6C, 0x26C7, 0xFC6C, 0xE25E, 0x628, 0xA7A, 0x945, 0xE614, 0xF8E3, 0x2794, 0xF8E3, 0xE614, 0x945, 0x3CB, + 0x9A7, 0xE9CB, 0xF4FC, 0x2A3A, 0xF4FC, 0xE9CB, 0x9A7, 0x0, 0x77A, 0xEDFF, 0xF092, 0x2E2B, 0xF092, 0xEDFF, + 0x77A, 0x0, 0x34E, 0xF2C7, 0xEBB5, 0x32EB, 0xEBB5, 0xF2C7, 0x34E, 0x36B, 0xD6, 0xF54B, 0xE92F, 0x356F, + 0xE92F, 0xF54B, 0xD6, 0x5D4, 0xF83B, 0xE4A6, 0x2CC, 0x1CCD, 0x2CC, 0xE4A6, 0xF83B, 0x1758, 0x0, 0xDF09, + 0x0, 0x232E, 0x0, 0xDF09, 0x0, 0x1AE2, 0x73D, 0xE3B2, 0xFCED, 0x2043, 0xFCED, 0xE3B2, 0x73D, 0x127D, + 0xBDC, 0xE715, 0xFA02, 0x200D, 0xFA02, 0xE715, 0xBDC, 0xA64, 0xE3E, 0xEA2E, 0xF6CB, 0x21AF, 0xF6CB, 0xEA2E, + 0xE3E, 0x3C5, 0xE4C, 0xED99, 0xF30E, 0x24B4, 0xF30E, 0xED99, 0xE4C, 0x0, 0xC00, 0xF1AC, 0xEEB9, 0x28C6, + 0xEEB9, 0xF1AC, 0xC00, 0x0, 0x7D3, 0xF665, 0xE9E8, 0x2D88, 0xE9E8, 0xF665, 0x7D3, 0x365, 0x55E, 0xF8E4, + 0xE766, 0x3009, 0xE766, 0xF8E4, 0x55E, 0x5CB, 0x7C5, 0xE4A6, 0xFD34, 0x1CCD, 0xFD34, 0xE4A6, 0x7C5, 0x1758, + 0xD4A, 0xE7FC, 0xFAAD, 0x1BBD, 0xFAAD, 0xE7FC, 0xD4A, 0xEFD, 0x110D, 0xEAC6, 0xF7F1, 0x1C8A, 0xF7F1, 0xEAC6, + 0x110D, 0x6C6, 0x12F5, 0xEDAB, 0xF4B3, 0x1ECF, 0xF4B3, 0xEDAB, 0x12F5, 0x0, 0x119F, 0xF1FD, 0xF1A2, 0x205E, + 0xF1A2, 0xF1FD, 0x119F, 0xFC61, 0xF2A, 0xF60D, 0xED38, 0x24AD, 0xED38, 0xF60D, 0xF2A, 0xFC7C, 0xB7A, 0xFA92, + 0xE6E9, 0x2C00, 0xE6E9, 0xFA92, 0xB7A, 0x0, 0x8CD, 0xFD49, 0xE430, 0x2EB9, 0xE430, 0xFD49, 0x8CD, 0x29B, + 0x128C, 0xEB39, 0xF892, 0x19CF, 0xF892, 0xEB39, 0x128C, 0x8AA, 0x15D3, 0xEDD9, 0xF5AF, 0x1B66, 0xF5AF, 0xEDD9, + 0x15D3, 0x0, 0x1501, 0xF26E, 0xF37A, 0x1B4F, 0xF37A, 0xF26E, 0x1501, 0xF985, 0x1344, 0xF681, 0xF04B, 0x1D7D, + 0xF04B, 0xF681, 0x1344, 0xF671, 0x1089, 0xFACA, 0xEB86, 0x2247, 0xEB86, 0xFACA, 0x1089, 0xF6BD, 0xC92, 0x0, + 0xE485, 0x2A2B, 0xE485, 0x0, 0xC92, 0xFA48, 0x933, 0x2D5, 0xE2F0, 0x2B13, 0xE2F0, 0x2D5, 0x933, 0xFD46, + 0x16C8, 0xF2C1, 0xF47C, 0x18A1, 0xF47C, 0xF2C1, 0x16C8, 0xF7BC, 0x1577, 0xF6E6, 0xF220, 0x1962, 0xF220, 0xF6E6, + 0x1577, 0xF249, 0x134D, 0xFB0F, 0xEE86, 0x1C51, 0xEE86, 0xFB0F, 0x134D, 0xEFC5, 0x100C, 0x0, 0xE8E7, 0x2213, + 0xE8E7, 0x0, 0x100C, 0xF061, 0x94F, 0x57C, 0xE5BA, 0x2419, 0xE5BA, 0x57C, 0x94F, 0xF640, 0x617, 0x80F, + 0xE417, 0x2549, 0xE417, 0x80F, 0x617, 0xF96C, 0x14A1, 0xFB40, 0xF02A, 0x1929, 0xF02A, 0xFB40, 0x14A1, 0xEB9B, + 0x11D6, 0x0, 0xEBA5, 0x1D41, 0xEBA5, 0x0, 0x11D6, 0xE9A5, 0xB39, 0x560, 0xE8D5, 0x1ECE, 0xE8D5, 0x560, + 0xB39, 0xEE58, 0x459, 0xAC8, 0xE54F, 0x217C, 0xE54F, 0xAC8, 0x459, 0xF525, 0x10B, 0xD5C, 0xE385, 0x22EF, + 0xE385, 0xD5C, 0x10B, 0xF8B8, 0xC32, 0x542, 0xEAA8, 0x1BD5, 0xEAA8, 0x542, 0xC32, 0xE970, 0x517, 0xAD9, + 0xE73F, 0x1E41, 0xE73F, 0xAD9, 0x517, 0xEFA7, 0xFDA3, 0xF84, 0xE535, 0x1F3A, 0xE535, 0xF84, 0xFDA3, 0xF897, + 0xFACB, 0x1064, 0xE609, 0x1DBA, 0xE609, 0x1064, 0xFACB, 0xFCDD, 0xFD51, 0xFDA, 0xE639, 0x1D78, 0xE639, 0xFDA, + 0xFD51, 0xF61C, 0xF735, 0x11A8, 0xE7C7, 0x1AA5, 0xE7C7, 0x11A8, 0xF735, 0x0, 0xF5B4, 0x1151, 0xE97D, 0x186D, + 0xE97D, 0x1151, 0xF5B4, 0x34F, 0xF379, 0x111B, 0xEBD5, 0x153F, 0xEBD5, 0x111B, 0xF379, 0x722, 0xF2AA, 0x10DA, + 0xECCD, 0x1407, 0xECCD, 0x10DA, 0xF2AA, 0x92E, 0xF0F2, 0x105C, 0xEED2, 0x1175, 0xEED2, 0x105C, 0xF0F2, 0xD57 +}; + +s16 wm_sin[] = { 0x0, 0xC8B, 0x18F8, 0x2527, 0x30FB, 0x3C56, 0x471C, 0x5133, 0x5A81, 0x62F1, 0x6A6C, 0x70E1, 0x7640, + 0x7A7C, 0x7D89, 0x7F61, 0x7FFF, 0x7F61, 0x7D89, 0x7A7C, 0x7640, 0x70E1, 0x6A6C, 0x62F1, 0x5A81, 0x5133, + 0x471C, 0x3C56, 0x30FB, 0x2527, 0x18F8, 0xC8B, 0x0, 0xF375, 0xE708, 0xDAD9, 0xCF05, 0xC3AA, 0xB8E4, + 0xAECD, 0xA57F, 0x9D0F, 0x9594, 0x8F1F, 0x89C0, 0x8584, 0x8277, 0x809F, 0x8001, 0x809F, 0x8277, 0x8584, + 0x89C0, 0x8F1F, 0x9594, 0x9D0F, 0xA57F, 0xAECD, 0xB8E4, 0xC3AA, 0xCF05, 0xDAD9, 0xE708, 0xF375, 0x0, + 0x18F8, 0x30FB, 0x471C, 0x5A81, 0x6A6C, 0x7640, 0x7D89, 0x7FFF, 0x7D89, 0x7640, 0x6A6C, 0x5A81, 0x471C, + 0x30FB, 0x18F8, 0x0, 0xE708, 0xCF05, 0xB8E4, 0xA57F, 0x9594, 0x89C0, 0x8277, 0x8001, 0x8277, 0x89C0, + 0x9594, 0xA57F, 0xB8E4, 0xCF05, 0xE708, 0x0, 0x18F8, 0x30FB, 0x471C, 0x5A81, 0x6A6C, 0x7640, 0x7D89, + 0x7FFF, 0x7D89, 0x7640, 0x6A6C, 0x5A81, 0x471C, 0x30FB, 0x18F8, 0x0, 0xE708, 0xCF05, 0xB8E4, 0xA57F, + 0x9594, 0x89C0, 0x8277, 0x8001, 0x8277, 0x89C0, 0x9594, 0xA57F, 0xB8E4, 0xCF05, 0xE708, 0x0, 0x30FB, + 0x5A81, 0x7640, 0x7FFF, 0x7640, 0x5A81, 0x30FB, 0x0, 0xCF05, 0xA57F, 0x89C0, 0x8001, 0x89C0, 0xA57F, + 0xCF05, 0x0, 0x30FB, 0x5A81, 0x7640, 0x7FFF, 0x7640, 0x5A81, 0x30FB, 0x0, 0xCF05, 0xA57F, 0x89C0, + 0x8001, 0x89C0, 0xA57F, 0xCF05, 0x0, 0x30FB, 0x5A81, 0x7640, 0x7FFF, 0x7640, 0x5A81, 0x30FB, 0x0, + 0xCF05, 0xA57F, 0x89C0, 0x8001, 0x89C0, 0xA57F, 0xCF05, 0x0, 0x30FB, 0x5A81, 0x7640, 0x7FFF, 0x7640, + 0x5A81, 0x30FB, 0x0, 0xCF05, 0xA57F, 0x89C0, 0x8001, 0x89C0, 0xA57F, 0xCF05, 0x0, 0x5A81, 0x7FFF, + 0x5A81, 0x0, 0xA57F, 0x8001, 0xA57F, 0x0, 0x5A81, 0x7FFF, 0x5A81, 0x0, 0xA57F, 0x8001, 0xA57F, + 0x0, 0x5A81, 0x7FFF, 0x5A81, 0x0, 0xA57F, 0x8001, 0xA57F, 0x0, 0x5A81, 0x7FFF, 0x5A81, 0x0, + 0xA57F, 0x8001, 0xA57F, 0x0, 0x5A81, 0x7FFF, 0x5A81, 0x0, 0xA57F, 0x8001, 0xA57F, 0x0, 0x5A81, + 0x7FFF, 0x5A81, 0x0, 0xA57F, 0x8001, 0xA57F, 0x0, 0x5A81, 0x7FFF, 0x5A81, 0x0, 0xA57F, 0x8001, + 0xA57F, 0x0, 0x5A81, 0x7FFF, 0x5A81, 0x0, 0xA57F, 0x8001, 0xA57F }; + +s16* WAVEMEM_TABLE[] = { wm_sin, wm_sin, wm_sin, wm_sin, wm_sin, wm_sin, wm_sin, wm_sin, wm_sin }; + +f32 PCENTTABLE[] = { + 0.5f, 0.5f, 0.50273597f, 0.50548798f, 0.50825399f, 0.51103598f, 0.51383299f, 0.516645f, 0.519472f, + 0.522315f, 0.525174f, 0.52804798f, 0.530938f, 0.53384298f, 0.53676498f, 0.539702f, 0.542656f, 0.54562598f, + 0.548612f, 0.55161399f, 0.554633f, 0.55766898f, 0.56072098f, 0.563789f, 0.56687498f, 0.56997699f, 0.57309699f, + 0.576233f, 0.579387f, 0.58255798f, 0.58574599f, 0.58895099f, 0.592175f, 0.595415f, 0.598674f, 0.60194999f, + 0.60524499f, 0.60855699f, 0.61188799f, 0.61523598f, 0.61860299f, 0.621989f, 0.62539297f, 0.628815f, 0.63225698f, + 0.63571697f, 0.63919598f, 0.642694f, 0.64621198f, 0.649748f, 0.65330398f, 0.65688f, 0.660475f, 0.664089f, + 0.667724f, 0.671378f, 0.67505199f, 0.678747f, 0.682461f, 0.686196f, 0.689952f, 0.693727f, 0.697524f, + 0.70134097f, 0.70517999f, 0.70903897f, 0.712919f, 0.716821f, 0.720744f, 0.724689f, 0.72865498f, 0.73264199f, + 0.736652f, 0.74068397f, 0.744737f, 0.74881297f, 0.75291097f, 0.757031f, 0.76117498f, 0.76533997f, 0.76952899f, + 0.77373999f, 0.777975f, 0.78223199f, 0.78651297f, 0.79081798f, 0.79514599f, 0.799497f, 0.803873f, 0.808272f, + 0.81269598f, 0.81714398f, 0.82161599f, 0.82611197f, 0.83063298f, 0.83517897f, 0.83974999f, 0.84434599f, 0.848966f, + 0.853613f, 0.858284f, 0.86298198f, 0.86770397f, 0.87245297f, 0.877228f, 0.882029f, 0.886856f, 0.891709f, + 0.89658999f, 0.90149599f, 0.90643f, 0.911391f, 0.91637897f, 0.92139399f, 0.926436f, 0.93150699f, 0.936604f, + 0.94173f, 0.94688398f, 0.952066f, 0.957277f, 0.962516f, 0.96778297f, 0.97307998f, 0.978405f, 0.98376f, + 0.989144f, 0.994557f, 1.0f, 1.005473f, 1.010975f, 1.016508f, 1.022071f, 1.027665f, 1.033289f, + 1.038944f, 1.04463f, 1.050347f, 1.056095f, 1.061875f, 1.067687f, 1.07353f, 1.079405f, 1.085312f, + 1.091252f, 1.097224f, 1.103229f, 1.109267f, 1.115337f, 1.121441f, 1.127579f, 1.13375f, 1.139955f, + 1.146193f, 1.152466f, 1.1587729f, 1.165115f, 1.171491f, 1.177903f, 1.1843489f, 1.1908309f, 1.197348f, + 1.203901f, 1.210489f, 1.217114f, 1.223775f, 1.230473f, 1.237207f, 1.243978f, 1.2507859f, 1.2576309f, + 1.264514f, 1.2714339f, 1.278392f, 1.2853889f, 1.292423f, 1.299497f, 1.306608f, 1.313759f, 1.320949f, + 1.328178f, 1.335447f, 1.342756f, 1.350104f, 1.357493f, 1.364922f, 1.372392f, 1.379903f, 1.387455f, + 1.395048f, 1.402683f, 1.41036f, 1.4180779f, 1.4258389f, 1.433642f, 1.441488f, 1.4493769f, 1.457309f, + 1.4652849f, 1.473304f, 1.481367f, 1.489474f, 1.4976259f, 1.5058219f, 1.514063f, 1.522349f, 1.530681f, + 1.539058f, 1.5474809f, 1.55595f, 1.564465f, 1.573027f, 1.581636f, 1.590292f, 1.598995f, 1.607746f, + 1.616545f, 1.625392f, 1.634287f, 1.643231f, 1.6522239f, 1.661266f, 1.6703579f, 1.6795f, 1.688691f, + 1.697933f, 1.707225f, 1.7165689f, 1.725963f, 1.735409f, 1.7449059f, 1.754456f, 1.764058f, 1.773712f, + 1.783419f, 1.793179f, 1.802993f, 1.81286f, 1.822782f, 1.832757f, 1.842788f, 1.852873f, 1.863013f, + 1.873209f, 1.883461f, 1.893768f, 1.904132f, 1.914553f, 1.9250309f, 1.935567f, 1.946159f, 1.95681f, + 1.96752f, 1.978287f, 1.989114f, 2.0f, +}; + +f32 PCENTTABLE2[] = { + 0.890899f, 0.890899f, 0.89170998f, 0.892521f, 0.893333f, 0.894146f, 0.89495999f, 0.895774f, 0.89658999f, + 0.89740598f, 0.898222f, 0.89903998f, 0.899858f, 0.900677f, 0.90149599f, 0.90231699f, 0.90313798f, 0.90395999f, + 0.904783f, 0.90560597f, 0.90643f, 0.90725499f, 0.908081f, 0.908907f, 0.909734f, 0.91056198f, 0.911391f, + 0.91222f, 0.91305f, 0.913881f, 0.914713f, 0.91554499f, 0.91637897f, 0.917213f, 0.918047f, 0.918883f, + 0.91971898f, 0.920556f, 0.92139399f, 0.92223197f, 0.92307198f, 0.92391199f, 0.924752f, 0.92559397f, 0.926436f, + 0.927279f, 0.928123f, 0.928968f, 0.929813f, 0.93066f, 0.93150699f, 0.93235397f, 0.93320298f, 0.93405199f, + 0.934902f, 0.93575299f, 0.936604f, 0.937457f, 0.93831f, 0.93916398f, 0.940019f, 0.94087398f, 0.94173f, + 0.942587f, 0.943445f, 0.94430399f, 0.945163f, 0.94602299f, 0.94688398f, 0.94774598f, 0.94860798f, 0.949472f, + 0.95033598f, 0.951201f, 0.952066f, 0.952933f, 0.9538f, 0.95466799f, 0.955537f, 0.956406f, 0.957277f, + 0.958148f, 0.95902f, 0.95989299f, 0.960766f, 0.961641f, 0.962516f, 0.963392f, 0.964268f, 0.965146f, + 0.96602398f, 0.96690297f, 0.96778297f, 0.96866399f, 0.969546f, 0.97042799f, 0.97131097f, 0.972195f, 0.97307998f, + 0.97396499f, 0.974852f, 0.975739f, 0.97662699f, 0.977516f, 0.978405f, 0.979296f, 0.980187f, 0.98107898f, + 0.98197198f, 0.98286498f, 0.98376f, 0.984655f, 0.985551f, 0.98644799f, 0.98734599f, 0.988244f, 0.989144f, + 0.990044f, 0.99094498f, 0.99184698f, 0.99274898f, 0.993653f, 0.994557f, 0.995462f, 0.99636799f, 0.99727499f, + 0.998182f, 0.999091f, 1.0f, 1.00091f, 1.001821f, 1.002733f, 1.0036449f, 1.004559f, 1.005473f, + 1.0063879f, 1.007304f, 1.00822f, 1.009138f, 1.010056f, 1.010975f, 1.011896f, 1.012816f, 1.013738f, + 1.014661f, 1.015584f, 1.016508f, 1.017433f, 1.0183589f, 1.019286f, 1.020214f, 1.021142f, 1.022071f, + 1.023002f, 1.023933f, 1.024864f, 1.025797f, 1.026731f, 1.027665f, 1.0286f, 1.029536f, 1.030473f, + 1.031411f, 1.0323499f, 1.033289f, 1.03423f, 1.035171f, 1.036113f, 1.037056f, 1.038f, 1.038944f, + 1.03989f, 1.040836f, 1.041783f, 1.042731f, 1.04368f, 1.04463f, 1.045581f, 1.046532f, 1.047485f, + 1.048438f, 1.049392f, 1.050347f, 1.051303f, 1.05226f, 1.053217f, 1.054176f, 1.055135f, 1.056095f, + 1.057056f, 1.058018f, 1.0589809f, 1.059945f, 1.06091f, 1.061875f, 1.062842f, 1.063809f, 1.064777f, + 1.0657459f, 1.066716f, 1.067687f, 1.068658f, 1.069631f, 1.070604f, 1.071578f, 1.072554f, 1.07353f, + 1.074507f, 1.075485f, 1.076463f, 1.077443f, 1.078424f, 1.079405f, 1.080387f, 1.08137f, 1.082355f, + 1.08334f, 1.084325f, 1.085312f, 1.0863f, 1.087289f, 1.088278f, 1.089268f, 1.09026f, 1.091252f, + 1.092245f, 1.0932389f, 1.094234f, 1.09523f, 1.096226f, 1.097224f, 1.098223f, 1.0992219f, 1.100222f, + 1.1012239f, 1.102226f, 1.103229f, 1.104233f, 1.105238f, 1.106244f, 1.10725f, 1.108258f, 1.109267f, + 1.110276f, 1.111287f, 1.112298f, 1.11331f, 1.114323f, 1.115337f, 1.116352f, 1.117368f, 1.118385f, + 1.119403f, 1.120422f, 1.121441f, 1.122462f, + +}; + +f32 PITCHTABLE[] = { + 0.105112f, 0.111362f, 0.117984f, 0.125f, 0.132433f, 0.14030799f, 0.148651f, 0.15749f, + 0.166855f, 0.176777f, 0.187288f, 0.19842499f, 0.210224f, 0.222725f, 0.235969f, 0.25f, + 0.26486599f, 0.28061599f, 0.297302f, 0.31498f, 0.33371f, 0.353553f, 0.37457699f, 0.39684999f, + 0.420448f, 0.44544899f, 0.471937f, 0.5f, 0.52973199f, 0.561231f, 0.594604f, 0.629961f, + 0.66742f, 0.707107f, 0.74915397f, 0.79370099f, 0.840897f, 0.890899f, 0.943875f, 1.0f, + 1.059463f, 1.122462f, 1.189207f, 1.259921f, 1.33484f, 1.414214f, 1.498307f, 1.587401f, + 1.681793f, 1.781798f, 1.887749f, 2.0f, 2.118926f, 2.244924f, 2.3784139f, 2.5198419f, + 2.66968f, 2.828428f, 2.9966149f, 3.174803f, 3.3635859f, 3.563596f, 3.7754979f, 4.0f, + 4.237853f, 4.489849f, 4.7568288f, 5.0396848f, 5.33936f, 5.656855f, 5.9932289f, 6.349606f, + 6.7271729f, 7.127192f, 7.5509958f, 8.0f, 8.475705f, 8.979697f, 9.5136576f, 10.07937f, + 10.67872f, 11.31371f, 11.986459f, 12.699211f, 13.454346f, 14.254383f, 15.101993f, 16.0f, + 16.95141f, 17.959394f, 19.027315f, 20.158739f, 21.35744f, 22.62742f, 23.972918f, 25.398422f, + 26.908691f, 28.508766f, 30.203985f, 32.0f, 33.90282f, 35.918789f, 38.05463f, 40.317478f, + 42.71488f, 45.25484f, 47.945835f, 50.796844f, 53.817383f, 57.017532f, 60.40797f, 64.0f, + 67.80564f, 71.837578f, 76.10926f, 80.634956f, 85.42976f, 0.055681f, 0.058991998f, 0.0625f, + 0.066215999f, 0.070153996f, 0.074325f, 0.078745f, 0.083426997f, 0.088388f, 0.093644f, 0.099212997f, +}; + +u8 DEFAULT_VTABLE[] = { + 0x0c, 0x19, 0x26, 0x33, 0x39, 0x40, 0x47, 0x4c, 0x53, 0x59, 0x60, 0x66, 0x6d, 0x73, 0x79, 0x7f +}; + +u8 DEFAULT_GTABLE[] = { + 0xe5, 0xcb, 0xb1, 0x97, 0x8b, 0x7e, 0x71, 0x64, 0x57, 0x4a, 0x3d, 0x30, 0x24, 0x17, 0x0a, 0x00 +}; + +envdat DEFAULT_ENV[] = { + { 1, 32000 }, + { 1000, 32000 }, + { -1, 0 }, + { 0, 0 }, +}; + +commonch NA_CHINIT_TABLE[1] = { { FALSE } }; + +commonch NA_SVCINIT_TABLE[1] = { { TRUE, TRUE } }; + +u16 CDELAYTABLE[] = { 0x3C, 0x3A, 0x38, 0x36, 0x34, 0x32, 0x30, 0x2E, 0x2C, 0x2A, 0x28, 0x26, 0x24, 0x22, 0x20, 0x1E, + 0x1C, 0x1A, 0x18, 0x16, 0x14, 0x12, 0x10, 0x0E, 0x0C, 0x0A, 0x08, 0x06, 0x04, 0x02, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; + +f32 PhoneLeft[] = { + 1.0f, 0.995386f, 0.990772f, 0.986157f, 0.981543f, 0.976929f, 0.972315f, 0.967701f, 0.963087f, + 0.958472f, 0.953858f, 0.949244f, 0.94463f, 0.94001597f, 0.93540198f, 0.930787f, 0.92617297f, 0.92155898f, + 0.91694498f, 0.91233099f, 0.90771699f, 0.90310198f, 0.89848799f, 0.89387399f, 0.88925999f, 0.884646f, 0.88003099f, + 0.87541699f, 0.870803f, 0.866189f, 0.861575f, 0.856961f, 0.852346f, 0.847732f, 0.843118f, 0.838504f, + 0.83389f, 0.829276f, 0.824661f, 0.820047f, 0.815433f, 0.81081897f, 0.80620497f, 0.80159098f, 0.79697597f, + 0.79236197f, 0.78774798f, 0.78313398f, 0.77851999f, 0.77390599f, 0.76929098f, 0.76467699f, 0.76006299f, 0.755449f, + 0.750835f, 0.74621999f, 0.741606f, 0.736992f, 0.732378f, 0.727764f, 0.72315f, 0.718535f, 0.713921f, + 0.709307f, 0.70537f, 0.70210999f, 0.69884998f, 0.69559097f, 0.692331f, 0.689071f, 0.68581098f, 0.682551f, + 0.679291f, 0.67603099f, 0.67277199f, 0.66951197f, 0.666252f, 0.662992f, 0.65973198f, 0.656472f, 0.653213f, + 0.649953f, 0.64669299f, 0.64343297f, 0.640173f, 0.636913f, 0.633654f, 0.63039398f, 0.627134f, 0.623874f, + 0.62061399f, 0.61735398f, 0.614094f, 0.610835f, 0.607575f, 0.60431498f, 0.601055f, 0.597795f, 0.59453499f, + 0.59127599f, 0.58801597f, 0.584756f, 0.581496f, 0.57823598f, 0.574976f, 0.571717f, 0.568457f, 0.56519699f, + 0.56193697f, 0.558677f, 0.555417f, 0.55215698f, 0.54889798f, 0.545638f, 0.542378f, 0.53911799f, 0.53585798f, + 0.532598f, 0.529339f, 0.526079f, 0.52281898f, 0.519559f, 0.516299f, 0.51303899f, 0.50977999f, 0.50651997f, + 0.50326f, 0.5f, +}; + +f32 WideLeft[] = { + 0.707f, 0.716228f, 0.725457f, 0.734685f, 0.74391299f, 0.753142f, 0.76236999f, 0.77159798f, + 0.78082699f, 0.79005498f, 0.799283f, 0.80851197f, 0.81774f, 0.826968f, 0.836197f, 0.845425f, + 0.854654f, 0.863882f, 0.87311f, 0.882339f, 0.89156699f, 0.90079498f, 0.91002399f, 0.91925198f, + 0.92848f, 0.93770897f, 0.946937f, 0.956165f, 0.965394f, 0.974622f, 0.98385f, 0.993079f, + 0.997693f, 0.988465f, 0.979236f, 0.970008f, 0.960779f, 0.951551f, 0.942323f, 0.93309498f, + 0.92386597f, 0.91463798f, 0.90540898f, 0.89618099f, 0.886953f, 0.87772399f, 0.868496f, 0.859268f, + 0.850039f, 0.840811f, 0.831583f, 0.822354f, 0.813126f, 0.80389798f, 0.79466897f, 0.78544098f, + 0.77621299f, 0.76698399f, 0.75775599f, 0.748528f, 0.739299f, 0.730071f, 0.720843f, 0.711614f, + 0.69586599f, 0.67359799f, 0.651331f, 0.629063f, 0.606795f, 0.584528f, 0.56225997f, 0.53999197f, + 0.51772398f, 0.49545699f, 0.473189f, 0.450921f, 0.42865399f, 0.40638599f, 0.38411799f, 0.36184999f, + 0.339583f, 0.317315f, 0.29504699f, 0.27278f, 0.250512f, 0.228244f, 0.20597599f, 0.183709f, + 0.161441f, 0.139173f, 0.116905f, 0.094637997f, 0.07237f, 0.050101999f, 0.027835f, 0.0055669998f, + 0.0083499998f, 0.019484f, 0.030618f, 0.041751999f, 0.052886f, 0.06402f, 0.075153999f, 0.086286999f, + 0.097420998f, 0.108555f, 0.119689f, 0.130823f, 0.141957f, 0.153091f, 0.164224f, 0.175358f, + 0.186492f, 0.19762599f, 0.20875999f, 0.219894f, 0.231028f, 0.242161f, 0.253295f, 0.264429f, + 0.275563f, 0.286697f, 0.297831f, 0.308965f, 0.320098f, 0.331232f, 0.342366f, 0.3535f, + +}; +f32 StereoLeft[] = { + 1.0f, 0.999924f, 0.99969399f, 0.99931198f, 0.998776f, 0.998088f, 0.99724799f, 0.996254f, + 0.995109f, 0.993811f, 0.992361f, 0.990759f, 0.98900598f, 0.987101f, 0.985045f, 0.98283899f, + 0.98048198f, 0.977976f, 0.97531998f, 0.97251397f, 0.96956f, 0.966457f, 0.963207f, 0.959809f, + 0.95626497f, 0.952574f, 0.948737f, 0.944755f, 0.940629f, 0.93635899f, 0.93194598f, 0.92738998f, + 0.922692f, 0.917853f, 0.912873f, 0.907754f, 0.90249699f, 0.89710099f, 0.89156699f, 0.88589799f, + 0.88009298f, 0.874153f, 0.868079f, 0.86187297f, 0.85553497f, 0.849066f, 0.842467f, 0.835739f, + 0.828884f, 0.821901f, 0.81479299f, 0.80756098f, 0.80020398f, 0.792725f, 0.785125f, 0.777405f, + 0.769566f, 0.76160997f, 0.75353599f, 0.74534798f, 0.73704499f, 0.72863f, 0.720103f, 0.711466f, + 0.70271999f, 0.693867f, 0.68490797f, 0.675843f, 0.66667598f, 0.65740597f, 0.648036f, 0.63856697f, + 0.629f, 0.619337f, 0.609579f, 0.59972799f, 0.58978498f, 0.579752f, 0.56963f, 0.559421f, + 0.549126f, 0.538748f, 0.52828699f, 0.517745f, 0.507124f, 0.496425f, 0.48565099f, 0.47480199f, + 0.46388f, 0.452888f, 0.44182599f, 0.43069699f, 0.41950199f, 0.408243f, 0.396921f, 0.385538f, + 0.37409699f, 0.362598f, 0.351044f, 0.33943599f, 0.327776f, 0.316066f, 0.304308f, 0.292503f, + 0.280653f, 0.268761f, 0.256827f, 0.244854f, 0.232844f, 0.220798f, 0.208718f, 0.196606f, + 0.184465f, 0.172295f, 0.160098f, 0.14787699f, 0.135634f, 0.12337f, 0.111087f, 0.098785996f, + 0.086470999f, 0.074143f, 0.061802998f, 0.049454f, 0.037097f, 0.024734f, 0.012368f, 0.0f, +}; + +u8 BDB_SEQDATA[] = { 0xd3, 0x20, 0xd5, 0x3c, 0xda, 0x01, 0x00, 0x0a, 0xdb, 0x7f, 0xdd, 0xc8, 0xd7, 0xff, 0xff, 0x90, + 0x00, 0x18, 0xfd, 0x8c, 0x80, 0xf4, 0xfb, 0xff, 0xec, 0xe8, 0x00, 0x00, 0xff, 0x00, 0x40, 0x40, + 0x00, 0x00, 0xd0, 0x00, 0xdc, 0x00, 0xc3, 0xdf, 0x7f, 0xe0, 0x7f, 0xd8, 0x00, 0xd7, 0x60, 0xfe, + 0x60, 0xf2, 0xfc, 0xc7, 0x00, 0x00, 0xa4, 0xc7, 0x00, 0x00, 0x9a, 0x74, 0x61, 0xc7, 0x00, 0x00, + 0x47, 0x62, 0xc7, 0x00, 0x00, 0x49, 0xc6, 0x00, 0xc1, 0x00, 0xc8, 0x7e, 0xf3, 0x09, 0xc8, 0x01, + 0xf3, 0x21, 0x88, 0x00, 0x98, 0xf4, 0x1f, 0x88, 0x00, 0x9c, 0xcc, 0x00, 0xc7, 0x00, 0x00, 0xa4, + 0x64, 0xc7, 0x00, 0x00, 0xa5, 0xfe, 0x60, 0xf5, 0x00, 0x71, 0x64, 0xf5, 0x00, 0x65, 0x90, 0xf4, + 0xbe, 0xf4, 0xee, 0x88, 0x00, 0x9c, 0xcc, 0x00, 0xc7, 0x00, 0x00, 0xa5, 0xfe, 0x60, 0xf5, 0x00, + 0x88, 0x64, 0xf5, 0x00, 0x7c, 0x90, 0xf4, 0xa7, 0xc7, 0x00, 0x00, 0xa4, 0x74, 0xf4, 0xed, 0x42, + 0x6e, 0x6b, 0x50, 0x72, 0x67, 0x4f, 0x6e, 0x00, 0xc7, 0x05, 0x27, 0x08, 0xca, 0x40, 0xc1, 0x7f, + 0xc9, 0x00, 0xc4, 0xc2, 0x00, 0x00, 0x80, 0x04, 0xf4, 0xf9, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00 }; From 30516f42b338eb397472bfc3011fbf15f88bcb87 Mon Sep 17 00:00:00 2001 From: roeming Date: Thu, 3 Jul 2025 17:25:02 -0400 Subject: [PATCH 4/6] link audiowork --- configure.py | 2 +- src/static/jaudio_NES/internal/audiowork.c | 8 ++++++++ 2 files changed, 9 insertions(+), 1 deletion(-) create mode 100644 src/static/jaudio_NES/internal/audiowork.c diff --git a/configure.py b/configure.py index 0241db58..b481c13b 100644 --- a/configure.py +++ b/configure.py @@ -760,7 +760,7 @@ config.libs = [ Object(Matching, "jaudio_NES/internal/aramcall.c"), Object(Matching, "jaudio_NES/internal/audioconst.c"), Object(Matching, "jaudio_NES/internal/audiotable.c"), - Object(NonMatching, "jaudio_NES/internal/audiowork.c"), + Object(Matching, "jaudio_NES/internal/audiowork.c"), Object(Matching, "jaudio_NES/internal/bankdrv.c", extra_cflags=["-pragma \"scheduling 7400\""]), Object(Matching, "jaudio_NES/internal/bankread.c"), Object(Matching, "jaudio_NES/internal/centcalc.c"), diff --git a/src/static/jaudio_NES/internal/audiowork.c b/src/static/jaudio_NES/internal/audiowork.c new file mode 100644 index 00000000..44a4d6d3 --- /dev/null +++ b/src/static/jaudio_NES/internal/audiowork.c @@ -0,0 +1,8 @@ +#include "jaudio_NES/audiowork.h" + +AudioGlobals AG; +VFRAME_CALLBACK NA_VFRAME_CALLBACK; +SequenceCallback NA_CALLBACK; +GRP_CALLBACK NA_GRP_CALLBACK; +SOUND_CALLBACK NA_SOUND_CALLBACK; +DACOUT_CALLBACK NA_DACOUT_CALLBACK; From b9fd1250a442c9ae70cf6128f60f5e56caf25f05 Mon Sep 17 00:00:00 2001 From: roeming Date: Fri, 4 Jul 2025 12:53:40 -0400 Subject: [PATCH 5/6] jaudio memory almost fully matched --- include/jaudio_NES/channel.h | 3 + include/jaudio_NES/memory.h | 2 +- include/jaudio_NES/system.h | 5 + src/static/jaudio_NES/internal/memory.c | 1446 ++++++++++++++++++++--- src/static/jaudio_NES/internal/system.c | 174 +-- 5 files changed, 1363 insertions(+), 267 deletions(-) diff --git a/include/jaudio_NES/channel.h b/include/jaudio_NES/channel.h index bfab8930..21d66d1d 100644 --- a/include/jaudio_NES/channel.h +++ b/include/jaudio_NES/channel.h @@ -22,5 +22,8 @@ extern void Nas_Release_Channel_Force(note* n); extern void Nas_EntryTrack(channel* chan, note* n); extern void Nas_CutList(link* l); +extern void Nas_StopVoice(channel* chan); +extern void Nas_ChannelInit(void); +extern void Nas_InitChannelList(void); #endif diff --git a/include/jaudio_NES/memory.h b/include/jaudio_NES/memory.h index cdac9215..8b27782c 100644 --- a/include/jaudio_NES/memory.h +++ b/include/jaudio_NES/memory.h @@ -14,7 +14,7 @@ extern void* Nas_Alloc_Single(s32 size, s32 bank_id, u8* wave_addr, s8 medium, s extern void* Nas_CacheOff(u8* addr, s32 size); extern void* Nas_SzHeapAlloc(s32 table_type, s32 size, s32 cache_type, s32 id); -extern u32 Nas_SzCacheCheck(s32 type, s32 cache_type, s32 id); +extern void* Nas_SzCacheCheck(s32 type, s32 cache_type, s32 id); extern void Nas_SzStayDelete(s32 type); extern void Nas_SzHeapReset(u32 fix_size); diff --git a/include/jaudio_NES/system.h b/include/jaudio_NES/system.h index 1e5ba751..9162905c 100644 --- a/include/jaudio_NES/system.h +++ b/include/jaudio_NES/system.h @@ -55,6 +55,11 @@ extern void LpsDma(s32 reset_status); extern s32 Nas_CheckBgWave(s32 reset_status); extern void Nas_BgCopyMain(s32 reset_status); +extern void EmemReload(void); +extern void Nas_BgCopyInit(void); +extern void MK_Init(void); +extern void Nas_WaveDmaNew(s32 n_channels); + extern BOOL AUDIO_SYSTEM_READY; extern Na_DmaProc NA_DMA_PROC; extern OSMesgQueue MK_QUEUE; diff --git a/src/static/jaudio_NES/internal/memory.c b/src/static/jaudio_NES/internal/memory.c index 0adebabb..690aec4f 100644 --- a/src/static/jaudio_NES/internal/memory.c +++ b/src/static/jaudio_NES/internal/memory.c @@ -1,13 +1,32 @@ #include "jaudio_NES/memory.h" +#include "jaudio_NES/audioconst.h" +#include "jaudio_NES/audiowork.h" +#include "jaudio_NES/channel.h" +#include "jaudio_NES/track.h" +#include "jaudio_NES/os.h" +#include "jaudio_NES/system.h" +#include "dolphin/os.h" + +void DirtyWave(s32); +void* __Nas_SzCacheCheck_Inner(s32 a, s32 b, s32 c); +void __RomAddrSet(SwMember*, smzwavetable*); +SwMember* __Nas_Alloc_Single_Stay_Inner(s32 a); +SwMember* __Nas_Alloc_Single_Auto_Inner(s32 a); +void __ExchangeWave(s32, s32); +void __KillSwMember(SwMember* a); +void __Nas_MemoryReconfig(); +void Emem_KillSwMember(); +void Dirty_AllWave(); +void Nas_SetDelayLine(s32 a, fxconfig* b, s32 c); +int Nas_Init_Single(s32, s32); /* * --INFO-- * Address: ........ * Size: 00001C */ -void __CalcRelf(f32) -{ - // UNUSED FUNCTION +f32 __CalcRelf(f32 val) { + return (AG.audio_params.updates_per_frame_inverse_scaled * 256.f) / val; } /* @@ -15,9 +34,23 @@ void __CalcRelf(f32) * Address: ........ * Size: 000170 */ -void MakeReleaseTable() -{ - // UNUSED FUNCTION +void MakeReleaseTable() { + int i; + AG.adsr_decay_table[0xff] = __CalcRelf(0.25f); + AG.adsr_decay_table[0xfe] = __CalcRelf(0.33f); + AG.adsr_decay_table[0xfd] = __CalcRelf(0.5f); + AG.adsr_decay_table[0xfc] = __CalcRelf(0.66f); + AG.adsr_decay_table[0xfb] = __CalcRelf(0.75f); + for (i = 0x80; i < 0xfb; i++) { + AG.adsr_decay_table[i] = __CalcRelf(0xfb - i); + } + for (i = 0x10; i < 0x80; i++) { + AG.adsr_decay_table[i] = __CalcRelf((0x80 - i) * 4 + 0x3c); + } + for (i = 1; i < 0x10; i++) { + AG.adsr_decay_table[i] = __CalcRelf((0xf - i) * 0x3c + 0x1e0); + } + AG.adsr_decay_table[0] = 0.f; } /* @@ -25,9 +58,20 @@ void MakeReleaseTable() * Address: ........ * Size: 0000A0 */ -void Nas_ResetIDtable() -{ - // UNUSED FUNCTION +void Nas_ResetIDtable() { + int i; + for (i = 0; i < ARRAY_COUNT(AG.bank_load_status); i++) { + if (AG.bank_load_status[i] != 5) + AG.bank_load_status[i] = 0; + } + for (i = 0; i < ARRAY_COUNT(AG.wave_load_status); i++) { + if (AG.wave_load_status[i] != 5) + AG.wave_load_status[i] = 0; + } + for (i = 0; i < ARRAY_COUNT(AG.sequence_load_status); i++) { + if (AG.sequence_load_status[i] != 5) + AG.sequence_load_status[i] = 0; + } } /* @@ -35,9 +79,20 @@ void Nas_ResetIDtable() * Address: ........ * Size: 0000E0 */ -void Nas_ForceStopChannel(s32) -{ - // UNUSED FUNCTION +void Nas_ForceStopChannel(s32 bankID) { + int i; + for (i = 0; i < AG.num_channels; i++) { + channel* channel = &AG.channels[i]; + if (channel->playback_ch.bank_id == bankID) { + if (channel->playback_ch.status == 0 && channel->playback_ch.priority != 0) { + channel->playback_ch.current_parent_note->enabled = FALSE; + channel->playback_ch.current_parent_note->finished = TRUE; + } + Nas_StopVoice(channel); + Nas_CutList(&channel->link); + Nas_AddList(&AG.channel_node.freeList, &channel->link); + } + } } /* @@ -45,9 +100,8 @@ void Nas_ForceStopChannel(s32) * Address: ........ * Size: 00006C */ -void Nas_ForceReleaseChannel(s32) -{ - // UNUSED FUNCTION +void Nas_ForceReleaseChannel(s32 param_1) { + // UNUSED FUNCTION } /* @@ -55,9 +109,13 @@ void Nas_ForceReleaseChannel(s32) * Address: ........ * Size: 000084 */ -void Nas_ForceStopSeq(s32) -{ - // UNUSED FUNCTION +void Nas_ForceStopSeq(s32 id) { + int i; + for (i = 0; i < AG.audio_params.num_groups; i++) { + if (AG.groups[i].flags.enabled && AG.groups[i].seq_id == id) { + Nas_ReleaseGroup(AG.groups_p[i]); + } + } } /* @@ -65,9 +123,9 @@ void Nas_ForceStopSeq(s32) * Address: ........ * Size: 000030 */ -void* Nas_CacheOff(u8*, s32) -{ - // UNUSED FUNCTION +void* Nas_CacheOff(u8* vaddr, s32 nbytes) { + osWritebackDCache2(vaddr, nbytes); + return vaddr; } /* @@ -75,9 +133,15 @@ void* Nas_CacheOff(u8*, s32) * Address: ........ * Size: 00006C */ -void Nas_2ndHeapAlloc_CL(ALHeap*, s32) -{ - // UNUSED FUNCTION +void* Nas_2ndHeapAlloc_CL(ALHeap* heap, s32 size) { + void* ret = NULL; + if (AG.external_heap.base != NULL) { + ret = Nas_HeapAlloc_CL(&AG.external_heap, size); + } + if (ret == NULL) { + ret = Nas_HeapAlloc_CL(heap, size); + } + return ret; } /* @@ -85,9 +149,15 @@ void Nas_2ndHeapAlloc_CL(ALHeap*, s32) * Address: ........ * Size: 00006C */ -void* Nas_2ndHeapAlloc(ALHeap*, s32) -{ - // UNUSED FUNCTION +void* Nas_2ndHeapAlloc(ALHeap* heap, s32 size) { + void* ret = NULL; + if (AG.external_heap.base != NULL) { + ret = Nas_HeapAlloc(&AG.external_heap, size); + } + if (ret == NULL) { + ret = Nas_HeapAlloc(heap, size); + } + return ret; } /* @@ -95,9 +165,12 @@ void* Nas_2ndHeapAlloc(ALHeap*, s32) * Address: ........ * Size: 00003C */ -void* Nas_NcHeapAlloc(ALHeap*, s32) -{ - // UNUSED FUNCTION +void* Nas_NcHeapAlloc(ALHeap* heap, s32 size) { + void* ret = Nas_HeapAlloc(heap, size); + if (ret != NULL) { + ret = Nas_CacheOff((u8*)ret, size); + } + return ret; } /* @@ -105,9 +178,12 @@ void* Nas_NcHeapAlloc(ALHeap*, s32) * Address: ........ * Size: 00003C */ -void Nas_NcHeapAlloc_CL(ALHeap*, s32) -{ - // UNUSED FUNCTION +void* Nas_NcHeapAlloc_CL(ALHeap* heap, s32 size) { + void* ret = Nas_HeapAlloc_CL(heap, size); + if (ret != NULL) { + ret = Nas_CacheOff((u8*)ret, size); + } + return ret; } /* @@ -115,9 +191,16 @@ void Nas_NcHeapAlloc_CL(ALHeap*, s32) * Address: ........ * Size: 000054 */ -void* Nas_HeapAlloc_CL(ALHeap*, s32) -{ - // UNUSED FUNCTION +void* Nas_HeapAlloc_CL(ALHeap* heap, s32 size) { + // int i; + void* ret = Nas_HeapAlloc(heap, size); + if (ret != NULL) { + u8* i = (u8*)ret; + while (i < heap->current) { + *i++ = 0; + } + } + return ret; } /* @@ -125,9 +208,8 @@ void* Nas_HeapAlloc_CL(ALHeap*, s32) * Address: ........ * Size: 000048 */ -void Nas_TmpAlloc(ALHeap*, s32) -{ - // UNUSED FUNCTION +void Nas_TmpAlloc(ALHeap* param_1, s32 param_2) { + // UNUSED FUNCTION } /* @@ -135,9 +217,8 @@ void Nas_TmpAlloc(ALHeap*, s32) * Address: ........ * Size: 000034 */ -void Nas_HeapFree(ALHeap*) -{ - // UNUSED FUNCTION +void Nas_HeapFree(ALHeap* param_1) { + // UNUSED FUNCTION } /* @@ -145,26 +226,26 @@ void Nas_HeapFree(ALHeap*) * Address: 80005640 * Size: 00006C */ -void* Nas_HeapAlloc(ALHeap* heap, s32 size) -{ - s32* REF_size; +void* Nas_HeapAlloc(ALHeap* heap, s32 size) { + s32* REF_size; - REF_size = &size; - u32 roundedSize = ALIGN_NEXT(size, 32); - if (!heap->base) { - return NULL; - } + REF_size = &size; + u32 roundedSize = ALIGN_NEXT(size, 32); + if (!heap->base) { + OSReport("Warning: Not Allocated Heap\n"); + return NULL; + } - u8* prev = heap->current; - if (prev + roundedSize <= heap->base + heap->length) { - heap->current = prev + roundedSize; - } else { - return NULL; - } + u8* prev = heap->current; + if (prev + roundedSize <= heap->base + heap->length) { + heap->current = prev + roundedSize; + } else { + return NULL; + } - heap->count++; - heap->last = prev; - return prev; + heap->count++; + heap->last = prev; + return prev; } /* @@ -172,25 +253,25 @@ void* Nas_HeapAlloc(ALHeap* heap, s32 size) * Address: 800056C0 * Size: 000058 */ -void Nas_HeapInit(ALHeap* heap, u8* p2, s32 p3) -{ - ALHeap** REF_heap; +void Nas_HeapInit(ALHeap* heap, u8* p2, s32 p3) { + ALHeap** REF_heap; - int length; + int length; - REF_heap = &heap; - heap->count = 0; - if (!p2) { - heap->length = 0; - heap->current = NULL; - heap->last = NULL; - } else { - length = p3 - ((u32)p2 & 0x1F); - heap->base = (u8*)ALIGN_NEXT((u32)p2, 32); - heap->current = heap->base; - heap->length = length; - heap->last = NULL; - } + REF_heap = &heap; + heap->count = 0; + if (!p2) { + OSReport("Warning: 0 base heap.\n"); + heap->length = 0; + heap->current = NULL; + heap->last = NULL; + } else { + length = p3 - ((u32)p2 & 0x1F); + heap->base = (u8*)ALIGN_NEXT((u32)p2, 32); + heap->current = heap->base; + heap->length = length; + heap->last = NULL; + } } /* @@ -198,9 +279,10 @@ void Nas_HeapInit(ALHeap* heap, u8* p2, s32 p3) * Address: ........ * Size: 000018 */ -void Nas_SzStayClear(SZStay*) -{ - // UNUSED FUNCTION +void Nas_SzStayClear(SZStay* p1) { + p1->heap.current = p1->heap.base; + p1->heap.count = NULL; + p1->num_entries = 0; } /* @@ -208,9 +290,14 @@ void Nas_SzStayClear(SZStay*) * Address: ........ * Size: 00003C */ -void Nas_SzAutoClear(SZAuto*) -{ - // UNUSED FUNCTION +void Nas_SzAutoClear(SZAuto* p1) { + p1->heap.current = p1->heap.base; + p1->heap.count = 0; + p1->use_entry_idx = 0; + p1->entries[0].addr = p1->heap.base; + p1->entries[1].addr = p1->heap.base + p1->heap.length; + p1->entries[0].id = -1; + p1->entries[1].id = -1; } /* @@ -228,9 +315,36 @@ void Nas_SzAutoClear(SZAuto*) * Address: ........ * Size: 00010C */ -void Nas_SzStayDelete(s32) -{ - // UNUSED FUNCTION +void Nas_SzStayDelete(s32 a) { + SZHeap* r31; + u8* r30; + switch (a) { + case SEQUENCE_TABLE: { + r31 = &AG.seq_heap; + r30 = AG.sequence_load_status; + } break; + case BANK_TABLE: { + r31 = &AG.bank_heap; + r30 = AG.bank_load_status; + } break; + case WAVE_TABLE: { + r31 = &AG.wave_heap; + r30 = AG.wave_load_status; + } break; + } + ALHeap* heap = &r31->stay_heap.heap; + if (r31->stay_heap.num_entries != 0) { + heap->current = r31->stay_heap.entries[r31->stay_heap.num_entries - 1].addr; + heap->count--; + if (a == 2) { + DirtyWave(r31->stay_heap.entries[r31->stay_heap.num_entries - 1].id); + } + if (a == 1) { + Nas_ForceStopChannel(r31->stay_heap.entries[r31->stay_heap.num_entries - 1].id); + } + r30[r31->stay_heap.entries[r31->stay_heap.num_entries - 1].id] = 0; + r31->stay_heap.num_entries--; + } } /* @@ -238,9 +352,11 @@ void Nas_SzStayDelete(s32) * Address: ........ * Size: 000068 */ -void Nas_SzHeapReset(u32) -{ - // UNUSED FUNCTION +void Nas_SzHeapReset(u32 fixSize) { + OSReport("FixSIZE is %x\n", fixSize); + Nas_HeapInit(&AG.init_heap, (u8*)AG.audio_heap_p, fixSize); + Nas_HeapInit(&AG.session_heap, (u8*)AG.audio_heap_p + fixSize, AG.audio_heap_size - fixSize); + AG.external_heap.base = NULL; } /* @@ -248,9 +364,11 @@ void Nas_SzHeapReset(u32) * Address: ........ * Size: 000058 */ -void Nas_SzHeapDivide(AudioHeapstrc*) -{ - // UNUSED FUNCTION +void Nas_SzHeapDivide(AudioHeapstrc* param_1) { + AG.session_heap.current = AG.session_heap.base; + Nas_HeapInit(&AG.misc_heap, (u8*)Nas_HeapAlloc(&AG.session_heap, param_1->misc_heap_size), param_1->misc_heap_size); + Nas_HeapInit(&AG.sz_data_heap, (u8*)Nas_HeapAlloc(&AG.session_heap, param_1->cache_heap_size), + param_1->cache_heap_size); } /* @@ -258,9 +376,10 @@ void Nas_SzHeapDivide(AudioHeapstrc*) * Address: ........ * Size: 000014 */ -void Nas_SzDataDivide(DataHeapstrc*) -{ - // UNUSED FUNCTION +void Nas_SzDataDivide(DataHeapstrc* param_1) { + AG.sz_data_heap.current = AG.sz_data_heap.base; + Nas_HeapInit(&AG.data_heap, (u8*)Nas_HeapAlloc(&AG.sz_data_heap, param_1->data_size), param_1->data_size); + Nas_HeapInit(&AG.sz_auto_heap, (u8*)Nas_HeapAlloc(&AG.sz_data_heap, param_1->auto_size), param_1->auto_size); } /* @@ -268,9 +387,17 @@ void Nas_SzDataDivide(DataHeapstrc*) * Address: ........ * Size: 0000B4 */ -void Nas_SzStayDivide(StayHeapstrc*) -{ - // UNUSED FUNCTION +void Nas_SzStayDivide(StayHeapstrc* param_1) { + AG.data_heap.current = AG.data_heap.base; + Nas_HeapInit(&AG.seq_heap.stay_heap.heap, (u8*)Nas_HeapAlloc(&AG.data_heap, param_1->seq_heap_size), + param_1->seq_heap_size); + Nas_HeapInit(&AG.bank_heap.stay_heap.heap, (u8*)Nas_HeapAlloc(&AG.data_heap, param_1->bank_heap_size), + param_1->bank_heap_size); + Nas_HeapInit(&AG.wave_heap.stay_heap.heap, (u8*)Nas_HeapAlloc(&AG.data_heap, param_1->wave_heap_size), + param_1->wave_heap_size); + Nas_SzStayClear(&AG.seq_heap.stay_heap); + Nas_SzStayClear(&AG.bank_heap.stay_heap); + Nas_SzStayClear(&AG.wave_heap.stay_heap); } /* @@ -278,9 +405,16 @@ void Nas_SzStayDivide(StayHeapstrc*) * Address: ........ * Size: 0000B4 */ -void Nas_SzAutoDivide(AutoHeapstrc*) -{ - // UNUSED FUNCTION +void Nas_SzAutoDivide(AutoHeapstrc* param_1) { + AG.sz_auto_heap.current = AG.sz_auto_heap.base; + Nas_HeapInit(&AG.seq_heap.auto_heap.heap, (u8*)Nas_HeapAlloc(&AG.sz_auto_heap, param_1->seqLen), param_1->seqLen); + Nas_HeapInit(&AG.bank_heap.auto_heap.heap, (u8*)Nas_HeapAlloc(&AG.sz_auto_heap, param_1->bankLen), + param_1->bankLen); + Nas_HeapInit(&AG.wave_heap.auto_heap.heap, (u8*)Nas_HeapAlloc(&AG.sz_auto_heap, param_1->waveLen), + param_1->waveLen); + Nas_SzAutoClear(&AG.seq_heap.auto_heap); + Nas_SzAutoClear(&AG.bank_heap.auto_heap); + Nas_SzAutoClear(&AG.wave_heap.auto_heap); } /* @@ -288,9 +422,271 @@ void Nas_SzAutoDivide(AutoHeapstrc*) * Address: ........ * Size: 0006CC */ -void* Nas_SzHeapAlloc(s32, s32, s32, s32) -{ - // UNUSED FUNCTION +void* Nas_SzHeapAlloc(s32 tableType, s32 size, s32 param_3, s32 id) { + SZAuto* auto_heap; + SZHeap* sound_heap; + void* alloc; + ALHeap* heap; + u8 status0; + u8 status1; + int end; + ALHeapEntry* entry; + int checkId; + u8* outStatus; + int idx; + + switch (tableType) { + case SEQUENCE_TABLE: { + sound_heap = &AG.seq_heap; + outStatus = AG.sequence_load_status; + } break; + case BANK_TABLE: { + sound_heap = &AG.bank_heap; + outStatus = AG.bank_load_status; + } break; + case WAVE_TABLE: { + sound_heap = &AG.wave_heap; + outStatus = AG.wave_load_status; + } break; + } + + if (param_3 == 0) { + auto_heap = &sound_heap->auto_heap; + heap = &auto_heap->heap; + if (auto_heap->heap.length < size) { + return NULL; + } + + if (auto_heap->entries[0].id == HEAP_INVALID_INDEX) { + status0 = 0; + } else { + status0 = outStatus[auto_heap->entries[0].id]; + } + + if (auto_heap->entries[1].id == HEAP_INVALID_INDEX) { + status1 = 0; + } else { + status1 = outStatus[auto_heap->entries[1].id]; + } + + if (tableType == BANK_TABLE) { + if (status0 == 4) { + int i; + end = AG.num_channels; + checkId = auto_heap->entries[0].id; + for (i = 0; i < end; i++) { + if (checkId == AG.channels[i].playback_ch.bank_id && AG.channels[i].common_ch.enabled) { + break; + } + } + + if (i == AG.num_channels) { + Nas_WriteIDbank(auto_heap->entries[0].id, 3); + status0 = 3; + } + } + + if (status1 == 4) { + int i; + end = AG.num_channels; + for (i = 0; i < end; i++) { + if (auto_heap->entries[1].id == AG.channels[i].playback_ch.bank_id && + AG.channels[i].common_ch.enabled) { + break; + } + } + + if (i == AG.num_channels) { + Nas_WriteIDbank(auto_heap->entries[1].id, 3); + status1 = 3; + } + } + } + + if (status0 == 0) { + auto_heap->use_entry_idx = FALSE; + goto aftretnull; + } + + if (status1 == 0) { + auto_heap->use_entry_idx = TRUE; + goto aftretnull; + } + + if (status0 != 3 || status1 != 3) { + if (status0 == 3) { + auto_heap->use_entry_idx = FALSE; + goto aftretnull; + } else if (status1 == 3) { + auto_heap->use_entry_idx = TRUE; + goto aftretnull; + } else if (tableType == SEQUENCE_TABLE) { + if (status0 == 2) { + int i; + end = AG.audio_params.num_groups; + for (i = 0; i < end; i++) { + if (AG.groups[i].flags.enabled && AG.groups[i].seq_id == auto_heap->entries[0].id) { + break; + } + } + if (i == end) { + auto_heap->use_entry_idx = FALSE; + goto aftretnull; + } + } + if (status1 == 2) { + int i; + end = AG.audio_params.num_groups; + for (i = 0; i < end; i++) { + if (AG.groups[i].flags.enabled && AG.groups[i].seq_id == auto_heap->entries[1].id) { + break; + } + } + if (i == end) { + auto_heap->use_entry_idx = TRUE; + goto aftretnull; + } + } + } else if (tableType == BANK_TABLE) { + if (status0 == 2) { + int i; + end = AG.num_channels; + for (i = 0; i < end; i++) { + if (auto_heap->entries[0].id == AG.channels[i].playback_ch.bank_id && + AG.channels[i].common_ch.enabled) { + break; + } + } + if (i == end) { + auto_heap->use_entry_idx = FALSE; + goto aftretnull; + } + } + if (status1 == 2) { + int i; + end = AG.num_channels; + checkId = auto_heap->entries[1].id; + for (i = 0; i < end; i++) { + if (auto_heap->entries[1].id == AG.channels[i].playback_ch.bank_id && + AG.channels[i].common_ch.enabled) { + break; + } + } + if (i == end) { + auto_heap->use_entry_idx = TRUE; + goto aftretnull; + } + } + } + } else { + goto aftretnull; + } + + if (auto_heap->use_entry_idx == FALSE) { + if (status0 == 1) { + if (status1 == 1) { + goto retnull; + } + auto_heap->use_entry_idx = TRUE; + } + } else { + if (status1 == 1) { + if (status0 == 1) { + goto retnull; + } + auto_heap->use_entry_idx = FALSE; + } + } + goto aftretnull; + + retnull: + return NULL; + aftretnull: + + idx = auto_heap->use_entry_idx; + // entry = &auto_heap->entries[idx]; + if (auto_heap->entries[idx].id != HEAP_INVALID_INDEX) { + if (tableType == WAVE_TABLE) { + DirtyWave(auto_heap->entries[idx].id); + } + outStatus[auto_heap->entries[idx].id] = 0; + if (tableType == BANK_TABLE) { + Nas_ForceStopChannel(auto_heap->entries[idx].id); + } + } + + switch (idx) { + case FALSE: { + auto_heap->entries[0].addr = heap->base; + auto_heap->entries[0].id = id; + auto_heap->entries[0].size = size; + heap->current = heap->base + size; + if (auto_heap->entries[1].id != HEAP_INVALID_INDEX && heap->current > auto_heap->entries[1].addr) { + if (tableType == WAVE_TABLE) { + DirtyWave(auto_heap->entries[1].id); + } + outStatus[auto_heap->entries[1].id] = 0; + switch (tableType) { + case SEQUENCE_TABLE: { + Nas_ForceStopSeq(auto_heap->entries[1].id); + } break; + case BANK_TABLE: { + Nas_ForceStopChannel(auto_heap->entries[1].id); + } break; + } + auto_heap->entries[1].id = -1; + auto_heap->entries[1].addr = heap->base + heap->length; + } + alloc = auto_heap->entries[0].addr; + } break; + case TRUE: { + auto_heap->entries[1].addr = (u8*)OSRoundDown32B(heap->base + heap->length - size); + auto_heap->entries[1].id = id; + auto_heap->entries[1].size = size; + if (auto_heap->entries[0].id != HEAP_INVALID_INDEX && heap->current > auto_heap->entries[1].addr) { + if (tableType == WAVE_TABLE) { + DirtyWave(auto_heap->entries[0].id); + } + outStatus[auto_heap->entries[0].id] = 0; + switch (tableType) { + case SEQUENCE_TABLE: { + Nas_ForceStopSeq(auto_heap->entries[0].id); + } break; + case BANK_TABLE: { + Nas_ForceStopChannel(auto_heap->entries[0].id); + } break; + } + auto_heap->entries[0].id = HEAP_INVALID_INDEX; + heap->current = heap->base; + } + alloc = auto_heap->entries[1].addr; + } break; + default: { + return NULL; + } break; + } + + // heap->use_entry_idx = !heap->use_entry_idx; + auto_heap->use_entry_idx ^= TRUE; + return alloc; + } else { // param_3 != 0 + alloc = Nas_HeapAlloc(&sound_heap->stay_heap.heap, size); + sound_heap->stay_heap.entries[sound_heap->stay_heap.num_entries].addr = (u8*)alloc; + if (alloc == NULL) { + switch (param_3) { + case 2: { + return Nas_SzHeapAlloc(tableType, size, 0, id); + } break; + case 0: + case 1: { + return NULL; + } break; + } + } + sound_heap->stay_heap.entries[sound_heap->stay_heap.num_entries].id = id; + sound_heap->stay_heap.entries[sound_heap->stay_heap.num_entries].size = size; + return sound_heap->stay_heap.entries[sound_heap->stay_heap.num_entries++].addr; + } } /* @@ -298,9 +694,15 @@ void* Nas_SzHeapAlloc(s32, s32, s32, s32) * Address: ........ * Size: 000064 */ -u32 Nas_SzCacheCheck(s32, s32, s32) -{ - // UNUSED FUNCTION +void* Nas_SzCacheCheck(s32 tabletype, s32 audioCacheType, s32 id) { + void* v = EmemOnCheck(tabletype, id); + if (v) { + return v; + } + if (audioCacheType == CACHE_PERMANENT) { + return NULL; + } + return __Nas_SzCacheCheck_Inner(tabletype, audioCacheType, id); } /* @@ -308,9 +710,40 @@ u32 Nas_SzCacheCheck(s32, s32, s32) * Address: ........ * Size: 000114 */ -void __Nas_SzCacheCheck_Inner(s32, s32, s32) -{ - // UNUSED FUNCTION +void* __Nas_SzCacheCheck_Inner(s32 tabletype, s32 audioCacheType, s32 id) { + SZHeap* heap; + switch (tabletype) { + case SEQUENCE_TABLE: { + heap = &AG.seq_heap; + } break; + case BANK_TABLE: { + heap = &AG.bank_heap; + } break; + case WAVE_TABLE: { + heap = &AG.wave_heap; + } break; + } + SZAuto* autoHeap = &heap->auto_heap; + if (audioCacheType == 0) { + if (autoHeap->entries[0].id == id) { + autoHeap->use_entry_idx = TRUE; + return autoHeap->entries[0].addr; + } + if (autoHeap->entries[1].id == id) { + autoHeap->use_entry_idx = FALSE; + return autoHeap->entries[1].addr; + } + return NULL; + } + for (int i = 0; i < heap->stay_heap.num_entries; i++) { + if (id == heap->stay_heap.entries[i].id) { + return heap->stay_heap.entries[i].addr; + } + } + if (audioCacheType == 2) { + return Nas_SzCacheCheck(tabletype, 0, id); + } + return NULL; } /* @@ -318,9 +751,8 @@ void __Nas_SzCacheCheck_Inner(s32, s32, s32) * Address: ........ * Size: 0000D4 */ -void Nas_InitFilterCoef(f32, f32, u16*) -{ - // UNUSED FUNCTION +void Nas_InitFilterCoef(f32 param_1, f32 param_2, u16* param_3) { + // UNUSED FUNCTION } /* @@ -328,9 +760,8 @@ void Nas_InitFilterCoef(f32, f32, u16*) * Address: ........ * Size: 000020 */ -void Nas_ClearFilter(s16*) -{ - // UNUSED FUNCTION +void Nas_ClearFilter(s16* param_1) { + // UNUSED FUNCTION } /* @@ -338,9 +769,13 @@ void Nas_ClearFilter(s16*) * Address: ........ * Size: 000040 */ -void Nas_SetLPFilter(s16*, s32) -{ - // UNUSED FUNCTION +extern s16 LSF_TABLE[]; +void Nas_SetLPFilter(s16* a, s32 b) { + int i; + int c = b * 8; + for (i = 0; i < 8; i++) { + a[i] = LSF_TABLE[c + i]; + } } /* @@ -348,9 +783,13 @@ void Nas_SetLPFilter(s16*, s32) * Address: ........ * Size: 000044 */ -void Nas_SetHPFilter(s16*, s32) -{ - // UNUSED FUNCTION +extern s16 HSF_TABLE[]; +void Nas_SetHPFilter(s16* a, s32 b) { + int i; + int c = (b - 1) * 8; + for (i = 0; i < 8; i++) { + a[i] = HSF_TABLE[c + i]; + } } /* @@ -358,9 +797,44 @@ void Nas_SetHPFilter(s16*, s32) * Address: ........ * Size: 000134 */ -void Nas_SetBPFilter(s16*, s32, s32) -{ - // UNUSED FUNCTION +extern s16 EL_FILTER[]; +extern s16 BP_FILTER[]; +void Nas_SetBPFilter(s16* a, s32 b, s32 c) { + int i; + int k; + int ind; + int constant; + if (b == 0 && c == 0) { + Nas_SetLPFilter(a, 0); + return; + } else if (c == 0) { + Nas_SetLPFilter(a, b); + return; + } else if (b == 0) { + Nas_SetLPFilter(a, c); + return; + } + k = 0; + constant = 14; + if (c > b) { + for (i = b; i > 1; i--) { + k += constant; + constant--; + } + ind = (c - b) - 1 + k; + for (i = 0; i < 8; i++) { + a[i] = EL_FILTER[i + ind]; + } + } else if (c < b) { + for (i = c; i > 1; i--) { + k += constant; + constant--; + } + ind = (b - c) - 1 + k; + for (i = 0; i < 8; i++) { + a[i] = BP_FILTER[i + ind]; + } + } } /* @@ -368,9 +842,8 @@ void Nas_SetBPFilter(s16*, s32, s32) * Address: ........ * Size: 000004 */ -void __DownDelay(delay*) -{ - // UNUSED FUNCTION +void __DownDelay(delay* unused) { + return; } /* @@ -378,9 +851,24 @@ void __DownDelay(delay*) * Address: ........ * Size: 0000A0 */ -void __Nas_DelayDown() -{ - // UNUSED FUNCTION +void __Nas_DelayDown() { + int i; + int j; + delay* delay_p; + int c; + + if (AG.audio_params.spec == 2) { + c = 2; + } else { + c = 1; + } + + for (i = 0; i < AG.num_synth_reverbs; i++) { + delay_p = &AG.synth_delay[i]; + for (j = 0; j < c; j++) { + __DownDelay(delay_p); + } + } } /* @@ -388,9 +876,13 @@ void __Nas_DelayDown() * Address: ........ * Size: 000048 */ -void __Nas_DacClear() -{ - // UNUSED FUNCTION +void __Nas_DacClear() { + int i; + int bufferIdx = AG.current_ai_buffer_idx; + AG.num_samples_per_frame[bufferIdx] = AG.audio_params.num_samples_per_frame_min; + for (i = 0; i < 0x7c0; i++) { + AG.ai_buffers[bufferIdx][i] = 0; + } } /* @@ -398,9 +890,65 @@ void __Nas_DacClear() * Address: ........ * Size: 000258 */ -s32 Nas_SpecChange() -{ - // UNUSED FUNCTION +s32 Nas_SpecChange() { + int i; + int j; + int c = AG.audio_params.spec == 2 ? 2 : 1; + switch (AG.reset_status) { + case 5: { + for (i = 0; i < AG.audio_params.num_groups; i++) { + Nas_ReleaseGroup_Force(AG.groups_p[i]); + } + AG.audio_reset_fadeout_frames_left = 2 / c; + AG.reset_status--; + } break; + case 4: { + if (AG.audio_reset_fadeout_frames_left != 0) { + AG.audio_reset_fadeout_frames_left--; + __Nas_DelayDown(); + } else { + for (i = 0; i < AG.num_channels; i++) { + if (AG.channels[i].common_ch.enabled && AG.channels[i].playback_ch.adsr_envp.state.flags.status) { + AG.channels[i].playback_ch.adsr_envp.fadeout_velocity = + AG.audio_params.updates_per_frame_inverse; + AG.channels[i].playback_ch.adsr_envp.state.flags.release = TRUE; + } + } + AG.audio_reset_fadeout_frames_left = 8 / c; + AG.reset_status--; + } + } break; + case 3: { + if (AG.audio_reset_fadeout_frames_left) { + AG.audio_reset_fadeout_frames_left--; + __Nas_DelayDown(); + } else { + AG.audio_reset_fadeout_frames_left = 2 / c; + AG.reset_status--; + } + } break; + case 2: { + __Nas_DacClear(); + if (AG.audio_reset_fadeout_frames_left) { + AG.audio_reset_fadeout_frames_left--; + } else { + AG.reset_status--; + Emem_KillSwMember(); + Dirty_AllWave(); + } + } break; + case 1: { + __Nas_MemoryReconfig(); + AG.reset_status = 0; + for (i = 0; i < ARRAY_COUNT(AG.ai_buffers) - 1; i++) { + AG.num_samples_per_frame[i] = AG.audio_params.num_samples_per_frame_max; + for (j = 0; j < 0x7c0; j++) { + AG.ai_buffers[i][j] = 0; + } + } + } break; + } + return AG.reset_status > 2; } /* @@ -408,9 +956,133 @@ s32 Nas_SpecChange() * Address: ........ * Size: 0006B4 */ -void __Nas_MemoryReconfig() -{ - // UNUSED FUNCTION +void __Nas_MemoryReconfig() { + s32 j; + s32 i; + s32 a; + s32 b; + s32 c; + s32 d; + na_spec_config* spec = &NA_SPEC_CONFIG[AG.spec_id]; + + /*0x2640*/ AG.num_waveloads = 0; + /*0x286E*/ AG.audio_params.sampling_frequency = spec->_00; + /*0x2872*/ AG.audio_params.num_samples_per_frame_target = spec->_00 / AG.refresh_rate; + /*0x2878*/ AG.audio_params.updates_per_frame = 4; + /*0x2876*/ AG.audio_params.num_samples_per_frame_min = AG.audio_params.num_samples_per_frame_target - 0x10; + /*0x2874*/ AG.audio_params.num_samples_per_frame_max = AG.audio_params.num_samples_per_frame_target + 0x10; + /*0x287A*/ AG.audio_params.num_samples_per_update = + (AG.audio_params.num_samples_per_frame_target / AG.audio_params.updates_per_frame) & ~7; + /*0x2870*/ AG.audio_params.ai_sampling_frequency = AG.audio_params.sampling_frequency; + OSReport("----------------------------- SFS_NORMAL = %d\n", AG.audio_params.num_samples_per_update); + /* + order is + 287c + 287e + 2884 + 2898 + 289c + 28b8 + 2888 + 2880 + 288c + 2890 + */ + /*0x287C*/ AG.audio_params.num_samples_per_update_max = AG.audio_params.num_samples_per_update + 8; + /*0x287E*/ AG.audio_params.num_samples_per_update_min = AG.audio_params.num_samples_per_update - 8; + /*0x2884*/ AG.audio_params.resample_rate = 33476.156f / (s32)AG.audio_params.sampling_frequency; + /*0x288C*/ AG.audio_params.updates_per_frame_inverse_scaled = (1.f / 256.f) / AG.audio_params.updates_per_frame; + /*0x2890*/ AG.audio_params.updates_per_frame_scaled = AG.audio_params.updates_per_frame / 4.0f; + /*0x2888*/ AG.audio_params.updates_per_frame_inverse = 1.f / AG.audio_params.updates_per_frame; + + /*0x2898*/ AG.waveload_dma_buf0_size = spec->_10; + /*0x289C*/ AG.waveload_dma_buf1_size = spec->_12; + + /*0x28B8*/ AG.num_channels = spec->_05; + /*0x2880*/ AG.audio_params.num_groups = spec->_06; + if (AG.audio_params.num_groups > 5) { + /*0x2880*/ AG.audio_params.num_groups = 5; + } + + /*0x2A18*/ AG.num_abi_cmds_max = 8; + /*0x0002*/ AG._0002 = spec->_14; + + s32 tmp = AG.audio_params.updates_per_frame; + /*0x28BC*/ AG.max_tempo = ((((60.0f * 1000.0f * 48) * tmp) / AGC.timeBase) / AG._29D8) / 1.04613; + + /*0x2894*/ AG._2894 = (f32)AG.refresh_rate * (f32)tmp / AG.audio_params.ai_sampling_frequency / AG.max_tempo; + + /*0x286C*/ AG.audio_params.spec = spec->_04; + /*0x2894*/ AG._2894 = AG.refresh_rate; + /*0x2894*/ AG._2894 *= tmp; + /*0x2894*/ AG._2894 /= AG.audio_params.ai_sampling_frequency; + /*0x2894*/ AG._2894 /= AG.max_tempo; + /*0x2876*/ AG.audio_params.num_samples_per_frame_min *= AG.audio_params.spec; + /*0x2878*/ AG.audio_params.updates_per_frame *= AG.audio_params.spec; + /*0x2872*/ AG.audio_params.num_samples_per_frame_target *= AG.audio_params.spec; + /*0x2874*/ AG.audio_params.num_samples_per_frame_max *= AG.audio_params.spec; + + if (AG.audio_params.spec > 1) { + /*0x2874*/ AG.audio_params.num_samples_per_frame_max -= 0x10; + } + // int c = (a + b); + /*0x28B4*/ AG.max_audio_cmds = (AG.num_channels * 20 * AG.audio_params.updates_per_frame) + (spec->_09 * 30) + 400; + a = (spec->_18 + spec->_1C + spec->_20 + 0x40); + b = (spec->_24 + spec->_28 + spec->_2C + 0x40); + c = a + b; + d = AG.session_heap.length - c - 0x100; + if (/*0x2A34*/ AG.external_heap.base != NULL) { + /*0x2A38*/ AG.external_heap.current = AG.external_heap.base; + } + /*0x34EC*/ AG.audio_heap_info.misc_heap_size = d; + /*0x34F8*/ AG.audio_heap_info.cache_heap_size = c; + Nas_SzHeapDivide(&AG.audio_heap_info); + /*0x34FC*/ AG.cache_heap.data_size = a; + /*0x3500*/ AG.cache_heap.auto_size = b; + Nas_SzDataDivide(&AG.cache_heap); + + /*0x3504*/ AG.persistent_common_heap_info.seq_heap_size = spec->_18; + /*0x3508*/ AG.persistent_common_heap_info.bank_heap_size = spec->_1C; + /*0x350C*/ AG.persistent_common_heap_info.wave_heap_size = spec->_20; + Nas_SzStayDivide(&AG.persistent_common_heap_info); + AG.temporary_common_heap_info.seq_heap_size = spec->_24; + AG.temporary_common_heap_info.bank_heap_size = spec->_28; + AG.temporary_common_heap_info.wave_heap_size = spec->_2C; + // fake? maybe temporary_common_heap_info is wrong type? + Nas_SzAutoDivide((AutoHeapstrc*)&AG.temporary_common_heap_info); + Nas_ResetIDtable(); + AG.channels = (channel*)Nas_HeapAlloc_CL(&AG.misc_heap, AG.num_channels * sizeof(channel)); + Nas_ChannelInit(); + Nas_InitChannelList(); + AG.common_channel = (commonch*)Nas_HeapAlloc_CL(&AG.misc_heap, AG.audio_params.updates_per_frame * AG.num_channels * + sizeof(commonch)); + + for (i = 0; i < ARRAY_COUNT(AG.abi_cmd_bufs); i++) { + AG.abi_cmd_bufs[i] = (Acmd*)Nas_NcHeapAlloc_CL(&AG.misc_heap, AG.max_audio_cmds * sizeof(Acmd)); + } + AG.adsr_decay_table = (f32*)Nas_HeapAlloc(&AG.misc_heap, sizeof(f32) * 0x100); + MakeReleaseTable(); + for (i = 0; i < ARRAY_COUNT(AG.synth_delay); i++) { + AG.synth_delay[i].use_reverb = FALSE; + } + AG.num_synth_reverbs = spec->_09; + for (i = 0; i < AG.num_synth_reverbs; i++) { + Nas_SetDelayLine(i, &spec->_0C[i], 1); + } + Nas_InitPlayer(); + for (j = 0; j < AG.audio_params.num_groups; j++) { + Nas_AssignSubTrack(j); + Nas_InitMySeq(AG.groups_p[j]); + } + Nas_Init_Single(spec->_30, spec->_34); + Nas_WaveDmaNew(AG.num_channels); + AG.num_requested_samples = 0; + LpsInit(); + MK_Init(); + Nas_BgCopyInit(); + AG._0004 = 0x1000; + EmemReload(); + Z_osWritebackDCacheAll(); } /* @@ -418,9 +1090,14 @@ void __Nas_MemoryReconfig() * Address: ........ * Size: 00005C */ -void* EmemOnCheck(s32, s32) -{ - // UNUSED FUNCTION +void* EmemOnCheck(s32 tableType, s32 id) { + int i; + for (i = 0; i < AG.emem_heap.count; i++) { + if (tableType == AG.emem_entries[i].table_type && id == AG.emem_entries[i].id) { + return AG.emem_entries[i].addr; + } + } + return NULL; } /* @@ -428,9 +1105,17 @@ void* EmemOnCheck(s32, s32) * Address: ........ * Size: 00007C */ -void* EmemAlloc(s32, s32, s32) -{ - // UNUSED FUNCTION +void* EmemAlloc(s32 tableType, s32 id, s32 size) { + u32 heapCount = AG.emem_heap.count; + u8* p = (u8*)Nas_HeapAlloc(&AG.emem_heap, size); + AG.emem_entries[heapCount].addr = p; + if (p == NULL) { + return NULL; + } + AG.emem_entries[heapCount].table_type = tableType; + AG.emem_entries[heapCount].id = id; + AG.emem_entries[heapCount].size = size; + return p; } /* @@ -438,9 +1123,23 @@ void* EmemAlloc(s32, s32, s32) * Address: ........ * Size: 000064 */ -void Nas_Alloc_Single(s32, s32, u8*, char, s32) -{ - // UNUSED FUNCTION + +void* Nas_Alloc_Single(s32 a, s32 sampleBankID, u8* sampleAddr, s8 originalMedium, s32 e) { + SwMember* alloc; + if (e == 0) { + alloc = __Nas_Alloc_Single_Auto_Inner(a); + } else { + alloc = __Nas_Alloc_Single_Stay_Inner(a); + } + if (alloc != NULL) { + SwMember* entry = (SwMember*)alloc; + entry->sample_bank_id = sampleBankID; + entry->sample_addr = sampleAddr; + entry->original_medium = originalMedium; + return entry->allocated_addr; + } else { + return NULL; + } } /* @@ -448,9 +1147,22 @@ void Nas_Alloc_Single(s32, s32, u8*, char, s32) * Address: ........ * Size: 0000C4 */ -void Nas_Init_Single(s32, s32) -{ - // UNUSED FUNCTION +int Nas_Init_Single(s32 a, s32 b) { + u8* alloc = (u8*)Nas_2ndHeapAlloc(&AG.misc_heap, a); + if (alloc == NULL) { + AG.emem_persistent_wave_heap.heap.length = 0; + } else { + Nas_HeapInit(&AG.emem_persistent_wave_heap.heap, alloc, a); + } + + alloc = (u8*)Nas_2ndHeapAlloc(&AG.misc_heap, b); + if (alloc == NULL) { + AG.emem_temporary_wave_heap.heap.length = 0; + } else { + Nas_HeapInit(&AG.emem_temporary_wave_heap.heap, alloc, b); + } + AG.emem_persistent_wave_heap.num_entries = 0; + AG.emem_temporary_wave_heap.num_entries = 0; } /* @@ -458,9 +1170,71 @@ void Nas_Init_Single(s32, s32) * Address: ........ * Size: 000200 */ -void __Nas_Alloc_Single_Auto_Inner(s32) -{ - // UNUSED FUNCTION +SwMember* __Nas_Alloc_Single_Auto_Inner(s32 size) { + SwHeap* heap = &AG.emem_temporary_wave_heap; + void* alloc; + u8* oldCurrent = heap->heap.current; + u8* nowCurrent; + alloc = Nas_HeapAlloc(&heap->heap, size); + int i; + + if (!alloc) { + u8* nowCurrent = heap->heap.current; + heap->heap.current = heap->heap.base; + alloc = Nas_HeapAlloc(&heap->heap, size); + if (!alloc) { + heap->heap.current = nowCurrent; + return NULL; + } + oldCurrent = heap->heap.base; + } + nowCurrent = heap->heap.current; + + int s = -1; + for (i = 0; i < AG.num_requested_samples; i++) { + Bgloadreq* loadReq = &AG.requested_samples[i]; + if (loadReq->is_free == FALSE) { + u8* p = loadReq->ram_addr + loadReq->sample->size - 1; + if ((p >= oldCurrent || loadReq->ram_addr >= oldCurrent) && + (p < nowCurrent || loadReq->ram_addr < nowCurrent)) { + loadReq->is_free = TRUE; + } + } + } + for (i = 0; i < heap->num_entries; i++) { + s8 inUse = heap->entries[i].in_use; + if (inUse) { + u8* p = heap->entries[i].allocated_addr + heap->entries[i].size - 1; + if ((p >= oldCurrent || heap->entries[i].allocated_addr >= oldCurrent) && + (p < nowCurrent || heap->entries[i].allocated_addr < nowCurrent)) { + __KillSwMember(&heap->entries[i]); + heap->entries[i].in_use = 0; + if (s == -1) { + s = i; + } + } + } + } + if (s == -1) { + for (i = 0; i < heap->num_entries; i++) { + s8 inUse = heap->entries[i].in_use; + if (inUse == 0) { + break; + } + } + s = i; + if (s == heap->num_entries) { + if (heap->num_entries == ARRAY_COUNT(heap->entries)) { + return NULL; + } + heap->num_entries++; + } + } + SwMember* entry = &heap->entries[s]; + entry->in_use = TRUE; + entry->allocated_addr = (u8*)alloc; + entry->size = size; + return entry; } /* @@ -468,9 +1242,34 @@ void __Nas_Alloc_Single_Auto_Inner(s32) * Address: ........ * Size: 00012C */ -void __SearchBank(SwMember*, s32) -{ - // UNUSED FUNCTION +void __SearchBank(SwMember* entry, s32 bank) { + perctable* pt; + percvoicetable* pv; + voicetable* vt; + for (int i = 0; i < AG.voice_info[bank].num_instruments; i++) { + vt = ProgToVp(bank, i); + if (vt) { + if (vt->normal_range_low != 0) { + __RomAddrSet(entry, vt->low_pitch_tuned_sample.wavetable); + } + if (vt->normal_range_high != 0x7f) { + __RomAddrSet(entry, vt->high_pitch_tuned_sample.wavetable); + } + __RomAddrSet(entry, vt->normal_pitch_tuned_sample.wavetable); + } + } + for (int i = 0; i < AG.voice_info[bank].num_drums; i++) { + pt = PercToPp(bank, i); + if (pt) { + __RomAddrSet(entry, pt->tuned_sample.wavetable); + } + } + for (int i = 0; i < AG.voice_info[bank].num_sfx; i++) { + pv = VpercToVep(bank, i); + if (pv) { + __RomAddrSet(entry, pv->tuned_sample.wavetable); + } + } } /* @@ -478,9 +1277,16 @@ void __SearchBank(SwMember*, s32) * Address: ........ * Size: 0000EC */ -void __KillSwMember(SwMember*) -{ - // UNUSED FUNCTION +void __KillSwMember(SwMember* a) { + for (int i = 0, end = AG.bank_header->numEntries; i < end; i++) { + int bank0 = AG.voice_info[i].wave_bank_id0; + int bank1 = AG.voice_info[i].wave_bank_id1; + if (((bank0 != 0xff && bank0 == a->sample_bank_id) || (bank1 != 0xff && bank1 == a->sample_bank_id) || + (a->sample_bank_id == 0 || a->sample_bank_id == 0xfe)) && + Nas_SzCacheCheck(1, 2, i) && Nas_CheckIDbank(i)) { + __SearchBank(a, i); + } + } } /* @@ -488,9 +1294,11 @@ void __KillSwMember(SwMember*) * Address: ........ * Size: 000034 */ -void __RomAddrSet(SwMember*, smzwavetable*) -{ - // UNUSED FUNCTION +void __RomAddrSet(SwMember* a, smzwavetable* b) { + if (b != NULL && b->sample == a->allocated_addr) { + b->sample = (u8*)a->sample_addr; + b->medium = a->original_medium; + } } /* @@ -498,9 +1306,21 @@ void __RomAddrSet(SwMember*, smzwavetable*) * Address: ........ * Size: 000094 */ -void __Nas_Alloc_Single_Stay_Inner(s32) -{ - // UNUSED FUNCTION +SwMember* __Nas_Alloc_Single_Stay_Inner(s32 a) { + SwHeap* heap = &AG.emem_persistent_wave_heap; + u8* alloc = (u8*)Nas_HeapAlloc(&heap->heap, a); + if (alloc == NULL) { + return NULL; + } + if (heap->num_entries == ARRAY_COUNT(heap->entries)) { + return NULL; + } + SwMember* entry = &heap->entries[heap->num_entries]; + entry->in_use = TRUE; + entry->allocated_addr = (u8*)alloc; + entry->size = a; + heap->num_entries++; + return entry; } /* @@ -508,9 +1328,10 @@ void __Nas_Alloc_Single_Stay_Inner(s32) * Address: ........ * Size: 000040 */ -void __Do_EmemKill(SwMember*, s32, s32, s32) -{ - // UNUSED FUNCTION +void __Do_EmemKill(SwMember* entry, s32 id0, s32 id1, s32 bank) { + if (id0 == entry->sample_bank_id || id1 == entry->sample_bank_id || entry->sample_bank_id == 0) { + __SearchBank(entry, bank); + } } /* @@ -518,9 +1339,20 @@ void __Do_EmemKill(SwMember*, s32, s32, s32) * Address: ........ * Size: 000128 */ -void Emem_KillSwMember() -{ - // UNUSED FUNCTION +void Emem_KillSwMember() { + s32 i, j, end; + for (i = 0, end = AG.bank_header->numEntries; i < end; i++) { + s32 id0 = AG.voice_info[i].wave_bank_id0; + s32 id1 = AG.voice_info[i].wave_bank_id1; + if ((id0 != 0xff || id1 != 0xff) && Nas_SzCacheCheck(1, 3, i) && Nas_CheckIDbank(i)) { + for (j = 0; j < AG.emem_persistent_wave_heap.num_entries; j++) { + __Do_EmemKill(&AG.emem_persistent_wave_heap.entries[j], id0, id1, i); + } + for (j = 0; j < AG.emem_temporary_wave_heap.num_entries; j++) { + __Do_EmemKill(&AG.emem_temporary_wave_heap.entries[j], id0, id1, i); + } + } + } } /* @@ -528,9 +1360,23 @@ void Emem_KillSwMember() * Address: ........ * Size: 0000A0 */ -void __RestoreAddr(Wavelookuptable*, smzwavetable*) -{ - // UNUSED FUNCTION +s32 EXGTYPE; +void __RestoreAddr(Wavelookuptable* a, smzwavetable* b) { + if (b != NULL && (b->medium == a->medium || EXGTYPE != 1) && (b->medium == 0 || EXGTYPE != 0)) { + + u8* a_sample = a->sample; + u8* b_sample = b->sample; + u8* o = a_sample + a->_08; + if (b_sample >= a_sample && b_sample < o) { + // fakematch? + b->sample = (u8*)((u32)a->_04 + (b->sample - (u32)a->sample)); + if (EXGTYPE == 0) { + b->medium = a->medium; + } else { + b->medium = 0; + } + } + } } /* @@ -538,9 +1384,9 @@ void __RestoreAddr(Wavelookuptable*, smzwavetable*) * Address: ........ * Size: 000030 */ -void DirtyWave(s32) -{ - // UNUSED FUNCTION +void DirtyWave(s32 id) { + EXGTYPE = 0; + __ExchangeWave(0, id); } /* @@ -548,9 +1394,9 @@ void DirtyWave(s32) * Address: ........ * Size: 000030 */ -void EntryWave(s32) -{ - // UNUSED FUNCTION +void EntryWave(s32 id) { + EXGTYPE = 1; + __ExchangeWave(1, id); } /* @@ -558,9 +1404,63 @@ void EntryWave(s32) * Address: ........ * Size: 000238 */ -void __ExchangeWave(s32, s32) -{ - // UNUSED FUNCTION +void __ExchangeWave(s32 a, s32 b) { + s32 i; + Wavelookuptable wavetable; + voiceinfo* voiceinfo; + s32 bVar1; + s32 bVar2; + ArcHeader* wave_header = AG.wave_header; + s16 numEntries = AG.bank_header->numEntries; + Wavelookuptable* pWaveTable = &wavetable; + u8* alloc = (u8*)Nas_SzCacheCheck(2, 2, b); + pWaveTable->sample = alloc; + if (pWaveTable->sample) { + pWaveTable->_08 = (s32)wave_header[b].entries[0].size; + pWaveTable->medium = wave_header[b].entries[0].medium; + pWaveTable->_04 = (u8*)wave_header[b].entries[0].addr; + switch (a) { + case 1: { + pWaveTable->_04 = alloc; + pWaveTable->sample = (u8*)wave_header[b].entries[0].addr; + } break; + case 0: + default: + break; + } + for (i = 0; i < numEntries; i++) { + voiceinfo = &AG.voice_info[i]; + bVar1 = voiceinfo->wave_bank_id0; + bVar2 = voiceinfo->wave_bank_id1; + if ((bVar1 != 0xff || bVar2 != 0xff) && Nas_CheckIDbank(i) && Nas_SzCacheCheck(1, 2, i) && + (bVar1 == b || bVar2 == b)) { + for (int j = 0; j < AG.voice_info[i].num_instruments; j++) { + voicetable* voicetable = ProgToVp(i, j); + if (voicetable) { + if (voicetable->normal_range_low) { + __RestoreAddr(pWaveTable, voicetable->low_pitch_tuned_sample.wavetable); + } + if (voicetable->normal_range_high != 0x7f) { + __RestoreAddr(pWaveTable, voicetable->high_pitch_tuned_sample.wavetable); + } + __RestoreAddr(pWaveTable, voicetable->normal_pitch_tuned_sample.wavetable); + } + } + for (int j = 0; j < AG.voice_info[i].num_drums; j++) { + perctable* pTable = PercToPp(i, j); + if (pTable) { + __RestoreAddr(pWaveTable, pTable->tuned_sample.wavetable); + } + } + for (int j = 0; j < AG.voice_info[i].num_sfx; j++) { + percvoicetable* pTable = VpercToVep(i, j); + if (pTable) { + __RestoreAddr(pWaveTable, pTable->tuned_sample.wavetable); + } + } + } + } + } } /* @@ -568,9 +1468,18 @@ void __ExchangeWave(s32, s32) * Address: ........ * Size: 000088 */ -void Dirty_AllWave() -{ - // UNUSED FUNCTION +void Dirty_AllWave() { + int i; + SZHeap* heap = &AG.wave_heap; + if (heap->auto_heap.entries[0].id != HEAP_INVALID_INDEX) { + DirtyWave(heap->auto_heap.entries[0].id); + } + if (heap->auto_heap.entries[1].id != HEAP_INVALID_INDEX) { + DirtyWave(heap->auto_heap.entries[1].id); + } + for (i = 0; i < heap->stay_heap.num_entries; i++) { + DirtyWave(heap->stay_heap.entries[i].id); + } } /* @@ -578,9 +1487,18 @@ void Dirty_AllWave() * Address: ........ * Size: 0000AC */ -void __Nas_GetCompressBuffer(delay*) -{ - // UNUSED FUNCTION +int __Nas_GetCompressBuffer(delay* a) { + if (a->left_load_resample_buf != NULL && a->right_save_resample_buf != NULL) { + return 0; + } + a->left_load_resample_buf = (s16*)Nas_HeapAlloc_CL(&AG.misc_heap, 0x20); + a->right_load_resample_buf = (s16*)Nas_HeapAlloc_CL(&AG.misc_heap, 0x20); + a->left_save_resample_buf = (s16*)Nas_HeapAlloc_CL(&AG.misc_heap, 0x20); + a->right_save_resample_buf = (s16*)Nas_HeapAlloc_CL(&AG.misc_heap, 0x20); + if (a->right_save_resample_buf == NULL) { + return -1; + } + return 0; } /* @@ -588,9 +1506,104 @@ void __Nas_GetCompressBuffer(delay*) * Address: ........ * Size: 00028C */ -void Nas_SetDelayLineParam(s32, s32, s32, s32) -{ - // UNUSED FUNCTION +void Nas_SetDelayLineParam(s32 a, s32 b, s32 c, s32 d) { + delay* delay = &AG.synth_delay[a]; + switch (b) { + case 0: { + Nas_SetDelayLine(a, (fxconfig*)c, 0); + } break; + case 1: { + if (c < 4) { + c = 4; + } + + int delay_num_samples = c * 0x40; + if (c * 0x40 < 0x100) { + delay_num_samples = 0x100; + } + + delay_num_samples /= delay->downsample_rate; + + if (d == 0) { + if (delay->delay_num_samples_after_downsampling < c / delay->downsample_rate) { + return; + } + if (delay_num_samples <= delay->next_reverb_buf_pos || + delay_num_samples <= delay->delay_num_samples_unk) { + delay->next_reverb_buf_pos = 0; + delay->delay_num_samples_unk = 0; + } + } + delay->delay_num_samples = delay_num_samples; + if (delay->downsample_rate != 1 || delay->resample_effect_on) { + delay->downsample_pitch = 0x8000 / delay->downsample_rate; + if (__Nas_GetCompressBuffer(delay) == -1) { + delay->downsample_rate = 1; + } + } + } break; + case 2: { + delay->decay_ratio = c; + } break; + case 3: { + delay->sub_volume = c; + } break; + case 4: { + delay->volume = c; + } break; + case 5: { + delay->leak_rtl = c; + } break; + case 6: { + delay->leak_ltl = c; + } break; + case 7: { + if (c) { + if (d || delay->filter_left_init == NULL) { + delay->filter_left_state = (s16*)Nas_NcHeapAlloc_CL(&AG.misc_heap, 0x20 * sizeof(s16)); + delay->filter_left_init = (s16*)Nas_NcHeapAlloc(&AG.misc_heap, 0x8 * sizeof(s16)); + } + delay->filter_left = delay->filter_left_init; + if (delay->filter_left) { + Nas_SetLPFilter(delay->filter_left, c); + } + } else { + delay->filter_left = NULL; + if (d) { + delay->filter_left_init = NULL; + } + } + } break; + case 8: { + if (c) { + if (d || delay->filter_right_init == NULL) { + delay->filter_right_state = (s16*)Nas_NcHeapAlloc_CL(&AG.misc_heap, 0x20 * sizeof(s16)); + delay->filter_right_init = (s16*)Nas_NcHeapAlloc(&AG.misc_heap, 0x8 * sizeof(s16)); + } + delay->filter_right = delay->filter_right_init; + if (delay->filter_right) { + Nas_SetLPFilter(delay->filter_right, c); + } + } else { + delay->filter_right = NULL; + if (d) { + delay->filter_right_init = NULL; + } + } + } break; + case 9: { + delay->resample_effect_extra_samples = c; + if (c == 0) { + delay->resample_effect_on = FALSE; + } else { + delay->resample_effect_on = TRUE; + } + if (__Nas_GetCompressBuffer(delay) == -1) { + delay->resample_effect_on = FALSE; + delay->resample_effect_extra_samples = FALSE; + } + } break; + } } /* @@ -598,7 +1611,48 @@ void Nas_SetDelayLineParam(s32, s32, s32, s32) * Address: ........ * Size: 0001E0 */ -void Nas_SetDelayLine(s32, fxconfig_*, s32) -{ - // UNUSED FUNCTION +void Nas_SetDelayLine(s32 a, fxconfig* b, s32 c) { + delay* d = &AG.synth_delay[a]; + if (c) { + d->delay_num_samples_after_downsampling = b->_02 / b->downsample_rate; + d->left_load_resample_buf = NULL; + } else if (d->delay_num_samples_after_downsampling < b->_02 / b->downsample_rate) { + return; + } + d->downsample_rate = b->downsample_rate; + d->resample_effect_on = 0; + d->resample_effect_extra_samples = 0; + d->resample_effect_load_unk = 0; + d->resample_effect_save_unk = 0; + Nas_SetDelayLineParam(a, 1, b->_02, c); + d->decay_ratio = b->decay_ratio; + d->volume = b->volume; + d->sub_delay = b->sub_delay * 64; + d->sub_volume = b->sub_volume; + d->leak_rtl = b->leak_rtl; + d->leak_ltl = b->leak_ltl; + d->mix_reverb_idx = b->mix_reverb_idx; + d->mix_reverb_strength = b->mix_reverb_strength; + d->use_reverb = 8; + if (c) { + d->left_reverb_buf = (s16*)Nas_2ndHeapAlloc_CL(&AG.misc_heap, d->delay_num_samples * sizeof(s16)); + d->right_reverb_buf = (s16*)Nas_2ndHeapAlloc_CL(&AG.misc_heap, d->delay_num_samples * sizeof(s16)); + d->resample_flags = 1; + d->next_reverb_buf_pos = 0; + d->delay_num_samples_unk = 0; + d->cur_frame = 0; + d->frames_to_ignore = 2; + } + d->tuned_sample.wavetable = &d->sample; + d->sample.loop = &d->adpcm_loop; + d->tuned_sample.tuning = 1.f; + d->sample.codec = 4; + d->sample.medium = 0; + d->sample.size = d->delay_num_samples * sizeof(s16); + d->sample.sample = (u8*)d->left_reverb_buf; + d->adpcm_loop.loop_start = 0; + d->adpcm_loop.loop_end = d->delay_num_samples; + d->adpcm_loop.count = 1; + Nas_SetDelayLineParam(a, 7, b->_14, c); + Nas_SetDelayLineParam(a, 8, b->_16, c); } diff --git a/src/static/jaudio_NES/internal/system.c b/src/static/jaudio_NES/internal/system.c index 1536a1f5..30d667fa 100644 --- a/src/static/jaudio_NES/internal/system.c +++ b/src/static/jaudio_NES/internal/system.c @@ -24,8 +24,8 @@ static void* FASTDMA_BUFFER = NULL; Na_DmaProc NA_DMA_PROC = Z_osEPiStartDma; Na_SyncProc NA_SYNC_PROC = Nas_GetSyncDummy; -static s32 Nas_StartDma(OSIoMesg* ioMsg, s32 priority, s32 direction, u32 device_addr, - void* dram_addr, u32 size, OSMesgQueue* mq, s32 medium, s8* dma_type); +static s32 Nas_StartDma(OSIoMesg* ioMsg, s32 priority, s32 direction, u32 device_addr, void* dram_addr, u32 size, + OSMesgQueue* mq, s32 medium, s8* dma_type); s32 Nas_BankOfsToAddr(s32 bank_id, u8* ctrl_p, WaveMedia* wave_media, s32 async); static s32 __Link_BankNum(s32 type, s32 id); @@ -39,7 +39,8 @@ static u8* __Load_Bank(s32 table_type, s32 id, s32* did_alloc); static u32 __Load_Wave(s32 wave_id, u32* medium, s32 no_load); static void* __Check_Cache(s32 table_type, s32 id); static void __WaveTouch(wtstr* wavetouch_str, u32 ram_addr, WaveMedia* wave_media); -static Bgload* Nas_BgCopyDisk(s32 dev_medium, u8* src, u8* dst, u32 size, s32 medium, s32 n_chunks, OSMesgQueue* mq, s32 msg); +static Bgload* Nas_BgCopyDisk(s32 dev_medium, u8* src, u8* dst, u32 size, s32 medium, s32 n_chunks, OSMesgQueue* mq, + s32 msg); static Bgload* Nas_BgCopyReq(u8* src, u8* dst, u32 size, s32 medium, s32 n_chunks, OSMesgQueue* mq, s32 msg); static smzwavetable* __GetWaveTable(s32 bank_id, s32 inst_id); static void __Nas_SlowDiskCopy(u8* dev_addr, u8* ram_addr, u32 size, s32 medium); @@ -50,7 +51,6 @@ static void __Nas_BgDiskCopy(u8* src, u8* dst, u32 size, s32 param); static void __Nas_ExCopy(Bgload* bgload, s32 size); static void __Nas_BgCopy(Bgload* bgload, s32 size); - void Nas_WaveDmaFrameWork(void) { WaveLoad* wl; WaveLoad* wl2; @@ -107,8 +107,10 @@ void* Nas_WaveDmaCallBack(u32 device_addr, u32 size, s32 arg2, u8* waveload_idx, // Move the WAVELOAD out of the reuse queue, by swapping it with the // read pos, and then incrementing the read pos. if (waveload->reuse_idx != AG.waveload_dma_queue1_rpos) { - AG.waveload_dma_queue1[waveload->reuse_idx] = AG.waveload_dma_queue1[AG.waveload_dma_queue1_rpos]; - AG.waveload_list[AG.waveload_dma_queue1[AG.waveload_dma_queue1_rpos]] .reuse_idx = waveload->reuse_idx; + AG.waveload_dma_queue1[waveload->reuse_idx] = + AG.waveload_dma_queue1[AG.waveload_dma_queue1_rpos]; + AG.waveload_list[AG.waveload_dma_queue1[AG.waveload_dma_queue1_rpos]].reuse_idx = + waveload->reuse_idx; } AG.waveload_dma_queue1_rpos++; } @@ -130,7 +132,7 @@ void* Nas_WaveDmaCallBack(u32 device_addr, u32 size, s32 arg2, u8* waveload_idx, hasWaveload = TRUE; } } else { -search_short_lived: + search_short_lived: waveload = AG.waveload_list + *waveload_idx; for (i = 0; i <= AG.waveload_count; waveload = AG.waveload_list + i++) { bufferPos = device_addr - waveload->device_addr; @@ -140,8 +142,10 @@ search_short_lived: // Move the WAVELOAD out of the reuse queue, by swapping it with the // read pos, and then incrementing the read pos. if (waveload->reuse_idx != AG.waveload_dma_queue0_rpos) { - AG.waveload_dma_queue0[waveload->reuse_idx] = AG.waveload_dma_queue0[AG.waveload_dma_queue0_rpos]; - AG.waveload_list[AG.waveload_dma_queue0[AG.waveload_dma_queue0_rpos]].reuse_idx = waveload->reuse_idx; + AG.waveload_dma_queue0[waveload->reuse_idx] = + AG.waveload_dma_queue0[AG.waveload_dma_queue0_rpos]; + AG.waveload_list[AG.waveload_dma_queue0[AG.waveload_dma_queue0_rpos]].reuse_idx = + waveload->reuse_idx; } AG.waveload_dma_queue0_rpos++; } @@ -168,8 +172,9 @@ search_short_lived: waveload->time_to_live = 3; waveload->device_addr = waveloadDevAddr; waveload->size_unused = transfer; - Nas_StartDma(&AG.cur_adio_frame_dma_io_mesg_buf[AG.current_frame_dma_count++], 0 /* OS_MESG_PRI_NORMAL */, 0 /* OS_READ */, - waveloadDevAddr, waveload->ram_addr, transfer, &AG.cur_audio_frame_dma_queue, medium, (s8*)"SUPERDMA"); + Nas_StartDma(&AG.cur_adio_frame_dma_io_mesg_buf[AG.current_frame_dma_count++], 0 /* OS_MESG_PRI_NORMAL */, + 0 /* OS_READ */, waveloadDevAddr, waveload->ram_addr, transfer, &AG.cur_audio_frame_dma_queue, medium, + (s8*)"SUPERDMA"); *waveload_idx = waveloadIndex; return (device_addr - waveloadDevAddr) + waveload->ram_addr; } @@ -180,7 +185,8 @@ void Nas_WaveDmaNew(s32 n_channels) { s32 t2; AG.waveload_dma_cur_buf_size = AG.waveload_dma_buf0_size; - AG.waveload_list = (WaveLoad*)Nas_HeapAlloc(&AG.misc_heap, 4 * AG.num_channels * sizeof(WaveLoad) * AG.audio_params.spec); + AG.waveload_list = + (WaveLoad*)Nas_HeapAlloc(&AG.misc_heap, 4 * AG.num_channels * sizeof(WaveLoad) * AG.audio_params.spec); t2 = 3 * AG.num_channels * AG.audio_params.spec; for (i = 0; i < t2; i++) { waveload = &AG.waveload_list[AG.num_waveloads]; @@ -371,7 +377,8 @@ static s32 __Nas_LoadVoice_Inner(smzwavetable* wavetable, s32 bank_id) { if (wavetable->is_relocated == TRUE) { if (wavetable->medium != MEDIUM_RAM) { - sample_addr = (u8*)Nas_Alloc_Single(wavetable->size, bank_id, wavetable->sample, wavetable->medium, CACHE_PERSISTENT); + sample_addr = + (u8*)Nas_Alloc_Single(wavetable->size, bank_id, wavetable->sample, wavetable->medium, CACHE_PERSISTENT); if (sample_addr == NULL) { return -1; } @@ -390,7 +397,6 @@ static s32 __Nas_LoadVoice_Inner(smzwavetable* wavetable, s32 bank_id) { return 0; } - s32 Nas_LoadVoice(s32 bank_id, s32 instId, s32 drumId) { if (instId < 0x7F) { voicetable* voice = ProgToVp(bank_id, instId); @@ -551,7 +557,7 @@ static s32 __Nas_StartSeq(s32 group_idx, s32 seq_id, s32 param) { Nas_InitMySeq(group); group->seq_id = seq_id; - + if (bank_id != 0xFF) { bank_id = __Link_BankNum(BANK_TABLE, bank_id); group->bank_id = bank_id; @@ -600,12 +606,12 @@ static u32 __Load_Wave(s32 wave_id, u32* medium, s32 no_load) { *medium = MEDIUM_RAM; return (u32)ram_p; } - + if (header->entries[wave_id].cacheType == CACHE_LOAD_EITHER_NOSYNC || no_load == TRUE) { *medium = header->entries[wave_id].medium; return header->entries[link_id].addr; } - + ram_p = __Load_Bank(WAVE_TABLE, wave_id, &no_load); if (ram_p != NULL) { *medium = MEDIUM_RAM; @@ -633,7 +639,7 @@ static u8* __Load_Ctrl(s32 bank_id) { wave_media.wave0_bank_id = wave_id0; wave_media.wave1_bank_id = wave_id1; - + if (wave_id0 != 0xFF) { wave_media.wave0_p = (void*)__Load_Wave(wave_id0, &wave_media.wave0_media, FALSE); } else { @@ -719,7 +725,7 @@ static u8* __Load_Bank(s32 table_type, s32 id, s32* did_alloc) { if (rom_addr == NULL) { return NULL; } - + if (table_type == BANK_TABLE) { size -= sizeof(ArcEntry); vinfo = &AG.voice_info[link_id]; @@ -781,7 +787,7 @@ static void* __Check_Cache(s32 table_type, s32 id) { return ram_p; } - ram_p = (void*)Nas_SzCacheCheck(table_type, CACHE_EITHER, id); + ram_p = Nas_SzCacheCheck(table_type, CACHE_EITHER, id); if (ram_p) { return ram_p; } @@ -828,7 +834,7 @@ static void Nas_BankOfsToAddr_Inner(s32 bank_id, u8* ctrl_p, WaveMedia* wave_med continue; // empty percussion/drum entry } - inst_ofs += (u32)ctrl_p;//OFS2RAM(ctrl_p, ofs); + inst_ofs += (u32)ctrl_p; // OFS2RAM(ctrl_p, ofs); percvt = (perctable*)inst_ofs; ((perctable**)*BANK_ENTRY(ctrl_p, 0))[i] = percvt; @@ -920,7 +926,7 @@ void Nas_FastCopy(u8* SrcAddr, u8* DestAdd, size_t Length, s32 medium) { if ((((u32)SrcAddr) & 0x1F) != 0) { OSReport("DMA Warning: SrcAddr %d is not align32\n", SrcAddr); } - + if ((((u32)DestAdd) & 0x1F) != 0) { OSReport("DMA Warning: DestAdd %d is not align32\n", DestAdd); } @@ -930,16 +936,18 @@ void Nas_FastCopy(u8* SrcAddr, u8* DestAdd, size_t Length, s32 medium) { // DMA the first non-align32 bytes // @BUG - FASTDMA_BUFFER is always NULL - Nas_StartDma(&AG.sync_dma_io_mesg, 1, 0, (u32)SrcAddr - (((u32)SrcAddr) & 0x1F), FASTDMA_BUFFER, 0x20, &AG.sync_dma_queue, medium, (s8*)"FastCopy"); + Nas_StartDma(&AG.sync_dma_io_mesg, 1, 0, (u32)SrcAddr - (((u32)SrcAddr) & 0x1F), FASTDMA_BUFFER, 0x20, + &AG.sync_dma_queue, medium, (s8*)"FastCopy"); Z_osRecvMesg(&AG.sync_dma_queue, NULL, OS_MESG_BLOCK); unalign_copy_len = 32 - (((u32)SrcAddr) & 0x1F); Z_bcopy(unalign_src_copy + (((u32)SrcAddr) & 0x1F), DestAdd, 32 - (((u32)SrcAddr) & 0x1F)); SrcAddr += unalign_copy_len; DestAdd += unalign_copy_len; Length -= unalign_copy_len; - + while (Length != 0) { - Nas_StartDma(&AG.sync_dma_io_mesg, 1, 0, (u32)SrcAddr, unalign_src_copy, 0x400, &AG.sync_dma_queue, medium, (s8*)"FastCopy"); + Nas_StartDma(&AG.sync_dma_io_mesg, 1, 0, (u32)SrcAddr, unalign_src_copy, 0x400, &AG.sync_dma_queue, medium, + (s8*)"FastCopy"); Z_osRecvMesg(&AG.sync_dma_queue, NULL, OS_MESG_BLOCK); if (Length < 0x400) { @@ -959,7 +967,8 @@ void Nas_FastCopy(u8* SrcAddr, u8* DestAdd, size_t Length, s32 medium) { break; } - Nas_StartDma(&AG.sync_dma_io_mesg, 1, 0, (u32)SrcAddr, DestAdd, 0x400, &AG.sync_dma_queue, medium, (s8*)"FastCopy"); + Nas_StartDma(&AG.sync_dma_io_mesg, 1, 0, (u32)SrcAddr, DestAdd, 0x400, &AG.sync_dma_queue, medium, + (s8*)"FastCopy"); Z_osRecvMesg(&AG.sync_dma_queue, NULL, OS_MESG_BLOCK); Length -= 0x400; SrcAddr += 0x400; @@ -967,7 +976,8 @@ void Nas_FastCopy(u8* SrcAddr, u8* DestAdd, size_t Length, s32 medium) { } if (Length != 0) { - Nas_StartDma(&AG.sync_dma_io_mesg, 1, 0, (u32)SrcAddr, DestAdd, Length, &AG.sync_dma_queue, medium, (s8*)"FastCopy"); + Nas_StartDma(&AG.sync_dma_io_mesg, 1, 0, (u32)SrcAddr, DestAdd, Length, &AG.sync_dma_queue, medium, + (s8*)"FastCopy"); Z_osRecvMesg(&AG.sync_dma_queue, NULL, OS_MESG_BLOCK); } } @@ -977,11 +987,11 @@ extern void Nas_FastDiskCopy(u8* SrcAddr, u8* DestAdd, size_t Length, s32 medium // empty } -static s32 Nas_StartDma(OSIoMesg* ioMsg, s32 priority, s32 direction, u32 device_addr, - void* dram_addr, u32 size, OSMesgQueue* mq, s32 medium, s8* dma_type) { +static s32 Nas_StartDma(OSIoMesg* ioMsg, s32 priority, s32 direction, u32 device_addr, void* dram_addr, u32 size, + OSMesgQueue* mq, s32 medium, s8* dma_type) { OSPiHandle* handle; - - osInvalDCache2(dram_addr, size); + + osInvalDCache2(dram_addr, size); if (AG.reset_timer > 16) { return -1; } @@ -1055,7 +1065,8 @@ static u8* __Load_Bank_BG(s32 table_type, s32 id, s32 n_chunks, s32 ret_data, OS ramAddr = (u8*)__Check_Cache(table_type, link_id); if (ramAddr != NULL) { loadStatus = LOAD_STATUS_COMPLETE; - Z_osSendMesg(ret_queue, (OSMesg)MK_BGLOAD_MSG(ret_data, SEQUENCE_TABLE, 0, LOAD_STATUS_NOT_LOADED), OS_MESG_NOBLOCK); + Z_osSendMesg(ret_queue, (OSMesg)MK_BGLOAD_MSG(ret_data, SEQUENCE_TABLE, 0, LOAD_STATUS_NOT_LOADED), + OS_MESG_NOBLOCK); } else { header = __Get_ArcHeader(table_type); size = header->entries[link_id].size; @@ -1101,7 +1112,7 @@ static u8* __Load_Bank_BG(s32 table_type, s32 id, s32 n_chunks, s32 ret_data, OS if (devAddr == 0) { return NULL; } - + if (table_type == BANK_TABLE) { size -= 0x10; vinfo = &AG.voice_info[link_id]; @@ -1113,11 +1124,11 @@ static u8* __Load_Bank_BG(s32 table_type, s32 id, s32 n_chunks, s32 ret_data, OS } if (medium == MEDIUM_DISK) { - Nas_BgCopyDisk(header->medium, (u8*)devAddr, ramAddr, size, medium, - n_chunks, ret_queue, MK_BGLOAD_MSG(ret_data, table_type, link_id, asyncLoadStatus)); + Nas_BgCopyDisk(header->medium, (u8*)devAddr, ramAddr, size, medium, n_chunks, ret_queue, + MK_BGLOAD_MSG(ret_data, table_type, link_id, asyncLoadStatus)); } else { Nas_BgCopyReq((u8*)devAddr, ramAddr, size, medium, n_chunks, ret_queue, - MK_BGLOAD_MSG(ret_data, table_type, link_id, asyncLoadStatus)); + MK_BGLOAD_MSG(ret_data, table_type, link_id, asyncLoadStatus)); } loadStatus = LOAD_STATUS_IN_PROGRESS; } @@ -1200,12 +1211,13 @@ void Nas_InitAudio(u64* heap_p, s32 heap_size) { *(u32*)&AG.unused_rsp_tasks[0][56] = 0; // OSTask.t.data_size = 0; *(u32*)&AG.unused_rsp_tasks[1][56] = 0; // OSTask.t.data_size = 0; Z_osCreateMesgQueue(&AG.sync_dma_queue, AG.sync_dma_queue_msg, ARRAY_COUNT(AG.sync_dma_queue_msg)); - Z_osCreateMesgQueue(&AG.cur_audio_frame_dma_queue, AG.cur_audio_frame_dma_mesg_buf, ARRAY_COUNT(AG.cur_audio_frame_dma_mesg_buf)); + Z_osCreateMesgQueue(&AG.cur_audio_frame_dma_queue, AG.cur_audio_frame_dma_mesg_buf, + ARRAY_COUNT(AG.cur_audio_frame_dma_mesg_buf)); Z_osCreateMesgQueue(&AG.external_load_queue, AG.external_load_mesg_buf, ARRAY_COUNT(AG.external_load_mesg_buf)); Z_osCreateMesgQueue(&AG.preload_sample_queue, AG.preload_sample_mesg_buf, ARRAY_COUNT(AG.preload_sample_mesg_buf)); AG.current_frame_dma_count = 0; AG.num_waveloads = 0; - + AG.audio_heap_p = heap_p; AG.audio_heap_size = heap_size; OSReport("AUDIOHEAP SET ADDR %xh (SIZE %xh) \n", (u32)heap_p, heap_size); @@ -1293,7 +1305,8 @@ s32 VoiceLoad(s32 bank_id, u32 inst_id, s8* done_p) { cache->sample = *wavetable; cache->is_done = done_p; - cache->current_ram_addr = (u8*)Nas_Alloc_Single(wavetable->size, bank_id, wavetable->sample, wavetable->medium, CACHE_TEMPORARY); + cache->current_ram_addr = + (u8*)Nas_Alloc_Single(wavetable->size, bank_id, wavetable->sample, wavetable->medium, CACHE_TEMPORARY); if (cache->current_ram_addr == NULL) { if (wavetable->medium == MEDIUM_DISK || wavetable->codec == CODEC_S16_INMEMORY) { @@ -1386,7 +1399,8 @@ void LpsDma(s32 reset_status) { *cache->is_done = TRUE; } else if (cache->bytes_remaining < 0x400) { if (cache->medium == MEDIUM_DISK) { - __Nas_SlowDiskCopy((u8*)cache->current_device_addr, cache->current_ram_addr, cache->bytes_remaining, cache->unk_medium_param); + __Nas_SlowDiskCopy((u8*)cache->current_device_addr, cache->current_ram_addr, + cache->bytes_remaining, cache->unk_medium_param); } else { __Nas_SlowCopy(cache, cache->bytes_remaining); } @@ -1394,7 +1408,8 @@ void LpsDma(s32 reset_status) { cache->bytes_remaining = 0; } else { if (cache->medium == MEDIUM_DISK) { - __Nas_SlowDiskCopy((u8*)cache->current_device_addr, cache->current_ram_addr, 0x400, cache->unk_medium_param); + __Nas_SlowDiskCopy((u8*)cache->current_device_addr, cache->current_ram_addr, 0x400, + cache->unk_medium_param); } else { __Nas_SlowCopy(cache, 0x400); } @@ -1412,7 +1427,8 @@ void LpsDma(s32 reset_status) { static void __Nas_SlowCopy(lpscache* cache, s32 size) { osInvalDCache2(cache->current_ram_addr, size); Z_osCreateMesgQueue(&cache->mq, cache->msg, ARRAY_COUNT(cache->msg)); - Nas_StartDma(&cache->io_mesg, 0, 0, cache->current_device_addr, cache->current_ram_addr, size, &cache->mq, cache->medium, (s8*)"SLOWCOPY"); + Nas_StartDma(&cache->io_mesg, 0, 0, cache->current_device_addr, cache->current_ram_addr, size, &cache->mq, + cache->medium, (s8*)"SLOWCOPY"); } static void __Nas_SlowDiskCopy(u8* dev_addr, u8* ram_addr, u32 size, s32 medium) { @@ -1431,7 +1447,7 @@ s32 SeqLoad(s32 seq_id, u8* ram_addr, s8* is_done) { cache->sample.sample = NULL; cache->is_done = is_done; - + size = header->entries[link_id].size; size = ALIGN_NEXT(size, 32); @@ -1459,7 +1475,8 @@ void Nas_BgCopyInit(void) { } } -static Bgload* Nas_BgCopyDisk(s32 dev_medium, u8* src, u8* dst, u32 size, s32 medium, s32 n_chunks, OSMesgQueue* mq, s32 msg) { +static Bgload* Nas_BgCopyDisk(s32 dev_medium, u8* src, u8* dst, u32 size, s32 medium, s32 n_chunks, OSMesgQueue* mq, + s32 msg) { Bgload* bgload = Nas_BgCopyReq(src, dst, size, medium, n_chunks, mq, msg); if (bgload == NULL) { @@ -1491,7 +1508,7 @@ static Bgload* Nas_BgCopyReq(u8* src, u8* dst, u32 size, s32 medium, s32 n_chunk bgload->ram_addr = dst; bgload->current_ram_addr = dst; bgload->bytes_remaining = size; - + if (n_chunks == 0) { bgload->chunk_size = 0x1000; } else if (n_chunks == 1) { @@ -1562,7 +1579,7 @@ static void __BgCopyFinishProcess(Bgload* bgload) { s32 wave0; s32 wave1; WaveMedia wavemedia; - + type = BGLOAD_TBLTYPE(msg); status = BGLOAD_LOAD_STATUS(msg); id = BGLOAD_ID(msg); @@ -1591,7 +1608,7 @@ static void __BgCopyFinishProcess(Bgload* bgload) { } else { wavemedia.wave1_p = NULL; } - + Nas_WriteIDbank(id, status); Nas_BankOfsToAddr(id, bgload->ram_addr, &wavemedia, TRUE); break; @@ -1627,7 +1644,8 @@ static void __BgCopySub(Bgload* bgload, s32 reset_status) { if (bgload->bytes_remaining < bgload->chunk_size) { if (bgload->medium == MEDIUM_DISK) { - __Nas_BgDiskCopy((u8*)bgload->current_device_addr, bgload->current_ram_addr, bgload->bytes_remaining, header->medium); + __Nas_BgDiskCopy((u8*)bgload->current_device_addr, bgload->current_ram_addr, bgload->bytes_remaining, + header->medium); } else if (bgload->medium == MEDIUM_RAM_UNLOADED) { __Nas_ExCopy(bgload, bgload->bytes_remaining); } else { @@ -1637,7 +1655,8 @@ static void __BgCopySub(Bgload* bgload, s32 reset_status) { bgload->bytes_remaining = 0; } else { if (bgload->medium == MEDIUM_DISK) { - __Nas_BgDiskCopy((u8*)bgload->current_device_addr, bgload->current_ram_addr, bgload->chunk_size, header->medium); + __Nas_BgDiskCopy((u8*)bgload->current_device_addr, bgload->current_ram_addr, bgload->chunk_size, + header->medium); } else if (bgload->medium == MEDIUM_RAM_UNLOADED) { __Nas_ExCopy(bgload, bgload->chunk_size); } else { @@ -1654,7 +1673,8 @@ static void __Nas_BgCopy(Bgload* bgload, s32 size) { size = ALIGN_NEXT(size, 32); osInvalDCache2(bgload->current_ram_addr, size); Z_osCreateMesgQueue(&bgload->mq, bgload->msg, ARRAY_COUNT(bgload->msg)); - Nas_StartDma(&bgload->io_mesg, 0, 0, bgload->current_device_addr, bgload->current_ram_addr, size, &bgload->mq, bgload->medium, (s8*)"BGCOPY"); + Nas_StartDma(&bgload->io_mesg, 0, 0, bgload->current_device_addr, bgload->current_ram_addr, size, &bgload->mq, + bgload->medium, (s8*)"BGCOPY"); } static void __Nas_ExCopy(Bgload* bgload, s32 size) { @@ -1672,7 +1692,7 @@ static void __Nas_BgDiskCopy(u8* src, u8* dst, u32 size, s32 param) { static void __WaveTouch(wtstr* wavetouch_str, u32 ram_addr, WaveMedia* wave_media) { smzwavetable* wavetable; void* reloc; - + if ((u32)wavetouch_str->wavetable <= OS_BASE_CACHED) { // wave is not relocated reloc = (void*)((u32)wavetouch_str->wavetable + ram_addr); @@ -1703,7 +1723,8 @@ static void __WaveTouch(wtstr* wavetouch_str, u32 ram_addr, WaveMedia* wave_medi } wavetable->is_relocated = TRUE; - if (wavetable->bit26 && wavetable->medium != MEDIUM_RAM && AG.num_used_samples < ARRAY_COUNT(AG.used_samples)) { + if (wavetable->bit26 && wavetable->medium != MEDIUM_RAM && + AG.num_used_samples < ARRAY_COUNT(AG.used_samples)) { AG.used_samples[AG.num_used_samples++] = wavetable; } } @@ -1744,24 +1765,30 @@ s32 Nas_BankOfsToAddr(s32 bank_id, u8* ctrl_p, WaveMedia* wave_media, s32 async) wavetable = AG.used_samples[i]; wave_ram_p = NULL; - + switch (async) { case FALSE: if (wavetable->medium == wave_media->wave0_media) { - wave_ram_p = (u8*)Nas_Alloc_Single(wavetable->size, wave_media->wave0_bank_id, wavetable->sample, wavetable->medium, CACHE_PERSISTENT); + wave_ram_p = (u8*)Nas_Alloc_Single(wavetable->size, wave_media->wave0_bank_id, wavetable->sample, + wavetable->medium, CACHE_PERSISTENT); } else if (wavetable->medium == wave_media->wave1_media) { - wave_ram_p = (u8*)Nas_Alloc_Single(wavetable->size, wave_media->wave1_bank_id, wavetable->sample, wavetable->medium, CACHE_PERSISTENT); + wave_ram_p = (u8*)Nas_Alloc_Single(wavetable->size, wave_media->wave1_bank_id, wavetable->sample, + wavetable->medium, CACHE_PERSISTENT); } else if (wavetable->medium == MEDIUM_DISK_DRIVE) { - wave_ram_p = (u8*)Nas_Alloc_Single(wavetable->size, 0xFE, wavetable->sample, wavetable->medium, CACHE_PERSISTENT); + wave_ram_p = (u8*)Nas_Alloc_Single(wavetable->size, 0xFE, wavetable->sample, wavetable->medium, + CACHE_PERSISTENT); } break; case TRUE: if (wavetable->medium == wave_media->wave0_media) { - wave_ram_p = (u8*)Nas_Alloc_Single(wavetable->size, wave_media->wave0_bank_id, wavetable->sample, wavetable->medium, CACHE_TEMPORARY); + wave_ram_p = (u8*)Nas_Alloc_Single(wavetable->size, wave_media->wave0_bank_id, wavetable->sample, + wavetable->medium, CACHE_TEMPORARY); } else if (wavetable->medium == wave_media->wave1_media) { - wave_ram_p = (u8*)Nas_Alloc_Single(wavetable->size, wave_media->wave1_bank_id, wavetable->sample, wavetable->medium, CACHE_TEMPORARY); + wave_ram_p = (u8*)Nas_Alloc_Single(wavetable->size, wave_media->wave1_bank_id, wavetable->sample, + wavetable->medium, CACHE_TEMPORARY); } else if (wavetable->medium == MEDIUM_DISK_DRIVE) { - wave_ram_p = (u8*)Nas_Alloc_Single(wavetable->size, 0xFE, wavetable->sample, wavetable->medium, CACHE_TEMPORARY); + wave_ram_p = (u8*)Nas_Alloc_Single(wavetable->size, 0xFE, wavetable->sample, wavetable->medium, + CACHE_TEMPORARY); } break; } @@ -1800,7 +1827,8 @@ s32 Nas_BankOfsToAddr(s32 bank_id, u8* ctrl_p, WaveMedia* wave_media, s32 async) wavetable = top_preload->sample; n_chunks = 1; n_chunks += (wavetable->size / 0x1000); - Nas_BgCopyReq(wavetable->sample, top_preload->ram_addr, wavetable->size, wavetable->medium, n_chunks, &AG.preload_sample_queue, top_preload->encoded_info); + Nas_BgCopyReq(wavetable->sample, top_preload->ram_addr, wavetable->size, wavetable->medium, n_chunks, + &AG.preload_sample_queue, top_preload->encoded_info); } // @BUG - this function clearly has no return value @@ -1814,7 +1842,7 @@ s32 Nas_CheckBgWave(s32 reset_status) { u32 preload_idx; s32 key; s32 n_chunks; - + if (AG.num_requested_samples > 0) { if (reset_status != 0) { Z_osRecvMesg(&AG.preload_sample_queue, (OSMesg*)&preload_idx, OS_MESG_NOBLOCK); @@ -1860,7 +1888,8 @@ s32 Nas_CheckBgWave(s32 reset_status) { preload->is_free = TRUE; AG.num_requested_samples--; } else { - Nas_BgCopyReq(wavetable->sample, preload->ram_addr, wavetable->size, wavetable->medium, n_chunks, &AG.preload_sample_queue, preload->encoded_info); + Nas_BgCopyReq(wavetable->sample, preload->ram_addr, wavetable->size, wavetable->medium, n_chunks, + &AG.preload_sample_queue, preload->encoded_info); break; } } @@ -1925,7 +1954,7 @@ void WaveReload(s32 bank_id, s32 async, WaveMedia* wavemedia) { for (i = 0; i < n_drums; i++) { percussion = PercToPp(bank_id, i); - + if (percussion != NULL) { __Reload(&percussion->tuned_sample); } @@ -1933,7 +1962,7 @@ void WaveReload(s32 bank_id, s32 async, WaveMedia* wavemedia) { for (i = 0; i < n_sfx; i++) { sfx = VpercToVep(bank_id, i); - + if (sfx != NULL) { __Reload(&sfx->tuned_sample); } @@ -1961,16 +1990,20 @@ void WaveReload(s32 bank_id, s32 async, WaveMedia* wavemedia) { switch (async) { case FALSE: if (wavetable->medium == wavemedia->wave0_media) { - addr = (u8*)Nas_Alloc_Single(wavetable->size, wavemedia->wave0_bank_id, wavetable->sample, wavetable->medium, CACHE_PERSISTENT); + addr = (u8*)Nas_Alloc_Single(wavetable->size, wavemedia->wave0_bank_id, wavetable->sample, + wavetable->medium, CACHE_PERSISTENT); } else if (wavetable->medium == wavemedia->wave1_media) { - addr = (u8*)Nas_Alloc_Single(wavetable->size, wavemedia->wave1_bank_id, wavetable->sample, wavetable->medium, CACHE_PERSISTENT); + addr = (u8*)Nas_Alloc_Single(wavetable->size, wavemedia->wave1_bank_id, wavetable->sample, + wavetable->medium, CACHE_PERSISTENT); } break; case TRUE: if (wavetable->medium == wavemedia->wave0_media) { - addr = (u8*)Nas_Alloc_Single(wavetable->size, wavemedia->wave0_bank_id, wavetable->sample, wavetable->medium, CACHE_TEMPORARY); + addr = (u8*)Nas_Alloc_Single(wavetable->size, wavemedia->wave0_bank_id, wavetable->sample, + wavetable->medium, CACHE_TEMPORARY); } else if (wavetable->medium == wavemedia->wave1_media) { - addr = (u8*)Nas_Alloc_Single(wavetable->size, wavemedia->wave1_bank_id, wavetable->sample, wavetable->medium, CACHE_TEMPORARY); + addr = (u8*)Nas_Alloc_Single(wavetable->size, wavemedia->wave1_bank_id, wavetable->sample, + wavetable->medium, CACHE_TEMPORARY); } break; } @@ -2009,7 +2042,8 @@ void WaveReload(s32 bank_id, s32 async, WaveMedia* wavemedia) { wavetable = top_preload->sample; n_chunks = 1; n_chunks += (wavetable->size / 0x1000); - Nas_BgCopyReq(wavetable->sample, top_preload->ram_addr, wavetable->size, wavetable->medium, n_chunks, &AG.preload_sample_queue, top_preload->encoded_info); + Nas_BgCopyReq(wavetable->sample, top_preload->ram_addr, wavetable->size, wavetable->medium, n_chunks, + &AG.preload_sample_queue, top_preload->encoded_info); } } @@ -2056,7 +2090,7 @@ u8* MK_RMES[MK_ENTRIES]; void MK_load(s32 table_type, s32 id, u8* done_p) { static s32 use = 0; - + MK_RMES[use] = done_p; Nas_PreLoad_BG(table_type, id, 0, use, &MK_QUEUE); use++; From 1449b46ca2937ffd88e2f601899f4f059d486cde Mon Sep 17 00:00:00 2001 From: roeming Date: Fri, 4 Jul 2025 13:12:34 -0400 Subject: [PATCH 6/6] forgot the proc flags --- configure.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/configure.py b/configure.py index b481c13b..827e3422 100644 --- a/configure.py +++ b/configure.py @@ -781,7 +781,7 @@ config.libs = [ Object(Matching, "jaudio_NES/internal/ja_calc.c", extra_cflags=["-sym off"]), Object(NonMatching, "jaudio_NES/internal/jammain_2.c", extra_cflags=["-sym on"]), Object(Matching, "jaudio_NES/internal/jamosc.c"), - Object(NonMatching, "jaudio_NES/internal/memory.c"), + Object(NonMatching, "jaudio_NES/internal/memory.c", extra_cflags=["-pragma \"scheduling 7400\""]), Object(Matching, "jaudio_NES/internal/midplay.c"), Object(Matching, "jaudio_NES/internal/noteon.c"), Object(Matching, "jaudio_NES/internal/oneshot.c"),