From 783014e53254fe17102a34c30120eeabf5227a47 Mon Sep 17 00:00:00 2001 From: spicyjpeg Date: Wed, 19 Oct 2022 14:15:28 +0200 Subject: Clean up SDK debug logging, fix getTPage() --- libpsn00b/psxspu/common.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'libpsn00b/psxspu/common.c') diff --git a/libpsn00b/psxspu/common.c b/libpsn00b/psxspu/common.c index 7d90858..42f7cb7 100644 --- a/libpsn00b/psxspu/common.c +++ b/libpsn00b/psxspu/common.c @@ -4,7 +4,7 @@ */ #include -#include +#include #include #include @@ -25,16 +25,16 @@ static void _wait_status(uint16_t mask, uint16_t value) { return; } - _sdk_log("psxspu: status register timeout (0x%04x)\n", SPU_STAT); + _sdk_log("status register timeout (0x%04x)\n", SPU_STAT); } static void _dma_transfer(uint32_t *data, size_t length, int write) { if (length % 4) - _sdk_log("psxspu: can't transfer a number of bytes that isn't multiple of 4\n"); + _sdk_log("can't transfer a number of bytes that isn't multiple of 4\n"); length /= 4; if ((length >= DMA_CHUNK_LENGTH) && (length % DMA_CHUNK_LENGTH)) { - _sdk_log("psxspu: transfer data length (%d) is not a multiple of %d, rounding\n", length, DMA_CHUNK_LENGTH); + _sdk_log("transfer data length (%d) is not a multiple of %d, rounding\n", length, DMA_CHUNK_LENGTH); length += DMA_CHUNK_LENGTH - 1; } -- cgit v1.2.3 From 5f25c0bf306d316c87fca9d3fe160d6661be230d Mon Sep 17 00:00:00 2001 From: spicyjpeg Date: Sun, 23 Oct 2022 15:03:16 +0200 Subject: Library bugfixes and additions, _sdk_log_inner() removal --- libpsn00b/include/assert.h | 7 ++- libpsn00b/include/psxsio.h | 14 +++-- libpsn00b/include/psxspu.h | 22 +++++-- libpsn00b/libc/_start.s | 17 +++++ libpsn00b/libc/_stubs.s | 27 -------- libpsn00b/libc/abort.c | 8 ++- libpsn00b/psxpress/vlc.s | 152 ++++++++++++++++++--------------------------- libpsn00b/psxsio/sio.c | 16 +++-- libpsn00b/psxspu/common.c | 9 ++- 9 files changed, 131 insertions(+), 141 deletions(-) create mode 100644 libpsn00b/libc/_start.s delete mode 100644 libpsn00b/libc/_stubs.s (limited to 'libpsn00b/psxspu/common.c') diff --git a/libpsn00b/include/assert.h b/libpsn00b/include/assert.h index e93c983..12212af 100644 --- a/libpsn00b/include/assert.h +++ b/libpsn00b/include/assert.h @@ -9,8 +9,9 @@ #ifndef __ASSERT_H #define __ASSERT_H +#include + void _assert_abort(const char *file, int line, const char *expr); -void _sdk_log_inner(const char *fmt, ...); #ifdef NDEBUG @@ -24,9 +25,9 @@ void _sdk_log_inner(const char *fmt, ...); } #ifdef SDK_LIBRARY_NAME -#define _sdk_log(fmt, ...) _sdk_log_inner(SDK_LIBRARY_NAME ": " fmt, ##__VA_ARGS__) +#define _sdk_log(fmt, ...) printf(SDK_LIBRARY_NAME ": " fmt, ##__VA_ARGS__) #else -#define _sdk_log(fmt, ...) _sdk_log_inner(fmt, ##__VA_ARGS__) +#define _sdk_log(fmt, ...) printf(fmt, ##__VA_ARGS__) #endif #endif diff --git a/libpsn00b/include/psxsio.h b/libpsn00b/include/psxsio.h index e0cc49b..d5f7d9a 100644 --- a/libpsn00b/include/psxsio.h +++ b/libpsn00b/include/psxsio.h @@ -145,15 +145,19 @@ int SIO_ReadSync(int mode); /** * @brief Registers a function to be called whenever a byte is received. The - * received byte is appended to the RX buffer and passed as an argument to the - * callback. The callback will run in the exception handler's context, so it - * should be as fast as possible and not use any function that relies on - * interrupts in order to work. + * received byte is passed as an argument to the callback, which shall then + * return a zero value to also store the byte in the RX buffer or a non-zero + * value to drop it. This can be used to e.g. filter or validate incoming data, + * or to bypass the library's RX buffer for custom buffering purposes. + * + * The callback will run in the exception handler's context, so it should be as + * fast as possible and shall not call any function that relies on interrupts + * being enabled. * * @param func * @return Previously set callback or NULL */ -void *SIO_ReadCallback(void (*func)(uint8_t)); +void *SIO_ReadCallback(int (*func)(uint8_t)); /** * @brief Sends the given byte, or appends it to the TX buffer if the serial diff --git a/libpsn00b/include/psxspu.h b/libpsn00b/include/psxspu.h index cf78e3d..7858e88 100644 --- a/libpsn00b/include/psxspu.h +++ b/libpsn00b/include/psxspu.h @@ -73,6 +73,20 @@ typedef struct _SpuCommonAttr { SpuExtAttr cd, ext; } SpuCommonAttr; +/* Macros */ + +#define getSPUAddr(addr) ((uint16_t) (((addr) + 7) / 8)) +#define getSPUSampleRate(rate) ((uint16_t) (((rate) * (1 << 12)) / 44100)) + +#define getSPUADSR(ar, dr, sr, rr, sl) ( \ + (sl) | \ + ((dr) << 4) | \ + ((ar) << 8) | \ + ((rr) << 16) | \ + ((sr) << 22) | \ + (1 << 30) \ +) + /* "Useless" macros for official SDK compatibility */ #define SpuSetCommonMasterVolume(left, right) \ @@ -87,18 +101,18 @@ typedef struct _SpuCommonAttr { ((enable) ? (SPU_CTRL |= 0x0002) : (SPU_CTRL &= 0xfffd)) #define SpuSetReverbAddr(addr) \ - (SPU_REVERB_ADDR = ((addr) + 7) / 8) + (SPU_REVERB_ADDR = getSPUAddr(addr)) #define SpuSetIRQAddr(addr) \ - (SPU_IRQ_ADDR = ((addr) + 7) / 8) + (SPU_IRQ_ADDR = getSPUAddr(addr)) #define SpuSetVoiceVolume(ch, left, right) \ (SPU_CH_VOL_L(ch) = (left), SPU_CH_VOL_R(ch) = (right)) #define SpuSetVoicePitch(ch, pitch) \ (SPU_CH_FREQ(ch) = (pitch)) #define SpuSetVoiceStartAddr(ch, addr) \ - (SPU_CH_ADDR(ch) = ((addr) + 7) / 8) + (SPU_CH_ADDR(ch) = getSPUAddr(addr)) #define SpuSetVoiceADSR(ch, ar, dr, sr, rr, sl) \ - (SPU_CH_ADSR(ch) = ((sl)) | ((dr) << 4) | ((ar) << 8) | ((rr) << 16) | ((sr) << 22) | (1 << 30)) + (SPU_CH_ADSR(ch) = getSPUADSR(ar, dr, sr, rr, sl)) #define SpuSetKey(enable, voice_bit) \ ((enable) ? (SPU_KEY_ON = (voice_bit)) : (SPU_KEY_OFF = (voice_bit))) diff --git a/libpsn00b/libc/_start.s b/libpsn00b/libc/_start.s new file mode 100644 index 0000000..fcd4c4c --- /dev/null +++ b/libpsn00b/libc/_start.s @@ -0,0 +1,17 @@ +# PSn00bSDK _start() trampoline +# (C) 2022 spicyjpeg - MPL licensed +# +# This file provides a weak function that can be easily overridden to e.g. set +# $sp or perform additional initialization before the "real" _start() function +# (_start_inner()) is called. + +.set noreorder + +.section .text._start +.global _start +.type _start, @function +.weak _start +_start: + la $gp, _gp + j _start_inner + nop diff --git a/libpsn00b/libc/_stubs.s b/libpsn00b/libc/_stubs.s deleted file mode 100644 index aa7bfbe..0000000 --- a/libpsn00b/libc/_stubs.s +++ /dev/null @@ -1,27 +0,0 @@ -# PSn00bSDK _start() trampoline and logging endpoint -# (C) 2022 spicyjpeg - MPL licensed -# -# This file provides a weak function that can be easily overridden to e.g. set -# $sp or perform additional initialization before the "real" _start() function -# (_start_inner()) is called. The _sdk_log_inner() function called by other -# libraries to log debug messages can also be overridden in a similar way. - -.set noreorder - -.section .text._start -.global _start -.type _start, @function -.weak _start -_start: - la $gp, _gp - j _start_inner - nop - -.section .text._sdk_log_inner -.global _sdk_log_inner -.type _sdk_log_inner, @function -.weak _sdk_log_inner -_sdk_log_inner: - li $t2, 0xa0 - jr $t2 - li $t1, 0x3f diff --git a/libpsn00b/libc/abort.c b/libpsn00b/libc/abort.c index 9a4661a..0a3c325 100644 --- a/libpsn00b/libc/abort.c +++ b/libpsn00b/libc/abort.c @@ -3,13 +3,15 @@ * (C) 2022 spicyjpeg - MPL licensed */ +#undef SDK_LIBRARY_NAME + #include #include /* Internal function used by assert() macro */ void _assert_abort(const char *file, int line, const char *expr) { - _sdk_log_inner("%s:%d: assert(%s)\n", file, line, expr); + _sdk_log("%s:%d: assert(%s)\n", file, line, expr); for (;;) __asm__ volatile(""); @@ -18,7 +20,7 @@ void _assert_abort(const char *file, int line, const char *expr) { /* Standard abort */ void abort(void) { - _sdk_log_inner("abort()\n"); + _sdk_log("abort()\n"); for (;;) __asm__ volatile(""); @@ -27,7 +29,7 @@ void abort(void) { /* Pure virtual function call (C++) */ void __cxa_pure_virtual(void) { - _sdk_log_inner("__cxa_pure_virtual()\n"); + _sdk_log("__cxa_pure_virtual()\n"); for (;;) __asm__ volatile(""); diff --git a/libpsn00b/psxpress/vlc.s b/libpsn00b/psxpress/vlc.s index 885a3f7..75e33d3 100644 --- a/libpsn00b/psxpress/vlc.s +++ b/libpsn00b/psxpress/vlc.s @@ -29,17 +29,17 @@ .set VLC_Context_block_index, 20 .set VLC_Context_coeff_index, 21 -.set DECDCTSMALLTAB_lut0, 0 -.set DECDCTSMALLTAB_lut2, 4 -.set DECDCTSMALLTAB_lut3, 36 -.set DECDCTSMALLTAB_lut4, 292 -.set DECDCTSMALLTAB_lut5, 308 -.set DECDCTSMALLTAB_lut7, 324 -.set DECDCTSMALLTAB_lut8, 356 -.set DECDCTSMALLTAB_lut9, 420 -.set DECDCTSMALLTAB_lut10, 484 -.set DECDCTSMALLTAB_lut11, 548 -.set DECDCTSMALLTAB_lut12, 612 +.set DECDCTTAB_lut0, 0 +.set DECDCTTAB_lut2, 4 +.set DECDCTTAB_lut3, 36 +.set DECDCTTAB_lut4, 292 +.set DECDCTTAB_lut5, 308 +.set DECDCTTAB_lut7, 324 +.set DECDCTTAB_lut8, 356 +.set DECDCTTAB_lut9, 420 +.set DECDCTTAB_lut10, 484 +.set DECDCTTAB_lut11, 548 +.set DECDCTTAB_lut12, 612 .section .text.DecDCTvlcStart .global DecDCTvlcStart @@ -115,7 +115,7 @@ _vlc_skip_context_load: # Obtain the addresses of the lookup table and jump area in advance so that # they don't have to be retrieved for each coefficient decoded. lw $t8, _vlc_huffman_table - la $t9, .Lac_jump_area + la $t9, .Lac_prefix_10 beqz $a2, .Lstop_processing addiu $a1, 4 # output = (uint16_t *) &output[1] @@ -123,32 +123,32 @@ _vlc_skip_context_load: .Lprocess_next_code_loop: # while (max_size) # This is the "hot" part of the decoder, executed for each code in the # bitstream. The first step is to determine if the next code is a DC or AC - # coefficient. The GTE is also given the task of counting the number of - # leading zeroes/ones, which takes 2 more cycles. + # coefficient. bnez $t7, .Lprocess_ac_coefficient - mtc2 $t0, $30 + addiu $t7, 1 # coeff_index++ bnez $t4, .Lprocess_dc_v3_coefficient - #nop + li $v1, 0x01ff .Lprocess_dc_v2_coefficient: # if (!coeff_index && !is_v3) # The DC coefficient in version 2 frames is not compressed. Value 0x1ff is # used to signal the end of the bitstream. srl $v0, $t0, 22 # prefix = (window >> (32 - 10)) - li $v1, 0x01ff beq $v0, $v1, .Lstop_processing # if (prefix == 0x1ff) break or $v0, $t3 # *output = prefix | quant_scale sll $t0, 10 # window <<= 10 - addiu $t5, -10 # bit_offset -= 10 b .Lwrite_value - addiu $t7, 1 # coeff_index++ + addiu $t5, -10 # bit_offset -= 10 .Lprocess_dc_v3_coefficient: # if (!coeff_index && is_v3) # TODO: version 3 is currently not supported. jr $ra li $v0, -1 - #b .Lwrite_value .Lprocess_ac_coefficient: # if (coeff_index) + # Start counting the number of leading zeroes/ones using the GTE. This + # takes 2 more cycles. + mtc2 $t0, $30 + # Check whether the prefix code is one of the shorter, more common ones. srl $v0, $t0, 30 li $v1, 3 @@ -157,33 +157,34 @@ _vlc_skip_context_load: beq $v0, $v1, .Lac_prefix_10 li $v1, 1 beq $v0, $v1, .Lac_prefix_01 - #srl $v0, $t0, 29 - #beq $v0, $v1, .Lac_prefix_001 - #nop + nop # If the code is longer, retrieve the number of leading zeroes from the GTE # and use it as an index into the jump area. Each block in the area is 8 # instructions long and handles decoding a specific prefix. mfc2 $v0, $31 - nop - andi $v0, 15 # jump_addr = &ac_jump_area[(prefix % 16) * 8 * sizeof(u32)] - sll $v0, 5 + li $v1, 11 + bgt $v0, $v1, .Lreturn_error # if (prefix > 11) return -1 + sll $v0, 5 # jump_addr = &ac_jump_area[prefix * 8 * sizeof(u32)] addu $v0, $t9 jr $v0 nop +.Lreturn_error: + jr $ra + li $v0, -1 + .Lac_prefix_11: # Prefix 11 is followed by a single bit. srl $v0, $t0, 28 # index = ((window >> (32 - 2 - 1)) & 1) * sizeof(u16) andi $v0, 2 addu $v0, $t8 # value = table->lut0[index] - lhu $v0, DECDCTSMALLTAB_lut0($v0) + lhu $v0, DECDCTTAB_lut0($v0) sll $t0, 3 # window <<= 3 - addiu $t5, -3 # bit_offset -= 3 b .Lwrite_value - addiu $t7, 1 # coeff_index++ + addiu $t5, -3 # bit_offset -= 3 + #.word 0 -.Lac_jump_area: .Lac_prefix_10: # Prefix 10 marks the end of a block. li $v0, 0xfe00 # value = 0xfe00 @@ -202,11 +203,10 @@ _vlc_skip_context_load: srl $v0, $t0, 25 # index = ((window >> (32 - 2 - 3)) & 7) * sizeof(u32) andi $v0, 28 addu $v0, $t8 # value = table->lut2[index] - lw $v0, DECDCTSMALLTAB_lut2($v0) - addiu $t7, 1 # coeff_index++ + lw $v0, DECDCTTAB_lut2($v0) b .Lupdate_window_and_write srl $v1, $v0, 16 # length = value >> 16 - .word 0 + .word 0, 0 .Lac_prefix_001: # Prefix 001 can be followed by a 6-bit lookup index starting with 00, or a @@ -214,136 +214,106 @@ _vlc_skip_context_load: srl $v0, $t0, 21 # index = ((window >> (32 - 3 - 6)) & 63) * sizeof(u32) andi $v0, 252 addu $v0, $t8 # value = table->lut3[index] - lw $v0, DECDCTSMALLTAB_lut3($v0) - addiu $t7, 1 # coeff_index++ + lw $v0, DECDCTTAB_lut3($v0) b .Lupdate_window_and_write srl $v1, $v0, 16 # length = value >> 16 - .word 0 + .word 0, 0 .Lac_prefix_0001: # Prefix 0001 is followed by a 3-bit lookup index. srl $v0, $t0, 24 # index = ((window >> (32 - 4 - 3)) & 7) * sizeof(u16) andi $v0, 14 addu $v0, $t8 # value = table->lut4[index] - lhu $v0, DECDCTSMALLTAB_lut4($v0) + lhu $v0, DECDCTTAB_lut4($v0) sll $t0, 7 # window <<= 4 + 3 - addiu $t5, -7 # bit_offset -= 4 + 3 b .Lwrite_value - addiu $t7, 1 # coeff_index++ + addiu $t5, -7 # bit_offset -= 4 + 3 + .word 0 .Lac_prefix_00001: # Prefix 00001 is followed by a 3-bit lookup index. srl $v0, $t0, 23 # index = ((window >> (32 - 5 - 3)) & 7) * sizeof(u16) andi $v0, 14 addu $v0, $t8 # value = table->lut5[index] - lhu $v0, DECDCTSMALLTAB_lut5($v0) + lhu $v0, DECDCTTAB_lut5($v0) sll $t0, 8 # window <<= 5 + 3 - addiu $t5, -8 # bit_offset -= 5 + 3 b .Lwrite_value - addiu $t7, 1 # coeff_index++ + addiu $t5, -8 # bit_offset -= 5 + 3 + .word 0 .Lac_prefix_000001: # Prefix 000001 is an escape code followed by a full 16-bit MDEC value. srl $v0, $t0, 10 # value = window >> (32 - 6 - 16) sll $t0, 22 # window <<= 6 + 16 - addiu $t5, -22 # bit_offset -= 6 + 16 b .Lwrite_value - addiu $t7, 1 # coeff_index++ - .word 0, 0, 0 + addiu $t5, -22 # bit_offset -= 6 + 16 + .word 0, 0, 0, 0 .Lac_prefix_0000001: # Prefix 0000001 is followed by a 4-bit lookup index. srl $v0, $t0, 20 # index = ((window >> (32 - 7 - 4)) & 15) * sizeof(u16) andi $v0, 30 addu $v0, $t8 # value = table->lut7[index] - lhu $v0, DECDCTSMALLTAB_lut7($v0) + lhu $v0, DECDCTTAB_lut7($v0) sll $t0, 11 # window <<= 7 + 4 - addiu $t5, -11 # bit_offset -= 7 + 4 b .Lwrite_value - addiu $t7, 1 # coeff_index++ + addiu $t5, -11 # bit_offset -= 7 + 4 + .word 0 .Lac_prefix_00000001: # Prefix 00000001 is followed by a 5-bit lookup index. srl $v0, $t0, 18 # index = ((window >> (32 - 8 - 5)) & 31) * sizeof(u16) andi $v0, 62 addu $v0, $t8 # value = table->lut8[index] - lhu $v0, DECDCTSMALLTAB_lut8($v0) + lhu $v0, DECDCTTAB_lut8($v0) sll $t0, 13 # window <<= 8 + 5 - addiu $t5, -13 # bit_offset -= 8 + 5 b .Lwrite_value - addiu $t7, 1 # coeff_index++ + addiu $t5, -13 # bit_offset -= 8 + 5 + .word 0 .Lac_prefix_000000001: # Prefix 000000001 is followed by a 5-bit lookup index. srl $v0, $t0, 17 # index = ((window >> (32 - 9 - 5)) & 31) * sizeof(u16) andi $v0, 62 addu $v0, $t8 # value = table->lut9[index] - lhu $v0, DECDCTSMALLTAB_lut9($v0) + lhu $v0, DECDCTTAB_lut9($v0) sll $t0, 14 # window <<= 9 + 5 - addiu $t5, -14 # bit_offset -= 9 + 5 b .Lwrite_value - addiu $t7, 1 # coeff_index++ + addiu $t5, -14 # bit_offset -= 9 + 5 + .word 0 .Lac_prefix_0000000001: # Prefix 0000000001 is followed by a 5-bit lookup index. srl $v0, $t0, 16 # index = ((window >> (32 - 10 - 5)) & 31) * sizeof(u16) andi $v0, 62 addu $v0, $t8 # value = table->lut10[index] - lhu $v0, DECDCTSMALLTAB_lut10($v0) + lhu $v0, DECDCTTAB_lut10($v0) sll $t0, 15 # window <<= 10 + 5 - addiu $t5, -15 # bit_offset -= 10 + 5 b .Lwrite_value - addiu $t7, 1 # coeff_index++ + addiu $t5, -15 # bit_offset -= 10 + 5 + .word 0 .Lac_prefix_00000000001: # Prefix 00000000001 is followed by a 5-bit lookup index. srl $v0, $t0, 15 # index = ((window >> (32 - 11 - 5)) & 31) * sizeof(u16) andi $v0, 62 addu $v0, $t8 # value = table->lut11[index] - lhu $v0, DECDCTSMALLTAB_lut11($v0) + lhu $v0, DECDCTTAB_lut11($v0) sll $t0, 16 # window <<= 11 + 5 - addiu $t5, -16 # bit_offset -= 11 + 5 b .Lwrite_value - addiu $t7, 1 # coeff_index++ + addiu $t5, -16 # bit_offset -= 11 + 5 + .word 0 .Lac_prefix_000000000001: # Prefix 000000000001 is followed by a 5-bit lookup index. srl $v0, $t0, 14 # index = ((window >> (32 - 12 - 5)) & 31) * sizeof(u16) andi $v0, 62 addu $v0, $t8 # value = table->lut12[index] - lhu $v0, DECDCTSMALLTAB_lut12($v0) + lhu $v0, DECDCTTAB_lut12($v0) sll $t0, 17 # window <<= 12 + 5 - addiu $t5, -17 # bit_offset -= 12 + 5 b .Lwrite_value - addiu $t7, 1 # coeff_index++ - - # Prefix 0000000000001 is not valid. - beqz $t0, .Lstop_processing - nop - jr $ra - li $v0, -1 - .word 0, 0, 0, 0 - - # Prefix 00000000000001 is not valid. - beqz $t0, .Lstop_processing - nop - jr $ra - li $v0, -1 - .word 0, 0, 0, 0 - - # Prefix 000000000000001 is not valid. - beqz $t0, .Lstop_processing - nop - jr $ra - li $v0, -1 - .word 0, 0, 0, 0 - - # Prefix 0000000000000001 is not valid. - beqz $t0, .Lstop_processing - nop - jr $ra - li $v0, -1 - #.word 0, 0, 0, 0 + addiu $t5, -17 # bit_offset -= 12 + 5 + .word 0 .Lupdate_window_and_write: sllv $t0, $t0, $v1 # window <<= length diff --git a/libpsn00b/psxsio/sio.c b/libpsn00b/psxsio/sio.c index 3fb3caf..6b80352 100644 --- a/libpsn00b/psxsio/sio.c +++ b/libpsn00b/psxsio/sio.c @@ -27,7 +27,7 @@ typedef struct { static SIO_FlowControl _flow_control; static uint16_t _ctrl_reg_flag; -static void (*_read_callback)(uint8_t) = (void *) 0; +static int (*_read_callback)(uint8_t) = (void *) 0; static void (*_old_sio_handler)(void) = (void *) 0; static volatile RingBuffer _tx_buffer, _rx_buffer; @@ -41,7 +41,15 @@ static void _sio_handler(void) { // Handle any incoming bytes. while (SIO_STAT & SR_RXRDY) { uint8_t value = SIO_TXRX; - int length = _rx_buffer.length; + + // Skip storing this byte into the RX buffer if the callback returns a + // non-zero value. + if (_read_callback) { + if (_read_callback(value)) + continue; + } + + int length = _rx_buffer.length; if (length >= BUFFER_LENGTH) { //_sdk_log("RX overrun, dropping bytes\n"); @@ -53,8 +61,6 @@ static void _sio_handler(void) { _rx_buffer.length = length + 1; _rx_buffer.data[tail] = value; - if (_read_callback) - _read_callback(value); } // Send the next byte in the buffer if the TX unit is ready. Note that @@ -185,7 +191,7 @@ int SIO_ReadSync(int mode) { return 0; } -void *SIO_ReadCallback(void (*func)(uint8_t)) { +void *SIO_ReadCallback(int (*func)(uint8_t)) { EnterCriticalSection(); void *old_callback = _read_callback; diff --git a/libpsn00b/psxspu/common.c b/libpsn00b/psxspu/common.c index 42f7cb7..1613ca9 100644 --- a/libpsn00b/psxspu/common.c +++ b/libpsn00b/psxspu/common.c @@ -38,13 +38,16 @@ static void _dma_transfer(uint32_t *data, size_t length, int write) { length += DMA_CHUNK_LENGTH - 1; } - SPU_CTRL &= 0xffcf; // Disable DMA request + SPU_DMA_CTRL = 0x0004; // Reset transfer mode + SPU_CTRL &= 0xffcf; // Disable DMA request _wait_status(0x0030, 0x0000); // Enable DMA request for writing (2) or reading (3) + uint16_t ctrl = write ? 0x0020 : 0x0030; + SPU_ADDR = _transfer_addr; - SPU_CTRL |= write ? 0x0020 : 0x0030; - _wait_status(0x0400, 0x0000); + SPU_CTRL |= ctrl; + _wait_status(0x0430, ctrl); DMA_MADR(4) = (uint32_t) data; if (length < DMA_CHUNK_LENGTH) -- cgit v1.2.3 From 4dbf47f129a55428b90df2805228fbd481e1d117 Mon Sep 17 00:00:00 2001 From: spicyjpeg Date: Thu, 27 Oct 2022 12:04:11 +0200 Subject: Fix SPU_TRANSFER_BY_IO mode, add IRQ/DMA enums --- libpsn00b/include/psxcd.h | 4 +- libpsn00b/include/psxetc.h | 35 ++++++++++++++-- libpsn00b/include/psxspu.h | 5 ++- libpsn00b/psxcd/psxcd.c | 2 +- libpsn00b/psxetc/interrupts.c | 8 ++-- libpsn00b/psxpress/vlc.s | 9 ++--- libpsn00b/psxspu/common.c | 93 ++++++++++++++++++++++++++++--------------- 7 files changed, 107 insertions(+), 49 deletions(-) (limited to 'libpsn00b/psxspu/common.c') diff --git a/libpsn00b/include/psxcd.h b/libpsn00b/include/psxcd.h index 0460f20..bd89f53 100644 --- a/libpsn00b/include/psxcd.h +++ b/libpsn00b/include/psxcd.h @@ -136,7 +136,7 @@ extern "C" { int CdInit(void); CdlLOC* CdIntToPos(int i, CdlLOC *p); -int CdPosToInt(CdlLOC *p); +int CdPosToInt(const CdlLOC *p); int CdGetToc(CdlLOC *toc); int CdControl(uint8_t com, const void *param, uint8_t *result); @@ -159,7 +159,7 @@ uint32_t CdReadCallback(CdlCB func); int CdStatus(void); int CdMode(void); -int CdMix(CdlATV *vol); +int CdMix(const CdlATV *vol); /* ORIGINAL CODE */ CdlDIR* CdOpenDir(const char* path); diff --git a/libpsn00b/include/psxetc.h b/libpsn00b/include/psxetc.h index 24485d9..3b18784 100644 --- a/libpsn00b/include/psxetc.h +++ b/libpsn00b/include/psxetc.h @@ -6,16 +6,43 @@ #ifndef __PSXETC_H #define __PSXETC_H +/* IRQ and DMA channel definitions */ + +typedef enum _IRQ_Channel { + IRQ_VBLANK = 0, + IRQ_GPU = 1, + IRQ_CD = 2, + IRQ_DMA = 3, + IRQ_TIMER0 = 4, + IRQ_TIMER1 = 5, + IRQ_TIMER2 = 6, + IRQ_SIO0 = 7, + IRQ_SIO1 = 8, + IRQ_SPU = 9, + IRQ_GUN = 10, + IRQ_PIO = 10 +} IRQ_Channel; + +typedef enum _DMA_Channel { + DMA_MDEC_IN = 0, + DMA_MDEC_OUT = 1, + DMA_GPU = 2, + DMA_CD = 3, + DMA_SPU = 4, + DMA_PIO = 5, + DMA_OTC = 6 +} DMA_Channel; + /* Public API */ #ifdef __cplusplus extern "C" { #endif -void *InterruptCallback(int irq, void (*func)(void)); -void *GetInterruptCallback(int irq); -void *DMACallback(int dma, void (*func)(void)); -void *GetDMACallback(int dma); +void *InterruptCallback(IRQ_Channel irq, void (*func)(void)); +void *GetInterruptCallback(IRQ_Channel irq); +void *DMACallback(DMA_Channel dma, void (*func)(void)); +void *GetDMACallback(DMA_Channel dma); int ResetCallback(void); void RestartCallback(void); diff --git a/libpsn00b/include/psxspu.h b/libpsn00b/include/psxspu.h index 7858e88..05737f7 100644 --- a/libpsn00b/include/psxspu.h +++ b/libpsn00b/include/psxspu.h @@ -125,8 +125,9 @@ extern "C" { void SpuInit(void); -void SpuRead(uint32_t *data, size_t size); -void SpuWrite(const uint32_t *data, size_t size); +size_t SpuRead(uint32_t *data, size_t size); +size_t SpuWrite(const uint32_t *data, size_t size); +size_t SpuWritePartly(const uint32_t *data, size_t size); SPU_TransferMode SpuSetTransferMode(SPU_TransferMode mode); uint32_t SpuSetTransferStartAddr(uint32_t addr); int SpuIsTransferCompleted(int mode); diff --git a/libpsn00b/psxcd/psxcd.c b/libpsn00b/psxcd/psxcd.c index d8d0686..9392d30 100644 --- a/libpsn00b/psxcd/psxcd.c +++ b/libpsn00b/psxcd/psxcd.c @@ -208,7 +208,7 @@ CdlLOC *CdIntToPos(int i, CdlLOC *p) { } -int CdPosToInt(CdlLOC *p) +int CdPosToInt(const CdlLOC *p) { return ((75*(btoi(p->minute)*60))+(75*btoi(p->second))+btoi(p->sector))-150; } diff --git a/libpsn00b/psxetc/interrupts.c b/libpsn00b/psxetc/interrupts.c index cc9d12c..0d926c4 100644 --- a/libpsn00b/psxetc/interrupts.c +++ b/libpsn00b/psxetc/interrupts.c @@ -98,7 +98,7 @@ static void _global_dma_handler(void) { /* IRQ and DMA handler API */ -void *InterruptCallback(int irq, void (*func)(void)) { +void *InterruptCallback(IRQ_Channel irq, void (*func)(void)) { if ((irq < 0) || (irq >= NUM_IRQ_CHANNELS)) return 0; @@ -115,14 +115,14 @@ void *InterruptCallback(int irq, void (*func)(void)) { return old_callback; } -void *GetInterruptCallback(int irq) { +void *GetInterruptCallback(IRQ_Channel irq) { if ((irq < 0) || (irq >= NUM_IRQ_CHANNELS)) return 0; return _irq_handlers[irq]; } -void *DMACallback(int dma, void (*func)(void)) { +void *DMACallback(DMA_Channel dma, void (*func)(void)) { if ((dma < 0) || (dma >= NUM_DMA_CHANNELS)) return 0; @@ -150,7 +150,7 @@ void *DMACallback(int dma, void (*func)(void)) { return old_callback; } -void *GetDMACallback(int dma) { +void *GetDMACallback(DMA_Channel dma) { if ((dma < 0) || (dma >= NUM_DMA_CHANNELS)) return 0; diff --git a/libpsn00b/psxpress/vlc.s b/libpsn00b/psxpress/vlc.s index 75e33d3..f3a1c67 100644 --- a/libpsn00b/psxpress/vlc.s +++ b/libpsn00b/psxpress/vlc.s @@ -145,17 +145,16 @@ _vlc_skip_context_load: li $v0, -1 .Lprocess_ac_coefficient: # if (coeff_index) - # Start counting the number of leading zeroes/ones using the GTE. This - # takes 2 more cycles. - mtc2 $t0, $30 - - # Check whether the prefix code is one of the shorter, more common ones. + # Check whether the prefix code is one of the shorter, more common ones, + # and start counting the number of leading zeroes/ones using the GTE (which + # takes 2 more cycles). srl $v0, $t0, 30 li $v1, 3 beq $v0, $v1, .Lac_prefix_11 li $v1, 2 beq $v0, $v1, .Lac_prefix_10 li $v1, 1 + mtc2 $t0, $30 beq $v0, $v1, .Lac_prefix_01 nop diff --git a/libpsn00b/psxspu/common.c b/libpsn00b/psxspu/common.c index 1613ca9..ca4b201 100644 --- a/libpsn00b/psxspu/common.c +++ b/libpsn00b/psxspu/common.c @@ -8,6 +8,8 @@ #include #include +#define _min(x, y) (((x) < (y)) ? (x) : (y)) + #define WRITABLE_AREA_ADDR 0x200 #define DMA_CHUNK_LENGTH 16 #define STATUS_TIMEOUT 0x100000 @@ -28,7 +30,7 @@ static void _wait_status(uint16_t mask, uint16_t value) { _sdk_log("status register timeout (0x%04x)\n", SPU_STAT); } -static void _dma_transfer(uint32_t *data, size_t length, int write) { +static size_t _dma_transfer(uint32_t *data, size_t length, int write) { if (length % 4) _sdk_log("can't transfer a number of bytes that isn't multiple of 4\n"); @@ -38,8 +40,7 @@ static void _dma_transfer(uint32_t *data, size_t length, int write) { length += DMA_CHUNK_LENGTH - 1; } - SPU_DMA_CTRL = 0x0004; // Reset transfer mode - SPU_CTRL &= 0xffcf; // Disable DMA request + SPU_CTRL &= 0xffcf; // Disable DMA request _wait_status(0x0030, 0x0000); // Enable DMA request for writing (2) or reading (3) @@ -47,7 +48,7 @@ static void _dma_transfer(uint32_t *data, size_t length, int write) { SPU_ADDR = _transfer_addr; SPU_CTRL |= ctrl; - _wait_status(0x0430, ctrl); + _wait_status(0x0030, ctrl); DMA_MADR(4) = (uint32_t) data; if (length < DMA_CHUNK_LENGTH) @@ -56,6 +57,42 @@ static void _dma_transfer(uint32_t *data, size_t length, int write) { DMA_BCR(4) = DMA_CHUNK_LENGTH | ((length / DMA_CHUNK_LENGTH) << 16); DMA_CHCR(4) = 0x01000200 | write; + return length; +} + +static size_t _manual_write(const uint16_t *data, size_t length) { + if (length % 2) + _sdk_log("can't transfer a number of bytes that isn't multiple of 2\n"); + + length /= 2; + + SPU_CTRL &= 0xffcf; // Disable DMA request + _wait_status(0x0030, 0x0000); + + // Manual transfers have to be done by filling up the SPU's transfer buffer + // and then letting the SPU empty it one 64-byte chunk at a time. + uint16_t addr = _transfer_addr; + + while (length) { + size_t chunk = _min(DMA_CHUNK_LENGTH * 2, length); + length -= chunk; + + SPU_ADDR = addr; + addr += chunk / 4; + + for (; chunk; chunk--) + SPU_DATA = *(data++); + + SPU_CTRL |= 0x0010; // Manual transfer mode + _wait_status(0x0030, 0x0010); + _wait_status(0x0400, 0x0000); + + // This additional delay is required according to nocash docs. + for (int i = 0; i < 1000; i++) + __asm__ volatile(""); + } + + return length; } /* Public API */ @@ -81,17 +118,16 @@ void SpuInit(void) { DMA_DPCR |= 0x000b0000; // Enable DMA4 DMA_CHCR(4) = 0x00000201; // Stop DMA4 - SPU_CTRL = 0xc011; // Enable SPU, DAC, CD audio, set manual transfer mode - _wait_status(0x001f, 0x0011); + SPU_DMA_CTRL = 0x0004; // Reset transfer mode + SPU_CTRL = 0xc001; // Enable SPU, DAC, CD audio, disable DMA request + _wait_status(0x003f, 0x0001); - // Upload a dummy ADPCM block to the first 16 bytes of SPU RAM. This may be - // freely used or overwritten. - SPU_ADDR = WRITABLE_AREA_ADDR; - _wait_status(0x0400, 0x0000); + // Upload a dummy looping ADPCM block to the first 16 bytes of SPU RAM. + // This may be freely used or overwritten. + uint32_t block[4] = { 0x0500, 0, 0, 0 }; - SPU_DATA = 0x0500; - for (int i = 7; i; i--) - SPU_DATA = 0x0000; + _transfer_addr = WRITABLE_AREA_ADDR; + _manual_write((const uint16_t *) block, 16); // "Play" the dummy block on all channels. This will reset the start // address and ADSR envelope status of each channel. @@ -111,31 +147,26 @@ void SpuInit(void) { SPU_CD_VOL_R = 0x7fff; } -void SpuRead(uint32_t *data, size_t size) { - _dma_transfer(data, size, 0); +size_t SpuRead(uint32_t *data, size_t size) { + return _dma_transfer(data, size, 0) * 4; } -void SpuWrite(const uint32_t *data, size_t size) { +size_t SpuWrite(const uint32_t *data, size_t size) { if (_transfer_addr < WRITABLE_AREA_ADDR) - return; + return 0; // I/O transfer mode is not that useful, but whatever. - if (_transfer_mode) { - SPU_ADDR = _transfer_addr; - SPU_CTRL = (SPU_CTRL & 0xffcf) | 0x0010; // Manual transfer mode - _wait_status(0x0400, 0x0000); - - for (int i = size; i; i -= 4) { - uint32_t value = *(data++); - - SPU_DATA = (uint16_t) value; - SPU_DATA = (uint16_t) (value >> 16); - } + if (_transfer_mode) + return _manual_write((const uint16_t *) data, size) * 2; + else + return _dma_transfer((uint32_t *) data, size, 1) * 4; +} - return; - } +size_t SpuWritePartly(const uint32_t *data, size_t size) { + size_t _size = SpuWrite(data, size); - _dma_transfer((uint32_t *) data, size, 1); + _transfer_addr += (_size + 1) / 2; + return _size; } SPU_TransferMode SpuSetTransferMode(SPU_TransferMode mode) { -- cgit v1.2.3 From f6c41f3783c4fce49a9899b710ebb50ba9f647ab Mon Sep 17 00:00:00 2001 From: spicyjpeg Date: Thu, 27 Oct 2022 16:55:08 +0200 Subject: Refactor sound examples, add new spustream example --- CHANGELOG.md | 14 + examples/README.md | 7 +- examples/sound/cdstream/CMakeLists.txt | 23 ++ examples/sound/cdstream/iso.xml | 28 ++ examples/sound/cdstream/main.c | 439 ++++++++++++++++++++++++++++ examples/sound/cdstream/stream.vag | Bin 0 -> 4646912 bytes examples/sound/cdstream/system.cnf | 4 + examples/sound/spustream/CMakeLists.txt | 16 +- examples/sound/spustream/convert_stream.py | 112 ------- examples/sound/spustream/interleave.py | 152 ++++++++++ examples/sound/spustream/iso.xml | 28 -- examples/sound/spustream/main.c | 360 +++++++++-------------- examples/sound/spustream/stream.bin | Bin 4685824 -> 0 bytes examples/sound/spustream/stream.vag | Bin 0 -> 1140736 bytes examples/sound/spustream/system.cnf | 4 - examples/sound/vagsample/3dfx.vag | Bin 227936 -> 227968 bytes examples/sound/vagsample/main.c | 455 +++++++++++++---------------- examples/sound/vagsample/proyt.vag | Bin 189264 -> 189248 bytes libpsn00b/include/hwregs_a.inc | 22 +- libpsn00b/include/hwregs_c.h | 21 +- libpsn00b/include/psxspu.h | 14 +- libpsn00b/psxspu/common.c | 15 +- 22 files changed, 1049 insertions(+), 665 deletions(-) create mode 100644 examples/sound/cdstream/CMakeLists.txt create mode 100644 examples/sound/cdstream/iso.xml create mode 100644 examples/sound/cdstream/main.c create mode 100644 examples/sound/cdstream/stream.vag create mode 100644 examples/sound/cdstream/system.cnf delete mode 100644 examples/sound/spustream/convert_stream.py create mode 100644 examples/sound/spustream/interleave.py delete mode 100644 examples/sound/spustream/iso.xml delete mode 100644 examples/sound/spustream/stream.bin create mode 100644 examples/sound/spustream/stream.vag delete mode 100644 examples/sound/spustream/system.cnf (limited to 'libpsn00b/psxspu/common.c') diff --git a/CHANGELOG.md b/CHANGELOG.md index e9d7e16..d6b49e9 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -19,6 +19,20 @@ to ensure the changelog can be parsed correctly. ------------------------------------------------------------------------------- +# 2022-10-27 + +spicyjpeg: + +- psxspu: Fixed bugs in `SpuInit()` and in `SpuWrite()` when using manual + transfer mode (`SPU_TRANSFER_BY_IO`). Added `SpuWritePartly()`. + +- psxetc: Added `IRQ_Channel` and `DMA_Channel` enums. + +- examples: Refactored and bugfixed all sound examples. Renamed the old + `spustream` example to `cdstream` and added a new `spustream` example + demonstrating SPU audio streaming from main RAM. Both streaming examples now + make use of the interleaved .VAG file format. + ## 2022-10-21: 0.21 spicyjpeg: diff --git a/examples/README.md b/examples/README.md index ade94b0..ae601f1 100644 --- a/examples/README.md +++ b/examples/README.md @@ -26,8 +26,9 @@ Additional information may be found in the source code of each example. | [`lowlevel/cartrom`](./lowlevel/cartrom) | ROM firmware for cheat devices written using GNU GAS | ROM | 4 | | [`mdec/mdecimage`](./mdec/mdecimage) | Displays a (raw) MDEC format image | EXE | | | [`mdec/strvideo`](./mdec/strvideo) | Plays a .STR video file using the MDEC | CD | 1 | -| [`sound/spustream`](./sound/spustream) | Custom (non XA) CD-ROM audio streaming using the SPU | CD | | -| [`sound/vagsample`](./sound/vagsample) | Demonstrates playing VAG sound files using the SPU | EXE | | +| [`sound/cdstream`](./sound/cdstream) | Streams an interleaved .VAG file from the CD-ROM | CD | | +| [`sound/spustream`](./sound/spustream) | Streams an interleaved .VAG file from main RAM | EXE | | +| [`sound/vagsample`](./sound/vagsample) | Loads and plays .VAG sound files using the SPU | EXE | | | [`system/childexec`](./system/childexec) | Loading a child program and returning to parent | EXE | | | [`system/console`](./system/console) | TTY based text console that interrupts gameplay | EXE | | | [`system/dynlink`](./system/dynlink) | Demonstrates dynamically linked libraries | CD | | @@ -85,4 +86,4 @@ are for rebuilding the examples *after* the SDK has been installed. CD images for each example. ----------------------------------------- -_Last updated on 2022-10-16 by spicyjpeg_ +_Last updated on 2022-10-27 by spicyjpeg_ diff --git a/examples/sound/cdstream/CMakeLists.txt b/examples/sound/cdstream/CMakeLists.txt new file mode 100644 index 0000000..e569449 --- /dev/null +++ b/examples/sound/cdstream/CMakeLists.txt @@ -0,0 +1,23 @@ +# PSn00bSDK example CMake script +# (C) 2021 spicyjpeg - MPL licensed + +cmake_minimum_required(VERSION 3.21) + +project( + cdstream + LANGUAGES C + VERSION 1.0.0 + DESCRIPTION "PSn00bSDK SPU CD audio streaming example" + HOMEPAGE_URL "http://lameguy64.net/?page=psn00bsdk" +) + +file(GLOB _sources *.c) +psn00bsdk_add_executable(cdstream GPREL ${_sources}) +psn00bsdk_add_cd_image(cdstream_iso cdstream iso.xml DEPENDS cdstream) + +install( + FILES + ${PROJECT_BINARY_DIR}/cdstream.bin + ${PROJECT_BINARY_DIR}/cdstream.cue + TYPE BIN +) diff --git a/examples/sound/cdstream/iso.xml b/examples/sound/cdstream/iso.xml new file mode 100644 index 0000000..66f1f74 --- /dev/null +++ b/examples/sound/cdstream/iso.xml @@ -0,0 +1,28 @@ + + + + + + + + + + + + + + + + + diff --git a/examples/sound/cdstream/main.c b/examples/sound/cdstream/main.c new file mode 100644 index 0000000..636ef10 --- /dev/null +++ b/examples/sound/cdstream/main.c @@ -0,0 +1,439 @@ +/* + * PSn00bSDK SPU CD-ROM streaming example + * (C) 2022 spicyjpeg - MPL licensed + * + * This is an extended version of the sound/spustream example demonstrating + * playback of a large multi-channel audio file from the CD using the SPU, + * without having to rely on the CD drive's own ability to play CD-DA or XA + * tracks. + * + * The main difference from spustream is that the SPU IRQ handler does not + * upload a chunk from main RAM to SPU RAM immediately, it only sets a flag. + * The main loop checks if the flag has been set and starts reading the next + * chunk from the CD into a buffer in RAM asynchronously; the chunk is then + * uploaded to the SPU and the IRQ is re-enabled. + * + * Chunks are read once again from an interleaved .VAG file, laid out on the + * disc as follows: + * + * +--Sector--+--Sector--+--Sector--+--Sector--+--Sector--+--Sector--+---- + * | | +--------------------+---------------------+ | + * | .VAG | | Left channel data | Right channel data | Padding | ... + * | header | +--------------------+---------------------+ | + * +----------+----------+----------+----------+----------+----------+---- + * \__________________Chunk___________________/ + * + * Note that chunks have to be large enough to give the drive enough time to + * seek from one chunk to another. The included .VAG file has been encoded with + * a chunk size of 0x7000 bytes, however you might want to try smaller sizes to + * reduce SPU RAM usage. Chunk size can be set by passing the -b option to the + * .VAG interleaving script included in the spustream directory. + * + * Implementing SPU streaming might seem pointless, but it actually has a + * number of advantages over CD-DA or XA: + * + * - Any sample rate up to 44.1 kHz can be used. The sample rate can also be + * changed on-the-fly to play the stream at different speeds and pitches (as + * long as the CD drive can keep up), or even interpolated for effects like + * tape stops. + * - Manual streaming is not limited to mono or stereo but can be expanded to + * as many channels as needed, only limited by the amount of SPU RAM required + * for chunks and CD bandwidth. Having more than 2 channels can be useful for + * e.g. smoothly crossfading between tracks (not possible with XA) or + * controlling volume and panning of each instrument separately. + * - XA playback tends to skip on consoles with a worn out drive, as XA sectors + * cannot have any error correction data. SPU streaming is not subject to + * this limitation since sectors are read and processed in software. + * - Depending on how streaming/interleaving is implemented it is possible to + * have 500-1000ms idle periods during which the CD drive isn't buffering the + * stream, that can be used to read small amounts of other data without ever + * interrupting playback. This is different from XA-style interleaving as the + * drive is free to seek to *any* region of the disc during these periods (it + * must seek back to the stream's next chunk afterwards though). + * - It is also possible to seek back to the beginning of the stream and load + * the first chunk before the end is reached, allowing for seamless looping + * without having to resort to tricks like separate filler samples. + * - Finally, SPU streaming can be used on some PS1-based arcade boards that + * use IDE/SCSI drives or flash memory for storage and thus lack support for + * XA or CD-DA playback. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +extern const uint8_t stream_data[]; + +#define NUM_CHANNELS 2 + +/* Display/GPU context utilities */ + +#define SCREEN_XRES 320 +#define SCREEN_YRES 240 + +#define BGCOLOR_R 48 +#define BGCOLOR_G 24 +#define BGCOLOR_B 0 + +typedef struct { + DISPENV disp; + DRAWENV draw; +} Framebuffer; + +typedef struct { + Framebuffer db[2]; + int db_active; +} RenderContext; + +void init_context(RenderContext *ctx) { + Framebuffer *db; + + ResetGraph(0); + ctx->db_active = 0; + + db = &(ctx->db[0]); + SetDefDispEnv(&(db->disp), 0, 0, SCREEN_XRES, SCREEN_YRES); + SetDefDrawEnv(&(db->draw), SCREEN_XRES, 0, SCREEN_XRES, SCREEN_YRES); + setRGB0(&(db->draw), BGCOLOR_R, BGCOLOR_G, BGCOLOR_B); + db->draw.isbg = 1; + db->draw.dtd = 1; + + db = &(ctx->db[1]); + SetDefDispEnv(&(db->disp), SCREEN_XRES, 0, SCREEN_XRES, SCREEN_YRES); + SetDefDrawEnv(&(db->draw), 0, 0, SCREEN_XRES, SCREEN_YRES); + setRGB0(&(db->draw), BGCOLOR_R, BGCOLOR_G, BGCOLOR_B); + db->draw.isbg = 1; + db->draw.dtd = 1; + + PutDrawEnv(&(db->draw)); + //PutDispEnv(&(db->disp)); + + // Create a text stream at the top of the screen. + FntLoad(960, 0); + FntOpen(8, 16, 304, 208, 2, 512); +} + +void display(RenderContext *ctx) { + Framebuffer *db; + + DrawSync(0); + VSync(0); + ctx->db_active ^= 1; + + db = &(ctx->db[ctx->db_active]); + PutDrawEnv(&(db->draw)); + PutDispEnv(&(db->disp)); + SetDispMask(1); +} + +/* .VAG header structure */ + +typedef struct { + uint32_t magic; // 0x69474156 ("VAGi") for interleaved files + uint32_t version; + uint32_t interleave; // Little-endian, size of each channel buffer + uint32_t size; // Big-endian, in bytes + uint32_t sample_rate; // Big-endian, in Hertz + uint32_t _reserved[3]; + char name[16]; +} VAG_Header; + +#define SWAP_ENDIAN(x) ( \ + (((uint32_t) (x) & 0x000000ff) << 24) | \ + (((uint32_t) (x) & 0x0000ff00) << 8) | \ + (((uint32_t) (x) & 0x00ff0000) >> 8) | \ + (((uint32_t) (x) & 0xff000000) >> 24) \ +) + +/* Interrupt callbacks */ + +// The first 4 KB of SPU RAM are reserved for capture buffers and psxspu +// additionally uploads a dummy sample (16 bytes) at 0x1000 by default, so the +// chunks must be placed after those. The dummy sample is going to be used to +// keep unused SPU channels busy, preventing them from accidentally triggering +// the SPU IRQ and throwing off the timing (all channels are always reading +// from SPU RAM, even when "stopped"). +// https://problemkaputt.de/psx-spx.htm#spuinterrupt +#define DUMMY_BLOCK_ADDR 0x1000 +#define BUFFER_START_ADDR 0x1010 + +typedef enum { + STATE_IDLE, + STATE_DATA_NEEDED, + STATE_READING, + STATE_BUFFERING +} StreamState; + +typedef struct { + uint32_t *read_buffer; + int lba, chunk_secs; + int buffer_size, num_chunks, sample_rate; + + volatile int next_chunk, spu_addr; + volatile int8_t db_active, state; +} StreamContext; + +static StreamContext str_ctx; + +void spu_irq_handler(void) { + // Acknowledge the interrupt to ensure it can be triggered again. The only + // way to do this is actually to disable the interrupt entirely; we'll + // enable it again once the chunk is ready. + SPU_CTRL &= 0xffbf; + + int chunk_size = str_ctx.buffer_size * NUM_CHANNELS; + int chunk = (str_ctx.next_chunk + 1) % (uint32_t) str_ctx.num_chunks; + + str_ctx.db_active ^= 1; + str_ctx.state = STATE_DATA_NEEDED; + str_ctx.next_chunk = chunk; + + // Configure to SPU to trigger an IRQ once the chunk that is going to be + // filled now starts playing (so the next buffer can be loaded) and + // override both channels' loop addresses to make them "jump" to the new + // buffers, rather than actually looping when they encounter the loop flag + // at the end of the currently playing buffers. + int addr = BUFFER_START_ADDR + (str_ctx.db_active ? chunk_size : 0); + str_ctx.spu_addr = addr; + + SPU_IRQ_ADDR = getSPUAddr(addr); + for (int i = 0; i < NUM_CHANNELS; i++) + SPU_CH_LOOP_ADDR(i) = getSPUAddr(addr + str_ctx.buffer_size * i); + + // Note that we can't call CdRead() here as it requires interrupts to be + // enabled. Instead, feed_stream() (called from the main loop) will check + // if str_ctx.state is set to STATE_DATA_NEEDED and fetch the next chunk. +} + +void cd_read_handler(int event, uint8_t *payload) { + // Attempt to read the chunk again if an error has occurred, otherwise + // start uploading it to SPU RAM. + if (event == CdlDiskError) { + str_ctx.state = STATE_DATA_NEEDED; + return; + } + + SpuSetTransferStartAddr(str_ctx.spu_addr); + SpuWrite(str_ctx.read_buffer, str_ctx.buffer_size * NUM_CHANNELS); + + str_ctx.state = STATE_BUFFERING; +} + +void spu_dma_handler(void) { + // Re-enable the SPU IRQ once the new chunk has been fully uploaded. + SPU_CTRL |= 0x0040; + + str_ctx.state = STATE_IDLE; +} + +/* Helper functions */ + +// This isn't actually required for this example, however it is necessary if +// you want to allocate the stream buffers into a region of SPU RAM that was +// previously used (to make sure the IRQ isn't going to be triggered by any +// inactive channels). +void reset_spu_channels(void) { + SpuSetKey(0, 0x00ffffff); + + for (int i = 0; i < 24; i++) { + SPU_CH_ADDR(i) = getSPUAddr(DUMMY_BLOCK_ADDR); + SPU_CH_FREQ(i) = 0x1000; + } + + SpuSetKey(1, 0x00ffffff); +} + +void feed_stream(void) { + if (str_ctx.state != STATE_DATA_NEEDED) + return; + + // Start reading the next chunk from the CD. + int lba = str_ctx.lba + str_ctx.next_chunk * str_ctx.chunk_secs; + + CdlLOC pos; + CdIntToPos(lba, &pos); + CdControl(CdlSetloc, &pos, 0); + + CdReadCallback(&cd_read_handler); + CdRead(str_ctx.chunk_secs, str_ctx.read_buffer, CdlModeSpeed); + + str_ctx.state = STATE_READING; +} + +void init_stream(const CdlLOC *pos) { + EnterCriticalSection(); + InterruptCallback(IRQ_SPU, &spu_irq_handler); + DMACallback(DMA_SPU, &spu_dma_handler); + ExitCriticalSection(); + + // Read the header. Note that in interleaved .VAG files the first sector. + uint32_t header[512]; + CdControl(CdlSetloc, pos, 0); + + CdReadCallback(0); + CdRead(1, header, CdlModeSpeed); + CdReadSync(0, 0); + + VAG_Header *vag = (VAG_Header *) header; + int buf_size = vag->interleave; + int chunk_secs = ((buf_size * NUM_CHANNELS) + 2047) / 2048; + + str_ctx.read_buffer = malloc(chunk_secs * 2048); + str_ctx.lba = CdPosToInt(pos) + 1; + str_ctx.chunk_secs = chunk_secs; + str_ctx.buffer_size = buf_size; + str_ctx.num_chunks = (SWAP_ENDIAN(vag->size) + buf_size - 1) / buf_size; + str_ctx.sample_rate = SWAP_ENDIAN(vag->sample_rate); + + str_ctx.db_active = 1; + str_ctx.next_chunk = -1; + + // Ensure at least one chunk is in SPU RAM by invoking the IRQ handler + // manually and blocking until the chunk has loaded. + spu_irq_handler(); + while (str_ctx.state != STATE_IDLE) + feed_stream(); +} + +void start_stream(void) { + int bits = 0x00ffffff >> (24 - NUM_CHANNELS); + + for (int i = 0; i < NUM_CHANNELS; i++) { + SPU_CH_ADDR(i) = getSPUAddr(str_ctx.spu_addr + str_ctx.buffer_size * i); + SPU_CH_FREQ(i) = getSPUSampleRate(str_ctx.sample_rate); + SPU_CH_ADSR1(i) = 0x80ff; + SPU_CH_ADSR2(i) = 0x1fee; + } + + // Unmute the channels and route them for stereo output. You'll want to + // edit this if you are using more than 2 channels, and/or if you want to + // provide an option to output mono audio instead of stereo. + SPU_CH_VOL_L(0) = 0x3fff; + SPU_CH_VOL_R(0) = 0x0000; + SPU_CH_VOL_L(1) = 0x0000; + SPU_CH_VOL_R(1) = 0x3fff; + + spu_irq_handler(); + SpuSetKey(1, bits); +} + +// This is basically a variant of reset_spu_channels() that only resets the +// channels used to play the stream, to (again) prevent them from triggering +// the SPU IRQ while the stream is paused. +void stop_stream(void) { + int bits = 0x00ffffff >> (24 - NUM_CHANNELS); + + SpuSetKey(0, bits); + + for (int i = 0; i < NUM_CHANNELS; i++) + SPU_CH_ADDR(i) = getSPUAddr(DUMMY_BLOCK_ADDR); + + SpuSetKey(1, bits); +} + +/* Main */ + +static RenderContext ctx; + +#define SHOW_STATUS(...) { FntPrint(-1, __VA_ARGS__); FntFlush(-1); display(&ctx); } +#define SHOW_ERROR(...) { SHOW_STATUS(__VA_ARGS__); while (1) __asm__("nop"); } + +static const char *state_strings[] = { "IDLE", "DATA NEEDED", "READING", "BUFFERING" }; + +int main(int argc, const char* argv[]) { + init_context(&ctx); + SpuInit(); + CdInit(); + reset_spu_channels(); + SHOW_STATUS(""); + + // Set up controller polling. + uint8_t pad_buff[2][34]; + InitPAD(pad_buff[0], 34, pad_buff[1], 34); + StartPAD(); + ChangeClearPAD(0); + + CdlFILE file; + SHOW_STATUS("OPENING STREAM FILE\n"); + if (!CdSearchFile(&file, "\\STREAM.VAG")) + SHOW_ERROR("FAILED TO FIND STREAM.VAG\n"); + + SHOW_STATUS("BUFFERING STREAM\n"); + init_stream(&file.pos); + start_stream(); + + int paused = 0, sample_rate = getSPUSampleRate(str_ctx.sample_rate); + + uint16_t last_buttons = 0xffff; + + while (1) { + feed_stream(); + + FntPrint(-1, "PLAYING SPU STREAM\n\n"); + FntPrint(-1, "BUFFER: %d\n", str_ctx.db_active); + FntPrint(-1, "STATUS: %s\n\n", state_strings[str_ctx.state]); + + FntPrint(-1, "POSITION: %d/%d\n", str_ctx.next_chunk, str_ctx.num_chunks); + FntPrint(-1, "SMP RATE: %5d HZ\n\n", (sample_rate * 44100) >> 12); + + FntPrint(-1, "[START] %s\n", paused ? "RESUME" : "PAUSE"); + FntPrint(-1, "[LEFT/RIGHT] SEEK\n"); + FntPrint(-1, "[O] RESET POSITION\n"); + FntPrint(-1, "[UP/DOWN] CHANGE SAMPLE RATE\n"); + FntPrint(-1, "[X] RESET SAMPLE RATE\n"); + + FntFlush(-1); + display(&ctx); + + // Check if a compatible controller is connected and handle button + // presses. + PADTYPE *pad = (PADTYPE *) pad_buff[0]; + if (pad->stat) + continue; + if ( + (pad->type != PAD_ID_DIGITAL) && + (pad->type != PAD_ID_ANALOG_STICK) && + (pad->type != PAD_ID_ANALOG) + ) + continue; + + if ((last_buttons & PAD_START) && !(pad->btn & PAD_START)) { + paused ^= 1; + if (paused) + stop_stream(); + else + start_stream(); + } + + if (!(pad->btn & PAD_LEFT)) + str_ctx.next_chunk--; + if (!(pad->btn & PAD_RIGHT)) + str_ctx.next_chunk++; + if ((last_buttons & PAD_CIRCLE) && !(pad->btn & PAD_CIRCLE)) + str_ctx.next_chunk = -1; + + if (!(pad->btn & PAD_DOWN) && (sample_rate > 0x400)) + sample_rate -= 0x40; + if (!(pad->btn & PAD_UP) && (sample_rate < 0x2000)) + sample_rate += 0x40; + if ((last_buttons & PAD_CROSS) && !(pad->btn & PAD_CROSS)) + sample_rate = getSPUSampleRate(str_ctx.sample_rate); + + // Only set the sample rate registers if necessary. + if (pad->btn != 0xffff) { + for (int i = 0; i < NUM_CHANNELS; i++) + SPU_CH_FREQ(i) = sample_rate; + } + + last_buttons = pad->btn; + } + + return 0; +} diff --git a/examples/sound/cdstream/stream.vag b/examples/sound/cdstream/stream.vag new file mode 100644 index 0000000..a6faf74 Binary files /dev/null and b/examples/sound/cdstream/stream.vag differ diff --git a/examples/sound/cdstream/system.cnf b/examples/sound/cdstream/system.cnf new file mode 100644 index 0000000..11ca055 --- /dev/null +++ b/examples/sound/cdstream/system.cnf @@ -0,0 +1,4 @@ +BOOT=cdrom:\cdstream.exe;1 +TCB=4 +EVENT=10 +STACK=801FFFF0 diff --git a/examples/sound/spustream/CMakeLists.txt b/examples/sound/spustream/CMakeLists.txt index 63d113b..465e291 100644 --- a/examples/sound/spustream/CMakeLists.txt +++ b/examples/sound/spustream/CMakeLists.txt @@ -5,20 +5,16 @@ cmake_minimum_required(VERSION 3.21) project( spustream - LANGUAGES C + LANGUAGES C ASM VERSION 1.0.0 - DESCRIPTION "PSn00bSDK SPU custom streaming example" + DESCRIPTION "PSn00bSDK SPU audio streaming example" HOMEPAGE_URL "http://lameguy64.net/?page=psn00bsdk" ) -# TODO: add rules to actually generate a valid STREAM.BIN file file(GLOB _sources *.c) psn00bsdk_add_executable(spustream GPREL ${_sources}) -psn00bsdk_add_cd_image(spustream_iso spustream iso.xml DEPENDS spustream) +#psn00bsdk_add_cd_image(spustream_iso spustream iso.xml DEPENDS spustream) -install( - FILES - ${PROJECT_BINARY_DIR}/spustream.bin - ${PROJECT_BINARY_DIR}/spustream.cue - TYPE BIN -) +psn00bsdk_target_incbin(spustream PRIVATE stream_data stream.vag) + +install(FILES ${PROJECT_BINARY_DIR}/spustream.exe TYPE BIN) diff --git a/examples/sound/spustream/convert_stream.py b/examples/sound/spustream/convert_stream.py deleted file mode 100644 index 1b1696f..0000000 --- a/examples/sound/spustream/convert_stream.py +++ /dev/null @@ -1,112 +0,0 @@ -#!/usr/bin/env python3 -# Simple .VAG to STREAM.BIN interleaving tool -# (C) 2021 spicyjpeg - MPL licensed - -import sys -from warnings import warn -from struct import Struct -from itertools import zip_longest -from argparse import ArgumentParser, FileType - -VAG_HEADER = Struct("> 4s I 4x 2I 12x 16s") -VAG_MAGIC = b"VAGp" -SAMPLE_RATE = 44100 -BUFFER_SIZE = 26624 # (26624 / 16 * 28) / 44100 = 1.05 seconds -ALIGN_SIZE = 2048 - -## Helpers - -def align(data, size): - chunks = (len(data) + size - 1) // size - - return data.ljust(chunks * size, b"\x00") - -def set_loop_flag(data): - last_block = bytearray(data[-16:]) - last_block[1] = 0x03 # Jump to loop point + sustain - - return data[:-16] + last_block - -## .VAG file reader - -def read_vag(_file, chunk_size): - with _file: - header = _file.read(VAG_HEADER.size) - ( - magic, - version, - size, - sample_rate, - name - ) = VAG_HEADER.unpack(header) - - #if magic != VAG_MAGIC: - #raise RuntimeError(f"{_file.name} is not a valid .VAG file") - if sample_rate != SAMPLE_RATE: - warn(RuntimeWarning(f"{_file.name} sample rate is not {SAMPLE_RATE} Hz")) - - for i in range(0, size, chunk_size): - chunk = _file.read(chunk_size) - - if len(chunk) % 16: - warn(RuntimeWarning(f"{_file.name} is not 16-byte aligned, trimming")) - chunk = chunk[0:len(chunk) // 16 * 16] - - chunk = set_loop_flag(chunk) - - yield chunk.ljust(chunk_size, b"\x00") - -## Main - -def get_args(): - parser = ArgumentParser( - description = "Generates interleaved stream data from one or more .VAG files." - ) - parser.add_argument( - "input_file", - nargs = "+", - type = FileType("rb"), - help = f"mono input files for each channel (must be {SAMPLE_RATE} Hz .VAG)" - ) - parser.add_argument( - "-o", "--output", - type = FileType("wb"), - default = "stream.bin", - help = "where to output converted stream data (stream.bin by default)", - metavar = "file" - ) - parser.add_argument( - "-b", "--buffer-size", - type = int, - default = BUFFER_SIZE, - help = f"size of each interleaved chunk (one per channel, default {BUFFER_SIZE})", - metavar = "bytes" - ) - parser.add_argument( - "-a", "--align", - type = int, - default = ALIGN_SIZE, - help = f"align each group of chunks to N bytes (default {ALIGN_SIZE})", - metavar = "bytes" - ) - - return parser.parse_args() - -def main(): - args = get_args() - if args.buffer_size % 16: - raise ValueError("buffer size must be a multiple of 16 bytes") - - interleave = zip_longest( - *( read_vag(_file, args.buffer_size) for _file in args.input_file ), - fillvalue = b"\x00" * args.buffer_size - ) - - with args.output as _file: - for chunks in interleave: - data = b"".join(chunks) - - _file.write(align(data, args.align)) - -if __name__ == "__main__": - main() diff --git a/examples/sound/spustream/interleave.py b/examples/sound/spustream/interleave.py new file mode 100644 index 0000000..4e68974 --- /dev/null +++ b/examples/sound/spustream/interleave.py @@ -0,0 +1,152 @@ +#!/usr/bin/env python3 +# Simple .VAG interleaving tool +# (C) 2021-2022 spicyjpeg - MPL licensed + +import os, sys +from warnings import warn +from struct import Struct +from itertools import zip_longest +from argparse import ArgumentParser, FileType + +VAG_HEADER = Struct("> 4s I 4s 2I 12x 16s") +VAG_MAGIC = b"VAGp" +VAGI_MAGIC = b"VAGi" +VAG_VERSION = 0x20 +BUFFER_SIZE = 0x1000 +CHUNK_ALIGN = 0x800 + +## Helpers + +def align(data, size): + chunks = (len(data) + size - 1) // size + + return data.ljust(chunks * size, b"\x00") + +def get_loop_offset(data): + for index, flag in enumerate(data[1::16]): + if flag & 0x01: + return index * 16 + + return len(data) - 16 + +## .VAG file reader + +class VAGReader: + def __init__(self, _file): + self.file = _file + header = _file.read(VAG_HEADER.size) + + ( + magic, _, _, + self.size, + self.sample_rate, + self.name + ) = VAG_HEADER.unpack(header) + + if magic == VAGI_MAGIC: + raise RuntimeError(f"{_file.name} is an interleaved .VAG file (must be mono)") + if magic != VAG_MAGIC: + raise RuntimeError(f"{_file.name} is not a valid .VAG file") + + def read(self, chunk_size): + for _ in range(0, self.size, chunk_size): + chunk = self.file.read(chunk_size) + + if len(chunk) < 16: + break + if len(chunk) % 16: + warn(RuntimeWarning(f"{self.file.name} is not 16-byte aligned, trimming")) + chunk = chunk[0:(len(chunk) // 16) * 16] + + # If there already is an end flag in the chunk replace it with a + # loop flag, otherwise add a new loop flag at the end. + end = get_loop_offset(chunk) + chunk = bytearray(chunk) + + chunk[end + 1] = 0x03 # Jump to loop point + sustain + yield chunk.ljust(chunk_size, b"\x00") + +## Main + +def get_args(): + parser = ArgumentParser( + description = "Generates interleaved audio stream data from one or more .VAG files." + ) + parser.add_argument( + "input_file", + nargs = "+", + type = FileType("rb"), + help = "mono input files for each channel in .VAG format" + ) + parser.add_argument( + "output_file", + type = FileType("wb"), + help = "where to output converted stream data" + ) + parser.add_argument( + "-b", "--buffer-size", + type = int, + default = BUFFER_SIZE, + help = f"size of each channel buffer in each chunk (default {BUFFER_SIZE})", + metavar = "bytes" + ) + parser.add_argument( + "-a", "--align", + type = int, + default = CHUNK_ALIGN, + help = f"pad each chunk to a multiple of the given size (default {CHUNK_ALIGN})", + metavar = "bytes" + ) + parser.add_argument( + "-r", "--raw", + action = "store_true", + help = "do not add an interleaved .VAG header to the output file" + ) + + return parser.parse_args() + +def main(): + args = get_args() + if args.buffer_size % 16: + raise ValueError("buffer size must be a multiple of 16 bytes") + if args.buffer_size % args.align: + warn(RuntimeWarning(f"buffer size should be a multiple of {args.align}")) + + input_files = tuple(map(VAGReader, args.input_file)) + size = input_files[0].size + sample_rate = input_files[0].sample_rate + + if (not args.raw) and (len(input_files) != 2): + warn(RuntimeWarning("interleaved .VAG only supports stereo (2 input files)")) + + for vag in input_files[1:]: + if vag.size != size: + warn(RuntimeWarning(f"{vag.file.name} has a different file size")) + if vag.sample_rate != sample_rate: + warn(RuntimeWarning(f"{vag.file.name} has a different sample rate")) + + interleave = zip_longest( + *( vag.read(args.buffer_size) for vag in input_files ), + fillvalue = b"\x00" * args.buffer_size + ) + + with args.output_file as _file: + if not args.raw: + header = VAG_HEADER.pack( + VAGI_MAGIC, + VAG_VERSION, + args.buffer_size.to_bytes(4, "little"), + size, + sample_rate, + os.path.basename(_file.name).encode()[0:16] + ) + + _file.write(align(header, args.align)) + + for chunks in interleave: + data = b"".join(chunks) + + _file.write(align(data, args.align)) + +if __name__ == "__main__": + main() diff --git a/examples/sound/spustream/iso.xml b/examples/sound/spustream/iso.xml deleted file mode 100644 index 050d673..0000000 --- a/examples/sound/spustream/iso.xml +++ /dev/null @@ -1,28 +0,0 @@ - - - - - - - - - - - - - - - - - diff --git a/examples/sound/spustream/main.c b/examples/sound/spustream/main.c index 1fee883..68cf9b0 100644 --- a/examples/sound/spustream/main.c +++ b/examples/sound/spustream/main.c @@ -1,111 +1,60 @@ /* - * PSn00bSDK SPU audio streaming example - * (C) 2021 spicyjpeg - MPL licensed + * PSn00bSDK SPU .VAG streaming example + * (C) 2022 spicyjpeg - MPL licensed * - * This example demonstrates how to play a large multi-channel audio file - * "manually" by streaming it through the SPU, without having to rely on the CD - * drive's ability to play audio tracks or XA files. + * This example shows how to play arbitrarily long sounds, which normally would + * not fit into SPU RAM in their entirety, by streaming them to the SPU from + * main RAM. In this example audio data is streamed from an in-memory file, + * however the code can easily be modified to stream from the CD instead (see + * the cdstream example). * - * The way this works is by splitting the audio file into a series of ~1 second - * "chunks", each of which in turn is an array of concatenated buffers holding - * SPU ADPCM data (one for each channel, so a stereo stream would have 2 - * buffers per chunk). All buffers in a chunk are played simultaneously using - * multiple SPU channels; each buffer has the loop flag set at the end, so each - * channel will jump to its loop address (SPU_CH_LOOP_ADDR(n)) once the chunk - * is played. + * The way SPU streaming works is by splitting the audio data into a series of + * small "chunks", each of which in turn is an array of concatenated buffers + * holding SPU ADPCM data (one for each channel, so a stereo stream would have + * 2 buffers per chunk). All buffers in a chunk are played simultaneously using + * multiple SPU channels; each buffer has the loop flag set at the end, so the + * SPU will jump to the loop point set in the SPU_CH_LOOP_ADDR registers after + * the chunk is played. * - * Since the loop point doesn't necessarily have to be within the chunk itself, - * we can abuse it to "queue" another set of buffers to be played immediately - * after the currently playing chunk. This allows us to fetch a chunk from the - * CD, upload it to SPU RAM (2048 bytes at a time to avoid having to keep - * another large buffer in main RAM) and queue it for playback while a - * previously buffered chunk is playing in the background. SPU RAM always holds - * two chunks, one of which is played while the other one is buffered. This is - * the layout used in this example: + * As the loop point doesn't necessarily have to be within the chunk itself, it + * can be used to "queue" another chunk to be played immediately after the + * current one. This allows for double buffering: two chunks are always kept in + * SPU RAM and one is overwritten with while the other is playing. Chunks are + * laid out in SPU RAM as follows: * - * /================================================\ - * | /==================\ | - * v Loop point | v Loop point | + * ________________________________________________ + * / __________________ \ + * | / \ | + * v Loop point | Loop flag v Loop point | Loop flag * +-------+----------------+----------------+----------------+----------------+ * | Dummy | Left buffer 0 | Right buffer 0 | Left buffer 1 | Right buffer 1 | * +-------+----------------+----------------+----------------+----------------+ * \____________Chunk 0____________/ \____________Chunk 1____________/ * - * It's pretty much the same thing as GPU double buffering (aka page flipping), - * just with chunks instead of framebuffers. + * In order to keep streaming continuously we need to know when each chunk + * actually starts playing. The SPU can be configured to trigger an interrupt + * whenever a specific address in SPU RAM is read by a channel, so we can just + * point it to the beginning of the buffered chunk's first buffer and wait + * until the IRQ is fired before loading the next chunk. * - * We need to know when the chunk we've buffered actually starts playing in - * order to start buffering the next one. The SPU can be configured to trigger - * an interrupt whenever a specific address in SPU RAM is read by a channel, so - * we can just point it to the beginning of the buffered chunk's first buffer. - * The interrupt callback will then kick off CD reading and adjust the loop/IRQ - * addresses to the ones of the chunk that is going to be buffered next. - * - * Chunks are read from a STREAM.BIN file which is just a series of sector - * aligned chunks, arranged as follows: - * - * +--Sector--+--Sector--+--Sector--+--Sector--+--Sector--+--Sector--+---- - * | +--------------------------+--------------------------+ | - * | | Left channel data | Right channel data | Padding | ... - * | +--------------------------+--------------------------+ | - * +----------+----------+----------+----------+----------+----------+---- - * \________________________Chunk________________________/ - * - * A Python script is included to generate STREAM.BIN from one or more SPU - * ADPCM (.VAG) files, one for each channel (the .VAG format only supports - * mono). - * - * Of course SPU streaming isn't the only way to play music, as the CD drive - * can play CD-DA tracks and XA files natively with zero CPU overhead. However - * streaming has a number of advantages over CD audio or XA: - * - * - Any sample rate up to 44.1 kHz can be used. The sample rate can also be - * changed on-the-fly to play the stream at different speeds and pitches (as - * long as the CD drive can keep up of course), or even interpolated for - * effects like tape stops or DJ scratches. - * - Manual streaming is not limited to mono or stereo but can be expanded to - * as many channels as needed, only limited by the amount of SPU RAM required - * for chunks and CD bandwidth. Having more than 2 channels can be useful for - * e.g. crossfading between tracks (not possible with XA) or controlling - * volume and panning of each individual instrument. - * - Depending on how streaming/interleaving is implemented it is possible to - * have 500-1000ms idle periods during which the CD drive isn't buffering the - * stream, that can be used to read small amounts of other data without ever - * interrupting playback. This is different from XA-style interleaving as the - * drive is free to seek to *any* region of the disc during these periods - * (it must seek back to the stream's next chunk afterwards though). - * - Thanks to the idle periods it is possible to seek back to the beginning of - * the stream and preload the first chunk before the end is reached, allowing - * the track to be looped seamlessly without having to resort to tricks like - * filler samples. - * - Unlike XA, SPU streaming can be used on some PS1-based arcade boards such - * as the Konami System 573. These systems usually use IDE/SCSI CD drives or - * flash memory, neither of which supports XA playback. + * Chunks are read from a special type of .VAG file which has been interleaved + * ahead-of-time and already contains the loop flags required to make streaming + * work. A Python script is provided to generate such file from one or more + * mono .VAG files. */ #include -#include -#include -#include +#include #include #include #include #include #include -#include #include -// To maximize STREAM.BIN packing efficiency and get rid of padding between -// chunks, buffer size should be a multiple of sector size (2048 bytes). Buffer -// size can be increased to get more idle time between CD reads, however it is -// usually best to keep it to 1-2 seconds as SPU RAM is only 512 KB. -#define SAMPLE_RATE 0x1000 // 44100 Hz -#define BUFFER_SIZE 0x6800 // (0x6800 / 16 * 28) / 44100 = 1.05 seconds - -#define NUM_CHANNELS 2 -#define CHANNEL_MASK 0x03 +extern const uint8_t stream_data[]; -#define SPU_RAM_ADDR(x) ((uint16_t) (((uint32_t) (x)) >> 3)) +#define NUM_CHANNELS 2 /* Display/GPU context utilities */ @@ -167,159 +116,137 @@ void display(RenderContext *ctx) { SetDispMask(1); } -/* Stream interrupt handlers */ +/* .VAG header structure */ -// The first 4 KB of SPU RAM are reserved for capture buffers, so we have to -// place stream buffers after those. A dummy sample is additionally placed by -// default by the SPU library at 0x1000; it is going to be used here to keep -// unused SPU channels busy, preventing them from accidentally triggering the -// SPU RAM interrupt and throwing off the timing (all channels are always -// reading sample data, even when "stopped"). +typedef struct { + uint32_t magic; // 0x69474156 ("VAGi") for interleaved files + uint32_t version; + uint32_t interleave; // Little-endian, size of each channel buffer + uint32_t size; // Big-endian, in bytes + uint32_t sample_rate; // Big-endian, in Hertz + uint32_t _reserved[3]; + char name[16]; +} VAG_Header; + +#define SWAP_ENDIAN(x) ( \ + (((uint32_t) (x) & 0x000000ff) << 24) | \ + (((uint32_t) (x) & 0x0000ff00) << 8) | \ + (((uint32_t) (x) & 0x00ff0000) >> 8) | \ + (((uint32_t) (x) & 0xff000000) >> 24) \ +) + +/* Interrupt callbacks */ + +// The first 4 KB of SPU RAM are reserved for capture buffers and psxspu +// additionally uploads a dummy sample (16 bytes) at 0x1000 by default, so the +// chunks must be placed after those. The dummy sample is going to be used to +// keep unused SPU channels busy, preventing them from accidentally triggering +// the SPU IRQ and throwing off the timing (all channels are always reading +// from SPU RAM, even when "stopped"). // https://problemkaputt.de/psx-spx.htm#spuinterrupt -#define DUMMY_BLOCK_ADDR 0x1000 -#define BUFFER_START_ADDR 0x1010 -#define CHUNK_SIZE (BUFFER_SIZE * NUM_CHANNELS) +#define DUMMY_BLOCK_ADDR 0x1000 +#define BUFFER_START_ADDR 0x1010 + +typedef enum { + STATE_IDLE, + STATE_BUFFERING +} StreamState; typedef struct { - int lba, length; + const uint8_t *data; + int buffer_size, num_chunks, sample_rate; - volatile int pos; - volatile int spu_addr, spu_pos; - volatile int db_active; + volatile int next_chunk, spu_addr; + volatile int8_t db_active, state; } StreamContext; static StreamContext str_ctx; -// This buffer is used by cd_event_handler() as a temporary area for sectors -// read from the CD and uploaded to SPU RAM. Due to DMA limitations it can't be -// allocated on the stack (especially not in the interrupt callbacks' stack, -// whose size is very limited). -static uint32_t sector_buffer[512]; - void spu_irq_handler(void) { // Acknowledge the interrupt to ensure it can be triggered again. The only // way to do this is actually to disable the interrupt entirely; we'll - // enable it again once the buffer is ready. + // enable it again once the chunk is ready. SPU_CTRL &= 0xffbf; - str_ctx.db_active ^= 1; - str_ctx.spu_pos = 0; + int chunk_size = str_ctx.buffer_size * NUM_CHANNELS; + int chunk = (str_ctx.next_chunk + 1) % (uint32_t) str_ctx.num_chunks; - // Align the sector counter to the size of a chunk (to prevent glitches - // after seeking) and reset it if it exceeds the stream's length. - str_ctx.pos %= str_ctx.length; - str_ctx.pos -= str_ctx.pos % ((CHUNK_SIZE + 2047) / 2048); + str_ctx.db_active ^= 1; + str_ctx.state = STATE_BUFFERING; + str_ctx.next_chunk = chunk; - // Configure to SPU to trigger an IRQ once the buffer that is going to be + // Configure to SPU to trigger an IRQ once the chunk that is going to be // filled now starts playing (so the next buffer can be loaded) and // override both channels' loop addresses to make them "jump" to the new - // buffer rather than actually looping when they encounter the loop flag at - // the end of the currently playing buffer. - str_ctx.spu_addr = BUFFER_START_ADDR + CHUNK_SIZE * str_ctx.db_active; - SPU_IRQ_ADDR = SPU_RAM_ADDR(str_ctx.spu_addr); + // buffers, rather than actually looping when they encounter the loop flag + // at the end of the currently playing buffers. + int addr = BUFFER_START_ADDR + (str_ctx.db_active ? chunk_size : 0); + str_ctx.spu_addr = addr; + SPU_IRQ_ADDR = getSPUAddr(addr); for (int i = 0; i < NUM_CHANNELS; i++) - SPU_CH_LOOP_ADDR(i) = SPU_RAM_ADDR(str_ctx.spu_addr + BUFFER_SIZE * i); + SPU_CH_LOOP_ADDR(i) = getSPUAddr(addr + str_ctx.buffer_size * i); - // Start loading the next chunk. cd_event_handler() will be called - // repeatedly for each sector until the entire chunk is read. - CdlLOC pos; - CdIntToPos(str_ctx.lba + str_ctx.pos, &pos); - CdControlF(CdlReadN, &pos); + // Start uploading the next chunk to the SPU. + SpuSetTransferStartAddr(addr); + SpuWrite((const uint32_t *) &str_ctx.data[chunk * chunk_size], chunk_size); } -void cd_event_handler(int event, uint8_t *payload) { - // Ignore all events other than a sector being ready. - // TODO: read errors should be handled properly - if (event != CdlDataReady) - return; - - // Fetch the sector that has been read from the drive. - CdGetSector(sector_buffer, 512); - str_ctx.pos++; - - // Set loop flags to make sure the buffer will loop (actually jump to the - // other buffer, as we're overriding loop addresses) at the end. - // NOTE: this isn't actually necessary here as the stream converter script - // already sets these flags in the file. - /*for (int i = 0; i < NUM_CHANNELS; i++) { - if ( - str_ctx.spu_pos >= (BUFFER_SIZE * i - 2048) && - str_ctx.spu_pos < (BUFFER_SIZE * i) - ) - sector_buffer[(BUFFER_SIZE * i - str_ctx.spu_pos) - 15] = 0x03; - }*/ - - // Copy the sector to SPU RAM, appending it to the buffer that is not - // playing currently. As the left and right buffers are adjacent, we can - // just treat the chunk as a single blob of data and copy it as-is; we only - // have to trim the padding at the end (if any) to avoid overwriting other - // data in SPU RAM. - size_t length = CHUNK_SIZE - str_ctx.spu_pos; - if (length > 2048) - length = 2048; - - SpuSetTransferStartAddr(str_ctx.spu_addr + str_ctx.spu_pos); - SpuWrite(sector_buffer, length); - str_ctx.spu_pos += length; - - // If the buffer has been filled completely, stop reading and re-enable the - // SPU IRQ. - if (str_ctx.spu_pos >= CHUNK_SIZE) { - CdControlF(CdlPause, 0); - SPU_CTRL |= 0x0040; - } +void spu_dma_handler(void) { + // Re-enable the SPU IRQ once the new chunk has been fully uploaded. + SPU_CTRL |= 0x0040; + + str_ctx.state = STATE_IDLE; } -/* Stream helpers */ +/* Helper functions */ // This isn't actually required for this example, however it is necessary if // you want to allocate the stream buffers into a region of SPU RAM that was // previously used (to make sure the IRQ isn't going to be triggered by any // inactive channels). void reset_spu_channels(void) { - SPU_KEY_OFF = 0x00ffffff; + SpuSetKey(0, 0x00ffffff); for (int i = 0; i < 24; i++) { - SPU_CH_ADDR(i) = SPU_RAM_ADDR(DUMMY_BLOCK_ADDR); + SPU_CH_ADDR(i) = getSPUAddr(DUMMY_BLOCK_ADDR); SPU_CH_FREQ(i) = 0x1000; } - SPU_KEY_ON = 0x00ffffff; + SpuSetKey(1, 0x00ffffff); } -void init_stream(CdlFILE *file) { +void init_stream(const VAG_Header *vag) { EnterCriticalSection(); - InterruptCallback(9, &spu_irq_handler); - CdReadyCallback(&cd_event_handler); + InterruptCallback(IRQ_SPU, &spu_irq_handler); + DMACallback(DMA_SPU, &spu_dma_handler); ExitCriticalSection(); - // Configure the CD drive to read 2048-byte sectors at 2x speed. - uint8_t mode = CdlModeSpeed; - CdControl(CdlSetmode, (const uint8_t *) &mode, 0); + int buf_size = vag->interleave; + + str_ctx.data = &((const uint8_t *) vag)[2048]; + str_ctx.buffer_size = buf_size; + str_ctx.num_chunks = (SWAP_ENDIAN(vag->size) + buf_size - 1) / buf_size; + str_ctx.sample_rate = SWAP_ENDIAN(vag->sample_rate); - // Set the initial LBA of the stream file, which is going to be incremented - // as the stream is played. - str_ctx.lba = CdPosToInt(&(file->pos)); - str_ctx.length = file->size / 2048; - str_ctx.pos = 0; + str_ctx.db_active = 1; + str_ctx.next_chunk = -1; - // Ensure at least one chunk is in SPU RAM by invoking the SPU IRQ handler + // Ensure at least one chunk is in SPU RAM by invoking the IRQ handler // manually and blocking until the chunk has loaded. - str_ctx.db_active = 1; spu_irq_handler(); - - while (str_ctx.spu_pos < CHUNK_SIZE) + while (str_ctx.state != STATE_IDLE) __asm__ volatile(""); } void start_stream(void) { - uint32_t addr = BUFFER_START_ADDR + CHUNK_SIZE * str_ctx.db_active; + int bits = 0x00ffffff >> (24 - NUM_CHANNELS); for (int i = 0; i < NUM_CHANNELS; i++) { - SPU_CH_ADDR(i) = SPU_RAM_ADDR(addr + BUFFER_SIZE * i); - SPU_CH_FREQ(i) = SAMPLE_RATE; - SPU_CH_ADSR(i) = 0x1fee80ff; + SPU_CH_ADDR(i) = getSPUAddr(str_ctx.spu_addr + str_ctx.buffer_size * i); + SPU_CH_FREQ(i) = getSPUSampleRate(str_ctx.sample_rate); + SPU_CH_ADSR1(i) = 0x80ff; + SPU_CH_ADSR2(i) = 0x1fee; } // Unmute the channels and route them for stereo output. You'll want to @@ -330,35 +257,31 @@ void start_stream(void) { SPU_CH_VOL_L(1) = 0x0000; SPU_CH_VOL_R(1) = 0x3fff; - SPU_KEY_ON = CHANNEL_MASK; spu_irq_handler(); + SpuSetKey(1, bits); } // This is basically a variant of reset_spu_channels() that only resets the // channels used to play the stream, to (again) prevent them from triggering // the SPU IRQ while the stream is paused. void stop_stream(void) { - SPU_KEY_OFF = CHANNEL_MASK; + int bits = 0x00ffffff >> (24 - NUM_CHANNELS); + + SpuSetKey(0, bits); for (int i = 0; i < NUM_CHANNELS; i++) - SPU_CH_ADDR(i) = SPU_RAM_ADDR(DUMMY_BLOCK_ADDR); + SPU_CH_ADDR(i) = getSPUAddr(DUMMY_BLOCK_ADDR); - SPU_KEY_ON = CHANNEL_MASK; + SpuSetKey(1, bits); } /* Main */ static RenderContext ctx; -#define SHOW_STATUS(...) { FntPrint(-1, __VA_ARGS__); FntFlush(-1); display(&ctx); } -#define SHOW_ERROR(...) { SHOW_STATUS(__VA_ARGS__); while (1) __asm__("nop"); } - int main(int argc, const char* argv[]) { init_context(&ctx); - - SHOW_STATUS("INITIALIZING\n"); SpuInit(); - CdInit(); reset_spu_channels(); // Set up controller polling. @@ -367,34 +290,19 @@ int main(int argc, const char* argv[]) { StartPAD(); ChangeClearPAD(0); - SHOW_STATUS("OPENING STREAM FILE\n"); - - CdlFILE file; - if (!CdSearchFile(&file, "\\STREAM.BIN")) - SHOW_ERROR("FAILED TO FIND STREAM.BIN\n"); - - SHOW_STATUS("BUFFERING STREAM\n"); - init_stream(&file); + init_stream((const VAG_Header *) stream_data); start_stream(); - int paused = 0; + int paused = 0, sample_rate = getSPUSampleRate(str_ctx.sample_rate); - uint16_t sample_rate = SAMPLE_RATE; uint16_t last_buttons = 0xffff; while (1) { FntPrint(-1, "PLAYING SPU STREAM\n\n"); + FntPrint(-1, "BUFFER: %d\n", str_ctx.db_active); + FntPrint(-1, "STATUS: %s\n\n", str_ctx.state ? "BUFFERING" : "IDLE"); - FntPrint(-1, "BUFFER: %d\nSTATUS: ", str_ctx.db_active); - if (str_ctx.spu_pos >= CHUNK_SIZE) - FntPrint(-1, "IDLE\n\n"); - else if (str_ctx.spu_pos) - FntPrint(-1, "BUFFERING\n\n"); - else - FntPrint(-1, "SEEKING\n\n"); - - FntPrint(-1, "POSITION: %5d/%5d\n", str_ctx.pos, str_ctx.length); - FntPrint(-1, "BUFFERED: %5d/%5d\n", str_ctx.spu_pos, CHUNK_SIZE); + FntPrint(-1, "POSITION: %d/%d\n", str_ctx.next_chunk, str_ctx.num_chunks); FntPrint(-1, "SMP RATE: %5d HZ\n\n", (sample_rate * 44100) >> 12); FntPrint(-1, "[START] %s\n", paused ? "RESUME" : "PAUSE"); @@ -411,7 +319,11 @@ int main(int argc, const char* argv[]) { PADTYPE *pad = (PADTYPE *) pad_buff[0]; if (pad->stat) continue; - if ((pad->type != 4) && (pad->type != 5) && (pad->type != 7)) + if ( + (pad->type != PAD_ID_DIGITAL) && + (pad->type != PAD_ID_ANALOG_STICK) && + (pad->type != PAD_ID_ANALOG) + ) continue; if ((last_buttons & PAD_START) && !(pad->btn & PAD_START)) { @@ -422,21 +334,19 @@ int main(int argc, const char* argv[]) { start_stream(); } - // Seeking by an arbitrary number of sectors isn't a problem as - // spu_irq_handler() always realigns the counter. if (!(pad->btn & PAD_LEFT)) - str_ctx.pos -= 16; + str_ctx.next_chunk--; if (!(pad->btn & PAD_RIGHT)) - str_ctx.pos += 16; + str_ctx.next_chunk++; if ((last_buttons & PAD_CIRCLE) && !(pad->btn & PAD_CIRCLE)) - str_ctx.pos = 0; + str_ctx.next_chunk = -1; if (!(pad->btn & PAD_DOWN) && (sample_rate > 0x400)) sample_rate -= 0x40; if (!(pad->btn & PAD_UP) && (sample_rate < 0x2000)) sample_rate += 0x40; if ((last_buttons & PAD_CROSS) && !(pad->btn & PAD_CROSS)) - sample_rate = SAMPLE_RATE; + sample_rate = getSPUSampleRate(str_ctx.sample_rate); // Only set the sample rate registers if necessary. if (pad->btn != 0xffff) { diff --git a/examples/sound/spustream/stream.bin b/examples/sound/spustream/stream.bin deleted file mode 100644 index e53b726..0000000 Binary files a/examples/sound/spustream/stream.bin and /dev/null differ diff --git a/examples/sound/spustream/stream.vag b/examples/sound/spustream/stream.vag new file mode 100644 index 0000000..e1cb4f4 Binary files /dev/null and b/examples/sound/spustream/stream.vag differ diff --git a/examples/sound/spustream/system.cnf b/examples/sound/spustream/system.cnf deleted file mode 100644 index 0c4561a..0000000 --- a/examples/sound/spustream/system.cnf +++ /dev/null @@ -1,4 +0,0 @@ -BOOT=cdrom:\spustrm.exe;1 -TCB=4 -EVENT=10 -STACK=801FFFF0 diff --git a/examples/sound/vagsample/3dfx.vag b/examples/sound/vagsample/3dfx.vag index 9284a9a..3a006bc 100644 Binary files a/examples/sound/vagsample/3dfx.vag and b/examples/sound/vagsample/3dfx.vag differ diff --git a/examples/sound/vagsample/main.c b/examples/sound/vagsample/main.c index c79e68e..6a60c19 100644 --- a/examples/sound/vagsample/main.c +++ b/examples/sound/vagsample/main.c @@ -1,280 +1,215 @@ -/* - * LibPSn00b Example Programs +/* + * PSn00bSDK SPU .VAG playback example + * (C) 2021-2022 Lameguy64, spicyjpeg - MPL licensed * - * VAG Playback Example - * 2019-2021 Meido-Tek Productions / PSn00bSDK Project + * This example demonstrates basic usage of the SPU. Two mono audio samples (in + * the standard PS1 .VAG format) are uploaded from main memory to SPU RAM and + * played on one of the 24 channels by manipulating the SPU's registers. The + * .VAG header is parsed to obtain the sample rate and data size, while the + * actual audio data does not need any processing as it is already encoded in + * the ADPCM format expected by the SPU. * - * This example program demonstrates the basic use of the SPU; uploading sound - * clips to SPU RAM and playing it back on one of 24 SPU voices (and possibly - * leave you with ears ringing from the cacophony). - * - * The PS1 SPU only supports playing back of specially encoded ADPCM samples - * natively and can play them at sample rates of up to 44.1KHz, so sound files - * will have to be converted to 'VAG' format before it can be used on the PS1. - * While it is possible to play plain PCM samples on the SPU, this requires - * some special trickery that involves abusing the echo buffer and is not - * supported by the (half-baked) SPU library of PSn00bSDK. - * - * Additionally, the SPU can only play ADPCM samples from its own local memory - * called the SPU RAM, so sound samples will have to be uploaded to SPU RAM - * before it can be played by the SPU. - * - * The included sound clips are by HighTreason610 (0proyt) and - * Lameguy64 (threedeeffeggzz) respectively. - * - * Example by Lameguy64 - * - * - * Changelog: - * - * October 6, 2021 - Initial version + * Note that PSn00bSDK does not yet provide any tool for SPU ADPCM encoding, so + * you will have to use an external program to convert your samples to .VAG. * + * The included sound clips are by HighTreason610 (proyt.vag) and Lameguy64 + * (3dfx.vag) respectively. */ - -#include + #include -#include -#include #include -#include #include +#include #include #include -extern const unsigned char proyt[]; -extern const int proyt_size; -extern const unsigned char tdfx[]; -extern const int tdfx_size; - -// Define display/draw environments for double buffering -DISPENV disp[2]; -DRAWENV draw[2]; -int db; - -unsigned char pad_buff[2][34]; - -// SPU addresses of the uploaded sound clips -int proyt_addr; -int tdfx_addr; - -// Init function -void init(void) -{ - int addr_temp; - - // This not only resets the GPU but it also installs the library's - // ISR subsystem to the kernel +extern const uint8_t proyt[]; +extern const uint8_t tdfx[]; + +/* Display/GPU context utilities */ + +#define SCREEN_XRES 320 +#define SCREEN_YRES 240 + +#define BGCOLOR_R 48 +#define BGCOLOR_G 24 +#define BGCOLOR_B 0 + +typedef struct { + DISPENV disp; + DRAWENV draw; +} Framebuffer; + +typedef struct { + Framebuffer db[2]; + int db_active; +} RenderContext; + +void init_context(RenderContext *ctx) { + Framebuffer *db; + ResetGraph(0); - - // Define display environments, first on top and second on bottom - SetDefDispEnv(&disp[0], 0, 0, 320, 240); - SetDefDispEnv(&disp[1], 0, 240, 320, 240); - - // Define drawing environments, first on bottom and second on top - SetDefDrawEnv(&draw[0], 0, 240, 320, 240); - SetDefDrawEnv(&draw[1], 0, 0, 320, 240); - - // Set and enable clear color - setRGB0(&draw[0], 0, 96, 0); - setRGB0(&draw[1], 0, 96, 0); - draw[0].isbg = 1; - draw[1].isbg = 1; - - // Clear double buffer counter - db = 0; - - // Apply the GPU environments - PutDispEnv(&disp[db]); - PutDrawEnv(&draw[db]); - - // Load test font + ctx->db_active = 0; + + db = &(ctx->db[0]); + SetDefDispEnv(&(db->disp), 0, 0, SCREEN_XRES, SCREEN_YRES); + SetDefDrawEnv(&(db->draw), SCREEN_XRES, 0, SCREEN_XRES, SCREEN_YRES); + setRGB0(&(db->draw), BGCOLOR_R, BGCOLOR_G, BGCOLOR_B); + db->draw.isbg = 1; + db->draw.dtd = 1; + + db = &(ctx->db[1]); + SetDefDispEnv(&(db->disp), SCREEN_XRES, 0, SCREEN_XRES, SCREEN_YRES); + SetDefDrawEnv(&(db->draw), 0, 0, SCREEN_XRES, SCREEN_YRES); + setRGB0(&(db->draw), BGCOLOR_R, BGCOLOR_G, BGCOLOR_B); + db->draw.isbg = 1; + db->draw.dtd = 1; + + PutDrawEnv(&(db->draw)); + //PutDispEnv(&(db->disp)); + + // Create a text stream at the top of the screen. FntLoad(960, 0); - - // Open up a test font text stream of 100 characters - FntOpen(0, 8, 320, 224, 0, 100); - - // Initialize the SPU - SpuInit(); - - // Set SPU transfer mode to DMA (only mode currently supported) + FntOpen(8, 16, 304, 208, 2, 512); +} + +void display(RenderContext *ctx) { + Framebuffer *db; + + DrawSync(0); + VSync(0); + ctx->db_active ^= 1; + + db = &(ctx->db[ctx->db_active]); + PutDrawEnv(&(db->draw)); + PutDispEnv(&(db->disp)); + SetDispMask(1); +} + +/* .VAG header structure */ + +typedef struct { + uint32_t magic; // 0x70474156 ("VAGp") for mono files + uint32_t version; + uint32_t interleave; // Unused in mono files + uint32_t size; // Big-endian, in bytes + uint32_t sample_rate; // Big-endian, in Hertz + uint32_t _reserved[3]; + char name[16]; +} VAG_Header; + +#define SWAP_ENDIAN(x) ( \ + (((uint32_t) (x) & 0x000000ff) << 24) | \ + (((uint32_t) (x) & 0x0000ff00) << 8) | \ + (((uint32_t) (x) & 0x00ff0000) >> 8) | \ + (((uint32_t) (x) & 0xff000000) >> 24) \ +) + +/* Helper functions */ + +// The first 4 KB of SPU RAM are reserved for capture buffers and psxspu +// additionally uploads a dummy sample (16 bytes) at 0x1000 by default, so the +// samples must be placed after those. +#define ALLOC_START_ADDR 0x1010 + +static int next_channel = 0; +static int next_sample_addr = ALLOC_START_ADDR; + +int upload_sample(const void *data, int size) { + // Round the size up to the nearest multiple of 64, as SPU DMA transfers + // are done in 64-byte blocks. + int _addr = next_sample_addr; + int _size = (size + 63) & 0xffffffc0; + SpuSetTransferMode(SPU_TRANSFER_BY_DMA); - - // Set SPU transfer address (start address for sample upload) - addr_temp = 0x1000; - SpuSetTransferStartAddr(addr_temp); - - // Upload first sound clip and wait for transfer to finish - SpuWrite((const uint32_t *) &proyt[48], proyt_size-48); - SpuIsTransferCompleted(SPU_TRANSFER_WAIT); - - // Obtain the address of the sound and advance address for the next one - // Samples are addressed in 8-byte units, so it'll have to be divided by 8 - proyt_addr = addr_temp/8; - addr_temp += proyt_size-48; - - printf("proyt.vag\t= %02x\n", proyt_addr); - - // Upload second sound clip - SpuSetTransferStartAddr(addr_temp); - SpuWrite((const uint32_t *) &tdfx[48], tdfx_size-48); + SpuSetTransferStartAddr(_addr); + + SpuWrite((const uint32_t *) data, _size); SpuIsTransferCompleted(SPU_TRANSFER_WAIT); - - // Obtain the address of the second sound clip - tdfx_addr = addr_temp/8; - addr_temp += tdfx_size-48; - - printf("3dfx.vag\t= %02x\n", tdfx_addr); - - // Begin pad polling - InitPAD( pad_buff[0], 34, pad_buff[1], 34 ); + + next_sample_addr = _addr + _size; + return _addr; +} + +void play_sample(int addr, int sample_rate) { + int ch = next_channel; + + // Make sure the channel is stopped. + SpuSetKey(0, 1 << ch); + + // Set the channel's sample rate and start address. Note that the SPU + // expects the sample rate to be in 4.12 fixed point format (with + // 1.0 = 44100 Hz) and the address in 8-byte units; psxspu.h provides the + // getSPUSampleRate() and getSPUAddr() macros to convert values to these + // units. + SPU_CH_FREQ(ch) = getSPUSampleRate(sample_rate); + SPU_CH_ADDR(ch) = getSPUAddr(addr); + + // Set the channel's volume and ADSR parameters (0x80ff and 0x1fee are + // dummy values that disable the ADSR envelope entirely). + SPU_CH_VOL_L(ch) = 0x3fff; + SPU_CH_VOL_R(ch) = 0x3fff; + SPU_CH_ADSR1(ch) = 0x80ff; + SPU_CH_ADSR2(ch) = 0x1fee; + + // Start the channel. + SpuSetKey(1, 1 << ch); + + next_channel = (ch + 1) % 24; +} + +/* Main */ + +static RenderContext ctx; + +int main(int argc, const char* argv[]) { + init_context(&ctx); + SpuInit(); + + // Upload the samples to the SPU and parse their headers. + VAG_Header *proyt_vag = (VAG_Header *) proyt; + VAG_Header *tdfx_vag = (VAG_Header *) tdfx; + + int proyt_addr = upload_sample(&proyt_vag[1], SWAP_ENDIAN(proyt_vag->size)); + int tdfx_addr = upload_sample(&tdfx_vag[1], SWAP_ENDIAN(tdfx_vag->size)); + int proyt_sr = SWAP_ENDIAN(proyt_vag->sample_rate); + int tdfx_sr = SWAP_ENDIAN(tdfx_vag->sample_rate); + + // Set up controller polling. + uint8_t pad_buff[2][34]; + InitPAD(pad_buff[0], 34, pad_buff[1], 34); StartPAD(); ChangeClearPAD(0); -} /* init */ - -// Display function -void display(void) -{ - // Flip buffer index - db = !db; - - // Wait for all drawing to complete - DrawSync(0); - - // Wait for vertical sync to cap the logic to 60fps (or 50 in PAL mode) - // and prevent screen tearing - VSync(0); - // Switch pages - PutDispEnv(&disp[db]); - PutDrawEnv(&draw[db]); - - // Enable display output, ResetGraph() disables it by default - SetDispMask(1); - -} /* main */ - -// Main function, program entrypoint -int main(int argc, const char *argv[]) -{ - int counter,nextchan; - int cross_pressed; - int circle_pressed; - PADTYPE *pad; - - // Init stuff - init(); - - // Main loop - counter = 0; - nextchan = 0; - cross_pressed = 0; - circle_pressed = 0; - - while(1) - { - pad = (PADTYPE*)&pad_buff[0][0]; - - if( pad->stat == 0 ) - { - // For digital pad, dual-analog and dual-shock - if( ( pad->type == 0x4 ) || ( pad->type == 0x5 ) || ( pad->type == 0x7 ) ) - { - // Plays the first sound - if( !(pad->btn&PAD_CROSS) ) - { - if( !cross_pressed ) - { - // Voice frequency - // (800h = 22.05KHz) - SPU_CH_FREQ(nextchan) = 0x800; - // Voice start playback address - // (transfer address / 8) - SPU_CH_ADDR(nextchan) = proyt_addr; - // Voice loop address - // (transfer address / 8) - SPU_CH_LOOP_ADDR(nextchan) = proyt_addr; - // Voice volume and envelope - SPU_CH_VOL_L(nextchan) = 0x3fff; - SPU_CH_VOL_R(nextchan) = 0x3fff; - SPU_CH_ADSR(nextchan) = 0x1fee80ff; - - // Set voice to key-off to allow restart - SPU_KEY_OFF = 1 << nextchan; - // Set voice to key-on - SPU_KEY_ON = 1 << nextchan; - - // Advance to next voice - nextchan++; - if( nextchan > 23 ) - nextchan = 0; - - cross_pressed = 1; - } - } - else - { - cross_pressed = 0; - } - - // Plays the second sound - if( !(pad->btn&PAD_CIRCLE) ) - { - if( !circle_pressed ) - { - // Voice frequency - // (1000h = 44.1KHz) - SPU_CH_FREQ(nextchan) = 0x1000; - // Voice start playback address - // (transfer address / 8) - SPU_CH_ADDR(nextchan) = tdfx_addr; - // Voice loop address - // (transfer address / 8) - SPU_CH_LOOP_ADDR(nextchan) = tdfx_addr; - // Voice volume and envelope - SPU_CH_VOL_L(nextchan) = 0x3fff; - SPU_CH_VOL_R(nextchan) = 0x3fff; - SPU_CH_ADSR(nextchan) = 0x1fee80ff; - - // Set voice to key-off to allow restart - SPU_KEY_OFF = 1 << nextchan; - // Set voice to key-on - SPU_KEY_ON = 1 << nextchan; - - // Advance to next voice - nextchan++; - if( nextchan > 23 ) - nextchan = 0; - - circle_pressed = 1; - } - } - else - { - circle_pressed = 0; - } - } - } - else - { - cross_pressed = 0; - circle_pressed = 0; - } - - // Print the obligatory hello world and counter to show that the - // program isn't locking up to the last created text stream - FntPrint(-1, "VAG SAMPLE - PRESS X OR O TO PLAY\n"); - FntPrint(-1, "COUNTER=%d\n", counter); - - // Draw the last created text stream + uint16_t last_buttons = 0xffff; + + while (1) { + FntPrint(-1, "SPU SAMPLE PLAYBACK DEMO\n\n"); + FntPrint(-1, "[X] PLAY FIRST SAMPLE\n"); + FntPrint(-1, "[O] PLAY SECOND SAMPLE\n"); + FntFlush(-1); - - // Update display - display(); - - // Increment the counter - counter++; + display(&ctx); + + // Check if a compatible controller is connected and handle button + // presses. + PADTYPE *pad = (PADTYPE *) pad_buff[0]; + if (pad->stat) + continue; + if ( + (pad->type != PAD_ID_DIGITAL) && + (pad->type != PAD_ID_ANALOG_STICK) && + (pad->type != PAD_ID_ANALOG) + ) + continue; + + if ((last_buttons & PAD_CROSS) && !(pad->btn & PAD_CROSS)) + play_sample(proyt_addr, proyt_sr); + if ((last_buttons & PAD_CIRCLE) && !(pad->btn & PAD_CIRCLE)) + play_sample(tdfx_addr, tdfx_sr); + + last_buttons = pad->btn; } - + return 0; - -} /* main */ +} diff --git a/examples/sound/vagsample/proyt.vag b/examples/sound/vagsample/proyt.vag index 663828d..b8d68d6 100644 Binary files a/examples/sound/vagsample/proyt.vag and b/examples/sound/vagsample/proyt.vag differ diff --git a/libpsn00b/include/hwregs_a.inc b/libpsn00b/include/hwregs_a.inc index c78b41a..ca38542 100644 --- a/libpsn00b/include/hwregs_a.inc +++ b/libpsn00b/include/hwregs_a.inc @@ -32,12 +32,18 @@ .set SPU_MASTER_VOL_R, 0x1d82 .set SPU_REVERB_VOL_L, 0x1d84 .set SPU_REVERB_VOL_R, 0x1d86 -.set SPU_KEY_ON, 0x1d88 -.set SPU_KEY_OFF, 0x1d8c -.set SPU_FM_MODE, 0x1d90 -.set SPU_NOISE_MODE, 0x1d94 -.set SPU_REVERB_ON, 0x1d98 -.set SPU_CHAN_STATUS, 0x1d9c +.set SPU_KEY_ON1, 0x1d88 +.set SPU_KEY_ON1, 0x1d8a +.set SPU_KEY_OFF1, 0x1d8c +.set SPU_KEY_OFF2, 0x1d8e +.set SPU_FM_MODE1, 0x1d90 +.set SPU_FM_MODE2, 0x1d92 +.set SPU_NOISE_MODE1, 0x1d94 +.set SPU_NOISE_MODE2, 0x1d96 +.set SPU_REVERB_ON1, 0x1d98 +.set SPU_REVERB_ON2, 0x1d9a +.set SPU_CHAN_STATUS1, 0x1d9c +.set SPU_CHAN_STATUS2, 0x1d9e .set SPU_REVERB_ADDR, 0x1da2 .set SPU_IRQ_ADDR, 0x1da4 @@ -59,8 +65,8 @@ .set SPU_VOICE_VOL_R, 0x02 .set SPU_VOICE_FREQ, 0x04 .set SPU_VOICE_ADDR, 0x06 -.set SPU_VOICE_ADSR_L, 0x08 -.set SPU_VOICE_ADSR_H, 0x0a +.set SPU_VOICE_ADSR1, 0x08 +.set SPU_VOICE_ADSR2, 0x0a .set SPU_VOICE_LOOP, 0x0e ## MDEC diff --git a/libpsn00b/include/hwregs_c.h b/libpsn00b/include/hwregs_c.h index b205b87..0e21922 100644 --- a/libpsn00b/include/hwregs_c.h +++ b/libpsn00b/include/hwregs_c.h @@ -38,12 +38,18 @@ #define SPU_MASTER_VOL_R _MMIO16(IOBASE | 0x1d82) #define SPU_REVERB_VOL_L _MMIO16(IOBASE | 0x1d84) #define SPU_REVERB_VOL_R _MMIO16(IOBASE | 0x1d86) -#define SPU_KEY_ON _MMIO32(IOBASE | 0x1d88) -#define SPU_KEY_OFF _MMIO32(IOBASE | 0x1d8c) -#define SPU_FM_MODE _MMIO32(IOBASE | 0x1d90) -#define SPU_NOISE_MODE _MMIO32(IOBASE | 0x1d94) -#define SPU_REVERB_ON _MMIO32(IOBASE | 0x1d98) -#define SPU_CHAN_STATUS _MMIO32(IOBASE | 0x1d9c) +#define SPU_KEY_ON1 _MMIO16(IOBASE | 0x1d88) +#define SPU_KEY_ON2 _MMIO16(IOBASE | 0x1d8a) +#define SPU_KEY_OFF1 _MMIO16(IOBASE | 0x1d8c) +#define SPU_KEY_OFF2 _MMIO16(IOBASE | 0x1d8e) +#define SPU_FM_MODE1 _MMIO16(IOBASE | 0x1d90) +#define SPU_FM_MODE2 _MMIO16(IOBASE | 0x1d92) +#define SPU_NOISE_MODE1 _MMIO16(IOBASE | 0x1d94) +#define SPU_NOISE_MODE2 _MMIO16(IOBASE | 0x1d96) +#define SPU_REVERB_ON1 _MMIO16(IOBASE | 0x1d98) +#define SPU_REVERB_ON2 _MMIO16(IOBASE | 0x1d9a) +#define SPU_CHAN_STATUS1 _MMIO16(IOBASE | 0x1d9c) +#define SPU_CHAN_STATUS2 _MMIO16(IOBASE | 0x1d9e) #define SPU_REVERB_ADDR _MMIO16(IOBASE | 0x1da2) #define SPU_IRQ_ADDR _MMIO16(IOBASE | 0x1da4) @@ -67,7 +73,8 @@ #define SPU_CH_VOL_R(N) _MMIO16(IOBASE | 0x1c02 + 16 * (N)) #define SPU_CH_FREQ(N) _MMIO16(IOBASE | 0x1c04 + 16 * (N)) #define SPU_CH_ADDR(N) _MMIO16(IOBASE | 0x1c06 + 16 * (N)) -#define SPU_CH_ADSR(N) _MMIO32(IOBASE | 0x1c08 + 16 * (N)) +#define SPU_CH_ADSR1(N) _MMIO16(IOBASE | 0x1c08 + 16 * (N)) +#define SPU_CH_ADSR2(N) _MMIO16(IOBASE | 0x1c0a + 16 * (N)) #define SPU_CH_LOOP_ADDR(N) _MMIO16(IOBASE | 0x1c0e + 16 * (N)) /* MDEC */ diff --git a/libpsn00b/include/psxspu.h b/libpsn00b/include/psxspu.h index 05737f7..cdc3ac7 100644 --- a/libpsn00b/include/psxspu.h +++ b/libpsn00b/include/psxspu.h @@ -111,11 +111,19 @@ typedef struct _SpuCommonAttr { (SPU_CH_FREQ(ch) = (pitch)) #define SpuSetVoiceStartAddr(ch, addr) \ (SPU_CH_ADDR(ch) = getSPUAddr(addr)) -#define SpuSetVoiceADSR(ch, ar, dr, sr, rr, sl) \ - (SPU_CH_ADSR(ch) = getSPUADSR(ar, dr, sr, rr, sl)) +#define SpuSetVoiceADSR(ch, ar, dr, sr, rr, sl) ( \ + SPU_CH_ADSR1(ch) = (sl) | ((dr) << 4) | ((ar) << 8), \ + SPU_CH_ADSR2(ch) = (rr) | ((sr) << 6) | (1 << 14) \ +) #define SpuSetKey(enable, voice_bit) \ - ((enable) ? (SPU_KEY_ON = (voice_bit)) : (SPU_KEY_OFF = (voice_bit))) + ((enable) ? ( \ + SPU_KEY_ON1 = (uint16_t) (voice_bit), \ + SPU_KEY_ON2 = (uint16_t) ((voice_bit) >> 16) \ + ) : ( \ + SPU_KEY_OFF1 = (uint16_t) (voice_bit), \ + SPU_KEY_OFF2 = (uint16_t) ((voice_bit) >> 16) \ + )) /* Public API */ diff --git a/libpsn00b/psxspu/common.c b/libpsn00b/psxspu/common.c index ca4b201..d1dabfe 100644 --- a/libpsn00b/psxspu/common.c +++ b/libpsn00b/psxspu/common.c @@ -105,10 +105,14 @@ void SpuInit(void) { SPU_MASTER_VOL_R = 0; SPU_REVERB_VOL_L = 0; SPU_REVERB_VOL_R = 0; - SPU_KEY_OFF = 0x00ffffff; - SPU_FM_MODE = 0; - SPU_NOISE_MODE = 0; - SPU_REVERB_ON = 0; + SPU_KEY_OFF1 = 0xffff; + SPU_KEY_OFF2 = 0x00ff; + SPU_FM_MODE1 = 0; + SPU_FM_MODE2 = 0; + SPU_NOISE_MODE1 = 0; + SPU_NOISE_MODE2 = 0; + SPU_REVERB_ON1 = 0; + SPU_REVERB_ON2 = 0; SPU_REVERB_ADDR = 0xfffe; SPU_CD_VOL_L = 0; SPU_CD_VOL_R = 0; @@ -140,7 +144,8 @@ void SpuInit(void) { // Sony's implementation leaves everything muted, however it makes sense to // turn up at least the master and CD audio volume by default. - SPU_KEY_ON = 0x00ffffff; + SPU_KEY_ON1 = 0xffff; + SPU_KEY_ON2 = 0x00ff; SPU_MASTER_VOL_L = 0x3fff; SPU_MASTER_VOL_R = 0x3fff; SPU_CD_VOL_L = 0x7fff; -- cgit v1.2.3