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