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