Leahnaya/pokeplatinum
1
0
Fork 0
mirror of https://github.com/pret/pokeplatinum.git synced 2026-04-26 00:32:20 -05:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Match all of NitroSDK/snd

Browse Source
This commit is contained in:
Nomura 2023-01-10 17:43:39 +01:00
parent 899f8b83ac
commit 30ff062613
20 changed files with 2781 additions and 1916 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
lib/NitroSDK/asm/snd/include/snd_bank.inc
View File

@ -1,3 +0,0 @@
.public DC_StoreRange
.public SNDi_LockMutex
.public SNDi_UnlockMutex

24
lib/NitroSDK/asm/snd/include/snd_command.inc
View File

@ -1,24 +0,0 @@
.public OS_IsRunOnEmulator
.public DC_FlushRange
.public OS_DisableInterrupts
.public OS_RestoreInterrupts
.public OS_SpinWait
.public SND_RecvCommandReply
.public SND_AllocCommand
.public SND_PushCommand
.public SND_FlushCommand
.public SND_IsFinishedCommandTag
.public SND_CountFreeCommand
.public SND_CountReservedCommand
.public SND_CountWaitingCommand
.public PxiFifoCallback
.public InitPXI
.public RequestCommandProc
.public AllocCommand
.public IsCommandAvailable
.public SNDi_CallAlarmHandler
.public SNDi_GetFinishedCommandTag
.public SNDi_InitSharedWork
.public PXI_SetFifoRecvCallback
.public PXI_IsCallbackReady
.public PXI_SendWordByFifo

7
lib/NitroSDK/asm/snd/include/snd_interface.inc
View File

@ -1,7 +0,0 @@
.public SNDi_SetPlayerParam
.public SNDi_SetTrackParam
.public PushCommand_impl
.public SND_AllocCommand
.public SND_PushCommand
.public SNDi_IncAlarmId
.public SNDi_SetAlarmHandler

5
lib/NitroSDK/asm/snd/include/snd_main.inc
View File

@ -1,5 +0,0 @@
.public OS_InitMutex
.public OS_LockMutex
.public OS_UnlockMutex
.public SND_CommandInit
.public SND_AlarmInit

2
lib/NitroSDK/asm/snd/include/snd_work.inc
View File

@ -1,2 +0,0 @@
.public DC_InvalidateRange
.public DC_FlushRange

85
lib/NitroSDK/asm/snd/snd_alarm.s
View File

@ -1,85 +0,0 @@
.include "macros/function.inc"
.extern Unk_021CEB20
.text
arm_func_start SND_AlarmInit
SND_AlarmInit: ; 0x020C5CF0
mov r1, #0
ldr r2, _020C5D1C ; =0x021CEB20
mov r0, r1
_020C5CFC:
str r0, [r2, #0]
str r0, [r2, #4]
add r1, r1, #1
strb r0, [r2, #8]
cmp r1, #8
add r2, r2, #0xc
blt _020C5CFC
bx lr
; .align 2, 0
_020C5D1C: .word Unk_021CEB20
arm_func_end SND_AlarmInit
arm_func_start SNDi_IncAlarmId
SNDi_IncAlarmId: ; 0x020C5D20
ldr r2, _020C5D3C ; =0x021CEB20
mov r1, #0xc
mla r1, r0, r1, r2
ldrb r0, [r1, #8]
add r0, r0, #1
strb r0, [r1, #8]
bx lr
; .align 2, 0
_020C5D3C: .word Unk_021CEB20
arm_func_end SNDi_IncAlarmId
arm_func_start SNDi_SetAlarmHandler
SNDi_SetAlarmHandler: ; 0x020C5D40
mov r3, #0xc
mul r3, r0, r3
ldr r0, _020C5D6C ; =0x021CEB20
str r1, [r0, r3]
add r1, r0, r3
str r2, [r1, #4]
ldrb r0, [r1, #8]
add r0, r0, #1
strb r0, [r1, #8]
and r0, r0, #0xff
bx lr
; .align 2, 0
_020C5D6C: .word Unk_021CEB20
arm_func_end SNDi_SetAlarmHandler
arm_func_start SNDi_CallAlarmHandler
SNDi_CallAlarmHandler: ; 0x020C5D70
stmfd sp!, {r3, lr}
ldr r3, _020C5DB0 ; =0x021CEB20
and r2, r0, #0xff
mov r1, #0xc
mla r3, r2, r1, r3
mov r1, r0, asr #8
ldrb r0, [r3, #8]
and r1, r1, #0xff
cmp r1, r0
ldmneia sp!, {r3, pc}
ldr r1, [r3, #0]
cmp r1, #0
ldmeqia sp!, {r3, pc}
ldr r0, [r3, #4]
blx r1
ldmia sp!, {r3, pc}
; .align 2, 0
_020C5DB0: .word Unk_021CEB20
arm_func_end SNDi_CallAlarmHandler
.bss
.global Unk_021CEB20
Unk_021CEB20: ; 0x021CEB20
.space 0x60

318
lib/NitroSDK/asm/snd/snd_bank.s
View File

@ -1,318 +0,0 @@
.include "macros/function.inc"
.include "include/snd_bank.inc"
.text
arm_func_start SND_AssignWaveArc
SND_AssignWaveArc: ; 0x020C5F5C
stmfd sp!, {r4, r5, r6, lr}
mov r6, r0
mov r5, r1
mov r4, r2
bl SNDi_LockMutex
add r3, r6, r5, lsl #3
ldr r2, [r3, #0x18]
cmp r2, #0
beq _020C5FEC
cmp r4, r2
bne _020C5F90
bl SNDi_UnlockMutex
ldmia sp!, {r4, r5, r6, pc}
_020C5F90:
add r1, r6, #0x18
ldr r0, [r2, #0x18]
add ip, r1, r5, lsl #3
cmp ip, r0
bne _020C5FBC
ldr r0, [r3, #0x1c]
mov r1, #0x3c
str r0, [r2, #0x18]
ldr r0, [r3, #0x18]
bl DC_StoreRange
b _020C5FEC
_020C5FBC:
cmp r0, #0
beq _020C5FD8
_020C5FC4:
ldr r1, [r0, #4]
cmp ip, r1
movne r0, r1
cmpne r1, #0
bne _020C5FC4
_020C5FD8:
add r1, r6, r5, lsl #3
ldr r2, [r1, #0x1c]
mov r1, #8
str r2, [r0, #4]
bl DC_StoreRange
_020C5FEC:
add r0, r6, #0x18
ldr r1, [r4, #0x18]
add r0, r0, r5, lsl #3
str r0, [r4, #0x18]
add r0, r6, r5, lsl #3
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, r5, r6, pc}
arm_func_end SND_AssignWaveArc
arm_func_start SND_DestroyBank
SND_DestroyBank: ; 0x020C6028
stmfd sp!, {r4, r5, r6, r7, r8, lr}
mov r7, r0
bl SNDi_LockMutex
add r5, r7, #0x18
mov r6, #0
mov r8, #8
mov r4, #0x3c
_020C6044:
add r1, r7, r6, lsl #3
ldr r0, [r1, #0x18]
cmp r0, #0
beq _020C60A8
ldr r3, [r0, #0x18]
cmp r5, r3
bne _020C6074
ldr r2, [r1, #0x1c]
mov r1, r4
str r2, [r0, #0x18]
bl DC_StoreRange
b _020C60A8
_020C6074:
cmp r3, #0
beq _020C6090
_020C607C:
ldr r0, [r3, #4]
cmp r5, r0
movne r3, r0
cmpne r0, #0
bne _020C607C
_020C6090:
add r0, r7, r6, lsl #3
ldr r2, [r0, #0x1c]
mov r0, r3
mov r1, r8
str r2, [r3, #4]
bl DC_StoreRange
_020C60A8:
add r6, r6, #1
cmp r6, #4
add r5, r5, #8
blt _020C6044
bl SNDi_UnlockMutex
ldmia sp!, {r4, r5, r6, r7, r8, pc}
arm_func_end SND_DestroyBank
arm_func_start SND_DestroyWaveArc
SND_DestroyWaveArc: ; 0x020C60C0
stmfd sp!, {r4, r5, r6, lr}
mov r4, r0
bl SNDi_LockMutex
ldr r0, [r4, #0x18]
cmp r0, #0
beq _020C6100
mov r5, #0
mov r4, #8
_020C60E0:
ldr r6, [r0, #4]
mov r1, r4
str r5, [r0, #0]
str r5, [r0, #4]
bl DC_StoreRange
mov r0, r6
cmp r6, #0
bne _020C60E0
_020C6100:
bl SNDi_UnlockMutex
ldmia sp!, {r4, r5, r6, pc}
arm_func_end SND_DestroyWaveArc
arm_func_start SND_GetFirstInstDataPos
SND_GetFirstInstDataPos: ; 0x020C6108
sub sp, sp, #8
mov r1, #0
str r1, [r0, #0]
str r1, [sp]
str r1, [sp, #4]
str r1, [r0, #4]
add sp, sp, #8
bx lr
arm_func_end SND_GetFirstInstDataPos
arm_func_start SND_GetNextInstData
SND_GetNextInstData: ; 0x020C6128
stmfd sp!, {r3, r4, r5, lr}
ldr r4, [r2, #0]
ldr r3, [r0, #0x38]
cmp r4, r3
bhs _020C62D0
mov ip, #0
_020C6140:
add r3, r0, r4, lsl #2
ldr r4, [r3, #0x3c]
and r3, r4, #0xff
strb r4, [r1]
cmp r3, #0x10
mov r4, r4, lsr #8
bgt _020C6188
cmp r3, #0x10
bge _020C61D4
cmp r3, #5
addls pc, pc, r3, lsl #2
b _020C62B4
_020C6170: ; jump table
b _020C62B4 ; case 0
b _020C6194 ; case 1
b _020C6194 ; case 2
b _020C6194 ; case 3
b _020C6194 ; case 4
b _020C6194 ; case 5
_020C6188:
cmp r3, #0x11
beq _020C6248
b _020C62B4
_020C6194:
add r5, r0, r4
ldrh r4, [r0, r4]
ldrh r3, [r5, #2]
mov r0, #1
strh r4, [r1, #2]
strh r3, [r1, #4]
ldrh r4, [r5, #4]
ldrh r3, [r5, #6]
strh r4, [r1, #6]
strh r3, [r1, #8]
ldrh r3, [r5, #8]
strh r3, [r1, #0xa]
ldr r1, [r2, #0]
add r1, r1, #1
str r1, [r2, #0]
ldmia sp!, {r3, r4, r5, pc}
_020C61D4:
add r5, r0, r4
b _020C6228
_020C61DC:
mov r0, #0xc
mla ip, lr, r0, r5
ldrh r4, [ip, #2]
ldrh r3, [ip, #4]
mov r0, #1
strh r4, [r1]
strh r3, [r1, #2]
ldrh r4, [ip, #6]
ldrh r3, [ip, #8]
strh r4, [r1, #4]
strh r3, [r1, #6]
ldrh r4, [ip, #0xa]
ldrh r3, [ip, #0xc]
strh r4, [r1, #8]
strh r3, [r1, #0xa]
ldr r1, [r2, #4]
add r1, r1, #1
str r1, [r2, #4]
ldmia sp!, {r3, r4, r5, pc}
_020C6228:
ldrb r4, [r5, #1]
ldrb r3, [r5]
ldr lr, [r2, #4]
sub r3, r4, r3
add r3, r3, #1
cmp lr, r3
blo _020C61DC
b _020C62B4
_020C6248:
add r4, r0, r4
b _020C62A8
_020C6250:
ldrb lr, [r4, r3]
cmp lr, #0
beq _020C62B4
mov r0, #0xc
mla lr, r3, r0, r4
ldrh ip, [lr, #8]
ldrh r3, [lr, #0xa]
mov r0, #1
strh ip, [r1]
strh r3, [r1, #2]
ldrh ip, [lr, #0xc]
ldrh r3, [lr, #0xe]
strh ip, [r1, #4]
strh r3, [r1, #6]
ldrh ip, [lr, #0x10]
ldrh r3, [lr, #0x12]
strh ip, [r1, #8]
strh r3, [r1, #0xa]
ldr r1, [r2, #4]
add r1, r1, #1
str r1, [r2, #4]
ldmia sp!, {r3, r4, r5, pc}
_020C62A8:
ldr r3, [r2, #4]
cmp r3, #8
blo _020C6250
_020C62B4:
ldr r3, [r2, #0]
add r3, r3, #1
stmia r2, {r3, ip}
ldr r4, [r2, #0]
ldr r3, [r0, #0x38]
cmp r4, r3
blo _020C6140
_020C62D0:
mov r0, #0
ldmia sp!, {r3, r4, r5, pc}
arm_func_end SND_GetNextInstData
arm_func_start SND_GetWaveDataCount
SND_GetWaveDataCount: ; 0x020C62D8
ldr r0, [r0, #0x38]
bx lr
arm_func_end SND_GetWaveDataCount
arm_func_start SND_SetWaveDataAddress
SND_SetWaveDataAddress: ; 0x020C62E0
stmfd sp!, {r4, r5, r6, lr}
mov r6, r0
mov r5, r1
mov r4, r2
bl SNDi_LockMutex
add r0, r6, #0x3c
add r2, r6, r5, lsl #2
add r0, r0, r5, lsl #2
mov r1, #4
str r4, [r2, #0x3c]
bl DC_StoreRange
bl SNDi_UnlockMutex
ldmia sp!, {r4, r5, r6, pc}
arm_func_end SND_SetWaveDataAddress
arm_func_start SND_GetWaveDataAddress
SND_GetWaveDataAddress: ; 0x020C6314
stmfd sp!, {r3, r4, r5, lr}
mov r5, r0
mov r4, r1
bl SNDi_LockMutex
add r0, r5, r4, lsl #2
ldr r4, [r0, #0x3c]
cmp r4, #0
beq _020C6340
cmp r4, #0x2000000
addlo r4, r5, r4
b _020C6344
_020C6340:
mov r4, #0
_020C6344:
bl SNDi_UnlockMutex
mov r0, r4
ldmia sp!, {r3, r4, r5, pc}
arm_func_end SND_GetWaveDataAddress

622
lib/NitroSDK/asm/snd/snd_command.s
View File

@ -1,622 +0,0 @@
.include "macros/function.inc"
.include "include/snd_command.inc"
.extern Unk_021CD064
.extern Unk_021CD0A0
.extern Unk_021CD320
.extern Unk_021CEB80
.extern Unk_021CD040
.text
arm_func_start SND_CommandInit
SND_CommandInit: ; 0x020C55E0
stmfd sp!, {r4, lr}
bl InitPXI
ldr lr, _020C569C ; =0x021CD320
ldr r0, _020C56A0 ; =0x021CD040
mov r4, #0
str lr, [r0]
mov r0, #0x18
mov r1, r0
b _020C5618
_020C5604:
add r3, r4, #1
mul r2, r4, r1
mla ip, r3, r0, lr
mov r4, r3
str ip, [lr, r2]
_020C5618:
cmp r4, #0xff
blt _020C5604
ldr r0, _020C56A4 ; =0x021CE040
mov r3, #0
str r3, [r0, #0xac8]
ldr r1, _020C56A8 ; =0x021CEB08
ldr r2, _020C56A0 ; =0x021CD040
mov r0, #1
str r1, [r2, #0x10]
str r3, [r2, #8]
str r3, [r2, #0xc]
str r3, [r2, #0x1c]
str r3, [r2, #0x14]
str r3, [r2, #0x18]
str r0, [r2, #0x20]
ldr r0, _020C56AC ; =0x021CD0A0
ldr r1, _020C56B0 ; =0x021CEB80
str r3, [r2, #4]
str r0, [r1, #0]
bl SNDi_InitSharedWork
mov r0, #1
bl SND_AllocCommand
cmp r0, #0
ldmeqia sp!, {r4, pc}
mov r2, #0x1d
ldr r1, _020C56B0 ; =0x021CEB80
str r2, [r0, #4]
ldr r1, [r1, #0]
str r1, [r0, #8]
bl SND_PushCommand
mov r0, #1
bl SND_FlushCommand
ldmia sp!, {r4, pc}
; .align 2, 0
_020C569C: .word Unk_021CD320
_020C56A0: .word Unk_021CD040
_020C56A4: .word 0x021CE040
_020C56A8: .word 0x021CEB08
_020C56AC: .word Unk_021CD0A0
_020C56B0: .word Unk_021CEB80
arm_func_end SND_CommandInit
arm_func_start SND_RecvCommandReply
SND_RecvCommandReply: ; 0x020C56B4
stmfd sp!, {r4, r5, r6, lr}
mov r5, r0
bl OS_DisableInterrupts
mov r4, r0
tst r5, #1
beq _020C5710
bl SNDi_GetFinishedCommandTag
ldr r5, _020C57BC ; =0x021CD040
ldr r1, [r5, #4]
cmp r1, r0
bne _020C5734
mov r6, #0x64
_020C56E4:
mov r0, r4
bl OS_RestoreInterrupts
mov r0, r6
bl OS_SpinWait
bl OS_DisableInterrupts
mov r4, r0
bl SNDi_GetFinishedCommandTag
ldr r1, [r5, #4]
cmp r1, r0
beq _020C56E4
b _020C5734
_020C5710:
bl SNDi_GetFinishedCommandTag
ldr r1, _020C57BC ; =0x021CD040
ldr r1, [r1, #4]
cmp r1, r0
bne _020C5734
mov r0, r4
bl OS_RestoreInterrupts
mov r0, #0
ldmia sp!, {r4, r5, r6, pc}
_020C5734:
ldr r0, _020C57BC ; =0x021CD040
ldr r2, _020C57C0 ; =0x021CD064
ldr r3, [r0, #0x14]
add r1, r3, #1
ldr r5, [r2, r3, lsl #2]
str r1, [r0, #0x14]
cmp r1, #8
movgt r1, #0
strgt r1, [r0, #0x14]
ldr r0, [r5, #0]
mov r2, r5
cmp r0, #0
beq _020C5778
_020C5768:
ldr r2, [r2, #0]
ldr r0, [r2, #0]
cmp r0, #0
bne _020C5768
_020C5778:
ldr r0, _020C57BC ; =0x021CD040
ldr r1, [r0, #0x10]
cmp r1, #0
strne r5, [r1]
streq r5, [r0]
ldr r1, _020C57BC ; =0x021CD040
mov r0, r4
str r2, [r1, #0x10]
ldr r2, [r1, #0x1c]
sub r2, r2, #1
str r2, [r1, #0x1c]
ldr r2, [r1, #4]
add r2, r2, #1
str r2, [r1, #4]
bl OS_RestoreInterrupts
mov r0, r5
ldmia sp!, {r4, r5, r6, pc}
; .align 2, 0
_020C57BC: .word Unk_021CD040
_020C57C0: .word Unk_021CD064
arm_func_end SND_RecvCommandReply
arm_func_start SND_AllocCommand
SND_AllocCommand: ; 0x020C57C4
stmfd sp!, {r4, lr}
mov r4, r0
bl IsCommandAvailable
cmp r0, #0
moveq r0, #0
ldmeqia sp!, {r4, pc}
bl AllocCommand
cmp r0, #0
ldmneia sp!, {r4, pc}
tst r4, #1
moveq r0, #0
ldmeqia sp!, {r4, pc}
bl SND_CountWaitingCommand
cmp r0, #0
ble _020C5824
mov r4, #0
_020C5804:
mov r0, r4
bl SND_RecvCommandReply
cmp r0, #0
bne _020C5804
bl AllocCommand
cmp r0, #0
beq _020C582C
ldmia sp!, {r4, pc}
_020C5824:
mov r0, #1
bl SND_FlushCommand
_020C582C:
bl RequestCommandProc
mov r4, #1
_020C5834:
mov r0, r4
bl SND_RecvCommandReply
bl AllocCommand
cmp r0, #0
beq _020C5834
ldmia sp!, {r4, pc}
arm_func_end SND_AllocCommand
arm_func_start SND_PushCommand
SND_PushCommand: ; 0x020C584C
stmfd sp!, {r4, lr}
mov r4, r0
bl OS_DisableInterrupts
ldr r1, _020C5880 ; =0x021CD040
ldr r2, [r1, #0xc]
cmp r2, #0
streq r4, [r1, #8]
strne r4, [r2]
str r4, [r1, #0xc]
mov r1, #0
str r1, [r4, #0]
bl OS_RestoreInterrupts
ldmia sp!, {r4, pc}
; .align 2, 0
_020C5880: .word Unk_021CD040
arm_func_end SND_PushCommand
arm_func_start SND_FlushCommand
SND_FlushCommand: ; 0x020C5884
stmfd sp!, {r3, r4, r5, r6, r7, r8, sb, sl, fp, lr}
mov sl, r0
bl OS_DisableInterrupts
ldr r4, _020C5A34 ; =0x021CD040
mov sb, r0
ldr r1, [r4, #8]
cmp r1, #0
bne _020C58B0
bl OS_RestoreInterrupts
mov r0, #1
ldmia sp!, {r3, r4, r5, r6, r7, r8, sb, sl, fp, pc}
_020C58B0:
ldr r1, [r4, #0x1c]
cmp r1, #8
blt _020C5908
tst sl, #1
bne _020C58D0
bl OS_RestoreInterrupts
mov r0, #0
ldmia sp!, {r3, r4, r5, r6, r7, r8, sb, sl, fp, pc}
_020C58D0:
mov r5, #1
_020C58D4:
mov r0, r5
bl SND_RecvCommandReply
ldr r0, [r4, #0x1c]
cmp r0, #8
bge _020C58D4
ldr r0, _020C5A34 ; =0x021CD040
ldr r0, [r0, #8]
cmp r0, #0
bne _020C5908
mov r0, sb
bl OS_RestoreInterrupts
mov r0, #1
ldmia sp!, {r3, r4, r5, r6, r7, r8, sb, sl, fp, pc}
_020C5908:
ldr r0, _020C5A38 ; =0x021CD320
mov r1, #0x1800
bl DC_FlushRange
ldr r1, _020C5A34 ; =0x021CD040
mov r0, #7
ldr r1, [r1, #8]
mov r2, #0
bl PXI_SendWordByFifo
cmp r0, #0
bge _020C59C8
tst sl, #1
bne _020C5948
mov r0, sb
bl OS_RestoreInterrupts
mov r0, #0
ldmia sp!, {r3, r4, r5, r6, r7, r8, sb, sl, fp, pc}
_020C5948:
mov fp, #0
mov r5, #7
mov r8, fp
ldr r7, _020C5A38 ; =0x021CD320
mov r6, #0x1800
ldr r4, _020C5A34 ; =0x021CD040
b _020C59A4
_020C5964:
mov r0, sb
bl OS_RestoreInterrupts
mov r0, r8
bl SND_RecvCommandReply
bl OS_DisableInterrupts
mov sb, r0
mov r0, r7
mov r1, r6
bl DC_FlushRange
ldr r0, [r4, #8]
cmp r0, #0
bne _020C59A4
mov r0, sb
bl OS_RestoreInterrupts
mov r0, #1
ldmia sp!, {r3, r4, r5, r6, r7, r8, sb, sl, fp, pc}
_020C59A4:
ldr r0, [r4, #0x1c]
cmp r0, #8
bge _020C5964
ldr r1, [r4, #8]
mov r0, r5
mov r2, fp
bl PXI_SendWordByFifo
cmp r0, #0
blt _020C5964
_020C59C8:
ldr r0, _020C5A34 ; =0x021CD040
ldr r2, _020C5A3C ; =0x021CD064
ldr r3, [r0, #0x18]
ldr r4, [r0, #8]
add r1, r3, #1
str r4, [r2, r3, lsl #2]
str r1, [r0, #0x18]
cmp r1, #8
movgt r1, #0
strgt r1, [r0, #0x18]
ldr r1, _020C5A34 ; =0x021CD040
mov r0, #0
str r0, [r1, #8]
str r0, [r1, #0xc]
ldr r2, [r1, #0x1c]
mov r0, sb
add r2, r2, #1
str r2, [r1, #0x1c]
ldr r2, [r1, #0x20]
add r2, r2, #1
str r2, [r1, #0x20]
bl OS_RestoreInterrupts
tst sl, #2
beq _020C5A2C
bl RequestCommandProc
_020C5A2C:
mov r0, #1
ldmia sp!, {r3, r4, r5, r6, r7, r8, sb, sl, fp, pc}
; .align 2, 0
_020C5A34: .word Unk_021CD040
_020C5A38: .word Unk_021CD320
_020C5A3C: .word Unk_021CD064
arm_func_end SND_FlushCommand
arm_func_start SND_WaitForCommandProc
SND_WaitForCommandProc: ; 0x020C5A40
stmfd sp!, {r3, r4, r5, lr}
mov r5, r0
bl SND_IsFinishedCommandTag
cmp r0, #0
ldmneia sp!, {r3, r4, r5, pc}
mov r4, #0
_020C5A58:
mov r0, r4
bl SND_RecvCommandReply
cmp r0, #0
bne _020C5A58
mov r0, r5
bl SND_IsFinishedCommandTag
cmp r0, #0
ldmneia sp!, {r3, r4, r5, pc}
bl RequestCommandProc
mov r0, r5
bl SND_IsFinishedCommandTag
cmp r0, #0
ldmneia sp!, {r3, r4, r5, pc}
mov r4, #1
_020C5A90:
mov r0, r4
bl SND_RecvCommandReply
mov r0, r5
bl SND_IsFinishedCommandTag
cmp r0, #0
beq _020C5A90
ldmia sp!, {r3, r4, r5, pc}
arm_func_end SND_WaitForCommandProc
arm_func_start SND_GetCurrentCommandTag
SND_GetCurrentCommandTag: ; 0x020C5AAC
stmfd sp!, {r4, lr}
bl OS_DisableInterrupts
ldr r1, _020C5AD4 ; =0x021CD040
ldr r2, [r1, #8]
cmp r2, #0
ldreq r4, [r1, #4]
ldrne r4, [r1, #0x20]
bl OS_RestoreInterrupts
mov r0, r4
ldmia sp!, {r4, pc}
; .align 2, 0
_020C5AD4: .word Unk_021CD040
arm_func_end SND_GetCurrentCommandTag
arm_func_start SND_IsFinishedCommandTag
SND_IsFinishedCommandTag: ; 0x020C5AD8
stmfd sp!, {r4, lr}
mov r4, r0
bl OS_DisableInterrupts
ldr r1, _020C5B24 ; =0x021CD040
ldr r1, [r1, #4]
cmp r4, r1
bls _020C5B08
sub r1, r4, r1
cmp r1, #-0x80000000
movlo r4, #0
movhs r4, #1
b _020C5B18
_020C5B08:
sub r1, r1, r4
cmp r1, #-0x80000000
movlo r4, #1
movhs r4, #0
_020C5B18:
bl OS_RestoreInterrupts
mov r0, r4
ldmia sp!, {r4, pc}
; .align 2, 0
_020C5B24: .word Unk_021CD040
arm_func_end SND_IsFinishedCommandTag
arm_func_start SND_CountFreeCommand
SND_CountFreeCommand: ; 0x020C5B28
stmfd sp!, {r4, lr}
bl OS_DisableInterrupts
ldr r1, _020C5B60 ; =0x021CD040
mov r4, #0
ldr r1, [r1, #0]
cmp r1, #0
beq _020C5B54
_020C5B44:
ldr r1, [r1, #0]
add r4, r4, #1
cmp r1, #0
bne _020C5B44
_020C5B54:
bl OS_RestoreInterrupts
mov r0, r4
ldmia sp!, {r4, pc}
; .align 2, 0
_020C5B60: .word Unk_021CD040
arm_func_end SND_CountFreeCommand
arm_func_start SND_CountReservedCommand
SND_CountReservedCommand: ; 0x020C5B64
stmfd sp!, {r4, lr}
bl OS_DisableInterrupts
ldr r1, _020C5B9C ; =0x021CD040
mov r4, #0
ldr r1, [r1, #8]
cmp r1, #0
beq _020C5B90
_020C5B80:
ldr r1, [r1, #0]
add r4, r4, #1
cmp r1, #0
bne _020C5B80
_020C5B90:
bl OS_RestoreInterrupts
mov r0, r4
ldmia sp!, {r4, pc}
; .align 2, 0
_020C5B9C: .word Unk_021CD040
arm_func_end SND_CountReservedCommand
arm_func_start SND_CountWaitingCommand
SND_CountWaitingCommand: ; 0x020C5BA0
stmfd sp!, {r4, lr}
bl SND_CountFreeCommand
mov r4, r0
bl SND_CountReservedCommand
rsb r1, r4, #0x100
sub r0, r1, r0
ldmia sp!, {r4, pc}
arm_func_end SND_CountWaitingCommand
arm_func_start PxiFifoCallback
PxiFifoCallback: ; 0x020C5BBC
stmfd sp!, {r3, r4, r5, lr}
mov r5, r1
bl OS_DisableInterrupts
mov r4, r0
mov r0, r5
bl SNDi_CallAlarmHandler
mov r0, r4
bl OS_RestoreInterrupts
ldmia sp!, {r3, r4, r5, pc}
arm_func_end PxiFifoCallback
arm_func_start InitPXI
InitPXI: ; 0x020C5BE0
stmfd sp!, {r4, r5, r6, lr}
ldr r1, _020C5C3C ; =PxiFifoCallback
mov r0, #7
bl PXI_SetFifoRecvCallback
bl IsCommandAvailable
cmp r0, #0
ldmeqia sp!, {r4, r5, r6, pc}
mov r0, #7
mov r1, #1
bl PXI_IsCallbackReady
cmp r0, #0
ldmneia sp!, {r4, r5, r6, pc}
mov r6, #0x64
mov r5, #7
mov r4, #1
_020C5C1C:
mov r0, r6
bl OS_SpinWait
mov r0, r5
mov r1, r4
bl PXI_IsCallbackReady
cmp r0, #0
beq _020C5C1C
ldmia sp!, {r4, r5, r6, pc}
; .align 2, 0
_020C5C3C: .word PxiFifoCallback
arm_func_end InitPXI
arm_func_start RequestCommandProc
RequestCommandProc: ; 0x020C5C40
stmfd sp!, {r3, r4, r5, lr}
mov r5, #7
mov r4, #0
_020C5C4C:
mov r0, r5
mov r1, r4
mov r2, r4
bl PXI_SendWordByFifo
cmp r0, #0
blt _020C5C4C
ldmia sp!, {r3, r4, r5, pc}
arm_func_end RequestCommandProc
arm_func_start AllocCommand
AllocCommand: ; 0x020C5C68
stmfd sp!, {r4, lr}
bl OS_DisableInterrupts
ldr r1, _020C5CAC ; =0x021CD040
ldr r4, [r1, #0]
cmp r4, #0
bne _020C5C8C
bl OS_RestoreInterrupts
mov r0, #0
ldmia sp!, {r4, pc}
_020C5C8C:
ldr r2, [r4, #0]
str r2, [r1, #0]
cmp r2, #0
moveq r2, #0
streq r2, [r1, #0x10]
bl OS_RestoreInterrupts
mov r0, r4
ldmia sp!, {r4, pc}
; .align 2, 0
_020C5CAC: .word Unk_021CD040
arm_func_end AllocCommand
arm_func_start IsCommandAvailable
IsCommandAvailable: ; 0x020C5CB0
stmfd sp!, {r4, lr}
bl OS_IsRunOnEmulator
cmp r0, #0
moveq r0, #1
ldmeqia sp!, {r4, pc}
bl OS_DisableInterrupts
ldr r1, _020C5CEC ; =0x04FFF200
mov r2, #0x10
str r2, [r1, #0]
ldr r4, [r1, #0]
bl OS_RestoreInterrupts
cmp r4, #0
movne r0, #1
moveq r0, #0
ldmia sp!, {r4, pc}
; .align 2, 0
_020C5CEC: .word 0x04FFF200
arm_func_end IsCommandAvailable
.bss
.global Unk_021CD040
Unk_021CD040: ; 0x021CD040
.space 0x4
.global Unk_021CD044
Unk_021CD044: ; 0x021CD044
.space 0x4
.global Unk_021CD048
Unk_021CD048: ; 0x021CD048
.space 0x4
.global Unk_021CD04C
Unk_021CD04C: ; 0x021CD04C
.space 0x4
.global Unk_021CD050
Unk_021CD050: ; 0x021CD050
.space 0x4
.global Unk_021CD054
Unk_021CD054: ; 0x021CD054
.space 0x4
.global Unk_021CD058
Unk_021CD058: ; 0x021CD058
.space 0x4
.global Unk_021CD05C
Unk_021CD05C: ; 0x021CD05C
.space 0x4
.global Unk_021CD060
Unk_021CD060: ; 0x021CD060
.space 0x4
.global Unk_021CD064
Unk_021CD064: ; 0x021CD064
.space 0x3C
.global Unk_021CD0A0
Unk_021CD0A0: ; 0x021CD0A0
.space 0x280
.global Unk_021CD320
Unk_021CD320: ; 0x021CD320
.space 0x1800

433
lib/NitroSDK/asm/snd/snd_interface.s
View File

@ -1,433 +0,0 @@
.include "macros/function.inc"
.include "include/snd_interface.inc"
.text
arm_func_start SND_StopSeq
SND_StopSeq: ; 0x020C50D4
stmfd sp!, {r3, lr}
mov r2, #0
mov r1, r0
mov r3, r2
mov r0, #1
str r2, [sp]
bl PushCommand_impl
ldmia sp!, {r3, pc}
arm_func_end SND_StopSeq
arm_func_start SND_PrepareSeq
SND_PrepareSeq: ; 0x020C50F4
stmfd sp!, {r3, lr}
mov lr, r1
mov ip, r2
str r3, [sp]
mov r1, r0
mov r2, lr
mov r3, ip
mov r0, #2
bl PushCommand_impl
ldmia sp!, {r3, pc}
arm_func_end SND_PrepareSeq
arm_func_start SND_StartPreparedSeq
SND_StartPreparedSeq: ; 0x020C511C
stmfd sp!, {r3, lr}
mov r2, #0
mov r1, r0
mov r3, r2
mov r0, #3
str r2, [sp]
bl PushCommand_impl
ldmia sp!, {r3, pc}
arm_func_end SND_StartPreparedSeq
arm_func_start SND_PauseSeq
SND_PauseSeq: ; 0x020C513C
stmfd sp!, {r3, lr}
mov r2, r1
mov r3, #0
mov r1, r0
mov r0, #4
str r3, [sp]
bl PushCommand_impl
ldmia sp!, {r3, pc}
arm_func_end SND_PauseSeq
arm_func_start SND_SetPlayerTempoRatio
SND_SetPlayerTempoRatio: ; 0x020C515C
ldr ip, _020C5170 ; =SNDi_SetPlayerParam
mov r2, r1
mov r1, #0x1a
mov r3, #2
bx ip
; .align 2, 0
_020C5170: .word SNDi_SetPlayerParam
arm_func_end SND_SetPlayerTempoRatio
arm_func_start SND_SetPlayerVolume
SND_SetPlayerVolume: ; 0x020C5174
ldr ip, _020C5188 ; =SNDi_SetPlayerParam
mov r2, r1
mov r1, #6
mov r3, #2
bx ip
; .align 2, 0
_020C5188: .word SNDi_SetPlayerParam
arm_func_end SND_SetPlayerVolume
arm_func_start SND_SetPlayerChannelPriority
SND_SetPlayerChannelPriority: ; 0x020C518C
ldr ip, _020C51A0 ; =SNDi_SetPlayerParam
mov r2, r1
mov r1, #4
mov r3, #1
bx ip
; .align 2, 0
_020C51A0: .word SNDi_SetPlayerParam
arm_func_end SND_SetPlayerChannelPriority
arm_func_start SND_SetTrackPitch
SND_SetTrackPitch: ; 0x020C51A4
stmfd sp!, {r3, lr}
mov r3, r2
mov ip, #2
mov r2, #0xc
str ip, [sp]
bl SNDi_SetTrackParam
ldmia sp!, {r3, pc}
arm_func_end SND_SetTrackPitch
arm_func_start SND_SetTrackPan
SND_SetTrackPan: ; 0x020C51C0
stmfd sp!, {r3, lr}
mov r3, r2
mov ip, #1
mov r2, #9
str ip, [sp]
bl SNDi_SetTrackParam
ldmia sp!, {r3, pc}
arm_func_end SND_SetTrackPan
arm_func_start SND_SetTrackAllocatableChannel
SND_SetTrackAllocatableChannel: ; 0x020C51DC
stmfd sp!, {r3, lr}
mov lr, r1
mov r3, r2
mov ip, #0
mov r1, r0
mov r2, lr
mov r0, #9
str ip, [sp]
bl PushCommand_impl
ldmia sp!, {r3, pc}
arm_func_end SND_SetTrackAllocatableChannel
arm_func_start SND_StartTimer
SND_StartTimer: ; 0x020C5204
stmfd sp!, {r3, lr}
mov lr, r1
mov ip, r2
str r3, [sp]
mov r1, r0
mov r2, lr
mov r3, ip
mov r0, #0xc
bl PushCommand_impl
ldmia sp!, {r3, pc}
arm_func_end SND_StartTimer
arm_func_start SND_StopTimer
SND_StopTimer: ; 0x020C522C
stmfd sp!, {r3, r4, r5, r6, r7, r8, sb, lr}
mov r7, r2
mov sb, r0
mov r8, r1
mov r6, r3
mov r5, r7
mov r4, #0
b _020C5264
_020C524C:
tst r5, #1
beq _020C525C
mov r0, r4
bl SNDi_IncAlarmId
_020C525C:
add r4, r4, #1
mov r5, r5, lsr #1
_020C5264:
cmp r4, #8
bge _020C5274
cmp r5, #0
bne _020C524C
_020C5274:
mov r1, sb
mov r2, r8
mov r3, r7
mov r0, #0xd
str r6, [sp]
bl PushCommand_impl
ldmia sp!, {r3, r4, r5, r6, r7, r8, sb, pc}
arm_func_end SND_StopTimer
arm_func_start SND_SetupCapture
SND_SetupCapture: ; 0x020C5290
stmfd sp!, {r3, lr}
mov r1, r1, lsl #0x1e
orr r0, r1, r0, lsl #31
ldr ip, [sp, #8]
mov r1, r2
orr r0, r0, ip, lsl #29
ldr r2, [sp, #0xc]
mov lr, #0
orr r0, r0, r2, lsl #28
ldr ip, [sp, #0x10]
mov r2, r3
orr r3, r0, ip, lsl #27
mov r0, #0x11
str lr, [sp]
bl PushCommand_impl
ldmia sp!, {r3, pc}
arm_func_end SND_SetupCapture
arm_func_start SND_SetupAlarm
SND_SetupAlarm: ; 0x020C52D0
stmfd sp!, {r3, r4, r5, r6, lr}
sub sp, sp, #4
mov r4, r2
mov r5, r1
ldr r2, [sp, #0x18]
mov r6, r0
mov r1, r3
bl SNDi_SetAlarmHandler
str r0, [sp]
mov r1, r6
mov r2, r5
mov r3, r4
mov r0, #0x12
bl PushCommand_impl
add sp, sp, #4
ldmia sp!, {r3, r4, r5, r6, pc}
arm_func_end SND_SetupAlarm
arm_func_start SND_LockChannel
SND_LockChannel: ; 0x020C5310
stmfd sp!, {r3, lr}
mov r2, r1
mov r3, #0
mov r1, r0
mov r0, #0x1a
str r3, [sp]
bl PushCommand_impl
ldmia sp!, {r3, pc}
arm_func_end SND_LockChannel
arm_func_start SND_UnlockChannel
SND_UnlockChannel: ; 0x020C5330
stmfd sp!, {r3, lr}
mov r2, r1
mov r3, #0
mov r1, r0
mov r0, #0x1b
str r3, [sp]
bl PushCommand_impl
ldmia sp!, {r3, pc}
arm_func_end SND_UnlockChannel
arm_func_start SND_SetChannelTimer
SND_SetChannelTimer: ; 0x020C5350
stmfd sp!, {r3, lr}
mov r2, r1
mov r3, #0
mov r1, r0
mov r0, #0x13
str r3, [sp]
bl PushCommand_impl
ldmia sp!, {r3, pc}
arm_func_end SND_SetChannelTimer
arm_func_start SND_SetChannelVolume
SND_SetChannelVolume: ; 0x020C5370
stmfd sp!, {r3, lr}
mov lr, r1
mov r3, r2
mov ip, #0
mov r1, r0
mov r2, lr
mov r0, #0x14
str ip, [sp]
bl PushCommand_impl
ldmia sp!, {r3, pc}
arm_func_end SND_SetChannelVolume
arm_func_start SND_SetChannelPan
SND_SetChannelPan: ; 0x020C5398
stmfd sp!, {r3, lr}
mov r2, r1
mov r3, #0
mov r1, r0
mov r0, #0x15
str r3, [sp]
bl PushCommand_impl
ldmia sp!, {r3, pc}
arm_func_end SND_SetChannelPan
arm_func_start SND_SetupChannelPcm
SND_SetupChannelPcm: ; 0x020C53B8
stmfd sp!, {r3, r4, r5, lr}
ldr ip, [sp, #0x1c]
mov r1, r1, lsl #0x18
orr r4, r1, r3, lsl #26
ldr r5, [sp, #0x24]
mov r1, ip, lsl #0x16
ldr r3, [sp, #0x18]
ldr ip, [sp, #0x10]
orr r4, r4, r5, lsl #16
orr r4, ip, r4
ldr lr, [sp, #0x20]
orr r3, r1, r3, lsl #24
ldr ip, [sp, #0x14]
orr r1, r0, lr, lsl #16
orr r3, ip, r3
mov r0, #0xe
str r4, [sp]
bl PushCommand_impl
ldmia sp!, {r3, r4, r5, pc}
arm_func_end SND_SetupChannelPcm
arm_func_start SND_InvalidateSeqData
SND_InvalidateSeqData: ; 0x020C5404
stmfd sp!, {r3, lr}
mov r2, r1
mov r3, #0
mov r1, r0
mov r0, #0x1e
str r3, [sp]
bl PushCommand_impl
ldmia sp!, {r3, pc}
arm_func_end SND_InvalidateSeqData
arm_func_start SND_InvalidateBankData
SND_InvalidateBankData: ; 0x020C5424
stmfd sp!, {r3, lr}
mov r2, r1
mov r3, #0
mov r1, r0
mov r0, #0x1f
str r3, [sp]
bl PushCommand_impl
ldmia sp!, {r3, pc}
arm_func_end SND_InvalidateBankData
arm_func_start SND_InvalidateWaveData
SND_InvalidateWaveData: ; 0x020C5444
stmfd sp!, {r3, lr}
mov r2, r1
mov r3, #0
mov r1, r0
mov r0, #0x20
str r3, [sp]
bl PushCommand_impl
ldmia sp!, {r3, pc}
arm_func_end SND_InvalidateWaveData
arm_func_start SND_SetMasterVolume
SND_SetMasterVolume: ; 0x020C5464
stmfd sp!, {r3, lr}
mov r2, #0
mov r1, r0
mov r3, r2
mov r0, #0x17
str r2, [sp]
bl PushCommand_impl
ldmia sp!, {r3, pc}
arm_func_end SND_SetMasterVolume
arm_func_start SND_SetOutputSelector
SND_SetOutputSelector: ; 0x020C5484
stmfd sp!, {r3, lr}
mov lr, r1
mov ip, r2
str r3, [sp]
mov r1, r0
mov r2, lr
mov r3, ip
mov r0, #0x19
bl PushCommand_impl
ldmia sp!, {r3, pc}
arm_func_end SND_SetOutputSelector
arm_func_start SND_SetMasterPan
SND_SetMasterPan: ; 0x020C54AC
stmfd sp!, {r3, lr}
mov r2, #0
mov r1, r0
mov r3, r2
mov r0, #0x18
str r2, [sp]
bl PushCommand_impl
ldmia sp!, {r3, pc}
arm_func_end SND_SetMasterPan
arm_func_start SND_ResetMasterPan
SND_ResetMasterPan: ; 0x020C54CC
stmfd sp!, {r3, lr}
mov r2, #0
mov r0, #0x18
mov r3, r2
sub r1, r0, #0x19
str r2, [sp]
bl PushCommand_impl
ldmia sp!, {r3, pc}
arm_func_end SND_ResetMasterPan
arm_func_start SNDi_SetPlayerParam
SNDi_SetPlayerParam: ; 0x020C54EC
stmfd sp!, {r3, lr}
mov lr, r1
mov ip, r2
str r3, [sp]
mov r1, r0
mov r2, lr
mov r3, ip
mov r0, #6
bl PushCommand_impl
ldmia sp!, {r3, pc}
arm_func_end SNDi_SetPlayerParam
arm_func_start SNDi_SetTrackParam
SNDi_SetTrackParam: ; 0x020C5514
stmfd sp!, {r3, lr}
ldr ip, [sp, #8]
mov lr, r2
str r3, [sp]
mov r2, r1
orr r1, r0, ip, lsl #24
mov r3, lr
mov r0, #7
bl PushCommand_impl
ldmia sp!, {r3, pc}
arm_func_end SNDi_SetTrackParam
arm_func_start PushCommand_impl
PushCommand_impl: ; 0x020C553C
stmfd sp!, {r3, r4, r5, r6, r7, lr}
mov r7, r0
mov r0, #1
mov r6, r1
mov r5, r2
mov r4, r3
bl SND_AllocCommand
cmp r0, #0
ldmeqia sp!, {r3, r4, r5, r6, r7, pc}
str r7, [r0, #4]
str r6, [r0, #8]
str r5, [r0, #0xc]
ldr r1, [sp, #0x18]
str r4, [r0, #0x10]
str r1, [r0, #0x14]
bl SND_PushCommand
ldmia sp!, {r3, r4, r5, r6, r7, pc}
arm_func_end PushCommand_impl

60
lib/NitroSDK/asm/snd/snd_main.s
View File

@ -1,60 +0,0 @@
.include "macros/function.inc"
.include "include/snd_main.inc"
.extern Unk_021CD020
.extern Unk_021CD024
.text
arm_func_start SND_Init
SND_Init: ; 0x020C5580
stmfd sp!, {r3, lr}
ldr r1, _020C55B0 ; =0x021CD020
ldr r0, [r1, #0]
cmp r0, #0
ldmneia sp!, {r3, pc}
ldr r0, _020C55B4 ; =0x021CD024
mov r2, #1
str r2, [r1, #0]
bl OS_InitMutex
bl SND_CommandInit
bl SND_AlarmInit
ldmia sp!, {r3, pc}
; .align 2, 0
_020C55B0: .word Unk_021CD020
_020C55B4: .word Unk_021CD024
arm_func_end SND_Init
arm_func_start SNDi_LockMutex
SNDi_LockMutex: ; 0x020C55B8
ldr ip, _020C55C4 ; =OS_LockMutex
ldr r0, _020C55C8 ; =0x021CD024
bx ip
; .align 2, 0
_020C55C4: .word OS_LockMutex
_020C55C8: .word Unk_021CD024
arm_func_end SNDi_LockMutex
arm_func_start SNDi_UnlockMutex
SNDi_UnlockMutex: ; 0x020C55CC
ldr ip, _020C55D8 ; =OS_UnlockMutex
ldr r0, _020C55DC ; =0x021CD024
bx ip
; .align 2, 0
_020C55D8: .word OS_UnlockMutex
_020C55DC: .word Unk_021CD024
arm_func_end SNDi_UnlockMutex
.bss
.global Unk_021CD020
Unk_021CD020: ; 0x021CD020
.space 0x4
.global Unk_021CD024
Unk_021CD024: ; 0x021CD024
.space 0x1C

229
lib/NitroSDK/asm/snd/snd_util.s
View File

@ -1,229 +0,0 @@
.include "macros/function.inc"
.text
arm_func_start SND_CalcChannelVolume
SND_CalcChannelVolume: ; 0x020C5EEC
ldr r1, _020C5F54 ; =0xFFFFFD2D
cmp r0, r1
movlt r0, r1
blt _020C5F04
cmp r0, #0
movgt r0, #0
_020C5F04:
add r1, r0, #0xd3
mvn r2, #0xef
cmp r0, r2
ldr r3, _020C5F58 ; =0x020FE1B0
add r1, r1, #0x200
ldrb r3, [r3, r1]
movlt r0, #3
blt _020C5F44
add r1, r2, #0x78
cmp r0, r1
movlt r0, #2
blt _020C5F44
add r1, r2, #0xb4
cmp r0, r1
movlt r0, #1
movge r0, #0
_020C5F44:
orr r0, r3, r0, lsl #8
mov r0, r0, lsl #0x10
mov r0, r0, lsr #0x10
bx lr
; .align 2, 0
_020C5F54: .word 0xFFFFFD2D
_020C5F58: .word Unk_020FE1B0
arm_func_end SND_CalcChannelVolume
.rodata
.global Unk_020FD9B0
Unk_020FD9B0: ; 0x020FD9B0
.incbin "incbin/arm9_rodata.bin", 0x18D70, 0x18E70 - 0x18D70
.global SNDi_DecibelTable
SNDi_DecibelTable: ; 0x020FDAB0
.incbin "incbin/arm9_rodata.bin", 0x18E70, 0x18F70 - 0x18E70
.global Unk_020FDBB0
Unk_020FDBB0: ; 0x020FDBB0
.short 0x0000, 0x003B, 0x0076, 0x00B2, 0x00ED, 0x0128, 0x0164, 0x019F
.short 0x01DB, 0x0217, 0x0252, 0x028E, 0x02CA, 0x0305, 0x0341, 0x037D
.short 0x03B9, 0x03F5, 0x0431, 0x046E, 0x04AA, 0x04E6, 0x0522, 0x055F
.short 0x059B, 0x05D8, 0x0614, 0x0651, 0x068D, 0x06CA, 0x0707, 0x0743
.short 0x0780, 0x07BD, 0x07FA, 0x0837, 0x0874, 0x08B1, 0x08EF, 0x092C
.short 0x0969, 0x09A7, 0x09E4, 0x0A21, 0x0A5F, 0x0A9C, 0x0ADA, 0x0B18
.short 0x0B56, 0x0B93, 0x0BD1, 0x0C0F, 0x0C4D, 0x0C8B, 0x0CC9, 0x0D07
.short 0x0D45, 0x0D84, 0x0DC2, 0x0E00, 0x0E3F, 0x0E7D, 0x0EBC, 0x0EFA
.short 0x0F39, 0x0F78, 0x0FB6, 0x0FF5, 0x1034, 0x1073, 0x10B2, 0x10F1
.short 0x1130, 0x116F, 0x11AE, 0x11EE, 0x122D, 0x126C, 0x12AC, 0x12EB
.short 0x132B, 0x136B, 0x13AA, 0x13EA, 0x142A, 0x146A, 0x14A9, 0x14E9
.short 0x1529, 0x1569, 0x15AA, 0x15EA, 0x162A, 0x166A, 0x16AB, 0x16EB
.short 0x172C, 0x176C, 0x17AD, 0x17ED, 0x182E, 0x186F, 0x18B0, 0x18F0
.short 0x1931, 0x1972, 0x19B3, 0x19F5, 0x1A36, 0x1A77, 0x1AB8, 0x1AFA
.short 0x1B3B, 0x1B7D, 0x1BBE, 0x1C00, 0x1C41, 0x1C83, 0x1CC5, 0x1D07
.short 0x1D48, 0x1D8A, 0x1DCC, 0x1E0E, 0x1E51, 0x1E93, 0x1ED5, 0x1F17
.short 0x1F5A, 0x1F9C, 0x1FDF, 0x2021, 0x2064, 0x20A6, 0x20E9, 0x212C
.short 0x216F, 0x21B2, 0x21F5, 0x2238, 0x227B, 0x22BE, 0x2301, 0x2344
.short 0x2388, 0x23CB, 0x240E, 0x2452, 0x2496, 0x24D9, 0x251D, 0x2561
.short 0x25A4, 0x25E8, 0x262C, 0x2670, 0x26B4, 0x26F8, 0x273D, 0x2781
.short 0x27C5, 0x280A, 0x284E, 0x2892, 0x28D7, 0x291C, 0x2960, 0x29A5
.short 0x29EA, 0x2A2F, 0x2A74, 0x2AB9, 0x2AFE, 0x2B43, 0x2B88, 0x2BCD
.short 0x2C13, 0x2C58, 0x2C9D, 0x2CE3, 0x2D28, 0x2D6E, 0x2DB4, 0x2DF9
.short 0x2E3F, 0x2E85, 0x2ECB, 0x2F11, 0x2F57, 0x2F9D, 0x2FE3, 0x302A
.short 0x3070, 0x30B6, 0x30FD, 0x3143, 0x318A, 0x31D0, 0x3217, 0x325E
.short 0x32A5, 0x32EC, 0x3332, 0x3379, 0x33C1, 0x3408, 0x344F, 0x3496
.short 0x34DD, 0x3525, 0x356C, 0x35B4, 0x35FB, 0x3643, 0x368B, 0x36D3
.short 0x371A, 0x3762, 0x37AA, 0x37F2, 0x383A, 0x3883, 0x38CB, 0x3913
.short 0x395C, 0x39A4, 0x39ED, 0x3A35, 0x3A7E, 0x3AC6, 0x3B0F, 0x3B58
.short 0x3BA1, 0x3BEA, 0x3C33, 0x3C7C, 0x3CC5, 0x3D0E, 0x3D58, 0x3DA1
.short 0x3DEA, 0x3E34, 0x3E7D, 0x3EC7, 0x3F11, 0x3F5A, 0x3FA4, 0x3FEE
.short 0x4038, 0x4082, 0x40CC, 0x4116, 0x4161, 0x41AB, 0x41F5, 0x4240
.short 0x428A, 0x42D5, 0x431F, 0x436A, 0x43B5, 0x4400, 0x444B, 0x4495
.short 0x44E1, 0x452C, 0x4577, 0x45C2, 0x460D, 0x4659, 0x46A4, 0x46F0
.short 0x473B, 0x4787, 0x47D3, 0x481E, 0x486A, 0x48B6, 0x4902, 0x494E
.short 0x499A, 0x49E6, 0x4A33, 0x4A7F, 0x4ACB, 0x4B18, 0x4B64, 0x4BB1
.short 0x4BFE, 0x4C4A, 0x4C97, 0x4CE4, 0x4D31, 0x4D7E, 0x4DCB, 0x4E18
.short 0x4E66, 0x4EB3, 0x4F00, 0x4F4E, 0x4F9B, 0x4FE9, 0x5036, 0x5084
.short 0x50D2, 0x5120, 0x516E, 0x51BC, 0x520A, 0x5258, 0x52A6, 0x52F4
.short 0x5343, 0x5391, 0x53E0, 0x542E, 0x547D, 0x54CC, 0x551A, 0x5569
.short 0x55B8, 0x5607, 0x5656, 0x56A5, 0x56F4, 0x5744, 0x5793, 0x57E2
.short 0x5832, 0x5882, 0x58D1, 0x5921, 0x5971, 0x59C1, 0x5A10, 0x5A60
.short 0x5AB0, 0x5B01, 0x5B51, 0x5BA1, 0x5BF1, 0x5C42, 0x5C92, 0x5CE3
.short 0x5D34, 0x5D84, 0x5DD5, 0x5E26, 0x5E77, 0x5EC8, 0x5F19, 0x5F6A
.short 0x5FBB, 0x600D, 0x605E, 0x60B0, 0x6101, 0x6153, 0x61A4, 0x61F6
.short 0x6248, 0x629A, 0x62EC, 0x633E, 0x6390, 0x63E2, 0x6434, 0x6487
.short 0x64D9, 0x652C, 0x657E, 0x65D1, 0x6624, 0x6676, 0x66C9, 0x671C
.short 0x676F, 0x67C2, 0x6815, 0x6869, 0x68BC, 0x690F, 0x6963, 0x69B6
.short 0x6A0A, 0x6A5E, 0x6AB1, 0x6B05, 0x6B59, 0x6BAD, 0x6C01, 0x6C55
.short 0x6CAA, 0x6CFE, 0x6D52, 0x6DA7, 0x6DFB, 0x6E50, 0x6EA4, 0x6EF9
.short 0x6F4E, 0x6FA3, 0x6FF8, 0x704D, 0x70A2, 0x70F7, 0x714D, 0x71A2
.short 0x71F7, 0x724D, 0x72A2, 0x72F8, 0x734E, 0x73A4, 0x73FA, 0x7450
.short 0x74A6, 0x74FC, 0x7552, 0x75A8, 0x75FF, 0x7655, 0x76AC, 0x7702
.short 0x7759, 0x77B0, 0x7807, 0x785E, 0x78B4, 0x790C, 0x7963, 0x79BA
.short 0x7A11, 0x7A69, 0x7AC0, 0x7B18, 0x7B6F, 0x7BC7, 0x7C1F, 0x7C77
.short 0x7CCF, 0x7D27, 0x7D7F, 0x7DD7, 0x7E2F, 0x7E88, 0x7EE0, 0x7F38
.short 0x7F91, 0x7FEA, 0x8042, 0x809B, 0x80F4, 0x814D, 0x81A6, 0x81FF
.short 0x8259, 0x82B2, 0x830B, 0x8365, 0x83BE, 0x8418, 0x8472, 0x84CB
.short 0x8525, 0x857F, 0x85D9, 0x8633, 0x868E, 0x86E8, 0x8742, 0x879D
.short 0x87F7, 0x8852, 0x88AC, 0x8907, 0x8962, 0x89BD, 0x8A18, 0x8A73
.short 0x8ACE, 0x8B2A, 0x8B85, 0x8BE0, 0x8C3C, 0x8C97, 0x8CF3, 0x8D4F
.short 0x8DAB, 0x8E07, 0x8E63, 0x8EBF, 0x8F1B, 0x8F77, 0x8FD4, 0x9030
.short 0x908C, 0x90E9, 0x9146, 0x91A2, 0x91FF, 0x925C, 0x92B9, 0x9316
.short 0x9373, 0x93D1, 0x942E, 0x948C, 0x94E9, 0x9547, 0x95A4, 0x9602
.short 0x9660, 0x96BE, 0x971C, 0x977A, 0x97D8, 0x9836, 0x9895, 0x98F3
.short 0x9952, 0x99B0, 0x9A0F, 0x9A6E, 0x9ACD, 0x9B2C, 0x9B8B, 0x9BEA
.short 0x9C49, 0x9CA8, 0x9D08, 0x9D67, 0x9DC7, 0x9E26, 0x9E86, 0x9EE6
.short 0x9F46, 0x9FA6, 0xA006, 0xA066, 0xA0C6, 0xA127, 0xA187, 0xA1E8
.short 0xA248, 0xA2A9, 0xA30A, 0xA36B, 0xA3CC, 0xA42D, 0xA48E, 0xA4EF
.short 0xA550, 0xA5B2, 0xA613, 0xA675, 0xA6D6, 0xA738, 0xA79A, 0xA7FC
.short 0xA85E, 0xA8C0, 0xA922, 0xA984, 0xA9E7, 0xAA49, 0xAAAC, 0xAB0E
.short 0xAB71, 0xABD4, 0xAC37, 0xAC9A, 0xACFD, 0xAD60, 0xADC3, 0xAE27
.short 0xAE8A, 0xAEED, 0xAF51, 0xAFB5, 0xB019, 0xB07C, 0xB0E0, 0xB145
.short 0xB1A9, 0xB20D, 0xB271, 0xB2D6, 0xB33A, 0xB39F, 0xB403, 0xB468
.short 0xB4CD, 0xB532, 0xB597, 0xB5FC, 0xB662, 0xB6C7, 0xB72C, 0xB792
.short 0xB7F7, 0xB85D, 0xB8C3, 0xB929, 0xB98F, 0xB9F5, 0xBA5B, 0xBAC1
.short 0xBB28, 0xBB8E, 0xBBF5, 0xBC5B, 0xBCC2, 0xBD29, 0xBD90, 0xBDF7
.short 0xBE5E, 0xBEC5, 0xBF2C, 0xBF94, 0xBFFB, 0xC063, 0xC0CA, 0xC132
.short 0xC19A, 0xC202, 0xC26A, 0xC2D2, 0xC33A, 0xC3A2, 0xC40B, 0xC473
.short 0xC4DC, 0xC544, 0xC5AD, 0xC616, 0xC67F, 0xC6E8, 0xC751, 0xC7BB
.short 0xC824, 0xC88D, 0xC8F7, 0xC960, 0xC9CA, 0xCA34, 0xCA9E, 0xCB08
.short 0xCB72, 0xCBDC, 0xCC47, 0xCCB1, 0xCD1B, 0xCD86, 0xCDF1, 0xCE5B
.short 0xCEC6, 0xCF31, 0xCF9C, 0xD008, 0xD073, 0xD0DE, 0xD14A, 0xD1B5
.short 0xD221, 0xD28D, 0xD2F8, 0xD364, 0xD3D0, 0xD43D, 0xD4A9, 0xD515
.short 0xD582, 0xD5EE, 0xD65B, 0xD6C7, 0xD734, 0xD7A1, 0xD80E, 0xD87B
.short 0xD8E9, 0xD956, 0xD9C3, 0xDA31, 0xDA9E, 0xDB0C, 0xDB7A, 0xDBE8
.short 0xDC56, 0xDCC4, 0xDD32, 0xDDA0, 0xDE0F, 0xDE7D, 0xDEEC, 0xDF5B
.short 0xDFC9, 0xE038, 0xE0A7, 0xE116, 0xE186, 0xE1F5, 0xE264, 0xE2D4
.short 0xE343, 0xE3B3, 0xE423, 0xE493, 0xE503, 0xE573, 0xE5E3, 0xE654
.short 0xE6C4, 0xE735, 0xE7A5, 0xE816, 0xE887, 0xE8F8, 0xE969, 0xE9DA
.short 0xEA4B, 0xEABC, 0xEB2E, 0xEB9F, 0xEC11, 0xEC83, 0xECF5, 0xED66
.short 0xEDD9, 0xEE4B, 0xEEBD, 0xEF2F, 0xEFA2, 0xF014, 0xF087, 0xF0FA
.short 0xF16D, 0xF1E0, 0xF253, 0xF2C6, 0xF339, 0xF3AD, 0xF420, 0xF494
.short 0xF507, 0xF57B, 0xF5EF, 0xF663, 0xF6D7, 0xF74C, 0xF7C0, 0xF834
.short 0xF8A9, 0xF91E, 0xF992, 0xFA07, 0xFA7C, 0xFAF1, 0xFB66, 0xFBDC
.short 0xFC51, 0xFCC7, 0xFD3C, 0xFDB2, 0xFE28, 0xFE9E, 0xFF14, 0xFF8A
.global Unk_020FE1B0
Unk_020FE1B0: ; 0x020FE1B0
.byte 0x00
.byte 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01
.byte 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01
.byte 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01
.byte 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01
.byte 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01
.byte 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01
.byte 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01
.byte 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01
.byte 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01
.byte 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02
.byte 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02
.byte 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02
.byte 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02
.byte 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02
.byte 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03
.byte 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03
.byte 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04
.byte 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04
.byte 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04
.byte 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05
.byte 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x06, 0x06
.byte 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06
.byte 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07
.byte 0x07, 0x07, 0x07, 0x07, 0x07, 0x08, 0x08, 0x08, 0x08, 0x08
.byte 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x09, 0x09, 0x09, 0x09
.byte 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x0A, 0x0A, 0x0A, 0x0A
.byte 0x0A, 0x0A, 0x0A, 0x0A, 0x0B, 0x0B, 0x0B, 0x0B, 0x0B, 0x0B
.byte 0x0B, 0x0B, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C
.byte 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0E, 0x0E, 0x0E, 0x0E
.byte 0x0E, 0x0E, 0x0E, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x10, 0x10
.byte 0x10, 0x10, 0x10, 0x10, 0x11, 0x11, 0x11, 0x11, 0x11, 0x12
.byte 0x12, 0x12, 0x12, 0x12, 0x13, 0x13, 0x13, 0x13, 0x14, 0x14
.byte 0x14, 0x14, 0x14, 0x15, 0x15, 0x15, 0x15, 0x16, 0x16, 0x16
.byte 0x16, 0x17, 0x17, 0x17, 0x18, 0x18, 0x18, 0x18, 0x19, 0x19
.byte 0x19, 0x19, 0x1A, 0x1A, 0x1A, 0x1B, 0x1B, 0x1B, 0x1C, 0x1C
.byte 0x1C, 0x1D, 0x1D, 0x1D, 0x1E, 0x1E, 0x1E, 0x1F, 0x1F, 0x1F
.byte 0x20, 0x20, 0x20, 0x21, 0x21, 0x22, 0x22, 0x22, 0x23, 0x23
.byte 0x24, 0x24, 0x24, 0x25, 0x25, 0x26, 0x26, 0x27, 0x27, 0x27
.byte 0x28, 0x28, 0x29, 0x29, 0x2A, 0x2A, 0x2B, 0x2B, 0x2C, 0x2C
.byte 0x2D, 0x2D, 0x2E, 0x2E, 0x2F, 0x2F, 0x30, 0x31, 0x31, 0x32
.byte 0x32, 0x33, 0x33, 0x34, 0x35, 0x35, 0x36, 0x36, 0x37, 0x38
.byte 0x38, 0x39, 0x3A, 0x3A, 0x3B, 0x3C, 0x3C, 0x3D, 0x3E, 0x3F
.byte 0x3F, 0x40, 0x41, 0x42, 0x42, 0x43, 0x44, 0x45, 0x45, 0x46
.byte 0x47, 0x48, 0x49, 0x4A, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F
.byte 0x50, 0x51, 0x52, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58
.byte 0x59, 0x5A, 0x5B, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63
.byte 0x64, 0x65, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6D, 0x6E, 0x6F
.byte 0x71, 0x72, 0x73, 0x75, 0x76, 0x77, 0x79, 0x7A, 0x7B, 0x7D
.byte 0x7E, 0x7F, 0x20, 0x21, 0x21, 0x21, 0x22, 0x22, 0x23, 0x23
.byte 0x23, 0x24, 0x24, 0x25, 0x25, 0x26, 0x26, 0x26, 0x27, 0x27
.byte 0x28, 0x28, 0x29, 0x29, 0x2A, 0x2A, 0x2B, 0x2B, 0x2C, 0x2C
.byte 0x2D, 0x2D, 0x2E, 0x2E, 0x2F, 0x2F, 0x30, 0x30, 0x31, 0x31
.byte 0x32, 0x33, 0x33, 0x34, 0x34, 0x35, 0x36, 0x36, 0x37, 0x37
.byte 0x38, 0x39, 0x39, 0x3A, 0x3B, 0x3B, 0x3C, 0x3D, 0x3E, 0x3E
.byte 0x3F, 0x40, 0x40, 0x41, 0x42, 0x43, 0x43, 0x44, 0x45, 0x46
.byte 0x47, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4D, 0x4E
.byte 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58
.byte 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x62, 0x63
.byte 0x64, 0x65, 0x66, 0x67, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6F
.byte 0x70, 0x71, 0x73, 0x74, 0x75, 0x77, 0x78, 0x79, 0x7B, 0x7C
.byte 0x7E, 0x7E, 0x40, 0x41, 0x42, 0x43, 0x43, 0x44, 0x45, 0x46
.byte 0x47, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4C, 0x4D, 0x4E
.byte 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58
.byte 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62
.byte 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6B, 0x6C, 0x6D, 0x6E
.byte 0x70, 0x71, 0x72, 0x74, 0x75, 0x76, 0x78, 0x79, 0x7B, 0x7C
.byte 0x7D, 0x7E, 0x40, 0x41, 0x42, 0x42, 0x43, 0x44, 0x45, 0x46
.byte 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4B, 0x4C, 0x4D, 0x4E
.byte 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58
.byte 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62
.byte 0x63, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6C, 0x6D, 0x6E
.byte 0x6F, 0x71, 0x72, 0x73, 0x75, 0x76, 0x77, 0x79, 0x7A, 0x7C
.byte 0x7D, 0x7E, 0x7F

121
lib/NitroSDK/asm/snd/snd_work.s
View File

@ -1,121 +0,0 @@
.include "macros/function.inc"
.include "include/snd_work.inc"
.extern Unk_021CEB80
.text
arm_func_start SND_GetPlayerStatus
SND_GetPlayerStatus: ; 0x020C5DB4
stmfd sp!, {r3, lr}
ldr r0, _020C5DDC ; =0x021CEB80
mov r1, #4
ldr r0, [r0, #0]
add r0, r0, #4
bl DC_InvalidateRange
ldr r0, _020C5DDC ; =0x021CEB80
ldr r0, [r0, #0]
ldr r0, [r0, #4]
ldmia sp!, {r3, pc}
; .align 2, 0
_020C5DDC: .word Unk_021CEB80
arm_func_end SND_GetPlayerStatus
arm_func_start SND_GetChannelStatus
SND_GetChannelStatus: ; 0x020C5DE0
stmfd sp!, {r3, lr}
ldr r0, _020C5E08 ; =0x021CEB80
mov r1, #2
ldr r0, [r0, #0]
add r0, r0, #8
bl DC_InvalidateRange
ldr r0, _020C5E08 ; =0x021CEB80
ldr r0, [r0, #0]
ldrh r0, [r0, #8]
ldmia sp!, {r3, pc}
; .align 2, 0
_020C5E08: .word Unk_021CEB80
arm_func_end SND_GetChannelStatus
arm_func_start SND_GetPlayerTickCounter
SND_GetPlayerTickCounter: ; 0x020C5E0C
stmfd sp!, {r4, lr}
mov r1, #0x24
mul r4, r0, r1
ldr r0, _020C5E44 ; =0x021CEB80
mov r1, #4
ldr r0, [r0, #0]
add r0, r0, #0x40
add r0, r0, r4
bl DC_InvalidateRange
ldr r0, _020C5E44 ; =0x021CEB80
ldr r0, [r0, #0]
add r0, r0, r4
ldr r0, [r0, #0x40]
ldmia sp!, {r4, pc}
; .align 2, 0
_020C5E44: .word Unk_021CEB80
arm_func_end SND_GetPlayerTickCounter
arm_func_start SNDi_GetFinishedCommandTag
SNDi_GetFinishedCommandTag: ; 0x020C5E48
stmfd sp!, {r3, lr}
ldr r0, _020C5E6C ; =0x021CEB80
mov r1, #4
ldr r0, [r0, #0]
bl DC_InvalidateRange
ldr r0, _020C5E6C ; =0x021CEB80
ldr r0, [r0, #0]
ldr r0, [r0, #0]
ldmia sp!, {r3, pc}
; .align 2, 0
_020C5E6C: .word Unk_021CEB80
arm_func_end SNDi_GetFinishedCommandTag
arm_func_start SNDi_InitSharedWork
SNDi_InitSharedWork: ; 0x020C5E70
stmfd sp!, {r4, lr}
mov ip, #0
str ip, [r0, #4]
strh ip, [r0, #8]
strh ip, [r0, #0xa]
mov r4, r0
str ip, [r0]
mvn r2, #0
mov r3, ip
_020C5E94:
mov lr, r3
str r3, [r4, #0x40]
_020C5E9C:
add r1, r4, lr, lsl #1
add lr, lr, #1
strh r2, [r1, #0x20]
cmp lr, #0x10
blt _020C5E9C
add ip, ip, #1
cmp ip, #0x10
add r4, r4, #0x24
blt _020C5E94
mov r3, #0
mvn r2, #0
_020C5EC8:
add r1, r0, r3, lsl #1
add r1, r1, #0x200
add r3, r3, #1
strh r2, [r1, #0x60]
cmp r3, #0x10
blt _020C5EC8
mov r1, #0x280
bl DC_FlushRange
ldmia sp!, {r4, pc}
arm_func_end SNDi_InitSharedWork
.bss
.global Unk_021CEB80
Unk_021CEB80: ; 0x021CEB80
.space 0x4

163
lib/NitroSDK/src/snd/snd_alarm.c Normal file
View File

@ -0,0 +1,163 @@
#include <nitro/snd/common/alarm.h>
#include <nitro/pxi.h>
#include <nitro/snd/common/work.h>
#ifdef SDK_ARM9
typedef struct AlarmCallbackInfo {
void (* func) (void *);
void * arg;
u8 id;
u8 pad;
u16 pad2;
} AlarmCallbackInfo;
#endif
#ifdef SDK_ARM9
static AlarmCallbackInfo sCallbackTable[SND_ALARM_NUM];
#endif
#ifdef SDK_ARM7
static void AlarmHandler(void * arg);
#endif
#ifdef SDK_ARM9
void SND_AlarmInit (void) {
int alarmNo;
for (alarmNo = 0; alarmNo < SND_ALARM_NUM; alarmNo++) {
AlarmCallbackInfo * info;
info = &sCallbackTable[alarmNo];
info->func = NULL;
info->arg = NULL;
info->id = 0;
}
}
#else
void SND_AlarmInit (void) {
int alarmNo;
for (alarmNo = 0; alarmNo < SND_ALARM_NUM; alarmNo++) {
SNDi_Work.alarm[alarmNo].enable = FALSE;
SNDi_Work.alarm[alarmNo].id = 0;
}
}
void SND_SetupAlarm (int alarmNo, OSTick tick, OSTick period, int id) {
SNDAlarm * alarm;
SDK_MINMAX_ASSERT(alarmNo, SND_ALARM_MIN, SND_ALARM_MAX);
SDK_MINMAX_ASSERT(id, 0x00, 0xff);
alarm = &SNDi_Work.alarm[alarmNo];
if (alarm->enable) {
OS_CancelAlarm(&alarm->alarm);
alarm->enable = FALSE;
}
alarm->setting.tick = tick;
alarm->setting.period = period;
alarm->id = (u8)id;
}
void SND_StartAlarm (int alarmNo) {
OSTick tick;
OSTick period;
SNDAlarm * alarm;
void * arg;
SDK_MINMAX_ASSERT(alarmNo, SND_ALARM_MIN, SND_ALARM_MAX);
alarm = &SNDi_Work.alarm[alarmNo];
if (alarm->enable) {
OS_CancelAlarm(&alarm->alarm);
alarm->enable = FALSE;
}
tick = alarm->setting.tick;
period = alarm->setting.period;
arg = (void *)((alarm->id << 8) | alarmNo);
OS_CreateAlarm(&alarm->alarm);
if (period == 0) {
OS_SetAlarm(&alarm->alarm, tick, AlarmHandler, arg);
} else {
OS_SetPeriodicAlarm(&alarm->alarm, OS_GetTick() + tick, period, AlarmHandler, arg);
}
alarm->enable = TRUE;
}
void SND_StopAlarm (int alarmNo) {
SNDAlarm * alarm;
SDK_MINMAX_ASSERT(alarmNo, SND_ALARM_MIN, SND_ALARM_MAX);
alarm = &SNDi_Work.alarm[alarmNo];
if (!alarm->enable) {
return;
}
OS_CancelAlarm(&alarm->alarm);
alarm->id++;
alarm->enable = FALSE;
}
#endif
#ifdef SDK_ARM7
static void AlarmHandler (void * arg) {
while (PXI_SendWordByFifo(PXI_FIFO_TAG_SOUND, (u32)arg, FALSE) < 0) {
}
}
#endif
#ifdef SDK_ARM9
void SNDi_IncAlarmId (int alarmNo) {
AlarmCallbackInfo * info;
SDK_MINMAX_ASSERT(alarmNo, SND_ALARM_MIN, SND_ALARM_MAX);
info = &sCallbackTable[alarmNo];
info->id++;
}
u8 SNDi_SetAlarmHandler (int alarmNo, SNDAlarmHandler handler, void * arg) {
AlarmCallbackInfo * info;
SDK_MINMAX_ASSERT(alarmNo, SND_ALARM_MIN, SND_ALARM_MAX);
info = &sCallbackTable[alarmNo];
info->func = handler;
info->arg = arg;
info->id++;
return info->id;
}
void SNDi_CallAlarmHandler (int msg) {
AlarmCallbackInfo * info;
int alarmNo = msg & 0xff;
int id = (msg >> 8) & 0xff;
SDK_MINMAX_ASSERT(alarmNo, SND_ALARM_MIN, SND_ALARM_MAX);
info = &sCallbackTable[alarmNo];
if (id == info->id) {
if (info->func != NULL) {
info->func(info->arg);
}
}
}
#endif

531
lib/NitroSDK/src/snd/snd_bank.c Normal file
View File

@ -0,0 +1,531 @@
#include <nitro/snd/common/bank.h>
#ifndef SDK_FROM_TOOL
#include <nitro/misc.h>
#include <nitro/mi.h>
#include <nitro/snd/common/main.h>
#else
#define SDK_ASSERT(exp) ((void)0)
#define SDK_NULL_ASSERT(exp) ((void)0)
#define SDK_MINMAX_ASSERT(exp, min, max) ((void)0)
#define SNDi_LockMutex() ((void)0)
#define SNDi_UnlockMutex() ((void)0)
static u8 MI_ReadByte (const void * address) {
return *(u8 *)address;
}
#define HW_MAIN_MEM 0x02000000
#ifdef _MSC_VER
#pragma warning( disable : 4018 )
#pragma warning( disable : 4311 )
#pragma warning( disable : 4312 )
#endif
#endif
static const SNDWaveData * GetWaveData(const SNDBankData * bank, int waveArcNo, int waveIndex);
void SND_AssignWaveArc (SNDBankData * bank, int index, SNDWaveArc * waveArc) {
SNDWaveArcLink * next;
SNDWaveArcLink * prev;
SDK_NULL_ASSERT(bank);
SDK_NULL_ASSERT(waveArc);
#ifdef SDK_ARM9
SDK_ASSERTMSG(((u32)bank & 0x1f) == 0, "bank address must be aligned 32 bytes boundary.");
SDK_ASSERTMSG(((u32)waveArc & 0x1f) == 0, "waveArc address must be aligned 32 bytes boundary.");
#endif
SDK_MINMAX_ASSERT(index, 0, SND_BANK_TO_WAVEARC_MAX - 1);
SNDi_LockMutex();
if (bank->waveArcLink[index].waveArc != NULL) {
if (waveArc == bank->waveArcLink[index].waveArc) {
SNDi_UnlockMutex();
return;
}
if (&bank->waveArcLink[index] == bank->waveArcLink[index].waveArc->topLink) {
bank->waveArcLink[index].waveArc->topLink = bank->waveArcLink[index].next;
#ifdef SDK_ARM9
DC_StoreRange(bank->waveArcLink[index].waveArc, sizeof(SNDWaveArc));
#endif
} else {
prev = bank->waveArcLink[index].waveArc->topLink;
while (prev != NULL) {
if (&bank->waveArcLink[index] == prev->next) {
break;
}
prev = prev->next;
}
SDK_NULL_ASSERT(prev);
prev->next = bank->waveArcLink[index].next;
#ifdef SDK_ARM9
DC_StoreRange(prev, sizeof(SNDWaveArcLink));
#endif
}
}
next = waveArc->topLink;
waveArc->topLink = &bank->waveArcLink[index];
bank->waveArcLink[index].next = next;
bank->waveArcLink[index].waveArc = waveArc;
SNDi_UnlockMutex();
#ifdef SDK_ARM9
DC_StoreRange(bank, sizeof(SNDBankData));
DC_StoreRange(waveArc, sizeof(SNDWaveArc));
#endif
}
void SND_DestroyBank (SNDBankData * bank) {
SNDWaveArc * waveArc;
SNDWaveArcLink * prev;
int i;
SDK_NULL_ASSERT(bank);
#ifdef SDK_ARM9
SDK_ASSERTMSG(((u32)bank & 0x1f) == 0, "bank address must be aligned 32 bytes boundary.");
#endif
SNDi_LockMutex();
for (i = 0; i < SND_BANK_TO_WAVEARC_MAX; i++) {
waveArc = bank->waveArcLink[i].waveArc;
if (waveArc == NULL) {
continue;
}
if (&bank->waveArcLink[i] == waveArc->topLink) {
waveArc->topLink = bank->waveArcLink[i].next;
#ifdef SDK_ARM9
DC_StoreRange(waveArc, sizeof(SNDWaveArc));
#endif
} else {
prev = waveArc->topLink;
while (prev != NULL) {
if (&bank->waveArcLink[i] == prev->next) {
break;
}
prev = prev->next;
}
SDK_NULL_ASSERT(prev);
prev->next = bank->waveArcLink[i].next;
#ifdef SDK_ARM9
DC_StoreRange(prev, sizeof(SNDWaveArcLink));
#endif
}
}
SNDi_UnlockMutex();
}
void SND_DestroyWaveArc (SNDWaveArc * waveArc) {
SNDWaveArcLink * link;
SNDWaveArcLink * next;
SDK_NULL_ASSERT(waveArc);
#ifdef SDK_ARM9
SDK_ASSERTMSG(((u32)waveArc & 0x1f) == 0, "waveArc address must be aligned 32 bytes boundary.");
#endif
SNDi_LockMutex();
link = waveArc->topLink;
while (link != NULL) {
next = link->next;
link->waveArc = NULL;
link->next = NULL;
#ifdef SDK_ARM9
DC_StoreRange(link, sizeof(SNDWaveArcLink));
#endif
link = next;
}
SNDi_UnlockMutex();
}
BOOL SND_ReadInstData (const SNDBankData * bank, int prgNo, int key, SNDInstData * inst) {
u32 instOffset;
SDK_NULL_ASSERT(bank);
SDK_NULL_ASSERT(inst);
if (prgNo < 0) {
return FALSE;
}
#ifdef SDK_FROM_TOOL
if (bank->fileHeader.signature[0] == 'S' &&
bank->fileHeader.signature[1] == 'B' &&
bank->fileHeader.signature[2] == 'C' && bank->fileHeader.signature[3] == 'B') {
const SNDBankDataCallback * bankcb = (const SNDBankDataCallback *)bank;
return bankcb->readInstDataFunc(bankcb, prgNo, key, inst);
}
#endif
SNDi_LockMutex();
if (prgNo >= bank->instCount) {
SNDi_UnlockMutex();
return FALSE;
}
instOffset = bank->instOffset[prgNo];
inst->type = (u8)(instOffset & 0xff);
instOffset >>= 8;
switch (inst->type) {
case SND_INST_PCM:
case SND_INST_PSG:
case SND_INST_NOISE:
case SND_INST_DIRECTPCM:
case SND_INST_NULL:
{
const SNDInstParam * param = (const SNDInstParam *)((u8 *)bank + instOffset);
inst->param = *param;
break;
}
case SND_INST_DRUM_SET:
{
const SNDDrumSet * drumSet = (const SNDDrumSet *)((u8 *)bank + instOffset);
u8 min = MI_ReadByte(&drumSet->min);
u8 max = MI_ReadByte(&drumSet->max);
if (key < min || key > max) {
SNDi_UnlockMutex();
return FALSE;
}
*inst = drumSet->instOffset[key - min];
break;
}
case SND_INST_KEY_SPLIT:
{
int index = 0;
const SNDKeySplit * keySplit = (const SNDKeySplit *)((u8 *)bank + instOffset);
while (key > MI_ReadByte(&keySplit->key[index])) {
index++;
if (index >= SND_INST_KEYSPLIT_MAX) {
SNDi_UnlockMutex();
return FALSE;
}
}
*inst = keySplit->instOffset[index];
break;
}
case SND_INST_INVALID:
default:
SNDi_UnlockMutex();
return FALSE;
}
SNDi_UnlockMutex();
return TRUE;
}
BOOL SND_WriteInstData (SNDBankData * bank, int prgNo, int key, const struct SNDInstData * inst) {
u32 instOffset;
u8 type;
SDK_NULL_ASSERT(bank);
SDK_NULL_ASSERT(inst);
if (prgNo < 0) {
return FALSE;
}
SNDi_LockMutex();
if (prgNo >= bank->instCount) {
SNDi_UnlockMutex();
return FALSE;
}
instOffset = bank->instOffset[prgNo];
type = (u8)(instOffset & 0xff);
instOffset >>= 8;
switch (type) {
case SND_INST_PCM:
case SND_INST_PSG:
case SND_INST_NOISE:
case SND_INST_DIRECTPCM:
case SND_INST_NULL:
{
SNDInstParam * param = (SNDInstParam *)((u8 *)bank + instOffset);
bank->instOffset[prgNo] = (instOffset << 8) | inst->type;
*param = inst->param;
break;
}
case SND_INST_DRUM_SET:
{
SNDDrumSet * drumSet = (SNDDrumSet *)((u8 *)bank + instOffset);
u8 min = MI_ReadByte(&drumSet->min);
u8 max = MI_ReadByte(&drumSet->max);
if (key < min || key > max) {
SNDi_UnlockMutex();
return FALSE;
}
drumSet->instOffset[key - min] = *inst;
break;
}
case SND_INST_KEY_SPLIT:
{
int index = 0;
SNDKeySplit * keySplit = (SNDKeySplit *)((u8 *)bank + instOffset);
while (key > MI_ReadByte(&keySplit->key[index])) {
index++;
if (index >= SND_INST_KEYSPLIT_MAX) {
SNDi_UnlockMutex();
return FALSE;
}
}
keySplit->instOffset[index] = *inst;
break;
}
case SND_INST_INVALID:
default:
SNDi_UnlockMutex();
return FALSE;
}
SNDi_UnlockMutex();
#ifdef SDK_ARM9
DC_StoreRange(bank, bank->fileHeader.fileSize);
#endif
return TRUE;
}
SNDInstPos SND_GetFirstInstDataPos (const SNDBankData * bank) {
SNDInstPos pos;
SDK_NULL_ASSERT(bank);
(void)bank;
pos.prgNo = 0;
pos.index = 0;
return pos;
}
BOOL SND_GetNextInstData (const SNDBankData * bank, SNDInstData * inst, SNDInstPos * pos) {
SDK_NULL_ASSERT(bank);
SDK_NULL_ASSERT(inst);
SDK_NULL_ASSERT(pos);
for (; pos->prgNo < bank->instCount; pos->prgNo++, pos->index = 0) {
u32 instOffset = bank->instOffset[pos->prgNo];
inst->type = (u8)(instOffset & 0xff);
instOffset >>= 8;
switch (inst->type) {
case SND_INST_PCM:
case SND_INST_PSG:
case SND_INST_NOISE:
case SND_INST_DIRECTPCM:
case SND_INST_NULL:
{
const SNDInstParam * param = (const SNDInstParam *)((u8 *)bank + instOffset);
inst->param = *param;
pos->prgNo++;
return TRUE;
}
case SND_INST_DRUM_SET:
{
const SNDDrumSet * drumSet = (const SNDDrumSet *)((u8 *)bank + instOffset);
for (; pos->index < drumSet->max - drumSet->min + 1; pos->index++) {
*inst = drumSet->instOffset[pos->index];
pos->index++;
return TRUE;
}
break;
}
case SND_INST_KEY_SPLIT:
{
const SNDKeySplit * keySplit = (const SNDKeySplit *)((u8 *)bank + instOffset);
for (; pos->index < SND_INST_KEYSPLIT_MAX; pos->index++) {
if (keySplit->key[pos->index] == 0) {
break;
}
*inst = keySplit->instOffset[pos->index];
pos->index++;
return TRUE;
}
break;
}
default:
break;
}
}
return FALSE;
}
u32 SND_GetWaveDataCount (const struct SNDWaveArc * waveArc) {
SDK_NULL_ASSERT(waveArc);
return waveArc->waveCount;
}
void SND_SetWaveDataAddress (SNDWaveArc * waveArc, int index, const SNDWaveData * address) {
SDK_NULL_ASSERT(waveArc);
SDK_MINMAX_ASSERT(index, 0, waveArc->waveCount);
SDK_ASSERT(address == NULL || address >= (void *)HW_MAIN_MEM);
SNDi_LockMutex();
waveArc->waveOffset[index] = (u32)address;
#ifdef SDK_ARM9
DC_StoreRange(&waveArc->waveOffset[index], sizeof(u32));
#endif
SNDi_UnlockMutex();
}
const SNDWaveData * SND_GetWaveDataAddress (const SNDWaveArc * waveArc, int index) {
const SNDWaveData * wave;
u32 offset;
SDK_NULL_ASSERT(waveArc);
SDK_MINMAX_ASSERT(index, 0, waveArc->waveCount);
SNDi_LockMutex();
offset = waveArc->waveOffset[index];
if (offset != 0) {
if (offset < HW_MAIN_MEM) {
wave = (const SNDWaveData *)((u8 *)waveArc + offset);
} else {
wave = (const SNDWaveData *)offset;
}
} else {
wave = NULL;
}
SNDi_UnlockMutex();
return wave;
}
#ifdef SDK_ARM7
BOOL SND_NoteOn (SNDExChannel * ch_p, int key, int velocity, s32 length, const SNDBankData * bank, const SNDInstData * inst) {
const SNDWaveData * wave_data;
int release;
BOOL result;
SDK_NULL_ASSERT(ch_p);
SDK_MINMAX_ASSERT(key, 0, 127);
SDK_MINMAX_ASSERT(velocity, 0, 127);
SDK_NULL_ASSERT(inst);
release = inst->param.release;
if (inst->param.release == SND_BANK_DISABLE_RELEASE) {
length = -1;
release = 0;
}
switch (inst->type) {
case SND_INST_PCM:
case SND_INST_DIRECTPCM:
if (inst->type == SND_INST_PCM) {
wave_data = GetWaveData(bank, inst->param.wave[1], inst->param.wave[0]);
} else {
wave_data = (const SNDWaveData *)(inst->param.wave[1] << 16 | inst->param.wave[0]);
}
if (wave_data != NULL) {
result = SND_StartExChannelPcm(ch_p, &wave_data->param, wave_data->samples, length);
} else {
result = FALSE;
}
break;
case SND_INST_PSG:
result = SND_StartExChannelPsg(ch_p, (SNDDuty)inst->param.wave[0], length);
break;
case SND_INST_NOISE:
result = SND_StartExChannelNoise(ch_p, length);
break;
default:
result = FALSE;
break;
}
if (!result) {
return FALSE;
}
ch_p->key = (u8)key;
ch_p->original_key = inst->param.original_key;
ch_p->velocity = (u8)velocity;
SND_SetExChannelAttack(ch_p, inst->param.attack);
SND_SetExChannelDecay(ch_p, inst->param.decay);
SND_SetExChannelSustain(ch_p, inst->param.sustain);
SND_SetExChannelRelease(ch_p, release);
ch_p->init_pan = (s8)(inst->param.pan - 64);
return TRUE;
}
#endif
#ifdef SDK_ARM7
static const SNDWaveData * GetWaveData (const SNDBankData * bank, int waveArcNo, int waveIndex) {
const SNDWaveArc * arc;
SDK_MINMAX_ASSERT(waveArcNo, 0, SND_BANK_TO_WAVEARC_MAX - 1);
arc = bank->waveArcLink[waveArcNo].waveArc;
if (arc == NULL) {
return NULL;
}
if (waveIndex >= arc->waveCount) {
return NULL;
}
return SND_GetWaveDataAddress(arc, waveIndex);
}
#endif

838
lib/NitroSDK/src/snd/snd_command.c Normal file
View File

@ -0,0 +1,838 @@
#include <nitro/snd/common/command.h>
#include <nitro/misc.h>
#include <nitro/os.h>
#include <nitro/pxi.h>
#include <nitro/mi.h>
#include <nitro/snd/common/seq.h>
#include <nitro/snd/common/capture.h>
#include <nitro/snd/common/work.h>
#include <nitro/snd/common/global.h>
#include <nitro/snd/common/util.h>
#include <nitro/snd/common/alarm.h>
#include <nitro/snd/common/main.h>
#define SND_COMMAND_NUM 256
#define SND_PXI_FIFO_MESSAGE_BUFSIZE 8
#define SND_MSG_REQUEST_COMMAND_PROC 0
#define UNPACK_COMMAND(arg, shift, bit) (((arg) >> (shift)) & ((1 << (bit)) - 1))
#ifdef SDK_ARM9
static SNDCommand sCommandArray[SND_COMMAND_NUM] ATTRIBUTE_ALIGN(32);
static SNDCommand * sFreeList;
static SNDCommand * sFreeListEnd;
static SNDCommand * sReserveList;
static SNDCommand * sReserveListEnd;
static SNDCommand * sWaitingCommandListQueue[SND_PXI_FIFO_MESSAGE_BUFSIZE + 1];
static int sWaitingCommandListQueueRead;
static int sWaitingCommandListQueueWrite;
static int sWaitingCommandListCount;
static u32 sCurrentTag;
static u32 sFinishedTag;
static SNDSharedWork sSharedWork ATTRIBUTE_ALIGN(32);
#else
static OSMessage sCommandMesgBuffer[SND_PXI_FIFO_MESSAGE_BUFSIZE];
static OSMessageQueue sCommandMesgQueue;
#endif
static void PxiFifoCallback(PXIFifoTag tag, u32 data, BOOL err);
static void InitPXI(void);
#ifdef SDK_ARM9
static void RequestCommandProc(void);
static SNDCommand * AllocCommand(void);
static BOOL IsCommandAvailable(void);
#else
static void SetChannelTimer(u32 chBitMask, int timer);
static void SetChannelVolume(u32 chBitMask, int volume, SNDChannelDataShift shift);
static void SetChannelPan(u32 chBitMask, int pan);
static void StartTimer(u32 chBitMask, u32 capBitMask, u32 alarmBitMask, u32 flags);
static void StopTimer(u32 chBitMask, u32 capBitMask, u32 alarmBitMask, u32 flags);
static void ReadDriverInfo(SNDDriverInfo * info);
#endif
void SND_CommandInit (void) {
#ifdef SDK_ARM9
SNDCommand * command;
int i;
#endif
#ifdef SDK_ARM7
OS_InitMessageQueue(&sCommandMesgQueue, sCommandMesgBuffer, SND_PXI_FIFO_MESSAGE_BUFSIZE);
#endif
InitPXI();
#ifdef SDK_ARM9
sFreeList = &sCommandArray[0];
for (i = 0; i < SND_COMMAND_NUM - 1; i++) {
sCommandArray[i].next = &sCommandArray[i + 1];
}
sCommandArray[SND_COMMAND_NUM - 1].next = NULL;
sFreeListEnd = &sCommandArray[SND_COMMAND_NUM - 1];
sReserveList = NULL;
sReserveListEnd = NULL;
sWaitingCommandListCount = 0;
sWaitingCommandListQueueRead = 0;
sWaitingCommandListQueueWrite = 0;
sCurrentTag = 1;
sFinishedTag = 0;
SNDi_SharedWork = &sSharedWork;
SNDi_InitSharedWork(SNDi_SharedWork);
command = SND_AllocCommand(SND_COMMAND_BLOCK);
if (command != NULL) {
command->id = SND_COMMAND_SHARED_WORK;
command->arg[0] = (u32)SNDi_SharedWork;
SND_PushCommand(command);
(void)SND_FlushCommand(SND_COMMAND_BLOCK);
}
#else
SNDi_SharedWork = NULL;
#endif
}
#ifdef SDK_ARM9
const SNDCommand * SND_RecvCommandReply (u32 flags) {
OSIntrMode bak_psr = OS_DisableInterrupts();
SNDCommand * commandList;
SNDCommand * commandListEnd;
if (flags & SND_COMMAND_BLOCK) {
while (sFinishedTag == SNDi_GetFinishedCommandTag()) {
(void)OS_RestoreInterrupts(bak_psr);
OS_SpinWait(100);
bak_psr = OS_DisableInterrupts();
}
} else {
if (sFinishedTag == SNDi_GetFinishedCommandTag()) {
(void)OS_RestoreInterrupts(bak_psr);
return NULL;
}
}
commandList = sWaitingCommandListQueue[sWaitingCommandListQueueRead];
sWaitingCommandListQueueRead++;
if (sWaitingCommandListQueueRead > SND_PXI_FIFO_MESSAGE_BUFSIZE) {
sWaitingCommandListQueueRead = 0;
}
commandListEnd = commandList;
while (commandListEnd->next != NULL) {
commandListEnd = commandListEnd->next;
}
if (sFreeListEnd != NULL) {
sFreeListEnd->next = commandList;
} else {
sFreeList = commandList;
}
sFreeListEnd = commandListEnd;
sWaitingCommandListCount--;
sFinishedTag++;
(void)OS_RestoreInterrupts(bak_psr);
return commandList;
}
SNDCommand * SND_AllocCommand (u32 flags) {
SNDCommand * command;
if (!IsCommandAvailable()) {
return NULL;
}
command = AllocCommand();
if (command != NULL) {
return command;
}
if ((flags & SND_COMMAND_BLOCK) == 0) {
return NULL;
}
if (SND_CountWaitingCommand() > 0) {
while (SND_RecvCommandReply(SND_COMMAND_NOBLOCK) != NULL) {
}
command = AllocCommand();
if (command != NULL) {
return command;
}
} else {
(void)SND_FlushCommand(SND_COMMAND_BLOCK);
}
RequestCommandProc();
do{
(void)SND_RecvCommandReply(SND_COMMAND_BLOCK);
command = AllocCommand();
} while (command == NULL);
return command;
}
void SND_PushCommand (struct SNDCommand * command) {
OSIntrMode bak_psr;
SDK_NULL_ASSERT(command);
bak_psr = OS_DisableInterrupts();
if (sReserveListEnd == NULL) {
sReserveList = command;
sReserveListEnd = command;
} else {
sReserveListEnd->next = command;
sReserveListEnd = command;
}
command->next = NULL;
(void)OS_RestoreInterrupts(bak_psr);
}
BOOL SND_FlushCommand (u32 flags) {
OSIntrMode bak_psr = OS_DisableInterrupts();
if (sReserveList == NULL) {
(void)OS_RestoreInterrupts(bak_psr);
return TRUE;
}
if (sWaitingCommandListCount >= SND_PXI_FIFO_MESSAGE_BUFSIZE) {
if ((flags & SND_COMMAND_BLOCK) == 0) {
(void)OS_RestoreInterrupts(bak_psr);
return FALSE;
}
do{
(void)SND_RecvCommandReply(SND_COMMAND_BLOCK);
} while (sWaitingCommandListCount >= SND_PXI_FIFO_MESSAGE_BUFSIZE);
if (sReserveList == NULL) {
(void)OS_RestoreInterrupts(bak_psr);
return TRUE;
}
}
DC_FlushRange(sCommandArray, sizeof(sCommandArray));
if (PXI_SendWordByFifo(PXI_FIFO_TAG_SOUND, (u32)sReserveList, FALSE) < 0) {
if ((flags & SND_COMMAND_BLOCK) == 0) {
(void)OS_RestoreInterrupts(bak_psr);
return FALSE;
}
while (sWaitingCommandListCount >= SND_PXI_FIFO_MESSAGE_BUFSIZE ||
PXI_SendWordByFifo(PXI_FIFO_TAG_SOUND, (u32)sReserveList, FALSE) < 0) {
(void)OS_RestoreInterrupts(bak_psr);
(void)SND_RecvCommandReply(SND_COMMAND_NOBLOCK);
bak_psr = OS_DisableInterrupts();
DC_FlushRange(sCommandArray, sizeof(sCommandArray));
if (sReserveList == NULL) {
(void)OS_RestoreInterrupts(bak_psr);
return TRUE;
}
}
}
sWaitingCommandListQueue[sWaitingCommandListQueueWrite] = sReserveList;
sWaitingCommandListQueueWrite++;
if (sWaitingCommandListQueueWrite > SND_PXI_FIFO_MESSAGE_BUFSIZE) {
sWaitingCommandListQueueWrite = 0;
}
sReserveList = NULL;
sReserveListEnd = NULL;
sWaitingCommandListCount++;
sCurrentTag++;
(void)OS_RestoreInterrupts(bak_psr);
if (flags & SND_COMMAND_IMMEDIATE) {
RequestCommandProc();
}
return TRUE;
}
void SND_WaitForCommandProc (u32 tag) {
if (SND_IsFinishedCommandTag(tag)) {
return;
}
while (SND_RecvCommandReply(SND_COMMAND_NOBLOCK) != NULL) {
}
if (SND_IsFinishedCommandTag(tag)) {
return;
}
RequestCommandProc();
while (!SND_IsFinishedCommandTag(tag)) {
(void)SND_RecvCommandReply(SND_COMMAND_BLOCK);
}
}
void SND_WaitForFreeCommand (int count) {
int freeCount = SND_CountFreeCommand();
SDK_MAX_ASSERT(count, SND_COMMAND_NUM);
if (freeCount >= count) {
return;
}
if (freeCount + SND_CountWaitingCommand() >= count) {
while (SND_RecvCommandReply(SND_COMMAND_NOBLOCK) != NULL) {
}
if (SND_CountFreeCommand() >= count) {
return;
}
} else {
(void)SND_FlushCommand(SND_COMMAND_BLOCK);
}
RequestCommandProc();
do{
(void)SND_RecvCommandReply(SND_COMMAND_BLOCK);
} while (SND_CountFreeCommand() < count);
}
u32 SND_GetCurrentCommandTag (void) {
OSIntrMode bak_psr = OS_DisableInterrupts();
u32 tag;
if (sReserveList == NULL) {
tag = sFinishedTag;
} else {
tag = sCurrentTag;
}
(void)OS_RestoreInterrupts(bak_psr);
return tag;
}
BOOL SND_IsFinishedCommandTag (u32 tag) {
OSIntrMode bak_psr = 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;
}
}
(void)OS_RestoreInterrupts(bak_psr);
return result;
}
int SND_CountFreeCommand (void) {
OSIntrMode bak_psr = OS_DisableInterrupts();
SNDCommand * command;
int count = 0;
command = sFreeList;
while (command != NULL) {
++count;
command = command->next;
}
(void)OS_RestoreInterrupts(bak_psr);
return count;
}
int SND_CountReservedCommand (void) {
OSIntrMode bak_psr = OS_DisableInterrupts();
SNDCommand * command;
int count = 0;
command = sReserveList;
while (command != NULL) {
++count;
command = command->next;
}
(void)OS_RestoreInterrupts(bak_psr);
return count;
}
int SND_CountWaitingCommand (void) {
int freeCount = SND_CountFreeCommand();
int reservedCount = SND_CountReservedCommand();
return SND_COMMAND_NUM - freeCount - reservedCount;
}
#else
void SND_CommandProc (void) {
OSMessage message;
const SNDCommand * command_p;
SNDCommand command;
while (OS_ReceiveMessage(&sCommandMesgQueue, &message, OS_MESSAGE_NOBLOCK)) {
command_p = (const SNDCommand *)message;
while (command_p != NULL) {
command = *command_p;
switch (command.id) {
case SND_COMMAND_START_SEQ:
SND_StartSeq(
(int)command.arg[0],
(const void *)command.arg[1],
command.arg[2], (struct SNDBankData *)command.arg[3]
);
break;
case SND_COMMAND_STOP_SEQ:
SND_StopSeq((int)command.arg[0]);
break;
case SND_COMMAND_PREPARE_SEQ:
SND_PrepareSeq(
(int)command.arg[0],
(const void *)command.arg[1],
command.arg[2], (struct SNDBankData *)command.arg[3]
);
break;
case SND_COMMAND_START_PREPARED_SEQ:
SND_StartPreparedSeq((int)command.arg[0]);
break;
case SND_COMMAND_PAUSE_SEQ:
SND_PauseSeq((int)command.arg[0], (BOOL)command.arg[1]);
break;
case SND_COMMAND_SKIP_SEQ:
SND_SkipSeq((int)command.arg[0], (u32)command.arg[1]);
break;
case SND_COMMAND_PLAYER_PARAM:
SNDi_SetPlayerParam(
(int)command.arg[0],
command.arg[1], command.arg[2], (int)command.arg[3]
);
break;
case SND_COMMAND_TRACK_PARAM:
SNDi_SetTrackParam(
(int)UNPACK_COMMAND(command.arg[0], 0, 24),
command.arg[1],
command.arg[2],
command.arg[3], (int)UNPACK_COMMAND(command.arg[0], 24, 8)
);
break;
case SND_COMMAND_MUTE_TRACK:
SND_SetTrackMute((int)command.arg[0], command.arg[1], (SNDSeqMute)command.arg[2]);
break;
case SND_COMMAND_ALLOCATABLE_CHANNEL:
SND_SetTrackAllocatableChannel((int)command.arg[0], command.arg[1], command.arg[2]);
break;
case SND_COMMAND_PLAYER_LOCAL_VAR:
SND_SetPlayerLocalVariable(
(int)command.arg[0],
(int)command.arg[1], (s16)command.arg[2]
);
break;
case SND_COMMAND_PLAYER_GLOBAL_VAR:
SND_SetPlayerGlobalVariable((int)command.arg[0], (s16)command.arg[1]);
break;
case SND_COMMAND_START_TIMER:
StartTimer(command.arg[0], command.arg[1], command.arg[2], command.arg[3]);
break;
case SND_COMMAND_STOP_TIMER:
StopTimer(command.arg[0], command.arg[1], command.arg[2], command.arg[3]);
break;
case SND_COMMAND_SETUP_CAPTURE:
SND_SetupCapture(
(SNDCapture)UNPACK_COMMAND(command.arg[2], 31, 1),
(SNDCaptureFormat)UNPACK_COMMAND(command.arg[2], 30, 1),
(void *)command.arg[0],
(int)command.arg[1],
(BOOL)UNPACK_COMMAND(command.arg[2], 29, 1),
(SNDCaptureIn)UNPACK_COMMAND(command.arg[2], 28, 1),
(SNDCaptureOut)UNPACK_COMMAND(command.arg[2], 27, 1)
);
break;
case SND_COMMAND_SETUP_ALARM:
SND_SetupAlarm(
(int)command.arg[0],
(OSTick)command.arg[1], (OSTick)command.arg[2], (int)command.arg[3]
);
break;
case SND_COMMAND_CHANNEL_TIMER:
SetChannelTimer((u32)command.arg[0], (int)command.arg[1]);
break;
case SND_COMMAND_CHANNEL_VOLUME:
SetChannelVolume(
(u32)command.arg[0],
(int)command.arg[1], (SNDChannelDataShift)command.arg[2]
);
break;
case SND_COMMAND_CHANNEL_PAN:
SetChannelPan((u32)command.arg[0], (int)command.arg[1]);
break;
case SND_COMMAND_SETUP_CHANNEL_PCM:
SND_SetupChannelPcm(
(int)UNPACK_COMMAND(command.arg[0], 0, 16),
(const void *)UNPACK_COMMAND(command.arg[1], 0, 27),
(SNDWaveFormat)UNPACK_COMMAND(command.arg[3], 24, 2),
(SNDChannelLoop)UNPACK_COMMAND(command.arg[3], 26, 2),
(int)UNPACK_COMMAND(command.arg[3], 0, 16),
(int)UNPACK_COMMAND(command.arg[2], 0, 22),
(int)UNPACK_COMMAND(command.arg[2], 24, 7),
(SNDChannelDataShift)UNPACK_COMMAND(command.arg[2], 22, 2),
(int)UNPACK_COMMAND(command.arg[0], 16, 16),
(int)UNPACK_COMMAND(command.arg[3], 16, 7)
);
break;
case SND_COMMAND_SETUP_CHANNEL_PSG:
SND_SetupChannelPsg(
(int)command.arg[0],
(SNDDuty)command.arg[3],
(int)UNPACK_COMMAND(command.arg[1], 0, 7),
(SNDChannelDataShift)UNPACK_COMMAND(command.arg[1], 8, 2),
(int)UNPACK_COMMAND(command.arg[2], 8, 16),
(int)UNPACK_COMMAND(command.arg[2], 0, 7)
);
break;
case SND_COMMAND_SETUP_CHANNEL_NOISE:
SND_SetupChannelNoise(
(int)command.arg[0],
(int)UNPACK_COMMAND(command.arg[1], 0, 7),
(SNDChannelDataShift)UNPACK_COMMAND(command.arg[1], 8, 2),
(int)UNPACK_COMMAND(command.arg[2], 8, 16),
(int)UNPACK_COMMAND(command.arg[2], 0, 7)
);
break;
case SND_COMMAND_SURROUND_DECAY:
SNDi_SetSurroundDecay((int)command.arg[0]);
break;
case SND_COMMAND_MASTER_VOLUME:
SND_SetMasterVolume((int)command.arg[0]);
break;
case SND_COMMAND_MASTER_PAN:
SND_SetMasterPan((int)command.arg[0]);
break;
case SND_COMMAND_OUTPUT_SELECTOR:
SND_SetOutputSelector(
(SNDOutput)command.arg[0],
(SNDOutput)command.arg[1],
(SNDChannelOut)command.arg[2], (SNDChannelOut)command.arg[3]
);
break;
case SND_COMMAND_LOCK_CHANNEL:
SND_LockChannel(command.arg[0], command.arg[1]);
break;
case SND_COMMAND_UNLOCK_CHANNEL:
SND_UnlockChannel(command.arg[0], command.arg[1]);
break;
case SND_COMMAND_STOP_UNLOCKED_CHANNEL:
SND_StopUnlockedChannel(command.arg[0], command.arg[1]);
break;
case SND_COMMAND_INVALIDATE_SEQ:
SND_InvalidateSeq((const void *)command.arg[0], (const void *)command.arg[1]);
break;
case SND_COMMAND_INVALIDATE_BANK:
SND_InvalidateBank((const void *)command.arg[0], (const void *)command.arg[1]);
break;
case SND_COMMAND_INVALIDATE_WAVE:
SND_InvalidateWave((const void *)command.arg[0], (const void *)command.arg[1]);
break;
case SND_COMMAND_SHARED_WORK:
SNDi_SharedWork = (SNDSharedWork *)command.arg[0];
break;
case SND_COMMAND_READ_DRIVER_INFO:
ReadDriverInfo((SNDDriverInfo *)command.arg[0]);
break;
}
command_p = command.next;
}
SDK_NULL_ASSERT(SNDi_SharedWork);
SNDi_SharedWork->finishCommandTag++;
}
}
#endif
static void PxiFifoCallback (PXIFifoTag tag, u32 data, BOOL) {
OSIntrMode enabled;
BOOL result;
#ifdef SDK_DEBUG
SDK_ASSERT(tag == PXI_FIFO_TAG_SOUND);
#else
#pragma unused( tag )
#endif
enabled = OS_DisableInterrupts();
#ifdef SDK_ARM9
#pragma unused( result )
SNDi_CallAlarmHandler((int)data);
#else
if (data >= HW_MAIN_MEM) {
result = OS_SendMessage(&sCommandMesgQueue, (OSMessage)data, OS_MESSAGE_NOBLOCK);
SDK_ASSERTMSG(result, "Failed OS_SendMessage");
} else {
switch (data) {
case SND_MSG_REQUEST_COMMAND_PROC:
{
(void)SND_SendWakeupMessage();
break;
}
}
}
#endif
(void)OS_RestoreInterrupts(enabled);
}
static void InitPXI (void) {
PXI_SetFifoRecvCallback(PXI_FIFO_TAG_SOUND, PxiFifoCallback);
#ifdef SDK_ARM9
if (IsCommandAvailable()) {
while (!PXI_IsCallbackReady(PXI_FIFO_TAG_SOUND, PXI_PROC_ARM7)) {
OS_SpinWait(100);
}
}
#endif
}
#ifdef SDK_ARM9
static void RequestCommandProc (void) {
while (PXI_SendWordByFifo(PXI_FIFO_TAG_SOUND, SND_MSG_REQUEST_COMMAND_PROC, FALSE) < 0) {
}
}
static SNDCommand * AllocCommand (void) {
OSIntrMode bak_psr = OS_DisableInterrupts();
SNDCommand * command;
if (sFreeList == NULL) {
(void)OS_RestoreInterrupts(bak_psr);
return NULL;
}
command = sFreeList;
sFreeList = sFreeList->next;
if (sFreeList == NULL) {
sFreeListEnd = NULL;
}
(void)OS_RestoreInterrupts(bak_psr);
return command;
}
static BOOL IsCommandAvailable (void) {
OSIntrMode prev_mode;
u32 res;
if (!OS_IsRunOnEmulator()) {
return TRUE;
}
prev_mode = OS_DisableInterrupts();
*(vu32 *)0x4fff200 = 0x10;
res = *(vu32 *)0x4fff200;
(void)OS_RestoreInterrupts(prev_mode);
return res ? TRUE : FALSE;
}
#else
static void SetChannelTimer (u32 chBitMask, int timer) {
int ch;
for (ch = 0; ch < SND_CHANNEL_NUM && chBitMask != 0; ch++, chBitMask >>= 1) {
if ((chBitMask & 0x01) == 0) {
continue;
}
SND_SetChannelTimer(ch, timer);
}
}
static void SetChannelVolume (u32 chBitMask, int volume, SNDChannelDataShift shift) {
int ch;
for (ch = 0; ch < SND_CHANNEL_NUM && chBitMask != 0; ch++, chBitMask >>= 1) {
if ((chBitMask & 0x01) == 0) {
continue;
}
SND_SetChannelVolume(ch, volume, shift);
}
}
static void SetChannelPan (u32 chBitMask, int pan) {
int ch;
for (ch = 0; ch < SND_CHANNEL_NUM && chBitMask != 0; ch++, chBitMask >>= 1) {
if ((chBitMask & 0x01) == 0) {
continue;
}
SND_SetChannelPan(ch, pan);
}
}
static void StartTimer (u32 chBitMask, u32 capBitMask, u32 alarmBitMask, u32) {
OSIntrMode enabled;
int i;
enabled = OS_DisableInterrupts();
for (i = 0; i < SND_CHANNEL_NUM && chBitMask != 0; i++, chBitMask >>= 1) {
if ((chBitMask & 0x01) == 0) {
continue;
}
SND_StartChannel(i);
}
if (capBitMask & (1 << SND_CAPTURE_0)) {
if (capBitMask & (1 << SND_CAPTURE_1)) {
SND_StartCaptureBoth();
} else {
SND_StartCapture(SND_CAPTURE_0);
}
} else if (capBitMask & (1 << SND_CAPTURE_1)) {
SND_StartCapture(SND_CAPTURE_1);
}
for (i = 0; i < SND_ALARM_NUM && alarmBitMask != 0; i++, alarmBitMask >>= 1) {
if ((alarmBitMask & 0x01) == 0) {
continue;
}
SND_StartAlarm(i);
}
(void)OS_RestoreInterrupts(enabled);
SND_UpdateSharedWork();
}
static void StopTimer (u32 chBitMask, u32 capBitMask, u32 alarmBitMask, u32 flags) {
OSIntrMode enabled;
int i;
enabled = OS_DisableInterrupts();
for (i = 0; i < SND_ALARM_NUM && alarmBitMask != 0; i++, alarmBitMask >>= 1) {
if ((alarmBitMask & 0x01) == 0) {
continue;
}
SND_StopAlarm(i);
}
for (i = 0; i < SND_CHANNEL_NUM && chBitMask != 0; i++, chBitMask >>= 1) {
if ((chBitMask & 0x01) == 0) {
continue;
}
SND_StopChannel(i, (s32)flags);
}
if (capBitMask & (1 << SND_CAPTURE_0)) {
SND_StopCapture(SND_CAPTURE_0);
}
if (capBitMask & (1 << SND_CAPTURE_1)) {
SND_StopCapture(SND_CAPTURE_1);
}
(void)OS_RestoreInterrupts(enabled);
SND_UpdateSharedWork();
}
static void ReadDriverInfo (SNDDriverInfo * info) {
int ch;
MI_CpuCopy32(&SNDi_Work, &info->work, sizeof(SNDi_Work));
info->workAddress = &SNDi_Work;
for (ch = 0; ch < SND_CHANNEL_NUM; ch++) {
info->chCtrl[ch] = SND_GetChannelControl(ch);
}
info->lockedChannels = SND_GetLockedChannel(0);
}
#endif

311
lib/NitroSDK/src/snd/snd_interface.c Normal file
View File

@ -0,0 +1,311 @@
#include <nitro/snd/ARM9/interface.h>
#include <nitro/misc.h>
#include <nitro/snd/common/command.h>
#include <nitro/snd/common/seq.h>
#include <nitro/snd/common/alarm.h>
#define PushCommand(c, a0, a1, a2, a3) PushCommand_impl((c), (u32)(a0), (u32)(a1), (u32)(a2), (u32)(a3))
#define GetOffset(type, member) ((u32)(&((type *)0)->member))
#define GetSize(type, member) (sizeof(((type *)0)->member))
static void PushCommand_impl(SNDCommandID command, u32 arg0, u32 arg1, u32 arg2, u32 arg3);
void SND_StartSeq (int playerNo, const void * base, u32 offset, const struct SNDBankData * bank) {
SDK_MINMAX_ASSERT(playerNo, SND_PLAYER_MIN, SND_PLAYER_MAX);
SDK_NULL_ASSERT(base);
SDK_NULL_ASSERT(bank);
PushCommand(SND_COMMAND_START_SEQ, playerNo, base, offset, bank);
}
void SND_StopSeq (int playerNo) {
SDK_MINMAX_ASSERT(playerNo, SND_PLAYER_MIN, SND_PLAYER_MAX);
PushCommand(SND_COMMAND_STOP_SEQ, playerNo, 0, 0, 0);
}
void SND_PrepareSeq (int playerNo, const void * base, u32 offset, const struct SNDBankData * bank) {
SDK_MINMAX_ASSERT(playerNo, SND_PLAYER_MIN, SND_PLAYER_MAX);
SDK_NULL_ASSERT(base);
SDK_NULL_ASSERT(bank);
PushCommand(SND_COMMAND_PREPARE_SEQ, playerNo, base, offset, bank);
}
void SND_StartPreparedSeq (int playerNo) {
SDK_MINMAX_ASSERT(playerNo, SND_PLAYER_MIN, SND_PLAYER_MAX);
PushCommand(SND_COMMAND_START_PREPARED_SEQ, playerNo, 0, 0, 0);
}
void SND_PauseSeq (int playerNo, BOOL flag) {
SDK_MINMAX_ASSERT(playerNo, SND_PLAYER_MIN, SND_PLAYER_MAX);
PushCommand(SND_COMMAND_PAUSE_SEQ, playerNo, flag, 0, 0);
}
void SND_SetPlayerTempoRatio (int playerNo, int ratio) {
SDK_MINMAX_ASSERT(playerNo, SND_PLAYER_MIN, SND_PLAYER_MAX);
SDK_MIN_ASSERT(ratio, 1);
SNDi_SetPlayerParam(
playerNo,
GetOffset(SNDPlayer, tempo_ratio),
(u32)ratio, GetSize(SNDPlayer, tempo_ratio)
);
}
void SND_SetPlayerVolume (int playerNo, int volume) {
SDK_MINMAX_ASSERT(playerNo, SND_PLAYER_MIN, SND_PLAYER_MAX);
SDK_MINMAX_ASSERT(volume, -32768, 0);
SNDi_SetPlayerParam(
playerNo,
GetOffset(SNDPlayer, extFader), (u32)volume, GetSize(SNDPlayer, extFader)
);
}
void SND_SetPlayerChannelPriority (int playerNo, int prio) {
SDK_MINMAX_ASSERT(playerNo, SND_PLAYER_MIN, SND_PLAYER_MAX);
SDK_MINMAX_ASSERT(prio, 0, 127);
SNDi_SetPlayerParam(playerNo, GetOffset(SNDPlayer, prio), (u32)prio, GetSize(SNDPlayer, prio));
}
void SND_SetPlayerLocalVariable (int playerNo, int varNo, s16 var) {
SDK_MINMAX_ASSERT(playerNo, SND_PLAYER_MIN, SND_PLAYER_MAX);
SDK_MINMAX_ASSERT(varNo, 0, SND_PLAYER_VARIABLE_NUM - 1);
PushCommand(SND_COMMAND_PLAYER_LOCAL_VAR, playerNo, varNo, var, 0);
}
void SND_SetPlayerGlobalVariable (int varNo, s16 var) {
SDK_MINMAX_ASSERT(varNo, 0, SND_GLOBAL_VARIABLE_NUM - 1);
PushCommand(SND_COMMAND_PLAYER_GLOBAL_VAR, varNo, var, 0, 0);
}
void SND_SetTrackVolume (int playerNo, u32 trackBitMask, int volume) {
SDK_MINMAX_ASSERT(playerNo, SND_PLAYER_MIN, SND_PLAYER_MAX);
SDK_MINMAX_ASSERT(volume, -32768, 0);
SNDi_SetTrackParam(
playerNo, trackBitMask,
GetOffset(SNDTrack, extFader), (u32)volume, GetSize(SNDTrack, extFader)
);
}
void SND_SetTrackPitch (int playerNo, u32 trackBitMask, int pitch) {
SDK_MINMAX_ASSERT(playerNo, SND_PLAYER_MIN, SND_PLAYER_MAX);
SDK_MINMAX_ASSERT(pitch, -32768, 32767);
SNDi_SetTrackParam(
playerNo, trackBitMask,
GetOffset(SNDTrack, ext_pitch), (u32)pitch, GetSize(SNDTrack, ext_pitch)
);
}
void SND_SetTrackPan (int playerNo, u32 trackBitMask, int pan) {
SDK_MINMAX_ASSERT(playerNo, SND_PLAYER_MIN, SND_PLAYER_MAX);
SDK_MINMAX_ASSERT(pan, -128, 127);
SNDi_SetTrackParam(
playerNo, trackBitMask,
GetOffset(SNDTrack, ext_pan), (u32)pan, GetSize(SNDTrack, ext_pan)
);
}
void SND_SetTrackPanRange (int playerNo, u32 trackBitMask, int panRange) {
SDK_MINMAX_ASSERT(playerNo, SND_PLAYER_MIN, SND_PLAYER_MAX);
SDK_MINMAX_ASSERT(panRange, 0, 127);
SNDi_SetTrackParam(
playerNo, trackBitMask,
GetOffset(SNDTrack, pan_range), (u32)panRange, GetSize(SNDTrack, pan_range)
);
}
void SND_SetTrackModDepth (int playerNo, u32 trackBitMask, int depth) {
SDK_MINMAX_ASSERT(playerNo, SND_PLAYER_MIN, SND_PLAYER_MAX);
SDK_MINMAX_ASSERT(depth, 0, 255);
SNDi_SetTrackParam(
playerNo, trackBitMask,
GetOffset(SNDTrack, mod.depth), (u32)depth, GetSize(SNDTrack, mod.depth)
);
}
void SND_SetTrackModSpeed (int playerNo, u32 trackBitMask, int speed) {
SDK_MINMAX_ASSERT(playerNo, SND_PLAYER_MIN, SND_PLAYER_MAX);
SDK_MINMAX_ASSERT(speed, 0, 255);
SNDi_SetTrackParam(
playerNo, trackBitMask,
GetOffset(SNDTrack, mod.speed), (u32)speed, GetSize(SNDTrack, mod.speed)
);
}
void SND_SetTrackAllocatableChannel (int playerNo, u32 trackBitMask, u32 chBitMask) {
SDK_MINMAX_ASSERT(playerNo, SND_PLAYER_MIN, SND_PLAYER_MAX);
SDK_MINMAX_ASSERT(chBitMask, 0, 0xffff);
PushCommand(SND_COMMAND_ALLOCATABLE_CHANNEL, playerNo, trackBitMask, chBitMask, 0);
}
void SND_StartTimer (u32 chBitMask, u32 capBitMask, u32 alarmBitMask, u32 flags) {
PushCommand(SND_COMMAND_START_TIMER, chBitMask, capBitMask, alarmBitMask, flags);
}
void SND_StopTimer (u32 chBitMask, u32 capBitMask, u32 alarmBitMask, u32 flags) {
int alarmNo;
u32 mask = alarmBitMask;
for (alarmNo = 0; alarmNo < SND_ALARM_NUM && mask != 0; alarmNo++, mask >>= 1) {
if ((mask & 0x01) == 0) {
continue;
}
SNDi_IncAlarmId(alarmNo);
}
PushCommand(SND_COMMAND_STOP_TIMER, chBitMask, capBitMask, alarmBitMask, flags);
}
void SND_SetupCapture (SNDCapture capture, SNDCaptureFormat format, void * buffer_p, u32 length, BOOL loopFlag, SNDCaptureIn in, SNDCaptureOut out) {
PushCommand(
SND_COMMAND_SETUP_CAPTURE,
buffer_p,
length, capture << 31 | format << 30 | loopFlag << 29 | in << 28 | out << 27, 0
);
}
void SND_SetupAlarm (int alarmNo, u32 tick, u32 period, SNDAlarmHandler handler, void * arg) {
u8 id = SNDi_SetAlarmHandler(
alarmNo,
handler,
arg
);
PushCommand(SND_COMMAND_SETUP_ALARM, alarmNo, tick, period, id);
}
void SND_SetTrackMute (int playerNo, u32 trackBitMask, BOOL flag) {
PushCommand(
SND_COMMAND_MUTE_TRACK, playerNo, trackBitMask,
flag ? SND_SEQ_MUTE_STOP : SND_SEQ_MUTE_OFF, 0
);
}
void SND_SetTrackMuteEx (int playerNo, u32 trackBitMask, SNDSeqMute mute) {
PushCommand(SND_COMMAND_MUTE_TRACK, playerNo, trackBitMask, mute, 0);
}
void SND_StopUnlockedChannel (u32 chBitMask, u32 flags) {
PushCommand(SND_COMMAND_STOP_UNLOCKED_CHANNEL, chBitMask, flags, 0, 0);
}
void SND_LockChannel (u32 chBitMask, u32 flags) {
PushCommand(SND_COMMAND_LOCK_CHANNEL, chBitMask, flags, 0, 0);
}
void SND_UnlockChannel (u32 chBitMask, u32 flags) {
PushCommand(SND_COMMAND_UNLOCK_CHANNEL, chBitMask, flags, 0, 0);
}
void SND_SetChannelTimer (u32 chBitMask, int timer) {
PushCommand(SND_COMMAND_CHANNEL_TIMER, chBitMask, timer, 0, 0);
}
void SND_SetChannelVolume (u32 chBitMask, int volume, SNDChannelDataShift shift) {
PushCommand(SND_COMMAND_CHANNEL_VOLUME, chBitMask, volume, shift, 0);
}
void SND_SetChannelPan (u32 chBitMask, int pan) {
PushCommand(SND_COMMAND_CHANNEL_PAN, chBitMask, pan, 0, 0);
}
void SND_SetupChannelPcm (int chNo, SNDWaveFormat format, const void * dataaddr, SNDChannelLoop loop, int loopStart, int loopLen, int volume, SNDChannelDataShift shift, int timer, int pan) {
PushCommand(
SND_COMMAND_SETUP_CHANNEL_PCM,
timer << 16 | chNo,
dataaddr,
volume << 24 | shift << 22 | loopLen,
loop << 26 | format << 24 | pan << 16 | loopStart
);
}
void SND_SetupChannelPsg (int chNo, SNDDuty duty, int volume, SNDChannelDataShift shift, int timer, int pan) {
PushCommand(SND_COMMAND_SETUP_CHANNEL_PSG, chNo, shift << 8 | volume, timer << 8 | pan, duty);
}
void SND_SetupChannelNoise (int chNo, int volume, SNDChannelDataShift shift, int timer, int pan) {
PushCommand(SND_COMMAND_SETUP_CHANNEL_NOISE, chNo, shift << 8 | volume, timer << 8 | pan, 0);
}
void SND_InvalidateSeqData (const void * start, const void * end) {
PushCommand(SND_COMMAND_INVALIDATE_SEQ, start, end, 0, 0);
}
void SND_InvalidateBankData (const void * start, const void * end) {
PushCommand(SND_COMMAND_INVALIDATE_BANK, start, end, 0, 0);
}
void SND_InvalidateWaveData (const void * start, const void * end) {
PushCommand(SND_COMMAND_INVALIDATE_WAVE, start, end, 0, 0);
}
void SND_SetMasterVolume (int volume) {
PushCommand(SND_COMMAND_MASTER_VOLUME, volume, 0, 0, 0);
}
void SND_SetOutputSelector (SNDOutput left, SNDOutput right, SNDChannelOut channel1, SNDChannelOut channel3) {
PushCommand(SND_COMMAND_OUTPUT_SELECTOR, left, right, channel1, channel3);
}
void SND_SetMasterPan (int pan) {
SDK_MINMAX_ASSERT(pan, SND_CHANNEL_PAN_MIN, SND_CHANNEL_PAN_MAX);
PushCommand(SND_COMMAND_MASTER_PAN, pan, 0, 0, 0);
}
void SND_ResetMasterPan (void) {
PushCommand(SND_COMMAND_MASTER_PAN, -1, 0, 0, 0);
}
void SND_ReadDriverInfo (struct SNDDriverInfo * info) {
PushCommand(SND_COMMAND_READ_DRIVER_INFO, info, 0, 0, 0);
}
void SNDi_SetPlayerParam (int playerNo, u32 offset, u32 data, int size) {
PushCommand(SND_COMMAND_PLAYER_PARAM, playerNo, offset, data, size);
}
void SNDi_SetTrackParam (int playerNo, u32 trackBitMask, u32 offset, u32 data, int size) {
PushCommand(SND_COMMAND_TRACK_PARAM, size << 24 | playerNo, trackBitMask, offset, data);
}
void SNDi_SetSurroundDecay (int decay) {
PushCommand(SND_COMMAND_SURROUND_DECAY, decay, 0, 0, 0);
}
void SNDi_SkipSeq (int playerNo, u32 tick) {
SDK_MINMAX_ASSERT(playerNo, SND_PLAYER_MIN, SND_PLAYER_MAX);
PushCommand(SND_COMMAND_SKIP_SEQ, playerNo, tick, 0, 0);
}
static void PushCommand_impl (SNDCommandID id, u32 arg0, u32 arg1, u32 arg2, u32 arg3) {
SNDCommand * command = SND_AllocCommand(SND_COMMAND_BLOCK);
if (command == NULL) {
return;
}
command->id = id;
command->arg[0] = arg0;
command->arg[1] = arg1;
command->arg[2] = arg2;
command->arg[3] = arg3;
SND_PushCommand(command);
}

184
lib/NitroSDK/src/snd/snd_main.c Normal file
View File

@ -0,0 +1,184 @@
#include <nitro/snd/common/main.h>
#include <nitro/os.h>
#include <nitro/snd/common/global.h>
#include <nitro/snd/common/exchannel.h>
#include <nitro/snd/common/seq.h>
#include <nitro/snd/common/alarm.h>
#include <nitro/snd/common/command.h>
#include <nitro/snd/common/util.h>
#include <nitro/snd/common/work.h>
#ifdef SDK_ARM7
#define SND_THREAD_STACK_SIZE 1024
#define SND_THREAD_MESSAGE_BUFSIZE 8
#define SND_ALARM_COUNT_P1 0x10000
#endif
#ifdef SDK_ARM9
static OSMutex sSndMutex;
#else
static OSThread sndThread;
static u64 sndStack[SND_THREAD_STACK_SIZE / sizeof(u64)];
static OSAlarm sndAlarm;
static OSMessageQueue sndMesgQueue;
static OSMessage sndMesgBuffer[SND_THREAD_MESSAGE_BUFSIZE];
#endif
#ifdef SDK_ARM7
static void SndThread(void * arg);
static void SndAlarmCallback(void * arg);
#endif
#ifdef SDK_ARM9
void SND_Init (void) {
{
static BOOL initialized = FALSE;
if (initialized) {
return;
}
initialized = TRUE;
}
OS_InitMutex(&sSndMutex);
SND_CommandInit();
SND_AlarmInit();
}
#else
void SND_Init (u32 threadPrio) {
{
static BOOL initialized = FALSE;
if (initialized) {
return;
}
initialized = TRUE;
}
SND_CommandInit();
SND_CreateThread(threadPrio);
}
void SND_CreateThread (u32 threadPrio) {
OS_CreateThread(
&sndThread,
SndThread,
NULL,
sndStack + SND_THREAD_STACK_SIZE / sizeof(u64),
SND_THREAD_STACK_SIZE, threadPrio
);
OS_WakeupThreadDirect(&sndThread);
}
BOOL SND_SetThreadPriority (u32 prio) {
return OS_SetThreadPriority(&sndThread, prio);
}
void SND_InitIntervalTimer (void) {
OS_InitMessageQueue(&sndMesgQueue, sndMesgBuffer, SND_THREAD_MESSAGE_BUFSIZE);
OS_CreateAlarm(&sndAlarm);
}
void SND_StartIntervalTimer (void) {
OS_SetPeriodicAlarm(
&sndAlarm,
OS_GetTick() + SND_ALARM_COUNT_P1,
SND_PROC_INTERVAL, &SndAlarmCallback, NULL
);
}
void SND_StopIntervalTimer (void) {
OS_CancelAlarm(&sndAlarm);
}
OSMessage SND_WaitForIntervalTimer (void) {
OSMessage message;
(void)OS_ReceiveMessage(&sndMesgQueue, &message, OS_MESSAGE_BLOCK);
return message;
}
BOOL SND_SendWakeupMessage (void) {
return OS_SendMessage(&sndMesgQueue, (OSMessage)SND_MESSAGE_WAKEUP_THREAD, OS_MESSAGE_NOBLOCK);
}
#endif
void SNDi_LockMutex (void) {
#ifdef SDK_ARM9
OS_LockMutex(&sSndMutex);
#endif
}
void SNDi_UnlockMutex (void) {
#ifdef SDK_ARM9
OS_UnlockMutex(&sSndMutex);
#endif
}
#ifdef SDK_ARM7
static void SndAlarmCallback (void *) {
if (!OS_SendMessage(&sndMesgQueue, (OSMessage)SND_MESSAGE_PERIODIC, OS_MESSAGE_NOBLOCK)) {
OS_PutString("Failed sound alarm OS_SendMessage\n");
}
}
static void SndThread (void *) {
SND_InitIntervalTimer();
SND_ExChannelInit();
SND_SeqInit();
SND_AlarmInit();
SND_Enable();
SND_SetOutputSelector(
SND_OUTPUT_MIXER,
SND_OUTPUT_MIXER, SND_CHANNEL_OUT_MIXER, SND_CHANNEL_OUT_MIXER
);
SND_SetMasterVolume(SND_MASTER_VOLUME_MAX);
SND_StartIntervalTimer();
while (1) {
OSMessage message;
BOOL doPeriodicProc = FALSE;
message = SND_WaitForIntervalTimer();
switch ((u32)message) {
case SND_MESSAGE_PERIODIC:
doPeriodicProc = TRUE;
break;
case SND_MESSAGE_WAKEUP_THREAD:
break;
}
SND_UpdateExChannel();
SND_CommandProc();
SND_SeqMain(doPeriodicProc);
SND_ExChannelMain(doPeriodicProc);
SND_UpdateSharedWork();
(void)SND_CalcRandom();
}
SND_Disable();
SND_StopIntervalTimer();
}
#endif

354
lib/NitroSDK/src/snd/snd_util.c Normal file
View File

@ -0,0 +1,354 @@
#include <nitro/snd/common/util.h>
#include <nitro/snd/common/channel.h>
#ifndef SDK_FROM_TOOL
#include <nitro/os.h>
#endif
#define SND_VOLUME_SHIFT_2_MIN -240
#define SND_VOLUME_SHIFT_1_MIN -120
#define SND_VOLUME_SHIFT_0_MIN -60
#if defined(SDK_TS) && defined(SDK_ARM7)
#define SND_USE_SYSTEM_ROM_TABLE
#endif
#ifndef SND_USE_SYSTEM_ROM_TABLE
static const u16 PitchTable[SND_PITCH_TABLE_SIZE] = {
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 VolumeTable[SND_VOLUME_TABLE_SIZE] = {
0x00,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04,
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x06, 0x06,
0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
0x07, 0x07, 0x07, 0x07, 0x07, 0x08, 0x08, 0x08, 0x08, 0x08,
0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x09, 0x09, 0x09, 0x09,
0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x0a, 0x0a, 0x0a, 0x0a,
0x0a, 0x0a, 0x0a, 0x0a, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
0x0b, 0x0b, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0e, 0x0e, 0x0e, 0x0e,
0x0e, 0x0e, 0x0e, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 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
};
#endif
const s16 SNDi_DecibelTable[SND_DECIBEL_TABLE_SIZE] = {
-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
};
const s16 SNDi_DecibelSquareTable[SND_DECIBEL_SQUARE_TABLE_SIZE] = {
-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
};
#ifdef SDK_ARM7
static const s8 SinTable[SND_SIN_TABLE_SIZE + 1] = {
0, 6, 12, 19, 25, 31, 37, 43,
49, 54, 60, 65, 71, 76, 81, 85,
90, 94, 98, 102, 106, 109, 112, 115,
117, 120, 122, 123, 125, 126, 126, 127,
127
};
#endif
u16 SND_CalcTimer (int base_timer, int pitch_) {
u64 timer;
int shift = 0;
int pitch = -pitch_;
while (pitch < 0) {
shift--;
pitch += SND_PITCH_TABLE_SIZE;
}
while (pitch >= SND_PITCH_TABLE_SIZE) {
shift++;
pitch -= SND_PITCH_TABLE_SIZE;
}
#ifdef SND_USE_SYSTEM_ROM_TABLE
timer = SVC_GetPitchTable(pitch);
#else
timer = PitchTable[pitch];
#endif
timer += SND_PITCH_TABLE_BIAS;
timer *= base_timer;
shift -= SND_PITCH_TABLE_SHIFT;
if (shift <= 0) {
timer >>= -shift;
} else if (shift < 32) {
const u64 mask = (0xffffffffffffffff << (32 - shift));
if (timer & mask) {
return SND_CHANNEL_TIMER_MAX;
} else {
timer <<= shift;
}
} else {
return SND_CHANNEL_TIMER_MAX;
}
if (timer < SND_CHANNEL_TIMER_MIN) {
timer = SND_CHANNEL_TIMER_MIN;
} else if (timer > SND_CHANNEL_TIMER_MAX) {
timer = SND_CHANNEL_TIMER_MAX;
}
return (u16)timer;
}
u16 SND_CalcChannelVolume (int dB) {
SNDChannelDataShift shift;
u8 volume;
if (dB < SND_VOLUME_DB_MIN) {
dB = SND_VOLUME_DB_MIN;
} else if (dB > SND_VOLUME_DB_MAX) {
dB = SND_VOLUME_DB_MAX;
}
#ifdef SND_USE_SYSTEM_ROM_TABLE
volume = SVC_GetVolumeTable(dB - SND_VOLUME_DB_MIN);
#else
volume = VolumeTable[dB - SND_VOLUME_DB_MIN];
#endif
if (dB < SND_VOLUME_SHIFT_2_MIN) {
shift = SND_CHANNEL_DATASHIFT_4BIT;
} else if (dB < SND_VOLUME_SHIFT_1_MIN) {
shift = SND_CHANNEL_DATASHIFT_2BIT;
} else if (dB < SND_VOLUME_SHIFT_0_MIN) {
shift = SND_CHANNEL_DATASHIFT_1BIT;
} else {
shift = SND_CHANNEL_DATASHIFT_NONE;
}
return (u16)(shift << 8 | volume);
}
#ifdef SDK_ARM7
s8 SND_SinIdx (int index) {
SDK_MINMAX_ASSERT(index, 0, SND_SIN_PERIOD - 1);
if (index < SND_SIN_TABLE_SIZE) {
return SinTable[index];
}
if (index < SND_SIN_TABLE_SIZE * 2) {
return SinTable[SND_SIN_TABLE_SIZE - (index - SND_SIN_TABLE_SIZE)];
}
if (index < SND_SIN_TABLE_SIZE * 3) {
return (s8)(-SinTable[index - SND_SIN_TABLE_SIZE * 2]);
}
return (s8)(-SinTable[SND_SIN_TABLE_SIZE - (index - SND_SIN_TABLE_SIZE * 3)]);
}
u16 SND_CalcRandom (void) {
static u32 u = 0x12345678;
u = u * 1664525 + 1013904223;
return (u16)(u >> 16);
}
#endif

393
lib/NitroSDK/src/snd/snd_work.c Normal file
View File

@ -0,0 +1,393 @@
#include <nitro/snd/common/work.h>
#ifndef SDK_FROM_TOOL
#else
#define REG_SND_SOUND0CNT_E_SHIFT 31
#define REG_SND_SOUND0CNT_E_SIZE 1
#define REG_SND_SOUND0CNT_E_MASK 0x80000000
#define REG_SND_SOUND0CNT_FORMAT_SHIFT 29
#define REG_SND_SOUND0CNT_FORMAT_SIZE 2
#define REG_SND_SOUND0CNT_FORMAT_MASK 0x60000000
#define REG_SND_SOUND0CNT_REPEAT_SHIFT 27
#define REG_SND_SOUND0CNT_REPEAT_SIZE 2
#define REG_SND_SOUND0CNT_REPEAT_MASK 0x18000000
#define REG_SND_SOUND0CNT_DUTY_SHIFT 24
#define REG_SND_SOUND0CNT_DUTY_SIZE 3
#define REG_SND_SOUND0CNT_DUTY_MASK 0x07000000
#define REG_SND_SOUND0CNT_PAN_SHIFT 16
#define REG_SND_SOUND0CNT_PAN_SIZE 7
#define REG_SND_SOUND0CNT_PAN_MASK 0x007f0000
#define REG_SND_SOUND0CNT_HOLD_SHIFT 15
#define REG_SND_SOUND0CNT_HOLD_SIZE 1
#define REG_SND_SOUND0CNT_HOLD_MASK 0x00008000
#define REG_SND_SOUND0CNT_SHIFT_SHIFT 8
#define REG_SND_SOUND0CNT_SHIFT_SIZE 2
#define REG_SND_SOUND0CNT_SHIFT_MASK 0x00000300
#define REG_SND_SOUND0CNT_VOLUME_SHIFT 0
#define REG_SND_SOUND0CNT_VOLUME_SIZE 7
#define REG_SND_SOUND0CNT_VOLUME_MASK 0x0000007f
#define SDK_ASSERT(exp) ((void)0)
#define SDK_NULL_ASSERT(exp) ((void)0)
#define SDK_MINMAX_ASSERT(exp, min, max) ((void)0)
#endif
SNDSharedWork * SNDi_SharedWork;
#ifdef SDK_ARM7
SNDWork SNDi_Work;
#endif
static const void * ConvAddr(const void * p, const void * baseFrom, const void * baseTo);
#ifndef _MSC_VER
static inline
#else
__inline
#endif
const void * ConvAddr (const void * p, const void * baseFrom, const void * baseTo) {
if (p == NULL) {
return NULL;
}
return (const char *)baseTo + ((const char *)p - (const char *)baseFrom);
}
u32 SND_GetPlayerStatus (void) {
SDK_NULL_ASSERT(SNDi_SharedWork);
#ifdef SDK_ARM9
DC_InvalidateRange(
(void *)&SNDi_SharedWork->playerStatus,
sizeof(SNDi_SharedWork->playerStatus)
);
#endif
return SNDi_SharedWork->playerStatus;
}
u32 SND_GetChannelStatus (void) {
SDK_NULL_ASSERT(SNDi_SharedWork);
#ifdef SDK_ARM9
DC_InvalidateRange(
(void *)&SNDi_SharedWork->channelStatus,
sizeof(SNDi_SharedWork->channelStatus)
);
#endif
return SNDi_SharedWork->channelStatus;
}
u32 SND_GetCaptureStatus (void) {
SDK_NULL_ASSERT(SNDi_SharedWork);
#ifdef SDK_ARM9
DC_InvalidateRange(
(void *)&SNDi_SharedWork->captureStatus,
sizeof(SNDi_SharedWork->captureStatus)
);
#endif
return SNDi_SharedWork->captureStatus;
}
u32 SND_GetPlayerTickCounter (int playerNo) {
SDK_NULL_ASSERT(SNDi_SharedWork);
SDK_MINMAX_ASSERT(playerNo, SND_PLAYER_MIN, SND_PLAYER_MAX);
#ifdef SDK_ARM9
DC_InvalidateRange(
(void *)&SNDi_SharedWork->player[playerNo].tickCounter,
sizeof(SNDi_SharedWork->player[playerNo].tickCounter)
);
#endif
return SNDi_SharedWork->player[playerNo].tickCounter;
}
s16 SND_GetPlayerLocalVariable (int playerNo, int varNo) {
SDK_NULL_ASSERT(SNDi_SharedWork);
SDK_MINMAX_ASSERT(playerNo, SND_PLAYER_MIN, SND_PLAYER_MAX);
SDK_MINMAX_ASSERT(varNo, 0, SND_PLAYER_VARIABLE_NUM - 1);
#ifdef SDK_ARM9
DC_InvalidateRange(
(void *)&SNDi_SharedWork->player[playerNo].variable[varNo],
sizeof(SNDi_SharedWork->player[playerNo].variable[varNo])
);
#endif
return SNDi_SharedWork->player[playerNo].variable[varNo];
}
s16 SND_GetPlayerGlobalVariable (int varNo) {
SDK_NULL_ASSERT(SNDi_SharedWork);
SDK_MINMAX_ASSERT(varNo, 0, SND_GLOBAL_VARIABLE_NUM - 1);
#ifdef SDK_ARM9
DC_InvalidateRange(
(void *)&SNDi_SharedWork->globalVariable[varNo],
sizeof(SNDi_SharedWork->globalVariable[varNo])
);
#endif
return SNDi_SharedWork->globalVariable[varNo];
}
BOOL SND_ReadChannelInfo (const SNDDriverInfo * driverInfo, int chNo, SNDChannelInfo * chInfo) {
u32 lockedChannel;
SDK_NULL_ASSERT(driverInfo);
SDK_NULL_ASSERT(chInfo);
if (chNo < SND_CHANNEL_MIN || SND_CHANNEL_MAX < chNo) {
return FALSE;
}
lockedChannel = driverInfo->lockedChannels;
chInfo->lockFlag = (lockedChannel & (1 << chNo)) ? TRUE : FALSE;
if (chInfo->lockFlag) {
const u32 chCtrl = driverInfo->chCtrl[chNo];
chInfo->activeFlag = (chCtrl & REG_SND_SOUND0CNT_E_MASK) ? TRUE : FALSE;
{
const u8 volume =
(u8)((chCtrl & REG_SND_SOUND0CNT_VOLUME_MASK) >> REG_SND_SOUND0CNT_VOLUME_SHIFT);
const SNDChannelDataShift shift =
(SNDChannelDataShift)((chCtrl & REG_SND_SOUND0CNT_SHIFT_MASK) >>
REG_SND_SOUND0CNT_SHIFT_SHIFT);
chInfo->volume = volume;
chInfo->volume <<= 4;
switch (shift) {
case SND_CHANNEL_DATASHIFT_NONE:
break;
case SND_CHANNEL_DATASHIFT_1BIT:
chInfo->volume >>= 1;
break;
case SND_CHANNEL_DATASHIFT_2BIT:
chInfo->volume >>= 2;
break;
case SND_CHANNEL_DATASHIFT_4BIT:
chInfo->volume >>= 4;
break;
}
}
chInfo->pan = (u8)((chCtrl & REG_SND_SOUND0CNT_PAN_MASK) >> REG_SND_SOUND0CNT_PAN_SHIFT);
} else {
const SNDExChannel * chp = &driverInfo->work.channel[chNo];
SDK_NULL_ASSERT(chp);
chInfo->activeFlag = chp->active_flag;
chInfo->envStatus = (SNDEnvStatus)(chp->env_status);
{
const u8 volume = (u8)(chp->volume & 0xff);
const SNDChannelDataShift shift = (SNDChannelDataShift)(chp->volume >> 8);
chInfo->volume = volume;
chInfo->volume <<= 4;
switch (shift) {
case SND_CHANNEL_DATASHIFT_NONE:
break;
case SND_CHANNEL_DATASHIFT_1BIT:
chInfo->volume >>= 1;
break;
case SND_CHANNEL_DATASHIFT_2BIT:
chInfo->volume >>= 2;
break;
case SND_CHANNEL_DATASHIFT_4BIT:
chInfo->volume >>= 4;
break;
}
}
chInfo->pan = chp->pan;
}
return TRUE;
}
BOOL SND_ReadPlayerInfo (const SNDDriverInfo * driverInfo, int playerNo, SNDPlayerInfo * playerInfo) {
const SNDPlayer * player;
int trackNo;
SDK_NULL_ASSERT(driverInfo);
SDK_NULL_ASSERT(playerInfo);
if (playerNo < SND_PLAYER_MIN || SND_PLAYER_MAX < playerNo) {
return FALSE;
}
player = &driverInfo->work.player[playerNo];
SDK_NULL_ASSERT(player);
playerInfo->trackBitMask = 0;
for (trackNo = 0; trackNo < SND_TRACK_NUM_PER_PLAYER; trackNo++) {
if (player->tracks[trackNo] != SND_INVALID_TRACK_INDEX) {
playerInfo->trackBitMask |= (1 << trackNo);
}
}
playerInfo->activeFlag = player->active_flag;
playerInfo->pauseFlag = player->pause_flag;
playerInfo->tempo = player->tempo;
playerInfo->volume = player->volume;
return TRUE;
}
BOOL SND_ReadTrackInfo (const SNDDriverInfo * driverInfo, int playerNo, int trackNo, SNDTrackInfo * trackInfo) {
const SNDPlayer * player;
const SNDTrack * track;
u8 trackID;
SDK_NULL_ASSERT(driverInfo);
SDK_NULL_ASSERT(trackInfo);
if (playerNo < SND_PLAYER_MIN || SND_PLAYER_MAX < playerNo) {
return FALSE;
}
if (trackNo < 0 || SND_TRACK_NUM_PER_PLAYER - 1 < trackNo) {
return FALSE;
}
player = &driverInfo->work.player[playerNo];
SDK_NULL_ASSERT(player);
trackID = player->tracks[trackNo];
if (trackID == SND_INVALID_TRACK_INDEX) {
return FALSE;
}
track = &driverInfo->work.track[trackID];
SDK_NULL_ASSERT(track);
trackInfo->prgNo = track->prgNo;
trackInfo->volume = track->volume;
trackInfo->volume2 = track->volume2;
trackInfo->pitchBend = track->pitch_bend;
trackInfo->bendRange = track->bend_range;
trackInfo->pan = (u8)(track->pan + SND_CHANNEL_PAN_CENTER);
trackInfo->transpose = track->transpose;
{
const SNDExChannel * chp =
(const SNDExChannel *)ConvAddr(
track->channel_list, driverInfo->workAddress,
&driverInfo->work
);
trackInfo->chCount = 0;
while (chp != NULL) {
trackInfo->channel[trackInfo->chCount] = chp->myNo;
trackInfo->chCount++;
chp =
(const SNDExChannel *)ConvAddr(
chp->nextLink, driverInfo->workAddress,
&driverInfo->work
);
}
}
return TRUE;
}
#ifdef SDK_ARM7
void SND_SetPlayerLocalVariable (int playerNo, int varNo, s16 var) {
SDK_NULL_ASSERT(SNDi_SharedWork);
SDK_MINMAX_ASSERT(playerNo, SND_PLAYER_MIN, SND_PLAYER_MAX);
SDK_MINMAX_ASSERT(varNo, 0, SND_PLAYER_VARIABLE_NUM - 1);
SNDi_SharedWork->player[playerNo].variable[varNo] = var;
}
void SND_SetPlayerGlobalVariable (int varNo, s16 var) {
SDK_NULL_ASSERT(SNDi_SharedWork);
SDK_MINMAX_ASSERT(varNo, 0, SND_GLOBAL_VARIABLE_NUM - 1);
SNDi_SharedWork->globalVariable[varNo] = var;
}
void SND_UpdateSharedWork (void) {
u16 channelStatus = 0;
u16 captureStatus = 0;
int chNo;
if (SNDi_SharedWork == NULL) {
return;
}
for (chNo = 0; chNo < SND_CHANNEL_NUM; chNo++) {
if (SND_IsChannelActive(chNo)) {
channelStatus |= (1 << chNo);
}
}
if (SND_IsCaptureActive(SND_CAPTURE_0)) {
captureStatus |= (1 << 0);
}
if (SND_IsCaptureActive(SND_CAPTURE_1)) {
captureStatus |= (1 << 1);
}
SNDi_SharedWork->channelStatus = channelStatus;
SNDi_SharedWork->captureStatus = captureStatus;
}
#endif
u32 SNDi_GetFinishedCommandTag (void) {
SDK_NULL_ASSERT(SNDi_SharedWork);
#ifdef SDK_ARM9
DC_InvalidateRange(
(void *)&SNDi_SharedWork->finishCommandTag,
sizeof(SNDi_SharedWork->finishCommandTag)
);
#endif
return SNDi_SharedWork->finishCommandTag;
}
#ifdef SDK_ARM9
void SNDi_InitSharedWork (SNDSharedWork * work) {
int playerNo, variableNo;
work->playerStatus = 0;
work->channelStatus = 0;
work->captureStatus = 0;
work->finishCommandTag = 0;
for (playerNo = 0; playerNo < SND_PLAYER_NUM; playerNo++) {
work->player[playerNo].tickCounter = 0;
for (variableNo = 0; variableNo < SND_PLAYER_VARIABLE_NUM; variableNo++) {
work->player[playerNo].variable[variableNo] = SND_DEFAULT_VARIABLE;
}
}
for (variableNo = 0; variableNo < SND_GLOBAL_VARIABLE_NUM; variableNo++) {
work->globalVariable[variableNo] = SND_DEFAULT_VARIABLE;
}
DC_FlushRange(work, sizeof(SNDSharedWork));
}
#endif

14
main.lsf
View File

@ -515,13 +515,13 @@ Static main
Object lib/NitroSDK/src/mi/mi_uncompress.o
Object lib/NitroSDK/src/mi/mi_dma_card.o
Object lib/NitroSDK/src/mi/mi_init.o
Object lib/NitroSDK/asm/snd/snd_interface.o
Object lib/NitroSDK/asm/snd/snd_main.o
Object lib/NitroSDK/asm/snd/snd_command.o
Object lib/NitroSDK/asm/snd/snd_alarm.o
Object lib/NitroSDK/asm/snd/snd_work.o
Object lib/NitroSDK/asm/snd/snd_util.o
Object lib/NitroSDK/asm/snd/snd_bank.o
Object lib/NitroSDK/src/snd/snd_interface.o
Object lib/NitroSDK/src/snd/snd_main.o
Object lib/NitroSDK/src/snd/snd_command.o
Object lib/NitroSDK/src/snd/snd_alarm.o
Object lib/NitroSDK/src/snd/snd_work.o
Object lib/NitroSDK/src/snd/snd_util.o
Object lib/NitroSDK/src/snd/snd_bank.o
Object lib/NitroSDK/src/pxi/pxi_init.o
Object lib/NitroSDK/src/pxi/pxi_fifo.o
Object lib/NitroSDK/src/fs/fs_command.o