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