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