1 /* 2 * QEMU Audio subsystem 3 * 4 * Copyright (c) 2003-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 "qemu/osdep.h" 25 #include "hw/hw.h" 26 #include "audio.h" 27 #include "monitor/monitor.h" 28 #include "qemu/timer.h" 29 #include "sysemu/sysemu.h" 30 #include "qemu/cutils.h" 31 #include "sysemu/replay.h" 32 33 #define AUDIO_CAP "audio" 34 #include "audio_int.h" 35 36 /* #define DEBUG_LIVE */ 37 /* #define DEBUG_OUT */ 38 /* #define DEBUG_CAPTURE */ 39 /* #define DEBUG_POLL */ 40 41 #define SW_NAME(sw) (sw)->name ? (sw)->name : "unknown" 42 43 44 /* Order of CONFIG_AUDIO_DRIVERS is import. 45 The 1st one is the one used by default, that is the reason 46 that we generate the list. 47 */ 48 static struct audio_driver *drvtab[] = { 49 #ifdef CONFIG_SPICE 50 &spice_audio_driver, 51 #endif 52 CONFIG_AUDIO_DRIVERS 53 &no_audio_driver, 54 &wav_audio_driver 55 }; 56 57 struct fixed_settings { 58 int enabled; 59 int nb_voices; 60 int greedy; 61 struct audsettings settings; 62 }; 63 64 static struct { 65 struct fixed_settings fixed_out; 66 struct fixed_settings fixed_in; 67 union { 68 int hertz; 69 int64_t ticks; 70 } period; 71 int try_poll_in; 72 int try_poll_out; 73 } conf = { 74 .fixed_out = { /* DAC fixed settings */ 75 .enabled = 1, 76 .nb_voices = 1, 77 .greedy = 1, 78 .settings = { 79 .freq = 44100, 80 .nchannels = 2, 81 .fmt = AUD_FMT_S16, 82 .endianness = AUDIO_HOST_ENDIANNESS, 83 } 84 }, 85 86 .fixed_in = { /* ADC fixed settings */ 87 .enabled = 1, 88 .nb_voices = 1, 89 .greedy = 1, 90 .settings = { 91 .freq = 44100, 92 .nchannels = 2, 93 .fmt = AUD_FMT_S16, 94 .endianness = AUDIO_HOST_ENDIANNESS, 95 } 96 }, 97 98 .period = { .hertz = 100 }, 99 .try_poll_in = 1, 100 .try_poll_out = 1, 101 }; 102 103 static AudioState glob_audio_state; 104 105 const struct mixeng_volume nominal_volume = { 106 .mute = 0, 107 #ifdef FLOAT_MIXENG 108 .r = 1.0, 109 .l = 1.0, 110 #else 111 .r = 1ULL << 32, 112 .l = 1ULL << 32, 113 #endif 114 }; 115 116 #ifdef AUDIO_IS_FLAWLESS_AND_NO_CHECKS_ARE_REQURIED 117 #error No its not 118 #else 119 static void audio_print_options (const char *prefix, 120 struct audio_option *opt); 121 122 int audio_bug (const char *funcname, int cond) 123 { 124 if (cond) { 125 static int shown; 126 127 AUD_log (NULL, "A bug was just triggered in %s\n", funcname); 128 if (!shown) { 129 struct audio_driver *d; 130 131 shown = 1; 132 AUD_log (NULL, "Save all your work and restart without audio\n"); 133 AUD_log (NULL, "Please send bug report to av1474@comtv.ru\n"); 134 AUD_log (NULL, "I am sorry\n"); 135 d = glob_audio_state.drv; 136 if (d) { 137 audio_print_options (d->name, d->options); 138 } 139 } 140 AUD_log (NULL, "Context:\n"); 141 142 #if defined AUDIO_BREAKPOINT_ON_BUG 143 # if defined HOST_I386 144 # if defined __GNUC__ 145 __asm__ ("int3"); 146 # elif defined _MSC_VER 147 _asm _emit 0xcc; 148 # else 149 abort (); 150 # endif 151 # else 152 abort (); 153 # endif 154 #endif 155 } 156 157 return cond; 158 } 159 #endif 160 161 static inline int audio_bits_to_index (int bits) 162 { 163 switch (bits) { 164 case 8: 165 return 0; 166 167 case 16: 168 return 1; 169 170 case 32: 171 return 2; 172 173 default: 174 audio_bug ("bits_to_index", 1); 175 AUD_log (NULL, "invalid bits %d\n", bits); 176 return 0; 177 } 178 } 179 180 void *audio_calloc (const char *funcname, int nmemb, size_t size) 181 { 182 int cond; 183 size_t len; 184 185 len = nmemb * size; 186 cond = !nmemb || !size; 187 cond |= nmemb < 0; 188 cond |= len < size; 189 190 if (audio_bug ("audio_calloc", cond)) { 191 AUD_log (NULL, "%s passed invalid arguments to audio_calloc\n", 192 funcname); 193 AUD_log (NULL, "nmemb=%d size=%zu (len=%zu)\n", nmemb, size, len); 194 return NULL; 195 } 196 197 return g_malloc0 (len); 198 } 199 200 static char *audio_alloc_prefix (const char *s) 201 { 202 const char qemu_prefix[] = "QEMU_"; 203 size_t len, i; 204 char *r, *u; 205 206 if (!s) { 207 return NULL; 208 } 209 210 len = strlen (s); 211 r = g_malloc (len + sizeof (qemu_prefix)); 212 213 u = r + sizeof (qemu_prefix) - 1; 214 215 pstrcpy (r, len + sizeof (qemu_prefix), qemu_prefix); 216 pstrcat (r, len + sizeof (qemu_prefix), s); 217 218 for (i = 0; i < len; ++i) { 219 u[i] = qemu_toupper(u[i]); 220 } 221 222 return r; 223 } 224 225 static const char *audio_audfmt_to_string (audfmt_e fmt) 226 { 227 switch (fmt) { 228 case AUD_FMT_U8: 229 return "U8"; 230 231 case AUD_FMT_U16: 232 return "U16"; 233 234 case AUD_FMT_S8: 235 return "S8"; 236 237 case AUD_FMT_S16: 238 return "S16"; 239 240 case AUD_FMT_U32: 241 return "U32"; 242 243 case AUD_FMT_S32: 244 return "S32"; 245 } 246 247 dolog ("Bogus audfmt %d returning S16\n", fmt); 248 return "S16"; 249 } 250 251 static audfmt_e audio_string_to_audfmt (const char *s, audfmt_e defval, 252 int *defaultp) 253 { 254 if (!strcasecmp (s, "u8")) { 255 *defaultp = 0; 256 return AUD_FMT_U8; 257 } 258 else if (!strcasecmp (s, "u16")) { 259 *defaultp = 0; 260 return AUD_FMT_U16; 261 } 262 else if (!strcasecmp (s, "u32")) { 263 *defaultp = 0; 264 return AUD_FMT_U32; 265 } 266 else if (!strcasecmp (s, "s8")) { 267 *defaultp = 0; 268 return AUD_FMT_S8; 269 } 270 else if (!strcasecmp (s, "s16")) { 271 *defaultp = 0; 272 return AUD_FMT_S16; 273 } 274 else if (!strcasecmp (s, "s32")) { 275 *defaultp = 0; 276 return AUD_FMT_S32; 277 } 278 else { 279 dolog ("Bogus audio format `%s' using %s\n", 280 s, audio_audfmt_to_string (defval)); 281 *defaultp = 1; 282 return defval; 283 } 284 } 285 286 static audfmt_e audio_get_conf_fmt (const char *envname, 287 audfmt_e defval, 288 int *defaultp) 289 { 290 const char *var = getenv (envname); 291 if (!var) { 292 *defaultp = 1; 293 return defval; 294 } 295 return audio_string_to_audfmt (var, defval, defaultp); 296 } 297 298 static int audio_get_conf_int (const char *key, int defval, int *defaultp) 299 { 300 int val; 301 char *strval; 302 303 strval = getenv (key); 304 if (strval) { 305 *defaultp = 0; 306 val = atoi (strval); 307 return val; 308 } 309 else { 310 *defaultp = 1; 311 return defval; 312 } 313 } 314 315 static const char *audio_get_conf_str (const char *key, 316 const char *defval, 317 int *defaultp) 318 { 319 const char *val = getenv (key); 320 if (!val) { 321 *defaultp = 1; 322 return defval; 323 } 324 else { 325 *defaultp = 0; 326 return val; 327 } 328 } 329 330 void AUD_vlog (const char *cap, const char *fmt, va_list ap) 331 { 332 if (cap) { 333 fprintf(stderr, "%s: ", cap); 334 } 335 336 vfprintf(stderr, fmt, ap); 337 } 338 339 void AUD_log (const char *cap, const char *fmt, ...) 340 { 341 va_list ap; 342 343 va_start (ap, fmt); 344 AUD_vlog (cap, fmt, ap); 345 va_end (ap); 346 } 347 348 static void audio_print_options (const char *prefix, 349 struct audio_option *opt) 350 { 351 char *uprefix; 352 353 if (!prefix) { 354 dolog ("No prefix specified\n"); 355 return; 356 } 357 358 if (!opt) { 359 dolog ("No options\n"); 360 return; 361 } 362 363 uprefix = audio_alloc_prefix (prefix); 364 365 for (; opt->name; opt++) { 366 const char *state = "default"; 367 printf (" %s_%s: ", uprefix, opt->name); 368 369 if (opt->overriddenp && *opt->overriddenp) { 370 state = "current"; 371 } 372 373 switch (opt->tag) { 374 case AUD_OPT_BOOL: 375 { 376 int *intp = opt->valp; 377 printf ("boolean, %s = %d\n", state, *intp ? 1 : 0); 378 } 379 break; 380 381 case AUD_OPT_INT: 382 { 383 int *intp = opt->valp; 384 printf ("integer, %s = %d\n", state, *intp); 385 } 386 break; 387 388 case AUD_OPT_FMT: 389 { 390 audfmt_e *fmtp = opt->valp; 391 printf ( 392 "format, %s = %s, (one of: U8 S8 U16 S16 U32 S32)\n", 393 state, 394 audio_audfmt_to_string (*fmtp) 395 ); 396 } 397 break; 398 399 case AUD_OPT_STR: 400 { 401 const char **strp = opt->valp; 402 printf ("string, %s = %s\n", 403 state, 404 *strp ? *strp : "(not set)"); 405 } 406 break; 407 408 default: 409 printf ("???\n"); 410 dolog ("Bad value tag for option %s_%s %d\n", 411 uprefix, opt->name, opt->tag); 412 break; 413 } 414 printf (" %s\n", opt->descr); 415 } 416 417 g_free (uprefix); 418 } 419 420 static void audio_process_options (const char *prefix, 421 struct audio_option *opt) 422 { 423 char *optname; 424 const char qemu_prefix[] = "QEMU_"; 425 size_t preflen, optlen; 426 427 if (audio_bug(__func__, !prefix)) { 428 dolog ("prefix = NULL\n"); 429 return; 430 } 431 432 if (audio_bug(__func__, !opt)) { 433 dolog ("opt = NULL\n"); 434 return; 435 } 436 437 preflen = strlen (prefix); 438 439 for (; opt->name; opt++) { 440 size_t len, i; 441 int def; 442 443 if (!opt->valp) { 444 dolog ("Option value pointer for `%s' is not set\n", 445 opt->name); 446 continue; 447 } 448 449 len = strlen (opt->name); 450 /* len of opt->name + len of prefix + size of qemu_prefix 451 * (includes trailing zero) + zero + underscore (on behalf of 452 * sizeof) */ 453 optlen = len + preflen + sizeof (qemu_prefix) + 1; 454 optname = g_malloc (optlen); 455 456 pstrcpy (optname, optlen, qemu_prefix); 457 458 /* copy while upper-casing, including trailing zero */ 459 for (i = 0; i <= preflen; ++i) { 460 optname[i + sizeof (qemu_prefix) - 1] = qemu_toupper(prefix[i]); 461 } 462 pstrcat (optname, optlen, "_"); 463 pstrcat (optname, optlen, opt->name); 464 465 def = 1; 466 switch (opt->tag) { 467 case AUD_OPT_BOOL: 468 case AUD_OPT_INT: 469 { 470 int *intp = opt->valp; 471 *intp = audio_get_conf_int (optname, *intp, &def); 472 } 473 break; 474 475 case AUD_OPT_FMT: 476 { 477 audfmt_e *fmtp = opt->valp; 478 *fmtp = audio_get_conf_fmt (optname, *fmtp, &def); 479 } 480 break; 481 482 case AUD_OPT_STR: 483 { 484 const char **strp = opt->valp; 485 *strp = audio_get_conf_str (optname, *strp, &def); 486 } 487 break; 488 489 default: 490 dolog ("Bad value tag for option `%s' - %d\n", 491 optname, opt->tag); 492 break; 493 } 494 495 if (!opt->overriddenp) { 496 opt->overriddenp = &opt->overridden; 497 } 498 *opt->overriddenp = !def; 499 g_free (optname); 500 } 501 } 502 503 static void audio_print_settings (struct audsettings *as) 504 { 505 dolog ("frequency=%d nchannels=%d fmt=", as->freq, as->nchannels); 506 507 switch (as->fmt) { 508 case AUD_FMT_S8: 509 AUD_log (NULL, "S8"); 510 break; 511 case AUD_FMT_U8: 512 AUD_log (NULL, "U8"); 513 break; 514 case AUD_FMT_S16: 515 AUD_log (NULL, "S16"); 516 break; 517 case AUD_FMT_U16: 518 AUD_log (NULL, "U16"); 519 break; 520 case AUD_FMT_S32: 521 AUD_log (NULL, "S32"); 522 break; 523 case AUD_FMT_U32: 524 AUD_log (NULL, "U32"); 525 break; 526 default: 527 AUD_log (NULL, "invalid(%d)", as->fmt); 528 break; 529 } 530 531 AUD_log (NULL, " endianness="); 532 switch (as->endianness) { 533 case 0: 534 AUD_log (NULL, "little"); 535 break; 536 case 1: 537 AUD_log (NULL, "big"); 538 break; 539 default: 540 AUD_log (NULL, "invalid"); 541 break; 542 } 543 AUD_log (NULL, "\n"); 544 } 545 546 static int audio_validate_settings (struct audsettings *as) 547 { 548 int invalid; 549 550 invalid = as->nchannels != 1 && as->nchannels != 2; 551 invalid |= as->endianness != 0 && as->endianness != 1; 552 553 switch (as->fmt) { 554 case AUD_FMT_S8: 555 case AUD_FMT_U8: 556 case AUD_FMT_S16: 557 case AUD_FMT_U16: 558 case AUD_FMT_S32: 559 case AUD_FMT_U32: 560 break; 561 default: 562 invalid = 1; 563 break; 564 } 565 566 invalid |= as->freq <= 0; 567 return invalid ? -1 : 0; 568 } 569 570 static int audio_pcm_info_eq (struct audio_pcm_info *info, struct audsettings *as) 571 { 572 int bits = 8, sign = 0; 573 574 switch (as->fmt) { 575 case AUD_FMT_S8: 576 sign = 1; 577 /* fall through */ 578 case AUD_FMT_U8: 579 break; 580 581 case AUD_FMT_S16: 582 sign = 1; 583 /* fall through */ 584 case AUD_FMT_U16: 585 bits = 16; 586 break; 587 588 case AUD_FMT_S32: 589 sign = 1; 590 /* fall through */ 591 case AUD_FMT_U32: 592 bits = 32; 593 break; 594 } 595 return info->freq == as->freq 596 && info->nchannels == as->nchannels 597 && info->sign == sign 598 && info->bits == bits 599 && info->swap_endianness == (as->endianness != AUDIO_HOST_ENDIANNESS); 600 } 601 602 void audio_pcm_init_info (struct audio_pcm_info *info, struct audsettings *as) 603 { 604 int bits = 8, sign = 0, shift = 0; 605 606 switch (as->fmt) { 607 case AUD_FMT_S8: 608 sign = 1; 609 case AUD_FMT_U8: 610 break; 611 612 case AUD_FMT_S16: 613 sign = 1; 614 case AUD_FMT_U16: 615 bits = 16; 616 shift = 1; 617 break; 618 619 case AUD_FMT_S32: 620 sign = 1; 621 case AUD_FMT_U32: 622 bits = 32; 623 shift = 2; 624 break; 625 } 626 627 info->freq = as->freq; 628 info->bits = bits; 629 info->sign = sign; 630 info->nchannels = as->nchannels; 631 info->shift = (as->nchannels == 2) + shift; 632 info->align = (1 << info->shift) - 1; 633 info->bytes_per_second = info->freq << info->shift; 634 info->swap_endianness = (as->endianness != AUDIO_HOST_ENDIANNESS); 635 } 636 637 void audio_pcm_info_clear_buf (struct audio_pcm_info *info, void *buf, int len) 638 { 639 if (!len) { 640 return; 641 } 642 643 if (info->sign) { 644 memset (buf, 0x00, len << info->shift); 645 } 646 else { 647 switch (info->bits) { 648 case 8: 649 memset (buf, 0x80, len << info->shift); 650 break; 651 652 case 16: 653 { 654 int i; 655 uint16_t *p = buf; 656 int shift = info->nchannels - 1; 657 short s = INT16_MAX; 658 659 if (info->swap_endianness) { 660 s = bswap16 (s); 661 } 662 663 for (i = 0; i < len << shift; i++) { 664 p[i] = s; 665 } 666 } 667 break; 668 669 case 32: 670 { 671 int i; 672 uint32_t *p = buf; 673 int shift = info->nchannels - 1; 674 int32_t s = INT32_MAX; 675 676 if (info->swap_endianness) { 677 s = bswap32 (s); 678 } 679 680 for (i = 0; i < len << shift; i++) { 681 p[i] = s; 682 } 683 } 684 break; 685 686 default: 687 AUD_log (NULL, "audio_pcm_info_clear_buf: invalid bits %d\n", 688 info->bits); 689 break; 690 } 691 } 692 } 693 694 /* 695 * Capture 696 */ 697 static void noop_conv (struct st_sample *dst, const void *src, int samples) 698 { 699 (void) src; 700 (void) dst; 701 (void) samples; 702 } 703 704 static CaptureVoiceOut *audio_pcm_capture_find_specific ( 705 struct audsettings *as 706 ) 707 { 708 CaptureVoiceOut *cap; 709 AudioState *s = &glob_audio_state; 710 711 for (cap = s->cap_head.lh_first; cap; cap = cap->entries.le_next) { 712 if (audio_pcm_info_eq (&cap->hw.info, as)) { 713 return cap; 714 } 715 } 716 return NULL; 717 } 718 719 static void audio_notify_capture (CaptureVoiceOut *cap, audcnotification_e cmd) 720 { 721 struct capture_callback *cb; 722 723 #ifdef DEBUG_CAPTURE 724 dolog ("notification %d sent\n", cmd); 725 #endif 726 for (cb = cap->cb_head.lh_first; cb; cb = cb->entries.le_next) { 727 cb->ops.notify (cb->opaque, cmd); 728 } 729 } 730 731 static void audio_capture_maybe_changed (CaptureVoiceOut *cap, int enabled) 732 { 733 if (cap->hw.enabled != enabled) { 734 audcnotification_e cmd; 735 cap->hw.enabled = enabled; 736 cmd = enabled ? AUD_CNOTIFY_ENABLE : AUD_CNOTIFY_DISABLE; 737 audio_notify_capture (cap, cmd); 738 } 739 } 740 741 static void audio_recalc_and_notify_capture (CaptureVoiceOut *cap) 742 { 743 HWVoiceOut *hw = &cap->hw; 744 SWVoiceOut *sw; 745 int enabled = 0; 746 747 for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) { 748 if (sw->active) { 749 enabled = 1; 750 break; 751 } 752 } 753 audio_capture_maybe_changed (cap, enabled); 754 } 755 756 static void audio_detach_capture (HWVoiceOut *hw) 757 { 758 SWVoiceCap *sc = hw->cap_head.lh_first; 759 760 while (sc) { 761 SWVoiceCap *sc1 = sc->entries.le_next; 762 SWVoiceOut *sw = &sc->sw; 763 CaptureVoiceOut *cap = sc->cap; 764 int was_active = sw->active; 765 766 if (sw->rate) { 767 st_rate_stop (sw->rate); 768 sw->rate = NULL; 769 } 770 771 QLIST_REMOVE (sw, entries); 772 QLIST_REMOVE (sc, entries); 773 g_free (sc); 774 if (was_active) { 775 /* We have removed soft voice from the capture: 776 this might have changed the overall status of the capture 777 since this might have been the only active voice */ 778 audio_recalc_and_notify_capture (cap); 779 } 780 sc = sc1; 781 } 782 } 783 784 static int audio_attach_capture (HWVoiceOut *hw) 785 { 786 AudioState *s = &glob_audio_state; 787 CaptureVoiceOut *cap; 788 789 audio_detach_capture (hw); 790 for (cap = s->cap_head.lh_first; cap; cap = cap->entries.le_next) { 791 SWVoiceCap *sc; 792 SWVoiceOut *sw; 793 HWVoiceOut *hw_cap = &cap->hw; 794 795 sc = audio_calloc(__func__, 1, sizeof(*sc)); 796 if (!sc) { 797 dolog ("Could not allocate soft capture voice (%zu bytes)\n", 798 sizeof (*sc)); 799 return -1; 800 } 801 802 sc->cap = cap; 803 sw = &sc->sw; 804 sw->hw = hw_cap; 805 sw->info = hw->info; 806 sw->empty = 1; 807 sw->active = hw->enabled; 808 sw->conv = noop_conv; 809 sw->ratio = ((int64_t) hw_cap->info.freq << 32) / sw->info.freq; 810 sw->vol = nominal_volume; 811 sw->rate = st_rate_start (sw->info.freq, hw_cap->info.freq); 812 if (!sw->rate) { 813 dolog ("Could not start rate conversion for `%s'\n", SW_NAME (sw)); 814 g_free (sw); 815 return -1; 816 } 817 QLIST_INSERT_HEAD (&hw_cap->sw_head, sw, entries); 818 QLIST_INSERT_HEAD (&hw->cap_head, sc, entries); 819 #ifdef DEBUG_CAPTURE 820 sw->name = g_strdup_printf ("for %p %d,%d,%d", 821 hw, sw->info.freq, sw->info.bits, 822 sw->info.nchannels); 823 dolog ("Added %s active = %d\n", sw->name, sw->active); 824 #endif 825 if (sw->active) { 826 audio_capture_maybe_changed (cap, 1); 827 } 828 } 829 return 0; 830 } 831 832 /* 833 * Hard voice (capture) 834 */ 835 static int audio_pcm_hw_find_min_in (HWVoiceIn *hw) 836 { 837 SWVoiceIn *sw; 838 int m = hw->total_samples_captured; 839 840 for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) { 841 if (sw->active) { 842 m = audio_MIN (m, sw->total_hw_samples_acquired); 843 } 844 } 845 return m; 846 } 847 848 int audio_pcm_hw_get_live_in (HWVoiceIn *hw) 849 { 850 int live = hw->total_samples_captured - audio_pcm_hw_find_min_in (hw); 851 if (audio_bug(__func__, live < 0 || live > hw->samples)) { 852 dolog ("live=%d hw->samples=%d\n", live, hw->samples); 853 return 0; 854 } 855 return live; 856 } 857 858 int audio_pcm_hw_clip_out (HWVoiceOut *hw, void *pcm_buf, 859 int live, int pending) 860 { 861 int left = hw->samples - pending; 862 int len = audio_MIN (left, live); 863 int clipped = 0; 864 865 while (len) { 866 struct st_sample *src = hw->mix_buf + hw->rpos; 867 uint8_t *dst = advance (pcm_buf, hw->rpos << hw->info.shift); 868 int samples_till_end_of_buf = hw->samples - hw->rpos; 869 int samples_to_clip = audio_MIN (len, samples_till_end_of_buf); 870 871 hw->clip (dst, src, samples_to_clip); 872 873 hw->rpos = (hw->rpos + samples_to_clip) % hw->samples; 874 len -= samples_to_clip; 875 clipped += samples_to_clip; 876 } 877 return clipped; 878 } 879 880 /* 881 * Soft voice (capture) 882 */ 883 static int audio_pcm_sw_get_rpos_in (SWVoiceIn *sw) 884 { 885 HWVoiceIn *hw = sw->hw; 886 int live = hw->total_samples_captured - sw->total_hw_samples_acquired; 887 int rpos; 888 889 if (audio_bug(__func__, live < 0 || live > hw->samples)) { 890 dolog ("live=%d hw->samples=%d\n", live, hw->samples); 891 return 0; 892 } 893 894 rpos = hw->wpos - live; 895 if (rpos >= 0) { 896 return rpos; 897 } 898 else { 899 return hw->samples + rpos; 900 } 901 } 902 903 int audio_pcm_sw_read (SWVoiceIn *sw, void *buf, int size) 904 { 905 HWVoiceIn *hw = sw->hw; 906 int samples, live, ret = 0, swlim, isamp, osamp, rpos, total = 0; 907 struct st_sample *src, *dst = sw->buf; 908 909 rpos = audio_pcm_sw_get_rpos_in (sw) % hw->samples; 910 911 live = hw->total_samples_captured - sw->total_hw_samples_acquired; 912 if (audio_bug(__func__, live < 0 || live > hw->samples)) { 913 dolog ("live_in=%d hw->samples=%d\n", live, hw->samples); 914 return 0; 915 } 916 917 samples = size >> sw->info.shift; 918 if (!live) { 919 return 0; 920 } 921 922 swlim = (live * sw->ratio) >> 32; 923 swlim = audio_MIN (swlim, samples); 924 925 while (swlim) { 926 src = hw->conv_buf + rpos; 927 isamp = hw->wpos - rpos; 928 /* XXX: <= ? */ 929 if (isamp <= 0) { 930 isamp = hw->samples - rpos; 931 } 932 933 if (!isamp) { 934 break; 935 } 936 osamp = swlim; 937 938 if (audio_bug(__func__, osamp < 0)) { 939 dolog ("osamp=%d\n", osamp); 940 return 0; 941 } 942 943 st_rate_flow (sw->rate, src, dst, &isamp, &osamp); 944 swlim -= osamp; 945 rpos = (rpos + isamp) % hw->samples; 946 dst += osamp; 947 ret += osamp; 948 total += isamp; 949 } 950 951 if (!(hw->ctl_caps & VOICE_VOLUME_CAP)) { 952 mixeng_volume (sw->buf, ret, &sw->vol); 953 } 954 955 sw->clip (buf, sw->buf, ret); 956 sw->total_hw_samples_acquired += total; 957 return ret << sw->info.shift; 958 } 959 960 /* 961 * Hard voice (playback) 962 */ 963 static int audio_pcm_hw_find_min_out (HWVoiceOut *hw, int *nb_livep) 964 { 965 SWVoiceOut *sw; 966 int m = INT_MAX; 967 int nb_live = 0; 968 969 for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) { 970 if (sw->active || !sw->empty) { 971 m = audio_MIN (m, sw->total_hw_samples_mixed); 972 nb_live += 1; 973 } 974 } 975 976 *nb_livep = nb_live; 977 return m; 978 } 979 980 static int audio_pcm_hw_get_live_out (HWVoiceOut *hw, int *nb_live) 981 { 982 int smin; 983 int nb_live1; 984 985 smin = audio_pcm_hw_find_min_out (hw, &nb_live1); 986 if (nb_live) { 987 *nb_live = nb_live1; 988 } 989 990 if (nb_live1) { 991 int live = smin; 992 993 if (audio_bug(__func__, live < 0 || live > hw->samples)) { 994 dolog ("live=%d hw->samples=%d\n", live, hw->samples); 995 return 0; 996 } 997 return live; 998 } 999 return 0; 1000 } 1001 1002 /* 1003 * Soft voice (playback) 1004 */ 1005 int audio_pcm_sw_write (SWVoiceOut *sw, void *buf, int size) 1006 { 1007 int hwsamples, samples, isamp, osamp, wpos, live, dead, left, swlim, blck; 1008 int ret = 0, pos = 0, total = 0; 1009 1010 if (!sw) { 1011 return size; 1012 } 1013 1014 hwsamples = sw->hw->samples; 1015 1016 live = sw->total_hw_samples_mixed; 1017 if (audio_bug(__func__, live < 0 || live > hwsamples)) { 1018 dolog ("live=%d hw->samples=%d\n", live, hwsamples); 1019 return 0; 1020 } 1021 1022 if (live == hwsamples) { 1023 #ifdef DEBUG_OUT 1024 dolog ("%s is full %d\n", sw->name, live); 1025 #endif 1026 return 0; 1027 } 1028 1029 wpos = (sw->hw->rpos + live) % hwsamples; 1030 samples = size >> sw->info.shift; 1031 1032 dead = hwsamples - live; 1033 swlim = ((int64_t) dead << 32) / sw->ratio; 1034 swlim = audio_MIN (swlim, samples); 1035 if (swlim) { 1036 sw->conv (sw->buf, buf, swlim); 1037 1038 if (!(sw->hw->ctl_caps & VOICE_VOLUME_CAP)) { 1039 mixeng_volume (sw->buf, swlim, &sw->vol); 1040 } 1041 } 1042 1043 while (swlim) { 1044 dead = hwsamples - live; 1045 left = hwsamples - wpos; 1046 blck = audio_MIN (dead, left); 1047 if (!blck) { 1048 break; 1049 } 1050 isamp = swlim; 1051 osamp = blck; 1052 st_rate_flow_mix ( 1053 sw->rate, 1054 sw->buf + pos, 1055 sw->hw->mix_buf + wpos, 1056 &isamp, 1057 &osamp 1058 ); 1059 ret += isamp; 1060 swlim -= isamp; 1061 pos += isamp; 1062 live += osamp; 1063 wpos = (wpos + osamp) % hwsamples; 1064 total += osamp; 1065 } 1066 1067 sw->total_hw_samples_mixed += total; 1068 sw->empty = sw->total_hw_samples_mixed == 0; 1069 1070 #ifdef DEBUG_OUT 1071 dolog ( 1072 "%s: write size %d ret %d total sw %d\n", 1073 SW_NAME (sw), 1074 size >> sw->info.shift, 1075 ret, 1076 sw->total_hw_samples_mixed 1077 ); 1078 #endif 1079 1080 return ret << sw->info.shift; 1081 } 1082 1083 #ifdef DEBUG_AUDIO 1084 static void audio_pcm_print_info (const char *cap, struct audio_pcm_info *info) 1085 { 1086 dolog ("%s: bits %d, sign %d, freq %d, nchan %d\n", 1087 cap, info->bits, info->sign, info->freq, info->nchannels); 1088 } 1089 #endif 1090 1091 #define DAC 1092 #include "audio_template.h" 1093 #undef DAC 1094 #include "audio_template.h" 1095 1096 /* 1097 * Timer 1098 */ 1099 static int audio_is_timer_needed (void) 1100 { 1101 HWVoiceIn *hwi = NULL; 1102 HWVoiceOut *hwo = NULL; 1103 1104 while ((hwo = audio_pcm_hw_find_any_enabled_out (hwo))) { 1105 if (!hwo->poll_mode) return 1; 1106 } 1107 while ((hwi = audio_pcm_hw_find_any_enabled_in (hwi))) { 1108 if (!hwi->poll_mode) return 1; 1109 } 1110 return 0; 1111 } 1112 1113 static void audio_reset_timer (AudioState *s) 1114 { 1115 if (audio_is_timer_needed ()) { 1116 timer_mod_anticipate_ns(s->ts, 1117 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + conf.period.ticks); 1118 } 1119 else { 1120 timer_del (s->ts); 1121 } 1122 } 1123 1124 static void audio_timer (void *opaque) 1125 { 1126 audio_run ("timer"); 1127 audio_reset_timer (opaque); 1128 } 1129 1130 /* 1131 * Public API 1132 */ 1133 int AUD_write (SWVoiceOut *sw, void *buf, int size) 1134 { 1135 if (!sw) { 1136 /* XXX: Consider options */ 1137 return size; 1138 } 1139 1140 if (!sw->hw->enabled) { 1141 dolog ("Writing to disabled voice %s\n", SW_NAME (sw)); 1142 return 0; 1143 } 1144 1145 return sw->hw->pcm_ops->write(sw, buf, size); 1146 } 1147 1148 int AUD_read (SWVoiceIn *sw, void *buf, int size) 1149 { 1150 if (!sw) { 1151 /* XXX: Consider options */ 1152 return size; 1153 } 1154 1155 if (!sw->hw->enabled) { 1156 dolog ("Reading from disabled voice %s\n", SW_NAME (sw)); 1157 return 0; 1158 } 1159 1160 return sw->hw->pcm_ops->read(sw, buf, size); 1161 } 1162 1163 int AUD_get_buffer_size_out (SWVoiceOut *sw) 1164 { 1165 return sw->hw->samples << sw->hw->info.shift; 1166 } 1167 1168 void AUD_set_active_out (SWVoiceOut *sw, int on) 1169 { 1170 HWVoiceOut *hw; 1171 1172 if (!sw) { 1173 return; 1174 } 1175 1176 hw = sw->hw; 1177 if (sw->active != on) { 1178 AudioState *s = &glob_audio_state; 1179 SWVoiceOut *temp_sw; 1180 SWVoiceCap *sc; 1181 1182 if (on) { 1183 hw->pending_disable = 0; 1184 if (!hw->enabled) { 1185 hw->enabled = 1; 1186 if (s->vm_running) { 1187 hw->pcm_ops->ctl_out (hw, VOICE_ENABLE, conf.try_poll_out); 1188 audio_reset_timer (s); 1189 } 1190 } 1191 } 1192 else { 1193 if (hw->enabled) { 1194 int nb_active = 0; 1195 1196 for (temp_sw = hw->sw_head.lh_first; temp_sw; 1197 temp_sw = temp_sw->entries.le_next) { 1198 nb_active += temp_sw->active != 0; 1199 } 1200 1201 hw->pending_disable = nb_active == 1; 1202 } 1203 } 1204 1205 for (sc = hw->cap_head.lh_first; sc; sc = sc->entries.le_next) { 1206 sc->sw.active = hw->enabled; 1207 if (hw->enabled) { 1208 audio_capture_maybe_changed (sc->cap, 1); 1209 } 1210 } 1211 sw->active = on; 1212 } 1213 } 1214 1215 void AUD_set_active_in (SWVoiceIn *sw, int on) 1216 { 1217 HWVoiceIn *hw; 1218 1219 if (!sw) { 1220 return; 1221 } 1222 1223 hw = sw->hw; 1224 if (sw->active != on) { 1225 AudioState *s = &glob_audio_state; 1226 SWVoiceIn *temp_sw; 1227 1228 if (on) { 1229 if (!hw->enabled) { 1230 hw->enabled = 1; 1231 if (s->vm_running) { 1232 hw->pcm_ops->ctl_in (hw, VOICE_ENABLE, conf.try_poll_in); 1233 audio_reset_timer (s); 1234 } 1235 } 1236 sw->total_hw_samples_acquired = hw->total_samples_captured; 1237 } 1238 else { 1239 if (hw->enabled) { 1240 int nb_active = 0; 1241 1242 for (temp_sw = hw->sw_head.lh_first; temp_sw; 1243 temp_sw = temp_sw->entries.le_next) { 1244 nb_active += temp_sw->active != 0; 1245 } 1246 1247 if (nb_active == 1) { 1248 hw->enabled = 0; 1249 hw->pcm_ops->ctl_in (hw, VOICE_DISABLE); 1250 } 1251 } 1252 } 1253 sw->active = on; 1254 } 1255 } 1256 1257 static int audio_get_avail (SWVoiceIn *sw) 1258 { 1259 int live; 1260 1261 if (!sw) { 1262 return 0; 1263 } 1264 1265 live = sw->hw->total_samples_captured - sw->total_hw_samples_acquired; 1266 if (audio_bug(__func__, live < 0 || live > sw->hw->samples)) { 1267 dolog ("live=%d sw->hw->samples=%d\n", live, sw->hw->samples); 1268 return 0; 1269 } 1270 1271 ldebug ( 1272 "%s: get_avail live %d ret %" PRId64 "\n", 1273 SW_NAME (sw), 1274 live, (((int64_t) live << 32) / sw->ratio) << sw->info.shift 1275 ); 1276 1277 return (((int64_t) live << 32) / sw->ratio) << sw->info.shift; 1278 } 1279 1280 static int audio_get_free (SWVoiceOut *sw) 1281 { 1282 int live, dead; 1283 1284 if (!sw) { 1285 return 0; 1286 } 1287 1288 live = sw->total_hw_samples_mixed; 1289 1290 if (audio_bug(__func__, live < 0 || live > sw->hw->samples)) { 1291 dolog ("live=%d sw->hw->samples=%d\n", live, sw->hw->samples); 1292 return 0; 1293 } 1294 1295 dead = sw->hw->samples - live; 1296 1297 #ifdef DEBUG_OUT 1298 dolog ("%s: get_free live %d dead %d ret %" PRId64 "\n", 1299 SW_NAME (sw), 1300 live, dead, (((int64_t) dead << 32) / sw->ratio) << sw->info.shift); 1301 #endif 1302 1303 return (((int64_t) dead << 32) / sw->ratio) << sw->info.shift; 1304 } 1305 1306 static void audio_capture_mix_and_clear (HWVoiceOut *hw, int rpos, int samples) 1307 { 1308 int n; 1309 1310 if (hw->enabled) { 1311 SWVoiceCap *sc; 1312 1313 for (sc = hw->cap_head.lh_first; sc; sc = sc->entries.le_next) { 1314 SWVoiceOut *sw = &sc->sw; 1315 int rpos2 = rpos; 1316 1317 n = samples; 1318 while (n) { 1319 int till_end_of_hw = hw->samples - rpos2; 1320 int to_write = audio_MIN (till_end_of_hw, n); 1321 int bytes = to_write << hw->info.shift; 1322 int written; 1323 1324 sw->buf = hw->mix_buf + rpos2; 1325 written = audio_pcm_sw_write (sw, NULL, bytes); 1326 if (written - bytes) { 1327 dolog ("Could not mix %d bytes into a capture " 1328 "buffer, mixed %d\n", 1329 bytes, written); 1330 break; 1331 } 1332 n -= to_write; 1333 rpos2 = (rpos2 + to_write) % hw->samples; 1334 } 1335 } 1336 } 1337 1338 n = audio_MIN (samples, hw->samples - rpos); 1339 mixeng_clear (hw->mix_buf + rpos, n); 1340 mixeng_clear (hw->mix_buf, samples - n); 1341 } 1342 1343 static void audio_run_out (AudioState *s) 1344 { 1345 HWVoiceOut *hw = NULL; 1346 SWVoiceOut *sw; 1347 1348 while ((hw = audio_pcm_hw_find_any_enabled_out (hw))) { 1349 int played; 1350 int live, free, nb_live, cleanup_required, prev_rpos; 1351 1352 live = audio_pcm_hw_get_live_out (hw, &nb_live); 1353 if (!nb_live) { 1354 live = 0; 1355 } 1356 1357 if (audio_bug(__func__, live < 0 || live > hw->samples)) { 1358 dolog ("live=%d hw->samples=%d\n", live, hw->samples); 1359 continue; 1360 } 1361 1362 if (hw->pending_disable && !nb_live) { 1363 SWVoiceCap *sc; 1364 #ifdef DEBUG_OUT 1365 dolog ("Disabling voice\n"); 1366 #endif 1367 hw->enabled = 0; 1368 hw->pending_disable = 0; 1369 hw->pcm_ops->ctl_out (hw, VOICE_DISABLE); 1370 for (sc = hw->cap_head.lh_first; sc; sc = sc->entries.le_next) { 1371 sc->sw.active = 0; 1372 audio_recalc_and_notify_capture (sc->cap); 1373 } 1374 continue; 1375 } 1376 1377 if (!live) { 1378 for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) { 1379 if (sw->active) { 1380 free = audio_get_free (sw); 1381 if (free > 0) { 1382 sw->callback.fn (sw->callback.opaque, free); 1383 } 1384 } 1385 } 1386 continue; 1387 } 1388 1389 prev_rpos = hw->rpos; 1390 played = hw->pcm_ops->run_out (hw, live); 1391 replay_audio_out(&played); 1392 if (audio_bug(__func__, hw->rpos >= hw->samples)) { 1393 dolog ("hw->rpos=%d hw->samples=%d played=%d\n", 1394 hw->rpos, hw->samples, played); 1395 hw->rpos = 0; 1396 } 1397 1398 #ifdef DEBUG_OUT 1399 dolog ("played=%d\n", played); 1400 #endif 1401 1402 if (played) { 1403 hw->ts_helper += played; 1404 audio_capture_mix_and_clear (hw, prev_rpos, played); 1405 } 1406 1407 cleanup_required = 0; 1408 for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) { 1409 if (!sw->active && sw->empty) { 1410 continue; 1411 } 1412 1413 if (audio_bug(__func__, played > sw->total_hw_samples_mixed)) { 1414 dolog ("played=%d sw->total_hw_samples_mixed=%d\n", 1415 played, sw->total_hw_samples_mixed); 1416 played = sw->total_hw_samples_mixed; 1417 } 1418 1419 sw->total_hw_samples_mixed -= played; 1420 1421 if (!sw->total_hw_samples_mixed) { 1422 sw->empty = 1; 1423 cleanup_required |= !sw->active && !sw->callback.fn; 1424 } 1425 1426 if (sw->active) { 1427 free = audio_get_free (sw); 1428 if (free > 0) { 1429 sw->callback.fn (sw->callback.opaque, free); 1430 } 1431 } 1432 } 1433 1434 if (cleanup_required) { 1435 SWVoiceOut *sw1; 1436 1437 sw = hw->sw_head.lh_first; 1438 while (sw) { 1439 sw1 = sw->entries.le_next; 1440 if (!sw->active && !sw->callback.fn) { 1441 audio_close_out (sw); 1442 } 1443 sw = sw1; 1444 } 1445 } 1446 } 1447 } 1448 1449 static void audio_run_in (AudioState *s) 1450 { 1451 HWVoiceIn *hw = NULL; 1452 1453 while ((hw = audio_pcm_hw_find_any_enabled_in (hw))) { 1454 SWVoiceIn *sw; 1455 int captured = 0, min; 1456 1457 if (replay_mode != REPLAY_MODE_PLAY) { 1458 captured = hw->pcm_ops->run_in(hw); 1459 } 1460 replay_audio_in(&captured, hw->conv_buf, &hw->wpos, hw->samples); 1461 1462 min = audio_pcm_hw_find_min_in (hw); 1463 hw->total_samples_captured += captured - min; 1464 hw->ts_helper += captured; 1465 1466 for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) { 1467 sw->total_hw_samples_acquired -= min; 1468 1469 if (sw->active) { 1470 int avail; 1471 1472 avail = audio_get_avail (sw); 1473 if (avail > 0) { 1474 sw->callback.fn (sw->callback.opaque, avail); 1475 } 1476 } 1477 } 1478 } 1479 } 1480 1481 static void audio_run_capture (AudioState *s) 1482 { 1483 CaptureVoiceOut *cap; 1484 1485 for (cap = s->cap_head.lh_first; cap; cap = cap->entries.le_next) { 1486 int live, rpos, captured; 1487 HWVoiceOut *hw = &cap->hw; 1488 SWVoiceOut *sw; 1489 1490 captured = live = audio_pcm_hw_get_live_out (hw, NULL); 1491 rpos = hw->rpos; 1492 while (live) { 1493 int left = hw->samples - rpos; 1494 int to_capture = audio_MIN (live, left); 1495 struct st_sample *src; 1496 struct capture_callback *cb; 1497 1498 src = hw->mix_buf + rpos; 1499 hw->clip (cap->buf, src, to_capture); 1500 mixeng_clear (src, to_capture); 1501 1502 for (cb = cap->cb_head.lh_first; cb; cb = cb->entries.le_next) { 1503 cb->ops.capture (cb->opaque, cap->buf, 1504 to_capture << hw->info.shift); 1505 } 1506 rpos = (rpos + to_capture) % hw->samples; 1507 live -= to_capture; 1508 } 1509 hw->rpos = rpos; 1510 1511 for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) { 1512 if (!sw->active && sw->empty) { 1513 continue; 1514 } 1515 1516 if (audio_bug(__func__, captured > sw->total_hw_samples_mixed)) { 1517 dolog ("captured=%d sw->total_hw_samples_mixed=%d\n", 1518 captured, sw->total_hw_samples_mixed); 1519 captured = sw->total_hw_samples_mixed; 1520 } 1521 1522 sw->total_hw_samples_mixed -= captured; 1523 sw->empty = sw->total_hw_samples_mixed == 0; 1524 } 1525 } 1526 } 1527 1528 void audio_run (const char *msg) 1529 { 1530 AudioState *s = &glob_audio_state; 1531 1532 audio_run_out (s); 1533 audio_run_in (s); 1534 audio_run_capture (s); 1535 #ifdef DEBUG_POLL 1536 { 1537 static double prevtime; 1538 double currtime; 1539 struct timeval tv; 1540 1541 if (gettimeofday (&tv, NULL)) { 1542 perror ("audio_run: gettimeofday"); 1543 return; 1544 } 1545 1546 currtime = tv.tv_sec + tv.tv_usec * 1e-6; 1547 dolog ("Elapsed since last %s: %f\n", msg, currtime - prevtime); 1548 prevtime = currtime; 1549 } 1550 #endif 1551 } 1552 1553 static struct audio_option audio_options[] = { 1554 /* DAC */ 1555 { 1556 .name = "DAC_FIXED_SETTINGS", 1557 .tag = AUD_OPT_BOOL, 1558 .valp = &conf.fixed_out.enabled, 1559 .descr = "Use fixed settings for host DAC" 1560 }, 1561 { 1562 .name = "DAC_FIXED_FREQ", 1563 .tag = AUD_OPT_INT, 1564 .valp = &conf.fixed_out.settings.freq, 1565 .descr = "Frequency for fixed host DAC" 1566 }, 1567 { 1568 .name = "DAC_FIXED_FMT", 1569 .tag = AUD_OPT_FMT, 1570 .valp = &conf.fixed_out.settings.fmt, 1571 .descr = "Format for fixed host DAC" 1572 }, 1573 { 1574 .name = "DAC_FIXED_CHANNELS", 1575 .tag = AUD_OPT_INT, 1576 .valp = &conf.fixed_out.settings.nchannels, 1577 .descr = "Number of channels for fixed DAC (1 - mono, 2 - stereo)" 1578 }, 1579 { 1580 .name = "DAC_VOICES", 1581 .tag = AUD_OPT_INT, 1582 .valp = &conf.fixed_out.nb_voices, 1583 .descr = "Number of voices for DAC" 1584 }, 1585 { 1586 .name = "DAC_TRY_POLL", 1587 .tag = AUD_OPT_BOOL, 1588 .valp = &conf.try_poll_out, 1589 .descr = "Attempt using poll mode for DAC" 1590 }, 1591 /* ADC */ 1592 { 1593 .name = "ADC_FIXED_SETTINGS", 1594 .tag = AUD_OPT_BOOL, 1595 .valp = &conf.fixed_in.enabled, 1596 .descr = "Use fixed settings for host ADC" 1597 }, 1598 { 1599 .name = "ADC_FIXED_FREQ", 1600 .tag = AUD_OPT_INT, 1601 .valp = &conf.fixed_in.settings.freq, 1602 .descr = "Frequency for fixed host ADC" 1603 }, 1604 { 1605 .name = "ADC_FIXED_FMT", 1606 .tag = AUD_OPT_FMT, 1607 .valp = &conf.fixed_in.settings.fmt, 1608 .descr = "Format for fixed host ADC" 1609 }, 1610 { 1611 .name = "ADC_FIXED_CHANNELS", 1612 .tag = AUD_OPT_INT, 1613 .valp = &conf.fixed_in.settings.nchannels, 1614 .descr = "Number of channels for fixed ADC (1 - mono, 2 - stereo)" 1615 }, 1616 { 1617 .name = "ADC_VOICES", 1618 .tag = AUD_OPT_INT, 1619 .valp = &conf.fixed_in.nb_voices, 1620 .descr = "Number of voices for ADC" 1621 }, 1622 { 1623 .name = "ADC_TRY_POLL", 1624 .tag = AUD_OPT_BOOL, 1625 .valp = &conf.try_poll_in, 1626 .descr = "Attempt using poll mode for ADC" 1627 }, 1628 /* Misc */ 1629 { 1630 .name = "TIMER_PERIOD", 1631 .tag = AUD_OPT_INT, 1632 .valp = &conf.period.hertz, 1633 .descr = "Timer period in HZ (0 - use lowest possible)" 1634 }, 1635 { /* End of list */ } 1636 }; 1637 1638 static void audio_pp_nb_voices (const char *typ, int nb) 1639 { 1640 switch (nb) { 1641 case 0: 1642 printf ("Does not support %s\n", typ); 1643 break; 1644 case 1: 1645 printf ("One %s voice\n", typ); 1646 break; 1647 case INT_MAX: 1648 printf ("Theoretically supports many %s voices\n", typ); 1649 break; 1650 default: 1651 printf ("Theoretically supports up to %d %s voices\n", nb, typ); 1652 break; 1653 } 1654 1655 } 1656 1657 void AUD_help (void) 1658 { 1659 size_t i; 1660 1661 audio_process_options ("AUDIO", audio_options); 1662 for (i = 0; i < ARRAY_SIZE (drvtab); i++) { 1663 struct audio_driver *d = drvtab[i]; 1664 if (d->options) { 1665 audio_process_options (d->name, d->options); 1666 } 1667 } 1668 1669 printf ("Audio options:\n"); 1670 audio_print_options ("AUDIO", audio_options); 1671 printf ("\n"); 1672 1673 printf ("Available drivers:\n"); 1674 1675 for (i = 0; i < ARRAY_SIZE (drvtab); i++) { 1676 struct audio_driver *d = drvtab[i]; 1677 1678 printf ("Name: %s\n", d->name); 1679 printf ("Description: %s\n", d->descr); 1680 1681 audio_pp_nb_voices ("playback", d->max_voices_out); 1682 audio_pp_nb_voices ("capture", d->max_voices_in); 1683 1684 if (d->options) { 1685 printf ("Options:\n"); 1686 audio_print_options (d->name, d->options); 1687 } 1688 else { 1689 printf ("No options\n"); 1690 } 1691 printf ("\n"); 1692 } 1693 1694 printf ( 1695 "Options are settable through environment variables.\n" 1696 "Example:\n" 1697 #ifdef _WIN32 1698 " set QEMU_AUDIO_DRV=wav\n" 1699 " set QEMU_WAV_PATH=c:\\tune.wav\n" 1700 #else 1701 " export QEMU_AUDIO_DRV=wav\n" 1702 " export QEMU_WAV_PATH=$HOME/tune.wav\n" 1703 "(for csh replace export with setenv in the above)\n" 1704 #endif 1705 " qemu ...\n\n" 1706 ); 1707 } 1708 1709 static int audio_driver_init (AudioState *s, struct audio_driver *drv) 1710 { 1711 if (drv->options) { 1712 audio_process_options (drv->name, drv->options); 1713 } 1714 s->drv_opaque = drv->init (); 1715 1716 if (s->drv_opaque) { 1717 audio_init_nb_voices_out (drv); 1718 audio_init_nb_voices_in (drv); 1719 s->drv = drv; 1720 return 0; 1721 } 1722 else { 1723 dolog ("Could not init `%s' audio driver\n", drv->name); 1724 return -1; 1725 } 1726 } 1727 1728 static void audio_vm_change_state_handler (void *opaque, int running, 1729 RunState state) 1730 { 1731 AudioState *s = opaque; 1732 HWVoiceOut *hwo = NULL; 1733 HWVoiceIn *hwi = NULL; 1734 int op = running ? VOICE_ENABLE : VOICE_DISABLE; 1735 1736 s->vm_running = running; 1737 while ((hwo = audio_pcm_hw_find_any_enabled_out (hwo))) { 1738 hwo->pcm_ops->ctl_out (hwo, op, conf.try_poll_out); 1739 } 1740 1741 while ((hwi = audio_pcm_hw_find_any_enabled_in (hwi))) { 1742 hwi->pcm_ops->ctl_in (hwi, op, conf.try_poll_in); 1743 } 1744 audio_reset_timer (s); 1745 } 1746 1747 static bool is_cleaning_up; 1748 1749 bool audio_is_cleaning_up(void) 1750 { 1751 return is_cleaning_up; 1752 } 1753 1754 void audio_cleanup(void) 1755 { 1756 AudioState *s = &glob_audio_state; 1757 HWVoiceOut *hwo, *hwon; 1758 HWVoiceIn *hwi, *hwin; 1759 1760 is_cleaning_up = true; 1761 QLIST_FOREACH_SAFE(hwo, &glob_audio_state.hw_head_out, entries, hwon) { 1762 SWVoiceCap *sc; 1763 1764 if (hwo->enabled) { 1765 hwo->pcm_ops->ctl_out (hwo, VOICE_DISABLE); 1766 } 1767 hwo->pcm_ops->fini_out (hwo); 1768 1769 for (sc = hwo->cap_head.lh_first; sc; sc = sc->entries.le_next) { 1770 CaptureVoiceOut *cap = sc->cap; 1771 struct capture_callback *cb; 1772 1773 for (cb = cap->cb_head.lh_first; cb; cb = cb->entries.le_next) { 1774 cb->ops.destroy (cb->opaque); 1775 } 1776 } 1777 QLIST_REMOVE(hwo, entries); 1778 } 1779 1780 QLIST_FOREACH_SAFE(hwi, &glob_audio_state.hw_head_in, entries, hwin) { 1781 if (hwi->enabled) { 1782 hwi->pcm_ops->ctl_in (hwi, VOICE_DISABLE); 1783 } 1784 hwi->pcm_ops->fini_in (hwi); 1785 QLIST_REMOVE(hwi, entries); 1786 } 1787 1788 if (s->drv) { 1789 s->drv->fini (s->drv_opaque); 1790 s->drv = NULL; 1791 } 1792 } 1793 1794 static const VMStateDescription vmstate_audio = { 1795 .name = "audio", 1796 .version_id = 1, 1797 .minimum_version_id = 1, 1798 .fields = (VMStateField[]) { 1799 VMSTATE_END_OF_LIST() 1800 } 1801 }; 1802 1803 static void audio_init (void) 1804 { 1805 size_t i; 1806 int done = 0; 1807 const char *drvname; 1808 VMChangeStateEntry *e; 1809 AudioState *s = &glob_audio_state; 1810 1811 if (s->drv) { 1812 return; 1813 } 1814 1815 QLIST_INIT (&s->hw_head_out); 1816 QLIST_INIT (&s->hw_head_in); 1817 QLIST_INIT (&s->cap_head); 1818 atexit(audio_cleanup); 1819 1820 s->ts = timer_new_ns(QEMU_CLOCK_VIRTUAL, audio_timer, s); 1821 1822 audio_process_options ("AUDIO", audio_options); 1823 1824 s->nb_hw_voices_out = conf.fixed_out.nb_voices; 1825 s->nb_hw_voices_in = conf.fixed_in.nb_voices; 1826 1827 if (s->nb_hw_voices_out <= 0) { 1828 dolog ("Bogus number of playback voices %d, setting to 1\n", 1829 s->nb_hw_voices_out); 1830 s->nb_hw_voices_out = 1; 1831 } 1832 1833 if (s->nb_hw_voices_in <= 0) { 1834 dolog ("Bogus number of capture voices %d, setting to 0\n", 1835 s->nb_hw_voices_in); 1836 s->nb_hw_voices_in = 0; 1837 } 1838 1839 { 1840 int def; 1841 drvname = audio_get_conf_str ("QEMU_AUDIO_DRV", NULL, &def); 1842 } 1843 1844 if (drvname) { 1845 int found = 0; 1846 1847 for (i = 0; i < ARRAY_SIZE (drvtab); i++) { 1848 if (!strcmp (drvname, drvtab[i]->name)) { 1849 done = !audio_driver_init (s, drvtab[i]); 1850 found = 1; 1851 break; 1852 } 1853 } 1854 1855 if (!found) { 1856 dolog ("Unknown audio driver `%s'\n", drvname); 1857 dolog ("Run with -audio-help to list available drivers\n"); 1858 } 1859 } 1860 1861 if (!done) { 1862 for (i = 0; !done && i < ARRAY_SIZE (drvtab); i++) { 1863 if (drvtab[i]->can_be_default) { 1864 done = !audio_driver_init (s, drvtab[i]); 1865 } 1866 } 1867 } 1868 1869 if (!done) { 1870 done = !audio_driver_init (s, &no_audio_driver); 1871 assert(done); 1872 dolog("warning: Using timer based audio emulation\n"); 1873 } 1874 1875 if (conf.period.hertz <= 0) { 1876 if (conf.period.hertz < 0) { 1877 dolog ("warning: Timer period is negative - %d " 1878 "treating as zero\n", 1879 conf.period.hertz); 1880 } 1881 conf.period.ticks = 1; 1882 } else { 1883 conf.period.ticks = NANOSECONDS_PER_SECOND / conf.period.hertz; 1884 } 1885 1886 e = qemu_add_vm_change_state_handler (audio_vm_change_state_handler, s); 1887 if (!e) { 1888 dolog ("warning: Could not register change state handler\n" 1889 "(Audio can continue looping even after stopping the VM)\n"); 1890 } 1891 1892 QLIST_INIT (&s->card_head); 1893 vmstate_register (NULL, 0, &vmstate_audio, s); 1894 } 1895 1896 void AUD_register_card (const char *name, QEMUSoundCard *card) 1897 { 1898 audio_init (); 1899 card->name = g_strdup (name); 1900 memset (&card->entries, 0, sizeof (card->entries)); 1901 QLIST_INSERT_HEAD (&glob_audio_state.card_head, card, entries); 1902 } 1903 1904 void AUD_remove_card (QEMUSoundCard *card) 1905 { 1906 QLIST_REMOVE (card, entries); 1907 g_free (card->name); 1908 } 1909 1910 1911 CaptureVoiceOut *AUD_add_capture ( 1912 struct audsettings *as, 1913 struct audio_capture_ops *ops, 1914 void *cb_opaque 1915 ) 1916 { 1917 AudioState *s = &glob_audio_state; 1918 CaptureVoiceOut *cap; 1919 struct capture_callback *cb; 1920 1921 if (audio_validate_settings (as)) { 1922 dolog ("Invalid settings were passed when trying to add capture\n"); 1923 audio_print_settings (as); 1924 goto err0; 1925 } 1926 1927 cb = audio_calloc(__func__, 1, sizeof(*cb)); 1928 if (!cb) { 1929 dolog ("Could not allocate capture callback information, size %zu\n", 1930 sizeof (*cb)); 1931 goto err0; 1932 } 1933 cb->ops = *ops; 1934 cb->opaque = cb_opaque; 1935 1936 cap = audio_pcm_capture_find_specific (as); 1937 if (cap) { 1938 QLIST_INSERT_HEAD (&cap->cb_head, cb, entries); 1939 return cap; 1940 } 1941 else { 1942 HWVoiceOut *hw; 1943 CaptureVoiceOut *cap; 1944 1945 cap = audio_calloc(__func__, 1, sizeof(*cap)); 1946 if (!cap) { 1947 dolog ("Could not allocate capture voice, size %zu\n", 1948 sizeof (*cap)); 1949 goto err1; 1950 } 1951 1952 hw = &cap->hw; 1953 QLIST_INIT (&hw->sw_head); 1954 QLIST_INIT (&cap->cb_head); 1955 1956 /* XXX find a more elegant way */ 1957 hw->samples = 4096 * 4; 1958 hw->mix_buf = audio_calloc(__func__, hw->samples, 1959 sizeof(struct st_sample)); 1960 if (!hw->mix_buf) { 1961 dolog ("Could not allocate capture mix buffer (%d samples)\n", 1962 hw->samples); 1963 goto err2; 1964 } 1965 1966 audio_pcm_init_info (&hw->info, as); 1967 1968 cap->buf = audio_calloc(__func__, hw->samples, 1 << hw->info.shift); 1969 if (!cap->buf) { 1970 dolog ("Could not allocate capture buffer " 1971 "(%d samples, each %d bytes)\n", 1972 hw->samples, 1 << hw->info.shift); 1973 goto err3; 1974 } 1975 1976 hw->clip = mixeng_clip 1977 [hw->info.nchannels == 2] 1978 [hw->info.sign] 1979 [hw->info.swap_endianness] 1980 [audio_bits_to_index (hw->info.bits)]; 1981 1982 QLIST_INSERT_HEAD (&s->cap_head, cap, entries); 1983 QLIST_INSERT_HEAD (&cap->cb_head, cb, entries); 1984 1985 QLIST_FOREACH(hw, &glob_audio_state.hw_head_out, entries) { 1986 audio_attach_capture (hw); 1987 } 1988 return cap; 1989 1990 err3: 1991 g_free (cap->hw.mix_buf); 1992 err2: 1993 g_free (cap); 1994 err1: 1995 g_free (cb); 1996 err0: 1997 return NULL; 1998 } 1999 } 2000 2001 void AUD_del_capture (CaptureVoiceOut *cap, void *cb_opaque) 2002 { 2003 struct capture_callback *cb; 2004 2005 for (cb = cap->cb_head.lh_first; cb; cb = cb->entries.le_next) { 2006 if (cb->opaque == cb_opaque) { 2007 cb->ops.destroy (cb_opaque); 2008 QLIST_REMOVE (cb, entries); 2009 g_free (cb); 2010 2011 if (!cap->cb_head.lh_first) { 2012 SWVoiceOut *sw = cap->hw.sw_head.lh_first, *sw1; 2013 2014 while (sw) { 2015 SWVoiceCap *sc = (SWVoiceCap *) sw; 2016 #ifdef DEBUG_CAPTURE 2017 dolog ("freeing %s\n", sw->name); 2018 #endif 2019 2020 sw1 = sw->entries.le_next; 2021 if (sw->rate) { 2022 st_rate_stop (sw->rate); 2023 sw->rate = NULL; 2024 } 2025 QLIST_REMOVE (sw, entries); 2026 QLIST_REMOVE (sc, entries); 2027 g_free (sc); 2028 sw = sw1; 2029 } 2030 QLIST_REMOVE (cap, entries); 2031 g_free (cap->hw.mix_buf); 2032 g_free (cap->buf); 2033 g_free (cap); 2034 } 2035 return; 2036 } 2037 } 2038 } 2039 2040 void AUD_set_volume_out (SWVoiceOut *sw, int mute, uint8_t lvol, uint8_t rvol) 2041 { 2042 if (sw) { 2043 HWVoiceOut *hw = sw->hw; 2044 2045 sw->vol.mute = mute; 2046 sw->vol.l = nominal_volume.l * lvol / 255; 2047 sw->vol.r = nominal_volume.r * rvol / 255; 2048 2049 if (hw->pcm_ops->ctl_out) { 2050 hw->pcm_ops->ctl_out (hw, VOICE_VOLUME, sw); 2051 } 2052 } 2053 } 2054 2055 void AUD_set_volume_in (SWVoiceIn *sw, int mute, uint8_t lvol, uint8_t rvol) 2056 { 2057 if (sw) { 2058 HWVoiceIn *hw = sw->hw; 2059 2060 sw->vol.mute = mute; 2061 sw->vol.l = nominal_volume.l * lvol / 255; 2062 sw->vol.r = nominal_volume.r * rvol / 255; 2063 2064 if (hw->pcm_ops->ctl_in) { 2065 hw->pcm_ops->ctl_in (hw, VOICE_VOLUME, sw); 2066 } 2067 } 2068 } 2069