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/help_option.h" 36 #include "sysemu/sysemu.h" 37 #include "sysemu/replay.h" 38 #include "sysemu/runstate.h" 39 #include "ui/qemu-spice.h" 40 #include "trace.h" 41 42 #define AUDIO_CAP "audio" 43 #include "audio_int.h" 44 45 /* #define DEBUG_LIVE */ 46 /* #define DEBUG_OUT */ 47 /* #define DEBUG_CAPTURE */ 48 /* #define DEBUG_POLL */ 49 50 #define SW_NAME(sw) (sw)->name ? (sw)->name : "unknown" 51 52 53 /* Order of CONFIG_AUDIO_DRIVERS is import. 54 The 1st one is the one used by default, that is the reason 55 that we generate the list. 56 */ 57 const char *audio_prio_list[] = { 58 "spice", 59 CONFIG_AUDIO_DRIVERS 60 "none", 61 "wav", 62 NULL 63 }; 64 65 static QLIST_HEAD(, audio_driver) audio_drivers; 66 static AudiodevListHead audiodevs = QSIMPLEQ_HEAD_INITIALIZER(audiodevs); 67 68 void audio_driver_register(audio_driver *drv) 69 { 70 QLIST_INSERT_HEAD(&audio_drivers, drv, next); 71 } 72 73 audio_driver *audio_driver_lookup(const char *name) 74 { 75 struct audio_driver *d; 76 77 QLIST_FOREACH(d, &audio_drivers, next) { 78 if (strcmp(name, d->name) == 0) { 79 return d; 80 } 81 } 82 83 audio_module_load_one(name); 84 QLIST_FOREACH(d, &audio_drivers, next) { 85 if (strcmp(name, d->name) == 0) { 86 return d; 87 } 88 } 89 90 return NULL; 91 } 92 93 static QTAILQ_HEAD(AudioStateHead, AudioState) audio_states = 94 QTAILQ_HEAD_INITIALIZER(audio_states); 95 96 const struct mixeng_volume nominal_volume = { 97 .mute = 0, 98 #ifdef FLOAT_MIXENG 99 .r = 1.0, 100 .l = 1.0, 101 #else 102 .r = 1ULL << 32, 103 .l = 1ULL << 32, 104 #endif 105 }; 106 107 static bool legacy_config = true; 108 109 int audio_bug (const char *funcname, int cond) 110 { 111 if (cond) { 112 static int shown; 113 114 AUD_log (NULL, "A bug was just triggered in %s\n", funcname); 115 if (!shown) { 116 shown = 1; 117 AUD_log (NULL, "Save all your work and restart without audio\n"); 118 AUD_log (NULL, "I am sorry\n"); 119 } 120 AUD_log (NULL, "Context:\n"); 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 abort(); 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 abort(); 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 abort(); 547 } 548 return live; 549 } 550 551 static size_t audio_pcm_hw_conv_in(HWVoiceIn *hw, void *pcm_buf, size_t samples) 552 { 553 size_t conv = 0; 554 STSampleBuffer *conv_buf = hw->conv_buf; 555 556 while (samples) { 557 uint8_t *src = advance(pcm_buf, conv * hw->info.bytes_per_frame); 558 size_t proc = MIN(samples, conv_buf->size - conv_buf->pos); 559 560 hw->conv(conv_buf->samples + conv_buf->pos, src, proc); 561 conv_buf->pos = (conv_buf->pos + proc) % conv_buf->size; 562 samples -= proc; 563 conv += proc; 564 } 565 566 return conv; 567 } 568 569 /* 570 * Soft voice (capture) 571 */ 572 static size_t audio_pcm_sw_read(SWVoiceIn *sw, void *buf, size_t size) 573 { 574 HWVoiceIn *hw = sw->hw; 575 size_t samples, live, ret = 0, swlim, isamp, osamp, rpos, total = 0; 576 struct st_sample *src, *dst = sw->buf; 577 578 live = hw->total_samples_captured - sw->total_hw_samples_acquired; 579 if (!live) { 580 return 0; 581 } 582 if (audio_bug(__func__, live > hw->conv_buf->size)) { 583 dolog("live_in=%zu hw->conv_buf->size=%zu\n", live, hw->conv_buf->size); 584 abort(); 585 } 586 587 rpos = audio_ring_posb(hw->conv_buf->pos, live, hw->conv_buf->size); 588 589 samples = size / sw->info.bytes_per_frame; 590 591 swlim = (live * sw->ratio) >> 32; 592 swlim = MIN (swlim, samples); 593 594 while (swlim) { 595 src = hw->conv_buf->samples + rpos; 596 if (hw->conv_buf->pos > rpos) { 597 isamp = hw->conv_buf->pos - rpos; 598 } else { 599 isamp = hw->conv_buf->size - rpos; 600 } 601 602 if (!isamp) { 603 break; 604 } 605 osamp = swlim; 606 607 st_rate_flow (sw->rate, src, dst, &isamp, &osamp); 608 swlim -= osamp; 609 rpos = (rpos + isamp) % hw->conv_buf->size; 610 dst += osamp; 611 ret += osamp; 612 total += isamp; 613 } 614 615 if (!hw->pcm_ops->volume_in) { 616 mixeng_volume (sw->buf, ret, &sw->vol); 617 } 618 619 sw->clip (buf, sw->buf, ret); 620 sw->total_hw_samples_acquired += total; 621 return ret * sw->info.bytes_per_frame; 622 } 623 624 /* 625 * Hard voice (playback) 626 */ 627 static size_t audio_pcm_hw_find_min_out (HWVoiceOut *hw, int *nb_livep) 628 { 629 SWVoiceOut *sw; 630 size_t m = SIZE_MAX; 631 int nb_live = 0; 632 633 for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) { 634 if (sw->active || !sw->empty) { 635 m = MIN (m, sw->total_hw_samples_mixed); 636 nb_live += 1; 637 } 638 } 639 640 *nb_livep = nb_live; 641 return m; 642 } 643 644 static size_t audio_pcm_hw_get_live_out (HWVoiceOut *hw, int *nb_live) 645 { 646 size_t smin; 647 int nb_live1; 648 649 smin = audio_pcm_hw_find_min_out (hw, &nb_live1); 650 if (nb_live) { 651 *nb_live = nb_live1; 652 } 653 654 if (nb_live1) { 655 size_t live = smin; 656 657 if (audio_bug(__func__, live > hw->mix_buf->size)) { 658 dolog("live=%zu hw->mix_buf->size=%zu\n", live, hw->mix_buf->size); 659 abort(); 660 } 661 return live; 662 } 663 return 0; 664 } 665 666 static size_t audio_pcm_hw_get_free(HWVoiceOut *hw) 667 { 668 return (hw->pcm_ops->buffer_get_free ? hw->pcm_ops->buffer_get_free(hw) : 669 INT_MAX) / hw->info.bytes_per_frame; 670 } 671 672 static void audio_pcm_hw_clip_out(HWVoiceOut *hw, void *pcm_buf, size_t len) 673 { 674 size_t clipped = 0; 675 size_t pos = hw->mix_buf->pos; 676 677 while (len) { 678 st_sample *src = hw->mix_buf->samples + pos; 679 uint8_t *dst = advance(pcm_buf, clipped * hw->info.bytes_per_frame); 680 size_t samples_till_end_of_buf = hw->mix_buf->size - pos; 681 size_t samples_to_clip = MIN(len, samples_till_end_of_buf); 682 683 hw->clip(dst, src, samples_to_clip); 684 685 pos = (pos + samples_to_clip) % hw->mix_buf->size; 686 len -= samples_to_clip; 687 clipped += samples_to_clip; 688 } 689 } 690 691 /* 692 * Soft voice (playback) 693 */ 694 static size_t audio_pcm_sw_write(SWVoiceOut *sw, void *buf, size_t size) 695 { 696 size_t hwsamples, samples, isamp, osamp, wpos, live, dead, left, blck; 697 size_t hw_free; 698 size_t ret = 0, pos = 0, total = 0; 699 700 if (!sw) { 701 return size; 702 } 703 704 hwsamples = sw->hw->mix_buf->size; 705 706 live = sw->total_hw_samples_mixed; 707 if (audio_bug(__func__, live > hwsamples)) { 708 dolog("live=%zu hw->mix_buf->size=%zu\n", live, hwsamples); 709 abort(); 710 } 711 712 if (live == hwsamples) { 713 #ifdef DEBUG_OUT 714 dolog ("%s is full %zu\n", sw->name, live); 715 #endif 716 return 0; 717 } 718 719 wpos = (sw->hw->mix_buf->pos + live) % hwsamples; 720 721 dead = hwsamples - live; 722 hw_free = audio_pcm_hw_get_free(sw->hw); 723 hw_free = hw_free > live ? hw_free - live : 0; 724 samples = ((int64_t)MIN(dead, hw_free) << 32) / sw->ratio; 725 samples = MIN(samples, size / sw->info.bytes_per_frame); 726 if (samples) { 727 sw->conv(sw->buf, buf, samples); 728 729 if (!sw->hw->pcm_ops->volume_out) { 730 mixeng_volume(sw->buf, samples, &sw->vol); 731 } 732 } 733 734 while (samples) { 735 dead = hwsamples - live; 736 left = hwsamples - wpos; 737 blck = MIN (dead, left); 738 if (!blck) { 739 break; 740 } 741 isamp = samples; 742 osamp = blck; 743 st_rate_flow_mix ( 744 sw->rate, 745 sw->buf + pos, 746 sw->hw->mix_buf->samples + wpos, 747 &isamp, 748 &osamp 749 ); 750 ret += isamp; 751 samples -= isamp; 752 pos += isamp; 753 live += osamp; 754 wpos = (wpos + osamp) % hwsamples; 755 total += osamp; 756 } 757 758 sw->total_hw_samples_mixed += total; 759 sw->empty = sw->total_hw_samples_mixed == 0; 760 761 #ifdef DEBUG_OUT 762 dolog ( 763 "%s: write size %zu ret %zu total sw %zu\n", 764 SW_NAME (sw), 765 size / sw->info.bytes_per_frame, 766 ret, 767 sw->total_hw_samples_mixed 768 ); 769 #endif 770 771 return ret * sw->info.bytes_per_frame; 772 } 773 774 #ifdef DEBUG_AUDIO 775 static void audio_pcm_print_info (const char *cap, struct audio_pcm_info *info) 776 { 777 dolog("%s: bits %d, sign %d, float %d, freq %d, nchan %d\n", 778 cap, info->bits, info->is_signed, info->is_float, info->freq, 779 info->nchannels); 780 } 781 #endif 782 783 #define DAC 784 #include "audio_template.h" 785 #undef DAC 786 #include "audio_template.h" 787 788 /* 789 * Timer 790 */ 791 static int audio_is_timer_needed(AudioState *s) 792 { 793 HWVoiceIn *hwi = NULL; 794 HWVoiceOut *hwo = NULL; 795 796 while ((hwo = audio_pcm_hw_find_any_enabled_out(s, hwo))) { 797 if (!hwo->poll_mode) { 798 return 1; 799 } 800 } 801 while ((hwi = audio_pcm_hw_find_any_enabled_in(s, hwi))) { 802 if (!hwi->poll_mode) { 803 return 1; 804 } 805 } 806 return 0; 807 } 808 809 static void audio_reset_timer (AudioState *s) 810 { 811 if (audio_is_timer_needed(s)) { 812 timer_mod_anticipate_ns(s->ts, 813 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + s->period_ticks); 814 if (!s->timer_running) { 815 s->timer_running = true; 816 s->timer_last = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL); 817 trace_audio_timer_start(s->period_ticks / SCALE_MS); 818 } 819 } else { 820 timer_del(s->ts); 821 if (s->timer_running) { 822 s->timer_running = false; 823 trace_audio_timer_stop(); 824 } 825 } 826 } 827 828 static void audio_timer (void *opaque) 829 { 830 int64_t now, diff; 831 AudioState *s = opaque; 832 833 now = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL); 834 diff = now - s->timer_last; 835 if (diff > s->period_ticks * 3 / 2) { 836 trace_audio_timer_delayed(diff / SCALE_MS); 837 } 838 s->timer_last = now; 839 840 audio_run(s, "timer"); 841 audio_reset_timer(s); 842 } 843 844 /* 845 * Public API 846 */ 847 size_t AUD_write(SWVoiceOut *sw, void *buf, size_t size) 848 { 849 HWVoiceOut *hw; 850 851 if (!sw) { 852 /* XXX: Consider options */ 853 return size; 854 } 855 hw = sw->hw; 856 857 if (!hw->enabled) { 858 dolog ("Writing to disabled voice %s\n", SW_NAME (sw)); 859 return 0; 860 } 861 862 if (audio_get_pdo_out(hw->s->dev)->mixing_engine) { 863 return audio_pcm_sw_write(sw, buf, size); 864 } else { 865 return hw->pcm_ops->write(hw, buf, size); 866 } 867 } 868 869 size_t AUD_read(SWVoiceIn *sw, void *buf, size_t size) 870 { 871 HWVoiceIn *hw; 872 873 if (!sw) { 874 /* XXX: Consider options */ 875 return size; 876 } 877 hw = sw->hw; 878 879 if (!hw->enabled) { 880 dolog ("Reading from disabled voice %s\n", SW_NAME (sw)); 881 return 0; 882 } 883 884 if (audio_get_pdo_in(hw->s->dev)->mixing_engine) { 885 return audio_pcm_sw_read(sw, buf, size); 886 } else { 887 return hw->pcm_ops->read(hw, buf, size); 888 } 889 } 890 891 int AUD_get_buffer_size_out(SWVoiceOut *sw) 892 { 893 return sw->hw->samples * sw->hw->info.bytes_per_frame; 894 } 895 896 void AUD_set_active_out (SWVoiceOut *sw, int on) 897 { 898 HWVoiceOut *hw; 899 900 if (!sw) { 901 return; 902 } 903 904 hw = sw->hw; 905 if (sw->active != on) { 906 AudioState *s = sw->s; 907 SWVoiceOut *temp_sw; 908 SWVoiceCap *sc; 909 910 if (on) { 911 hw->pending_disable = 0; 912 if (!hw->enabled) { 913 hw->enabled = 1; 914 if (s->vm_running) { 915 if (hw->pcm_ops->enable_out) { 916 hw->pcm_ops->enable_out(hw, true); 917 } 918 audio_reset_timer (s); 919 } 920 } 921 } else { 922 if (hw->enabled) { 923 int nb_active = 0; 924 925 for (temp_sw = hw->sw_head.lh_first; temp_sw; 926 temp_sw = temp_sw->entries.le_next) { 927 nb_active += temp_sw->active != 0; 928 } 929 930 hw->pending_disable = nb_active == 1; 931 } 932 } 933 934 for (sc = hw->cap_head.lh_first; sc; sc = sc->entries.le_next) { 935 sc->sw.active = hw->enabled; 936 if (hw->enabled) { 937 audio_capture_maybe_changed (sc->cap, 1); 938 } 939 } 940 sw->active = on; 941 } 942 } 943 944 void AUD_set_active_in (SWVoiceIn *sw, int on) 945 { 946 HWVoiceIn *hw; 947 948 if (!sw) { 949 return; 950 } 951 952 hw = sw->hw; 953 if (sw->active != on) { 954 AudioState *s = sw->s; 955 SWVoiceIn *temp_sw; 956 957 if (on) { 958 if (!hw->enabled) { 959 hw->enabled = 1; 960 if (s->vm_running) { 961 if (hw->pcm_ops->enable_in) { 962 hw->pcm_ops->enable_in(hw, true); 963 } 964 audio_reset_timer (s); 965 } 966 } 967 sw->total_hw_samples_acquired = hw->total_samples_captured; 968 } else { 969 if (hw->enabled) { 970 int nb_active = 0; 971 972 for (temp_sw = hw->sw_head.lh_first; temp_sw; 973 temp_sw = temp_sw->entries.le_next) { 974 nb_active += temp_sw->active != 0; 975 } 976 977 if (nb_active == 1) { 978 hw->enabled = 0; 979 if (hw->pcm_ops->enable_in) { 980 hw->pcm_ops->enable_in(hw, false); 981 } 982 } 983 } 984 } 985 sw->active = on; 986 } 987 } 988 989 static size_t audio_get_avail (SWVoiceIn *sw) 990 { 991 size_t live; 992 993 if (!sw) { 994 return 0; 995 } 996 997 live = sw->hw->total_samples_captured - sw->total_hw_samples_acquired; 998 if (audio_bug(__func__, live > sw->hw->conv_buf->size)) { 999 dolog("live=%zu sw->hw->conv_buf->size=%zu\n", live, 1000 sw->hw->conv_buf->size); 1001 abort(); 1002 } 1003 1004 ldebug ( 1005 "%s: get_avail live %zu ret %" PRId64 "\n", 1006 SW_NAME (sw), 1007 live, (((int64_t) live << 32) / sw->ratio) * sw->info.bytes_per_frame 1008 ); 1009 1010 return (((int64_t) live << 32) / sw->ratio) * sw->info.bytes_per_frame; 1011 } 1012 1013 static size_t audio_sw_bytes_free(SWVoiceOut *sw, size_t free) 1014 { 1015 return (((int64_t)free << 32) / sw->ratio) * sw->info.bytes_per_frame; 1016 } 1017 1018 static size_t audio_get_free(SWVoiceOut *sw) 1019 { 1020 size_t live, dead; 1021 1022 if (!sw) { 1023 return 0; 1024 } 1025 1026 live = sw->total_hw_samples_mixed; 1027 1028 if (audio_bug(__func__, live > sw->hw->mix_buf->size)) { 1029 dolog("live=%zu sw->hw->mix_buf->size=%zu\n", live, 1030 sw->hw->mix_buf->size); 1031 abort(); 1032 } 1033 1034 dead = sw->hw->mix_buf->size - live; 1035 1036 #ifdef DEBUG_OUT 1037 dolog("%s: get_free live %zu dead %zu sw_bytes %zu\n", 1038 SW_NAME(sw), live, dead, audio_sw_bytes_free(sw, dead)); 1039 #endif 1040 1041 return dead; 1042 } 1043 1044 static void audio_capture_mix_and_clear(HWVoiceOut *hw, size_t rpos, 1045 size_t samples) 1046 { 1047 size_t n; 1048 1049 if (hw->enabled) { 1050 SWVoiceCap *sc; 1051 1052 for (sc = hw->cap_head.lh_first; sc; sc = sc->entries.le_next) { 1053 SWVoiceOut *sw = &sc->sw; 1054 int rpos2 = rpos; 1055 1056 n = samples; 1057 while (n) { 1058 size_t till_end_of_hw = hw->mix_buf->size - rpos2; 1059 size_t to_write = MIN(till_end_of_hw, n); 1060 size_t bytes = to_write * hw->info.bytes_per_frame; 1061 size_t written; 1062 1063 sw->buf = hw->mix_buf->samples + rpos2; 1064 written = audio_pcm_sw_write (sw, NULL, bytes); 1065 if (written - bytes) { 1066 dolog("Could not mix %zu bytes into a capture " 1067 "buffer, mixed %zu\n", 1068 bytes, written); 1069 break; 1070 } 1071 n -= to_write; 1072 rpos2 = (rpos2 + to_write) % hw->mix_buf->size; 1073 } 1074 } 1075 } 1076 1077 n = MIN(samples, hw->mix_buf->size - rpos); 1078 mixeng_clear(hw->mix_buf->samples + rpos, n); 1079 mixeng_clear(hw->mix_buf->samples, samples - n); 1080 } 1081 1082 static size_t audio_pcm_hw_run_out(HWVoiceOut *hw, size_t live) 1083 { 1084 size_t clipped = 0; 1085 1086 while (live) { 1087 size_t size = live * hw->info.bytes_per_frame; 1088 size_t decr, proc; 1089 void *buf = hw->pcm_ops->get_buffer_out(hw, &size); 1090 1091 if (size == 0) { 1092 break; 1093 } 1094 1095 decr = MIN(size / hw->info.bytes_per_frame, live); 1096 if (buf) { 1097 audio_pcm_hw_clip_out(hw, buf, decr); 1098 } 1099 proc = hw->pcm_ops->put_buffer_out(hw, buf, 1100 decr * hw->info.bytes_per_frame) / 1101 hw->info.bytes_per_frame; 1102 1103 live -= proc; 1104 clipped += proc; 1105 hw->mix_buf->pos = (hw->mix_buf->pos + proc) % hw->mix_buf->size; 1106 1107 if (proc == 0 || proc < decr) { 1108 break; 1109 } 1110 } 1111 1112 if (hw->pcm_ops->run_buffer_out) { 1113 hw->pcm_ops->run_buffer_out(hw); 1114 } 1115 1116 return clipped; 1117 } 1118 1119 static void audio_run_out (AudioState *s) 1120 { 1121 HWVoiceOut *hw = NULL; 1122 SWVoiceOut *sw; 1123 1124 if (!audio_get_pdo_out(s->dev)->mixing_engine) { 1125 while ((hw = audio_pcm_hw_find_any_enabled_out(s, hw))) { 1126 /* there is exactly 1 sw for each hw with no mixeng */ 1127 sw = hw->sw_head.lh_first; 1128 1129 if (hw->pending_disable) { 1130 hw->enabled = 0; 1131 hw->pending_disable = 0; 1132 if (hw->pcm_ops->enable_out) { 1133 hw->pcm_ops->enable_out(hw, false); 1134 } 1135 } 1136 1137 if (sw->active) { 1138 sw->callback.fn(sw->callback.opaque, INT_MAX); 1139 } 1140 } 1141 return; 1142 } 1143 1144 while ((hw = audio_pcm_hw_find_any_enabled_out(s, hw))) { 1145 size_t played, live, prev_rpos; 1146 size_t hw_free = audio_pcm_hw_get_free(hw); 1147 int nb_live; 1148 1149 for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) { 1150 if (sw->active) { 1151 size_t sw_free = audio_get_free(sw); 1152 size_t free; 1153 1154 if (hw_free > sw->total_hw_samples_mixed) { 1155 free = audio_sw_bytes_free(sw, 1156 MIN(sw_free, hw_free - sw->total_hw_samples_mixed)); 1157 } else { 1158 free = 0; 1159 } 1160 if (free > 0) { 1161 sw->callback.fn(sw->callback.opaque, free); 1162 } 1163 } 1164 } 1165 1166 live = audio_pcm_hw_get_live_out (hw, &nb_live); 1167 if (!nb_live) { 1168 live = 0; 1169 } 1170 1171 if (audio_bug(__func__, live > hw->mix_buf->size)) { 1172 dolog("live=%zu hw->mix_buf->size=%zu\n", live, hw->mix_buf->size); 1173 abort(); 1174 } 1175 1176 if (hw->pending_disable && !nb_live) { 1177 SWVoiceCap *sc; 1178 #ifdef DEBUG_OUT 1179 dolog ("Disabling voice\n"); 1180 #endif 1181 hw->enabled = 0; 1182 hw->pending_disable = 0; 1183 if (hw->pcm_ops->enable_out) { 1184 hw->pcm_ops->enable_out(hw, false); 1185 } 1186 for (sc = hw->cap_head.lh_first; sc; sc = sc->entries.le_next) { 1187 sc->sw.active = 0; 1188 audio_recalc_and_notify_capture (sc->cap); 1189 } 1190 continue; 1191 } 1192 1193 if (!live) { 1194 if (hw->pcm_ops->run_buffer_out) { 1195 hw->pcm_ops->run_buffer_out(hw); 1196 } 1197 continue; 1198 } 1199 1200 prev_rpos = hw->mix_buf->pos; 1201 played = audio_pcm_hw_run_out(hw, live); 1202 replay_audio_out(&played); 1203 if (audio_bug(__func__, hw->mix_buf->pos >= hw->mix_buf->size)) { 1204 dolog("hw->mix_buf->pos=%zu hw->mix_buf->size=%zu played=%zu\n", 1205 hw->mix_buf->pos, hw->mix_buf->size, played); 1206 abort(); 1207 } 1208 1209 #ifdef DEBUG_OUT 1210 dolog("played=%zu\n", played); 1211 #endif 1212 1213 if (played) { 1214 hw->ts_helper += played; 1215 audio_capture_mix_and_clear (hw, prev_rpos, played); 1216 } 1217 1218 for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) { 1219 if (!sw->active && sw->empty) { 1220 continue; 1221 } 1222 1223 if (audio_bug(__func__, played > sw->total_hw_samples_mixed)) { 1224 dolog("played=%zu sw->total_hw_samples_mixed=%zu\n", 1225 played, sw->total_hw_samples_mixed); 1226 abort(); 1227 } 1228 1229 sw->total_hw_samples_mixed -= played; 1230 1231 if (!sw->total_hw_samples_mixed) { 1232 sw->empty = 1; 1233 } 1234 } 1235 } 1236 } 1237 1238 static size_t audio_pcm_hw_run_in(HWVoiceIn *hw, size_t samples) 1239 { 1240 size_t conv = 0; 1241 1242 if (hw->pcm_ops->run_buffer_in) { 1243 hw->pcm_ops->run_buffer_in(hw); 1244 } 1245 1246 while (samples) { 1247 size_t proc; 1248 size_t size = samples * hw->info.bytes_per_frame; 1249 void *buf = hw->pcm_ops->get_buffer_in(hw, &size); 1250 1251 assert(size % hw->info.bytes_per_frame == 0); 1252 if (size == 0) { 1253 break; 1254 } 1255 1256 proc = audio_pcm_hw_conv_in(hw, buf, size / hw->info.bytes_per_frame); 1257 1258 samples -= proc; 1259 conv += proc; 1260 hw->pcm_ops->put_buffer_in(hw, buf, proc * hw->info.bytes_per_frame); 1261 } 1262 1263 return conv; 1264 } 1265 1266 static void audio_run_in (AudioState *s) 1267 { 1268 HWVoiceIn *hw = NULL; 1269 1270 if (!audio_get_pdo_in(s->dev)->mixing_engine) { 1271 while ((hw = audio_pcm_hw_find_any_enabled_in(s, hw))) { 1272 /* there is exactly 1 sw for each hw with no mixeng */ 1273 SWVoiceIn *sw = hw->sw_head.lh_first; 1274 if (sw->active) { 1275 sw->callback.fn(sw->callback.opaque, INT_MAX); 1276 } 1277 } 1278 return; 1279 } 1280 1281 while ((hw = audio_pcm_hw_find_any_enabled_in(s, hw))) { 1282 SWVoiceIn *sw; 1283 size_t captured = 0, min; 1284 1285 if (replay_mode != REPLAY_MODE_PLAY) { 1286 captured = audio_pcm_hw_run_in( 1287 hw, hw->conv_buf->size - audio_pcm_hw_get_live_in(hw)); 1288 } 1289 replay_audio_in(&captured, hw->conv_buf->samples, &hw->conv_buf->pos, 1290 hw->conv_buf->size); 1291 1292 min = audio_pcm_hw_find_min_in (hw); 1293 hw->total_samples_captured += captured - min; 1294 hw->ts_helper += captured; 1295 1296 for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) { 1297 sw->total_hw_samples_acquired -= min; 1298 1299 if (sw->active) { 1300 size_t avail; 1301 1302 avail = audio_get_avail (sw); 1303 if (avail > 0) { 1304 sw->callback.fn (sw->callback.opaque, avail); 1305 } 1306 } 1307 } 1308 } 1309 } 1310 1311 static void audio_run_capture (AudioState *s) 1312 { 1313 CaptureVoiceOut *cap; 1314 1315 for (cap = s->cap_head.lh_first; cap; cap = cap->entries.le_next) { 1316 size_t live, rpos, captured; 1317 HWVoiceOut *hw = &cap->hw; 1318 SWVoiceOut *sw; 1319 1320 captured = live = audio_pcm_hw_get_live_out (hw, NULL); 1321 rpos = hw->mix_buf->pos; 1322 while (live) { 1323 size_t left = hw->mix_buf->size - rpos; 1324 size_t to_capture = MIN(live, left); 1325 struct st_sample *src; 1326 struct capture_callback *cb; 1327 1328 src = hw->mix_buf->samples + rpos; 1329 hw->clip (cap->buf, src, to_capture); 1330 mixeng_clear (src, to_capture); 1331 1332 for (cb = cap->cb_head.lh_first; cb; cb = cb->entries.le_next) { 1333 cb->ops.capture (cb->opaque, cap->buf, 1334 to_capture * hw->info.bytes_per_frame); 1335 } 1336 rpos = (rpos + to_capture) % hw->mix_buf->size; 1337 live -= to_capture; 1338 } 1339 hw->mix_buf->pos = rpos; 1340 1341 for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) { 1342 if (!sw->active && sw->empty) { 1343 continue; 1344 } 1345 1346 if (audio_bug(__func__, captured > sw->total_hw_samples_mixed)) { 1347 dolog("captured=%zu sw->total_hw_samples_mixed=%zu\n", 1348 captured, sw->total_hw_samples_mixed); 1349 abort(); 1350 } 1351 1352 sw->total_hw_samples_mixed -= captured; 1353 sw->empty = sw->total_hw_samples_mixed == 0; 1354 } 1355 } 1356 } 1357 1358 void audio_run(AudioState *s, const char *msg) 1359 { 1360 audio_run_out(s); 1361 audio_run_in(s); 1362 audio_run_capture(s); 1363 1364 #ifdef DEBUG_POLL 1365 { 1366 static double prevtime; 1367 double currtime; 1368 struct timeval tv; 1369 1370 if (gettimeofday (&tv, NULL)) { 1371 perror ("audio_run: gettimeofday"); 1372 return; 1373 } 1374 1375 currtime = tv.tv_sec + tv.tv_usec * 1e-6; 1376 dolog ("Elapsed since last %s: %f\n", msg, currtime - prevtime); 1377 prevtime = currtime; 1378 } 1379 #endif 1380 } 1381 1382 void audio_generic_run_buffer_in(HWVoiceIn *hw) 1383 { 1384 if (unlikely(!hw->buf_emul)) { 1385 hw->size_emul = hw->samples * hw->info.bytes_per_frame; 1386 hw->buf_emul = g_malloc(hw->size_emul); 1387 hw->pos_emul = hw->pending_emul = 0; 1388 } 1389 1390 while (hw->pending_emul < hw->size_emul) { 1391 size_t read_len = MIN(hw->size_emul - hw->pos_emul, 1392 hw->size_emul - hw->pending_emul); 1393 size_t read = hw->pcm_ops->read(hw, hw->buf_emul + hw->pos_emul, 1394 read_len); 1395 hw->pending_emul += read; 1396 hw->pos_emul = (hw->pos_emul + read) % hw->size_emul; 1397 if (read < read_len) { 1398 break; 1399 } 1400 } 1401 } 1402 1403 void *audio_generic_get_buffer_in(HWVoiceIn *hw, size_t *size) 1404 { 1405 size_t start; 1406 1407 start = audio_ring_posb(hw->pos_emul, hw->pending_emul, hw->size_emul); 1408 assert(start < hw->size_emul); 1409 1410 *size = MIN(*size, hw->pending_emul); 1411 *size = MIN(*size, hw->size_emul - start); 1412 return hw->buf_emul + start; 1413 } 1414 1415 void audio_generic_put_buffer_in(HWVoiceIn *hw, void *buf, size_t size) 1416 { 1417 assert(size <= hw->pending_emul); 1418 hw->pending_emul -= size; 1419 } 1420 1421 size_t audio_generic_buffer_get_free(HWVoiceOut *hw) 1422 { 1423 if (hw->buf_emul) { 1424 return hw->size_emul - hw->pending_emul; 1425 } else { 1426 return hw->samples * hw->info.bytes_per_frame; 1427 } 1428 } 1429 1430 void audio_generic_run_buffer_out(HWVoiceOut *hw) 1431 { 1432 while (hw->pending_emul) { 1433 size_t write_len, written, start; 1434 1435 start = audio_ring_posb(hw->pos_emul, hw->pending_emul, hw->size_emul); 1436 assert(start < hw->size_emul); 1437 1438 write_len = MIN(hw->pending_emul, hw->size_emul - start); 1439 1440 written = hw->pcm_ops->write(hw, hw->buf_emul + start, write_len); 1441 hw->pending_emul -= written; 1442 1443 if (written < write_len) { 1444 break; 1445 } 1446 } 1447 } 1448 1449 void *audio_generic_get_buffer_out(HWVoiceOut *hw, size_t *size) 1450 { 1451 if (unlikely(!hw->buf_emul)) { 1452 hw->size_emul = hw->samples * hw->info.bytes_per_frame; 1453 hw->buf_emul = g_malloc(hw->size_emul); 1454 hw->pos_emul = hw->pending_emul = 0; 1455 } 1456 1457 *size = MIN(hw->size_emul - hw->pending_emul, 1458 hw->size_emul - hw->pos_emul); 1459 return hw->buf_emul + hw->pos_emul; 1460 } 1461 1462 size_t audio_generic_put_buffer_out(HWVoiceOut *hw, void *buf, size_t size) 1463 { 1464 assert(buf == hw->buf_emul + hw->pos_emul && 1465 size + hw->pending_emul <= hw->size_emul); 1466 1467 hw->pending_emul += size; 1468 hw->pos_emul = (hw->pos_emul + size) % hw->size_emul; 1469 1470 return size; 1471 } 1472 1473 size_t audio_generic_write(HWVoiceOut *hw, void *buf, size_t size) 1474 { 1475 size_t total = 0; 1476 1477 if (hw->pcm_ops->buffer_get_free) { 1478 size_t free = hw->pcm_ops->buffer_get_free(hw); 1479 1480 size = MIN(size, free); 1481 } 1482 1483 while (total < size) { 1484 size_t dst_size = size - total; 1485 size_t copy_size, proc; 1486 void *dst = hw->pcm_ops->get_buffer_out(hw, &dst_size); 1487 1488 if (dst_size == 0) { 1489 break; 1490 } 1491 1492 copy_size = MIN(size - total, dst_size); 1493 if (dst) { 1494 memcpy(dst, (char *)buf + total, copy_size); 1495 } 1496 proc = hw->pcm_ops->put_buffer_out(hw, dst, copy_size); 1497 total += proc; 1498 1499 if (proc == 0 || proc < copy_size) { 1500 break; 1501 } 1502 } 1503 1504 if (hw->pcm_ops->run_buffer_out) { 1505 hw->pcm_ops->run_buffer_out(hw); 1506 } 1507 1508 return total; 1509 } 1510 1511 size_t audio_generic_read(HWVoiceIn *hw, void *buf, size_t size) 1512 { 1513 size_t total = 0; 1514 1515 if (hw->pcm_ops->run_buffer_in) { 1516 hw->pcm_ops->run_buffer_in(hw); 1517 } 1518 1519 while (total < size) { 1520 size_t src_size = size - total; 1521 void *src = hw->pcm_ops->get_buffer_in(hw, &src_size); 1522 1523 if (src_size == 0) { 1524 break; 1525 } 1526 1527 memcpy((char *)buf + total, src, src_size); 1528 hw->pcm_ops->put_buffer_in(hw, src, src_size); 1529 total += src_size; 1530 } 1531 1532 return total; 1533 } 1534 1535 static int audio_driver_init(AudioState *s, struct audio_driver *drv, 1536 bool msg, Audiodev *dev) 1537 { 1538 s->drv_opaque = drv->init(dev); 1539 1540 if (s->drv_opaque) { 1541 if (!drv->pcm_ops->get_buffer_in) { 1542 drv->pcm_ops->get_buffer_in = audio_generic_get_buffer_in; 1543 drv->pcm_ops->put_buffer_in = audio_generic_put_buffer_in; 1544 } 1545 if (!drv->pcm_ops->get_buffer_out) { 1546 drv->pcm_ops->get_buffer_out = audio_generic_get_buffer_out; 1547 drv->pcm_ops->put_buffer_out = audio_generic_put_buffer_out; 1548 } 1549 1550 audio_init_nb_voices_out(s, drv); 1551 audio_init_nb_voices_in(s, drv); 1552 s->drv = drv; 1553 return 0; 1554 } else { 1555 if (msg) { 1556 dolog("Could not init `%s' audio driver\n", drv->name); 1557 } 1558 return -1; 1559 } 1560 } 1561 1562 static void audio_vm_change_state_handler (void *opaque, bool running, 1563 RunState state) 1564 { 1565 AudioState *s = opaque; 1566 HWVoiceOut *hwo = NULL; 1567 HWVoiceIn *hwi = NULL; 1568 1569 s->vm_running = running; 1570 while ((hwo = audio_pcm_hw_find_any_enabled_out(s, hwo))) { 1571 if (hwo->pcm_ops->enable_out) { 1572 hwo->pcm_ops->enable_out(hwo, running); 1573 } 1574 } 1575 1576 while ((hwi = audio_pcm_hw_find_any_enabled_in(s, hwi))) { 1577 if (hwi->pcm_ops->enable_in) { 1578 hwi->pcm_ops->enable_in(hwi, running); 1579 } 1580 } 1581 audio_reset_timer (s); 1582 } 1583 1584 static void free_audio_state(AudioState *s) 1585 { 1586 HWVoiceOut *hwo, *hwon; 1587 HWVoiceIn *hwi, *hwin; 1588 1589 QLIST_FOREACH_SAFE(hwo, &s->hw_head_out, entries, hwon) { 1590 SWVoiceCap *sc; 1591 1592 if (hwo->enabled && hwo->pcm_ops->enable_out) { 1593 hwo->pcm_ops->enable_out(hwo, false); 1594 } 1595 hwo->pcm_ops->fini_out (hwo); 1596 1597 for (sc = hwo->cap_head.lh_first; sc; sc = sc->entries.le_next) { 1598 CaptureVoiceOut *cap = sc->cap; 1599 struct capture_callback *cb; 1600 1601 for (cb = cap->cb_head.lh_first; cb; cb = cb->entries.le_next) { 1602 cb->ops.destroy (cb->opaque); 1603 } 1604 } 1605 QLIST_REMOVE(hwo, entries); 1606 } 1607 1608 QLIST_FOREACH_SAFE(hwi, &s->hw_head_in, entries, hwin) { 1609 if (hwi->enabled && hwi->pcm_ops->enable_in) { 1610 hwi->pcm_ops->enable_in(hwi, false); 1611 } 1612 hwi->pcm_ops->fini_in (hwi); 1613 QLIST_REMOVE(hwi, entries); 1614 } 1615 1616 if (s->drv) { 1617 s->drv->fini (s->drv_opaque); 1618 s->drv = NULL; 1619 } 1620 1621 if (s->dev) { 1622 qapi_free_Audiodev(s->dev); 1623 s->dev = NULL; 1624 } 1625 1626 if (s->ts) { 1627 timer_free(s->ts); 1628 s->ts = NULL; 1629 } 1630 1631 g_free(s); 1632 } 1633 1634 void audio_cleanup(void) 1635 { 1636 while (!QTAILQ_EMPTY(&audio_states)) { 1637 AudioState *s = QTAILQ_FIRST(&audio_states); 1638 QTAILQ_REMOVE(&audio_states, s, list); 1639 free_audio_state(s); 1640 } 1641 } 1642 1643 static bool vmstate_audio_needed(void *opaque) 1644 { 1645 /* 1646 * Never needed, this vmstate only exists in case 1647 * an old qemu sends it to us. 1648 */ 1649 return false; 1650 } 1651 1652 static const VMStateDescription vmstate_audio = { 1653 .name = "audio", 1654 .version_id = 1, 1655 .minimum_version_id = 1, 1656 .needed = vmstate_audio_needed, 1657 .fields = (VMStateField[]) { 1658 VMSTATE_END_OF_LIST() 1659 } 1660 }; 1661 1662 static void audio_validate_opts(Audiodev *dev, Error **errp); 1663 1664 static AudiodevListEntry *audiodev_find( 1665 AudiodevListHead *head, const char *drvname) 1666 { 1667 AudiodevListEntry *e; 1668 QSIMPLEQ_FOREACH(e, head, next) { 1669 if (strcmp(AudiodevDriver_str(e->dev->driver), drvname) == 0) { 1670 return e; 1671 } 1672 } 1673 1674 return NULL; 1675 } 1676 1677 /* 1678 * if we have dev, this function was called because of an -audiodev argument => 1679 * initialize a new state with it 1680 * if dev == NULL => legacy implicit initialization, return the already created 1681 * state or create a new one 1682 */ 1683 static AudioState *audio_init(Audiodev *dev, const char *name) 1684 { 1685 static bool atexit_registered; 1686 size_t i; 1687 int done = 0; 1688 const char *drvname = NULL; 1689 VMChangeStateEntry *e; 1690 AudioState *s; 1691 struct audio_driver *driver; 1692 /* silence gcc warning about uninitialized variable */ 1693 AudiodevListHead head = QSIMPLEQ_HEAD_INITIALIZER(head); 1694 1695 if (using_spice) { 1696 /* 1697 * When using spice allow the spice audio driver being picked 1698 * as default. 1699 * 1700 * Temporary hack. Using audio devices without explicit 1701 * audiodev= property is already deprecated. Same goes for 1702 * the -soundhw switch. Once this support gets finally 1703 * removed we can also drop the concept of a default audio 1704 * backend and this can go away. 1705 */ 1706 driver = audio_driver_lookup("spice"); 1707 if (driver) { 1708 driver->can_be_default = 1; 1709 } 1710 } 1711 1712 if (dev) { 1713 /* -audiodev option */ 1714 legacy_config = false; 1715 drvname = AudiodevDriver_str(dev->driver); 1716 } else if (!QTAILQ_EMPTY(&audio_states)) { 1717 if (!legacy_config) { 1718 dolog("Device %s: audiodev default parameter is deprecated, please " 1719 "specify audiodev=%s\n", name, 1720 QTAILQ_FIRST(&audio_states)->dev->id); 1721 } 1722 return QTAILQ_FIRST(&audio_states); 1723 } else { 1724 /* legacy implicit initialization */ 1725 head = audio_handle_legacy_opts(); 1726 /* 1727 * In case of legacy initialization, all Audiodevs in the list will have 1728 * the same configuration (except the driver), so it doesn't matter which 1729 * one we chose. We need an Audiodev to set up AudioState before we can 1730 * init a driver. Also note that dev at this point is still in the 1731 * list. 1732 */ 1733 dev = QSIMPLEQ_FIRST(&head)->dev; 1734 audio_validate_opts(dev, &error_abort); 1735 } 1736 1737 s = g_new0(AudioState, 1); 1738 s->dev = dev; 1739 1740 QLIST_INIT (&s->hw_head_out); 1741 QLIST_INIT (&s->hw_head_in); 1742 QLIST_INIT (&s->cap_head); 1743 if (!atexit_registered) { 1744 atexit(audio_cleanup); 1745 atexit_registered = true; 1746 } 1747 1748 s->ts = timer_new_ns(QEMU_CLOCK_VIRTUAL, audio_timer, s); 1749 1750 s->nb_hw_voices_out = audio_get_pdo_out(dev)->voices; 1751 s->nb_hw_voices_in = audio_get_pdo_in(dev)->voices; 1752 1753 if (s->nb_hw_voices_out <= 0) { 1754 dolog ("Bogus number of playback voices %d, setting to 1\n", 1755 s->nb_hw_voices_out); 1756 s->nb_hw_voices_out = 1; 1757 } 1758 1759 if (s->nb_hw_voices_in <= 0) { 1760 dolog ("Bogus number of capture voices %d, setting to 0\n", 1761 s->nb_hw_voices_in); 1762 s->nb_hw_voices_in = 0; 1763 } 1764 1765 if (drvname) { 1766 driver = audio_driver_lookup(drvname); 1767 if (driver) { 1768 done = !audio_driver_init(s, driver, true, dev); 1769 } else { 1770 dolog ("Unknown audio driver `%s'\n", drvname); 1771 } 1772 if (!done) { 1773 free_audio_state(s); 1774 return NULL; 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 QTAILQ_INSERT_TAIL(&audio_states, s, list); 1814 QLIST_INIT (&s->card_head); 1815 vmstate_register (NULL, 0, &vmstate_audio, s); 1816 return s; 1817 } 1818 1819 void audio_free_audiodev_list(AudiodevListHead *head) 1820 { 1821 AudiodevListEntry *e; 1822 while ((e = QSIMPLEQ_FIRST(head))) { 1823 QSIMPLEQ_REMOVE_HEAD(head, next); 1824 qapi_free_Audiodev(e->dev); 1825 g_free(e); 1826 } 1827 } 1828 1829 void AUD_register_card (const char *name, QEMUSoundCard *card) 1830 { 1831 if (!card->state) { 1832 card->state = audio_init(NULL, name); 1833 } 1834 1835 card->name = g_strdup (name); 1836 memset (&card->entries, 0, sizeof (card->entries)); 1837 QLIST_INSERT_HEAD(&card->state->card_head, card, entries); 1838 } 1839 1840 void AUD_remove_card (QEMUSoundCard *card) 1841 { 1842 QLIST_REMOVE (card, entries); 1843 g_free (card->name); 1844 } 1845 1846 static struct audio_pcm_ops capture_pcm_ops; 1847 1848 CaptureVoiceOut *AUD_add_capture( 1849 AudioState *s, 1850 struct audsettings *as, 1851 struct audio_capture_ops *ops, 1852 void *cb_opaque 1853 ) 1854 { 1855 CaptureVoiceOut *cap; 1856 struct capture_callback *cb; 1857 1858 if (!s) { 1859 if (!legacy_config) { 1860 dolog("Capturing without setting an audiodev is deprecated\n"); 1861 } 1862 s = audio_init(NULL, NULL); 1863 } 1864 1865 if (!audio_get_pdo_out(s->dev)->mixing_engine) { 1866 dolog("Can't capture with mixeng disabled\n"); 1867 return NULL; 1868 } 1869 1870 if (audio_validate_settings (as)) { 1871 dolog ("Invalid settings were passed when trying to add capture\n"); 1872 audio_print_settings (as); 1873 return NULL; 1874 } 1875 1876 cb = g_malloc0(sizeof(*cb)); 1877 cb->ops = *ops; 1878 cb->opaque = cb_opaque; 1879 1880 cap = audio_pcm_capture_find_specific(s, as); 1881 if (cap) { 1882 QLIST_INSERT_HEAD (&cap->cb_head, cb, entries); 1883 return cap; 1884 } else { 1885 HWVoiceOut *hw; 1886 CaptureVoiceOut *cap; 1887 1888 cap = g_malloc0(sizeof(*cap)); 1889 1890 hw = &cap->hw; 1891 hw->s = s; 1892 hw->pcm_ops = &capture_pcm_ops; 1893 QLIST_INIT (&hw->sw_head); 1894 QLIST_INIT (&cap->cb_head); 1895 1896 /* XXX find a more elegant way */ 1897 hw->samples = 4096 * 4; 1898 audio_pcm_hw_alloc_resources_out(hw); 1899 1900 audio_pcm_init_info (&hw->info, as); 1901 1902 cap->buf = g_malloc0_n(hw->mix_buf->size, hw->info.bytes_per_frame); 1903 1904 if (hw->info.is_float) { 1905 hw->clip = mixeng_clip_float[hw->info.nchannels == 2]; 1906 } else { 1907 hw->clip = mixeng_clip 1908 [hw->info.nchannels == 2] 1909 [hw->info.is_signed] 1910 [hw->info.swap_endianness] 1911 [audio_bits_to_index(hw->info.bits)]; 1912 } 1913 1914 QLIST_INSERT_HEAD (&s->cap_head, cap, entries); 1915 QLIST_INSERT_HEAD (&cap->cb_head, cb, entries); 1916 1917 QLIST_FOREACH(hw, &s->hw_head_out, entries) { 1918 audio_attach_capture (hw); 1919 } 1920 return cap; 1921 } 1922 } 1923 1924 void AUD_del_capture (CaptureVoiceOut *cap, void *cb_opaque) 1925 { 1926 struct capture_callback *cb; 1927 1928 for (cb = cap->cb_head.lh_first; cb; cb = cb->entries.le_next) { 1929 if (cb->opaque == cb_opaque) { 1930 cb->ops.destroy (cb_opaque); 1931 QLIST_REMOVE (cb, entries); 1932 g_free (cb); 1933 1934 if (!cap->cb_head.lh_first) { 1935 SWVoiceOut *sw = cap->hw.sw_head.lh_first, *sw1; 1936 1937 while (sw) { 1938 SWVoiceCap *sc = (SWVoiceCap *) sw; 1939 #ifdef DEBUG_CAPTURE 1940 dolog ("freeing %s\n", sw->name); 1941 #endif 1942 1943 sw1 = sw->entries.le_next; 1944 if (sw->rate) { 1945 st_rate_stop (sw->rate); 1946 sw->rate = NULL; 1947 } 1948 QLIST_REMOVE (sw, entries); 1949 QLIST_REMOVE (sc, entries); 1950 g_free (sc); 1951 sw = sw1; 1952 } 1953 QLIST_REMOVE (cap, entries); 1954 g_free (cap->hw.mix_buf); 1955 g_free (cap->buf); 1956 g_free (cap); 1957 } 1958 return; 1959 } 1960 } 1961 } 1962 1963 void AUD_set_volume_out (SWVoiceOut *sw, int mute, uint8_t lvol, uint8_t rvol) 1964 { 1965 Volume vol = { .mute = mute, .channels = 2, .vol = { lvol, rvol } }; 1966 audio_set_volume_out(sw, &vol); 1967 } 1968 1969 void audio_set_volume_out(SWVoiceOut *sw, Volume *vol) 1970 { 1971 if (sw) { 1972 HWVoiceOut *hw = sw->hw; 1973 1974 sw->vol.mute = vol->mute; 1975 sw->vol.l = nominal_volume.l * vol->vol[0] / 255; 1976 sw->vol.r = nominal_volume.l * vol->vol[vol->channels > 1 ? 1 : 0] / 1977 255; 1978 1979 if (hw->pcm_ops->volume_out) { 1980 hw->pcm_ops->volume_out(hw, vol); 1981 } 1982 } 1983 } 1984 1985 void AUD_set_volume_in (SWVoiceIn *sw, int mute, uint8_t lvol, uint8_t rvol) 1986 { 1987 Volume vol = { .mute = mute, .channels = 2, .vol = { lvol, rvol } }; 1988 audio_set_volume_in(sw, &vol); 1989 } 1990 1991 void audio_set_volume_in(SWVoiceIn *sw, Volume *vol) 1992 { 1993 if (sw) { 1994 HWVoiceIn *hw = sw->hw; 1995 1996 sw->vol.mute = vol->mute; 1997 sw->vol.l = nominal_volume.l * vol->vol[0] / 255; 1998 sw->vol.r = nominal_volume.r * vol->vol[vol->channels > 1 ? 1 : 0] / 1999 255; 2000 2001 if (hw->pcm_ops->volume_in) { 2002 hw->pcm_ops->volume_in(hw, vol); 2003 } 2004 } 2005 } 2006 2007 void audio_create_pdos(Audiodev *dev) 2008 { 2009 switch (dev->driver) { 2010 #define CASE(DRIVER, driver, pdo_name) \ 2011 case AUDIODEV_DRIVER_##DRIVER: \ 2012 if (!dev->u.driver.has_in) { \ 2013 dev->u.driver.in = g_malloc0( \ 2014 sizeof(Audiodev##pdo_name##PerDirectionOptions)); \ 2015 dev->u.driver.has_in = true; \ 2016 } \ 2017 if (!dev->u.driver.has_out) { \ 2018 dev->u.driver.out = g_malloc0( \ 2019 sizeof(Audiodev##pdo_name##PerDirectionOptions)); \ 2020 dev->u.driver.has_out = true; \ 2021 } \ 2022 break 2023 2024 CASE(NONE, none, ); 2025 CASE(ALSA, alsa, Alsa); 2026 CASE(COREAUDIO, coreaudio, Coreaudio); 2027 CASE(DBUS, dbus, ); 2028 CASE(DSOUND, dsound, ); 2029 CASE(JACK, jack, Jack); 2030 CASE(OSS, oss, Oss); 2031 CASE(PA, pa, Pa); 2032 CASE(SDL, sdl, Sdl); 2033 CASE(SPICE, spice, ); 2034 CASE(WAV, wav, ); 2035 2036 case AUDIODEV_DRIVER__MAX: 2037 abort(); 2038 }; 2039 } 2040 2041 static void audio_validate_per_direction_opts( 2042 AudiodevPerDirectionOptions *pdo, Error **errp) 2043 { 2044 if (!pdo->has_mixing_engine) { 2045 pdo->has_mixing_engine = true; 2046 pdo->mixing_engine = true; 2047 } 2048 if (!pdo->has_fixed_settings) { 2049 pdo->has_fixed_settings = true; 2050 pdo->fixed_settings = pdo->mixing_engine; 2051 } 2052 if (!pdo->fixed_settings && 2053 (pdo->has_frequency || pdo->has_channels || pdo->has_format)) { 2054 error_setg(errp, 2055 "You can't use frequency, channels or format with fixed-settings=off"); 2056 return; 2057 } 2058 if (!pdo->mixing_engine && pdo->fixed_settings) { 2059 error_setg(errp, "You can't use fixed-settings without mixeng"); 2060 return; 2061 } 2062 2063 if (!pdo->has_frequency) { 2064 pdo->has_frequency = true; 2065 pdo->frequency = 44100; 2066 } 2067 if (!pdo->has_channels) { 2068 pdo->has_channels = true; 2069 pdo->channels = 2; 2070 } 2071 if (!pdo->has_voices) { 2072 pdo->has_voices = true; 2073 pdo->voices = pdo->mixing_engine ? 1 : INT_MAX; 2074 } 2075 if (!pdo->has_format) { 2076 pdo->has_format = true; 2077 pdo->format = AUDIO_FORMAT_S16; 2078 } 2079 } 2080 2081 static void audio_validate_opts(Audiodev *dev, Error **errp) 2082 { 2083 Error *err = NULL; 2084 2085 audio_create_pdos(dev); 2086 2087 audio_validate_per_direction_opts(audio_get_pdo_in(dev), &err); 2088 if (err) { 2089 error_propagate(errp, err); 2090 return; 2091 } 2092 2093 audio_validate_per_direction_opts(audio_get_pdo_out(dev), &err); 2094 if (err) { 2095 error_propagate(errp, err); 2096 return; 2097 } 2098 2099 if (!dev->has_timer_period) { 2100 dev->has_timer_period = true; 2101 dev->timer_period = 10000; /* 100Hz -> 10ms */ 2102 } 2103 } 2104 2105 void audio_help(void) 2106 { 2107 int i; 2108 2109 printf("Available audio drivers:\n"); 2110 2111 for (i = 0; i < AUDIODEV_DRIVER__MAX; i++) { 2112 audio_driver *driver = audio_driver_lookup(AudiodevDriver_str(i)); 2113 if (driver) { 2114 printf("%s\n", driver->name); 2115 } 2116 } 2117 } 2118 2119 void audio_parse_option(const char *opt) 2120 { 2121 Audiodev *dev = NULL; 2122 2123 if (is_help_option(opt)) { 2124 audio_help(); 2125 exit(EXIT_SUCCESS); 2126 } 2127 Visitor *v = qobject_input_visitor_new_str(opt, "driver", &error_fatal); 2128 visit_type_Audiodev(v, NULL, &dev, &error_fatal); 2129 visit_free(v); 2130 2131 audio_define(dev); 2132 } 2133 2134 void audio_define(Audiodev *dev) 2135 { 2136 AudiodevListEntry *e; 2137 2138 audio_validate_opts(dev, &error_fatal); 2139 2140 e = g_new0(AudiodevListEntry, 1); 2141 e->dev = dev; 2142 QSIMPLEQ_INSERT_TAIL(&audiodevs, e, next); 2143 } 2144 2145 bool audio_init_audiodevs(void) 2146 { 2147 AudiodevListEntry *e; 2148 2149 QSIMPLEQ_FOREACH(e, &audiodevs, next) { 2150 if (!audio_init(e->dev, NULL)) { 2151 return false; 2152 } 2153 } 2154 2155 return true; 2156 } 2157 2158 audsettings audiodev_to_audsettings(AudiodevPerDirectionOptions *pdo) 2159 { 2160 return (audsettings) { 2161 .freq = pdo->frequency, 2162 .nchannels = pdo->channels, 2163 .fmt = pdo->format, 2164 .endianness = AUDIO_HOST_ENDIANNESS, 2165 }; 2166 } 2167 2168 int audioformat_bytes_per_sample(AudioFormat fmt) 2169 { 2170 switch (fmt) { 2171 case AUDIO_FORMAT_U8: 2172 case AUDIO_FORMAT_S8: 2173 return 1; 2174 2175 case AUDIO_FORMAT_U16: 2176 case AUDIO_FORMAT_S16: 2177 return 2; 2178 2179 case AUDIO_FORMAT_U32: 2180 case AUDIO_FORMAT_S32: 2181 case AUDIO_FORMAT_F32: 2182 return 4; 2183 2184 case AUDIO_FORMAT__MAX: 2185 ; 2186 } 2187 abort(); 2188 } 2189 2190 2191 /* frames = freq * usec / 1e6 */ 2192 int audio_buffer_frames(AudiodevPerDirectionOptions *pdo, 2193 audsettings *as, int def_usecs) 2194 { 2195 uint64_t usecs = pdo->has_buffer_length ? pdo->buffer_length : def_usecs; 2196 return (as->freq * usecs + 500000) / 1000000; 2197 } 2198 2199 /* samples = channels * frames = channels * freq * usec / 1e6 */ 2200 int audio_buffer_samples(AudiodevPerDirectionOptions *pdo, 2201 audsettings *as, int def_usecs) 2202 { 2203 return as->nchannels * audio_buffer_frames(pdo, as, def_usecs); 2204 } 2205 2206 /* 2207 * bytes = bytes_per_sample * samples = 2208 * bytes_per_sample * channels * freq * usec / 1e6 2209 */ 2210 int audio_buffer_bytes(AudiodevPerDirectionOptions *pdo, 2211 audsettings *as, int def_usecs) 2212 { 2213 return audio_buffer_samples(pdo, as, def_usecs) * 2214 audioformat_bytes_per_sample(as->fmt); 2215 } 2216 2217 AudioState *audio_state_by_name(const char *name) 2218 { 2219 AudioState *s; 2220 QTAILQ_FOREACH(s, &audio_states, list) { 2221 assert(s->dev); 2222 if (strcmp(name, s->dev->id) == 0) { 2223 return s; 2224 } 2225 } 2226 return NULL; 2227 } 2228 2229 const char *audio_get_id(QEMUSoundCard *card) 2230 { 2231 if (card->state) { 2232 assert(card->state->dev); 2233 return card->state->dev->id; 2234 } else { 2235 return ""; 2236 } 2237 } 2238 2239 const char *audio_application_name(void) 2240 { 2241 const char *vm_name; 2242 2243 vm_name = qemu_get_vm_name(); 2244 return vm_name ? vm_name : "qemu"; 2245 } 2246 2247 void audio_rate_start(RateCtl *rate) 2248 { 2249 memset(rate, 0, sizeof(RateCtl)); 2250 rate->start_ticks = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL); 2251 } 2252 2253 size_t audio_rate_get_bytes(struct audio_pcm_info *info, RateCtl *rate, 2254 size_t bytes_avail) 2255 { 2256 int64_t now; 2257 int64_t ticks; 2258 int64_t bytes; 2259 int64_t samples; 2260 size_t ret; 2261 2262 now = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL); 2263 ticks = now - rate->start_ticks; 2264 bytes = muldiv64(ticks, info->bytes_per_second, NANOSECONDS_PER_SECOND); 2265 samples = (bytes - rate->bytes_sent) / info->bytes_per_frame; 2266 if (samples < 0 || samples > 65536) { 2267 AUD_log(NULL, "Resetting rate control (%" PRId64 " samples)\n", samples); 2268 audio_rate_start(rate); 2269 samples = 0; 2270 } 2271 2272 ret = MIN(samples * info->bytes_per_frame, bytes_avail); 2273 rate->bytes_sent += ret; 2274 return ret; 2275 } 2276