mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-04-10 15:45:19 +00:00
Code Issues Packages Projects Releases Wiki Activity

(PS2 audio) Style nit changes

Browse Source
This commit is contained in:
twinaphex 2019-01-03 13:26:45 +01:00
parent 56bf1c53ca
commit 24ef966ca3
1 changed files with 110 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

192
audio/drivers/ps2_audio.c
View File

@ -23,7 +23,8 @@
#include "../audio_driver.h" #include "../audio_driver.h"
typedef struct ps2_audio { typedef struct ps2_audio
{
fifo_buffer_t* buffer; fifo_buffer_t* buffer;
bool nonblocking; bool nonblocking;
volatile bool running; volatile bool running;
@ -43,13 +44,17 @@ static u8 audioThreadStack[4 * 1024] __attribute__ ((aligned(16)));
#define AUDIO_PRIORITY 0x7F /* LOWER VALUE GRATHER PRIORITY*/ #define AUDIO_PRIORITY 0x7F /* LOWER VALUE GRATHER PRIORITY*/
static void audioMainLoop(void *data) { static void audioMainLoop(void *data)
{
char out_tmp[AUDIO_OUT_BUFFER]; char out_tmp[AUDIO_OUT_BUFFER];
ps2_audio_t* ps2 = backup_ps2; ps2_audio_t* ps2 = backup_ps2;
while (ps2->running) { while (ps2->running)
{
size_t size;
WaitSema(ps2->lock); WaitSema(ps2->lock);
size_t size = MIN(fifo_read_avail(ps2->buffer), sizeof(out_tmp)); size = MIN(fifo_read_avail(ps2->buffer), sizeof(out_tmp));
fifo_read(ps2->buffer, out_tmp, size); fifo_read(ps2->buffer, out_tmp, size);
iSignalSema(ps2->lock); iSignalSema(ps2->lock);
iSignalSema(ps2->cond_lock); iSignalSema(ps2->cond_lock);
@ -63,67 +68,76 @@ static void audioMainLoop(void *data) {
} }
static void audioCreateThread(ps2_audio_t *ps2) { static void audioCreateThread(ps2_audio_t *ps2)
int ret; {
ee_thread_t thread; int ret;
ee_thread_t thread;
thread.func=&audioMainLoop; thread.func=&audioMainLoop;
thread.stack=audioThreadStack; thread.stack=audioThreadStack;
thread.stack_size=sizeof(audioThreadStack); thread.stack_size=sizeof(audioThreadStack);
thread.gp_reg=&_gp; thread.gp_reg=&_gp;
thread.initial_priority=AUDIO_PRIORITY; thread.initial_priority=AUDIO_PRIORITY;
thread.attr=thread.option=0; thread.attr=thread.option=0;
/*Backup the PS2 content to be used in the thread */ /*Backup the PS2 content to be used in the thread */
backup_ps2 = ps2; backup_ps2 = ps2;
ps2->running = true; ps2->running = true;
ps2->worker_thread = CreateThread(&thread); ps2->worker_thread = CreateThread(&thread);
if (ps2->worker_thread >= 0) {
ret = StartThread(ps2->worker_thread, NULL); if (ps2->worker_thread >= 0)
if (ret < 0) { {
ret = StartThread(ps2->worker_thread, NULL);
if (ret < 0)
printf("sound_init: StartThread returned %d\n", ret); printf("sound_init: StartThread returned %d\n", ret);
}
} else {
printf("CreateThread failed: %d\n", ps2->worker_thread);
} }
else
printf("CreateThread failed: %d\n", ps2->worker_thread);
} }
static void audioStopNDeleteThread(ps2_audio_t *ps2) { static void audioStopNDeleteThread(ps2_audio_t *ps2)
{
ps2->running = false; ps2->running = false;
if (ps2->worker_thread) { if (ps2->worker_thread)
ps2->worker_thread = 0; ps2->worker_thread = 0;
}
} }
static void audioConfigure(ps2_audio_t *ps2, unsigned rate) { static void audioConfigure(ps2_audio_t *ps2, unsigned rate)
{
int err; int err;
struct audsrv_fmt_t format; struct audsrv_fmt_t format;
format.bits = AUDIO_BITS;
format.freq = rate;
format.channels = AUDIO_CHANNELS;
err = audsrv_set_format(&format); format.bits = AUDIO_BITS;
if (err) { format.freq = rate;
format.channels = AUDIO_CHANNELS;
err = audsrv_set_format(&format);
if (err)
{
printf("set format returned %d\n", err); printf("set format returned %d\n", err);
printf("audsrv returned error string: %s\n", audsrv_get_error_string()); printf("audsrv returned error string: %s\n", audsrv_get_error_string());
} }
audsrv_set_volume(MAX_VOLUME); audsrv_set_volume(MAX_VOLUME);
} }
static void audioCreateSemas(ps2_audio_t *ps2) { static void audioCreateSemas(ps2_audio_t *ps2)
{
ee_sema_t lock_info; ee_sema_t lock_info;
lock_info.max_count = 1;
lock_info.init_count = 1;
lock_info.option = 0;
ps2->lock = CreateSema(&lock_info);
ee_sema_t cond_lock_info; ee_sema_t cond_lock_info;
lock_info.max_count = 1;
lock_info.init_count = 1;
lock_info.option = 0;
ps2->lock = CreateSema(&lock_info);
cond_lock_info.init_count = 1; cond_lock_info.init_count = 1;
cond_lock_info.max_count = 1; cond_lock_info.max_count = 1;
cond_lock_info.option = 0; cond_lock_info.option = 0;
ps2->cond_lock = CreateSema(&cond_lock_info);
ps2->cond_lock = CreateSema(&cond_lock_info);
} }
static void *ps2_audio_init(const char *device, static void *ps2_audio_init(const char *device,
@ -133,30 +147,35 @@ static void *ps2_audio_init(const char *device,
{ {
ps2_audio_t *ps2 = (ps2_audio_t*)calloc(1, sizeof(ps2_audio_t)); ps2_audio_t *ps2 = (ps2_audio_t*)calloc(1, sizeof(ps2_audio_t));
if (ps2) { if (!ps2)
ps2->buffer = fifo_new(AUDIO_BUFFER); return NULL;
audioConfigure(ps2, rate);
audioCreateSemas(ps2); ps2->buffer = fifo_new(AUDIO_BUFFER);
audioCreateThread(ps2); audioConfigure(ps2, rate);
} audioCreateSemas(ps2);
audioCreateThread(ps2);
return ps2; return ps2;
} }
static void ps2_audio_free(void *data) { static void ps2_audio_free(void *data)
{
ps2_audio_t* ps2 = (ps2_audio_t*)data; ps2_audio_t* ps2 = (ps2_audio_t*)data;
if(!ps2) if(!ps2)
return; return;
if(ps2->running){ if(ps2->running)
{
audioStopNDeleteThread(ps2); audioStopNDeleteThread(ps2);
if (ps2->lock) { if (ps2->lock)
{
iDeleteSema(ps2->lock); iDeleteSema(ps2->lock);
ps2->lock = 0; ps2->lock = 0;
} }
if (ps2->cond_lock) { if (ps2->cond_lock)
{
iDeleteSema(ps2->cond_lock); iDeleteSema(ps2->cond_lock);
ps2->cond_lock = 0; ps2->cond_lock = 0;
} }
@ -166,20 +185,21 @@ static void ps2_audio_free(void *data) {
free(ps2); free(ps2);
} }
static ssize_t ps2_audio_write(void *data, const void *buf, size_t size) { static ssize_t ps2_audio_write(void *data, const void *buf, size_t size)
{
ps2_audio_t* ps2 = (ps2_audio_t*)data; ps2_audio_t* ps2 = (ps2_audio_t*)data;
if (!ps2->running) if (!ps2->running)
return -1; return -1;
if (ps2->nonblocking) { if (ps2->nonblocking)
{
if (fifo_write_avail(ps2->buffer) < size) if (fifo_write_avail(ps2->buffer) < size)
return 0; return 0;
} }
while (fifo_write_avail(ps2->buffer) < size) { while (fifo_write_avail(ps2->buffer) < size)
WaitSema(ps2->cond_lock); WaitSema(ps2->cond_lock);
}
WaitSema(ps2->lock); WaitSema(ps2->lock);
fifo_write(ps2->buffer, buf, size); fifo_write(ps2->buffer, buf, size);
@ -188,22 +208,24 @@ static ssize_t ps2_audio_write(void *data, const void *buf, size_t size) {
return size; return size;
} }
static bool ps2_audio_alive(void *data) { static bool ps2_audio_alive(void *data)
{
bool alive = false; bool alive = false;
ps2_audio_t* ps2 = (ps2_audio_t*)data; ps2_audio_t* ps2 = (ps2_audio_t*)data;
if (ps2) { if (ps2)
alive = ps2->running; alive = ps2->running;
}
return alive; return alive;
} }
static bool ps2_audio_stop(void *data) { static bool ps2_audio_stop(void *data)
{
bool stop = true; bool stop = true;
ps2_audio_t* ps2 = (ps2_audio_t*)data; ps2_audio_t* ps2 = (ps2_audio_t*)data;
if (ps2) { if (ps2)
{
audioStopNDeleteThread(ps2); audioStopNDeleteThread(ps2);
audsrv_stop_audio(); audsrv_stop_audio();
} }
@ -211,45 +233,51 @@ static bool ps2_audio_stop(void *data) {
return stop; return stop;
} }
static bool ps2_audio_start(void *data, bool is_shutdown) { static bool ps2_audio_start(void *data, bool is_shutdown)
bool start = true; {
bool start = true;
ps2_audio_t* ps2 = (ps2_audio_t*)data; ps2_audio_t* ps2 = (ps2_audio_t*)data;
if(ps2) { if(ps2)
if (!ps2->running && !ps2->worker_thread) { {
if (!ps2->running && !ps2->worker_thread)
audioCreateThread(ps2); audioCreateThread(ps2);
}
} }
return start; return start;
} }
static void ps2_audio_set_nonblock_state(void *data, bool toggle) { static void ps2_audio_set_nonblock_state(void *data, bool toggle)
{
ps2_audio_t* ps2 = (ps2_audio_t*)data; ps2_audio_t* ps2 = (ps2_audio_t*)data;
if (ps2) { if (ps2)
ps2->nonblocking = toggle; ps2->nonblocking = toggle;
}
} }
static bool ps2_audio_use_float(void *data) { static bool ps2_audio_use_float(void *data)
{
return false; return false;
} }
static size_t ps2_audio_write_avail(void *data) { static size_t ps2_audio_write_avail(void *data)
size_t size = 0; {
ps2_audio_t* ps2 = (ps2_audio_t*)data; ps2_audio_t* ps2 = (ps2_audio_t*)data;
if (ps2 && ps2->running) { if (ps2 && ps2->running)
{
size_t size;
WaitSema(ps2->lock); WaitSema(ps2->lock);
size_t size = AUDIO_BUFFER - fifo_read_avail(ps2->buffer); size = AUDIO_BUFFER - fifo_read_avail(ps2->buffer);
iSignalSema(ps2->lock); iSignalSema(ps2->lock);
return size;
} }
return size; return 0;
} }
static size_t ps2_audio_buffer_size(void *data) { static size_t ps2_audio_buffer_size(void *data)
return AUDIO_BUFFER ; {
return AUDIO_BUFFER;
} }
audio_driver_t audio_ps2 = { audio_driver_t audio_ps2 = {