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