1 /* 2 * QEMU ALSA audio driver 3 * 4 * Copyright (c) 2005 Vassili Karpov (malc) 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a copy 7 * of this software and associated documentation files (the "Software"), to deal 8 * in the Software without restriction, including without limitation the rights 9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10 * copies of the Software, and to permit persons to whom the Software is 11 * furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice shall be included in 14 * all copies or substantial portions of the Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 22 * THE SOFTWARE. 23 */ 24 #include <alsa/asoundlib.h> 25 #include "qemu-common.h" 26 #include "qemu-char.h" 27 #include "audio.h" 28 29 #if QEMU_GNUC_PREREQ(4, 3) 30 #pragma GCC diagnostic ignored "-Waddress" 31 #endif 32 33 #define AUDIO_CAP "alsa" 34 #include "audio_int.h" 35 36 struct pollhlp { 37 snd_pcm_t *handle; 38 struct pollfd *pfds; 39 int count; 40 int mask; 41 }; 42 43 typedef struct ALSAVoiceOut { 44 HWVoiceOut hw; 45 int wpos; 46 int pending; 47 void *pcm_buf; 48 snd_pcm_t *handle; 49 struct pollhlp pollhlp; 50 } ALSAVoiceOut; 51 52 typedef struct ALSAVoiceIn { 53 HWVoiceIn hw; 54 snd_pcm_t *handle; 55 void *pcm_buf; 56 struct pollhlp pollhlp; 57 } ALSAVoiceIn; 58 59 static struct { 60 int size_in_usec_in; 61 int size_in_usec_out; 62 const char *pcm_name_in; 63 const char *pcm_name_out; 64 unsigned int buffer_size_in; 65 unsigned int period_size_in; 66 unsigned int buffer_size_out; 67 unsigned int period_size_out; 68 unsigned int threshold; 69 70 int buffer_size_in_overridden; 71 int period_size_in_overridden; 72 73 int buffer_size_out_overridden; 74 int period_size_out_overridden; 75 int verbose; 76 } conf = { 77 .buffer_size_out = 4096, 78 .period_size_out = 1024, 79 .pcm_name_out = "default", 80 .pcm_name_in = "default", 81 }; 82 83 struct alsa_params_req { 84 int freq; 85 snd_pcm_format_t fmt; 86 int nchannels; 87 int size_in_usec; 88 int override_mask; 89 unsigned int buffer_size; 90 unsigned int period_size; 91 }; 92 93 struct alsa_params_obt { 94 int freq; 95 audfmt_e fmt; 96 int endianness; 97 int nchannels; 98 snd_pcm_uframes_t samples; 99 }; 100 101 static void GCC_FMT_ATTR (2, 3) alsa_logerr (int err, const char *fmt, ...) 102 { 103 va_list ap; 104 105 va_start (ap, fmt); 106 AUD_vlog (AUDIO_CAP, fmt, ap); 107 va_end (ap); 108 109 AUD_log (AUDIO_CAP, "Reason: %s\n", snd_strerror (err)); 110 } 111 112 static void GCC_FMT_ATTR (3, 4) alsa_logerr2 ( 113 int err, 114 const char *typ, 115 const char *fmt, 116 ... 117 ) 118 { 119 va_list ap; 120 121 AUD_log (AUDIO_CAP, "Could not initialize %s\n", typ); 122 123 va_start (ap, fmt); 124 AUD_vlog (AUDIO_CAP, fmt, ap); 125 va_end (ap); 126 127 AUD_log (AUDIO_CAP, "Reason: %s\n", snd_strerror (err)); 128 } 129 130 static void alsa_fini_poll (struct pollhlp *hlp) 131 { 132 int i; 133 struct pollfd *pfds = hlp->pfds; 134 135 if (pfds) { 136 for (i = 0; i < hlp->count; ++i) { 137 qemu_set_fd_handler (pfds[i].fd, NULL, NULL, NULL); 138 } 139 qemu_free (pfds); 140 } 141 hlp->pfds = NULL; 142 hlp->count = 0; 143 hlp->handle = NULL; 144 } 145 146 static void alsa_anal_close1 (snd_pcm_t **handlep) 147 { 148 int err = snd_pcm_close (*handlep); 149 if (err) { 150 alsa_logerr (err, "Failed to close PCM handle %p\n", *handlep); 151 } 152 *handlep = NULL; 153 } 154 155 static void alsa_anal_close (snd_pcm_t **handlep, struct pollhlp *hlp) 156 { 157 alsa_fini_poll (hlp); 158 alsa_anal_close1 (handlep); 159 } 160 161 static int alsa_recover (snd_pcm_t *handle) 162 { 163 int err = snd_pcm_prepare (handle); 164 if (err < 0) { 165 alsa_logerr (err, "Failed to prepare handle %p\n", handle); 166 return -1; 167 } 168 return 0; 169 } 170 171 static int alsa_resume (snd_pcm_t *handle) 172 { 173 int err = snd_pcm_resume (handle); 174 if (err < 0) { 175 alsa_logerr (err, "Failed to resume handle %p\n", handle); 176 return -1; 177 } 178 return 0; 179 } 180 181 static void alsa_poll_handler (void *opaque) 182 { 183 int err, count; 184 snd_pcm_state_t state; 185 struct pollhlp *hlp = opaque; 186 unsigned short revents; 187 188 count = poll (hlp->pfds, hlp->count, 0); 189 if (count < 0) { 190 dolog ("alsa_poll_handler: poll %s\n", strerror (errno)); 191 return; 192 } 193 194 if (!count) { 195 return; 196 } 197 198 /* XXX: ALSA example uses initial count, not the one returned by 199 poll, correct? */ 200 err = snd_pcm_poll_descriptors_revents (hlp->handle, hlp->pfds, 201 hlp->count, &revents); 202 if (err < 0) { 203 alsa_logerr (err, "snd_pcm_poll_descriptors_revents"); 204 return; 205 } 206 207 if (!(revents & hlp->mask)) { 208 if (conf.verbose) { 209 dolog ("revents = %d\n", revents); 210 } 211 return; 212 } 213 214 state = snd_pcm_state (hlp->handle); 215 switch (state) { 216 case SND_PCM_STATE_SETUP: 217 alsa_recover (hlp->handle); 218 break; 219 220 case SND_PCM_STATE_XRUN: 221 alsa_recover (hlp->handle); 222 break; 223 224 case SND_PCM_STATE_SUSPENDED: 225 alsa_resume (hlp->handle); 226 break; 227 228 case SND_PCM_STATE_PREPARED: 229 audio_run ("alsa run (prepared)"); 230 break; 231 232 case SND_PCM_STATE_RUNNING: 233 audio_run ("alsa run (running)"); 234 break; 235 236 default: 237 dolog ("Unexpected state %d\n", state); 238 } 239 } 240 241 static int alsa_poll_helper (snd_pcm_t *handle, struct pollhlp *hlp, int mask) 242 { 243 int i, count, err; 244 struct pollfd *pfds; 245 246 count = snd_pcm_poll_descriptors_count (handle); 247 if (count <= 0) { 248 dolog ("Could not initialize poll mode\n" 249 "Invalid number of poll descriptors %d\n", count); 250 return -1; 251 } 252 253 pfds = audio_calloc ("alsa_poll_helper", count, sizeof (*pfds)); 254 if (!pfds) { 255 dolog ("Could not initialize poll mode\n"); 256 return -1; 257 } 258 259 err = snd_pcm_poll_descriptors (handle, pfds, count); 260 if (err < 0) { 261 alsa_logerr (err, "Could not initialize poll mode\n" 262 "Could not obtain poll descriptors\n"); 263 qemu_free (pfds); 264 return -1; 265 } 266 267 for (i = 0; i < count; ++i) { 268 if (pfds[i].events & POLLIN) { 269 err = qemu_set_fd_handler (pfds[i].fd, alsa_poll_handler, 270 NULL, hlp); 271 } 272 if (pfds[i].events & POLLOUT) { 273 if (conf.verbose) { 274 dolog ("POLLOUT %d %d\n", i, pfds[i].fd); 275 } 276 err = qemu_set_fd_handler (pfds[i].fd, NULL, 277 alsa_poll_handler, hlp); 278 } 279 if (conf.verbose) { 280 dolog ("Set handler events=%#x index=%d fd=%d err=%d\n", 281 pfds[i].events, i, pfds[i].fd, err); 282 } 283 284 if (err) { 285 dolog ("Failed to set handler events=%#x index=%d fd=%d err=%d\n", 286 pfds[i].events, i, pfds[i].fd, err); 287 288 while (i--) { 289 qemu_set_fd_handler (pfds[i].fd, NULL, NULL, NULL); 290 } 291 qemu_free (pfds); 292 return -1; 293 } 294 } 295 hlp->pfds = pfds; 296 hlp->count = count; 297 hlp->handle = handle; 298 hlp->mask = mask; 299 return 0; 300 } 301 302 static int alsa_poll_out (HWVoiceOut *hw) 303 { 304 ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw; 305 306 return alsa_poll_helper (alsa->handle, &alsa->pollhlp, POLLOUT); 307 } 308 309 static int alsa_poll_in (HWVoiceIn *hw) 310 { 311 ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw; 312 313 return alsa_poll_helper (alsa->handle, &alsa->pollhlp, POLLIN); 314 } 315 316 static int alsa_write (SWVoiceOut *sw, void *buf, int len) 317 { 318 return audio_pcm_sw_write (sw, buf, len); 319 } 320 321 static snd_pcm_format_t aud_to_alsafmt (audfmt_e fmt) 322 { 323 switch (fmt) { 324 case AUD_FMT_S8: 325 return SND_PCM_FORMAT_S8; 326 327 case AUD_FMT_U8: 328 return SND_PCM_FORMAT_U8; 329 330 case AUD_FMT_S16: 331 return SND_PCM_FORMAT_S16_LE; 332 333 case AUD_FMT_U16: 334 return SND_PCM_FORMAT_U16_LE; 335 336 case AUD_FMT_S32: 337 return SND_PCM_FORMAT_S32_LE; 338 339 case AUD_FMT_U32: 340 return SND_PCM_FORMAT_U32_LE; 341 342 default: 343 dolog ("Internal logic error: Bad audio format %d\n", fmt); 344 #ifdef DEBUG_AUDIO 345 abort (); 346 #endif 347 return SND_PCM_FORMAT_U8; 348 } 349 } 350 351 static int alsa_to_audfmt (snd_pcm_format_t alsafmt, audfmt_e *fmt, 352 int *endianness) 353 { 354 switch (alsafmt) { 355 case SND_PCM_FORMAT_S8: 356 *endianness = 0; 357 *fmt = AUD_FMT_S8; 358 break; 359 360 case SND_PCM_FORMAT_U8: 361 *endianness = 0; 362 *fmt = AUD_FMT_U8; 363 break; 364 365 case SND_PCM_FORMAT_S16_LE: 366 *endianness = 0; 367 *fmt = AUD_FMT_S16; 368 break; 369 370 case SND_PCM_FORMAT_U16_LE: 371 *endianness = 0; 372 *fmt = AUD_FMT_U16; 373 break; 374 375 case SND_PCM_FORMAT_S16_BE: 376 *endianness = 1; 377 *fmt = AUD_FMT_S16; 378 break; 379 380 case SND_PCM_FORMAT_U16_BE: 381 *endianness = 1; 382 *fmt = AUD_FMT_U16; 383 break; 384 385 case SND_PCM_FORMAT_S32_LE: 386 *endianness = 0; 387 *fmt = AUD_FMT_S32; 388 break; 389 390 case SND_PCM_FORMAT_U32_LE: 391 *endianness = 0; 392 *fmt = AUD_FMT_U32; 393 break; 394 395 case SND_PCM_FORMAT_S32_BE: 396 *endianness = 1; 397 *fmt = AUD_FMT_S32; 398 break; 399 400 case SND_PCM_FORMAT_U32_BE: 401 *endianness = 1; 402 *fmt = AUD_FMT_U32; 403 break; 404 405 default: 406 dolog ("Unrecognized audio format %d\n", alsafmt); 407 return -1; 408 } 409 410 return 0; 411 } 412 413 static void alsa_dump_info (struct alsa_params_req *req, 414 struct alsa_params_obt *obt, 415 snd_pcm_format_t obtfmt) 416 { 417 dolog ("parameter | requested value | obtained value\n"); 418 dolog ("format | %10d | %10d\n", req->fmt, obtfmt); 419 dolog ("channels | %10d | %10d\n", 420 req->nchannels, obt->nchannels); 421 dolog ("frequency | %10d | %10d\n", req->freq, obt->freq); 422 dolog ("============================================\n"); 423 dolog ("requested: buffer size %d period size %d\n", 424 req->buffer_size, req->period_size); 425 dolog ("obtained: samples %ld\n", obt->samples); 426 } 427 428 static void alsa_set_threshold (snd_pcm_t *handle, snd_pcm_uframes_t threshold) 429 { 430 int err; 431 snd_pcm_sw_params_t *sw_params; 432 433 snd_pcm_sw_params_alloca (&sw_params); 434 435 err = snd_pcm_sw_params_current (handle, sw_params); 436 if (err < 0) { 437 dolog ("Could not fully initialize DAC\n"); 438 alsa_logerr (err, "Failed to get current software parameters\n"); 439 return; 440 } 441 442 err = snd_pcm_sw_params_set_start_threshold (handle, sw_params, threshold); 443 if (err < 0) { 444 dolog ("Could not fully initialize DAC\n"); 445 alsa_logerr (err, "Failed to set software threshold to %ld\n", 446 threshold); 447 return; 448 } 449 450 err = snd_pcm_sw_params (handle, sw_params); 451 if (err < 0) { 452 dolog ("Could not fully initialize DAC\n"); 453 alsa_logerr (err, "Failed to set software parameters\n"); 454 return; 455 } 456 } 457 458 static int alsa_open (int in, struct alsa_params_req *req, 459 struct alsa_params_obt *obt, snd_pcm_t **handlep) 460 { 461 snd_pcm_t *handle; 462 snd_pcm_hw_params_t *hw_params; 463 int err; 464 int size_in_usec; 465 unsigned int freq, nchannels; 466 const char *pcm_name = in ? conf.pcm_name_in : conf.pcm_name_out; 467 snd_pcm_uframes_t obt_buffer_size; 468 const char *typ = in ? "ADC" : "DAC"; 469 snd_pcm_format_t obtfmt; 470 471 freq = req->freq; 472 nchannels = req->nchannels; 473 size_in_usec = req->size_in_usec; 474 475 snd_pcm_hw_params_alloca (&hw_params); 476 477 err = snd_pcm_open ( 478 &handle, 479 pcm_name, 480 in ? SND_PCM_STREAM_CAPTURE : SND_PCM_STREAM_PLAYBACK, 481 SND_PCM_NONBLOCK 482 ); 483 if (err < 0) { 484 alsa_logerr2 (err, typ, "Failed to open `%s':\n", pcm_name); 485 return -1; 486 } 487 488 err = snd_pcm_hw_params_any (handle, hw_params); 489 if (err < 0) { 490 alsa_logerr2 (err, typ, "Failed to initialize hardware parameters\n"); 491 goto err; 492 } 493 494 err = snd_pcm_hw_params_set_access ( 495 handle, 496 hw_params, 497 SND_PCM_ACCESS_RW_INTERLEAVED 498 ); 499 if (err < 0) { 500 alsa_logerr2 (err, typ, "Failed to set access type\n"); 501 goto err; 502 } 503 504 err = snd_pcm_hw_params_set_format (handle, hw_params, req->fmt); 505 if (err < 0 && conf.verbose) { 506 alsa_logerr2 (err, typ, "Failed to set format %d\n", req->fmt); 507 } 508 509 err = snd_pcm_hw_params_set_rate_near (handle, hw_params, &freq, 0); 510 if (err < 0) { 511 alsa_logerr2 (err, typ, "Failed to set frequency %d\n", req->freq); 512 goto err; 513 } 514 515 err = snd_pcm_hw_params_set_channels_near ( 516 handle, 517 hw_params, 518 &nchannels 519 ); 520 if (err < 0) { 521 alsa_logerr2 (err, typ, "Failed to set number of channels %d\n", 522 req->nchannels); 523 goto err; 524 } 525 526 if (nchannels != 1 && nchannels != 2) { 527 alsa_logerr2 (err, typ, 528 "Can not handle obtained number of channels %d\n", 529 nchannels); 530 goto err; 531 } 532 533 if (req->buffer_size) { 534 unsigned long obt; 535 536 if (size_in_usec) { 537 int dir = 0; 538 unsigned int btime = req->buffer_size; 539 540 err = snd_pcm_hw_params_set_buffer_time_near ( 541 handle, 542 hw_params, 543 &btime, 544 &dir 545 ); 546 obt = btime; 547 } 548 else { 549 snd_pcm_uframes_t bsize = req->buffer_size; 550 551 err = snd_pcm_hw_params_set_buffer_size_near ( 552 handle, 553 hw_params, 554 &bsize 555 ); 556 obt = bsize; 557 } 558 if (err < 0) { 559 alsa_logerr2 (err, typ, "Failed to set buffer %s to %d\n", 560 size_in_usec ? "time" : "size", req->buffer_size); 561 goto err; 562 } 563 564 if ((req->override_mask & 2) && (obt - req->buffer_size)) 565 dolog ("Requested buffer %s %u was rejected, using %lu\n", 566 size_in_usec ? "time" : "size", req->buffer_size, obt); 567 } 568 569 if (req->period_size) { 570 unsigned long obt; 571 572 if (size_in_usec) { 573 int dir = 0; 574 unsigned int ptime = req->period_size; 575 576 err = snd_pcm_hw_params_set_period_time_near ( 577 handle, 578 hw_params, 579 &ptime, 580 &dir 581 ); 582 obt = ptime; 583 } 584 else { 585 int dir = 0; 586 snd_pcm_uframes_t psize = req->period_size; 587 588 err = snd_pcm_hw_params_set_period_size_near ( 589 handle, 590 hw_params, 591 &psize, 592 &dir 593 ); 594 obt = psize; 595 } 596 597 if (err < 0) { 598 alsa_logerr2 (err, typ, "Failed to set period %s to %d\n", 599 size_in_usec ? "time" : "size", req->period_size); 600 goto err; 601 } 602 603 if (((req->override_mask & 1) && (obt - req->period_size))) 604 dolog ("Requested period %s %u was rejected, using %lu\n", 605 size_in_usec ? "time" : "size", req->period_size, obt); 606 } 607 608 err = snd_pcm_hw_params (handle, hw_params); 609 if (err < 0) { 610 alsa_logerr2 (err, typ, "Failed to apply audio parameters\n"); 611 goto err; 612 } 613 614 err = snd_pcm_hw_params_get_buffer_size (hw_params, &obt_buffer_size); 615 if (err < 0) { 616 alsa_logerr2 (err, typ, "Failed to get buffer size\n"); 617 goto err; 618 } 619 620 err = snd_pcm_hw_params_get_format (hw_params, &obtfmt); 621 if (err < 0) { 622 alsa_logerr2 (err, typ, "Failed to get format\n"); 623 goto err; 624 } 625 626 if (alsa_to_audfmt (obtfmt, &obt->fmt, &obt->endianness)) { 627 dolog ("Invalid format was returned %d\n", obtfmt); 628 goto err; 629 } 630 631 err = snd_pcm_prepare (handle); 632 if (err < 0) { 633 alsa_logerr2 (err, typ, "Could not prepare handle %p\n", handle); 634 goto err; 635 } 636 637 if (!in && conf.threshold) { 638 snd_pcm_uframes_t threshold; 639 int bytes_per_sec; 640 641 bytes_per_sec = freq << (nchannels == 2); 642 643 switch (obt->fmt) { 644 case AUD_FMT_S8: 645 case AUD_FMT_U8: 646 break; 647 648 case AUD_FMT_S16: 649 case AUD_FMT_U16: 650 bytes_per_sec <<= 1; 651 break; 652 653 case AUD_FMT_S32: 654 case AUD_FMT_U32: 655 bytes_per_sec <<= 2; 656 break; 657 } 658 659 threshold = (conf.threshold * bytes_per_sec) / 1000; 660 alsa_set_threshold (handle, threshold); 661 } 662 663 obt->nchannels = nchannels; 664 obt->freq = freq; 665 obt->samples = obt_buffer_size; 666 667 *handlep = handle; 668 669 if (conf.verbose && 670 (obtfmt != req->fmt || 671 obt->nchannels != req->nchannels || 672 obt->freq != req->freq)) { 673 dolog ("Audio parameters for %s\n", typ); 674 alsa_dump_info (req, obt, obtfmt); 675 } 676 677 #ifdef DEBUG 678 alsa_dump_info (req, obt, obtfmt); 679 #endif 680 return 0; 681 682 err: 683 alsa_anal_close1 (&handle); 684 return -1; 685 } 686 687 static snd_pcm_sframes_t alsa_get_avail (snd_pcm_t *handle) 688 { 689 snd_pcm_sframes_t avail; 690 691 avail = snd_pcm_avail_update (handle); 692 if (avail < 0) { 693 if (avail == -EPIPE) { 694 if (!alsa_recover (handle)) { 695 avail = snd_pcm_avail_update (handle); 696 } 697 } 698 699 if (avail < 0) { 700 alsa_logerr (avail, 701 "Could not obtain number of available frames\n"); 702 return -1; 703 } 704 } 705 706 return avail; 707 } 708 709 static void alsa_write_pending (ALSAVoiceOut *alsa) 710 { 711 HWVoiceOut *hw = &alsa->hw; 712 713 while (alsa->pending) { 714 int left_till_end_samples = hw->samples - alsa->wpos; 715 int len = audio_MIN (alsa->pending, left_till_end_samples); 716 char *src = advance (alsa->pcm_buf, alsa->wpos << hw->info.shift); 717 718 while (len) { 719 snd_pcm_sframes_t written; 720 721 written = snd_pcm_writei (alsa->handle, src, len); 722 723 if (written <= 0) { 724 switch (written) { 725 case 0: 726 if (conf.verbose) { 727 dolog ("Failed to write %d frames (wrote zero)\n", len); 728 } 729 return; 730 731 case -EPIPE: 732 if (alsa_recover (alsa->handle)) { 733 alsa_logerr (written, "Failed to write %d frames\n", 734 len); 735 return; 736 } 737 if (conf.verbose) { 738 dolog ("Recovering from playback xrun\n"); 739 } 740 continue; 741 742 case -ESTRPIPE: 743 /* stream is suspended and waiting for an 744 application recovery */ 745 if (alsa_resume (alsa->handle)) { 746 alsa_logerr (written, "Failed to write %d frames\n", 747 len); 748 return; 749 } 750 if (conf.verbose) { 751 dolog ("Resuming suspended output stream\n"); 752 } 753 continue; 754 755 case -EAGAIN: 756 return; 757 758 default: 759 alsa_logerr (written, "Failed to write %d frames from %p\n", 760 len, src); 761 return; 762 } 763 } 764 765 alsa->wpos = (alsa->wpos + written) % hw->samples; 766 alsa->pending -= written; 767 len -= written; 768 } 769 } 770 } 771 772 static int alsa_run_out (HWVoiceOut *hw, int live) 773 { 774 ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw; 775 int decr; 776 snd_pcm_sframes_t avail; 777 778 avail = alsa_get_avail (alsa->handle); 779 if (avail < 0) { 780 dolog ("Could not get number of available playback frames\n"); 781 return 0; 782 } 783 784 decr = audio_MIN (live, avail); 785 decr = audio_pcm_hw_clip_out (hw, alsa->pcm_buf, decr, alsa->pending); 786 alsa->pending += decr; 787 alsa_write_pending (alsa); 788 return decr; 789 } 790 791 static void alsa_fini_out (HWVoiceOut *hw) 792 { 793 ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw; 794 795 ldebug ("alsa_fini\n"); 796 alsa_anal_close (&alsa->handle, &alsa->pollhlp); 797 798 if (alsa->pcm_buf) { 799 qemu_free (alsa->pcm_buf); 800 alsa->pcm_buf = NULL; 801 } 802 } 803 804 static int alsa_init_out (HWVoiceOut *hw, struct audsettings *as) 805 { 806 ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw; 807 struct alsa_params_req req; 808 struct alsa_params_obt obt; 809 snd_pcm_t *handle; 810 struct audsettings obt_as; 811 812 req.fmt = aud_to_alsafmt (as->fmt); 813 req.freq = as->freq; 814 req.nchannels = as->nchannels; 815 req.period_size = conf.period_size_out; 816 req.buffer_size = conf.buffer_size_out; 817 req.size_in_usec = conf.size_in_usec_out; 818 req.override_mask = 819 (conf.period_size_out_overridden ? 1 : 0) | 820 (conf.buffer_size_out_overridden ? 2 : 0); 821 822 if (alsa_open (0, &req, &obt, &handle)) { 823 return -1; 824 } 825 826 obt_as.freq = obt.freq; 827 obt_as.nchannels = obt.nchannels; 828 obt_as.fmt = obt.fmt; 829 obt_as.endianness = obt.endianness; 830 831 audio_pcm_init_info (&hw->info, &obt_as); 832 hw->samples = obt.samples; 833 834 alsa->pcm_buf = audio_calloc (AUDIO_FUNC, obt.samples, 1 << hw->info.shift); 835 if (!alsa->pcm_buf) { 836 dolog ("Could not allocate DAC buffer (%d samples, each %d bytes)\n", 837 hw->samples, 1 << hw->info.shift); 838 alsa_anal_close1 (&handle); 839 return -1; 840 } 841 842 alsa->handle = handle; 843 return 0; 844 } 845 846 #define VOICE_CTL_PAUSE 0 847 #define VOICE_CTL_PREPARE 1 848 #define VOICE_CTL_START 2 849 850 static int alsa_voice_ctl (snd_pcm_t *handle, const char *typ, int ctl) 851 { 852 int err; 853 854 if (ctl == VOICE_CTL_PAUSE) { 855 err = snd_pcm_drop (handle); 856 if (err < 0) { 857 alsa_logerr (err, "Could not stop %s\n", typ); 858 return -1; 859 } 860 } 861 else { 862 err = snd_pcm_prepare (handle); 863 if (err < 0) { 864 alsa_logerr (err, "Could not prepare handle for %s\n", typ); 865 return -1; 866 } 867 if (ctl == VOICE_CTL_START) { 868 err = snd_pcm_start(handle); 869 if (err < 0) { 870 alsa_logerr (err, "Could not start handle for %s\n", typ); 871 return -1; 872 } 873 } 874 } 875 876 return 0; 877 } 878 879 static int alsa_ctl_out (HWVoiceOut *hw, int cmd, ...) 880 { 881 ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw; 882 883 switch (cmd) { 884 case VOICE_ENABLE: 885 { 886 va_list ap; 887 int poll_mode; 888 889 va_start (ap, cmd); 890 poll_mode = va_arg (ap, int); 891 va_end (ap); 892 893 ldebug ("enabling voice\n"); 894 if (poll_mode && alsa_poll_out (hw)) { 895 poll_mode = 0; 896 } 897 hw->poll_mode = poll_mode; 898 return alsa_voice_ctl (alsa->handle, "playback", VOICE_CTL_PREPARE); 899 } 900 901 case VOICE_DISABLE: 902 ldebug ("disabling voice\n"); 903 if (hw->poll_mode) { 904 hw->poll_mode = 0; 905 alsa_fini_poll (&alsa->pollhlp); 906 } 907 return alsa_voice_ctl (alsa->handle, "playback", VOICE_CTL_PAUSE); 908 } 909 910 return -1; 911 } 912 913 static int alsa_init_in (HWVoiceIn *hw, struct audsettings *as) 914 { 915 ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw; 916 struct alsa_params_req req; 917 struct alsa_params_obt obt; 918 snd_pcm_t *handle; 919 struct audsettings obt_as; 920 921 req.fmt = aud_to_alsafmt (as->fmt); 922 req.freq = as->freq; 923 req.nchannels = as->nchannels; 924 req.period_size = conf.period_size_in; 925 req.buffer_size = conf.buffer_size_in; 926 req.size_in_usec = conf.size_in_usec_in; 927 req.override_mask = 928 (conf.period_size_in_overridden ? 1 : 0) | 929 (conf.buffer_size_in_overridden ? 2 : 0); 930 931 if (alsa_open (1, &req, &obt, &handle)) { 932 return -1; 933 } 934 935 obt_as.freq = obt.freq; 936 obt_as.nchannels = obt.nchannels; 937 obt_as.fmt = obt.fmt; 938 obt_as.endianness = obt.endianness; 939 940 audio_pcm_init_info (&hw->info, &obt_as); 941 hw->samples = obt.samples; 942 943 alsa->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift); 944 if (!alsa->pcm_buf) { 945 dolog ("Could not allocate ADC buffer (%d samples, each %d bytes)\n", 946 hw->samples, 1 << hw->info.shift); 947 alsa_anal_close1 (&handle); 948 return -1; 949 } 950 951 alsa->handle = handle; 952 return 0; 953 } 954 955 static void alsa_fini_in (HWVoiceIn *hw) 956 { 957 ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw; 958 959 alsa_anal_close (&alsa->handle, &alsa->pollhlp); 960 961 if (alsa->pcm_buf) { 962 qemu_free (alsa->pcm_buf); 963 alsa->pcm_buf = NULL; 964 } 965 } 966 967 static int alsa_run_in (HWVoiceIn *hw) 968 { 969 ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw; 970 int hwshift = hw->info.shift; 971 int i; 972 int live = audio_pcm_hw_get_live_in (hw); 973 int dead = hw->samples - live; 974 int decr; 975 struct { 976 int add; 977 int len; 978 } bufs[2] = { 979 { .add = hw->wpos, .len = 0 }, 980 { .add = 0, .len = 0 } 981 }; 982 snd_pcm_sframes_t avail; 983 snd_pcm_uframes_t read_samples = 0; 984 985 if (!dead) { 986 return 0; 987 } 988 989 avail = alsa_get_avail (alsa->handle); 990 if (avail < 0) { 991 dolog ("Could not get number of captured frames\n"); 992 return 0; 993 } 994 995 if (!avail) { 996 snd_pcm_state_t state; 997 998 state = snd_pcm_state (alsa->handle); 999 switch (state) { 1000 case SND_PCM_STATE_PREPARED: 1001 avail = hw->samples; 1002 break; 1003 case SND_PCM_STATE_SUSPENDED: 1004 /* stream is suspended and waiting for an application recovery */ 1005 if (alsa_resume (alsa->handle)) { 1006 dolog ("Failed to resume suspended input stream\n"); 1007 return 0; 1008 } 1009 if (conf.verbose) { 1010 dolog ("Resuming suspended input stream\n"); 1011 } 1012 break; 1013 default: 1014 if (conf.verbose) { 1015 dolog ("No frames available and ALSA state is %d\n", state); 1016 } 1017 return 0; 1018 } 1019 } 1020 1021 decr = audio_MIN (dead, avail); 1022 if (!decr) { 1023 return 0; 1024 } 1025 1026 if (hw->wpos + decr > hw->samples) { 1027 bufs[0].len = (hw->samples - hw->wpos); 1028 bufs[1].len = (decr - (hw->samples - hw->wpos)); 1029 } 1030 else { 1031 bufs[0].len = decr; 1032 } 1033 1034 for (i = 0; i < 2; ++i) { 1035 void *src; 1036 struct st_sample *dst; 1037 snd_pcm_sframes_t nread; 1038 snd_pcm_uframes_t len; 1039 1040 len = bufs[i].len; 1041 1042 src = advance (alsa->pcm_buf, bufs[i].add << hwshift); 1043 dst = hw->conv_buf + bufs[i].add; 1044 1045 while (len) { 1046 nread = snd_pcm_readi (alsa->handle, src, len); 1047 1048 if (nread <= 0) { 1049 switch (nread) { 1050 case 0: 1051 if (conf.verbose) { 1052 dolog ("Failed to read %ld frames (read zero)\n", len); 1053 } 1054 goto exit; 1055 1056 case -EPIPE: 1057 if (alsa_recover (alsa->handle)) { 1058 alsa_logerr (nread, "Failed to read %ld frames\n", len); 1059 goto exit; 1060 } 1061 if (conf.verbose) { 1062 dolog ("Recovering from capture xrun\n"); 1063 } 1064 continue; 1065 1066 case -EAGAIN: 1067 goto exit; 1068 1069 default: 1070 alsa_logerr ( 1071 nread, 1072 "Failed to read %ld frames from %p\n", 1073 len, 1074 src 1075 ); 1076 goto exit; 1077 } 1078 } 1079 1080 hw->conv (dst, src, nread, &nominal_volume); 1081 1082 src = advance (src, nread << hwshift); 1083 dst += nread; 1084 1085 read_samples += nread; 1086 len -= nread; 1087 } 1088 } 1089 1090 exit: 1091 hw->wpos = (hw->wpos + read_samples) % hw->samples; 1092 return read_samples; 1093 } 1094 1095 static int alsa_read (SWVoiceIn *sw, void *buf, int size) 1096 { 1097 return audio_pcm_sw_read (sw, buf, size); 1098 } 1099 1100 static int alsa_ctl_in (HWVoiceIn *hw, int cmd, ...) 1101 { 1102 ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw; 1103 1104 switch (cmd) { 1105 case VOICE_ENABLE: 1106 { 1107 va_list ap; 1108 int poll_mode; 1109 1110 va_start (ap, cmd); 1111 poll_mode = va_arg (ap, int); 1112 va_end (ap); 1113 1114 ldebug ("enabling voice\n"); 1115 if (poll_mode && alsa_poll_in (hw)) { 1116 poll_mode = 0; 1117 } 1118 hw->poll_mode = poll_mode; 1119 1120 return alsa_voice_ctl (alsa->handle, "capture", VOICE_CTL_START); 1121 } 1122 1123 case VOICE_DISABLE: 1124 ldebug ("disabling voice\n"); 1125 if (hw->poll_mode) { 1126 hw->poll_mode = 0; 1127 alsa_fini_poll (&alsa->pollhlp); 1128 } 1129 return alsa_voice_ctl (alsa->handle, "capture", VOICE_CTL_PAUSE); 1130 } 1131 1132 return -1; 1133 } 1134 1135 static void *alsa_audio_init (void) 1136 { 1137 return &conf; 1138 } 1139 1140 static void alsa_audio_fini (void *opaque) 1141 { 1142 (void) opaque; 1143 } 1144 1145 static struct audio_option alsa_options[] = { 1146 { 1147 .name = "DAC_SIZE_IN_USEC", 1148 .tag = AUD_OPT_BOOL, 1149 .valp = &conf.size_in_usec_out, 1150 .descr = "DAC period/buffer size in microseconds (otherwise in frames)" 1151 }, 1152 { 1153 .name = "DAC_PERIOD_SIZE", 1154 .tag = AUD_OPT_INT, 1155 .valp = &conf.period_size_out, 1156 .descr = "DAC period size (0 to go with system default)", 1157 .overriddenp = &conf.period_size_out_overridden 1158 }, 1159 { 1160 .name = "DAC_BUFFER_SIZE", 1161 .tag = AUD_OPT_INT, 1162 .valp = &conf.buffer_size_out, 1163 .descr = "DAC buffer size (0 to go with system default)", 1164 .overriddenp = &conf.buffer_size_out_overridden 1165 }, 1166 { 1167 .name = "ADC_SIZE_IN_USEC", 1168 .tag = AUD_OPT_BOOL, 1169 .valp = &conf.size_in_usec_in, 1170 .descr = 1171 "ADC period/buffer size in microseconds (otherwise in frames)" 1172 }, 1173 { 1174 .name = "ADC_PERIOD_SIZE", 1175 .tag = AUD_OPT_INT, 1176 .valp = &conf.period_size_in, 1177 .descr = "ADC period size (0 to go with system default)", 1178 .overriddenp = &conf.period_size_in_overridden 1179 }, 1180 { 1181 .name = "ADC_BUFFER_SIZE", 1182 .tag = AUD_OPT_INT, 1183 .valp = &conf.buffer_size_in, 1184 .descr = "ADC buffer size (0 to go with system default)", 1185 .overriddenp = &conf.buffer_size_in_overridden 1186 }, 1187 { 1188 .name = "THRESHOLD", 1189 .tag = AUD_OPT_INT, 1190 .valp = &conf.threshold, 1191 .descr = "(undocumented)" 1192 }, 1193 { 1194 .name = "DAC_DEV", 1195 .tag = AUD_OPT_STR, 1196 .valp = &conf.pcm_name_out, 1197 .descr = "DAC device name (for instance dmix)" 1198 }, 1199 { 1200 .name = "ADC_DEV", 1201 .tag = AUD_OPT_STR, 1202 .valp = &conf.pcm_name_in, 1203 .descr = "ADC device name" 1204 }, 1205 { 1206 .name = "VERBOSE", 1207 .tag = AUD_OPT_BOOL, 1208 .valp = &conf.verbose, 1209 .descr = "Behave in a more verbose way" 1210 }, 1211 { /* End of list */ } 1212 }; 1213 1214 static struct audio_pcm_ops alsa_pcm_ops = { 1215 .init_out = alsa_init_out, 1216 .fini_out = alsa_fini_out, 1217 .run_out = alsa_run_out, 1218 .write = alsa_write, 1219 .ctl_out = alsa_ctl_out, 1220 1221 .init_in = alsa_init_in, 1222 .fini_in = alsa_fini_in, 1223 .run_in = alsa_run_in, 1224 .read = alsa_read, 1225 .ctl_in = alsa_ctl_in, 1226 }; 1227 1228 struct audio_driver alsa_audio_driver = { 1229 .name = "alsa", 1230 .descr = "ALSA http://www.alsa-project.org", 1231 .options = alsa_options, 1232 .init = alsa_audio_init, 1233 .fini = alsa_audio_fini, 1234 .pcm_ops = &alsa_pcm_ops, 1235 .can_be_default = 1, 1236 .max_voices_out = INT_MAX, 1237 .max_voices_in = INT_MAX, 1238 .voice_size_out = sizeof (ALSAVoiceOut), 1239 .voice_size_in = sizeof (ALSAVoiceIn) 1240 }; 1241