mirror/oot
1
0
Fork 0
mirror of https://github.com/zeldaret/oot.git synced 2025-05-12 20:13:47 +00:00
Code Issues Projects Releases Wiki Activity

Clean up audio sample counts: bytes, samples, frames (#1289)

Browse source 
* Clean up bytes, samples, frames

* Improve macro usage

* More missed macros

* rename macro now that it crosses files

* redefine macros in terms of frames

* Another use of macro

* Fix, it's number of samples, not size

* Partial PR Suggestions

* Small change

* size to length

* Correct/Clarify comments

* remove comment

* More PR suggestions, cleanup

* Bad formatting, fixed
This commit is contained in:
engineer124 2022-07-27 15:53:56 -06:00 • committed by GitHub
parent ffcbc0de79
commit 423fec9f79
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
6 changed files with 246 additions and 157 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

25
include/z64audio.h
View file

@ -23,7 +23,24 @@
#define ADSR_GOTO -2 #define ADSR_GOTO -2
#define ADSR_RESTART -3 #define ADSR_RESTART -3
#define AIBUF_LEN 0x580 // size of a single sample point
#define SAMPLE_SIZE sizeof(s16)
// Samples are processed in groups of 16 called a "frame"
#define SAMPLES_PER_FRAME ADPCMFSIZE
// The length of one left/right channel is 13 frames
#define DMEM_1CH_SIZE (13 * SAMPLES_PER_FRAME * SAMPLE_SIZE)
// Both left and right channels
#define DMEM_2CH_SIZE (2 * DMEM_1CH_SIZE)
#define AIBUF_LEN (88 * SAMPLES_PER_FRAME) // number of samples
#define AIBUF_SIZE (AIBUF_LEN * SAMPLE_SIZE) // number of bytes
// Filter sizes
#define FILTER_SIZE (8 * SAMPLE_SIZE)
#define FILTER_BUF_PART1 (8 * SAMPLE_SIZE)
#define FILTER_BUF_PART2 (8 * SAMPLE_SIZE)
// Must be the same amount of samples as copied by aDuplicate() (audio microcode) // Must be the same amount of samples as copied by aDuplicate() (audio microcode)
#define WAVE_SAMPLE_COUNT 64 #define WAVE_SAMPLE_COUNT 64
@ -57,10 +74,10 @@ typedef enum {
} SampleMedium; } SampleMedium;
typedef enum { typedef enum {
/* 0 */ CODEC_ADPCM, /* 0 */ CODEC_ADPCM, // 16 2-byte samples (32 bytes) compressed into 4-bit samples (8 bytes) + 1 header byte
/* 1 */ CODEC_S8, /* 1 */ CODEC_S8, // 16 2-byte samples (32 bytes) compressed into 8-bit samples (16 bytes)
/* 2 */ CODEC_S16_INMEMORY, /* 2 */ CODEC_S16_INMEMORY,
/* 3 */ CODEC_SMALL_ADPCM, /* 3 */ CODEC_SMALL_ADPCM, // 16 2-byte samples (32 bytes) compressed into 2-bit samples (4 bytes) + 1 header byte
/* 4 */ CODEC_REVERB, /* 4 */ CODEC_REVERB,
/* 5 */ CODEC_S16 /* 5 */ CODEC_S16
} SampleCodec; } SampleCodec;

67
src/code/audio_data.c
View file

@ -557,9 +557,70 @@ NoteSubEu gDefaultNoteSub = {
}; };
u16 gHeadsetPanQuantization[64] = { u16 gHeadsetPanQuantization[64] = {
60, 58, 56, 54, 52, 50, 48, 46, 44, 42, 40, 38, 36, 34, 32, 30, 28, 26, 24, 22, 20, 18, 30 * SAMPLE_SIZE,
16, 14, 12, 10, 8, 6, 4, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 29 * SAMPLE_SIZE,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 28 * SAMPLE_SIZE,
27 * SAMPLE_SIZE,
26 * SAMPLE_SIZE,
25 * SAMPLE_SIZE,
24 * SAMPLE_SIZE,
23 * SAMPLE_SIZE,
22 * SAMPLE_SIZE,
21 * SAMPLE_SIZE,
20 * SAMPLE_SIZE,
19 * SAMPLE_SIZE,
18 * SAMPLE_SIZE,
17 * SAMPLE_SIZE,
16 * SAMPLE_SIZE,
15 * SAMPLE_SIZE,
14 * SAMPLE_SIZE,
13 * SAMPLE_SIZE,
12 * SAMPLE_SIZE,
11 * SAMPLE_SIZE,
10 * SAMPLE_SIZE,
9 * SAMPLE_SIZE,
8 * SAMPLE_SIZE,
7 * SAMPLE_SIZE,
6 * SAMPLE_SIZE,
5 * SAMPLE_SIZE,
4 * SAMPLE_SIZE,
3 * SAMPLE_SIZE,
2 * SAMPLE_SIZE,
1 * SAMPLE_SIZE,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
}; };
s32 D_8012FBA4 = 0; s32 D_8012FBA4 = 0;

34
src/code/audio_heap.c
View file

@ -961,7 +961,7 @@ void AudioHeap_Init(void) {
// Initialize audio binary interface command list buffers // Initialize audio binary interface command list buffers
for (i = 0; i != 2; i++) { for (i = 0; i != 2; i++) {
gAudioContext.abiCmdBufs[i] = gAudioContext.abiCmdBufs[i] =
AudioHeap_AllocDmaMemoryZeroed(&gAudioContext.miscPool, gAudioContext.maxAudioCmds * sizeof(u64)); AudioHeap_AllocDmaMemoryZeroed(&gAudioContext.miscPool, gAudioContext.maxAudioCmds * sizeof(Acmd));
} }
// Initialize the decay rate table for adsr // Initialize the decay rate table for adsr
@ -992,9 +992,9 @@ void AudioHeap_Init(void) {
reverb->unk_08 = settings->unk_12; reverb->unk_08 = settings->unk_12;
reverb->useReverb = 8; reverb->useReverb = 8;
reverb->leftRingBuf = reverb->leftRingBuf =
AudioHeap_AllocZeroedAttemptExternal(&gAudioContext.miscPool, reverb->windowSize * sizeof(s16)); AudioHeap_AllocZeroedAttemptExternal(&gAudioContext.miscPool, reverb->windowSize * SAMPLE_SIZE);
reverb->rightRingBuf = reverb->rightRingBuf =
AudioHeap_AllocZeroedAttemptExternal(&gAudioContext.miscPool, reverb->windowSize * sizeof(s16)); AudioHeap_AllocZeroedAttemptExternal(&gAudioContext.miscPool, reverb->windowSize * SAMPLE_SIZE);
reverb->nextRingBufPos = 0; reverb->nextRingBufPos = 0;
reverb->unk_20 = 0; reverb->unk_20 = 0;
reverb->curFrame = 0; reverb->curFrame = 0;
@ -1006,7 +1006,7 @@ void AudioHeap_Init(void) {
reverb->tunedSample.tuning = 1.0f; reverb->tunedSample.tuning = 1.0f;
reverb->sample.codec = CODEC_REVERB; reverb->sample.codec = CODEC_REVERB;
reverb->sample.medium = MEDIUM_RAM; reverb->sample.medium = MEDIUM_RAM;
reverb->sample.size = reverb->windowSize * 2; reverb->sample.size = reverb->windowSize * SAMPLE_SIZE;
reverb->sample.sampleAddr = (u8*)reverb->leftRingBuf; reverb->sample.sampleAddr = (u8*)reverb->leftRingBuf;
reverb->loop.start = 0; reverb->loop.start = 0;
reverb->loop.count = 1; reverb->loop.count = 1;
@ -1014,32 +1014,34 @@ void AudioHeap_Init(void) {
if (reverb->downsampleRate != 1) { if (reverb->downsampleRate != 1) {
reverb->unk_0E = 0x8000 / reverb->downsampleRate; reverb->unk_0E = 0x8000 / reverb->downsampleRate;
reverb->unk_30 = AudioHeap_AllocZeroed(&gAudioContext.miscPool, 0x20); reverb->unk_30 = AudioHeap_AllocZeroed(&gAudioContext.miscPool, sizeof(RESAMPLE_STATE));
reverb->unk_34 = AudioHeap_AllocZeroed(&gAudioContext.miscPool, 0x20); reverb->unk_34 = AudioHeap_AllocZeroed(&gAudioContext.miscPool, sizeof(RESAMPLE_STATE));
reverb->unk_38 = AudioHeap_AllocZeroed(&gAudioContext.miscPool, 0x20); reverb->unk_38 = AudioHeap_AllocZeroed(&gAudioContext.miscPool, sizeof(RESAMPLE_STATE));
reverb->unk_3C = AudioHeap_AllocZeroed(&gAudioContext.miscPool, 0x20); reverb->unk_3C = AudioHeap_AllocZeroed(&gAudioContext.miscPool, sizeof(RESAMPLE_STATE));
for (j = 0; j < gAudioContext.audioBufferParameters.updatesPerFrame; j++) { for (j = 0; j < gAudioContext.audioBufferParameters.updatesPerFrame; j++) {
ramAddr = AudioHeap_AllocZeroedAttemptExternal(&gAudioContext.miscPool, 0x340); ramAddr = AudioHeap_AllocZeroedAttemptExternal(&gAudioContext.miscPool, DMEM_2CH_SIZE);
reverb->items[0][j].toDownsampleLeft = ramAddr; reverb->items[0][j].toDownsampleLeft = ramAddr;
reverb->items[0][j].toDownsampleRight = ramAddr + 0x1A0 / sizeof(s16); reverb->items[0][j].toDownsampleRight = ramAddr + DMEM_1CH_SIZE / SAMPLE_SIZE;
ramAddr = AudioHeap_AllocZeroedAttemptExternal(&gAudioContext.miscPool, 0x340); ramAddr = AudioHeap_AllocZeroedAttemptExternal(&gAudioContext.miscPool, DMEM_2CH_SIZE);
reverb->items[1][j].toDownsampleLeft = ramAddr; reverb->items[1][j].toDownsampleLeft = ramAddr;
reverb->items[1][j].toDownsampleRight = ramAddr + 0x1A0 / sizeof(s16); reverb->items[1][j].toDownsampleRight = ramAddr + DMEM_1CH_SIZE / SAMPLE_SIZE;
} }
} }
if (settings->lowPassFilterCutoffLeft != 0) { if (settings->lowPassFilterCutoffLeft != 0) {
reverb->filterLeftState = AudioHeap_AllocDmaMemoryZeroed(&gAudioContext.miscPool, 0x40); reverb->filterLeftState =
reverb->filterLeft = AudioHeap_AllocDmaMemory(&gAudioContext.miscPool, 8 * sizeof(s16)); AudioHeap_AllocDmaMemoryZeroed(&gAudioContext.miscPool, 2 * (FILTER_BUF_PART1 + FILTER_BUF_PART2));
reverb->filterLeft = AudioHeap_AllocDmaMemory(&gAudioContext.miscPool, FILTER_SIZE);
AudioHeap_LoadLowPassFilter(reverb->filterLeft, settings->lowPassFilterCutoffLeft); AudioHeap_LoadLowPassFilter(reverb->filterLeft, settings->lowPassFilterCutoffLeft);
} else { } else {
reverb->filterLeft = NULL; reverb->filterLeft = NULL;
} }
if (settings->lowPassFilterCutoffRight != 0) { if (settings->lowPassFilterCutoffRight != 0) {
reverb->filterRightState = AudioHeap_AllocDmaMemoryZeroed(&gAudioContext.miscPool, 0x40); reverb->filterRightState =
reverb->filterRight = AudioHeap_AllocDmaMemory(&gAudioContext.miscPool, 8 * sizeof(s16)); AudioHeap_AllocDmaMemoryZeroed(&gAudioContext.miscPool, 2 * (FILTER_BUF_PART1 + FILTER_BUF_PART2));
reverb->filterRight = AudioHeap_AllocDmaMemory(&gAudioContext.miscPool, FILTER_SIZE);
AudioHeap_LoadLowPassFilter(reverb->filterRight, settings->lowPassFilterCutoffRight); AudioHeap_LoadLowPassFilter(reverb->filterRight, settings->lowPassFilterCutoffRight);
} else { } else {
reverb->filterRight = NULL; reverb->filterRight = NULL;

2
src/code/audio_init_params.c
View file

@ -17,7 +17,7 @@ const s16 D_8014A6C0[] = {
#define SFX_SOUNDFONT_2_SIZE 0x17B0 #define SFX_SOUNDFONT_2_SIZE 0x17B0
// Sizes of everything on the init pool // Sizes of everything on the init pool
#define AI_BUFFERS_SIZE (AIBUF_LEN * sizeof(s16) * ARRAY_COUNT(gAudioContext.aiBuffers)) #define AI_BUFFERS_SIZE (AIBUF_SIZE * ARRAY_COUNT(gAudioContext.aiBuffers))
#define SOUNDFONT_LIST_SIZE (NUM_SOUNDFONTS * sizeof(SoundFont)) #define SOUNDFONT_LIST_SIZE (NUM_SOUNDFONTS * sizeof(SoundFont))
#define PERMANENT_POOL_SIZE (SFX_SEQ_SIZE + SFX_SOUNDFONT_1_SIZE + SFX_SOUNDFONT_2_SIZE) #define PERMANENT_POOL_SIZE (SFX_SEQ_SIZE + SFX_SOUNDFONT_1_SIZE + SFX_SOUNDFONT_2_SIZE)

4
src/code/audio_load.c
View file

@ -1200,8 +1200,8 @@ void AudioLoad_Init(void* heap, u32 heapSize) {
AudioHeap_InitMainPools(gAudioHeapInitSizes.initPoolSize); AudioHeap_InitMainPools(gAudioHeapInitSizes.initPoolSize);
// Initialize the audio interface buffers // Initialize the audio interface buffers
for (i = 0; i < 3; i++) { for (i = 0; i < ARRAY_COUNT(gAudioContext.aiBuffers); i++) {
gAudioContext.aiBuffers[i] = AudioHeap_AllocZeroed(&gAudioContext.initPool, AIBUF_LEN * sizeof(s16)); gAudioContext.aiBuffers[i] = AudioHeap_AllocZeroed(&gAudioContext.initPool, AIBUF_SIZE);
} }
// Set audio tables pointers // Set audio tables pointers

271
src/code/audio_synthesis.c
View file

@ -1,25 +1,22 @@
#include "ultra64.h" #include "ultra64.h"
#include "global.h" #include "global.h"
#define DEFAULT_LEN_1CH 0x1A0
#define DEFAULT_LEN_2CH 0x340
// DMEM Addresses for the RSP // DMEM Addresses for the RSP
#define DMEM_TEMP 0x3C0 #define DMEM_TEMP 0x3C0
#define DMEM_UNCOMPRESSED_NOTE 0x580 #define DMEM_UNCOMPRESSED_NOTE 0x580
#define DMEM_NOTE_PAN_TEMP 0x5C0 #define DMEM_NOTE_PAN_TEMP 0x5C0
#define DMEM_SCRATCH2 0x760 // = DMEM_TEMP + DEFAULT_LEN_2CH + a bit more #define DMEM_SCRATCH2 0x760 // = DMEM_TEMP + DMEM_2CH_SIZE + a bit more
#define DMEM_COMPRESSED_ADPCM_DATA 0x940 // = DMEM_LEFT_CH #define DMEM_COMPRESSED_ADPCM_DATA 0x940 // = DMEM_LEFT_CH
#define DMEM_LEFT_CH 0x940 #define DMEM_LEFT_CH 0x940
#define DMEM_RIGHT_CH 0xAE0 #define DMEM_RIGHT_CH 0xAE0
#define DMEM_WET_TEMP 0x3E0 #define DMEM_WET_TEMP 0x3E0
#define DMEM_WET_SCRATCH 0x720 // = DMEM_WET_TEMP + DEFAULT_LEN_2CH #define DMEM_WET_SCRATCH 0x720 // = DMEM_WET_TEMP + DMEM_2CH_SIZE
#define DMEM_WET_LEFT_CH 0xC80 #define DMEM_WET_LEFT_CH 0xC80
#define DMEM_WET_RIGHT_CH 0xE20 // = DMEM_WET_LEFT_CH + DEFAULT_LEN_1CH #define DMEM_WET_RIGHT_CH 0xE20 // = DMEM_WET_LEFT_CH + DMEM_1CH_SIZE
Acmd* AudioSynth_LoadRingBufferPart(Acmd* cmd, u16 dmem, u16 startPos, s32 length, SynthesisReverb* reverb); Acmd* AudioSynth_LoadRingBufferPart(Acmd* cmd, u16 dmem, u16 startPos, s32 size, SynthesisReverb* reverb);
Acmd* AudioSynth_SaveBufferOffset(Acmd* cmd, u16 dmem, u16 offset, s32 length, s16* buf); Acmd* AudioSynth_SaveBufferOffset(Acmd* cmd, u16 dmem, u16 offset, s32 size, s16* buf);
Acmd* AudioSynth_SaveRingBufferPart(Acmd* cmd, u16 dmem, u16 startPos, s32 length, SynthesisReverb* reverb); Acmd* AudioSynth_SaveRingBufferPart(Acmd* cmd, u16 dmem, u16 startPos, s32 size, SynthesisReverb* reverb);
Acmd* AudioSynth_DoOneAudioUpdate(s16* aiBuf, s32 aiBufLen, Acmd* cmd, s32 updateIndex); Acmd* AudioSynth_DoOneAudioUpdate(s16* aiBuf, s32 aiBufLen, Acmd* cmd, s32 updateIndex);
Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisState* synthState, s16* aiBuf, Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisState* synthState, s16* aiBuf,
s32 aiBufLen, Acmd* cmd, s32 updateIndex); s32 aiBufLen, Acmd* cmd, s32 updateIndex);
@ -28,7 +25,7 @@ Acmd* AudioSynth_NoteApplyHeadsetPanEffects(Acmd* cmd, NoteSubEu* noteSubEu, Not
s32 flags, s32 side); s32 flags, s32 side);
Acmd* AudioSynth_ProcessEnvelope(Acmd* cmd, NoteSubEu* noteSubEu, NoteSynthesisState* synthState, s32 aiBufLen, Acmd* AudioSynth_ProcessEnvelope(Acmd* cmd, NoteSubEu* noteSubEu, NoteSynthesisState* synthState, s32 aiBufLen,
u16 inBuf, s32 headsetPanSettings, s32 flags); u16 inBuf, s32 headsetPanSettings, s32 flags);
Acmd* AudioSynth_FinalResample(Acmd* cmd, NoteSynthesisState* synthState, s32 count, u16 pitch, u16 inpDmem, Acmd* AudioSynth_FinalResample(Acmd* cmd, NoteSynthesisState* synthState, s32 size, u16 pitch, u16 inpDmem,
s32 resampleFlags); s32 resampleFlags);
u32 D_801304A0 = _SHIFTL(A_ENVMIXER, 24, 8); u32 D_801304A0 = _SHIFTL(A_ENVMIXER, 24, 8);
@ -61,14 +58,14 @@ void AudioSynth_InitNextRingBuf(s32 chunkLen, s32 updateIndex, s32 reverbIndex)
if (reverb->downsampleRate >= 2) { if (reverb->downsampleRate >= 2) {
if (reverb->framesToIgnore == 0) { if (reverb->framesToIgnore == 0) {
bufItem = &reverb->items[reverb->curFrame][updateIndex]; bufItem = &reverb->items[reverb->curFrame][updateIndex];
Audio_InvalDCache(bufItem->toDownsampleLeft, DEFAULT_LEN_2CH); Audio_InvalDCache(bufItem->toDownsampleLeft, DMEM_2CH_SIZE);
for (j = 0, i = 0; i < bufItem->lengthA / 2; j += reverb->downsampleRate, i++) { for (j = 0, i = 0; i < bufItem->lengthA / (s32)SAMPLE_SIZE; j += reverb->downsampleRate, i++) {
reverb->leftRingBuf[bufItem->startPos + i] = bufItem->toDownsampleLeft[j]; reverb->leftRingBuf[bufItem->startPos + i] = bufItem->toDownsampleLeft[j];
reverb->rightRingBuf[bufItem->startPos + i] = bufItem->toDownsampleRight[j]; reverb->rightRingBuf[bufItem->startPos + i] = bufItem->toDownsampleRight[j];
} }
for (i = 0; i < bufItem->lengthB / 2; j += reverb->downsampleRate, i++) { for (i = 0; i < bufItem->lengthB / (s32)SAMPLE_SIZE; j += reverb->downsampleRate, i++) {
reverb->leftRingBuf[i] = bufItem->toDownsampleLeft[j]; reverb->leftRingBuf[i] = bufItem->toDownsampleLeft[j];
reverb->rightRingBuf[i] = bufItem->toDownsampleRight[j]; reverb->rightRingBuf[i] = bufItem->toDownsampleRight[j];
} }
@ -80,14 +77,14 @@ void AudioSynth_InitNextRingBuf(s32 chunkLen, s32 updateIndex, s32 reverbIndex)
extraSamples = (numSamples + reverb->nextRingBufPos) - reverb->bufSizePerChan; extraSamples = (numSamples + reverb->nextRingBufPos) - reverb->bufSizePerChan;
temp_a0_2 = reverb->nextRingBufPos; temp_a0_2 = reverb->nextRingBufPos;
if (extraSamples < 0) { if (extraSamples < 0) {
bufItem->lengthA = numSamples * 2; bufItem->lengthA = numSamples * SAMPLE_SIZE;
bufItem->lengthB = 0; bufItem->lengthB = 0;
bufItem->startPos = reverb->nextRingBufPos; bufItem->startPos = reverb->nextRingBufPos;
reverb->nextRingBufPos += numSamples; reverb->nextRingBufPos += numSamples;
} else { } else {
// End of the buffer is reached. Loop back around // End of the buffer is reached. Loop back around
bufItem->lengthA = (numSamples - extraSamples) * 2; bufItem->lengthA = (numSamples - extraSamples) * SAMPLE_SIZE;
bufItem->lengthB = extraSamples * 2; bufItem->lengthB = extraSamples * SAMPLE_SIZE;
bufItem->startPos = reverb->nextRingBufPos; bufItem->startPos = reverb->nextRingBufPos;
reverb->nextRingBufPos = extraSamples; reverb->nextRingBufPos = extraSamples;
} }
@ -104,13 +101,13 @@ void AudioSynth_InitNextRingBuf(s32 chunkLen, s32 updateIndex, s32 reverbIndex)
numSamples = chunkLen / reverb->downsampleRate; numSamples = chunkLen / reverb->downsampleRate;
extraSamples = (temp_a0_4 + numSamples) - reverb->bufSizePerChan; extraSamples = (temp_a0_4 + numSamples) - reverb->bufSizePerChan;
if (extraSamples < 0) { if (extraSamples < 0) {
bufItem->lengthA = numSamples * 2; bufItem->lengthA = numSamples * SAMPLE_SIZE;
bufItem->lengthB = 0; bufItem->lengthB = 0;
bufItem->startPos = temp_a0_4; bufItem->startPos = temp_a0_4;
} else { } else {
// End of the buffer is reached. Loop back around // End of the buffer is reached. Loop back around
bufItem->lengthA = (numSamples - extraSamples) * 2; bufItem->lengthA = (numSamples - extraSamples) * SAMPLE_SIZE;
bufItem->lengthB = extraSamples * 2; bufItem->lengthB = extraSamples * SAMPLE_SIZE;
bufItem->startPos = temp_a0_4; bufItem->startPos = temp_a0_4;
} }
bufItem->numSamplesAfterDownsampling = numSamples; bufItem->numSamplesAfterDownsampling = numSamples;
@ -175,7 +172,7 @@ Acmd* AudioSynth_Update(Acmd* cmdStart, s32* cmdCnt, s16* aiStart, s32 aiBufLen)
cmdP = AudioSynth_DoOneAudioUpdate(aiBufP, chunkLen, cmdP, cmdP = AudioSynth_DoOneAudioUpdate(aiBufP, chunkLen, cmdP,
gAudioContext.audioBufferParameters.updatesPerFrame - i); gAudioContext.audioBufferParameters.updatesPerFrame - i);
aiBufLen -= chunkLen; aiBufLen -= chunkLen;
aiBufP += chunkLen * 2; aiBufP += 2 * chunkLen;
} }
for (j = 0; j < gAudioContext.numSynthesisReverbs; j++) { for (j = 0; j < gAudioContext.numSynthesisReverbs; j++) {
@ -229,9 +226,9 @@ Acmd* AudioSynth_SaveRingBuffer1AtTemp(Acmd* cmd, SynthesisReverb* reverb, s16 u
* Leak some audio from the left reverb channel into the right reverb channel and vice versa (pan) * Leak some audio from the left reverb channel into the right reverb channel and vice versa (pan)
*/ */
Acmd* AudioSynth_LeakReverb(Acmd* cmd, SynthesisReverb* reverb) { Acmd* AudioSynth_LeakReverb(Acmd* cmd, SynthesisReverb* reverb) {
aDMEMMove(cmd++, DMEM_WET_LEFT_CH, DMEM_WET_SCRATCH, DEFAULT_LEN_1CH); aDMEMMove(cmd++, DMEM_WET_LEFT_CH, DMEM_WET_SCRATCH, DMEM_1CH_SIZE);
aMix(cmd++, 0x1A, reverb->leakRtl, DMEM_WET_RIGHT_CH, DMEM_WET_LEFT_CH); aMix(cmd++, DMEM_1CH_SIZE >> 4, reverb->leakRtl, DMEM_WET_RIGHT_CH, DMEM_WET_LEFT_CH);
aMix(cmd++, 0x1A, reverb->leakLtr, DMEM_WET_SCRATCH, DMEM_WET_RIGHT_CH); aMix(cmd++, DMEM_1CH_SIZE >> 4, reverb->leakLtr, DMEM_WET_SCRATCH, DMEM_WET_RIGHT_CH);
return cmd; return cmd;
} }
@ -240,16 +237,17 @@ Acmd* func_800DB4E4(Acmd* cmd, s32 aiBufLen, SynthesisReverb* reverb, s16 update
s16 offsetA; s16 offsetA;
s16 offsetB; s16 offsetB;
offsetA = (item->startPos & 7) * 2; offsetA = (item->startPos & 7) * SAMPLE_SIZE;
offsetB = ALIGN16(offsetA + item->lengthA); offsetB = ALIGN16(offsetA + item->lengthA);
cmd = AudioSynth_LoadRingBufferPart(cmd, DMEM_WET_TEMP, item->startPos - (offsetA / 2), DEFAULT_LEN_1CH, reverb); cmd = AudioSynth_LoadRingBufferPart(cmd, DMEM_WET_TEMP, item->startPos - (offsetA / (s32)SAMPLE_SIZE),
DMEM_1CH_SIZE, reverb);
if (item->lengthB != 0) { if (item->lengthB != 0) {
// Ring buffer wrapped // Ring buffer wrapped
cmd = AudioSynth_LoadRingBufferPart(cmd, DMEM_WET_TEMP + offsetB, 0, DEFAULT_LEN_1CH - offsetB, reverb); cmd = AudioSynth_LoadRingBufferPart(cmd, DMEM_WET_TEMP + offsetB, 0, DMEM_1CH_SIZE - offsetB, reverb);
} }
aSetBuffer(cmd++, 0, DMEM_WET_TEMP + offsetA, DMEM_WET_LEFT_CH, aiBufLen * 2); aSetBuffer(cmd++, 0, DMEM_WET_TEMP + offsetA, DMEM_WET_LEFT_CH, aiBufLen * SAMPLE_SIZE);
aResample(cmd++, reverb->resampleFlags, reverb->unk_0E, reverb->unk_30); aResample(cmd++, reverb->resampleFlags, reverb->unk_0E, reverb->unk_30);
aSetBuffer(cmd++, 0, DMEM_WET_TEMP + DEFAULT_LEN_1CH + offsetA, DMEM_WET_RIGHT_CH, aiBufLen * 2); aSetBuffer(cmd++, 0, DMEM_WET_TEMP + DMEM_1CH_SIZE + offsetA, DMEM_WET_RIGHT_CH, aiBufLen * SAMPLE_SIZE);
aResample(cmd++, reverb->resampleFlags, reverb->unk_0E, reverb->unk_34); aResample(cmd++, reverb->resampleFlags, reverb->unk_0E, reverb->unk_34);
return cmd; return cmd;
} }
@ -257,7 +255,7 @@ Acmd* func_800DB4E4(Acmd* cmd, s32 aiBufLen, SynthesisReverb* reverb, s16 update
Acmd* func_800DB680(Acmd* cmd, SynthesisReverb* reverb, s16 updateIndex) { Acmd* func_800DB680(Acmd* cmd, SynthesisReverb* reverb, s16 updateIndex) {
ReverbRingBufferItem* bufItem = &reverb->items[reverb->curFrame][updateIndex]; ReverbRingBufferItem* bufItem = &reverb->items[reverb->curFrame][updateIndex];
aSetBuffer(cmd++, 0, DMEM_WET_LEFT_CH, DMEM_WET_SCRATCH, bufItem->unk_18 * 2); aSetBuffer(cmd++, 0, DMEM_WET_LEFT_CH, DMEM_WET_SCRATCH, bufItem->unk_18 * SAMPLE_SIZE);
aResample(cmd++, reverb->resampleFlags, bufItem->unk_16, reverb->unk_38); aResample(cmd++, reverb->resampleFlags, bufItem->unk_16, reverb->unk_38);
cmd = AudioSynth_SaveBufferOffset(cmd, DMEM_WET_SCRATCH, bufItem->startPos, bufItem->lengthA, reverb->leftRingBuf); cmd = AudioSynth_SaveBufferOffset(cmd, DMEM_WET_SCRATCH, bufItem->startPos, bufItem->lengthA, reverb->leftRingBuf);
@ -266,7 +264,7 @@ Acmd* func_800DB680(Acmd* cmd, SynthesisReverb* reverb, s16 updateIndex) {
cmd = AudioSynth_SaveBufferOffset(cmd, DMEM_WET_SCRATCH + bufItem->lengthA, 0, bufItem->lengthB, cmd = AudioSynth_SaveBufferOffset(cmd, DMEM_WET_SCRATCH + bufItem->lengthA, 0, bufItem->lengthB,
reverb->leftRingBuf); reverb->leftRingBuf);
} }
aSetBuffer(cmd++, 0, DMEM_WET_RIGHT_CH, DMEM_WET_SCRATCH, bufItem->unk_18 * 2); aSetBuffer(cmd++, 0, DMEM_WET_RIGHT_CH, DMEM_WET_SCRATCH, bufItem->unk_18 * SAMPLE_SIZE);
aResample(cmd++, reverb->resampleFlags, bufItem->unk_16, reverb->unk_3C); aResample(cmd++, reverb->resampleFlags, bufItem->unk_16, reverb->unk_3C);
cmd = AudioSynth_SaveBufferOffset(cmd, DMEM_WET_SCRATCH, bufItem->startPos, bufItem->lengthA, reverb->rightRingBuf); cmd = AudioSynth_SaveBufferOffset(cmd, DMEM_WET_SCRATCH, bufItem->startPos, bufItem->lengthA, reverb->rightRingBuf);
@ -285,17 +283,18 @@ Acmd* func_800DB828(Acmd* cmd, s32 aiBufLen, SynthesisReverb* reverb, s16 update
s16 offsetB; s16 offsetB;
item->unk_14 = (item->unk_18 << 0xF) / aiBufLen; item->unk_14 = (item->unk_18 << 0xF) / aiBufLen;
offsetA = (item->startPos & 7) * 2; offsetA = (item->startPos & 7) * SAMPLE_SIZE;
item->unk_16 = (aiBufLen << 0xF) / item->unk_18; item->unk_16 = (aiBufLen << 0xF) / item->unk_18;
offsetB = ALIGN16(offsetA + item->lengthA); offsetB = ALIGN16(offsetA + item->lengthA);
cmd = AudioSynth_LoadRingBufferPart(cmd, DMEM_WET_TEMP, item->startPos - (offsetA / 2), DEFAULT_LEN_1CH, reverb); cmd = AudioSynth_LoadRingBufferPart(cmd, DMEM_WET_TEMP, item->startPos - (offsetA / (s32)SAMPLE_SIZE),
DMEM_1CH_SIZE, reverb);
if (item->lengthB != 0) { if (item->lengthB != 0) {
// Ring buffer wrapped // Ring buffer wrapped
cmd = AudioSynth_LoadRingBufferPart(cmd, DMEM_WET_TEMP + offsetB, 0, DEFAULT_LEN_1CH - offsetB, reverb); cmd = AudioSynth_LoadRingBufferPart(cmd, DMEM_WET_TEMP + offsetB, 0, DMEM_1CH_SIZE - offsetB, reverb);
} }
aSetBuffer(cmd++, 0, DMEM_WET_TEMP + offsetA, DMEM_WET_LEFT_CH, aiBufLen * 2); aSetBuffer(cmd++, 0, DMEM_WET_TEMP + offsetA, DMEM_WET_LEFT_CH, aiBufLen * SAMPLE_SIZE);
aResample(cmd++, reverb->resampleFlags, item->unk_14, reverb->unk_30); aResample(cmd++, reverb->resampleFlags, item->unk_14, reverb->unk_30);
aSetBuffer(cmd++, 0, DMEM_WET_TEMP + DEFAULT_LEN_1CH + offsetA, DMEM_WET_RIGHT_CH, aiBufLen * 2); aSetBuffer(cmd++, 0, DMEM_WET_TEMP + DMEM_1CH_SIZE + offsetA, DMEM_WET_RIGHT_CH, aiBufLen * SAMPLE_SIZE);
aResample(cmd++, reverb->resampleFlags, item->unk_14, reverb->unk_34); aResample(cmd++, reverb->resampleFlags, item->unk_14, reverb->unk_34);
return cmd; return cmd;
} }
@ -303,14 +302,14 @@ Acmd* func_800DB828(Acmd* cmd, s32 aiBufLen, SynthesisReverb* reverb, s16 update
/** /**
* Apply a filter (convolution) to each reverb channel. * Apply a filter (convolution) to each reverb channel.
*/ */
Acmd* AudioSynth_FilterReverb(Acmd* cmd, s32 count, SynthesisReverb* reverb) { Acmd* AudioSynth_FilterReverb(Acmd* cmd, s32 size, SynthesisReverb* reverb) {
if (reverb->filterLeft != NULL) { if (reverb->filterLeft != NULL) {
aFilter(cmd++, 2, count, reverb->filterLeft); aFilter(cmd++, 2, size, reverb->filterLeft);
aFilter(cmd++, reverb->resampleFlags, DMEM_WET_LEFT_CH, reverb->filterLeftState); aFilter(cmd++, reverb->resampleFlags, DMEM_WET_LEFT_CH, reverb->filterLeftState);
} }
if (reverb->filterRight != NULL) { if (reverb->filterRight != NULL) {
aFilter(cmd++, 2, count, reverb->filterRight); aFilter(cmd++, 2, size, reverb->filterRight);
aFilter(cmd++, reverb->resampleFlags, DMEM_WET_RIGHT_CH, reverb->filterRightState); aFilter(cmd++, reverb->resampleFlags, DMEM_WET_RIGHT_CH, reverb->filterRightState);
} }
return cmd; return cmd;
@ -322,7 +321,7 @@ Acmd* AudioSynth_MaybeMixRingBuffer1(Acmd* cmd, SynthesisReverb* reverb, s32 upd
temp_a3 = &gAudioContext.synthesisReverbs[reverb->unk_05]; temp_a3 = &gAudioContext.synthesisReverbs[reverb->unk_05];
if (temp_a3->downsampleRate == 1) { if (temp_a3->downsampleRate == 1) {
cmd = AudioSynth_LoadRingBuffer1AtTemp(cmd, temp_a3, updateIndex); cmd = AudioSynth_LoadRingBuffer1AtTemp(cmd, temp_a3, updateIndex);
aMix(cmd++, 0x34, reverb->unk_08, DMEM_WET_LEFT_CH, DMEM_WET_TEMP); aMix(cmd++, DMEM_2CH_SIZE >> 4, reverb->unk_08, DMEM_WET_LEFT_CH, DMEM_WET_TEMP);
cmd = AudioSynth_SaveRingBuffer1AtTemp(cmd, temp_a3, updateIndex); cmd = AudioSynth_SaveRingBuffer1AtTemp(cmd, temp_a3, updateIndex);
} }
return cmd; return cmd;
@ -357,8 +356,8 @@ void func_800DBC10(void) {
void func_800DBC18(void) { void func_800DBC18(void) {
} }
void AudioSynth_SetBuffer(Acmd* cmd, s32 flags, s32 dmemIn, s32 dmemOut, s32 count) { void AudioSynth_SetBuffer(Acmd* cmd, s32 flags, s32 dmemIn, s32 dmemOut, u32 size) {
aSetBuffer(cmd, flags, dmemIn, dmemOut, count); aSetBuffer(cmd, flags, dmemIn, dmemOut, size);
} }
void func_800DBC54(void) { void func_800DBC54(void) {
@ -368,9 +367,9 @@ void func_800DBC5C(void) {
} }
// possible fake match? // possible fake match?
void AudioSynth_DMemMove(Acmd* cmd, s32 dmemIn, s32 dmemOut, s32 count) { void AudioSynth_DMemMove(Acmd* cmd, s32 dmemIn, s32 dmemOut, u32 size) {
cmd->words.w0 = _SHIFTL(A_DMEMMOVE, 24, 8) | _SHIFTL(dmemIn, 0, 24); cmd->words.w0 = _SHIFTL(A_DMEMMOVE, 24, 8) | _SHIFTL(dmemIn, 0, 24);
cmd->words.w1 = _SHIFTL(dmemOut, 16, 16) | _SHIFTL(count, 0, 16); cmd->words.w1 = _SHIFTL(dmemOut, 16, 16) | _SHIFTL(size, 0, 16);
} }
void func_800DBC90(void) { void func_800DBC90(void) {
@ -385,8 +384,8 @@ void func_800DBCA0(void) {
void func_800DBCA8(void) { void func_800DBCA8(void) {
} }
void AudioSynth_InterL(Acmd* cmd, s32 dmemIn, s32 dmemOut, s32 count) { void AudioSynth_InterL(Acmd* cmd, s32 dmemIn, s32 dmemOut, s32 numSamples) {
cmd->words.w0 = _SHIFTL(A_INTERL, 24, 8) | _SHIFTL(count, 0, 16); cmd->words.w0 = _SHIFTL(A_INTERL, 24, 8) | _SHIFTL(numSamples, 0, 16);
cmd->words.w1 = _SHIFTL(dmemIn, 16, 16) | _SHIFTL(dmemOut, 0, 16); cmd->words.w1 = _SHIFTL(dmemIn, 16, 16) | _SHIFTL(dmemOut, 0, 16);
} }
@ -423,13 +422,13 @@ void AudioSynth_S8Dec(Acmd* cmd, s32 flags, s16* state) {
aS8Dec(cmd, flags, state); aS8Dec(cmd, flags, state);
} }
void AudioSynth_HiLoGain(Acmd* cmd, s32 gain, s32 dmemIn, s32 dmemOut, s32 count) { void AudioSynth_HiLoGain(Acmd* cmd, s32 gain, s32 dmemIn, s32 dmemOut, s32 size) {
cmd->words.w0 = _SHIFTL(A_HILOGAIN, 24, 8) | _SHIFTL(gain, 16, 8) | _SHIFTL(count, 0, 16); cmd->words.w0 = _SHIFTL(A_HILOGAIN, 24, 8) | _SHIFTL(gain, 16, 8) | _SHIFTL(size, 0, 16);
cmd->words.w1 = _SHIFTL(dmemIn, 16, 16) | _SHIFTL(dmemOut, 0, 16); cmd->words.w1 = _SHIFTL(dmemIn, 16, 16) | _SHIFTL(dmemOut, 0, 16);
} }
void AudioSynth_UnkCmd19(Acmd* cmd, s32 arg1, s32 arg2, s32 arg3, s32 arg4) { void AudioSynth_UnkCmd19(Acmd* cmd, s32 arg1, s32 arg2, s32 size, s32 arg4) {
cmd->words.w0 = _SHIFTL(A_UNK19, 24, 8) | _SHIFTL(arg4, 16, 8) | _SHIFTL(arg3, 0, 16); cmd->words.w0 = _SHIFTL(A_UNK19, 24, 8) | _SHIFTL(arg4, 16, 8) | _SHIFTL(size, 0, 16);
cmd->words.w1 = _SHIFTL(arg1, 16, 16) | _SHIFTL(arg2, 0, 16); cmd->words.w1 = _SHIFTL(arg1, 16, 16) | _SHIFTL(arg2, 0, 16);
} }
@ -445,8 +444,8 @@ void func_800DBE28(void) {
void func_800DBE30(void) { void func_800DBE30(void) {
} }
void AudioSynth_UnkCmd3(Acmd* cmd, s32 arg1, s32 arg2, s32 arg3) { void AudioSynth_UnkCmd3(Acmd* cmd, s32 arg1, s32 arg2, s32 size) {
cmd->words.w0 = _SHIFTL(A_UNK3, 24, 8) | _SHIFTL(arg3, 0, 16); cmd->words.w0 = _SHIFTL(A_UNK3, 24, 8) | _SHIFTL(size, 0, 16);
cmd->words.w1 = _SHIFTL(arg1, 16, 16) | _SHIFTL(arg2, 0, 16); cmd->words.w1 = _SHIFTL(arg1, 16, 16) | _SHIFTL(arg2, 0, 16);
} }
@ -459,12 +458,12 @@ void func_800DBE64(void) {
void func_800DBE6C(void) { void func_800DBE6C(void) {
} }
void AudioSynth_LoadFilter(Acmd* cmd, s32 flags, s32 countOrBuf, void* addr) { void AudioSynth_LoadFilterBuffer(Acmd* cmd, s32 flags, s32 buf, void* addr) {
aFilter(cmd, flags, countOrBuf, addr); aFilter(cmd, flags, buf, addr);
} }
void AudioSynth_LoadFilterCount(Acmd* cmd, s32 count, void* addr) { void AudioSynth_LoadFilterSize(Acmd* cmd, s32 size, void* addr) {
aFilter(cmd, 2, count, addr); aFilter(cmd, 2, size, addr);
} }
Acmd* AudioSynth_LoadRingBuffer1(Acmd* cmd, s32 aiBufLen, SynthesisReverb* reverb, s16 updateIndex) { Acmd* AudioSynth_LoadRingBuffer1(Acmd* cmd, s32 aiBufLen, SynthesisReverb* reverb, s16 updateIndex) {
@ -492,20 +491,20 @@ Acmd* AudioSynth_LoadRingBuffer2(Acmd* cmd, s32 aiBufLen, SynthesisReverb* rever
return cmd; return cmd;
} }
Acmd* AudioSynth_LoadRingBufferPart(Acmd* cmd, u16 dmem, u16 startPos, s32 length, SynthesisReverb* reverb) { Acmd* AudioSynth_LoadRingBufferPart(Acmd* cmd, u16 dmem, u16 startPos, s32 size, SynthesisReverb* reverb) {
aLoadBuffer(cmd++, &reverb->leftRingBuf[startPos], dmem, length); aLoadBuffer(cmd++, &reverb->leftRingBuf[startPos], dmem, size);
aLoadBuffer(cmd++, &reverb->rightRingBuf[startPos], dmem + DEFAULT_LEN_1CH, length); aLoadBuffer(cmd++, &reverb->rightRingBuf[startPos], dmem + DMEM_1CH_SIZE, size);
return cmd; return cmd;
} }
Acmd* AudioSynth_SaveRingBufferPart(Acmd* cmd, u16 dmem, u16 startPos, s32 length, SynthesisReverb* reverb) { Acmd* AudioSynth_SaveRingBufferPart(Acmd* cmd, u16 dmem, u16 startPos, s32 size, SynthesisReverb* reverb) {
aSaveBuffer(cmd++, dmem, &reverb->leftRingBuf[startPos], length); aSaveBuffer(cmd++, dmem, &reverb->leftRingBuf[startPos], size);
aSaveBuffer(cmd++, dmem + DEFAULT_LEN_1CH, &reverb->rightRingBuf[startPos], length); aSaveBuffer(cmd++, dmem + DMEM_1CH_SIZE, &reverb->rightRingBuf[startPos], size);
return cmd; return cmd;
} }
Acmd* AudioSynth_SaveBufferOffset(Acmd* cmd, u16 dmem, u16 offset, s32 length, s16* buf) { Acmd* AudioSynth_SaveBufferOffset(Acmd* cmd, u16 dmem, u16 offset, s32 size, s16* buf) {
aSaveBuffer(cmd++, dmem, &buf[offset], length); aSaveBuffer(cmd++, dmem, &buf[offset], size);
return cmd; return cmd;
} }
@ -549,7 +548,7 @@ Acmd* AudioSynth_SaveReverbSamples(Acmd* cmd, SynthesisReverb* reverb, s16 updat
} else { } else {
// Downsampling is done later by CPU when RSP is done, therefore we need to have // Downsampling is done later by CPU when RSP is done, therefore we need to have
// double buffering. Left and right buffers are adjacent in memory. // double buffering. Left and right buffers are adjacent in memory.
AudioSynth_SaveBuffer(cmd++, DMEM_WET_LEFT_CH, DEFAULT_LEN_2CH, AudioSynth_SaveBuffer(cmd++, DMEM_WET_LEFT_CH, DMEM_2CH_SIZE,
reverb->items[reverb->curFrame][updateIndex].toDownsampleLeft); reverb->items[reverb->curFrame][updateIndex].toDownsampleLeft);
} }
@ -606,7 +605,7 @@ Acmd* AudioSynth_DoOneAudioUpdate(s16* aiBuf, s32 aiBufLen, Acmd* cmd, s32 updat
} }
} }
aClearBuffer(cmd++, DMEM_LEFT_CH, DEFAULT_LEN_2CH); aClearBuffer(cmd++, DMEM_LEFT_CH, DMEM_2CH_SIZE);
i = 0; i = 0;
for (reverbIndex = 0; reverbIndex < gAudioContext.numSynthesisReverbs; reverbIndex++) { for (reverbIndex = 0; reverbIndex < gAudioContext.numSynthesisReverbs; reverbIndex++) {
@ -620,15 +619,15 @@ Acmd* AudioSynth_DoOneAudioUpdate(s16* aiBuf, s32 aiBufLen, Acmd* cmd, s32 updat
// Mixes reverb sample into the main dry channel // Mixes reverb sample into the main dry channel
// reverb->volume is always set to 0x7FFF (audio spec), and DMEM_LEFT_CH is cleared before the loop. // reverb->volume is always set to 0x7FFF (audio spec), and DMEM_LEFT_CH is cleared before the loop.
// So for the first iteration, this is essentially a DMEMmove from DMEM_WET_LEFT_CH to DMEM_LEFT_CH // So for the first iteration, this is essentially a DMEMmove from DMEM_WET_LEFT_CH to DMEM_LEFT_CH
aMix(cmd++, DEFAULT_LEN_2CH >> 4, reverb->volume, DMEM_WET_LEFT_CH, DMEM_LEFT_CH); aMix(cmd++, DMEM_2CH_SIZE >> 4, reverb->volume, DMEM_WET_LEFT_CH, DMEM_LEFT_CH);
unk14 = reverb->unk_14; unk14 = reverb->unk_14;
if (unk14) { if (unk14) {
aDMEMMove(cmd++, DMEM_WET_LEFT_CH, DMEM_WET_TEMP, DEFAULT_LEN_2CH); aDMEMMove(cmd++, DMEM_WET_LEFT_CH, DMEM_WET_TEMP, DMEM_2CH_SIZE);
} }
// Decays reverb over time. The (+ 0x8000) here is -100% // Decays reverb over time. The (+ 0x8000) here is -100%
aMix(cmd++, DEFAULT_LEN_2CH >> 4, reverb->decayRatio + 0x8000, DMEM_WET_LEFT_CH, DMEM_WET_LEFT_CH); aMix(cmd++, DMEM_2CH_SIZE >> 4, reverb->decayRatio + 0x8000, DMEM_WET_LEFT_CH, DMEM_WET_LEFT_CH);
// Leak reverb between the left and right channels // Leak reverb between the left and right channels
if (reverb->leakRtl != 0 || reverb->leakLtr != 0) { if (reverb->leakRtl != 0 || reverb->leakLtr != 0) {
@ -642,7 +641,7 @@ Acmd* AudioSynth_DoOneAudioUpdate(s16* aiBuf, s32 aiBufLen, Acmd* cmd, s32 updat
cmd = AudioSynth_MaybeMixRingBuffer1(cmd, reverb, updateIndex); cmd = AudioSynth_MaybeMixRingBuffer1(cmd, reverb, updateIndex);
} }
cmd = AudioSynth_MaybeLoadRingBuffer2(cmd, aiBufLen, reverb, updateIndex); cmd = AudioSynth_MaybeLoadRingBuffer2(cmd, aiBufLen, reverb, updateIndex);
aMix(cmd++, 0x34, reverb->unk_16, DMEM_WET_TEMP, DMEM_WET_LEFT_CH); aMix(cmd++, DMEM_2CH_SIZE >> 4, reverb->unk_16, DMEM_WET_TEMP, DMEM_WET_LEFT_CH);
} }
} }
@ -660,7 +659,7 @@ Acmd* AudioSynth_DoOneAudioUpdate(s16* aiBuf, s32 aiBufLen, Acmd* cmd, s32 updat
if (useReverb) { if (useReverb) {
if (reverb->filterLeft != NULL || reverb->filterRight != NULL) { if (reverb->filterLeft != NULL || reverb->filterRight != NULL) {
cmd = AudioSynth_FilterReverb(cmd, aiBufLen * 2, reverb); cmd = AudioSynth_FilterReverb(cmd, aiBufLen * SAMPLE_SIZE, reverb);
} }
// Saves the wet channel sample from DMEM (DMEM_WET_LEFT_CH) into RDRAM (ringBuffer) for future use // Saves the wet channel sample from DMEM (DMEM_WET_LEFT_CH) into RDRAM (ringBuffer) for future use
@ -682,9 +681,8 @@ Acmd* AudioSynth_DoOneAudioUpdate(s16* aiBuf, s32 aiBufLen, Acmd* cmd, s32 updat
i++; i++;
} }
updateIndex = aiBufLen * 2; aInterleave(cmd++, DMEM_TEMP, DMEM_LEFT_CH, DMEM_RIGHT_CH, 2 * aiBufLen);
aInterleave(cmd++, DMEM_TEMP, DMEM_LEFT_CH, DMEM_RIGHT_CH, updateIndex); aSaveBuffer(cmd++, DMEM_TEMP, aiBuf, 2 * (aiBufLen * (s32)SAMPLE_SIZE));
aSaveBuffer(cmd++, DMEM_TEMP, aiBuf, updateIndex * 2);
return cmd; return cmd;
} }
@ -710,7 +708,7 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
s32 nSamplesToDecode; s32 nSamplesToDecode;
u32 sampleAddr; u32 sampleAddr;
u32 samplesLenFixedPoint; u32 samplesLenFixedPoint;
s32 samplesLenAdjusted; s32 samplesLenAdjusted; // seems to be used as both bytes and numSamples?
s32 nSamplesProcessed; s32 nSamplesProcessed;
s32 loopEndPos; s32 loopEndPos;
s32 nSamplesToProcess; s32 nSamplesToProcess;
@ -780,7 +778,7 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
if (noteSubEu->bitField1.isSyntheticWave) { if (noteSubEu->bitField1.isSyntheticWave) {
cmd = AudioSynth_LoadWaveSamples(cmd, noteSubEu, synthState, numSamplesToLoad); cmd = AudioSynth_LoadWaveSamples(cmd, noteSubEu, synthState, numSamplesToLoad);
sampleDmemBeforeResampling = DMEM_UNCOMPRESSED_NOTE + (synthState->samplePosInt * (s32)sizeof(s16)); sampleDmemBeforeResampling = DMEM_UNCOMPRESSED_NOTE + (synthState->samplePosInt * (s32)SAMPLE_SIZE);
synthState->samplePosInt += numSamplesToLoad; synthState->samplePosInt += numSamplesToLoad;
} else { } else {
sample = noteSubEu->tunedSample->sample; sample = noteSubEu->tunedSample->sample;
@ -804,6 +802,7 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
if (sample->codec == CODEC_ADPCM || sample->codec == CODEC_SMALL_ADPCM) { if (sample->codec == CODEC_ADPCM || sample->codec == CODEC_SMALL_ADPCM) {
if (gAudioContext.curLoadedBook != sample->book->book) { if (gAudioContext.curLoadedBook != sample->book->book) {
u32 nEntries; u32 nEntries;
switch (bookOffset) { switch (bookOffset) {
case 1: case 1:
gAudioContext.curLoadedBook = &D_8012FBA8[1]; gAudioContext.curLoadedBook = &D_8012FBA8[1];
@ -817,7 +816,7 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
if (1) {} if (1) {}
if (1) {} if (1) {}
if (1) {} if (1) {}
nEntries = 16 * sample->book->order * sample->book->numPredictors; nEntries = SAMPLES_PER_FRAME * sample->book->order * sample->book->numPredictors;
aLoadADPCM(cmd++, nEntries, gAudioContext.curLoadedBook); aLoadADPCM(cmd++, nEntries, gAudioContext.curLoadedBook);
} }
} }
@ -832,13 +831,14 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
nSamplesToProcess = samplesLenAdjusted - nSamplesProcessed; nSamplesToProcess = samplesLenAdjusted - nSamplesProcessed;
if (nFirstFrameSamplesToIgnore == 0 && !synthState->restart) { if (nFirstFrameSamplesToIgnore == 0 && !synthState->restart) {
nFirstFrameSamplesToIgnore = 16; nFirstFrameSamplesToIgnore = SAMPLES_PER_FRAME;
} }
nSamplesInFirstFrame = 16 - nFirstFrameSamplesToIgnore; nSamplesInFirstFrame = SAMPLES_PER_FRAME - nFirstFrameSamplesToIgnore;
if (nSamplesToProcess < nSamplesUntilLoopEnd) { if (nSamplesToProcess < nSamplesUntilLoopEnd) {
nFramesToDecode = (s32)(nSamplesToProcess - nSamplesInFirstFrame + 15) / 16; nFramesToDecode =
nSamplesToDecode = nFramesToDecode * 16; (s32)(nSamplesToProcess - nSamplesInFirstFrame + SAMPLES_PER_FRAME - 1) / SAMPLES_PER_FRAME;
nSamplesToDecode = nFramesToDecode * SAMPLES_PER_FRAME;
nTrailingSamplesToIgnore = nSamplesInFirstFrame + nSamplesToDecode - nSamplesToProcess; nTrailingSamplesToIgnore = nSamplesInFirstFrame + nSamplesToDecode - nSamplesToProcess;
} else { } else {
nSamplesToDecode = nSamplesUntilLoopEnd - nSamplesInFirstFrame; nSamplesToDecode = nSamplesUntilLoopEnd - nSamplesInFirstFrame;
@ -847,7 +847,7 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
nSamplesToDecode = 0; nSamplesToDecode = 0;
nSamplesInFirstFrame = nSamplesUntilLoopEnd; nSamplesInFirstFrame = nSamplesUntilLoopEnd;
} }
nFramesToDecode = (nSamplesToDecode + 15) / 16; nFramesToDecode = (nSamplesToDecode + SAMPLES_PER_FRAME - 1) / SAMPLES_PER_FRAME;
if (loopInfo->count != 0) { if (loopInfo->count != 0) {
// Loop around and restart // Loop around and restart
restart = true; restart = true;
@ -858,25 +858,29 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
switch (sample->codec) { switch (sample->codec) {
case CODEC_ADPCM: case CODEC_ADPCM:
// 16 2-byte samples (32 bytes) compressed into 4-bit samples (8 bytes) + 1 header byte
frameSize = 9; frameSize = 9;
skipInitialSamples = 16; skipInitialSamples = SAMPLES_PER_FRAME;
sampleDataStart = 0; sampleDataStart = 0;
break; break;
case CODEC_SMALL_ADPCM: case CODEC_SMALL_ADPCM:
// 16 2-byte samples (32 bytes) compressed into 2-bit samples (4 bytes) + 1 header byte
frameSize = 5; frameSize = 5;
skipInitialSamples = 16; skipInitialSamples = SAMPLES_PER_FRAME;
sampleDataStart = 0; sampleDataStart = 0;
break; break;
case CODEC_S8: case CODEC_S8:
// 16 2-byte samples (32 bytes) compressed into 8-bit samples (16 bytes)
frameSize = 16; frameSize = 16;
skipInitialSamples = 16; skipInitialSamples = SAMPLES_PER_FRAME;
sampleDataStart = 0; sampleDataStart = 0;
break; break;
case CODEC_S16_INMEMORY: case CODEC_S16_INMEMORY:
AudioSynth_ClearBuffer(cmd++, DMEM_UNCOMPRESSED_NOTE, (samplesLenAdjusted * 2) + 0x20); AudioSynth_ClearBuffer(cmd++, DMEM_UNCOMPRESSED_NOTE,
(samplesLenAdjusted + SAMPLES_PER_FRAME) * SAMPLE_SIZE);
flags = A_CONTINUE; flags = A_CONTINUE;
skipBytes = 0; skipBytes = 0;
nSamplesProcessed = samplesLenAdjusted; nSamplesProcessed = samplesLenAdjusted;
@ -884,7 +888,8 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
goto skip; goto skip;
case CODEC_S16: case CODEC_S16:
AudioSynth_ClearBuffer(cmd++, DMEM_UNCOMPRESSED_NOTE, (samplesLenAdjusted * 2) + 0x20); AudioSynth_ClearBuffer(cmd++, DMEM_UNCOMPRESSED_NOTE,
(samplesLenAdjusted + SAMPLES_PER_FRAME) * SAMPLE_SIZE);
flags = A_CONTINUE; flags = A_CONTINUE;
skipBytes = 0; skipBytes = 0;
nSamplesProcessed = samplesLenAdjusted; nSamplesProcessed = samplesLenAdjusted;
@ -896,7 +901,8 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
} }
if (nFramesToDecode != 0) { if (nFramesToDecode != 0) {
frameIndex = (synthState->samplePosInt + skipInitialSamples - nFirstFrameSamplesToIgnore) / 16; frameIndex = (synthState->samplePosInt + skipInitialSamples - nFirstFrameSamplesToIgnore) /
SAMPLES_PER_FRAME;
sampleDataOffset = frameIndex * frameSize; sampleDataOffset = frameIndex * frameSize;
if (sample->medium == MEDIUM_RAM) { if (sample->medium == MEDIUM_RAM) {
sampleData = (u8*)(sampleDataStart + sampleDataOffset + sampleAddr); sampleData = (u8*)(sampleDataStart + sampleDataOffset + sampleAddr);
@ -904,8 +910,8 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
return cmd; return cmd;
} else { } else {
sampleData = AudioLoad_DmaSampleData(sampleDataStart + sampleDataOffset + sampleAddr, sampleData = AudioLoad_DmaSampleData(sampleDataStart + sampleDataOffset + sampleAddr,
ALIGN16((nFramesToDecode * frameSize) + 0x10), flags, ALIGN16((nFramesToDecode * frameSize) + SAMPLES_PER_FRAME),
&synthState->sampleDmaIndex, sample->medium); flags, &synthState->sampleDmaIndex, sample->medium);
} }
if (sampleData == NULL) { if (sampleData == NULL) {
@ -913,7 +919,7 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
} }
sampleDataStartPad = (u32)sampleData & 0xF; sampleDataStartPad = (u32)sampleData & 0xF;
aligned = ALIGN16((nFramesToDecode * frameSize) + 16); aligned = ALIGN16((nFramesToDecode * frameSize) + SAMPLES_PER_FRAME);
addr = DMEM_COMPRESSED_ADPCM_DATA - aligned; addr = DMEM_COMPRESSED_ADPCM_DATA - aligned;
aLoadBuffer(cmd++, sampleData - sampleDataStartPad, addr, aligned); aLoadBuffer(cmd++, sampleData - sampleDataStartPad, addr, aligned);
} else { } else {
@ -930,59 +936,59 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
nSamplesInThisIteration = nSamplesToDecode + nSamplesInFirstFrame - nTrailingSamplesToIgnore; nSamplesInThisIteration = nSamplesToDecode + nSamplesInFirstFrame - nTrailingSamplesToIgnore;
if (nSamplesProcessed == 0) { if (nSamplesProcessed == 0) {
if (1) {} if (1) {}
skipBytes = nFirstFrameSamplesToIgnore * 2; skipBytes = nFirstFrameSamplesToIgnore * SAMPLE_SIZE;
} else { } else {
phi_s4 = ALIGN16(s5 + 16); phi_s4 = ALIGN16(s5 + 8 * SAMPLE_SIZE);
} }
switch (sample->codec) { switch (sample->codec) {
case CODEC_ADPCM: case CODEC_ADPCM:
aligned = ALIGN16((nFramesToDecode * frameSize) + 0x10); aligned = ALIGN16((nFramesToDecode * frameSize) + SAMPLES_PER_FRAME);
addr = DMEM_COMPRESSED_ADPCM_DATA - aligned; addr = DMEM_COMPRESSED_ADPCM_DATA - aligned;
aSetBuffer(cmd++, 0, addr + sampleDataStartPad, DMEM_UNCOMPRESSED_NOTE + phi_s4, aSetBuffer(cmd++, 0, addr + sampleDataStartPad, DMEM_UNCOMPRESSED_NOTE + phi_s4,
nSamplesToDecode * 2); nSamplesToDecode * SAMPLE_SIZE);
aADPCMdec(cmd++, flags, synthState->synthesisBuffers->adpcmdecState); aADPCMdec(cmd++, flags, synthState->synthesisBuffers->adpcmdecState);
break; break;
case CODEC_SMALL_ADPCM: case CODEC_SMALL_ADPCM:
aligned = ALIGN16((nFramesToDecode * frameSize) + 0x10); aligned = ALIGN16((nFramesToDecode * frameSize) + SAMPLES_PER_FRAME);
addr = DMEM_COMPRESSED_ADPCM_DATA - aligned; addr = DMEM_COMPRESSED_ADPCM_DATA - aligned;
aSetBuffer(cmd++, 0, addr + sampleDataStartPad, DMEM_UNCOMPRESSED_NOTE + phi_s4, aSetBuffer(cmd++, 0, addr + sampleDataStartPad, DMEM_UNCOMPRESSED_NOTE + phi_s4,
nSamplesToDecode * 2); nSamplesToDecode * SAMPLE_SIZE);
aADPCMdec(cmd++, flags | 4, synthState->synthesisBuffers->adpcmdecState); aADPCMdec(cmd++, flags | 4, synthState->synthesisBuffers->adpcmdecState);
break; break;
case CODEC_S8: case CODEC_S8:
aligned = ALIGN16((nFramesToDecode * frameSize) + 0x10); aligned = ALIGN16((nFramesToDecode * frameSize) + SAMPLES_PER_FRAME);
addr = DMEM_COMPRESSED_ADPCM_DATA - aligned; addr = DMEM_COMPRESSED_ADPCM_DATA - aligned;
AudioSynth_SetBuffer(cmd++, 0, addr + sampleDataStartPad, DMEM_UNCOMPRESSED_NOTE + phi_s4, AudioSynth_SetBuffer(cmd++, 0, addr + sampleDataStartPad, DMEM_UNCOMPRESSED_NOTE + phi_s4,
nSamplesToDecode * 2); nSamplesToDecode * SAMPLE_SIZE);
AudioSynth_S8Dec(cmd++, flags, synthState->synthesisBuffers->adpcmdecState); AudioSynth_S8Dec(cmd++, flags, synthState->synthesisBuffers->adpcmdecState);
break; break;
} }
if (nSamplesProcessed != 0) { if (nSamplesProcessed != 0) {
aDMEMMove(cmd++, DMEM_UNCOMPRESSED_NOTE + phi_s4 + (nFirstFrameSamplesToIgnore * 2), aDMEMMove(cmd++, DMEM_UNCOMPRESSED_NOTE + phi_s4 + (nFirstFrameSamplesToIgnore * SAMPLE_SIZE),
DMEM_UNCOMPRESSED_NOTE + s5, nSamplesInThisIteration * 2); DMEM_UNCOMPRESSED_NOTE + s5, nSamplesInThisIteration * SAMPLE_SIZE);
} }
nSamplesProcessed += nSamplesInThisIteration; nSamplesProcessed += nSamplesInThisIteration;
switch (flags) { switch (flags) {
case A_INIT: case A_INIT:
skipBytes = 0x20; skipBytes = SAMPLES_PER_FRAME * SAMPLE_SIZE;
s5 = (nSamplesToDecode + 0x10) * 2; s5 = (nSamplesToDecode + SAMPLES_PER_FRAME) * SAMPLE_SIZE;
break; break;
case A_LOOP: case A_LOOP:
s5 = nSamplesInThisIteration * 2 + s5; s5 = nSamplesInThisIteration * SAMPLE_SIZE + s5;
break; break;
default: default:
if (s5 != 0) { if (s5 != 0) {
s5 = nSamplesInThisIteration * 2 + s5; s5 = nSamplesInThisIteration * SAMPLE_SIZE + s5;
} else { } else {
s5 = (nFirstFrameSamplesToIgnore + nSamplesInThisIteration) * 2; s5 = (nFirstFrameSamplesToIgnore + nSamplesInThisIteration) * SAMPLE_SIZE;
} }
break; break;
} }
@ -992,7 +998,7 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
skip: skip:
if (noteFinished) { if (noteFinished) {
AudioSynth_ClearBuffer(cmd++, DMEM_UNCOMPRESSED_NOTE + s5, AudioSynth_ClearBuffer(cmd++, DMEM_UNCOMPRESSED_NOTE + s5,
(samplesLenAdjusted - nSamplesProcessed) * 2); (samplesLenAdjusted - nSamplesProcessed) * SAMPLE_SIZE);
finished = true; finished = true;
note->noteSubEu.bitField0.finished = true; note->noteSubEu.bitField0.finished = true;
func_800DB2C0(updateIndex, noteIndex); func_800DB2C0(updateIndex, noteIndex);
@ -1015,19 +1021,21 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
case 2: case 2:
switch (curPart) { switch (curPart) {
case 0: case 0:
AudioSynth_InterL(cmd++, DMEM_UNCOMPRESSED_NOTE + skipBytes, DMEM_TEMP + 0x20, AudioSynth_InterL(cmd++, DMEM_UNCOMPRESSED_NOTE + skipBytes,
DMEM_TEMP + (SAMPLES_PER_FRAME * SAMPLE_SIZE),
ALIGN8(samplesLenAdjusted / 2)); ALIGN8(samplesLenAdjusted / 2));
resampledTempLen = samplesLenAdjusted; resampledTempLen = samplesLenAdjusted;
sampleDmemBeforeResampling = DMEM_TEMP + 0x20; sampleDmemBeforeResampling = DMEM_TEMP + (SAMPLES_PER_FRAME * SAMPLE_SIZE);
if (finished) { if (finished) {
AudioSynth_ClearBuffer(cmd++, sampleDmemBeforeResampling + resampledTempLen, AudioSynth_ClearBuffer(cmd++, sampleDmemBeforeResampling + resampledTempLen,
samplesLenAdjusted + 0x10); samplesLenAdjusted + SAMPLES_PER_FRAME);
} }
break; break;
case 1: case 1:
AudioSynth_InterL(cmd++, DMEM_UNCOMPRESSED_NOTE + skipBytes, AudioSynth_InterL(cmd++, DMEM_UNCOMPRESSED_NOTE + skipBytes,
DMEM_TEMP + 0x20 + resampledTempLen, ALIGN8(samplesLenAdjusted / 2)); DMEM_TEMP + (SAMPLES_PER_FRAME * SAMPLE_SIZE) + resampledTempLen,
ALIGN8(samplesLenAdjusted / 2));
break; break;
} }
} }
@ -1043,14 +1051,14 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
flags = A_INIT; flags = A_INIT;
} }
cmd = AudioSynth_FinalResample(cmd, synthState, aiBufLen * 2, resamplingRateFixedPoint, sampleDmemBeforeResampling, cmd = AudioSynth_FinalResample(cmd, synthState, aiBufLen * (s32)SAMPLE_SIZE, resamplingRateFixedPoint,
flags); sampleDmemBeforeResampling, flags);
if (bookOffset == 3) { if (bookOffset == 3) {
AudioSynth_UnkCmd19(cmd++, DMEM_TEMP, DMEM_TEMP, aiBufLen * 2, 0); AudioSynth_UnkCmd19(cmd++, DMEM_TEMP, DMEM_TEMP, aiBufLen * SAMPLE_SIZE, 0);
} }
if (bookOffset == 2) { if (bookOffset == 2) {
AudioSynth_UnkCmd3(cmd++, DMEM_TEMP, DMEM_TEMP, aiBufLen * 2); AudioSynth_UnkCmd3(cmd++, DMEM_TEMP, DMEM_TEMP, aiBufLen * SAMPLE_SIZE);
} }
gain = noteSubEu->gain; gain = noteSubEu->gain;
@ -1059,20 +1067,20 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
if (gain < 0x10) { if (gain < 0x10) {
gain = 0x10; gain = 0x10;
} }
AudioSynth_HiLoGain(cmd++, gain, DMEM_TEMP, 0, (aiBufLen * 2) + 0x20); AudioSynth_HiLoGain(cmd++, gain, DMEM_TEMP, 0, (aiBufLen + SAMPLES_PER_FRAME) * SAMPLE_SIZE);
} }
filter = noteSubEu->filter; filter = noteSubEu->filter;
if (filter != 0) { if (filter != 0) {
AudioSynth_LoadFilterCount(cmd++, aiBufLen * 2, filter); AudioSynth_LoadFilterSize(cmd++, aiBufLen * SAMPLE_SIZE, filter);
AudioSynth_LoadFilter(cmd++, flags, DMEM_TEMP, synthState->synthesisBuffers->mixEnvelopeState); AudioSynth_LoadFilterBuffer(cmd++, flags, DMEM_TEMP, synthState->synthesisBuffers->mixEnvelopeState);
} }
unk7 = noteSubEu->unk_07; unk7 = noteSubEu->unk_07;
unkE = noteSubEu->unk_0E; unkE = noteSubEu->unk_0E;
buf = &synthState->synthesisBuffers->panSamplesBuffer[0x18]; buf = &synthState->synthesisBuffers->panSamplesBuffer[0x18];
if (unk7 != 0 && noteSubEu->unk_0E != 0) { if (unk7 != 0 && noteSubEu->unk_0E != 0) {
AudioSynth_DMemMove(cmd++, DMEM_TEMP, DMEM_SCRATCH2, aiBufLen * 2); AudioSynth_DMemMove(cmd++, DMEM_TEMP, DMEM_SCRATCH2, aiBufLen * SAMPLE_SIZE);
thing = DMEM_SCRATCH2 - unk7; thing = DMEM_SCRATCH2 - unk7;
if (synthState->unk_1A != 0) { if (synthState->unk_1A != 0) {
AudioSynth_ClearBuffer(cmd++, thing, unk7); AudioSynth_ClearBuffer(cmd++, thing, unk7);
@ -1080,9 +1088,9 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
} else { } else {
AudioSynth_LoadBuffer(cmd++, thing, unk7, buf); AudioSynth_LoadBuffer(cmd++, thing, unk7, buf);
} }
AudioSynth_SaveBuffer(cmd++, DMEM_TEMP + (aiBufLen * 2) - unk7, unk7, buf); AudioSynth_SaveBuffer(cmd++, DMEM_TEMP + (aiBufLen * SAMPLE_SIZE) - unk7, unk7, buf);
AudioSynth_Mix(cmd++, (aiBufLen * 2) >> 4, unkE, DMEM_SCRATCH2, thing); AudioSynth_Mix(cmd++, (aiBufLen * (s32)SAMPLE_SIZE) >> 4, unkE, DMEM_SCRATCH2, thing);
AudioSynth_DMemMove(cmd++, thing, DMEM_TEMP, aiBufLen * 2); AudioSynth_DMemMove(cmd++, thing, DMEM_TEMP, aiBufLen * SAMPLE_SIZE);
} else { } else {
synthState->unk_1A = 1; synthState->unk_1A = 1;
} }
@ -1099,17 +1107,18 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
if (!(flags & A_INIT)) { if (!(flags & A_INIT)) {
flags = A_CONTINUE; flags = A_CONTINUE;
} }
cmd = AudioSynth_NoteApplyHeadsetPanEffects(cmd, noteSubEu, synthState, aiBufLen * 2, flags, side); cmd =
AudioSynth_NoteApplyHeadsetPanEffects(cmd, noteSubEu, synthState, aiBufLen * (s32)SAMPLE_SIZE, flags, side);
} }
return cmd; return cmd;
} }
Acmd* AudioSynth_FinalResample(Acmd* cmd, NoteSynthesisState* synthState, s32 count, u16 pitch, u16 inpDmem, Acmd* AudioSynth_FinalResample(Acmd* cmd, NoteSynthesisState* synthState, s32 size, u16 pitch, u16 inpDmem,
s32 resampleFlags) { s32 resampleFlags) {
if (pitch == 0) { if (pitch == 0) {
AudioSynth_ClearBuffer(cmd++, DMEM_TEMP, count); AudioSynth_ClearBuffer(cmd++, DMEM_TEMP, size);
} else { } else {
aSetBuffer(cmd++, 0, inpDmem, DMEM_TEMP, count); aSetBuffer(cmd++, 0, inpDmem, DMEM_TEMP, size);
aResample(cmd++, resampleFlags, pitch, synthState->synthesisBuffers->finalResampleState); aResample(cmd++, resampleFlags, pitch, synthState->synthesisBuffers->finalResampleState);
} }
return cmd; return cmd;
@ -1163,7 +1172,7 @@ Acmd* AudioSynth_ProcessEnvelope(Acmd* cmd, NoteSubEu* noteSubEu, NoteSynthesisS
synthState->curVolRight = curVolRight + (rampRight * (aiBufLen >> 3)); synthState->curVolRight = curVolRight + (rampRight * (aiBufLen >> 3));
if (noteSubEu->bitField1.usesHeadsetPanEffects2) { if (noteSubEu->bitField1.usesHeadsetPanEffects2) {
AudioSynth_ClearBuffer(cmd++, DMEM_NOTE_PAN_TEMP, DEFAULT_LEN_1CH); AudioSynth_ClearBuffer(cmd++, DMEM_NOTE_PAN_TEMP, DMEM_1CH_SIZE);
AudioSynth_EnvSetup1(cmd++, phi_t1 * 2, rampReverb, rampLeft, rampRight); AudioSynth_EnvSetup1(cmd++, phi_t1 * 2, rampReverb, rampLeft, rampRight);
AudioSynth_EnvSetup2(cmd++, curVolLeft, curVolRight); AudioSynth_EnvSetup2(cmd++, curVolLeft, curVolRight);
switch (headsetPanSettings) { switch (headsetPanSettings) {
@ -1198,13 +1207,13 @@ Acmd* AudioSynth_LoadWaveSamples(Acmd* cmd, NoteSubEu* noteSubEu, NoteSynthesisS
if (noteSubEu->bitField1.bookOffset != 0) { if (noteSubEu->bitField1.bookOffset != 0) {
// Move the noise wave (that reads compiled assembly as samples) from ram to dmem // Move the noise wave (that reads compiled assembly as samples) from ram to dmem
AudioSynth_LoadBuffer(cmd++, DMEM_UNCOMPRESSED_NOTE, ALIGN16(numSamplesToLoad * sizeof(s16)), gWaveSamples[8]); AudioSynth_LoadBuffer(cmd++, DMEM_UNCOMPRESSED_NOTE, ALIGN16(numSamplesToLoad * SAMPLE_SIZE), gWaveSamples[8]);
// Offset the address for the samples read by gWaveSamples[8] to the next set of samples // Offset the address for the samples read by gWaveSamples[8] to the next set of samples
gWaveSamples[8] += numSamplesToLoad * sizeof(s16); gWaveSamples[8] += numSamplesToLoad * SAMPLE_SIZE;
return cmd; return cmd;
} else { } else {
// Move the synthetic wave from ram to dmem // Move the synthetic wave from ram to dmem
aLoadBuffer(cmd++, noteSubEu->waveSampleAddr, DMEM_UNCOMPRESSED_NOTE, WAVE_SAMPLE_COUNT * sizeof(s16)); aLoadBuffer(cmd++, noteSubEu->waveSampleAddr, DMEM_UNCOMPRESSED_NOTE, WAVE_SAMPLE_COUNT * SAMPLE_SIZE);
// If the harmonic changes, map the offset in the wave from one harmonic to another for continuity // If the harmonic changes, map the offset in the wave from one harmonic to another for continuity
if (harmonicIndexCurAndPrev != 0) { if (harmonicIndexCurAndPrev != 0) {
@ -1222,10 +1231,10 @@ Acmd* AudioSynth_LoadWaveSamples(Acmd* cmd, NoteSubEu* noteSubEu, NoteSynthesisS
// Duplicate (copy) the WAVE_SAMPLE_COUNT samples as many times as needed to reach numSamplesToLoad. // Duplicate (copy) the WAVE_SAMPLE_COUNT samples as many times as needed to reach numSamplesToLoad.
// (numSamplesToLoad - numSamplesAvail) is the number of samples missing. // (numSamplesToLoad - numSamplesAvail) is the number of samples missing.
// Divide by WAVE_SAMPLE_COUNT, rounding up, to get the amount of duplicates // Divide by WAVE_SAMPLE_COUNT, rounding up, to get the amount of duplicates
numDuplicates = ((numSamplesToLoad - numSamplesAvail + (WAVE_SAMPLE_COUNT - 1)) / WAVE_SAMPLE_COUNT); numDuplicates = ((numSamplesToLoad - numSamplesAvail + WAVE_SAMPLE_COUNT - 1) / WAVE_SAMPLE_COUNT);
if (numDuplicates != 0) { if (numDuplicates != 0) {
aDuplicate(cmd++, numDuplicates, DMEM_UNCOMPRESSED_NOTE, aDuplicate(cmd++, numDuplicates, DMEM_UNCOMPRESSED_NOTE,
DMEM_UNCOMPRESSED_NOTE + (WAVE_SAMPLE_COUNT * sizeof(s16))); DMEM_UNCOMPRESSED_NOTE + (WAVE_SAMPLE_COUNT * SAMPLE_SIZE));
} }
} }
synthState->samplePosInt = samplePosInt; synthState->samplePosInt = samplePosInt;