Leahnaya/pokediamond
1
0
Fork 0
mirror of https://github.com/pret/pokediamond.git synced 2026-09-30 12:26:48 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge branch 'master' of https://github.com/martmists/pokediamond

Browse Source
This commit is contained in:
red031000
2020-05-29 18:45:08 +01:00
parent 83d33f36fc d6fd8d1ed9
commit 0d8876b37a
22 changed files with 1645 additions and 1836 deletions
Download Patch File Download Diff File Expand all files Collapse all files

82
arm9/asm/SND_alarm.s
View File

@@ -1,82 +0,0 @@
.include "asm/macros.inc"
.include "global.inc"
.section .bss
.global UNK_021D5300
UNK_021D5300: ; 0x021D5300
.space 0x60
.text
arm_func_start SNDi_CallAlarmHandler
SNDi_CallAlarmHandler: ; 0x020CF4B0
stmdb sp!, {lr}
sub sp, sp, #0x4
ldr r3, _020CF50C ; =UNK_021D5300
and r2, r0, #0xff
mov r1, #0xc
mla r3, r2, r1, r3
mov r1, r0, asr #0x8
ldrb r0, [r3, #0x8]
and r1, r1, #0xff
cmp r1, r0
addne sp, sp, #0x4
ldmneia sp!, {lr}
bxne lr
ldr r1, [r3, #0x0]
cmp r1, #0x0
addeq sp, sp, #0x4
ldmeqia sp!, {lr}
bxeq lr
ldr r0, [r3, #0x4]
blx r1
add sp, sp, #0x4
ldmia sp!, {lr}
bx lr
.balign 4
_020CF50C: .word UNK_021D5300
arm_func_start SNDi_SetAlarmHandler
SNDi_SetAlarmHandler:
mov r3, #0xc
mul r3, r0, r3
ldr r0, _020CF53C ; =UNK_021D5300
str r1, [r0, r3]
add r1, r0, r3
str r2, [r1, #0x4]
ldrb r0, [r1, #0x8]
add r0, r0, #0x1
strb r0, [r1, #0x8]
ldrb r0, [r1, #0x8]
bx lr
.balign 4
_020CF53C: .word UNK_021D5300
arm_func_start SNDi_IncAlarmId
SNDi_IncAlarmId: ; 0x020CF540
ldr r2, _020CF55C ; =UNK_021D5300
mov r1, #0xc
mla r1, r0, r1, r2
ldrb r0, [r1, #0x8]
add r0, r0, #0x1
strb r0, [r1, #0x8]
bx lr
.balign 4
_020CF55C: .word UNK_021D5300
arm_func_start SND_AlarmInit
SND_AlarmInit: ; 0x020CF560
ldr r1, _020CF58C ; =UNK_021D5300
mov r2, #0x0
mov r0, r2
_020CF56C:
str r0, [r1, #0x0]
str r0, [r1, #0x4]
add r2, r2, #0x1
strb r0, [r1, #0x8]
cmp r2, #0x8
add r1, r1, #0xc
blt _020CF56C
bx lr
.balign 4
_020CF58C: .word UNK_021D5300

328
arm9/asm/SND_bank.s
View File

@@ -1,328 +0,0 @@
.include "asm/macros.inc"
.include "global.inc"
.text
arm_func_start SND_GetWaveDataAddress
SND_GetWaveDataAddress: ; 0x020CF768
stmdb sp!, {r4-r5,lr}
sub sp, sp, #0x4
mov r5, r0
mov r4, r1
bl SNDi_LockMutex
add r0, r5, r4, lsl #0x2
ldr r4, [r0, #0x3c]
cmp r4, #0x0
beq _020CF798
cmp r4, #0x2000000
addcc r4, r5, r4
b _020CF79C
_020CF798:
mov r4, #0x0
_020CF79C:
bl SNDi_UnlockMutex
mov r0, r4
add sp, sp, #0x4
ldmia sp!, {r4-r5,lr}
bx lr
arm_func_start SND_SetWaveDataAddress
SND_SetWaveDataAddress: ; 0x020CF7B0
stmdb sp!, {r4-r6,lr}
mov r6, r0
mov r5, r1
mov r4, r2
bl SNDi_LockMutex
add r0, r6, #0x3c
add r2, r6, r5, lsl #0x2
add r0, r0, r5, lsl #0x2
mov r1, #0x4
str r4, [r2, #0x3c]
bl DC_StoreRange
bl SNDi_UnlockMutex
ldmia sp!, {r4-r6,lr}
bx lr
arm_func_start SND_GetWaveDataCount
SND_GetWaveDataCount: ; 0x020CF7E8
ldr r0, [r0, #0x38]
bx lr
arm_func_start SND_GetNextInstData
SND_GetNextInstData: ; 0x020CF7F0
stmdb sp!, {r4-r5,lr}
sub sp, sp, #0x4
ldr r4, [r2, #0x0]
ldr r3, [r0, #0x38]
cmp r4, r3
bhs _020CF9B8
mov r12, #0x0
_020CF80C:
add r3, r0, r4, lsl #0x2
ldr r4, [r3, #0x3c]
strb r4, [r1, #0x0]
ldrb r3, [r1, #0x0]
cmp r3, #0x10
bgt _020CF850
cmp r3, #0x10
bge _020CF8A8
cmp r3, #0x5
addls pc, pc, r3, lsl #0x2
b _020CF998
_020CF838:
b _020CF998
b _020CF85C
b _020CF85C
b _020CF85C
b _020CF85C
b _020CF85C
_020CF850:
cmp r3, #0x11
beq _020CF924
b _020CF998
_020CF85C:
mov r3, r4, lsr #0x8
add r5, r0, r4, lsr #0x8
ldrh r4, [r0, r3]
ldrh r3, [r5, #0x2]
add sp, sp, #0x4
mov r0, #0x1
strh r4, [r1, #0x2]
strh r3, [r1, #0x4]
ldrh r4, [r5, #0x4]
ldrh r3, [r5, #0x6]
strh r4, [r1, #0x6]
strh r3, [r1, #0x8]
ldrh r3, [r5, #0x8]
strh r3, [r1, #0xA]
ldr r1, [r2]
add r1, r1, #0x1
str r1, [r2]
ldmia sp!, {r4-r5,lr}
bx lr
_020CF8A8:
add r5, r0, r4, lsr #0x8
b _020CF904
_020CF8B0:
mov r0, #0xc
mla r12, lr, r0, r5
ldrh r4, [r12, #0x2]
ldrh r3, [r12, #0x4]
add sp, sp, #0x4
mov r0, #0x1
strh r4, [r1, #0x0]
strh r3, [r1, #0x2]
ldrh r4, [r12, #0x6]
ldrh r3, [r12, #0x8]
strh r4, [r1, #0x4]
strh r3, [r1, #0x6]
ldrh r4, [r12, #0xa]
ldrh r3, [r12, #0xc]
strh r4, [r1, #0x8]
strh r3, [r1, #0xa]
ldr r1, [r2, #0x4]
add r1, r1, #0x1
str r1, [r2, #0x4]
ldmia sp!, {r4-r5,lr}
bx lr
_020CF904:
ldrb r4, [r5, #0x1]
ldrb r3, [r5, #0x0]
ldr lr, [r2, #0x4]
sub r3, r4, r3
add r3, r3, #0x1
cmp lr, r3
blo _020CF8B0
b _020CF998
_020CF924:
add r4, r0, r4, lsr #0x8
b _020CF98C
_020CF92C:
ldrb lr, [r4, r3]
cmp lr, #0x0
beq _020CF998
mov r0, #0xc
mla lr, r3, r0, r4
ldrh r12, [lr, #0x8]
ldrh r3, [lr, #0xa]
add sp, sp, #0x4
mov r0, #0x1
strh r12, [r1, #0x0]
strh r3, [r1, #0x2]
ldrh r12, [lr, #0xc]
ldrh r3, [lr, #0xe]
strh r12, [r1, #0x4]
strh r3, [r1, #0x6]
ldrh r12, [lr, #0x10]
ldrh r3, [lr, #0x12]
strh r12, [r1, #0x8]
strh r3, [r1, #0xa]
ldr r1, [r2, #0x4]
add r1, r1, #0x1
str r1, [r2, #0x4]
ldmia sp!, {r4-r5,lr}
bx lr
_020CF98C:
ldr r3, [r2, #0x4]
cmp r3, #0x8
blo _020CF92C
_020CF998:
ldr r3, [r2, #0x0]
add r3, r3, #0x1
str r3, [r2, #0x0]
str r12, [r2, #0x4]
ldr r4, [r2, #0x0]
ldr r3, [r0, #0x38]
cmp r4, r3
blo _020CF80C
_020CF9B8:
mov r0, #0x0
add sp, sp, #0x4
ldmia sp!, {r4-r5,lr}
bx lr
arm_func_start SND_GetFirstInstDataPos
SND_GetFirstInstDataPos: ; 0x020CF9C8
sub sp, sp, #0x8
mov r1, #0x0
str r1, [sp, #0x0]
str r1, [sp, #0x4]
str r1, [r0, #0x0]
str r1, [r0, #0x4]
add sp, sp, #0x8
bx lr
arm_func_start SND_DestroyWaveArc
SND_DestroyWaveArc: ; 0x020CF9E8
stmdb sp!, {r4-r6,lr}
mov r4, r0
bl SNDi_LockMutex
ldr r0, [r4, #0x18]
cmp r0, #0x0
beq _020CFA28
mov r5, #0x0
mov r4, #0x8
_020CFA08:
ldr r6, [r0, #0x4]
mov r1, r4
str r5, [r0, #0x0]
str r5, [r0, #0x4]
bl DC_StoreRange
mov r0, r6
cmp r6, #0x0
bne _020CFA08
_020CFA28:
bl SNDi_UnlockMutex
ldmia sp!, {r4-r6,lr}
bx lr
arm_func_start SND_DestroyBank
SND_DestroyBank: ; 0x020CFA34
stmdb sp!, {r4-r8,lr}
mov r7, r0
bl SNDi_LockMutex
add r5, r7, #0x18
mov r6, #0x0
mov r8, #0x8
mov r4, #0x3c
_020CFA50:
add r1, r7, r6, lsl #0x3
ldr r0, [r1, #0x18]
cmp r0, #0x0
beq _020CFAB8
ldr r3, [r0, #0x18]
cmp r5, r3
bne _020CFA80
ldr r2, [r1, #0x1c]
mov r1, r4
str r2, [r0, #0x18]
bl DC_StoreRange
b _020CFAB8
_020CFA80:
cmp r3, #0x0
beq _020CFAA0
_020CFA88:
ldr r0, [r3, #0x4]
cmp r5, r0
beq _020CFAA0
mov r3, r0
cmp r0, #0x0
bne _020CFA88
_020CFAA0:
add r0, r7, r6, lsl #0x3
ldr r2, [r0, #0x1c]
mov r0, r3
mov r1, r8
str r2, [r3, #0x4]
bl DC_StoreRange
_020CFAB8:
add r6, r6, #0x1
cmp r6, #0x4
add r5, r5, #0x8
blt _020CFA50
bl SNDi_UnlockMutex
ldmia sp!, {r4-r8,lr}
bx lr
arm_func_start SND_AssignWaveArc
SND_AssignWaveArc: ; 0x020CFAD4
stmdb sp!, {r4-r6,lr}
mov r6, r0
mov r5, r1
mov r4, r2
bl SNDi_LockMutex
add r3, r6, r5, lsl #0x3
ldr r2, [r3, #0x18]
mov r12, r5, lsl #0x3
cmp r2, #0x0
beq _020CFB70
cmp r4, r2
bne _020CFB10
bl SNDi_UnlockMutex
ldmia sp!, {r4-r6,lr}
bx lr
_020CFB10:
add r1, r6, #0x18
ldr r0, [r2, #0x18]
add r12, r1, r12
cmp r12, r0
bne _020CFB3C
ldr r0, [r3, #0x1c]
mov r1, #0x3c
str r0, [r2, #0x18]
ldr r0, [r3, #0x18]
bl DC_StoreRange
b _020CFB70
_020CFB3C:
cmp r0, #0x0
beq _020CFB5C
_020CFB44:
ldr r1, [r0, #0x4]
cmp r12, r1
beq _020CFB5C
mov r0, r1
cmp r1, #0x0
bne _020CFB44
_020CFB5C:
add r1, r6, r5, lsl #0x3
ldr r2, [r1, #0x1c]
mov r1, #0x8
str r2, [r0, #0x4]
bl DC_StoreRange
_020CFB70:
add r0, r6, #0x18
ldr r1, [r4, #0x18]
add r0, r0, r5, lsl #0x3
str r0, [r4, #0x18]
add r0, r6, r5, lsl #0x3
str r1, [r0, #0x1c]
str r4, [r0, #0x18]
bl SNDi_UnlockMutex
mov r0, r6
mov r1, #0x3c
bl DC_StoreRange
mov r0, r4
mov r1, #0x3c
bl DC_StoreRange
ldmia sp!, {r4-r6,lr}
bx lr

677
arm9/asm/SND_command.s
View File

@@ -1,677 +0,0 @@
.include "asm/macros.inc"
.include "global.inc"
.extern UNK_021D5360
.section .bss
.global UNK_021D3838
UNK_021D3838: ; 0x021D3838
.space 0x4
.global UNK_021D383C
UNK_021D383C: ; 0x021D383C
.space 0x4
.global UNK_021D3840
UNK_021D3840: ; 0x021D3840
.space 0x4
.global UNK_021D3844
UNK_021D3844: ; 0x021D3844
.space 0x4
.global UNK_021D3848
UNK_021D3848: ; 0x021D3848
.space 0x4
.global UNK_021D384C
UNK_021D384C: ; 0x021D384C
.space 0x4
.global UNK_021D3850
UNK_021D3850: ; 0x021D3850
.space 0x4
.global UNK_021D3854
UNK_021D3854: ; 0x021D3854
.space 0x4
.global UNK_021D3858
UNK_021D3858: ; 0x021D3858
.space 0x4
.global UNK_021D385C
UNK_021D385C: ; 0x021D385C
.space 0x24
.global UNK_021D3880
UNK_021D3880: ; 0x021D3880
.space 0x280
.global UNK_021D3B00
UNK_021D3B00: ; 0x021D3B00
.space 0x1000
.global UNK_021D4B00
UNK_021D4B00: ; 0x021D4B00
.space 0x7e8
.global UNK_021D52E8
UNK_021D52E8: ; 0x021D52E8
.space 0x18
.text
arm_func_start IsCommandAvailable
IsCommandAvailable:
stmdb sp!, {r4,lr}
bl OS_IsRunOnEmulator
_020CEC94:
cmp r0, #0x0
moveq r0, #0x1
ldmeqia sp!, {r4, lr}
bxeq lr
bl OS_DisableInterrupts
ldr r1, _020CECD0
mov r2, #0x10
str r2, [r1]
ldr r4, [r1]
bl OS_RestoreInterrupts
cmp r4, #0x0
movne r0, #0x1
moveq r0, #0x0
ldmia sp!, {r4, lr}
bx lr
_020CECD0: .word 0x04FFF200
arm_func_start AllocCommand
AllocCommand: ; 0x020CECD4
stmdb sp!, {r4,lr}
bl OS_DisableInterrupts
ldr r1, _020CED24 ; =UNK_021D3838
ldr r4, [r1, #0x0]
cmp r4, #0x0
bne _020CECFC
bl OS_RestoreInterrupts
_020CECF0:
mov r0, #0x0
ldmia sp!, {r4, lr}
bx lr
_020CECFC:
ldr r2, [r4, #0x0]
str r2, [r1, #0x0]
cmp r2, #0x0
ldreq r1, _020CED28 ; =UNK_021D3848
moveq r2, #0x0
streq r2, [r1, #0x0]
bl OS_RestoreInterrupts
mov r0, r4
ldmia sp!, {r4,lr}
bx lr
.balign 4
_020CED24: .word UNK_021D3838
_020CED28: .word UNK_021D3848
arm_func_start RequestCommandProc
RequestCommandProc: ; 0x020CED2C
stmdb sp!, {r4-r5,lr}
sub sp, sp, #0x4
mov r5, #0x7
mov r4, #0x0
_020CED3C:
mov r0, r5
mov r1, r4
mov r2, r4
bl PXI_SendWordByFifo
_020CED4C:
cmp r0, #0
blt _020CED3C
add sp, sp, #0x4
ldmia sp!, {r4-r5,lr}
bx lr
arm_func_start InitPXI
InitPXI: ; 0x020CED60
stmdb sp!, {r4-r6,lr}
ldr r1, _020CEDC8 ; =PxiFifoCallback
mov r0, #0x7
bl PXI_SetFifoRecvCallback
bl IsCommandAvailable
_020CED74:
cmp r0, #0x0
ldmeqia sp!, {r4-r6, lr}
bxeq lr
mov r0, #0x7
mov r1, #0x1
bl PXI_IsCallbackReady
cmp r0, #0x0
ldmneia sp!, {r4-r6, lr}
bxne lr
mov r6, #0x64
mov r5, #0x7
mov r4, #0x1
_020CEDA4:
mov r0, r6
bl OS_SpinWait
mov r0, r5
mov r1, r4
bl PXI_IsCallbackReady
cmp r0, #0x0
beq _020CEDA4
ldmia sp!, {r4-r6, lr}
bx lr
_020CEDC8: .word PxiFifoCallback
arm_func_start PxiFifoCallback
PxiFifoCallback: ; 0x020CEDCC
stmdb sp!, {r4-r5,lr}
sub sp, sp, #0x4
mov r5, r1
bl OS_DisableInterrupts
mov r4, r0
mov r0, r5
bl SNDi_CallAlarmHandler
mov r0, r4
bl OS_RestoreInterrupts
add sp, sp, #0x4
ldmia sp!, {r4-r5,lr}
bx lr
arm_func_start SND_CountWaitingCommand
SND_CountWaitingCommand: ; 0x020CEDFC
stmdb sp!, {r4,lr}
bl SND_CountFreeCommand
mov r4, r0
bl SND_CountReservedCommand
rsb r1, r4, #0x100
sub r0, r1, r0
ldmia sp!, {r4,lr}
bx lr
arm_func_start SND_CountReservedCommand
SND_CountReservedCommand: ; 0x020CEE1C
stmdb sp!, {r4,lr}
bl OS_DisableInterrupts
ldr r1, _020CEE58 ; =UNK_021D3840
mov r4, #0x0
ldr r1, [r1, #0x0]
cmp r1, #0x0
beq _020CEE48
_020CEE38:
ldr r1, [r1, #0x0]
add r4, r4, #0x1
cmp r1, #0x0
bne _020CEE38
_020CEE48:
bl OS_RestoreInterrupts
mov r0, r4
ldmia sp!, {r4,lr}
bx lr
.balign 4
_020CEE58: .word UNK_021D3840
arm_func_start SND_CountFreeCommand
SND_CountFreeCommand: ; 0x020CEE5C
stmdb sp!, {r4,lr}
bl OS_DisableInterrupts
ldr r1, _020CEE98 ; =UNK_021D3838
mov r4, #0x0
ldr r1, [r1, #0x0]
cmp r1, #0x0
beq _020CEE88
_020CEE78:
ldr r1, [r1, #0x0]
add r4, r4, #0x1
cmp r1, #0x0
bne _020CEE78
_020CEE88:
bl OS_RestoreInterrupts
mov r0, r4
ldmia sp!, {r4,lr}
bx lr
.balign 4
_020CEE98: .word UNK_021D3838
arm_func_start SND_IsFinishedCommandTag
SND_IsFinishedCommandTag:
stmdb sp!, {r4,lr}
mov r4, r0
bl OS_DisableInterrupts
ldr r1, _020CEEEC ; =UNK_021D383C
ldr r1, [r1, #0x0]
cmp r4, r1
bls _020CEECC
sub r1, r4, r1
cmp r1, #0x80000000
movcc r4, #0x0
movcs r4, #0x1
b _020CEEDC
_020CEECC:
sub r1, r1, r4
cmp r1, #0x80000000
movcc r4, #0x1
movcs r4, #0x0
_020CEEDC:
bl OS_RestoreInterrupts
mov r0, r4
ldmia sp!, {r4,lr}
bx lr
.balign 4
_020CEEEC: .word UNK_021D383C
arm_func_start SND_GetCurrentCommandTag
SND_GetCurrentCommandTag: ; 0x020CEEF0
stmdb sp!, {r4,lr}
bl OS_DisableInterrupts
ldr r1, _020CEF24 ; =UNK_021D3840
ldr r1, [r1, #0x0]
cmp r1, #0x0
ldreq r1, _020CEF28 ; =UNK_021D383C
ldreq r4, [r1, #0x0]
ldrne r1, _020CEF2C ; =UNK_021D3858
ldrne r4, [r1, #0x0]
bl OS_RestoreInterrupts
mov r0, r4
ldmia sp!, {r4,lr}
bx lr
.balign 4
_020CEF24: .word UNK_021D3840
_020CEF28: .word UNK_021D383C
_020CEF2C: .word UNK_021D3858
arm_func_start SND_WaitForCommandProc
SND_WaitForCommandProc: ; 0x020CEF30
stmdb sp!, {r4-r5,lr}
sub sp, sp, #0x4
mov r5, r0
bl SND_IsFinishedCommandTag
_020CEF40:
cmp r0, #0x0
addne sp, sp, #0x4
ldmneia sp!, {r4-r5, lr}
bxne lr
mov r4, #0x0
_020CEF54:
mov r0, r4
bl SND_RecvCommandReply
cmp r0, #0x0
bne _020CEF54
mov r0, r5
bl SND_IsFinishedCommandTag
cmp r0, #0x0
addne sp, sp, #0x4
ldmneia sp!, {r4-r5, lr}
bxne lr
bl RequestCommandProc
mov r0, r5
bl SND_IsFinishedCommandTag
cmp r0, #0x0
addne sp, sp, #0x4
ldmneia sp!, {r4-r5, lr}
bxne lr
mov r4, #0x1
_020CEF9C:
mov r0, r4
bl SND_RecvCommandReply
mov r0, r5
bl SND_IsFinishedCommandTag
cmp r0, #0x0
beq _020CEF9C
add sp, sp, #0x4
ldmia sp!, {r4-r5, lr}
bx lr
arm_func_start SND_FlushCommand
SND_FlushCommand: ; 0x020CEFC0
stmdb sp!, {r4-r9,lr}
sub sp, sp, #0x4
mov r5, r0
bl OS_DisableInterrupts
ldr r1, _020CF164 ; =UNK_021D3840
mov r4, r0
ldr r1, [r1, #0x0]
cmp r1, #0x0
bne _020CEFF8
bl OS_RestoreInterrupts
add sp, sp, #0x4
mov r0, #0x1
ldmia sp!, {r4-r9,lr}
bx lr
_020CEFF8:
ldr r1, _020CF168 ; =UNK_021D3854
ldr r1, [r1, #0x0]
cmp r1, #0x8
blt _020CF03C
ands r1, r5, #0x1
bne _020CF024
bl OS_RestoreInterrupts
add sp, sp, #0x4
mov r0, #0x0
ldmia sp!, {r4-r9,lr}
bx lr
_020CF024:
mov r0, #0x1
bl SND_RecvCommandReply
ldr r0, _020CF168 ; =UNK_021D3854
ldr r0, [r0, #0x0]
cmp r0, #0x8
bge _020CF024
_020CF03C:
ldr r0, _020CF16C ; =UNK_021D3B00
mov r1, #0x1800
bl DC_FlushRange
ldr r1, _020CF164 ; =UNK_021D3840
mov r0, #0x7
ldr r1, [r1, #0x0]
mov r2, #0x0
bl PXI_SendWordByFifo
_020CF05C:
cmp r0, #0x0
bge _020CF0E0
ands r0, r5, #0x1
bne _020CF084
mov r0, r4
bl OS_RestoreInterrupts
add sp, sp, #0x4
mov r0, #0x0
ldmia sp!, {r4-r9, lr}
bx lr
_020CF084:
ldr r1, _020CF164
mov r0, #0x7
ldr r1, [r1]
mov r2, #0x0
bl PXI_SendWordByFifo
cmp r0, #0x0
bge _020CF0E0
ldr r6, _020CF164
mov r9, #0x64
mov r8, #0x7
mov r7, #0x0
_020CF0B0:
mov r0, r4
bl OS_RestoreInterrupts
mov r0, r9
bl OS_SpinWait
bl OS_DisableInterrupts
mov r4, r0
mov r0, r8
ldr r1, [r6]
mov r2, r7
bl PXI_SendWordByFifo
cmp r0, #0x0
blt _020CF0B0
_020CF0E0:
ands r0, r5, #0x2
beq _020CF0EC
bl RequestCommandProc
_020CF0EC:
ldr r0, _020CF170
ldr r1, _020CF164
ldr r3, [r0]
ldr r5, [r1]
add r1, r3, #0x1
ldr r2, _020CF174
str r1, [r0]
str r5, [r2, r3, lsl #2]
cmp r1, #0x8
movgt r1, #0x0
ldr r2, _020CF168
strgt r1, [r0]
ldr r1, _020CF178
ldr r3, [r2]
ldr r0, [r1]
add ip, r3, #0x1
add r6, r0, #0x1
ldr r5, _020CF164
mov lr, #0x0
ldr r3, _020CF17C
mov r0, r4
str lr, [r5]
str lr, [r3]
str ip, [r2]
str r6, [r1]
bl OS_RestoreInterrupts
mov r0, #0x1
add sp, sp, #0x4
ldmia sp!, {r4-r9, lr}
bx lr
_020CF164: .word UNK_021D3840
_020CF168: .word UNK_021D3854
_020CF16C: .word UNK_021D3B00
_020CF170: .word UNK_021D3850
_020CF174: .word UNK_021D385C
_020CF178: .word UNK_021D3858
_020CF17C: .word UNK_021D3844
arm_func_start SND_PushCommand
SND_PushCommand: ; 0x020CF180
stmdb sp!, {r4,lr}
mov r4, r0
bl OS_DisableInterrupts
ldr r2, _020CF1C0 ; =UNK_021D3844
ldr r1, [r2, #0x0]
cmp r1, #0x0
ldreq r1, _020CF1C4 ; =UNK_021D3840
streq r4, [r2, #0x0]
streq r4, [r1, #0x0]
strne r4, [r1, #0x0]
strne r4, [r2, #0x0]
mov r1, #0x0
str r1, [r4, #0x0]
bl OS_RestoreInterrupts
ldmia sp!, {r4,lr}
bx lr
.balign 4
_020CF1C0: .word UNK_021D3844
_020CF1C4: .word UNK_021D3840
arm_func_start SND_AllocCommand
SND_AllocCommand:
stmdb sp!, {r4,lr}
mov r4, r0
bl IsCommandAvailable
_020CF1D4:
cmp r0, #0x0
moveq r0, #0x0
ldmeqia sp!, {r4,lr}
bxeq lr
bl AllocCommand
cmp r0, #0x0
ldmneia sp!, {r4,lr}
bxne lr
ands r0, r4, #0x1
moveq r0, #0x0
ldmeqia sp!, {r4,lr}
bxeq lr
bl SND_CountWaitingCommand
cmp r0, #0x0
ble _020CF238
mov r4, #0x0
_020CF214:
mov r0, r4
bl SND_RecvCommandReply
cmp r0, #0x0
bne _020CF214
bl AllocCommand
cmp r0, #0x0
beq _020CF240
ldmia sp!, {r4,lr}
bx lr
_020CF238:
mov r0, #0x1
bl SND_FlushCommand
_020CF240:
bl RequestCommandProc
mov r4, #0x1
_020CF248:
mov r0, r4
bl SND_RecvCommandReply
bl AllocCommand
cmp r0, #0x0
beq _020CF248
ldmia sp!, {r4,lr}
bx lr
arm_func_start SND_RecvCommandReply
SND_RecvCommandReply: ; 0x020CF264
stmdb sp!, {r4-r6,lr}
mov r4, r0
bl OS_DisableInterrupts
mov r5, r0
ands r0, r4, #0x1
beq _020CF2C0
bl SNDi_GetFinishedCommandTag
ldr r4, _020CF380 ; =UNK_021D383C
ldr r1, [r4, #0x0]
cmp r1, r0
bne _020CF2E8
mov r6, #0x64
_020CF294:
mov r0, r5
bl OS_RestoreInterrupts
mov r0, r6
bl OS_SpinWait
bl OS_DisableInterrupts
mov r5, r0
bl SNDi_GetFinishedCommandTag
ldr r1, [r4, #0x0]
cmp r1, r0
beq _020CF294
b _020CF2E8
_020CF2C0:
bl SNDi_GetFinishedCommandTag
ldr r1, _020CF380 ; =UNK_021D383C
ldr r1, [r1, #0x0]
cmp r1, r0
bne _020CF2E8
mov r0, r5
bl OS_RestoreInterrupts
_020CF2DC:
mov r0, #0x0
ldmia sp!, {r4-r6, lr}
bx lr
_020CF2E8:
ldr r0, _020CF384 ; =UNK_021D384C
ldr r2, _020CF388 ; =UNK_021D385C
ldr r3, [r0, #0x0]
add r1, r3, #0x1
ldr r4, [r2, r3, lsl #0x2]
str r1, [r0, #0x0]
cmp r1, #0x8
movgt r1, #0x0
strgt r1, [r0, #0x0]
ldr r0, [r4, #0x0]
mov r1, r4
cmp r0, #0x0
beq _020CF32C
_020CF31C:
ldr r1, [r1, #0x0]
ldr r0, [r1, #0x0]
cmp r0, #0x0
bne _020CF31C
_020CF32C:
ldr r0, _020CF38C ; =UNK_021D3848
ldr r3, _020CF390 ; =UNK_021D3854
ldr r0, [r0, #0x0]
ldr r2, _020CF380 ; =UNK_021D383C
cmp r0, #0x0
strne r4, [r0, #0x0]
ldreq r0, _020CF394 ; =UNK_021D3838
ldr lr, [r3, #0x0]
streq r4, [r0, #0x0]
ldr ip, _020CF38C ; =UNK_021D3848
sub r6, lr, #0x1
ldr r0, [r2, #0x0]
str r1, [r12, #0x0]
add lr, r0, #0x1
mov r0, r5
str r6, [r3, #0x0]
str lr, [r2, #0x0]
bl OS_RestoreInterrupts
mov r0, r4
ldmia sp!, {r4-r6,lr}
bx lr
.balign 4
_020CF380: .word UNK_021D383C
_020CF384: .word UNK_021D384C
_020CF388: .word UNK_021D385C
_020CF38C: .word UNK_021D3848
_020CF390: .word UNK_021D3854
_020CF394: .word UNK_021D3838
arm_func_start SND_CommandInit
SND_CommandInit: ; 0x020CF398
stmdb sp!, {r4-r11,lr}
sub sp, sp, #0x4
bl InitPXI
ldr r3, _020CF478 ; =UNK_021D3B00
ldr r0, _020CF47C ; =UNK_021D3838
mov r4, #0x0
str r3, [r0, #0x0]
mov r1, r3
mov r0, #0x18
_020CF3BC:
add r4, r4, #0x1
mla r2, r4, r0, r1
cmp r4, #0xff
str r2, [r3], #0x18
blt _020CF3BC
ldr r7, _020CF480 ; =UNK_021D4B00
mov r10, #0x0
ldr r5, _020CF484 ; =UNK_021D3840
ldr r4, _020CF488 ; =UNK_021D3844
ldr lr, _020CF48C ; =UNK_021D3854
ldr ip, _020CF490 ; =UNK_021D384C
ldr r3, _020CF494 ; =UNK_021D3850
ldr r1, _020CF498 ; =UNK_021D383C
ldr sb, _020CF49C ; =UNK_021D52E8
ldr r6, _020CF4A0 ; =UNK_021D3848
ldr r2, _020CF4A4 ; =UNK_021D3858
mov r8, #0x1
ldr r0, _020CF4A8 ; =UNK_021D3880
ldr fp, _020CF4AC ; =UNK_021D5360
str r9, [r6, #0x0]
str r10, [r7, #0x7e8]
str r10, [r5, #0x0]
str r10, [r4, #0x0]
str r10, [lr, #0x0]
str r10, [r12, #0x0]
str r10, [r3, #0x0]
str r8, [r2, #0x0]
str r10, [r1, #0x0]
str r0, [r11, #0x0]
bl SNDi_InitSharedWork
mov r0, r8
bl SND_AllocCommand
_020CF43C:
cmp r0, #0x0
addeq sp, sp, #0x4
ldmeqia sp!, {r4-r11, lr}
bxeq lr
mov r2, #0x1D
mov r1, fp
str r2, [r0, #0x4]
ldr r1, [r1]
str r1, [r0, #0x8]
bl SND_PushCommand
mov r0, r8
bl SND_FlushCommand
add sp, sp, #0x4
ldmia sp!, {r4-r11, lr}
bx lr
_020CF478: .word UNK_021D3B00
_020CF47C: .word UNK_021D3838
_020CF480: .word UNK_021D4B00
_020CF484: .word UNK_021D3840
_020CF488: .word UNK_021D3844
_020CF48C: .word UNK_021D3854
_020CF490: .word UNK_021D384C
_020CF494: .word UNK_021D3850
_020CF498: .word UNK_021D383C
_020CF49C: .word UNK_021D52E8
_020CF4A0: .word UNK_021D3848
_020CF4A4: .word UNK_021D3858
_020CF4A8: .word UNK_021D3880
_020CF4AC: .word UNK_021D5360

459
arm9/asm/SND_interface.s
View File

@@ -1,459 +0,0 @@
.include "asm/macros.inc"
.include "global.inc"
.text
arm_func_start PushCommand_impl
PushCommand_impl: ; 0x020CE66C
stmdb sp!, {r4-r7,lr}
sub sp, sp, #0x4
mov r7, r0
mov r0, #0x1
mov r6, r1
mov r5, r2
mov r4, r3
bl SND_AllocCommand
_020CE68C:
cmp r0, #0x0
addeq sp, sp, #0x4
ldmeqia sp!, {r4-r7, lr}
bxeq lr
str r7, [r0, #0x4]
str r6, [r0, #0x8]
str r5, [r0, #0xc]
ldr r1, [sp, #0x18]
str r4, [r0, #0x10]
str r1, [r0, #0x14]
bl SND_PushCommand
add sp, sp, #0x4
ldmia sp!, {r4-r7, lr}
bx lr
arm_func_start SNDi_SetTrackParam
SNDi_SetTrackParam: ; 0x020CE6C4
stmdb sp!, {lr}
sub sp, sp, #0x4
ldr r12, [sp, #0x8]
mov lr, r2
str r3, [sp, #0x0]
mov r2, r1
orr r1, r0, r12, lsl #0x18
mov r3, lr
mov r0, #0x7
bl PushCommand_impl
add sp, sp, #0x4
ldmia sp!, {lr}
bx lr
arm_func_start FUN_020CE6F8
FUN_020CE6F8: ; 0x020CE6F8
stmdb sp!, {lr}
sub sp, sp, #0x4
mov lr, r1
mov r12, r2
str r3, [sp, #0x0]
mov r1, r0
mov r2, lr
mov r3, r12
mov r0, #0x6
bl PushCommand_impl
add sp, sp, #0x4
ldmia sp!, {lr}
bx lr
arm_func_start SND_ResetMasterPan
SND_ResetMasterPan: ; 0x020CE72C
stmdb sp!, {lr}
sub sp, sp, #0x4
mov r2, #0x0
mov r3, r2
mov r0, #0x18
mvn r1, #0x0
str r2, [sp, #0x0]
bl PushCommand_impl
add sp, sp, #0x4
ldmia sp!, {lr}
bx lr
arm_func_start SND_SetMasterPan
SND_SetMasterPan: ; 0x020CE758
stmdb sp!, {lr}
sub sp, sp, #0x4
mov r2, #0x0
mov r1, r0
mov r3, r2
mov r0, #0x18
str r2, [sp, #0x0]
bl PushCommand_impl
add sp, sp, #0x4
ldmia sp!, {lr}
bx lr
arm_func_start SND_SetOutputSelector
SND_SetOutputSelector: ; 0x020CE784
stmdb sp!, {lr}
sub sp, sp, #0x4
mov lr, r1
mov r12, r2
str r3, [sp, #0x0]
mov r1, r0
mov r2, lr
mov r3, r12
mov r0, #0x19
bl PushCommand_impl
add sp, sp, #0x4
ldmia sp!, {lr}
bx lr
arm_func_start SND_InvalidateWaveData
SND_InvalidateWaveData: ; 0x020CE7B8
stmdb sp!, {lr}
sub sp, sp, #0x4
mov r2, r1
mov r3, #0x0
mov r1, r0
mov r0, #0x20
str r3, [sp, #0x0]
bl PushCommand_impl
add sp, sp, #0x4
ldmia sp!, {lr}
bx lr
arm_func_start SND_InvalidateBankData
SND_InvalidateBankData: ; 0x020CE7E4
stmdb sp!, {lr}
sub sp, sp, #0x4
mov r2, r1
mov r3, #0x0
mov r1, r0
mov r0, #0x1f
str r3, [sp, #0x0]
bl PushCommand_impl
add sp, sp, #0x4
ldmia sp!, {lr}
bx lr
arm_func_start SND_InvalidateSeqData
SND_InvalidateSeqData: ; 0x020CE810
stmdb sp!, {lr}
sub sp, sp, #0x4
mov r2, r1
mov r3, #0x0
mov r1, r0
mov r0, #0x1e
str r3, [sp, #0x0]
bl PushCommand_impl
add sp, sp, #0x4
ldmia sp!, {lr}
bx lr
arm_func_start SND_SetupChannelPcm
SND_SetupChannelPcm: ; 0x020CE83C
stmdb sp!, {r4-r5,lr}
sub sp, sp, #0x4
ldr r12, [sp, #0x18]
mov r3, r3, lsl #0x1a
orr r4, r3, r1, lsl #0x18
ldr r5, [sp, #0x24]
mov r3, r12, lsl #0x18
ldr r1, [sp, #0x1c]
ldr r12, [sp, #0x10]
orr r4, r4, r5, lsl #0x10
orr r4, r12, r4
ldr lr, [sp, #0x20]
orr r3, r3, r1, lsl #0x16
ldr r12, [sp, #0x14]
orr r1, r0, lr, lsl #0x10
orr r3, r12, r3
mov r0, #0xe
str r4, [sp, #0x0]
bl PushCommand_impl
add sp, sp, #0x4
ldmia sp!, {r4-r5,lr}
bx lr
arm_func_start SND_SetChannelPan
SND_SetChannelPan: ; 0x020CE894
stmdb sp!, {lr}
sub sp, sp, #0x4
mov r2, r1
mov r3, #0x0
mov r1, r0
mov r0, #0x15
str r3, [sp, #0x0]
bl PushCommand_impl
add sp, sp, #0x4
ldmia sp!, {lr}
bx lr
arm_func_start SND_SetChannelVolume
SND_SetChannelVolume: ; 0x020CE8C0
stmdb sp!, {lr}
sub sp, sp, #0x4
mov lr, r1
mov r3, r2
mov r12, #0x0
mov r1, r0
mov r2, lr
mov r0, #0x14
str r12, [sp, #0x0]
bl PushCommand_impl
add sp, sp, #0x4
ldmia sp!, {lr}
bx lr
arm_func_start SND_SetChannelTimer
SND_SetChannelTimer: ; 0x020CE8F4
stmdb sp!, {lr}
sub sp, sp, #0x4
mov r2, r1
mov r3, #0x0
mov r1, r0
mov r0, #0x13
str r3, [sp, #0x0]
bl PushCommand_impl
add sp, sp, #0x4
ldmia sp!, {lr}
bx lr
arm_func_start SND_UnlockChannel
SND_UnlockChannel: ; 0x020CE920
stmdb sp!, {lr}
sub sp, sp, #0x4
mov r2, r1
mov r3, #0x0
mov r1, r0
mov r0, #0x1b
str r3, [sp, #0x0]
bl PushCommand_impl
add sp, sp, #0x4
ldmia sp!, {lr}
bx lr
arm_func_start SND_LockChannel
SND_LockChannel: ; 0x020CE94C
stmdb sp!, {lr}
sub sp, sp, #0x4
mov r2, r1
mov r3, #0x0
mov r1, r0
mov r0, #0x1a
str r3, [sp, #0x0]
bl PushCommand_impl
add sp, sp, #0x4
ldmia sp!, {lr}
bx lr
arm_func_start SND_SetupAlarm
SND_SetupAlarm: ; 0x020CE978
stmdb sp!, {r4-r6,lr}
sub sp, sp, #0x8
mov r4, r2
mov r5, r1
ldr r2, [sp, #0x18]
mov r6, r0
mov r1, r3
bl SNDi_SetAlarmHandler
_020CE998:
str r0, [sp]
mov r1, r6
mov r2, r5
mov r3, r4
mov r0, #0x12
bl PushCommand_impl
add sp, sp, #0x8
ldmia sp!, {r4-r6, lr}
bx lr
arm_func_start SND_SetupCapture
SND_SetupCapture: ; 0x020CE9BC
stmdb sp!, {lr}
sub sp, sp, #0x4
mov r0, r0, lsl #0x1f
orr r0, r0, r1, lsl #0x1e
ldr r12, [sp, #0x8]
mov r1, r2
orr r0, r0, r12, lsl #0x1d
ldr r2, [sp, #0xc]
mov lr, #0x0
orr r0, r0, r2, lsl #0x1c
ldr r12, [sp, #0x10]
mov r2, r3
orr r3, r0, r12, lsl #0x1b
mov r0, #0x11
str lr, [sp, #0x0]
bl PushCommand_impl
add sp, sp, #0x4
ldmia sp!, {lr}
bx lr
arm_func_start SND_StopTimer
SND_StopTimer: ; 0x020CEA08
stmdb sp!, {r4-r9,lr}
sub sp, sp, #0x4
mov r7, r2
mov r9, r0
mov r8, r1
mov r6, r3
mov r4, r7
mov r5, #0x0
b _020CEA44
_020CEA2C:
ands r0, r4, #0x1
beq _020CEA3C
mov r0, r5
bl SNDi_IncAlarmId
_020CEA3C:
add r5, r5, #0x1
mov r4, r4, lsr #0x1
_020CEA44:
cmp r5, #0x8
bge _020CEA54
cmp r4, #0x0
bne _020CEA2C
_020CEA54:
mov r1, r9
mov r2, r8
mov r3, r7
mov r0, #0xd
str r6, [sp, #0x0]
bl PushCommand_impl
add sp, sp, #0x4
ldmia sp!, {r4-r9,lr}
bx lr
arm_func_start SND_StartTimer
SND_StartTimer: ; 0x020CEA78
stmdb sp!, {lr}
sub sp, sp, #0x4
mov lr, r1
mov r12, r2
str r3, [sp, #0x0]
mov r1, r0
mov r2, lr
mov r3, r12
mov r0, #0xc
bl PushCommand_impl
add sp, sp, #0x4
ldmia sp!, {lr}
bx lr
arm_func_start SND_SetTrackAllocatableChannel
SND_SetTrackAllocatableChannel: ; 0x020CEAAC
stmdb sp!, {lr}
sub sp, sp, #0x4
mov lr, r1
mov r3, r2
mov r12, #0x0
mov r1, r0
mov r2, lr
mov r0, #0x9
str r12, [sp, #0x0]
bl PushCommand_impl
add sp, sp, #0x4
ldmia sp!, {lr}
bx lr
arm_func_start SND_SetTrackPan
SND_SetTrackPan: ; 0x020CEAE0
stmdb sp!, {lr}
sub sp, sp, #0x4
mov r3, r2
mov r12, #0x1
mov r2, #0x9
str r12, [sp, #0x0]
bl SNDi_SetTrackParam
add sp, sp, #0x4
ldmia sp!, {lr}
bx lr
arm_func_start SND_SetTrackPitch
SND_SetTrackPitch: ; 0x020CEB08
stmdb sp!, {lr}
sub sp, sp, #0x4
mov r3, r2
mov r12, #0x2
mov r2, #0xc
str r12, [sp, #0x0]
bl SNDi_SetTrackParam
add sp, sp, #0x4
ldmia sp!, {lr}
bx lr
arm_func_start SND_SetPlayerChannelPriority
SND_SetPlayerChannelPriority: ; 0x020CEB30
ldr ip, _020CEB44 ; =FUN_020CE6F8
mov r2, r1
mov r1, #0x4
mov r3, #0x1
bx r12
.balign 4
_020CEB44: .word FUN_020CE6F8
arm_func_start SND_SetPlayerVolume
SND_SetPlayerVolume: ; 0x020CEB48
ldr ip, _020CEB5C ; =FUN_020CE6F8
mov r2, r1
mov r1, #0x6
mov r3, #0x2
bx r12
.balign 4
_020CEB5C: .word FUN_020CE6F8
arm_func_start SND_PauseSeq
SND_PauseSeq: ; 0x020CEB60
stmdb sp!, {lr}
sub sp, sp, #0x4
mov r2, r1
mov r3, #0x0
mov r1, r0
mov r0, #0x4
str r3, [sp, #0x0]
bl PushCommand_impl
add sp, sp, #0x4
ldmia sp!, {lr}
bx lr
arm_func_start SND_StartPreparedSeq
SND_StartPreparedSeq: ; 0x020CEB8C
stmdb sp!, {lr}
sub sp, sp, #0x4
mov r2, #0x0
mov r1, r0
mov r3, r2
mov r0, #0x3
str r2, [sp, #0x0]
bl PushCommand_impl
add sp, sp, #0x4
ldmia sp!, {lr}
bx lr
arm_func_start SND_PrepareSeq
SND_PrepareSeq: ; 0x020CEBB8
stmdb sp!, {lr}
sub sp, sp, #0x4
mov lr, r1
mov r12, r2
str r3, [sp, #0x0]
mov r1, r0
mov r2, lr
mov r3, r12
mov r0, #0x2
bl PushCommand_impl
add sp, sp, #0x4
ldmia sp!, {lr}
bx lr
arm_func_start SND_StopSeq
SND_StopSeq: ; 0x020CEBEC
stmdb sp!, {lr}
sub sp, sp, #0x4
mov r2, #0x0
mov r1, r0
mov r3, r2
mov r0, #0x1
str r2, [sp, #0x0]
bl PushCommand_impl
add sp, sp, #0x4
ldmia sp!, {lr}
bx lr

55
arm9/asm/SND_main.s
View File

@@ -1,55 +0,0 @@
.include "asm/macros.inc"
.include "global.inc"
.section .bss
.global UNK_021D381C
UNK_021D381C: ; 0x021D381C
.space 0x4
.global UNK_021D3820
UNK_021D3820: ; 0x021D3820
.space 0x18
.text
arm_func_start SNDi_UnlockMutex
SNDi_UnlockMutex: ; 0x020CEC18
ldr ip, _020CEC24 ; =OS_UnlockMutex
ldr r0, _020CEC28 ; =UNK_021D3820
bx r12
.balign 4
_020CEC24: .word OS_UnlockMutex
_020CEC28: .word UNK_021D3820
arm_func_start SNDi_LockMutex
SNDi_LockMutex: ; 0x020CEC2C
ldr ip, _020CEC38 ; =OS_LockMutex
ldr r0, _020CEC3C ; =UNK_021D3820
bx r12
.balign 4
_020CEC38: .word OS_LockMutex
_020CEC3C: .word UNK_021D3820
arm_func_start SND_Init
SND_Init: ; 0x020CEC40
stmdb sp!, {lr}
sub sp, sp, #0x4
ldr r1, _020CEC84 ; =UNK_021D381C
ldr r0, [r1, #0x0]
cmp r0, #0x0
addne sp, sp, #0x4
ldmneia sp!, {lr}
bxne lr
ldr r0, _020CEC88 ; =UNK_021D3820
mov r2, #0x1
str r2, [r1, #0x0]
bl OS_InitMutex
bl SND_CommandInit
bl SND_AlarmInit
add sp, sp, #0x4
ldmia sp!, {lr}
bx lr
.balign 4
_020CEC84: .word UNK_021D381C
_020CEC88: .word UNK_021D3820

109
arm9/asm/SND_util.s
View File

@@ -1,109 +0,0 @@
.include "asm/macros.inc"
.include "global.inc"
.section .rodata
.global UNK_02103BAC
UNK_02103BAC: ; 0x02103BAC
.byte 0x00, 0x80, 0x5B, 0xFE, 0x97, 0xFE, 0xBB, 0xFE, 0xD4, 0xFE, 0xE7, 0xFE, 0xF7, 0xFE, 0x04, 0xFF
.byte 0x10, 0xFF, 0x1A, 0xFF, 0x23, 0xFF, 0x2C, 0xFF, 0x33, 0xFF, 0x3A, 0xFF, 0x40, 0xFF, 0x46, 0xFF
.byte 0x4C, 0xFF, 0x51, 0xFF, 0x56, 0xFF, 0x5B, 0xFF, 0x5F, 0xFF, 0x64, 0xFF, 0x68, 0xFF, 0x6C, 0xFF
.byte 0x6F, 0xFF, 0x73, 0xFF, 0x76, 0xFF, 0x7A, 0xFF, 0x7D, 0xFF, 0x80, 0xFF, 0x83, 0xFF, 0x86, 0xFF
.byte 0x88, 0xFF, 0x8B, 0xFF, 0x8E, 0xFF, 0x90, 0xFF, 0x92, 0xFF, 0x95, 0xFF, 0x97, 0xFF, 0x99, 0xFF
.byte 0x9C, 0xFF, 0x9E, 0xFF, 0xA0, 0xFF, 0xA2, 0xFF, 0xA4, 0xFF, 0xA6, 0xFF, 0xA8, 0xFF, 0xAA, 0xFF
.byte 0xAB, 0xFF, 0xAD, 0xFF, 0xAF, 0xFF, 0xB1, 0xFF, 0xB2, 0xFF, 0xB4, 0xFF, 0xB6, 0xFF, 0xB7, 0xFF
.byte 0xB9, 0xFF, 0xBA, 0xFF, 0xBC, 0xFF, 0xBD, 0xFF, 0xBF, 0xFF, 0xC0, 0xFF, 0xC2, 0xFF, 0xC3, 0xFF
.byte 0xC4, 0xFF, 0xC6, 0xFF, 0xC7, 0xFF, 0xC8, 0xFF, 0xCA, 0xFF, 0xCB, 0xFF, 0xCC, 0xFF, 0xCD, 0xFF
.byte 0xCF, 0xFF, 0xD0, 0xFF, 0xD1, 0xFF, 0xD2, 0xFF, 0xD3, 0xFF, 0xD5, 0xFF, 0xD6, 0xFF, 0xD7, 0xFF
.byte 0xD8, 0xFF, 0xD9, 0xFF, 0xDA, 0xFF, 0xDB, 0xFF, 0xDC, 0xFF, 0xDD, 0xFF, 0xDE, 0xFF, 0xDF, 0xFF
.byte 0xE0, 0xFF, 0xE1, 0xFF, 0xE2, 0xFF, 0xE3, 0xFF, 0xE4, 0xFF, 0xE5, 0xFF, 0xE6, 0xFF, 0xE7, 0xFF
.byte 0xE8, 0xFF, 0xE9, 0xFF, 0xE9, 0xFF, 0xEA, 0xFF, 0xEB, 0xFF, 0xEC, 0xFF, 0xED, 0xFF, 0xEE, 0xFF
.byte 0xEF, 0xFF, 0xEF, 0xFF, 0xF0, 0xFF, 0xF1, 0xFF, 0xF2, 0xFF, 0xF3, 0xFF, 0xF4, 0xFF, 0xF4, 0xFF
.byte 0xF5, 0xFF, 0xF6, 0xFF, 0xF7, 0xFF, 0xF7, 0xFF, 0xF8, 0xFF, 0xF9, 0xFF, 0xFA, 0xFF, 0xFA, 0xFF
.byte 0xFB, 0xFF, 0xFC, 0xFF, 0xFD, 0xFF, 0xFD, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00
.global UNK_02103CAC
UNK_02103CAC: ; 0x02103CAC
.byte 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01
.byte 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01
.byte 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01
.byte 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01
.byte 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01
.byte 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01
.byte 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02
.byte 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02
.byte 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03
.byte 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03
.byte 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04
.byte 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04
.byte 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05
.byte 0x05, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06
.byte 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x08, 0x08, 0x08, 0x08
.byte 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09
.byte 0x09, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0B, 0x0B, 0x0B, 0x0B, 0x0B, 0x0B, 0x0B
.byte 0x0B, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0E
.byte 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x10, 0x10, 0x10, 0x10, 0x10
.byte 0x10, 0x11, 0x11, 0x11, 0x11, 0x11, 0x12, 0x12, 0x12, 0x12, 0x12, 0x13, 0x13, 0x13, 0x13, 0x14
.byte 0x14, 0x14, 0x14, 0x14, 0x15, 0x15, 0x15, 0x15, 0x16, 0x16, 0x16, 0x16, 0x17, 0x17, 0x17, 0x18
.byte 0x18, 0x18, 0x18, 0x19, 0x19, 0x19, 0x19, 0x1A, 0x1A, 0x1A, 0x1B, 0x1B, 0x1B, 0x1C, 0x1C, 0x1C
.byte 0x1D, 0x1D, 0x1D, 0x1E, 0x1E, 0x1E, 0x1F, 0x1F, 0x1F, 0x20, 0x20, 0x20, 0x21, 0x21, 0x22, 0x22
.byte 0x22, 0x23, 0x23, 0x24, 0x24, 0x24, 0x25, 0x25, 0x26, 0x26, 0x27, 0x27, 0x27, 0x28, 0x28, 0x29
.byte 0x29, 0x2A, 0x2A, 0x2B, 0x2B, 0x2C, 0x2C, 0x2D, 0x2D, 0x2E, 0x2E, 0x2F, 0x2F, 0x30, 0x31, 0x31
.byte 0x32, 0x32, 0x33, 0x33, 0x34, 0x35, 0x35, 0x36, 0x36, 0x37, 0x38, 0x38, 0x39, 0x3A, 0x3A, 0x3B
.byte 0x3C, 0x3C, 0x3D, 0x3E, 0x3F, 0x3F, 0x40, 0x41, 0x42, 0x42, 0x43, 0x44, 0x45, 0x45, 0x46, 0x47
.byte 0x48, 0x49, 0x4A, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x52, 0x53, 0x54, 0x55
.byte 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x67
.byte 0x68, 0x69, 0x6A, 0x6B, 0x6D, 0x6E, 0x6F, 0x71, 0x72, 0x73, 0x75, 0x76, 0x77, 0x79, 0x7A, 0x7B
.byte 0x7D, 0x7E, 0x7F, 0x20, 0x21, 0x21, 0x21, 0x22, 0x22, 0x23, 0x23, 0x23, 0x24, 0x24, 0x25, 0x25
.byte 0x26, 0x26, 0x26, 0x27, 0x27, 0x28, 0x28, 0x29, 0x29, 0x2A, 0x2A, 0x2B, 0x2B, 0x2C, 0x2C, 0x2D
.byte 0x2D, 0x2E, 0x2E, 0x2F, 0x2F, 0x30, 0x30, 0x31, 0x31, 0x32, 0x33, 0x33, 0x34, 0x34, 0x35, 0x36
.byte 0x36, 0x37, 0x37, 0x38, 0x39, 0x39, 0x3A, 0x3B, 0x3B, 0x3C, 0x3D, 0x3E, 0x3E, 0x3F, 0x40, 0x40
.byte 0x41, 0x42, 0x43, 0x43, 0x44, 0x45, 0x46, 0x47, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4D
.byte 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D
.byte 0x5E, 0x5F, 0x60, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6F, 0x70
.byte 0x71, 0x73, 0x74, 0x75, 0x77, 0x78, 0x79, 0x7B, 0x7C, 0x7E, 0x7E, 0x40, 0x41, 0x42, 0x43, 0x43
.byte 0x44, 0x45, 0x46, 0x47, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51
.byte 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61
.byte 0x62, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6B, 0x6C, 0x6D, 0x6E, 0x70, 0x71, 0x72, 0x74, 0x75
.byte 0x76, 0x78, 0x79, 0x7B, 0x7C, 0x7D, 0x7E, 0x40, 0x41, 0x42, 0x42, 0x43, 0x44, 0x45, 0x46, 0x46
.byte 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55
.byte 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x65, 0x66
.byte 0x67, 0x68, 0x69, 0x6A, 0x6C, 0x6D, 0x6E, 0x6F, 0x71, 0x72, 0x73, 0x75, 0x76, 0x77, 0x79, 0x7A
.byte 0x7C, 0x7D, 0x7E, 0x7F
.text
arm_func_start SND_CalcChannelVolume
SND_CalcChannelVolume: ; 0x020CF6F4
ldr r1, _020CF75C ; =0xFFFFFD2D
cmp r0, r1
movlt r0, r1
blt _020CF70C
cmp r0, #0x0
movgt r0, #0x0
_020CF70C:
ldr r1, _020CF760 ; =0x000002D3
ldr r2, _020CF764 ; =UNK_02103CAC
add r3, r0, r1
mvn r1, #0xef
cmp r0, r1
ldrb r2, [r2, r3]
movlt r0, #0x3
blt _020CF74C
mvn r1, #0x77
cmp r0, r1
movlt r0, #0x2
blt _020CF74C
mvn r1, #0x3b
cmp r0, r1
movlt r0, #0x1
movge r0, #0x0
_020CF74C:
orr r0, r2, r0, lsl #0x8
mov r0, r0, lsl #0x10
mov r0, r0, lsr #0x10
bx lr
.balign 4
_020CF75C: .word 0xFFFFFD2D
_020CF760: .word 0x000002D3
_020CF764: .word UNK_02103CAC

121
arm9/asm/SND_work.s
View File

@@ -1,121 +0,0 @@
.include "asm/macros.inc"
.include "global.inc"
.section .bss
.global UNK_021D5360
UNK_021D5360: ; 0x021D5360
.space 0x4
.text
arm_func_start SNDi_InitSharedWork
SNDi_InitSharedWork: ; 0x020CF590
stmdb sp!, {r4,lr}
mov r4, #0x0
str r4, [r0, #0x4]
strh r4, [r0, #0x8]
strh r4, [r0, #0xa]
mov r12, r0
str r4, [r0, #0x0]
mov r3, r4
mvn r2, #0x0
_020CF5B4:
mov lr, r3
str r3, [r12, #0x40]
_020CF5BC:
add r1, r12, lr, lsl #0x1
add lr, lr, #0x1
strh r2, [r1, #0x20]
cmp lr, #0x10
blt _020CF5BC
add r4, r4, #0x1
cmp r4, #0x10
add r12, r12, #0x24
blt _020CF5B4
mov r3, #0x0
mvn r2, #0x0
_020CF5E8:
add r1, r0, r3, lsl #0x1
add r1, r1, #0x200
add r3, r3, #0x1
strh r2, [r1, #0x60]
cmp r3, #0x10
blt _020CF5E8
mov r1, #0x280
bl DC_FlushRange
ldmia sp!, {r4,lr}
bx lr
arm_func_start SNDi_GetFinishedCommandTag
SNDi_GetFinishedCommandTag: ; 0x020CF610
stmdb sp!, {lr}
sub sp, sp, #0x4
ldr r0, _020CF640 ; =UNK_021D5360
mov r1, #0x4
ldr r0, [r0, #0x0]
bl DC_InvalidateRange
ldr r0, _020CF640 ; =UNK_021D5360
ldr r0, [r0, #0x0]
ldr r0, [r0, #0x0]
add sp, sp, #0x4
ldmia sp!, {lr}
bx lr
.balign 4
_020CF640: .word UNK_021D5360
arm_func_start SND_GetPlayerTickCounter
SND_GetPlayerTickCounter: ; 0x020CF644
stmdb sp!, {r4,lr}
mov r1, #0x24
mul r4, r0, r1
ldr r0, _020CF680 ; =UNK_021D5360
mov r1, #0x4
ldr r0, [r0, #0x0]
add r0, r0, #0x40
add r0, r0, r4
bl DC_InvalidateRange
ldr r0, _020CF680 ; =UNK_021D5360
ldr r0, [r0, #0x0]
add r0, r0, r4
ldr r0, [r0, #0x40]
ldmia sp!, {r4,lr}
bx lr
.balign 4
_020CF680: .word UNK_021D5360
arm_func_start SND_GetChannelStatus
SND_GetChannelStatus: ; 0x020CF684
stmdb sp!, {lr}
sub sp, sp, #0x4
ldr r0, _020CF6B8 ; =UNK_021D5360
mov r1, #0x2
ldr r0, [r0, #0x0]
add r0, r0, #0x8
bl DC_InvalidateRange
ldr r0, _020CF6B8 ; =UNK_021D5360
ldr r0, [r0, #0x0]
ldrh r0, [r0, #0x8]
add sp, sp, #0x4
ldmia sp!, {lr}
bx lr
.balign 4
_020CF6B8: .word UNK_021D5360
arm_func_start SND_GetPlayerStatus
SND_GetPlayerStatus: ; 0x020CF6BC
stmdb sp!, {lr}
sub sp, sp, #0x4
ldr r0, _020CF6F0 ; =UNK_021D5360
mov r1, #0x4
ldr r0, [r0, #0x0]
add r0, r0, #0x4
bl DC_InvalidateRange
ldr r0, _020CF6F0 ; =UNK_021D5360
ldr r0, [r0, #0x0]
ldr r0, [r0, #0x4]
add sp, sp, #0x4
ldmia sp!, {lr}
bx lr
.balign 4
_020CF6F0: .word UNK_021D5360

10
arm9/asm/unk_020ADA84.s
View File

@@ -1,7 +1,7 @@
.include "asm/macros.inc"
.include "global.inc"
.extern UNK_02103BAC
.extern SNDi_DecibelTable
.extern GXi_DmaId
.section .rodata
@@ -24277,7 +24277,7 @@ FUN_020C0BA0: ; 0x020C0BA0
ldmeqia sp!, {r4-r11,pc}
mov r0, #0x8000
rsb r0, r0, #0x0
ldr r4, _020C0D18 ; =UNK_02103BAC
ldr r4, _020C0D18 ; =SNDi_DecibelTable
str r0, [sp, #0x4]
mov r5, #0x1
mov r11, #0x0
@@ -24367,7 +24367,7 @@ _020C0D00:
ldmia sp!, {r4-r11,pc}
.balign 4
_020C0D14: .word UNK_021D1E08
_020C0D18: .word UNK_02103BAC
_020C0D18: .word SNDi_DecibelTable
_020C0D1C: .word 0x00007FFF
arm_func_start FUN_020C0D20
@@ -27918,7 +27918,7 @@ FUN_020C3C88:
sub sp, sp, #0x4
ldr r5, _020C3D94 ; =UNK_021D2DFC
mov r7, #0x0
ldr r4, _020C3D98 ; =UNK_02103BAC
ldr r4, _020C3D98 ; =SNDi_DecibelTable
_020C3C9C:
ldr r1, [r5, #0x110]
mov r0, r1, lsl #0x1f
@@ -27988,7 +27988,7 @@ _020C3D7C:
ldmia sp!, {r4-r7,pc}
.balign 4
_020C3D94: .word UNK_021D2DFC
_020C3D98: .word UNK_02103BAC
_020C3D98: .word SNDi_DecibelTable
arm_func_start FUN_020C3D9C
FUN_020C3D9C:

25
arm9/lib/include/SND_alarm.h Normal file
View File

@@ -0,0 +1,25 @@
#ifndef GUARD_SND_ALARM_H
#define GUARD_SND_ALARM_H
#include "global.h"
#include "OS_alarm.h"
typedef void (*SNDAlarmCallback)(void *);
struct SNDAlarm {
u8 enable; // 0x00
u8 id; // 0x01
u16 unk_2; // 0x02
OSTick tick; // 0x04
OSTick period; // 0x0C
OSAlarm alarm; // 0x14
}; // size = 0x40
void SND_AlarmInit(void);
void SNDi_IncAlarmId(u32 idx);
u8 SNDi_SetAlarmHandler(u32 idx, SNDAlarmCallback cb, void *data);
void SNDi_CallAlarmHandler(s32 idx);
#define SND_ALARM_COUNT 8
#endif

95
arm9/lib/include/SND_bank.h Normal file
View File

@@ -0,0 +1,95 @@
#ifndef GUARD_SND_BANK_H
#define GUARD_SND_BANK_H
#include "global.h"
#include "SND_main.h"
#define SND_INST_ILLEGAL 0
#define SND_INST_PCM 1
#define SND_INST_PSG 2
#define SND_INST_NOISE 3
#define SND_INST_DIRECTPCM 4
#define SND_INST_DUMMY 5
#define SND_INST_DRUM_TABLE 16
#define SND_INST_KEY_SPLIT 17
#define SND_BANK_MAX_WAVEARC 4
#define SND_INST_MAX_KEYSPLIT 8
#define SND_INST_OFFSET_TYPE(off) ((u8)off)
#define SND_INST_OFFSET_NORMAL(bank, off) ((struct SNDInstParam *)((u8 *)bank + (u32)(off >> 8)))
#define SND_INST_OFFSET_DRUMS(bank, off) ((struct SNDDrumSet *)((u8 *)bank + (u32)(off >> 8)))
#define SND_INST_OFFSET_KEYSPL(bank, off) ((struct SNDKeySplit *)((u8 *)bank + (u32)(off >> 8)))
struct SNDWaveArc;
struct SNDWaveArcLink {
struct SNDWaveArc *waveArc; // 0x0
struct SNDWaveArcLink *waveArcLLnext; // 0x4
}; // size = 0x8
struct SNDBankData {
struct SNDBinaryFileHeader fileHeader; // 0x00
struct SNDBinaryBlockHeader blockHeader; // 0x10
struct SNDWaveArcLink waveArcLinks[SND_BANK_MAX_WAVEARC]; // 0x18
u32 instCount; // 0x38
u32 instOffsets[]; // 0x3C
}; // size = 0x40
struct SNDWaveArc {
struct SNDBinaryFileHeader fileHeader; // 0x00
struct SNDBinaryBlockHeader blockHeader; // 0x10
struct SNDWaveArcLink *waveArcLLHead; // 0x18
u8 unk_1C[28]; // 0x1C
u32 waveCount; // 0x38
u32 waveOffsets[]; // 0x3C
}; // size = 0x3C
struct SNDInstParam {
u16 wave[2]; // 0x0
u8 rootKey; // 0x4
u8 envAttack; // 0x5
u8 envDecay; // 0x6
u8 envSustain; // 0x7
u8 envRelease; // 0x8
u8 pan; // 0x9
}; // size = 0xA
struct SNDInstData {
u8 type; // 0x0
u8 unk_1; // 0x1
struct SNDInstParam param; // 0x2
}; // size = 0xC
struct SNDKeySplit {
u8 key[SND_INST_MAX_KEYSPLIT]; // 0x0
struct SNDInstData instruments[]; // 0x8
}; // size = 0x8
struct SNDDrumSet {
u8 minKey;
u8 maxKey;
struct SNDInstData instruments[];
}; // size = 0x2
struct SNDInstPos {
u32 program; // 0x0
u32 index; // 0x4
}; // size = 0x8
struct SNDWaveData {
struct SNDWaveParam param; // 0x0
u8 sampleData[]; // 0xC
}; // size = 0xC
void SND_AssignWaveArc(struct SNDBankData *bankData, s32 index, struct SNDWaveArc *waveArc);
void SND_DestroyBank(struct SNDBankData *bankData);
void SND_DestroyWaveArc(struct SNDWaveArc *waveArc);
struct SNDInstPos SND_GetFirstInstDataPos(const struct SNDBankData *bankData);
BOOL SND_GetNextInstData(const struct SNDBankData *bankData, struct SNDInstData *instData, struct SNDInstPos *instPos);
u32 SND_GetWaveDataCount(const struct SNDWaveArc *waveArc);
void SND_SetWaveDataAddress(struct SNDWaveArc *waveArc, s32 index, const struct SNDWaveData *waveData);
const struct SNDWaveData *SND_GetWaveDataAddress(const struct SNDWaveArc *waveArc, s32 index);
#endif // GUARD_SND_BANK_H

67
arm9/lib/include/SND_command.h Normal file
View File

@@ -0,0 +1,67 @@
#ifndef GUARD_SND_COMMAND_H
#define GUARD_SND_COMMAND_H
#include "global.h"
#define SND_CMD_COUNT 256
#define SND_CMD_ARG_MAX 4
#define SND_CMD_FLAG_NOBLOCK 0x0
#define SND_CMD_FLAG_BLOCK 0x1
#define SND_CMD_FLAG_IMMEDIATE 0x2
#define SND_CMD_START_SEQ 0x00
#define SND_CMD_STOP_SEQ 0x01
#define SND_CMD_PREPARE_SEQ 0x02
#define SND_CMD_START_PREPARED_SEQ 0x03
#define SND_CMD_PAUSE_SEQ 0x04
#define SND_CMD_SKIP_SEQ 0x05
#define SND_CMD_PLAYER_PARAM 0x06
#define SND_CMD_TRACK_PARAM 0x07
#define SND_CMD_MUTE_TRACK 0x08
#define SND_CMD_ALLOCATABLE_CHANNEL 0x09
#define SND_CMD_PLAYER_LOCAL_VAR 0x0A
#define SND_CMD_PLAYER_GLOBAL_VAR 0x0B
#define SND_CMD_START_TIMER 0x0C
#define SND_CMD_STOP_TIMER 0x0D
#define SND_CMD_SETUP_CHANNEL_PCM 0x0E
#define SND_CMD_SETUP_CHANNEL_PSG 0x0F
#define SND_CMD_SETUP_CHANNEL_NOISE 0x10
#define SND_CMD_SETUP_CAPTURE 0x11
#define SND_CMD_SETUP_ALARM 0x12
#define SND_CMD_CHANNEL_TIMER 0x13
#define SND_CMD_CHANNEL_VOLUME 0x14
#define SND_CMD_CHANNEL_PAN 0x15
#define SND_CMD_SURROUND_DECAY 0x16
#define SND_CMD_MASTER_VOLUME 0x17
#define SND_CMD_MASTER_PAN 0x18
#define SND_CMD_OUTPUT_SELECTOR 0x19
#define SND_CMD_LOCK_CHANNEL 0x1A
#define SND_CMD_UNLOCK_CHANNEL 0x1B
#define SND_CMD_STOP_UNLOCKED_CHANNEL 0x1C
#define SND_CMD_SET_SHARED_WORK 0x1D
#define SND_CMD_INVALIDATE_SEQ 0x1E
#define SND_CMD_INVALIDATE_BANK 0x1F
#define SND_CMD_INVALIDATE_WAVE 0x20
#define SND_CMD_READ_DRIVER_INFO 0x21
struct SNDCommand {
struct SNDCommand *llNext; // 0x0
s32 id; // 0x4
u32 arg[SND_CMD_ARG_MAX]; // 0x8
}; // size = 0x18
void SND_CommandInit(void);
const struct SNDCommand *SND_RecvCommandReply(u32 flags);
struct SNDCommand *SND_AllocCommand(u32 flags);
void SND_PushCommand(struct SNDCommand *cmd);
BOOL SND_FlushCommand(u32 flags);
void SND_WaitForCommandProc(u32 tag);
void SND_WaitForFreeCommand(s32 count);
u32 SND_GetCurrentCommandTag(void);
BOOL SND_IsFinishedCommandTag(u32 tag);
s32 SND_CountFreeCommand(void);
s32 SND_CountReservedCommand(void);
s32 SND_CountWaitingCommand(void);
#endif // GUARD_SND_COMMAND_H

62
arm9/lib/include/SND_interface.h Normal file
View File

@@ -0,0 +1,62 @@
#ifndef GUARD_SND_INTERFACE_H
#define GUARD_SND_INTERFACE_H
#include "global.h"
#include "SND_bank.h"
#include "SND_work.h"
void SND_StartSeq(s32 player, const void *seqBasePtr, u32 seqOffset, struct SNDBankData *bankData);
void SND_StopSeq(s32 player);
void SND_PrepareSeq(s32 player, const void *seqBasePtr, u32 seqOffset, struct SNDBankData *bankData);
void SND_StartPreparedSeq(s32 player);
void SND_PauseSeq(s32 player, BOOL flag);
void SND_SetPlayerTempoRatio(s32 player, s32 ratio);
void SND_SetPlayerVolume(s32 player, s32 volume);
void SND_SetPlayerChannelPriority(s32 player, s32 prio);
void SND_SetPlayerLocalVariable(s32 player, s32 varNo, s16 var);
void SND_SetPlayerGlobalVariable(s32 varNo, s16 var);
void SND_SetTrackVolume(s32 player, u32 trackBitMask, s32 volume);
void SND_SetTrackPitch(s32 player, u32 trackBitMask, s32 pitch);
void SND_SetTrackPan(s32 player, u32 trackBitMask, s32 pan);
void SND_SetTrackPanRange(s32 player, u32 trackBitMask, s32 panRange);
void SND_SetTrackModDepth(s32 player, u32 trackBitMask, s32 depth);
void SND_SetTrackModSpeed(s32 player, u32 trackBitMask, s32 speed);
void SND_SetTrackAllocatableChannel(s32 player, u32 trackBitMask, u32 chnBitMask);
void SND_SetTrackMute(s32 player, u32 trackBitMask, BOOL flag);
void SND_StartTimer(u32 chnBitMask, u32 capBitMask, u32 alarmBitMask, u32 flags);
void SND_StopTimer(u32 chnBitMask, u32 capBitMask, u32 alarmBitMask, u32 flags);
void SND_SetupCapture(s32 capture, s32 format, void *bufferPtr, u32 length, BOOL loopFlag, s32 in, s32 out);
void SND_SetupAlarm(s32 alarm, u32 tick, u32 period, SNDAlarmCallback cb, void *userData);
void SND_StopUnlockedChannel(u32 chnBitMask, u32 flags);
void SND_LockChannel(u32 chnBitMask, u32 flags);
void SND_UnlockChannel(u32 chnBitMask, u32 flags);
void SND_SetChannelTimer(u32 chnBitMask, s32 timer);
void SND_SetChannelVolume(u32 chnBitMask, s32 volume, s32 chnDataShift);
void SND_SetChannelPan(u32 chnBitMask, s32 pan);
void SND_SetupChannelPcm(s32 chn, s32 waveFormat, const void *dataAddr, s32 loopMode, s32 loopStart, s32 dataLen, s32 volume, s32 chnDataShift, s32 timer, s32 pan);
void SND_SetupChannelPsg(s32 chn, s32 sndDuty, s32 volume, s32 chnDataShift, s32 timer, s32 pan);
void SND_SetupChannelNoise(s32 chn, s32 volume, s32 chnDataShift, s32 timer, s32 pan);
void SND_InvalidateSeqData(const void *start, const void *end);
void SND_InvalidateBankData(const void *start, const void *end);
void SND_InvalidateWaveData(const void *start, const void *end);
void SND_SetMasterVolume(s32 volume);
void SND_SetOutputSelector(s32 left, s32 right, s32 channel1, s32 channel3);
void SND_SetMasterPan(s32 pan);
void SND_ResetMasterPan(void);
void SND_ReadDriverInfo(struct SNDDriverInfo *info);
void SNDi_SetPlayerParam(s32 player, u32 offset, u32 data, s32 size);
void SNDi_SetTrackParam(s32 player, u32 trackBitMask, u32 offset, u32 data, s32 size);
void SNDi_SetSurroundDecay(s32 decay);
void SNDi_SkipSeq(s32 player, u32 tick);
#endif // GUARD_SND_INTERFACE_H

185
arm9/lib/include/SND_main.h Normal file
View File

@@ -0,0 +1,185 @@
#ifndef GUARD_SND_MAIN_H
#define GUARD_SND_MAIN_H
#include "global.h"
void SNDi_UnlockMutex(void);
void SNDi_LockMutex(void);
void SND_Init(void);
struct SNDBinaryFileHeader {
s8 signature[4]; // 0x0
u16 byteOrder; // 0x4
u16 version; // 0x6
u32 fileSize; // 0x8
u16 headerSize; // 0xC
u16 dataBlocks; // 0xE
}; // size = 0x10
typedef struct SNDBinaryBlockHeader {
u32 type; // 0x0
u32 size; // 0x4
}; // size = 0x8
struct SNDWaveParam {
u8 format; // 0x0
u8 loopEnabled; // 0x1
u16 samplerate; // 0x2
u16 timer; // 0x4
u16 loopStart; // 0x6
u32 loopLength; // 0x8
}; // size = 0xC
struct SNDLfoParam {
u8 target; // 0x0
u8 speed; // 0x1
u8 depth; // 0x2
u8 range; // 0x3
u16 delay; // 0x4
}; // size = 0x6
struct SNDLfo {
struct SNDLfoParam param; // 0x0
u16 delayCounter; // 0x6
u16 counter; // 0x8
}; // size = 0xA
struct SNDExChannel {
u8 id; // 0x00
u8 type; // 0x01
u8 envStatus; // 0x02
struct {
u8 active : 1;
u8 start : 1;
u8 autoSweep : 1;
u8 syncFlag : 5;
} flags; // 0x03
u8 panRange; // 0x04
u8 rootMidiKey; // 0x05
s16 userDecay2; // 0x06
u8 midiKey; // 0x08
u8 velocity; // 0x09
s8 initPan; // 0x0A
s8 userPan; // 0x0B
s16 userDecay; // 0x0C
s16 userPitch; // 0x0E
s32 envAttenuation; // 0x10
s32 sweepCounter; // 0x14
s32 sweepLength; // 0x18
u8 envAttack; // 0x1C
u8 envSustain; // 0x1D
u16 envDecay; // 0x1E
u16 envRelease; // 0x20
u8 priority; // 0x22
u8 pan; // 0x23
u16 volume; // 0x24
u16 timer; // 0x26
struct SNDLfo lfo; // 0x28
s16 sweepPitch; // 0x32
s32 length; // 0x34
struct SNDWaveParam waveParam; // 0x38
union {
const void *waveDataPtr;
u32 dutyCycle;
}; // 0x44
void (*callback)(struct SNDExChannel *chn, u32 status, void *userData); // 0x48
void *callbackUserData; // 0x4C
struct SNDExChannel *channelLLNext; // 0x50
}; // size = 0x54
#define SND_TRACK_COUNT_PER_PLAYER 16
#define SND_INVALID_TRACK_INDEX 0xFF
struct SNDPlayer {
struct {
u8 active : 1;
u8 prepared : 1;
u8 paused : 1;
} flags; // 0x0
u8 playerId; // 0x1
u8 unk_2[2]; // 0x2
u8 prio; // 0x4
u8 volume; // 0x5
s16 extFader; // 0x6
u8 tracks[SND_TRACK_COUNT_PER_PLAYER]; // 0x8
u16 tempo; // 0x18
u16 tempoRatio; // 0x1A
u16 tempoCounter; // 0x1C
u8 unk_1E[2]; // 0x1E
struct SNDBankData *bank; // 0x20
}; // size = 0x24
#define SND_TRACK_MAX_CALL 3
struct SNDBankData;
struct SNDTrack {
struct {
u8 active : 1;
u8 noteWait : 1;
u8 muted : 1;
u8 tie : 1;
u8 noteFinishWait : 1;
u8 portamento : 1;
u8 cmp : 1; // ???
u8 channelMask : 1;
} flags; // 0x00
u8 panRange; // 0x01
u16 program; // 0x02
u8 volume; // 0x04
u8 expression; // 0x05
s8 pitchBend; // 0x06
u8 bendRange; // 0x07
s8 pan; // 0x08
s8 extPan; // 0x09
s16 extFader; // 0x0A
s16 extPitch; // 0x0C
u8 envAttack; // 0x0E
u8 envDecay; // 0x0F
u8 envSustain; // 0x10
u8 envRelease; // 0x11
u8 priority; // 0x12
s8 transpose; // 0x13
u8 portamentoKey; // 0x14
u8 portamentoTime; // 0x15
s16 sweepPitch; // 0x16
struct SNDLfoParam mod; // 0x18
u16 channelMask; // 0x1E
s32 wait; // 0x20
const u8 *trackDataStart; // 0x24
const u8 *trackDataPos; // 0x28
const u8 *posCallStack[SND_TRACK_MAX_CALL]; // 0x34
u8 loopCount[SND_TRACK_MAX_CALL]; // 0x38
u8 callStackDepth; // 0x3B
struct SNDExChannel *channelLLHead; // 0x3C
}; // size = 0x40
#endif // GUARD_SND_MAIN_H

14
arm9/lib/include/SND_util.h Normal file
View File

@@ -0,0 +1,14 @@
#ifndef GUARD_SND_UTIL_H
#define GUARD_SND_UTIL_H
#include "global.h"
void SND_CalcTimer(void);
u16 SND_CalcChannelVolume(s32 x);
extern const s16 SNDi_DecibelTable[0x80];
// not used in pokediamond
//extern const s16 SNDi_DecibelSquareTable[0x80];
#endif // GUARD_SND_UTIL_H

92
arm9/lib/include/SND_work.h Normal file
View File

@@ -0,0 +1,92 @@
#ifndef GUARD_SND_WORK_H
#define GUARD_SND_WORK_H
#include "global.h"
#include "SND_main.h"
#include "SND_alarm.h"
#define SND_PLAYER_COUNT 16
#define SND_CHANNEL_COUNT 16
#define SND_TRACK_COUNT 32
struct SNDWork {
struct SNDExChannel channels[SND_CHANNEL_COUNT]; // 0x00
struct SNDPlayer players[SND_PLAYER_COUNT]; // 0x540
struct SNDTrack tracks[SND_TRACK_COUNT]; // 0x780
struct SNDAlarm alarms[SND_ALARM_COUNT]; // 0xF80
}; // size = 0x1180
struct SNDSharedWork {
u32 finishedCommandTag; // 0x0
u32 playerStatus; // 0x4
u16 channelStatus; // 0x8
u16 captureStatus; // 0xA
u8 unk_C[0x14]; // 0xC
struct {
s16 localVars[16]; // local 0x0
u32 tickCounter; // local 0x20
} players[SND_PLAYER_COUNT]; // 0x20
s16 globalVars[16]; // 0x260
}; // size = 0x280
struct SNDDriverInfo {
struct SNDWork work; // 0x0000
u32 channelControls[SND_CHANNEL_COUNT]; // 0x1180
struct SNDWork *workPtr; // 0x11C0
u32 lockedChannels; // 0x11C4
u8 unk_XXX[24]; // 0x11C8
}; // size = 0x11E0
struct SNDChannelInfo {
struct {
BOOL active : 1;
BOOL locked: 1;
} flags; // 0x0
u16 volume; // 0x4
u8 pan; // 0x6
u8 unk_7; // 0x7
s32 envStatus; // 0x8
}; // size = 0xC
struct SNDPlayerInfo {
struct {
BOOL active : 1;
BOOL paused : 1;
} flags; // 0x0
u16 trackBitMask; // 0x4
u16 tempo; // 0x6
u8 volume; // 0x8
u8 unk_9[3]; // 0x9
}; // size = 0xC
struct SNDTrackInfo {
u16 program; // 0x0
u8 volume; // 0x2
u8 expression; // 0x3
s8 pitchBend; // 0x4
u8 bendRange; // 0x5
u8 pan; // 0x6
s8 transpose; // 0x7
u8 unk_8; // 0x8
u8 chnCount; // 0x9
u8 channel[SND_CHANNEL_COUNT]; // 0xA
}; // size = 0x1A
u32 SND_GetPlayerStatus(void);
u16 SND_GetChannelStatus(void);
//u16 SND_GetCaptureStatus(void);
u32 SND_GetPlayerTickCounter(u32 playerId);
//s16 SND_GetPlayerLocalVariable(u32 playerId, u32 var);
//s16 SND_GetPlayerGlobalVariable(u32 var);
//BOOL SND_ReadChannelInfo(const SNDDriverInfo *driverInfo, s32 chnId, SNDChannelInfo *chnInfo);
//BOOL SND_ReadPlayerInfo(const SNDDriverInfo *driverInfo, s32 playerId, s32 trackId, SNDPlayerInfo *playerInfo);
//BOOL SND_ReadTrackInfo(const SNDDriverInfo *driverInfo s32 playerId, s32 trackId, SNDTrackInfo *trackInfo);
u32 SNDi_GetFinishedCommandTag(void);
void SNDi_InitSharedWork(struct SNDSharedWork *sw);
extern struct SNDSharedWork *SNDi_SharedWork;
#endif // GUARD_SND_WORK_H

39
arm9/lib/src/SND_alarm.c Normal file
View File

@@ -0,0 +1,39 @@
#include "SND_alarm.h"
struct AlarmCallback {
SNDAlarmCallback cb;
void *data;
u8 id;
};
static struct AlarmCallback sCallbackTable[SND_ALARM_COUNT];
ARM_FUNC void SND_AlarmInit(void) {
for (s32 i = 0; i < SND_ALARM_COUNT; i++) {
sCallbackTable[i].cb = NULL;
sCallbackTable[i].data = NULL;
sCallbackTable[i].id = 0;
}
}
ARM_FUNC void SNDi_IncAlarmId(u32 idx) {
struct AlarmCallback *ac = &sCallbackTable[idx];
ac->id++;
}
ARM_FUNC u8 SNDi_SetAlarmHandler(u32 idx, SNDAlarmCallback cb, void *data) {
struct AlarmCallback *ac = &sCallbackTable[idx];
ac->cb = cb;
ac->data = data;
ac->id++;
return ac->id;
}
ARM_FUNC void SNDi_CallAlarmHandler(s32 idx) {
struct AlarmCallback *ac = &sCallbackTable[idx & 0xFF];
if (((idx >> 8) & 0xFF) != ac->id)
return;
if (ac->cb == NULL)
return;
ac->cb(ac->data);
}

175
arm9/lib/src/SND_bank.c Normal file
View File

@@ -0,0 +1,175 @@
#include "SND_bank.h"
#include "OS_mutex.h"
void OS_LockMutex(struct OSMutex *);
void OS_UnlockMutex(struct OSMutex *);
void DC_StoreRange(const void *, u32);
/*
* WaveArc linking seems to work like the following:
*
* Each SNDBankData can have up to 4 WaveArcs assigned.
* To avoid loading the same WaveArc by multiple banks,
* a linked list using WaveArcLinks is chained through all banks
* which use a WaveArc.
*
* That WaveArc has a head pointer, which points to the first
* WaveArcLink in that chain of banks.
*/
/*
* Set bank's wavearc link at index to specified wavearc
*/
ARM_FUNC void SND_AssignWaveArc(struct SNDBankData *bankData, s32 index, struct SNDWaveArc *waveArc) {
SNDi_LockMutex();
struct SNDWaveArc *selectedWaveArc = bankData->waveArcLinks[index].waveArc;
if (selectedWaveArc != NULL) {
if (waveArc == selectedWaveArc) {
SNDi_UnlockMutex();
return;
}
if (&bankData->waveArcLinks[index] == selectedWaveArc->waveArcLLHead) {
selectedWaveArc->waveArcLLHead = bankData->waveArcLinks[index].waveArcLLnext;
DC_StoreRange(bankData->waveArcLinks[index].waveArc, sizeof(struct SNDWaveArc));
} else {
struct SNDWaveArcLink *cur;
for (cur = selectedWaveArc->waveArcLLHead; cur != NULL; cur = cur->waveArcLLnext) {
if (&bankData->waveArcLinks[index] == cur->waveArcLLnext)
break;
}
cur->waveArcLLnext = bankData->waveArcLinks[index].waveArcLLnext;
DC_StoreRange(cur, sizeof(*cur));
}
}
struct SNDWaveArcLink *oldHead = waveArc->waveArcLLHead;
waveArc->waveArcLLHead = &bankData->waveArcLinks[index];
bankData->waveArcLinks[index].waveArcLLnext = oldHead;
bankData->waveArcLinks[index].waveArc = waveArc;
// BUG: Shouldn't the mutex unlock be after writing to cache?
SNDi_UnlockMutex();
DC_StoreRange(bankData, sizeof(*bankData));
DC_StoreRange(waveArc, sizeof(*waveArc));
}
ARM_FUNC void SND_DestroyBank(struct SNDBankData *bankData) {
SNDi_LockMutex();
for (s32 i = 0; i < SND_BANK_MAX_WAVEARC; i++) {
struct SNDWaveArcLink *curWaveArcLink = &bankData->waveArcLinks[i];
struct SNDWaveArc *curWaveArc = bankData->waveArcLinks[i].waveArc;
if (curWaveArc == NULL)
continue;
if (curWaveArcLink == curWaveArc->waveArcLLHead) {
curWaveArc->waveArcLLHead = bankData->waveArcLinks[i].waveArcLLnext;
DC_StoreRange(curWaveArc, sizeof(*curWaveArc));
} else {
struct SNDWaveArcLink *cur;
for (cur = curWaveArc->waveArcLLHead; cur != NULL; cur = cur->waveArcLLnext) {
if (&bankData->waveArcLinks[i] == cur->waveArcLLnext)
break;
}
cur->waveArcLLnext = bankData->waveArcLinks[i].waveArcLLnext;
DC_StoreRange(cur, sizeof(*cur));
}
}
SNDi_UnlockMutex();
}
ARM_FUNC void SND_DestroyWaveArc(struct SNDWaveArc *waveArc) {
SNDi_LockMutex();
struct SNDWaveArcLink *cur = waveArc->waveArcLLHead;
while (cur != NULL) {
struct SNDWaveArcLink *newCur = cur->waveArcLLnext;
cur->waveArc = NULL;
cur->waveArcLLnext = NULL;
DC_StoreRange(cur, sizeof(*cur));
cur = newCur;
}
SNDi_UnlockMutex();
}
ARM_FUNC struct SNDInstPos SND_GetFirstInstDataPos(const struct SNDBankData *bankData) {
struct SNDInstPos retval;
retval.program = 0;
retval.index = 0;
return retval;
}
ARM_FUNC static inline struct SNDDrumSet *test(const struct SNDBankData *bank, u32 off) {
return (struct SNDDrumSet *)((u8 *)bank + (off >> 8));
}
ARM_FUNC BOOL SND_GetNextInstData(const struct SNDBankData *bankData, struct SNDInstData *instData, struct SNDInstPos *instPos) {
while (instPos->program < bankData->instCount) {
struct SNDDrumSet *drums;
struct SNDKeySplit *keySplit;
u32 instOffset = bankData->instOffsets[instPos->program];
instData->type = SND_INST_OFFSET_TYPE(instOffset);
switch (instData->type) {
case SND_INST_PCM:
case SND_INST_PSG:
case SND_INST_NOISE:
case SND_INST_DIRECTPCM:
case SND_INST_DUMMY:
instData->param = *SND_INST_OFFSET_NORMAL(bankData, instOffset);
instPos->program++;
return TRUE;
case SND_INST_DRUM_TABLE:
drums = SND_INST_OFFSET_DRUMS(bankData, instOffset);
// silly programming 101: put a loop in a place that never loops
for (; instPos->index < drums->maxKey - drums->minKey + 1;) {
*instData = drums->instruments[instPos->index];
instPos->index++;
return TRUE;
}
break;
case SND_INST_KEY_SPLIT:
keySplit = SND_INST_OFFSET_KEYSPL(bankData, instOffset);
for (; instPos->index < SND_INST_MAX_KEYSPLIT;) {
if (keySplit->key[instPos->index] == 0)
break;
*instData = keySplit->instruments[instPos->index];
instPos->index++;
return TRUE;
}
break;
}
instPos->program++;
instPos->index = 0;
}
return FALSE;
}
ARM_FUNC u32 SND_GetWaveDataCount(const struct SNDWaveArc *waveArc) {
return waveArc->waveCount;
}
ARM_FUNC void SND_SetWaveDataAddress(struct SNDWaveArc *waveArc, s32 index, const struct SNDWaveData *waveData) {
SNDi_LockMutex();
waveArc->waveOffsets[index] = (u32)waveData;
DC_StoreRange(&waveArc->waveOffsets[index], sizeof(u32));
SNDi_UnlockMutex();
}
ARM_FUNC const struct SNDWaveData *SND_GetWaveDataAddress(const struct SNDWaveArc *waveArc, s32 index) {
SNDi_LockMutex();
u32 retval = waveArc->waveOffsets[index];
if (retval != 0) {
// < 0x2000000 aka, not a pointer to main RAM
if (retval < 0x2000000)
retval = (u32)&((u8 *)waveArc)[retval];
} else {
retval = 0;
}
SNDi_UnlockMutex();
return (struct SNDWaveData *)retval;
}

333
arm9/lib/src/SND_command.c Normal file
View File

@@ -0,0 +1,333 @@
#include "SND_command.h"
#include "SND_work.h"
#include "OS_system.h"
#define SND_CMD_WAIT_QUEUE_COUNT 8
static struct SNDCommand sCommandArray[SND_CMD_COUNT];
static struct SNDSharedWork sSharedWork;
static struct SNDCommand *sWaitingCommandListQueue[SND_CMD_WAIT_QUEUE_COUNT + 1]; // not sure why this is one element to large
static struct SNDCommand *sReserveList;
static struct SNDCommand *sReserveListEnd;
static struct SNDCommand *sFreeListEnd;
static s32 sWaitingCommandListQueueRead;
static s32 sWaitingCommandListQueueWrite;
static s32 sWaitingCommandListCount;
static u32 sCurrentTag;
static u32 sFinishedTag;
static struct SNDCommand *sFreeList;
// TODO remove these function declarations once they are in the headers
extern s32 PXI_SendWordByFifo(u32, u32, u32);
extern void PXI_SetFifoRecvCallback(u32, void (*)(s32, s32));
extern BOOL PXI_IsCallbackReady(u32, u32);
static void InitPXI(void);
static void RequestCommandProc(void);
static struct SNDCommand *AllocCommand(void);
static BOOL IsCommandAvailable(void);
ARM_FUNC void SND_CommandInit(void) {
InitPXI();
sFreeList = sCommandArray;
for (int i = 0; i < SND_CMD_COUNT - 1; i++) {
sCommandArray[i].llNext = &sCommandArray[i+1];
}
sCommandArray[SND_CMD_COUNT - 1].llNext = NULL;
sFreeListEnd = &sCommandArray[SND_CMD_COUNT - 1];
sReserveList = NULL;
sReserveListEnd = NULL;
sWaitingCommandListCount = 0;
sWaitingCommandListQueueRead = 0;
sWaitingCommandListQueueWrite = 0;
sCurrentTag = 1;
sFinishedTag = 0;
SNDi_SharedWork = &sSharedWork;
SNDi_InitSharedWork(SNDi_SharedWork);
struct SNDCommand *cmd = SND_AllocCommand(SND_CMD_FLAG_BLOCK);
if (cmd == NULL)
return;
cmd->id = SND_CMD_SET_SHARED_WORK;
cmd->arg[0] = (u32)SNDi_SharedWork;
SND_PushCommand(cmd);
SND_FlushCommand(SND_CMD_FLAG_BLOCK);
}
ARM_FUNC const struct SNDCommand *SND_RecvCommandReply(u32 flags) {
OSIntrMode oldirq = OS_DisableInterrupts();
if (flags & SND_CMD_FLAG_BLOCK) {
u32 tag = SNDi_GetFinishedCommandTag();
while (sFinishedTag == tag) {
OS_RestoreInterrupts(oldirq);
OS_SpinWait(100);
oldirq = OS_DisableInterrupts();
tag = SNDi_GetFinishedCommandTag();
}
} else {
u32 tag = SNDi_GetFinishedCommandTag();
if (sFinishedTag == tag) {
OS_RestoreInterrupts(oldirq);
return NULL;
}
}
struct SNDCommand *queueRead = sWaitingCommandListQueue[sWaitingCommandListQueueRead];
if (++sWaitingCommandListQueueRead > SND_CMD_WAIT_QUEUE_COUNT)
sWaitingCommandListQueueRead = 0;
struct SNDCommand *cur = queueRead;
while (cur->llNext != NULL)
cur = cur->llNext;
if (sFreeListEnd != NULL) {
sFreeListEnd->llNext = queueRead;
} else {
sFreeList = queueRead;
}
sFreeListEnd = cur;
sWaitingCommandListCount--;
sFinishedTag++;
OS_RestoreInterrupts(oldirq);
return queueRead;
}
ARM_FUNC struct SNDCommand *SND_AllocCommand(u32 flags) {
struct SNDCommand *cmd;
if (!IsCommandAvailable())
return NULL;
cmd = AllocCommand();
if (cmd != NULL)
return cmd;
if ((flags & SND_CMD_FLAG_BLOCK) == 0)
return NULL;
if (SND_CountWaitingCommand() > 0) {
while (SND_RecvCommandReply(SND_CMD_FLAG_NOBLOCK) != NULL) { }
cmd = AllocCommand();
if (cmd != NULL)
return cmd;
} else {
SND_FlushCommand(SND_CMD_FLAG_BLOCK);
}
RequestCommandProc();
do {
SND_RecvCommandReply(SND_CMD_FLAG_BLOCK);
cmd = AllocCommand();
} while (cmd == NULL);
return cmd;
}
ARM_FUNC void SND_PushCommand(struct SNDCommand *cmd) {
OSIntrMode oldirq = OS_DisableInterrupts();
struct SNDCommand *newend = cmd;
if (sReserveListEnd == NULL) {
sReserveList = cmd;
sReserveListEnd = cmd;
} else {
sReserveListEnd->llNext = cmd;
sReserveListEnd = cmd;
}
cmd->llNext = NULL;
OS_RestoreInterrupts(oldirq);
}
ARM_FUNC BOOL SND_FlushCommand(u32 flags) {
OSIntrMode oldirq = OS_DisableInterrupts();
if (sReserveList == NULL) {
OS_RestoreInterrupts(oldirq);
return TRUE;
}
if (sWaitingCommandListCount >= SND_CMD_WAIT_QUEUE_COUNT) {
if ((flags & SND_CMD_FLAG_BLOCK) == 0) {
OS_RestoreInterrupts(oldirq);
return FALSE;
}
do {
SND_RecvCommandReply(SND_CMD_FLAG_BLOCK);
} while (sWaitingCommandListCount >= SND_CMD_WAIT_QUEUE_COUNT);
}
DC_FlushRange(sCommandArray, sizeof(sCommandArray));
s32 result = PXI_SendWordByFifo(7, (u32)sReserveList, 0);
if (result < 0) {
if ((flags & SND_CMD_FLAG_BLOCK) == 0) {
OS_RestoreInterrupts(oldirq);
return FALSE;
}
result = PXI_SendWordByFifo(7, (u32)sReserveList, 0);
while (result < 0) {
OS_RestoreInterrupts(oldirq);
OS_SpinWait(100);
oldirq = OS_DisableInterrupts();
result = PXI_SendWordByFifo(7, (u32)sReserveList, 0);
}
}
if ((flags & SND_CMD_FLAG_IMMEDIATE) != 0) {
RequestCommandProc();
}
sWaitingCommandListQueue[sWaitingCommandListQueueWrite] = sReserveList;
if (++sWaitingCommandListQueueWrite > SND_CMD_WAIT_QUEUE_COUNT) {
sWaitingCommandListQueueWrite = 0;
}
sReserveList = NULL;
sReserveListEnd = NULL;
sWaitingCommandListCount++;
sCurrentTag++;
OS_RestoreInterrupts(oldirq);
return TRUE;
}
ARM_FUNC void SND_WaitForCommandProc(u32 tag) {
if (SND_IsFinishedCommandTag(tag))
return;
while (SND_RecvCommandReply(SND_CMD_FLAG_NOBLOCK) != NULL) { }
if (SND_IsFinishedCommandTag(tag))
return;
RequestCommandProc();
if (SND_IsFinishedCommandTag(tag))
return;
do {
SND_RecvCommandReply(SND_CMD_FLAG_BLOCK);
} while (SND_IsFinishedCommandTag(tag) == 0);
}
ARM_FUNC u32 SND_GetCurrentCommandTag(void) {
OSIntrMode oldirq = OS_DisableInterrupts();
u32 retval;
if (sReserveList == NULL)
retval = sFinishedTag;
else
retval = sCurrentTag;
OS_RestoreInterrupts(oldirq);
return retval;
}
ARM_FUNC BOOL SND_IsFinishedCommandTag(u32 tag) {
OSIntrMode oldirq = OS_DisableInterrupts();
BOOL result;
if (tag > sFinishedTag) {
if (tag - sFinishedTag < 0x80000000)
result = FALSE;
else
result = TRUE;
} else {
if (sFinishedTag - tag < 0x80000000)
result = TRUE;
else
result = FALSE;
}
OS_RestoreInterrupts(oldirq);
return result;
}
ARM_FUNC s32 SND_CountFreeCommand(void) {
OSIntrMode oldirq = OS_DisableInterrupts();
s32 count = 0;
for (struct SNDCommand *cmd = sFreeList; cmd != NULL; cmd = cmd->llNext)
count++;
OS_RestoreInterrupts(oldirq);
return count;
}
ARM_FUNC s32 SND_CountReservedCommand(void) {
OSIntrMode oldirq = OS_DisableInterrupts();
s32 count = 0;
for (struct SNDCommand *cmd = sReserveList; cmd != NULL; cmd = cmd->llNext)
count++;
OS_RestoreInterrupts(oldirq);
return count;
}
ARM_FUNC s32 SND_CountWaitingCommand(void) {
return SND_CMD_COUNT - SND_CountFreeCommand() - SND_CountReservedCommand();
}
ARM_FUNC static void PxiFifoCallback(s32 a, s32 b) {
OSIntrMode oldirq = OS_DisableInterrupts();
SNDi_CallAlarmHandler(b);
OS_RestoreInterrupts(oldirq);
}
ARM_FUNC static void InitPXI(void) {
PXI_SetFifoRecvCallback(7, PxiFifoCallback);
if (!IsCommandAvailable())
return;
if (PXI_IsCallbackReady(7, 1))
return;
do {
OS_SpinWait(100);
} while (!PXI_IsCallbackReady(7, 1));
}
ARM_FUNC static void RequestCommandProc(void) {
while (PXI_SendWordByFifo(7, 0, 0) < 0) { }
}
ARM_FUNC static struct SNDCommand *AllocCommand(void) {
OSIntrMode oldirq = OS_DisableInterrupts();
if (sFreeList == NULL) {
OS_RestoreInterrupts(oldirq);
return NULL;
}
struct SNDCommand *retval = sFreeList;
sFreeList = sFreeList->llNext;
if (sFreeList == NULL)
sFreeListEnd = NULL;
OS_RestoreInterrupts(oldirq);
return retval;
}
ARM_FUNC static BOOL IsCommandAvailable(void) {
if (!OS_IsRunOnEmulator())
return TRUE;
OSIntrMode oldirq = OS_DisableInterrupts();
// TODO use proper register names here
// is this some kind of debug or ensata register?
*(vu32 *)0x4FFF200 = 0x10;
u32 resp = *(vu32 *)0x4FFF200;
OS_RestoreInterrupts(oldirq);
return resp != 0;
}

172
arm9/lib/src/SND_interface.c Normal file
View File

@@ -0,0 +1,172 @@
#include "SND_interface.h"
#include "SND_command.h"
static void PushCommand_impl(s32 id, u32 par1, u32 par2, u32 par3, u32 par4);
#define PushCmd1(id, a) PushCommand_impl(id, (u32)(a), 0, 0, 0)
#define PushCmd2(id, a, b) PushCommand_impl(id, (u32)(a), (u32)(b), 0, 0)
#define PushCmd3(id, a, b, c) PushCommand_impl(id, (u32)(a), (u32)(b), (u32)(c), 0)
#define PushCmd4(id, a, b, c, d) PushCommand_impl(id, (u32)(a), (u32)(b), (u32)(c), (u32)(d))
// TODO fill in "random" constants with macros
// ARM_FUNC void SND_StartSeq(s32 player, const void *seqBasePtr, u32 seqOffset, struct SNDBankData *bankData) { }
ARM_FUNC void SND_StopSeq(s32 player) {
PushCmd1(SND_CMD_STOP_SEQ, player);
}
ARM_FUNC void SND_PrepareSeq(s32 player, const void *seqBasePtr, u32 seqOffset, struct SNDBankData *bankData) {
PushCmd4(SND_CMD_PREPARE_SEQ, player, seqBasePtr, seqOffset, bankData);
}
ARM_FUNC void SND_StartPreparedSeq(s32 player) {
PushCmd1(SND_CMD_START_PREPARED_SEQ, player);
}
ARM_FUNC void SND_PauseSeq(s32 player, BOOL flag) {
PushCmd2(SND_CMD_PAUSE_SEQ, player, flag);
}
// ARM_FUNC void SND_SetPlayerTempoRatio(s32 player, s32 ratio) { }
ARM_FUNC void SND_SetPlayerVolume(s32 player, s32 volume) {
SNDi_SetPlayerParam(player, 6, volume, 2);
}
ARM_FUNC void SND_SetPlayerChannelPriority(s32 player, s32 prio) {
SNDi_SetPlayerParam(player, 4, prio, 1);
}
// ARM_FUNC void SND_SetPlayerLocalVariable(s32 player, s32 varNo, s16 var) { }
// ARM_FUNC void SND_SetPlayerGlobalVariable(s32 varNo, s16 var) { }
// ARM_FUNC void SND_SetTrackVolume(s32 player, u32 trackBitMask, s32 volume) { }
ARM_FUNC void SND_SetTrackPitch(s32 player, u32 trackBitMask, s32 pitch) {
SNDi_SetTrackParam(player, trackBitMask, 12, pitch, 2);
}
ARM_FUNC void SND_SetTrackPan(s32 player, u32 trackBitMask, s32 pan) {
SNDi_SetTrackParam(player, trackBitMask, 9, pan, 1);
}
ARM_FUNC void SND_SetTrackAllocatableChannel(s32 player, u32 trackBitMask, u32 chnBitMask) {
PushCmd3(SND_CMD_ALLOCATABLE_CHANNEL, player, trackBitMask, chnBitMask);
}
ARM_FUNC void SND_StartTimer(u32 chnBitMask, u32 capBitMask, u32 alarmBitMask, u32 flags) {
PushCmd4(SND_CMD_START_TIMER, chnBitMask, capBitMask, alarmBitMask, flags);
}
ARM_FUNC void SND_StopTimer(u32 chnBitMask, u32 capBitMask, u32 alarmBitMask, u32 flags) {
s32 i = 0;
u32 tmpMask = alarmBitMask;
while (i < SND_ALARM_COUNT && tmpMask != 0) {
if (tmpMask & 1)
SNDi_IncAlarmId(i);
i++;
tmpMask >>= 1;
}
PushCmd4(SND_CMD_STOP_TIMER, chnBitMask, capBitMask, alarmBitMask, flags);
}
ARM_FUNC void SND_SetupCapture(s32 capture, s32 format, void *bufferPtr, u32 length, BOOL loopFlag, s32 in, s32 out) {
PushCmd3(SND_CMD_SETUP_CAPTURE, bufferPtr, length,
(capture << 31) | (format << 30) | (loopFlag << 29) | (in << 28) | (out << 27));
}
ARM_FUNC void SND_SetupAlarm(s32 alarm, u32 tick, u32 period, SNDAlarmCallback cb, void *userData) {
PushCmd4(SND_CMD_SETUP_ALARM, alarm, tick, period, SNDi_SetAlarmHandler(alarm, cb, userData));
}
// ARM_FUNC void SND_SetTrackMute(s32 player, u32 trackBitMask, BOOL flag) { }
// ARM_FUNC void SND_StopUnlockedChannel(u32 chnBitMask, u32 flags) { }
ARM_FUNC void SND_LockChannel(u32 chnBitMask, u32 flags) {
PushCmd2(SND_CMD_LOCK_CHANNEL, chnBitMask, flags);
}
ARM_FUNC void SND_UnlockChannel(u32 chnBitMask, u32 flags) {
PushCmd2(SND_CMD_UNLOCK_CHANNEL, chnBitMask, flags);
}
ARM_FUNC void SND_SetChannelTimer(u32 chnBitMask, s32 timer) {
PushCmd2(SND_CMD_CHANNEL_TIMER, chnBitMask, timer);
}
ARM_FUNC void SND_SetChannelVolume(u32 chnBitMask, s32 volume, s32 chnDataShift) {
PushCmd3(SND_CMD_CHANNEL_VOLUME, chnBitMask, volume, chnDataShift);
}
ARM_FUNC void SND_SetChannelPan(u32 chnBitMask, s32 pan) {
PushCmd2(SND_CMD_CHANNEL_PAN, chnBitMask, pan);
}
ARM_FUNC void SND_SetupChannelPcm(s32 chn, s32 waveFormat, const void *dataAddr, s32 loopMode, s32 loopStart, s32 dataLen, s32 volume, s32 chnDataShift, s32 timer, s32 pan) {
PushCmd4(SND_CMD_SETUP_CHANNEL_PCM,
chn | (timer << 16),
dataAddr,
(volume << 24) | (chnDataShift << 22) | dataLen,
(loopMode << 26) | (waveFormat << 24) | (pan << 16) | loopStart);
}
// ARM_FUNC void SND_SetupChannelPsg(s32 chn, s32 sndDuty, s32 volume, s32 chnDataShift, s32 timer, s32 pan) { }
// ARM_FUNC void SND_SetupChannelNoise(s32 chn, s32 volume, s32 chnDataShift, s32 timer, s32 pan) { }
ARM_FUNC void SND_InvalidateSeqData(const void *start, const void *end) {
PushCmd2(SND_CMD_INVALIDATE_SEQ, start, end);
}
ARM_FUNC void SND_InvalidateBankData(const void *start, const void *end) {
PushCmd2(SND_CMD_INVALIDATE_BANK, start, end);
}
ARM_FUNC void SND_InvalidateWaveData(const void *start, const void *end) {
PushCmd2(SND_CMD_INVALIDATE_WAVE, start, end);
}
// ARM_FUNC void SND_SetMasterVolume(s32 volume) { }
ARM_FUNC void SND_SetOutputSelector(s32 left, s32 right, s32 channel1, s32 channel3) {
PushCmd4(SND_CMD_OUTPUT_SELECTOR, left, right, channel1, channel3);
}
ARM_FUNC void SND_SetMasterPan(s32 pan) {
PushCmd1(SND_CMD_MASTER_PAN, pan);
}
ARM_FUNC void SND_ResetMasterPan(void) {
PushCmd1(SND_CMD_MASTER_PAN, -1);
}
// ARM_FUNC void SND_ReadDriverInfo(struct SNDDriverInfo *info) { }
ARM_FUNC void SNDi_SetPlayerParam(s32 player, u32 offset, u32 data, s32 size) {
PushCmd4(SND_CMD_PLAYER_PARAM, player, offset, data, size);
}
ARM_FUNC void SNDi_SetTrackParam(s32 player, u32 trackBitMask, u32 offset, u32 data, s32 size) {
PushCmd4(SND_CMD_TRACK_PARAM, player | (size << 24), trackBitMask, offset, data);
}
// ARM_FUNC void SNDi_SetSurroundDecay(s32 decay) { }
// ARM_FUNC void SNDi_SkipSeq(s32 player, u32 tick) { }
ARM_FUNC static void PushCommand_impl(s32 id, u32 par1, u32 par2, u32 par3, u32 par4) {
struct SNDCommand *cmd = SND_AllocCommand(SND_CMD_FLAG_BLOCK);
if (cmd == NULL)
return;
cmd->id = id;
cmd->arg[0] = par1;
cmd->arg[1] = par2;
cmd->arg[2] = par3;
cmd->arg[3] = par4;
SND_PushCommand(cmd);
}

28
arm9/lib/src/SND_main.c Normal file
View File

@@ -0,0 +1,28 @@
#include "SND_main.h"
#include "global.h"
#include "OS_mutex.h"
static struct OSMutex sSndMutex;
static s32 sSndInitialized;
// TODO remove these declarations once we have the functions in the headers
void OS_UnlockMutex(struct OSMutex *);
void OS_LockMutex(struct OSMutex *);
ARM_FUNC void SND_Init(void) {
if (sSndInitialized)
return;
sSndInitialized = 1;
OS_InitMutex(&sSndMutex);
SND_CommandInit();
SND_AlarmInit();
}
ARM_FUNC void SNDi_LockMutex(void) {
OS_LockMutex(&sSndMutex);
}
ARM_FUNC void SNDi_UnlockMutex(void) {
OS_UnlockMutex(&sSndMutex);
}

238
arm9/lib/src/SND_util.c Normal file
View File

@@ -0,0 +1,238 @@
#include "SND_util.h"
// not used in pokediamond
//static const u16 sPitchTable[0x600] = {
// 0x0000, 0x003B, 0x0076, 0x00B2, 0x00ED, 0x0128, 0x0164, 0x019f,
// 0x01DB, 0x0217, 0x0252, 0x028E, 0x02CA, 0x0305, 0x0341, 0x037D,
// 0x03B9, 0x03F5, 0x0431, 0x046E, 0x04AA, 0x04E6, 0x0522, 0x055F,
// 0x059B, 0x05D8, 0x0614, 0x0651, 0x068D, 0x06CA, 0x0707, 0x0743,
// 0x0780, 0x07BD, 0x07FA, 0x0837, 0x0874, 0x08B1, 0x08EF, 0x092C,
// 0x0969, 0x09A7, 0x09E4, 0x0A21, 0x0A5F, 0x0A9C, 0x0ADA, 0x0B18,
// 0x0B56, 0x0B93, 0x0BD1, 0x0C0F, 0x0C4D, 0x0C8B, 0x0CC9, 0x0D07,
// 0x0D45, 0x0D84, 0x0DC2, 0x0E00, 0x0E3F, 0x0E7D, 0x0EBC, 0x0EFA,
// 0x0F39, 0x0F78, 0x0FB6, 0x0FF5, 0x1034, 0x1073, 0x10B2, 0x10F1,
// 0x1130, 0x116F, 0x11AE, 0x11EE, 0x122D, 0x126C, 0x12AC, 0x12EB,
// 0x132B, 0x136B, 0x13AA, 0x13EA, 0x142A, 0x146A, 0x14A9, 0x14E9,
// 0x1529, 0x1569, 0x15AA, 0x15EA, 0x162A, 0x166A, 0x16AB, 0x16EB,
// 0x172C, 0x176C, 0x17AD, 0x17ED, 0x182E, 0x186F, 0x18B0, 0x18F0,
// 0x1931, 0x1972, 0x19B3, 0x19F5, 0x1A36, 0x1A77, 0x1AB8, 0x1AFA,
// 0x1B3B, 0x1B7D, 0x1BBE, 0x1C00, 0x1C41, 0x1C83, 0x1CC5, 0x1D07,
// 0x1D48, 0x1D8A, 0x1DCC, 0x1E0E, 0x1E51, 0x1E93, 0x1ED5, 0x1F17,
// 0x1F5A, 0x1F9C, 0x1FDF, 0x2021, 0x2064, 0x20A6, 0x20E9, 0x212C,
// 0x216F, 0x21B2, 0x21F5, 0x2238, 0x227B, 0x22BE, 0x2301, 0x2344,
// 0x2388, 0x23CB, 0x240E, 0x2452, 0x2496, 0x24D9, 0x251D, 0x2561,
// 0x25A4, 0x25E8, 0x262C, 0x2670, 0x26B4, 0x26F8, 0x273D, 0x2781,
// 0x27C5, 0x280A, 0x284E, 0x2892, 0x28D7, 0x291C, 0x2960, 0x29A5,
// 0x29EA, 0x2A2F, 0x2A74, 0x2AB9, 0x2AFE, 0x2B43, 0x2B88, 0x2BCD,
// 0x2C13, 0x2C58, 0x2C9D, 0x2CE3, 0x2D28, 0x2D6E, 0x2DB4, 0x2DF9,
// 0x2E3F, 0x2E85, 0x2ECB, 0x2F11, 0x2F57, 0x2F9D, 0x2FE3, 0x302A,
// 0x3070, 0x30B6, 0x30FD, 0x3143, 0x318A, 0x31D0, 0x3217, 0x325E,
// 0x32A5, 0x32EC, 0x3332, 0x3379, 0x33C1, 0x3408, 0x344F, 0x3496,
// 0x34DD, 0x3525, 0x356C, 0x35B4, 0x35FB, 0x3643, 0x368B, 0x36D3,
// 0x371A, 0x3762, 0x37AA, 0x37F2, 0x383A, 0x3883, 0x38CB, 0x3913,
// 0x395C, 0x39A4, 0x39ED, 0x3A35, 0x3A7E, 0x3AC6, 0x3B0F, 0x3B58,
// 0x3BA1, 0x3BEA, 0x3C33, 0x3C7C, 0x3CC5, 0x3D0E, 0x3D58, 0x3DA1,
// 0x3DEA, 0x3E34, 0x3E7D, 0x3EC7, 0x3F11, 0x3F5A, 0x3FA4, 0x3FEE,
// 0x4038, 0x4082, 0x40CC, 0x4116, 0x4161, 0x41AB, 0x41F5, 0x4240,
// 0x428A, 0x42D5, 0x431F, 0x436A, 0x43B5, 0x4400, 0x444B, 0x4495,
// 0x44E1, 0x452C, 0x4577, 0x45C2, 0x460D, 0x4659, 0x46A4, 0x46F0,
// 0x473B, 0x4787, 0x47D3, 0x481E, 0x486A, 0x48B6, 0x4902, 0x494E,
// 0x499A, 0x49E6, 0x4A33, 0x4A7F, 0x4ACB, 0x4B18, 0x4B64, 0x4BB1,
// 0x4BFE, 0x4C4A, 0x4C97, 0x4CE4, 0x4D31, 0x4D7E, 0x4DCB, 0x4E18,
// 0x4E66, 0x4EB3, 0x4F00, 0x4F4E, 0x4F9B, 0x4FE9, 0x5036, 0x5084,
// 0x50D2, 0x5120, 0x516E, 0x51BC, 0x520A, 0x5258, 0x52A6, 0x52F4,
// 0x5343, 0x5391, 0x53E0, 0x542E, 0x547D, 0x54CC, 0x551A, 0x5569,
// 0x55B8, 0x5607, 0x5656, 0x56A5, 0x56F4, 0x5744, 0x5793, 0x57E2,
// 0x5832, 0x5882, 0x58D1, 0x5921, 0x5971, 0x59C1, 0x5A10, 0x5A60,
// 0x5AB0, 0x5B01, 0x5B51, 0x5BA1, 0x5BF1, 0x5C42, 0x5C92, 0x5CE3,
// 0x5D34, 0x5D84, 0x5DD5, 0x5E26, 0x5E77, 0x5EC8, 0x5F19, 0x5F6A,
// 0x5FBB, 0x600D, 0x605E, 0x60B0, 0x6101, 0x6153, 0x61A4, 0x61F6,
// 0x6248, 0x629A, 0x62EC, 0x633E, 0x6390, 0x63E2, 0x6434, 0x6487,
// 0x64D9, 0x652C, 0x657E, 0x65D1, 0x6624, 0x6676, 0x66C9, 0x671C,
// 0x676F, 0x67C2, 0x6815, 0x6869, 0x68BC, 0x690F, 0x6963, 0x69B6,
// 0x6A0A, 0x6A5E, 0x6AB1, 0x6B05, 0x6B59, 0x6BAD, 0x6C01, 0x6C55,
// 0x6CAA, 0x6CFE, 0x6D52, 0x6DA7, 0x6DFB, 0x6E50, 0x6EA4, 0x6EF9,
// 0x6F4E, 0x6FA3, 0x6FF8, 0x704D, 0x70A2, 0x70F7, 0x714D, 0x71A2,
// 0x71F7, 0x724D, 0x72A2, 0x72F8, 0x734E, 0x73A4, 0x73FA, 0x7450,
// 0x74A6, 0x74FC, 0x7552, 0x75A8, 0x75FF, 0x7655, 0x76AC, 0x7702,
// 0x7759, 0x77B0, 0x7807, 0x785E, 0x78B4, 0x790C, 0x7963, 0x79BA,
// 0x7A11, 0x7A69, 0x7AC0, 0x7B18, 0x7B6F, 0x7BC7, 0x7C1F, 0x7C77,
// 0x7CCF, 0x7D27, 0x7D7F, 0x7DD7, 0x7E2F, 0x7E88, 0x7EE0, 0x7F38,
// 0x7F91, 0x7FEA, 0x8042, 0x809B, 0x80F4, 0x814D, 0x81A6, 0x81FF,
// 0x8259, 0x82B2, 0x830B, 0x8365, 0x83BE, 0x8418, 0x8472, 0x84CB,
// 0x8525, 0x857F, 0x85D9, 0x8633, 0x868E, 0x86E8, 0x8742, 0x879D,
// 0x87F7, 0x8852, 0x88AC, 0x8907, 0x8962, 0x89BD, 0x8A18, 0x8A73,
// 0x8ACE, 0x8B2A, 0x8B85, 0x8BE0, 0x8C3C, 0x8C97, 0x8CF3, 0x8D4F,
// 0x8DAB, 0x8E07, 0x8E63, 0x8EBF, 0x8F1B, 0x8F77, 0x8FD4, 0x9030,
// 0x908C, 0x90E9, 0x9146, 0x91A2, 0x91FF, 0x925C, 0x92B9, 0x9316,
// 0x9373, 0x93D1, 0x942E, 0x948C, 0x94E9, 0x9547, 0x95A4, 0x9602,
// 0x9660, 0x96BE, 0x971C, 0x977A, 0x97D8, 0x9836, 0x9895, 0x98F3,
// 0x9952, 0x99B0, 0x9A0F, 0x9A6E, 0x9ACD, 0x9B2C, 0x9B8B, 0x9BEA,
// 0x9C49, 0x9CA8, 0x9D08, 0x9D67, 0x9DC7, 0x9E26, 0x9E86, 0x9EE6,
// 0x9F46, 0x9FA6, 0xA006, 0xA066, 0xA0C6, 0xA127, 0xA187, 0xA1E8,
// 0xA248, 0xA2A9, 0xA30A, 0xA36B, 0xA3CC, 0xA42D, 0xA48E, 0xA4EF,
// 0xA550, 0xA5B2, 0xA613, 0xA675, 0xA6D6, 0xA738, 0xA79A, 0xA7FC,
// 0xA85E, 0xA8C0, 0xA922, 0xA984, 0xA9E7, 0xAA49, 0xAAAC, 0xAB0E,
// 0xAB71, 0xABD4, 0xAC37, 0xAC9A, 0xACFD, 0xAD60, 0xADC3, 0xAE27,
// 0xAE8A, 0xAEED, 0xAF51, 0xAFB5, 0xB019, 0xB07C, 0xB0E0, 0xB145,
// 0xB1A9, 0xB20D, 0xB271, 0xB2D6, 0xB33A, 0xB39F, 0xB403, 0xB468,
// 0xB4CD, 0xB532, 0xB597, 0xB5FC, 0xB662, 0xB6C7, 0xB72C, 0xB792,
// 0xB7F7, 0xB85D, 0xB8C3, 0xB929, 0xB98F, 0xB9F5, 0xBA5B, 0xBAC1,
// 0xBB28, 0xBB8E, 0xBBF5, 0xBC5B, 0xBCC2, 0xBD29, 0xBD90, 0xBDF7,
// 0xBE5E, 0xBEC5, 0xBF2C, 0xBF94, 0xBFFB, 0xC063, 0xC0CA, 0xC132,
// 0xC19A, 0xC202, 0xC26A, 0xC2D2, 0xC33A, 0xC3A2, 0xC40B, 0xC473,
// 0xC4DC, 0xC544, 0xC5AD, 0xC616, 0xC67F, 0xC6E8, 0xC751, 0xC7BB,
// 0xC824, 0xC88D, 0xC8F7, 0xC960, 0xC9CA, 0xCA34, 0xCA9E, 0xCB08,
// 0xCB72, 0xCBDC, 0xCC47, 0xCCB1, 0xCD1B, 0xCD86, 0xCDF1, 0xCE5B,
// 0xCEC6, 0xCF31, 0xCF9C, 0xD008, 0xD073, 0xD0DE, 0xD14A, 0xD1B5,
// 0xD221, 0xD28D, 0xD2F8, 0xD364, 0xD3D0, 0xD43D, 0xD4A9, 0xD515,
// 0xD582, 0xD5EE, 0xD65B, 0xD6C7, 0xD734, 0xD7A1, 0xD80E, 0xD87B,
// 0xD8E9, 0xD956, 0xD9C3, 0xDA31, 0xDA9E, 0xDB0C, 0xDB7A, 0xDBE8,
// 0xDC56, 0xDCC4, 0xDD32, 0xDDA0, 0xDE0F, 0xDE7D, 0xDEEC, 0xDF5B,
// 0xDFC9, 0xE038, 0xE0A7, 0xE116, 0xE186, 0xE1F5, 0xE264, 0xE2D4,
// 0xE343, 0xE3B3, 0xE423, 0xE493, 0xE503, 0xE573, 0xE5E3, 0xE654,
// 0xE6C4, 0xE735, 0xE7A5, 0xE816, 0xE887, 0xE8F8, 0xE969, 0xE9DA,
// 0xEA4B, 0xEABC, 0xEB2E, 0xEB9F, 0xEC11, 0xEC83, 0xECF5, 0xED66,
// 0xEDD9, 0xEE4B, 0xEEBD, 0xEF2F, 0xEFA2, 0xF014, 0xF087, 0xF0FA,
// 0xF16D, 0xF1E0, 0xF253, 0xF2C6, 0xF339, 0xF3AD, 0xF420, 0xF494,
// 0xF507, 0xF57B, 0xF5EF, 0xF663, 0xF6D7, 0xF74C, 0xF7C0, 0xF834,
// 0xF8A9, 0xF91E, 0xF992, 0xFA07, 0xFA7C, 0xFAF1, 0xFB66, 0xFBDC,
// 0xFC51, 0xFCC7, 0xFD3C, 0xFDB2, 0xFE28, 0xFE9E, 0xFF14, 0xFF8A,
//};
static const u8 sVolumeTable[724] = {
0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8,
8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9,
9, 9, 0xA, 0xA, 0xA, 0xA, 0xA, 0xA, 0xA, 0xA, 0xB,
0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xB, 0xC, 0xC, 0xC, 0xC,
0xC, 0xC, 0xC, 0xC, 0xD, 0xD, 0xD, 0xD, 0xD, 0xD, 0xE,
0xE, 0xE, 0xE, 0xE, 0xE, 0xE, 0xF, 0xF, 0xF, 0xF, 0xF,
0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x11, 0x11, 0x11,
0x11, 0x11, 0x12, 0x12, 0x12, 0x12, 0x12, 0x13, 0x13,
0x13, 0x13, 0x14, 0x14, 0x14, 0x14, 0x14, 0x15, 0x15,
0x15, 0x15, 0x16, 0x16, 0x16, 0x16, 0x17, 0x17, 0x17,
0x18, 0x18, 0x18, 0x18, 0x19, 0x19, 0x19, 0x19, 0x1A,
0x1A, 0x1A, 0x1B, 0x1B, 0x1B, 0x1C, 0x1C, 0x1C, 0x1D,
0x1D, 0x1D, 0x1E, 0x1E, 0x1E, 0x1F, 0x1F, 0x1F, 0x20,
0x20, 0x20, 0x21, 0x21, 0x22, 0x22, 0x22, 0x23, 0x23,
0x24, 0x24, 0x24, 0x25, 0x25, 0x26, 0x26, 0x27, 0x27,
0x27, 0x28, 0x28, 0x29, 0x29, 0x2A, 0x2A, 0x2B, 0x2B,
0x2C, 0x2C, 0x2D, 0x2D, 0x2E, 0x2E, 0x2F, 0x2F, 0x30,
0x31, 0x31, 0x32, 0x32, 0x33, 0x33, 0x34, 0x35, 0x35,
0x36, 0x36, 0x37, 0x38, 0x38, 0x39, 0x3A, 0x3A, 0x3B,
0x3C, 0x3C, 0x3D, 0x3E, 0x3F, 0x3F, 0x40, 0x41, 0x42,
0x42, 0x43, 0x44, 0x45, 0x45, 0x46, 0x47, 0x48, 0x49,
0x4A, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51,
0x52, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
0x5A, 0x5B, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63,
0x64, 0x65, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6D, 0x6E,
0x6F, 0x71, 0x72, 0x73, 0x75, 0x76, 0x77, 0x79, 0x7A,
0x7B, 0x7D, 0x7E, 0x7F, 0x20, 0x21, 0x21, 0x21, 0x22,
0x22, 0x23, 0x23, 0x23, 0x24, 0x24, 0x25, 0x25, 0x26,
0x26, 0x26, 0x27, 0x27, 0x28, 0x28, 0x29, 0x29, 0x2A,
0x2A, 0x2B, 0x2B, 0x2C, 0x2C, 0x2D, 0x2D, 0x2E, 0x2E,
0x2F, 0x2F, 0x30, 0x30, 0x31, 0x31, 0x32, 0x33, 0x33,
0x34, 0x34, 0x35, 0x36, 0x36, 0x37, 0x37, 0x38, 0x39,
0x39, 0x3A, 0x3B, 0x3B, 0x3C, 0x3D, 0x3E, 0x3E, 0x3F,
0x40, 0x40, 0x41, 0x42, 0x43, 0x43, 0x44, 0x45, 0x46,
0x47, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4D,
0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56,
0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F,
0x60, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x69, 0x6A,
0x6B, 0x6C, 0x6D, 0x6F, 0x70, 0x71, 0x73, 0x74, 0x75,
0x77, 0x78, 0x79, 0x7B, 0x7C, 0x7E, 0x7E, 0x40, 0x41,
0x42, 0x43, 0x43, 0x44, 0x45, 0x46, 0x47, 0x47, 0x48,
0x49, 0x4A, 0x4B, 0x4C, 0x4C, 0x4D, 0x4E, 0x4F, 0x50,
0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62,
0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6B, 0x6C, 0x6D,
0x6E, 0x70, 0x71, 0x72, 0x74, 0x75, 0x76, 0x78, 0x79,
0x7B, 0x7C, 0x7D, 0x7E, 0x40, 0x41, 0x42, 0x42, 0x43,
0x44, 0x45, 0x46, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B,
0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53,
0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C,
0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x65, 0x66,
0x67, 0x68, 0x69, 0x6A, 0x6C, 0x6D, 0x6E, 0x6F, 0x71,
0x72, 0x73, 0x75, 0x76, 0x77, 0x79, 0x7A, 0x7C, 0x7D,
0x7E, 0x7F,
};
const s16 SNDi_DecibelTable[0x80] = {
-32768,-421,-361, -325, -300, -281, -265, -252,
-240, -230, -221, -212, -205, -198, -192, -186,
-180, -175, -170, -165, -161, -156, -152, -148,
-145, -141, -138, -134, -131, -128, -125, -122,
-120, -117, -114, -112, -110, -107, -105, -103,
-100, -98, -96, -94, -92, -90, -88, -86,
-85, -83, -81, -79, -78, -76, -74, -73,
-71, -70, -68, -67, -65, -64, -62, -61,
-60, -58, -57, -56, -54, -53, -52, -51,
-49, -48, -47, -46, -45, -43, -42, -41,
-40, -39, -38, -37, -36, -35, -34, -33,
-32, -31, -30, -29, -28, -27, -26, -25,
-24, -23, -23, -22, -21, -20, -19, -18,
-17, -17, -16, -15, -14, -13, -12, -12,
-11, -10, -9, -9, -8, -7, -6, -6,
-5, -4, -3, -3, -2, -1, -1, 0,
};
// not used in pokediamond
//const s16 SNDi_DecibelSquareTable[0x80] = {
// -32768,-722,-721, -651, -601, -562, -530, -503,
// -480, -460, -442, -425, -410, -396, -383, -371,
// -360, -349, -339, -330, -321, -313, -305, -297,
// -289, -282, -276, -269, -263, -257, -251, -245,
// -239, -234, -229, -224, -219, -214, -210, -205,
// -201, -196, -192, -188, -184, -180, -176, -173,
// -169, -165, -162, -158, -155, -152, -149, -145,
// -142, -139, -136, -133, -130, -127, -125, -122,
// -119, -116, -114, -111, -109, -106, -103, -101,
// -99, -96, -94, -91, -89, -87, -85, -82,
// -80, -78, -76, -74, -72, -70, -68, -66,
// -64, -62, -60, -58, -56, -54, -52, -50,
// -49, -47, -45, -43, -42, -40, -38, -36,
// -35, -33, -31, -30, -28, -27, -25, -23,
// -22, -20, -19, -17, -16, -14, -13, -11,
// -10, -8, -7, -6, -4, -3, -1, 0,
//};
ARM_FUNC u16 SND_CalcChannelVolume(s32 x) {
// directly using s32 doesn't match
int decibels = (int)x;
if (decibels < -723)
decibels = -723;
else if (decibels > 0)
decibels = 0;
u32 resultLo = sVolumeTable[decibels + 723];
u32 resultHi;
if (decibels < -240) {
resultHi = 3;
} else {
if (decibels < -120) {
resultHi = 2;
} else {
if (decibels < -60) {
resultHi = 1;
} else {
resultHi = 0;
}
}
}
return (u16)((resultHi << 8u) | resultLo);
}

115
arm9/lib/src/SND_work.c Normal file
View File

@@ -0,0 +1,115 @@
#include "SND_work.h"
#include "SND_alarm.h"
#include "SND_main.h"
struct SNDSharedWork *SNDi_SharedWork;
void DC_InvalidateRange(void *mem, u32 size);
void DC_FlushRange(void *mem, u32 size);
u32 SND_GetPlayerStatus(void) {
DC_InvalidateRange(&SNDi_SharedWork->playerStatus, 4);
return SNDi_SharedWork->playerStatus;
}
u16 SND_GetChannelStatus(void) {
DC_InvalidateRange(&SNDi_SharedWork->channelStatus, 2);
return SNDi_SharedWork->channelStatus;
}
//u16 SND_GetCaptureStatus(void) {
// DC_InvalidateRange(&SNDi_SharedWork->captureStatus, 2);
// return SNDi_SharedWork->captureStatus;
//}
u32 SND_GetPlayerTickCounter(u32 playerId) {
DC_InvalidateRange(&SNDi_SharedWork->players[playerId].tickCounter, 4);
return SNDi_SharedWork->players[playerId].tickCounter;
}
//s16 SND_GetPlayerLocalVariable(u32 playerId, u32 var) {
// DC_InvalidateRange(&SNDi_SharedWork->players[playerId].localVars[var], 2);
// return SNDi_SharedWork->players[playerId].localVars[var];
//}
//
//s16 SND_GetPlayerLocalVariable(u32 var) {
// DC_InvalidateRange(&SNDi_SharedWork->globalVars[var], 2);
// return SNDi_SharedWork->globalVars[var];
//}
//
//BOOL SND_ReadChannelInfo(const SNDDriverInfo *driverInfo, s32 chnId, SNDChannelInfo *chnInfo) {
// // T O D O, implement if it's actually used
//}
//
//BOOL SND_ReadPlayerInfo(const SNDDriverInfo *driverInfo, s32 playerId, SNDPlayerInfo *playerInfo) {
// if (playerId < 0 || playerId >= SND_PLAYER_COUNT)
// return FALSE;
// SNDPlayer *player = &driverInfo->work.players[playerId];
// playerInfo->trackBitMask = 0;
// for (s32 i = 0; i < SND_TRACK_COUNT; i++) {
// if (player->tracks[i] != SND_INVALID_TRACK_INDEX) {
// playerInfo->trackBitMask |= (1 << i);
// }
// }
// playerInfo->flags.active = player->flags.active;
// playerInfo->flags.paused = player->flags.paused;
// playerInfo->tempo = player->tempo;
// playerInfo->volume = player->volume;
// return TRUE;
//}
//
//
//BOOL SND_ReadTrackInfo(const SNDDriverInfo *driverInfo s32 playerId, s32 trackId, SNDTrackInfo *trackInfo) {
// if (playerId < 0 || playerId >= SND_PLAYER_COUNT)
// return FALSE;
// if (trackId < 0 || trackId >= SND_TRACK_COUNT)
// return FALSE;
// SNDPlayer *player = &driverInfo->work.players[playerId];
// if (player->tracks[trackId] == SND_INVALID_TRACK_INDEX)
// return FALSE;
// SNDTrack *track = &driverInfo->work.tracks[trackId];
// trackInfo->program = track->program;
// trackInfo->volume = track->volume;
// trackInfo->expression = track->expression;
// trackInfo->pitchBend = track->pitchBend;
// trackInfo->bendRange = track->bendRange;
// trackInfo->pan = track->pan + 0x40; // 0x40 == MIDI center pan
// trackInfo->transpose = track->transpose;
// trackInfo->chnCount = 0;
//
// //#define LL_READ_PTR(ptr, basePtr, base) (ptr ? ((typeof(ptr))(s32)(ptr) - (s32)(basePtr) + (s32)&(base)) : NULL)
// //for (SNDExChannel *exChn = LL_READ_PTR(track->channelLLHead, driverInfo->workPtr, driverInfo->work);
// // exChn != NULL; exChn = LL_READ_PTR(exChn->channelLLNext, driverInfo->workPtr, driverInfo->work))
// //{
// // trackInfo->channel[trackInfo->chnCount] = exChn->id;
// // trackInfo->chnCount++;
// //}
// //#undef LL_READ_PTR
//
// return TRUE;
//}
ARM_FUNC u32 SNDi_GetFinishedCommandTag(void) {
DC_InvalidateRange(&SNDi_SharedWork->finishedCommandTag, 4);
return SNDi_SharedWork->finishedCommandTag;
}
ARM_FUNC void SNDi_InitSharedWork(struct SNDSharedWork *sw) {
sw->playerStatus = 0;
sw->channelStatus = 0;
sw->captureStatus = 0;
sw->finishedCommandTag = 0;
for (s32 i = 0; i < SND_PLAYER_COUNT; i++) {
sw->players[i].tickCounter = 0;
for (s32 j = 0; j < 16; j++) {
sw->players[i].localVars[j] = -1;
}
}
for (s32 i = 0; i < 16; i++) {
sw->globalVars[i] = -1;
}
DC_FlushRange(sw, sizeof(*sw));
}