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