audio/audio.c

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