configure: move accelerator logic to meson
[qemu.git] / audio / paaudio.c
1 /* public domain */
2
3 #include "qemu/osdep.h"
4 #include "qemu/module.h"
5 #include "qemu-common.h"
6 #include "audio.h"
7 #include "qapi/opts-visitor.h"
8
9 #include <pulse/pulseaudio.h>
10
11 #define AUDIO_CAP "pulseaudio"
12 #include "audio_int.h"
13
14 typedef struct PAConnection {
15 char *server;
16 int refcount;
17 QTAILQ_ENTRY(PAConnection) list;
18
19 pa_threaded_mainloop *mainloop;
20 pa_context *context;
21 } PAConnection;
22
23 static QTAILQ_HEAD(PAConnectionHead, PAConnection) pa_conns =
24 QTAILQ_HEAD_INITIALIZER(pa_conns);
25
26 typedef struct {
27 Audiodev *dev;
28 PAConnection *conn;
29 } paaudio;
30
31 typedef struct {
32 HWVoiceOut hw;
33 pa_stream *stream;
34 paaudio *g;
35 } PAVoiceOut;
36
37 typedef struct {
38 HWVoiceIn hw;
39 pa_stream *stream;
40 const void *read_data;
41 size_t read_length;
42 paaudio *g;
43 } PAVoiceIn;
44
45 static void qpa_conn_fini(PAConnection *c);
46
47 static void GCC_FMT_ATTR (2, 3) qpa_logerr (int err, const char *fmt, ...)
48 {
49 va_list ap;
50
51 va_start (ap, fmt);
52 AUD_vlog (AUDIO_CAP, fmt, ap);
53 va_end (ap);
54
55 AUD_log (AUDIO_CAP, "Reason: %s\n", pa_strerror (err));
56 }
57
58 #ifndef PA_CONTEXT_IS_GOOD
59 static inline int PA_CONTEXT_IS_GOOD(pa_context_state_t x)
60 {
61 return
62 x == PA_CONTEXT_CONNECTING ||
63 x == PA_CONTEXT_AUTHORIZING ||
64 x == PA_CONTEXT_SETTING_NAME ||
65 x == PA_CONTEXT_READY;
66 }
67 #endif
68
69 #ifndef PA_STREAM_IS_GOOD
70 static inline int PA_STREAM_IS_GOOD(pa_stream_state_t x)
71 {
72 return
73 x == PA_STREAM_CREATING ||
74 x == PA_STREAM_READY;
75 }
76 #endif
77
78 #define CHECK_SUCCESS_GOTO(c, expression, label, msg) \
79 do { \
80 if (!(expression)) { \
81 qpa_logerr(pa_context_errno((c)->context), msg); \
82 goto label; \
83 } \
84 } while (0)
85
86 #define CHECK_DEAD_GOTO(c, stream, label, msg) \
87 do { \
88 if (!(c)->context || !PA_CONTEXT_IS_GOOD (pa_context_get_state((c)->context)) || \
89 !(stream) || !PA_STREAM_IS_GOOD (pa_stream_get_state ((stream)))) { \
90 if (((c)->context && pa_context_get_state ((c)->context) == PA_CONTEXT_FAILED) || \
91 ((stream) && pa_stream_get_state ((stream)) == PA_STREAM_FAILED)) { \
92 qpa_logerr(pa_context_errno((c)->context), msg); \
93 } else { \
94 qpa_logerr(PA_ERR_BADSTATE, msg); \
95 } \
96 goto label; \
97 } \
98 } while (0)
99
100 static void *qpa_get_buffer_in(HWVoiceIn *hw, size_t *size)
101 {
102 PAVoiceIn *p = (PAVoiceIn *) hw;
103 PAConnection *c = p->g->conn;
104 int r;
105
106 pa_threaded_mainloop_lock(c->mainloop);
107
108 CHECK_DEAD_GOTO(c, p->stream, unlock_and_fail,
109 "pa_threaded_mainloop_lock failed\n");
110
111 if (!p->read_length) {
112 r = pa_stream_peek(p->stream, &p->read_data, &p->read_length);
113 CHECK_SUCCESS_GOTO(c, r == 0, unlock_and_fail,
114 "pa_stream_peek failed\n");
115 }
116
117 *size = MIN(p->read_length, *size);
118
119 pa_threaded_mainloop_unlock(c->mainloop);
120 return (void *) p->read_data;
121
122 unlock_and_fail:
123 pa_threaded_mainloop_unlock(c->mainloop);
124 *size = 0;
125 return NULL;
126 }
127
128 static void qpa_put_buffer_in(HWVoiceIn *hw, void *buf, size_t size)
129 {
130 PAVoiceIn *p = (PAVoiceIn *) hw;
131 PAConnection *c = p->g->conn;
132 int r;
133
134 pa_threaded_mainloop_lock(c->mainloop);
135
136 CHECK_DEAD_GOTO(c, p->stream, unlock,
137 "pa_threaded_mainloop_lock failed\n");
138
139 assert(buf == p->read_data && size <= p->read_length);
140
141 p->read_data += size;
142 p->read_length -= size;
143
144 if (size && !p->read_length) {
145 r = pa_stream_drop(p->stream);
146 CHECK_SUCCESS_GOTO(c, r == 0, unlock, "pa_stream_drop failed\n");
147 }
148
149 unlock:
150 pa_threaded_mainloop_unlock(c->mainloop);
151 }
152
153 static size_t qpa_read(HWVoiceIn *hw, void *data, size_t length)
154 {
155 PAVoiceIn *p = (PAVoiceIn *) hw;
156 PAConnection *c = p->g->conn;
157 size_t total = 0;
158
159 pa_threaded_mainloop_lock(c->mainloop);
160
161 CHECK_DEAD_GOTO(c, p->stream, unlock_and_fail,
162 "pa_threaded_mainloop_lock failed\n");
163 if (pa_stream_get_state(p->stream) != PA_STREAM_READY) {
164 /* wait for stream to become ready */
165 goto unlock;
166 }
167
168 while (total < length) {
169 size_t l;
170 int r;
171
172 if (!p->read_length) {
173 r = pa_stream_peek(p->stream, &p->read_data, &p->read_length);
174 CHECK_SUCCESS_GOTO(c, r == 0, unlock_and_fail,
175 "pa_stream_peek failed\n");
176 if (!p->read_length) {
177 /* buffer is empty */
178 break;
179 }
180 }
181
182 l = MIN(p->read_length, length - total);
183 memcpy((char *)data + total, p->read_data, l);
184
185 p->read_data += l;
186 p->read_length -= l;
187 total += l;
188
189 if (!p->read_length) {
190 r = pa_stream_drop(p->stream);
191 CHECK_SUCCESS_GOTO(c, r == 0, unlock_and_fail,
192 "pa_stream_drop failed\n");
193 }
194 }
195
196 unlock:
197 pa_threaded_mainloop_unlock(c->mainloop);
198 return total;
199
200 unlock_and_fail:
201 pa_threaded_mainloop_unlock(c->mainloop);
202 return 0;
203 }
204
205 static void *qpa_get_buffer_out(HWVoiceOut *hw, size_t *size)
206 {
207 PAVoiceOut *p = (PAVoiceOut *) hw;
208 PAConnection *c = p->g->conn;
209 void *ret;
210 int r;
211
212 pa_threaded_mainloop_lock(c->mainloop);
213
214 CHECK_DEAD_GOTO(c, p->stream, unlock_and_fail,
215 "pa_threaded_mainloop_lock failed\n");
216
217 *size = -1;
218 r = pa_stream_begin_write(p->stream, &ret, size);
219 CHECK_SUCCESS_GOTO(c, r >= 0, unlock_and_fail,
220 "pa_stream_begin_write failed\n");
221
222 pa_threaded_mainloop_unlock(c->mainloop);
223 return ret;
224
225 unlock_and_fail:
226 pa_threaded_mainloop_unlock(c->mainloop);
227 *size = 0;
228 return NULL;
229 }
230
231 static size_t qpa_write(HWVoiceOut *hw, void *data, size_t length)
232 {
233 PAVoiceOut *p = (PAVoiceOut *) hw;
234 PAConnection *c = p->g->conn;
235 size_t l;
236 int r;
237
238 pa_threaded_mainloop_lock(c->mainloop);
239
240 CHECK_DEAD_GOTO(c, p->stream, unlock_and_fail,
241 "pa_threaded_mainloop_lock failed\n");
242
243 l = pa_stream_writable_size(p->stream);
244
245 CHECK_SUCCESS_GOTO(c, l != (size_t) -1, unlock_and_fail,
246 "pa_stream_writable_size failed\n");
247
248 if (l > length) {
249 l = length;
250 }
251
252 r = pa_stream_write(p->stream, data, l, NULL, 0LL, PA_SEEK_RELATIVE);
253 CHECK_SUCCESS_GOTO(c, r >= 0, unlock_and_fail, "pa_stream_write failed\n");
254
255 pa_threaded_mainloop_unlock(c->mainloop);
256 return l;
257
258 unlock_and_fail:
259 pa_threaded_mainloop_unlock(c->mainloop);
260 return 0;
261 }
262
263 static pa_sample_format_t audfmt_to_pa (AudioFormat afmt, int endianness)
264 {
265 int format;
266
267 switch (afmt) {
268 case AUDIO_FORMAT_S8:
269 case AUDIO_FORMAT_U8:
270 format = PA_SAMPLE_U8;
271 break;
272 case AUDIO_FORMAT_S16:
273 case AUDIO_FORMAT_U16:
274 format = endianness ? PA_SAMPLE_S16BE : PA_SAMPLE_S16LE;
275 break;
276 case AUDIO_FORMAT_S32:
277 case AUDIO_FORMAT_U32:
278 format = endianness ? PA_SAMPLE_S32BE : PA_SAMPLE_S32LE;
279 break;
280 case AUDIO_FORMAT_F32:
281 format = endianness ? PA_SAMPLE_FLOAT32BE : PA_SAMPLE_FLOAT32LE;
282 break;
283 default:
284 dolog ("Internal logic error: Bad audio format %d\n", afmt);
285 format = PA_SAMPLE_U8;
286 break;
287 }
288 return format;
289 }
290
291 static AudioFormat pa_to_audfmt (pa_sample_format_t fmt, int *endianness)
292 {
293 switch (fmt) {
294 case PA_SAMPLE_U8:
295 return AUDIO_FORMAT_U8;
296 case PA_SAMPLE_S16BE:
297 *endianness = 1;
298 return AUDIO_FORMAT_S16;
299 case PA_SAMPLE_S16LE:
300 *endianness = 0;
301 return AUDIO_FORMAT_S16;
302 case PA_SAMPLE_S32BE:
303 *endianness = 1;
304 return AUDIO_FORMAT_S32;
305 case PA_SAMPLE_S32LE:
306 *endianness = 0;
307 return AUDIO_FORMAT_S32;
308 case PA_SAMPLE_FLOAT32BE:
309 *endianness = 1;
310 return AUDIO_FORMAT_F32;
311 case PA_SAMPLE_FLOAT32LE:
312 *endianness = 0;
313 return AUDIO_FORMAT_F32;
314 default:
315 dolog ("Internal logic error: Bad pa_sample_format %d\n", fmt);
316 return AUDIO_FORMAT_U8;
317 }
318 }
319
320 static void context_state_cb (pa_context *c, void *userdata)
321 {
322 PAConnection *conn = userdata;
323
324 switch (pa_context_get_state(c)) {
325 case PA_CONTEXT_READY:
326 case PA_CONTEXT_TERMINATED:
327 case PA_CONTEXT_FAILED:
328 pa_threaded_mainloop_signal(conn->mainloop, 0);
329 break;
330
331 case PA_CONTEXT_UNCONNECTED:
332 case PA_CONTEXT_CONNECTING:
333 case PA_CONTEXT_AUTHORIZING:
334 case PA_CONTEXT_SETTING_NAME:
335 break;
336 }
337 }
338
339 static void stream_state_cb (pa_stream *s, void * userdata)
340 {
341 PAConnection *c = userdata;
342
343 switch (pa_stream_get_state (s)) {
344
345 case PA_STREAM_READY:
346 case PA_STREAM_FAILED:
347 case PA_STREAM_TERMINATED:
348 pa_threaded_mainloop_signal(c->mainloop, 0);
349 break;
350
351 case PA_STREAM_UNCONNECTED:
352 case PA_STREAM_CREATING:
353 break;
354 }
355 }
356
357 static pa_stream *qpa_simple_new (
358 PAConnection *c,
359 const char *name,
360 pa_stream_direction_t dir,
361 const char *dev,
362 const pa_sample_spec *ss,
363 const pa_buffer_attr *attr,
364 int *rerror)
365 {
366 int r;
367 pa_stream *stream = NULL;
368 pa_stream_flags_t flags;
369 pa_channel_map map;
370
371 pa_threaded_mainloop_lock(c->mainloop);
372
373 pa_channel_map_init(&map);
374 map.channels = ss->channels;
375
376 /*
377 * TODO: This currently expects the only frontend supporting more than 2
378 * channels is the usb-audio. We will need some means to set channel
379 * order when a new frontend gains multi-channel support.
380 */
381 switch (ss->channels) {
382 case 1:
383 map.map[0] = PA_CHANNEL_POSITION_MONO;
384 break;
385
386 case 2:
387 map.map[0] = PA_CHANNEL_POSITION_LEFT;
388 map.map[1] = PA_CHANNEL_POSITION_RIGHT;
389 break;
390
391 case 6:
392 map.map[0] = PA_CHANNEL_POSITION_FRONT_LEFT;
393 map.map[1] = PA_CHANNEL_POSITION_FRONT_RIGHT;
394 map.map[2] = PA_CHANNEL_POSITION_CENTER;
395 map.map[3] = PA_CHANNEL_POSITION_LFE;
396 map.map[4] = PA_CHANNEL_POSITION_REAR_LEFT;
397 map.map[5] = PA_CHANNEL_POSITION_REAR_RIGHT;
398 break;
399
400 case 8:
401 map.map[0] = PA_CHANNEL_POSITION_FRONT_LEFT;
402 map.map[1] = PA_CHANNEL_POSITION_FRONT_RIGHT;
403 map.map[2] = PA_CHANNEL_POSITION_CENTER;
404 map.map[3] = PA_CHANNEL_POSITION_LFE;
405 map.map[4] = PA_CHANNEL_POSITION_REAR_LEFT;
406 map.map[5] = PA_CHANNEL_POSITION_REAR_RIGHT;
407 map.map[6] = PA_CHANNEL_POSITION_SIDE_LEFT;
408 map.map[7] = PA_CHANNEL_POSITION_SIDE_RIGHT;
409 break;
410
411 default:
412 dolog("Internal error: unsupported channel count %d\n", ss->channels);
413 goto fail;
414 }
415
416 stream = pa_stream_new(c->context, name, ss, &map);
417 if (!stream) {
418 goto fail;
419 }
420
421 pa_stream_set_state_callback(stream, stream_state_cb, c);
422
423 flags =
424 PA_STREAM_INTERPOLATE_TIMING
425 | PA_STREAM_AUTO_TIMING_UPDATE
426 | PA_STREAM_EARLY_REQUESTS;
427
428 if (dev) {
429 /* don't move the stream if the user specified a sink/source */
430 flags |= PA_STREAM_DONT_MOVE;
431 }
432
433 if (dir == PA_STREAM_PLAYBACK) {
434 r = pa_stream_connect_playback(stream, dev, attr, flags, NULL, NULL);
435 } else {
436 r = pa_stream_connect_record(stream, dev, attr, flags);
437 }
438
439 if (r < 0) {
440 goto fail;
441 }
442
443 pa_threaded_mainloop_unlock(c->mainloop);
444
445 return stream;
446
447 fail:
448 pa_threaded_mainloop_unlock(c->mainloop);
449
450 if (stream) {
451 pa_stream_unref (stream);
452 }
453
454 *rerror = pa_context_errno(c->context);
455
456 return NULL;
457 }
458
459 static int qpa_init_out(HWVoiceOut *hw, struct audsettings *as,
460 void *drv_opaque)
461 {
462 int error;
463 pa_sample_spec ss;
464 pa_buffer_attr ba;
465 struct audsettings obt_as = *as;
466 PAVoiceOut *pa = (PAVoiceOut *) hw;
467 paaudio *g = pa->g = drv_opaque;
468 AudiodevPaOptions *popts = &g->dev->u.pa;
469 AudiodevPaPerDirectionOptions *ppdo = popts->out;
470 PAConnection *c = g->conn;
471
472 ss.format = audfmt_to_pa (as->fmt, as->endianness);
473 ss.channels = as->nchannels;
474 ss.rate = as->freq;
475
476 ba.tlength = pa_usec_to_bytes(ppdo->latency, &ss);
477 ba.minreq = -1;
478 ba.maxlength = -1;
479 ba.prebuf = -1;
480
481 obt_as.fmt = pa_to_audfmt (ss.format, &obt_as.endianness);
482
483 pa->stream = qpa_simple_new (
484 c,
485 ppdo->has_stream_name ? ppdo->stream_name : g->dev->id,
486 PA_STREAM_PLAYBACK,
487 ppdo->has_name ? ppdo->name : NULL,
488 &ss,
489 &ba, /* buffering attributes */
490 &error
491 );
492 if (!pa->stream) {
493 qpa_logerr (error, "pa_simple_new for playback failed\n");
494 goto fail1;
495 }
496
497 audio_pcm_init_info (&hw->info, &obt_as);
498 hw->samples = audio_buffer_samples(
499 qapi_AudiodevPaPerDirectionOptions_base(ppdo),
500 &obt_as, ppdo->buffer_length);
501
502 return 0;
503
504 fail1:
505 return -1;
506 }
507
508 static int qpa_init_in(HWVoiceIn *hw, struct audsettings *as, void *drv_opaque)
509 {
510 int error;
511 pa_sample_spec ss;
512 pa_buffer_attr ba;
513 struct audsettings obt_as = *as;
514 PAVoiceIn *pa = (PAVoiceIn *) hw;
515 paaudio *g = pa->g = drv_opaque;
516 AudiodevPaOptions *popts = &g->dev->u.pa;
517 AudiodevPaPerDirectionOptions *ppdo = popts->in;
518 PAConnection *c = g->conn;
519
520 ss.format = audfmt_to_pa (as->fmt, as->endianness);
521 ss.channels = as->nchannels;
522 ss.rate = as->freq;
523
524 ba.fragsize = pa_usec_to_bytes(ppdo->latency, &ss);
525 ba.maxlength = pa_usec_to_bytes(ppdo->latency * 2, &ss);
526 ba.minreq = -1;
527 ba.prebuf = -1;
528
529 obt_as.fmt = pa_to_audfmt (ss.format, &obt_as.endianness);
530
531 pa->stream = qpa_simple_new (
532 c,
533 ppdo->has_stream_name ? ppdo->stream_name : g->dev->id,
534 PA_STREAM_RECORD,
535 ppdo->has_name ? ppdo->name : NULL,
536 &ss,
537 &ba, /* buffering attributes */
538 &error
539 );
540 if (!pa->stream) {
541 qpa_logerr (error, "pa_simple_new for capture failed\n");
542 goto fail1;
543 }
544
545 audio_pcm_init_info (&hw->info, &obt_as);
546 hw->samples = audio_buffer_samples(
547 qapi_AudiodevPaPerDirectionOptions_base(ppdo),
548 &obt_as, ppdo->buffer_length);
549
550 return 0;
551
552 fail1:
553 return -1;
554 }
555
556 static void qpa_simple_disconnect(PAConnection *c, pa_stream *stream)
557 {
558 int err;
559
560 /*
561 * wait until actually connects. workaround pa bug #247
562 * https://gitlab.freedesktop.org/pulseaudio/pulseaudio/issues/247
563 */
564 while (pa_stream_get_state(stream) == PA_STREAM_CREATING) {
565 pa_threaded_mainloop_wait(c->mainloop);
566 }
567
568 err = pa_stream_disconnect(stream);
569 if (err != 0) {
570 dolog("Failed to disconnect! err=%d\n", err);
571 }
572 pa_stream_unref(stream);
573 }
574
575 static void qpa_fini_out (HWVoiceOut *hw)
576 {
577 PAVoiceOut *pa = (PAVoiceOut *) hw;
578
579 if (pa->stream) {
580 PAConnection *c = pa->g->conn;
581
582 pa_threaded_mainloop_lock(c->mainloop);
583 qpa_simple_disconnect(c, pa->stream);
584 pa->stream = NULL;
585 pa_threaded_mainloop_unlock(c->mainloop);
586 }
587 }
588
589 static void qpa_fini_in (HWVoiceIn *hw)
590 {
591 PAVoiceIn *pa = (PAVoiceIn *) hw;
592
593 if (pa->stream) {
594 PAConnection *c = pa->g->conn;
595
596 pa_threaded_mainloop_lock(c->mainloop);
597 if (pa->read_length) {
598 int r = pa_stream_drop(pa->stream);
599 if (r) {
600 qpa_logerr(pa_context_errno(c->context),
601 "pa_stream_drop failed\n");
602 }
603 pa->read_length = 0;
604 }
605 qpa_simple_disconnect(c, pa->stream);
606 pa->stream = NULL;
607 pa_threaded_mainloop_unlock(c->mainloop);
608 }
609 }
610
611 static void qpa_volume_out(HWVoiceOut *hw, Volume *vol)
612 {
613 PAVoiceOut *pa = (PAVoiceOut *) hw;
614 pa_operation *op;
615 pa_cvolume v;
616 PAConnection *c = pa->g->conn;
617 int i;
618
619 #ifdef PA_CHECK_VERSION /* macro is present in 0.9.16+ */
620 pa_cvolume_init (&v); /* function is present in 0.9.13+ */
621 #endif
622
623 v.channels = vol->channels;
624 for (i = 0; i < vol->channels; ++i) {
625 v.values[i] = ((PA_VOLUME_NORM - PA_VOLUME_MUTED) * vol->vol[i]) / 255;
626 }
627
628 pa_threaded_mainloop_lock(c->mainloop);
629
630 op = pa_context_set_sink_input_volume(c->context,
631 pa_stream_get_index(pa->stream),
632 &v, NULL, NULL);
633 if (!op) {
634 qpa_logerr(pa_context_errno(c->context),
635 "set_sink_input_volume() failed\n");
636 } else {
637 pa_operation_unref(op);
638 }
639
640 op = pa_context_set_sink_input_mute(c->context,
641 pa_stream_get_index(pa->stream),
642 vol->mute, NULL, NULL);
643 if (!op) {
644 qpa_logerr(pa_context_errno(c->context),
645 "set_sink_input_mute() failed\n");
646 } else {
647 pa_operation_unref(op);
648 }
649
650 pa_threaded_mainloop_unlock(c->mainloop);
651 }
652
653 static void qpa_volume_in(HWVoiceIn *hw, Volume *vol)
654 {
655 PAVoiceIn *pa = (PAVoiceIn *) hw;
656 pa_operation *op;
657 pa_cvolume v;
658 PAConnection *c = pa->g->conn;
659 int i;
660
661 #ifdef PA_CHECK_VERSION
662 pa_cvolume_init (&v);
663 #endif
664
665 v.channels = vol->channels;
666 for (i = 0; i < vol->channels; ++i) {
667 v.values[i] = ((PA_VOLUME_NORM - PA_VOLUME_MUTED) * vol->vol[i]) / 255;
668 }
669
670 pa_threaded_mainloop_lock(c->mainloop);
671
672 op = pa_context_set_source_output_volume(c->context,
673 pa_stream_get_index(pa->stream),
674 &v, NULL, NULL);
675 if (!op) {
676 qpa_logerr(pa_context_errno(c->context),
677 "set_source_output_volume() failed\n");
678 } else {
679 pa_operation_unref(op);
680 }
681
682 op = pa_context_set_source_output_mute(c->context,
683 pa_stream_get_index(pa->stream),
684 vol->mute, NULL, NULL);
685 if (!op) {
686 qpa_logerr(pa_context_errno(c->context),
687 "set_source_output_mute() failed\n");
688 } else {
689 pa_operation_unref(op);
690 }
691
692 pa_threaded_mainloop_unlock(c->mainloop);
693 }
694
695 static int qpa_validate_per_direction_opts(Audiodev *dev,
696 AudiodevPaPerDirectionOptions *pdo)
697 {
698 if (!pdo->has_buffer_length) {
699 pdo->has_buffer_length = true;
700 pdo->buffer_length = 46440;
701 }
702 if (!pdo->has_latency) {
703 pdo->has_latency = true;
704 pdo->latency = 15000;
705 }
706 return 1;
707 }
708
709 /* common */
710 static void *qpa_conn_init(const char *server)
711 {
712 const char *vm_name;
713 PAConnection *c = g_malloc0(sizeof(PAConnection));
714 QTAILQ_INSERT_TAIL(&pa_conns, c, list);
715
716 c->mainloop = pa_threaded_mainloop_new();
717 if (!c->mainloop) {
718 goto fail;
719 }
720
721 vm_name = qemu_get_vm_name();
722 c->context = pa_context_new(pa_threaded_mainloop_get_api(c->mainloop),
723 vm_name ? vm_name : "qemu");
724 if (!c->context) {
725 goto fail;
726 }
727
728 pa_context_set_state_callback(c->context, context_state_cb, c);
729
730 if (pa_context_connect(c->context, server, 0, NULL) < 0) {
731 qpa_logerr(pa_context_errno(c->context),
732 "pa_context_connect() failed\n");
733 goto fail;
734 }
735
736 pa_threaded_mainloop_lock(c->mainloop);
737
738 if (pa_threaded_mainloop_start(c->mainloop) < 0) {
739 goto unlock_and_fail;
740 }
741
742 for (;;) {
743 pa_context_state_t state;
744
745 state = pa_context_get_state(c->context);
746
747 if (state == PA_CONTEXT_READY) {
748 break;
749 }
750
751 if (!PA_CONTEXT_IS_GOOD(state)) {
752 qpa_logerr(pa_context_errno(c->context),
753 "Wrong context state\n");
754 goto unlock_and_fail;
755 }
756
757 /* Wait until the context is ready */
758 pa_threaded_mainloop_wait(c->mainloop);
759 }
760
761 pa_threaded_mainloop_unlock(c->mainloop);
762 return c;
763
764 unlock_and_fail:
765 pa_threaded_mainloop_unlock(c->mainloop);
766 fail:
767 AUD_log (AUDIO_CAP, "Failed to initialize PA context");
768 qpa_conn_fini(c);
769 return NULL;
770 }
771
772 static void *qpa_audio_init(Audiodev *dev)
773 {
774 paaudio *g;
775 AudiodevPaOptions *popts = &dev->u.pa;
776 const char *server;
777 PAConnection *c;
778
779 assert(dev->driver == AUDIODEV_DRIVER_PA);
780
781 if (!popts->has_server) {
782 char pidfile[64];
783 char *runtime;
784 struct stat st;
785
786 runtime = getenv("XDG_RUNTIME_DIR");
787 if (!runtime) {
788 return NULL;
789 }
790 snprintf(pidfile, sizeof(pidfile), "%s/pulse/pid", runtime);
791 if (stat(pidfile, &st) != 0) {
792 return NULL;
793 }
794 }
795
796 if (!qpa_validate_per_direction_opts(dev, popts->in)) {
797 return NULL;
798 }
799 if (!qpa_validate_per_direction_opts(dev, popts->out)) {
800 return NULL;
801 }
802
803 g = g_malloc0(sizeof(paaudio));
804 server = popts->has_server ? popts->server : NULL;
805
806 g->dev = dev;
807
808 QTAILQ_FOREACH(c, &pa_conns, list) {
809 if (server == NULL || c->server == NULL ?
810 server == c->server :
811 strcmp(server, c->server) == 0) {
812 g->conn = c;
813 break;
814 }
815 }
816 if (!g->conn) {
817 g->conn = qpa_conn_init(server);
818 }
819 if (!g->conn) {
820 g_free(g);
821 return NULL;
822 }
823
824 ++g->conn->refcount;
825 return g;
826 }
827
828 static void qpa_conn_fini(PAConnection *c)
829 {
830 if (c->mainloop) {
831 pa_threaded_mainloop_stop(c->mainloop);
832 }
833
834 if (c->context) {
835 pa_context_disconnect(c->context);
836 pa_context_unref(c->context);
837 }
838
839 if (c->mainloop) {
840 pa_threaded_mainloop_free(c->mainloop);
841 }
842
843 QTAILQ_REMOVE(&pa_conns, c, list);
844 g_free(c);
845 }
846
847 static void qpa_audio_fini (void *opaque)
848 {
849 paaudio *g = opaque;
850 PAConnection *c = g->conn;
851
852 if (--c->refcount == 0) {
853 qpa_conn_fini(c);
854 }
855
856 g_free(g);
857 }
858
859 static struct audio_pcm_ops qpa_pcm_ops = {
860 .init_out = qpa_init_out,
861 .fini_out = qpa_fini_out,
862 .write = qpa_write,
863 .get_buffer_out = qpa_get_buffer_out,
864 .put_buffer_out = qpa_write, /* pa handles it */
865 .volume_out = qpa_volume_out,
866
867 .init_in = qpa_init_in,
868 .fini_in = qpa_fini_in,
869 .read = qpa_read,
870 .get_buffer_in = qpa_get_buffer_in,
871 .put_buffer_in = qpa_put_buffer_in,
872 .volume_in = qpa_volume_in
873 };
874
875 static struct audio_driver pa_audio_driver = {
876 .name = "pa",
877 .descr = "http://www.pulseaudio.org/",
878 .init = qpa_audio_init,
879 .fini = qpa_audio_fini,
880 .pcm_ops = &qpa_pcm_ops,
881 .can_be_default = 1,
882 .max_voices_out = INT_MAX,
883 .max_voices_in = INT_MAX,
884 .voice_size_out = sizeof (PAVoiceOut),
885 .voice_size_in = sizeof (PAVoiceIn),
886 };
887
888 static void register_audio_pa(void)
889 {
890 audio_driver_register(&pa_audio_driver);
891 }
892 type_init(register_audio_pa);