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