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 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 qemu_mallocz (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 = qemu_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 qemu_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 = qemu_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 qemu_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, 706 int samples, struct mixeng_volume *vol) 707 { 708 (void) src; 709 (void) dst; 710 (void) samples; 711 (void) vol; 712 } 713 714 static CaptureVoiceOut *audio_pcm_capture_find_specific ( 715 struct audsettings *as 716 ) 717 { 718 CaptureVoiceOut *cap; 719 AudioState *s = &glob_audio_state; 720 721 for (cap = s->cap_head.lh_first; cap; cap = cap->entries.le_next) { 722 if (audio_pcm_info_eq (&cap->hw.info, as)) { 723 return cap; 724 } 725 } 726 return NULL; 727 } 728 729 static void audio_notify_capture (CaptureVoiceOut *cap, audcnotification_e cmd) 730 { 731 struct capture_callback *cb; 732 733 #ifdef DEBUG_CAPTURE 734 dolog ("notification %d sent\n", cmd); 735 #endif 736 for (cb = cap->cb_head.lh_first; cb; cb = cb->entries.le_next) { 737 cb->ops.notify (cb->opaque, cmd); 738 } 739 } 740 741 static void audio_capture_maybe_changed (CaptureVoiceOut *cap, int enabled) 742 { 743 if (cap->hw.enabled != enabled) { 744 audcnotification_e cmd; 745 cap->hw.enabled = enabled; 746 cmd = enabled ? AUD_CNOTIFY_ENABLE : AUD_CNOTIFY_DISABLE; 747 audio_notify_capture (cap, cmd); 748 } 749 } 750 751 static void audio_recalc_and_notify_capture (CaptureVoiceOut *cap) 752 { 753 HWVoiceOut *hw = &cap->hw; 754 SWVoiceOut *sw; 755 int enabled = 0; 756 757 for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) { 758 if (sw->active) { 759 enabled = 1; 760 break; 761 } 762 } 763 audio_capture_maybe_changed (cap, enabled); 764 } 765 766 static void audio_detach_capture (HWVoiceOut *hw) 767 { 768 SWVoiceCap *sc = hw->cap_head.lh_first; 769 770 while (sc) { 771 SWVoiceCap *sc1 = sc->entries.le_next; 772 SWVoiceOut *sw = &sc->sw; 773 CaptureVoiceOut *cap = sc->cap; 774 int was_active = sw->active; 775 776 if (sw->rate) { 777 st_rate_stop (sw->rate); 778 sw->rate = NULL; 779 } 780 781 QLIST_REMOVE (sw, entries); 782 QLIST_REMOVE (sc, entries); 783 qemu_free (sc); 784 if (was_active) { 785 /* We have removed soft voice from the capture: 786 this might have changed the overall status of the capture 787 since this might have been the only active voice */ 788 audio_recalc_and_notify_capture (cap); 789 } 790 sc = sc1; 791 } 792 } 793 794 static int audio_attach_capture (HWVoiceOut *hw) 795 { 796 AudioState *s = &glob_audio_state; 797 CaptureVoiceOut *cap; 798 799 audio_detach_capture (hw); 800 for (cap = s->cap_head.lh_first; cap; cap = cap->entries.le_next) { 801 SWVoiceCap *sc; 802 SWVoiceOut *sw; 803 HWVoiceOut *hw_cap = &cap->hw; 804 805 sc = audio_calloc (AUDIO_FUNC, 1, sizeof (*sc)); 806 if (!sc) { 807 dolog ("Could not allocate soft capture voice (%zu bytes)\n", 808 sizeof (*sc)); 809 return -1; 810 } 811 812 sc->cap = cap; 813 sw = &sc->sw; 814 sw->hw = hw_cap; 815 sw->info = hw->info; 816 sw->empty = 1; 817 sw->active = hw->enabled; 818 sw->conv = noop_conv; 819 sw->ratio = ((int64_t) hw_cap->info.freq << 32) / sw->info.freq; 820 sw->rate = st_rate_start (sw->info.freq, hw_cap->info.freq); 821 if (!sw->rate) { 822 dolog ("Could not start rate conversion for `%s'\n", SW_NAME (sw)); 823 qemu_free (sw); 824 return -1; 825 } 826 QLIST_INSERT_HEAD (&hw_cap->sw_head, sw, entries); 827 QLIST_INSERT_HEAD (&hw->cap_head, sc, entries); 828 #ifdef DEBUG_CAPTURE 829 asprintf (&sw->name, "for %p %d,%d,%d", 830 hw, sw->info.freq, sw->info.bits, sw->info.nchannels); 831 dolog ("Added %s active = %d\n", sw->name, sw->active); 832 #endif 833 if (sw->active) { 834 audio_capture_maybe_changed (cap, 1); 835 } 836 } 837 return 0; 838 } 839 840 /* 841 * Hard voice (capture) 842 */ 843 static int audio_pcm_hw_find_min_in (HWVoiceIn *hw) 844 { 845 SWVoiceIn *sw; 846 int m = hw->total_samples_captured; 847 848 for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) { 849 if (sw->active) { 850 m = audio_MIN (m, sw->total_hw_samples_acquired); 851 } 852 } 853 return m; 854 } 855 856 int audio_pcm_hw_get_live_in (HWVoiceIn *hw) 857 { 858 int live = hw->total_samples_captured - audio_pcm_hw_find_min_in (hw); 859 if (audio_bug (AUDIO_FUNC, live < 0 || live > hw->samples)) { 860 dolog ("live=%d hw->samples=%d\n", live, hw->samples); 861 return 0; 862 } 863 return live; 864 } 865 866 int audio_pcm_hw_clip_out (HWVoiceOut *hw, void *pcm_buf, 867 int live, int pending) 868 { 869 int left = hw->samples - pending; 870 int len = audio_MIN (left, live); 871 int clipped = 0; 872 873 while (len) { 874 struct st_sample *src = hw->mix_buf + hw->rpos; 875 uint8_t *dst = advance (pcm_buf, hw->rpos << hw->info.shift); 876 int samples_till_end_of_buf = hw->samples - hw->rpos; 877 int samples_to_clip = audio_MIN (len, samples_till_end_of_buf); 878 879 hw->clip (dst, src, samples_to_clip); 880 881 hw->rpos = (hw->rpos + samples_to_clip) % hw->samples; 882 len -= samples_to_clip; 883 clipped += samples_to_clip; 884 } 885 return clipped; 886 } 887 888 /* 889 * Soft voice (capture) 890 */ 891 static int audio_pcm_sw_get_rpos_in (SWVoiceIn *sw) 892 { 893 HWVoiceIn *hw = sw->hw; 894 int live = hw->total_samples_captured - sw->total_hw_samples_acquired; 895 int rpos; 896 897 if (audio_bug (AUDIO_FUNC, live < 0 || live > hw->samples)) { 898 dolog ("live=%d hw->samples=%d\n", live, hw->samples); 899 return 0; 900 } 901 902 rpos = hw->wpos - live; 903 if (rpos >= 0) { 904 return rpos; 905 } 906 else { 907 return hw->samples + rpos; 908 } 909 } 910 911 int audio_pcm_sw_read (SWVoiceIn *sw, void *buf, int size) 912 { 913 HWVoiceIn *hw = sw->hw; 914 int samples, live, ret = 0, swlim, isamp, osamp, rpos, total = 0; 915 struct st_sample *src, *dst = sw->buf; 916 917 rpos = audio_pcm_sw_get_rpos_in (sw) % hw->samples; 918 919 live = hw->total_samples_captured - sw->total_hw_samples_acquired; 920 if (audio_bug (AUDIO_FUNC, live < 0 || live > hw->samples)) { 921 dolog ("live_in=%d hw->samples=%d\n", live, hw->samples); 922 return 0; 923 } 924 925 samples = size >> sw->info.shift; 926 if (!live) { 927 return 0; 928 } 929 930 swlim = (live * sw->ratio) >> 32; 931 swlim = audio_MIN (swlim, samples); 932 933 while (swlim) { 934 src = hw->conv_buf + rpos; 935 isamp = hw->wpos - rpos; 936 /* XXX: <= ? */ 937 if (isamp <= 0) { 938 isamp = hw->samples - rpos; 939 } 940 941 if (!isamp) { 942 break; 943 } 944 osamp = swlim; 945 946 if (audio_bug (AUDIO_FUNC, osamp < 0)) { 947 dolog ("osamp=%d\n", osamp); 948 return 0; 949 } 950 951 st_rate_flow (sw->rate, src, dst, &isamp, &osamp); 952 swlim -= osamp; 953 rpos = (rpos + isamp) % hw->samples; 954 dst += osamp; 955 ret += osamp; 956 total += isamp; 957 } 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, &sw->vol); 1041 } 1042 1043 while (swlim) { 1044 dead = hwsamples - live; 1045 left = hwsamples - wpos; 1046 blck = audio_MIN (dead, left); 1047 if (!blck) { 1048 break; 1049 } 1050 isamp = swlim; 1051 osamp = blck; 1052 st_rate_flow_mix ( 1053 sw->rate, 1054 sw->buf + pos, 1055 sw->hw->mix_buf + wpos, 1056 &isamp, 1057 &osamp 1058 ); 1059 ret += isamp; 1060 swlim -= isamp; 1061 pos += isamp; 1062 live += osamp; 1063 wpos = (wpos + osamp) % hwsamples; 1064 total += osamp; 1065 } 1066 1067 sw->total_hw_samples_mixed += total; 1068 sw->empty = sw->total_hw_samples_mixed == 0; 1069 1070 #ifdef DEBUG_OUT 1071 dolog ( 1072 "%s: write size %d ret %d total sw %d\n", 1073 SW_NAME (sw), 1074 size >> sw->info.shift, 1075 ret, 1076 sw->total_hw_samples_mixed 1077 ); 1078 #endif 1079 1080 return ret << sw->info.shift; 1081 } 1082 1083 #ifdef DEBUG_AUDIO 1084 static void audio_pcm_print_info (const char *cap, struct audio_pcm_info *info) 1085 { 1086 dolog ("%s: bits %d, sign %d, freq %d, nchan %d\n", 1087 cap, info->bits, info->sign, info->freq, info->nchannels); 1088 } 1089 #endif 1090 1091 #define DAC 1092 #include "audio_template.h" 1093 #undef DAC 1094 #include "audio_template.h" 1095 1096 /* 1097 * Timer 1098 */ 1099 static int audio_is_timer_needed (void) 1100 { 1101 HWVoiceIn *hwi = NULL; 1102 HWVoiceOut *hwo = NULL; 1103 1104 while ((hwo = audio_pcm_hw_find_any_enabled_out (hwo))) { 1105 if (!hwo->poll_mode) return 1; 1106 } 1107 while ((hwi = audio_pcm_hw_find_any_enabled_in (hwi))) { 1108 if (!hwi->poll_mode) return 1; 1109 } 1110 return 0; 1111 } 1112 1113 static void audio_reset_timer (AudioState *s) 1114 { 1115 if (audio_is_timer_needed ()) { 1116 qemu_mod_timer (s->ts, qemu_get_clock (vm_clock) + 1); 1117 } 1118 else { 1119 qemu_del_timer (s->ts); 1120 } 1121 } 1122 1123 static void audio_timer (void *opaque) 1124 { 1125 audio_run ("timer"); 1126 audio_reset_timer (opaque); 1127 } 1128 1129 /* 1130 * Public API 1131 */ 1132 int AUD_write (SWVoiceOut *sw, void *buf, int size) 1133 { 1134 int bytes; 1135 1136 if (!sw) { 1137 /* XXX: Consider options */ 1138 return size; 1139 } 1140 1141 if (!sw->hw->enabled) { 1142 dolog ("Writing to disabled voice %s\n", SW_NAME (sw)); 1143 return 0; 1144 } 1145 1146 bytes = sw->hw->pcm_ops->write (sw, buf, size); 1147 return bytes; 1148 } 1149 1150 int AUD_read (SWVoiceIn *sw, void *buf, int size) 1151 { 1152 int bytes; 1153 1154 if (!sw) { 1155 /* XXX: Consider options */ 1156 return size; 1157 } 1158 1159 if (!sw->hw->enabled) { 1160 dolog ("Reading from disabled voice %s\n", SW_NAME (sw)); 1161 return 0; 1162 } 1163 1164 bytes = sw->hw->pcm_ops->read (sw, buf, size); 1165 return bytes; 1166 } 1167 1168 int AUD_get_buffer_size_out (SWVoiceOut *sw) 1169 { 1170 return sw->hw->samples << sw->hw->info.shift; 1171 } 1172 1173 void AUD_set_active_out (SWVoiceOut *sw, int on) 1174 { 1175 HWVoiceOut *hw; 1176 1177 if (!sw) { 1178 return; 1179 } 1180 1181 hw = sw->hw; 1182 if (sw->active != on) { 1183 AudioState *s = &glob_audio_state; 1184 SWVoiceOut *temp_sw; 1185 SWVoiceCap *sc; 1186 1187 if (on) { 1188 hw->pending_disable = 0; 1189 if (!hw->enabled) { 1190 hw->enabled = 1; 1191 if (s->vm_running) { 1192 hw->pcm_ops->ctl_out (hw, VOICE_ENABLE, conf.try_poll_out); 1193 audio_reset_timer (s); 1194 } 1195 } 1196 } 1197 else { 1198 if (hw->enabled) { 1199 int nb_active = 0; 1200 1201 for (temp_sw = hw->sw_head.lh_first; temp_sw; 1202 temp_sw = temp_sw->entries.le_next) { 1203 nb_active += temp_sw->active != 0; 1204 } 1205 1206 hw->pending_disable = nb_active == 1; 1207 } 1208 } 1209 1210 for (sc = hw->cap_head.lh_first; sc; sc = sc->entries.le_next) { 1211 sc->sw.active = hw->enabled; 1212 if (hw->enabled) { 1213 audio_capture_maybe_changed (sc->cap, 1); 1214 } 1215 } 1216 sw->active = on; 1217 } 1218 } 1219 1220 void AUD_set_active_in (SWVoiceIn *sw, int on) 1221 { 1222 HWVoiceIn *hw; 1223 1224 if (!sw) { 1225 return; 1226 } 1227 1228 hw = sw->hw; 1229 if (sw->active != on) { 1230 AudioState *s = &glob_audio_state; 1231 SWVoiceIn *temp_sw; 1232 1233 if (on) { 1234 if (!hw->enabled) { 1235 hw->enabled = 1; 1236 if (s->vm_running) { 1237 hw->pcm_ops->ctl_in (hw, VOICE_ENABLE, conf.try_poll_in); 1238 audio_reset_timer (s); 1239 } 1240 } 1241 sw->total_hw_samples_acquired = hw->total_samples_captured; 1242 } 1243 else { 1244 if (hw->enabled) { 1245 int nb_active = 0; 1246 1247 for (temp_sw = hw->sw_head.lh_first; temp_sw; 1248 temp_sw = temp_sw->entries.le_next) { 1249 nb_active += temp_sw->active != 0; 1250 } 1251 1252 if (nb_active == 1) { 1253 hw->enabled = 0; 1254 hw->pcm_ops->ctl_in (hw, VOICE_DISABLE); 1255 } 1256 } 1257 } 1258 sw->active = on; 1259 } 1260 } 1261 1262 static int audio_get_avail (SWVoiceIn *sw) 1263 { 1264 int live; 1265 1266 if (!sw) { 1267 return 0; 1268 } 1269 1270 live = sw->hw->total_samples_captured - sw->total_hw_samples_acquired; 1271 if (audio_bug (AUDIO_FUNC, live < 0 || live > sw->hw->samples)) { 1272 dolog ("live=%d sw->hw->samples=%d\n", live, sw->hw->samples); 1273 return 0; 1274 } 1275 1276 ldebug ( 1277 "%s: get_avail live %d ret %" PRId64 "\n", 1278 SW_NAME (sw), 1279 live, (((int64_t) live << 32) / sw->ratio) << sw->info.shift 1280 ); 1281 1282 return (((int64_t) live << 32) / sw->ratio) << sw->info.shift; 1283 } 1284 1285 static int audio_get_free (SWVoiceOut *sw) 1286 { 1287 int live, dead; 1288 1289 if (!sw) { 1290 return 0; 1291 } 1292 1293 live = sw->total_hw_samples_mixed; 1294 1295 if (audio_bug (AUDIO_FUNC, live < 0 || live > sw->hw->samples)) { 1296 dolog ("live=%d sw->hw->samples=%d\n", live, sw->hw->samples); 1297 return 0; 1298 } 1299 1300 dead = sw->hw->samples - live; 1301 1302 #ifdef DEBUG_OUT 1303 dolog ("%s: get_free live %d dead %d ret %" PRId64 "\n", 1304 SW_NAME (sw), 1305 live, dead, (((int64_t) dead << 32) / sw->ratio) << sw->info.shift); 1306 #endif 1307 1308 return (((int64_t) dead << 32) / sw->ratio) << sw->info.shift; 1309 } 1310 1311 static void audio_capture_mix_and_clear (HWVoiceOut *hw, int rpos, int samples) 1312 { 1313 int n; 1314 1315 if (hw->enabled) { 1316 SWVoiceCap *sc; 1317 1318 for (sc = hw->cap_head.lh_first; sc; sc = sc->entries.le_next) { 1319 SWVoiceOut *sw = &sc->sw; 1320 int rpos2 = rpos; 1321 1322 n = samples; 1323 while (n) { 1324 int till_end_of_hw = hw->samples - rpos2; 1325 int to_write = audio_MIN (till_end_of_hw, n); 1326 int bytes = to_write << hw->info.shift; 1327 int written; 1328 1329 sw->buf = hw->mix_buf + rpos2; 1330 written = audio_pcm_sw_write (sw, NULL, bytes); 1331 if (written - bytes) { 1332 dolog ("Could not mix %d bytes into a capture " 1333 "buffer, mixed %d\n", 1334 bytes, written); 1335 break; 1336 } 1337 n -= to_write; 1338 rpos2 = (rpos2 + to_write) % hw->samples; 1339 } 1340 } 1341 } 1342 1343 n = audio_MIN (samples, hw->samples - rpos); 1344 mixeng_clear (hw->mix_buf + rpos, n); 1345 mixeng_clear (hw->mix_buf, samples - n); 1346 } 1347 1348 static void audio_run_out (AudioState *s) 1349 { 1350 HWVoiceOut *hw = NULL; 1351 SWVoiceOut *sw; 1352 1353 while ((hw = audio_pcm_hw_find_any_enabled_out (hw))) { 1354 int played; 1355 int live, free, nb_live, cleanup_required, prev_rpos; 1356 1357 live = audio_pcm_hw_get_live_out (hw, &nb_live); 1358 if (!nb_live) { 1359 live = 0; 1360 } 1361 1362 if (audio_bug (AUDIO_FUNC, live < 0 || live > hw->samples)) { 1363 dolog ("live=%d hw->samples=%d\n", live, hw->samples); 1364 continue; 1365 } 1366 1367 if (hw->pending_disable && !nb_live) { 1368 SWVoiceCap *sc; 1369 #ifdef DEBUG_OUT 1370 dolog ("Disabling voice\n"); 1371 #endif 1372 hw->enabled = 0; 1373 hw->pending_disable = 0; 1374 hw->pcm_ops->ctl_out (hw, VOICE_DISABLE); 1375 for (sc = hw->cap_head.lh_first; sc; sc = sc->entries.le_next) { 1376 sc->sw.active = 0; 1377 audio_recalc_and_notify_capture (sc->cap); 1378 } 1379 continue; 1380 } 1381 1382 if (!live) { 1383 for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) { 1384 if (sw->active) { 1385 free = audio_get_free (sw); 1386 if (free > 0) { 1387 sw->callback.fn (sw->callback.opaque, free); 1388 } 1389 } 1390 } 1391 continue; 1392 } 1393 1394 prev_rpos = hw->rpos; 1395 played = hw->pcm_ops->run_out (hw, live); 1396 if (audio_bug (AUDIO_FUNC, hw->rpos >= hw->samples)) { 1397 dolog ("hw->rpos=%d hw->samples=%d played=%d\n", 1398 hw->rpos, hw->samples, played); 1399 hw->rpos = 0; 1400 } 1401 1402 #ifdef DEBUG_OUT 1403 dolog ("played=%d\n", played); 1404 #endif 1405 1406 if (played) { 1407 hw->ts_helper += played; 1408 audio_capture_mix_and_clear (hw, prev_rpos, played); 1409 } 1410 1411 cleanup_required = 0; 1412 for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) { 1413 if (!sw->active && sw->empty) { 1414 continue; 1415 } 1416 1417 if (audio_bug (AUDIO_FUNC, played > sw->total_hw_samples_mixed)) { 1418 dolog ("played=%d sw->total_hw_samples_mixed=%d\n", 1419 played, sw->total_hw_samples_mixed); 1420 played = sw->total_hw_samples_mixed; 1421 } 1422 1423 sw->total_hw_samples_mixed -= played; 1424 1425 if (!sw->total_hw_samples_mixed) { 1426 sw->empty = 1; 1427 cleanup_required |= !sw->active && !sw->callback.fn; 1428 } 1429 1430 if (sw->active) { 1431 free = audio_get_free (sw); 1432 if (free > 0) { 1433 sw->callback.fn (sw->callback.opaque, free); 1434 } 1435 } 1436 } 1437 1438 if (cleanup_required) { 1439 SWVoiceOut *sw1; 1440 1441 sw = hw->sw_head.lh_first; 1442 while (sw) { 1443 sw1 = sw->entries.le_next; 1444 if (!sw->active && !sw->callback.fn) { 1445 #ifdef DEBUG_PLIVE 1446 dolog ("Finishing with old voice\n"); 1447 #endif 1448 audio_close_out (sw); 1449 } 1450 sw = sw1; 1451 } 1452 } 1453 } 1454 } 1455 1456 static void audio_run_in (AudioState *s) 1457 { 1458 HWVoiceIn *hw = NULL; 1459 1460 while ((hw = audio_pcm_hw_find_any_enabled_in (hw))) { 1461 SWVoiceIn *sw; 1462 int captured, min; 1463 1464 captured = hw->pcm_ops->run_in (hw); 1465 1466 min = audio_pcm_hw_find_min_in (hw); 1467 hw->total_samples_captured += captured - min; 1468 hw->ts_helper += captured; 1469 1470 for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) { 1471 sw->total_hw_samples_acquired -= min; 1472 1473 if (sw->active) { 1474 int avail; 1475 1476 avail = audio_get_avail (sw); 1477 if (avail > 0) { 1478 sw->callback.fn (sw->callback.opaque, avail); 1479 } 1480 } 1481 } 1482 } 1483 } 1484 1485 static void audio_run_capture (AudioState *s) 1486 { 1487 CaptureVoiceOut *cap; 1488 1489 for (cap = s->cap_head.lh_first; cap; cap = cap->entries.le_next) { 1490 int live, rpos, captured; 1491 HWVoiceOut *hw = &cap->hw; 1492 SWVoiceOut *sw; 1493 1494 captured = live = audio_pcm_hw_get_live_out (hw, NULL); 1495 rpos = hw->rpos; 1496 while (live) { 1497 int left = hw->samples - rpos; 1498 int to_capture = audio_MIN (live, left); 1499 struct st_sample *src; 1500 struct capture_callback *cb; 1501 1502 src = hw->mix_buf + rpos; 1503 hw->clip (cap->buf, src, to_capture); 1504 mixeng_clear (src, to_capture); 1505 1506 for (cb = cap->cb_head.lh_first; cb; cb = cb->entries.le_next) { 1507 cb->ops.capture (cb->opaque, cap->buf, 1508 to_capture << hw->info.shift); 1509 } 1510 rpos = (rpos + to_capture) % hw->samples; 1511 live -= to_capture; 1512 } 1513 hw->rpos = rpos; 1514 1515 for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) { 1516 if (!sw->active && sw->empty) { 1517 continue; 1518 } 1519 1520 if (audio_bug (AUDIO_FUNC, captured > sw->total_hw_samples_mixed)) { 1521 dolog ("captured=%d sw->total_hw_samples_mixed=%d\n", 1522 captured, sw->total_hw_samples_mixed); 1523 captured = sw->total_hw_samples_mixed; 1524 } 1525 1526 sw->total_hw_samples_mixed -= captured; 1527 sw->empty = sw->total_hw_samples_mixed == 0; 1528 } 1529 } 1530 } 1531 1532 void audio_run (const char *msg) 1533 { 1534 AudioState *s = &glob_audio_state; 1535 1536 audio_run_out (s); 1537 audio_run_in (s); 1538 audio_run_capture (s); 1539 #ifdef DEBUG_POLL 1540 { 1541 static double prevtime; 1542 double currtime; 1543 struct timeval tv; 1544 1545 if (gettimeofday (&tv, NULL)) { 1546 perror ("audio_run: gettimeofday"); 1547 return; 1548 } 1549 1550 currtime = tv.tv_sec + tv.tv_usec * 1e-6; 1551 dolog ("Elapsed since last %s: %f\n", msg, currtime - prevtime); 1552 prevtime = currtime; 1553 } 1554 #endif 1555 } 1556 1557 static struct audio_option audio_options[] = { 1558 /* DAC */ 1559 { 1560 .name = "DAC_FIXED_SETTINGS", 1561 .tag = AUD_OPT_BOOL, 1562 .valp = &conf.fixed_out.enabled, 1563 .descr = "Use fixed settings for host DAC" 1564 }, 1565 { 1566 .name = "DAC_FIXED_FREQ", 1567 .tag = AUD_OPT_INT, 1568 .valp = &conf.fixed_out.settings.freq, 1569 .descr = "Frequency for fixed host DAC" 1570 }, 1571 { 1572 .name = "DAC_FIXED_FMT", 1573 .tag = AUD_OPT_FMT, 1574 .valp = &conf.fixed_out.settings.fmt, 1575 .descr = "Format for fixed host DAC" 1576 }, 1577 { 1578 .name = "DAC_FIXED_CHANNELS", 1579 .tag = AUD_OPT_INT, 1580 .valp = &conf.fixed_out.settings.nchannels, 1581 .descr = "Number of channels for fixed DAC (1 - mono, 2 - stereo)" 1582 }, 1583 { 1584 .name = "DAC_VOICES", 1585 .tag = AUD_OPT_INT, 1586 .valp = &conf.fixed_out.nb_voices, 1587 .descr = "Number of voices for DAC" 1588 }, 1589 { 1590 .name = "DAC_TRY_POLL", 1591 .tag = AUD_OPT_BOOL, 1592 .valp = &conf.try_poll_out, 1593 .descr = "Attempt using poll mode for DAC" 1594 }, 1595 /* ADC */ 1596 { 1597 .name = "ADC_FIXED_SETTINGS", 1598 .tag = AUD_OPT_BOOL, 1599 .valp = &conf.fixed_in.enabled, 1600 .descr = "Use fixed settings for host ADC" 1601 }, 1602 { 1603 .name = "ADC_FIXED_FREQ", 1604 .tag = AUD_OPT_INT, 1605 .valp = &conf.fixed_in.settings.freq, 1606 .descr = "Frequency for fixed host ADC" 1607 }, 1608 { 1609 .name = "ADC_FIXED_FMT", 1610 .tag = AUD_OPT_FMT, 1611 .valp = &conf.fixed_in.settings.fmt, 1612 .descr = "Format for fixed host ADC" 1613 }, 1614 { 1615 .name = "ADC_FIXED_CHANNELS", 1616 .tag = AUD_OPT_INT, 1617 .valp = &conf.fixed_in.settings.nchannels, 1618 .descr = "Number of channels for fixed ADC (1 - mono, 2 - stereo)" 1619 }, 1620 { 1621 .name = "ADC_VOICES", 1622 .tag = AUD_OPT_INT, 1623 .valp = &conf.fixed_in.nb_voices, 1624 .descr = "Number of voices for ADC" 1625 }, 1626 { 1627 .name = "ADC_TRY_POLL", 1628 .tag = AUD_OPT_BOOL, 1629 .valp = &conf.try_poll_in, 1630 .descr = "Attempt using poll mode for ADC" 1631 }, 1632 /* Misc */ 1633 { 1634 .name = "TIMER_PERIOD", 1635 .tag = AUD_OPT_INT, 1636 .valp = &conf.period.hertz, 1637 .descr = "Timer period in HZ (0 - use lowest possible)" 1638 }, 1639 { 1640 .name = "PLIVE", 1641 .tag = AUD_OPT_BOOL, 1642 .valp = &conf.plive, 1643 .descr = "(undocumented)" 1644 }, 1645 { 1646 .name = "LOG_TO_MONITOR", 1647 .tag = AUD_OPT_BOOL, 1648 .valp = &conf.log_to_monitor, 1649 .descr = "Print logging messages to monitor instead of stderr" 1650 }, 1651 { /* End of list */ } 1652 }; 1653 1654 static void audio_pp_nb_voices (const char *typ, int nb) 1655 { 1656 switch (nb) { 1657 case 0: 1658 printf ("Does not support %s\n", typ); 1659 break; 1660 case 1: 1661 printf ("One %s voice\n", typ); 1662 break; 1663 case INT_MAX: 1664 printf ("Theoretically supports many %s voices\n", typ); 1665 break; 1666 default: 1667 printf ("Theoretically supports upto %d %s voices\n", nb, typ); 1668 break; 1669 } 1670 1671 } 1672 1673 void AUD_help (void) 1674 { 1675 size_t i; 1676 1677 audio_process_options ("AUDIO", audio_options); 1678 for (i = 0; i < ARRAY_SIZE (drvtab); i++) { 1679 struct audio_driver *d = drvtab[i]; 1680 if (d->options) { 1681 audio_process_options (d->name, d->options); 1682 } 1683 } 1684 1685 printf ("Audio options:\n"); 1686 audio_print_options ("AUDIO", audio_options); 1687 printf ("\n"); 1688 1689 printf ("Available drivers:\n"); 1690 1691 for (i = 0; i < ARRAY_SIZE (drvtab); i++) { 1692 struct audio_driver *d = drvtab[i]; 1693 1694 printf ("Name: %s\n", d->name); 1695 printf ("Description: %s\n", d->descr); 1696 1697 audio_pp_nb_voices ("playback", d->max_voices_out); 1698 audio_pp_nb_voices ("capture", d->max_voices_in); 1699 1700 if (d->options) { 1701 printf ("Options:\n"); 1702 audio_print_options (d->name, d->options); 1703 } 1704 else { 1705 printf ("No options\n"); 1706 } 1707 printf ("\n"); 1708 } 1709 1710 printf ( 1711 "Options are settable through environment variables.\n" 1712 "Example:\n" 1713 #ifdef _WIN32 1714 " set QEMU_AUDIO_DRV=wav\n" 1715 " set QEMU_WAV_PATH=c:\\tune.wav\n" 1716 #else 1717 " export QEMU_AUDIO_DRV=wav\n" 1718 " export QEMU_WAV_PATH=$HOME/tune.wav\n" 1719 "(for csh replace export with setenv in the above)\n" 1720 #endif 1721 " qemu ...\n\n" 1722 ); 1723 } 1724 1725 static int audio_driver_init (AudioState *s, struct audio_driver *drv) 1726 { 1727 if (drv->options) { 1728 audio_process_options (drv->name, drv->options); 1729 } 1730 s->drv_opaque = drv->init (); 1731 1732 if (s->drv_opaque) { 1733 audio_init_nb_voices_out (drv); 1734 audio_init_nb_voices_in (drv); 1735 s->drv = drv; 1736 return 0; 1737 } 1738 else { 1739 dolog ("Could not init `%s' audio driver\n", drv->name); 1740 return -1; 1741 } 1742 } 1743 1744 static void audio_vm_change_state_handler (void *opaque, int running, 1745 int reason) 1746 { 1747 AudioState *s = opaque; 1748 HWVoiceOut *hwo = NULL; 1749 HWVoiceIn *hwi = NULL; 1750 int op = running ? VOICE_ENABLE : VOICE_DISABLE; 1751 1752 s->vm_running = running; 1753 while ((hwo = audio_pcm_hw_find_any_enabled_out (hwo))) { 1754 hwo->pcm_ops->ctl_out (hwo, op, conf.try_poll_out); 1755 } 1756 1757 while ((hwi = audio_pcm_hw_find_any_enabled_in (hwi))) { 1758 hwi->pcm_ops->ctl_in (hwi, op, conf.try_poll_in); 1759 } 1760 audio_reset_timer (s); 1761 } 1762 1763 static void audio_atexit (void) 1764 { 1765 AudioState *s = &glob_audio_state; 1766 HWVoiceOut *hwo = NULL; 1767 HWVoiceIn *hwi = NULL; 1768 1769 while ((hwo = audio_pcm_hw_find_any_enabled_out (hwo))) { 1770 SWVoiceCap *sc; 1771 1772 hwo->pcm_ops->ctl_out (hwo, VOICE_DISABLE); 1773 hwo->pcm_ops->fini_out (hwo); 1774 1775 for (sc = hwo->cap_head.lh_first; sc; sc = sc->entries.le_next) { 1776 CaptureVoiceOut *cap = sc->cap; 1777 struct capture_callback *cb; 1778 1779 for (cb = cap->cb_head.lh_first; cb; cb = cb->entries.le_next) { 1780 cb->ops.destroy (cb->opaque); 1781 } 1782 } 1783 } 1784 1785 while ((hwi = audio_pcm_hw_find_any_enabled_in (hwi))) { 1786 hwi->pcm_ops->ctl_in (hwi, VOICE_DISABLE); 1787 hwi->pcm_ops->fini_in (hwi); 1788 } 1789 1790 if (s->drv) { 1791 s->drv->fini (s->drv_opaque); 1792 } 1793 } 1794 1795 static const VMStateDescription vmstate_audio = { 1796 .name = "audio", 1797 .version_id = 1, 1798 .minimum_version_id = 1, 1799 .minimum_version_id_old = 1, 1800 .fields = (VMStateField []) { 1801 VMSTATE_END_OF_LIST() 1802 } 1803 }; 1804 1805 static void audio_init (void) 1806 { 1807 size_t i; 1808 int done = 0; 1809 const char *drvname; 1810 VMChangeStateEntry *e; 1811 AudioState *s = &glob_audio_state; 1812 1813 if (s->drv) { 1814 return; 1815 } 1816 1817 QLIST_INIT (&s->hw_head_out); 1818 QLIST_INIT (&s->hw_head_in); 1819 QLIST_INIT (&s->cap_head); 1820 atexit (audio_atexit); 1821 1822 s->ts = qemu_new_timer (vm_clock, audio_timer, s); 1823 if (!s->ts) { 1824 hw_error("Could not create audio timer\n"); 1825 } 1826 1827 audio_process_options ("AUDIO", audio_options); 1828 1829 s->nb_hw_voices_out = conf.fixed_out.nb_voices; 1830 s->nb_hw_voices_in = conf.fixed_in.nb_voices; 1831 1832 if (s->nb_hw_voices_out <= 0) { 1833 dolog ("Bogus number of playback voices %d, setting to 1\n", 1834 s->nb_hw_voices_out); 1835 s->nb_hw_voices_out = 1; 1836 } 1837 1838 if (s->nb_hw_voices_in <= 0) { 1839 dolog ("Bogus number of capture voices %d, setting to 0\n", 1840 s->nb_hw_voices_in); 1841 s->nb_hw_voices_in = 0; 1842 } 1843 1844 { 1845 int def; 1846 drvname = audio_get_conf_str ("QEMU_AUDIO_DRV", NULL, &def); 1847 } 1848 1849 if (drvname) { 1850 int found = 0; 1851 1852 for (i = 0; i < ARRAY_SIZE (drvtab); i++) { 1853 if (!strcmp (drvname, drvtab[i]->name)) { 1854 done = !audio_driver_init (s, drvtab[i]); 1855 found = 1; 1856 break; 1857 } 1858 } 1859 1860 if (!found) { 1861 dolog ("Unknown audio driver `%s'\n", drvname); 1862 dolog ("Run with -audio-help to list available drivers\n"); 1863 } 1864 } 1865 1866 if (!done) { 1867 for (i = 0; !done && i < ARRAY_SIZE (drvtab); i++) { 1868 if (drvtab[i]->can_be_default) { 1869 done = !audio_driver_init (s, drvtab[i]); 1870 } 1871 } 1872 } 1873 1874 if (!done) { 1875 done = !audio_driver_init (s, &no_audio_driver); 1876 if (!done) { 1877 hw_error("Could not initialize audio subsystem\n"); 1878 } 1879 else { 1880 dolog ("warning: Using timer based audio emulation\n"); 1881 } 1882 } 1883 1884 if (conf.period.hertz <= 0) { 1885 if (conf.period.hertz < 0) { 1886 dolog ("warning: Timer period is negative - %d " 1887 "treating as zero\n", 1888 conf.period.hertz); 1889 } 1890 conf.period.ticks = 1; 1891 } else { 1892 conf.period.ticks = 1893 muldiv64 (1, get_ticks_per_sec (), conf.period.hertz); 1894 } 1895 1896 e = qemu_add_vm_change_state_handler (audio_vm_change_state_handler, s); 1897 if (!e) { 1898 dolog ("warning: Could not register change state handler\n" 1899 "(Audio can continue looping even after stopping the VM)\n"); 1900 } 1901 1902 QLIST_INIT (&s->card_head); 1903 vmstate_register (NULL, 0, &vmstate_audio, s); 1904 } 1905 1906 void AUD_register_card (const char *name, QEMUSoundCard *card) 1907 { 1908 audio_init (); 1909 card->name = qemu_strdup (name); 1910 memset (&card->entries, 0, sizeof (card->entries)); 1911 QLIST_INSERT_HEAD (&glob_audio_state.card_head, card, entries); 1912 } 1913 1914 void AUD_remove_card (QEMUSoundCard *card) 1915 { 1916 QLIST_REMOVE (card, entries); 1917 qemu_free (card->name); 1918 } 1919 1920 1921 CaptureVoiceOut *AUD_add_capture ( 1922 struct audsettings *as, 1923 struct audio_capture_ops *ops, 1924 void *cb_opaque 1925 ) 1926 { 1927 AudioState *s = &glob_audio_state; 1928 CaptureVoiceOut *cap; 1929 struct capture_callback *cb; 1930 1931 if (audio_validate_settings (as)) { 1932 dolog ("Invalid settings were passed when trying to add capture\n"); 1933 audio_print_settings (as); 1934 goto err0; 1935 } 1936 1937 cb = audio_calloc (AUDIO_FUNC, 1, sizeof (*cb)); 1938 if (!cb) { 1939 dolog ("Could not allocate capture callback information, size %zu\n", 1940 sizeof (*cb)); 1941 goto err0; 1942 } 1943 cb->ops = *ops; 1944 cb->opaque = cb_opaque; 1945 1946 cap = audio_pcm_capture_find_specific (as); 1947 if (cap) { 1948 QLIST_INSERT_HEAD (&cap->cb_head, cb, entries); 1949 return cap; 1950 } 1951 else { 1952 HWVoiceOut *hw; 1953 CaptureVoiceOut *cap; 1954 1955 cap = audio_calloc (AUDIO_FUNC, 1, sizeof (*cap)); 1956 if (!cap) { 1957 dolog ("Could not allocate capture voice, size %zu\n", 1958 sizeof (*cap)); 1959 goto err1; 1960 } 1961 1962 hw = &cap->hw; 1963 QLIST_INIT (&hw->sw_head); 1964 QLIST_INIT (&cap->cb_head); 1965 1966 /* XXX find a more elegant way */ 1967 hw->samples = 4096 * 4; 1968 hw->mix_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1969 sizeof (struct st_sample)); 1970 if (!hw->mix_buf) { 1971 dolog ("Could not allocate capture mix buffer (%d samples)\n", 1972 hw->samples); 1973 goto err2; 1974 } 1975 1976 audio_pcm_init_info (&hw->info, as); 1977 1978 cap->buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift); 1979 if (!cap->buf) { 1980 dolog ("Could not allocate capture buffer " 1981 "(%d samples, each %d bytes)\n", 1982 hw->samples, 1 << hw->info.shift); 1983 goto err3; 1984 } 1985 1986 hw->clip = mixeng_clip 1987 [hw->info.nchannels == 2] 1988 [hw->info.sign] 1989 [hw->info.swap_endianness] 1990 [audio_bits_to_index (hw->info.bits)]; 1991 1992 QLIST_INSERT_HEAD (&s->cap_head, cap, entries); 1993 QLIST_INSERT_HEAD (&cap->cb_head, cb, entries); 1994 1995 hw = NULL; 1996 while ((hw = audio_pcm_hw_find_any_out (hw))) { 1997 audio_attach_capture (hw); 1998 } 1999 return cap; 2000 2001 err3: 2002 qemu_free (cap->hw.mix_buf); 2003 err2: 2004 qemu_free (cap); 2005 err1: 2006 qemu_free (cb); 2007 err0: 2008 return NULL; 2009 } 2010 } 2011 2012 void AUD_del_capture (CaptureVoiceOut *cap, void *cb_opaque) 2013 { 2014 struct capture_callback *cb; 2015 2016 for (cb = cap->cb_head.lh_first; cb; cb = cb->entries.le_next) { 2017 if (cb->opaque == cb_opaque) { 2018 cb->ops.destroy (cb_opaque); 2019 QLIST_REMOVE (cb, entries); 2020 qemu_free (cb); 2021 2022 if (!cap->cb_head.lh_first) { 2023 SWVoiceOut *sw = cap->hw.sw_head.lh_first, *sw1; 2024 2025 while (sw) { 2026 SWVoiceCap *sc = (SWVoiceCap *) sw; 2027 #ifdef DEBUG_CAPTURE 2028 dolog ("freeing %s\n", sw->name); 2029 #endif 2030 2031 sw1 = sw->entries.le_next; 2032 if (sw->rate) { 2033 st_rate_stop (sw->rate); 2034 sw->rate = NULL; 2035 } 2036 QLIST_REMOVE (sw, entries); 2037 QLIST_REMOVE (sc, entries); 2038 qemu_free (sc); 2039 sw = sw1; 2040 } 2041 QLIST_REMOVE (cap, entries); 2042 qemu_free (cap); 2043 } 2044 return; 2045 } 2046 } 2047 } 2048 2049 void AUD_set_volume_out (SWVoiceOut *sw, int mute, uint8_t lvol, uint8_t rvol) 2050 { 2051 if (sw) { 2052 sw->vol.mute = mute; 2053 sw->vol.l = nominal_volume.l * lvol / 255; 2054 sw->vol.r = nominal_volume.r * rvol / 255; 2055 } 2056 } 2057 2058 void AUD_set_volume_in (SWVoiceIn *sw, int mute, uint8_t lvol, uint8_t rvol) 2059 { 2060 if (sw) { 2061 sw->vol.mute = mute; 2062 sw->vol.l = nominal_volume.l * lvol / 255; 2063 sw->vol.r = nominal_volume.r * rvol / 255; 2064 } 2065 } 2066