audio/paaudio.c

   1 /* public domain */
   2
   3 #include "qemu/osdep.h"
   4 #include "qemu/module.h"
   5 #include "audio.h"
   6 #include "qapi/opts-visitor.h"
   7
   8 #include <pulse/pulseaudio.h>
   9
  10 #define AUDIO_CAP "pulseaudio"
  11 #include "audio_int.h"
  12
  13 typedef struct PAConnection {
  14     char *server;
  15     int refcount;
  16     QTAILQ_ENTRY(PAConnection) list;
  17
  18     pa_threaded_mainloop *mainloop;
  19     pa_context *context;
  20 } PAConnection;
  21
  22 static QTAILQ_HEAD(PAConnectionHead, PAConnection) pa_conns =
  23     QTAILQ_HEAD_INITIALIZER(pa_conns);
  24
  25 typedef struct {
  26     Audiodev *dev;
  27     PAConnection *conn;
  28 } paaudio;
  29
  30 typedef struct {
  31     HWVoiceOut hw;
  32     pa_stream *stream;
  33     paaudio *g;
  34     size_t samples;
  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     size_t samples;
  44 } PAVoiceIn;
  45
  46 static void qpa_conn_fini(PAConnection *c);
  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, expression, label, msg)           \
  80     do {                                                        \
  81         if (!(expression)) {                                    \
  82             qpa_logerr(pa_context_errno((c)->context), msg);    \
  83             goto label;                                         \
  84         }                                                       \
  85     } while (0)
  86
  87 #define CHECK_DEAD_GOTO(c, stream, label, msg)                          \
  88     do {                                                                \
  89         if (!(c)->context || !PA_CONTEXT_IS_GOOD (pa_context_get_state((c)->context)) || \
  90             !(stream) || !PA_STREAM_IS_GOOD (pa_stream_get_state ((stream)))) { \
  91             if (((c)->context && pa_context_get_state ((c)->context) == PA_CONTEXT_FAILED) || \
  92                 ((stream) && pa_stream_get_state ((stream)) == PA_STREAM_FAILED)) { \
  93                 qpa_logerr(pa_context_errno((c)->context), msg);        \
  94             } else {                                                    \
  95                 qpa_logerr(PA_ERR_BADSTATE, msg);                       \
  96             }                                                           \
  97             goto label;                                                 \
  98         }                                                               \
  99     } while (0)
 100
 101 static size_t qpa_read(HWVoiceIn *hw, void *data, size_t length)
 102 {
 103     PAVoiceIn *p = (PAVoiceIn *) hw;
 104     PAConnection *c = p->g->conn;
 105     size_t l;
 106     int r;
 107
 108     pa_threaded_mainloop_lock(c->mainloop);
 109
 110     CHECK_DEAD_GOTO(c, p->stream, unlock_and_fail,
 111                     "pa_threaded_mainloop_lock failed\n");
 112
 113     if (!p->read_length) {
 114         r = pa_stream_peek(p->stream, &p->read_data, &p->read_length);
 115         CHECK_SUCCESS_GOTO(c, r == 0, unlock_and_fail,
 116                            "pa_stream_peek failed\n");
 117     }
 118
 119     l = MIN(p->read_length, length);
 120     memcpy(data, p->read_data, l);
 121
 122     p->read_data += l;
 123     p->read_length -= l;
 124
 125     if (!p->read_length) {
 126         r = pa_stream_drop(p->stream);
 127         CHECK_SUCCESS_GOTO(c, r == 0, unlock_and_fail,
 128                            "pa_stream_drop failed\n");
 129     }
 130
 131     pa_threaded_mainloop_unlock(c->mainloop);
 132     return l;
 133
 134 unlock_and_fail:
 135     pa_threaded_mainloop_unlock(c->mainloop);
 136     return 0;
 137 }
 138
 139 static size_t qpa_write(HWVoiceOut *hw, void *data, size_t length)
 140 {
 141     PAVoiceOut *p = (PAVoiceOut *) hw;
 142     PAConnection *c = p->g->conn;
 143     size_t l;
 144     int r;
 145
 146     pa_threaded_mainloop_lock(c->mainloop);
 147
 148     CHECK_DEAD_GOTO(c, p->stream, unlock_and_fail,
 149                     "pa_threaded_mainloop_lock failed\n");
 150
 151     l = pa_stream_writable_size(p->stream);
 152
 153     CHECK_SUCCESS_GOTO(c, l != (size_t) -1, unlock_and_fail,
 154                        "pa_stream_writable_size failed\n");
 155
 156     if (l > length) {
 157         l = length;
 158     }
 159
 160     r = pa_stream_write(p->stream, data, l, NULL, 0LL, PA_SEEK_RELATIVE);
 161     CHECK_SUCCESS_GOTO(c, r >= 0, unlock_and_fail, "pa_stream_write failed\n");
 162
 163     pa_threaded_mainloop_unlock(c->mainloop);
 164     return l;
 165
 166 unlock_and_fail:
 167     pa_threaded_mainloop_unlock(c->mainloop);
 168     return 0;
 169 }
 170
 171 static pa_sample_format_t audfmt_to_pa (AudioFormat afmt, int endianness)
 172 {
 173     int format;
 174
 175     switch (afmt) {
 176     case AUDIO_FORMAT_S8:
 177     case AUDIO_FORMAT_U8:
 178         format = PA_SAMPLE_U8;
 179         break;
 180     case AUDIO_FORMAT_S16:
 181     case AUDIO_FORMAT_U16:
 182         format = endianness ? PA_SAMPLE_S16BE : PA_SAMPLE_S16LE;
 183         break;
 184     case AUDIO_FORMAT_S32:
 185     case AUDIO_FORMAT_U32:
 186         format = endianness ? PA_SAMPLE_S32BE : PA_SAMPLE_S32LE;
 187         break;
 188     default:
 189         dolog ("Internal logic error: Bad audio format %d\n", afmt);
 190         format = PA_SAMPLE_U8;
 191         break;
 192     }
 193     return format;
 194 }
 195
 196 static AudioFormat pa_to_audfmt (pa_sample_format_t fmt, int *endianness)
 197 {
 198     switch (fmt) {
 199     case PA_SAMPLE_U8:
 200         return AUDIO_FORMAT_U8;
 201     case PA_SAMPLE_S16BE:
 202         *endianness = 1;
 203         return AUDIO_FORMAT_S16;
 204     case PA_SAMPLE_S16LE:
 205         *endianness = 0;
 206         return AUDIO_FORMAT_S16;
 207     case PA_SAMPLE_S32BE:
 208         *endianness = 1;
 209         return AUDIO_FORMAT_S32;
 210     case PA_SAMPLE_S32LE:
 211         *endianness = 0;
 212         return AUDIO_FORMAT_S32;
 213     default:
 214         dolog ("Internal logic error: Bad pa_sample_format %d\n", fmt);
 215         return AUDIO_FORMAT_U8;
 216     }
 217 }
 218
 219 static void context_state_cb (pa_context *c, void *userdata)
 220 {
 221     PAConnection *conn = userdata;
 222
 223     switch (pa_context_get_state(c)) {
 224     case PA_CONTEXT_READY:
 225     case PA_CONTEXT_TERMINATED:
 226     case PA_CONTEXT_FAILED:
 227         pa_threaded_mainloop_signal(conn->mainloop, 0);
 228         break;
 229
 230     case PA_CONTEXT_UNCONNECTED:
 231     case PA_CONTEXT_CONNECTING:
 232     case PA_CONTEXT_AUTHORIZING:
 233     case PA_CONTEXT_SETTING_NAME:
 234         break;
 235     }
 236 }
 237
 238 static void stream_state_cb (pa_stream *s, void * userdata)
 239 {
 240     PAConnection *c = userdata;
 241
 242     switch (pa_stream_get_state (s)) {
 243
 244     case PA_STREAM_READY:
 245     case PA_STREAM_FAILED:
 246     case PA_STREAM_TERMINATED:
 247         pa_threaded_mainloop_signal(c->mainloop, 0);
 248         break;
 249
 250     case PA_STREAM_UNCONNECTED:
 251     case PA_STREAM_CREATING:
 252         break;
 253     }
 254 }
 255
 256 static pa_stream *qpa_simple_new (
 257         PAConnection *c,
 258         const char *name,
 259         pa_stream_direction_t dir,
 260         const char *dev,
 261         const pa_sample_spec *ss,
 262         const pa_channel_map *map,
 263         const pa_buffer_attr *attr,
 264         int *rerror)
 265 {
 266     int r;
 267     pa_stream *stream;
 268     pa_stream_flags_t flags;
 269
 270     pa_threaded_mainloop_lock(c->mainloop);
 271
 272     stream = pa_stream_new(c->context, name, ss, map);
 273     if (!stream) {
 274         goto fail;
 275     }
 276
 277     pa_stream_set_state_callback(stream, stream_state_cb, c);
 278
 279     flags =
 280         PA_STREAM_INTERPOLATE_TIMING
 281         | PA_STREAM_AUTO_TIMING_UPDATE
 282         | PA_STREAM_EARLY_REQUESTS;
 283
 284     if (dev) {
 285         /* don't move the stream if the user specified a sink/source */
 286         flags |= PA_STREAM_DONT_MOVE;
 287     }
 288
 289     if (dir == PA_STREAM_PLAYBACK) {
 290         r = pa_stream_connect_playback(stream, dev, attr, flags, NULL, NULL);
 291     } else {
 292         r = pa_stream_connect_record(stream, dev, attr, flags);
 293     }
 294
 295     if (r < 0) {
 296       goto fail;
 297     }
 298
 299     pa_threaded_mainloop_unlock(c->mainloop);
 300
 301     return stream;
 302
 303 fail:
 304     pa_threaded_mainloop_unlock(c->mainloop);
 305
 306     if (stream) {
 307         pa_stream_unref (stream);
 308     }
 309
 310     *rerror = pa_context_errno(c->context);
 311
 312     return NULL;
 313 }
 314
 315 static int qpa_init_out(HWVoiceOut *hw, struct audsettings *as,
 316                         void *drv_opaque)
 317 {
 318     int error;
 319     pa_sample_spec ss;
 320     pa_buffer_attr ba;
 321     struct audsettings obt_as = *as;
 322     PAVoiceOut *pa = (PAVoiceOut *) hw;
 323     paaudio *g = pa->g = drv_opaque;
 324     AudiodevPaOptions *popts = &g->dev->u.pa;
 325     AudiodevPaPerDirectionOptions *ppdo = popts->out;
 326     PAConnection *c = g->conn;
 327
 328     ss.format = audfmt_to_pa (as->fmt, as->endianness);
 329     ss.channels = as->nchannels;
 330     ss.rate = as->freq;
 331
 332     ba.tlength = pa_usec_to_bytes(ppdo->latency, &ss);
 333     ba.minreq = -1;
 334     ba.maxlength = -1;
 335     ba.prebuf = -1;
 336
 337     obt_as.fmt = pa_to_audfmt (ss.format, &obt_as.endianness);
 338
 339     pa->stream = qpa_simple_new (
 340         c,
 341         "qemu",
 342         PA_STREAM_PLAYBACK,
 343         ppdo->has_name ? ppdo->name : NULL,
 344         &ss,
 345         NULL,                   /* channel map */
 346         &ba,                    /* buffering attributes */
 347         &error
 348         );
 349     if (!pa->stream) {
 350         qpa_logerr (error, "pa_simple_new for playback failed\n");
 351         goto fail1;
 352     }
 353
 354     audio_pcm_init_info (&hw->info, &obt_as);
 355     hw->samples = pa->samples = audio_buffer_samples(
 356         qapi_AudiodevPaPerDirectionOptions_base(ppdo),
 357         &obt_as, ppdo->buffer_length);
 358
 359     return 0;
 360
 361  fail1:
 362     return -1;
 363 }
 364
 365 static int qpa_init_in(HWVoiceIn *hw, struct audsettings *as, void *drv_opaque)
 366 {
 367     int error;
 368     pa_sample_spec ss;
 369     pa_buffer_attr ba;
 370     struct audsettings obt_as = *as;
 371     PAVoiceIn *pa = (PAVoiceIn *) hw;
 372     paaudio *g = pa->g = drv_opaque;
 373     AudiodevPaOptions *popts = &g->dev->u.pa;
 374     AudiodevPaPerDirectionOptions *ppdo = popts->in;
 375     PAConnection *c = g->conn;
 376
 377     ss.format = audfmt_to_pa (as->fmt, as->endianness);
 378     ss.channels = as->nchannels;
 379     ss.rate = as->freq;
 380
 381     ba.fragsize = pa_usec_to_bytes(ppdo->latency, &ss);
 382     ba.maxlength = pa_usec_to_bytes(ppdo->latency * 2, &ss);
 383     ba.minreq = -1;
 384     ba.prebuf = -1;
 385
 386     obt_as.fmt = pa_to_audfmt (ss.format, &obt_as.endianness);
 387
 388     pa->stream = qpa_simple_new (
 389         c,
 390         "qemu",
 391         PA_STREAM_RECORD,
 392         ppdo->has_name ? ppdo->name : NULL,
 393         &ss,
 394         NULL,                   /* channel map */
 395         &ba,                    /* buffering attributes */
 396         &error
 397         );
 398     if (!pa->stream) {
 399         qpa_logerr (error, "pa_simple_new for capture failed\n");
 400         goto fail1;
 401     }
 402
 403     audio_pcm_init_info (&hw->info, &obt_as);
 404     hw->samples = pa->samples = audio_buffer_samples(
 405         qapi_AudiodevPaPerDirectionOptions_base(ppdo),
 406         &obt_as, ppdo->buffer_length);
 407
 408     return 0;
 409
 410  fail1:
 411     return -1;
 412 }
 413
 414 static void qpa_simple_disconnect(PAConnection *c, pa_stream *stream)
 415 {
 416     int err;
 417
 418     pa_threaded_mainloop_lock(c->mainloop);
 419     /*
 420      * wait until actually connects. workaround pa bug #247
 421      * https://gitlab.freedesktop.org/pulseaudio/pulseaudio/issues/247
 422      */
 423     while (pa_stream_get_state(stream) == PA_STREAM_CREATING) {
 424         pa_threaded_mainloop_wait(c->mainloop);
 425     }
 426
 427     err = pa_stream_disconnect(stream);
 428     if (err != 0) {
 429         dolog("Failed to disconnect! err=%d\n", err);
 430     }
 431     pa_stream_unref(stream);
 432     pa_threaded_mainloop_unlock(c->mainloop);
 433 }
 434
 435 static void qpa_fini_out (HWVoiceOut *hw)
 436 {
 437     PAVoiceOut *pa = (PAVoiceOut *) hw;
 438
 439     if (pa->stream) {
 440         qpa_simple_disconnect(pa->g->conn, pa->stream);
 441         pa->stream = NULL;
 442     }
 443 }
 444
 445 static void qpa_fini_in (HWVoiceIn *hw)
 446 {
 447     PAVoiceIn *pa = (PAVoiceIn *) hw;
 448
 449     if (pa->stream) {
 450         qpa_simple_disconnect(pa->g->conn, pa->stream);
 451         pa->stream = NULL;
 452     }
 453 }
 454
 455 static int qpa_ctl_out (HWVoiceOut *hw, int cmd, ...)
 456 {
 457     PAVoiceOut *pa = (PAVoiceOut *) hw;
 458     pa_operation *op;
 459     pa_cvolume v;
 460     PAConnection *c = pa->g->conn;
 461
 462 #ifdef PA_CHECK_VERSION    /* macro is present in 0.9.16+ */
 463     pa_cvolume_init (&v);  /* function is present in 0.9.13+ */
 464 #endif
 465
 466     switch (cmd) {
 467     case VOICE_VOLUME:
 468         {
 469             SWVoiceOut *sw;
 470             va_list ap;
 471
 472             va_start (ap, cmd);
 473             sw = va_arg (ap, SWVoiceOut *);
 474             va_end (ap);
 475
 476             v.channels = 2;
 477             v.values[0] = ((PA_VOLUME_NORM - PA_VOLUME_MUTED) * sw->vol.l) / UINT32_MAX;
 478             v.values[1] = ((PA_VOLUME_NORM - PA_VOLUME_MUTED) * sw->vol.r) / UINT32_MAX;
 479
 480             pa_threaded_mainloop_lock(c->mainloop);
 481
 482             op = pa_context_set_sink_input_volume(c->context,
 483                 pa_stream_get_index (pa->stream),
 484                 &v, NULL, NULL);
 485             if (!op) {
 486                 qpa_logerr(pa_context_errno(c->context),
 487                            "set_sink_input_volume() failed\n");
 488             } else {
 489                 pa_operation_unref(op);
 490             }
 491
 492             op = pa_context_set_sink_input_mute(c->context,
 493                 pa_stream_get_index (pa->stream),
 494                sw->vol.mute, NULL, NULL);
 495             if (!op) {
 496                 qpa_logerr(pa_context_errno(c->context),
 497                            "set_sink_input_mute() failed\n");
 498             } else {
 499                 pa_operation_unref(op);
 500             }
 501
 502             pa_threaded_mainloop_unlock(c->mainloop);
 503         }
 504     }
 505     return 0;
 506 }
 507
 508 static int qpa_ctl_in (HWVoiceIn *hw, int cmd, ...)
 509 {
 510     PAVoiceIn *pa = (PAVoiceIn *) hw;
 511     pa_operation *op;
 512     pa_cvolume v;
 513     PAConnection *c = pa->g->conn;
 514
 515 #ifdef PA_CHECK_VERSION
 516     pa_cvolume_init (&v);
 517 #endif
 518
 519     switch (cmd) {
 520     case VOICE_VOLUME:
 521         {
 522             SWVoiceIn *sw;
 523             va_list ap;
 524
 525             va_start (ap, cmd);
 526             sw = va_arg (ap, SWVoiceIn *);
 527             va_end (ap);
 528
 529             v.channels = 2;
 530             v.values[0] = ((PA_VOLUME_NORM - PA_VOLUME_MUTED) * sw->vol.l) / UINT32_MAX;
 531             v.values[1] = ((PA_VOLUME_NORM - PA_VOLUME_MUTED) * sw->vol.r) / UINT32_MAX;
 532
 533             pa_threaded_mainloop_lock(c->mainloop);
 534
 535             op = pa_context_set_source_output_volume(c->context,
 536                 pa_stream_get_index(pa->stream),
 537                 &v, NULL, NULL);
 538             if (!op) {
 539                 qpa_logerr(pa_context_errno(c->context),
 540                            "set_source_output_volume() failed\n");
 541             } else {
 542                 pa_operation_unref(op);
 543             }
 544
 545             op = pa_context_set_source_output_mute(c->context,
 546                 pa_stream_get_index (pa->stream),
 547                 sw->vol.mute, NULL, NULL);
 548             if (!op) {
 549                 qpa_logerr(pa_context_errno(c->context),
 550                            "set_source_output_mute() failed\n");
 551             } else {
 552                 pa_operation_unref (op);
 553             }
 554
 555             pa_threaded_mainloop_unlock(c->mainloop);
 556         }
 557     }
 558     return 0;
 559 }
 560
 561 static int qpa_validate_per_direction_opts(Audiodev *dev,
 562                                            AudiodevPaPerDirectionOptions *pdo)
 563 {
 564     if (!pdo->has_buffer_length) {
 565         pdo->has_buffer_length = true;
 566         pdo->buffer_length = 46440;
 567     }
 568     if (!pdo->has_latency) {
 569         pdo->has_latency = true;
 570         pdo->latency = 15000;
 571     }
 572     return 1;
 573 }
 574
 575 /* common */
 576 static void *qpa_conn_init(const char *server)
 577 {
 578     PAConnection *c = g_malloc0(sizeof(PAConnection));
 579     QTAILQ_INSERT_TAIL(&pa_conns, c, list);
 580
 581     c->mainloop = pa_threaded_mainloop_new();
 582     if (!c->mainloop) {
 583         goto fail;
 584     }
 585
 586     c->context = pa_context_new(pa_threaded_mainloop_get_api(c->mainloop),
 587                                 server);
 588     if (!c->context) {
 589         goto fail;
 590     }
 591
 592     pa_context_set_state_callback(c->context, context_state_cb, c);
 593
 594     if (pa_context_connect(c->context, server, 0, NULL) < 0) {
 595         qpa_logerr(pa_context_errno(c->context),
 596                    "pa_context_connect() failed\n");
 597         goto fail;
 598     }
 599
 600     pa_threaded_mainloop_lock(c->mainloop);
 601
 602     if (pa_threaded_mainloop_start(c->mainloop) < 0) {
 603         goto unlock_and_fail;
 604     }
 605
 606     for (;;) {
 607         pa_context_state_t state;
 608
 609         state = pa_context_get_state(c->context);
 610
 611         if (state == PA_CONTEXT_READY) {
 612             break;
 613         }
 614
 615         if (!PA_CONTEXT_IS_GOOD(state)) {
 616             qpa_logerr(pa_context_errno(c->context),
 617                        "Wrong context state\n");
 618             goto unlock_and_fail;
 619         }
 620
 621         /* Wait until the context is ready */
 622         pa_threaded_mainloop_wait(c->mainloop);
 623     }
 624
 625     pa_threaded_mainloop_unlock(c->mainloop);
 626     return c;
 627
 628 unlock_and_fail:
 629     pa_threaded_mainloop_unlock(c->mainloop);
 630 fail:
 631     AUD_log (AUDIO_CAP, "Failed to initialize PA context");
 632     qpa_conn_fini(c);
 633     return NULL;
 634 }
 635
 636 static void *qpa_audio_init(Audiodev *dev)
 637 {
 638     paaudio *g;
 639     AudiodevPaOptions *popts = &dev->u.pa;
 640     const char *server;
 641     PAConnection *c;
 642
 643     assert(dev->driver == AUDIODEV_DRIVER_PA);
 644
 645     if (!popts->has_server) {
 646         char pidfile[64];
 647         char *runtime;
 648         struct stat st;
 649
 650         runtime = getenv("XDG_RUNTIME_DIR");
 651         if (!runtime) {
 652             return NULL;
 653         }
 654         snprintf(pidfile, sizeof(pidfile), "%s/pulse/pid", runtime);
 655         if (stat(pidfile, &st) != 0) {
 656             return NULL;
 657         }
 658     }
 659
 660     if (!qpa_validate_per_direction_opts(dev, popts->in)) {
 661         return NULL;
 662     }
 663     if (!qpa_validate_per_direction_opts(dev, popts->out)) {
 664         return NULL;
 665     }
 666
 667     g = g_malloc0(sizeof(paaudio));
 668     server = popts->has_server ? popts->server : NULL;
 669
 670     g->dev = dev;
 671
 672     QTAILQ_FOREACH(c, &pa_conns, list) {
 673         if (server == NULL || c->server == NULL ?
 674             server == c->server :
 675             strcmp(server, c->server) == 0) {
 676             g->conn = c;
 677             break;
 678         }
 679     }
 680     if (!g->conn) {
 681         g->conn = qpa_conn_init(server);
 682     }
 683     if (!g->conn) {
 684         g_free(g);
 685         return NULL;
 686     }
 687
 688     ++g->conn->refcount;
 689     return g;
 690 }
 691
 692 static void qpa_conn_fini(PAConnection *c)
 693 {
 694     if (c->mainloop) {
 695         pa_threaded_mainloop_stop(c->mainloop);
 696     }
 697
 698     if (c->context) {
 699         pa_context_disconnect(c->context);
 700         pa_context_unref(c->context);
 701     }
 702
 703     if (c->mainloop) {
 704         pa_threaded_mainloop_free(c->mainloop);
 705     }
 706
 707     QTAILQ_REMOVE(&pa_conns, c, list);
 708     g_free(c);
 709 }
 710
 711 static void qpa_audio_fini (void *opaque)
 712 {
 713     paaudio *g = opaque;
 714     PAConnection *c = g->conn;
 715
 716     if (--c->refcount == 0) {
 717         qpa_conn_fini(c);
 718     }
 719
 720     g_free(g);
 721 }
 722
 723 static struct audio_pcm_ops qpa_pcm_ops = {
 724     .init_out = qpa_init_out,
 725     .fini_out = qpa_fini_out,
 726     .write    = qpa_write,
 727     .ctl_out  = qpa_ctl_out,
 728
 729     .init_in  = qpa_init_in,
 730     .fini_in  = qpa_fini_in,
 731     .read     = qpa_read,
 732     .ctl_in   = qpa_ctl_in
 733 };
 734
 735 static struct audio_driver pa_audio_driver = {
 736     .name           = "pa",
 737     .descr          = "http://www.pulseaudio.org/",
 738     .init           = qpa_audio_init,
 739     .fini           = qpa_audio_fini,
 740     .pcm_ops        = &qpa_pcm_ops,
 741     .can_be_default = 1,
 742     .max_voices_out = INT_MAX,
 743     .max_voices_in  = INT_MAX,
 744     .voice_size_out = sizeof (PAVoiceOut),
 745     .voice_size_in  = sizeof (PAVoiceIn),
 746     .ctl_caps       = VOICE_VOLUME_CAP
 747 };
 748
 749 static void register_audio_pa(void)
 750 {
 751     audio_driver_register(&pa_audio_driver);
 752 }
 753 type_init(register_audio_pa);