Merge remote-tracking branch 'remotes/jasowang/tags/net-pull-request' into staging
[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 size_t l;
211 int r;
212
213 pa_threaded_mainloop_lock(c->mainloop);
214
215 CHECK_DEAD_GOTO(c, p->stream, unlock_and_fail,
216 "pa_threaded_mainloop_lock failed\n");
217 if (pa_stream_get_state(p->stream) != PA_STREAM_READY) {
218 /* wait for stream to become ready */
219 l = 0;
220 ret = NULL;
221 goto unlock;
222 }
223
224 l = pa_stream_writable_size(p->stream);
225 CHECK_SUCCESS_GOTO(c, l != (size_t) -1, unlock_and_fail,
226 "pa_stream_writable_size failed\n");
227
228 *size = -1;
229 r = pa_stream_begin_write(p->stream, &ret, size);
230 CHECK_SUCCESS_GOTO(c, r >= 0, unlock_and_fail,
231 "pa_stream_begin_write failed\n");
232
233 unlock:
234 pa_threaded_mainloop_unlock(c->mainloop);
235 if (*size > l) {
236 *size = l;
237 }
238 return ret;
239
240 unlock_and_fail:
241 pa_threaded_mainloop_unlock(c->mainloop);
242 *size = 0;
243 return NULL;
244 }
245
246 static size_t qpa_put_buffer_out(HWVoiceOut *hw, void *data, size_t length)
247 {
248 PAVoiceOut *p = (PAVoiceOut *)hw;
249 PAConnection *c = p->g->conn;
250 int r;
251
252 pa_threaded_mainloop_lock(c->mainloop);
253
254 CHECK_DEAD_GOTO(c, p->stream, unlock_and_fail,
255 "pa_threaded_mainloop_lock failed\n");
256
257 r = pa_stream_write(p->stream, data, length, NULL, 0LL, PA_SEEK_RELATIVE);
258 CHECK_SUCCESS_GOTO(c, r >= 0, unlock_and_fail, "pa_stream_write failed\n");
259
260 pa_threaded_mainloop_unlock(c->mainloop);
261 return length;
262
263 unlock_and_fail:
264 pa_threaded_mainloop_unlock(c->mainloop);
265 return 0;
266 }
267
268 static size_t qpa_write(HWVoiceOut *hw, void *data, size_t length)
269 {
270 PAVoiceOut *p = (PAVoiceOut *) hw;
271 PAConnection *c = p->g->conn;
272 size_t l;
273 int r;
274
275 pa_threaded_mainloop_lock(c->mainloop);
276
277 CHECK_DEAD_GOTO(c, p->stream, unlock_and_fail,
278 "pa_threaded_mainloop_lock failed\n");
279 if (pa_stream_get_state(p->stream) != PA_STREAM_READY) {
280 /* wait for stream to become ready */
281 l = 0;
282 goto unlock;
283 }
284
285 l = pa_stream_writable_size(p->stream);
286
287 CHECK_SUCCESS_GOTO(c, l != (size_t) -1, unlock_and_fail,
288 "pa_stream_writable_size failed\n");
289
290 if (l > length) {
291 l = length;
292 }
293
294 r = pa_stream_write(p->stream, data, l, NULL, 0LL, PA_SEEK_RELATIVE);
295 CHECK_SUCCESS_GOTO(c, r >= 0, unlock_and_fail, "pa_stream_write failed\n");
296
297 unlock:
298 pa_threaded_mainloop_unlock(c->mainloop);
299 return l;
300
301 unlock_and_fail:
302 pa_threaded_mainloop_unlock(c->mainloop);
303 return 0;
304 }
305
306 static pa_sample_format_t audfmt_to_pa (AudioFormat afmt, int endianness)
307 {
308 int format;
309
310 switch (afmt) {
311 case AUDIO_FORMAT_S8:
312 case AUDIO_FORMAT_U8:
313 format = PA_SAMPLE_U8;
314 break;
315 case AUDIO_FORMAT_S16:
316 case AUDIO_FORMAT_U16:
317 format = endianness ? PA_SAMPLE_S16BE : PA_SAMPLE_S16LE;
318 break;
319 case AUDIO_FORMAT_S32:
320 case AUDIO_FORMAT_U32:
321 format = endianness ? PA_SAMPLE_S32BE : PA_SAMPLE_S32LE;
322 break;
323 case AUDIO_FORMAT_F32:
324 format = endianness ? PA_SAMPLE_FLOAT32BE : PA_SAMPLE_FLOAT32LE;
325 break;
326 default:
327 dolog ("Internal logic error: Bad audio format %d\n", afmt);
328 format = PA_SAMPLE_U8;
329 break;
330 }
331 return format;
332 }
333
334 static AudioFormat pa_to_audfmt (pa_sample_format_t fmt, int *endianness)
335 {
336 switch (fmt) {
337 case PA_SAMPLE_U8:
338 return AUDIO_FORMAT_U8;
339 case PA_SAMPLE_S16BE:
340 *endianness = 1;
341 return AUDIO_FORMAT_S16;
342 case PA_SAMPLE_S16LE:
343 *endianness = 0;
344 return AUDIO_FORMAT_S16;
345 case PA_SAMPLE_S32BE:
346 *endianness = 1;
347 return AUDIO_FORMAT_S32;
348 case PA_SAMPLE_S32LE:
349 *endianness = 0;
350 return AUDIO_FORMAT_S32;
351 case PA_SAMPLE_FLOAT32BE:
352 *endianness = 1;
353 return AUDIO_FORMAT_F32;
354 case PA_SAMPLE_FLOAT32LE:
355 *endianness = 0;
356 return AUDIO_FORMAT_F32;
357 default:
358 dolog ("Internal logic error: Bad pa_sample_format %d\n", fmt);
359 return AUDIO_FORMAT_U8;
360 }
361 }
362
363 static void context_state_cb (pa_context *c, void *userdata)
364 {
365 PAConnection *conn = userdata;
366
367 switch (pa_context_get_state(c)) {
368 case PA_CONTEXT_READY:
369 case PA_CONTEXT_TERMINATED:
370 case PA_CONTEXT_FAILED:
371 pa_threaded_mainloop_signal(conn->mainloop, 0);
372 break;
373
374 case PA_CONTEXT_UNCONNECTED:
375 case PA_CONTEXT_CONNECTING:
376 case PA_CONTEXT_AUTHORIZING:
377 case PA_CONTEXT_SETTING_NAME:
378 break;
379 }
380 }
381
382 static void stream_state_cb (pa_stream *s, void * userdata)
383 {
384 PAConnection *c = userdata;
385
386 switch (pa_stream_get_state (s)) {
387
388 case PA_STREAM_READY:
389 case PA_STREAM_FAILED:
390 case PA_STREAM_TERMINATED:
391 pa_threaded_mainloop_signal(c->mainloop, 0);
392 break;
393
394 case PA_STREAM_UNCONNECTED:
395 case PA_STREAM_CREATING:
396 break;
397 }
398 }
399
400 static pa_stream *qpa_simple_new (
401 PAConnection *c,
402 const char *name,
403 pa_stream_direction_t dir,
404 const char *dev,
405 const pa_sample_spec *ss,
406 const pa_buffer_attr *attr,
407 int *rerror)
408 {
409 int r;
410 pa_stream *stream = NULL;
411 pa_stream_flags_t flags;
412 pa_channel_map map;
413
414 pa_threaded_mainloop_lock(c->mainloop);
415
416 pa_channel_map_init(&map);
417 map.channels = ss->channels;
418
419 /*
420 * TODO: This currently expects the only frontend supporting more than 2
421 * channels is the usb-audio. We will need some means to set channel
422 * order when a new frontend gains multi-channel support.
423 */
424 switch (ss->channels) {
425 case 1:
426 map.map[0] = PA_CHANNEL_POSITION_MONO;
427 break;
428
429 case 2:
430 map.map[0] = PA_CHANNEL_POSITION_LEFT;
431 map.map[1] = PA_CHANNEL_POSITION_RIGHT;
432 break;
433
434 case 6:
435 map.map[0] = PA_CHANNEL_POSITION_FRONT_LEFT;
436 map.map[1] = PA_CHANNEL_POSITION_FRONT_RIGHT;
437 map.map[2] = PA_CHANNEL_POSITION_CENTER;
438 map.map[3] = PA_CHANNEL_POSITION_LFE;
439 map.map[4] = PA_CHANNEL_POSITION_REAR_LEFT;
440 map.map[5] = PA_CHANNEL_POSITION_REAR_RIGHT;
441 break;
442
443 case 8:
444 map.map[0] = PA_CHANNEL_POSITION_FRONT_LEFT;
445 map.map[1] = PA_CHANNEL_POSITION_FRONT_RIGHT;
446 map.map[2] = PA_CHANNEL_POSITION_CENTER;
447 map.map[3] = PA_CHANNEL_POSITION_LFE;
448 map.map[4] = PA_CHANNEL_POSITION_REAR_LEFT;
449 map.map[5] = PA_CHANNEL_POSITION_REAR_RIGHT;
450 map.map[6] = PA_CHANNEL_POSITION_SIDE_LEFT;
451 map.map[7] = PA_CHANNEL_POSITION_SIDE_RIGHT;
452 break;
453
454 default:
455 dolog("Internal error: unsupported channel count %d\n", ss->channels);
456 goto fail;
457 }
458
459 stream = pa_stream_new(c->context, name, ss, &map);
460 if (!stream) {
461 goto fail;
462 }
463
464 pa_stream_set_state_callback(stream, stream_state_cb, c);
465
466 flags =
467 PA_STREAM_INTERPOLATE_TIMING
468 | PA_STREAM_AUTO_TIMING_UPDATE
469 | PA_STREAM_EARLY_REQUESTS;
470
471 if (dev) {
472 /* don't move the stream if the user specified a sink/source */
473 flags |= PA_STREAM_DONT_MOVE;
474 }
475
476 if (dir == PA_STREAM_PLAYBACK) {
477 r = pa_stream_connect_playback(stream, dev, attr, flags, NULL, NULL);
478 } else {
479 r = pa_stream_connect_record(stream, dev, attr, flags);
480 }
481
482 if (r < 0) {
483 goto fail;
484 }
485
486 pa_threaded_mainloop_unlock(c->mainloop);
487
488 return stream;
489
490 fail:
491 pa_threaded_mainloop_unlock(c->mainloop);
492
493 if (stream) {
494 pa_stream_unref (stream);
495 }
496
497 *rerror = pa_context_errno(c->context);
498
499 return NULL;
500 }
501
502 static int qpa_init_out(HWVoiceOut *hw, struct audsettings *as,
503 void *drv_opaque)
504 {
505 int error;
506 pa_sample_spec ss;
507 pa_buffer_attr ba;
508 struct audsettings obt_as = *as;
509 PAVoiceOut *pa = (PAVoiceOut *) hw;
510 paaudio *g = pa->g = drv_opaque;
511 AudiodevPaOptions *popts = &g->dev->u.pa;
512 AudiodevPaPerDirectionOptions *ppdo = popts->out;
513 PAConnection *c = g->conn;
514
515 ss.format = audfmt_to_pa (as->fmt, as->endianness);
516 ss.channels = as->nchannels;
517 ss.rate = as->freq;
518
519 ba.tlength = pa_usec_to_bytes(ppdo->latency, &ss);
520 ba.minreq = pa_usec_to_bytes(MIN(ppdo->latency >> 2,
521 (g->dev->timer_period >> 2) * 3), &ss);
522 ba.maxlength = -1;
523 ba.prebuf = -1;
524
525 obt_as.fmt = pa_to_audfmt (ss.format, &obt_as.endianness);
526
527 pa->stream = qpa_simple_new (
528 c,
529 ppdo->has_stream_name ? ppdo->stream_name : g->dev->id,
530 PA_STREAM_PLAYBACK,
531 ppdo->has_name ? ppdo->name : NULL,
532 &ss,
533 &ba, /* buffering attributes */
534 &error
535 );
536 if (!pa->stream) {
537 qpa_logerr (error, "pa_simple_new for playback failed\n");
538 goto fail1;
539 }
540
541 audio_pcm_init_info (&hw->info, &obt_as);
542 /*
543 * This is wrong. hw->samples counts in frames. hw->samples will be
544 * number of channels times larger than expected.
545 */
546 hw->samples = audio_buffer_samples(
547 qapi_AudiodevPaPerDirectionOptions_base(ppdo), &obt_as, 46440);
548
549 return 0;
550
551 fail1:
552 return -1;
553 }
554
555 static int qpa_init_in(HWVoiceIn *hw, struct audsettings *as, void *drv_opaque)
556 {
557 int error;
558 pa_sample_spec ss;
559 pa_buffer_attr ba;
560 struct audsettings obt_as = *as;
561 PAVoiceIn *pa = (PAVoiceIn *) hw;
562 paaudio *g = pa->g = drv_opaque;
563 AudiodevPaOptions *popts = &g->dev->u.pa;
564 AudiodevPaPerDirectionOptions *ppdo = popts->in;
565 PAConnection *c = g->conn;
566
567 ss.format = audfmt_to_pa (as->fmt, as->endianness);
568 ss.channels = as->nchannels;
569 ss.rate = as->freq;
570
571 ba.fragsize = pa_usec_to_bytes((g->dev->timer_period >> 1) * 3, &ss);
572 ba.maxlength = pa_usec_to_bytes(
573 MAX(ppdo->latency, g->dev->timer_period * 3), &ss);
574 ba.minreq = -1;
575 ba.prebuf = -1;
576
577 obt_as.fmt = pa_to_audfmt (ss.format, &obt_as.endianness);
578
579 pa->stream = qpa_simple_new (
580 c,
581 ppdo->has_stream_name ? ppdo->stream_name : g->dev->id,
582 PA_STREAM_RECORD,
583 ppdo->has_name ? ppdo->name : NULL,
584 &ss,
585 &ba, /* buffering attributes */
586 &error
587 );
588 if (!pa->stream) {
589 qpa_logerr (error, "pa_simple_new for capture failed\n");
590 goto fail1;
591 }
592
593 audio_pcm_init_info (&hw->info, &obt_as);
594 /*
595 * This is wrong. hw->samples counts in frames. hw->samples will be
596 * number of channels times larger than expected.
597 */
598 hw->samples = audio_buffer_samples(
599 qapi_AudiodevPaPerDirectionOptions_base(ppdo), &obt_as, 46440);
600
601 return 0;
602
603 fail1:
604 return -1;
605 }
606
607 static void qpa_simple_disconnect(PAConnection *c, pa_stream *stream)
608 {
609 int err;
610
611 /*
612 * wait until actually connects. workaround pa bug #247
613 * https://gitlab.freedesktop.org/pulseaudio/pulseaudio/issues/247
614 */
615 while (pa_stream_get_state(stream) == PA_STREAM_CREATING) {
616 pa_threaded_mainloop_wait(c->mainloop);
617 }
618
619 err = pa_stream_disconnect(stream);
620 if (err != 0) {
621 dolog("Failed to disconnect! err=%d\n", err);
622 }
623 pa_stream_unref(stream);
624 }
625
626 static void qpa_fini_out (HWVoiceOut *hw)
627 {
628 PAVoiceOut *pa = (PAVoiceOut *) hw;
629
630 if (pa->stream) {
631 PAConnection *c = pa->g->conn;
632
633 pa_threaded_mainloop_lock(c->mainloop);
634 qpa_simple_disconnect(c, pa->stream);
635 pa->stream = NULL;
636 pa_threaded_mainloop_unlock(c->mainloop);
637 }
638 }
639
640 static void qpa_fini_in (HWVoiceIn *hw)
641 {
642 PAVoiceIn *pa = (PAVoiceIn *) hw;
643
644 if (pa->stream) {
645 PAConnection *c = pa->g->conn;
646
647 pa_threaded_mainloop_lock(c->mainloop);
648 if (pa->read_length) {
649 int r = pa_stream_drop(pa->stream);
650 if (r) {
651 qpa_logerr(pa_context_errno(c->context),
652 "pa_stream_drop failed\n");
653 }
654 pa->read_length = 0;
655 }
656 qpa_simple_disconnect(c, pa->stream);
657 pa->stream = NULL;
658 pa_threaded_mainloop_unlock(c->mainloop);
659 }
660 }
661
662 static void qpa_volume_out(HWVoiceOut *hw, Volume *vol)
663 {
664 PAVoiceOut *pa = (PAVoiceOut *) hw;
665 pa_operation *op;
666 pa_cvolume v;
667 PAConnection *c = pa->g->conn;
668 int i;
669
670 #ifdef PA_CHECK_VERSION /* macro is present in 0.9.16+ */
671 pa_cvolume_init (&v); /* function is present in 0.9.13+ */
672 #endif
673
674 v.channels = vol->channels;
675 for (i = 0; i < vol->channels; ++i) {
676 v.values[i] = ((PA_VOLUME_NORM - PA_VOLUME_MUTED) * vol->vol[i]) / 255;
677 }
678
679 pa_threaded_mainloop_lock(c->mainloop);
680
681 op = pa_context_set_sink_input_volume(c->context,
682 pa_stream_get_index(pa->stream),
683 &v, NULL, NULL);
684 if (!op) {
685 qpa_logerr(pa_context_errno(c->context),
686 "set_sink_input_volume() failed\n");
687 } else {
688 pa_operation_unref(op);
689 }
690
691 op = pa_context_set_sink_input_mute(c->context,
692 pa_stream_get_index(pa->stream),
693 vol->mute, NULL, NULL);
694 if (!op) {
695 qpa_logerr(pa_context_errno(c->context),
696 "set_sink_input_mute() failed\n");
697 } else {
698 pa_operation_unref(op);
699 }
700
701 pa_threaded_mainloop_unlock(c->mainloop);
702 }
703
704 static void qpa_volume_in(HWVoiceIn *hw, Volume *vol)
705 {
706 PAVoiceIn *pa = (PAVoiceIn *) hw;
707 pa_operation *op;
708 pa_cvolume v;
709 PAConnection *c = pa->g->conn;
710 int i;
711
712 #ifdef PA_CHECK_VERSION
713 pa_cvolume_init (&v);
714 #endif
715
716 v.channels = vol->channels;
717 for (i = 0; i < vol->channels; ++i) {
718 v.values[i] = ((PA_VOLUME_NORM - PA_VOLUME_MUTED) * vol->vol[i]) / 255;
719 }
720
721 pa_threaded_mainloop_lock(c->mainloop);
722
723 op = pa_context_set_source_output_volume(c->context,
724 pa_stream_get_index(pa->stream),
725 &v, NULL, NULL);
726 if (!op) {
727 qpa_logerr(pa_context_errno(c->context),
728 "set_source_output_volume() failed\n");
729 } else {
730 pa_operation_unref(op);
731 }
732
733 op = pa_context_set_source_output_mute(c->context,
734 pa_stream_get_index(pa->stream),
735 vol->mute, NULL, NULL);
736 if (!op) {
737 qpa_logerr(pa_context_errno(c->context),
738 "set_source_output_mute() failed\n");
739 } else {
740 pa_operation_unref(op);
741 }
742
743 pa_threaded_mainloop_unlock(c->mainloop);
744 }
745
746 static int qpa_validate_per_direction_opts(Audiodev *dev,
747 AudiodevPaPerDirectionOptions *pdo)
748 {
749 if (!pdo->has_latency) {
750 pdo->has_latency = true;
751 pdo->latency = 15000;
752 }
753 return 1;
754 }
755
756 /* common */
757 static void *qpa_conn_init(const char *server)
758 {
759 const char *vm_name;
760 PAConnection *c = g_malloc0(sizeof(PAConnection));
761 QTAILQ_INSERT_TAIL(&pa_conns, c, list);
762
763 c->mainloop = pa_threaded_mainloop_new();
764 if (!c->mainloop) {
765 goto fail;
766 }
767
768 vm_name = qemu_get_vm_name();
769 c->context = pa_context_new(pa_threaded_mainloop_get_api(c->mainloop),
770 vm_name ? vm_name : "qemu");
771 if (!c->context) {
772 goto fail;
773 }
774
775 pa_context_set_state_callback(c->context, context_state_cb, c);
776
777 if (pa_context_connect(c->context, server, 0, NULL) < 0) {
778 qpa_logerr(pa_context_errno(c->context),
779 "pa_context_connect() failed\n");
780 goto fail;
781 }
782
783 pa_threaded_mainloop_lock(c->mainloop);
784
785 if (pa_threaded_mainloop_start(c->mainloop) < 0) {
786 goto unlock_and_fail;
787 }
788
789 for (;;) {
790 pa_context_state_t state;
791
792 state = pa_context_get_state(c->context);
793
794 if (state == PA_CONTEXT_READY) {
795 break;
796 }
797
798 if (!PA_CONTEXT_IS_GOOD(state)) {
799 qpa_logerr(pa_context_errno(c->context),
800 "Wrong context state\n");
801 goto unlock_and_fail;
802 }
803
804 /* Wait until the context is ready */
805 pa_threaded_mainloop_wait(c->mainloop);
806 }
807
808 pa_threaded_mainloop_unlock(c->mainloop);
809 return c;
810
811 unlock_and_fail:
812 pa_threaded_mainloop_unlock(c->mainloop);
813 fail:
814 AUD_log (AUDIO_CAP, "Failed to initialize PA context");
815 qpa_conn_fini(c);
816 return NULL;
817 }
818
819 static void *qpa_audio_init(Audiodev *dev)
820 {
821 paaudio *g;
822 AudiodevPaOptions *popts = &dev->u.pa;
823 const char *server;
824 PAConnection *c;
825
826 assert(dev->driver == AUDIODEV_DRIVER_PA);
827
828 if (!popts->has_server) {
829 char pidfile[64];
830 char *runtime;
831 struct stat st;
832
833 runtime = getenv("XDG_RUNTIME_DIR");
834 if (!runtime) {
835 return NULL;
836 }
837 snprintf(pidfile, sizeof(pidfile), "%s/pulse/pid", runtime);
838 if (stat(pidfile, &st) != 0) {
839 return NULL;
840 }
841 }
842
843 if (!qpa_validate_per_direction_opts(dev, popts->in)) {
844 return NULL;
845 }
846 if (!qpa_validate_per_direction_opts(dev, popts->out)) {
847 return NULL;
848 }
849
850 g = g_malloc0(sizeof(paaudio));
851 server = popts->has_server ? popts->server : NULL;
852
853 g->dev = dev;
854
855 QTAILQ_FOREACH(c, &pa_conns, list) {
856 if (server == NULL || c->server == NULL ?
857 server == c->server :
858 strcmp(server, c->server) == 0) {
859 g->conn = c;
860 break;
861 }
862 }
863 if (!g->conn) {
864 g->conn = qpa_conn_init(server);
865 }
866 if (!g->conn) {
867 g_free(g);
868 return NULL;
869 }
870
871 ++g->conn->refcount;
872 return g;
873 }
874
875 static void qpa_conn_fini(PAConnection *c)
876 {
877 if (c->mainloop) {
878 pa_threaded_mainloop_stop(c->mainloop);
879 }
880
881 if (c->context) {
882 pa_context_disconnect(c->context);
883 pa_context_unref(c->context);
884 }
885
886 if (c->mainloop) {
887 pa_threaded_mainloop_free(c->mainloop);
888 }
889
890 QTAILQ_REMOVE(&pa_conns, c, list);
891 g_free(c);
892 }
893
894 static void qpa_audio_fini (void *opaque)
895 {
896 paaudio *g = opaque;
897 PAConnection *c = g->conn;
898
899 if (--c->refcount == 0) {
900 qpa_conn_fini(c);
901 }
902
903 g_free(g);
904 }
905
906 static struct audio_pcm_ops qpa_pcm_ops = {
907 .init_out = qpa_init_out,
908 .fini_out = qpa_fini_out,
909 .write = qpa_write,
910 .get_buffer_out = qpa_get_buffer_out,
911 .put_buffer_out = qpa_put_buffer_out,
912 .volume_out = qpa_volume_out,
913
914 .init_in = qpa_init_in,
915 .fini_in = qpa_fini_in,
916 .read = qpa_read,
917 .get_buffer_in = qpa_get_buffer_in,
918 .put_buffer_in = qpa_put_buffer_in,
919 .volume_in = qpa_volume_in
920 };
921
922 static struct audio_driver pa_audio_driver = {
923 .name = "pa",
924 .descr = "http://www.pulseaudio.org/",
925 .init = qpa_audio_init,
926 .fini = qpa_audio_fini,
927 .pcm_ops = &qpa_pcm_ops,
928 .can_be_default = 1,
929 .max_voices_out = INT_MAX,
930 .max_voices_in = INT_MAX,
931 .voice_size_out = sizeof (PAVoiceOut),
932 .voice_size_in = sizeof (PAVoiceIn),
933 };
934
935 static void register_audio_pa(void)
936 {
937 audio_driver_register(&pa_audio_driver);
938 }
939 type_init(register_audio_pa);