mirror of
https://github.com/libretro/RetroArch
synced 2025-01-25 06:35:30 +00:00
301 lines
7.7 KiB
C
301 lines
7.7 KiB
C
/* SSNES - A Super Ninteno Entertainment System (SNES) Emulator frontend for libsnes.
|
|
* Copyright (C) 2010 - Hans-Kristian Arntzen
|
|
*
|
|
* Some code herein may be based on code found in BSNES.
|
|
*
|
|
* SSNES 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.
|
|
*
|
|
* SSNES 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 SSNES.
|
|
* If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
|
|
#include "driver.h"
|
|
#include <stdlib.h>
|
|
#include "general.h"
|
|
|
|
#include <jack/jack.h>
|
|
#include <jack/types.h>
|
|
#include <jack/ringbuffer.h>
|
|
#include <pthread.h>
|
|
#include <stdint.h>
|
|
#include <stdbool.h>
|
|
#include <string.h>
|
|
#include <assert.h>
|
|
|
|
#define FRAMES(x) (x / (sizeof(int16_t) * 2))
|
|
#define SAMPLES(x) (x / sizeof(int16_t))
|
|
|
|
typedef struct jack
|
|
{
|
|
jack_client_t *client;
|
|
jack_port_t *ports[2];
|
|
jack_ringbuffer_t *buffer[2];
|
|
volatile bool shutdown;
|
|
bool nonblock;
|
|
|
|
pthread_cond_t cond;
|
|
pthread_mutex_t cond_lock;
|
|
} jack_t;
|
|
|
|
static int process_cb(jack_nframes_t nframes, void *data)
|
|
{
|
|
jack_t *jd = data;
|
|
if (nframes <= 0)
|
|
{
|
|
pthread_cond_signal(&jd->cond);
|
|
return 0;
|
|
}
|
|
|
|
jack_nframes_t avail[2];
|
|
avail[0] = jack_ringbuffer_read_space(jd->buffer[0]);
|
|
avail[1] = jack_ringbuffer_read_space(jd->buffer[1]);
|
|
jack_nframes_t min_avail = ((avail[0] < avail[1]) ? avail[0] : avail[1]) / sizeof(jack_default_audio_sample_t);
|
|
|
|
if (min_avail > nframes)
|
|
min_avail = nframes;
|
|
|
|
//static int underrun = 0;
|
|
//if (min_avail < nframes)
|
|
//{
|
|
// SSNES_LOG("JACK: Underrun count: %d\n", underrun++);
|
|
// fprintf(stderr, "required %d frames, got %d.\n", (int)nframes, (int)min_avail);
|
|
//}
|
|
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
jack_default_audio_sample_t *out = jack_port_get_buffer(jd->ports[i], nframes);
|
|
assert(out);
|
|
jack_ringbuffer_read(jd->buffer[i], (char*)out, min_avail * sizeof(jack_default_audio_sample_t));
|
|
|
|
for (jack_nframes_t f = min_avail; f < nframes; f++)
|
|
{
|
|
out[f] = 0.0f;
|
|
}
|
|
}
|
|
pthread_cond_signal(&jd->cond);
|
|
return 0;
|
|
}
|
|
|
|
static void shutdown_cb(void *data)
|
|
{
|
|
jack_t *jd = data;
|
|
jd->shutdown = true;
|
|
pthread_cond_signal(&jd->cond);
|
|
}
|
|
|
|
static inline void s16_to_float(jack_default_audio_sample_t * restrict out, const int16_t * restrict in, size_t samples)
|
|
{
|
|
for (int i = 0; i < samples; i++)
|
|
out[i] = (float)in[i] / 0x8000;
|
|
}
|
|
|
|
static void parse_ports(const char **dest_ports, const char **jports)
|
|
{
|
|
int parsed = 0;
|
|
|
|
const char *con = strtok(g_settings.audio.device, ",");
|
|
if (con)
|
|
dest_ports[parsed++] = con;
|
|
con = strtok(NULL, ",");
|
|
if (con)
|
|
dest_ports[parsed++] = con;
|
|
|
|
for (int i = parsed; i < 2; i++)
|
|
dest_ports[i] = jports[i];
|
|
}
|
|
|
|
static void* __jack_init(const char* device, int rate, int latency)
|
|
{
|
|
jack_t *jd = calloc(1, sizeof(jack_t));
|
|
if ( jd == NULL )
|
|
return NULL;
|
|
|
|
const char **jports = NULL;
|
|
|
|
jd->client = jack_client_open("SSNES", JackNullOption, NULL);
|
|
if (jd->client == NULL)
|
|
goto error;
|
|
|
|
g_settings.audio.out_rate = jack_get_sample_rate(jd->client);
|
|
|
|
jack_set_process_callback(jd->client, process_cb, jd);
|
|
jack_on_shutdown(jd->client, shutdown_cb, jd);
|
|
|
|
jd->ports[0] = jack_port_register(jd->client, "left", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
|
|
jd->ports[1] = jack_port_register(jd->client, "right", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
|
|
if (jd->ports[0] == NULL || jd->ports[1] == NULL)
|
|
{
|
|
SSNES_ERR("Failed to register ports.\n");
|
|
goto error;
|
|
}
|
|
|
|
jack_nframes_t bufsize;
|
|
jack_nframes_t jack_bufsize = jack_get_buffer_size(jd->client);
|
|
|
|
bufsize = (latency * g_settings.audio.out_rate / 1000) > jack_bufsize * 2 ? (latency * g_settings.audio.out_rate / 1000) : jack_bufsize * 2;
|
|
bufsize *= sizeof(jack_default_audio_sample_t);
|
|
|
|
//fprintf(stderr, "jack buffer size: %d\n", (int)bufsize);
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
jd->buffer[i] = jack_ringbuffer_create(bufsize);
|
|
if (jd->buffer[i] == NULL)
|
|
{
|
|
SSNES_ERR("Failed to create buffers.\n");
|
|
goto error;
|
|
}
|
|
}
|
|
|
|
const char *dest_ports[2];
|
|
jports = jack_get_ports(jd->client, NULL, NULL, JackPortIsPhysical | JackPortIsInput);
|
|
if (jports == NULL)
|
|
{
|
|
SSNES_ERR("Failed to get ports.\n");
|
|
goto error;
|
|
}
|
|
|
|
parse_ports(dest_ports, jports);
|
|
|
|
if (jack_activate(jd->client) < 0)
|
|
{
|
|
SSNES_ERR("Failed to activate Jack...\n");
|
|
goto error;
|
|
}
|
|
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
if (jack_connect(jd->client, jack_port_name(jd->ports[i]), dest_ports[i]))
|
|
{
|
|
SSNES_ERR("Failed to connect to Jack port.\n");
|
|
goto error;
|
|
}
|
|
}
|
|
|
|
pthread_cond_init(&jd->cond, NULL);
|
|
pthread_mutex_init(&jd->cond_lock, NULL);
|
|
|
|
|
|
jack_free(jports);
|
|
return jd;
|
|
|
|
error:
|
|
if (jports != NULL)
|
|
jack_free(jports);
|
|
return NULL;
|
|
}
|
|
|
|
static size_t write_buffer(jack_t *jd, const void *buf, size_t size)
|
|
{
|
|
//fprintf(stderr, "write_buffer: size: %zu\n", size);
|
|
// Convert our data to float, deinterleave and write.
|
|
jack_default_audio_sample_t out_buffer[size / sizeof(int16_t)];
|
|
jack_default_audio_sample_t out_deinterleaved_buffer[2][FRAMES(size)];
|
|
s16_to_float(out_buffer, buf, SAMPLES(size));
|
|
|
|
for (int i = 0; i < 2; i++)
|
|
for (size_t j = 0; j < FRAMES(size); j++)
|
|
out_deinterleaved_buffer[i][j] = out_buffer[j * 2 + i];
|
|
|
|
for(;;)
|
|
{
|
|
if (jd->shutdown)
|
|
return 0;
|
|
|
|
size_t avail[2];
|
|
avail[0] = jack_ringbuffer_write_space(jd->buffer[0]);
|
|
avail[1] = jack_ringbuffer_write_space(jd->buffer[1]);
|
|
size_t min_avail = avail[0] < avail[1] ? avail[0] : avail[1];
|
|
|
|
if (jd->nonblock)
|
|
{
|
|
if (min_avail < FRAMES(size) * sizeof(jack_default_audio_sample_t))
|
|
size = min_avail * 2 * sizeof(int16_t) / sizeof(jack_default_audio_sample_t);
|
|
break;
|
|
}
|
|
|
|
else
|
|
{
|
|
//fprintf(stderr, "Write avail is: %d\n", (int)min_avail);
|
|
if (min_avail >= FRAMES(size) * sizeof(jack_default_audio_sample_t))
|
|
break;
|
|
}
|
|
|
|
pthread_mutex_lock(&jd->cond_lock);
|
|
pthread_cond_wait(&jd->cond, &jd->cond_lock);
|
|
pthread_mutex_unlock(&jd->cond_lock);
|
|
}
|
|
|
|
for (int i = 0; i < 2; i++)
|
|
jack_ringbuffer_write(jd->buffer[i], (const char*)out_deinterleaved_buffer[i], FRAMES(size) * sizeof(jack_default_audio_sample_t));
|
|
return size;
|
|
}
|
|
|
|
static ssize_t __jack_write(void* data, const void* buf, size_t size)
|
|
{
|
|
jack_t *jd = data;
|
|
|
|
return write_buffer(jd, buf, size);
|
|
}
|
|
|
|
static bool __jack_stop(void *data)
|
|
{
|
|
(void)data;
|
|
return true;
|
|
}
|
|
|
|
static void __jack_set_nonblock_state(void *data, bool state)
|
|
{
|
|
jack_t *jd = data;
|
|
jd->nonblock = state;
|
|
}
|
|
|
|
static bool __jack_start(void *data)
|
|
{
|
|
(void)data;
|
|
return true;
|
|
}
|
|
|
|
static void __jack_free(void *data)
|
|
{
|
|
jack_t *jd = data;
|
|
|
|
jd->shutdown = true;
|
|
|
|
if (jd->client != NULL)
|
|
{
|
|
jack_deactivate(jd->client);
|
|
jack_client_close(jd->client);
|
|
}
|
|
|
|
for (int i = 0; i < 2; i++)
|
|
if (jd->buffer[i] != NULL)
|
|
jack_ringbuffer_free(jd->buffer[i]);
|
|
|
|
pthread_mutex_destroy(&jd->cond_lock);
|
|
pthread_cond_destroy(&jd->cond);
|
|
free(jd);
|
|
}
|
|
|
|
const audio_driver_t audio_jack = {
|
|
.init = __jack_init,
|
|
.write = __jack_write,
|
|
.stop = __jack_stop,
|
|
.start = __jack_start,
|
|
.set_nonblock_state = __jack_set_nonblock_state,
|
|
.free = __jack_free,
|
|
.ident = "jack"
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|