/* public domain */
+
#include "qemu/osdep.h"
-#include "qemu-common.h"
+#include "qemu/module.h"
#include "audio.h"
+#include "qapi/opts-visitor.h"
#include <pulse/pulseaudio.h>
#define AUDIO_CAP "pulseaudio"
#include "audio_int.h"
-#include "audio_pt_int.h"
-typedef struct {
- int samples;
+typedef struct PAConnection {
char *server;
- char *sink;
- char *source;
-} PAConf;
+ int refcount;
+ QTAILQ_ENTRY(PAConnection) list;
-typedef struct {
- PAConf conf;
pa_threaded_mainloop *mainloop;
pa_context *context;
+} PAConnection;
+
+static QTAILQ_HEAD(PAConnectionHead, PAConnection) pa_conns =
+ QTAILQ_HEAD_INITIALIZER(pa_conns);
+
+typedef struct {
+ Audiodev *dev;
+ PAConnection *conn;
} paaudio;
typedef struct {
HWVoiceOut hw;
- int done;
- int live;
- int decr;
- int rpos;
pa_stream *stream;
- void *pcm_buf;
- struct audio_pt pt;
paaudio *g;
} PAVoiceOut;
typedef struct {
HWVoiceIn hw;
- int done;
- int dead;
- int incr;
- int wpos;
pa_stream *stream;
- void *pcm_buf;
- struct audio_pt pt;
const void *read_data;
- size_t read_index, read_length;
+ size_t read_length;
paaudio *g;
} PAVoiceIn;
-static void qpa_audio_fini(void *opaque);
+static void qpa_conn_fini(PAConnection *c);
-static void GCC_FMT_ATTR (2, 3) qpa_logerr (int err, const char *fmt, ...)
+static void G_GNUC_PRINTF (2, 3) qpa_logerr (int err, const char *fmt, ...)
{
va_list ap;
}
#endif
-#define CHECK_SUCCESS_GOTO(c, rerror, expression, label) \
+#define CHECK_SUCCESS_GOTO(c, expression, label, msg) \
do { \
if (!(expression)) { \
- if (rerror) { \
- *(rerror) = pa_context_errno ((c)->context); \
- } \
+ qpa_logerr(pa_context_errno((c)->context), msg); \
goto label; \
} \
- } while (0);
+ } while (0)
-#define CHECK_DEAD_GOTO(c, stream, rerror, label) \
+#define CHECK_DEAD_GOTO(c, stream, label, msg) \
do { \
if (!(c)->context || !PA_CONTEXT_IS_GOOD (pa_context_get_state((c)->context)) || \
!(stream) || !PA_STREAM_IS_GOOD (pa_stream_get_state ((stream)))) { \
if (((c)->context && pa_context_get_state ((c)->context) == PA_CONTEXT_FAILED) || \
((stream) && pa_stream_get_state ((stream)) == PA_STREAM_FAILED)) { \
- if (rerror) { \
- *(rerror) = pa_context_errno ((c)->context); \
- } \
+ qpa_logerr(pa_context_errno((c)->context), msg); \
} else { \
- if (rerror) { \
- *(rerror) = PA_ERR_BADSTATE; \
- } \
+ qpa_logerr(PA_ERR_BADSTATE, msg); \
} \
goto label; \
} \
- } while (0);
+ } while (0)
-static int qpa_simple_read (PAVoiceIn *p, void *data, size_t length, int *rerror)
+static void *qpa_get_buffer_in(HWVoiceIn *hw, size_t *size)
{
- paaudio *g = p->g;
+ PAVoiceIn *p = (PAVoiceIn *) hw;
+ PAConnection *c = p->g->conn;
+ int r;
- pa_threaded_mainloop_lock (g->mainloop);
+ pa_threaded_mainloop_lock(c->mainloop);
- CHECK_DEAD_GOTO (g, p->stream, rerror, unlock_and_fail);
+ CHECK_DEAD_GOTO(c, p->stream, unlock_and_fail,
+ "pa_threaded_mainloop_lock failed\n");
- while (length > 0) {
- size_t l;
+ if (!p->read_length) {
+ r = pa_stream_peek(p->stream, &p->read_data, &p->read_length);
+ CHECK_SUCCESS_GOTO(c, r == 0, unlock_and_fail,
+ "pa_stream_peek failed\n");
+ }
- while (!p->read_data) {
- int r;
+ *size = MIN(p->read_length, *size);
- r = pa_stream_peek (p->stream, &p->read_data, &p->read_length);
- CHECK_SUCCESS_GOTO (g, rerror, r == 0, unlock_and_fail);
+ pa_threaded_mainloop_unlock(c->mainloop);
+ return (void *) p->read_data;
- if (!p->read_data) {
- pa_threaded_mainloop_wait (g->mainloop);
- CHECK_DEAD_GOTO (g, p->stream, rerror, unlock_and_fail);
- } else {
- p->read_index = 0;
- }
- }
+unlock_and_fail:
+ pa_threaded_mainloop_unlock(c->mainloop);
+ *size = 0;
+ return NULL;
+}
- l = p->read_length < length ? p->read_length : length;
- memcpy (data, (const uint8_t *) p->read_data+p->read_index, l);
+static void qpa_put_buffer_in(HWVoiceIn *hw, void *buf, size_t size)
+{
+ PAVoiceIn *p = (PAVoiceIn *) hw;
+ PAConnection *c = p->g->conn;
+ int r;
- data = (uint8_t *) data + l;
- length -= l;
+ pa_threaded_mainloop_lock(c->mainloop);
- p->read_index += l;
- p->read_length -= l;
+ CHECK_DEAD_GOTO(c, p->stream, unlock,
+ "pa_threaded_mainloop_lock failed\n");
- if (!p->read_length) {
- int r;
+ assert(buf == p->read_data && size <= p->read_length);
- r = pa_stream_drop (p->stream);
- p->read_data = NULL;
- p->read_length = 0;
- p->read_index = 0;
+ p->read_data += size;
+ p->read_length -= size;
- CHECK_SUCCESS_GOTO (g, rerror, r == 0, unlock_and_fail);
- }
+ if (size && !p->read_length) {
+ r = pa_stream_drop(p->stream);
+ CHECK_SUCCESS_GOTO(c, r == 0, unlock, "pa_stream_drop failed\n");
}
- pa_threaded_mainloop_unlock (g->mainloop);
- return 0;
-
-unlock_and_fail:
- pa_threaded_mainloop_unlock (g->mainloop);
- return -1;
+unlock:
+ pa_threaded_mainloop_unlock(c->mainloop);
}
-static int qpa_simple_write (PAVoiceOut *p, const void *data, size_t length, int *rerror)
+static size_t qpa_read(HWVoiceIn *hw, void *data, size_t length)
{
- paaudio *g = p->g;
+ PAVoiceIn *p = (PAVoiceIn *) hw;
+ PAConnection *c = p->g->conn;
+ size_t total = 0;
- pa_threaded_mainloop_lock (g->mainloop);
+ pa_threaded_mainloop_lock(c->mainloop);
- CHECK_DEAD_GOTO (g, p->stream, rerror, unlock_and_fail);
+ CHECK_DEAD_GOTO(c, p->stream, unlock_and_fail,
+ "pa_threaded_mainloop_lock failed\n");
+ if (pa_stream_get_state(p->stream) != PA_STREAM_READY) {
+ /* wait for stream to become ready */
+ goto unlock;
+ }
- while (length > 0) {
+ while (total < length) {
size_t l;
int r;
- while (!(l = pa_stream_writable_size (p->stream))) {
- pa_threaded_mainloop_wait (g->mainloop);
- CHECK_DEAD_GOTO (g, p->stream, rerror, unlock_and_fail);
+ if (!p->read_length) {
+ r = pa_stream_peek(p->stream, &p->read_data, &p->read_length);
+ CHECK_SUCCESS_GOTO(c, r == 0, unlock_and_fail,
+ "pa_stream_peek failed\n");
+ if (!p->read_length) {
+ /* buffer is empty */
+ break;
+ }
}
- CHECK_SUCCESS_GOTO (g, rerror, l != (size_t) -1, unlock_and_fail);
+ l = MIN(p->read_length, length - total);
+ memcpy((char *)data + total, p->read_data, l);
- if (l > length) {
- l = length;
- }
-
- r = pa_stream_write (p->stream, data, l, NULL, 0LL, PA_SEEK_RELATIVE);
- CHECK_SUCCESS_GOTO (g, rerror, r >= 0, unlock_and_fail);
+ p->read_data += l;
+ p->read_length -= l;
+ total += l;
- data = (const uint8_t *) data + l;
- length -= l;
+ if (!p->read_length) {
+ r = pa_stream_drop(p->stream);
+ CHECK_SUCCESS_GOTO(c, r == 0, unlock_and_fail,
+ "pa_stream_drop failed\n");
+ }
}
- pa_threaded_mainloop_unlock (g->mainloop);
- return 0;
+unlock:
+ pa_threaded_mainloop_unlock(c->mainloop);
+ return total;
unlock_and_fail:
- pa_threaded_mainloop_unlock (g->mainloop);
- return -1;
+ pa_threaded_mainloop_unlock(c->mainloop);
+ return 0;
}
-static void *qpa_thread_out (void *arg)
+static size_t qpa_buffer_get_free(HWVoiceOut *hw)
{
- PAVoiceOut *pa = arg;
- HWVoiceOut *hw = &pa->hw;
+ PAVoiceOut *p = (PAVoiceOut *)hw;
+ PAConnection *c = p->g->conn;
+ size_t l;
- if (audio_pt_lock (&pa->pt, AUDIO_FUNC)) {
- return NULL;
- }
-
- for (;;) {
- int decr, to_mix, rpos;
+ pa_threaded_mainloop_lock(c->mainloop);
- for (;;) {
- if (pa->done) {
- goto exit;
- }
-
- if (pa->live > 0) {
- break;
- }
-
- if (audio_pt_wait (&pa->pt, AUDIO_FUNC)) {
- goto exit;
- }
- }
+ CHECK_DEAD_GOTO(c, p->stream, unlock_and_fail,
+ "pa_threaded_mainloop_lock failed\n");
+ if (pa_stream_get_state(p->stream) != PA_STREAM_READY) {
+ /* wait for stream to become ready */
+ l = 0;
+ goto unlock;
+ }
- decr = to_mix = audio_MIN (pa->live, pa->g->conf.samples >> 2);
- rpos = pa->rpos;
+ l = pa_stream_writable_size(p->stream);
+ CHECK_SUCCESS_GOTO(c, l != (size_t) -1, unlock_and_fail,
+ "pa_stream_writable_size failed\n");
- if (audio_pt_unlock (&pa->pt, AUDIO_FUNC)) {
- return NULL;
- }
+unlock:
+ pa_threaded_mainloop_unlock(c->mainloop);
+ return l;
- while (to_mix) {
- int error;
- int chunk = audio_MIN (to_mix, hw->samples - rpos);
- struct st_sample *src = hw->mix_buf + rpos;
+unlock_and_fail:
+ pa_threaded_mainloop_unlock(c->mainloop);
+ return 0;
+}
- hw->clip (pa->pcm_buf, src, chunk);
+static void *qpa_get_buffer_out(HWVoiceOut *hw, size_t *size)
+{
+ PAVoiceOut *p = (PAVoiceOut *)hw;
+ PAConnection *c = p->g->conn;
+ void *ret;
+ int r;
- if (qpa_simple_write (pa, pa->pcm_buf,
- chunk << hw->info.shift, &error) < 0) {
- qpa_logerr (error, "pa_simple_write failed\n");
- return NULL;
- }
+ pa_threaded_mainloop_lock(c->mainloop);
- rpos = (rpos + chunk) % hw->samples;
- to_mix -= chunk;
- }
+ CHECK_DEAD_GOTO(c, p->stream, unlock_and_fail,
+ "pa_threaded_mainloop_lock failed\n");
- if (audio_pt_lock (&pa->pt, AUDIO_FUNC)) {
- return NULL;
- }
+ *size = -1;
+ r = pa_stream_begin_write(p->stream, &ret, size);
+ CHECK_SUCCESS_GOTO(c, r >= 0, unlock_and_fail,
+ "pa_stream_begin_write failed\n");
- pa->rpos = rpos;
- pa->live -= decr;
- pa->decr += decr;
- }
+ pa_threaded_mainloop_unlock(c->mainloop);
+ return ret;
- exit:
- audio_pt_unlock (&pa->pt, AUDIO_FUNC);
+unlock_and_fail:
+ pa_threaded_mainloop_unlock(c->mainloop);
+ *size = 0;
return NULL;
}
-static int qpa_run_out (HWVoiceOut *hw, int live)
+static size_t qpa_put_buffer_out(HWVoiceOut *hw, void *data, size_t length)
{
- int decr;
- PAVoiceOut *pa = (PAVoiceOut *) hw;
-
- if (audio_pt_lock (&pa->pt, AUDIO_FUNC)) {
- return 0;
- }
-
- decr = audio_MIN (live, pa->decr);
- pa->decr -= decr;
- pa->live = live - decr;
- hw->rpos = pa->rpos;
- if (pa->live > 0) {
- audio_pt_unlock_and_signal (&pa->pt, AUDIO_FUNC);
- }
- else {
- audio_pt_unlock (&pa->pt, AUDIO_FUNC);
- }
- return decr;
-}
-
-static int qpa_write (SWVoiceOut *sw, void *buf, int len)
-{
- return audio_pcm_sw_write (sw, buf, len);
-}
-
-/* capture */
-static void *qpa_thread_in (void *arg)
-{
- PAVoiceIn *pa = arg;
- HWVoiceIn *hw = &pa->hw;
-
- if (audio_pt_lock (&pa->pt, AUDIO_FUNC)) {
- return NULL;
- }
-
- for (;;) {
- int incr, to_grab, wpos;
+ PAVoiceOut *p = (PAVoiceOut *)hw;
+ PAConnection *c = p->g->conn;
+ int r;
- for (;;) {
- if (pa->done) {
- goto exit;
- }
+ pa_threaded_mainloop_lock(c->mainloop);
- if (pa->dead > 0) {
- break;
- }
+ CHECK_DEAD_GOTO(c, p->stream, unlock_and_fail,
+ "pa_threaded_mainloop_lock failed\n");
- if (audio_pt_wait (&pa->pt, AUDIO_FUNC)) {
- goto exit;
- }
- }
+ r = pa_stream_write(p->stream, data, length, NULL, 0LL, PA_SEEK_RELATIVE);
+ CHECK_SUCCESS_GOTO(c, r >= 0, unlock_and_fail, "pa_stream_write failed\n");
- incr = to_grab = audio_MIN (pa->dead, pa->g->conf.samples >> 2);
- wpos = pa->wpos;
+ pa_threaded_mainloop_unlock(c->mainloop);
+ return length;
- if (audio_pt_unlock (&pa->pt, AUDIO_FUNC)) {
- return NULL;
- }
-
- while (to_grab) {
- int error;
- int chunk = audio_MIN (to_grab, hw->samples - wpos);
- void *buf = advance (pa->pcm_buf, wpos);
-
- if (qpa_simple_read (pa, buf,
- chunk << hw->info.shift, &error) < 0) {
- qpa_logerr (error, "pa_simple_read failed\n");
- return NULL;
- }
+unlock_and_fail:
+ pa_threaded_mainloop_unlock(c->mainloop);
+ return 0;
+}
- hw->conv (hw->conv_buf + wpos, buf, chunk);
- wpos = (wpos + chunk) % hw->samples;
- to_grab -= chunk;
- }
+static size_t qpa_write(HWVoiceOut *hw, void *data, size_t length)
+{
+ PAVoiceOut *p = (PAVoiceOut *) hw;
+ PAConnection *c = p->g->conn;
+ size_t l;
+ int r;
- if (audio_pt_lock (&pa->pt, AUDIO_FUNC)) {
- return NULL;
- }
+ pa_threaded_mainloop_lock(c->mainloop);
- pa->wpos = wpos;
- pa->dead -= incr;
- pa->incr += incr;
+ CHECK_DEAD_GOTO(c, p->stream, unlock_and_fail,
+ "pa_threaded_mainloop_lock failed\n");
+ if (pa_stream_get_state(p->stream) != PA_STREAM_READY) {
+ /* wait for stream to become ready */
+ l = 0;
+ goto unlock;
}
- exit:
- audio_pt_unlock (&pa->pt, AUDIO_FUNC);
- return NULL;
-}
+ l = pa_stream_writable_size(p->stream);
-static int qpa_run_in (HWVoiceIn *hw)
-{
- int live, incr, dead;
- PAVoiceIn *pa = (PAVoiceIn *) hw;
+ CHECK_SUCCESS_GOTO(c, l != (size_t) -1, unlock_and_fail,
+ "pa_stream_writable_size failed\n");
- if (audio_pt_lock (&pa->pt, AUDIO_FUNC)) {
- return 0;
+ if (l > length) {
+ l = length;
}
- live = audio_pcm_hw_get_live_in (hw);
- dead = hw->samples - live;
- incr = audio_MIN (dead, pa->incr);
- pa->incr -= incr;
- pa->dead = dead - incr;
- hw->wpos = pa->wpos;
- if (pa->dead > 0) {
- audio_pt_unlock_and_signal (&pa->pt, AUDIO_FUNC);
- }
- else {
- audio_pt_unlock (&pa->pt, AUDIO_FUNC);
- }
- return incr;
-}
+ r = pa_stream_write(p->stream, data, l, NULL, 0LL, PA_SEEK_RELATIVE);
+ CHECK_SUCCESS_GOTO(c, r >= 0, unlock_and_fail, "pa_stream_write failed\n");
-static int qpa_read (SWVoiceIn *sw, void *buf, int len)
-{
- return audio_pcm_sw_read (sw, buf, len);
+unlock:
+ pa_threaded_mainloop_unlock(c->mainloop);
+ return l;
+
+unlock_and_fail:
+ pa_threaded_mainloop_unlock(c->mainloop);
+ return 0;
}
-static pa_sample_format_t audfmt_to_pa (audfmt_e afmt, int endianness)
+static pa_sample_format_t audfmt_to_pa (AudioFormat afmt, int endianness)
{
int format;
switch (afmt) {
- case AUD_FMT_S8:
- case AUD_FMT_U8:
+ case AUDIO_FORMAT_S8:
+ case AUDIO_FORMAT_U8:
format = PA_SAMPLE_U8;
break;
- case AUD_FMT_S16:
- case AUD_FMT_U16:
+ case AUDIO_FORMAT_S16:
+ case AUDIO_FORMAT_U16:
format = endianness ? PA_SAMPLE_S16BE : PA_SAMPLE_S16LE;
break;
- case AUD_FMT_S32:
- case AUD_FMT_U32:
+ case AUDIO_FORMAT_S32:
+ case AUDIO_FORMAT_U32:
format = endianness ? PA_SAMPLE_S32BE : PA_SAMPLE_S32LE;
break;
+ case AUDIO_FORMAT_F32:
+ format = endianness ? PA_SAMPLE_FLOAT32BE : PA_SAMPLE_FLOAT32LE;
+ break;
default:
dolog ("Internal logic error: Bad audio format %d\n", afmt);
format = PA_SAMPLE_U8;
return format;
}
-static audfmt_e pa_to_audfmt (pa_sample_format_t fmt, int *endianness)
+static AudioFormat pa_to_audfmt (pa_sample_format_t fmt, int *endianness)
{
switch (fmt) {
case PA_SAMPLE_U8:
- return AUD_FMT_U8;
+ return AUDIO_FORMAT_U8;
case PA_SAMPLE_S16BE:
*endianness = 1;
- return AUD_FMT_S16;
+ return AUDIO_FORMAT_S16;
case PA_SAMPLE_S16LE:
*endianness = 0;
- return AUD_FMT_S16;
+ return AUDIO_FORMAT_S16;
case PA_SAMPLE_S32BE:
*endianness = 1;
- return AUD_FMT_S32;
+ return AUDIO_FORMAT_S32;
case PA_SAMPLE_S32LE:
*endianness = 0;
- return AUD_FMT_S32;
+ return AUDIO_FORMAT_S32;
+ case PA_SAMPLE_FLOAT32BE:
+ *endianness = 1;
+ return AUDIO_FORMAT_F32;
+ case PA_SAMPLE_FLOAT32LE:
+ *endianness = 0;
+ return AUDIO_FORMAT_F32;
default:
dolog ("Internal logic error: Bad pa_sample_format %d\n", fmt);
- return AUD_FMT_U8;
+ return AUDIO_FORMAT_U8;
}
}
static void context_state_cb (pa_context *c, void *userdata)
{
- paaudio *g = userdata;
+ PAConnection *conn = userdata;
switch (pa_context_get_state(c)) {
case PA_CONTEXT_READY:
case PA_CONTEXT_TERMINATED:
case PA_CONTEXT_FAILED:
- pa_threaded_mainloop_signal (g->mainloop, 0);
+ pa_threaded_mainloop_signal(conn->mainloop, 0);
break;
case PA_CONTEXT_UNCONNECTED:
static void stream_state_cb (pa_stream *s, void * userdata)
{
- paaudio *g = userdata;
+ PAConnection *c = userdata;
switch (pa_stream_get_state (s)) {
case PA_STREAM_READY:
case PA_STREAM_FAILED:
case PA_STREAM_TERMINATED:
- pa_threaded_mainloop_signal (g->mainloop, 0);
+ pa_threaded_mainloop_signal(c->mainloop, 0);
break;
case PA_STREAM_UNCONNECTED:
}
}
-static void stream_request_cb (pa_stream *s, size_t length, void *userdata)
-{
- paaudio *g = userdata;
-
- pa_threaded_mainloop_signal (g->mainloop, 0);
-}
-
static pa_stream *qpa_simple_new (
- paaudio *g,
+ PAConnection *c,
const char *name,
pa_stream_direction_t dir,
const char *dev,
const pa_sample_spec *ss,
- const pa_channel_map *map,
const pa_buffer_attr *attr,
int *rerror)
{
int r;
- pa_stream *stream;
+ pa_stream *stream = NULL;
+ pa_stream_flags_t flags;
+ pa_channel_map map;
+
+ pa_threaded_mainloop_lock(c->mainloop);
- pa_threaded_mainloop_lock (g->mainloop);
+ pa_channel_map_init(&map);
+ map.channels = ss->channels;
- stream = pa_stream_new (g->context, name, ss, map);
+ /*
+ * TODO: This currently expects the only frontend supporting more than 2
+ * channels is the usb-audio. We will need some means to set channel
+ * order when a new frontend gains multi-channel support.
+ */
+ switch (ss->channels) {
+ case 1:
+ map.map[0] = PA_CHANNEL_POSITION_MONO;
+ break;
+
+ case 2:
+ map.map[0] = PA_CHANNEL_POSITION_LEFT;
+ map.map[1] = PA_CHANNEL_POSITION_RIGHT;
+ break;
+
+ case 6:
+ map.map[0] = PA_CHANNEL_POSITION_FRONT_LEFT;
+ map.map[1] = PA_CHANNEL_POSITION_FRONT_RIGHT;
+ map.map[2] = PA_CHANNEL_POSITION_CENTER;
+ map.map[3] = PA_CHANNEL_POSITION_LFE;
+ map.map[4] = PA_CHANNEL_POSITION_REAR_LEFT;
+ map.map[5] = PA_CHANNEL_POSITION_REAR_RIGHT;
+ break;
+
+ case 8:
+ map.map[0] = PA_CHANNEL_POSITION_FRONT_LEFT;
+ map.map[1] = PA_CHANNEL_POSITION_FRONT_RIGHT;
+ map.map[2] = PA_CHANNEL_POSITION_CENTER;
+ map.map[3] = PA_CHANNEL_POSITION_LFE;
+ map.map[4] = PA_CHANNEL_POSITION_REAR_LEFT;
+ map.map[5] = PA_CHANNEL_POSITION_REAR_RIGHT;
+ map.map[6] = PA_CHANNEL_POSITION_SIDE_LEFT;
+ map.map[7] = PA_CHANNEL_POSITION_SIDE_RIGHT;
+ break;
+
+ default:
+ dolog("Internal error: unsupported channel count %d\n", ss->channels);
+ goto fail;
+ }
+
+ stream = pa_stream_new(c->context, name, ss, &map);
if (!stream) {
goto fail;
}
- pa_stream_set_state_callback (stream, stream_state_cb, g);
- pa_stream_set_read_callback (stream, stream_request_cb, g);
- pa_stream_set_write_callback (stream, stream_request_cb, g);
+ pa_stream_set_state_callback(stream, stream_state_cb, c);
+
+ flags = PA_STREAM_EARLY_REQUESTS;
+
+ if (dev) {
+ /* don't move the stream if the user specified a sink/source */
+ flags |= PA_STREAM_DONT_MOVE;
+ }
if (dir == PA_STREAM_PLAYBACK) {
- r = pa_stream_connect_playback (stream, dev, attr,
- PA_STREAM_INTERPOLATE_TIMING
-#ifdef PA_STREAM_ADJUST_LATENCY
- |PA_STREAM_ADJUST_LATENCY
-#endif
- |PA_STREAM_AUTO_TIMING_UPDATE, NULL, NULL);
+ r = pa_stream_connect_playback(stream, dev, attr, flags, NULL, NULL);
} else {
- r = pa_stream_connect_record (stream, dev, attr,
- PA_STREAM_INTERPOLATE_TIMING
-#ifdef PA_STREAM_ADJUST_LATENCY
- |PA_STREAM_ADJUST_LATENCY
-#endif
- |PA_STREAM_AUTO_TIMING_UPDATE);
+ r = pa_stream_connect_record(stream, dev, attr, flags);
}
if (r < 0) {
- goto fail;
+ goto fail;
}
- pa_threaded_mainloop_unlock (g->mainloop);
+ pa_threaded_mainloop_unlock(c->mainloop);
return stream;
fail:
- pa_threaded_mainloop_unlock (g->mainloop);
+ pa_threaded_mainloop_unlock(c->mainloop);
if (stream) {
pa_stream_unref (stream);
}
- *rerror = pa_context_errno (g->context);
+ *rerror = pa_context_errno(c->context);
return NULL;
}
struct audsettings obt_as = *as;
PAVoiceOut *pa = (PAVoiceOut *) hw;
paaudio *g = pa->g = drv_opaque;
+ AudiodevPaOptions *popts = &g->dev->u.pa;
+ AudiodevPaPerDirectionOptions *ppdo = popts->out;
+ PAConnection *c = g->conn;
ss.format = audfmt_to_pa (as->fmt, as->endianness);
ss.channels = as->nchannels;
ss.rate = as->freq;
- /*
- * qemu audio tick runs at 100 Hz (by default), so processing
- * data chunks worth 10 ms of sound should be a good fit.
- */
- ba.tlength = pa_usec_to_bytes (10 * 1000, &ss);
- ba.minreq = pa_usec_to_bytes (5 * 1000, &ss);
+ ba.tlength = pa_usec_to_bytes(ppdo->latency, &ss);
+ ba.minreq = pa_usec_to_bytes(MIN(ppdo->latency >> 2,
+ (g->dev->timer_period >> 2) * 3), &ss);
ba.maxlength = -1;
ba.prebuf = -1;
obt_as.fmt = pa_to_audfmt (ss.format, &obt_as.endianness);
pa->stream = qpa_simple_new (
- g,
- "qemu",
+ c,
+ ppdo->stream_name ?: g->dev->id,
PA_STREAM_PLAYBACK,
- g->conf.sink,
+ ppdo->name,
&ss,
- NULL, /* channel map */
&ba, /* buffering attributes */
&error
);
}
audio_pcm_init_info (&hw->info, &obt_as);
- hw->samples = g->conf.samples;
- pa->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift);
- pa->rpos = hw->rpos;
- if (!pa->pcm_buf) {
- dolog ("Could not allocate buffer (%d bytes)\n",
- hw->samples << hw->info.shift);
- goto fail2;
- }
-
- if (audio_pt_init (&pa->pt, qpa_thread_out, hw, AUDIO_CAP, AUDIO_FUNC)) {
- goto fail3;
- }
+ /* hw->samples counts in frames */
+ hw->samples = audio_buffer_frames(
+ qapi_AudiodevPaPerDirectionOptions_base(ppdo), &obt_as, 46440);
return 0;
- fail3:
- g_free (pa->pcm_buf);
- pa->pcm_buf = NULL;
- fail2:
- if (pa->stream) {
- pa_stream_unref (pa->stream);
- pa->stream = NULL;
- }
fail1:
return -1;
}
{
int error;
pa_sample_spec ss;
+ pa_buffer_attr ba;
struct audsettings obt_as = *as;
PAVoiceIn *pa = (PAVoiceIn *) hw;
paaudio *g = pa->g = drv_opaque;
+ AudiodevPaOptions *popts = &g->dev->u.pa;
+ AudiodevPaPerDirectionOptions *ppdo = popts->in;
+ PAConnection *c = g->conn;
ss.format = audfmt_to_pa (as->fmt, as->endianness);
ss.channels = as->nchannels;
ss.rate = as->freq;
+ ba.fragsize = pa_usec_to_bytes((g->dev->timer_period >> 1) * 3, &ss);
+ ba.maxlength = pa_usec_to_bytes(
+ MAX(ppdo->latency, g->dev->timer_period * 3), &ss);
+ ba.minreq = -1;
+ ba.prebuf = -1;
+
obt_as.fmt = pa_to_audfmt (ss.format, &obt_as.endianness);
pa->stream = qpa_simple_new (
- g,
- "qemu",
+ c,
+ ppdo->stream_name ?: g->dev->id,
PA_STREAM_RECORD,
- g->conf.source,
+ ppdo->name,
&ss,
- NULL, /* channel map */
- NULL, /* buffering attributes */
+ &ba, /* buffering attributes */
&error
);
if (!pa->stream) {
}
audio_pcm_init_info (&hw->info, &obt_as);
- hw->samples = g->conf.samples;
- pa->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift);
- pa->wpos = hw->wpos;
- if (!pa->pcm_buf) {
- dolog ("Could not allocate buffer (%d bytes)\n",
- hw->samples << hw->info.shift);
- goto fail2;
- }
-
- if (audio_pt_init (&pa->pt, qpa_thread_in, hw, AUDIO_CAP, AUDIO_FUNC)) {
- goto fail3;
- }
+ /* hw->samples counts in frames */
+ hw->samples = audio_buffer_frames(
+ qapi_AudiodevPaPerDirectionOptions_base(ppdo), &obt_as, 46440);
return 0;
- fail3:
- g_free (pa->pcm_buf);
- pa->pcm_buf = NULL;
- fail2:
- if (pa->stream) {
- pa_stream_unref (pa->stream);
- pa->stream = NULL;
- }
fail1:
return -1;
}
+static void qpa_simple_disconnect(PAConnection *c, pa_stream *stream)
+{
+ int err;
+
+ /*
+ * wait until actually connects. workaround pa bug #247
+ * https://gitlab.freedesktop.org/pulseaudio/pulseaudio/issues/247
+ */
+ while (pa_stream_get_state(stream) == PA_STREAM_CREATING) {
+ pa_threaded_mainloop_wait(c->mainloop);
+ }
+
+ err = pa_stream_disconnect(stream);
+ if (err != 0) {
+ dolog("Failed to disconnect! err=%d\n", err);
+ }
+ pa_stream_unref(stream);
+}
+
static void qpa_fini_out (HWVoiceOut *hw)
{
- void *ret;
PAVoiceOut *pa = (PAVoiceOut *) hw;
- audio_pt_lock (&pa->pt, AUDIO_FUNC);
- pa->done = 1;
- audio_pt_unlock_and_signal (&pa->pt, AUDIO_FUNC);
- audio_pt_join (&pa->pt, &ret, AUDIO_FUNC);
-
if (pa->stream) {
- pa_stream_unref (pa->stream);
+ PAConnection *c = pa->g->conn;
+
+ pa_threaded_mainloop_lock(c->mainloop);
+ qpa_simple_disconnect(c, pa->stream);
pa->stream = NULL;
+ pa_threaded_mainloop_unlock(c->mainloop);
}
-
- audio_pt_fini (&pa->pt, AUDIO_FUNC);
- g_free (pa->pcm_buf);
- pa->pcm_buf = NULL;
}
static void qpa_fini_in (HWVoiceIn *hw)
{
- void *ret;
PAVoiceIn *pa = (PAVoiceIn *) hw;
- audio_pt_lock (&pa->pt, AUDIO_FUNC);
- pa->done = 1;
- audio_pt_unlock_and_signal (&pa->pt, AUDIO_FUNC);
- audio_pt_join (&pa->pt, &ret, AUDIO_FUNC);
-
if (pa->stream) {
- pa_stream_unref (pa->stream);
+ PAConnection *c = pa->g->conn;
+
+ pa_threaded_mainloop_lock(c->mainloop);
+ if (pa->read_length) {
+ int r = pa_stream_drop(pa->stream);
+ if (r) {
+ qpa_logerr(pa_context_errno(c->context),
+ "pa_stream_drop failed\n");
+ }
+ pa->read_length = 0;
+ }
+ qpa_simple_disconnect(c, pa->stream);
pa->stream = NULL;
+ pa_threaded_mainloop_unlock(c->mainloop);
}
-
- audio_pt_fini (&pa->pt, AUDIO_FUNC);
- g_free (pa->pcm_buf);
- pa->pcm_buf = NULL;
}
-static int qpa_ctl_out (HWVoiceOut *hw, int cmd, ...)
+static void qpa_volume_out(HWVoiceOut *hw, Volume *vol)
{
PAVoiceOut *pa = (PAVoiceOut *) hw;
pa_operation *op;
pa_cvolume v;
- paaudio *g = pa->g;
+ PAConnection *c = pa->g->conn;
+ int i;
#ifdef PA_CHECK_VERSION /* macro is present in 0.9.16+ */
pa_cvolume_init (&v); /* function is present in 0.9.13+ */
#endif
- switch (cmd) {
- case VOICE_VOLUME:
- {
- SWVoiceOut *sw;
- va_list ap;
-
- va_start (ap, cmd);
- sw = va_arg (ap, SWVoiceOut *);
- va_end (ap);
-
- v.channels = 2;
- v.values[0] = ((PA_VOLUME_NORM - PA_VOLUME_MUTED) * sw->vol.l) / UINT32_MAX;
- v.values[1] = ((PA_VOLUME_NORM - PA_VOLUME_MUTED) * sw->vol.r) / UINT32_MAX;
-
- pa_threaded_mainloop_lock (g->mainloop);
-
- op = pa_context_set_sink_input_volume (g->context,
- pa_stream_get_index (pa->stream),
- &v, NULL, NULL);
- if (!op)
- qpa_logerr (pa_context_errno (g->context),
- "set_sink_input_volume() failed\n");
- else
- pa_operation_unref (op);
-
- op = pa_context_set_sink_input_mute (g->context,
- pa_stream_get_index (pa->stream),
- sw->vol.mute, NULL, NULL);
- if (!op) {
- qpa_logerr (pa_context_errno (g->context),
- "set_sink_input_mute() failed\n");
- } else {
- pa_operation_unref (op);
- }
+ v.channels = vol->channels;
+ for (i = 0; i < vol->channels; ++i) {
+ v.values[i] = ((PA_VOLUME_NORM - PA_VOLUME_MUTED) * vol->vol[i]) / 255;
+ }
- pa_threaded_mainloop_unlock (g->mainloop);
- }
+ pa_threaded_mainloop_lock(c->mainloop);
+
+ op = pa_context_set_sink_input_volume(c->context,
+ pa_stream_get_index(pa->stream),
+ &v, NULL, NULL);
+ if (!op) {
+ qpa_logerr(pa_context_errno(c->context),
+ "set_sink_input_volume() failed\n");
+ } else {
+ pa_operation_unref(op);
}
- return 0;
+
+ op = pa_context_set_sink_input_mute(c->context,
+ pa_stream_get_index(pa->stream),
+ vol->mute, NULL, NULL);
+ if (!op) {
+ qpa_logerr(pa_context_errno(c->context),
+ "set_sink_input_mute() failed\n");
+ } else {
+ pa_operation_unref(op);
+ }
+
+ pa_threaded_mainloop_unlock(c->mainloop);
}
-static int qpa_ctl_in (HWVoiceIn *hw, int cmd, ...)
+static void qpa_volume_in(HWVoiceIn *hw, Volume *vol)
{
PAVoiceIn *pa = (PAVoiceIn *) hw;
pa_operation *op;
pa_cvolume v;
- paaudio *g = pa->g;
+ PAConnection *c = pa->g->conn;
+ int i;
#ifdef PA_CHECK_VERSION
pa_cvolume_init (&v);
#endif
- switch (cmd) {
- case VOICE_VOLUME:
- {
- SWVoiceIn *sw;
- va_list ap;
-
- va_start (ap, cmd);
- sw = va_arg (ap, SWVoiceIn *);
- va_end (ap);
-
- v.channels = 2;
- v.values[0] = ((PA_VOLUME_NORM - PA_VOLUME_MUTED) * sw->vol.l) / UINT32_MAX;
- v.values[1] = ((PA_VOLUME_NORM - PA_VOLUME_MUTED) * sw->vol.r) / UINT32_MAX;
-
- pa_threaded_mainloop_lock (g->mainloop);
-
- /* FIXME: use the upcoming "set_source_output_{volume,mute}" */
- op = pa_context_set_source_volume_by_index (g->context,
- pa_stream_get_device_index (pa->stream),
- &v, NULL, NULL);
- if (!op) {
- qpa_logerr (pa_context_errno (g->context),
- "set_source_volume() failed\n");
- } else {
- pa_operation_unref(op);
- }
+ v.channels = vol->channels;
+ for (i = 0; i < vol->channels; ++i) {
+ v.values[i] = ((PA_VOLUME_NORM - PA_VOLUME_MUTED) * vol->vol[i]) / 255;
+ }
- op = pa_context_set_source_mute_by_index (g->context,
- pa_stream_get_index (pa->stream),
- sw->vol.mute, NULL, NULL);
- if (!op) {
- qpa_logerr (pa_context_errno (g->context),
- "set_source_mute() failed\n");
- } else {
- pa_operation_unref (op);
- }
+ pa_threaded_mainloop_lock(c->mainloop);
- pa_threaded_mainloop_unlock (g->mainloop);
- }
+ op = pa_context_set_source_output_volume(c->context,
+ pa_stream_get_index(pa->stream),
+ &v, NULL, NULL);
+ if (!op) {
+ qpa_logerr(pa_context_errno(c->context),
+ "set_source_output_volume() failed\n");
+ } else {
+ pa_operation_unref(op);
}
- return 0;
+
+ op = pa_context_set_source_output_mute(c->context,
+ pa_stream_get_index(pa->stream),
+ vol->mute, NULL, NULL);
+ if (!op) {
+ qpa_logerr(pa_context_errno(c->context),
+ "set_source_output_mute() failed\n");
+ } else {
+ pa_operation_unref(op);
+ }
+
+ pa_threaded_mainloop_unlock(c->mainloop);
}
-/* common */
-static PAConf glob_conf = {
- .samples = 4096,
-};
+static int qpa_validate_per_direction_opts(Audiodev *dev,
+ AudiodevPaPerDirectionOptions *pdo)
+{
+ if (!pdo->has_latency) {
+ pdo->has_latency = true;
+ pdo->latency = 46440;
+ }
+ return 1;
+}
-static void *qpa_audio_init (void)
+/* common */
+static void *qpa_conn_init(const char *server)
{
- paaudio *g = g_malloc(sizeof(paaudio));
- g->conf = glob_conf;
- g->mainloop = NULL;
- g->context = NULL;
+ PAConnection *c = g_new0(PAConnection, 1);
+ QTAILQ_INSERT_TAIL(&pa_conns, c, list);
- g->mainloop = pa_threaded_mainloop_new ();
- if (!g->mainloop) {
+ c->mainloop = pa_threaded_mainloop_new();
+ if (!c->mainloop) {
goto fail;
}
- g->context = pa_context_new (pa_threaded_mainloop_get_api (g->mainloop),
- g->conf.server);
- if (!g->context) {
+ c->context = pa_context_new(pa_threaded_mainloop_get_api(c->mainloop),
+ audio_application_name());
+ if (!c->context) {
goto fail;
}
- pa_context_set_state_callback (g->context, context_state_cb, g);
+ pa_context_set_state_callback(c->context, context_state_cb, c);
- if (pa_context_connect (g->context, g->conf.server, 0, NULL) < 0) {
- qpa_logerr (pa_context_errno (g->context),
- "pa_context_connect() failed\n");
+ if (pa_context_connect(c->context, server, 0, NULL) < 0) {
+ qpa_logerr(pa_context_errno(c->context),
+ "pa_context_connect() failed\n");
goto fail;
}
- pa_threaded_mainloop_lock (g->mainloop);
+ pa_threaded_mainloop_lock(c->mainloop);
- if (pa_threaded_mainloop_start (g->mainloop) < 0) {
+ if (pa_threaded_mainloop_start(c->mainloop) < 0) {
goto unlock_and_fail;
}
for (;;) {
pa_context_state_t state;
- state = pa_context_get_state (g->context);
+ state = pa_context_get_state(c->context);
if (state == PA_CONTEXT_READY) {
break;
}
- if (!PA_CONTEXT_IS_GOOD (state)) {
- qpa_logerr (pa_context_errno (g->context),
- "Wrong context state\n");
+ if (!PA_CONTEXT_IS_GOOD(state)) {
+ qpa_logerr(pa_context_errno(c->context),
+ "Wrong context state\n");
goto unlock_and_fail;
}
/* Wait until the context is ready */
- pa_threaded_mainloop_wait (g->mainloop);
+ pa_threaded_mainloop_wait(c->mainloop);
}
- pa_threaded_mainloop_unlock (g->mainloop);
-
- return g;
+ pa_threaded_mainloop_unlock(c->mainloop);
+ return c;
unlock_and_fail:
- pa_threaded_mainloop_unlock (g->mainloop);
+ pa_threaded_mainloop_unlock(c->mainloop);
fail:
AUD_log (AUDIO_CAP, "Failed to initialize PA context");
- qpa_audio_fini(g);
+ qpa_conn_fini(c);
return NULL;
}
-static void qpa_audio_fini (void *opaque)
+static void *qpa_audio_init(Audiodev *dev)
{
- paaudio *g = opaque;
+ paaudio *g;
+ AudiodevPaOptions *popts = &dev->u.pa;
+ const char *server;
+ PAConnection *c;
+
+ assert(dev->driver == AUDIODEV_DRIVER_PA);
+
+ if (!popts->server) {
+ char pidfile[64];
+ char *runtime;
+ struct stat st;
+
+ runtime = getenv("XDG_RUNTIME_DIR");
+ if (!runtime) {
+ return NULL;
+ }
+ snprintf(pidfile, sizeof(pidfile), "%s/pulse/pid", runtime);
+ if (stat(pidfile, &st) != 0) {
+ return NULL;
+ }
+ }
+
+ if (!qpa_validate_per_direction_opts(dev, popts->in)) {
+ return NULL;
+ }
+ if (!qpa_validate_per_direction_opts(dev, popts->out)) {
+ return NULL;
+ }
+
+ g = g_new0(paaudio, 1);
+ server = popts->server;
+
+ g->dev = dev;
+
+ QTAILQ_FOREACH(c, &pa_conns, list) {
+ if (server == NULL || c->server == NULL ?
+ server == c->server :
+ strcmp(server, c->server) == 0) {
+ g->conn = c;
+ break;
+ }
+ }
+ if (!g->conn) {
+ g->conn = qpa_conn_init(server);
+ }
+ if (!g->conn) {
+ g_free(g);
+ return NULL;
+ }
+
+ ++g->conn->refcount;
+ return g;
+}
- if (g->mainloop) {
- pa_threaded_mainloop_stop (g->mainloop);
+static void qpa_conn_fini(PAConnection *c)
+{
+ if (c->mainloop) {
+ pa_threaded_mainloop_stop(c->mainloop);
}
- if (g->context) {
- pa_context_disconnect (g->context);
- pa_context_unref (g->context);
+ if (c->context) {
+ pa_context_disconnect(c->context);
+ pa_context_unref(c->context);
}
- if (g->mainloop) {
- pa_threaded_mainloop_free (g->mainloop);
+ if (c->mainloop) {
+ pa_threaded_mainloop_free(c->mainloop);
}
- g_free(g);
+ QTAILQ_REMOVE(&pa_conns, c, list);
+ g_free(c);
}
-struct audio_option qpa_options[] = {
- {
- .name = "SAMPLES",
- .tag = AUD_OPT_INT,
- .valp = &glob_conf.samples,
- .descr = "buffer size in samples"
- },
- {
- .name = "SERVER",
- .tag = AUD_OPT_STR,
- .valp = &glob_conf.server,
- .descr = "server address"
- },
- {
- .name = "SINK",
- .tag = AUD_OPT_STR,
- .valp = &glob_conf.sink,
- .descr = "sink device name"
- },
- {
- .name = "SOURCE",
- .tag = AUD_OPT_STR,
- .valp = &glob_conf.source,
- .descr = "source device name"
- },
- { /* End of list */ }
-};
+static void qpa_audio_fini (void *opaque)
+{
+ paaudio *g = opaque;
+ PAConnection *c = g->conn;
+
+ if (--c->refcount == 0) {
+ qpa_conn_fini(c);
+ }
+
+ g_free(g);
+}
static struct audio_pcm_ops qpa_pcm_ops = {
.init_out = qpa_init_out,
.fini_out = qpa_fini_out,
- .run_out = qpa_run_out,
.write = qpa_write,
- .ctl_out = qpa_ctl_out,
+ .buffer_get_free = qpa_buffer_get_free,
+ .get_buffer_out = qpa_get_buffer_out,
+ .put_buffer_out = qpa_put_buffer_out,
+ .volume_out = qpa_volume_out,
.init_in = qpa_init_in,
.fini_in = qpa_fini_in,
- .run_in = qpa_run_in,
.read = qpa_read,
- .ctl_in = qpa_ctl_in
+ .get_buffer_in = qpa_get_buffer_in,
+ .put_buffer_in = qpa_put_buffer_in,
+ .volume_in = qpa_volume_in
};
-struct audio_driver pa_audio_driver = {
+static struct audio_driver pa_audio_driver = {
.name = "pa",
.descr = "http://www.pulseaudio.org/",
- .options = qpa_options,
.init = qpa_audio_init,
.fini = qpa_audio_fini,
.pcm_ops = &qpa_pcm_ops,
.max_voices_in = INT_MAX,
.voice_size_out = sizeof (PAVoiceOut),
.voice_size_in = sizeof (PAVoiceIn),
- .ctl_caps = VOICE_VOLUME_CAP
};
+
+static void register_audio_pa(void)
+{
+ audio_driver_register(&pa_audio_driver);
+}
+type_init(register_audio_pa);
projects / mirror_qemu.git / blobdiff