[mirror_qemu.git] / audio / jackaudio.c

/*
 * QEMU JACK Audio Connection Kit Client
 *
 * Copyright (c) 2020 Geoffrey McRae (gnif)
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#include "qemu/osdep.h"
#include "qemu/module.h"
#include "qemu/atomic.h"
#include "qemu/main-loop.h"
#include "audio.h"

#define AUDIO_CAP "jack"
#include "audio_int.h"

#include <jack/jack.h>
#include <jack/thread.h>

struct QJack;

typedef enum QJackState {
    QJACK_STATE_DISCONNECTED,
    QJACK_STATE_RUNNING,
    QJACK_STATE_SHUTDOWN
}
QJackState;

typedef struct QJackBuffer {
    int          channels;
    int          frames;
    uint32_t     used;
    int          rptr, wptr;
    float      **data;
}
QJackBuffer;

typedef struct QJackClient {
    AudiodevJackPerDirectionOptions *opt;

    bool out;
    bool enabled;
    bool connect_ports;
    int  packets;

    QJackState      state;
    jack_client_t  *client;
    jack_nframes_t  freq;
    QEMUBH         *shutdown_bh;

    struct QJack   *j;
    int             nchannels;
    int             buffersize;
    jack_port_t   **port;
    QJackBuffer     fifo;

    /* Used as workspace by qjack_process() */
    float **process_buffers;
}
QJackClient;

typedef struct QJackOut {
    HWVoiceOut  hw;
    QJackClient c;
}
QJackOut;

typedef struct QJackIn {
    HWVoiceIn   hw;
    QJackClient c;
}
QJackIn;

static int qjack_client_init(QJackClient *c);
static void qjack_client_connect_ports(QJackClient *c);
static void qjack_client_fini(QJackClient *c);
static QemuMutex qjack_shutdown_lock;

static void qjack_buffer_create(QJackBuffer *buffer, int channels, int frames)
{
    buffer->channels = channels;
    buffer->frames   = frames;
    buffer->used     = 0;
    buffer->rptr     = 0;
    buffer->wptr     = 0;
    buffer->data     = g_new(float *, channels);
    for (int i = 0; i < channels; ++i) {
        buffer->data[i] = g_new(float, frames);
    }
}

static void qjack_buffer_clear(QJackBuffer *buffer)
{
    assert(buffer->data);
    qatomic_store_release(&buffer->used, 0);
    buffer->rptr = 0;
    buffer->wptr = 0;
}

static void qjack_buffer_free(QJackBuffer *buffer)
{
    if (!buffer->data) {
        return;
    }

    for (int i = 0; i < buffer->channels; ++i) {
        g_free(buffer->data[i]);
    }

    g_free(buffer->data);
    buffer->data = NULL;
}

/* write PCM interleaved */
static int qjack_buffer_write(QJackBuffer *buffer, float *data, int size)
{
    assert(buffer->data);
    const int samples = size / sizeof(float);
    int frames        = samples / buffer->channels;
    const int avail   = buffer->frames - qatomic_load_acquire(&buffer->used);

    if (frames > avail) {
        frames = avail;
    }

    int copy = frames;
    int wptr = buffer->wptr;

    while (copy) {

        for (int c = 0; c < buffer->channels; ++c) {
            buffer->data[c][wptr] = *data++;
        }

        if (++wptr == buffer->frames) {
            wptr = 0;
        }

        --copy;
    }

    buffer->wptr = wptr;

    qatomic_add(&buffer->used, frames);
    return frames * buffer->channels * sizeof(float);
};

/* write PCM linear */
static int qjack_buffer_write_l(QJackBuffer *buffer, float **dest, int frames)
{
    assert(buffer->data);
    const int avail   = buffer->frames - qatomic_load_acquire(&buffer->used);
    int wptr = buffer->wptr;

    if (frames > avail) {
        frames = avail;
    }

    int right = buffer->frames - wptr;
    if (right > frames) {
        right = frames;
    }

    const int left = frames - right;
    for (int c = 0; c < buffer->channels; ++c) {
        memcpy(buffer->data[c] + wptr, dest[c]        , right * sizeof(float));
        memcpy(buffer->data[c]       , dest[c] + right, left  * sizeof(float));
    }

    wptr += frames;
    if (wptr >= buffer->frames) {
        wptr -= buffer->frames;
    }
    buffer->wptr = wptr;

    qatomic_add(&buffer->used, frames);
    return frames;
}

/* read PCM interleaved */
static int qjack_buffer_read(QJackBuffer *buffer, float *dest, int size)
{
    assert(buffer->data);
    const int samples = size / sizeof(float);
    int frames        = samples / buffer->channels;
    const int avail   = qatomic_load_acquire(&buffer->used);

    if (frames > avail) {
        frames = avail;
    }

    int copy = frames;
    int rptr = buffer->rptr;

    while (copy) {

        for (int c = 0; c < buffer->channels; ++c) {
            *dest++ = buffer->data[c][rptr];
        }

        if (++rptr == buffer->frames) {
            rptr = 0;
        }

        --copy;
    }

    buffer->rptr = rptr;

    qatomic_sub(&buffer->used, frames);
    return frames * buffer->channels * sizeof(float);
}

/* read PCM linear */
static int qjack_buffer_read_l(QJackBuffer *buffer, float **dest, int frames)
{
    assert(buffer->data);
    int copy       = frames;
    const int used = qatomic_load_acquire(&buffer->used);
    int rptr       = buffer->rptr;

    if (copy > used) {
        copy = used;
    }

    int right = buffer->frames - rptr;
    if (right > copy) {
        right = copy;
    }

    const int left = copy - right;
    for (int c = 0; c < buffer->channels; ++c) {
        memcpy(dest[c]        , buffer->data[c] + rptr, right * sizeof(float));
        memcpy(dest[c] + right, buffer->data[c]       , left  * sizeof(float));
    }

    rptr += copy;
    if (rptr >= buffer->frames) {
        rptr -= buffer->frames;
    }
    buffer->rptr = rptr;

    qatomic_sub(&buffer->used, copy);
    return copy;
}

static int qjack_process(jack_nframes_t nframes, void *arg)
{
    QJackClient *c = (QJackClient *)arg;

    if (c->state != QJACK_STATE_RUNNING) {
        return 0;
    }

    /* get the buffers for the ports */
    for (int i = 0; i < c->nchannels; ++i) {
        c->process_buffers[i] = jack_port_get_buffer(c->port[i], nframes);
    }

    if (c->out) {
        if (likely(c->enabled)) {
            qjack_buffer_read_l(&c->fifo, c->process_buffers, nframes);
        } else {
            for (int i = 0; i < c->nchannels; ++i) {
                memset(c->process_buffers[i], 0, nframes * sizeof(float));
            }
        }
    } else {
        if (likely(c->enabled)) {
            qjack_buffer_write_l(&c->fifo, c->process_buffers, nframes);
        }
    }

    return 0;
}

static void qjack_port_registration(jack_port_id_t port, int reg, void *arg)
{
    if (reg) {
        QJackClient *c = (QJackClient *)arg;
        c->connect_ports = true;
    }
}

static int qjack_xrun(void *arg)
{
    QJackClient *c = (QJackClient *)arg;
    if (c->state != QJACK_STATE_RUNNING) {
        return 0;
    }

    qjack_buffer_clear(&c->fifo);
    return 0;
}

static void qjack_shutdown_bh(void *opaque)
{
    QJackClient *c = (QJackClient *)opaque;
    qjack_client_fini(c);
}

static void qjack_shutdown(void *arg)
{
    QJackClient *c = (QJackClient *)arg;
    c->state = QJACK_STATE_SHUTDOWN;
    qemu_bh_schedule(c->shutdown_bh);
}

static void qjack_client_recover(QJackClient *c)
{
    if (c->state != QJACK_STATE_DISCONNECTED) {
        return;
    }

    /* packets is used simply to throttle this */
    if (c->packets % 100 == 0) {

        /* if enabled then attempt to recover */
        if (c->enabled) {
            dolog("attempting to reconnect to server\n");
            qjack_client_init(c);
        }
    }
}

static size_t qjack_write(HWVoiceOut *hw, void *buf, size_t len)
{
    QJackOut *jo = (QJackOut *)hw;
    ++jo->c.packets;

    if (jo->c.state != QJACK_STATE_RUNNING) {
        qjack_client_recover(&jo->c);
        return len;
    }

    qjack_client_connect_ports(&jo->c);
    return qjack_buffer_write(&jo->c.fifo, buf, len);
}

static size_t qjack_read(HWVoiceIn *hw, void *buf, size_t len)
{
    QJackIn *ji = (QJackIn *)hw;
    ++ji->c.packets;

    if (ji->c.state != QJACK_STATE_RUNNING) {
        qjack_client_recover(&ji->c);
        return len;
    }

    qjack_client_connect_ports(&ji->c);
    return qjack_buffer_read(&ji->c.fifo, buf, len);
}

static void qjack_client_connect_ports(QJackClient *c)
{
    if (!c->connect_ports || !c->opt->connect_ports) {
        return;
    }

    c->connect_ports = false;
    const char **ports;
    ports = jack_get_ports(c->client, c->opt->connect_ports, NULL,
        c->out ? JackPortIsInput : JackPortIsOutput);

    if (!ports) {
        return;
    }

    for (int i = 0; i < c->nchannels && ports[i]; ++i) {
        const char *p = jack_port_name(c->port[i]);
        if (jack_port_connected_to(c->port[i], ports[i])) {
            continue;
        }

        if (c->out) {
            dolog("connect %s -> %s\n", p, ports[i]);
            jack_connect(c->client, p, ports[i]);
        } else {
            dolog("connect %s -> %s\n", ports[i], p);
            jack_connect(c->client, ports[i], p);
        }
    }
}

static int qjack_client_init(QJackClient *c)
{
    jack_status_t status;
    int client_name_len = jack_client_name_size(); /* includes NUL */
    g_autofree char *client_name = g_new(char, client_name_len);
    jack_options_t options = JackNullOption;

    if (c->state == QJACK_STATE_RUNNING) {
        return 0;
    }

    c->connect_ports = true;

    snprintf(client_name, client_name_len, "%s-%s",
        c->out ? "out" : "in",
        c->opt->client_name ? c->opt->client_name : audio_application_name());

    if (c->opt->exact_name) {
        options |= JackUseExactName;
    }

    if (!c->opt->start_server) {
        options |= JackNoStartServer;
    }

    if (c->opt->server_name) {
        options |= JackServerName;
    }

    c->client = jack_client_open(client_name, options, &status,
      c->opt->server_name);

    if (c->client == NULL) {
        dolog("jack_client_open failed: status = 0x%2.0x\n", status);
        if (status & JackServerFailed) {
            dolog("unable to connect to JACK server\n");
        }
        return -1;
    }

    c->freq = jack_get_sample_rate(c->client);

    if (status & JackServerStarted) {
        dolog("JACK server started\n");
    }

    if (status & JackNameNotUnique) {
        dolog("JACK unique name assigned %s\n",
          jack_get_client_name(c->client));
    }

    /* Allocate working buffer for process callback */
    c->process_buffers = g_new(float *, c->nchannels);

    jack_set_process_callback(c->client, qjack_process , c);
    jack_set_port_registration_callback(c->client, qjack_port_registration, c);
    jack_set_xrun_callback(c->client, qjack_xrun, c);
    jack_on_shutdown(c->client, qjack_shutdown, c);

    /* allocate and register the ports */
    c->port = g_new(jack_port_t *, c->nchannels);
    for (int i = 0; i < c->nchannels; ++i) {

        char port_name[16];
        snprintf(
            port_name,
            sizeof(port_name),
            c->out ? "output %d" : "input %d",
            i);

        c->port[i] = jack_port_register(
            c->client,
            port_name,
            JACK_DEFAULT_AUDIO_TYPE,
            c->out ? JackPortIsOutput : JackPortIsInput,
            0);
    }

    /* activate the session */
    jack_activate(c->client);
    c->buffersize = jack_get_buffer_size(c->client);

    /*
     * ensure the buffersize is no smaller then 512 samples, some (all?) qemu
     * virtual devices do not work correctly otherwise
     */
    if (c->buffersize < 512) {
        c->buffersize = 512;
    }

    /* create a 3 period buffer */
    qjack_buffer_create(&c->fifo, c->nchannels, c->buffersize * 3);

    qjack_client_connect_ports(c);
    c->state = QJACK_STATE_RUNNING;
    return 0;
}

static int qjack_init_out(HWVoiceOut *hw, struct audsettings *as,
    void *drv_opaque)
{
    QJackOut *jo  = (QJackOut *)hw;
    Audiodev *dev = (Audiodev *)drv_opaque;

    jo->c.out       = true;
    jo->c.enabled   = false;
    jo->c.nchannels = as->nchannels;
    jo->c.opt       = dev->u.jack.out;

    jo->c.shutdown_bh = qemu_bh_new(qjack_shutdown_bh, &jo->c);

    int ret = qjack_client_init(&jo->c);
    if (ret != 0) {
        qemu_bh_delete(jo->c.shutdown_bh);
        return ret;
    }

    /* report the buffer size to qemu */
    hw->samples = jo->c.buffersize;

    /* report the audio format we support */
    struct audsettings os = {
        .freq       = jo->c.freq,
        .nchannels  = jo->c.nchannels,
        .fmt        = AUDIO_FORMAT_F32,
        .endianness = 0
    };
    audio_pcm_init_info(&hw->info, &os);

    dolog("JACK output configured for %dHz (%d samples)\n",
        jo->c.freq, jo->c.buffersize);

    return 0;
}

static int qjack_init_in(HWVoiceIn *hw, struct audsettings *as,
    void *drv_opaque)
{
    QJackIn  *ji  = (QJackIn *)hw;
    Audiodev *dev = (Audiodev *)drv_opaque;

    ji->c.out       = false;
    ji->c.enabled   = false;
    ji->c.nchannels = as->nchannels;
    ji->c.opt       = dev->u.jack.in;

    ji->c.shutdown_bh = qemu_bh_new(qjack_shutdown_bh, &ji->c);

    int ret = qjack_client_init(&ji->c);
    if (ret != 0) {
        qemu_bh_delete(ji->c.shutdown_bh);
        return ret;
    }

    /* report the buffer size to qemu */
    hw->samples = ji->c.buffersize;

    /* report the audio format we support */
    struct audsettings is = {
        .freq       = ji->c.freq,
        .nchannels  = ji->c.nchannels,
        .fmt        = AUDIO_FORMAT_F32,
        .endianness = 0
    };
    audio_pcm_init_info(&hw->info, &is);

    dolog("JACK input configured for %dHz (%d samples)\n",
        ji->c.freq, ji->c.buffersize);

    return 0;
}

static void qjack_client_fini_locked(QJackClient *c)
{
    switch (c->state) {
    case QJACK_STATE_RUNNING:
        jack_deactivate(c->client);
        /* fallthrough */

    case QJACK_STATE_SHUTDOWN:
        jack_client_close(c->client);
        c->client = NULL;

        qjack_buffer_free(&c->fifo);
        g_free(c->port);
        g_free(c->process_buffers);

        c->state = QJACK_STATE_DISCONNECTED;
        /* fallthrough */

    case QJACK_STATE_DISCONNECTED:
        break;
    }
}

static void qjack_client_fini(QJackClient *c)
{
    qemu_mutex_lock(&qjack_shutdown_lock);
    qjack_client_fini_locked(c);
    qemu_mutex_unlock(&qjack_shutdown_lock);
}

static void qjack_fini_out(HWVoiceOut *hw)
{
    QJackOut *jo = (QJackOut *)hw;
    qjack_client_fini(&jo->c);

    qemu_bh_delete(jo->c.shutdown_bh);
}

static void qjack_fini_in(HWVoiceIn *hw)
{
    QJackIn *ji = (QJackIn *)hw;
    qjack_client_fini(&ji->c);

    qemu_bh_delete(ji->c.shutdown_bh);
}

static void qjack_enable_out(HWVoiceOut *hw, bool enable)
{
    QJackOut *jo = (QJackOut *)hw;
    jo->c.enabled = enable;
}

static void qjack_enable_in(HWVoiceIn *hw, bool enable)
{
    QJackIn *ji = (QJackIn *)hw;
    ji->c.enabled = enable;
}

#if !defined(WIN32) && defined(CONFIG_PTHREAD_SETNAME_NP_W_TID)
static int qjack_thread_creator(jack_native_thread_t *thread,
    const pthread_attr_t *attr, void *(*function)(void *), void *arg)
{
    int ret = pthread_create(thread, attr, function, arg);
    if (ret != 0) {
        return ret;
    }

    /* set the name of the thread */
    pthread_setname_np(*thread, "jack-client");

    return ret;
}
#endif

static void *qjack_init(Audiodev *dev, Error **errp)
{
    assert(dev->driver == AUDIODEV_DRIVER_JACK);
    return dev;
}

static void qjack_fini(void *opaque)
{
}

static struct audio_pcm_ops jack_pcm_ops = {
    .init_out       = qjack_init_out,
    .fini_out       = qjack_fini_out,
    .write          = qjack_write,
    .buffer_get_free = audio_generic_buffer_get_free,
    .run_buffer_out = audio_generic_run_buffer_out,
    .enable_out     = qjack_enable_out,

    .init_in        = qjack_init_in,
    .fini_in        = qjack_fini_in,
    .read           = qjack_read,
    .run_buffer_in  = audio_generic_run_buffer_in,
    .enable_in      = qjack_enable_in
};

static struct audio_driver jack_driver = {
    .name           = "jack",
    .descr          = "JACK Audio Connection Kit Client",
    .init           = qjack_init,
    .fini           = qjack_fini,
    .pcm_ops        = &jack_pcm_ops,
    .max_voices_out = INT_MAX,
    .max_voices_in  = INT_MAX,
    .voice_size_out = sizeof(QJackOut),
    .voice_size_in  = sizeof(QJackIn)
};

static void qjack_error(const char *msg)
{
    dolog("E: %s\n", msg);
}

static void qjack_info(const char *msg)
{
    dolog("I: %s\n", msg);
}

static void register_audio_jack(void)
{
    qemu_mutex_init(&qjack_shutdown_lock);
    audio_driver_register(&jack_driver);
#if !defined(WIN32) && defined(CONFIG_PTHREAD_SETNAME_NP_W_TID)
    jack_set_thread_creator(qjack_thread_creator);
#endif
    jack_set_error_function(qjack_error);
    jack_set_info_function(qjack_info);
}
type_init(register_audio_jack);
Commit	Line	Data
2e445703 GM	1	/*
	2	* QEMU JACK Audio Connection Kit Client
	3	*
	4	* Copyright (c) 2020 Geoffrey McRae (gnif)
	5	*
	6	* Permission is hereby granted, free of charge, to any person obtaining a copy
	7	* of this software and associated documentation files (the "Software"), to deal
	8	* in the Software without restriction, including without limitation the rights
	9	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	10	* copies of the Software, and to permit persons to whom the Software is
	11	* furnished to do so, subject to the following conditions:
	12	*
	13	* The above copyright notice and this permission notice shall be included in
	14	* all copies or substantial portions of the Software.
	15	*
	16	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	17	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	18	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	19	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	20	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	21	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	22	* THE SOFTWARE.
	23	*/
	24
	25	#include "qemu/osdep.h"
	26	#include "qemu/module.h"
	27	#include "qemu/atomic.h"
a6e03739	28	#include "qemu/main-loop.h"
2e445703 GM	29	#include "audio.h"
	30
	31	#define AUDIO_CAP "jack"
	32	#include "audio_int.h"
	33
	34	#include <jack/jack.h>
	35	#include <jack/thread.h>
	36
	37	struct QJack;
	38
	39	typedef enum QJackState {
	40	QJACK_STATE_DISCONNECTED,
2e445703 GM	41	QJACK_STATE_RUNNING,
	42	QJACK_STATE_SHUTDOWN
	43	}
	44	QJackState;
	45
	46	typedef struct QJackBuffer {
	47	int channels;
	48	int frames;
	49	uint32_t used;
	50	int rptr, wptr;
	51	float **data;
	52	}
	53	QJackBuffer;
	54
	55	typedef struct QJackClient {
	56	AudiodevJackPerDirectionOptions *opt;
	57
	58	bool out;
81e0efb2	59	bool enabled;
2e445703 GM	60	bool connect_ports;
	61	int packets;
	62
	63	QJackState state;
	64	jack_client_t *client;
	65	jack_nframes_t freq;
a6e03739	66	QEMUBH *shutdown_bh;
2e445703 GM	67
	68	struct QJack *j;
	69	int nchannels;
	70	int buffersize;
	71	jack_port_t **port;
	72	QJackBuffer fifo;
07ffc4b9 PM	73
	74	/* Used as workspace by qjack_process() */
	75	float **process_buffers;
2e445703 GM	76	}
	77	QJackClient;
	78
	79	typedef struct QJackOut {
	80	HWVoiceOut hw;
	81	QJackClient c;
	82	}
	83	QJackOut;
	84
	85	typedef struct QJackIn {
	86	HWVoiceIn hw;
	87	QJackClient c;
	88	}
	89	QJackIn;
	90
	91	static int qjack_client_init(QJackClient *c);
	92	static void qjack_client_connect_ports(QJackClient *c);
	93	static void qjack_client_fini(QJackClient *c);
a6e03739	94	static QemuMutex qjack_shutdown_lock;
2e445703 GM	95
	96	static void qjack_buffer_create(QJackBuffer *buffer, int channels, int frames)
	97	{
	98	buffer->channels = channels;
	99	buffer->frames = frames;
	100	buffer->used = 0;
	101	buffer->rptr = 0;
	102	buffer->wptr = 0;
b21e2380	103	buffer->data = g_new(float *, channels);
2e445703	104	for (int i = 0; i < channels; ++i) {
b21e2380	105	buffer->data[i] = g_new(float, frames);
2e445703 GM	106	}
	107	}
	108
	109	static void qjack_buffer_clear(QJackBuffer *buffer)
	110	{
	111	assert(buffer->data);
d73415a3	112	qatomic_store_release(&buffer->used, 0);
2e445703 GM	113	buffer->rptr = 0;
	114	buffer->wptr = 0;
	115	}
	116
	117	static void qjack_buffer_free(QJackBuffer *buffer)
	118	{
	119	if (!buffer->data) {
	120	return;
	121	}
	122
	123	for (int i = 0; i < buffer->channels; ++i) {
	124	g_free(buffer->data[i]);
	125	}
	126
	127	g_free(buffer->data);
	128	buffer->data = NULL;
	129	}
	130
	131	/* write PCM interleaved */
	132	static int qjack_buffer_write(QJackBuffer buffer, float data, int size)
	133	{
	134	assert(buffer->data);
	135	const int samples = size / sizeof(float);
	136	int frames = samples / buffer->channels;
d73415a3	137	const int avail = buffer->frames - qatomic_load_acquire(&buffer->used);
2e445703 GM	138
	139	if (frames > avail) {
	140	frames = avail;
	141	}
	142
	143	int copy = frames;
	144	int wptr = buffer->wptr;
	145
	146	while (copy) {
	147
	148	for (int c = 0; c < buffer->channels; ++c) {
	149	buffer->data[c][wptr] = *data++;
	150	}
	151
	152	if (++wptr == buffer->frames) {
	153	wptr = 0;
	154	}
	155
	156	--copy;
	157	}
	158
	159	buffer->wptr = wptr;
	160
d73415a3	161	qatomic_add(&buffer->used, frames);
2e445703 GM	162	return frames * buffer->channels * sizeof(float);
	163	};
	164
	165	/* write PCM linear */
	166	static int qjack_buffer_write_l(QJackBuffer buffer, float *dest, int frames)
	167	{
	168	assert(buffer->data);
d73415a3	169	const int avail = buffer->frames - qatomic_load_acquire(&buffer->used);
2e445703 GM	170	int wptr = buffer->wptr;
	171
	172	if (frames > avail) {
	173	frames = avail;
	174	}
	175
	176	int right = buffer->frames - wptr;
	177	if (right > frames) {
	178	right = frames;
	179	}
	180
	181	const int left = frames - right;
	182	for (int c = 0; c < buffer->channels; ++c) {
	183	memcpy(buffer->data[c] + wptr, dest[c] , right * sizeof(float));
	184	memcpy(buffer->data[c] , dest[c] + right, left * sizeof(float));
	185	}
	186
	187	wptr += frames;
	188	if (wptr >= buffer->frames) {
	189	wptr -= buffer->frames;
	190	}
	191	buffer->wptr = wptr;
	192
d73415a3	193	qatomic_add(&buffer->used, frames);
2e445703 GM	194	return frames;
	195	}
	196
	197	/* read PCM interleaved */
	198	static int qjack_buffer_read(QJackBuffer buffer, float dest, int size)
	199	{
	200	assert(buffer->data);
	201	const int samples = size / sizeof(float);
	202	int frames = samples / buffer->channels;
d73415a3	203	const int avail = qatomic_load_acquire(&buffer->used);
2e445703 GM	204
	205	if (frames > avail) {
	206	frames = avail;
	207	}
	208
	209	int copy = frames;
	210	int rptr = buffer->rptr;
	211
	212	while (copy) {
	213
	214	for (int c = 0; c < buffer->channels; ++c) {
	215	*dest++ = buffer->data[c][rptr];
	216	}
	217
	218	if (++rptr == buffer->frames) {
	219	rptr = 0;
	220	}
	221
	222	--copy;
	223	}
	224
	225	buffer->rptr = rptr;
	226
d73415a3	227	qatomic_sub(&buffer->used, frames);
2e445703 GM	228	return frames * buffer->channels * sizeof(float);
	229	}
	230
	231	/* read PCM linear */
	232	static int qjack_buffer_read_l(QJackBuffer buffer, float *dest, int frames)
	233	{
	234	assert(buffer->data);
	235	int copy = frames;
d73415a3	236	const int used = qatomic_load_acquire(&buffer->used);
2e445703 GM	237	int rptr = buffer->rptr;
	238
	239	if (copy > used) {
	240	copy = used;
	241	}
	242
	243	int right = buffer->frames - rptr;
	244	if (right > copy) {
	245	right = copy;
	246	}
	247
	248	const int left = copy - right;
	249	for (int c = 0; c < buffer->channels; ++c) {
	250	memcpy(dest[c] , buffer->data[c] + rptr, right * sizeof(float));
	251	memcpy(dest[c] + right, buffer->data[c] , left * sizeof(float));
	252	}
	253
	254	rptr += copy;
	255	if (rptr >= buffer->frames) {
	256	rptr -= buffer->frames;
	257	}
	258	buffer->rptr = rptr;
	259
d73415a3	260	qatomic_sub(&buffer->used, copy);
2e445703 GM	261	return copy;
	262	}
	263
	264	static int qjack_process(jack_nframes_t nframes, void *arg)
	265	{
	266	QJackClient c = (QJackClient )arg;
	267
	268	if (c->state != QJACK_STATE_RUNNING) {
	269	return 0;
	270	}
	271
	272	/* get the buffers for the ports */
2e445703	273	for (int i = 0; i < c->nchannels; ++i) {
07ffc4b9	274	c->process_buffers[i] = jack_port_get_buffer(c->port[i], nframes);
2e445703 GM	275	}
	276
	277	if (c->out) {
81e0efb2	278	if (likely(c->enabled)) {
07ffc4b9	279	qjack_buffer_read_l(&c->fifo, c->process_buffers, nframes);
81e0efb2	280	} else {
3c8de96c	281	for (int i = 0; i < c->nchannels; ++i) {
07ffc4b9	282	memset(c->process_buffers[i], 0, nframes * sizeof(float));
81e0efb2 GM	283	}
81e0efb2 GM	284	}
2e445703	285	} else {
81e0efb2	286	if (likely(c->enabled)) {
07ffc4b9	287	qjack_buffer_write_l(&c->fifo, c->process_buffers, nframes);
81e0efb2	288	}
2e445703 GM	289	}
	290
	291	return 0;
	292	}
	293
	294	static void qjack_port_registration(jack_port_id_t port, int reg, void *arg)
	295	{
	296	if (reg) {
	297	QJackClient c = (QJackClient )arg;
	298	c->connect_ports = true;
	299	}
	300	}
	301
	302	static int qjack_xrun(void *arg)
	303	{
	304	QJackClient c = (QJackClient )arg;
	305	if (c->state != QJACK_STATE_RUNNING) {
	306	return 0;
	307	}
	308
	309	qjack_buffer_clear(&c->fifo);
	310	return 0;
	311	}
	312
a6e03739 GM	313	static void qjack_shutdown_bh(void *opaque)
	314	{
	315	QJackClient c = (QJackClient )opaque;
	316	qjack_client_fini(c);
	317	}
	318
2e445703 GM	319	static void qjack_shutdown(void *arg)
	320	{
	321	QJackClient c = (QJackClient )arg;
	322	c->state = QJACK_STATE_SHUTDOWN;
a6e03739	323	qemu_bh_schedule(c->shutdown_bh);
2e445703 GM	324	}
	325
	326	static void qjack_client_recover(QJackClient *c)
	327	{
a6e03739 GM	328	if (c->state != QJACK_STATE_DISCONNECTED) {
a6e03739 GM	329	return;
2e445703 GM	330	}
	331
	332	/* packets is used simply to throttle this */
a6e03739	333	if (c->packets % 100 == 0) {
2e445703	334
81e0efb2 GM	335	/* if enabled then attempt to recover */
81e0efb2 GM	336	if (c->enabled) {
2e445703 GM	337	dolog("attempting to reconnect to server\n");
	338	qjack_client_init(c);
	339	}
	340	}
	341	}
	342
	343	static size_t qjack_write(HWVoiceOut hw, void buf, size_t len)
	344	{
	345	QJackOut jo = (QJackOut )hw;
	346	++jo->c.packets;
	347
	348	if (jo->c.state != QJACK_STATE_RUNNING) {
	349	qjack_client_recover(&jo->c);
	350	return len;
	351	}
	352
	353	qjack_client_connect_ports(&jo->c);
	354	return qjack_buffer_write(&jo->c.fifo, buf, len);
	355	}
	356
	357	static size_t qjack_read(HWVoiceIn hw, void buf, size_t len)
	358	{
	359	QJackIn ji = (QJackIn )hw;
	360	++ji->c.packets;
	361
	362	if (ji->c.state != QJACK_STATE_RUNNING) {
	363	qjack_client_recover(&ji->c);
	364	return len;
	365	}
	366
	367	qjack_client_connect_ports(&ji->c);
	368	return qjack_buffer_read(&ji->c.fifo, buf, len);
	369	}
	370
	371	static void qjack_client_connect_ports(QJackClient *c)
	372	{
	373	if (!c->connect_ports \|\| !c->opt->connect_ports) {
	374	return;
	375	}
	376
	377	c->connect_ports = false;
	378	const char **ports;
	379	ports = jack_get_ports(c->client, c->opt->connect_ports, NULL,
	380	c->out ? JackPortIsInput : JackPortIsOutput);
	381
	382	if (!ports) {
	383	return;
	384	}
	385
	386	for (int i = 0; i < c->nchannels && ports[i]; ++i) {
	387	const char *p = jack_port_name(c->port[i]);
	388	if (jack_port_connected_to(c->port[i], ports[i])) {
	389	continue;
	390	}
	391
	392	if (c->out) {
	393	dolog("connect %s -> %s\n", p, ports[i]);
	394	jack_connect(c->client, p, ports[i]);
	395	} else {
	396	dolog("connect %s -> %s\n", ports[i], p);
	397	jack_connect(c->client, ports[i], p);
	398	}
	399	}
	400	}
401
402	static int qjack_client_init(QJackClient *c)
403	{
404	jack_status_t status;
d71c3d30 PM	405	int client_name_len = jack_client_name_size(); /* includes NUL */
d71c3d30 PM	406	g_autofree char *client_name = g_new(char, client_name_len);
2e445703 GM	407	jack_options_t options = JackNullOption;
2e445703 GM	408
bc81e6e5 GM	409	if (c->state == QJACK_STATE_RUNNING) {
	410	return 0;
	411	}
	412
2e445703 GM	413	c->connect_ports = true;
2e445703 GM	414
d71c3d30	415	snprintf(client_name, client_name_len, "%s-%s",
2e445703	416	c->out ? "out" : "in",
2833d697	417	c->opt->client_name ? c->opt->client_name : audio_application_name());
2e445703 GM	418
	419	if (c->opt->exact_name) {
	420	options \|= JackUseExactName;
	421	}
	422
	423	if (!c->opt->start_server) {
	424	options \|= JackNoStartServer;
	425	}
	426
	427	if (c->opt->server_name) {
	428	options \|= JackServerName;
	429	}
	430
	431	c->client = jack_client_open(client_name, options, &status,
	432	c->opt->server_name);
	433
	434	if (c->client == NULL) {
	435	dolog("jack_client_open failed: status = 0x%2.0x\n", status);
	436	if (status & JackServerFailed) {
	437	dolog("unable to connect to JACK server\n");
	438	}
	439	return -1;
	440	}
	441
	442	c->freq = jack_get_sample_rate(c->client);
	443
	444	if (status & JackServerStarted) {
	445	dolog("JACK server started\n");
	446	}
	447
	448	if (status & JackNameNotUnique) {
	449	dolog("JACK unique name assigned %s\n",
	450	jack_get_client_name(c->client));
	451	}
	452
07ffc4b9 PM	453	/* Allocate working buffer for process callback */
	454	c->process_buffers = g_new(float *, c->nchannels);
	455
2e445703 GM	456	jack_set_process_callback(c->client, qjack_process , c);
	457	jack_set_port_registration_callback(c->client, qjack_port_registration, c);
	458	jack_set_xrun_callback(c->client, qjack_xrun, c);
	459	jack_on_shutdown(c->client, qjack_shutdown, c);
	460
2e445703	461	/* allocate and register the ports */
b21e2380	462	c->port = g_new(jack_port_t *, c->nchannels);
2e445703 GM	463	for (int i = 0; i < c->nchannels; ++i) {
	464
	465	char port_name[16];
	466	snprintf(
	467	port_name,
	468	sizeof(port_name),
	469	c->out ? "output %d" : "input %d",
	470	i);
	471
	472	c->port[i] = jack_port_register(
	473	c->client,
	474	port_name,
	475	JACK_DEFAULT_AUDIO_TYPE,
	476	c->out ? JackPortIsOutput : JackPortIsInput,
	477	0);
	478	}
	479
	480	/* activate the session */
	481	jack_activate(c->client);
	482	c->buffersize = jack_get_buffer_size(c->client);
	483
36963ed1 GM	484	/*
	485	* ensure the buffersize is no smaller then 512 samples, some (all?) qemu
	486	* virtual devices do not work correctly otherwise
	487	*/
	488	if (c->buffersize < 512) {
	489	c->buffersize = 512;
	490	}
	491
369829a4 VR	492	/* create a 3 period buffer */
369829a4 VR	493	qjack_buffer_create(&c->fifo, c->nchannels, c->buffersize * 3);
36963ed1	494
2e445703 GM	495	qjack_client_connect_ports(c);
	496	c->state = QJACK_STATE_RUNNING;
	497	return 0;
	498	}
	499
	500	static int qjack_init_out(HWVoiceOut hw, struct audsettings as,
	501	void *drv_opaque)
	502	{
	503	QJackOut jo = (QJackOut )hw;
	504	Audiodev dev = (Audiodev )drv_opaque;
	505
2e445703	506	jo->c.out = true;
81e0efb2	507	jo->c.enabled = false;
2e445703 GM	508	jo->c.nchannels = as->nchannels;
2e445703 GM	509	jo->c.opt = dev->u.jack.out;
81e0efb2	510
a6e03739 GM	511	jo->c.shutdown_bh = qemu_bh_new(qjack_shutdown_bh, &jo->c);
a6e03739 GM	512
2e445703 GM	513	int ret = qjack_client_init(&jo->c);
2e445703 GM	514	if (ret != 0) {
a6e03739	515	qemu_bh_delete(jo->c.shutdown_bh);
2e445703 GM	516	return ret;
	517	}
	518
	519	/* report the buffer size to qemu */
	520	hw->samples = jo->c.buffersize;
	521
	522	/* report the audio format we support */
	523	struct audsettings os = {
	524	.freq = jo->c.freq,
	525	.nchannels = jo->c.nchannels,
	526	.fmt = AUDIO_FORMAT_F32,
	527	.endianness = 0
	528	};
	529	audio_pcm_init_info(&hw->info, &os);
	530
	531	dolog("JACK output configured for %dHz (%d samples)\n",
	532	jo->c.freq, jo->c.buffersize);
	533
	534	return 0;
	535	}
	536
	537	static int qjack_init_in(HWVoiceIn hw, struct audsettings as,
	538	void *drv_opaque)
	539	{
	540	QJackIn ji = (QJackIn )hw;
	541	Audiodev dev = (Audiodev )drv_opaque;
	542
2e445703	543	ji->c.out = false;
81e0efb2	544	ji->c.enabled = false;
2e445703 GM	545	ji->c.nchannels = as->nchannels;
2e445703 GM	546	ji->c.opt = dev->u.jack.in;
81e0efb2	547
a6e03739 GM	548	ji->c.shutdown_bh = qemu_bh_new(qjack_shutdown_bh, &ji->c);
a6e03739 GM	549
2e445703 GM	550	int ret = qjack_client_init(&ji->c);
2e445703 GM	551	if (ret != 0) {
a6e03739	552	qemu_bh_delete(ji->c.shutdown_bh);
2e445703 GM	553	return ret;
	554	}
	555
	556	/* report the buffer size to qemu */
	557	hw->samples = ji->c.buffersize;
	558
	559	/* report the audio format we support */
	560	struct audsettings is = {
	561	.freq = ji->c.freq,
	562	.nchannels = ji->c.nchannels,
	563	.fmt = AUDIO_FORMAT_F32,
	564	.endianness = 0
	565	};
	566	audio_pcm_init_info(&hw->info, &is);
	567
	568	dolog("JACK input configured for %dHz (%d samples)\n",
	569	ji->c.freq, ji->c.buffersize);
	570
	571	return 0;
	572	}
	573
a6e03739	574	static void qjack_client_fini_locked(QJackClient *c)
2e445703 GM	575	{
	576	switch (c->state) {
	577	case QJACK_STATE_RUNNING:
2e445703 GM	578	jack_deactivate(c->client);
	579	/* fallthrough */
	580
	581	case QJACK_STATE_SHUTDOWN:
	582	jack_client_close(c->client);
a6e03739 GM	583	c->client = NULL;
	584
	585	qjack_buffer_free(&c->fifo);
	586	g_free(c->port);
07ffc4b9	587	g_free(c->process_buffers);
a6e03739 GM	588
a6e03739 GM	589	c->state = QJACK_STATE_DISCONNECTED;
2e445703 GM	590	/* fallthrough */
	591
	592	case QJACK_STATE_DISCONNECTED:
	593	break;
	594	}
a6e03739	595	}
2e445703	596
a6e03739 GM	597	static void qjack_client_fini(QJackClient *c)
	598	{
	599	qemu_mutex_lock(&qjack_shutdown_lock);
	600	qjack_client_fini_locked(c);
	601	qemu_mutex_unlock(&qjack_shutdown_lock);
2e445703 GM	602	}
	603
	604	static void qjack_fini_out(HWVoiceOut *hw)
	605	{
	606	QJackOut jo = (QJackOut )hw;
2e445703	607	qjack_client_fini(&jo->c);
a6e03739 GM	608
a6e03739 GM	609	qemu_bh_delete(jo->c.shutdown_bh);
2e445703 GM	610	}
	611
	612	static void qjack_fini_in(HWVoiceIn *hw)
	613	{
	614	QJackIn ji = (QJackIn )hw;
2e445703	615	qjack_client_fini(&ji->c);
a6e03739 GM	616
a6e03739 GM	617	qemu_bh_delete(ji->c.shutdown_bh);
2e445703 GM	618	}
	619
	620	static void qjack_enable_out(HWVoiceOut *hw, bool enable)
	621	{
81e0efb2 GM	622	QJackOut jo = (QJackOut )hw;
81e0efb2 GM	623	jo->c.enabled = enable;
2e445703 GM	624	}
	625
	626	static void qjack_enable_in(HWVoiceIn *hw, bool enable)
	627	{
81e0efb2 GM	628	QJackIn ji = (QJackIn )hw;
81e0efb2 GM	629	ji->c.enabled = enable;
2e445703 GM	630	}
2e445703 GM	631
ead789eb	632	#if !defined(WIN32) && defined(CONFIG_PTHREAD_SETNAME_NP_W_TID)
2e445703 GM	633	static int qjack_thread_creator(jack_native_thread_t *thread,
	634	const pthread_attr_t attr, void (function)(void ), void *arg)
	635	{
	636	int ret = pthread_create(thread, attr, function, arg);
	637	if (ret != 0) {
	638	return ret;
	639	}
	640
	641	/* set the name of the thread */
	642	pthread_setname_np(*thread, "jack-client");
	643
	644	return ret;
	645	}
ead789eb	646	#endif
2e445703	647
f6061733	648	static void qjack_init(Audiodev dev, Error **errp)
2e445703 GM	649	{
2e445703 GM	650	assert(dev->driver == AUDIODEV_DRIVER_JACK);
2e445703 GM	651	return dev;
	652	}
	653
	654	static void qjack_fini(void *opaque)
	655	{
	656	}
	657
	658	static struct audio_pcm_ops jack_pcm_ops = {
	659	.init_out = qjack_init_out,
	660	.fini_out = qjack_fini_out,
	661	.write = qjack_write,
9833438e	662	.buffer_get_free = audio_generic_buffer_get_free,
2e445703 GM	663	.run_buffer_out = audio_generic_run_buffer_out,
	664	.enable_out = qjack_enable_out,
	665
	666	.init_in = qjack_init_in,
	667	.fini_in = qjack_fini_in,
	668	.read = qjack_read,
a2893c83	669	.run_buffer_in = audio_generic_run_buffer_in,
2e445703 GM	670	.enable_in = qjack_enable_in
	671	};
	672
	673	static struct audio_driver jack_driver = {
	674	.name = "jack",
	675	.descr = "JACK Audio Connection Kit Client",
	676	.init = qjack_init,
	677	.fini = qjack_fini,
	678	.pcm_ops = &jack_pcm_ops,
2e445703 GM	679	.max_voices_out = INT_MAX,
	680	.max_voices_in = INT_MAX,
	681	.voice_size_out = sizeof(QJackOut),
	682	.voice_size_in = sizeof(QJackIn)
	683	};
	684
	685	static void qjack_error(const char *msg)
	686	{
	687	dolog("E: %s\n", msg);
	688	}
	689
	690	static void qjack_info(const char *msg)
	691	{
	692	dolog("I: %s\n", msg);
	693	}
	694
	695	static void register_audio_jack(void)
	696	{
a6e03739	697	qemu_mutex_init(&qjack_shutdown_lock);
2e445703	698	audio_driver_register(&jack_driver);
ead789eb	699	#if !defined(WIN32) && defined(CONFIG_PTHREAD_SETNAME_NP_W_TID)
2e445703	700	jack_set_thread_creator(qjack_thread_creator);
ead789eb	701	#endif
2e445703 GM	702	jack_set_error_function(qjack_error);
	703	jack_set_info_function(qjack_info);
	704	}
	705	type_init(register_audio_jack);