[qemu.git] / audio / paaudio.c

/* public domain */
#include "qemu-common.h"
#include "audio.h"

#include <pulse/simple.h>
#include <pulse/error.h>

#define AUDIO_CAP "pulseaudio"
#include "audio_int.h"
#include "audio_pt_int.h"

typedef struct {
    HWVoiceOut hw;
    int done;
    int live;
    int decr;
    int rpos;
    pa_simple *s;
    void *pcm_buf;
    struct audio_pt pt;
} PAVoiceOut;

typedef struct {
    HWVoiceIn hw;
    int done;
    int dead;
    int incr;
    int wpos;
    pa_simple *s;
    void *pcm_buf;
    struct audio_pt pt;
} PAVoiceIn;

static struct {
    int samples;
    int divisor;
    char *server;
    char *sink;
    char *source;
} conf = {
    1024,
    2,
    NULL,
    NULL,
    NULL
};

static void GCC_FMT_ATTR (2, 3) qpa_logerr (int err, const char *fmt, ...)
{
    va_list ap;

    va_start (ap, fmt);
    AUD_vlog (AUDIO_CAP, fmt, ap);
    va_end (ap);

    AUD_log (AUDIO_CAP, "Reason: %s\n", pa_strerror (err));
}

static void *qpa_thread_out (void *arg)
{
    PAVoiceOut *pa = arg;
    HWVoiceOut *hw = &pa->hw;
    int threshold;

    threshold = conf.divisor ? hw->samples / conf.divisor : 0;

    if (audio_pt_lock (&pa->pt, AUDIO_FUNC)) {
        return NULL;
    }

    for (;;) {
        int decr, to_mix, rpos;

        for (;;) {
            if (pa->done) {
                goto exit;
            }

            if (pa->live > threshold) {
                break;
            }

            if (audio_pt_wait (&pa->pt, AUDIO_FUNC)) {
                goto exit;
            }
        }

        decr = to_mix = pa->live;
        rpos = hw->rpos;

        if (audio_pt_unlock (&pa->pt, AUDIO_FUNC)) {
            return NULL;
        }

        while (to_mix) {
            int error;
            int chunk = audio_MIN (to_mix, hw->samples - rpos);
            st_sample_t *src = hw->mix_buf + rpos;

            hw->clip (pa->pcm_buf, src, chunk);

            if (pa_simple_write (pa->s, pa->pcm_buf,
                                 chunk << hw->info.shift, &error) < 0) {
                qpa_logerr (error, "pa_simple_write failed\n");
                return NULL;
            }

            rpos = (rpos + chunk) % hw->samples;
            to_mix -= chunk;
        }

        if (audio_pt_lock (&pa->pt, AUDIO_FUNC)) {
            return NULL;
        }

        pa->rpos = rpos;
        pa->live -= decr;
        pa->decr += decr;
    }

 exit:
    audio_pt_unlock (&pa->pt, AUDIO_FUNC);
    return NULL;
}

static int qpa_run_out (HWVoiceOut *hw)
{
    int live, decr;
    PAVoiceOut *pa = (PAVoiceOut *) hw;

    if (audio_pt_lock (&pa->pt, AUDIO_FUNC)) {
        return 0;
    }

    live = audio_pcm_hw_get_live_out (hw);
    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;
    int threshold;

    threshold = conf.divisor ? hw->samples / conf.divisor : 0;

    if (audio_pt_lock (&pa->pt, AUDIO_FUNC)) {
        return NULL;
    }

    for (;;) {
        int incr, to_grab, wpos;

        for (;;) {
            if (pa->done) {
                goto exit;
            }

            if (pa->dead > threshold) {
                break;
            }

            if (audio_pt_wait (&pa->pt, AUDIO_FUNC)) {
                goto exit;
            }
        }

        incr = to_grab = pa->dead;
        wpos = hw->wpos;

        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 (pa_simple_read (pa->s, buf,
                                chunk << hw->info.shift, &error) < 0) {
                qpa_logerr (error, "pa_simple_read failed\n");
                return NULL;
            }

            hw->conv (hw->conv_buf + wpos, buf, chunk, &nominal_volume);
            wpos = (wpos + chunk) % hw->samples;
            to_grab -= chunk;
        }

        if (audio_pt_lock (&pa->pt, AUDIO_FUNC)) {
            return NULL;
        }

        pa->wpos = wpos;
        pa->dead -= incr;
        pa->incr += incr;
    }

 exit:
    audio_pt_unlock (&pa->pt, AUDIO_FUNC);
    return NULL;
}

static int qpa_run_in (HWVoiceIn *hw)
{
    int live, incr, dead;
    PAVoiceIn *pa = (PAVoiceIn *) hw;

    if (audio_pt_lock (&pa->pt, AUDIO_FUNC)) {
        return 0;
    }

    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;
}

static int qpa_read (SWVoiceIn *sw, void *buf, int len)
{
    return audio_pcm_sw_read (sw, buf, len);
}

static pa_sample_format_t audfmt_to_pa (audfmt_e afmt, int endianness)
{
    int format;

    switch (afmt) {
    case AUD_FMT_S8:
    case AUD_FMT_U8:
        format = PA_SAMPLE_U8;
        break;
    case AUD_FMT_S16:
    case AUD_FMT_U16:
        format = endianness ? PA_SAMPLE_S16BE : PA_SAMPLE_S16LE;
        break;
    case AUD_FMT_S32:
    case AUD_FMT_U32:
        format = endianness ? PA_SAMPLE_S32BE : PA_SAMPLE_S32LE;
        break;
    default:
        dolog ("Internal logic error: Bad audio format %d\n", afmt);
        format = PA_SAMPLE_U8;
        break;
    }
    return format;
}

static audfmt_e pa_to_audfmt (pa_sample_format_t fmt, int *endianness)
{
    switch (fmt) {
    case PA_SAMPLE_U8:
        return AUD_FMT_U8;
    case PA_SAMPLE_S16BE:
        *endianness = 1;
        return AUD_FMT_S16;
    case PA_SAMPLE_S16LE:
        *endianness = 0;
        return AUD_FMT_S16;
    case PA_SAMPLE_S32BE:
        *endianness = 1;
        return AUD_FMT_S32;
    case PA_SAMPLE_S32LE:
        *endianness = 0;
        return AUD_FMT_S32;
    default:
        dolog ("Internal logic error: Bad pa_sample_format %d\n", fmt);
        return AUD_FMT_U8;
    }
}

static int qpa_init_out (HWVoiceOut *hw, audsettings_t *as)
{
    int error;
    static pa_sample_spec ss;
    audsettings_t obt_as = *as;
    PAVoiceOut *pa = (PAVoiceOut *) hw;

    ss.format = audfmt_to_pa (as->fmt, as->endianness);
    ss.channels = as->nchannels;
    ss.rate = as->freq;

    obt_as.fmt = pa_to_audfmt (ss.format, &obt_as.endianness);

    pa->s = pa_simple_new (
        conf.server,
        "qemu",
        PA_STREAM_PLAYBACK,
        conf.sink,
        "pcm.playback",
        &ss,
        NULL,                   /* channel map */
        NULL,                   /* buffering attributes */
        &error
        );
    if (!pa->s) {
        qpa_logerr (error, "pa_simple_new for playback failed\n");
        goto fail1;
    }

    audio_pcm_init_info (&hw->info, &obt_as);
    hw->samples = conf.samples;
    pa->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift);
    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;
    }

    return 0;

 fail3:
    free (pa->pcm_buf);
    pa->pcm_buf = NULL;
 fail2:
    pa_simple_free (pa->s);
    pa->s = NULL;
 fail1:
    return -1;
}

static int qpa_init_in (HWVoiceIn *hw, audsettings_t *as)
{
    int error;
    static pa_sample_spec ss;
    audsettings_t obt_as = *as;
    PAVoiceIn *pa = (PAVoiceIn *) hw;

    ss.format = audfmt_to_pa (as->fmt, as->endianness);
    ss.channels = as->nchannels;
    ss.rate = as->freq;

    obt_as.fmt = pa_to_audfmt (ss.format, &obt_as.endianness);

    pa->s = pa_simple_new (
        conf.server,
        "qemu",
        PA_STREAM_RECORD,
        conf.source,
        "pcm.capture",
        &ss,
        NULL,                   /* channel map */
        NULL,                   /* buffering attributes */
        &error
        );
    if (!pa->s) {
        qpa_logerr (error, "pa_simple_new for capture failed\n");
        goto fail1;
    }

    audio_pcm_init_info (&hw->info, &obt_as);
    hw->samples = conf.samples;
    pa->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift);
    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;
    }

    return 0;

 fail3:
    free (pa->pcm_buf);
    pa->pcm_buf = NULL;
 fail2:
    pa_simple_free (pa->s);
    pa->s = NULL;
 fail1:
    return -1;
}

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->s) {
        pa_simple_free (pa->s);
        pa->s = NULL;
    }

    audio_pt_fini (&pa->pt, AUDIO_FUNC);
    qemu_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->s) {
        pa_simple_free (pa->s);
        pa->s = NULL;
    }

    audio_pt_fini (&pa->pt, AUDIO_FUNC);
    qemu_free (pa->pcm_buf);
    pa->pcm_buf = NULL;
}

static int qpa_ctl_out (HWVoiceOut *hw, int cmd, ...)
{
    (void) hw;
    (void) cmd;
    return 0;
}

static int qpa_ctl_in (HWVoiceIn *hw, int cmd, ...)
{
    (void) hw;
    (void) cmd;
    return 0;
}

/* common */
static void *qpa_audio_init (void)
{
    return &conf;
}

static void qpa_audio_fini (void *opaque)
{
    (void) opaque;
}

struct audio_option qpa_options[] = {
    {"SAMPLES", AUD_OPT_INT, &conf.samples,
     "buffer size in samples", NULL, 0},

    {"DIVISOR", AUD_OPT_INT, &conf.divisor,
     "threshold divisor", NULL, 0},

    {"SERVER", AUD_OPT_STR, &conf.server,
     "server address", NULL, 0},

    {"SINK", AUD_OPT_STR, &conf.sink,
     "sink device name", NULL, 0},

    {"SOURCE", AUD_OPT_STR, &conf.source,
     "source device name", NULL, 0},

    {NULL, 0, NULL, NULL, NULL, 0}
};

static const struct audio_pcm_ops qpa_pcm_ops = {
    qpa_init_out,
    qpa_fini_out,
    qpa_run_out,
    qpa_write,
    qpa_ctl_out,
    qpa_init_in,
    qpa_fini_in,
    qpa_run_in,
    qpa_read,
    qpa_ctl_in
};

struct audio_driver pa_audio_driver = {
    INIT_FIELD (name           = ) "pa",
    INIT_FIELD (descr          = ) "http://www.pulseaudio.org/",
    INIT_FIELD (options        = ) qpa_options,
    INIT_FIELD (init           = ) qpa_audio_init,
    INIT_FIELD (fini           = ) qpa_audio_fini,
    INIT_FIELD (pcm_ops        = ) &qpa_pcm_ops,
    INIT_FIELD (can_be_default = ) 0,
    INIT_FIELD (max_voices_out = ) INT_MAX,
    INIT_FIELD (max_voices_in  = ) INT_MAX,
    INIT_FIELD (voice_size_out = ) sizeof (PAVoiceOut),
    INIT_FIELD (voice_size_in  = ) sizeof (PAVoiceIn)
};
Commit	Line	Data
b8e59f18	1	/* public domain */
	2	#include "qemu-common.h"
	3	#include "audio.h"
	4
	5	#include <pulse/simple.h>
	6	#include <pulse/error.h>
	7
	8	#define AUDIO_CAP "pulseaudio"
	9	#include "audio_int.h"
	10	#include "audio_pt_int.h"
	11
	12	typedef struct {
	13	HWVoiceOut hw;
	14	int done;
	15	int live;
	16	int decr;
	17	int rpos;
	18	pa_simple *s;
	19	void *pcm_buf;
	20	struct audio_pt pt;
	21	} PAVoiceOut;
	22
	23	typedef struct {
	24	HWVoiceIn hw;
	25	int done;
	26	int dead;
	27	int incr;
	28	int wpos;
	29	pa_simple *s;
	30	void *pcm_buf;
	31	struct audio_pt pt;
	32	} PAVoiceIn;
	33
	34	static struct {
	35	int samples;
	36	int divisor;
	37	char *server;
	38	char *sink;
	39	char *source;
	40	} conf = {
	41	1024,
	42	2,
	43	NULL,
	44	NULL,
	45	NULL
	46	};
	47
	48	static void GCC_FMT_ATTR (2, 3) qpa_logerr (int err, const char *fmt, ...)
	49	{
	50	va_list ap;
	51
	52	va_start (ap, fmt);
	53	AUD_vlog (AUDIO_CAP, fmt, ap);
	54	va_end (ap);
	55
	56	AUD_log (AUDIO_CAP, "Reason: %s\n", pa_strerror (err));
	57	}
	58
	59	static void qpa_thread_out (void arg)
	60	{
	61	PAVoiceOut *pa = arg;
	62	HWVoiceOut *hw = &pa->hw;
	63	int threshold;
	64
65	threshold = conf.divisor ? hw->samples / conf.divisor : 0;
66
67	if (audio_pt_lock (&pa->pt, AUDIO_FUNC)) {
68	return NULL;
69	}
70
71	for (;;) {
72	int decr, to_mix, rpos;
73
74	for (;;) {
75	if (pa->done) {
76	goto exit;
77	}
78
79	if (pa->live > threshold) {
80	break;
81	}
82
83	if (audio_pt_wait (&pa->pt, AUDIO_FUNC)) {
84	goto exit;
85	}
86	}
87
88	decr = to_mix = pa->live;
89	rpos = hw->rpos;
90
91	if (audio_pt_unlock (&pa->pt, AUDIO_FUNC)) {
92	return NULL;
93	}
94
95	while (to_mix) {
96	int error;
97	int chunk = audio_MIN (to_mix, hw->samples - rpos);
98	st_sample_t *src = hw->mix_buf + rpos;
99
100	hw->clip (pa->pcm_buf, src, chunk);
101
102	if (pa_simple_write (pa->s, pa->pcm_buf,
103	chunk << hw->info.shift, &error) < 0) {
104	qpa_logerr (error, "pa_simple_write failed\n");
105	return NULL;
106	}
107
108	rpos = (rpos + chunk) % hw->samples;
109	to_mix -= chunk;
110	}
111
112	if (audio_pt_lock (&pa->pt, AUDIO_FUNC)) {
113	return NULL;
114	}
115
116	pa->rpos = rpos;
117	pa->live -= decr;
118	pa->decr += decr;
119	}
120
121	exit:
122	audio_pt_unlock (&pa->pt, AUDIO_FUNC);
123	return NULL;
124	}
125
126	static int qpa_run_out (HWVoiceOut *hw)
127	{
128	int live, decr;
129	PAVoiceOut pa = (PAVoiceOut ) hw;
130
131	if (audio_pt_lock (&pa->pt, AUDIO_FUNC)) {
132	return 0;
133	}
134
135	live = audio_pcm_hw_get_live_out (hw);
136	decr = audio_MIN (live, pa->decr);
137	pa->decr -= decr;
138	pa->live = live - decr;
139	hw->rpos = pa->rpos;
140	if (pa->live > 0) {
141	audio_pt_unlock_and_signal (&pa->pt, AUDIO_FUNC);
142	}
143	else {
144	audio_pt_unlock (&pa->pt, AUDIO_FUNC);
145	}
146	return decr;
147	}
148
149	static int qpa_write (SWVoiceOut sw, void buf, int len)
150	{
151	return audio_pcm_sw_write (sw, buf, len);
152	}
153
154	/* capture */
155	static void qpa_thread_in (void arg)
156	{
157	PAVoiceIn *pa = arg;
158	HWVoiceIn *hw = &pa->hw;
159	int threshold;
160
161	threshold = conf.divisor ? hw->samples / conf.divisor : 0;
162
163	if (audio_pt_lock (&pa->pt, AUDIO_FUNC)) {
164	return NULL;
165	}
166
167	for (;;) {
168	int incr, to_grab, wpos;
169
170	for (;;) {
171	if (pa->done) {
172	goto exit;
173	}
174
175	if (pa->dead > threshold) {
176	break;
177	}
178
179	if (audio_pt_wait (&pa->pt, AUDIO_FUNC)) {
180	goto exit;
181	}
182	}
183
184	incr = to_grab = pa->dead;
185	wpos = hw->wpos;
186
187	if (audio_pt_unlock (&pa->pt, AUDIO_FUNC)) {
188	return NULL;
189	}
190
191	while (to_grab) {
192	int error;
193	int chunk = audio_MIN (to_grab, hw->samples - wpos);
194	void *buf = advance (pa->pcm_buf, wpos);
195
196	if (pa_simple_read (pa->s, buf,
197	chunk << hw->info.shift, &error) < 0) {
198	qpa_logerr (error, "pa_simple_read failed\n");
199	return NULL;
200	}
201
202	hw->conv (hw->conv_buf + wpos, buf, chunk, &nominal_volume);
203	wpos = (wpos + chunk) % hw->samples;
204	to_grab -= chunk;
205	}
206
207	if (audio_pt_lock (&pa->pt, AUDIO_FUNC)) {
208	return NULL;
209	}
210
211	pa->wpos = wpos;
212	pa->dead -= incr;
213	pa->incr += incr;
214	}
215
216	exit:
217	audio_pt_unlock (&pa->pt, AUDIO_FUNC);
218	return NULL;
219	}
220
221	static int qpa_run_in (HWVoiceIn *hw)
222	{
223	int live, incr, dead;
224	PAVoiceIn pa = (PAVoiceIn ) hw;
225
226	if (audio_pt_lock (&pa->pt, AUDIO_FUNC)) {
227	return 0;
228	}
229
230	live = audio_pcm_hw_get_live_in (hw);
231	dead = hw->samples - live;
232	incr = audio_MIN (dead, pa->incr);
233	pa->incr -= incr;
234	pa->dead = dead - incr;
235	hw->wpos = pa->wpos;
236	if (pa->dead > 0) {
237	audio_pt_unlock_and_signal (&pa->pt, AUDIO_FUNC);
238	}
239	else {
240	audio_pt_unlock (&pa->pt, AUDIO_FUNC);
241	}
242	return incr;
243	}
244
245	static int qpa_read (SWVoiceIn sw, void buf, int len)
246	{
247	return audio_pcm_sw_read (sw, buf, len);
248	}
249
250	static pa_sample_format_t audfmt_to_pa (audfmt_e afmt, int endianness)
251	{
252	int format;
253
254	switch (afmt) {
255	case AUD_FMT_S8:
256	case AUD_FMT_U8:
257	format = PA_SAMPLE_U8;
258	break;
259	case AUD_FMT_S16:
260	case AUD_FMT_U16:
261	format = endianness ? PA_SAMPLE_S16BE : PA_SAMPLE_S16LE;
262	break;
263	case AUD_FMT_S32:
264	case AUD_FMT_U32:
265	format = endianness ? PA_SAMPLE_S32BE : PA_SAMPLE_S32LE;
266	break;
267	default:
268	dolog ("Internal logic error: Bad audio format %d\n", afmt);
269	format = PA_SAMPLE_U8;
270	break;
271	}
272	return format;
273	}
274
275	static audfmt_e pa_to_audfmt (pa_sample_format_t fmt, int *endianness)
276	{
277	switch (fmt) {
278	case PA_SAMPLE_U8:
279	return AUD_FMT_U8;
280	case PA_SAMPLE_S16BE:
281	*endianness = 1;
282	return AUD_FMT_S16;
283	case PA_SAMPLE_S16LE:
284	*endianness = 0;
285	return AUD_FMT_S16;
286	case PA_SAMPLE_S32BE:
287	*endianness = 1;
288	return AUD_FMT_S32;
289	case PA_SAMPLE_S32LE:
290	*endianness = 0;
291	return AUD_FMT_S32;
292	default:
293	dolog ("Internal logic error: Bad pa_sample_format %d\n", fmt);
294	return AUD_FMT_U8;
295	}
296	}
297
298	static int qpa_init_out (HWVoiceOut hw, audsettings_t as)
299	{
300	int error;
301	static pa_sample_spec ss;
302	audsettings_t obt_as = *as;
303	PAVoiceOut pa = (PAVoiceOut ) hw;
304
305	ss.format = audfmt_to_pa (as->fmt, as->endianness);
306	ss.channels = as->nchannels;
307	ss.rate = as->freq;
308
309	obt_as.fmt = pa_to_audfmt (ss.format, &obt_as.endianness);
310
311	pa->s = pa_simple_new (
312	conf.server,
313	"qemu",
314	PA_STREAM_PLAYBACK,
315	conf.sink,
316	"pcm.playback",
317	&ss,
318	NULL, /* channel map */
319	NULL, /* buffering attributes */
320	&error
321	);
322	if (!pa->s) {
323	qpa_logerr (error, "pa_simple_new for playback failed\n");
324	goto fail1;
325	}
326
327	audio_pcm_init_info (&hw->info, &obt_as);
328	hw->samples = conf.samples;
329	pa->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift);
330	if (!pa->pcm_buf) {
331	dolog ("Could not allocate buffer (%d bytes)\n",
332	hw->samples << hw->info.shift);
333	goto fail2;
334	}
335
336	if (audio_pt_init (&pa->pt, qpa_thread_out, hw, AUDIO_CAP, AUDIO_FUNC)) {
337	goto fail3;
338	}
339
340	return 0;
341
342	fail3:
343	free (pa->pcm_buf);
344	pa->pcm_buf = NULL;
345	fail2:
346	pa_simple_free (pa->s);
347	pa->s = NULL;
348	fail1:
349	return -1;
350	}
351
352	static int qpa_init_in (HWVoiceIn hw, audsettings_t as)
353	{
354	int error;
355	static pa_sample_spec ss;
356	audsettings_t obt_as = *as;
357	PAVoiceIn pa = (PAVoiceIn ) hw;
358
359	ss.format = audfmt_to_pa (as->fmt, as->endianness);
360	ss.channels = as->nchannels;
361	ss.rate = as->freq;
362
363	obt_as.fmt = pa_to_audfmt (ss.format, &obt_as.endianness);
364
365	pa->s = pa_simple_new (
366	conf.server,
367	"qemu",
368	PA_STREAM_RECORD,
369	conf.source,
370	"pcm.capture",
371	&ss,
372	NULL, /* channel map */
373	NULL, /* buffering attributes */
374	&error
375	);
376	if (!pa->s) {
377	qpa_logerr (error, "pa_simple_new for capture failed\n");
378	goto fail1;
379	}
380
381	audio_pcm_init_info (&hw->info, &obt_as);
382	hw->samples = conf.samples;
383	pa->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift);
384	if (!pa->pcm_buf) {
385	dolog ("Could not allocate buffer (%d bytes)\n",
386	hw->samples << hw->info.shift);
387	goto fail2;
388	}
389
390	if (audio_pt_init (&pa->pt, qpa_thread_in, hw, AUDIO_CAP, AUDIO_FUNC)) {
391	goto fail3;
392	}
393
394	return 0;
395
396	fail3:
397	free (pa->pcm_buf);
398	pa->pcm_buf = NULL;
399	fail2:
400	pa_simple_free (pa->s);
401	pa->s = NULL;
402	fail1:
403	return -1;
404	}
405
406	static void qpa_fini_out (HWVoiceOut *hw)
407	{
408	void *ret;
409	PAVoiceOut pa = (PAVoiceOut ) hw;
410
411	audio_pt_lock (&pa->pt, AUDIO_FUNC);
412	pa->done = 1;
413	audio_pt_unlock_and_signal (&pa->pt, AUDIO_FUNC);
414	audio_pt_join (&pa->pt, &ret, AUDIO_FUNC);
415
416	if (pa->s) {
417	pa_simple_free (pa->s);
418	pa->s = NULL;
419	}
420
421	audio_pt_fini (&pa->pt, AUDIO_FUNC);
422	qemu_free (pa->pcm_buf);
423	pa->pcm_buf = NULL;
424	}
425
426	static void qpa_fini_in (HWVoiceIn *hw)
427	{
428	void *ret;
429	PAVoiceIn pa = (PAVoiceIn ) hw;
430
431	audio_pt_lock (&pa->pt, AUDIO_FUNC);
432	pa->done = 1;
433	audio_pt_unlock_and_signal (&pa->pt, AUDIO_FUNC);
434	audio_pt_join (&pa->pt, &ret, AUDIO_FUNC);
435
436	if (pa->s) {
437	pa_simple_free (pa->s);
438	pa->s = NULL;
439	}
440
441	audio_pt_fini (&pa->pt, AUDIO_FUNC);
442	qemu_free (pa->pcm_buf);
443	pa->pcm_buf = NULL;
444	}
445
446	static int qpa_ctl_out (HWVoiceOut *hw, int cmd, ...)
447	{
448	(void) hw;
449	(void) cmd;
450	return 0;
451	}
452
453	static int qpa_ctl_in (HWVoiceIn *hw, int cmd, ...)
454	{
455	(void) hw;
456	(void) cmd;
457	return 0;
458	}
459
460	/* common */
461	static void *qpa_audio_init (void)
462	{
463	return &conf;
464	}
465
466	static void qpa_audio_fini (void *opaque)
467	{
468	(void) opaque;
469	}
470
471	struct audio_option qpa_options[] = {
472	{"SAMPLES", AUD_OPT_INT, &conf.samples,
473	"buffer size in samples", NULL, 0},
474
475	{"DIVISOR", AUD_OPT_INT, &conf.divisor,
476	"threshold divisor", NULL, 0},
477
478	{"SERVER", AUD_OPT_STR, &conf.server,
479	"server address", NULL, 0},
480
481	{"SINK", AUD_OPT_STR, &conf.sink,
482	"sink device name", NULL, 0},
483
484	{"SOURCE", AUD_OPT_STR, &conf.source,
485	"source device name", NULL, 0},
486
487	{NULL, 0, NULL, NULL, NULL, 0}
488	};
489
8869defe	490	static const struct audio_pcm_ops qpa_pcm_ops = {
b8e59f18	491	qpa_init_out,
	492	qpa_fini_out,
	493	qpa_run_out,
	494	qpa_write,
	495	qpa_ctl_out,
	496	qpa_init_in,
	497	qpa_fini_in,
	498	qpa_run_in,
	499	qpa_read,
	500	qpa_ctl_in
	501	};
	502
	503	struct audio_driver pa_audio_driver = {
	504	INIT_FIELD (name = ) "pa",
	505	INIT_FIELD (descr = ) "http://www.pulseaudio.org/",
	506	INIT_FIELD (options = ) qpa_options,
	507	INIT_FIELD (init = ) qpa_audio_init,
	508	INIT_FIELD (fini = ) qpa_audio_fini,
	509	INIT_FIELD (pcm_ops = ) &qpa_pcm_ops,
	510	INIT_FIELD (can_be_default = ) 0,
	511	INIT_FIELD (max_voices_out = ) INT_MAX,
	512	INIT_FIELD (max_voices_in = ) INT_MAX,
	513	INIT_FIELD (voice_size_out = ) sizeof (PAVoiceOut),
	514	INIT_FIELD (voice_size_in = ) sizeof (PAVoiceIn)
	515	};