VirtualBox

source: vbox/trunk/src/VBox/Devices/Audio/audio.c@ 11444

Last change on this file since 11444 was 11269, checked in by vboxsync, 16 years ago

Devices: pData -> pThis.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 51.2 KB
Line 
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#define LOG_GROUP LOG_GROUP_DEV_AUDIO
25#include <VBox/pdm.h>
26#include <VBox/err.h>
27#include <VBox/mm.h>
28
29#include <VBox/log.h>
30#include <iprt/assert.h>
31#include <iprt/uuid.h>
32#include <iprt/string.h>
33#include <iprt/alloc.h>
34
35#include "Builtins.h"
36#include "../../vl_vbox.h"
37
38#include <ctype.h>
39#include <stdlib.h>
40
41#define AUDIO_CAP "audio"
42#include "audio.h"
43#include "audio_int.h"
44
45#ifdef RT_OS_WINDOWS
46#define strcasecmp stricmp
47#endif
48
49/* #define DEBUG_PLIVE */
50/* #define DEBUG_LIVE */
51/* #define DEBUG_OUT */
52/* #define DEBUG_CAPTURE */
53
54#define SW_NAME(sw) (sw)->name ? (sw)->name : "unknown"
55
56typedef struct DRVAUDIO
57{
58 /** The audio interface. */
59 PDMIAUDIOCONNECTOR IAudioConnector;
60 /** Pointer to the driver instance. */
61 PPDMDRVINS pDrvIns;
62} DRVAUDIO, *PDRVAUDIO;
63
64static struct audio_driver *drvtab[] = {
65#ifdef RT_OS_LINUX
66 &oss_audio_driver,
67#ifdef VBOX_WITH_ALSA
68 &alsa_audio_driver,
69#endif
70#ifdef VBOX_WITH_PULSE
71 &pulse_audio_driver,
72#endif
73#endif
74#ifdef RT_OS_DARWIN
75 &coreaudio_audio_driver,
76#endif
77#ifdef RT_OS_WINDOWS
78 &dsound_audio_driver,
79#endif
80#ifdef RT_OS_L4
81 &oss_audio_driver,
82#endif
83#ifdef RT_OS_SOLARIS
84 &solaudio_audio_driver,
85#endif
86 &no_audio_driver
87};
88
89static char *audio_streamname;
90
91const char *audio_get_stream_name(void)
92{
93 return audio_streamname;
94}
95
96struct fixed_settings {
97 int enabled;
98 int nb_voices;
99 int greedy;
100 audsettings_t settings;
101};
102
103static struct {
104 struct fixed_settings fixed_out;
105 struct fixed_settings fixed_in;
106 union {
107 int hz;
108 int64_t ticks;
109 } period;
110 int plive;
111} conf = {
112 { /* DAC fixed settings */
113 1, /* enabled */
114 1, /* nb_voices */
115 1, /* greedy */
116 {
117 44100, /* freq */
118 2, /* nchannels */
119 AUD_FMT_S16 /* fmt */
120 }
121 },
122
123 { /* ADC fixed settings */
124 1, /* enabled */
125 1, /* nb_voices */
126 1, /* greedy */
127 {
128 44100, /* freq */
129 2, /* nchannels */
130 AUD_FMT_S16 /* fmt */
131 }
132 },
133
134 { 100 }, /* period */
135 0, /* plive */
136};
137
138static AudioState glob_audio_state;
139
140volume_t nominal_volume = {
141 0,
142#ifdef FLOAT_MIXENG
143 1.0,
144 1.0
145#else
146#ifndef VBOX
147 UINT_MAX,
148 UINT_MAX
149#else
150 INT_MAX,
151 INT_MAX
152#endif
153#endif
154};
155
156#ifdef VBOX
157volume_t sum_out_volume =
158{
159 0,
160 INT_MAX,
161 INT_MAX
162};
163volume_t master_out_volume =
164{
165 0,
166 INT_MAX,
167 INT_MAX
168};
169volume_t pcm_out_volume =
170{
171 0,
172 INT_MAX,
173 INT_MAX
174};
175volume_t pcm_in_volume =
176{
177 0,
178 INT_MAX,
179 INT_MAX
180};
181#endif
182
183/* http://www.df.lth.se/~john_e/gems/gem002d.html */
184/* http://www.multi-platforms.com/Tips/PopCount.htm */
185uint32_t popcount (uint32_t u)
186{
187 u = ((u&0x55555555) + ((u>>1)&0x55555555));
188 u = ((u&0x33333333) + ((u>>2)&0x33333333));
189 u = ((u&0x0f0f0f0f) + ((u>>4)&0x0f0f0f0f));
190 u = ((u&0x00ff00ff) + ((u>>8)&0x00ff00ff));
191 u = ( u&0x0000ffff) + (u>>16);
192 return u;
193}
194
195uint32_t lsbindex (uint32_t u)
196{
197 return popcount ((u&-u)-1);
198}
199
200uint64_t audio_get_clock (void)
201{
202 AudioState *s;
203
204 s = &glob_audio_state;
205 return s->pDrvIns->pDrvHlp->pfnTMGetVirtualTime (s->pDrvIns);
206}
207
208uint64_t audio_get_ticks_per_sec (void)
209{
210 AudioState *s;
211
212 s = &glob_audio_state;
213 return s->pDrvIns->pDrvHlp->pfnTMGetVirtualFreq (s->pDrvIns);
214}
215
216#ifdef AUDIO_IS_FLAWLESS_AND_NO_CHECKS_ARE_REQURIED
217#error No its not
218#else
219int audio_bug (const char *funcname, int cond)
220{
221 if (cond) {
222 static int shown;
223
224 AUD_log (NULL, "A bug was just triggered in %s\n", funcname);
225 if (!shown) {
226 shown = 1;
227 AUD_log (NULL, "Save all your work and restart without audio\n");
228 AUD_log (NULL, "Please send a bug, see www.virtualbox.org\n");
229 AUD_log (NULL, "I am sorry\n");
230 }
231 AUD_log (NULL, "Context:\n");
232
233#if defined AUDIO_BREAKPOINT_ON_BUG
234# if defined HOST_I386
235# if defined __GNUC__
236 __asm__ ("int3");
237# elif defined _MSC_VER
238 _asm _emit 0xcc;
239# else
240 abort ();
241# endif
242# else
243 abort ();
244# endif
245#endif
246 }
247
248 return cond;
249}
250#endif
251
252static inline int audio_bits_to_index (int bits)
253{
254 switch (bits) {
255 case 8:
256 return 0;
257
258 case 16:
259 return 1;
260
261 case 32:
262 return 2;
263
264 default:
265 audio_bug ("bits_to_index", 1);
266 AUD_log (NULL, "invalid bits %d\n", bits);
267 return 0;
268 }
269}
270
271void *audio_calloc (const char *funcname, int nmemb, size_t size)
272{
273 int cond;
274 size_t len;
275
276 len = nmemb * size;
277 cond = !nmemb || !size;
278 cond |= nmemb < 0;
279 cond |= len < size;
280
281 if (audio_bug ("audio_calloc", cond)) {
282 AUD_log (NULL, "%s passed invalid arguments to audio_calloc\n",
283 funcname);
284 AUD_log (NULL, "nmemb=%d size=%" FMTZ "u (len=%" FMTZ "u)\n",
285 nmemb, size, len);
286 return NULL;
287 }
288
289 return qemu_mallocz (len);
290}
291
292static const char *audio_audfmt_to_string (audfmt_e fmt)
293{
294 switch (fmt) {
295 case AUD_FMT_U8:
296 return "U8";
297
298 case AUD_FMT_U16:
299 return "U16";
300
301 case AUD_FMT_U32:
302 return "U32";
303
304 case AUD_FMT_S8:
305 return "S8";
306
307 case AUD_FMT_S16:
308 return "S16";
309
310 case AUD_FMT_S32:
311 return "S32";
312 }
313
314 dolog ("Bogus audfmt %d returning S16\n", fmt);
315 return "S16";
316}
317
318static audfmt_e audio_string_to_audfmt (const char *s, audfmt_e defval,
319 int *defaultp)
320{
321 if (!strcasecmp (s, "u8")) {
322 *defaultp = 0;
323 return AUD_FMT_U8;
324 }
325 else if (!strcasecmp (s, "u16")) {
326 *defaultp = 0;
327 return AUD_FMT_U16;
328 }
329 else if (!strcasecmp (s, "u32")) {
330 *defaultp = 0;
331 return AUD_FMT_U32;
332 }
333 else if (!strcasecmp (s, "s8")) {
334 *defaultp = 0;
335 return AUD_FMT_S8;
336 }
337 else if (!strcasecmp (s, "s16")) {
338 *defaultp = 0;
339 return AUD_FMT_S16;
340 }
341 else if (!strcasecmp (s, "s32")) {
342 *defaultp = 0;
343 return AUD_FMT_S32;
344 }
345 else {
346 dolog ("Bogus audio format `%s' using %s\n",
347 s, audio_audfmt_to_string (defval));
348 *defaultp = 1;
349 return defval;
350 }
351}
352
353static audfmt_e audio_get_conf_fmt (const char *envname,
354 audfmt_e defval,
355 int *defaultp)
356{
357 const char *var = getenv (envname);
358 if (!var) {
359 *defaultp = 1;
360 return defval;
361 }
362 return audio_string_to_audfmt (var, defval, defaultp);
363}
364
365static int audio_get_conf_int (const char *key, int defval, int *defaultp)
366{
367 int val;
368 char *strval;
369
370 strval = getenv (key);
371 if (strval) {
372 *defaultp = 0;
373 val = atoi (strval);
374 return val;
375 }
376 else {
377 *defaultp = 1;
378 return defval;
379 }
380}
381
382static const char *audio_get_conf_str (const char *key,
383 const char *defval,
384 int *defaultp)
385{
386 const char *val = getenv (key);
387 if (!val) {
388 *defaultp = 1;
389 return defval;
390 }
391 else {
392 *defaultp = 0;
393 return val;
394 }
395}
396
397void AUD_vlog (const char *cap, const char *fmt, va_list va)
398{
399 va_list va2;
400 va_copy (va2, va); /* Have to make a copy here or GCC will break. */
401 if (cap) {
402 Log (("%s: %N", cap, fmt, &va2));
403 }
404 else {
405 Log (("%N", fmt, &va2));
406 }
407 va_end (va2);
408}
409
410void AUD_log (const char *cap, const char *fmt, ...)
411{
412 va_list va;
413
414 va_start (va, fmt);
415 AUD_vlog (cap, fmt, va);
416 va_end (va);
417}
418
419static void audio_process_options (const char *prefix,
420 struct audio_option *opt)
421{
422 char *optname;
423 const char vbox_prefix[] = "VBOX_";
424 size_t preflen;
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 vbox_prefix
450 * (includes trailing zero) + zero + underscore (on behalf of
451 * sizeof) */
452 optname = qemu_malloc (len + preflen + sizeof (vbox_prefix) + 1);
453 if (!optname) {
454 dolog ("Could not allocate memory for option name `%s'\n",
455 opt->name);
456 continue;
457 }
458
459 strcpy (optname, vbox_prefix);
460
461 /* copy while upcasing, including trailing zero */
462 for (i = 0; i <= preflen; ++i) {
463 optname[i + sizeof (vbox_prefix) - 1] = toupper (prefix[i]);
464 }
465 strcat (optname, "_");
466 strcat (optname, opt->name);
467
468 def = 1;
469 switch (opt->tag) {
470 case AUD_OPT_BOOL:
471 case AUD_OPT_INT:
472 {
473 int *intp = opt->valp;
474 *intp = audio_get_conf_int (optname, *intp, &def);
475 }
476 break;
477
478 case AUD_OPT_FMT:
479 {
480 audfmt_e *fmtp = opt->valp;
481 *fmtp = audio_get_conf_fmt (optname, *fmtp, &def);
482 }
483 break;
484
485 case AUD_OPT_STR:
486 {
487 const char **strp = opt->valp;
488 *strp = audio_get_conf_str (optname, *strp, &def);
489 }
490 break;
491
492 default:
493 dolog ("Bad value tag for option `%s' - %d\n",
494 optname, opt->tag);
495 break;
496 }
497
498 if (!opt->overridenp) {
499 opt->overridenp = &opt->overriden;
500 }
501 *opt->overridenp = !def;
502 qemu_free (optname);
503 }
504}
505
506static void audio_print_settings (audsettings_t *as)
507{
508 dolog ("frequency=%d nchannels=%d fmt=", as->freq, as->nchannels);
509
510 switch (as->fmt) {
511 case AUD_FMT_S8:
512 AUD_log (NULL, "S8");
513 break;
514 case AUD_FMT_U8:
515 AUD_log (NULL, "U8");
516 break;
517 case AUD_FMT_S16:
518 AUD_log (NULL, "S16");
519 break;
520 case AUD_FMT_U16:
521 AUD_log (NULL, "U16");
522 break;
523 case AUD_FMT_S32:
524 AUD_log (NULL, "S32");
525 break;
526 case AUD_FMT_U32:
527 AUD_log (NULL, "U32");
528 break;
529 default:
530 AUD_log (NULL, "invalid(%d)", as->fmt);
531 break;
532 }
533
534 AUD_log (NULL, " endianness=");
535 switch (as->endianness) {
536 case 0:
537 AUD_log (NULL, "little");
538 break;
539 case 1:
540 AUD_log (NULL, "big");
541 break;
542 default:
543 AUD_log (NULL, "invalid");
544 break;
545 }
546 AUD_log (NULL, "\n");
547}
548
549static int audio_validate_settings (audsettings_t *as)
550{
551 int invalid;
552
553 invalid = as->nchannels != 1 && as->nchannels != 2;
554 invalid |= as->endianness != 0 && as->endianness != 1;
555
556 switch (as->fmt) {
557 case AUD_FMT_S8:
558 case AUD_FMT_U8:
559 case AUD_FMT_S16:
560 case AUD_FMT_U16:
561 case AUD_FMT_S32:
562 case AUD_FMT_U32:
563 break;
564 default:
565 invalid = 1;
566 break;
567 }
568
569 invalid |= as->freq <= 0;
570 return invalid ? -1 : 0;
571}
572
573static int audio_pcm_info_eq (struct audio_pcm_info *info, audsettings_t *as)
574{
575 int bits = 8, sign = 0;
576
577 switch (as->fmt) {
578 case AUD_FMT_S8:
579 sign = 1;
580 case AUD_FMT_U8:
581 break;
582
583 case AUD_FMT_S16:
584 sign = 1;
585 case AUD_FMT_U16:
586 bits = 16;
587 break;
588
589 case AUD_FMT_S32:
590 sign = 1;
591 case AUD_FMT_U32:
592 bits = 32;
593 break;
594 }
595 return info->freq == as->freq
596 && info->nchannels == as->nchannels
597 && info->sign == sign
598 && info->bits == bits
599 && info->swap_endianness == (as->endianness != AUDIO_HOST_ENDIANNESS);
600}
601
602void audio_pcm_init_info (struct audio_pcm_info *info, audsettings_t *as)
603{
604 int bits = 8, sign = 0, shift = 0;
605
606 switch (as->fmt) {
607 case AUD_FMT_S8:
608 sign = 1;
609 case AUD_FMT_U8:
610 break;
611
612 case AUD_FMT_S16:
613 sign = 1;
614 case AUD_FMT_U16:
615 bits = 16;
616 shift = 1;
617 break;
618
619 case AUD_FMT_S32:
620 sign = 1;
621 case AUD_FMT_U32:
622 bits = 32;
623 shift = 2;
624 break;
625 }
626
627 info->freq = as->freq;
628 info->bits = bits;
629 info->sign = sign;
630 info->nchannels = as->nchannels;
631 info->shift = (as->nchannels == 2) + shift;
632 info->align = (1 << info->shift) - 1;
633 info->bytes_per_second = info->freq << info->shift;
634 info->swap_endianness = (as->endianness != AUDIO_HOST_ENDIANNESS);
635}
636
637void audio_pcm_info_clear_buf (struct audio_pcm_info *info, void *buf, int len)
638{
639 if (!len) {
640 return;
641 }
642
643 if (info->sign) {
644 memset (buf, 0x00, len << info->shift);
645 }
646 else {
647 switch (info->bits) {
648 case 8:
649 memset (buf, 0x80, len << info->shift);
650 break;
651
652 case 16:
653 {
654 int i;
655 uint16_t *p = buf;
656 int shift = info->nchannels - 1;
657 short s = INT16_MAX;
658
659 if (info->swap_endianness) {
660 s = bswap16 (s);
661 }
662
663 for (i = 0; i < len << shift; i++) {
664 p[i] = s;
665 }
666 }
667 break;
668
669 case 32:
670 {
671 int i;
672 uint32_t *p = buf;
673 int shift = info->nchannels - 1;
674 int32_t s = INT32_MAX;
675
676 if (info->swap_endianness) {
677 s = bswap32 (s);
678 }
679
680 for (i = 0; i < len << shift; i++) {
681 p[i] = s;
682 }
683 }
684 break;
685
686 default:
687 AUD_log (NULL, "audio_pcm_info_clear_buf: invalid bits %d\n",
688 info->bits);
689 break;
690 }
691 }
692}
693
694/*
695 * Capture
696 */
697static void noop_conv (st_sample_t *dst, const void *src,
698 int samples, volume_t *vol)
699{
700 (void) src;
701 (void) dst;
702 (void) samples;
703 (void) vol;
704}
705
706static CaptureVoiceOut *audio_pcm_capture_find_specific (
707 AudioState *s,
708 audsettings_t *as
709 )
710{
711 CaptureVoiceOut *cap;
712
713 for (cap = s->cap_head.lh_first; cap; cap = cap->entries.le_next) {
714 if (audio_pcm_info_eq (&cap->hw.info, as)) {
715 return cap;
716 }
717 }
718 return NULL;
719}
720
721static void audio_notify_capture (CaptureVoiceOut *cap, audcnotification_e cmd)
722{
723 struct capture_callback *cb;
724
725#ifdef DEBUG_CAPTURE
726 dolog ("notification %d sent\n", cmd);
727#endif
728 for (cb = cap->cb_head.lh_first; cb; cb = cb->entries.le_next) {
729 cb->ops.notify (cb->opaque, cmd);
730 }
731}
732
733static void audio_capture_maybe_changed (CaptureVoiceOut *cap, int enabled)
734{
735 if (cap->hw.enabled != enabled) {
736 audcnotification_e cmd;
737 cap->hw.enabled = enabled;
738 cmd = enabled ? AUD_CNOTIFY_ENABLE : AUD_CNOTIFY_DISABLE;
739 audio_notify_capture (cap, cmd);
740 }
741}
742
743static void audio_recalc_and_notify_capture (CaptureVoiceOut *cap)
744{
745 HWVoiceOut *hw = &cap->hw;
746 SWVoiceOut *sw;
747 int enabled = 0;
748
749 for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) {
750 if (sw->active) {
751 enabled = 1;
752 break;
753 }
754 }
755 audio_capture_maybe_changed (cap, enabled);
756}
757
758static void audio_detach_capture (HWVoiceOut *hw)
759{
760 SWVoiceCap *sc = hw->cap_head.lh_first;
761
762 while (sc) {
763 SWVoiceCap *sc1 = sc->entries.le_next;
764 SWVoiceOut *sw = &sc->sw;
765 CaptureVoiceOut *cap = sc->cap;
766 int was_active = sw->active;
767
768 if (sw->rate) {
769 st_rate_stop (sw->rate);
770 sw->rate = NULL;
771 }
772
773 LIST_REMOVE (sw, entries);
774 LIST_REMOVE (sc, entries);
775 qemu_free (sc);
776 if (was_active) {
777 /* We have removed soft voice from the capture:
778 this might have changed the overall status of the capture
779 since this might have been the only active voice */
780 audio_recalc_and_notify_capture (cap);
781 }
782 sc = sc1;
783 }
784}
785
786static int audio_attach_capture (AudioState *s, HWVoiceOut *hw)
787{
788 CaptureVoiceOut *cap;
789
790 audio_detach_capture (hw);
791 for (cap = s->cap_head.lh_first; cap; cap = cap->entries.le_next) {
792 SWVoiceCap *sc;
793 SWVoiceOut *sw;
794 HWVoiceOut *hw_cap = &cap->hw;
795
796 sc = audio_calloc (AUDIO_FUNC, 1, sizeof (*sc));
797 if (!sc) {
798 dolog ("Could not allocate soft capture voice (%u bytes)\n",
799 sizeof (*sc));
800 return -1;
801 }
802
803 sc->cap = cap;
804 sw = &sc->sw;
805 sw->hw = hw_cap;
806 sw->info = hw->info;
807 sw->empty = 1;
808 sw->active = hw->enabled;
809 sw->conv = noop_conv;
810 sw->ratio = ((int64_t) hw_cap->info.freq << 32) / sw->info.freq;
811 sw->rate = st_rate_start (sw->info.freq, hw_cap->info.freq);
812 if (!sw->rate) {
813 dolog ("Could not start rate conversion for `%s'\n", SW_NAME (sw));
814 qemu_free (sw);
815 return -1;
816 }
817 LIST_INSERT_HEAD (&hw_cap->sw_head, sw, entries);
818 LIST_INSERT_HEAD (&hw->cap_head, sc, entries);
819#ifdef DEBUG_CAPTURE
820 asprintf (&sw->name, "for %p %d,%d,%d",
821 hw, sw->info.freq, sw->info.bits, 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 */
834static 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
847int 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/*
858 * Soft voice (capture)
859 */
860static int audio_pcm_sw_get_rpos_in (SWVoiceIn *sw)
861{
862 HWVoiceIn *hw = sw->hw;
863 int live = hw->total_samples_captured - sw->total_hw_samples_acquired;
864 int rpos;
865
866 if (audio_bug (AUDIO_FUNC, live < 0 || live > hw->samples)) {
867 dolog ("live=%d hw->samples=%d\n", live, hw->samples);
868 return 0;
869 }
870
871 rpos = hw->wpos - live;
872 if (rpos >= 0) {
873 return rpos;
874 }
875 else {
876 return hw->samples + rpos;
877 }
878}
879
880int audio_pcm_sw_read (SWVoiceIn *sw, void *buf, int size)
881{
882 HWVoiceIn *hw = sw->hw;
883 int samples, live, ret = 0, swlim, isamp, osamp, rpos, total = 0;
884 st_sample_t *src, *dst = sw->buf;
885
886 rpos = audio_pcm_sw_get_rpos_in (sw) % hw->samples;
887
888 live = hw->total_samples_captured - sw->total_hw_samples_acquired;
889 if (audio_bug (AUDIO_FUNC, live < 0 || live > hw->samples)) {
890 dolog ("live_in=%d hw->samples=%d\n", live, hw->samples);
891 return 0;
892 }
893
894 samples = size >> sw->info.shift;
895 if (!live) {
896 return 0;
897 }
898
899 swlim = (live * sw->ratio) >> 32;
900 swlim = audio_MIN (swlim, samples);
901
902 while (swlim) {
903 src = hw->conv_buf + rpos;
904 isamp = hw->wpos - rpos;
905 /* XXX: <= ? */
906 if (isamp <= 0) {
907 isamp = hw->samples - rpos;
908 }
909
910 if (!isamp) {
911 break;
912 }
913 osamp = swlim;
914
915 if (audio_bug (AUDIO_FUNC, osamp < 0)) {
916 dolog ("osamp=%d\n", osamp);
917 return 0;
918 }
919
920 st_rate_flow (sw->rate, src, dst, &isamp, &osamp);
921 swlim -= osamp;
922 rpos = (rpos + isamp) % hw->samples;
923 dst += osamp;
924 ret += osamp;
925 total += isamp;
926 }
927
928 sw->clip (buf, sw->buf, ret);
929 sw->total_hw_samples_acquired += total;
930 return ret << sw->info.shift;
931}
932
933/*
934 * Hard voice (playback)
935 */
936static int audio_pcm_hw_find_min_out (HWVoiceOut *hw, int *nb_livep)
937{
938 SWVoiceOut *sw;
939 int m = INT_MAX;
940 int nb_live = 0;
941
942 for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) {
943 if (sw->active || !sw->empty) {
944 m = audio_MIN (m, sw->total_hw_samples_mixed);
945 nb_live += 1;
946 }
947 }
948
949 *nb_livep = nb_live;
950 return m;
951}
952
953int audio_pcm_hw_get_live_out2 (HWVoiceOut *hw, int *nb_live)
954{
955 int smin;
956
957 smin = audio_pcm_hw_find_min_out (hw, nb_live);
958
959 if (!*nb_live) {
960 return 0;
961 }
962 else {
963 int live = smin;
964
965 if (audio_bug (AUDIO_FUNC, live < 0 || live > hw->samples)) {
966 dolog ("live=%d hw->samples=%d\n", live, hw->samples);
967 return 0;
968 }
969 return live;
970 }
971}
972
973int audio_pcm_hw_get_live_out (HWVoiceOut *hw)
974{
975 int nb_live;
976 int live;
977
978 live = audio_pcm_hw_get_live_out2 (hw, &nb_live);
979 if (audio_bug (AUDIO_FUNC, live < 0 || live > hw->samples)) {
980 dolog ("live=%d hw->samples=%d\n", live, hw->samples);
981 return 0;
982 }
983 return live;
984}
985
986/*
987 * Soft voice (playback)
988 */
989int audio_pcm_sw_write (SWVoiceOut *sw, void *buf, int size)
990{
991 int hwsamples, samples, isamp, osamp, wpos, live, dead, left, swlim, blck;
992 int ret = 0, pos = 0, total = 0;
993
994 if (!sw) {
995 return size;
996 }
997
998 hwsamples = sw->hw->samples;
999
1000 live = sw->total_hw_samples_mixed;
1001 if (audio_bug (AUDIO_FUNC, live < 0 || live > hwsamples)){
1002 dolog ("live=%d hw->samples=%d\n", live, hwsamples);
1003 return 0;
1004 }
1005
1006 if (live == hwsamples) {
1007#ifdef DEBUG_OUT
1008 dolog ("%s is full %d\n", sw->name, live);
1009#endif
1010 return 0;
1011 }
1012
1013 wpos = (sw->hw->rpos + live) % hwsamples;
1014 samples = size >> sw->info.shift;
1015
1016 dead = hwsamples - live;
1017 swlim = ((int64_t) dead << 32) / sw->ratio;
1018 swlim = audio_MIN (swlim, samples);
1019 if (swlim) {
1020#ifndef VBOX
1021 sw->conv (sw->buf, buf, swlim, &sw->vol);
1022#else
1023 sw->conv (sw->buf, buf, swlim, &sum_out_volume);
1024#endif
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 /* XXX: Consider options */
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 /* XXX: Consider options */
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 SWVoiceOut *temp_sw;
1132 SWVoiceCap *sc;
1133
1134 if (on) {
1135 hw->pending_disable = 0;
1136 if (!hw->enabled) {
1137 hw->enabled = 1;
1138 hw->pcm_ops->ctl_out (hw, VOICE_ENABLE);
1139 }
1140 }
1141 else {
1142 if (hw->enabled) {
1143 int nb_active = 0;
1144
1145 for (temp_sw = hw->sw_head.lh_first; temp_sw;
1146 temp_sw = temp_sw->entries.le_next) {
1147 nb_active += temp_sw->active != 0;
1148 }
1149
1150 hw->pending_disable = nb_active == 1;
1151 }
1152 }
1153
1154 for (sc = hw->cap_head.lh_first; sc; sc = sc->entries.le_next) {
1155 sc->sw.active = hw->enabled;
1156 if (hw->enabled) {
1157 audio_capture_maybe_changed (sc->cap, 1);
1158 }
1159 }
1160 sw->active = on;
1161 }
1162}
1163
1164void AUD_set_active_in (SWVoiceIn *sw, int on)
1165{
1166 HWVoiceIn *hw;
1167
1168 if (!sw) {
1169 return;
1170 }
1171
1172 hw = sw->hw;
1173 if (sw->active != on) {
1174 SWVoiceIn *temp_sw;
1175
1176 if (on) {
1177 if (!hw->enabled) {
1178 hw->enabled = 1;
1179 hw->pcm_ops->ctl_in (hw, VOICE_ENABLE);
1180 }
1181 sw->total_hw_samples_acquired = hw->total_samples_captured;
1182 }
1183 else {
1184 if (hw->enabled) {
1185 int nb_active = 0;
1186
1187 for (temp_sw = hw->sw_head.lh_first; temp_sw;
1188 temp_sw = temp_sw->entries.le_next) {
1189 nb_active += temp_sw->active != 0;
1190 }
1191
1192 if (nb_active == 1) {
1193 hw->enabled = 0;
1194 hw->pcm_ops->ctl_in (hw, VOICE_DISABLE);
1195 }
1196 }
1197 }
1198 sw->active = on;
1199 }
1200}
1201
1202static int audio_get_avail (SWVoiceIn *sw)
1203{
1204 int live;
1205
1206 if (!sw) {
1207 return 0;
1208 }
1209
1210 live = sw->hw->total_samples_captured - sw->total_hw_samples_acquired;
1211 if (audio_bug (AUDIO_FUNC, live < 0 || live > sw->hw->samples)) {
1212 dolog ("live=%d sw->hw->samples=%d\n", live, sw->hw->samples);
1213 return 0;
1214 }
1215
1216 ldebug (
1217 "%s: get_avail live %d ret %lld\n",
1218 SW_NAME (sw),
1219 live, (((int64_t) live << 32) / sw->ratio) << sw->info.shift
1220 );
1221
1222 return (((int64_t) live << 32) / sw->ratio) << sw->info.shift;
1223}
1224
1225static int audio_get_free (SWVoiceOut *sw)
1226{
1227 int live, dead;
1228
1229 if (!sw) {
1230 return 0;
1231 }
1232
1233 live = sw->total_hw_samples_mixed;
1234
1235 if (audio_bug (AUDIO_FUNC, live < 0 || live > sw->hw->samples)) {
1236 dolog ("live=%d sw->hw->samples=%d\n", live, sw->hw->samples);
1237 return 0;
1238 }
1239
1240 dead = sw->hw->samples - live;
1241
1242#ifdef DEBUG_OUT
1243 dolog ("%s: get_free live %d dead %d ret %lld\n",
1244 SW_NAME (sw),
1245 live, dead, (((int64_t) dead << 32) / sw->ratio) << sw->info.shift);
1246#endif
1247
1248 return (((int64_t) dead << 32) / sw->ratio) << sw->info.shift;
1249}
1250
1251static void audio_capture_mix_and_clear (HWVoiceOut *hw, int rpos, int samples)
1252{
1253 int n;
1254
1255 if (hw->enabled) {
1256 SWVoiceCap *sc;
1257
1258 for (sc = hw->cap_head.lh_first; sc; sc = sc->entries.le_next) {
1259 SWVoiceOut *sw = &sc->sw;
1260 int rpos2 = rpos;
1261
1262 n = samples;
1263 while (n) {
1264 int till_end_of_hw = hw->samples - rpos2;
1265 int to_write = audio_MIN (till_end_of_hw, n);
1266 int bytes = to_write << hw->info.shift;
1267 int written;
1268
1269 sw->buf = hw->mix_buf + rpos2;
1270 written = audio_pcm_sw_write (sw, NULL, bytes);
1271 if (written - bytes) {
1272 dolog ("Could not mix %d bytes into a capture "
1273 "buffer, mixed %d\n",
1274 bytes, written);
1275 break;
1276 }
1277 n -= to_write;
1278 rpos2 = (rpos2 + to_write) % hw->samples;
1279 }
1280 }
1281 }
1282
1283 n = audio_MIN (samples, hw->samples - rpos);
1284 mixeng_sniff_and_clear (hw, hw->mix_buf + rpos, n);
1285 mixeng_sniff_and_clear (hw, hw->mix_buf, samples - n);
1286}
1287
1288static void audio_run_out (AudioState *s)
1289{
1290 HWVoiceOut *hw = NULL;
1291 SWVoiceOut *sw;
1292
1293 while ((hw = audio_pcm_hw_find_any_enabled_out (s, hw))) {
1294 int played;
1295 int live, free, nb_live, cleanup_required, prev_rpos;
1296
1297 live = audio_pcm_hw_get_live_out2 (hw, &nb_live);
1298 if (!nb_live) {
1299 live = 0;
1300 }
1301
1302 if (audio_bug (AUDIO_FUNC, live < 0 || live > hw->samples)) {
1303 dolog ("live=%d hw->samples=%d\n", live, hw->samples);
1304 continue;
1305 }
1306
1307 if (hw->pending_disable && !nb_live) {
1308 SWVoiceCap *sc;
1309#ifdef DEBUG_OUT
1310 dolog ("Disabling voice\n");
1311#endif
1312 hw->enabled = 0;
1313 hw->pending_disable = 0;
1314 hw->pcm_ops->ctl_out (hw, VOICE_DISABLE);
1315 for (sc = hw->cap_head.lh_first; sc; sc = sc->entries.le_next) {
1316 sc->sw.active = 0;
1317 audio_recalc_and_notify_capture (sc->cap);
1318 }
1319 continue;
1320 }
1321
1322 if (!live) {
1323 for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) {
1324 if (sw->active) {
1325 free = audio_get_free (sw);
1326 if (free > 0) {
1327 sw->callback.fn (sw->callback.opaque, free);
1328 }
1329 }
1330 }
1331 continue;
1332 }
1333
1334 prev_rpos = hw->rpos;
1335 played = hw->pcm_ops->run_out (hw);
1336 if (audio_bug (AUDIO_FUNC, hw->rpos >= hw->samples)) {
1337 dolog ("hw->rpos=%d hw->samples=%d played=%d\n",
1338 hw->rpos, hw->samples, played);
1339 hw->rpos = 0;
1340 }
1341
1342#ifdef DEBUG_OUT
1343 dolog ("played=%d\n", played);
1344#endif
1345
1346 if (played) {
1347 hw->ts_helper += played;
1348 audio_capture_mix_and_clear (hw, prev_rpos, played);
1349 }
1350
1351 cleanup_required = 0;
1352 for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) {
1353 if (!sw->active && sw->empty) {
1354 continue;
1355 }
1356
1357 if (audio_bug (AUDIO_FUNC, played > sw->total_hw_samples_mixed)) {
1358 dolog ("played=%d sw->total_hw_samples_mixed=%d\n",
1359 played, sw->total_hw_samples_mixed);
1360 played = sw->total_hw_samples_mixed;
1361 }
1362
1363 sw->total_hw_samples_mixed -= played;
1364
1365 if (!sw->total_hw_samples_mixed) {
1366 sw->empty = 1;
1367 cleanup_required |= !sw->active && !sw->callback.fn;
1368 }
1369
1370 if (sw->active) {
1371 free = audio_get_free (sw);
1372 if (free > 0) {
1373 sw->callback.fn (sw->callback.opaque, free);
1374 }
1375 }
1376 }
1377
1378 if (cleanup_required) {
1379 SWVoiceOut *sw1;
1380
1381 sw = hw->sw_head.lh_first;
1382 while (sw) {
1383 sw1 = sw->entries.le_next;
1384 if (!sw->active && !sw->callback.fn) {
1385#ifdef DEBUG_PLIVE
1386 dolog ("Finishing with old voice\n");
1387#endif
1388 audio_close_out (s, sw);
1389 }
1390 sw = sw1;
1391 }
1392 }
1393 }
1394}
1395
1396static void audio_run_in (AudioState *s)
1397{
1398 HWVoiceIn *hw = NULL;
1399
1400 while ((hw = audio_pcm_hw_find_any_enabled_in (s, hw))) {
1401 SWVoiceIn *sw;
1402 int captured, min;
1403
1404 captured = hw->pcm_ops->run_in (hw);
1405
1406 min = audio_pcm_hw_find_min_in (hw);
1407 hw->total_samples_captured += captured - min;
1408 hw->ts_helper += captured;
1409
1410 for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) {
1411 sw->total_hw_samples_acquired -= min;
1412
1413 if (sw->active) {
1414 int avail;
1415
1416 avail = audio_get_avail (sw);
1417 if (avail > 0) {
1418 sw->callback.fn (sw->callback.opaque, avail);
1419 }
1420 }
1421 }
1422 }
1423}
1424
1425static void audio_run_capture (AudioState *s)
1426{
1427 CaptureVoiceOut *cap;
1428
1429 for (cap = s->cap_head.lh_first; cap; cap = cap->entries.le_next) {
1430 int live, rpos, captured;
1431 HWVoiceOut *hw = &cap->hw;
1432 SWVoiceOut *sw;
1433
1434 captured = live = audio_pcm_hw_get_live_out (hw);
1435 rpos = hw->rpos;
1436 while (live) {
1437 int left = hw->samples - rpos;
1438 int to_capture = audio_MIN (live, left);
1439 st_sample_t *src;
1440 struct capture_callback *cb;
1441
1442 src = hw->mix_buf + rpos;
1443 hw->clip (cap->buf, src, to_capture);
1444 mixeng_sniff_and_clear (hw, src, to_capture);
1445
1446 for (cb = cap->cb_head.lh_first; cb; cb = cb->entries.le_next) {
1447 cb->ops.capture (cb->opaque, cap->buf,
1448 to_capture << hw->info.shift);
1449 }
1450 rpos = (rpos + to_capture) % hw->samples;
1451 live -= to_capture;
1452 }
1453 hw->rpos = rpos;
1454
1455 for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) {
1456 if (!sw->active && sw->empty) {
1457 continue;
1458 }
1459
1460 if (audio_bug (AUDIO_FUNC, captured > sw->total_hw_samples_mixed)) {
1461 dolog ("captured=%d sw->total_hw_samples_mixed=%d\n",
1462 captured, sw->total_hw_samples_mixed);
1463 captured = sw->total_hw_samples_mixed;
1464 }
1465
1466 sw->total_hw_samples_mixed -= captured;
1467 sw->empty = sw->total_hw_samples_mixed == 0;
1468 }
1469 }
1470}
1471
1472static void audio_timer (void *opaque)
1473{
1474 AudioState *s = opaque;
1475
1476 audio_run_out (s);
1477 audio_run_in (s);
1478 audio_run_capture (s);
1479
1480 TMTimerSet (s->ts, TMTimerGet (s->ts) + conf.period.ticks);
1481}
1482
1483static struct audio_option audio_options[] = {
1484 /* DAC */
1485 {"DAC_FIXED_SETTINGS", AUD_OPT_BOOL, &conf.fixed_out.enabled,
1486 "Use fixed settings for host DAC", NULL, 0},
1487
1488 {"DAC_FIXED_FREQ", AUD_OPT_INT, &conf.fixed_out.settings.freq,
1489 "Frequency for fixed host DAC", NULL, 0},
1490
1491 {"DAC_FIXED_FMT", AUD_OPT_FMT, &conf.fixed_out.settings.fmt,
1492 "Format for fixed host DAC", NULL, 0},
1493
1494 {"DAC_FIXED_CHANNELS", AUD_OPT_INT, &conf.fixed_out.settings.nchannels,
1495 "Number of channels for fixed DAC (1 - mono, 2 - stereo)", NULL, 0},
1496
1497 {"DAC_VOICES", AUD_OPT_INT, &conf.fixed_out.nb_voices,
1498 "Number of voices for DAC", NULL, 0},
1499
1500 /* ADC */
1501 {"ADC_FIXED_SETTINGS", AUD_OPT_BOOL, &conf.fixed_in.enabled,
1502 "Use fixed settings for host ADC", NULL, 0},
1503
1504 {"ADC_FIXED_FREQ", AUD_OPT_INT, &conf.fixed_in.settings.freq,
1505 "Frequency for fixed host ADC", NULL, 0},
1506
1507 {"ADC_FIXED_FMT", AUD_OPT_FMT, &conf.fixed_in.settings.fmt,
1508 "Format for fixed host ADC", NULL, 0},
1509
1510 {"ADC_FIXED_CHANNELS", AUD_OPT_INT, &conf.fixed_in.settings.nchannels,
1511 "Number of channels for fixed ADC (1 - mono, 2 - stereo)", NULL, 0},
1512
1513 {"ADC_VOICES", AUD_OPT_INT, &conf.fixed_in.nb_voices,
1514 "Number of voices for ADC", NULL, 0},
1515
1516 /* Misc */
1517 {"TIMER_PERIOD", AUD_OPT_INT, &conf.period.hz,
1518 "Timer period in HZ (0 - use lowest possible)", NULL, 0},
1519
1520 {"PLIVE", AUD_OPT_BOOL, &conf.plive,
1521 "(undocumented)", NULL, 0},
1522
1523 {NULL, 0, NULL, NULL, NULL, 0}
1524};
1525
1526static int audio_driver_init (AudioState *s, struct audio_driver *drv)
1527{
1528 if (drv->options) {
1529 audio_process_options (drv->name, drv->options);
1530 }
1531 s->drv_opaque = drv->init ();
1532
1533 if (s->drv_opaque) {
1534 audio_init_nb_voices_out (s, drv);
1535 audio_init_nb_voices_in (s, drv);
1536 s->drv = drv;
1537 return 0;
1538 }
1539 else {
1540 dolog ("Could not init `%s' audio driver\n", drv->name);
1541 return -1;
1542 }
1543}
1544
1545static void audio_vm_change_state_handler (void *opaque, int running)
1546{
1547 AudioState *s = opaque;
1548 HWVoiceOut *hwo = NULL;
1549 HWVoiceIn *hwi = NULL;
1550 int op = running ? VOICE_ENABLE : VOICE_DISABLE;
1551
1552 while ((hwo = audio_pcm_hw_find_any_enabled_out (s, hwo))) {
1553 hwo->pcm_ops->ctl_out (hwo, op);
1554 }
1555
1556 while ((hwi = audio_pcm_hw_find_any_enabled_in (s, hwi))) {
1557 hwi->pcm_ops->ctl_in (hwi, op);
1558 }
1559}
1560
1561static void audio_atexit (void)
1562{
1563 AudioState *s = &glob_audio_state;
1564 HWVoiceOut *hwo = NULL;
1565 HWVoiceIn *hwi = NULL;
1566
1567 /* VBox change: audio_pcm_hw_find_any_enabled_out => audio_pcm_hw_find_any_out */
1568 while ((hwo = audio_pcm_hw_find_any_out (s, hwo))) {
1569 SWVoiceCap *sc;
1570
1571 hwo->pcm_ops->ctl_out (hwo, VOICE_DISABLE);
1572 hwo->pcm_ops->fini_out (hwo);
1573
1574 for (sc = hwo->cap_head.lh_first; sc; sc = sc->entries.le_next) {
1575 CaptureVoiceOut *cap = sc->cap;
1576 struct capture_callback *cb;
1577
1578 for (cb = cap->cb_head.lh_first; cb; cb = cb->entries.le_next) {
1579 cb->ops.destroy (cb->opaque);
1580 }
1581 }
1582 }
1583
1584 /* VBox change: audio_pcm_hw_find_any_enabled_in => audio_pcm_hw_find_any_in */
1585 while ((hwi = audio_pcm_hw_find_any_in (s, hwi))) {
1586 hwi->pcm_ops->ctl_in (hwi, VOICE_DISABLE);
1587 hwi->pcm_ops->fini_in (hwi);
1588 }
1589
1590 if (s->drv) {
1591 s->drv->fini (s->drv_opaque);
1592 }
1593}
1594
1595void AUD_register_card (const char *name, QEMUSoundCard *card)
1596{
1597 AudioState *s = &glob_audio_state;
1598 card->audio = s;
1599 card->name = qemu_strdup (name);
1600 memset (&card->entries, 0, sizeof (card->entries));
1601 LIST_INSERT_HEAD (&s->card_head, card, entries);
1602}
1603
1604void AUD_remove_card (QEMUSoundCard *card)
1605{
1606 LIST_REMOVE (card, entries);
1607 card->audio = NULL;
1608 qemu_free (card->name);
1609}
1610
1611static void audio_timer_helper (PPDMDRVINS pDrvIns, PTMTIMER pTimer)
1612{
1613 AudioState *s = &glob_audio_state;
1614 audio_timer (s);
1615}
1616
1617static int AUD_init (PPDMDRVINS pDrvIns, const char *drvname)
1618{
1619 size_t i;
1620 int done = 0;
1621 AudioState *s = &glob_audio_state;
1622 int rc;
1623
1624 LIST_INIT (&s->hw_head_out);
1625 LIST_INIT (&s->hw_head_in);
1626 LIST_INIT (&s->cap_head);
1627
1628 rc = pDrvIns->pDrvHlp->pfnTMTimerCreate (pDrvIns, TMCLOCK_VIRTUAL,
1629 audio_timer_helper, "Audio timer", &s->ts);
1630 if (RT_FAILURE (rc))
1631 return rc;
1632
1633 audio_process_options ("AUDIO", audio_options);
1634
1635 s->nb_hw_voices_out = conf.fixed_out.nb_voices;
1636 s->nb_hw_voices_in = conf.fixed_in.nb_voices;
1637
1638 if (s->nb_hw_voices_out <= 0) {
1639 dolog ("Bogus number of playback voices %d, setting to 1\n",
1640 s->nb_hw_voices_out);
1641 s->nb_hw_voices_out = 1;
1642 }
1643
1644 if (s->nb_hw_voices_in <= 0) {
1645 dolog ("Bogus number of capture voices %d, setting to 0\n",
1646 s->nb_hw_voices_in);
1647 s->nb_hw_voices_in = 0;
1648 }
1649
1650 LogRel(("Audio: Trying driver '%s'.\n", drvname));
1651
1652 if (drvname) {
1653 int found = 0;
1654
1655 for (i = 0; i < sizeof (drvtab) / sizeof (drvtab[0]); i++) {
1656 if (!strcmp (drvname, drvtab[i]->name)) {
1657 done = !audio_driver_init (s, drvtab[i]);
1658 found = 1;
1659 break;
1660 }
1661 }
1662
1663 if (!found) {
1664 dolog ("Unknown audio driver `%s'\n", drvname);
1665 }
1666 }
1667
1668 if (!done) {
1669 for (i = 0; !done && i < sizeof (drvtab) / sizeof (drvtab[0]); i++) {
1670 if (drvtab[i]->can_be_default) {
1671 LogRel(("Audio: Initialization of driver '%s' failed, trying '%s'.\n",
1672 drvname, drvtab[i]->name));
1673 drvname = drvtab[i]->name;
1674 done = !audio_driver_init (s, drvtab[i]);
1675 }
1676 }
1677 }
1678
1679 if (!done) {
1680 done = !audio_driver_init (s, &no_audio_driver);
1681 if (!done) {
1682 dolog ("Could not initialize audio subsystem\n");
1683 }
1684 else {
1685 LogRel(("Audio: Initialization of driver '%s' failed, using NULL driver.\n", drvname));
1686 dolog ("warning: Using timer based audio emulation\n");
1687 }
1688 }
1689
1690 if (done) {
1691 if (conf.period.hz <= 0) {
1692 if (conf.period.hz < 0) {
1693 dolog ("warning: Timer period is negative - %d "
1694 "treating as zero\n",
1695 conf.period.hz);
1696 }
1697 conf.period.ticks = 1;
1698 }
1699 else {
1700 conf.period.ticks = pDrvIns->pDrvHlp->pfnTMGetVirtualFreq (pDrvIns)
1701 / conf.period.hz;
1702 }
1703 }
1704 else {
1705 /* XXX */
1706 rc = TMTimerDestroy (s->ts);
1707 return rc;
1708 }
1709
1710 LIST_INIT (&s->card_head);
1711 TMTimerSet (s->ts, TMTimerGet (s->ts) + conf.period.ticks);
1712 return VINF_SUCCESS;
1713}
1714
1715int AUD_init_null(void)
1716{
1717 AudioState *s = &glob_audio_state;
1718
1719#ifdef VBOX
1720 if (s->drv)
1721 s->drv->fini (s->drv_opaque);
1722#endif
1723
1724 LogRel(("Audio: Using NULL audio driver\n"));
1725 return audio_driver_init (s, &no_audio_driver);
1726}
1727
1728CaptureVoiceOut *AUD_add_capture (
1729 AudioState *s,
1730 audsettings_t *as,
1731 struct audio_capture_ops *ops,
1732 void *cb_opaque
1733 )
1734{
1735 CaptureVoiceOut *cap;
1736 struct capture_callback *cb;
1737
1738 if (!s) {
1739 /* XXX suppress */
1740 s = &glob_audio_state;
1741 }
1742
1743 if (audio_validate_settings (as)) {
1744 dolog ("Invalid settings were passed when trying to add capture\n");
1745 audio_print_settings (as);
1746 goto err0;
1747 }
1748
1749 cb = audio_calloc (AUDIO_FUNC, 1, sizeof (*cb));
1750 if (!cb) {
1751 dolog ("Could not allocate capture callback information, size %u\n",
1752 sizeof (*cb));
1753 goto err0;
1754 }
1755 cb->ops = *ops;
1756 cb->opaque = cb_opaque;
1757
1758 cap = audio_pcm_capture_find_specific (s, as);
1759 if (cap) {
1760 LIST_INSERT_HEAD (&cap->cb_head, cb, entries);
1761 return cap;
1762 }
1763 else {
1764 HWVoiceOut *hw;
1765 CaptureVoiceOut *cap;
1766
1767 cap = audio_calloc (AUDIO_FUNC, 1, sizeof (*cap));
1768 if (!cap) {
1769 dolog ("Could not allocate capture voice, size %u\n",
1770 sizeof (*cap));
1771 goto err1;
1772 }
1773
1774 hw = &cap->hw;
1775 LIST_INIT (&hw->sw_head);
1776 LIST_INIT (&cap->cb_head);
1777
1778 /* XXX find a more elegant way */
1779 hw->samples = 4096 * 4;
1780 hw->mix_buf = audio_calloc (AUDIO_FUNC, hw->samples,
1781 sizeof (st_sample_t));
1782 if (!hw->mix_buf) {
1783 dolog ("Could not allocate capture mix buffer (%d samples)\n",
1784 hw->samples);
1785 goto err2;
1786 }
1787
1788 audio_pcm_init_info (&hw->info, as);
1789
1790 cap->buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift);
1791 if (!cap->buf) {
1792 dolog ("Could not allocate capture buffer "
1793 "(%d samples, each %d bytes)\n",
1794 hw->samples, 1 << hw->info.shift);
1795 goto err3;
1796 }
1797
1798 hw->clip = mixeng_clip
1799 [hw->info.nchannels == 2]
1800 [hw->info.sign]
1801 [hw->info.swap_endianness]
1802 [audio_bits_to_index (hw->info.bits)];
1803
1804 LIST_INSERT_HEAD (&s->cap_head, cap, entries);
1805 LIST_INSERT_HEAD (&cap->cb_head, cb, entries);
1806
1807 hw = NULL;
1808 while ((hw = audio_pcm_hw_find_any_out (s, hw))) {
1809 audio_attach_capture (s, hw);
1810 }
1811 return cap;
1812
1813 err3:
1814 qemu_free (cap->hw.mix_buf);
1815 err2:
1816 qemu_free (cap);
1817 err1:
1818 qemu_free (cb);
1819 err0:
1820 return NULL;
1821 }
1822}
1823
1824void AUD_del_capture (CaptureVoiceOut *cap, void *cb_opaque)
1825{
1826 struct capture_callback *cb;
1827
1828 for (cb = cap->cb_head.lh_first; cb; cb = cb->entries.le_next) {
1829 if (cb->opaque == cb_opaque) {
1830 cb->ops.destroy (cb_opaque);
1831 LIST_REMOVE (cb, entries);
1832 qemu_free (cb);
1833
1834 if (!cap->cb_head.lh_first) {
1835 SWVoiceOut *sw = cap->hw.sw_head.lh_first, *sw1;
1836
1837 while (sw) {
1838 SWVoiceCap *sc = (SWVoiceCap *) sw;
1839#ifdef DEBUG_CAPTURE
1840 dolog ("freeing %s\n", sw->name);
1841#endif
1842
1843 sw1 = sw->entries.le_next;
1844 if (sw->rate) {
1845 st_rate_stop (sw->rate);
1846 sw->rate = NULL;
1847 }
1848 LIST_REMOVE (sw, entries);
1849 LIST_REMOVE (sc, entries);
1850 qemu_free (sc);
1851 sw = sw1;
1852 }
1853 LIST_REMOVE (cap, entries);
1854 qemu_free (cap);
1855 }
1856 return;
1857 }
1858 }
1859}
1860
1861void AUD_set_volume_out (SWVoiceOut *sw, int mute, uint8_t lvol, uint8_t rvol)
1862{
1863 if (sw)
1864 {
1865 sw->vol.mute = mute;
1866 sw->vol.l = (uint32_t)lvol * 0x808080; /* maximum is INT_MAX = 0x7fffffff */
1867 sw->vol.r = (uint32_t)rvol * 0x808080; /* maximum is INT_MAX = 0x7fffffff */
1868 }
1869}
1870
1871void AUD_set_volume (audmixerctl_t mt, int *mute, uint8_t *lvol, uint8_t *rvol)
1872{
1873 volume_t *vol = NULL;
1874 const char *name;
1875
1876 switch (mt)
1877 {
1878 case AUD_MIXER_VOLUME:
1879 name = "MASTER";
1880 vol = &master_out_volume;
1881 break;
1882 case AUD_MIXER_PCM:
1883 name = "PCM_OUT";
1884 vol = &pcm_out_volume;
1885 break;
1886 case AUD_MIXER_LINE_IN:
1887 name = "LINE_IN";
1888 vol = &pcm_in_volume;
1889 break;
1890 default:
1891 return;
1892
1893 }
1894
1895 if (vol)
1896 {
1897 uint32_t u32VolumeLeft = (uint32_t)*lvol;
1898 uint32_t u32VolumeRight = (uint32_t)*rvol;
1899 /* 0x00..0xff => 0x01..0x100 */
1900 if (u32VolumeLeft)
1901 u32VolumeLeft++;
1902 if (u32VolumeRight)
1903 u32VolumeRight++;
1904 vol->mute = *mute;
1905 vol->l = u32VolumeLeft * 0x800000; /* maximum is 0x80000000 */
1906 vol->r = u32VolumeRight * 0x800000; /* maximum is 0x80000000 */
1907 }
1908 sum_out_volume.mute = master_out_volume.mute || pcm_out_volume.mute;
1909 sum_out_volume.l = ASMMultU64ByU32DivByU32(master_out_volume.l, pcm_out_volume.l, 0x80000000U);
1910 sum_out_volume.r = ASMMultU64ByU32DivByU32(master_out_volume.r, pcm_out_volume.r, 0x80000000U);
1911}
1912
1913void AUD_set_record_source (audrecsource_t *ars, audrecsource_t *als)
1914{
1915 LogRel(("Audio: set_record_source ars=%d als=%d (not implemented)\n", *ars, *als));
1916}
1917
1918/**
1919 * Queries an interface to the driver.
1920 *
1921 * @returns Pointer to interface.
1922 * @returns NULL if the interface was not supported by the driver.
1923 * @param pInterface Pointer to this interface structure.
1924 * @param enmInterface The requested interface identification.
1925 * @thread Any thread.
1926 */
1927static DECLCALLBACK(void *) drvAudioQueryInterface(PPDMIBASE pInterface,
1928 PDMINTERFACE enmInterface)
1929{
1930 PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
1931 PDRVAUDIO pThis = PDMINS_2_DATA(pDrvIns, PDRVAUDIO);
1932 switch (enmInterface)
1933 {
1934 case PDMINTERFACE_BASE:
1935 return &pDrvIns->IBase;
1936 case PDMINTERFACE_AUDIO_CONNECTOR:
1937 return &pThis->IAudioConnector;
1938 default:
1939 return NULL;
1940 }
1941}
1942
1943/**
1944 * Power Off notification.
1945 *
1946 * @param pDrvIns The driver instance data.
1947 */
1948static DECLCALLBACK(void) drvAudioPowerOff(PPDMDRVINS pDrvIns)
1949{
1950 AudioState *s = &glob_audio_state;
1951 audio_vm_change_state_handler (s, 0);
1952}
1953
1954/**
1955 * Destruct a driver instance.
1956 *
1957 * Most VM resources are freed by the VM. This callback is provided so that any non-VM
1958 * resources can be freed correctly.
1959 *
1960 * @param pDrvIns The driver instance data.
1961 */
1962static DECLCALLBACK(void) drvAudioDestruct(PPDMDRVINS pDrvIns)
1963{
1964 LogFlow(("drvAUDIODestruct:\n"));
1965
1966 audio_atexit ();
1967}
1968
1969/**
1970 * Construct an AUDIO driver instance.
1971 *
1972 * @returns VBox status.
1973 * @param pDrvIns The driver instance data.
1974 * If the registration structure is needed, pDrvIns->pDrvReg points to it.
1975 * @param pCfgHandle Configuration node handle for the driver. Use this to obtain the configuration
1976 * of the driver instance. It's also found in pDrvIns->pCfgHandle, but like
1977 * iInstance it's expected to be used a bit in this function.
1978 */
1979static DECLCALLBACK(int) drvAudioConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfgHandle)
1980{
1981 int rc;
1982 PDRVAUDIO pThis = PDMINS_2_DATA(pDrvIns, PDRVAUDIO);
1983 char *drvname;
1984
1985 LogFlow(("drvAUDIOConstruct:\n"));
1986 /*
1987 * Validate the config.
1988 */
1989 if (!CFGMR3AreValuesValid(pCfgHandle, "AudioDriver\0StreamName\0"))
1990 return VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES;
1991
1992 /*
1993 * Init the static parts.
1994 */
1995 pThis->pDrvIns = pDrvIns;
1996 /* IBase */
1997 pDrvIns->IBase.pfnQueryInterface = drvAudioQueryInterface;
1998 /* IAudio */
1999 /* pThis->IAudioConnector.pfn; */
2000
2001 glob_audio_state.pDrvIns = pDrvIns;
2002
2003 rc = CFGMR3QueryStringAlloc (pCfgHandle, "AudioDriver", &drvname);
2004 if (RT_FAILURE (rc))
2005 return rc;
2006
2007 rc = CFGMR3QueryStringAlloc (pCfgHandle, "StreamName", &audio_streamname);
2008 if (RT_FAILURE (rc))
2009 audio_streamname = NULL;
2010
2011 rc = AUD_init (pDrvIns, drvname);
2012 if (RT_FAILURE (rc))
2013 return rc;
2014
2015 MMR3HeapFree (drvname);
2016
2017 return VINF_SUCCESS;
2018}
2019
2020/**
2021 * Suspend notification.
2022 *
2023 * @returns VBox status.
2024 * @param pDrvIns The driver instance data.
2025 */
2026static DECLCALLBACK(void) drvAudioSuspend(PPDMDRVINS pDrvIns)
2027{
2028 AudioState *s = &glob_audio_state;
2029 audio_vm_change_state_handler (s, 0);
2030}
2031
2032/**
2033 * Resume notification.
2034 *
2035 * @returns VBox status.
2036 * @param pDrvIns The driver instance data.
2037 */
2038static DECLCALLBACK(void) audioResume(PPDMDRVINS pDrvIns)
2039{
2040 AudioState *s = &glob_audio_state;
2041 audio_vm_change_state_handler (s, 1);
2042}
2043
2044/**
2045 * Audio driver registration record.
2046 */
2047const PDMDRVREG g_DrvAUDIO =
2048{
2049 /* u32Version */
2050 PDM_DRVREG_VERSION,
2051 /* szDriverName */
2052 "AUDIO",
2053 /* pszDescription */
2054 "AUDIO Driver",
2055 /* fFlags */
2056 PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
2057 /* fClass. */
2058 PDM_DRVREG_CLASS_AUDIO,
2059 /* cMaxInstances */
2060 1,
2061 /* cbInstance */
2062 sizeof(DRVAUDIO),
2063 /* pfnConstruct */
2064 drvAudioConstruct,
2065 /* pfnDestruct */
2066 drvAudioDestruct,
2067 /* pfnIOCtl */
2068 NULL,
2069 /* pfnPowerOn */
2070 NULL,
2071 /* pfnReset */
2072 NULL,
2073 /* pfnSuspend */
2074 drvAudioSuspend,
2075 /* pfnResume */
2076 audioResume,
2077 /* pfnDetach */
2078 NULL,
2079 /* pfnPowerOff */
2080 drvAudioPowerOff
2081};
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette