ia64/xen-unstable

view tools/ioemu/audio/audio.c @ 9137:eb24eb6bc341

Fix some warnings when compiling tools.

Signed-off-by: Xin Li <xin.b.li@intel.com>
author kaf24@firebug.cl.cam.ac.uk
date Sat Mar 04 10:25:05 2006 +0100 (2006-03-04)
parents c4ae9456a459
children f7b43e5c42b9
line source
1 /*
2 * QEMU Audio subsystem
3 *
4 * Copyright (c) 2003-2004 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 <assert.h>
25 #include "vl.h"
27 #define USE_WAV_AUDIO
29 #include "audio/audio_int.h"
31 #define dolog(...) AUD_log ("audio", __VA_ARGS__)
32 #ifdef DEBUG
33 #define ldebug(...) dolog (__VA_ARGS__)
34 #else
35 #define ldebug(...)
36 #endif
38 #define QC_AUDIO_DRV "QEMU_AUDIO_DRV"
39 #define QC_VOICES "QEMU_VOICES"
40 #define QC_FIXED_FORMAT "QEMU_FIXED_FORMAT"
41 #define QC_FIXED_FREQ "QEMU_FIXED_FREQ"
43 static HWVoice *hw_voices;
45 AudioState audio_state = {
46 1, /* use fixed settings */
47 44100, /* fixed frequency */
48 2, /* fixed channels */
49 AUD_FMT_S16, /* fixed format */
50 1, /* number of hw voices */
51 -1 /* voice size */
52 };
54 /* http://www.df.lth.se/~john_e/gems/gem002d.html */
55 /* http://www.multi-platforms.com/Tips/PopCount.htm */
56 uint32_t popcount (uint32_t u)
57 {
58 u = ((u&0x55555555) + ((u>>1)&0x55555555));
59 u = ((u&0x33333333) + ((u>>2)&0x33333333));
60 u = ((u&0x0f0f0f0f) + ((u>>4)&0x0f0f0f0f));
61 u = ((u&0x00ff00ff) + ((u>>8)&0x00ff00ff));
62 u = ( u&0x0000ffff) + (u>>16);
63 return u;
64 }
66 inline uint32_t lsbindex (uint32_t u)
67 {
68 return popcount ((u&-u)-1);
69 }
71 int audio_get_conf_int (const char *key, int defval)
72 {
73 int val = defval;
74 char *strval;
76 strval = getenv (key);
77 if (strval) {
78 val = atoi (strval);
79 }
81 return val;
82 }
84 const char *audio_get_conf_str (const char *key, const char *defval)
85 {
86 const char *val = getenv (key);
87 if (!val)
88 return defval;
89 else
90 return val;
91 }
93 void AUD_log (const char *cap, const char *fmt, ...)
94 {
95 va_list ap;
96 fprintf (stderr, "%s: ", cap);
97 va_start (ap, fmt);
98 vfprintf (stderr, fmt, ap);
99 va_end (ap);
100 }
102 /*
103 * Soft Voice
104 */
105 void pcm_sw_free_resources (SWVoice *sw)
106 {
107 if (sw->buf) qemu_free (sw->buf);
108 if (sw->rate) st_rate_stop (sw->rate);
109 sw->buf = NULL;
110 sw->rate = NULL;
111 }
113 int pcm_sw_alloc_resources (SWVoice *sw)
114 {
115 sw->buf = qemu_mallocz (sw->hw->samples * sizeof (st_sample_t));
116 if (!sw->buf)
117 return -1;
119 sw->rate = st_rate_start (sw->freq, sw->hw->freq);
120 if (!sw->rate) {
121 qemu_free (sw->buf);
122 sw->buf = NULL;
123 return -1;
124 }
125 return 0;
126 }
128 void pcm_sw_fini (SWVoice *sw)
129 {
130 pcm_sw_free_resources (sw);
131 }
133 int pcm_sw_init (SWVoice *sw, HWVoice *hw, int freq,
134 int nchannels, audfmt_e fmt)
135 {
136 int bits = 8, sign = 0;
138 switch (fmt) {
139 case AUD_FMT_S8:
140 sign = 1;
141 case AUD_FMT_U8:
142 break;
144 case AUD_FMT_S16:
145 sign = 1;
146 case AUD_FMT_U16:
147 bits = 16;
148 break;
149 }
151 sw->hw = hw;
152 sw->freq = freq;
153 sw->fmt = fmt;
154 sw->nchannels = nchannels;
155 sw->shift = (nchannels == 2) + (bits == 16);
156 sw->align = (1 << sw->shift) - 1;
157 sw->left = 0;
158 sw->pos = 0;
159 sw->wpos = 0;
160 sw->live = 0;
161 sw->ratio = (sw->hw->freq * ((int64_t) INT_MAX)) / sw->freq;
162 sw->bytes_per_second = sw->freq << sw->shift;
163 sw->conv = mixeng_conv[nchannels == 2][sign][bits == 16];
165 pcm_sw_free_resources (sw);
166 return pcm_sw_alloc_resources (sw);
167 }
169 /* Hard voice */
170 void pcm_hw_free_resources (HWVoice *hw)
171 {
172 if (hw->mix_buf)
173 qemu_free (hw->mix_buf);
174 hw->mix_buf = NULL;
175 }
177 int pcm_hw_alloc_resources (HWVoice *hw)
178 {
179 hw->mix_buf = qemu_mallocz (hw->samples * sizeof (st_sample_t));
180 if (!hw->mix_buf)
181 return -1;
182 return 0;
183 }
185 void pcm_hw_fini (HWVoice *hw)
186 {
187 if (hw->active) {
188 ldebug ("pcm_hw_fini: %d %d %d\n", hw->freq, hw->nchannels, hw->fmt);
189 pcm_hw_free_resources (hw);
190 hw->pcm_ops->fini (hw);
191 memset (hw, 0, audio_state.drv->voice_size);
192 }
193 }
195 void pcm_hw_gc (HWVoice *hw)
196 {
197 if (hw->nb_voices)
198 return;
200 pcm_hw_fini (hw);
201 }
203 int pcm_hw_get_live (HWVoice *hw)
204 {
205 int i, alive = 0, live = hw->samples;
207 for (i = 0; i < hw->nb_voices; i++) {
208 if (hw->pvoice[i]->live) {
209 live = audio_MIN (hw->pvoice[i]->live, live);
210 alive += 1;
211 }
212 }
214 if (alive)
215 return live;
216 else
217 return -1;
218 }
220 int pcm_hw_get_live2 (HWVoice *hw, int *nb_active)
221 {
222 int i, alive = 0, live = hw->samples;
224 *nb_active = 0;
225 for (i = 0; i < hw->nb_voices; i++) {
226 if (hw->pvoice[i]->live) {
227 if (hw->pvoice[i]->live < live) {
228 *nb_active = hw->pvoice[i]->active != 0;
229 live = hw->pvoice[i]->live;
230 }
231 alive += 1;
232 }
233 }
235 if (alive)
236 return live;
237 else
238 return -1;
239 }
241 void pcm_hw_dec_live (HWVoice *hw, int decr)
242 {
243 int i;
245 for (i = 0; i < hw->nb_voices; i++) {
246 if (hw->pvoice[i]->live) {
247 hw->pvoice[i]->live -= decr;
248 }
249 }
250 }
252 void pcm_hw_clear (HWVoice *hw, void *buf, int len)
253 {
254 if (!len)
255 return;
257 switch (hw->fmt) {
258 case AUD_FMT_S16:
259 case AUD_FMT_S8:
260 memset (buf, 0x00, len << hw->shift);
261 break;
263 case AUD_FMT_U8:
264 memset (buf, 0x80, len << hw->shift);
265 break;
267 case AUD_FMT_U16:
268 {
269 unsigned int i;
270 uint16_t *p = buf;
271 int shift = hw->nchannels - 1;
273 for (i = 0; i < len << shift; i++) {
274 p[i] = INT16_MAX;
275 }
276 }
277 break;
278 }
279 }
281 int pcm_hw_write (SWVoice *sw, void *buf, int size)
282 {
283 int hwsamples, samples, isamp, osamp, wpos, live, dead, left, swlim, blck;
284 int ret = 0, pos = 0;
285 if (!sw)
286 return size;
288 hwsamples = sw->hw->samples;
289 samples = size >> sw->shift;
291 if (!sw->live) {
292 sw->wpos = sw->hw->rpos;
293 }
294 wpos = sw->wpos;
295 live = sw->live;
296 dead = hwsamples - live;
297 swlim = (dead * ((int64_t) INT_MAX)) / sw->ratio;
298 swlim = audio_MIN (swlim, samples);
300 ldebug ("size=%d live=%d dead=%d swlim=%d wpos=%d\n",
301 size, live, dead, swlim, wpos);
302 if (swlim)
303 sw->conv (sw->buf, buf, swlim);
305 while (swlim) {
306 dead = hwsamples - live;
307 left = hwsamples - wpos;
308 blck = audio_MIN (dead, left);
309 if (!blck) {
310 /* dolog ("swlim=%d\n", swlim); */
311 break;
312 }
313 isamp = swlim;
314 osamp = blck;
315 st_rate_flow (sw->rate, sw->buf + pos, sw->hw->mix_buf + wpos, &isamp, &osamp);
316 ret += isamp;
317 swlim -= isamp;
318 pos += isamp;
319 live += osamp;
320 wpos = (wpos + osamp) % hwsamples;
321 }
323 sw->wpos = wpos;
324 sw->live = live;
325 return ret << sw->shift;
326 }
328 int pcm_hw_init (HWVoice *hw, int freq, int nchannels, audfmt_e fmt)
329 {
330 int sign = 0, bits = 8;
332 pcm_hw_fini (hw);
333 ldebug ("pcm_hw_init: %d %d %d\n", freq, nchannels, fmt);
334 if (hw->pcm_ops->init (hw, freq, nchannels, fmt)) {
335 memset (hw, 0, audio_state.drv->voice_size);
336 return -1;
337 }
339 switch (hw->fmt) {
340 case AUD_FMT_S8:
341 sign = 1;
342 case AUD_FMT_U8:
343 break;
345 case AUD_FMT_S16:
346 sign = 1;
347 case AUD_FMT_U16:
348 bits = 16;
349 break;
350 }
352 hw->nb_voices = 0;
353 hw->active = 1;
354 hw->shift = (hw->nchannels == 2) + (bits == 16);
355 hw->bytes_per_second = hw->freq << hw->shift;
356 hw->align = (1 << hw->shift) - 1;
357 hw->samples = hw->bufsize >> hw->shift;
358 hw->clip = mixeng_clip[hw->nchannels == 2][sign][bits == 16];
359 if (pcm_hw_alloc_resources (hw)) {
360 pcm_hw_fini (hw);
361 return -1;
362 }
363 return 0;
364 }
366 static int dist (void *hw)
367 {
368 if (hw) {
369 return (((uint8_t *) hw - (uint8_t *) hw_voices)
370 / audio_state.voice_size) + 1;
371 }
372 else {
373 return 0;
374 }
375 }
377 #define ADVANCE(hw) hw ? advance (hw, audio_state.voice_size) : hw_voices
379 HWVoice *pcm_hw_find_any (HWVoice *hw)
380 {
381 int i = dist (hw);
382 for (; i < audio_state.nb_hw_voices; i++) {
383 hw = ADVANCE (hw);
384 return hw;
385 }
386 return NULL;
387 }
389 HWVoice *pcm_hw_find_any_active (HWVoice *hw)
390 {
391 int i = dist (hw);
392 for (; i < audio_state.nb_hw_voices; i++) {
393 hw = ADVANCE (hw);
394 if (hw->active)
395 return hw;
396 }
397 return NULL;
398 }
400 HWVoice *pcm_hw_find_any_active_enabled (HWVoice *hw)
401 {
402 int i = dist (hw);
403 for (; i < audio_state.nb_hw_voices; i++) {
404 hw = ADVANCE (hw);
405 if (hw->active && hw->enabled)
406 return hw;
407 }
408 return NULL;
409 }
411 HWVoice *pcm_hw_find_any_passive (HWVoice *hw)
412 {
413 int i = dist (hw);
414 for (; i < audio_state.nb_hw_voices; i++) {
415 hw = ADVANCE (hw);
416 if (!hw->active)
417 return hw;
418 }
419 return NULL;
420 }
422 HWVoice *pcm_hw_find_specific (HWVoice *hw, int freq,
423 int nchannels, audfmt_e fmt)
424 {
425 while ((hw = pcm_hw_find_any_active (hw))) {
426 if (hw->freq == freq &&
427 hw->nchannels == nchannels &&
428 hw->fmt == fmt)
429 return hw;
430 }
431 return NULL;
432 }
434 HWVoice *pcm_hw_add (int freq, int nchannels, audfmt_e fmt)
435 {
436 HWVoice *hw;
438 if (audio_state.fixed_format) {
439 freq = audio_state.fixed_freq;
440 nchannels = audio_state.fixed_channels;
441 fmt = audio_state.fixed_fmt;
442 }
444 hw = pcm_hw_find_specific (NULL, freq, nchannels, fmt);
446 if (hw)
447 return hw;
449 hw = pcm_hw_find_any_passive (NULL);
450 if (hw) {
451 hw->pcm_ops = audio_state.drv->pcm_ops;
452 if (!hw->pcm_ops)
453 return NULL;
455 if (pcm_hw_init (hw, freq, nchannels, fmt)) {
456 pcm_hw_gc (hw);
457 return NULL;
458 }
459 else
460 return hw;
461 }
463 return pcm_hw_find_any (NULL);
464 }
466 int pcm_hw_add_sw (HWVoice *hw, SWVoice *sw)
467 {
468 SWVoice **pvoice = qemu_mallocz ((hw->nb_voices + 1) * sizeof (sw));
469 if (!pvoice)
470 return -1;
472 memcpy (pvoice, hw->pvoice, hw->nb_voices * sizeof (sw));
473 qemu_free (hw->pvoice);
474 hw->pvoice = pvoice;
475 hw->pvoice[hw->nb_voices++] = sw;
476 return 0;
477 }
479 int pcm_hw_del_sw (HWVoice *hw, SWVoice *sw)
480 {
481 int i, j;
482 if (hw->nb_voices > 1) {
483 SWVoice **pvoice = qemu_mallocz ((hw->nb_voices - 1) * sizeof (sw));
485 if (!pvoice) {
486 dolog ("Can not maintain consistent state (not enough memory)\n");
487 return -1;
488 }
490 for (i = 0, j = 0; i < hw->nb_voices; i++) {
491 if (j >= hw->nb_voices - 1) {
492 dolog ("Can not maintain consistent state "
493 "(invariant violated)\n");
494 return -1;
495 }
496 if (hw->pvoice[i] != sw)
497 pvoice[j++] = hw->pvoice[i];
498 }
499 qemu_free (hw->pvoice);
500 hw->pvoice = pvoice;
501 hw->nb_voices -= 1;
502 }
503 else {
504 qemu_free (hw->pvoice);
505 hw->pvoice = NULL;
506 hw->nb_voices = 0;
507 }
508 return 0;
509 }
511 SWVoice *pcm_create_voice_pair (int freq, int nchannels, audfmt_e fmt)
512 {
513 SWVoice *sw;
514 HWVoice *hw;
516 sw = qemu_mallocz (sizeof (*sw));
517 if (!sw)
518 goto err1;
520 hw = pcm_hw_add (freq, nchannels, fmt);
521 if (!hw)
522 goto err2;
524 if (pcm_hw_add_sw (hw, sw))
525 goto err3;
527 if (pcm_sw_init (sw, hw, freq, nchannels, fmt))
528 goto err4;
530 return sw;
532 err4:
533 pcm_hw_del_sw (hw, sw);
534 err3:
535 pcm_hw_gc (hw);
536 err2:
537 qemu_free (sw);
538 err1:
539 return NULL;
540 }
542 SWVoice *AUD_open (SWVoice *sw, const char *name,
543 int freq, int nchannels, audfmt_e fmt)
544 {
545 if (!audio_state.drv) {
546 return NULL;
547 }
549 if (sw && freq == sw->freq && sw->nchannels == nchannels && sw->fmt == fmt) {
550 return sw;
551 }
553 if (sw) {
554 ldebug ("Different format %s %d %d %d\n",
555 name,
556 sw->freq == freq,
557 sw->nchannels == nchannels,
558 sw->fmt == fmt);
559 }
561 if (nchannels != 1 && nchannels != 2) {
562 dolog ("Bogus channel count %d for voice %s\n", nchannels, name);
563 return NULL;
564 }
566 if (!audio_state.fixed_format && sw) {
567 pcm_sw_fini (sw);
568 pcm_hw_del_sw (sw->hw, sw);
569 pcm_hw_gc (sw->hw);
570 if (sw->name) {
571 qemu_free (sw->name);
572 sw->name = NULL;
573 }
574 qemu_free (sw);
575 sw = NULL;
576 }
578 if (sw) {
579 HWVoice *hw = sw->hw;
580 if (!hw) {
581 dolog ("Internal logic error voice %s has no hardware store\n",
582 name);
583 return sw;
584 }
586 if (pcm_sw_init (sw, hw, freq, nchannels, fmt)) {
587 pcm_sw_fini (sw);
588 pcm_hw_del_sw (hw, sw);
589 pcm_hw_gc (hw);
590 if (sw->name) {
591 qemu_free (sw->name);
592 sw->name = NULL;
593 }
594 qemu_free (sw);
595 return NULL;
596 }
597 }
598 else {
599 sw = pcm_create_voice_pair (freq, nchannels, fmt);
600 if (!sw) {
601 dolog ("Failed to create voice %s\n", name);
602 return NULL;
603 }
604 }
606 if (sw->name) {
607 qemu_free (sw->name);
608 sw->name = NULL;
609 }
610 sw->name = qemu_strdup (name);
611 return sw;
612 }
614 void AUD_close (SWVoice *sw)
615 {
616 if (!sw)
617 return;
619 pcm_sw_fini (sw);
620 pcm_hw_del_sw (sw->hw, sw);
621 pcm_hw_gc (sw->hw);
622 if (sw->name) {
623 qemu_free (sw->name);
624 sw->name = NULL;
625 }
626 qemu_free (sw);
627 }
629 int AUD_write (SWVoice *sw, void *buf, int size)
630 {
631 int bytes;
633 if (!sw->hw->enabled)
634 dolog ("Writing to disabled voice %s\n", sw->name);
635 bytes = sw->hw->pcm_ops->write (sw, buf, size);
636 return bytes;
637 }
639 void AUD_run (void)
640 {
641 HWVoice *hw = NULL;
643 while ((hw = pcm_hw_find_any_active_enabled (hw))) {
644 int i;
645 if (hw->pending_disable && pcm_hw_get_live (hw) <= 0) {
646 hw->enabled = 0;
647 hw->pcm_ops->ctl (hw, VOICE_DISABLE);
648 for (i = 0; i < hw->nb_voices; i++) {
649 hw->pvoice[i]->live = 0;
650 /* hw->pvoice[i]->old_ticks = 0; */
651 }
652 continue;
653 }
655 hw->pcm_ops->run (hw);
656 assert (hw->rpos < hw->samples);
657 for (i = 0; i < hw->nb_voices; i++) {
658 SWVoice *sw = hw->pvoice[i];
659 if (!sw->active && !sw->live && sw->old_ticks) {
660 int64_t delta = qemu_get_clock (vm_clock) - sw->old_ticks;
661 if (delta > audio_state.ticks_threshold) {
662 ldebug ("resetting old_ticks for %s\n", sw->name);
663 sw->old_ticks = 0;
664 }
665 }
666 }
667 }
668 }
670 int AUD_get_free (SWVoice *sw)
671 {
672 int free;
674 if (!sw)
675 return 4096;
677 free = ((sw->hw->samples - sw->live) << sw->hw->shift) * sw->ratio
678 / INT_MAX;
680 free &= ~sw->hw->align;
681 if (!free) return 0;
683 return free;
684 }
686 int AUD_get_buffer_size (SWVoice *sw)
687 {
688 return sw->hw->bufsize;
689 }
691 void AUD_adjust (SWVoice *sw, int bytes)
692 {
693 if (!sw)
694 return;
695 sw->old_ticks += (ticks_per_sec * (int64_t) bytes) / sw->bytes_per_second;
696 }
698 void AUD_reset (SWVoice *sw)
699 {
700 sw->active = 0;
701 sw->old_ticks = 0;
702 }
704 int AUD_calc_elapsed (SWVoice *sw)
705 {
706 int64_t now, delta, bytes;
707 int dead, swlim;
709 if (!sw)
710 return 0;
712 now = qemu_get_clock (vm_clock);
713 delta = now - sw->old_ticks;
714 bytes = (delta * sw->bytes_per_second) / ticks_per_sec;
715 if (delta < 0) {
716 dolog ("whoops delta(<0)=%"PRId64"\n", delta);
717 return 0;
718 }
720 dead = sw->hw->samples - sw->live;
721 swlim = ((dead * (int64_t) INT_MAX) / sw->ratio);
723 if (bytes > swlim) {
724 return swlim;
725 }
726 else {
727 return bytes;
728 }
729 }
731 void AUD_enable (SWVoice *sw, int on)
732 {
733 int i;
734 HWVoice *hw;
736 if (!sw)
737 return;
739 hw = sw->hw;
740 if (on) {
741 if (!sw->live)
742 sw->wpos = sw->hw->rpos;
743 if (!sw->old_ticks) {
744 sw->old_ticks = qemu_get_clock (vm_clock);
745 }
746 }
748 if (sw->active != on) {
749 if (on) {
750 hw->pending_disable = 0;
751 if (!hw->enabled) {
752 hw->enabled = 1;
753 for (i = 0; i < hw->nb_voices; i++) {
754 ldebug ("resetting voice\n");
755 sw = hw->pvoice[i];
756 sw->old_ticks = qemu_get_clock (vm_clock);
757 }
758 hw->pcm_ops->ctl (hw, VOICE_ENABLE);
759 }
760 }
761 else {
762 if (hw->enabled && !hw->pending_disable) {
763 int nb_active = 0;
764 for (i = 0; i < hw->nb_voices; i++) {
765 nb_active += hw->pvoice[i]->active != 0;
766 }
768 if (nb_active == 1) {
769 hw->pending_disable = 1;
770 }
771 }
772 }
773 sw->active = on;
774 }
775 }
777 static struct audio_output_driver *drvtab[] = {
778 #ifdef CONFIG_OSS
779 &oss_output_driver,
780 #endif
781 #ifdef CONFIG_FMOD
782 &fmod_output_driver,
783 #endif
784 #ifdef CONFIG_SDL
785 &sdl_output_driver,
786 #endif
787 &no_output_driver,
788 #ifdef USE_WAV_AUDIO
789 &wav_output_driver,
790 #endif
791 };
793 static int voice_init (struct audio_output_driver *drv)
794 {
795 audio_state.opaque = drv->init ();
796 if (audio_state.opaque) {
797 if (audio_state.nb_hw_voices > drv->max_voices) {
798 dolog ("`%s' does not support %d multiple hardware channels\n"
799 "Resetting to %d\n",
800 drv->name, audio_state.nb_hw_voices, drv->max_voices);
801 audio_state.nb_hw_voices = drv->max_voices;
802 }
803 hw_voices = qemu_mallocz (audio_state.nb_hw_voices * drv->voice_size);
804 if (hw_voices) {
805 audio_state.drv = drv;
806 return 1;
807 }
808 else {
809 dolog ("Not enough memory for %d `%s' voices (each %d bytes)\n",
810 audio_state.nb_hw_voices, drv->name, drv->voice_size);
811 drv->fini (audio_state.opaque);
812 return 0;
813 }
814 }
815 else {
816 dolog ("Could not init `%s' audio\n", drv->name);
817 return 0;
818 }
819 }
821 static void audio_vm_stop_handler (void *opaque, int reason)
822 {
823 HWVoice *hw = NULL;
825 while ((hw = pcm_hw_find_any (hw))) {
826 if (!hw->pcm_ops)
827 continue;
829 hw->pcm_ops->ctl (hw, reason ? VOICE_ENABLE : VOICE_DISABLE);
830 }
831 }
833 static void audio_atexit (void)
834 {
835 HWVoice *hw = NULL;
837 while ((hw = pcm_hw_find_any (hw))) {
838 if (!hw->pcm_ops)
839 continue;
841 hw->pcm_ops->ctl (hw, VOICE_DISABLE);
842 hw->pcm_ops->fini (hw);
843 }
844 audio_state.drv->fini (audio_state.opaque);
845 }
847 static void audio_save (QEMUFile *f, void *opaque)
848 {
849 }
851 static int audio_load (QEMUFile *f, void *opaque, int version_id)
852 {
853 if (version_id != 1)
854 return -EINVAL;
856 return 0;
857 }
859 void AUD_init (void)
860 {
861 int i;
862 int done = 0;
863 const char *drvname;
865 audio_state.fixed_format =
866 !!audio_get_conf_int (QC_FIXED_FORMAT, audio_state.fixed_format);
867 audio_state.fixed_freq =
868 audio_get_conf_int (QC_FIXED_FREQ, audio_state.fixed_freq);
869 audio_state.nb_hw_voices =
870 audio_get_conf_int (QC_VOICES, audio_state.nb_hw_voices);
872 if (audio_state.nb_hw_voices <= 0) {
873 dolog ("Bogus number of voices %d, resetting to 1\n",
874 audio_state.nb_hw_voices);
875 }
877 drvname = audio_get_conf_str (QC_AUDIO_DRV, NULL);
878 if (drvname) {
879 int found = 0;
880 for (i = 0; i < sizeof (drvtab) / sizeof (drvtab[0]); i++) {
881 if (!strcmp (drvname, drvtab[i]->name)) {
882 done = voice_init (drvtab[i]);
883 found = 1;
884 break;
885 }
886 }
887 if (!found) {
888 dolog ("Unknown audio driver `%s'\n", drvname);
889 }
890 }
892 qemu_add_vm_stop_handler (audio_vm_stop_handler, NULL);
893 atexit (audio_atexit);
895 if (!done) {
896 for (i = 0; !done && i < sizeof (drvtab) / sizeof (drvtab[0]); i++) {
897 if (drvtab[i]->can_be_default)
898 done = voice_init (drvtab[i]);
899 }
900 }
902 audio_state.ticks_threshold = ticks_per_sec / 50;
903 audio_state.freq_threshold = 100;
905 register_savevm ("audio", 0, 1, audio_save, audio_load, NULL);
906 if (!done) {
907 dolog ("Can not initialize audio subsystem\n");
908 voice_init (&no_output_driver);
909 }
910 }