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