audio/paaudio.c

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