mirror of
https://github.com/libretro/RetroArch.git
synced 2024-11-24 00:20:01 +00:00
449 lines
12 KiB
C
449 lines
12 KiB
C
/* RetroArch - A frontend for libretro.
|
|
* Copyright (C) 2018 - misson20000
|
|
* Copyright (C) 2018 - m4xw
|
|
* Copyright (C) 2018 - lifajucejo
|
|
*
|
|
* RetroArch is free software: you can redistribute it and/or modify it under the terms
|
|
* of the GNU General Public License as published by the Free Software Found-
|
|
* ation, either version 3 of the License, or (at your option) any later version.
|
|
*
|
|
* RetroArch is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
|
|
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
* PURPOSE. See the GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along with RetroArch.
|
|
* If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <malloc.h>
|
|
#include <stdint.h>
|
|
#include <sys/unistd.h>
|
|
|
|
#ifdef HAVE_LIBNX
|
|
#include <switch.h>
|
|
#else
|
|
#include <libtransistor/nx.h>
|
|
#endif
|
|
|
|
#include <queues/fifo_queue.h>
|
|
#include "../audio_driver.h"
|
|
#include "../../verbosity.h"
|
|
|
|
#include "../../tasks/tasks_internal.h"
|
|
|
|
#include "switch_audio_compat.h"
|
|
|
|
static const size_t thread_stack_size = 1024 * 8;
|
|
static const int thread_preferred_cpu = 2;
|
|
static const int channel_count = 2;
|
|
static const size_t sample_size = sizeof(uint16_t);
|
|
static const size_t frame_size = channel_count * sample_size;
|
|
|
|
#define AUDIO_BUFFER_COUNT 2
|
|
|
|
typedef struct
|
|
{
|
|
fifo_buffer_t* fifo;
|
|
compat_mutex fifoLock;
|
|
compat_condvar cond;
|
|
compat_mutex condLock;
|
|
|
|
size_t fifoSize;
|
|
|
|
volatile bool running;
|
|
bool nonblocking;
|
|
bool is_paused;
|
|
|
|
compat_audio_out_buffer buffers[AUDIO_BUFFER_COUNT];
|
|
compat_thread thread;
|
|
|
|
unsigned latency;
|
|
uint32_t sampleRate;
|
|
|
|
#ifndef HAVE_LIBNX
|
|
audio_output_t output;
|
|
handle_t event;
|
|
#endif
|
|
} switch_thread_audio_t;
|
|
|
|
static void mainLoop(void* data)
|
|
{
|
|
Result rc;
|
|
uint32_t released_out_count = 0;
|
|
compat_audio_out_buffer *released_out_buffer = NULL;
|
|
switch_thread_audio_t *swa = (switch_thread_audio_t*)data;
|
|
|
|
if (!swa)
|
|
return;
|
|
|
|
RARCH_LOG("[Audio]: start mainLoop cpu %u tid %u\n", svcGetCurrentProcessorNumber(), swa->thread.handle);
|
|
|
|
|
|
while (swa->running)
|
|
{
|
|
size_t buf_avail, avail, to_write;
|
|
|
|
if (!released_out_buffer)
|
|
{
|
|
#ifdef HAVE_LIBNX
|
|
rc = audoutWaitPlayFinish(&released_out_buffer, &released_out_count, U64_MAX);
|
|
#else
|
|
uint32_t handle_idx = 0;
|
|
svcWaitSynchronization(&handle_idx, &swa->event, 1, 33333333);
|
|
svcResetSignal(swa->event);
|
|
|
|
rc = audio_ipc_output_get_released_buffer(&swa->output, &released_out_count, &released_out_buffer);
|
|
#endif
|
|
if (R_FAILED(rc))
|
|
{
|
|
swa->running = false;
|
|
RARCH_LOG("[Audio]: audoutGetReleasedAudioOutBuffer failed: %d\n", (int)rc);
|
|
break;
|
|
}
|
|
released_out_buffer->data_size = 0;
|
|
}
|
|
|
|
buf_avail = released_out_buffer->buffer_size - released_out_buffer->data_size;
|
|
|
|
compat_mutex_lock(&swa->fifoLock);
|
|
|
|
avail = fifo_read_avail(swa->fifo);
|
|
to_write = MIN(avail, buf_avail);
|
|
if (to_write > 0)
|
|
{
|
|
uint8_t *base;
|
|
#ifdef HAVE_LIBNX
|
|
base = (uint8_t*) released_out_buffer->buffer;
|
|
#else
|
|
base = (uint8_t*) released_out_buffer->sample_data;
|
|
#endif
|
|
fifo_read(swa->fifo, base + released_out_buffer->data_size, to_write);
|
|
}
|
|
|
|
compat_mutex_unlock(&swa->fifoLock);
|
|
compat_condvar_wake_all(&swa->cond);
|
|
|
|
released_out_buffer->data_size += to_write;
|
|
if (released_out_buffer->data_size >= released_out_buffer->buffer_size / 2)
|
|
{
|
|
rc = switch_audio_ipc_output_append_buffer(swa, released_out_buffer);
|
|
if (R_FAILED(rc))
|
|
{
|
|
RARCH_LOG("[Audio]: audoutAppendAudioOutBuffer failed: %d\n", (int)rc);
|
|
}
|
|
released_out_buffer = NULL;
|
|
}
|
|
else
|
|
svcSleepThread(16000000); /* 16ms */
|
|
}
|
|
}
|
|
|
|
static void *switch_thread_audio_init(const char *device, unsigned rate, unsigned latency, unsigned block_frames, unsigned *new_rate)
|
|
{
|
|
Result rc;
|
|
unsigned i;
|
|
uint32_t prio;
|
|
char names[8][0x20];
|
|
uint32_t num_names = 0;
|
|
switch_thread_audio_t *swa = (switch_thread_audio_t *)calloc(1, sizeof(*swa));
|
|
|
|
if (!swa)
|
|
return NULL;
|
|
|
|
swa->running = true;
|
|
swa->nonblocking = true;
|
|
swa->is_paused = true;
|
|
swa->latency = MAX(latency, 8);
|
|
|
|
rc = switch_audio_ipc_init();
|
|
if (R_FAILED(rc))
|
|
{
|
|
RARCH_LOG("[Audio]: audio init failed %d\n", (int)rc);
|
|
free(swa);
|
|
return NULL;
|
|
}
|
|
|
|
#ifdef HAVE_LIBNX
|
|
rc = audoutStartAudioOut();
|
|
if (R_FAILED(rc))
|
|
{
|
|
RARCH_LOG("[Audio]: audio start init failed: %d\n", (int)rc);
|
|
goto fail_audio_ipc;
|
|
}
|
|
|
|
swa->sampleRate = audoutGetSampleRate();
|
|
#else
|
|
if (audio_ipc_list_outputs(&names[0], 8, &num_names) != RESULT_OK)
|
|
goto fail_audio_ipc;
|
|
|
|
if (num_names != 1)
|
|
{
|
|
RARCH_ERR("[Audio]: got back more than one AudioOut\n");
|
|
goto fail_audio_ipc;
|
|
}
|
|
|
|
if (audio_ipc_open_output(names[0], &swa->output) != RESULT_OK)
|
|
goto fail_audio_ipc;
|
|
|
|
swa->sampleRate = swa->output.sample_rate;
|
|
|
|
if (swa->output.num_channels != 2)
|
|
{
|
|
RARCH_ERR("expected %d channels, got %d\n", 2,
|
|
swa->output.num_channels);
|
|
goto fail_audio_output;
|
|
}
|
|
|
|
if (swa->output.sample_format != PCM_INT16)
|
|
{
|
|
RARCH_ERR("expected PCM_INT16, got %d\n", swa->output.sample_format);
|
|
goto fail_audio_output;
|
|
}
|
|
|
|
if (audio_ipc_output_register_buffer_event(&swa->output, &swa->event) != 0)
|
|
goto fail_audio_output;
|
|
#endif
|
|
|
|
*new_rate = swa->sampleRate;
|
|
swa->fifoSize = (swa->sampleRate * sample_size * swa->latency) / 1000;
|
|
|
|
for (i = 0; i < AUDIO_BUFFER_COUNT; i++)
|
|
{
|
|
#ifdef HAVE_LIBNX
|
|
swa->buffers[i].next = NULL; /* Unused */
|
|
swa->buffers[i].data_offset = 0;
|
|
swa->buffers[i].buffer_size = swa->fifoSize;
|
|
swa->buffers[i].data_size = swa->buffers[i].buffer_size;
|
|
swa->buffers[i].buffer = memalign(0x1000, swa->buffers[i].buffer_size);
|
|
|
|
if (swa->buffers[i].buffer == NULL)
|
|
goto fail;
|
|
|
|
memset(swa->buffers[i].buffer, 0, swa->buffers[i].buffer_size);
|
|
#else
|
|
swa->buffers[i].ptr = &swa->buffers[i].sample_data;
|
|
swa->buffers[i].unknown = 0;
|
|
swa->buffers[i].buffer_size = swa->fifoSize;
|
|
swa->buffers[i].data_size = swa->buffers[i].buffer_size;
|
|
swa->buffers[i].sample_data = alloc_pages(swa->buffers[i].buffer_size, swa->buffers[i].buffer_size, NULL);
|
|
|
|
if (swa->buffers[i].sample_data == NULL)
|
|
goto fail_audio_output;
|
|
|
|
memset(swa->buffers[i].sample_data, 0, swa->buffers[i].buffer_size);
|
|
#endif
|
|
|
|
if (switch_audio_ipc_output_append_buffer(swa, &swa->buffers[i]) != 0)
|
|
goto fail_audio_output;
|
|
}
|
|
|
|
compat_mutex_create(&swa->fifoLock);
|
|
swa->fifo = fifo_new(swa->fifoSize);
|
|
|
|
compat_condvar_create(&swa->cond);
|
|
|
|
RARCH_LOG("[Audio]: switch_thread_audio_init device %s requested rate %hu rate %hu latency %hu block_frames %hu fifoSize %lu\n",
|
|
device, rate, swa->sampleRate, swa->latency, block_frames, swa->fifoSize);
|
|
|
|
svcGetThreadPriority(&prio, 0xffff8000);
|
|
rc = compat_thread_create(&swa->thread, &mainLoop, (void*)swa, thread_stack_size, prio - 1, thread_preferred_cpu);
|
|
|
|
if (R_FAILED(rc))
|
|
{
|
|
RARCH_LOG("[Audio]: thread creation failed create %u\n", swa->thread.handle);
|
|
swa->running = false;
|
|
return NULL;
|
|
}
|
|
|
|
if (R_FAILED(compat_thread_start(&swa->thread)))
|
|
{
|
|
RARCH_LOG("[Audio]: thread creation failed start %u\n", swa->thread.handle);
|
|
compat_thread_close(&swa->thread);
|
|
swa->running = false;
|
|
return NULL;
|
|
}
|
|
|
|
return swa;
|
|
|
|
fail_audio_output:
|
|
#ifndef HAVE_LIBNX
|
|
audio_ipc_output_close(&swa->output);
|
|
#endif
|
|
fail_audio_ipc:
|
|
switch_audio_ipc_finalize();
|
|
fail:
|
|
free(swa); // freeing a null ptr is valid
|
|
return NULL;
|
|
}
|
|
|
|
static bool switch_thread_audio_start(void *data, bool is_shutdown)
|
|
{
|
|
/* RARCH_LOG("[Audio]: switch_thread_audio_start\n"); */
|
|
switch_thread_audio_t *swa = (switch_thread_audio_t *)data;
|
|
|
|
if (!swa)
|
|
return false;
|
|
|
|
swa->is_paused = false;
|
|
return true;
|
|
}
|
|
|
|
static bool switch_thread_audio_stop(void *data)
|
|
{
|
|
switch_thread_audio_t* swa = (switch_thread_audio_t*)data;
|
|
|
|
if (!swa)
|
|
return false;
|
|
|
|
swa->is_paused = true;
|
|
return true;
|
|
}
|
|
|
|
static void switch_thread_audio_free(void *data)
|
|
{
|
|
unsigned i;
|
|
switch_thread_audio_t *swa = (switch_thread_audio_t *)data;
|
|
|
|
if (!swa)
|
|
return;
|
|
|
|
if (swa->running)
|
|
{
|
|
swa->running = false;
|
|
compat_thread_join(&swa->thread);
|
|
compat_thread_close(&swa->thread);
|
|
}
|
|
|
|
switch_audio_ipc_output_stop(swa);
|
|
switch_audio_ipc_finalize();
|
|
|
|
if (swa->fifo)
|
|
{
|
|
fifo_free(swa->fifo);
|
|
swa->fifo = NULL;
|
|
}
|
|
|
|
for (i = 0; i < ARRAY_SIZE(swa->buffers); i++)
|
|
{
|
|
#ifdef HAVE_LIBNX
|
|
free(swa->buffers[i].buffer);
|
|
#else
|
|
free_pages(swa->buffers[i].sample_data);
|
|
#endif
|
|
}
|
|
|
|
free(swa);
|
|
swa = NULL;
|
|
}
|
|
|
|
static ssize_t switch_thread_audio_write(void *data, const void *buf, size_t size)
|
|
{
|
|
size_t avail, written;
|
|
switch_thread_audio_t *swa = (switch_thread_audio_t *)data;
|
|
|
|
if (!swa || !swa->running)
|
|
return 0;
|
|
|
|
if (swa->nonblocking)
|
|
{
|
|
compat_mutex_lock(&swa->fifoLock);
|
|
avail = fifo_write_avail(swa->fifo);
|
|
written = MIN(avail, size);
|
|
if (written > 0)
|
|
fifo_write(swa->fifo, buf, written);
|
|
compat_mutex_unlock(&swa->fifoLock);
|
|
}
|
|
else
|
|
{
|
|
written = 0;
|
|
while (written < size && swa->running)
|
|
{
|
|
compat_mutex_lock(&swa->fifoLock);
|
|
avail = fifo_write_avail(swa->fifo);
|
|
if (avail == 0)
|
|
{
|
|
compat_mutex_unlock(&swa->fifoLock);
|
|
compat_mutex_lock(&swa->condLock);
|
|
if (swa->running)
|
|
compat_condvar_wait(&swa->cond, &swa->condLock);
|
|
compat_mutex_unlock(&swa->condLock);
|
|
}
|
|
else
|
|
{
|
|
size_t write_amt = MIN(size - written, avail);
|
|
fifo_write(swa->fifo, (const char*)buf + written, write_amt);
|
|
compat_mutex_unlock(&swa->fifoLock);
|
|
written += write_amt;
|
|
}
|
|
}
|
|
}
|
|
|
|
return written;
|
|
}
|
|
|
|
static bool switch_thread_audio_alive(void *data)
|
|
{
|
|
switch_thread_audio_t *swa = (switch_thread_audio_t *)data;
|
|
|
|
if (!swa)
|
|
return false;
|
|
|
|
return !swa->is_paused;
|
|
}
|
|
|
|
static void switch_thread_audio_set_nonblock_state(void *data, bool state)
|
|
{
|
|
switch_thread_audio_t *swa = (switch_thread_audio_t *)data;
|
|
|
|
if (swa)
|
|
swa->nonblocking = state;
|
|
}
|
|
|
|
static bool switch_thread_audio_use_float(void *data)
|
|
{
|
|
(void)data;
|
|
return false;
|
|
}
|
|
|
|
static size_t switch_thread_audio_write_avail(void *data)
|
|
{
|
|
size_t val;
|
|
switch_thread_audio_t* swa = (switch_thread_audio_t*)data;
|
|
|
|
compat_mutex_lock(&swa->fifoLock);
|
|
val = fifo_write_avail(swa->fifo);
|
|
compat_mutex_unlock(&swa->fifoLock);
|
|
|
|
return val;
|
|
}
|
|
|
|
size_t switch_thread_audio_buffer_size(void *data)
|
|
{
|
|
switch_thread_audio_t *swa = (switch_thread_audio_t *)data;
|
|
|
|
if (!swa)
|
|
return 0;
|
|
|
|
return swa->fifoSize;
|
|
}
|
|
|
|
audio_driver_t audio_switch_thread = {
|
|
switch_thread_audio_init,
|
|
switch_thread_audio_write,
|
|
switch_thread_audio_stop,
|
|
switch_thread_audio_start,
|
|
switch_thread_audio_alive,
|
|
switch_thread_audio_set_nonblock_state,
|
|
switch_thread_audio_free,
|
|
switch_thread_audio_use_float,
|
|
"switch_thread",
|
|
NULL, /* device_list_new */
|
|
NULL, /* device_list_free */
|
|
switch_thread_audio_write_avail,
|
|
switch_thread_audio_buffer_size
|
|
};
|
|
|
|
/* vim: set ts=3 sw=3 */
|