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