4 * Copyright (c) 2003-2005 Vassili Karpov (malc)
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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
26 #define AUDIO_CAP "audio"
27 #include "audio_int.h"
29 /* #define DEBUG_PLIVE */
30 /* #define DEBUG_LIVE */
31 /* #define DEBUG_OUT */
33 #define SW_NAME(sw) (sw)->name ? (sw)->name : "unknown"
35 static struct audio_driver
*drvtab
[] = {
42 #ifdef CONFIG_COREAUDIO
43 &coreaudio_audio_driver
,
58 struct fixed_settings
{
62 audsettings_t settings
;
66 struct fixed_settings fixed_out
;
67 struct fixed_settings fixed_in
;
75 { /* DAC fixed settings */
86 { /* ADC fixed settings */
99 0 /* log_to_monitor */
102 static AudioState glob_audio_state
;
104 volume_t nominal_volume
= {
115 /* http://www.df.lth.se/~john_e/gems/gem002d.html */
116 /* http://www.multi-platforms.com/Tips/PopCount.htm */
117 uint32_t popcount (uint32_t u
)
119 u
= ((u
&0x55555555) + ((u
>>1)&0x55555555));
120 u
= ((u
&0x33333333) + ((u
>>2)&0x33333333));
121 u
= ((u
&0x0f0f0f0f) + ((u
>>4)&0x0f0f0f0f));
122 u
= ((u
&0x00ff00ff) + ((u
>>8)&0x00ff00ff));
123 u
= ( u
&0x0000ffff) + (u
>>16);
127 inline uint32_t lsbindex (uint32_t u
)
129 return popcount ((u
&-u
)-1);
132 #ifdef AUDIO_IS_FLAWLESS_AND_NO_CHECKS_ARE_REQURIED
135 int audio_bug (const char *funcname
, int cond
)
140 AUD_log (NULL
, "Error a bug that was just triggered in %s\n", funcname
);
143 AUD_log (NULL
, "Save all your work and restart without audio\n");
144 AUD_log (NULL
, "Please send bug report to malc@pulsesoft.com\n");
145 AUD_log (NULL
, "I am sorry\n");
147 AUD_log (NULL
, "Context:\n");
149 #if defined AUDIO_BREAKPOINT_ON_BUG
150 # if defined HOST_I386
151 # if defined __GNUC__
153 # elif defined _MSC_VER
168 void *audio_calloc (const char *funcname
, int nmemb
, size_t size
)
174 cond
= !nmemb
|| !size
;
178 if (audio_bug ("audio_calloc", cond
)) {
179 AUD_log (NULL
, "%s passed invalid arguments to audio_calloc\n",
181 AUD_log (NULL
, "nmemb=%d size=%zu (len=%zu)\n", nmemb
, size
, len
);
185 return qemu_mallocz (len
);
188 static char *audio_alloc_prefix (const char *s
)
190 const char qemu_prefix
[] = "QEMU_";
199 r
= qemu_malloc (len
+ sizeof (qemu_prefix
));
203 char *u
= r
+ sizeof (qemu_prefix
) - 1;
205 strcpy (r
, qemu_prefix
);
208 for (i
= 0; i
< len
; ++i
) {
209 u
[i
] = toupper (u
[i
]);
215 const char *audio_audfmt_to_string (audfmt_e fmt
)
231 dolog ("Bogus audfmt %d returning S16\n", fmt
);
235 audfmt_e
audio_string_to_audfmt (const char *s
, audfmt_e defval
, int *defaultp
)
237 if (!strcasecmp (s
, "u8")) {
241 else if (!strcasecmp (s
, "u16")) {
245 else if (!strcasecmp (s
, "s8")) {
249 else if (!strcasecmp (s
, "s16")) {
254 dolog ("Bogus audio format `%s' using %s\n",
255 s
, audio_audfmt_to_string (defval
));
261 static audfmt_e
audio_get_conf_fmt (const char *envname
,
265 const char *var
= getenv (envname
);
270 return audio_string_to_audfmt (var
, defval
, defaultp
);
273 static int audio_get_conf_int (const char *key
, int defval
, int *defaultp
)
278 strval
= getenv (key
);
290 static const char *audio_get_conf_str (const char *key
,
294 const char *val
= getenv (key
);
305 void AUD_vlog (const char *cap
, const char *fmt
, va_list ap
)
307 if (conf
.log_to_monitor
) {
309 term_printf ("%s: ", cap
);
312 term_vprintf (fmt
, ap
);
316 fprintf (stderr
, "%s: ", cap
);
319 vfprintf (stderr
, fmt
, ap
);
323 void AUD_log (const char *cap
, const char *fmt
, ...)
328 AUD_vlog (cap
, fmt
, ap
);
332 static void audio_print_options (const char *prefix
,
333 struct audio_option
*opt
)
338 dolog ("No prefix specified\n");
343 dolog ("No options\n");
347 uprefix
= audio_alloc_prefix (prefix
);
349 for (; opt
->name
; opt
++) {
350 const char *state
= "default";
351 printf (" %s_%s: ", uprefix
, opt
->name
);
353 if (opt
->overridenp
&& *opt
->overridenp
) {
360 int *intp
= opt
->valp
;
361 printf ("boolean, %s = %d\n", state
, *intp
? 1 : 0);
367 int *intp
= opt
->valp
;
368 printf ("integer, %s = %d\n", state
, *intp
);
374 audfmt_e
*fmtp
= opt
->valp
;
376 "format, %s = %s, (one of: U8 S8 U16 S16)\n",
378 audio_audfmt_to_string (*fmtp
)
385 const char **strp
= opt
->valp
;
386 printf ("string, %s = %s\n",
388 *strp
? *strp
: "(not set)");
394 dolog ("Bad value tag for option %s_%s %d\n",
395 uprefix
, opt
->name
, opt
->tag
);
398 printf (" %s\n", opt
->descr
);
404 static void audio_process_options (const char *prefix
,
405 struct audio_option
*opt
)
408 const char qemu_prefix
[] = "QEMU_";
411 if (audio_bug (AUDIO_FUNC
, !prefix
)) {
412 dolog ("prefix = NULL\n");
416 if (audio_bug (AUDIO_FUNC
, !opt
)) {
417 dolog ("opt = NULL\n");
421 preflen
= strlen (prefix
);
423 for (; opt
->name
; opt
++) {
428 dolog ("Option value pointer for `%s' is not set\n",
433 len
= strlen (opt
->name
);
434 /* len of opt->name + len of prefix + size of qemu_prefix
435 * (includes trailing zero) + zero + underscore (on behalf of
437 optname
= qemu_malloc (len
+ preflen
+ sizeof (qemu_prefix
) + 1);
439 dolog ("Could not allocate memory for option name `%s'\n",
444 strcpy (optname
, qemu_prefix
);
446 /* copy while upper-casing, including trailing zero */
447 for (i
= 0; i
<= preflen
; ++i
) {
448 optname
[i
+ sizeof (qemu_prefix
) - 1] = toupper (prefix
[i
]);
450 strcat (optname
, "_");
451 strcat (optname
, opt
->name
);
458 int *intp
= opt
->valp
;
459 *intp
= audio_get_conf_int (optname
, *intp
, &def
);
465 audfmt_e
*fmtp
= opt
->valp
;
466 *fmtp
= audio_get_conf_fmt (optname
, *fmtp
, &def
);
472 const char **strp
= opt
->valp
;
473 *strp
= audio_get_conf_str (optname
, *strp
, &def
);
478 dolog ("Bad value tag for option `%s' - %d\n",
483 if (!opt
->overridenp
) {
484 opt
->overridenp
= &opt
->overriden
;
486 *opt
->overridenp
= !def
;
491 static void audio_print_settings (audsettings_t
*as
)
493 dolog ("frequency=%d nchannels=%d fmt=", as
->freq
, as
->nchannels
);
497 AUD_log (NULL
, "S8");
500 AUD_log (NULL
, "U8");
503 AUD_log (NULL
, "S16");
506 AUD_log (NULL
, "U16");
509 AUD_log (NULL
, "invalid(%d)", as
->fmt
);
512 AUD_log (NULL
, "\n");
515 static int audio_validate_settigs (audsettings_t
*as
)
519 invalid
= as
->nchannels
!= 1 && as
->nchannels
!= 2;
532 invalid
|= as
->freq
<= 0;
540 static int audio_pcm_info_eq (struct audio_pcm_info
*info
, audsettings_t
*as
)
542 int bits
= 8, sign
= 0;
556 return info
->freq
== as
->freq
557 && info
->nchannels
== as
->nchannels
558 && info
->sign
== sign
559 && info
->bits
== bits
;
562 void audio_pcm_init_info (
563 struct audio_pcm_info
*info
,
568 int bits
= 8, sign
= 0;
583 info
->freq
= as
->freq
;
586 info
->nchannels
= as
->nchannels
;
587 info
->shift
= (as
->nchannels
== 2) + (bits
== 16);
588 info
->align
= (1 << info
->shift
) - 1;
589 info
->bytes_per_second
= info
->freq
<< info
->shift
;
590 info
->swap_endian
= swap_endian
;
593 void audio_pcm_info_clear_buf (struct audio_pcm_info
*info
, void *buf
, int len
)
600 memset (buf
, len
<< info
->shift
, 0x00);
603 if (info
->bits
== 8) {
604 memset (buf
, len
<< info
->shift
, 0x80);
609 int shift
= info
->nchannels
- 1;
612 if (info
->swap_endian
) {
616 for (i
= 0; i
< len
<< shift
; i
++) {
624 * Hard voice (capture)
626 static int audio_pcm_hw_find_min_in (HWVoiceIn
*hw
)
629 int m
= hw
->total_samples_captured
;
631 for (sw
= hw
->sw_head
.lh_first
; sw
; sw
= sw
->entries
.le_next
) {
633 m
= audio_MIN (m
, sw
->total_hw_samples_acquired
);
639 int audio_pcm_hw_get_live_in (HWVoiceIn
*hw
)
641 int live
= hw
->total_samples_captured
- audio_pcm_hw_find_min_in (hw
);
642 if (audio_bug (AUDIO_FUNC
, live
< 0 || live
> hw
->samples
)) {
643 dolog ("live=%d hw->samples=%d\n", live
, hw
->samples
);
650 * Soft voice (capture)
652 static int audio_pcm_sw_get_rpos_in (SWVoiceIn
*sw
)
654 HWVoiceIn
*hw
= sw
->hw
;
655 int live
= hw
->total_samples_captured
- sw
->total_hw_samples_acquired
;
658 if (audio_bug (AUDIO_FUNC
, live
< 0 || live
> hw
->samples
)) {
659 dolog ("live=%d hw->samples=%d\n", live
, hw
->samples
);
663 rpos
= hw
->wpos
- live
;
668 return hw
->samples
+ rpos
;
672 int audio_pcm_sw_read (SWVoiceIn
*sw
, void *buf
, int size
)
674 HWVoiceIn
*hw
= sw
->hw
;
675 int samples
, live
, ret
= 0, swlim
, isamp
, osamp
, rpos
, total
= 0;
676 st_sample_t
*src
, *dst
= sw
->buf
;
678 rpos
= audio_pcm_sw_get_rpos_in (sw
) % hw
->samples
;
680 live
= hw
->total_samples_captured
- sw
->total_hw_samples_acquired
;
681 if (audio_bug (AUDIO_FUNC
, live
< 0 || live
> hw
->samples
)) {
682 dolog ("live_in=%d hw->samples=%d\n", live
, hw
->samples
);
686 samples
= size
>> sw
->info
.shift
;
691 swlim
= (live
* sw
->ratio
) >> 32;
692 swlim
= audio_MIN (swlim
, samples
);
695 src
= hw
->conv_buf
+ rpos
;
696 isamp
= hw
->wpos
- rpos
;
699 isamp
= hw
->samples
- rpos
;
707 if (audio_bug (AUDIO_FUNC
, osamp
< 0)) {
708 dolog ("osamp=%d\n", osamp
);
712 st_rate_flow (sw
->rate
, src
, dst
, &isamp
, &osamp
);
714 rpos
= (rpos
+ isamp
) % hw
->samples
;
720 sw
->clip (buf
, sw
->buf
, ret
);
721 sw
->total_hw_samples_acquired
+= total
;
722 return ret
<< sw
->info
.shift
;
726 * Hard voice (playback)
728 static int audio_pcm_hw_find_min_out (HWVoiceOut
*hw
, int *nb_livep
)
734 for (sw
= hw
->sw_head
.lh_first
; sw
; sw
= sw
->entries
.le_next
) {
735 if (sw
->active
|| !sw
->empty
) {
736 m
= audio_MIN (m
, sw
->total_hw_samples_mixed
);
745 int audio_pcm_hw_get_live_out2 (HWVoiceOut
*hw
, int *nb_live
)
749 smin
= audio_pcm_hw_find_min_out (hw
, nb_live
);
757 if (audio_bug (AUDIO_FUNC
, live
< 0 || live
> hw
->samples
)) {
758 dolog ("live=%d hw->samples=%d\n", live
, hw
->samples
);
765 int audio_pcm_hw_get_live_out (HWVoiceOut
*hw
)
770 live
= audio_pcm_hw_get_live_out2 (hw
, &nb_live
);
771 if (audio_bug (AUDIO_FUNC
, live
< 0 || live
> hw
->samples
)) {
772 dolog ("live=%d hw->samples=%d\n", live
, hw
->samples
);
779 * Soft voice (playback)
781 int audio_pcm_sw_write (SWVoiceOut
*sw
, void *buf
, int size
)
783 int hwsamples
, samples
, isamp
, osamp
, wpos
, live
, dead
, left
, swlim
, blck
;
784 int ret
= 0, pos
= 0, total
= 0;
790 hwsamples
= sw
->hw
->samples
;
792 live
= sw
->total_hw_samples_mixed
;
793 if (audio_bug (AUDIO_FUNC
, live
< 0 || live
> hwsamples
)){
794 dolog ("live=%d hw->samples=%d\n", live
, hwsamples
);
798 if (live
== hwsamples
) {
802 wpos
= (sw
->hw
->rpos
+ live
) % hwsamples
;
803 samples
= size
>> sw
->info
.shift
;
805 dead
= hwsamples
- live
;
806 swlim
= ((int64_t) dead
<< 32) / sw
->ratio
;
807 swlim
= audio_MIN (swlim
, samples
);
809 sw
->conv (sw
->buf
, buf
, swlim
, &sw
->vol
);
813 dead
= hwsamples
- live
;
814 left
= hwsamples
- wpos
;
815 blck
= audio_MIN (dead
, left
);
824 sw
->hw
->mix_buf
+ wpos
,
832 wpos
= (wpos
+ osamp
) % hwsamples
;
836 sw
->total_hw_samples_mixed
+= total
;
837 sw
->empty
= sw
->total_hw_samples_mixed
== 0;
841 "%s: write size %d ret %d total sw %d\n",
843 size
>> sw
->info
.shift
,
845 sw
->total_hw_samples_mixed
849 return ret
<< sw
->info
.shift
;
853 static void audio_pcm_print_info (const char *cap
, struct audio_pcm_info
*info
)
855 dolog ("%s: bits %d, sign %d, freq %d, nchan %d\n",
856 cap
, info
->bits
, info
->sign
, info
->freq
, info
->nchannels
);
861 #include "audio_template.h"
863 #include "audio_template.h"
865 int AUD_write (SWVoiceOut
*sw
, void *buf
, int size
)
870 /* XXX: Consider options */
874 if (!sw
->hw
->enabled
) {
875 dolog ("Writing to disabled voice %s\n", SW_NAME (sw
));
879 bytes
= sw
->hw
->pcm_ops
->write (sw
, buf
, size
);
883 int AUD_read (SWVoiceIn
*sw
, void *buf
, int size
)
888 /* XXX: Consider options */
892 if (!sw
->hw
->enabled
) {
893 dolog ("Reading from disabled voice %s\n", SW_NAME (sw
));
897 bytes
= sw
->hw
->pcm_ops
->read (sw
, buf
, size
);
901 int AUD_get_buffer_size_out (SWVoiceOut
*sw
)
903 return sw
->hw
->samples
<< sw
->hw
->info
.shift
;
906 void AUD_set_active_out (SWVoiceOut
*sw
, int on
)
915 if (sw
->active
!= on
) {
921 hw
->pending_disable
= 0;
924 hw
->pcm_ops
->ctl_out (hw
, VOICE_ENABLE
);
935 for (temp_sw
= hw
->sw_head
.lh_first
; temp_sw
;
936 temp_sw
= temp_sw
->entries
.le_next
) {
937 nb_active
+= temp_sw
->active
!= 0;
940 hw
->pending_disable
= nb_active
== 1;
947 void AUD_set_active_in (SWVoiceIn
*sw
, int on
)
956 if (sw
->active
!= on
) {
962 hw
->pcm_ops
->ctl_in (hw
, VOICE_ENABLE
);
964 sw
->total_hw_samples_acquired
= hw
->total_samples_captured
;
970 for (temp_sw
= hw
->sw_head
.lh_first
; temp_sw
;
971 temp_sw
= temp_sw
->entries
.le_next
) {
972 nb_active
+= temp_sw
->active
!= 0;
975 if (nb_active
== 1) {
977 hw
->pcm_ops
->ctl_in (hw
, VOICE_DISABLE
);
985 static int audio_get_avail (SWVoiceIn
*sw
)
993 live
= sw
->hw
->total_samples_captured
- sw
->total_hw_samples_acquired
;
994 if (audio_bug (AUDIO_FUNC
, live
< 0 || live
> sw
->hw
->samples
)) {
995 dolog ("live=%d sw->hw->samples=%d\n", live
, sw
->hw
->samples
);
1000 "%s: get_avail live %d ret %lld\n",
1002 live
, (((int64_t) live
<< 32) / sw
->ratio
) << sw
->info
.shift
1005 return (((int64_t) live
<< 32) / sw
->ratio
) << sw
->info
.shift
;
1008 static int audio_get_free (SWVoiceOut
*sw
)
1016 live
= sw
->total_hw_samples_mixed
;
1018 if (audio_bug (AUDIO_FUNC
, live
< 0 || live
> sw
->hw
->samples
)) {
1019 dolog ("live=%d sw->hw->samples=%d\n", live
, sw
->hw
->samples
);
1023 dead
= sw
->hw
->samples
- live
;
1026 dolog ("%s: get_free live %d dead %d ret %lld\n",
1028 live
, dead
, (((int64_t) dead
<< 32) / sw
->ratio
) << sw
->info
.shift
);
1031 return (((int64_t) dead
<< 32) / sw
->ratio
) << sw
->info
.shift
;
1034 static void audio_run_out (AudioState
*s
)
1036 HWVoiceOut
*hw
= NULL
;
1039 while ((hw
= audio_pcm_hw_find_any_enabled_out (s
, hw
))) {
1041 int live
, free
, nb_live
, cleanup_required
;
1043 live
= audio_pcm_hw_get_live_out2 (hw
, &nb_live
);
1048 if (audio_bug (AUDIO_FUNC
, live
< 0 || live
> hw
->samples
)) {
1049 dolog ("live=%d hw->samples=%d\n", live
, hw
->samples
);
1053 if (hw
->pending_disable
&& !nb_live
) {
1055 dolog ("Disabling voice\n");
1058 hw
->pending_disable
= 0;
1059 hw
->pcm_ops
->ctl_out (hw
, VOICE_DISABLE
);
1064 for (sw
= hw
->sw_head
.lh_first
; sw
; sw
= sw
->entries
.le_next
) {
1066 free
= audio_get_free (sw
);
1068 sw
->callback
.fn (sw
->callback
.opaque
, free
);
1075 played
= hw
->pcm_ops
->run_out (hw
);
1076 if (audio_bug (AUDIO_FUNC
, hw
->rpos
>= hw
->samples
)) {
1077 dolog ("hw->rpos=%d hw->samples=%d played=%d\n",
1078 hw
->rpos
, hw
->samples
, played
);
1083 dolog ("played=%d\n", played
);
1087 hw
->ts_helper
+= played
;
1090 cleanup_required
= 0;
1091 for (sw
= hw
->sw_head
.lh_first
; sw
; sw
= sw
->entries
.le_next
) {
1092 if (!sw
->active
&& sw
->empty
) {
1096 if (audio_bug (AUDIO_FUNC
, played
> sw
->total_hw_samples_mixed
)) {
1097 dolog ("played=%d sw->total_hw_samples_mixed=%d\n",
1098 played
, sw
->total_hw_samples_mixed
);
1099 played
= sw
->total_hw_samples_mixed
;
1102 sw
->total_hw_samples_mixed
-= played
;
1104 if (!sw
->total_hw_samples_mixed
) {
1106 cleanup_required
|= !sw
->active
&& !sw
->callback
.fn
;
1110 free
= audio_get_free (sw
);
1112 sw
->callback
.fn (sw
->callback
.opaque
, free
);
1117 if (cleanup_required
) {
1119 for (sw
= hw
->sw_head
.lh_first
; sw
; sw
= sw
->entries
.le_next
) {
1120 if (!sw
->active
&& !sw
->callback
.fn
) {
1122 dolog ("Finishing with old voice\n");
1124 audio_close_out (s
, sw
);
1125 goto restart
; /* play it safe */
1132 static void audio_run_in (AudioState
*s
)
1134 HWVoiceIn
*hw
= NULL
;
1136 while ((hw
= audio_pcm_hw_find_any_enabled_in (s
, hw
))) {
1140 captured
= hw
->pcm_ops
->run_in (hw
);
1142 min
= audio_pcm_hw_find_min_in (hw
);
1143 hw
->total_samples_captured
+= captured
- min
;
1144 hw
->ts_helper
+= captured
;
1146 for (sw
= hw
->sw_head
.lh_first
; sw
; sw
= sw
->entries
.le_next
) {
1147 sw
->total_hw_samples_acquired
-= min
;
1152 avail
= audio_get_avail (sw
);
1154 sw
->callback
.fn (sw
->callback
.opaque
, avail
);
1161 static void audio_timer (void *opaque
)
1163 AudioState
*s
= opaque
;
1168 qemu_mod_timer (s
->ts
, qemu_get_clock (vm_clock
) + conf
.period
.ticks
);
1171 static struct audio_option audio_options
[] = {
1173 {"DAC_FIXED_SETTINGS", AUD_OPT_BOOL
, &conf
.fixed_out
.enabled
,
1174 "Use fixed settings for host DAC", NULL
, 0},
1176 {"DAC_FIXED_FREQ", AUD_OPT_INT
, &conf
.fixed_out
.settings
.freq
,
1177 "Frequency for fixed host DAC", NULL
, 0},
1179 {"DAC_FIXED_FMT", AUD_OPT_FMT
, &conf
.fixed_out
.settings
.fmt
,
1180 "Format for fixed host DAC", NULL
, 0},
1182 {"DAC_FIXED_CHANNELS", AUD_OPT_INT
, &conf
.fixed_out
.settings
.nchannels
,
1183 "Number of channels for fixed DAC (1 - mono, 2 - stereo)", NULL
, 0},
1185 {"DAC_VOICES", AUD_OPT_INT
, &conf
.fixed_out
.nb_voices
,
1186 "Number of voices for DAC", NULL
, 0},
1189 {"ADC_FIXED_SETTINGS", AUD_OPT_BOOL
, &conf
.fixed_in
.enabled
,
1190 "Use fixed settings for host ADC", NULL
, 0},
1192 {"ADC_FIXED_FREQ", AUD_OPT_INT
, &conf
.fixed_in
.settings
.freq
,
1193 "Frequency for fixed host ADC", NULL
, 0},
1195 {"ADC_FIXED_FMT", AUD_OPT_FMT
, &conf
.fixed_in
.settings
.fmt
,
1196 "Format for fixed host ADC", NULL
, 0},
1198 {"ADC_FIXED_CHANNELS", AUD_OPT_INT
, &conf
.fixed_in
.settings
.nchannels
,
1199 "Number of channels for fixed ADC (1 - mono, 2 - stereo)", NULL
, 0},
1201 {"ADC_VOICES", AUD_OPT_INT
, &conf
.fixed_in
.nb_voices
,
1202 "Number of voices for ADC", NULL
, 0},
1205 {"TIMER_PERIOD", AUD_OPT_INT
, &conf
.period
.hz
,
1206 "Timer period in HZ (0 - use lowest possible)", NULL
, 0},
1208 {"PLIVE", AUD_OPT_BOOL
, &conf
.plive
,
1209 "(undocumented)", NULL
, 0},
1211 {"LOG_TO_MONITOR", AUD_OPT_BOOL
, &conf
.log_to_monitor
,
1212 "print logging messages to montior instead of stderr", NULL
, 0},
1214 {NULL
, 0, NULL
, NULL
, NULL
, 0}
1217 static void audio_pp_nb_voices (const char *typ
, int nb
)
1221 printf ("Does not support %s\n", typ
);
1224 printf ("One %s voice\n", typ
);
1227 printf ("Theoretically supports many %s voices\n", typ
);
1230 printf ("Theoretically supports upto %d %s voices\n", nb
, typ
);
1236 void AUD_help (void)
1240 audio_process_options ("AUDIO", audio_options
);
1241 for (i
= 0; i
< sizeof (drvtab
) / sizeof (drvtab
[0]); i
++) {
1242 struct audio_driver
*d
= drvtab
[i
];
1244 audio_process_options (d
->name
, d
->options
);
1248 printf ("Audio options:\n");
1249 audio_print_options ("AUDIO", audio_options
);
1252 printf ("Available drivers:\n");
1254 for (i
= 0; i
< sizeof (drvtab
) / sizeof (drvtab
[0]); i
++) {
1255 struct audio_driver
*d
= drvtab
[i
];
1257 printf ("Name: %s\n", d
->name
);
1258 printf ("Description: %s\n", d
->descr
);
1260 audio_pp_nb_voices ("playback", d
->max_voices_out
);
1261 audio_pp_nb_voices ("capture", d
->max_voices_in
);
1264 printf ("Options:\n");
1265 audio_print_options (d
->name
, d
->options
);
1268 printf ("No options\n");
1274 "Options are settable through environment variables.\n"
1277 " set QEMU_AUDIO_DRV=wav\n"
1278 " set QEMU_WAV_PATH=c:\\tune.wav\n"
1280 " export QEMU_AUDIO_DRV=wav\n"
1281 " export QEMU_WAV_PATH=$HOME/tune.wav\n"
1282 "(for csh replace export with setenv in the above)\n"
1288 static int audio_driver_init (AudioState
*s
, struct audio_driver
*drv
)
1291 audio_process_options (drv
->name
, drv
->options
);
1293 s
->drv_opaque
= drv
->init ();
1295 if (s
->drv_opaque
) {
1296 audio_init_nb_voices_out (s
, drv
);
1297 audio_init_nb_voices_in (s
, drv
);
1302 dolog ("Could not init `%s' audio driver\n", drv
->name
);
1307 static void audio_vm_change_state_handler (void *opaque
, int running
)
1309 AudioState
*s
= opaque
;
1310 HWVoiceOut
*hwo
= NULL
;
1311 HWVoiceIn
*hwi
= NULL
;
1312 int op
= running
? VOICE_ENABLE
: VOICE_DISABLE
;
1314 while ((hwo
= audio_pcm_hw_find_any_enabled_out (s
, hwo
))) {
1315 hwo
->pcm_ops
->ctl_out (hwo
, op
);
1318 while ((hwi
= audio_pcm_hw_find_any_enabled_in (s
, hwi
))) {
1319 hwi
->pcm_ops
->ctl_in (hwi
, op
);
1323 static void audio_atexit (void)
1325 AudioState
*s
= &glob_audio_state
;
1326 HWVoiceOut
*hwo
= NULL
;
1327 HWVoiceIn
*hwi
= NULL
;
1329 while ((hwo
= audio_pcm_hw_find_any_enabled_out (s
, hwo
))) {
1330 hwo
->pcm_ops
->ctl_out (hwo
, VOICE_DISABLE
);
1331 hwo
->pcm_ops
->fini_out (hwo
);
1334 while ((hwi
= audio_pcm_hw_find_any_enabled_in (s
, hwi
))) {
1335 hwi
->pcm_ops
->ctl_in (hwi
, VOICE_DISABLE
);
1336 hwi
->pcm_ops
->fini_in (hwi
);
1340 s
->drv
->fini (s
->drv_opaque
);
1344 static void audio_save (QEMUFile
*f
, void *opaque
)
1350 static int audio_load (QEMUFile
*f
, void *opaque
, int version_id
)
1355 if (version_id
!= 1) {
1362 void AUD_register_card (AudioState
*s
, const char *name
, QEMUSoundCard
*card
)
1365 card
->name
= qemu_strdup (name
);
1366 memset (&card
->entries
, 0, sizeof (card
->entries
));
1367 LIST_INSERT_HEAD (&s
->card_head
, card
, entries
);
1370 void AUD_remove_card (QEMUSoundCard
*card
)
1372 LIST_REMOVE (card
, entries
);
1374 qemu_free (card
->name
);
1377 AudioState
*AUD_init (void)
1381 const char *drvname
;
1382 AudioState
*s
= &glob_audio_state
;
1384 LIST_INIT (&s
->hw_head_out
);
1385 LIST_INIT (&s
->hw_head_in
);
1386 atexit (audio_atexit
);
1388 s
->ts
= qemu_new_timer (vm_clock
, audio_timer
, s
);
1390 dolog ("Could not create audio timer\n");
1394 audio_process_options ("AUDIO", audio_options
);
1396 s
->nb_hw_voices_out
= conf
.fixed_out
.nb_voices
;
1397 s
->nb_hw_voices_in
= conf
.fixed_in
.nb_voices
;
1399 if (s
->nb_hw_voices_out
<= 0) {
1400 dolog ("Bogus number of playback voices %d, setting to 1\n",
1401 s
->nb_hw_voices_out
);
1402 s
->nb_hw_voices_out
= 1;
1405 if (s
->nb_hw_voices_in
<= 0) {
1406 dolog ("Bogus number of capture voices %d, setting to 0\n",
1407 s
->nb_hw_voices_in
);
1408 s
->nb_hw_voices_in
= 0;
1413 drvname
= audio_get_conf_str ("QEMU_AUDIO_DRV", NULL
, &def
);
1419 for (i
= 0; i
< sizeof (drvtab
) / sizeof (drvtab
[0]); i
++) {
1420 if (!strcmp (drvname
, drvtab
[i
]->name
)) {
1421 done
= !audio_driver_init (s
, drvtab
[i
]);
1428 dolog ("Unknown audio driver `%s'\n", drvname
);
1429 dolog ("Run with -audio-help to list available drivers\n");
1434 for (i
= 0; !done
&& i
< sizeof (drvtab
) / sizeof (drvtab
[0]); i
++) {
1435 if (drvtab
[i
]->can_be_default
) {
1436 done
= !audio_driver_init (s
, drvtab
[i
]);
1442 done
= !audio_driver_init (s
, &no_audio_driver
);
1444 dolog ("Could not initialize audio subsystem\n");
1447 dolog ("warning: Using timer based audio emulation\n");
1452 VMChangeStateEntry
*e
;
1454 if (conf
.period
.hz
<= 0) {
1455 if (conf
.period
.hz
< 0) {
1456 dolog ("warning: Timer period is negative - %d "
1457 "treating as zero\n",
1460 conf
.period
.ticks
= 1;
1463 conf
.period
.ticks
= ticks_per_sec
/ conf
.period
.hz
;
1466 e
= qemu_add_vm_change_state_handler (audio_vm_change_state_handler
, s
);
1468 dolog ("warning: Could not register change state handler\n"
1469 "(Audio can continue looping even after stopping the VM)\n");
1473 qemu_del_timer (s
->ts
);
1477 LIST_INIT (&s
->card_head
);
1478 register_savevm ("audio", 0, 1, audio_save
, audio_load
, s
);
1479 qemu_mod_timer (s
->ts
, qemu_get_clock (vm_clock
) + conf
.period
.ticks
);