More MusyX progress, fully match hardware.c

asm/musyx/runtime/synthmacros.s

@@ -8,16 +8,23 @@
 
 .section .sbss
 .balign 8
-"cstep$1643":
+.obj "cstep$1643", local
 	.skip 0x8
-macRealTime:
+.endobj "cstep$1643"
+.obj macRealTime, local
 	.skip 0x8
-macTimeQueueRoot:
+.endobj macRealTime
+
+.obj macTimeQueueRoot, local
 	.skip 0x4
-macActiveMacroRoot:
+.endobj macTimeQueueRoot
+
+.obj macActiveMacroRoot, local
 	.skip 0x4
-DebugMacroSteps:
+.endobj macActiveMacroRoot
-	.skip 0x8
+.obj DebugMacroSteps, local
+	.skip 0x1
+.endobj DebugMacroSteps
 
 .section .data, "wa"
 .balign 8
@@ -1662,8 +1669,8 @@ lbl_803A3C3C:
 /* 803A3C4C 003A0BAC  38 21 00 50 */	addi r1, r1, 0x50
 /* 803A3C50 003A0BB0  4E 80 00 20 */	blr
 
-.global macSetPanning
+.global mcmdSetPanning
-macSetPanning:
+mcmdSetPanning:
 /* 803A3C54 003A0BB4  94 21 FF E0 */	stwu r1, -0x20(r1)
 /* 803A3C58 003A0BB8  7C 08 02 A6 */	mflr r0
 /* 803A3C5C 003A0BBC  90 01 00 24 */	stw r0, 0x24(r1)
@@ -1706,8 +1713,8 @@ lbl_803A3CC8:
 /* 803A3CE8 003A0C48  38 21 00 20 */	addi r1, r1, 0x20
 /* 803A3CEC 003A0C4C  4E 80 00 20 */	blr
 
-.global mcmdSetPanning
+.global mcmdSetSurroundPanning
-mcmdSetPanning:
+mcmdSetSurroundPanning:
 /* 803A3CF0 003A0C50  94 21 FF E0 */	stwu r1, -0x20(r1)
 /* 803A3CF4 003A0C54  7C 08 02 A6 */	mflr r0
 /* 803A3CF8 003A0C58  90 01 00 24 */	stw r0, 0x24(r1)
@@ -2843,8 +2850,8 @@ lbl_803A4CB0:
 /* 803A4CE8 003A1C48  38 21 00 10 */	addi r1, r1, 0x10
 /* 803A4CEC 003A1C4C  4E 80 00 20 */	blr
 
-.global mcmdSurroundingPanningSelect
+.global mcmdSurroundPanningSelect
-mcmdSurroundingPanningSelect:
+mcmdSurroundPanningSelect:
 /* 803A4CF0 003A1C50  94 21 FF F0 */	stwu r1, -0x10(r1)
 /* 803A4CF4 003A1C54  7C 08 02 A6 */	mflr r0
 /* 803A4CF8 003A1C58  3C A0 04 00 */	lis r5, 0x400
@@ -4108,7 +4115,6 @@ lbl_803A5E38:
 /* 803A5E8C 003A2DEC  7C 03 00 2E */	lwzx r0, r3, r0
 /* 803A5E90 003A2DF0  7C 09 03 A6 */	mtctr r0
 /* 803A5E94 003A2DF4  4E 80 04 20 */	bctr
-.global lbl_803A5E98
 lbl_803A5E98:
 /* 803A5E98 003A2DF8  7F E3 FB 78 */	mr r3, r31
 /* 803A5E9C 003A2DFC  48 00 18 A5 */	bl vidRemoveVoiceReferences
@@ -4116,7 +4122,6 @@ lbl_803A5E98:
 /* 803A5EA4 003A2E04  48 00 24 01 */	bl voiceFree
 /* 803A5EA8 003A2E08  3B C0 00 01 */	li r30, 1
 /* 803A5EAC 003A2E0C  48 00 0C 58 */	b lbl_803A6B04
-.global lbl_803A5EB0
 lbl_803A5EB0:
 /* 803A5EB0 003A2E10  7F E3 FB 78 */	mr r3, r31
 /* 803A5EB4 003A2E14  48 00 18 8D */	bl vidRemoveVoiceReferences
@@ -4124,7 +4129,6 @@ lbl_803A5EB0:
 /* 803A5EBC 003A2E1C  48 00 23 E9 */	bl voiceFree
 /* 803A5EC0 003A2E20  3B C0 00 01 */	li r30, 1
 /* 803A5EC4 003A2E24  48 00 0C 40 */	b lbl_803A6B04
-.global lbl_803A5EC8
 lbl_803A5EC8:
 /* 803A5EC8 003A2E28  A0 7F 01 2C */	lhz r3, 0x12c(r31)
 /* 803A5ECC 003A2E2C  57 40 C6 3E */	rlwinm r0, r26, 0x18, 0x18, 0x1f
@@ -4140,7 +4144,6 @@ lbl_803A5EC8:
 /* 803A5EF4 003A2E54  7C 03 02 14 */	add r0, r3, r0
 /* 803A5EF8 003A2E58  90 1F 00 38 */	stw r0, 0x38(r31)
 /* 803A5EFC 003A2E5C  48 00 0C 08 */	b lbl_803A6B04
-.global lbl_803A5F00
 lbl_803A5F00:
 /* 803A5F00 003A2E60  80 7F 01 54 */	lwz r3, 0x154(r31)
 /* 803A5F04 003A2E64  57 40 C6 3E */	rlwinm r0, r26, 0x18, 0x18, 0x1f
@@ -4157,20 +4160,17 @@ lbl_803A5F00:
 /* 803A5F30 003A2E90  7C 03 02 14 */	add r0, r3, r0
 /* 803A5F34 003A2E94  90 1F 00 38 */	stw r0, 0x38(r31)
 /* 803A5F38 003A2E98  48 00 0B CC */	b lbl_803A6B04
-.global lbl_803A5F3C
 lbl_803A5F3C:
 /* 803A5F3C 003A2E9C  7F E3 FB 78 */	mr r3, r31
 /* 803A5F40 003A2EA0  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A5F44 003A2EA4  4B FF CA 81 */	bl mcmdWait
 /* 803A5F48 003A2EA8  7C 7E 1B 78 */	mr r30, r3
 /* 803A5F4C 003A2EAC  48 00 0B B8 */	b lbl_803A6B04
-.global lbl_803A5F50
 lbl_803A5F50:
 /* 803A5F50 003A2EB0  7F E3 FB 78 */	mr r3, r31
 /* 803A5F54 003A2EB4  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A5F58 003A2EB8  4B FF CE 2D */	bl mcmdLoop
 /* 803A5F5C 003A2EBC  48 00 0B A8 */	b lbl_803A6B04
-.global lbl_803A5F60
 lbl_803A5F60:
 /* 803A5F60 003A2EC0  57 43 84 3E */	srwi r3, r26, 0x10
 /* 803A5F64 003A2EC4  4B FF C5 99 */	bl dataGetMacro
@@ -4192,7 +4192,6 @@ lbl_803A5F8C:
 lbl_803A5FA0:
 /* 803A5FA0 003A2F00  7C 9E 23 78 */	mr r30, r4
 /* 803A5FA4 003A2F04  48 00 0B 60 */	b lbl_803A6B04
-.global lbl_803A5FA8
 lbl_803A5FA8:
 /* 803A5FA8 003A2F08  38 00 00 01 */	li r0, 1
 /* 803A5FAC 003A2F0C  7F E3 FB 78 */	mr r3, r31
@@ -4201,13 +4200,11 @@ lbl_803A5FA8:
 /* 803A5FB8 003A2F18  4B FF CA 0D */	bl mcmdWait
 /* 803A5FBC 003A2F1C  7C 7E 1B 78 */	mr r30, r3
 /* 803A5FC0 003A2F20  48 00 0B 44 */	b lbl_803A6B04
-.global lbl_803A5FC4
 lbl_803A5FC4:
 /* 803A5FC4 003A2F24  7F E3 FB 78 */	mr r3, r31
 /* 803A5FC8 003A2F28  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A5FCC 003A2F2C  4B FF CF 0D */	bl mcmdPlayMacro
 /* 803A5FD0 003A2F30  48 00 0B 34 */	b lbl_803A6B04
-.global lbl_803A5FD4
 lbl_803A5FD4:
 /* 803A5FD4 003A2F34  88 9F 01 2F */	lbz r4, 0x12f(r31)
 /* 803A5FD8 003A2F38  57 43 C6 3E */	rlwinm r3, r26, 0x18, 0x18, 0x1f
@@ -4243,7 +4240,6 @@ lbl_803A6040:
 /* 803A6044 003A2FA4  7C 1B 00 40 */	cmplw r27, r0
 /* 803A6048 003A2FA8  41 80 FF B0 */	blt lbl_803A5FF8
 /* 803A604C 003A2FAC  48 00 0A B8 */	b lbl_803A6B04
-.global lbl_803A6050
 lbl_803A6050:
 /* 803A6050 003A2FB0  88 1F 01 21 */	lbz r0, 0x121(r31)
 /* 803A6054 003A2FB4  28 00 00 FF */	cmplwi r0, 0xff
@@ -4265,7 +4261,6 @@ lbl_803A6050:
 /* 803A6094 003A2FF4  7C 03 02 14 */	add r0, r3, r0
 /* 803A6098 003A2FF8  90 1F 00 38 */	stw r0, 0x38(r31)
 /* 803A609C 003A2FFC  48 00 0A 68 */	b lbl_803A6B04
-.global lbl_803A60A0
 lbl_803A60A0:
 /* 803A60A0 003A3000  A0 9F 01 2C */	lhz r4, 0x12c(r31)
 /* 803A60A4 003A3004  57 45 86 3E */	rlwinm r5, r26, 0x10, 0x18, 0x1f
@@ -4289,43 +4284,36 @@ lbl_803A60E4:
 /* 803A60E4 003A3044  90 1F 01 80 */	stw r0, 0x180(r31)
 /* 803A60E8 003A3048  90 1F 01 70 */	stw r0, 0x170(r31)
 /* 803A60EC 003A304C  48 00 0A 18 */	b lbl_803A6B04
-.global lbl_803A60F0
 lbl_803A60F0:
 /* 803A60F0 003A3050  7F E3 FB 78 */	mr r3, r31
 /* 803A60F4 003A3054  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A60F8 003A3058  4B FF D5 5D */	bl mcmdSetADSR
 /* 803A60FC 003A305C  48 00 0A 08 */	b lbl_803A6B04
-.global lbl_803A6100
 lbl_803A6100:
 /* 803A6100 003A3060  7F E3 FB 78 */	mr r3, r31
 /* 803A6104 003A3064  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A6108 003A3068  4B FF DC 85 */	bl mcmdScaleVolume
 /* 803A610C 003A306C  48 00 09 F8 */	b lbl_803A6B04
-.global lbl_803A6110
 lbl_803A6110:
 /* 803A6110 003A3070  7F E3 FB 78 */	mr r3, r31
 /* 803A6114 003A3074  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
-/* 803A6118 003A3078  4B FF DB 3D */	bl macSetPanning
+/* 803A6118 003A3078  4B FF DB 3D */	bl mcmdSetPanning
 /* 803A611C 003A307C  48 00 09 E8 */	b lbl_803A6B04
-.global lbl_803A6120
 lbl_803A6120:
 /* 803A6120 003A3080  7F E3 FB 78 */	mr r3, r31
 /* 803A6124 003A3084  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A6128 003A3088  4B FF DD 99 */	bl mcmdEnvelope
 /* 803A612C 003A308C  48 00 09 D8 */	b lbl_803A6B04
-.global lbl_803A6130
 lbl_803A6130:
 /* 803A6130 003A3090  7F E3 FB 78 */	mr r3, r31
 /* 803A6134 003A3094  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A6138 003A3098  4B FF D0 05 */	bl mcmdStartSample
 /* 803A613C 003A309C  48 00 09 C8 */	b lbl_803A6B04
-.global lbl_803A6140
 lbl_803A6140:
 /* 803A6140 003A30A0  80 1F 00 F4 */	lwz r0, 0xf4(r31)
 /* 803A6144 003A30A4  54 03 06 3E */	clrlwi r3, r0, 0x18
 /* 803A6148 003A30A8  48 00 D2 45 */	bl hwBreak
 /* 803A614C 003A30AC  48 00 09 B8 */	b lbl_803A6B04
-.global lbl_803A6150
 lbl_803A6150:
 /* 803A6150 003A30B0  80 1F 01 18 */	lwz r0, 0x118(r31)
 /* 803A6154 003A30B4  7F E3 FB 78 */	mr r3, r31
@@ -4333,7 +4321,6 @@ lbl_803A6150:
 /* 803A615C 003A30BC  90 1F 01 18 */	stw r0, 0x118(r31)
 /* 803A6160 003A30C0  4B FF 49 81 */	bl synthKeyStateUpdate
 /* 803A6164 003A30C4  48 00 09 A0 */	b lbl_803A6B04
-.global lbl_803A6168
 lbl_803A6168:
 /* 803A6168 003A30C8  48 00 CC 39 */	bl sndRand
 /* 803A616C 003A30CC  80 8D AE E0 */	lwz r4, "cstep$1643"@sda21(r13)
@@ -4351,38 +4338,32 @@ lbl_803A6168:
 /* 803A619C 003A30FC  7C 03 02 14 */	add r0, r3, r0
 /* 803A61A0 003A3100  90 1F 00 38 */	stw r0, 0x38(r31)
 /* 803A61A4 003A3104  48 00 09 60 */	b lbl_803A6B04
-.global lbl_803A61A8
 lbl_803A61A8:
 /* 803A61A8 003A3108  7F E3 FB 78 */	mr r3, r31
 /* 803A61AC 003A310C  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A61B0 003A3110  4B FF DE 41 */	bl mcmdFadeIn
 /* 803A61B4 003A3114  48 00 09 50 */	b lbl_803A6B04
-.global lbl_803A61B8
 lbl_803A61B8:
 /* 803A61B8 003A3118  7F E3 FB 78 */	mr r3, r31
 /* 803A61BC 003A311C  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
-/* 803A61C0 003A3120  4B FF DB 31 */	bl mcmdSetPanning
+/* 803A61C0 003A3120  4B FF DB 31 */	bl mcmdSetSurroundPanning
 /* 803A61C4 003A3124  48 00 09 40 */	b lbl_803A6B04
-.global lbl_803A61C8
 lbl_803A61C8:
 /* 803A61C8 003A3128  7F E3 FB 78 */	mr r3, r31
 /* 803A61CC 003A312C  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A61D0 003A3130  4B FF D6 DD */	bl mcmdSetADSRFromCtrl
 /* 803A61D4 003A3134  48 00 09 30 */	b lbl_803A6B04
-.global lbl_803A61D8
 lbl_803A61D8:
 /* 803A61D8 003A3138  7F E3 FB 78 */	mr r3, r31
 /* 803A61DC 003A313C  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A61E0 003A3140  4B FF DF 4D */	bl mcmdRandomKey
 /* 803A61E4 003A3144  48 00 09 20 */	b lbl_803A6B04
-.global lbl_803A61E8
 lbl_803A61E8:
 /* 803A61E8 003A3148  7F E3 FB 78 */	mr r3, r31
 /* 803A61EC 003A314C  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A61F0 003A3150  4B FF CE 75 */	bl mcmdAddKey
 /* 803A61F4 003A3154  7C 7E 1B 78 */	mr r30, r3
 /* 803A61F8 003A3158  48 00 09 0C */	b lbl_803A6B04
-.global lbl_803A61FC
 lbl_803A61FC:
 /* 803A61FC 003A315C  57 40 C6 7E */	rlwinm r0, r26, 0x18, 0x19, 0x1f
 /* 803A6200 003A3160  7F E3 FB 78 */	mr r3, r31
@@ -4406,7 +4387,6 @@ lbl_803A6234:
 /* 803A6244 003A31A4  4B FF C7 81 */	bl mcmdWait
 /* 803A6248 003A31A8  7C 7E 1B 78 */	mr r30, r3
 /* 803A624C 003A31AC  48 00 08 B8 */	b lbl_803A6B04
-.global lbl_803A6250
 lbl_803A6250:
 /* 803A6250 003A31B0  57 40 C6 3E */	rlwinm r0, r26, 0x18, 0x18, 0x1f
 /* 803A6254 003A31B4  88 7F 01 30 */	lbz r3, 0x130(r31)
@@ -4443,19 +4423,16 @@ lbl_803A62B4:
 /* 803A62C4 003A3224  4B FF C7 01 */	bl mcmdWait
 /* 803A62C8 003A3228  7C 7E 1B 78 */	mr r30, r3
 /* 803A62CC 003A322C  48 00 08 38 */	b lbl_803A6B04
-.global lbl_803A62D0
 lbl_803A62D0:
 /* 803A62D0 003A3230  7F E3 FB 78 */	mr r3, r31
 /* 803A62D4 003A3234  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A62D8 003A3238  4B FF F0 1D */	bl mcmdPortamento
 /* 803A62DC 003A323C  48 00 08 28 */	b lbl_803A6B04
-.global lbl_803A62E0
 lbl_803A62E0:
 /* 803A62E0 003A3240  7F E3 FB 78 */	mr r3, r31
 /* 803A62E4 003A3244  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A62E8 003A3248  4B FF D0 51 */	bl mcmdVibrato
 /* 803A62EC 003A324C  48 00 08 18 */	b lbl_803A6B04
-.global lbl_803A62F0
 lbl_803A62F0:
 /* 803A62F0 003A3250  38 00 00 00 */	li r0, 0
 /* 803A62F4 003A3254  90 1F 01 A0 */	stw r0, 0x1a0(r31)
@@ -4485,7 +4462,6 @@ lbl_803A6334:
 /* 803A634C 003A32AC  4B FF C6 79 */	bl mcmdWait
 /* 803A6350 003A32B0  7C 7E 1B 78 */	mr r30, r3
 /* 803A6354 003A32B4  48 00 07 B0 */	b lbl_803A6B04
-.global lbl_803A6358
 lbl_803A6358:
 /* 803A6358 003A32B8  38 00 00 00 */	li r0, 0
 /* 803A635C 003A32BC  90 1F 01 A4 */	stw r0, 0x1a4(r31)
@@ -4515,7 +4491,6 @@ lbl_803A639C:
 /* 803A63B4 003A3314  4B FF C6 11 */	bl mcmdWait
 /* 803A63B8 003A3318  7C 7E 1B 78 */	mr r30, r3
 /* 803A63BC 003A331C  48 00 07 48 */	b lbl_803A6B04
-.global lbl_803A63C0
 lbl_803A63C0:
 /* 803A63C0 003A3320  57 40 C2 3E */	srwi r0, r26, 8
 /* 803A63C4 003A3324  90 1F 01 28 */	stw r0, 0x128(r31)
@@ -4531,13 +4506,11 @@ lbl_803A63C0:
 /* 803A63EC 003A334C  7F E3 FB 78 */	mr r3, r31
 /* 803A63F0 003A3350  4B FF D0 C5 */	bl DoSetPitch
 /* 803A63F4 003A3354  48 00 07 10 */	b lbl_803A6B04
-.global lbl_803A63F8
 lbl_803A63F8:
 /* 803A63F8 003A3358  7F E3 FB 78 */	mr r3, r31
 /* 803A63FC 003A335C  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A6400 003A3360  4B FF D5 D9 */	bl mcmdSetPitchADSR
 /* 803A6404 003A3364  48 00 07 00 */	b lbl_803A6B04
-.global lbl_803A6408
 lbl_803A6408:
 /* 803A6408 003A3368  57 40 46 3F */	rlwinm. r0, r26, 8, 0x18, 0x1f
 /* 803A640C 003A336C  57 43 C4 3E */	rlwinm r3, r26, 0x18, 0x10, 0x1f
@@ -4565,7 +4538,6 @@ lbl_803A6454:
 /* 803A6458 003A33B8  60 00 10 00 */	ori r0, r0, 0x1000
 /* 803A645C 003A33BC  90 1F 01 14 */	stw r0, 0x114(r31)
 /* 803A6460 003A33C0  48 00 06 A4 */	b lbl_803A6B04
-.global lbl_803A6464
 lbl_803A6464:
 /* 803A6464 003A33C4  57 40 C2 3E */	srwi r0, r26, 8
 /* 803A6468 003A33C8  7C 00 07 74 */	extsb r0, r0
@@ -4601,7 +4573,6 @@ lbl_803A64B4:
 /* 803A64DC 003A343C  7C 00 20 50 */	subf r0, r0, r4
 /* 803A64E0 003A3440  B0 1F 01 50 */	sth r0, 0x150(r31)
 /* 803A64E4 003A3444  48 00 06 20 */	b lbl_803A6B04
-.global lbl_803A64E8
 lbl_803A64E8:
 /* 803A64E8 003A3448  57 40 C4 3E */	rlwinm r0, r26, 0x18, 0x10, 0x1f
 /* 803A64EC 003A344C  C0 02 D5 8C */	lfs f0, lbl_805AF2AC@sda21(r2)
@@ -4610,7 +4581,6 @@ lbl_803A64E8:
 /* 803A64F8 003A3458  B0 1F 01 6E */	sth r0, 0x16e(r31)
 /* 803A64FC 003A345C  D0 1F 01 68 */	stfs f0, 0x168(r31)
 /* 803A6500 003A3460  48 00 06 04 */	b lbl_803A6B04
-.global lbl_803A6504
 lbl_803A6504:
 /* 803A6504 003A3464  88 1F 00 8C */	lbz r0, 0x8c(r31)
 /* 803A6508 003A3468  28 00 00 00 */	cmplwi r0, 0
@@ -4633,14 +4603,12 @@ lbl_803A6504:
 /* 803A654C 003A34AC  38 03 FF FF */	addi r0, r3, -1
 /* 803A6550 003A34B0  98 1F 00 8C */	stb r0, 0x8c(r31)
 /* 803A6554 003A34B4  48 00 05 B0 */	b lbl_803A6B04
-.global lbl_803A6558
 lbl_803A6558:
 /* 803A6558 003A34B8  7F E3 FB 78 */	mr r3, r31
 /* 803A655C 003A34BC  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A6560 003A34C0  4B FF C7 55 */	bl mcmdGosub
 /* 803A6564 003A34C4  7C 7E 1B 78 */	mr r30, r3
 /* 803A6568 003A34C8  48 00 05 9C */	b lbl_803A6B04
-.global lbl_803A656C
 lbl_803A656C:
 /* 803A656C 003A34CC  57 43 84 3E */	srwi r3, r26, 0x10
 /* 803A6570 003A34D0  4B FF BF 8D */	bl dataGetMacro
@@ -4672,7 +4640,6 @@ lbl_803A656C:
 /* 803A65D8 003A3538  60 80 04 00 */	ori r0, r4, 0x400
 /* 803A65DC 003A353C  90 1F 01 14 */	stw r0, 0x114(r31)
 /* 803A65E0 003A3540  48 00 05 24 */	b lbl_803A6B04
-.global lbl_803A65E4
 lbl_803A65E4:
 /* 803A65E4 003A3544  57 43 D5 BA */	rlwinm r3, r26, 0x1a, 0x16, 0x1d
 /* 803A65E8 003A3548  38 80 00 00 */	li r4, 0
@@ -4693,13 +4660,11 @@ lbl_803A6610:
 /* 803A661C 003A357C  38 00 00 00 */	li r0, 0
 /* 803A6620 003A3580  98 1F 00 68 */	stb r0, 0x68(r31)
 /* 803A6624 003A3584  48 00 04 E0 */	b lbl_803A6B04
-.global lbl_803A6628
 lbl_803A6628:
 /* 803A6628 003A3588  7F E3 FB 78 */	mr r3, r31
 /* 803A662C 003A358C  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A6630 003A3590  4B FF F1 FD */	bl mcmdSendMessage
 /* 803A6634 003A3594  48 00 04 D0 */	b lbl_803A6B04
-.global lbl_803A6638
 lbl_803A6638:
 /* 803A6638 003A3598  88 1F 03 EC */	lbz r0, 0x3ec(r31)
 /* 803A663C 003A359C  38 A0 00 00 */	li r5, 0
@@ -4731,13 +4696,11 @@ lbl_803A6690:
 /* 803A669C 003A35FC  7C 60 22 14 */	add r3, r0, r4
 /* 803A66A0 003A3600  90 A3 FF C0 */	stw r5, -0x40(r3)
 /* 803A66A4 003A3604  48 00 04 60 */	b lbl_803A6B04
-.global lbl_803A66A8
 lbl_803A66A8:
 /* 803A66A8 003A3608  7F E3 FB 78 */	mr r3, r31
 /* 803A66AC 003A360C  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A66B0 003A3610  4B FF F3 C1 */	bl mcmdGetVID
 /* 803A66B4 003A3614  48 00 04 50 */	b lbl_803A6B04
-.global lbl_803A66B8
 lbl_803A66B8:
 /* 803A66B8 003A3618  80 7F 01 10 */	lwz r3, 0x110(r31)
 /* 803A66BC 003A361C  57 40 84 3E */	srwi r0, r26, 0x10
@@ -4769,7 +4732,6 @@ lbl_803A6704:
 /* 803A6718 003A3678  50 A4 C0 0E */	rlwimi r4, r5, 0x18, 0, 7
 /* 803A671C 003A367C  48 00 CA A9 */	bl hwSetPriority
 /* 803A6720 003A3680  48 00 03 E4 */	b lbl_803A6B04
-.global lbl_803A6724
 lbl_803A6724:
 /* 803A6724 003A3684  57 40 F8 60 */	rlwinm r0, r26, 0x1f, 1, 0x10
 /* 803A6728 003A3688  90 1F 01 10 */	stw r0, 0x110(r31)
@@ -4781,7 +4743,6 @@ lbl_803A6724:
 /* 803A6740 003A36A0  50 A4 C0 0E */	rlwimi r4, r5, 0x18, 0, 7
 /* 803A6744 003A36A4  48 00 CA 81 */	bl hwSetPriority
 /* 803A6748 003A36A8  48 00 03 BC */	b lbl_803A6B04
-.global lbl_803A674C
 lbl_803A674C:
 /* 803A674C 003A36AC  3C 60 80 55 */	lis r3, synthGlobalVariable@ha
 /* 803A6750 003A36B0  57 44 86 3E */	rlwinm r4, r26, 0x10, 0x18, 0x1f
@@ -4789,7 +4750,6 @@ lbl_803A674C:
 /* 803A6758 003A36B8  38 63 0A B4 */	addi r3, r3, synthGlobalVariable@l
 /* 803A675C 003A36BC  7C 83 01 2E */	stwx r4, r3, r0
 /* 803A6760 003A36C0  48 00 03 A4 */	b lbl_803A6B04
-.global lbl_803A6764
 lbl_803A6764:
 /* 803A6764 003A36C4  57 40 86 3E */	rlwinm r0, r26, 0x10, 0x18, 0x1f
 /* 803A6768 003A36C8  98 1F 01 D6 */	stb r0, 0x1d6(r31)
@@ -4797,7 +4757,6 @@ lbl_803A6764:
 /* 803A6770 003A36D0  54 00 C6 3E */	rlwinm r0, r0, 0x18, 0x18, 0x1f
 /* 803A6774 003A36D4  98 1F 01 D7 */	stb r0, 0x1d7(r31)
 /* 803A6778 003A36D8  48 00 03 8C */	b lbl_803A6B04
-.global lbl_803A677C
 lbl_803A677C:
 /* 803A677C 003A36DC  57 40 C6 3E */	rlwinm r0, r26, 0x18, 0x18, 0x1f
 /* 803A6780 003A36E0  98 1F 01 90 */	stb r0, 0x190(r31)
@@ -4805,20 +4764,17 @@ lbl_803A677C:
 /* 803A6788 003A36E8  54 00 86 3E */	rlwinm r0, r0, 0x10, 0x18, 0x1f
 /* 803A678C 003A36EC  98 1F 01 91 */	stb r0, 0x191(r31)
 /* 803A6790 003A36F0  48 00 03 74 */	b lbl_803A6B04
-.global lbl_803A6794
 lbl_803A6794:
 /* 803A6794 003A36F4  80 9F 01 18 */	lwz r4, 0x118(r31)
 /* 803A6798 003A36F8  3C 00 00 01 */	lis r0, 1
 /* 803A679C 003A36FC  7C 80 03 78 */	or r0, r4, r0
 /* 803A67A0 003A3700  90 1F 01 18 */	stw r0, 0x118(r31)
 /* 803A67A4 003A3704  48 00 03 60 */	b lbl_803A6B04
-.global lbl_803A67A8
 lbl_803A67A8:
 /* 803A67A8 003A3708  7F E3 FB 78 */	mr r3, r31
 /* 803A67AC 003A370C  57 44 C6 3E */	rlwinm r4, r26, 0x18, 0x18, 0x1f
 /* 803A67B0 003A3710  48 00 14 49 */	bl voiceSetPriority
 /* 803A67B4 003A3714  48 00 03 50 */	b lbl_803A6B04
-.global lbl_803A67B8
 lbl_803A67B8:
 /* 803A67B8 003A3718  57 40 84 3E */	srwi r0, r26, 0x10
 /* 803A67BC 003A371C  88 9F 01 0C */	lbz r4, 0x10c(r31)
@@ -4838,7 +4794,6 @@ lbl_803A67EC:
 /* 803A67EC 003A374C  54 04 06 3E */	clrlwi r4, r0, 0x18
 /* 803A67F0 003A3750  48 00 14 09 */	bl voiceSetPriority
 /* 803A67F4 003A3754  48 00 03 10 */	b lbl_803A6B04
-.global lbl_803A67F8
 lbl_803A67F8:
 /* 803A67F8 003A3758  80 7C 00 04 */	lwz r3, 4(r28)
 /* 803A67FC 003A375C  28 03 00 00 */	cmplwi r3, 0
@@ -4852,7 +4807,6 @@ lbl_803A6818:
 /* 803A6818 003A3778  38 00 00 00 */	li r0, 0
 /* 803A681C 003A377C  B0 1F 01 0E */	sth r0, 0x10e(r31)
 /* 803A6820 003A3780  48 00 02 E4 */	b lbl_803A6B04
-.global lbl_803A6824
 lbl_803A6824:
 /* 803A6824 003A3784  80 9F 01 54 */	lwz r4, 0x154(r31)
 /* 803A6828 003A3788  57 45 84 3E */	srwi r5, r26, 0x10
@@ -4876,97 +4830,81 @@ lbl_803A6854:
 /* 803A686C 003A37CC  50 A4 C0 0E */	rlwimi r4, r5, 0x18, 0, 7
 /* 803A6870 003A37D0  48 00 C9 55 */	bl hwSetPriority
 /* 803A6874 003A37D4  48 00 02 90 */	b lbl_803A6B04
-.global lbl_803A6878
 lbl_803A6878:
 /* 803A6878 003A37D8  7F E3 FB 78 */	mr r3, r31
 /* 803A687C 003A37DC  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A6880 003A37E0  4B FF DA 49 */	bl mcmdVolumeSelect
 /* 803A6884 003A37E4  48 00 02 80 */	b lbl_803A6B04
-.global lbl_803A6888
 lbl_803A6888:
 /* 803A6888 003A37E8  7F E3 FB 78 */	mr r3, r31
 /* 803A688C 003A37EC  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A6890 003A37F0  4B FF DB 3D */	bl mcmdPanningSelect
 /* 803A6894 003A37F4  48 00 02 70 */	b lbl_803A6B04
-.global lbl_803A6898
 lbl_803A6898:
 /* 803A6898 003A37F8  7F E3 FB 78 */	mr r3, r31
 /* 803A689C 003A37FC  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A68A0 003A3800  4B FF DC 31 */	bl mcmdPitchWheelSelect
 /* 803A68A4 003A3804  48 00 02 60 */	b lbl_803A6B04
-.global lbl_803A68A8
 lbl_803A68A8:
 /* 803A68A8 003A3808  7F E3 FB 78 */	mr r3, r31
 /* 803A68AC 003A380C  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A68B0 003A3810  4B FF DD 25 */	bl mcmdModWheelSelect
 /* 803A68B4 003A3814  48 00 02 50 */	b lbl_803A6B04
-.global lbl_803A68B8
 lbl_803A68B8:
 /* 803A68B8 003A3818  7F E3 FB 78 */	mr r3, r31
 /* 803A68BC 003A381C  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A68C0 003A3820  4B FF DE 19 */	bl mcmdPedalSelect
 /* 803A68C4 003A3824  48 00 02 40 */	b lbl_803A6B04
-.global lbl_803A68C8
 lbl_803A68C8:
 /* 803A68C8 003A3828  7F E3 FB 78 */	mr r3, r31
 /* 803A68CC 003A382C  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A68D0 003A3830  4B FF DF 0D */	bl mcmdPortamentoSelect
 /* 803A68D4 003A3834  48 00 02 30 */	b lbl_803A6B04
-.global lbl_803A68D8
 lbl_803A68D8:
 /* 803A68D8 003A3838  7F E3 FB 78 */	mr r3, r31
 /* 803A68DC 003A383C  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A68E0 003A3840  4B FF E0 01 */	bl mcmdReverbSelect
 /* 803A68E4 003A3844  48 00 02 20 */	b lbl_803A6B04
-.global lbl_803A68E8
 lbl_803A68E8:
 /* 803A68E8 003A3848  7F E3 FB 78 */	mr r3, r31
 /* 803A68EC 003A384C  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
-/* 803A68F0 003A3850  4B FF E4 01 */	bl mcmdSurroundingPanningSelect
+/* 803A68F0 003A3850  4B FF E4 01 */	bl mcmdSurroundPanningSelect
 /* 803A68F4 003A3854  48 00 02 10 */	b lbl_803A6B04
-.global lbl_803A68F8
 lbl_803A68F8:
 /* 803A68F8 003A3858  7F E3 FB 78 */	mr r3, r31
 /* 803A68FC 003A385C  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A6900 003A3860  4B FF E4 F5 */	bl mcmdDopplerSelect
 /* 803A6904 003A3864  48 00 02 00 */	b lbl_803A6B04
-.global lbl_803A6908
 lbl_803A6908:
 /* 803A6908 003A3868  7F E3 FB 78 */	mr r3, r31
 /* 803A690C 003A386C  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A6910 003A3870  4B FF E5 E9 */	bl mcmdTremoloSelect
 /* 803A6914 003A3874  48 00 01 F0 */	b lbl_803A6B04
-.global lbl_803A6918
 lbl_803A6918:
 /* 803A6918 003A3878  7F E3 FB 78 */	mr r3, r31
 /* 803A691C 003A387C  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A6920 003A3880  4B FF E0 C5 */	bl mcmdPreAuxASelect
 /* 803A6924 003A3884  48 00 01 E0 */	b lbl_803A6B04
-.global lbl_803A6928
 lbl_803A6928:
 /* 803A6928 003A3888  7F E3 FB 78 */	mr r3, r31
 /* 803A692C 003A388C  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A6930 003A3890  4B FF E1 B9 */	bl mcmdPreAuxBSelect
 /* 803A6934 003A3894  48 00 01 D0 */	b lbl_803A6B04
-.global lbl_803A6938
 lbl_803A6938:
 /* 803A6938 003A3898  7F E3 FB 78 */	mr r3, r31
 /* 803A693C 003A389C  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A6940 003A38A0  4B FF E2 AD */	bl mcmdPostAuxBSelect
 /* 803A6944 003A38A4  48 00 01 C0 */	b lbl_803A6B04
-.global lbl_803A6948
 lbl_803A6948:
 /* 803A6948 003A38A8  7F E3 FB 78 */	mr r3, r31
 /* 803A694C 003A38AC  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A6950 003A38B0  4B FF E6 AD */	bl mcmdAuxAFXSelect
 /* 803A6954 003A38B4  48 00 01 B0 */	b lbl_803A6B04
-.global lbl_803A6958
 lbl_803A6958:
 /* 803A6958 003A38B8  7F E3 FB 78 */	mr r3, r31
 /* 803A695C 003A38BC  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A6960 003A38C0  4B FF E8 19 */	bl mcmdAuxBFXSelect
 /* 803A6964 003A38C4  48 00 01 A0 */	b lbl_803A6B04
-.global lbl_803A6968
 lbl_803A6968:
 /* 803A6968 003A38C8  57 40 84 3E */	srwi r0, r26, 0x10
 /* 803A696C 003A38CC  38 61 00 08 */	addi r3, r1, 8
@@ -4989,7 +4927,6 @@ lbl_803A69AC:
 /* 803A69AC 003A390C  80 01 00 08 */	lwz r0, 8(r1)
 /* 803A69B0 003A3910  90 19 01 C0 */	stw r0, 0x1c0(r25)
 /* 803A69B4 003A3914  48 00 01 50 */	b lbl_803A6B04
-.global lbl_803A69B8
 lbl_803A69B8:
 /* 803A69B8 003A3918  57 43 C6 3E */	rlwinm r3, r26, 0x18, 0x18, 0x1f
 /* 803A69BC 003A391C  7C 03 00 D0 */	neg r0, r3
@@ -5002,13 +4939,11 @@ lbl_803A69B8:
 /* 803A69D8 003A3938  54 00 DE 3E */	rlwinm r0, r0, 0x1b, 0x18, 0x1f
 /* 803A69DC 003A393C  98 1F 01 93 */	stb r0, 0x193(r31)
 /* 803A69E0 003A3940  48 00 01 24 */	b lbl_803A6B04
-.global lbl_803A69E4
 lbl_803A69E4:
 /* 803A69E4 003A3944  7F E3 FB 78 */	mr r3, r31
 /* 803A69E8 003A3948  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A69EC 003A394C  4B FF F1 05 */	bl mcmdSetKeyGroup
 /* 803A69F0 003A3950  48 00 01 14 */	b lbl_803A6B04
-.global lbl_803A69F4
 lbl_803A69F4:
 /* 803A69F4 003A3954  80 1F 00 F4 */	lwz r0, 0xf4(r31)
 /* 803A69F8 003A3958  57 44 C6 3E */	rlwinm r4, r26, 0x18, 0x18, 0x1f
@@ -5023,42 +4958,36 @@ lbl_803A69F4:
 /* 803A6A1C 003A397C  60 00 08 00 */	ori r0, r0, 0x800
 /* 803A6A20 003A3980  90 1F 01 14 */	stw r0, 0x114(r31)
 /* 803A6A24 003A3984  48 00 00 E0 */	b lbl_803A6B04
-.global lbl_803A6A28
 lbl_803A6A28:
 /* 803A6A28 003A3988  7F E3 FB 78 */	mr r3, r31
 /* 803A6A2C 003A398C  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A6A30 003A3990  38 A0 00 00 */	li r5, 0
 /* 803A6A34 003A3994  4B FF EA 8D */	bl mcmdVarCalculation
 /* 803A6A38 003A3998  48 00 00 CC */	b lbl_803A6B04
-.global lbl_803A6A3C
 lbl_803A6A3C:
 /* 803A6A3C 003A399C  7F E3 FB 78 */	mr r3, r31
 /* 803A6A40 003A39A0  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A6A44 003A39A4  38 A0 00 01 */	li r5, 1
 /* 803A6A48 003A39A8  4B FF EA 79 */	bl mcmdVarCalculation
 /* 803A6A4C 003A39AC  48 00 00 B8 */	b lbl_803A6B04
-.global lbl_803A6A50
 lbl_803A6A50:
 /* 803A6A50 003A39B0  7F E3 FB 78 */	mr r3, r31
 /* 803A6A54 003A39B4  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A6A58 003A39B8  38 A0 00 02 */	li r5, 2
 /* 803A6A5C 003A39BC  4B FF EA 65 */	bl mcmdVarCalculation
 /* 803A6A60 003A39C0  48 00 00 A4 */	b lbl_803A6B04
-.global lbl_803A6A64
 lbl_803A6A64:
 /* 803A6A64 003A39C4  7F E3 FB 78 */	mr r3, r31
 /* 803A6A68 003A39C8  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A6A6C 003A39CC  38 A0 00 03 */	li r5, 3
 /* 803A6A70 003A39D0  4B FF EA 51 */	bl mcmdVarCalculation
 /* 803A6A74 003A39D4  48 00 00 90 */	b lbl_803A6B04
-.global lbl_803A6A78
 lbl_803A6A78:
 /* 803A6A78 003A39D8  7F E3 FB 78 */	mr r3, r31
 /* 803A6A7C 003A39DC  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A6A80 003A39E0  38 A0 00 04 */	li r5, 4
 /* 803A6A84 003A39E4  4B FF EA 3D */	bl mcmdVarCalculation
 /* 803A6A88 003A39E8  48 00 00 7C */	b lbl_803A6B04
-.global lbl_803A6A8C
 lbl_803A6A8C:
 /* 803A6A8C 003A39EC  80 7C 00 04 */	lwz r3, 4(r28)
 /* 803A6A90 003A39F0  57 40 C6 3F */	rlwinm. r0, r26, 0x18, 0x18, 0x1f
@@ -5083,20 +5012,17 @@ lbl_803A6AC8:
 /* 803A6AD4 003A3A34  7C 60 22 14 */	add r3, r0, r4
 /* 803A6AD8 003A3A38  90 A3 FF C0 */	stw r5, -0x40(r3)
 /* 803A6ADC 003A3A3C  48 00 00 28 */	b lbl_803A6B04
-.global lbl_803A6AE0
 lbl_803A6AE0:
 /* 803A6AE0 003A3A40  7F E3 FB 78 */	mr r3, r31
 /* 803A6AE4 003A3A44  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A6AE8 003A3A48  38 A0 00 00 */	li r5, 0
 /* 803A6AEC 003A3A4C  4B FF EB F5 */	bl mcmdIfVarCompare
 /* 803A6AF0 003A3A50  48 00 00 14 */	b lbl_803A6B04
-.global lbl_803A6AF4
 lbl_803A6AF4:
 /* 803A6AF4 003A3A54  7F E3 FB 78 */	mr r3, r31
 /* 803A6AF8 003A3A58  38 8D AE E0 */	addi r4, r13, "cstep$1643"@sda21
 /* 803A6AFC 003A3A5C  38 A0 00 01 */	li r5, 1
 /* 803A6B00 003A3A60  4B FF EB E1 */	bl mcmdIfVarCompare
-.global lbl_803A6B04
 lbl_803A6B04:
 /* 803A6B04 003A3A64  28 1E 00 00 */	cmplwi r30, 0
 /* 803A6B08 003A3A68  41 82 F3 30 */	beq lbl_803A5E38

configure.py

@@ -920,9 +920,9 @@ LIBS = [
     {
         "lib": "musyx",
         #"mw_version": "1.2.5",
-        #"cflags": "-proc gecko -fp hard -nodefaults -nosyspath -i include -i libc -g -sym on -D_DEBUG=1 -enum int ",
+        #"cflags": "-proc gecko -fp hard -nodefaults -nosyspath -i include -i libc -g -sym on -D_DEBUG=1 -enum int -DMUSY_VERSION_MAJOR=1 -DMUSY_VERSION_MINOR=5 -DMUSY_VERSION_PATCH=3",
         "mw_version": "1.3.2",
-        "cflags": "$cflags_musyx",
+        "cflags": "$cflags_musyx -DMUSY_VERSION_MAJOR=1 -DMUSY_VERSION_MINOR=5 -DMUSY_VERSION_PATCH=4",
         "host": False,
         "objects": [
             "musyx/runtime/seq",
@@ -951,7 +951,7 @@ LIBS = [
             ["musyx/runtime/hw_dolphin", True],
             ["musyx/runtime/hw_memory", True],
             ["musyx/runtime/CheapReverb/creverb_fx", True],
-            "musyx/runtime/CheapReverb/creverb",
+            ["musyx/runtime/CheapReverb/creverb", False],
             ["musyx/runtime/StdReverb/reverb_fx", True],
             ["musyx/runtime/StdReverb/reverb", False],
             ["musyx/runtime/Delay/delay_fx", True],

include/musyx/assert.h

@@ -4,29 +4,42 @@
 extern void OSPanic(const char* file, int line, const char* msg, ...);
 extern void OSReport(const char* msg, ...);
 
+static inline unsigned  __SOME_ASSERT_DERP1() {
+  return 0;
+}
+
+static inline unsigned __SOME_ASSERT_DERP2() {
+  return __SOME_ASSERT_DERP1();
+}
+
+static inline void __SOME_ASSERT_DERP() {
+    __SOME_ASSERT_DERP2() != 0;
+}
+
 #ifndef ASSERT
 #ifdef _DEBUG
-#define ASSERT(cond) \
+#define MUSY_ASSERT(cond) \
   do { \
     if (!(cond)) { \
       OSPanic(__FILE__, __LINE__, "Failed assertion " #cond); \
     } \
+    __SOME_ASSERT_DERP(); \
   } while(0)
 #else
-#define ASSERT(cond)
+#define MUSY_ASSERT(cond)
 #endif
 #endif
 
-#ifndef ASSERT_MSG
+#ifndef MUSY_ASSERT_MSG
 #ifdef _DEBUG
-#define ASSERT_MSG(cond, msg) \
+#define MUSY_ASSERT_MSG(cond, msg) \
   do { \
     if (!(cond)) { \
       OSPanic(__FILE__, __LINE__, msg); \
     } \
   } while(0)
 #else
-#define ASSERT_MSG(cond, msg)
+#define MUSY_ASSERT_MSG(cond, msg)
 #endif
 #endif
 

include/musyx/musyx.h

@@ -1,6 +1,8 @@
 #ifndef _MUSYX_MUSYX
 #define _MUSYX_MUSYX
 
+#include "musyx/version.h"
+
 #include <math.h>
 
 #ifdef __cplusplus

include/musyx/musyx_priv.h

@@ -1,6 +1,7 @@
 #ifndef _MUSYX_MUSYX_PRIV
 #define _MUSYX_MUSYX_PRIV
 
+#include "musyx/assert.h"
 #include "musyx/musyx.h"
 
 #ifdef __cplusplus
@@ -857,6 +858,7 @@ u32 dataRemoveMacro(u16 mid);
 u32 dataInsertCurve(u16 cid, void* curvedata);
 u32 dataRemoveCurve(u16 sid);
 long dataGetSample(u16 sid, SAMPLE_INFO* newsmp);
+void* dataGetCurve(u16 cid);
 u32 dataAddSampleReference(u16 sid);
 u32 dataRemoveSampleReference(u16 sid);
 u32 dataInsertKeymap(u16 cid, void* keymapdata);
@@ -884,14 +886,16 @@ void s3dKillEmitterByFXID(FX_TAB* fxTab, unsigned long num);
 void s3dExit();
 void synthInit(u32, u8); /* extern */
 void synthFXCloneMidiSetup(SYNTH_VOICE* dest, SYNTH_VOICE* src);
+
 extern u32 synthGlobalVariable[16];
-extern s16 voicePrioSortRootListRoot;
+extern u16 voicePrioSortRootListRoot;
 extern u8 voiceMusicRunning;
 extern u8 voiceFxRunning;
 extern u8 voiceListInsert;
 extern u8 voiceListRoot;
 void voiceSetPriority(struct SYNTH_VOICE* svoice, unsigned char prio);
 u32 voiceIsLastStarted(struct SYNTH_VOICE* svoice);
+s32 voiceKillSound(u32 voiceid);
 
 u32 synthGetTicksPerSecond(SYNTH_VOICE* svoice);
 void synthKillVoicesByMacroReferences(u16* ref);
@@ -916,6 +920,7 @@ typedef s32 (*SND_MESSAGE_CALLBACK)(u32, u32);
 typedef void (*SND_SOME_CALLBACK)();
 
 extern SND_MESSAGE_CALLBACK salMessageCallback;
+extern SND_MESSAGE_CALLBACK synthMessageCallback;
 /* Math */
 void salApplyMatrix(const SND_FMATRIX* a, const SND_FVECTOR* b, SND_FVECTOR* out);
 float salNormalizeVector(SND_FVECTOR* vec);
@@ -960,8 +965,13 @@ typedef struct SND_STREAM_INFO {
 } SND_STREAM_INFO;
 
 void streamOutputModeChanged();
-void inpSetExCtrl(struct SYNTH_VOICE* svoice, unsigned char ctrl, signed short v);
+void inpSetGlobalMIDIDirtyFlag(u8 chan, u8 midiSet, s32 flag);
+void inpAddCtrl(struct CTRL_DEST* dest, unsigned char ctrl, long scale, unsigned char comb,
+                unsigned long isVar);
+void inpSetExCtrl(SYNTH_VOICE* svoice, unsigned char ctrl, signed short v);
 CHANNEL_DEFAULTS* inpGetChannelDefaults(unsigned char midi, unsigned char midiSet);
+extern CTRL_DEST inpAuxA[8][4];
+extern CTRL_DEST inpAuxB[8][4];
 void inpSetMidiLastNote(u8 midi, u8 midiSet, u8 key);
 u8 inpGetMidiLastNote(u8 midi, u8 midiSet);
 unsigned short inpGetExCtrl(SYNTH_VOICE* svoice, unsigned char ctrl);

include/musyx/synth.h

@@ -18,7 +18,7 @@ extern void* synthAuxBUser[8];
 extern u8 synthITDDefault[16];
 extern u32 synthFlags;
 
-s32 vidGetInternalId(SND_VOICEID id);
+u32 vidGetInternalId(SND_VOICEID id);
 bool synthFXSetCtrl(SND_VOICEID vid, u8 ctrl, u8 value);
 bool synthFXSetCtrl14(SND_VOICEID vid, u8 ctrl, u16 value);
 bool synthSendKeyOff(SND_VOICEID vid);

include/musyx/version.h

@@ -0,0 +1,26 @@
+#ifndef _MUSYX_VERSION
+#define _MUSYX_VERSION
+
+
+#ifndef MUSY_VERSION_CHECK
+#define MUSY_VERSION_CHECK(major, minor, patch) ((major << 16) | (minor << 8) | (patch))
+#endif
+
+#ifndef MUSY_VERSION_MAJOR
+#define MUSY_VERSION_MAJOR 1
+#endif
+
+#ifndef MUSY_VERSION_MINOR
+#define MUSY_VERSION_MINOR 5
+#endif
+
+#ifndef MUSY_VERSION_PATCH
+#define MUSY_VERSION_PATCH 3
+#endif
+
+
+#ifndef MUSY_VERSION
+#define MUSY_VERSION MUSY_VERSION_CHECK(MUSY_VERSION_MAJOR, MUSY_VERSION_MINOR, MUSY_VERSION_PATCH)
+#endif
+
+#endif // _MUSYX_VERSION

libc/math.h

@@ -160,7 +160,7 @@ static inline int __fpclassifyd(double x) {
 #define isinf(x) (fpclassify(x) == FP_INFINITE)
 #define isfinite(x) ((fpclassify(x) > FP_INFINITE))
 
-static float sqrtf(float x) {
+static inline float sqrtf(float x) {
   const double _half = .5;
   const double _three = 3.0;
   volatile float y;
@@ -179,7 +179,7 @@ static float sqrtf(float x) {
   return x;
 }
 
-static double sqrt(double x) {
+static inline double sqrt(double x) {
   if (x > 0.0) {
     double guess = __frsqrte(x);                    /* returns an approximation to  */
     guess = .5 * guess * (3.0 - guess * guess * x); /* now have 8 sig bits          */

src/musyx/runtime/CheapReverb/creverb.c

@@ -0,0 +1,31 @@
+/* ---------------------------------------
+
+
+
+
+
+
+
+
+   ---------------------------------------
+*/
+#include "musyx/musyx_priv.h"
+
+static void DLsetdelay(_SND_REVSTD_DELAYLINE * dl, s32 lag) {
+  dl->outPoint = dl->inPoint - (lag * sizeof(f32));
+  while (dl->outPoint < 0) {
+    dl->outPoint += dl->length;
+  }
+}
+
+static void DLcreate(_SND_REVSTD_DELAYLINE* dl, s32 len) {
+  dl->length = len * sizeof(f32);
+  dl->inputs = (f32*)salMalloc(len * sizeof(f32));
+  memset(dl->inputs, 0, len * sizeof(len));
+  dl->lastOutput = 0.f;
+  DLsetdelay(dl, len >> 1);
+  dl->inPoint = 0;
+  dl->outPoint = 0;
+}
+
+static void DLdelete(_SND_REVSTD_DELAYLINE* dl) { salFree(dl->inputs); }

src/musyx/runtime/CheapReverb/creverb_fx.c

@@ -1,26 +1,46 @@
+/* ---------------------------------------
+
+
+
+
+
+
+
+
+   ---------------------------------------
+*/
+
 #include "musyx/musyx_priv.h"
 
 extern bool ReverbSTDCreate(_SND_REVSTD_WORK* rv, f32 coloration, f32 time, f32 mix, f32 damping,
                             f32 preDelay);
 extern void ReverbHIFree(_SND_REVSTD_WORK* rev);
 extern void ReverbSTDCallback(s32* left, s32* right, s32* surround, _SND_REVSTD_WORK* rv);
+extern unsigned long ReverbSTDModify(_SND_REVSTD_WORK* rv, float coloration, float time, float mix,
+                                     float damping, float predelay);
 
 void sndAuxCallbackReverbSTD(u8 reason, SND_AUX_INFO* info, void* user) {
-  SND_AUX_REVERBSTD* rev;
   switch (reason) {
   case SND_AUX_REASON_BUFFERUPDATE:
-    rev = (SND_AUX_REVERBSTD*)user;
+    if ((u8)((SND_AUX_REVERBSTD*)user)->tempDisableFX == 0) {
-    if ((u8)rev->tempDisableFX == 0) {
       ReverbSTDCallback(info->data.bufferUpdate.left, info->data.bufferUpdate.right,
-                        info->data.bufferUpdate.surround, &rev->rv);
+                        info->data.bufferUpdate.surround, &((SND_AUX_REVERBSTD*)user)->rv);
     }
+    break;
   case SND_AUX_REASON_PARAMETERUPDATE:
+    // UNIMPLEMENTED
     break;
   default:
-    // ASSERT_MSG(FALSE);
+    MUSY_ASSERT(FALSE);
     break;
   }
 }
+bool sndAuxCallbackUpdateSettingsReverbSTD(SND_AUX_REVERBSTD* rev) {
+  rev->tempDisableFX = TRUE;
+  ReverbSTDModify(&rev->rv, rev->coloration, rev->time, rev->mix, rev->damping, rev->preDelay);
+  rev->tempDisableFX = FALSE;
+  return TRUE;
+}
 
 bool sndAuxCallbackPrepareReverbSTD(SND_AUX_REVERBSTD* rev) {
   rev->tempDisableFX = 0;
@@ -31,5 +51,3 @@ bool sndAuxCallbackShutdownReverbSTD(SND_AUX_REVERBSTD* rev) {
   ReverbSTDFree(&rev->rv);
   return TRUE;
 }
-
-bool sndAuxCallbackUpdateSettingsReverbSTD(SND_AUX_REVERBSTD* rev) { return FALSE; }

src/musyx/runtime/Chorus/chorus_fx.c

@@ -109,363 +109,489 @@ static float rsmpTab12khz[512] = {
 
 const double i2fMagic = 4.503601774854144E15;
 
-#if NONMATCHING
+static asm void do_src1(_SND_CHORUS_SRCINFO* src) {
-void do_src1(_SND_CHORUS_SRCINFO* src) {
+  nofralloc  
-  // TODO: Match this
+
-}
+  stwu r1, -0x40(sp)
-#else
+  stmw r26, 0x28(sp)
-/* clang-format off */
+
-#pragma push
+  
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm void do_src1(_SND_CHORUS_SRCINFO* src) {
-  nofralloc
-  stwu r1, -0x40(r1)
-  stmw r26, 0x28(r1)
   lwz r4, 0xc(r3)
   lwz r5, 0x10(r3)
+
   lwz r6, 0x14(r3)
+
   lwz r8, 0x1c(r3)
   lwz r7, 0x20(r3)
+
   lwz r31, 4(r3)
+  
   lwz r30, 0(r3)
+  
   lwz r9, 8(r3)
+  
   lis r10, 0x4330
-  stw r10, 8(r1)
+  stw r10, 8(sp)
-  stw r10, 0x10(r1)
+  stw r10, 0x10(sp)
-  stw r10, 0x18(r1)
+  stw r10, 0x18(sp)
-  stw r10, 0x20(r1)
+  stw r10, 0x20(sp)
+  
   lis r10, i2fMagic@ha
   lfd f9, i2fMagic@l(r10)
+  
   slwi r10, r5, 2
   lwz r11, 0(r9)
+  
   lwz r29, 4(r9)
-  lwz r28, 8(r9)
+  lwz r28, 8(r9)  
   lwzx r27, r31, r10
+
   xoris r11, r11, 0x8000
-  xoris r29, r29, 0x8000
+  xoris r29, r29, 0x8000  
-  stw r11, 0xc(r1)
+  stw r11, 0xc(sp)
   xoris r28, r28, 0x8000
-  stw r29, 0x14(r1)
+  stw r29, 0x14(sp)
   xoris r27, r27, 0x8000
-  stw r28, 0x1c(r1)
+  stw r28, 0x1c(sp)
-  lfd f1, 8(r1)
+  lfd f1, 8(sp)
-  stw r27, 0x24(r1)
+  stw r27, 0x24(sp)
-  lfd f2, 0x10(r1)
+  lfd f2, 0x10(sp)  
   fsubs f1, f1, f9
-  lfd f3, 0x18(r1)
+  lfd f3, 0x18(sp)
   fsubs f2, f2, f9
-  lfd f4, 0x20(r1)
+  lfd f4, 0x20(sp)
   fsubs f3, f3, f9
   fsubs f4, f4, f9
+  
   li r26, -4
+  
   lis r12, rsmpTab12khz@ha
   addi r12, r12, rsmpTab12khz@l
+  
   li r9, 0xa0
   mtctr r9
 lbl_803B6D5C:
   rlwinm r10, r4, 7, 0x15, 0x1b
+
   addc r4, r4, r6
+
   add r10, r10, r12
+  
   mcrxr cr0
+
   lfs f5, 0(r10)
+
   beq lbl_803B6DA4
+
   lfs f6, 4(r10)
+
   fmuls f10, f1, f5
+
   lfs f7, 8(r10)
+  
   fmadds f10, f2, f6, f10
+  
   lfs f8, 0xc(r10)
+
   fmadds f10, f3, f7, f10
+
   addi r30, r30, 4
+
   fmadds f10, f4, f8, f10
+
   fctiwz f10, f10
+
   stfiwx f10, r26, r30
+
   bdnz lbl_803B6D5C
+  
   b lbl_803B6E10
+
+
 lbl_803B6DA4:
   addi r5, r5, 1
+
   lfs f6, 4(r10)
+  
   fmuls f10, f1, f5
+  
   cmpw r5, r8
+  
   fmr f1, f2
+  
   lfs f7, 8(r10)
+  
   fmadds f10, f2, f6, f10
+  
   fmr f2, f3
+  
   lfs f8, 0xc(r10)
+  
   fmadds f10, f3, f7, f10
+  
   addi r30, r30, 4
+  
   fmr f3, f4
+  
   bne+ lbl_803B6DDC
   mr r5, r7
+  
 lbl_803B6DDC:
   fmadds f10, f4, f8, f10
+
   slwi r9, r5, 2
+
   bdz lbl_803B6E08
+
   lwzx r10, r9, r31
+  
   fctiwz f10, f10
+  
   xoris r10, r10, 0x8000
-  stw r10, 0xc(r1)
+  
+  stw r10, 0xc(sp)
+  
   stfiwx f10, r26, r30
-  lfd f4, 8(r1)
+  
+  lfd f4, 8(sp)
+  
   fsubs f4, f4, f9
+  
   b lbl_803B6D5C
+
+
 lbl_803B6E08:
   fctiwz f10, f10
   stfiwx f10, r26, r30
+
+
 lbl_803B6E10:
   lwz r9, 8(r3)
+  
   fctiwz f1, f1
   fctiwz f2, f2
   fctiwz f3, f3
+  
   stfiwx f1, r0, r9
   addi r10, r9, 4
   stfiwx f2, r0, r10
   addi r10, r9, 8
   stfiwx f3, r0, r10
+  
   stw r4, 0xc(r3)
   stw r5, 0x10(r3)
-  lmw r26, 0x28(r1)
+  
+  lmw r26, 0x28(sp)
   addi r1, r1, 0x40
   blr
 }
-#pragma pop
-/* clang-format on */
-#endif
 
-#if NONMATCHING
-void do_src2(_SND_CHORUS_SRCINFO* src) {
-  // TODO: Match this
-}
-#else
-/* clang-format off */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm void do_src2(_SND_CHORUS_SRCINFO* src) {
-  nofralloc
-  stwu r1, -0x40(r1)
-  stmw r26, 0x28(r1)
-  lwz r4, 0xc(r3)
-  lwz r5, 0x10(r3)
-  lwz r6, 0x14(r3)
-  lwz r8, 0x1c(r3)
-  lwz r7, 0x20(r3)
-  lwz r31, 4(r3)
-  lwz r30, 0(r3)
-  lwz r9, 8(r3)
-  lis r10, 0x4330
-  stw r10, 8(r1)
-  stw r10, 0x10(r1)
-  stw r10, 0x18(r1)
-  stw r10, 0x20(r1)
-  lis r10, i2fMagic@ha
-  lfd f9, i2fMagic@l(r10)
-  slwi r10, r5, 2
-  lwz r11, 0(r9)
-  lwz r29, 4(r9)
-  lwz r28, 8(r9)
-  lwzx r27, r31, r10
-  xoris r11, r11, 0x8000
-  xoris r29, r29, 0x8000
-  stw r11, 0xc(r1)
-  xoris r28, r28, 0x8000
-  stw r29, 0x14(r1)
-  xoris r27, r27, 0x8000
-  stw r28, 0x1c(r1)
-  lfd f1, 8(r1)
-  stw r27, 0x24(r1)
-  lfd f2, 0x10(r1)
-  fsubs f1, f1, f9
-  lfd f3, 0x18(r1)
-  fsubs f2, f2, f9
-  lfd f4, 0x20(r1)
-  fsubs f3, f3, f9
-  fsubs f4, f4, f9
-  li r26, -4
-  lis r12, rsmpTab12khz@ha
-  addi r12, r12, rsmpTab12khz@l
-  li r9, 0xa0
-  mtctr r9
-lbl_803B6EF4:
-  rlwinm r10, r4, 7, 0x15, 0x1b
-  addc r4, r4, r6
-  add r10, r10, r12
-  mcrxr cr0
-  addi r5, r5, 1
-  lfs f5, 0(r10)
-  beq lbl_803B6F70
-  lfs f6, 4(r10)
-  fmuls f10, f1, f5
-  cmpw r5, r8
-  fmr f1, f2
-  lfs f7, 8(r10)
-  fmadds f10, f2, f6, f10
-  fmr f2, f3
-  lfs f8, 0xc(r10)
-  fmadds f10, f3, f7, f10
-  addi r30, r30, 4
-  fmr f3, f4
-  bne+ lbl_803B6F44
-  mr r5, r7
-lbl_803B6F44:
-  fmadds f10, f4, f8, f10
-  slwi r9, r5, 2
-  bdz lbl_803B6FF4
-  lwzx r10, r9, r31
-  fctiwz f10, f10
-  xoris r10, r10, 0x8000
-  stw r10, 0xc(r1)
-  stfiwx f10, r26, r30
-  lfd f4, 8(r1)
-  fsubs f4, f4, f9
-  b lbl_803B6EF4
-lbl_803B6F70:
-  cmpw r5, r8
-  lfs f6, 4(r10)
-  bne+ lbl_803B6F80
-  mr r5, r7
-lbl_803B6F80:
-  slwi r11, r5, 2
-  addi r5, r5, 1
-  lwzx r29, r11, r31
-  fmuls f10, f1, f5
-  cmpw r5, r8
-  xoris r29, r29, 0x8000
-  fmr f1, f3
-  lfs f7, 8(r10)
-  stw r29, 0xc(r1)
-  fmadds f10, f2, f6, f10
-  lfs f8, 0xc(r10)
-  fmadds f10, f3, f7, f10
-  lfd f3, 8(r1)
-  fmr f2, f4
-  addi r30, r30, 4
-  fsubs f3, f3, f9
-  bne+ lbl_803B6FC8
-  mr r5, r7
-lbl_803B6FC8:
-  fmadds f10, f4, f8, f10
-  slwi r9, r5, 2
-  bdz lbl_803B6FF4
-  lwzx r10, r9, r31
-  fctiwz f10, f10
-  xoris r10, r10, 0x8000
-  stw r10, 0xc(r1)
-  stfiwx f10, r26, r30
-  lfd f4, 8(r1)
-  fsubs f4, f4, f9
-  b lbl_803B6EF4
-lbl_803B6FF4:
-  fctiwz f10, f10
-  stfiwx f10, r26, r30
-  lwz r9, 8(r3)
-  fctiwz f1, f1
-  fctiwz f2, f2
-  fctiwz f3, f3
-  stfiwx f1, r0, r9
-  addi r10, r9, 4
-  stfiwx f2, r0, r10
-  addi r10, r9, 8
-  stfiwx f3, r0, r10
-  stw r4, 0xc(r3)
-  stw r5, 0x10(r3)
-  lmw r26, 0x28(r1)
-  addi r1, r1, 0x40
-  blr
-}
-#pragma pop
 /* clang-format on */
-#endif
+
+static asm void do_src2(register _SND_CHORUS_SRCINFO* src) {
+#define posLoV r4
+#define posHiV r5
+#define pitchLoV r6
+#define triggerV r8
+#define targetV r7
+#define oldPtr r9
+#define destPtr r30
+#define smpBasePtr r31
+
+  nofralloc;
+  /* Save stack state to stack */
+  stwu r1, -0x40(sp);
+  stmw r26, 0x28(sp);
+
+  lwz posLoV, src->posLo;
+  lwz posHiV, src->posHi;
+
+  lwz pitchLoV, src->pitchLo;
+
+  lwz triggerV, src->trigger;
+  lwz targetV, src->target;
+
+  lwz smpBasePtr, src->smpBase;
+
+  lwz destPtr, src->dest;
+
+  lwz oldPtr, src->old;
+  /* Store upper portion of int->float conversion constant */
+  lis r10, 0x4330;
+  stw r10, 0x08(sp);
+  stw r10, 0x10(sp);
+  stw r10, 0x18(sp);
+  stw r10, 0x20(sp);
+
+  lis r10, i2fMagic @ha;
+  lfd f9, i2fMagic @l(r10);
+
+  // posHi * 4
+  slwi r10, posHiV, 2;
+  lwz r11, 0(oldPtr);
+  lwz r29, 4(oldPtr);
+  lwz r28, 8(oldPtr);
+  lwzx r27, smpBasePtr, r10;
+
+  xoris r11, r11, 0x8000;
+  xoris r29, r29, 0x8000;
+  stw r11, 0xc(sp);
+  xoris r28, r28, 0x8000;
+  stw r29, 0x14(sp);
+  xoris r27, r27, 0x8000;
+  stw r28, 0x1c(sp);
+  lfd f1, 0x08(sp);
+  stw r27, 0x24(sp);
+  lfd f2, 0x10(sp);
+  fsubs f1, f1, f9;
+  lfd f3, 0x18(sp);
+  fsubs f2, f2, f9;
+  lfd f4, 0x20(sp);
+  fsubs f3, f3, f9;
+  fsubs f4, f4, f9;
+  /* Some offset? */
+  li r26, -4;
+
+  lis r12, rsmpTab12khz @ha;
+  addi r12, r12, rsmpTab12khz @l;
+
+  li r9, 0xa0;
+  mtctr r9;
+lbl_803B6EF4:
+  rlwinm r10, posLoV, 7, 0x15, 0x1b;
+
+  addc posLoV, posLoV, pitchLoV;
+
+  add r10, r10, r12;
+
+  mcrxr cr0;
+
+  addi posHiV, posHiV, 1;
+
+  lfs f5, 0(r10);
+
+  beq lbl_803B6F70;
+
+  lfs f6, 4(r10);
+
+  fmuls f10, f1, f5;
+
+  cmpw posHiV, triggerV;
+
+  fmr f1, f2;
+
+  lfs f7, 8(r10);
+
+  fmadds f10, f2, f6, f10;
+
+  fmr f2, f3;
+
+  lfs f8, 0xc(r10);
+
+  fmadds f10, f3, f7, f10;
+
+  addi destPtr, destPtr, 4;
+
+  fmr f3, f4;
+
+  bne + lbl_803B6F44;
+  mr posHiV, targetV;
+
+lbl_803B6F44:
+  fmadds f10, f4, f8, f10;
+
+  slwi r9, posHiV, 2;
+
+  bdz lbl_803B6FF4;
+
+  lwzx r10, r9, smpBasePtr;
+
+  fctiwz f10, f10;
+
+  xoris r10, r10, 0x8000;
+
+  stw r10, 0xc(sp);
+
+  stfiwx f10, r26, destPtr;
+
+  lfd f4, 8(sp);
+
+  fsubs f4, f4, f9;
+
+  b lbl_803B6EF4;
+
+lbl_803B6F70:
+
+  cmpw posHiV, triggerV;
+
+  lfs f6, 4(r10);
+
+  bne + lbl_803B6F80;
+  mr posHiV, targetV;
+
+lbl_803B6F80:
+
+  slwi r11, posHiV, 2;
+  addi posHiV, posHiV, 1;
+
+  lwzx r29, r11, smpBasePtr;
+
+  fmuls f10, f1, f5;
+
+  cmpw posHiV, triggerV;
+  xoris r29, r29, 0x8000;
+
+  fmr f1, f3;
+
+  lfs f7, 8(r10);
+
+  stw r29, 0xc(sp);
+
+  fmadds f10, f2, f6, f10;
+
+  lfs f8, 0xc(r10);
+
+  fmadds f10, f3, f7, f10;
+
+  lfd f3, 8(sp);
+
+  fmr f2, f4;
+
+  addi destPtr, destPtr, 4;
+
+  fsubs f3, f3, f9;
+
+  bne + lbl_803B6FC8;
+  mr posHiV, targetV;
+
+lbl_803B6FC8:
+
+  fmadds f10, f4, f8, f10;
+
+  slwi r9, posHiV, 2;
+
+  bdz lbl_803B6FF4;
+
+  lwzx r10, r9, smpBasePtr;
+
+  fctiwz f10, f10;
+
+  xoris r10, r10, 0x8000;
+
+  stw r10, 0xc(sp);
+
+  stfiwx f10, r26, destPtr;
+  lfd f4, 8(sp);
+  fsubs f4, f4, f9;
+
+  b lbl_803B6EF4;
+
+lbl_803B6FF4:
+
+  fctiwz f10, f10;
+  stfiwx f10, r26, destPtr;
+
+  lwz r9, 8(r3);
+
+  fctiwz f1, f1;
+  fctiwz f2, f2;
+  fctiwz f3, f3;
+  stfiwx f1, r0, r9;
+  addi r10, r9, 4;
+  stfiwx f2, r0, r10;
+  addi r10, r9, 8;
+  stfiwx f3, r0, r10;
+
+  stw posLoV, src->posLo;
+  stw posHiV, src->posHi;
+
+  /* Pop and restore LR to original values */
+  lmw r26, 0x28(sp);
+  addi r1, r1, 0x40;
+  blr;
+
+#undef posLoV
+#undef posHiV
+#undef pitchLoV
+#undef triggerV
+#undef targetV
+#undef oldPtr
+#undef destPtr
+#undef smpBasePtr
+}
 
 void sndAuxCallbackChorus(u8 reason, SND_AUX_INFO* info, void* user) {
-  SND_AUX_CHORUS* chorus;
+  SND_AUX_CHORUS* c;
-  u8 currLast;
+  s32 *leftD, *rightD, *surD, *leftS, *rightS, *surS;
-  s32* lastLeft;
-  s32* lastRight;
-  s32* lastSur;
-  s32* left;
-  s32* right;
-  s32* sur;
   u32 i;
-  s32 tmp;
+  u8 nextCurrentLast;
-
   switch (reason) {
   case SND_AUX_REASON_BUFFERUPDATE:
-    chorus = (SND_AUX_CHORUS*)user;
+    c = (SND_AUX_CHORUS*)user;
-    currLast = (chorus->work.currentLast + 1) % 3;
+    nextCurrentLast = (c->work.currentLast + 1) % 3;
-    lastLeft = chorus->work.lastLeft[currLast];
+    leftD = c->work.lastLeft[nextCurrentLast];
-    lastRight = chorus->work.lastRight[currLast];
+    rightD = c->work.lastRight[nextCurrentLast];
-    lastSur = chorus->work.lastSur[currLast];
+    surD = c->work.lastSur[nextCurrentLast];
-    left = info->data.bufferUpdate.left;
+    leftS = info->data.bufferUpdate.left;
-    right = info->data.bufferUpdate.right;
+    rightS = info->data.bufferUpdate.right;
-    sur = info->data.bufferUpdate.surround;
+    surS = info->data.bufferUpdate.surround;
 
     for (i = 0; i < 160; ++i) {
-      int tmp = *left;
+      *leftD = *leftS++;
-      ++left;
+      leftD++;
-      *lastLeft = tmp;
+      *rightD = *rightS++;
-      ++lastLeft;
+      rightD++;
-
+      *surD = *surS++;
-      tmp = *right;
+      surD++;
-      ++right;
-      *lastRight = tmp;
-      ++lastRight;
-
-      tmp = *sur;
-      ++sur;
-      *lastSur = tmp;
-      ++lastSur;
     }
 
-    chorus->work.src.pitchHi = (chorus->work.pitchOffset >> 0x10) + 1;
+    c->work.src.pitchHi = (c->work.pitchOffset >> 0x10) + 1;
-    chorus->work.src.pitchLo = (chorus->work.pitchOffset << 0x10);
+    c->work.src.pitchLo = ((c->work.pitchOffset & 0xFFFF) << 16);
-
+    if (--c->work.pitchOffsetPeriodCount == 0) {
-    tmp = chorus->work.pitchOffsetPeriodCount - 1;
+      c->work.pitchOffsetPeriodCount = c->work.pitchOffsetPeriod;
-    chorus->work.pitchOffsetPeriodCount = tmp;
+      c->work.pitchOffset = -c->work.pitchOffset;
-    if (tmp == 0) {
-      chorus->work.pitchOffsetPeriodCount = chorus->work.pitchOffsetPeriod;
-      chorus->work.pitchOffset = -chorus->work.pitchOffset;
     }
 
     for (i = 0; i < 3; ++i) {
-      chorus->work.src.posHi = chorus->work.currentPosHi;
+      c->work.src.posHi = c->work.currentPosHi;
-      chorus->work.src.posLo = chorus->work.currentPosLo;
+      c->work.src.posLo = c->work.currentPosLo;
       switch (i) {
       case 0:
-        chorus->work.src.smpBase = chorus->work.lastLeft[0];
+        c->work.src.smpBase = c->work.lastLeft[0];
-        chorus->work.src.dest = info->data.bufferUpdate.left;
+        c->work.src.dest = info->data.bufferUpdate.left;
-        chorus->work.src.old = chorus->work.oldLeft;
+        c->work.src.old = c->work.oldLeft;
         break;
       case 1:
-        chorus->work.src.smpBase = chorus->work.lastRight[0];
+        c->work.src.smpBase = c->work.lastRight[0];
-        chorus->work.src.dest = info->data.bufferUpdate.right;
+        c->work.src.dest = info->data.bufferUpdate.right;
-        chorus->work.src.old = chorus->work.oldRight;
+        c->work.src.old = c->work.oldRight;
         break;
       case 2:
-        chorus->work.src.smpBase = chorus->work.lastSur[0];
+        c->work.src.smpBase = c->work.lastSur[0];
-        chorus->work.src.dest = info->data.bufferUpdate.surround;
+        c->work.src.dest = info->data.bufferUpdate.surround;
-        chorus->work.src.old = chorus->work.oldSur;
+        c->work.src.old = c->work.oldSur;
         break;
       }
 
-      switch (chorus->work.src.pitchHi) {
+      switch (c->work.src.pitchHi) {
       case 0:
-        do_src1(&chorus->work.src);
+        do_src1(&c->work.src);
         break;
       case 1:
-        do_src2(&chorus->work.src);
+        do_src2(&c->work.src);
         break;
       }
     }
 
-    chorus->work.currentPosHi = chorus->work.src.posHi % 480;
+    c->work.currentPosHi = c->work.src.posHi % 480;
-    chorus->work.currentPosLo = chorus->work.src.posLo;
+    c->work.currentPosLo = c->work.src.posLo;
-    chorus->work.currentLast = currLast;
+    c->work.currentLast = nextCurrentLast;
     break;
   case SND_AUX_REASON_PARAMETERUPDATE:
     break;
   default:
-    ASSERT(FALSE);
+  #line 957
+    MUSY_ASSERT(FALSE);
     break;
   }
 }
@@ -482,7 +608,6 @@ bool sndAuxCallbackUpdateSettingsChorus(SND_AUX_CHORUS* ch) {
 
 bool sndAuxCallbackPrepareChorus(SND_AUX_CHORUS* chorus) {
   u32 i;
-  bool ret;
   s32* lastLeft;
   s32* lastRight;
   s32* lastSur;
@@ -493,7 +618,7 @@ bool sndAuxCallbackPrepareChorus(SND_AUX_CHORUS* chorus) {
     chorus->work.lastRight[0] = chorus->work.lastLeft[0] + 0x1e0;
     chorus->work.lastSur[0] = chorus->work.lastRight[0] + 0x1e0;
 
-    for (i = 0; i < 3; ++i) {
+    for (i = 1; i < 3; ++i) {
       chorus->work.lastLeft[i] = chorus->work.lastLeft[0] + i * 0xa0;
       chorus->work.lastRight[i] = chorus->work.lastRight[0] + i * 0xa0;
       chorus->work.lastSur[i] = chorus->work.lastSur[0] + i * 0xa0;
@@ -503,35 +628,20 @@ bool sndAuxCallbackPrepareChorus(SND_AUX_CHORUS* chorus) {
     lastRight = chorus->work.lastRight[0];
     lastSur = chorus->work.lastSur[0];
     for (i = 0; i < 0x140; i += 1) {
-      *lastLeft = 0;
+      *lastLeft++ = 0;
-      ++lastLeft;
+      *lastRight++ = 0;
-      *lastRight = 0;
+      *lastSur++ = 0;
-      ++lastRight;
-      *lastSur = 0;
-      ++lastSur;
     }
 
     chorus->work.currentLast = 1;
-    chorus->work.oldLeft[3] = 0;
+    chorus->work.oldLeft[0] = chorus->work.oldLeft[1] = chorus->work.oldLeft[2] = chorus->work.oldLeft[3] = 0;
-    chorus->work.oldLeft[2] = 0;
+    chorus->work.oldRight[0] = chorus->work.oldRight[1] = chorus->work.oldRight[2] = chorus->work.oldRight[3] = 0;
-    chorus->work.oldLeft[1] = 0;
+    chorus->work.oldSur[0] = chorus->work.oldSur[1] = chorus->work.oldSur[2] = chorus->work.oldSur[3] = 0;
-    chorus->work.oldLeft[0] = 0;
-    chorus->work.oldRight[3] = 0;
-    chorus->work.oldRight[2] = 0;
-    chorus->work.oldRight[1] = 0;
-    chorus->work.oldRight[0] = 0;
-    chorus->work.oldSur[3] = 0;
-    chorus->work.oldSur[2] = 0;
-    chorus->work.oldSur[1] = 0;
-    chorus->work.oldSur[0] = 0;
-
     chorus->work.src.trigger = 480;
     chorus->work.src.target = 0;
-    ret = sndAuxCallbackUpdateSettingsChorus(chorus);
+    return sndAuxCallbackUpdateSettingsChorus(chorus);
-  } else {
-    ret = FALSE;
   }
-  return ret;
+  return FALSE;
 }
 
 bool sndAuxCallbackShutdownChorus(SND_AUX_CHORUS* ch) {

src/musyx/runtime/Delay/delay_fx.c

@@ -12,56 +12,56 @@
 #include "musyx/musyx_priv.h"
 
 void sndAuxCallbackDelay(u8 reason, SND_AUX_INFO* info, void* user) {
-  s32 curSur;
+  long l;                  // r30
-  s32 curLeft;
+  long r;                  // r29
-  s32 curRight;
+  long s;                  // r28
-  s32 i;
+  long* lBuf;              // r27
-  s32* leftOffset;
+  long* rBuf;              // r26
-  s32* surOffset;
+  long* sBuf;              // r25
-  s32* rightOffset;
+  unsigned long i;         // r24
-  s32* leftPtr;
+  struct SND_AUX_DELAY* c; // r31
-  s32* rightPtr;
+  long* left;              // r23
-  s32* surPtr;
+  long* right;             // r22
-  SND_AUX_DELAY* delay;
+  long* sur;               // r21
+
   switch (reason) {
   case SND_AUX_REASON_BUFFERUPDATE:
-    delay = (SND_AUX_DELAY*)user;
+    c = (SND_AUX_DELAY*)user;
-    leftOffset = delay->left + (delay->currentPos[0] * 160);
+    left = info->data.bufferUpdate.left;
-    leftPtr = info->data.bufferUpdate.left;
+    right = info->data.bufferUpdate.right;
-    rightPtr = info->data.bufferUpdate.right;
+    sur = info->data.bufferUpdate.surround;
-    rightOffset = delay->right + (delay->currentPos[1] * 160);
+    lBuf = c->left + (c->currentPos[0] * 160);
-    surPtr = info->data.bufferUpdate.surround;
+    rBuf = c->right + (c->currentPos[1] * 160);
-    surOffset = delay->sur + (delay->currentPos[2] * 160);
+    sBuf = c->sur + (c->currentPos[2] * 160);
-    for (i = 160; i > 0; --i) {
+    for (i = 0; i < 160; ++i) {
-      curLeft = *leftOffset;
+
-      curRight = *rightOffset;
+      l = *lBuf;
-      curSur = *surOffset;
+      r = *rBuf;
-      *leftOffset = *leftPtr + ((s32)(curLeft * delay->currentFeedback[0]) >> 7);
+      s = *sBuf;
-      ++leftOffset;
+
-      *rightOffset = *rightPtr + ((s32)(curRight * delay->currentFeedback[1]) >> 7);
+      *lBuf++ = *left + ((s32)(l * c->currentFeedback[0]) >> 7);
-      ++rightOffset;
+      *rBuf++ = *right + ((s32)(r * c->currentFeedback[1]) >> 7);
-      *surOffset = *surPtr + ((s32)(curSur * delay->currentFeedback[2]) >> 7);
+      *sBuf++ = *sur + ((s32)(s * c->currentFeedback[2]) >> 7);
-      ++surOffset;
+
-      *leftPtr = (s32)(curLeft * delay->currentOutput[0]) >> 7;
+      *left++ = (s32)(l * c->currentOutput[0]) >> 7;
-      ++leftPtr;
+      *right++ = (s32)(r * c->currentOutput[1]) >> 7;
-      *rightPtr = (s32)(curRight * delay->currentOutput[1]) >> 7;
+      *sur++ = (s32)(s * c->currentOutput[2]) >> 7;
-      ++rightPtr;
-      *surPtr = (s32)(curSur * delay->currentOutput[2]) >> 7;
-      ++surPtr;
     }
-    delay->currentPos[0] = (delay->currentPos[0] + 1) % delay->currentSize[0];
+
-    delay->currentPos[1] = (delay->currentPos[1] + 1) % delay->currentSize[1];
+    c->currentPos[0] = (c->currentPos[0] + 1) % c->currentSize[0];
-    delay->currentPos[2] = (delay->currentPos[2] + 1) % delay->currentSize[2];
+    c->currentPos[1] = (c->currentPos[1] + 1) % c->currentSize[1];
+    c->currentPos[2] = (c->currentPos[2] + 1) % c->currentSize[2];
+    break;
   case SND_AUX_REASON_PARAMETERUPDATE:
     break;
   default:
-    // ASSERT_MSG(FALSE);
+    MUSY_ASSERT(FALSE);
     break;
   }
 }
 
 bool sndAuxCallbackUpdateSettingsDelay(SND_AUX_DELAY* delay) {
-  s32 i;
+  u32 i;
   s32* left;
   s32* right;
   s32* sur;
@@ -77,25 +77,25 @@ bool sndAuxCallbackUpdateSettingsDelay(SND_AUX_DELAY* delay) {
   delay->left = (s32*)salMalloc(delay->currentSize[0] * 160 * 4);
   delay->right = (s32*)salMalloc(delay->currentSize[1] * 160 * 4);
   delay->sur = (s32*)salMalloc(delay->currentSize[2] * 160 * 4);
+
+  /* clang-format off */
+  MUSY_ASSERT(delay->left!=NULL);
+  MUSY_ASSERT(delay->right!=NULL);
+  MUSY_ASSERT(delay->sur!=NULL);
+  /* clang-format on */
   left = delay->left;
   right = delay->right;
   sur = delay->sur;
-  // ASSERT_MSG(delay->left!=NULL);
-  // ASSERT_MSG(delay->right!=NULL);
-  // ASSERT_MSG(delay->sur!=NULL);
 
   for (i = 0; i < delay->currentSize[0] * 160; ++i) {
-    *left = 0;
+    *left++ = 0;
-    ++left;
   }
 
   for (i = 0; i < delay->currentSize[1] * 160; ++i) {
-    *right = 0;
+    *right++ = 0;
-    ++right;
   }
   for (i = 0; i < delay->currentSize[2] * 160; ++i) {
-    *sur = 0;
+    *sur++ = 0;
-    ++sur;
   }
   return TRUE;
 }

src/musyx/runtime/StdReverb/reverb_fx.c

@@ -26,10 +26,12 @@ void sndAuxCallbackReverbHI(u8 reason, SND_AUX_INFO* info, void* user) {
       ReverbHICallback(info->data.bufferUpdate.left, info->data.bufferUpdate.right,
                        info->data.bufferUpdate.surround, (SND_AUX_REVERBHI*)user);
     }
+
+    break;
   case SND_AUX_REASON_PARAMETERUPDATE:
     break;
   default:
-    // ASSERT_MSG(FALSE);
+    MUSY_ASSERT(FALSE);
     break;
   }
 }

src/musyx/runtime/hardware.c

@@ -1,4 +1,4 @@
-#include "musyx/assert.h"
+
 #include "musyx/musyx_priv.h"
 
 extern void OSReport(const char*, ...);
@@ -6,15 +6,13 @@ extern void OSReport(const char*, ...);
 extern void DCStoreRange(void* addr, u32 nBytes);
 
 static volatile const u16 itdOffTab[128] = {
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  1,  1,  1,  1,  1,  1,  2,  2,  2,  2,
+    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  1,  1,  1,  1,  1,  1,  2,  2,  2,  2,  2,  3,  3,  3,  3,  3,  4,  4,  4,  4,
-    2,  3,  3,  3,  3,  3,  4,  4,  4,  4,  5,  5,  5,  6,  6,  6,  7,  7,  7,  8,  8,  8,
+    5,  5,  5,  6,  6,  6,  7,  7,  7,  8,  8,  8,  9,  9,  9,  10, 10, 10, 11, 11, 12, 12, 12, 13, 13, 13, 14, 14, 15, 15, 15, 16,
-    9,  9,  9,  10, 10, 10, 11, 11, 12, 12, 12, 13, 13, 13, 14, 14, 15, 15, 15, 16, 16, 17,
+    16, 17, 17, 17, 18, 18, 19, 19, 19, 20, 20, 20, 21, 21, 22, 22, 22, 23, 23, 23, 24, 24, 24, 25, 25, 25, 26, 26, 26, 27, 27, 27,
-    17, 17, 18, 18, 19, 19, 19, 20, 20, 20, 21, 21, 22, 22, 22, 23, 23, 23, 24, 24, 24, 25,
+    28, 28, 28, 28, 29, 29, 29, 29, 29, 30, 30, 30, 30, 30, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
-    25, 25, 26, 26, 26, 27, 27, 27, 28, 28, 28, 28, 29, 29, 29, 29, 29, 30, 30, 30, 30, 30,
-    31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
 };
 
-SND_PROFILE_INFO prof;
+//SND_PROFILE_INFO prof;
 
 u8 salFrame;
 u8 salAuxFrame;
@@ -24,7 +22,7 @@ SND_HOOKS salHooks;
 u8 salTimeOffset;
 void hwSetTimeOffset(u8 offset);
 
-void snd_handle_irq() {
+static void snd_handle_irq() {
   u8 r; // r31
   u8 i; // r30
   u8 v; // r29
@@ -135,13 +133,13 @@ void hwSetTimeOffset(u8 offset) { salTimeOffset = offset; }
 u8 hwGetTimeOffset() { return salTimeOffset; }
 
 u32 hwIsActive(u32 v) { return dspVoice[v].state != 0; }
+u32 hwGlobalActivity() { return 0; }
 
 void hwSetMesgCallback(SND_MESSAGE_CALLBACK callback) { salMessageCallback = callback; }
 
 void hwSetPriority(u32 idx, u32 priority) { dspVoice[idx].prio = priority; }
 
-void hwInitSamplePlayback(u32 v, u16 smpID, void* newsmp, u32 set_defadsr, u32 prio,
+void hwInitSamplePlayback(u32 v, u16 smpID, void* newsmp, u32 set_defadsr, u32 prio, u32 callbackUserValue, u32 setSRC, u8 itdMode) {
-                          u32 callbackUserValue, u32 setSRC, u8 itdMode) {
   unsigned char i;  // r30
   unsigned long bf; // r29
   bf = 0;
@@ -257,8 +255,7 @@ void hwSetPitch(unsigned long v, unsigned short speed) {
     speed = 0x3fff;
   }
 
-  if (dsp_vptr->lastUpdate.pitch != 0xff &&
+  if (dsp_vptr->lastUpdate.pitch != 0xff && dsp_vptr->pitch[dsp_vptr->lastUpdate.pitch] == speed * 16) {
-      dsp_vptr->pitch[dsp_vptr->lastUpdate.pitch] == speed * 16) {
     return;
   }
 
@@ -281,7 +278,7 @@ void hwSetPolyPhaseFilter(unsigned long v, unsigned char salCoefSel) {
   dsp_vptr->changed[0] |= 0x80;
 }
 
-void SetupITD(DSPvoice* dsp_vptr, u8 pan) {
+static void SetupITD(DSPvoice* dsp_vptr, u8 pan) {
   dsp_vptr->itdShiftL = itdOffTab[pan];
   dsp_vptr->itdShiftR = 32 - itdOffTab[pan];
   dsp_vptr->changed[0] |= 0x200;
@@ -299,8 +296,7 @@ void hwSetITDMode(u32 v, u8 mode) {
 
 #define hwGetITDMode(dsp_vptr) (dsp_vptr->flags & 0x80000000)
 
-void hwSetVolume(unsigned long v, unsigned char table, float vol, unsigned long pan,
+void hwSetVolume(unsigned long v, unsigned char table, float vol, unsigned long pan, unsigned long span, float auxa, float auxb) {
-                 unsigned long span, float auxa, float auxb) {
   SAL_VOLINFO vi;                    // r1+0x24
   unsigned short il;                 // r30
   unsigned short ir;                 // r29
@@ -325,8 +321,7 @@ void hwSetVolume(unsigned long v, unsigned char table, float vol, unsigned long
   ir = 32767.f * vi.volR;
   is = 32767.f * vi.volS;
 
-  if (dsp_vptr->lastUpdate.vol == 0xff || dsp_vptr->volL != il || dsp_vptr->volR != ir ||
+  if (dsp_vptr->lastUpdate.vol == 0xff || dsp_vptr->volL != il || dsp_vptr->volR != ir || dsp_vptr->volS != is) {
-      dsp_vptr->volS != is) {
     dsp_vptr->volL = il;
     dsp_vptr->volR = ir;
     dsp_vptr->volS = is;
@@ -338,8 +333,7 @@ void hwSetVolume(unsigned long v, unsigned char table, float vol, unsigned long
   ir = 32767.f * vi.volAuxAR;
   is = 32767.f * vi.volAuxAS;
 
-  if (dsp_vptr->lastUpdate.volA == 0xff || dsp_vptr->volLa != il || dsp_vptr->volRa != ir ||
+  if (dsp_vptr->lastUpdate.volA == 0xff || dsp_vptr->volLa != il || dsp_vptr->volRa != ir || dsp_vptr->volSa != is) {
-      dsp_vptr->volSa != is) {
     dsp_vptr->volLa = il;
     dsp_vptr->volRa = ir;
     dsp_vptr->volSa = is;
@@ -351,8 +345,7 @@ void hwSetVolume(unsigned long v, unsigned char table, float vol, unsigned long
   ir = 32767.f * vi.volAuxBR;
   is = 32767.f * vi.volAuxBS;
 
-  if (dsp_vptr->lastUpdate.volB == 0xff || dsp_vptr->volLb != il || dsp_vptr->volRb != ir ||
+  if (dsp_vptr->lastUpdate.volB == 0xff || dsp_vptr->volLb != il || dsp_vptr->volRb != ir || dsp_vptr->volSb != is) {
-      dsp_vptr->volSb != is) {
     dsp_vptr->volLb = il;
     dsp_vptr->volRb = ir;
     dsp_vptr->volSb = is;
@@ -367,31 +360,24 @@ void hwSetVolume(unsigned long v, unsigned char table, float vol, unsigned long
 
 void hwOff(s32 vid) { salDeactivateVoice(&dspVoice[vid]); }
 
-void hwSetAUXProcessingCallbacks(u8 studio, SND_AUX_CALLBACK auxA, void* userA,
+void hwSetAUXProcessingCallbacks(u8 studio, SND_AUX_CALLBACK auxA, void* userA, SND_AUX_CALLBACK auxB, void* userB) {
-                                 SND_AUX_CALLBACK auxB, void* userB) {
   dspStudio[studio].auxAHandler = auxA;
   dspStudio[studio].auxAUser = userA;
   dspStudio[studio].auxBHandler = auxB;
   dspStudio[studio].auxBUser = userB;
 }
 
-void hwActivateStudio(unsigned char studio, unsigned long isMaster, SND_STUDIO_TYPE type) {
+void hwActivateStudio(unsigned char studio, unsigned long isMaster, SND_STUDIO_TYPE type) { salActivateStudio(studio, isMaster, type); }
-  salActivateStudio(studio, isMaster, type);
-}
 
 void hwDeactivateStudio(u8 studio) { salDeactivateStudio(studio); }
 
 void hwChangeStudioMix(u8 studio, u32 isMaster) { dspStudio[studio].isMaster = isMaster; }
 
-bool hwIsStudioActive(u32 studio) { return dspStudio[studio].state == 1; }
+bool hwIsStudioActive(u8 studio) { return dspStudio[studio].state == 1; }
 
-bool hwAddInput(u8 studio, SND_STUDIO_INPUT* in_desc) {
+bool hwAddInput(u8 studio, SND_STUDIO_INPUT* in_desc) { return salAddStudioInput(&dspStudio[studio], in_desc); }
-  return salAddStudioInput(&dspStudio[studio], in_desc);
-}
 
-bool hwRemoveInput(u8 studio, SND_STUDIO_INPUT* in_desc) {
+bool hwRemoveInput(u8 studio, SND_STUDIO_INPUT* in_desc) { return salRemoveStudioInput(&dspStudio[studio], in_desc); }
-  return salRemoveStudioInput(&dspStudio[studio], in_desc);
-}
 
 void hwChangeStudio(u32 v, u8 studio) { salReconnectVoice(&dspVoice[v], studio); }
 
@@ -424,84 +410,36 @@ u32 hwGetPos(u32 v) {
   return pos;
 }
 
-#if NONMATCHING
+void hwFlushStream(void* base, unsigned long offset, unsigned long bytes, unsigned char hwStreamHandle, void (*callback)(unsigned long),
-void hwFlushStream(void* base, unsigned long offset, unsigned long bytes,
-                   unsigned char hwStreamHandle, void (*callback)(unsigned long),
                    unsigned long user) {
-  unsigned long aram; // r28
+  u32 aram; // r28
-  unsigned long mram; // r29
+  u32 mram; // r29
-  unsigned long len;
+  u32 len;
   aram = aramGetStreamBufferAddress(hwStreamHandle, &len);
-  DCStoreRange((void*)((u32)base + (offset & ~31)), bytes + ((offset & 31) + 31) & ~31);
+  bytes += (offset & 31);
-  aramUploadData((void*)((u32)base + (offset & ~31)), aram + (offset & ~31),
+  offset &= ~31;
-                 bytes + ((offset & 31) + 31) & ~31, 1, callback, user);
+  bytes = (bytes + 31) & ~31;
+  mram = (u32)base + offset;
+  DCStoreRange((void*)mram, bytes);
+  aramUploadData((void*)mram, aram + offset, bytes, 1, callback, user);
 }
-#else
-/* clang-format off */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-extern void _savegpr_25();
-extern void _restgpr_25();
-asm void hwFlushStream(void* base, unsigned long offset, unsigned long bytes,
-                   unsigned char hwStreamHandle, void (*callback)(unsigned long),
-                   unsigned long user) {
-  nofralloc
-  stwu r1, -0x30(r1)
-  mflr r0
-  stw r0, 0x34(r1)
-  addi r11, r1, 0x30
-  bl _savegpr_25
-  mr r25, r3
-  mr r29, r4
-  mr r26, r5
-  mr r27, r7
-  mr r28, r8
-  mr r3, r6
-  addi r4, r1, 8
-  bl aramGetStreamBufferAddress
-  clrlwi r0, r29, 0x1b
-  rlwinm r30, r29, 0, 0, 0x1a
-  add r26, r26, r0
-  mr r31, r3
-  addi r0, r26, 0x1f
-  add r29, r25, r30
-  rlwinm r26, r0, 0, 0, 0x1a
-  mr r3, r29
-  mr r4, r26
-  bl DCStoreRange
-  mr r3, r29
-  mr r5, r26
-  mr r7, r27
-  mr r8, r28
-  add r4, r31, r30
-  li r6, 1
-  bl aramUploadData
-  addi r11, r1, 0x30
-  bl _restgpr_25
-  lwz r0, 0x34(r1)
-  mtlr r0
-  addi r1, r1, 0x30
-  blr
-}
-#pragma pop
-/* clang-format on */
-#endif
 
 void hwPrepareStreamBuffer() {}
 u32 hwInitStream(u32 len) { return aramAllocateStreamBuffer(len); }
 
 void hwExitStream(u8 id) { aramFreeStreamBuffer(id); }
 
-void* hwGetStreamPlayBuffer(u8 hwStreamHandle) {
+void* hwGetStreamPlayBuffer(u8 hwStreamHandle) { return (void*)aramGetStreamBufferAddress(hwStreamHandle, NULL); }
-  return (void*)aramGetStreamBufferAddress(hwStreamHandle, NULL);
-}
 
 void* hwTransAddr(void* samples) { return samples; }
 
 u32 hwFrq2Pitch(u32 frq) { return (frq * 4096.f) / synthInfo.mixFrq; }
 
-void hwInitSampleMem(u32 baseAddr, u32 length) { aramInit(length); }
+void hwInitSampleMem(u32 baseAddr, u32 length) {
+#line 940
+  MUSY_ASSERT(baseAddr == 0x00000000);
+  aramInit(length);
+}
 
 void hwExitSampleMem() { aramExit(); }
 
@@ -519,25 +457,17 @@ static u32 convert_length(u32 len, u8 type) {
 }
 
 void hwSaveSample(void* header, void* data) {
-  u32 len;
+  u32 len = ((u32*)*((u32*)header))[1] & 0xFFFFFF;
-  u8 type;
+  u8 type = ((u32*)*((u32*)header))[1] >> 0x18;
-
+  len = convert_length(len, type);
-  header = (void*)((u32*)header)[0];
+  *((u32*)data) = (u32)aramStoreData((void*)*((u32*)data), len);
-  header = (void*)((u32*)header)[1];
-  len = (u32)header & 0xFFFFFF;
-  type = (u32)header >> 0x18;
-  *((u32*)data) = (u32)aramStoreData((void*)*((u32*)data), convert_length(len, type));
 }
 
-void hwSetSaveSampleCallback(ARAMUploadCallback callback, unsigned long chunckSize) {
+void hwSetSaveSampleCallback(ARAMUploadCallback callback, unsigned long chunckSize) { aramSetUploadCallback(callback, chunckSize); }
-  aramSetUploadCallback(callback);
-}
 
 void hwRemoveSample(void* header, void* data) {
-  u32 len; // r31
+  u8 type = (((u32*)header))[1] >> 0x18;
-  u8 type; // r30
+  u32 len = convert_length((((u32*)header))[1] & 0xFFFFFF, type);
-  type = ((u32*)header)[1] >> 0x18;
-  len = convert_length(((u32*)header)[1] & 0xFFFFFF, type);
   aramRemoveData(data, len);
 }
 

src/musyx/runtime/hw_dolphin.c

@@ -134,7 +134,7 @@ u32 salExitDsp() {
 void salStartDsp(u16* cmdList) {
   salDspIsDone = FALSE;
   PPCSync();
-  ASSERT(((u32)cmdList & 0x1F)==0);
+  MUSY_ASSERT(((u32)cmdList & 0x1F)==0);
   DSPSendMailToDSP(dspCmdFirstSize | 0xbabe0000);
 
   while (DSPCheckMailToDSP())

src/musyx/runtime/hw_dspctrl.c

@@ -1,4 +1,4 @@
-#include "musyx/assert.h"
+
 #include "musyx/musyx_priv.h"
 
 #ifdef _DEBUG
@@ -31,7 +31,7 @@ u32 salInitDspCtrl(u8 numVoices, u8 numStudios, u32 defaultStudioDPL2) {
   salNumVoices = numVoices;
   salMaxStudioNum = numStudios;
 #line 66
-  ASSERT(salMaxStudioNum <= SAL_MAX_STUDIONUM);
+  MUSY_ASSERT(salMaxStudioNum <= SAL_MAX_STUDIONUM);
   dspARAMZeroBuffer = aramGetZeroBuffer();
   if ((dspCmdList = salMalloc(1024 * sizeof(u16))) != NULL) {
     MUSY_DEBUG("Allocated dspCmdList.\n\n");

src/musyx/runtime/s_data.c

@@ -1,4 +1,4 @@
-#include "musyx/assert.h"
+
 #include "musyx/musyx_priv.h"
 
 static GSTACK gs[128];
@@ -182,8 +182,8 @@ void sndSetSampleDataUploadCallback(void* (*callback)(unsigned long, unsigned lo
 u32 sndPushGroup(void* prj_data, u16 gid, void* samples, void* sdir, void* pool) {
   GROUP_DATA* g; // r31
 #line 0x18d
-  ASSERT_MSG(prj_data != NULL, "Project data pointer is NULL");
+  MUSY_ASSERT_MSG(prj_data != NULL, "Project data pointer is NULL");
-  ASSERT_MSG(sdir != NULL, "Sample directory pointer is NULL");
+  MUSY_ASSERT_MSG(sdir != NULL, "Sample directory pointer is NULL");
 
   if (sndActive && sp < 128) {
     g = prj_data;
@@ -232,8 +232,8 @@ unsigned long sndPopGroup() {
   void* prj;
   struct FX_DATA* fd;
 
-  ASSERT_MSG(sndActive != FALSE, "Sound system is not initialized.");
+  MUSY_ASSERT_MSG(sndActive != FALSE, "Sound system is not initialized.");
-  ASSERT_MSG(sp != 0, "Soundstack is empty.");
+  MUSY_ASSERT_MSG(sp != 0, "Soundstack is empty.");
   g = gs[--sp].gAddr;
   prj = gs[sp].prjAddr;
   sdir = gs[sp].sdirAddr;
@@ -282,7 +282,7 @@ u32 seqPlaySong(u16 sgid, u16 sid, void* arrfile, SND_PLAYPARA* para, u8 irq_cal
   MIDISETUP* midiSetup;
   u32 seqId;
   void* prj;
-  ASSERT_MSG(sndActive != FALSE, "Sound system is not initialized.");
+  MUSY_ASSERT_MSG(sndActive != FALSE, "Sound system is not initialized.");
 
   for (i = 0; i < sp; ++i) {
     if (sgid != gs[i].gAddr->id) {

src/musyx/runtime/snd_init.c

@@ -1,6 +1,6 @@
 #include "musyx/musyx_priv.h"
 //#define _DEBUG
-#include "musyx/assert.h"
+
 
 s32 DoInit(u32 rate, u32 aramSize, u8 voices, u32 flags) {
   dataInitStack();
@@ -50,8 +50,8 @@ void sndQuit() {
 }
 
 void sndSetMaxVoices(u8 music, u8 sfx) {
-  ASSERT_MSG(music > synthInfo.voiceNum, "Music voices are above maximum voice number.");
+  MUSY_ASSERT_MSG(music > synthInfo.voiceNum, "Music voices are above maximum voice number.");
-  ASSERT_MSG(sfx > synthInfo.voiceNum, "Sfx voices are above maximum voice number.");
+  MUSY_ASSERT_MSG(sfx > synthInfo.voiceNum, "Sfx voices are above maximum voice number.");
   synthInfo.maxMusic = music;
   synthInfo.maxSFX = sfx;
 }

src/musyx/runtime/snd_midictrl.c

@@ -1,4 +1,4 @@
-#include "musyx/assert.h"
+
 #include "musyx/musyx_priv.h"
 
 #define SYNTH_FX_MIDISET 0xFF
@@ -29,7 +29,7 @@ void inpResetGlobalMIDIDirtyFlags() {
 }
 
 bool inpResetGlobalMIDIDirtyFlag(u8 chan, u8 midiSet, s32 flag) {
-  // ASSERT(midiSet!=SYNTH_FX_MIDISET);
+  // MUSY_ASSERT(midiSet!=SYNTH_FX_MIDISET);
   bool ret = GetGlobalFlagSet(chan, midiSet, flag);
   if (ret) {
     inpGlobalMIDIDirtyFlags[midiSet][chan] &= ~flag;
@@ -38,7 +38,7 @@ bool inpResetGlobalMIDIDirtyFlag(u8 chan, u8 midiSet, s32 flag) {
 }
 
 void inpSetGlobalMIDIDirtyFlag(u8 chan, u8 midiSet, s32 flag) {
-  // ASSERT(midiSet!=SYNTH_FX_MIDISET);
+  // MUSY_ASSERT(midiSet!=SYNTH_FX_MIDISET);
   inpGlobalMIDIDirtyFlags[midiSet][chan] |= flag;
 }
 

src/musyx/runtime/synth.c

@@ -1,4 +1,4 @@
-#include "musyx/assert.h"
+
 #include "musyx/musyx_priv.h"
 
 static u32 synthTicksPerSecond[9][16];

src/musyx/runtime/synth_adsr.c

@@ -1,4 +1,4 @@
-#include "musyx/assert.h"
+
 #include "musyx/musyx_priv.h"
 #include "musyx/synth_dbtab.h"
 

src/musyx/runtime/synth_vsamples.c

@@ -1,4 +1,4 @@
-#include "musyx/assert.h"
+
 #include "musyx/musyx_priv.h"
 
 static VS vs;
@@ -160,8 +160,8 @@ unsigned long sndVirtualSampleAllocateBuffers(unsigned char numInstances,
   long i;            // r31
   unsigned long len; // r28
 #line 437
-  ASSERT_MSG(sndActive, "Sound system is not initialized.");
+  MUSY_ASSERT_MSG(sndActive, "Sound system is not initialized.");
-  ASSERT_MSG(numInstances <= 64, "Parameter exceeded maximum number of instances allowable");
+  MUSY_ASSERT_MSG(numInstances <= 64, "Parameter exceeded maximum number of instances allowable");
 #line 159
   hwDisableIrq();
   vs.numBuffers = numInstances;
@@ -193,7 +193,7 @@ unsigned long sndVirtualSampleAllocateBuffers(unsigned char numInstances,
 void sndVirtualSampleFreeBuffers() {
   u8 i; // r31
 #line 481
-  ASSERT_MSG(sndActive, "Sound system is not initialized.");
+  MUSY_ASSERT_MSG(sndActive, "Sound system is not initialized.");
 
   for (i = 0; i < vs.numBuffers; ++i) {
     aramFreeStreamBuffer(vs.streamBuffer[i].hwId);
@@ -205,7 +205,7 @@ void sndVirtualSampleFreeBuffers() {
 void sndVirtualSampleSetCallback(unsigned long (*callback)(unsigned char,
                                                            struct SND_VIRTUALSAMPLE_INFO*)) {
 #line 0x1ed
-  ASSERT_MSG(sndActive, "Sound system is not initialized.");
+  MUSY_ASSERT_MSG(sndActive, "Sound system is not initialized.");
   vs.callback = callback;
 }
 
@@ -221,7 +221,7 @@ void sndVirtualSampleARAMUpdate(unsigned short instID, void* base, unsigned long
                                 unsigned long len1, unsigned long off2, unsigned long len2) {
   u8 i;
 #line 0x203
-  ASSERT_MSG(sndActive, "Sound system is not initialized.");
+  MUSY_ASSERT_MSG(sndActive, "Sound system is not initialized.");
 
   hwDisableIrq();
 

src/musyx/runtime/synthdata.c

@@ -1,4 +1,4 @@
-#include "musyx/assert.h"
+
 #include "musyx/musyx_priv.h"
 
 static u16 dataSmpSDirNum = 0;

src/musyx/runtime/synthmacros.c

@@ -1,9 +1,6 @@
-#include "musyx/assert.h"
 #include "musyx/musyx_priv.h"
 
-#ifdef _DEBUG
 static u8 DebugMacroSteps = 0;
-#endif
 
 static SYNTH_VOICE* macActiveMacroRoot = NULL;
 static SYNTH_VOICE* macTimeQueueRoot = NULL;
@@ -17,6 +14,37 @@ void macSetExternalKeyoff(SYNTH_VOICE* svoice);
 
 static void DoSetPitch(SYNTH_VOICE* svoice);
 
+/*
+  This may look like a fakematch, however this actually makes sense if you break it down:
+   1) Shift right to clear bottom 2 nybbles;
+   2) Shift left to put the moved nybbles back to their original location
+   3) Mask off the top nybble leaving only 3rd nybble
+
+   So taking 0x1234567 as an example the logic looks something like this
+   1) 0x12345678 >> 16        == 0x00001234
+   2) 0x00001234 << 16        == 0x12340000
+   3) 0x12340000 & 0x00FFFFFF == 0x00340000
+
+  This behavior could also be matched with a simple mask
+     
+     0x12345678 & 0x00FF0000 == 0x00340000
+
+  But on PPC with CodeWarrior this just produces an improper load:
+
+  `
+    lwz     r0,0(r29)
+    rlwinm  r0,r0,0,8,0xf
+  `
+  
+  Instead of the expected
+  `
+    lwz     r3,0(r29)
+    rlwinm  r0,r3,0,8,0xf
+  `
+  Note the use of r3 instead of r0
+*/
+#define EXTRACT_3RDNYBBLE(v) (((v >> 16) << 16) & 0x00FFFFFF)
+
 static int SendSingleKeyOff(u32 voiceid) {
   u32 i; // r31
 
@@ -221,7 +249,7 @@ static u32 mcmdGoto(SYNTH_VOICE* svoice, MSTEP* cstep) {
 
 static u32 mcmdGosub(SYNTH_VOICE* svoice, MSTEP* cstep) {
   MSTEP* addr; // r30
-  if ((addr = (MSTEP*)dataGetMacro(cstep->para[0] >> 0x10)) != NULL) {
+  if ((addr = (MSTEP*)dataGetMacro((u16)(cstep->para[0] >> 0x10))) != NULL) {
     svoice->callStackIndex = (svoice->callStackIndex + 1) & 3;
     svoice->callStack[svoice->callStackIndex].addr = svoice->addr;
     svoice->callStack[svoice->callStackIndex].curAddr = svoice->curAddr;
@@ -271,11 +299,7 @@ static void mcmdPlayMacro(SYNTH_VOICE* svoice, MSTEP* cstep) {
   u32 new_child; // r30
 
   key = ((u32)svoice->orgNote + (s8)(u8)(cstep->para[0] >> 8));
-  if (key < 0) {
+  key = (key < 0) ? 0 : key > 0x7f ? 0x7f : key;
-    key = 0;
-  } else if (key > 0x7f) {
-    key = 0x7f;
-  }
 
   if (svoice->fxFlag != 0) {
     key |= 0x80;
@@ -601,8 +625,20 @@ static void mcmdSetPitchADSR(SYNTH_VOICE* svoice, MSTEP* cstep) {
   s32 ascale;          // r27
   s32 dscale;          // r26
 }
-u32 mcmdPitchSweep(SYNTH_VOICE* svoice, MSTEP* cstep, int num) {
+static u32 mcmdPitchSweep(SYNTH_VOICE* svoice, MSTEP* cstep, int num) {
   s32 delta; // r31
+  svoice->sweepOff[num] = 0;
+  svoice->sweepNum[num] = (u8)(cstep->para[0] >> 8);
+  svoice->sweepCnt[num] = (s32)svoice->sweepNum[num] << 0x10;
+  delta = (int)(short)(cstep->para[0] >> 0x10);
+  if (delta >= 0) {
+    delta = hwFrq2Pitch(delta);
+  } else {
+    delta = -hwFrq2Pitch(-delta);
+  }
+  svoice->sweepAdd[num] = delta << 0x10;
+  cstep->para[0] = 0;
+  mcmdWait(svoice, cstep);
 }
 
 static void DoPanningSetup(SYNTH_VOICE* svoice, MSTEP* cstep, u8 pi) {
@@ -624,32 +660,131 @@ static void DoPanningSetup(SYNTH_VOICE* svoice, MSTEP* cstep, u8 pi) {
 
 static void mcmdSetPanning(SYNTH_VOICE* svoice, MSTEP* cstep) { DoPanningSetup(svoice, cstep, 0); }
 
-static void mcmdSetSurroundPanning(SYNTH_VOICE* svoice, MSTEP* cstep) {}
+static void mcmdSetSurroundPanning(SYNTH_VOICE* svoice, MSTEP* cstep) {
+  DoPanningSetup(svoice, cstep, 1);
+}
+
 static void mcmdSetPianoPanning(SYNTH_VOICE* svoice, MSTEP* cstep) {
   s32 delta; // r31
   s32 scale; // r30
+  delta = (svoice->curNote << 16) - EXTRACT_3RDNYBBLE(cstep->para[0]);
+  scale = (s8)(u8)(cstep->para[0] >> 8);
+  delta = ((delta * scale) >> 7);
+  delta += (u8)(cstep->para[0] >> 0x18) << 16;
+  if (delta < 0) {
+    delta = 0;
+  } else if (delta > 0x7f0000) {
+    delta = 0x7f0000;
+  }
+  svoice->panTarget[0] = delta;
+  svoice->panning[0] = delta;
 }
 static u32 TranslateVolume(u32 volume, u16 curve) {
   u8* ptr;   // r30
   u32 vlow;  // r28
   u32 vhigh; // r31
   s32 d;     // r27
+
+  if (curve != 0xFFFF) {
+    if ((ptr = (u8*)dataGetCurve(curve))) {
+      vhigh = (volume >> 16) & 0xFFFF;
+      vlow = volume & 0xFFFF;
+
+      if (vhigh < 0x7f) {
+        d = vlow * (ptr[vhigh + 1] - ptr[vhigh]);
+        volume = d + (ptr[vhigh] << 16);
+      } else {
+        volume = ptr[vhigh] << 16;
+      }
+    }
+  }
+
+  return volume;
 }
+
 static void mcmdScaleVolume(SYNTH_VOICE* svoice, MSTEP* cstep) {
   u16 curve; // r29
   u16 scale; // r28
+  scale = (u16)(u8)(cstep->para[0] >> 8);
+
+  if ((u8)(cstep->para[1] >> 8) == 0) {
+    svoice->volume = (svoice->volume * scale) / 0x7f;
+  } else {
+    svoice->volume = (svoice->orgVolume * scale) / 0x7f;
+  }
+
+  svoice->volume += EXTRACT_3RDNYBBLE(cstep->para[0]);
+
+  if (svoice->volume > 0x7f0000) {
+    svoice->volume = 0x7f0000;
+  }
+
+  curve = (u8)(cstep->para[0] >> 0x18);
+  curve |= ((u16)((u8)cstep->para[1]) << 8);
+
+  svoice->volume = TranslateVolume(svoice->volume, curve);
+  svoice->cFlags |= 0x100000000000;
 }
+
 static void mcmdScaleVolumeDLS(SYNTH_VOICE* svoice, MSTEP* cstep) {
   u16 scale; // r31
+
+  scale = (u16)(cstep->para[0] >> 8);
+  if (cstep->para[0] >> 0x18 == 0) {
+    svoice->volume = ((svoice->volume >> 5) * scale) >> 7;
+  } else {
+    svoice->volume = ((svoice->orgVolume >> 5) * scale) >> 7;
+  }
+  if (svoice->volume > 0x7f0000) {
+    svoice->volume = 0x7f0000;
+  }
+
+  svoice->cFlags |= 0x100000000000;
 }
+
 static void DoEnvelopeCalculation(SYNTH_VOICE* svoice, MSTEP* cstep, s32 start_vol) {
   u32 tvol;   // r31
   u32 time;   // r1+0x14
   s32 mstime; // r28
   u16 curve;  // r27
+
+  time = (cstep->para[1] >> 16);
+
+  if ((u8)(cstep->para[1] >> 8) & 1) {
+    sndConvertMs(&time);
+  } else {
+    sndConvertTicks(&time, svoice);
+  }
+
+  mstime = sndConvert2Ms(time);
+  if (mstime == 0) {
+    mstime = 1;
+  }
+
+  tvol = (svoice->volume * (u8)(cstep->para[0] >> 8) >> 7);
+  tvol += EXTRACT_3RDNYBBLE(cstep->para[0]);
+
+  if (tvol > 0x7f0000) {
+    tvol = 0x7f0000;
+  }
+
+  curve = (u16)(u8)(cstep->para[0] >> 0x18);
+  curve |= (((u16)(u8)cstep->para[1]) << 8) & 0xFFFF00;
+  tvol = TranslateVolume(tvol, curve);
+  svoice->envTarget = tvol;
+  svoice->envCurrent = start_vol;
+  svoice->envDelta = (s32)(tvol - start_vol) / mstime;
+  svoice->volume = start_vol;
+  svoice->cFlags |= 0x8000;
 }
-static void mcmdEnvelope(SYNTH_VOICE* svoice, MSTEP* cstep) {}
+
-static void mcmdFadeIn(SYNTH_VOICE* svoice, MSTEP* cstep) {}
+static void mcmdEnvelope(SYNTH_VOICE* svoice, MSTEP* cstep) {
+  DoEnvelopeCalculation(svoice, cstep, svoice->volume);
+}
+static void mcmdFadeIn(SYNTH_VOICE* svoice, MSTEP* cstep) {
+  DoEnvelopeCalculation(svoice, cstep, 0);
+}
+
 static void mcmdRandomKey(SYNTH_VOICE* svoice, MSTEP* cstep) {
   u8 k1;     // r30
   u8 k2;     // r29
@@ -658,49 +793,105 @@ static void mcmdRandomKey(SYNTH_VOICE* svoice, MSTEP* cstep) {
   s32 i2;    // r27
   u8 detune; // r26
 }
-static void mcmdSetPitchbendAfterKeyOff(SYNTH_VOICE* svoice) {}
+static void mcmdSetPitchbendAfterKeyOff(SYNTH_VOICE* svoice) { svoice->cFlags |= 0x10000; }
-static void mcmdScaleReverb(SYNTH_VOICE* svoice, MSTEP* cstep) {}
+static void mcmdScaleReverb(SYNTH_VOICE* svoice, MSTEP* cstep) {
+  svoice->revVolScale = (u8)(cstep->para[0] >> 8);
+  svoice->revVolOffset = (u8)(cstep->para[0] >> 0x10);
+}
 static void SelectSource(SYNTH_VOICE* svoice, CTRL_DEST* dest, MSTEP* cstep, u64 tstflag,
                          u32 dirtyFlag) {
   u8 comb;   // r28
   s32 scale; // r30
+
+  if (!(svoice->cFlags & tstflag)) {
+    comb = 0;
+    svoice->cFlags |= tstflag;
+  } else {
+    comb = (u8)cstep->para[1];
+  }
+
+  scale = (s32)(cstep->para[0] & 0xFFFF0000) / 100;
+  if (scale < 0) {
+    scale -= ((s8)(cstep->para[1] >> 0x10) << 8) / 100;
+  } else {
+    scale += ((s8)(cstep->para[1] >> 0x10) << 8) / 100;
+  }
+
+  inpAddCtrl(dest, (u8)(cstep->para[0] >> 8), scale, comb, (u8)(cstep->para[1] >> 8) != 0);
+
+  if ((dirtyFlag & 0x80000000) != 0) {
+    inpSetGlobalMIDIDirtyFlag(svoice->midi, svoice->midiSet, dirtyFlag);
+  } else {
+    svoice->midiDirtyFlags |= dirtyFlag;
+  }
 }
-static void mcmdVolumeSelect(SYNTH_VOICE* svoice, MSTEP* cstep) {}
 
-static void mcmdPanningSelect(SYNTH_VOICE* svoice, MSTEP* cstep) {}
+static void mcmdVolumeSelect(SYNTH_VOICE* svoice, MSTEP* cstep) {
+  SelectSource(svoice, &svoice->inpVolume, cstep, 0x80000, 1);
+}
 
-static void mcmdPitchWheelSelect(SYNTH_VOICE* svoice, MSTEP* cstep) {}
+static void mcmdPanningSelect(SYNTH_VOICE* svoice, MSTEP* cstep) {
+  SelectSource(svoice, &svoice->inpPanning, cstep, 0x100000, 2);
+}
 
-static void mcmdModWheelSelect(SYNTH_VOICE* svoice, MSTEP* cstep) {}
+static void mcmdPitchWheelSelect(SYNTH_VOICE* svoice, MSTEP* cstep) {
+  SelectSource(svoice, &svoice->inpPitchBend, cstep, 0x200000, 8);
+}
 
-static void mcmdPedalSelect(SYNTH_VOICE* svoice, MSTEP* cstep) {}
+static void mcmdModWheelSelect(SYNTH_VOICE* svoice, MSTEP* cstep) {
+  SelectSource(svoice, &svoice->inpModulation, cstep, 0x400000, 0x20);
+}
 
-static void mcmdPortamentoSelect(SYNTH_VOICE* svoice, MSTEP* cstep) {}
+static void mcmdPedalSelect(SYNTH_VOICE* svoice, MSTEP* cstep) {
+  SelectSource(svoice, &svoice->inpPedal, cstep, 0x2000000, 0x40);
+}
 
-static void mcmdReverbSelect(SYNTH_VOICE* svoice, MSTEP* cstep) {}
+static void mcmdPortamentoSelect(SYNTH_VOICE* svoice, MSTEP* cstep) {
+  SelectSource(svoice, &svoice->inpPortamento, cstep, 0x1000000, 0x80);
+}
 
-static void mcmdPreAuxASelect(SYNTH_VOICE* svoice, MSTEP* cstep) {}
+static void mcmdReverbSelect(SYNTH_VOICE* svoice, MSTEP* cstep) {
+  SelectSource(svoice, &svoice->inpReverb, cstep, 0x800000, 0x200);
+}
 
-static void mcmdPreAuxBSelect(SYNTH_VOICE* svoice, MSTEP* cstep) {}
+static void mcmdPreAuxASelect(SYNTH_VOICE* svoice, MSTEP* cstep) {
+  SelectSource(svoice, &svoice->inpPreAuxA, cstep, 0x20000000, 0x100);
+}
 
-static void mcmdPostAuxBSelect(SYNTH_VOICE* svoice, MSTEP* cstep) {}
+static void mcmdPreAuxBSelect(SYNTH_VOICE* svoice, MSTEP* cstep) {
+  SelectSource(svoice, &svoice->inpPreAuxB, cstep, 0x40000000, 0x400);
+}
 
-static void mcmdSurroundPanningSelect(SYNTH_VOICE* svoice, MSTEP* cstep) {}
+static void mcmdPostAuxBSelect(SYNTH_VOICE* svoice, MSTEP* cstep) {
+  SelectSource(svoice, &svoice->inpPostAuxB, cstep, 0x80000000, 0x800);
+}
 
-static void mcmdDopplerSelect(SYNTH_VOICE* svoice, MSTEP* cstep) {}
+static void mcmdSurroundPanningSelect(SYNTH_VOICE* svoice, MSTEP* cstep) {
+  SelectSource(svoice, &svoice->inpSurroundPanning, cstep, 0x4000000, 4);
+}
 
-static void mcmdTremoloSelect(SYNTH_VOICE* svoice, MSTEP* cstep) {}
+static void mcmdDopplerSelect(SYNTH_VOICE* svoice, MSTEP* cstep) {
+  SelectSource(svoice, &svoice->inpDoppler, cstep, 0x8000000, 0x10);
+}
+
+static void mcmdTremoloSelect(SYNTH_VOICE* svoice, MSTEP* cstep) {
+  SelectSource(svoice, &svoice->inpTremolo, cstep, 0x10000000, 0x1000);
+}
 
 static void mcmdAuxAFXSelect(SYNTH_VOICE* svoice, MSTEP* cstep) {
   u32 i;                                                                     // r31
   static u64 mask[4] = {0x100000000, 0x200000000, 0x400000000, 0x800000000}; // size: 0x20
   static u32 dirty[4] = {0x80000001, 0x80000002, 0x80000004, 0x80000008};    // size: 0x10
+  i = cstep->para[1] >> 0x18;
+  SelectSource(svoice, &inpAuxA[svoice->studio][i], cstep, mask[i], dirty[i]);
 }
 
 static void mcmdAuxBFXSelect(SYNTH_VOICE* svoice, MSTEP* cstep) {
   u32 i;                                                                         // r31
   static u64 mask[4] = {0x1000000000, 0x2000000000, 0x4000000000, 0x8000000000}; // size: 0x20
   static u32 dirty[4] = {0x80000010, 0x80000020, 0x80000040, 0x80000080};        // size: 0x10
+  i = cstep->para[1] >> 0x18;
+  SelectSource(svoice, &inpAuxB[svoice->studio][i], cstep, mask[i], dirty[i]);
 }
 
 static void mcmdPortamento(SYNTH_VOICE* svoice, MSTEP* cstep) {
@@ -736,38 +927,161 @@ void varSet32(SYNTH_VOICE* svoice, u32 ctrl, u8 index, s32 v) {
   synthGlobalVariable[index - 16] = v;
 }
 void varSet(SYNTH_VOICE* svoice, u32 ctrl, u8 index, s16 v) { varSet32(svoice, ctrl, index, v); }
+
 static void mcmdVarCalculation(SYNTH_VOICE* svoice, MSTEP* cstep, u8 op) {
-  s16 s1; // r28
+  s16 s1 = 0; // r28
-  s16 s2; // r31
+  s16 s2 = 0; // r31
   s32 t;  // r30
+
+  s1 = varGet(svoice, (cstep->para[0] >> 24), cstep->para[1]);
+  if (op == 4) {
+    s2 = cstep->para[1] >> 8;
+  } else {
+    s2 = varGet(svoice, (u8)(cstep->para[1] >> 8), cstep->para[1] >> 16);
+  }
+  switch (op) {
+  case 4:
+  case 0:
+    t = (s1 + s2);
+    break;
+  case 1:
+    t = (s1 - s2);
+    break;
+  case 2:
+    t = (s1 * s2);
+    break;
+  case 3:
+    if (s2 != 0) {
+      t = (s1 / s2);
+    } else {
+      t = 0;
+    }
+    break;
+  }
+
+  varSet(svoice, (u8)(cstep->para[0] >> 8), (u8)(cstep->para[0] >> 0x10),
+         (t < -0x8000  ? -0x8000
+          : t > 0x7FFF ? 0x7FFF
+                       : t));
+}
+
+static void mcmdSetVarImmediate(SYNTH_VOICE* svoice, MSTEP* cstep) {
+  varSet(svoice, (u8)(cstep->para[0] >> 8), (u8)(cstep->para[0] >> 0x10), (s16)cstep->para[1]);
 }
-static void mcmdSetVarImmediate(SYNTH_VOICE* svoice, MSTEP* cstep) {}
 
 static void mcmdIfVarCompare(SYNTH_VOICE* svoice, MSTEP* cstep, u8 cmp) {
   s32 a;     // r28
   s32 b;     // r27
   u8 result; // r30
+
+  a = varGet32(svoice, (u8)(cstep->para[0] >> 8), (u8)(cstep->para[0] >> 0x10));
+  b = varGet32(svoice, (u8)(cstep->para[0] >> 0x18), (u8)cstep->para[1]);
+
+  switch (cmp) {
+  case 0:
+    result = (u16) !(b - a);
+    break;
+  case 1:
+    result = (a < b);
+    break;
+  }
+
+  if ((u8)(cstep->para[1] >> 8) != 0) {
+    result = !result;
+  }
+  if ((u8)result != 0) {
+    svoice->curAddr = svoice->addr + (u16)(cstep->para[1] >> 0x10);
+  }
 }
 u32 macPostMessage(u32 vid, s32 mesg) {
   SYNTH_VOICE* sv; // r31
+  if ((vid = vidGetInternalId(vid)) != -1 && (sv = &synthVoice[vid & 0xFF])->mesgNum < 4) {
+    ++sv->mesgNum;
+    sv->mesgQueue[sv->mesgWrite] = mesg;
+    sv->mesgWrite = (sv->mesgWrite + 1) & 3;
+    ExecuteTrap(sv, 2);
+    return 1;
+  }
+
+  return 0;
 }
 static void mcmdSendMessage(SYNTH_VOICE* svoice, MSTEP* cstep) {
   u8 i;      // r31
   s32 mesg;  // r30
   u16 macro; // r28
+
+  mesg = varGet32(svoice, 0, (u8)(cstep->para[1] >> 8));
+
+  if (!(u8)(cstep->para[0] >> 8)) {
+    macro = (u16)(cstep->para[0] >> 16);
+    if (macro != 0xFFFF) {
+      for (i = 0; i < synthInfo.voiceNum; ++i) {
+        if (synthVoice[i].addr != NULL && macro == synthVoice[i].macroId) {
+          macPostMessage(synthVoice[i].vidList->vid, mesg);
+        }
+      }
+    } else if (synthMessageCallback != NULL) {
+      synthMessageCallback(svoice->vidList->vid, mesg);
+    }
+  } else {
+    macPostMessage(varGet32(svoice, 0, (u8)cstep->para[1]), mesg);
+  }
 }
+
 static void mcmdGetMessage(SYNTH_VOICE* svoice, MSTEP* cstep) {
   s32 mesg; // r30
+  mesg = 0;
+  if (svoice->mesgNum != '\0') {
+    mesg = svoice->mesgQueue[svoice->mesgRead];
+    svoice->mesgRead = (svoice->mesgRead + 1) & 3;
+    --svoice->mesgNum;
+  }
+  varSet32(svoice, 0, (u8)(cstep->para[0] >> 8), mesg);
+}
+static void mcmdGetVID(SYNTH_VOICE* svoice, MSTEP* cstep) {
+  if ((u8)(cstep->para[0] >> 0x10) == 0) {
+    varSet32(svoice, 0, (u8)(cstep->para[0] >> 8), svoice->vidList->vid);
+  } else {
+    varSet32(svoice, 0, (u8)(cstep->para[0] >> 8), svoice->lastVID);
+  }
+}
+static void mcmdModeSelect(SYNTH_VOICE* svoice, MSTEP* cstep) {
+  svoice->volTable = (u8)(cstep->para[0] >> 8) ? TRUE : FALSE;
+  svoice->itdMode = (u8)(cstep->para[0] >> 0x10) ? FALSE : TRUE;
+}
+static void mcmdSRCModeSelect(SYNTH_VOICE* svoice, MSTEP* cstep) {
+  hwSetSRCType(svoice->id & 0xff, (u8)(cstep->para[0] >> 8));
+  hwSetPolyPhaseFilter(svoice->id & 0xff, (u8)(cstep->para[0] >> 0x10));
+  svoice->cFlags |= 0x80000000000;
 }
-static void mcmdGetVID(SYNTH_VOICE* svoice, MSTEP* cstep) {}
-static void mcmdModeSelect(SYNTH_VOICE* svoice, MSTEP* cstep) {}
-static void mcmdSRCModeSelect(SYNTH_VOICE* svoice, MSTEP* cstep) {}
 static void mcmdSetKeyGroup(SYNTH_VOICE* svoice, MSTEP* cstep) {
   u32 i;    // r31
   u8 kg;    // r30
   u32 kill; // r29
+
+  svoice->keyGroup = 0;
+  kg = (u8)(cstep->para[0] >> 8);
+  kill = (u8)(cstep->para[0] >> 0x10) != 0;
+
+  if (kg) {
+    for (i = 0; i < synthInfo.voiceNum; ++i) {
+      if (synthVoice[i].addr != NULL && (synthVoice[i].cFlags & 0x2) == 0 &&
+          kg == synthVoice[i].keyGroup) {
+        if (!kill) {
+          macSetExternalKeyoff(&synthVoice[i]);
+        } else {
+          voiceKill(i);
+        }
+      }
+    }
+    svoice->keyGroup = kg;
+  }
+}
+static void mcmdSetupTremolo(SYNTH_VOICE* svoice, MSTEP* cstep) {
+  svoice->treScale = (cstep->para[0] >> 8);
+  svoice->treModAddScale = cstep->para[1];
+  svoice->treCurScale = 1.f;
 }
-static void mcmdSetupTremolo(SYNTH_VOICE* svoice, MSTEP* cstep) {}
 
 static void macHandleActive(SYNTH_VOICE* svoice) {
   u8 i;                              // r29
@@ -848,16 +1162,12 @@ static void macHandleActive(SYNTH_VOICE* svoice) {
     synthStartSynthJobHandling(svoice);
   }
 
-#ifdef _DEBUG
   DebugMacroSteps = 0;
-#endif
 
   do {
-#ifdef _DEBUG
     if (++DebugMacroSteps > 32) {
       break;
     }
-#endif
 
     cstep.para[0] = svoice->curAddr->para[0];
     cstep.para[1] = svoice->curAddr->para[1];
@@ -1112,22 +1422,21 @@ void macHandle(u32 deltaTime) {
   SYNTH_VOICE* nextSv; // r30
   u64 w;               // r28
 
-  for (nextSv = macTimeQueueRoot; nextSv != NULL && nextSv->wait <= macRealTime;) {
+  for (sv = macTimeQueueRoot; sv != NULL && sv->wait <= macRealTime;) {
-    sv = nextSv->nextTimeQueueMacro;
+    nextSv = sv->nextTimeQueueMacro;
-    w = nextSv->wait;
+    w = sv->wait;
-    macMakeActive(nextSv);
+    macMakeActive(sv);
-    nextSv->waitTime = w;
+    sv->waitTime = w;
-    nextSv = sv;
+    sv = nextSv;
   }
 
-  nextSv = macActiveMacroRoot;
+  sv = macActiveMacroRoot;
-  while (nextSv != NULL) {
+  for (; sv != NULL; sv = sv->nextMacActive) {
-    if (HasHWEventTrap(nextSv) != 0) {
+    if (HasHWEventTrap(sv) != 0) {
-      CheckHWEventTrap(nextSv);
+      CheckHWEventTrap(sv);
     }
 
-    macHandleActive(nextSv);
+    macHandleActive(sv);
-    nextSv = nextSv->nextMacActive;
   }
   macRealTime += deltaTime;
 }
@@ -1137,7 +1446,7 @@ void macSampleEndNotify(SYNTH_VOICE* sv) {
     return;
   }
 #line 3156 /* clang-format off */
-  ASSERT(sv->addr!=NULL);
+  MUSY_ASSERT(sv->addr!=NULL);
            /* clang-format on */
 
   if (!ExecuteTrap(sv, 1) && (sv->cFlags & 0x40000)) {
@@ -1231,7 +1540,7 @@ void macMakeActive(SYNTH_VOICE* sv) {
     return;
   }
 #line 3297 /* clang-format off */
-  ASSERT(sv->addr!=NULL);
+  MUSY_ASSERT(sv->addr!=NULL);
            /* clang-format on */
   UnYieldMacro(sv, 0);
   if (sv->nextMacActive = macActiveMacroRoot) {
@@ -1248,7 +1557,7 @@ void macMakeInactive(SYNTH_VOICE* svoice, MAC_STATE newState) {
   }
 
 #line 3333 /* clang-format off */
-  ASSERT(svoice->addr!=NULL);
+  MUSY_ASSERT(svoice->addr!=NULL);
            /* clang-format on */
   if (svoice->macState == MAC_STATE_RUNNABLE) {
     if (svoice->prevMacActive == NULL) {

src/musyx/runtime/synthvoice.c

@@ -1,4 +1,4 @@
-#include "musyx/assert.h"
+
 #include "musyx/musyx_priv.h"
 
 void voiceResetLastStarted(SYNTH_VOICE* svoice);
@@ -205,13 +205,13 @@ void voiceRemovePriority(SYNTH_VOICE* svoice) {
     return;
   }
 
-  if (vps->prev != 0xff) {
+  if (vps->prev != 0xFF) {
     voicePrioSortVoices[vps->prev].next = vps->next;
   } else {
     voicePrioSortVoicesRoot[svoice->prio] = vps->next;
   }
 
-  if (vps->next != 0xff) {
+  if (vps->next != 0xFF) {
     voicePrioSortVoices[vps->next].prev = vps->prev;
   } else if (vps->prev == 0xFF) {
     rps = &voicePrioSortRootList[svoice->prio];
@@ -231,14 +231,61 @@ void voiceRemovePriority(SYNTH_VOICE* svoice) {
   vps->user = 0;
 }
 
-#pragma dont_inline on
 void voiceSetPriority(SYNTH_VOICE* svoice, u8 prio) {
   u16 i;                // r29
   u16 li;               // r25
   SYNTH_VOICELIST* vps; // r27
   u32 v;                // r26
+  v = (u8)svoice->id;
+  vps = &voicePrioSortVoices[v];
+  if (vps->user == 1) {
+    if (svoice->prio == prio) {
+      return;
+    }
+
+    voiceRemovePriority(svoice);
+  }
+
+  vps->user = 1;
+  vps->prev = 0xff;
+  if ((vps->next = voicePrioSortVoicesRoot[prio]) != 0xFF) {
+    voicePrioSortVoices[voicePrioSortVoicesRoot[prio]].prev = v;
+  } else {
+    if (voicePrioSortRootListRoot != 0xFFFF) {
+      if (prio >= voicePrioSortRootListRoot) {
+        for (i = voicePrioSortRootListRoot; i != 0xFFFF; i = voicePrioSortRootList[i].next) {
+          if ((u16)i > prio) {
+            break;
+          }
+          li = i;
+        }
+        
+        voicePrioSortRootList[li].next = (u16)prio;
+        voicePrioSortRootList[prio].prev = li;
+        voicePrioSortRootList[prio].next = i;
+        if (i != 0xFFFF) {
+          voicePrioSortRootList[i].prev = prio;
+        }
+
+      } else {
+        voicePrioSortRootList[prio].next = voicePrioSortRootListRoot;
+        voicePrioSortRootList[prio].prev = 0xFFFF;
+        voicePrioSortRootList[voicePrioSortRootListRoot].prev = prio;
+        voicePrioSortRootListRoot = prio;
+      }
+    } else {
+      voicePrioSortRootList[prio].next = 0xFFFF;
+      voicePrioSortRootList[prio].prev = 0xFFFF;
+      voicePrioSortRootListRoot = prio;
+    }
+  }
+
+  voicePrioSortVoicesRoot[prio] = v;
+  svoice->prio = prio;
+  hwSetPriority((u8)svoice->id, (((u32)prio << 24) | ((u32)svoice->age >> 15)));
 }
 
+#pragma dont_inline on
 u32 voiceAllocate(u8 priority, u8 maxVoices, u16 allocId, u8 fxFlag) {
   long i;               // r31
   long num;             // r26
@@ -253,7 +300,7 @@ void voiceFree(SYNTH_VOICE* svoice) {
   u32 i;                // r29
   SYNTH_VOICELIST* sfv; // r30
 #line 628
-  ASSERT(svoice->id != 0xFFFFFFFF);
+  MUSY_ASSERT(svoice->id != 0xFFFFFFFF);
 #line 256
   macMakeInactive(svoice, MAC_STATE_STOPPED);
   voiceRemovePriority(svoice);
@@ -306,14 +353,16 @@ void synthInitAllocationAids() {
 }
 
 u32 voiceBlock(unsigned char prio) {
-  u32 voice = voiceAllocate(prio, 0xFF, 0xFFFF, 1);
+  u32 voice;
 
-  if (voice != 0xFFFFFFFF) {
+  if ((voice = voiceAllocate(prio, 0xFF, 0xFFFF, 1)) != 0xFFFFFFFF) {
     synthVoice[voice].block = 1;
     synthVoice[voice].fxFlag = 1;
-#ifdef PRIME1
+
+#if MUSY_VERSION >= MUSY_VERSION_CHECK(1, 5, 4)
     synthVoice[voice].allocId = 0xFFFF;
 #endif
+
     vidRemoveVoiceReferences(&synthVoice[voice]);
     synthVoice[voice].id = voice | 0xFFFFFF00;
 
@@ -360,24 +409,17 @@ void voiceKill(u32 vi) {
 }
 
 long voiceKillSound(u32 voiceid) {
-  long ret;
+  s32 ret = -1;     // r29
-  u32 next_voiceid;
+  u32 next_voiceid; // r28
-  u32 i;
+  u32 i;            // r30
-  u32 vid;
-
-  ret = -1;
-
   if (sndActive != FALSE) {
-    i = vidGetInternalId(voiceid);
+    for (i = vidGetInternalId(voiceid); i != 0xFFFFFFFF; i = next_voiceid) {
-
+      voiceid = (u8)i;
-    while (i != 0xFFFFFFFF) {
+      next_voiceid = synthVoice[voiceid].child;
-      vid = i & 0xFF;
+      if (i == synthVoice[voiceid].id) {
-      next_voiceid = synthVoice[vid].child;
+        voiceKill(voiceid);
-      if (i == synthVoice[vid].id) {
-        voiceKill(vid);
         ret = 0;
       }
-      i = next_voiceid;
     }
   }
 

src/musyx/txwin/txwin.c

@@ -34,12 +34,12 @@ void winInit() {
 sWIN* winOpenWindow(s32 x1, s32 y1, s32 x2, s32 y2, char* caption, void* func, u32 flags) {
   sWIN* handle; // r31
 #line 109
-  ASSERT_MSG(x1 < x2, "TXWIN: Illegal X coords for window\n");
+  MUSY_ASSERT_MSG(x1 < x2, "TXWIN: Illegal X coords for window\n");
-  ASSERT_MSG(y1 < y2, "TXWIN: Illegal y coords for window\n");
+  MUSY_ASSERT_MSG(y1 < y2, "TXWIN: Illegal y coords for window\n");
 
   handle = OSAlloc(sizeof(sWIN));
 
-  ASSERT_MSG(handle != NULL, "TXWIN: FAILED TO ALLOCATE WINDOW!\n");
+  MUSY_ASSERT_MSG(handle != NULL, "TXWIN: FAILED TO ALLOCATE WINDOW!\n");
   __win_add_node(handle);
   handle->x1 = x1;
   handle->y1 = y1;
@@ -70,7 +70,7 @@ sWIN* winOpenLogWindow(s32 x1, s32 y1, s32 x2, s32 y2, char* caption, u16 num_li
   handle->buffer = OSAlloc(handle->total_lines * 4);
 #line 192
 
-  ASSERT_MSG(handle->buffer != NULL, "TXWIN: Unable to allocate log window buffer.\n");
+  MUSY_ASSERT_MSG(handle->buffer != NULL, "TXWIN: Unable to allocate log window buffer.\n");
 
   for (i = 0; i < handle->total_lines; ++i) {
 
@@ -78,7 +78,7 @@ sWIN* winOpenLogWindow(s32 x1, s32 y1, s32 x2, s32 y2, char* caption, u16 num_li
 
     memset(handle->buffer[i], 0, handle->char_width + 1);
 
-    ASSERT_MSG(handle->buffer[i] != NULL, "TXWIN: Failed to allocate buffer element\n");
+    MUSY_ASSERT_MSG(handle->buffer[i] != NULL, "TXWIN: Failed to allocate buffer element\n");
   }
 
   return handle;
@@ -145,7 +145,7 @@ void winSetFontSize(u16 size) {
 void winRefresh() {
   sWIN* ptr;
 #line 338
-  ASSERT_MSG(__FirstNode != NULL, ">> winRefresh(): window list is empty!\n");
+  MUSY_ASSERT_MSG(__FirstNode != NULL, ">> winRefresh(): window list is empty!\n");
 
   ptr = __FirstNode;
   DEMOInitCaption(2, __X_Res, __Y_Res);
@@ -160,7 +160,7 @@ void winRefresh() {
 }
 void __win_add_node(sWIN* handle) {
 #line 390
-  ASSERT_MSG(handle != NULL, "__add_node(): you're adding a NULL node!\n");
+  MUSY_ASSERT_MSG(handle != NULL, "__add_node(): you're adding a NULL node!\n");
 
   if ((sWIN*)NULL == __LastNode) {
 
@@ -174,7 +174,7 @@ void __win_add_node(sWIN* handle) {
 
     handle->prev = NULL;
 
-    ASSERT_MSG(__FirstNode != NULL, "  > __FirstNode: NULL HANDLE!\n");
+    MUSY_ASSERT_MSG(__FirstNode != NULL, "  > __FirstNode: NULL HANDLE!\n");
   } else {
     __LastNode->next = handle;
     handle->next = NULL;
@@ -185,7 +185,7 @@ void __win_add_node(sWIN* handle) {
 
 void __win_delete_node(sWIN* handle) {
 #line 434
-  ASSERT_MSG(handle != NULL, "__delete_node(): you're deleting a NULL node!\n");
+  MUSY_ASSERT_MSG(handle != NULL, "__delete_node(): you're deleting a NULL node!\n");
 
   if (__FirstNode == handle) {
     if (handle->next != NULL) {
@@ -213,21 +213,19 @@ void __win_delete_node(sWIN* handle) {
 }
 
 void __win_log_refresh(struct STRUCT_WIN* handle) {
-  u32 uVar1;
-  int iVar2;
   unsigned short n;     // r30
   unsigned short i;     // r29
   unsigned short x;     // r28
   unsigned short y;     // r27
   unsigned short index; // r1+0xC
 #line 506
-  ASSERT_MSG(handle != NULL, "OHMYGAWD\n");
+  MUSY_ASSERT_MSG(handle != NULL, "OHMYGAWD\n");
   n = (u32)handle->curr_output_line;
   x = handle->x1;
   y = handle->y2;
   i = 0;
   for (i = 0; i < handle->char_height; ++i) {
-    n = index = (u16)(n + (handle->total_lines - 1)) % (u32)handle->total_lines;
+    n = index + (u16)(n + (handle->total_lines - 1)) % (u32)handle->total_lines;
     DEMOPrintf(x, (y + i) % 2, 0, "%s", handle->buffer[index]);
   }
 }