xref: /qemu/audio/audio.c (revision 09a36158)
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 
audio_driver_register(audio_driver * drv)76 void audio_driver_register(audio_driver *drv)
77 {
78     QLIST_INSERT_HEAD(&audio_drivers, drv, next);
79 }
80 
audio_driver_lookup(const char * name)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 
audio_bug(const char * funcname,int cond)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 
audio_bits_to_index(int bits)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 
AUD_vlog(const char * cap,const char * fmt,va_list ap)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 
AUD_log(const char * cap,const char * fmt,...)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 
audio_print_settings(struct audsettings * as)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 
audio_validate_settings(struct audsettings * as)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 
audio_pcm_info_eq(struct audio_pcm_info * info,struct audsettings * as)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 
audio_pcm_init_info(struct audio_pcm_info * info,struct audsettings * as)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 
audio_pcm_info_clear_buf(struct audio_pcm_info * info,void * buf,int len)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  */
audio_pcm_capture_find_specific(AudioState * s,struct audsettings * as)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 
audio_notify_capture(CaptureVoiceOut * cap,audcnotification_e cmd)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 
audio_capture_maybe_changed(CaptureVoiceOut * cap,int enabled)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 
audio_recalc_and_notify_capture(CaptureVoiceOut * cap)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 
audio_detach_capture(HWVoiceOut * hw)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 
audio_attach_capture(HWVoiceOut * hw)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  */
audio_pcm_hw_find_min_in(HWVoiceIn * hw)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 
audio_pcm_hw_get_live_in(HWVoiceIn * hw)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 
audio_pcm_hw_conv_in(HWVoiceIn * hw,void * pcm_buf,size_t samples)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  */
audio_pcm_sw_resample_in(SWVoiceIn * sw,size_t frames_in_max,size_t frames_out_max,size_t * total_in,size_t * total_out)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 
audio_pcm_sw_read(SWVoiceIn * sw,void * buf,size_t buf_len)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  */
audio_pcm_hw_find_min_out(HWVoiceOut * hw,int * nb_livep)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 
audio_pcm_hw_get_live_out(HWVoiceOut * hw,int * nb_live)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 
audio_pcm_hw_get_free(HWVoiceOut * hw)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 
audio_pcm_hw_clip_out(HWVoiceOut * hw,void * pcm_buf,size_t len)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  */
audio_pcm_sw_resample_out(SWVoiceOut * sw,size_t frames_in_max,size_t frames_out_max,size_t * total_in,size_t * total_out)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 
audio_pcm_sw_write(SWVoiceOut * sw,void * buf,size_t buf_len)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
audio_pcm_print_info(const char * cap,struct audio_pcm_info * info)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  */
audio_is_timer_needed(AudioState * s)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 
audio_reset_timer(AudioState * s)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 
audio_timer(void * opaque)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  */
AUD_write(SWVoiceOut * sw,void * buf,size_t size)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 
AUD_read(SWVoiceIn * sw,void * buf,size_t size)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 
AUD_get_buffer_size_out(SWVoiceOut * sw)906 int AUD_get_buffer_size_out(SWVoiceOut *sw)
907 {
908     return sw->hw->samples * sw->hw->info.bytes_per_frame;
909 }
910 
AUD_set_active_out(SWVoiceOut * sw,int on)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 
AUD_set_active_in(SWVoiceIn * sw,int on)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 
audio_get_avail(SWVoiceIn * sw)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 
audio_get_free(SWVoiceOut * sw)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 
audio_capture_mix_and_clear(HWVoiceOut * hw,size_t rpos,size_t samples)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 
audio_pcm_hw_run_out(HWVoiceOut * hw,size_t live)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 
audio_run_out(AudioState * s)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 
audio_pcm_hw_run_in(HWVoiceIn * hw,size_t samples)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 
audio_run_in(AudioState * s)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 
audio_run_capture(AudioState * s)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 
audio_run(AudioState * s,const char * msg)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 
audio_generic_run_buffer_in(HWVoiceIn * hw)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 
audio_generic_get_buffer_in(HWVoiceIn * hw,size_t * size)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 
audio_generic_put_buffer_in(HWVoiceIn * hw,void * buf,size_t size)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 
audio_generic_buffer_get_free(HWVoiceOut * hw)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 
audio_generic_run_buffer_out(HWVoiceOut * hw)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 
audio_generic_get_buffer_out(HWVoiceOut * hw,size_t * size)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 
audio_generic_put_buffer_out(HWVoiceOut * hw,void * buf,size_t size)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 
audio_generic_write(HWVoiceOut * hw,void * buf,size_t size)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 
audio_generic_read(HWVoiceIn * hw,void * buf,size_t size)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 
audio_driver_init(AudioState * s,struct audio_driver * drv,Audiodev * dev,Error ** errp)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 
audio_vm_change_state_handler(void * opaque,bool running,RunState state)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 
free_audio_state(AudioState * s)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 
audio_cleanup(void)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 
vmstate_audio_needed(void * opaque)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 
audio_create_default_audiodevs(void)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  */
audio_init(Audiodev * dev,Error ** errp)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 
audio_get_default_audio_state(Error ** errp)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 
AUD_register_card(const char * name,QEMUSoundCard * card,Error ** errp)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 
AUD_remove_card(QEMUSoundCard * card)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 
AUD_add_capture(AudioState * s,struct audsettings * as,struct audio_capture_ops * ops,void * cb_opaque)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 
AUD_del_capture(CaptureVoiceOut * cap,void * cb_opaque)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 
AUD_set_volume_out(SWVoiceOut * sw,int mute,uint8_t lvol,uint8_t rvol)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 
audio_set_volume_out(SWVoiceOut * sw,Volume * vol)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 
AUD_set_volume_in(SWVoiceIn * sw,int mute,uint8_t lvol,uint8_t rvol)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 
audio_set_volume_in(SWVoiceIn * sw,Volume * vol)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 
audio_create_pdos(Audiodev * dev)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 
audio_validate_per_direction_opts(AudiodevPerDirectionOptions * pdo,Error ** errp)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 
audio_validate_opts(Audiodev * dev,Error ** errp)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 
audio_help(void)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 
audio_parse_option(const char * opt)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 
audio_define(Audiodev * dev)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 
audio_define_default(Audiodev * dev,Error ** errp)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 
audio_init_audiodevs(void)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 
audiodev_to_audsettings(AudiodevPerDirectionOptions * pdo)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 
audioformat_bytes_per_sample(AudioFormat fmt)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 */
audio_buffer_frames(AudiodevPerDirectionOptions * pdo,audsettings * as,int def_usecs)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 */
audio_buffer_samples(AudiodevPerDirectionOptions * pdo,audsettings * as,int def_usecs)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  */
audio_buffer_bytes(AudiodevPerDirectionOptions * pdo,audsettings * as,int def_usecs)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 
audio_state_by_name(const char * name,Error ** errp)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 
audio_get_id(QEMUSoundCard * card)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 
audio_application_name(void)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 
audio_rate_start(RateCtl * rate)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 
audio_rate_peek_bytes(RateCtl * rate,struct audio_pcm_info * info)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 
audio_rate_add_bytes(RateCtl * rate,size_t bytes_used)2286 void audio_rate_add_bytes(RateCtl *rate, size_t bytes_used)
2287 {
2288     rate->bytes_sent += bytes_used;
2289 }
2290 
audio_rate_get_bytes(RateCtl * rate,struct audio_pcm_info * info,size_t bytes_avail)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 
qmp_query_audiodevs(Error ** errp)2303 AudiodevList *qmp_query_audiodevs(Error **errp)
2304 {
2305     AudiodevList *ret = NULL;
2306     AudiodevListEntry *e;
2307     QSIMPLEQ_FOREACH(e, &audiodevs, next) {
2308         QAPI_LIST_PREPEND(ret, QAPI_CLONE(Audiodev, e->dev));
2309     }
2310     return ret;
2311 }
2312