2 #include "qemu-common.h"
5 #include <pulse/pulseaudio.h>
7 #define AUDIO_CAP "pulseaudio"
9 #include "audio_pt_int.h"
20 pa_threaded_mainloop
*mainloop
;
45 const void *read_data
;
46 size_t read_index
, read_length
;
50 static void GCC_FMT_ATTR (2, 3) qpa_logerr (int err
, const char *fmt
, ...)
55 AUD_vlog (AUDIO_CAP
, fmt
, ap
);
58 AUD_log (AUDIO_CAP
, "Reason: %s\n", pa_strerror (err
));
61 #ifndef PA_CONTEXT_IS_GOOD
62 static inline int PA_CONTEXT_IS_GOOD(pa_context_state_t x
)
65 x
== PA_CONTEXT_CONNECTING
||
66 x
== PA_CONTEXT_AUTHORIZING
||
67 x
== PA_CONTEXT_SETTING_NAME
||
68 x
== PA_CONTEXT_READY
;
72 #ifndef PA_STREAM_IS_GOOD
73 static inline int PA_STREAM_IS_GOOD(pa_stream_state_t x
)
76 x
== PA_STREAM_CREATING
||
81 #define CHECK_SUCCESS_GOTO(c, rerror, expression, label) \
83 if (!(expression)) { \
85 *(rerror) = pa_context_errno ((c)->context); \
91 #define CHECK_DEAD_GOTO(c, stream, rerror, label) \
93 if (!(c)->context || !PA_CONTEXT_IS_GOOD (pa_context_get_state((c)->context)) || \
94 !(stream) || !PA_STREAM_IS_GOOD (pa_stream_get_state ((stream)))) { \
95 if (((c)->context && pa_context_get_state ((c)->context) == PA_CONTEXT_FAILED) || \
96 ((stream) && pa_stream_get_state ((stream)) == PA_STREAM_FAILED)) { \
98 *(rerror) = pa_context_errno ((c)->context); \
102 *(rerror) = PA_ERR_BADSTATE; \
109 static int qpa_simple_read (PAVoiceIn
*p
, void *data
, size_t length
, int *rerror
)
113 pa_threaded_mainloop_lock (g
->mainloop
);
115 CHECK_DEAD_GOTO (g
, p
->stream
, rerror
, unlock_and_fail
);
120 while (!p
->read_data
) {
123 r
= pa_stream_peek (p
->stream
, &p
->read_data
, &p
->read_length
);
124 CHECK_SUCCESS_GOTO (g
, rerror
, r
== 0, unlock_and_fail
);
127 pa_threaded_mainloop_wait (g
->mainloop
);
128 CHECK_DEAD_GOTO (g
, p
->stream
, rerror
, unlock_and_fail
);
134 l
= p
->read_length
< length
? p
->read_length
: length
;
135 memcpy (data
, (const uint8_t *) p
->read_data
+p
->read_index
, l
);
137 data
= (uint8_t *) data
+ l
;
143 if (!p
->read_length
) {
146 r
= pa_stream_drop (p
->stream
);
151 CHECK_SUCCESS_GOTO (g
, rerror
, r
== 0, unlock_and_fail
);
155 pa_threaded_mainloop_unlock (g
->mainloop
);
159 pa_threaded_mainloop_unlock (g
->mainloop
);
163 static int qpa_simple_write (PAVoiceOut
*p
, const void *data
, size_t length
, int *rerror
)
167 pa_threaded_mainloop_lock (g
->mainloop
);
169 CHECK_DEAD_GOTO (g
, p
->stream
, rerror
, unlock_and_fail
);
175 while (!(l
= pa_stream_writable_size (p
->stream
))) {
176 pa_threaded_mainloop_wait (g
->mainloop
);
177 CHECK_DEAD_GOTO (g
, p
->stream
, rerror
, unlock_and_fail
);
180 CHECK_SUCCESS_GOTO (g
, rerror
, l
!= (size_t) -1, unlock_and_fail
);
186 r
= pa_stream_write (p
->stream
, data
, l
, NULL
, 0LL, PA_SEEK_RELATIVE
);
187 CHECK_SUCCESS_GOTO (g
, rerror
, r
>= 0, unlock_and_fail
);
189 data
= (const uint8_t *) data
+ l
;
193 pa_threaded_mainloop_unlock (g
->mainloop
);
197 pa_threaded_mainloop_unlock (g
->mainloop
);
201 static void *qpa_thread_out (void *arg
)
203 PAVoiceOut
*pa
= arg
;
204 HWVoiceOut
*hw
= &pa
->hw
;
206 if (audio_pt_lock (&pa
->pt
, AUDIO_FUNC
)) {
211 int decr
, to_mix
, rpos
;
222 if (audio_pt_wait (&pa
->pt
, AUDIO_FUNC
)) {
227 decr
= to_mix
= audio_MIN (pa
->live
, pa
->g
->conf
.samples
>> 2);
230 if (audio_pt_unlock (&pa
->pt
, AUDIO_FUNC
)) {
236 int chunk
= audio_MIN (to_mix
, hw
->samples
- rpos
);
237 struct st_sample
*src
= hw
->mix_buf
+ rpos
;
239 hw
->clip (pa
->pcm_buf
, src
, chunk
);
241 if (qpa_simple_write (pa
, pa
->pcm_buf
,
242 chunk
<< hw
->info
.shift
, &error
) < 0) {
243 qpa_logerr (error
, "pa_simple_write failed\n");
247 rpos
= (rpos
+ chunk
) % hw
->samples
;
251 if (audio_pt_lock (&pa
->pt
, AUDIO_FUNC
)) {
261 audio_pt_unlock (&pa
->pt
, AUDIO_FUNC
);
265 static int qpa_run_out (HWVoiceOut
*hw
, int live
)
268 PAVoiceOut
*pa
= (PAVoiceOut
*) hw
;
270 if (audio_pt_lock (&pa
->pt
, AUDIO_FUNC
)) {
274 decr
= audio_MIN (live
, pa
->decr
);
276 pa
->live
= live
- decr
;
279 audio_pt_unlock_and_signal (&pa
->pt
, AUDIO_FUNC
);
282 audio_pt_unlock (&pa
->pt
, AUDIO_FUNC
);
287 static int qpa_write (SWVoiceOut
*sw
, void *buf
, int len
)
289 return audio_pcm_sw_write (sw
, buf
, len
);
293 static void *qpa_thread_in (void *arg
)
296 HWVoiceIn
*hw
= &pa
->hw
;
298 if (audio_pt_lock (&pa
->pt
, AUDIO_FUNC
)) {
303 int incr
, to_grab
, wpos
;
314 if (audio_pt_wait (&pa
->pt
, AUDIO_FUNC
)) {
319 incr
= to_grab
= audio_MIN (pa
->dead
, pa
->g
->conf
.samples
>> 2);
322 if (audio_pt_unlock (&pa
->pt
, AUDIO_FUNC
)) {
328 int chunk
= audio_MIN (to_grab
, hw
->samples
- wpos
);
329 void *buf
= advance (pa
->pcm_buf
, wpos
);
331 if (qpa_simple_read (pa
, buf
,
332 chunk
<< hw
->info
.shift
, &error
) < 0) {
333 qpa_logerr (error
, "pa_simple_read failed\n");
337 hw
->conv (hw
->conv_buf
+ wpos
, buf
, chunk
);
338 wpos
= (wpos
+ chunk
) % hw
->samples
;
342 if (audio_pt_lock (&pa
->pt
, AUDIO_FUNC
)) {
352 audio_pt_unlock (&pa
->pt
, AUDIO_FUNC
);
356 static int qpa_run_in (HWVoiceIn
*hw
)
358 int live
, incr
, dead
;
359 PAVoiceIn
*pa
= (PAVoiceIn
*) hw
;
361 if (audio_pt_lock (&pa
->pt
, AUDIO_FUNC
)) {
365 live
= audio_pcm_hw_get_live_in (hw
);
366 dead
= hw
->samples
- live
;
367 incr
= audio_MIN (dead
, pa
->incr
);
369 pa
->dead
= dead
- incr
;
372 audio_pt_unlock_and_signal (&pa
->pt
, AUDIO_FUNC
);
375 audio_pt_unlock (&pa
->pt
, AUDIO_FUNC
);
380 static int qpa_read (SWVoiceIn
*sw
, void *buf
, int len
)
382 return audio_pcm_sw_read (sw
, buf
, len
);
385 static pa_sample_format_t
audfmt_to_pa (audfmt_e afmt
, int endianness
)
392 format
= PA_SAMPLE_U8
;
396 format
= endianness
? PA_SAMPLE_S16BE
: PA_SAMPLE_S16LE
;
400 format
= endianness
? PA_SAMPLE_S32BE
: PA_SAMPLE_S32LE
;
403 dolog ("Internal logic error: Bad audio format %d\n", afmt
);
404 format
= PA_SAMPLE_U8
;
410 static audfmt_e
pa_to_audfmt (pa_sample_format_t fmt
, int *endianness
)
415 case PA_SAMPLE_S16BE
:
418 case PA_SAMPLE_S16LE
:
421 case PA_SAMPLE_S32BE
:
424 case PA_SAMPLE_S32LE
:
428 dolog ("Internal logic error: Bad pa_sample_format %d\n", fmt
);
433 static void context_state_cb (pa_context
*c
, void *userdata
)
435 paaudio
*g
= userdata
;
437 switch (pa_context_get_state(c
)) {
438 case PA_CONTEXT_READY
:
439 case PA_CONTEXT_TERMINATED
:
440 case PA_CONTEXT_FAILED
:
441 pa_threaded_mainloop_signal (g
->mainloop
, 0);
444 case PA_CONTEXT_UNCONNECTED
:
445 case PA_CONTEXT_CONNECTING
:
446 case PA_CONTEXT_AUTHORIZING
:
447 case PA_CONTEXT_SETTING_NAME
:
452 static void stream_state_cb (pa_stream
*s
, void * userdata
)
454 paaudio
*g
= userdata
;
456 switch (pa_stream_get_state (s
)) {
458 case PA_STREAM_READY
:
459 case PA_STREAM_FAILED
:
460 case PA_STREAM_TERMINATED
:
461 pa_threaded_mainloop_signal (g
->mainloop
, 0);
464 case PA_STREAM_UNCONNECTED
:
465 case PA_STREAM_CREATING
:
470 static void stream_request_cb (pa_stream
*s
, size_t length
, void *userdata
)
472 paaudio
*g
= userdata
;
474 pa_threaded_mainloop_signal (g
->mainloop
, 0);
477 static pa_stream
*qpa_simple_new (
480 pa_stream_direction_t dir
,
482 const pa_sample_spec
*ss
,
483 const pa_channel_map
*map
,
484 const pa_buffer_attr
*attr
,
490 pa_threaded_mainloop_lock (g
->mainloop
);
492 stream
= pa_stream_new (g
->context
, name
, ss
, map
);
497 pa_stream_set_state_callback (stream
, stream_state_cb
, g
);
498 pa_stream_set_read_callback (stream
, stream_request_cb
, g
);
499 pa_stream_set_write_callback (stream
, stream_request_cb
, g
);
501 if (dir
== PA_STREAM_PLAYBACK
) {
502 r
= pa_stream_connect_playback (stream
, dev
, attr
,
503 PA_STREAM_INTERPOLATE_TIMING
504 #ifdef PA_STREAM_ADJUST_LATENCY
505 |PA_STREAM_ADJUST_LATENCY
507 |PA_STREAM_AUTO_TIMING_UPDATE
, NULL
, NULL
);
509 r
= pa_stream_connect_record (stream
, dev
, attr
,
510 PA_STREAM_INTERPOLATE_TIMING
511 #ifdef PA_STREAM_ADJUST_LATENCY
512 |PA_STREAM_ADJUST_LATENCY
514 |PA_STREAM_AUTO_TIMING_UPDATE
);
521 pa_threaded_mainloop_unlock (g
->mainloop
);
526 pa_threaded_mainloop_unlock (g
->mainloop
);
529 pa_stream_unref (stream
);
532 *rerror
= pa_context_errno (g
->context
);
537 static int qpa_init_out(HWVoiceOut
*hw
, struct audsettings
*as
,
543 struct audsettings obt_as
= *as
;
544 PAVoiceOut
*pa
= (PAVoiceOut
*) hw
;
545 paaudio
*g
= pa
->g
= drv_opaque
;
547 ss
.format
= audfmt_to_pa (as
->fmt
, as
->endianness
);
548 ss
.channels
= as
->nchannels
;
552 * qemu audio tick runs at 100 Hz (by default), so processing
553 * data chunks worth 10 ms of sound should be a good fit.
555 ba
.tlength
= pa_usec_to_bytes (10 * 1000, &ss
);
556 ba
.minreq
= pa_usec_to_bytes (5 * 1000, &ss
);
560 obt_as
.fmt
= pa_to_audfmt (ss
.format
, &obt_as
.endianness
);
562 pa
->stream
= qpa_simple_new (
568 NULL
, /* channel map */
569 &ba
, /* buffering attributes */
573 qpa_logerr (error
, "pa_simple_new for playback failed\n");
577 audio_pcm_init_info (&hw
->info
, &obt_as
);
578 hw
->samples
= g
->conf
.samples
;
579 pa
->pcm_buf
= audio_calloc (AUDIO_FUNC
, hw
->samples
, 1 << hw
->info
.shift
);
582 dolog ("Could not allocate buffer (%d bytes)\n",
583 hw
->samples
<< hw
->info
.shift
);
587 if (audio_pt_init (&pa
->pt
, qpa_thread_out
, hw
, AUDIO_CAP
, AUDIO_FUNC
)) {
594 g_free (pa
->pcm_buf
);
598 pa_stream_unref (pa
->stream
);
605 static int qpa_init_in(HWVoiceIn
*hw
, struct audsettings
*as
, void *drv_opaque
)
609 struct audsettings obt_as
= *as
;
610 PAVoiceIn
*pa
= (PAVoiceIn
*) hw
;
611 paaudio
*g
= pa
->g
= drv_opaque
;
613 ss
.format
= audfmt_to_pa (as
->fmt
, as
->endianness
);
614 ss
.channels
= as
->nchannels
;
617 obt_as
.fmt
= pa_to_audfmt (ss
.format
, &obt_as
.endianness
);
619 pa
->stream
= qpa_simple_new (
625 NULL
, /* channel map */
626 NULL
, /* buffering attributes */
630 qpa_logerr (error
, "pa_simple_new for capture failed\n");
634 audio_pcm_init_info (&hw
->info
, &obt_as
);
635 hw
->samples
= g
->conf
.samples
;
636 pa
->pcm_buf
= audio_calloc (AUDIO_FUNC
, hw
->samples
, 1 << hw
->info
.shift
);
639 dolog ("Could not allocate buffer (%d bytes)\n",
640 hw
->samples
<< hw
->info
.shift
);
644 if (audio_pt_init (&pa
->pt
, qpa_thread_in
, hw
, AUDIO_CAP
, AUDIO_FUNC
)) {
651 g_free (pa
->pcm_buf
);
655 pa_stream_unref (pa
->stream
);
662 static void qpa_fini_out (HWVoiceOut
*hw
)
665 PAVoiceOut
*pa
= (PAVoiceOut
*) hw
;
667 audio_pt_lock (&pa
->pt
, AUDIO_FUNC
);
669 audio_pt_unlock_and_signal (&pa
->pt
, AUDIO_FUNC
);
670 audio_pt_join (&pa
->pt
, &ret
, AUDIO_FUNC
);
673 pa_stream_unref (pa
->stream
);
677 audio_pt_fini (&pa
->pt
, AUDIO_FUNC
);
678 g_free (pa
->pcm_buf
);
682 static void qpa_fini_in (HWVoiceIn
*hw
)
685 PAVoiceIn
*pa
= (PAVoiceIn
*) hw
;
687 audio_pt_lock (&pa
->pt
, AUDIO_FUNC
);
689 audio_pt_unlock_and_signal (&pa
->pt
, AUDIO_FUNC
);
690 audio_pt_join (&pa
->pt
, &ret
, AUDIO_FUNC
);
693 pa_stream_unref (pa
->stream
);
697 audio_pt_fini (&pa
->pt
, AUDIO_FUNC
);
698 g_free (pa
->pcm_buf
);
702 static int qpa_ctl_out (HWVoiceOut
*hw
, int cmd
, ...)
704 PAVoiceOut
*pa
= (PAVoiceOut
*) hw
;
709 #ifdef PA_CHECK_VERSION /* macro is present in 0.9.16+ */
710 pa_cvolume_init (&v
); /* function is present in 0.9.13+ */
720 sw
= va_arg (ap
, SWVoiceOut
*);
724 v
.values
[0] = ((PA_VOLUME_NORM
- PA_VOLUME_MUTED
) * sw
->vol
.l
) / UINT32_MAX
;
725 v
.values
[1] = ((PA_VOLUME_NORM
- PA_VOLUME_MUTED
) * sw
->vol
.r
) / UINT32_MAX
;
727 pa_threaded_mainloop_lock (g
->mainloop
);
729 op
= pa_context_set_sink_input_volume (g
->context
,
730 pa_stream_get_index (pa
->stream
),
733 qpa_logerr (pa_context_errno (g
->context
),
734 "set_sink_input_volume() failed\n");
736 pa_operation_unref (op
);
738 op
= pa_context_set_sink_input_mute (g
->context
,
739 pa_stream_get_index (pa
->stream
),
740 sw
->vol
.mute
, NULL
, NULL
);
742 qpa_logerr (pa_context_errno (g
->context
),
743 "set_sink_input_mute() failed\n");
745 pa_operation_unref (op
);
748 pa_threaded_mainloop_unlock (g
->mainloop
);
754 static int qpa_ctl_in (HWVoiceIn
*hw
, int cmd
, ...)
756 PAVoiceIn
*pa
= (PAVoiceIn
*) hw
;
761 #ifdef PA_CHECK_VERSION
762 pa_cvolume_init (&v
);
772 sw
= va_arg (ap
, SWVoiceIn
*);
776 v
.values
[0] = ((PA_VOLUME_NORM
- PA_VOLUME_MUTED
) * sw
->vol
.l
) / UINT32_MAX
;
777 v
.values
[1] = ((PA_VOLUME_NORM
- PA_VOLUME_MUTED
) * sw
->vol
.r
) / UINT32_MAX
;
779 pa_threaded_mainloop_lock (g
->mainloop
);
781 /* FIXME: use the upcoming "set_source_output_{volume,mute}" */
782 op
= pa_context_set_source_volume_by_index (g
->context
,
783 pa_stream_get_device_index (pa
->stream
),
786 qpa_logerr (pa_context_errno (g
->context
),
787 "set_source_volume() failed\n");
789 pa_operation_unref(op
);
792 op
= pa_context_set_source_mute_by_index (g
->context
,
793 pa_stream_get_index (pa
->stream
),
794 sw
->vol
.mute
, NULL
, NULL
);
796 qpa_logerr (pa_context_errno (g
->context
),
797 "set_source_mute() failed\n");
799 pa_operation_unref (op
);
802 pa_threaded_mainloop_unlock (g
->mainloop
);
809 static PAConf glob_conf
= {
813 static void *qpa_audio_init (void)
815 paaudio
*g
= g_malloc(sizeof(paaudio
));
818 g
->mainloop
= pa_threaded_mainloop_new ();
823 g
->context
= pa_context_new (pa_threaded_mainloop_get_api (g
->mainloop
),
829 pa_context_set_state_callback (g
->context
, context_state_cb
, g
);
831 if (pa_context_connect (g
->context
, g
->conf
.server
, 0, NULL
) < 0) {
832 qpa_logerr (pa_context_errno (g
->context
),
833 "pa_context_connect() failed\n");
837 pa_threaded_mainloop_lock (g
->mainloop
);
839 if (pa_threaded_mainloop_start (g
->mainloop
) < 0) {
840 goto unlock_and_fail
;
844 pa_context_state_t state
;
846 state
= pa_context_get_state (g
->context
);
848 if (state
== PA_CONTEXT_READY
) {
852 if (!PA_CONTEXT_IS_GOOD (state
)) {
853 qpa_logerr (pa_context_errno (g
->context
),
854 "Wrong context state\n");
855 goto unlock_and_fail
;
858 /* Wait until the context is ready */
859 pa_threaded_mainloop_wait (g
->mainloop
);
862 pa_threaded_mainloop_unlock (g
->mainloop
);
867 pa_threaded_mainloop_unlock (g
->mainloop
);
869 AUD_log (AUDIO_CAP
, "Failed to initialize PA context");
874 static void qpa_audio_fini (void *opaque
)
879 pa_threaded_mainloop_stop (g
->mainloop
);
883 pa_context_disconnect (g
->context
);
884 pa_context_unref (g
->context
);
888 pa_threaded_mainloop_free (g
->mainloop
);
894 struct audio_option qpa_options
[] = {
898 .valp
= &glob_conf
.samples
,
899 .descr
= "buffer size in samples"
904 .valp
= &glob_conf
.server
,
905 .descr
= "server address"
910 .valp
= &glob_conf
.sink
,
911 .descr
= "sink device name"
916 .valp
= &glob_conf
.source
,
917 .descr
= "source device name"
919 { /* End of list */ }
922 static struct audio_pcm_ops qpa_pcm_ops
= {
923 .init_out
= qpa_init_out
,
924 .fini_out
= qpa_fini_out
,
925 .run_out
= qpa_run_out
,
927 .ctl_out
= qpa_ctl_out
,
929 .init_in
= qpa_init_in
,
930 .fini_in
= qpa_fini_in
,
931 .run_in
= qpa_run_in
,
936 struct audio_driver pa_audio_driver
= {
938 .descr
= "http://www.pulseaudio.org/",
939 .options
= qpa_options
,
940 .init
= qpa_audio_init
,
941 .fini
= qpa_audio_fini
,
942 .pcm_ops
= &qpa_pcm_ops
,
944 .max_voices_out
= INT_MAX
,
945 .max_voices_in
= INT_MAX
,
946 .voice_size_out
= sizeof (PAVoiceOut
),
947 .voice_size_in
= sizeof (PAVoiceIn
),
948 .ctl_caps
= VOICE_VOLUME_CAP