ShuriZma
/
RetroArch
mirror of https://github.com/libretro/RetroArch.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #5921 from frangarcj/rthreads_audio 

Rthreads audio
This commit is contained in:
Twinaphex 2017-12-28 01:42:31 +01:00 committed by GitHub
parent c7c71cb01f 599d08fe12
commit f330c0ebc7
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 67 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Makefile.psp1
View File

@ -33,6 +33,7 @@ LIBS = $(WHOLE_START) -lretro_psp1 $(WHOLE_END) -lstdc++ -lpspgu -lpspgum -lm -l
ifeq ($(HAVE_THREADS), 1) ifeq ($(HAVE_THREADS), 1)
RARCH_DEFINES += -DHAVE_THREADS RARCH_DEFINES += -DHAVE_THREADS
LIBS += -lpthread-psp
endif endif
ifeq ($(HAVE_FILE_LOGGER), 1) ifeq ($(HAVE_FILE_LOGGER), 1)

189
audio/drivers/psp_audio.c
View File

@ -20,6 +20,9 @@
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <rthreads/rthreads.h>
#include <queues/fifo_queue.h>
#ifdef VITA #ifdef VITA
#include <psp2/kernel/processmgr.h> #include <psp2/kernel/processmgr.h>
#include <psp2/kernel/threadmgr.h> #include <psp2/kernel/threadmgr.h>
@ -46,29 +49,21 @@ typedef struct psp_audio
volatile uint16_t read_pos; volatile uint16_t read_pos;
volatile uint16_t write_pos; volatile uint16_t write_pos;
#ifdef VITA sthread_t *worker_thread;
char lock[32] __attribute__ ((aligned (8))); slock_t *fifo_lock;
char cond_lock[32] __attribute__ ((aligned (8))); scond_t *cond;
char cond[32] __attribute__ ((aligned (8))); slock_t *cond_lock;
#else
SceUID lock;
SceUID cond;
#endif
} psp_audio_t; } psp_audio_t;
#define AUDIO_OUT_COUNT 512u #define AUDIO_OUT_COUNT 512u
#define AUDIO_BUFFER_SIZE (1u<<13u) #define AUDIO_BUFFER_SIZE (1u<<13u)
#define AUDIO_BUFFER_SIZE_MASK (AUDIO_BUFFER_SIZE-1) #define AUDIO_BUFFER_SIZE_MASK (AUDIO_BUFFER_SIZE-1)
#ifdef VITA static void audioMainLoop(void *data)
#define PSP_THREAD_STOPPED SCE_THREAD_STOPPED
#else
#define sceKernelGetThreadInfo sceKernelReferThreadStatus
#endif
static int audioMainLoop(SceSize args, void* argp)
{ {
psp_audio_t* psp = *((psp_audio_t**)argp); psp_audio_t* psp = (psp_audio_t*)data;
#ifdef VITA #ifdef VITA
int port = sceAudioOutOpenPort( int port = sceAudioOutOpenPort(
SCE_AUDIO_OUT_PORT_TYPE_MAIN, AUDIO_OUT_COUNT, SCE_AUDIO_OUT_PORT_TYPE_MAIN, AUDIO_OUT_COUNT,
@ -83,11 +78,7 @@ static int audioMainLoop(SceSize args, void* argp)
uint16_t read_pos = psp->read_pos; uint16_t read_pos = psp->read_pos;
uint16_t read_pos_2 = psp->read_pos; uint16_t read_pos_2 = psp->read_pos;
#ifdef VITA slock_lock(psp->fifo_lock);
sceKernelLockLwMutex((struct SceKernelLwMutexWork*)&psp->lock, 1, 0);
#else
sceKernelWaitSema(psp->lock, 1, 0);
#endif
cond = ((uint16_t)(psp->write_pos - read_pos) & AUDIO_BUFFER_SIZE_MASK) cond = ((uint16_t)(psp->write_pos - read_pos) & AUDIO_BUFFER_SIZE_MASK)
< (AUDIO_OUT_COUNT * 2); < (AUDIO_OUT_COUNT * 2);
@ -99,18 +90,16 @@ static int audioMainLoop(SceSize args, void* argp)
psp->read_pos = read_pos; psp->read_pos = read_pos;
} }
#ifdef VITA slock_unlock(psp->fifo_lock);
sceKernelUnlockLwMutex((struct SceKernelLwMutexWork*)&psp->lock, 1); slock_lock(psp->cond_lock);
sceKernelSignalLwCond((struct SceKernelLwCondWork*)&psp->cond); scond_signal(psp->cond);
slock_unlock(psp->cond_lock);
#ifdef VITA
sceAudioOutOutput(port, sceAudioOutOutput(port,
cond ? (psp->zeroBuffer) cond ? (psp->zeroBuffer)
: (psp->buffer + read_pos_2)); : (psp->buffer + read_pos_2));
#else #else
sceKernelSignalSema(psp->lock, 1);
if(!cond){
sceKernelSignalSema(psp->cond, 1);
}
sceAudioSRCOutputBlocking(PSP_AUDIO_VOLUME_MAX, cond ? (psp->zeroBuffer) sceAudioSRCOutputBlocking(PSP_AUDIO_VOLUME_MAX, cond ? (psp->zeroBuffer)
: (psp->buffer + read_pos)); : (psp->buffer + read_pos));
#endif #endif
@ -120,9 +109,9 @@ static int audioMainLoop(SceSize args, void* argp)
sceAudioOutReleasePort(port); sceAudioOutReleasePort(port);
#else #else
sceAudioSRCChRelease(); sceAudioSRCChRelease();
sceKernelExitThread(0);
#endif #endif
return 0;
return;
} }
static void *psp_audio_init(const char *device, static void *psp_audio_init(const char *device,
@ -138,7 +127,6 @@ static void *psp_audio_init(const char *device,
(void)device; (void)device;
(void)latency; (void)latency;
/* Cache aligned, not necessary but helpful. */ /* Cache aligned, not necessary but helpful. */
psp->buffer = (uint32_t*) psp->buffer = (uint32_t*)
memalign(64, AUDIO_BUFFER_SIZE * sizeof(uint32_t)); memalign(64, AUDIO_BUFFER_SIZE * sizeof(uint32_t));
@ -150,79 +138,67 @@ static void *psp_audio_init(const char *device,
psp->read_pos = 0; psp->read_pos = 0;
psp->write_pos = 0; psp->write_pos = 0;
psp->rate = rate; psp->rate = rate;
#if defined(VITA)
sceKernelCreateLwMutex((struct SceKernelLwMutexWork*)&psp->lock, "audio_get_lock", 0, 0, 0); psp->fifo_lock = slock_new();
sceKernelCreateLwMutex((struct SceKernelLwMutexWork*)&psp->cond_lock, "audio_get_cond_lock", 0, 0, 0); psp->cond_lock = slock_new();
sceKernelCreateLwCond((struct SceKernelLwCondWork*)&psp->cond, "audio_get_cond", 0, (struct SceKernelLwMutexWork*)&psp->cond_lock, 0); psp->cond = scond_new();
psp->thread = sceKernelCreateThread
("audioMainLoop", audioMainLoop, 0x10000100, 0x10000, 0, 0, NULL);
#else
psp->cond=sceKernelCreateSema("audio_start_sema", 0, 0, 1, NULL);
psp->lock=sceKernelCreateSema("audio_lock_sema", 0, 1, 1, NULL);
psp->thread = sceKernelCreateThread
("audioMainLoop", audioMainLoop, 0x08, 0x10000, 0, NULL);
#endif
psp->nonblocking = false; psp->nonblocking = false;
psp->running = true; psp->running = true;
sceKernelStartThread(psp->thread, sizeof(psp_audio_t*), &psp); psp->worker_thread = sthread_create(audioMainLoop, psp);
return psp; return psp;
} }
static void psp_audio_free(void *data) static void psp_audio_free(void *data)
{ {
SceUInt timeout = 100000;
psp_audio_t* psp = (psp_audio_t*)data; psp_audio_t* psp = (psp_audio_t*)data;
if(!psp) if(!psp)
return; return;
psp->running = false; if(psp->running){
#if defined(VITA) if (psp->worker_thread)
sceKernelWaitThreadEnd(psp->thread, NULL, &timeout); {
sceKernelDeleteLwMutex((struct SceKernelLwMutexWork*)&psp->lock); psp->running = false;
sceKernelDeleteLwMutex((struct SceKernelLwMutexWork*)&psp->cond_lock); sthread_join(psp->worker_thread);
sceKernelDeleteLwCond((struct SceKernelLwCondWork*)&psp->cond); }
#else
sceKernelWaitThreadEnd(psp->thread, &timeout); if (psp->cond)
sceKernelDeleteSema(psp->lock); scond_free(psp->cond);
sceKernelDeleteSema(psp->cond); if (psp->fifo_lock)
#endif slock_free(psp->fifo_lock);
if (psp->cond_lock)
slock_free(psp->cond_lock);
}
free(psp->buffer); free(psp->buffer);
sceKernelDeleteThread(psp->thread); psp->worker_thread = NULL;
free(psp->zeroBuffer); free(psp->zeroBuffer);
free(psp); free(psp);
} }
static ssize_t psp_audio_write(void *data, const void *buf, size_t size) static ssize_t psp_audio_write(void *data, const void *buf, size_t size)
{ {
psp_audio_t* psp = (psp_audio_t*)data; psp_audio_t* psp = (psp_audio_t*)data;
uint16_t write_pos = psp->write_pos; uint16_t write_pos = psp->write_pos;
uint16_t sampleCount = size / sizeof(uint32_t); uint16_t sampleCount = size / sizeof(uint32_t);
if (!psp->running)
return -1;
if (psp->nonblocking) if (psp->nonblocking)
{ {
//#ifdef VITA
if (AUDIO_BUFFER_SIZE - ((uint16_t) if (AUDIO_BUFFER_SIZE - ((uint16_t)
(psp->write_pos - psp->read_pos) & AUDIO_BUFFER_SIZE_MASK) < size) (psp->write_pos - psp->read_pos) & AUDIO_BUFFER_SIZE_MASK) < size)
return 0; return 0;
//#endif
} }
#ifdef VITA slock_lock(psp->cond_lock);
while (AUDIO_BUFFER_SIZE - ((uint16_t) while (AUDIO_BUFFER_SIZE - ((uint16_t)
(psp->write_pos - psp->read_pos) & AUDIO_BUFFER_SIZE_MASK) < size) (psp->write_pos - psp->read_pos) & AUDIO_BUFFER_SIZE_MASK) < size)
sceKernelWaitLwCond((struct SceKernelLwCondWork*)&psp->cond, 0); scond_wait(psp->cond, psp->cond_lock);
slock_unlock(psp->cond_lock);
sceKernelLockLwMutex((struct SceKernelLwMutexWork*)&psp->lock, 1, 0);
#else
while (AUDIO_BUFFER_SIZE - ((uint16_t)
(psp->write_pos - psp->read_pos) & AUDIO_BUFFER_SIZE_MASK) < size)
sceKernelWaitSema(psp->cond, 1, 0);
sceKernelWaitSema(psp->lock, 1, 0);
#endif
slock_lock(psp->fifo_lock);
if((write_pos + sampleCount) > AUDIO_BUFFER_SIZE) if((write_pos + sampleCount) > AUDIO_BUFFER_SIZE)
{ {
memcpy(psp->buffer + write_pos, buf, memcpy(psp->buffer + write_pos, buf,
@ -238,15 +214,10 @@ static ssize_t psp_audio_write(void *data, const void *buf, size_t size)
write_pos &= AUDIO_BUFFER_SIZE_MASK; write_pos &= AUDIO_BUFFER_SIZE_MASK;
psp->write_pos = write_pos; psp->write_pos = write_pos;
#ifdef VITA slock_unlock(psp->fifo_lock);
sceKernelUnlockLwMutex((struct SceKernelLwMutexWork*)&psp->lock, 1); return size;
return size;
#else
sceKernelSignalSema(psp->lock, 1);
return size;
#endif
} }
static bool psp_audio_alive(void *data) static bool psp_audio_alive(void *data)
@ -260,51 +231,32 @@ static bool psp_audio_alive(void *data)
static bool psp_audio_stop(void *data) static bool psp_audio_stop(void *data)
{ {
SceKernelThreadInfo info;
SceUInt timeout = 100000;
psp_audio_t* psp = (psp_audio_t*)data; psp_audio_t* psp = (psp_audio_t*)data;
if(psp && !psp->running) if (psp){
psp->running = false;
if (!psp->worker_thread)
return true; return true;
info.size = sizeof(SceKernelThreadInfo); sthread_join(psp->worker_thread);
psp->worker_thread = NULL;
if (sceKernelGetThreadInfo( }
psp->thread, &info) < 0) /* Error */
return false;
if (info.status == PSP_THREAD_STOPPED)
return false;
psp->running = false;
#if defined(VITA)
sceKernelWaitThreadEnd(psp->thread, NULL, &timeout);
#else
sceKernelWaitThreadEnd(psp->thread, &timeout);
#endif
return true; return true;
} }
static bool psp_audio_start(void *data, bool is_shutdown) static bool psp_audio_start(void *data, bool is_shutdown)
{ {
SceKernelThreadInfo info;
psp_audio_t* psp = (psp_audio_t*)data; psp_audio_t* psp = (psp_audio_t*)data;
if(psp && psp->running) if(psp && psp->running)
return true; return true;
info.size = sizeof(SceKernelThreadInfo); if (!psp->worker_thread)
{
if (sceKernelGetThreadInfo( psp->running = true;
psp->thread, &info) < 0) /* Error */ psp->worker_thread = sthread_create(audioMainLoop, psp);
return false; }
if (info.status != PSP_THREAD_STOPPED)
return false;
psp->running = true;
sceKernelStartThread(psp->thread, sizeof(psp_audio_t*), &psp);
return true; return true;
} }
@ -327,21 +279,12 @@ static size_t psp_write_avail(void *data)
size_t val; size_t val;
psp_audio_t* psp = (psp_audio_t*)data; psp_audio_t* psp = (psp_audio_t*)data;
#ifdef VITA if (!psp||!psp->running)
sceKernelLockLwMutex((struct SceKernelLwMutexWork*)&psp->lock, 1, 0); return 0;
#else slock_lock(psp->fifo_lock);
sceKernelWaitSema(psp->lock, 1, 0);
#endif
val = AUDIO_BUFFER_SIZE - ((uint16_t) val = AUDIO_BUFFER_SIZE - ((uint16_t)
(psp->write_pos - psp->read_pos) & AUDIO_BUFFER_SIZE_MASK); (psp->write_pos - psp->read_pos) & AUDIO_BUFFER_SIZE_MASK);
slock_unlock(psp->fifo_lock);
#ifdef VITA
sceKernelUnlockLwMutex((struct SceKernelLwMutexWork*)&psp->lock, 1);
#else
sceKernelSignalSema(psp->lock, 1);
#endif
return val; return val;
} }