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