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