audio/paaudio.c

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