Refresh 13 2

2026-01-21 10:38:08 -08:00 · 2020-12-03 20:57:48 -05:00
parent 6d87c424b8
commit a53de1e70c
7 changed files with 105 additions and 1324 deletions
--- a/src/audio/load.c
+++ b/src/audio/load.c
@@ -53,7 +53,7 @@ struct PendingDmaAudioBank {
    struct AudioBank *audioBank;
    uintptr_t devAddr;
    void *vAddr;
-    s32 remaining;
+    u32 remaining;
    u32 transferSize;
    u32 encodedInfo;
    OSMesgQueue *retQueue;
@@ -155,7 +155,7 @@ void func_sh_802f4bd8(struct PendingDmaSample *arg0, s32 len);
 void func_sh_802f4c5c(uintptr_t devAddr, void *vAddr, size_t nbytes, s32 arg3);
 struct PendingDmaAudioBank *func_sh_802f4cb4(uintptr_t devAddr, void *vAddr, s32 size, s32 medium, s32 numChunks, OSMesgQueue *retQueue, s32 encodedInfo);
 void func_sh_802f4dcc(s32 audioResetStatus);
-void func_sh_802f4e50(struct PendingDmaAudioBank *arg0, u32 arg1);
+void func_sh_802f4e50(struct PendingDmaAudioBank *audioBank, s32 audioResetStatus);
 void func_sh_802f50ec(struct PendingDmaAudioBank *arg0, size_t len);
 void func_sh_802f517c(uintptr_t devAddr, void *vAddr, size_t nbytes, s32 arg3);
 s32 func_sh_802f5310(s32 bankId, struct AudioBank *mem, struct PatchStruct *patchInfo, s32 arg3);
@@ -2168,99 +2168,95 @@ void func_sh_802f4dcc(s32 audioResetStatus) {
    }
 }

-#ifndef NON_MATCHING
-GLOBAL_ASM("asm/non_matchings/sh/audio/load/func_sh_802f4e50.s")
-#else
-void func_sh_802f4e50(struct PendingDmaAudioBank *arg0, u32 arg1) {
-    ALSeqFile *sp5C;
-    s32 temp_a0;
-    s32 sp44;
-    s32 id;
-    struct PatchStruct sp2C;
-    u8 t0;
-    u32 sp24;
-
-    sp5C = gAlTbl;
-    if (arg0->timer >= 2) {
-        arg0->timer = arg0->timer - 1;
+void func_sh_802f4e50(struct PendingDmaAudioBank *audioBank, s32 audioResetStatus) {
+    ALSeqFile *alSeqFile;
+    u32 *encodedInfo;
+    OSMesg mesg;
+    u32 temp;
+    u32 seqId;
+    s32 bankId1;
+    s32 bankId2;
+    struct PatchStruct patchStruct;
+    alSeqFile = gAlTbl;
+    if (audioBank->timer >= 2) {
+        audioBank->timer--;
        return;
    }
-    if (arg0->timer == 1) {
-        arg0->timer = 0;
+    if (audioBank->timer == 1) {
+        audioBank->timer = 0;
    } else {
-        if (arg1 != 0) {
-            osRecvMesg(&arg0->dmaRetQueue, NULL, OS_MESG_BLOCK);
-            arg0->inProgress = 0;
+        if (audioResetStatus != 0) {
+            osRecvMesg(&audioBank->dmaRetQueue, NULL, OS_MESG_BLOCK);
+            audioBank->inProgress = 0;
            return;
        }
-        if (osRecvMesg(&arg0->dmaRetQueue, NULL, OS_MESG_NOBLOCK) == -1) {
+        if (osRecvMesg(&audioBank->dmaRetQueue, NULL, OS_MESG_NOBLOCK) == -1) {
            return;
        }
    }
-    sp24 = arg0->remaining;
-    if (sp24 == 0) {
-        arg1 = arg0->encodedInfo;
-        sp24 = (arg1 >> 8) & 0xff;
-        t0 = (arg0->encodedInfo) >> 0x10;
-        switch (t0) {
+
+    encodedInfo = &audioBank->encodedInfo;
+    if (audioBank->remaining == 0) {
+        mesg = (OSMesg) audioBank->encodedInfo;
+        mesg = mesg;    //! needs an extra read from mesg here to match...
+        temp = *encodedInfo;
+        seqId = (temp >> 8) & 0xFF;
+        switch ((u8) (temp >> 0x10)) {
            case 0:
-                if (gSeqLoadStatus[sp24] != 5) {
-                    gSeqLoadStatus[sp24] = (arg0->encodedInfo) & 0xff;
+                if (gSeqLoadStatus[seqId] != 5) {
+                    gSeqLoadStatus[seqId] = (u8) (temp & 0xFF);
                }
                break;
            case 2:
-                if (gUnkLoadStatus[sp24] != 5) {
-                    gUnkLoadStatus[sp24] = (arg0->encodedInfo) & 0xff;
+                if (gUnkLoadStatus[seqId] != 5) {
+                    gUnkLoadStatus[seqId] = (u8) (temp & 0xFF);
                }
                break;
            case 1:
-                if (gBankLoadStatus[sp24] != 5) {
-                    gBankLoadStatus[sp24] = (arg0->encodedInfo) & 0xff;
+                if (gBankLoadStatus[seqId] != 5) {
+                    gBankLoadStatus[seqId] = (u8) (temp & 0xFF);
                }
-                temp_a0 = gCtlEntries[sp24].bankId1;
-                sp44 = gCtlEntries[sp24].bankId2;
-                sp2C.bankId1 = temp_a0;
-                sp2C.bankId2 = sp44;
-                if (temp_a0 != 0xFF) {
-                    sp2C.baseAddr1 = func_sh_802f3598(temp_a0, &sp2C.medium1);
+                bankId1 = gCtlEntries[seqId].bankId1;
+                bankId2 = gCtlEntries[seqId].bankId2;
+                patchStruct.bankId1 = bankId1;
+                patchStruct.bankId2 = bankId2;
+                if (bankId1 != 0xFF) {
+                    patchStruct.baseAddr1 = func_sh_802f3598(bankId1, &patchStruct.medium1);
                } else {
-                    sp2C.baseAddr1 = NULL;
+                    patchStruct.baseAddr1 = NULL;
                }
-                if (sp44 != 0xFF) {
-                    sp2C.baseAddr2 = func_sh_802f3598(sp44, &sp2C.medium2);
+                if (bankId2 != 0xFF) {
+                    patchStruct.baseAddr2 = func_sh_802f3598(bankId2, &patchStruct.medium2);
                } else {
-                    sp2C.baseAddr2 = NULL;
+                    patchStruct.baseAddr2 = NULL;
                }
-                func_sh_802f5310(sp24, arg0->audioBank, &sp2C, 1);
+
+                func_sh_802f5310(seqId, audioBank->audioBank, &patchStruct, 1);
                break;
-
        }
-        arg1 = arg0->encodedInfo;
-        arg0->inProgress = 0;
-        osSendMesg(arg0->retQueue, (OSMesg) arg1, 0);
-    } else {
-        sp24 = arg0->remaining;
-        if (sp24 < arg0->transferSize) {
-            if (1 == arg0->medium) {
-                func_sh_802f517c(arg0->devAddr, arg0->vAddr, sp24, sp5C->unk2);
-            } else {
-                func_sh_802f50ec(arg0, sp24);
-            }
-            arg0->remaining = 0;
+        mesg = (OSMesg) audioBank->encodedInfo;
+        audioBank->inProgress = 0;
+        osSendMesg(audioBank->retQueue, mesg, OS_MESG_NOBLOCK);
+    } else if (audioBank->remaining < audioBank->transferSize) {
+        if (audioBank->medium == 1) {
+            func_sh_802f517c(audioBank->devAddr, audioBank->vAddr, audioBank->remaining, alSeqFile->unk2);
        } else {
-            if (1 == arg0->medium) {
-                func_sh_802f517c(arg0->devAddr, arg0->vAddr, arg0->transferSize, sp5C->unk2);
-            } else {
-                func_sh_802f50ec(arg0, arg0->transferSize);
-            }
-
-            arg0->remaining = arg0->remaining - arg0->transferSize;
-            arg0->devAddr = arg0->devAddr + arg0->transferSize;
-            arg0->vAddr = ((u8 *) arg0->vAddr) + arg0->transferSize;
+            func_sh_802f50ec(audioBank, audioBank->remaining);
        }
+
+        audioBank->remaining = 0;
+    } else {
+        if (audioBank->medium == 1) {
+            func_sh_802f517c(audioBank->devAddr, audioBank->vAddr, audioBank->transferSize, alSeqFile->unk2);
+        } else {
+            func_sh_802f50ec(audioBank, audioBank->transferSize);
+        }
+
+        audioBank->remaining -= audioBank->transferSize;
+        audioBank->devAddr   += audioBank->transferSize;
+        audioBank->vAddr = ((u8 *) audioBank->vAddr) + audioBank->transferSize;
    }
 }
-#endif

 extern char shindouDebugPrint110[];
 void func_sh_802f50ec(struct PendingDmaAudioBank *arg0, size_t len) {
--- a/src/audio/seqplayer.c
+++ b/src/audio/seqplayer.c
@@ -2228,18 +2228,17 @@ void sequence_channel_process_script(struct SequenceChannel *seqChannel) {
    }
 }

-#if defined(VERSION_SH) && !defined(NON_MATCHING) // regalloc
-void sequence_player_process_sequence(struct SequencePlayer *seqPlayer);
-GLOBAL_ASM("asm/non_matchings/sh/audio/seqplayer/sequence_player_process_sequence.s")
-#else
 void sequence_player_process_sequence(struct SequencePlayer *seqPlayer) {
    u8 cmd;
+#ifdef VERSION_SH
+    UNUSED u32 pad;
+#endif
    u8 loBits;
    u8 temp;
    s32 value;
    s32 i;
    u16 u16v;
-    u8 *tempPtr;
+    u8 *seqData;
    struct M64ScriptState *state;
 #if defined(VERSION_EU) || defined(VERSION_SH)
    s32 temp32;
@@ -2518,19 +2517,19 @@ void sequence_player_process_sequence(struct SequencePlayer *seqPlayer) {

 #if defined(VERSION_EU) || defined(VERSION_SH)
                    case 0xda:
-                        temp = m64_read_u8(state);
+                        cmd = m64_read_u8(state);
                        u16v = m64_read_s16(state);
-                        switch (temp) {
+                        switch (cmd) {
                            case SEQUENCE_PLAYER_STATE_0:
                            case SEQUENCE_PLAYER_STATE_FADE_OUT:
                                if (seqPlayer->state != SEQUENCE_PLAYER_STATE_2) {
                                    seqPlayer->fadeTimerUnkEu = u16v;
-                                    seqPlayer->state = temp;
+                                    seqPlayer->state = cmd;
                                }
                                break;
                            case SEQUENCE_PLAYER_STATE_2:
                                seqPlayer->fadeRemainingFrames = u16v;
-                                seqPlayer->state = temp;
+                                seqPlayer->state = cmd;
                                seqPlayer->fadeVelocity =
                                    (0.0f - seqPlayer->fadeVolume) / (s32)(u16v & 0xFFFFu);
                                break;
@@ -2557,22 +2556,22 @@ void sequence_player_process_sequence(struct SequencePlayer *seqPlayer) {
                        break;
 #else
                    case 0xdb: // seq_setvol
-                        temp = m64_read_u8(state);
+                        cmd = m64_read_u8(state);
                        switch (seqPlayer->state) {
                            case SEQUENCE_PLAYER_STATE_2:
                                if (seqPlayer->fadeRemainingFrames != 0) {
-                                    f32 targetVolume = FLOAT_CAST(temp) / US_FLOAT(127.0);
+                                    f32 targetVolume = FLOAT_CAST(cmd) / US_FLOAT(127.0);
                                    seqPlayer->fadeVelocity = (targetVolume - seqPlayer->fadeVolume)
                                                              / FLOAT_CAST(seqPlayer->fadeRemainingFrames);
                                    break;
                                }
                                // fallthrough
                            case SEQUENCE_PLAYER_STATE_0:
-                                seqPlayer->fadeVolume = FLOAT_CAST(temp) / US_FLOAT(127.0);
+                                seqPlayer->fadeVolume = FLOAT_CAST(cmd) / US_FLOAT(127.0);
                                break;
                            case SEQUENCE_PLAYER_STATE_FADE_OUT:
                            case SEQUENCE_PLAYER_STATE_4:
-                                seqPlayer->volume = FLOAT_CAST(temp) / US_FLOAT(127.0);
+                                seqPlayer->volume = FLOAT_CAST(cmd) / US_FLOAT(127.0);
                                break;
                        }
                        break;
@@ -2617,11 +2616,11 @@ void sequence_player_process_sequence(struct SequencePlayer *seqPlayer) {
                    case 0xd2: // seq_setshortnotevelocitytable
                    case 0xd1: // seq_setshortnotedurationtable
                        u16v = m64_read_s16(state);
-                        tempPtr = seqPlayer->seqData + u16v;
+                        seqData = seqPlayer->seqData + u16v;
                        if (cmd == 0xd2) {
-                            seqPlayer->shortNoteVelocityTable = tempPtr;
+                            seqPlayer->shortNoteVelocityTable = seqData;
                        } else {
-                            seqPlayer->shortNoteDurationTable = tempPtr;
+                            seqPlayer->shortNoteDurationTable = seqData;
                        }
                        break;

@@ -2647,14 +2646,15 @@ void sequence_player_process_sequence(struct SequencePlayer *seqPlayer) {

 #ifdef VERSION_SH
                    case 0xc7:
-                        temp = m64_read_u8(state);
+                        cmd = m64_read_u8(state);
                        u16v = m64_read_s16(state);
-                        seqPlayer->seqData[u16v] = (u8) value + temp;
+                        seqData = seqPlayer->seqData + u16v;
+                        *seqData = (u8)value + cmd;
                        break;

                    case 0xc6:
                        seqPlayer->unkSh = TRUE;
-                        break;
+                        return;
 #endif

                    default:
@@ -2735,7 +2735,6 @@ void sequence_player_process_sequence(struct SequencePlayer *seqPlayer) {
 #endif
    }
 }
-#endif

 // This runs 240 times per second.
 void process_sequences(UNUSED s32 iterationsRemaining) {
--- a/src/audio/synthesis.c
+++ b/src/audio/synthesis.c
@@ -5,6 +5,7 @@
 #include "data.h"
 #include "load.h"
 #include "seqplayer.h"
+#include "internal.h"
 #include "external.h"


@@ -1858,8 +1859,7 @@ u64 *process_envelope(u64 *cmd, struct NoteSubEu *note, struct NoteSynthesisStat
 }

 #elif defined(VERSION_SH)
-#ifdef NON_MATCHING // regalloc
-u64 *process_envelope(u64 *cmd, struct NoteSubEu *note, struct NoteSynthesisState *synthesisState, s32 nSamples, u16 inBuf, s32 headsetPanSettings, u32 flags) {
+u64 *process_envelope(u64 *cmd, struct NoteSubEu *note, struct NoteSynthesisState *synthesisState, s32 nSamples, u16 inBuf, s32 headsetPanSettings, UNUSED u32 flags) {
    u16 sourceRight;
    u16 sourceLeft;
    u16 targetLeft;
@@ -1868,10 +1868,7 @@ u64 *process_envelope(u64 *cmd, struct NoteSubEu *note, struct NoteSynthesisStat
    s16 rampRight;
    s32 sourceReverbVol;
    s16 reverbVol;
-    s32 bit;
-    s32 sourceVol;
-    s32 targetVol;
-    UNUSED s32 pad[2];
+    s32 temp = 0;

    sourceLeft = synthesisState->curVolLeft;
    sourceRight = synthesisState->curVolRight;
@@ -1879,6 +1876,7 @@ u64 *process_envelope(u64 *cmd, struct NoteSubEu *note, struct NoteSynthesisStat
    targetRight = note->targetVolRight;
    targetLeft <<= 4;
    targetRight <<= 4;
+
    if (targetLeft != sourceLeft) {
        rampLeft = (targetLeft - sourceLeft) / (nSamples >> 3);
    } else {
@@ -1889,12 +1887,11 @@ u64 *process_envelope(u64 *cmd, struct NoteSubEu *note, struct NoteSynthesisStat
    } else {
        rampRight = 0;
    }
+
    sourceReverbVol = synthesisState->reverbVol;
-    targetVol = note->reverbVol & 0x7f;
-    sourceVol = sourceReverbVol & 0x7f;
-    bit = (sourceReverbVol & 0x80) >> 7;
    if (note->reverbVol != sourceReverbVol) {
-        reverbVol = ((targetVol - sourceVol) << 9) / (nSamples >> 3);
+        temp = ((note->reverbVol & 0x7f) - (sourceReverbVol & 0x7f)) << 9;
+        reverbVol = temp / (nSamples >> 3);
        synthesisState->reverbVol = note->reverbVol;
    } else {
        reverbVol = 0;
@@ -1904,14 +1901,14 @@ u64 *process_envelope(u64 *cmd, struct NoteSubEu *note, struct NoteSynthesisStat

    if (note->usesHeadsetPanEffects) {
        aClearBuffer(cmd++, DMEM_ADDR_NOTE_PAN_TEMP, DEFAULT_LEN_1CH);
-        aEnvSetup1(cmd++, (sourceVol * 2), reverbVol, rampLeft, rampRight);
+        aEnvSetup1(cmd++, (sourceReverbVol & 0x7f) * 2, reverbVol, rampLeft, rampRight);
        aEnvSetup2(cmd++, sourceLeft, sourceRight);

        switch (headsetPanSettings) {
            case 1:
                aEnvMixer(cmd++,
                    inBuf, nSamples,
-                    bit,
+                    (sourceReverbVol & 0x80) >> 7,
                    note->stereoStrongRight, note->stereoStrongLeft,
                    DMEM_ADDR_NOTE_PAN_TEMP,
                    DMEM_ADDR_RIGHT_CH,
@@ -1921,7 +1918,7 @@ u64 *process_envelope(u64 *cmd, struct NoteSubEu *note, struct NoteSynthesisStat
            case 2:
                aEnvMixer(cmd++,
                    inBuf, nSamples,
-                    bit,
+                    (sourceReverbVol & 0x80) >> 7,
                    note->stereoStrongRight, note->stereoStrongLeft,
                    DMEM_ADDR_LEFT_CH,
                    DMEM_ADDR_NOTE_PAN_TEMP,
@@ -1931,7 +1928,7 @@ u64 *process_envelope(u64 *cmd, struct NoteSubEu *note, struct NoteSynthesisStat
            default:
                aEnvMixer(cmd++,
                    inBuf, nSamples,
-                    bit,
+                    (sourceReverbVol & 0x80) >> 7,
                    note->stereoStrongRight, note->stereoStrongLeft,
                    DMEM_ADDR_LEFT_CH,
                    DMEM_ADDR_RIGHT_CH,
@@ -1940,11 +1937,11 @@ u64 *process_envelope(u64 *cmd, struct NoteSubEu *note, struct NoteSynthesisStat
                break;
        }
    } else {
-        aEnvSetup1(cmd++, (sourceVol * 2), reverbVol, rampLeft, rampRight);
+        aEnvSetup1(cmd++, (sourceReverbVol & 0x7f) * 2, reverbVol, rampLeft, rampRight);
        aEnvSetup2(cmd++, sourceLeft, sourceRight);
        aEnvMixer(cmd++,
                inBuf, nSamples,
-                bit,
+                (sourceReverbVol & 0x80) >> 7,
                note->stereoStrongRight, note->stereoStrongLeft,
                DMEM_ADDR_LEFT_CH,
                DMEM_ADDR_RIGHT_CH,
@@ -1953,9 +1950,6 @@ u64 *process_envelope(u64 *cmd, struct NoteSubEu *note, struct NoteSynthesisStat
    }
    return cmd;
 }
-#else
-GLOBAL_ASM("asm/non_matchings/sh/audio/synthesis/process_envelope.s")
-#endif
 #endif

 #if defined(VERSION_EU) || defined(VERSION_SH)