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 const char *audio_prio_list[] = { 49 "spice", 50 CONFIG_AUDIO_DRIVERS 51 "none", 52 "wav", 53 }; 54 55 static QLIST_HEAD(, audio_driver) audio_drivers; 56 57 void audio_driver_register(audio_driver *drv) 58 { 59 QLIST_INSERT_HEAD(&audio_drivers, drv, next); 60 } 61 62 audio_driver *audio_driver_lookup(const char *name) 63 { 64 struct audio_driver *d; 65 66 QLIST_FOREACH(d, &audio_drivers, next) { 67 if (strcmp(name, d->name) == 0) { 68 return d; 69 } 70 } 71 72 audio_module_load_one(name); 73 QLIST_FOREACH(d, &audio_drivers, next) { 74 if (strcmp(name, d->name) == 0) { 75 return d; 76 } 77 } 78 79 return NULL; 80 } 81 82 static void audio_module_load_all(void) 83 { 84 int i; 85 86 for (i = 0; i < ARRAY_SIZE(audio_prio_list); i++) { 87 audio_driver_lookup(audio_prio_list[i]); 88 } 89 } 90 91 struct fixed_settings { 92 int enabled; 93 int nb_voices; 94 int greedy; 95 struct audsettings settings; 96 }; 97 98 static struct { 99 struct fixed_settings fixed_out; 100 struct fixed_settings fixed_in; 101 union { 102 int hertz; 103 int64_t ticks; 104 } period; 105 int try_poll_in; 106 int try_poll_out; 107 } conf = { 108 .fixed_out = { /* DAC fixed settings */ 109 .enabled = 1, 110 .nb_voices = 1, 111 .greedy = 1, 112 .settings = { 113 .freq = 44100, 114 .nchannels = 2, 115 .fmt = AUD_FMT_S16, 116 .endianness = AUDIO_HOST_ENDIANNESS, 117 } 118 }, 119 120 .fixed_in = { /* ADC fixed settings */ 121 .enabled = 1, 122 .nb_voices = 1, 123 .greedy = 1, 124 .settings = { 125 .freq = 44100, 126 .nchannels = 2, 127 .fmt = AUD_FMT_S16, 128 .endianness = AUDIO_HOST_ENDIANNESS, 129 } 130 }, 131 132 .period = { .hertz = 100 }, 133 .try_poll_in = 1, 134 .try_poll_out = 1, 135 }; 136 137 static AudioState glob_audio_state; 138 139 const struct mixeng_volume nominal_volume = { 140 .mute = 0, 141 #ifdef FLOAT_MIXENG 142 .r = 1.0, 143 .l = 1.0, 144 #else 145 .r = 1ULL << 32, 146 .l = 1ULL << 32, 147 #endif 148 }; 149 150 #ifdef AUDIO_IS_FLAWLESS_AND_NO_CHECKS_ARE_REQURIED 151 #error No its not 152 #else 153 static void audio_print_options (const char *prefix, 154 struct audio_option *opt); 155 156 int audio_bug (const char *funcname, int cond) 157 { 158 if (cond) { 159 static int shown; 160 161 AUD_log (NULL, "A bug was just triggered in %s\n", funcname); 162 if (!shown) { 163 struct audio_driver *d; 164 165 shown = 1; 166 AUD_log (NULL, "Save all your work and restart without audio\n"); 167 AUD_log (NULL, "Please send bug report to av1474@comtv.ru\n"); 168 AUD_log (NULL, "I am sorry\n"); 169 d = glob_audio_state.drv; 170 if (d) { 171 audio_print_options (d->name, d->options); 172 } 173 } 174 AUD_log (NULL, "Context:\n"); 175 176 #if defined AUDIO_BREAKPOINT_ON_BUG 177 # if defined HOST_I386 178 # if defined __GNUC__ 179 __asm__ ("int3"); 180 # elif defined _MSC_VER 181 _asm _emit 0xcc; 182 # else 183 abort (); 184 # endif 185 # else 186 abort (); 187 # endif 188 #endif 189 } 190 191 return cond; 192 } 193 #endif 194 195 static inline int audio_bits_to_index (int bits) 196 { 197 switch (bits) { 198 case 8: 199 return 0; 200 201 case 16: 202 return 1; 203 204 case 32: 205 return 2; 206 207 default: 208 audio_bug ("bits_to_index", 1); 209 AUD_log (NULL, "invalid bits %d\n", bits); 210 return 0; 211 } 212 } 213 214 void *audio_calloc (const char *funcname, int nmemb, size_t size) 215 { 216 int cond; 217 size_t len; 218 219 len = nmemb * size; 220 cond = !nmemb || !size; 221 cond |= nmemb < 0; 222 cond |= len < size; 223 224 if (audio_bug ("audio_calloc", cond)) { 225 AUD_log (NULL, "%s passed invalid arguments to audio_calloc\n", 226 funcname); 227 AUD_log (NULL, "nmemb=%d size=%zu (len=%zu)\n", nmemb, size, len); 228 return NULL; 229 } 230 231 return g_malloc0 (len); 232 } 233 234 static char *audio_alloc_prefix (const char *s) 235 { 236 const char qemu_prefix[] = "QEMU_"; 237 size_t len, i; 238 char *r, *u; 239 240 if (!s) { 241 return NULL; 242 } 243 244 len = strlen (s); 245 r = g_malloc (len + sizeof (qemu_prefix)); 246 247 u = r + sizeof (qemu_prefix) - 1; 248 249 pstrcpy (r, len + sizeof (qemu_prefix), qemu_prefix); 250 pstrcat (r, len + sizeof (qemu_prefix), s); 251 252 for (i = 0; i < len; ++i) { 253 u[i] = qemu_toupper(u[i]); 254 } 255 256 return r; 257 } 258 259 static const char *audio_audfmt_to_string (audfmt_e fmt) 260 { 261 switch (fmt) { 262 case AUD_FMT_U8: 263 return "U8"; 264 265 case AUD_FMT_U16: 266 return "U16"; 267 268 case AUD_FMT_S8: 269 return "S8"; 270 271 case AUD_FMT_S16: 272 return "S16"; 273 274 case AUD_FMT_U32: 275 return "U32"; 276 277 case AUD_FMT_S32: 278 return "S32"; 279 } 280 281 dolog ("Bogus audfmt %d returning S16\n", fmt); 282 return "S16"; 283 } 284 285 static audfmt_e audio_string_to_audfmt (const char *s, audfmt_e defval, 286 int *defaultp) 287 { 288 if (!strcasecmp (s, "u8")) { 289 *defaultp = 0; 290 return AUD_FMT_U8; 291 } 292 else if (!strcasecmp (s, "u16")) { 293 *defaultp = 0; 294 return AUD_FMT_U16; 295 } 296 else if (!strcasecmp (s, "u32")) { 297 *defaultp = 0; 298 return AUD_FMT_U32; 299 } 300 else if (!strcasecmp (s, "s8")) { 301 *defaultp = 0; 302 return AUD_FMT_S8; 303 } 304 else if (!strcasecmp (s, "s16")) { 305 *defaultp = 0; 306 return AUD_FMT_S16; 307 } 308 else if (!strcasecmp (s, "s32")) { 309 *defaultp = 0; 310 return AUD_FMT_S32; 311 } 312 else { 313 dolog ("Bogus audio format `%s' using %s\n", 314 s, audio_audfmt_to_string (defval)); 315 *defaultp = 1; 316 return defval; 317 } 318 } 319 320 static audfmt_e audio_get_conf_fmt (const char *envname, 321 audfmt_e defval, 322 int *defaultp) 323 { 324 const char *var = getenv (envname); 325 if (!var) { 326 *defaultp = 1; 327 return defval; 328 } 329 return audio_string_to_audfmt (var, defval, defaultp); 330 } 331 332 static int audio_get_conf_int (const char *key, int defval, int *defaultp) 333 { 334 int val; 335 char *strval; 336 337 strval = getenv (key); 338 if (strval) { 339 *defaultp = 0; 340 val = atoi (strval); 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 static int audio_is_timer_needed (void) 1134 { 1135 HWVoiceIn *hwi = NULL; 1136 HWVoiceOut *hwo = NULL; 1137 1138 while ((hwo = audio_pcm_hw_find_any_enabled_out (hwo))) { 1139 if (!hwo->poll_mode) return 1; 1140 } 1141 while ((hwi = audio_pcm_hw_find_any_enabled_in (hwi))) { 1142 if (!hwi->poll_mode) return 1; 1143 } 1144 return 0; 1145 } 1146 1147 static void audio_reset_timer (AudioState *s) 1148 { 1149 if (audio_is_timer_needed ()) { 1150 timer_mod_anticipate_ns(s->ts, 1151 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + conf.period.ticks); 1152 } 1153 else { 1154 timer_del (s->ts); 1155 } 1156 } 1157 1158 static void audio_timer (void *opaque) 1159 { 1160 audio_run ("timer"); 1161 audio_reset_timer (opaque); 1162 } 1163 1164 /* 1165 * Public API 1166 */ 1167 int AUD_write (SWVoiceOut *sw, void *buf, int size) 1168 { 1169 if (!sw) { 1170 /* XXX: Consider options */ 1171 return size; 1172 } 1173 1174 if (!sw->hw->enabled) { 1175 dolog ("Writing to disabled voice %s\n", SW_NAME (sw)); 1176 return 0; 1177 } 1178 1179 return sw->hw->pcm_ops->write(sw, buf, size); 1180 } 1181 1182 int AUD_read (SWVoiceIn *sw, void *buf, int size) 1183 { 1184 if (!sw) { 1185 /* XXX: Consider options */ 1186 return size; 1187 } 1188 1189 if (!sw->hw->enabled) { 1190 dolog ("Reading from disabled voice %s\n", SW_NAME (sw)); 1191 return 0; 1192 } 1193 1194 return sw->hw->pcm_ops->read(sw, buf, size); 1195 } 1196 1197 int AUD_get_buffer_size_out (SWVoiceOut *sw) 1198 { 1199 return sw->hw->samples << sw->hw->info.shift; 1200 } 1201 1202 void AUD_set_active_out (SWVoiceOut *sw, int on) 1203 { 1204 HWVoiceOut *hw; 1205 1206 if (!sw) { 1207 return; 1208 } 1209 1210 hw = sw->hw; 1211 if (sw->active != on) { 1212 AudioState *s = &glob_audio_state; 1213 SWVoiceOut *temp_sw; 1214 SWVoiceCap *sc; 1215 1216 if (on) { 1217 hw->pending_disable = 0; 1218 if (!hw->enabled) { 1219 hw->enabled = 1; 1220 if (s->vm_running) { 1221 hw->pcm_ops->ctl_out (hw, VOICE_ENABLE, conf.try_poll_out); 1222 audio_reset_timer (s); 1223 } 1224 } 1225 } 1226 else { 1227 if (hw->enabled) { 1228 int nb_active = 0; 1229 1230 for (temp_sw = hw->sw_head.lh_first; temp_sw; 1231 temp_sw = temp_sw->entries.le_next) { 1232 nb_active += temp_sw->active != 0; 1233 } 1234 1235 hw->pending_disable = nb_active == 1; 1236 } 1237 } 1238 1239 for (sc = hw->cap_head.lh_first; sc; sc = sc->entries.le_next) { 1240 sc->sw.active = hw->enabled; 1241 if (hw->enabled) { 1242 audio_capture_maybe_changed (sc->cap, 1); 1243 } 1244 } 1245 sw->active = on; 1246 } 1247 } 1248 1249 void AUD_set_active_in (SWVoiceIn *sw, int on) 1250 { 1251 HWVoiceIn *hw; 1252 1253 if (!sw) { 1254 return; 1255 } 1256 1257 hw = sw->hw; 1258 if (sw->active != on) { 1259 AudioState *s = &glob_audio_state; 1260 SWVoiceIn *temp_sw; 1261 1262 if (on) { 1263 if (!hw->enabled) { 1264 hw->enabled = 1; 1265 if (s->vm_running) { 1266 hw->pcm_ops->ctl_in (hw, VOICE_ENABLE, conf.try_poll_in); 1267 audio_reset_timer (s); 1268 } 1269 } 1270 sw->total_hw_samples_acquired = hw->total_samples_captured; 1271 } 1272 else { 1273 if (hw->enabled) { 1274 int nb_active = 0; 1275 1276 for (temp_sw = hw->sw_head.lh_first; temp_sw; 1277 temp_sw = temp_sw->entries.le_next) { 1278 nb_active += temp_sw->active != 0; 1279 } 1280 1281 if (nb_active == 1) { 1282 hw->enabled = 0; 1283 hw->pcm_ops->ctl_in (hw, VOICE_DISABLE); 1284 } 1285 } 1286 } 1287 sw->active = on; 1288 } 1289 } 1290 1291 static int audio_get_avail (SWVoiceIn *sw) 1292 { 1293 int live; 1294 1295 if (!sw) { 1296 return 0; 1297 } 1298 1299 live = sw->hw->total_samples_captured - sw->total_hw_samples_acquired; 1300 if (audio_bug(__func__, live < 0 || live > sw->hw->samples)) { 1301 dolog ("live=%d sw->hw->samples=%d\n", live, sw->hw->samples); 1302 return 0; 1303 } 1304 1305 ldebug ( 1306 "%s: get_avail live %d ret %" PRId64 "\n", 1307 SW_NAME (sw), 1308 live, (((int64_t) live << 32) / sw->ratio) << sw->info.shift 1309 ); 1310 1311 return (((int64_t) live << 32) / sw->ratio) << sw->info.shift; 1312 } 1313 1314 static int audio_get_free (SWVoiceOut *sw) 1315 { 1316 int live, dead; 1317 1318 if (!sw) { 1319 return 0; 1320 } 1321 1322 live = sw->total_hw_samples_mixed; 1323 1324 if (audio_bug(__func__, live < 0 || live > sw->hw->samples)) { 1325 dolog ("live=%d sw->hw->samples=%d\n", live, sw->hw->samples); 1326 return 0; 1327 } 1328 1329 dead = sw->hw->samples - live; 1330 1331 #ifdef DEBUG_OUT 1332 dolog ("%s: get_free live %d dead %d ret %" PRId64 "\n", 1333 SW_NAME (sw), 1334 live, dead, (((int64_t) dead << 32) / sw->ratio) << sw->info.shift); 1335 #endif 1336 1337 return (((int64_t) dead << 32) / sw->ratio) << sw->info.shift; 1338 } 1339 1340 static void audio_capture_mix_and_clear (HWVoiceOut *hw, int rpos, int samples) 1341 { 1342 int n; 1343 1344 if (hw->enabled) { 1345 SWVoiceCap *sc; 1346 1347 for (sc = hw->cap_head.lh_first; sc; sc = sc->entries.le_next) { 1348 SWVoiceOut *sw = &sc->sw; 1349 int rpos2 = rpos; 1350 1351 n = samples; 1352 while (n) { 1353 int till_end_of_hw = hw->samples - rpos2; 1354 int to_write = audio_MIN (till_end_of_hw, n); 1355 int bytes = to_write << hw->info.shift; 1356 int written; 1357 1358 sw->buf = hw->mix_buf + rpos2; 1359 written = audio_pcm_sw_write (sw, NULL, bytes); 1360 if (written - bytes) { 1361 dolog ("Could not mix %d bytes into a capture " 1362 "buffer, mixed %d\n", 1363 bytes, written); 1364 break; 1365 } 1366 n -= to_write; 1367 rpos2 = (rpos2 + to_write) % hw->samples; 1368 } 1369 } 1370 } 1371 1372 n = audio_MIN (samples, hw->samples - rpos); 1373 mixeng_clear (hw->mix_buf + rpos, n); 1374 mixeng_clear (hw->mix_buf, samples - n); 1375 } 1376 1377 static void audio_run_out (AudioState *s) 1378 { 1379 HWVoiceOut *hw = NULL; 1380 SWVoiceOut *sw; 1381 1382 while ((hw = audio_pcm_hw_find_any_enabled_out (hw))) { 1383 int played; 1384 int live, free, nb_live, cleanup_required, prev_rpos; 1385 1386 live = audio_pcm_hw_get_live_out (hw, &nb_live); 1387 if (!nb_live) { 1388 live = 0; 1389 } 1390 1391 if (audio_bug(__func__, live < 0 || live > hw->samples)) { 1392 dolog ("live=%d hw->samples=%d\n", live, hw->samples); 1393 continue; 1394 } 1395 1396 if (hw->pending_disable && !nb_live) { 1397 SWVoiceCap *sc; 1398 #ifdef DEBUG_OUT 1399 dolog ("Disabling voice\n"); 1400 #endif 1401 hw->enabled = 0; 1402 hw->pending_disable = 0; 1403 hw->pcm_ops->ctl_out (hw, VOICE_DISABLE); 1404 for (sc = hw->cap_head.lh_first; sc; sc = sc->entries.le_next) { 1405 sc->sw.active = 0; 1406 audio_recalc_and_notify_capture (sc->cap); 1407 } 1408 continue; 1409 } 1410 1411 if (!live) { 1412 for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) { 1413 if (sw->active) { 1414 free = audio_get_free (sw); 1415 if (free > 0) { 1416 sw->callback.fn (sw->callback.opaque, free); 1417 } 1418 } 1419 } 1420 continue; 1421 } 1422 1423 prev_rpos = hw->rpos; 1424 played = hw->pcm_ops->run_out (hw, live); 1425 replay_audio_out(&played); 1426 if (audio_bug(__func__, hw->rpos >= hw->samples)) { 1427 dolog ("hw->rpos=%d hw->samples=%d played=%d\n", 1428 hw->rpos, hw->samples, played); 1429 hw->rpos = 0; 1430 } 1431 1432 #ifdef DEBUG_OUT 1433 dolog ("played=%d\n", played); 1434 #endif 1435 1436 if (played) { 1437 hw->ts_helper += played; 1438 audio_capture_mix_and_clear (hw, prev_rpos, played); 1439 } 1440 1441 cleanup_required = 0; 1442 for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) { 1443 if (!sw->active && sw->empty) { 1444 continue; 1445 } 1446 1447 if (audio_bug(__func__, played > sw->total_hw_samples_mixed)) { 1448 dolog ("played=%d sw->total_hw_samples_mixed=%d\n", 1449 played, sw->total_hw_samples_mixed); 1450 played = sw->total_hw_samples_mixed; 1451 } 1452 1453 sw->total_hw_samples_mixed -= played; 1454 1455 if (!sw->total_hw_samples_mixed) { 1456 sw->empty = 1; 1457 cleanup_required |= !sw->active && !sw->callback.fn; 1458 } 1459 1460 if (sw->active) { 1461 free = audio_get_free (sw); 1462 if (free > 0) { 1463 sw->callback.fn (sw->callback.opaque, free); 1464 } 1465 } 1466 } 1467 1468 if (cleanup_required) { 1469 SWVoiceOut *sw1; 1470 1471 sw = hw->sw_head.lh_first; 1472 while (sw) { 1473 sw1 = sw->entries.le_next; 1474 if (!sw->active && !sw->callback.fn) { 1475 audio_close_out (sw); 1476 } 1477 sw = sw1; 1478 } 1479 } 1480 } 1481 } 1482 1483 static void audio_run_in (AudioState *s) 1484 { 1485 HWVoiceIn *hw = NULL; 1486 1487 while ((hw = audio_pcm_hw_find_any_enabled_in (hw))) { 1488 SWVoiceIn *sw; 1489 int captured = 0, min; 1490 1491 if (replay_mode != REPLAY_MODE_PLAY) { 1492 captured = hw->pcm_ops->run_in(hw); 1493 } 1494 replay_audio_in(&captured, hw->conv_buf, &hw->wpos, hw->samples); 1495 1496 min = audio_pcm_hw_find_min_in (hw); 1497 hw->total_samples_captured += captured - min; 1498 hw->ts_helper += captured; 1499 1500 for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) { 1501 sw->total_hw_samples_acquired -= min; 1502 1503 if (sw->active) { 1504 int avail; 1505 1506 avail = audio_get_avail (sw); 1507 if (avail > 0) { 1508 sw->callback.fn (sw->callback.opaque, avail); 1509 } 1510 } 1511 } 1512 } 1513 } 1514 1515 static void audio_run_capture (AudioState *s) 1516 { 1517 CaptureVoiceOut *cap; 1518 1519 for (cap = s->cap_head.lh_first; cap; cap = cap->entries.le_next) { 1520 int live, rpos, captured; 1521 HWVoiceOut *hw = &cap->hw; 1522 SWVoiceOut *sw; 1523 1524 captured = live = audio_pcm_hw_get_live_out (hw, NULL); 1525 rpos = hw->rpos; 1526 while (live) { 1527 int left = hw->samples - rpos; 1528 int to_capture = audio_MIN (live, left); 1529 struct st_sample *src; 1530 struct capture_callback *cb; 1531 1532 src = hw->mix_buf + rpos; 1533 hw->clip (cap->buf, src, to_capture); 1534 mixeng_clear (src, to_capture); 1535 1536 for (cb = cap->cb_head.lh_first; cb; cb = cb->entries.le_next) { 1537 cb->ops.capture (cb->opaque, cap->buf, 1538 to_capture << hw->info.shift); 1539 } 1540 rpos = (rpos + to_capture) % hw->samples; 1541 live -= to_capture; 1542 } 1543 hw->rpos = rpos; 1544 1545 for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) { 1546 if (!sw->active && sw->empty) { 1547 continue; 1548 } 1549 1550 if (audio_bug(__func__, captured > sw->total_hw_samples_mixed)) { 1551 dolog ("captured=%d sw->total_hw_samples_mixed=%d\n", 1552 captured, sw->total_hw_samples_mixed); 1553 captured = sw->total_hw_samples_mixed; 1554 } 1555 1556 sw->total_hw_samples_mixed -= captured; 1557 sw->empty = sw->total_hw_samples_mixed == 0; 1558 } 1559 } 1560 } 1561 1562 void audio_run (const char *msg) 1563 { 1564 AudioState *s = &glob_audio_state; 1565 1566 audio_run_out (s); 1567 audio_run_in (s); 1568 audio_run_capture (s); 1569 #ifdef DEBUG_POLL 1570 { 1571 static double prevtime; 1572 double currtime; 1573 struct timeval tv; 1574 1575 if (gettimeofday (&tv, NULL)) { 1576 perror ("audio_run: gettimeofday"); 1577 return; 1578 } 1579 1580 currtime = tv.tv_sec + tv.tv_usec * 1e-6; 1581 dolog ("Elapsed since last %s: %f\n", msg, currtime - prevtime); 1582 prevtime = currtime; 1583 } 1584 #endif 1585 } 1586 1587 static struct audio_option audio_options[] = { 1588 /* DAC */ 1589 { 1590 .name = "DAC_FIXED_SETTINGS", 1591 .tag = AUD_OPT_BOOL, 1592 .valp = &conf.fixed_out.enabled, 1593 .descr = "Use fixed settings for host DAC" 1594 }, 1595 { 1596 .name = "DAC_FIXED_FREQ", 1597 .tag = AUD_OPT_INT, 1598 .valp = &conf.fixed_out.settings.freq, 1599 .descr = "Frequency for fixed host DAC" 1600 }, 1601 { 1602 .name = "DAC_FIXED_FMT", 1603 .tag = AUD_OPT_FMT, 1604 .valp = &conf.fixed_out.settings.fmt, 1605 .descr = "Format for fixed host DAC" 1606 }, 1607 { 1608 .name = "DAC_FIXED_CHANNELS", 1609 .tag = AUD_OPT_INT, 1610 .valp = &conf.fixed_out.settings.nchannels, 1611 .descr = "Number of channels for fixed DAC (1 - mono, 2 - stereo)" 1612 }, 1613 { 1614 .name = "DAC_VOICES", 1615 .tag = AUD_OPT_INT, 1616 .valp = &conf.fixed_out.nb_voices, 1617 .descr = "Number of voices for DAC" 1618 }, 1619 { 1620 .name = "DAC_TRY_POLL", 1621 .tag = AUD_OPT_BOOL, 1622 .valp = &conf.try_poll_out, 1623 .descr = "Attempt using poll mode for DAC" 1624 }, 1625 /* ADC */ 1626 { 1627 .name = "ADC_FIXED_SETTINGS", 1628 .tag = AUD_OPT_BOOL, 1629 .valp = &conf.fixed_in.enabled, 1630 .descr = "Use fixed settings for host ADC" 1631 }, 1632 { 1633 .name = "ADC_FIXED_FREQ", 1634 .tag = AUD_OPT_INT, 1635 .valp = &conf.fixed_in.settings.freq, 1636 .descr = "Frequency for fixed host ADC" 1637 }, 1638 { 1639 .name = "ADC_FIXED_FMT", 1640 .tag = AUD_OPT_FMT, 1641 .valp = &conf.fixed_in.settings.fmt, 1642 .descr = "Format for fixed host ADC" 1643 }, 1644 { 1645 .name = "ADC_FIXED_CHANNELS", 1646 .tag = AUD_OPT_INT, 1647 .valp = &conf.fixed_in.settings.nchannels, 1648 .descr = "Number of channels for fixed ADC (1 - mono, 2 - stereo)" 1649 }, 1650 { 1651 .name = "ADC_VOICES", 1652 .tag = AUD_OPT_INT, 1653 .valp = &conf.fixed_in.nb_voices, 1654 .descr = "Number of voices for ADC" 1655 }, 1656 { 1657 .name = "ADC_TRY_POLL", 1658 .tag = AUD_OPT_BOOL, 1659 .valp = &conf.try_poll_in, 1660 .descr = "Attempt using poll mode for ADC" 1661 }, 1662 /* Misc */ 1663 { 1664 .name = "TIMER_PERIOD", 1665 .tag = AUD_OPT_INT, 1666 .valp = &conf.period.hertz, 1667 .descr = "Timer period in HZ (0 - use lowest possible)" 1668 }, 1669 { /* End of list */ } 1670 }; 1671 1672 static void audio_pp_nb_voices (const char *typ, int nb) 1673 { 1674 switch (nb) { 1675 case 0: 1676 printf ("Does not support %s\n", typ); 1677 break; 1678 case 1: 1679 printf ("One %s voice\n", typ); 1680 break; 1681 case INT_MAX: 1682 printf ("Theoretically supports many %s voices\n", typ); 1683 break; 1684 default: 1685 printf ("Theoretically supports up to %d %s voices\n", nb, typ); 1686 break; 1687 } 1688 1689 } 1690 1691 void AUD_help (void) 1692 { 1693 struct audio_driver *d; 1694 1695 /* make sure we print the help text for modular drivers too */ 1696 audio_module_load_all(); 1697 1698 audio_process_options ("AUDIO", audio_options); 1699 QLIST_FOREACH(d, &audio_drivers, next) { 1700 if (d->options) { 1701 audio_process_options (d->name, d->options); 1702 } 1703 } 1704 1705 printf ("Audio options:\n"); 1706 audio_print_options ("AUDIO", audio_options); 1707 printf ("\n"); 1708 1709 printf ("Available drivers:\n"); 1710 1711 QLIST_FOREACH(d, &audio_drivers, next) { 1712 1713 printf ("Name: %s\n", d->name); 1714 printf ("Description: %s\n", d->descr); 1715 1716 audio_pp_nb_voices ("playback", d->max_voices_out); 1717 audio_pp_nb_voices ("capture", d->max_voices_in); 1718 1719 if (d->options) { 1720 printf ("Options:\n"); 1721 audio_print_options (d->name, d->options); 1722 } 1723 else { 1724 printf ("No options\n"); 1725 } 1726 printf ("\n"); 1727 } 1728 1729 printf ( 1730 "Options are settable through environment variables.\n" 1731 "Example:\n" 1732 #ifdef _WIN32 1733 " set QEMU_AUDIO_DRV=wav\n" 1734 " set QEMU_WAV_PATH=c:\\tune.wav\n" 1735 #else 1736 " export QEMU_AUDIO_DRV=wav\n" 1737 " export QEMU_WAV_PATH=$HOME/tune.wav\n" 1738 "(for csh replace export with setenv in the above)\n" 1739 #endif 1740 " qemu ...\n\n" 1741 ); 1742 } 1743 1744 static int audio_driver_init (AudioState *s, struct audio_driver *drv) 1745 { 1746 if (drv->options) { 1747 audio_process_options (drv->name, drv->options); 1748 } 1749 s->drv_opaque = drv->init (); 1750 1751 if (s->drv_opaque) { 1752 audio_init_nb_voices_out (drv); 1753 audio_init_nb_voices_in (drv); 1754 s->drv = drv; 1755 return 0; 1756 } 1757 else { 1758 dolog ("Could not init `%s' audio driver\n", drv->name); 1759 return -1; 1760 } 1761 } 1762 1763 static void audio_vm_change_state_handler (void *opaque, int running, 1764 RunState state) 1765 { 1766 AudioState *s = opaque; 1767 HWVoiceOut *hwo = NULL; 1768 HWVoiceIn *hwi = NULL; 1769 int op = running ? VOICE_ENABLE : VOICE_DISABLE; 1770 1771 s->vm_running = running; 1772 while ((hwo = audio_pcm_hw_find_any_enabled_out (hwo))) { 1773 hwo->pcm_ops->ctl_out (hwo, op, conf.try_poll_out); 1774 } 1775 1776 while ((hwi = audio_pcm_hw_find_any_enabled_in (hwi))) { 1777 hwi->pcm_ops->ctl_in (hwi, op, conf.try_poll_in); 1778 } 1779 audio_reset_timer (s); 1780 } 1781 1782 static bool is_cleaning_up; 1783 1784 bool audio_is_cleaning_up(void) 1785 { 1786 return is_cleaning_up; 1787 } 1788 1789 void audio_cleanup(void) 1790 { 1791 AudioState *s = &glob_audio_state; 1792 HWVoiceOut *hwo, *hwon; 1793 HWVoiceIn *hwi, *hwin; 1794 1795 is_cleaning_up = true; 1796 QLIST_FOREACH_SAFE(hwo, &glob_audio_state.hw_head_out, entries, hwon) { 1797 SWVoiceCap *sc; 1798 1799 if (hwo->enabled) { 1800 hwo->pcm_ops->ctl_out (hwo, VOICE_DISABLE); 1801 } 1802 hwo->pcm_ops->fini_out (hwo); 1803 1804 for (sc = hwo->cap_head.lh_first; sc; sc = sc->entries.le_next) { 1805 CaptureVoiceOut *cap = sc->cap; 1806 struct capture_callback *cb; 1807 1808 for (cb = cap->cb_head.lh_first; cb; cb = cb->entries.le_next) { 1809 cb->ops.destroy (cb->opaque); 1810 } 1811 } 1812 QLIST_REMOVE(hwo, entries); 1813 } 1814 1815 QLIST_FOREACH_SAFE(hwi, &glob_audio_state.hw_head_in, entries, hwin) { 1816 if (hwi->enabled) { 1817 hwi->pcm_ops->ctl_in (hwi, VOICE_DISABLE); 1818 } 1819 hwi->pcm_ops->fini_in (hwi); 1820 QLIST_REMOVE(hwi, entries); 1821 } 1822 1823 if (s->drv) { 1824 s->drv->fini (s->drv_opaque); 1825 s->drv = NULL; 1826 } 1827 } 1828 1829 static const VMStateDescription vmstate_audio = { 1830 .name = "audio", 1831 .version_id = 1, 1832 .minimum_version_id = 1, 1833 .fields = (VMStateField[]) { 1834 VMSTATE_END_OF_LIST() 1835 } 1836 }; 1837 1838 static void audio_init (void) 1839 { 1840 size_t i; 1841 int done = 0; 1842 const char *drvname; 1843 VMChangeStateEntry *e; 1844 AudioState *s = &glob_audio_state; 1845 struct audio_driver *driver; 1846 1847 if (s->drv) { 1848 return; 1849 } 1850 1851 QLIST_INIT (&s->hw_head_out); 1852 QLIST_INIT (&s->hw_head_in); 1853 QLIST_INIT (&s->cap_head); 1854 atexit(audio_cleanup); 1855 1856 s->ts = timer_new_ns(QEMU_CLOCK_VIRTUAL, audio_timer, s); 1857 1858 audio_process_options ("AUDIO", audio_options); 1859 1860 s->nb_hw_voices_out = conf.fixed_out.nb_voices; 1861 s->nb_hw_voices_in = conf.fixed_in.nb_voices; 1862 1863 if (s->nb_hw_voices_out <= 0) { 1864 dolog ("Bogus number of playback voices %d, setting to 1\n", 1865 s->nb_hw_voices_out); 1866 s->nb_hw_voices_out = 1; 1867 } 1868 1869 if (s->nb_hw_voices_in <= 0) { 1870 dolog ("Bogus number of capture voices %d, setting to 0\n", 1871 s->nb_hw_voices_in); 1872 s->nb_hw_voices_in = 0; 1873 } 1874 1875 { 1876 int def; 1877 drvname = audio_get_conf_str ("QEMU_AUDIO_DRV", NULL, &def); 1878 } 1879 1880 if (drvname) { 1881 driver = audio_driver_lookup(drvname); 1882 if (driver) { 1883 done = !audio_driver_init(s, driver); 1884 } else { 1885 dolog ("Unknown audio driver `%s'\n", drvname); 1886 dolog ("Run with -audio-help to list available drivers\n"); 1887 } 1888 } 1889 1890 if (!done) { 1891 for (i = 0; !done && i < ARRAY_SIZE(audio_prio_list); i++) { 1892 driver = audio_driver_lookup(audio_prio_list[i]); 1893 if (driver && driver->can_be_default) { 1894 done = !audio_driver_init(s, driver); 1895 } 1896 } 1897 } 1898 1899 if (!done) { 1900 driver = audio_driver_lookup("none"); 1901 done = !audio_driver_init(s, driver); 1902 assert(done); 1903 dolog("warning: Using timer based audio emulation\n"); 1904 } 1905 1906 if (conf.period.hertz <= 0) { 1907 if (conf.period.hertz < 0) { 1908 dolog ("warning: Timer period is negative - %d " 1909 "treating as zero\n", 1910 conf.period.hertz); 1911 } 1912 conf.period.ticks = 1; 1913 } else { 1914 conf.period.ticks = NANOSECONDS_PER_SECOND / conf.period.hertz; 1915 } 1916 1917 e = qemu_add_vm_change_state_handler (audio_vm_change_state_handler, s); 1918 if (!e) { 1919 dolog ("warning: Could not register change state handler\n" 1920 "(Audio can continue looping even after stopping the VM)\n"); 1921 } 1922 1923 QLIST_INIT (&s->card_head); 1924 vmstate_register (NULL, 0, &vmstate_audio, s); 1925 } 1926 1927 void AUD_register_card (const char *name, QEMUSoundCard *card) 1928 { 1929 audio_init (); 1930 card->name = g_strdup (name); 1931 memset (&card->entries, 0, sizeof (card->entries)); 1932 QLIST_INSERT_HEAD (&glob_audio_state.card_head, card, entries); 1933 } 1934 1935 void AUD_remove_card (QEMUSoundCard *card) 1936 { 1937 QLIST_REMOVE (card, entries); 1938 g_free (card->name); 1939 } 1940 1941 1942 CaptureVoiceOut *AUD_add_capture ( 1943 struct audsettings *as, 1944 struct audio_capture_ops *ops, 1945 void *cb_opaque 1946 ) 1947 { 1948 AudioState *s = &glob_audio_state; 1949 CaptureVoiceOut *cap; 1950 struct capture_callback *cb; 1951 1952 if (audio_validate_settings (as)) { 1953 dolog ("Invalid settings were passed when trying to add capture\n"); 1954 audio_print_settings (as); 1955 goto err0; 1956 } 1957 1958 cb = audio_calloc(__func__, 1, sizeof(*cb)); 1959 if (!cb) { 1960 dolog ("Could not allocate capture callback information, size %zu\n", 1961 sizeof (*cb)); 1962 goto err0; 1963 } 1964 cb->ops = *ops; 1965 cb->opaque = cb_opaque; 1966 1967 cap = audio_pcm_capture_find_specific (as); 1968 if (cap) { 1969 QLIST_INSERT_HEAD (&cap->cb_head, cb, entries); 1970 return cap; 1971 } 1972 else { 1973 HWVoiceOut *hw; 1974 CaptureVoiceOut *cap; 1975 1976 cap = audio_calloc(__func__, 1, sizeof(*cap)); 1977 if (!cap) { 1978 dolog ("Could not allocate capture voice, size %zu\n", 1979 sizeof (*cap)); 1980 goto err1; 1981 } 1982 1983 hw = &cap->hw; 1984 QLIST_INIT (&hw->sw_head); 1985 QLIST_INIT (&cap->cb_head); 1986 1987 /* XXX find a more elegant way */ 1988 hw->samples = 4096 * 4; 1989 hw->mix_buf = audio_calloc(__func__, hw->samples, 1990 sizeof(struct st_sample)); 1991 if (!hw->mix_buf) { 1992 dolog ("Could not allocate capture mix buffer (%d samples)\n", 1993 hw->samples); 1994 goto err2; 1995 } 1996 1997 audio_pcm_init_info (&hw->info, as); 1998 1999 cap->buf = audio_calloc(__func__, hw->samples, 1 << hw->info.shift); 2000 if (!cap->buf) { 2001 dolog ("Could not allocate capture buffer " 2002 "(%d samples, each %d bytes)\n", 2003 hw->samples, 1 << hw->info.shift); 2004 goto err3; 2005 } 2006 2007 hw->clip = mixeng_clip 2008 [hw->info.nchannels == 2] 2009 [hw->info.sign] 2010 [hw->info.swap_endianness] 2011 [audio_bits_to_index (hw->info.bits)]; 2012 2013 QLIST_INSERT_HEAD (&s->cap_head, cap, entries); 2014 QLIST_INSERT_HEAD (&cap->cb_head, cb, entries); 2015 2016 QLIST_FOREACH(hw, &glob_audio_state.hw_head_out, entries) { 2017 audio_attach_capture (hw); 2018 } 2019 return cap; 2020 2021 err3: 2022 g_free (cap->hw.mix_buf); 2023 err2: 2024 g_free (cap); 2025 err1: 2026 g_free (cb); 2027 err0: 2028 return NULL; 2029 } 2030 } 2031 2032 void AUD_del_capture (CaptureVoiceOut *cap, void *cb_opaque) 2033 { 2034 struct capture_callback *cb; 2035 2036 for (cb = cap->cb_head.lh_first; cb; cb = cb->entries.le_next) { 2037 if (cb->opaque == cb_opaque) { 2038 cb->ops.destroy (cb_opaque); 2039 QLIST_REMOVE (cb, entries); 2040 g_free (cb); 2041 2042 if (!cap->cb_head.lh_first) { 2043 SWVoiceOut *sw = cap->hw.sw_head.lh_first, *sw1; 2044 2045 while (sw) { 2046 SWVoiceCap *sc = (SWVoiceCap *) sw; 2047 #ifdef DEBUG_CAPTURE 2048 dolog ("freeing %s\n", sw->name); 2049 #endif 2050 2051 sw1 = sw->entries.le_next; 2052 if (sw->rate) { 2053 st_rate_stop (sw->rate); 2054 sw->rate = NULL; 2055 } 2056 QLIST_REMOVE (sw, entries); 2057 QLIST_REMOVE (sc, entries); 2058 g_free (sc); 2059 sw = sw1; 2060 } 2061 QLIST_REMOVE (cap, entries); 2062 g_free (cap->hw.mix_buf); 2063 g_free (cap->buf); 2064 g_free (cap); 2065 } 2066 return; 2067 } 2068 } 2069 } 2070 2071 void AUD_set_volume_out (SWVoiceOut *sw, int mute, uint8_t lvol, uint8_t rvol) 2072 { 2073 if (sw) { 2074 HWVoiceOut *hw = sw->hw; 2075 2076 sw->vol.mute = mute; 2077 sw->vol.l = nominal_volume.l * lvol / 255; 2078 sw->vol.r = nominal_volume.r * rvol / 255; 2079 2080 if (hw->pcm_ops->ctl_out) { 2081 hw->pcm_ops->ctl_out (hw, VOICE_VOLUME, sw); 2082 } 2083 } 2084 } 2085 2086 void AUD_set_volume_in (SWVoiceIn *sw, int mute, uint8_t lvol, uint8_t rvol) 2087 { 2088 if (sw) { 2089 HWVoiceIn *hw = sw->hw; 2090 2091 sw->vol.mute = mute; 2092 sw->vol.l = nominal_volume.l * lvol / 255; 2093 sw->vol.r = nominal_volume.r * rvol / 255; 2094 2095 if (hw->pcm_ops->ctl_in) { 2096 hw->pcm_ops->ctl_in (hw, VOICE_VOLUME, sw); 2097 } 2098 } 2099 } 2100