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