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