audio/paaudio.c

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