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