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