Merge branch 'main' into Caladius-patch-1Caladius-patch-1

8 files changed, 76 insertions, 146 deletions

diff --git a/src/audio/data.c b/src/audio/data.c
index 03e470fcf..e9c87e413 100644
--- a/src/audio/data.c
+++ b/src/audio/data.c
@@ -224,9 +224,9 @@ u8 gDefaultShortNoteDurationTable[16] = {
 };
 
 struct AdsrEnvelope gDefaultEnvelope[] = {
-    { BSWAP16(4), BSWAP16(32000) },    // go from 0 to 32000 over the course of 16ms
-    { BSWAP16(1000), BSWAP16(32000) }, // stay there for 4.16 seconds
-    { BSWAP16(ADSR_HANG), 0 }          // then continue staying there
+    { BOMSWAP16_CONST(4), BOMSWAP16_CONST(32000) },    // go from 0 to 32000 over the course of 16ms
+    { BOMSWAP16_CONST(1000), BOMSWAP16_CONST(32000) }, // stay there for 4.16 seconds
+    { BOMSWAP16_CONST(ADSR_HANG), 0 }                  // then continue staying there
 };
 
 //! @todo 0x00000000800f624c                fill2
diff --git a/src/audio/effects.h b/src/audio/effects.h
index 8c7712825..a10673207 100644
--- a/src/audio/effects.h
+++ b/src/audio/effects.h
@@ -26,13 +26,7 @@
 #define ADSR_GOTO -2
 #define ADSR_RESTART -3
 
-// Envelopes are always stored as big endian, to match sequence files which are
-// byte blobs and can embed envelopes. Hence this byteswapping macro.
-#if IS_BIG_ENDIAN
-#define BSWAP16(x) (x)
-#else
-#define BSWAP16(x) (((x) & 0xff) << 8 | (((x) >> 8) & 0xff))
-#endif
+#include <macros.h>
 
 void sequence_channel_process_sound(struct SequenceChannel* seqChannel, s32 recalculateVolume);
 void sequence_player_process_sound(struct SequencePlayer* seqPlayer);
diff --git a/src/audio/external.c b/src/audio/external.c
index 564079a55..90ce0cb63 100644
--- a/src/audio/external.c
+++ b/src/audio/external.c
@@ -392,8 +392,8 @@ void func_800C19D0(u8 arg0, u8 arg1, u8 arg2) {
 
 struct Unk_8018EFD8* func_800C1C88(u8 arg0, Vec3f position, f32* velocity, f32* arg3, u8 arg4, u32 soundBits) {
     struct Unk_8018EFD8* temp_a1;
-    struct Unk_8018EFD8* temp_v1;
-    u8 temp_t7;
+    UNUSED struct Unk_8018EFD8* temp_v1;
+    UNUSED u8 temp_t7;
     u8 why1;
 
     if (D_8018EFD8[D_8018FB90].next != 0xFF) {
@@ -949,7 +949,7 @@ void func_800C3448(u32 arg0) {
 }
 
 void func_800C3478(void) {
-    for (D_800EA1E8; D_800EA1E4 != D_800EA1E8;) {
+    while (D_800EA1E4 != D_800EA1E8) {
         func_800C2A2C(D_80192CD0[D_800EA1E8++]);
     }
 }
@@ -1410,7 +1410,7 @@ void func_800C4398(void) {
         sSoundBanks[bank][soundIndex].cameraId = var_a2->cameraId;
         sSoundBanks[bank][soundIndex].unk10 = var_a2->unk0C;
         sSoundBanks[bank][soundIndex].unk14 = var_a2->unk10;
-        sSoundBanks[bank][0, soundIndex].unk18 = var_a2->unk14;
+        sSoundBanks[bank][soundIndex].unk18 = var_a2->unk14;
         sSoundBanks[bank][soundIndex].soundBits = var_a2->soundBits;
         sSoundBanks[bank][soundIndex].soundStatus = (u8) ((u32) (var_a2->soundBits & 0x01000000) >> 0x18);
         sSoundBanks[bank][soundIndex].freshness = 2;
@@ -1928,11 +1928,11 @@ void func_800C5E38(u8 playerId) {
                             if ((s32) D_800EA1C0 < 2) {
                                 play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF9, 0x26), &D_800E9F7C[playerId].pos, playerId,
                                            &D_800E9F7C[playerId].unk_38, &D_800E9F04[playerId],
-                                           (u8*) &D_800E9F7C[playerId].unk_14);
+                                           (s8*) &D_800E9F7C[playerId].unk_14);
                             } else {
                                 play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0x80, 0x26), &D_800E9F7C[playerId].pos, playerId,
                                            &D_800E9F7C[playerId].unk_38, &D_800E9F04[playerId],
-                                           (u8*) &D_800E9F7C[playerId].unk_14);
+                                           (s8*) &D_800E9F7C[playerId].unk_14);
                             }
                         }
                         break;
@@ -2097,144 +2097,144 @@ void func_800C683C(u8 cameraId) {
             switch (D_800E9E74[cameraId]) {
                 case 3:
                     play_sound(SOUND_ACTION_TYRE_SQUEAL, &D_800E9F7C[cameraId].pos, cameraId, &D_800E9F14[cameraId],
-                               &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ACTION_TYRE_SQUEAL;
                     break;
                 case 18:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF8, 0x1D), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800EA1D4, (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800EA1D4, (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF8, 0x1D);
                     break;
                 case 19:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF8, 0x22), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800EA1D4, (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800EA1D4, (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF8, 0x22);
                     break;
                 case 1:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x09), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x09);
                     break;
                 case 2:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF4, 0x0A), &D_800E9F7C[cameraId].pos, cameraId,
-                               &D_800E9F14[cameraId], &D_800EA1D4, (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9F14[cameraId], &D_800EA1D4, (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF4, 0x0A);
                     break;
                 case 17:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x1E), &D_800E9F7C[cameraId].pos, cameraId,
-                               &D_800E9F14[cameraId], &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9F14[cameraId], &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x1E);
                     break;
                 case 15:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x1F), &D_800E9F7C[cameraId].pos, cameraId,
-                               &D_800E9F14[cameraId], &D_800EA1D4, (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9F14[cameraId], &D_800EA1D4, (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x1F);
                     break;
                 case 16:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x21), &D_800E9F7C[cameraId].pos, cameraId,
-                               &D_800E9F14[cameraId], &D_800EA1D4, (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9F14[cameraId], &D_800EA1D4, (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x21);
                     break;
                 case 20:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x27), &D_800E9F7C[cameraId].pos, cameraId,
-                               &D_800E9F14[cameraId], &D_800EA1D4, (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9F14[cameraId], &D_800EA1D4, (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x27);
                     break;
                 case 25:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x20), &D_800E9F7C[cameraId].pos, cameraId,
-                               &D_800E9F14[cameraId], &D_800EA1D4, (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9F14[cameraId], &D_800EA1D4, (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x20);
                     break;
                 case 26:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x23), &D_800E9F7C[cameraId].pos, cameraId,
-                               &D_800E9F14[cameraId], &D_800EA1D4, (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9F14[cameraId], &D_800EA1D4, (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x23);
                     break;
                 case 27:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0x80, 0x46), &D_800E9F7C[cameraId].pos, cameraId,
-                               &D_800E9F14[cameraId], &D_800EA1D4, (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9F14[cameraId], &D_800EA1D4, (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0x80, 0x46);
                     break;
                 case 28:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x25), &D_800E9F7C[cameraId].pos, cameraId,
-                               &D_800E9F14[cameraId], &D_800EA1D4, (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9F14[cameraId], &D_800EA1D4, (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x25);
                     break;
                 case 4:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x0B), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x0B);
                     break;
                 case 5:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x0C), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x0C);
                     break;
                 case 6:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x0D), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x0D);
                     break;
                 case 7:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x0E), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x0E);
                     break;
                 case 8:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x0F), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x0F);
                     break;
                 case 9:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x10), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x10);
                     break;
                 case 10:
                 case 14:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x11), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x11);
                     break;
                 case 11:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x12), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x12);
                     break;
                 case 12:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x13), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x13);
                     break;
                 case 29:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x48), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x48);
                     break;
                 case 30:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x49), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x49);
                     break;
                 case 31:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x4A), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x4A);
                     break;
                 case 13:
                 case 22:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x29), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x29);
                     break;
                 case 23:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x2A), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x2A);
                     break;
                 case 24:
                     play_sound(SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x2B), &D_800E9F7C[cameraId].pos, cameraId, &D_800EA1D4,
-                               &D_800E9EF4[cameraId], (u8*) &D_800E9F7C[cameraId].unk_14);
+                               &D_800E9EF4[cameraId], (s8*) &D_800E9F7C[cameraId].unk_14);
                     D_800E9E94[cameraId] = SOUND_ARG_LOAD(0x01, 0x00, 0xF0, 0x2B);
                     break;
                 default:
@@ -2751,7 +2751,7 @@ void func_800C847C(u8 playerId) {
                 (D_800EA0EC[playerId] == 0)) {
                 play_sound((gPlayers[playerId].characterId * 0x10) + SOUND_ARG_LOAD(0x29, 0x00, 0x80, 0x05),
                            &D_800E9F7C[playerId].pos, playerId, &D_800EA1D4, &D_800EA1D4,
-                           (u8*) &D_800E9F7C[playerId].unk_14);
+                           (s8*) &D_800E9F7C[playerId].unk_14);
             }
         }
     } else {
@@ -2763,7 +2763,7 @@ void func_800C847C(u8 playerId) {
             if ((IsKoopaTroopaBeach()) && (D_800EA0EC[playerId] == 0)) {
                 play_sound((gPlayers[playerId].characterId * 0x10) + SOUND_ARG_LOAD(0x29, 0x00, 0x80, 0x08),
                            &D_800E9F7C[playerId].pos, playerId, &D_800EA1D4, &D_800EA1D4,
-                           (u8*) &D_800E9F7C[playerId].unk_14);
+                           (s8*) &D_800E9F7C[playerId].unk_14);
             }
         }
     }
@@ -2927,7 +2927,7 @@ void play_sound2(s32 soundBits) {
     if ((soundBits == SOUND_ACTION_REV_ENGINE_2) && (IsDkJungle())) {
         soundBits = SOUND_ARG_LOAD(0x49, 0x00, 0x80, 0x28);
     }
-    play_sound(soundBits, &D_800EA1C8, 4, &D_800EA1D4, &D_800EA1D4, &D_800EA1DC);
+    play_sound(soundBits, &D_800EA1C8, 4, &D_800EA1D4, &D_800EA1D4, (s8*) &D_800EA1DC);
 }
 
 void play_sequence(u16 arg0) {
@@ -2957,7 +2957,7 @@ void func_800C8F80(u8 arg0, u32 soundBits) {
             case 2:
                 D_800EA0EC[arg0] = 1;
             case 0:
-                play_sound(soundBits, &D_800E9F7C[arg0].pos, arg0, &D_800EA1D4, &D_800EA1D4, &D_800EA1DC);
+                play_sound(soundBits, &D_800E9F7C[arg0].pos, arg0, &D_800EA1D4, &D_800EA1D4, (s8*) &D_800EA1DC);
                 break;
         }
     }
@@ -2974,7 +2974,7 @@ void func_800C9060(u8 playerId, u32 soundBits) {
                 D_800EA0EC[playerId] = 1;
             case 0:
                 play_sound(soundBits, &D_800E9F7C[playerId].pos, playerId, &D_800EA1D4, &D_800EA1D4,
-                           (u8*) &D_800E9F7C[playerId].unk_14);
+                           (s8*) &D_800E9F7C[playerId].unk_14);
                 break;
         }
     }
@@ -2993,10 +2993,10 @@ void func_800C90F4(u8 playerId, u32 soundBits) {
                 }
                 if (((gPlayers[playerId].effects & 0x40000000) == 0x40000000) && ((s32) D_800E9F2C[playerId] >= 0x1F)) {
                     play_sound(soundBits, &D_800E9F7C[playerId].pos, playerId, &D_800EA150, &D_800EA1D4,
-                               (u8*) &D_800E9F7C[playerId].unk_14);
+                               (s8*) &D_800E9F7C[playerId].unk_14);
                 } else {
                     play_sound(soundBits, &D_800E9F7C[playerId].pos, playerId, &D_800EA1D4, &D_800EA1D4,
-                               (u8*) &D_800E9F7C[playerId].unk_14);
+                               (s8*) &D_800E9F7C[playerId].unk_14);
                 }
                 break;
             default:
@@ -3022,10 +3022,10 @@ void func_800C92CC(u8 playerId, u32 soundBits) {
                 temp_v0->unk34 = 170.0f;
                 if (((gPlayers[playerId].effects & 0x40000000) == 0x40000000) && ((s32) D_800E9F2C[playerId] >= 0x1F)) {
                     play_sound((gPlayers[playerId].characterId * 0x10) + soundBits, &temp_v0->unk18, var_s0,
-                               &D_800EA150, &D_800EA1D4, &D_800EA06C[playerId].unk0C);
+                               &D_800EA150, &D_800EA1D4, (s8*) &D_800EA06C[playerId].unk0C);
                 } else {
                     play_sound((gPlayers[playerId].characterId * 0x10) + soundBits, &temp_v0->unk18, var_s0,
-                               &temp_v0->unk2C, &D_800EA1D4, &D_800EA06C[playerId].unk0C);
+                               &temp_v0->unk2C, &D_800EA1D4, (s8*) &D_800EA06C[playerId].unk0C);
                 }
             }
         }
@@ -3116,7 +3116,7 @@ void func_800C94A4(u8 playerId) {
                         break;
                 }
                 play_sound(var_a0, &D_800E9F7C[playerId].pos, playerId, &D_800E9F7C[playerId].unk_0C,
-                           &D_800E9F7C[playerId].unk_10, (u8*) &D_800E9F7C[playerId].unk_14);
+                           &D_800E9F7C[playerId].unk_10, (s8*) &D_800E9F7C[playerId].unk_14);
                 break;
             default:
                 break;
@@ -3141,7 +3141,7 @@ void func_800C98B8(Vec3f position, Vec3f velocity, u32 soundBits) {
             temp_v0 = func_800C1C88(0U, position, velocity, D_800EA1C8, (u8) var_s0, soundBits);
             if (temp_v0 != 0) {
                 temp_v0->unk34 = 170.0f;
-                play_sound(soundBits, &temp_v0->unk18, var_s0, &temp_v0->unk2C, &D_800EA1D4, &D_800EA1DC);
+                play_sound(soundBits, &temp_v0->unk18, var_s0, &temp_v0->unk2C, &D_800EA1D4, (s8*) &D_800EA1DC);
             }
         }
     }
@@ -3204,7 +3204,7 @@ void func_800C9A88(u8 playerId) {
                         if (temp_v0_6 != NULL) {
                             temp_v0_6->unk34 = 40.0f;
                             play_sound(soundBits, &temp_v0_6->unk18, var_s0, &temp_v0_6->unk2C,
-                                       &D_800EA06C[playerId].unk00[2], &D_800EA06C[playerId].unk0C);
+                                       &D_800EA06C[playerId].unk00[2], (s8*) &D_800EA06C[playerId].unk0C);
                         }
                     }
                 }
@@ -3230,9 +3230,9 @@ void func_800C9D80(Vec3f position, Vec3f velocity, u32 soundBits) {
             if (temp_v0 != 0) {
                 temp_v0->unk34 = 170.0f;
                 if (soundBits == SOUND_ARG_LOAD(0x51, 0x03, 0x70, 0x0B)) {
-                    play_sound(soundBits, &temp_v0->unk18, var_s0, &D_800EA178, &D_800EA17C, &D_800EA1DC);
+                    play_sound(soundBits, &temp_v0->unk18, var_s0, &D_800EA178, &D_800EA17C, (s8*) &D_800EA1DC);
                 } else {
-                    play_sound(soundBits, &temp_v0->unk18, var_s0, &temp_v0->unk2C, &D_800EA1D4, &D_800EA1DC);
+                    play_sound(soundBits, &temp_v0->unk18, var_s0, &temp_v0->unk2C, &D_800EA1D4, (s8*) &D_800EA1DC);
                 }
             }
         }
@@ -3415,7 +3415,7 @@ void func_800CA49C(u8 arg0) {
 void func_800CA59C(u8 playerId) {
     if ((D_800EA0EC[playerId] == 0) && (D_800EA108 == 0)) {
         play_sound((gPlayers[playerId].characterId * 0x10) + 0x29008001, &D_800E9F7C[playerId].pos, playerId,
-                   &D_800EA1D4, &D_800EA1D4, (u8*) &D_800E9F7C[playerId].unk_14);
+                   &D_800EA1D4, &D_800EA1D4, (s8*) &D_800E9F7C[playerId].unk_14);
         D_800EA164 = 1;
         if ((s32) D_800EA1C0 >= 2) {
             func_800C8F80(playerId, 0x0100FF2C);
@@ -3443,7 +3443,7 @@ void func_800CA730(u8 arg0) {
     if (D_800EA0EC[arg0] == 0) {
         if ((D_800EA108 == 0) && (D_800EA10C[arg0] != 0)) {
             play_sound(gPlayers[arg0].characterId * 0x10 + SOUND_ARG_LOAD(0x29, 0x00, 0x80, 0x08),
-                       &D_800E9F7C[arg0].pos, arg0, &D_800EA1D4, &D_800EA1D4, (u8*) &D_800E9F7C[arg0].unk_14);
+                       &D_800E9F7C[arg0].pos, arg0, &D_800EA1D4, &D_800EA1D4, (s8*) &D_800E9F7C[arg0].unk_14);
             if (D_800EA10C[arg0] != 0) {
                 if ((s32) D_800EA1C0 >= 2) {
                     func_800C9018(arg0, SOUND_ARG_LOAD(0x01, 0x00, 0xFF, 0x2C));
@@ -3490,7 +3490,7 @@ void func_800CA984(u8 arg0) {
             temp_v0_2 =
                 func_800C1C88(arg0, gPlayers[arg0].pos, D_800EA1C8, &gPlayers[arg0].unk_098, (u8) i, SOUND_ITEM_STAR);
             if (temp_v0_2) {
-                play_sound(SOUND_ITEM_STAR, &temp_v0_2->unk18, i, &D_800EA1D4, &D_800EA1D4, &D_800EA1DC);
+                play_sound(SOUND_ITEM_STAR, &temp_v0_2->unk18, i, &D_800EA1D4, &D_800EA1D4, (s8*) &D_800EA1DC);
             }
         }
     }
@@ -3513,7 +3513,7 @@ void func_800CAB4C(u8 arg0) {
             case 0:
                 func_800C36C4(0, 1U, 0x55U, 5);
                 func_800C9060(arg0, 0x1900F013U);
-                play_sound(SOUND_ITEM_THUNDERBOLT, &D_800EA1C8, 0U, &D_800EA1D4, &D_800EA1D4, &D_800EA1DC);
+                play_sound(SOUND_ITEM_THUNDERBOLT, &D_800EA1C8, 0U, &D_800EA1D4, &D_800EA1D4, (s8*) &D_800EA1DC);
                 break;
             default:
                 break;
@@ -3532,10 +3532,10 @@ void func_800CAC08() {
 
 void func_800CAC60(UNUSED s32 arg0) {
     if ((D_800EA108 == 0) && (D_800EA0F0 == 0)) {
-        play_sound(SOUND_ACTION_EXPLOSION_2, &D_800EA1C8, 0U, &D_800EA1D4, &D_800EA1D4, &D_800EA1DC);
+        play_sound(SOUND_ACTION_EXPLOSION_2, &D_800EA1C8, 0U, &D_800EA1D4, &D_800EA1D4, (s8*) &D_800EA1DC);
         if ((D_800EA10C[0] != 1) && (D_800EA10C[1] != 1)) {
             func_800C36C4(0, 1, 0x37U, 5);
-            play_sound(SOUND_ITEM_THUNDERBOLT, &D_800EA1C8, 0U, &D_800EA1D4, &D_800EA1D4, &D_800EA1DC);
+            play_sound(SOUND_ITEM_THUNDERBOLT, &D_800EA1C8, 0U, &D_800EA1D4, &D_800EA1D4, (s8*) &D_800EA1DC);
             D_800EA168 = 1;
         }
     }
@@ -3567,7 +3567,7 @@ void func_800CADD0(u8 playerId, f32 arg1) {
                 }
                 D_800EA110[playerId] = arg1;
                 play_sound(0x1900A209U, &D_800E9F7C[playerId].pos, playerId, &D_800EA1D4, &D_800EA110[playerId],
-                           (u8*) &D_800E9F7C[playerId].unk_14);
+                           (s8*) &D_800E9F7C[playerId].unk_14);
                 break;
             default:
                 break;
@@ -3593,7 +3593,7 @@ void func_800CAEC4(u8 playerId, f32 arg1) {
                 //! @warning this used to be gCurrentCourseId + 0x19007020
                 // This may not be equivallent.
                 play_sound(TrackBrowser_GetTrackIndex() + 0x19007020, &D_800E9F7C[playerId].pos, playerId, &D_800EA1D4,
-                           &D_800EA120[playerId], (u8*) &D_800E9F7C[playerId].unk_14);
+                           &D_800EA120[playerId], (s8*) &D_800E9F7C[playerId].unk_14);
                 break;
             default:
                 break;
diff --git a/src/audio/heap.c b/src/audio/heap.c
index 363a2fb52..269230109 100644
--- a/src/audio/heap.c
+++ b/src/audio/heap.c
@@ -418,7 +418,7 @@ void* alloc_bank_or_seq(struct SoundMultiPool* arg0, s32 arg1, s32 size, s32 arg
                 tp->entries[1].ptr = pool->start + pool->size - size - 0x10;
                 tp->entries[1].id = (s16) id;
                 tp->entries[1].size = (u32) size;
-                if ((u32) tp->entries[1].ptr < (u32) pool->cur) {
+                if ((uintptr_t) tp->entries[1].ptr < (uintptr_t) pool->cur) {
                     table[tp->entries[0].id] = 0;
                     switch (isSound) { /* switch 1; irregular */
                         case 0:        /* switch 1 */
@@ -710,61 +710,3 @@ void* unk_pool1_lookup(s32 poolIdx, s32 id) {
     }
     return NULL;
 }
-
-// SM64 does not appear to have a function
-// comparable to this one, not a clue what
-// this one is doing.
-void func_800BA8B0(s32 poolIdx, s32 id) {
-    ALSeqFile* sp3C;
-    s32 temp_a2;
-    u32 temp_a1;
-    u8* var_a3;
-    UNUSED u8* temp_v0;
-    UNUSED s32 pad;
-
-    switch (poolIdx) { /* irregular */
-        case 0:
-            sp3C = gSeqFileHeader;
-            break;
-        case 1:
-            sp3C = gAlCtlHeader;
-            break;
-        case 2:
-            sp3C = gAlTbl;
-            break;
-    }
-    if (sp3C->seqArray[id].len == 0) {
-        id = (s32) sp3C->seqArray[id].offset;
-    }
-    if (unk_pool1_lookup(poolIdx, id) == NULL) {
-        temp_a2 = gUnkPool1.pool.numAllocatedEntries;
-        temp_a1 = sp3C->seqArray[id].len;
-        var_a3 = sp3C->seqArray[id].offset;
-        if (poolIdx == 1) {
-            var_a3 += 0x10;
-        }
-        gUnkPool1.entries[temp_a2].ptr = soundAlloc(&gUnkPool1.pool, temp_a1);
-        if (gUnkPool1.entries[temp_a2].ptr != NULL) {
-            audio_dma_copy_immediate(var_a3, gUnkPool1.entries[temp_a2].ptr, temp_a1);
-            gUnkPool1.entries[temp_a2].poolIndex = poolIdx;
-            gUnkPool1.entries[temp_a2].id = id;
-            gUnkPool1.entries[temp_a2].size = temp_a1;
-            switch (poolIdx) { /* switch 1; irregular */
-                case 0:        /* switch 1 */
-                    if (gSeqLoadStatus[id] != 5) {
-                        gSeqLoadStatus[id] = 5;
-                    }
-                    break;
-                case 1: /* switch 1 */
-                    gCtlEntries[id].instruments = (struct Instrument**) (gUnkPool1.entries[temp_a2].ptr + 4);
-                    func_800BB584(id);
-                    if (gBankLoadStatus[id] != 5) {
-                        gBankLoadStatus[id] = 5;
-                    }
-                    break;
-                case 2: /* switch 1 */
-                    break;
-            }
-        }
-    }
-}
diff --git a/src/audio/heap.h b/src/audio/heap.h
index ae71257c4..26192292b 100644
--- a/src/audio/heap.h
+++ b/src/audio/heap.h
@@ -113,7 +113,6 @@ void decrease_reverb_gain(void);
 s32 audio_shut_down_and_reset_step(void);
 void audio_reset_session(void);
 void* unk_pool1_lookup(s32 poolIdx, s32 id);
-void func_800BA8B0(s32, s32);
 
 extern s32 D_800EA5D0;
 
diff --git a/src/audio/load.c b/src/audio/load.c
index b3555ed88..6499eda4a 100644
--- a/src/audio/load.c
+++ b/src/audio/load.c
@@ -602,7 +602,7 @@ void* sequence_dma_async(s32 seqId, s32 arg1, struct SequencePlayer* seqPlayer)
     return ptr;
 }
 
-uint8_t* load_sequence_immediate(s32 seqId, s32 arg1) {
+uint8_t* load_sequence_immediate(s32 seqId, UNUSED s32 arg1) {
     return GameEngine_LoadSequence(seqId)->data;
 }
 
@@ -660,7 +660,7 @@ void load_sequence(u32 player, u32 seqId, s32 loadAsync) {
     }
 }
 
-void load_sequence_internal(u32 player, u32 seqId, s32 loadAsync) {
+void load_sequence_internal(u32 player, u32 seqId, UNUSED s32 loadAsync) {
     struct SequencePlayer* seqPlayer = &gSequencePlayers[player];
 
     if (seqId >= gSequenceCount) {
@@ -707,13 +707,13 @@ void audio_init(void) {
     UNUSED s32 pad[2];
     s32 j;
     UNUSED s32 pad2[6];
-    u32 sp60[2];
+    UNUSED u32 sp60[2];
     UNUSED s32 pad1[2];
-    s32 aaa;
-    s32 size;
+    UNUSED s32 aaa;
+    UNUSED s32 size;
     UNUSED u64* ptr64;
     UNUSED s32 one = 1;
-    u8* test;
+    UNUSED u8* test;
 
     gAudioLoadLock = 0;
 
diff --git a/src/audio/mixer.c b/src/audio/mixer.c
index 9b8157ab5..729dc2949 100644
--- a/src/audio/mixer.c
+++ b/src/audio/mixer.c
@@ -7,6 +7,12 @@
 
 #include "mixer.h"
 
+// The Impl signatures mirror the RSP command layout, so unused parameters are expected here;
+// suppress the warning once for the file instead of tagging every signature.
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+
 #ifndef __clang__
 #pragma GCC optimize("unroll-loops")
 #endif
@@ -133,15 +139,6 @@ static inline int16_t clamp16(int32_t v) {
     return (int16_t) v;
 }
 
-static inline int32_t clamp32(int64_t v) {
-    if (v < -0x7fffffff - 1) {
-        return -0x7fffffff - 1;
-    } else if (v > 0x7fffffff) {
-        return 0x7fffffff;
-    }
-    return (int32_t) v;
-}
-
 void aClearBufferImpl(uint16_t addr, int nbytes) {
     nbytes = ROUND_UP_16(nbytes);
     memset(BUF_U8(addr), 0, nbytes);
@@ -296,8 +293,7 @@ void aADPCMdecImpl(uint8_t flags, ADPCM_STATE state) {
     __m128i mask = _mm_loadl_epi64((__m128i*) lower_bit);
 
     while (nbytes > 0) {
-        int shift = *in >> 4; // should be in 0..12 or 0..14
-        __m128i shift_vec = _mm_set1_epi16(shift);
+        int shift = *in >> 4;          // should be in 0..12 or 0..14
         int table_index = *in++ & 0xf; // should be in 0..7
         int16_t(*tbl)[8] = rspa.adpcm_table[table_index];
 
@@ -734,7 +730,6 @@ void aMixImpl(int16_t gain, uint16_t in_addr, uint16_t out_addr, uint16_t count)
     int16_t* in = BUF_S16(in_addr);
     int16_t* out = BUF_S16(out_addr);
     int i;
-    int32_t sample;
 
     if (gain == -0x8000) {
         while (nbytes > 0) {
diff --git a/src/audio/port_eu.c b/src/audio/port_eu.c
index dfc9b12d2..1c4f0c11a 100644
--- a/src/audio/port_eu.c
+++ b/src/audio/port_eu.c
@@ -47,7 +47,7 @@ s32 D_800EA4A4 = 0;
 char port_eu_unused_string7[] = "Undefined Port Command %d\n";
 
 void create_next_audio_buffer(s16* samples, u32 num_samples) {
-    static s32 gMaxAbiCmdCnt = 128;
+    UNUSED static s32 gMaxAbiCmdCnt = 128;
     s32 abiCmdCount;
     OSMesg specId;
     OSMesg msg;
@@ -100,7 +100,7 @@ struct SPTask* create_next_audio_frame_task(void) {
     osSendMesg(D_800EA3A8, (OSMesg) gAudioFrameCount, OS_MESG_NOBLOCK);
 #else
     OSMesg audioMesg;
-    audioMesg.ptr = (void*) gAudioFrameCount;
+    audioMesg.ptr = (void*) (uintptr_t) gAudioFrameCount;
     osSendMesg(D_800EA3A8, audioMesg, OS_MESG_NOBLOCK);
 #endif