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() --- CHANGELOG.md | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) (limited to 'CHANGELOG.md') diff --git a/CHANGELOG.md b/CHANGELOG.md index 461d2b8..fb40eb6 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -19,7 +19,19 @@ to ensure the changelog can be parsed correctly. ------------------------------------------------------------------------------- -## 2022-10-16: 0.21 +## 2022-10-19: 0.21 + +spicyjpeg: + +- libpsn00b: Cleaned up the internal logging system. + +- psxgpu: Added `MoveImage()` as well as `MoveImage2()`, `LoadImage2()` and + `StoreImage2()`. `LoadImage()` and `StoreImage()` now make use of the + library's internal drawing queue instead of blocking. Added `EnqueueDrawOp()` + for more advanced control of the drawing queue. The `getTPage()` macro now + supports extended Y coordinates (512-1023) on systems with 2 MB of VRAM. + +## 2022-10-16 spicyjpeg: -- cgit v1.2.3 From b1632d7df0e840692612461a80d0e05d6a3228ed Mon Sep 17 00:00:00 2001 From: spicyjpeg Date: Fri, 21 Oct 2022 13:24:54 +0200 Subject: Rewrite psxsio with new API, fix compiler warnings --- CHANGELOG.md | 6 +- libpsn00b/include/assert.h | 7 +- libpsn00b/include/psxsio.h | 258 +++++++++++++++++++++++++++++++-------- libpsn00b/libc/memset.s | 5 + libpsn00b/psxcd/isofs.c | 1 + libpsn00b/psxetc/dl.c | 3 +- libpsn00b/psxgpu/common.c | 68 ++++++----- libpsn00b/psxsio/_sio_control.s | 184 ---------------------------- libpsn00b/psxsio/sio.c | 263 ++++++++++++++++++++++++++++++++++++++++ libpsn00b/psxsio/siocons.c | 220 --------------------------------- libpsn00b/psxsio/tty.c | 107 ++++++++++++++++ 11 files changed, 631 insertions(+), 491 deletions(-) delete mode 100644 libpsn00b/psxsio/_sio_control.s create mode 100644 libpsn00b/psxsio/sio.c delete mode 100644 libpsn00b/psxsio/siocons.c create mode 100644 libpsn00b/psxsio/tty.c (limited to 'CHANGELOG.md') diff --git a/CHANGELOG.md b/CHANGELOG.md index fb40eb6..e9d7e16 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -19,7 +19,7 @@ to ensure the changelog can be parsed correctly. ------------------------------------------------------------------------------- -## 2022-10-19: 0.21 +## 2022-10-21: 0.21 spicyjpeg: @@ -31,6 +31,10 @@ spicyjpeg: for more advanced control of the drawing queue. The `getTPage()` macro now supports extended Y coordinates (512-1023) on systems with 2 MB of VRAM. +- psxsio: Removed `_sio_control()` and replaced it with a completely new + asynchronous buffered serial port driver. Rewritten the serial TTY driver to + make use of the new API. + ## 2022-10-16 spicyjpeg: diff --git a/libpsn00b/include/assert.h b/libpsn00b/include/assert.h index eabe369..e93c983 100644 --- a/libpsn00b/include/assert.h +++ b/libpsn00b/include/assert.h @@ -9,6 +9,9 @@ #ifndef __ASSERT_H #define __ASSERT_H +void _assert_abort(const char *file, int line, const char *expr); +void _sdk_log_inner(const char *fmt, ...); + #ifdef NDEBUG #define assert(expr) @@ -16,12 +19,10 @@ #else -void _assert_abort(const char *file, int line, const char *expr); -void _sdk_log_inner(const char *fmt, ...); - #define assert(expr) { \ if (!(expr)) _assert_abort(__FILE__, __LINE__, #expr); \ } + #ifdef SDK_LIBRARY_NAME #define _sdk_log(fmt, ...) _sdk_log_inner(SDK_LIBRARY_NAME ": " fmt, ##__VA_ARGS__) #else diff --git a/libpsn00b/include/psxsio.h b/libpsn00b/include/psxsio.h index 3f571d7..e0cc49b 100644 --- a/libpsn00b/include/psxsio.h +++ b/libpsn00b/include/psxsio.h @@ -1,64 +1,220 @@ +/* + * PSn00bSDK serial port library + * (C) 2019-2022 Lameguy64, spicyjpeg - MPL licensed + */ + #ifndef __PSXSIO_H #define __PSXSIO_H -#define SR_TXRDY 0x1 -#define SR_RXRDY 0x2 -#define SR_TXU 0x4 -#define SR_PERROR 0x8 -#define SR_OE 0x10 -#define SR_FE 0x20 -#define SR_DSR 0x80 -#define SR_CTS 0x100 -#define SR_IRQ 0x200 - -#define SIO_TXRDY 0x1 -#define SIO_RXRDY 0x2 -#define SIO_TXU 0x4 -#define SIO_PERROR 0x8 -#define SIO_OE 0x10 -#define SIO_FE 0x20 -#define SIO_DSR 0x80 -#define SIO_CTS 0x100 -#define SIO_IRQ 0x200 - -#define MR_CHLEN_5 0x00 -#define MR_CHLEN_6 0x04 -#define MR_CHLEN_7 0x08 -#define MR_CHLEN_8 0x0C -#define MR_PEN 0x10 -#define MR_P_EVEN 0x30 -#define MR_SB_01 0x40 -#define MR_SB_10 0x80 -#define MR_SB_11 0xc0 - -#define CR_TXEN 0x1 -#define CR_DTR 0x2 -#define CR_RXEN 0x4 -#define CR_BRK 0x8 -#define CR_INTRST 0x10 -#define CR_RTS 0x20 -#define CR_ERRRST 0x40 -#define CR_BUFSZ_1 0x00 -#define CR_BUFSZ_2 0x100 -#define CR_BUFSZ_4 0x200 -#define CR_BUFSZ_8 0x300 -#define CR_TXIEN 0x400 -#define CR_RXIEN 0x800 -#define CR_DSRIEN 0x1000 +#include + +/* Register definitions (used internally) */ + +typedef enum _SIO_StatusRegFlag { + SR_TXRDY = 1 << 0, + SR_RXRDY = 1 << 1, + SR_TXU = 1 << 2, + SR_PERROR = 1 << 3, + SR_OE = 1 << 4, + SR_FE = 1 << 5, + SR_DSR = 1 << 7, + SR_CTS = 1 << 8, + SR_IRQ = 1 << 9 +} SIO_StatusRegFlag; + +typedef enum _SIO_ModeRegFlag { + MR_BR_1 = 1 << 0, + MR_BR_16 = 2 << 0, + MR_BR_64 = 3 << 0, + MR_CHLEN_5 = 0 << 2, + MR_CHLEN_6 = 1 << 2, + MR_CHLEN_7 = 2 << 2, + MR_CHLEN_8 = 3 << 2, + MR_PEN = 1 << 4, + MR_P_EVEN = 1 << 5, + MR_SB_01 = 1 << 6, + MR_SB_10 = 2 << 6, + MR_SB_11 = 3 << 6 +} SIO_ModeRegFlag; + +typedef enum _SIO_ControlRegFlag { + CR_TXEN = 1 << 0, + CR_DTR = 1 << 1, + CR_RXEN = 1 << 2, + CR_BRK = 1 << 3, + CR_INTRST = 1 << 4, + CR_RTS = 1 << 5, + CR_ERRRST = 1 << 6, + CR_BUFSZ_1 = 0 << 8, + CR_BUFSZ_2 = 1 << 8, + CR_BUFSZ_4 = 2 << 8, + CR_BUFSZ_8 = 3 << 8, + CR_TXIEN = 1 << 10, + CR_RXIEN = 1 << 11, + CR_DSRIEN = 1 << 12 +} SIO_ControlRegFlag; + +typedef enum _SIO_FlowControl { + SIO_FC_NONE = 0, + SIO_FC_RTS_CTS = 1 + //SIO_FC_DTR_DSR = 2 +} SIO_FlowControl; + +/* Public API */ #ifdef __cplusplus extern "C" { #endif -int _sio_control(int cmd, int arg, int param); -void AddSIO(int baud); -void DelSIO(void); +/** + * @brief Resets the serial port, initializes the library's internal ring + * buffers and installs a serial IRQ handler. The given mode value (normally + * MR_CHLEN_8|MR_SB_01 for 8 data bits, 1 stop bit and no parity) is copied to + * the SIO_MODE register. Flow control is disabled by default (see + * SIO_SetFlowControl() for more details). + * + * This function must be called prior to using SIO_ReadByte(), SIO_ReadSync(), + * SIO_WriteByte(), SIO_WriteSync() or SIO_SetFlowControl(), and must not be + * called from an IRQ callback. + * + * @param baud Baud rate in bits per second + * @param mode Binary OR of SIO_ModeRegFlag enum members + */ +void SIO_Init(int baud, uint16_t mode); + +/** + * @brief Resets the serial port and removes the IRQ callback added by + * SIO_Init(), restoring any previously installed handler. + */ +void SIO_Quit(void); -void *Sio1Callback(void (*func)(void)); +/** + * @brief Changes the serial port's flow control mode. The following modes are + * available: + * + * - SIO_FC_NONE (default): do not assert RTS or DTR automatically and ignore + * DSR. Note that the hardware will still wait for CTS to be asserted before + * sending any data; there is no way to disable this behavior. + * - SIO_FC_RTS_CTS: assert RTS when the RX buffer is full and wait for CTS to + * be asserted before sending any data. + * + * The flow control mode shall only be changed while the TX and RX buffers are + * empty. + * + * @param mode + */ +void SIO_SetFlowControl(SIO_FlowControl mode); -// ORIGINAL -void WaitSIO(void); -int kbhit(); +/** + * @brief Reads a byte from the RX buffer. If the buffer is empty, blocks + * indefinitely until a byte is received. + * + * WARNING: this function shall not be used in a critical section or IRQ + * callback as no data is sent or received while interrupts are disabled. It + * also lacks a timeout, so consider polling for new data using SIO_ReadByte2() + * or SIO_ReadSync(1) and implementing a timeout instead. + * + * @return Received byte + */ +int SIO_ReadByte(void); + +/** + * @brief Non-blocking variant of SIO_ReadByte(). Reads a byte from the RX + * buffer or returns -1 if the buffer is empty. Unlike SIO_ReadByte() this + * function is safe to use in a critical section (although no data will be + * received while interrupts are disabled). + * + * @return Received byte, -1 if no data is available + */ +int SIO_ReadByte2(void); + +/** + * @brief Waits for at least one byte to be available in the RX buffer (if + * mode = 0) or returns the length of the RX buffer (if mode = 1). + * + * WARNING: this function shall not be used in a critical section or IRQ + * callback as no data is sent or received while interrupts are disabled. Using + * SIO_ReadSync(0) is additionally discouraged as it lacks a timeout; consider + * polling for new data using SIO_ReadByte2() or SIO_ReadSync(1) and + * implementing a timeout instead. + * + * @param mode + * @return Number of RX bytes in the buffer + */ +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. + * + * @param func + * @return Previously set callback or NULL + */ +void *SIO_ReadCallback(void (*func)(uint8_t)); + +/** + * @brief Sends the given byte, or appends it to the TX buffer if the serial + * port is busy. If the buffer is full, blocks until the byte can be stored in + * the buffer (with a timeout). + * + * WARNING: this function shall not be used in a critical section or IRQ + * callback as no data is sent or received while interrupts are disabled. + * + * @param value + * @return Number of TX bytes previously pending, -1 in case of a timeout + */ +int SIO_WriteByte(uint8_t value); + +/** + * @brief Non-blocking variant of SIO_WriteByte(). Sends the given byte, or + * appends it to the TX buffer if the serial port is busy. If the buffer is + * full, returns -1 without actually sending the byte. Unlike SIO_WriteByte() + * this function is safe to use in a critical section (although no data will be + * sent while interrupts are disabled). + * + * @param value + * @return Number of TX bytes previously pending, -1 in case of failure + */ +int SIO_WriteByte2(uint8_t value); + +/** + * @brief Waits for all bytes pending in the TX buffer to be sent (if mode = 0) + * or returns the length of the TX buffer (if mode = 1). + * + * WARNING: this function shall not be used in a critical section or IRQ + * callback as no data is sent or received while interrupts are disabled. + * + * @param mode + * @return Number of TX bytes pending, -1 in case of a timeout (mode = 0) + */ +int SIO_WriteSync(int mode); + +/** + * @brief Installs a BIOS file driver to redirect TTY stdin/stdout (including + * BIOS messages as well as PSn00bSDK's own debug logging) to the serial port. + * Uses SIO_Init() internally. The port is configured for 8 data bits, 1 stop + * bit and no parity. + * + * This function shall only be used for debugging purposes. Picking a high baud + * rate is recommended as all TTY writes are blocking and bypass the TX buffer. + * + * NOTE: some executable loaders, such as Unirom and Caetla, already replace + * the BIOS TTY driver with a custom one. Calling AddSIO() will break the + * built-in TTY functionality of these loaders. + * + * @param baud Baud rate in bits per second + */ +void AddSIO(int baud); + +/** + * @brief Uninstalls the BIOS driver installed by AddSIO() and attempts to + * restore a "dummy" TTY driver. Calling this function is not recommended as + * any further TTY usage may crash the system. + */ +void DelSIO(void); #ifdef __cplusplus } diff --git a/libpsn00b/libc/memset.s b/libpsn00b/libc/memset.s index 5a1589d..73f92bd 100644 --- a/libpsn00b/libc/memset.s +++ b/libpsn00b/libc/memset.s @@ -9,6 +9,7 @@ memset: # If more than 16 bytes have to be written then take the "large" path, # otherwise use the code below. + blez $a2, .Lnull_count addiu $t0, $a2, -16 bgtz $t0, .Llarge_fill move $v0, $a0 # return_value = dest @@ -41,6 +42,10 @@ memset: jr $ra sb $a1, 0xf($a0) +.Lnull_count: + jr $ra + move $v0, $a0 # return_value = dest + .Llarge_fill: # Initialize fast filling by repeating the fill byte 4 times, so it can be # written 32 bits at a time. diff --git a/libpsn00b/psxcd/isofs.c b/libpsn00b/psxcd/isofs.c index cb60152..e00ddeb 100644 --- a/libpsn00b/psxcd/isofs.c +++ b/libpsn00b/psxcd/isofs.c @@ -1,4 +1,5 @@ +#undef SDK_LIBRARY_NAME #define SDK_LIBRARY_NAME "psxcd/iso" #include diff --git a/libpsn00b/psxetc/dl.c b/libpsn00b/psxetc/dl.c index 51c1d2d..fa5e74d 100644 --- a/libpsn00b/psxetc/dl.c +++ b/libpsn00b/psxetc/dl.c @@ -23,6 +23,7 @@ * of entries */ +#undef SDK_LIBRARY_NAME #define SDK_LIBRARY_NAME "psxetc/dl" #include @@ -234,7 +235,7 @@ int32_t DL_ParseSymbolMap(const char *ptr, size_t size) { // insists on printing 64-bit addresses... wtf) and normalize the // type letter to upper case, then check if the entry is valid and // non-null. - void *address = (void *) address64; + void *address = (void *) ((uint32_t) address64); char _type = toupper(type_string[0]); uint32_t hash = _elf_hash(name); uint32_t hash_mod = hash % _symbol_map.nbucket; diff --git a/libpsn00b/psxgpu/common.c b/libpsn00b/psxgpu/common.c index 9eb4ea4..9f45f10 100644 --- a/libpsn00b/psxgpu/common.c +++ b/libpsn00b/psxgpu/common.c @@ -38,6 +38,9 @@ static volatile uint16_t _last_hblank; /* Private interrupt handlers */ +#define _ENTER_CRITICAL() uint16_t mask = IRQ_MASK; IRQ_MASK = 0; +#define _EXIT_CRITICAL() IRQ_MASK = mask; + static void _vblank_handler(void) { _vblank_counter++; @@ -51,9 +54,10 @@ static void _gpu_dma_handler(void) { __asm__ volatile(""); if (--_queue_length) { - volatile QueueEntry *entry = &_draw_queue[_queue_head++]; - _queue_head %= QUEUE_LENGTH; + int head = _queue_head; + _queue_head = (head + 1) % QUEUE_LENGTH; + volatile QueueEntry *entry = &_draw_queue[head]; entry->func(entry->arg1, entry->arg2, entry->arg3); } else { GPU_GP1 = 0x04000000; // Disable DMA request @@ -145,19 +149,22 @@ int VSync(int mode) { } void *VSyncHaltFunction(void (*func)(void)) { + //_ENTER_CRITICAL(); + void *old_callback = _vsync_halt_func; _vsync_halt_func = func; + //_EXIT_CRITICAL(); return old_callback; } void *VSyncCallback(void (*func)(void)) { - EnterCriticalSection(); + _ENTER_CRITICAL(); void *old_callback = _vsync_callback; _vsync_callback = func; - ExitCriticalSection(); + _EXIT_CRITICAL(); return old_callback; } @@ -176,37 +183,36 @@ int EnqueueDrawOp( // to checking if DMA is busy; disabling them afterwards would create a // race condition where the DMA transfer could end while interrupts are // being disabled. Interrupts are disabled through the IRQ_MASK register - // rather than by calling EnterCriticalSection() for performance reasons. - uint16_t mask = IRQ_MASK; - IRQ_MASK = 0; + // rather than via syscalls for performance reasons. + _ENTER_CRITICAL(); + int length = _queue_length; - if (_queue_length) { - int length = _queue_length; - - if (length >= QUEUE_LENGTH) { - IRQ_MASK = mask; - _sdk_log("draw queue overflow, dropping commands\n"); - return -1; - } + if (!length) { + _queue_length = 1; + _EXIT_CRITICAL(); - volatile QueueEntry *entry = &_draw_queue[_queue_tail++]; - _queue_tail %= QUEUE_LENGTH; - _queue_length = length + 1; - - entry->func = func; - entry->arg1 = arg1; - entry->arg2 = arg2; - entry->arg3 = arg3; + func(arg1, arg2, arg3); + return 0; + } + if (length >= QUEUE_LENGTH) { + _EXIT_CRITICAL(); - IRQ_MASK = mask; - return length; + _sdk_log("draw queue overflow, dropping commands\n"); + return -1; } - _queue_length = 1; + int tail = _queue_tail; + _queue_tail = (tail + 1) % QUEUE_LENGTH; + _queue_length = length + 1; + + volatile QueueEntry *entry = &_draw_queue[tail]; + entry->func = func; + entry->arg1 = arg1; + entry->arg2 = arg2; + entry->arg3 = arg3; - IRQ_MASK = mask; - func(arg1, arg2, arg3); - return 0; + _EXIT_CRITICAL(); + return length; } int DrawSync(int mode) { @@ -236,12 +242,12 @@ int DrawSync(int mode) { } void *DrawSyncCallback(void (*func)(void)) { - EnterCriticalSection(); + _ENTER_CRITICAL(); void *old_callback = _drawsync_callback; _drawsync_callback = func; - ExitCriticalSection(); + _EXIT_CRITICAL(); return old_callback; } diff --git a/libpsn00b/psxsio/_sio_control.s b/libpsn00b/psxsio/_sio_control.s deleted file mode 100644 index 6378def..0000000 --- a/libpsn00b/psxsio/_sio_control.s +++ /dev/null @@ -1,184 +0,0 @@ -.set noreorder - -.include "hwregs_a.inc" - -.section .text - -# Currently implemented serial control functions: -# -# cmd(a0) sub(a1) -# 0 0 Get serial status -# 0 1 Get control line status -# 0 2 Get serial mode -# 0 3 Get baud rate -# 0 4 Read 1 byte -# 1 1 Set serial control -# 1 2 Set serial mode -# 1 3 Set baud rate -# 1 4 Write 1 byte -# 2 0 Reset serial -# 2 1 Acknowledge serial - -.global _sio_control -.type _sio_control, @function -_sio_control: - - # a0 - command - # a1 - subcommand - # a2 - argument - - lui $a3, IOBASE - - beq $a0, $0, .Lcmd0 - nop - beq $a0, 1, .Lcmd1 - nop - beq $a0, 2, .Lcmd2 - nop - jr $ra - nop - - -.Lcmd0: - - beq $a1, $0, .Lcmd0arg0 - nop - beq $a1, 1, .Lcmd0arg1 - nop - beq $a1, 2, .Lcmd0arg2 - nop - beq $a1, 3, .Lcmd0arg3 - nop - beq $a1, 4, .Lcmd0arg4 - nop - jr $ra - nop - -.Lcmd0arg0: # Get SIO status - - lhu $v0, SIO_STAT($a3) - nop - - jr $ra - andi $v0, 0x3FF - -.Lcmd0arg1: # Get control line status - - lhu $v1, SIO_CTRL($a3) - nop - srl $v0, $v1, 1 - andi $v0, 0x1 - srl $v1, 4 - andi $v1, 0x2 - - jr $ra - or $v0, $v1 - - -.Lcmd0arg2: # Get serial mode - - lhu $v0, SIO_MODE($a3) - nop - jr $ra - andi $v0, 0xFF - -.Lcmd0arg3: - - lui $v1, 0x1f - lhu $v0, SIO_BAUD($a3) - ori $v1, 0xa400 - div $v1, $v0 - nop - nop - mflo $v0 - jr $ra - nop - -.Lcmd0arg4: # Serial RX read - - lbu $v0, SIO_TXRX($a3) - nop - jr $ra - nop - - -.Lcmd1: - - beq $a1, 1, .Lcmd1arg1 - nop - beq $a1, 2, .Lcmd1arg2 - nop - beq $a1, 3, .Lcmd1arg3 - nop - beq $a1, 4, .Lcmd1arg4 - nop - jr $ra - nop - -.Lcmd1arg1: - - andi $v0, $a2, 0x1CFF - sh $a2, SIO_CTRL($a3) - jr $ra - nop - -.Lcmd1arg2: - - sh $a2, SIO_MODE($a3) - jr $ra - nop - -.Lcmd1arg3: - - lui $v0, 0x1f - ori $v0, 0xa400 - divu $v0, $a2 - bnez $a2, .Lgood_baud - nop - jr $ra - nop - -.Lgood_baud: - - mflo $v0 - sh $v0, SIO_BAUD($a3) - nop - jr $ra - nop - -.Lcmd1arg4: - - sb $a2, SIO_TXRX($a3) - nop - jr $ra - nop - -.Lcmd2: - - beq $a1, $0 , .Lcmd2arg0 - li $v0, 1 - beq $a1, $v0, .Lcmd2arg1 - nop - jr $ra - nop - -.Lcmd2arg0: - - li $v0, 0x40 - sh $v0, SIO_CTRL($a3) - sh $0 , SIO_MODE($a3) - sh $0 , SIO_BAUD($a3) - nop - jr $ra - nop - -.Lcmd2arg1: - - lhu $v0, SIO_CTRL($a3) - nop - ori $v0, 0x10 - sh $v0, SIO_CTRL($a3) - jr $ra - nop - - \ No newline at end of file diff --git a/libpsn00b/psxsio/sio.c b/libpsn00b/psxsio/sio.c new file mode 100644 index 0000000..3fb3caf --- /dev/null +++ b/libpsn00b/psxsio/sio.c @@ -0,0 +1,263 @@ +/* + * PSn00bSDK buffered serial port driver + * (C) 2022 spicyjpeg - MPL licensed + * + * TODO: add proper support for DTR/DSR flow control + */ + +#include +#include +#include +#include +#include +#include + +#define BUFFER_LENGTH 128 +#define SIO_SYNC_TIMEOUT 0x100000 + +/* Private types */ + +typedef struct { + uint8_t data[BUFFER_LENGTH]; + uint8_t head, tail, length; +} RingBuffer; + +/* Internal globals */ + +static SIO_FlowControl _flow_control; +static uint16_t _ctrl_reg_flag; + +static void (*_read_callback)(uint8_t) = (void *) 0; +static void (*_old_sio_handler)(void) = (void *) 0; + +static volatile RingBuffer _tx_buffer, _rx_buffer; + +/* Private interrupt handler */ + +#define _ENTER_CRITICAL() uint16_t mask = IRQ_MASK; IRQ_MASK = 0; +#define _EXIT_CRITICAL() IRQ_MASK = mask; + +static void _sio_handler(void) { + // Handle any incoming bytes. + while (SIO_STAT & SR_RXRDY) { + uint8_t value = SIO_TXRX; + int length = _rx_buffer.length; + + if (length >= BUFFER_LENGTH) { + //_sdk_log("RX overrun, dropping bytes\n"); + break; + } + + int tail = _rx_buffer.tail; + _rx_buffer.tail = (tail + 1) % BUFFER_LENGTH; + _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 + // checking for CTS is unnecessary as the serial port is already hardwired + // to do so. + if (SIO_STAT & (SR_TXRDY | SR_TXU)) { + int length = _tx_buffer.length; + + if (length) { + int head = _tx_buffer.head; + _tx_buffer.head = (head + 1) % BUFFER_LENGTH; + _tx_buffer.length = length - 1; + + SIO_CTRL |= CR_TXIEN; + SIO_TXRX = _tx_buffer.data[head]; + } else { + SIO_CTRL &= CR_TXIEN ^ 0xffff; + } + } + + // Acknowledge the IRQ and update flow control signals. + if (_rx_buffer.length < BUFFER_LENGTH) + SIO_CTRL = CR_INTRST | (SIO_CTRL | _ctrl_reg_flag); + else + SIO_CTRL = CR_INTRST | (SIO_CTRL & (_ctrl_reg_flag ^ 0xffff)); +} + +/* Serial port initialization API */ + +void SIO_Init(int baud, uint16_t mode) { + EnterCriticalSection(); + _old_sio_handler = InterruptCallback(8, &_sio_handler); + + SIO_CTRL = CR_ERRRST; + SIO_MODE = (mode & 0xfffc) | MR_BR_16; + SIO_BAUD = (uint16_t) ((int) 0x1fa400 / baud); + SIO_CTRL = CR_TXEN | CR_RXEN | CR_RXIEN; + + _tx_buffer.head = 0; + _tx_buffer.tail = 0; + _tx_buffer.length = 0; + _rx_buffer.head = 0; + _rx_buffer.tail = 0; + _rx_buffer.length = 0; + + _flow_control = SIO_FC_NONE; + _ctrl_reg_flag = 0; + + ExitCriticalSection(); +} + +void SIO_Quit(void) { + EnterCriticalSection(); + InterruptCallback(8, _old_sio_handler); + + SIO_CTRL = CR_ERRRST; + + ExitCriticalSection(); +} + +void SIO_SetFlowControl(SIO_FlowControl mode) { + _ENTER_CRITICAL(); + + switch (mode) { + case SIO_FC_NONE: + _flow_control = SIO_FC_NONE; + _ctrl_reg_flag = 0; + + SIO_CTRL &= 0xffff ^ CR_DSRIEN; + break; + + case SIO_FC_RTS_CTS: + _flow_control = SIO_FC_RTS_CTS; + _ctrl_reg_flag = CR_RTS; + + SIO_CTRL &= 0xffff ^ CR_DSRIEN; + break; + + /*case SIO_FC_DTR_DSR: + _flow_control = SIO_FC_DTR_DSR; + _ctrl_reg_flag = CR_DTR; + + SIO_CTRL |= CR_DSRIEN; + break;*/ + } + + _EXIT_CRITICAL(); +} + +/* Reading API */ + +int SIO_ReadByte(void) { + /*for (int i = SIO_SYNC_TIMEOUT; i; i--) { + if (_rx_buffer.length) + return SIO_ReadByte2(); + }*/ + while (!_rx_buffer.length) + __asm__ volatile(""); + + return SIO_ReadByte2(); +} + +int SIO_ReadByte2(void) { + if (!_rx_buffer.length) + return -1; + + _ENTER_CRITICAL(); + + int head = _rx_buffer.head; + _rx_buffer.head = (head + 1) % BUFFER_LENGTH; + _rx_buffer.length--; + + _EXIT_CRITICAL(); + return _rx_buffer.data[head]; +} + +int SIO_ReadSync(int mode) { + if (mode) + return _rx_buffer.length; + + /*for (int i = SIO_SYNC_TIMEOUT; i; i--) { + if (_rx_buffer.length) + return 0; + }*/ + while (!_rx_buffer.length) + __asm__ volatile(""); + + return 0; +} + +void *SIO_ReadCallback(void (*func)(uint8_t)) { + EnterCriticalSection(); + + void *old_callback = _read_callback; + _read_callback = func; + + ExitCriticalSection(); +} + +/* Writing API */ + +int SIO_WriteByte(uint8_t value) { + for (int i = SIO_SYNC_TIMEOUT; i; i--) { + if (_tx_buffer.length < BUFFER_LENGTH) + return SIO_WriteByte2(value); + } + + //_sdk_log("SIO_WriteByte() timeout\n"); + return -1; +} + +int SIO_WriteByte2(uint8_t value) { + // If the TX unit is currently busy, append the byte to the buffer instead + // of sending it immediately. Note that interrupts must be disabled *prior* + // to checking if TX is busy; disabling them afterwards would create a race + // condition where the transfer could end while interrupts are being + // disabled. Interrupts are disabled through the IRQ_MASK register rather + // than via syscalls for performance reasons. + _ENTER_CRITICAL(); + + if (SIO_STAT & (SR_TXRDY | SR_TXU)) { + SIO_TXRX = value; + _EXIT_CRITICAL(); + return 0; + } + + int length = _tx_buffer.length; + + if (length >= BUFFER_LENGTH) { + _EXIT_CRITICAL(); + + //_sdk_log("TX overrun, dropping bytes\n"); + return -1; + } + + int tail = _tx_buffer.tail; + _tx_buffer.tail = (tail + 1) % BUFFER_LENGTH; + _tx_buffer.length = length + 1; + + _tx_buffer.data[tail] = value; + SIO_CTRL |= CR_TXIEN; + + _EXIT_CRITICAL(); + return length; +} + +int SIO_WriteSync(int mode) { + if (mode) + return _tx_buffer.length; + + // Wait for the buffer to become empty. + for (int i = SIO_SYNC_TIMEOUT; i; i--) { + if (!_tx_buffer.length) + break; + } + + if (!_tx_buffer.length) { + // Wait for the TX unit to finish sending the last byte. + while (!(SIO_STAT & (SR_TXRDY | SR_TXU))) + __asm__ volatile(""); + } else { + //_sdk_log("SIO_WriteSync() timeout\n"); + } + + return _tx_buffer.length; +} diff --git a/libpsn00b/psxsio/siocons.c b/libpsn00b/psxsio/siocons.c deleted file mode 100644 index 5937920..0000000 --- a/libpsn00b/psxsio/siocons.c +++ /dev/null @@ -1,220 +0,0 @@ -#include -#include -#include -#include -#include -#include - -#define SIO_BUFF_LEN 32 - -static volatile int _sio_key_pending; - -static volatile int _sio_buff_rpos; -static volatile int _sio_buff_wpos; -static volatile char _sio_buff[SIO_BUFF_LEN]; - -static void _sio_init() { - - _sio_key_pending = 0; - - memset((void*)_sio_buff, 0, SIO_BUFF_LEN); - _sio_buff_rpos = 0; - _sio_buff_wpos = 0; - -} - -static int _sio_open(FCB *fcb, const char* file, int mode) { - - fcb->diskid = 1; - - return 0; - -} - -static int _sio_inout(FCB *fcb, int cmd) { - - int i; - - if(cmd == 2) { // Write - - for(i=0; itrns_len; i++) { - while(!(_sio_control(0, 0, 0) & SR_TXU)); - _sio_control(1, 4, ((char*)fcb->trns_addr)[i]); - } - - return fcb->trns_len; - - } else if (cmd == 1) { // Read - - /*for(i=0; itrns_len; i++) { - while(!(_sio_control(0, 0, 0) & SR_RXRDY)); - ((char*)fcb->trns_addr)[i] = _sio_control(0, 4, 0); - }*/ - - - - for(i=0; itrns_len; i++) { - - while( _sio_key_pending == 0 ); - - ((char*)fcb->trns_addr)[i] = _sio_buff[_sio_buff_rpos]; - _sio_key_pending--; - _sio_buff_rpos++; - if( _sio_buff_rpos >= SIO_BUFF_LEN ) - { - _sio_buff_rpos = 0; - } - - } - - return fcb->trns_len; - - } - - return 0; - -} - -static int _sio_ioctl(FCB *fcb, int cmd, int arg) -{ - if( cmd == FIOCSCAN ) - { - if( _sio_key_pending ) - { - return 0; - } - } - - return -1; -} - -static int _sio_close(int h) { - - return h; - -} - -static void _sio_tty_cb(void) -{ - _sio_key_pending++; - - // Get received byte - if( _sio_key_pending < SIO_BUFF_LEN ) - { - _sio_buff[_sio_buff_wpos] = _sio_control(0, 4, 0); - _sio_buff_wpos++; - if( _sio_buff_wpos >= SIO_BUFF_LEN ) - { - _sio_buff_wpos = 0; - } - } - else - { - _sio_control(0, 4, 0); - } - - // Acknowledge SIO IRQ - _sio_control(2, 1, 0); -} - -static int _sio_dummy(void) -{ - return -1; -} - -static DCB _sio_dcb = { - "tty", - 0x3, - 0x1, - 0x0, - (void*)_sio_init, // init - (void*)_sio_open, // open - (void*)_sio_inout, // inout - _sio_close, // close - _sio_ioctl, // ioctl - _sio_dummy, // read - _sio_dummy, // write - _sio_dummy, // erase - _sio_dummy, // undelete - _sio_dummy, // firstfile - _sio_dummy, // nextfile - _sio_dummy, // format - _sio_dummy, // chdir - _sio_dummy, // rename - _sio_dummy, // remove - _sio_dummy // testdevice -}; - - -volatile void (*_sio_callback)(void) = NULL; - -void AddSIO(int baud) { - - _sio_control(2, 0, 0); - _sio_control(1, 2, MR_SB_01|MR_CHLEN_8|0x02); - _sio_control(1, 3, baud); - _sio_control(1, 1, CR_RXEN|CR_TXEN|CR_RXIEN); - - close(0); - close(1); - - DelDev(_sio_dcb.name); - AddDev(&_sio_dcb); - - Sio1Callback(_sio_tty_cb); - - open(_sio_dcb.name, 2); - open(_sio_dcb.name, 1); - -} - -void DelSIO(void) { - - Sio1Callback(NULL); - - // Reset serial interface - _sio_control(2, 0, 0); - - // Remove TTY device - DelDev(_sio_dcb.name); - - // Add dummy TTY device - AddDummyTty(); - -} - -void WaitSIO(void) { - - while((_sio_control(0, 0, 0)&(SR_RXRDY)) != (SR_RXRDY)); - _sio_control(0, 4, NULL); - -} - -void *Sio1Callback(void (*func)()) { - - void *old_isr; //= *((int*)&_sio_callback); - - EnterCriticalSection(); - - if( func ) { - - old_isr = InterruptCallback(8, func); - //_sio_callback = func; - - } else { - - old_isr = InterruptCallback(8, NULL); - //_sio_callback = NULL; - - } - - ExitCriticalSection(); - - return old_isr; - -} - -int kbhit() -{ - return(_sio_key_pending>0); -} diff --git a/libpsn00b/psxsio/tty.c b/libpsn00b/psxsio/tty.c new file mode 100644 index 0000000..4dc9fd1 --- /dev/null +++ b/libpsn00b/psxsio/tty.c @@ -0,0 +1,107 @@ +/* + * PSn00bSDK serial port BIOS TTY driver + * (C) 2019-2022 Lameguy64, spicyjpeg - MPL licensed + * + * This driver is designed to be as simple and reliable as possible: as such it + * only relies on the SIO_*() API for receiving and sends data synchronously. + * This allows printf() to work without issues, albeit slowly, if called from a + * critical section or even from an interrupt handler. + */ + +#include +#include +#include +#include + +/* TTY device control block */ + +static int _sio_open(FCB *fcb, const char* file, int mode) { + fcb->diskid = 1; + return 0; +} + +static int _sio_inout(FCB *fcb, int cmd) { + char *ptr = (char*) fcb->trns_addr; + + switch (cmd) { + case 1: // read + for (int i = 0; i < fcb->trns_len; i++) + *(ptr++) = (char) SIO_ReadByte(); + + return fcb->trns_len; + + case 2: // write + for (int i = 0; i < fcb->trns_len; i++) { + while (!(SIO_STAT & (SR_TXRDY | SR_TXU))) + __asm__ volatile(""); + + SIO_TXRX = *(ptr++); + } + + return fcb->trns_len; + + default: + return 0; + } +} + +static int _sio_close(FCB *fcb) { + return 0; +} + +static int _sio_ioctl(FCB *fcb, int cmd, int arg) { + switch (cmd) { + case FIOCSCAN: + return SIO_ReadSync(1) ? 0 : -1; + + default: + return -1; + } +} + +static int _sio_dummy(void) { + return -1; +} + +static DCB _sio_dcb = { + .name = "tty", + .flags = 3, + .ssize = 1, + .desc = "PSXSIO SERIAL CONSOLE", + .f_init = &_sio_dummy, + .f_open = &_sio_open, + .f_inout = &_sio_inout, + .f_close = &_sio_close, + .f_ioctl = &_sio_ioctl, + .f_read = &_sio_dummy, + .f_write = &_sio_dummy, + .f_erase = &_sio_dummy, + .f_undelete = &_sio_dummy, + .f_firstfile = &_sio_dummy, + .f_nextfile = &_sio_dummy, + .f_format = &_sio_dummy, + .f_chdir = &_sio_dummy, + .f_rename = &_sio_dummy, + .f_remove = &_sio_dummy, + .f_testdevice = &_sio_dummy +}; + +/* Public API */ + +void AddSIO(int baud) { + SIO_Init(baud, MR_SB_01 | MR_CHLEN_8); + + close(0); + close(1); + DelDev(_sio_dcb.name); + AddDev(&_sio_dcb); + open(_sio_dcb.name, 2); + open(_sio_dcb.name, 1); +} + +void DelSIO(void) { + SIO_Quit(); + + DelDev(_sio_dcb.name); + AddDummyTty(); +} -- 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 'CHANGELOG.md') 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