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/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 }