blob: 2a20e5be1b069a2ce31d6b213c54eebea308058e [file] [log] [blame]
bellard85571bc2004-11-07 18:04:02 +00001/*
2 * QEMU Audio subsystem
bellard1d14ffa2005-10-30 18:58:22 +00003 *
4 * Copyright (c) 2003-2005 Vassili Karpov (malc)
5 *
bellard85571bc2004-11-07 18:04:02 +00006 * 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 */
pbrook87ecb682007-11-17 17:14:51 +000024#include "hw/hw.h"
25#include "audio.h"
aliguori376253e2009-03-05 23:01:23 +000026#include "monitor.h"
pbrook87ecb682007-11-17 17:14:51 +000027#include "qemu-timer.h"
28#include "sysemu.h"
bellard85571bc2004-11-07 18:04:02 +000029
bellard1d14ffa2005-10-30 18:58:22 +000030#define AUDIO_CAP "audio"
31#include "audio_int.h"
bellard85571bc2004-11-07 18:04:02 +000032
bellard1d14ffa2005-10-30 18:58:22 +000033/* #define DEBUG_PLIVE */
34/* #define DEBUG_LIVE */
35/* #define DEBUG_OUT */
bellard8ead62c2006-07-04 16:51:32 +000036/* #define DEBUG_CAPTURE */
malc713a98f2009-09-12 02:28:45 +040037/* #define DEBUG_POLL */
bellard1d14ffa2005-10-30 18:58:22 +000038
bellardc0fe3822005-11-05 18:55:28 +000039#define SW_NAME(sw) (sw)->name ? (sw)->name : "unknown"
40
Juan Quintela2358a492009-07-27 16:13:25 +020041
42/* Order of CONFIG_AUDIO_DRIVERS is import.
43 The 1st one is the one used by default, that is the reason
44 that we generate the list.
45*/
bellard1d14ffa2005-10-30 18:58:22 +000046static struct audio_driver *drvtab[] = {
Juan Quintela2358a492009-07-27 16:13:25 +020047 CONFIG_AUDIO_DRIVERS
bellard1d14ffa2005-10-30 18:58:22 +000048 &no_audio_driver,
49 &wav_audio_driver
50};
bellard85571bc2004-11-07 18:04:02 +000051
bellardc0fe3822005-11-05 18:55:28 +000052struct fixed_settings {
53 int enabled;
54 int nb_voices;
55 int greedy;
malc1ea879e2008-12-03 22:48:44 +000056 struct audsettings settings;
bellardc0fe3822005-11-05 18:55:28 +000057};
bellard1d14ffa2005-10-30 18:58:22 +000058
bellardc0fe3822005-11-05 18:55:28 +000059static struct {
60 struct fixed_settings fixed_out;
61 struct fixed_settings fixed_in;
62 union {
malcc310de82008-11-12 20:36:27 +000063 int hertz;
bellardc0fe3822005-11-05 18:55:28 +000064 int64_t ticks;
65 } period;
66 int plive;
bellard541e0842005-11-11 00:04:19 +000067 int log_to_monitor;
malc713a98f2009-09-12 02:28:45 +040068 int try_poll_in;
69 int try_poll_out;
bellardc0fe3822005-11-05 18:55:28 +000070} conf = {
Juan Quintela14658cd2009-07-20 20:57:00 +020071 .fixed_out = { /* DAC fixed settings */
72 .enabled = 1,
73 .nb_voices = 1,
74 .greedy = 1,
75 .settings = {
76 .freq = 44100,
77 .nchannels = 2,
78 .fmt = AUD_FMT_S16,
79 .endianness = AUDIO_HOST_ENDIANNESS,
bellardc0fe3822005-11-05 18:55:28 +000080 }
81 },
bellard1d14ffa2005-10-30 18:58:22 +000082
Juan Quintela14658cd2009-07-20 20:57:00 +020083 .fixed_in = { /* ADC fixed settings */
84 .enabled = 1,
85 .nb_voices = 1,
86 .greedy = 1,
87 .settings = {
88 .freq = 44100,
89 .nchannels = 2,
90 .fmt = AUD_FMT_S16,
91 .endianness = AUDIO_HOST_ENDIANNESS,
bellardc0fe3822005-11-05 18:55:28 +000092 }
93 },
bellard1d14ffa2005-10-30 18:58:22 +000094
malcaea86742009-07-24 05:16:12 +040095 .period = { .hertz = 250 },
Juan Quintela14658cd2009-07-20 20:57:00 +020096 .plive = 0,
97 .log_to_monitor = 0,
malc713a98f2009-09-12 02:28:45 +040098 .try_poll_in = 1,
99 .try_poll_out = 1,
bellard1d14ffa2005-10-30 18:58:22 +0000100};
101
bellardc0fe3822005-11-05 18:55:28 +0000102static AudioState glob_audio_state;
103
malc1ea879e2008-12-03 22:48:44 +0000104struct mixeng_volume nominal_volume = {
Juan Quintela14658cd2009-07-20 20:57:00 +0200105 .mute = 0,
bellard1d14ffa2005-10-30 18:58:22 +0000106#ifdef FLOAT_MIXENG
Juan Quintela14658cd2009-07-20 20:57:00 +0200107 .r = 1.0,
108 .l = 1.0,
bellard1d14ffa2005-10-30 18:58:22 +0000109#else
Juan Quintela14658cd2009-07-20 20:57:00 +0200110 .r = 1ULL << 32,
111 .l = 1ULL << 32,
bellard1d14ffa2005-10-30 18:58:22 +0000112#endif
bellard85571bc2004-11-07 18:04:02 +0000113};
114
bellard1d14ffa2005-10-30 18:58:22 +0000115#ifdef AUDIO_IS_FLAWLESS_AND_NO_CHECKS_ARE_REQURIED
116#error No its not
117#else
malc82584e22010-01-17 02:03:30 +0300118static void audio_print_options (const char *prefix,
119 struct audio_option *opt);
120
bellard1d14ffa2005-10-30 18:58:22 +0000121int audio_bug (const char *funcname, int cond)
bellard85571bc2004-11-07 18:04:02 +0000122{
bellard1d14ffa2005-10-30 18:58:22 +0000123 if (cond) {
124 static int shown;
125
bellard8ead62c2006-07-04 16:51:32 +0000126 AUD_log (NULL, "A bug was just triggered in %s\n", funcname);
bellard1d14ffa2005-10-30 18:58:22 +0000127 if (!shown) {
malc82584e22010-01-17 02:03:30 +0300128 struct audio_driver *d;
129
bellard1d14ffa2005-10-30 18:58:22 +0000130 shown = 1;
131 AUD_log (NULL, "Save all your work and restart without audio\n");
malc155a8ad2009-09-18 11:52:45 +0400132 AUD_log (NULL, "Please send bug report to av1474@comtv.ru\n");
bellard1d14ffa2005-10-30 18:58:22 +0000133 AUD_log (NULL, "I am sorry\n");
malc82584e22010-01-17 02:03:30 +0300134 d = glob_audio_state.drv;
135 if (d) {
136 audio_print_options (d->name, d->options);
137 }
bellard1d14ffa2005-10-30 18:58:22 +0000138 }
139 AUD_log (NULL, "Context:\n");
140
141#if defined AUDIO_BREAKPOINT_ON_BUG
142# if defined HOST_I386
143# if defined __GNUC__
144 __asm__ ("int3");
145# elif defined _MSC_VER
146 _asm _emit 0xcc;
147# else
148 abort ();
149# endif
150# else
151 abort ();
152# endif
153#endif
154 }
155
156 return cond;
157}
158#endif
159
thsf941aa22007-02-17 22:19:29 +0000160static inline int audio_bits_to_index (int bits)
161{
162 switch (bits) {
163 case 8:
164 return 0;
165
166 case 16:
167 return 1;
168
169 case 32:
170 return 2;
171
172 default:
173 audio_bug ("bits_to_index", 1);
174 AUD_log (NULL, "invalid bits %d\n", bits);
175 return 0;
176 }
177}
178
bellardc0fe3822005-11-05 18:55:28 +0000179void *audio_calloc (const char *funcname, int nmemb, size_t size)
180{
181 int cond;
182 size_t len;
183
184 len = nmemb * size;
185 cond = !nmemb || !size;
186 cond |= nmemb < 0;
187 cond |= len < size;
188
189 if (audio_bug ("audio_calloc", cond)) {
190 AUD_log (NULL, "%s passed invalid arguments to audio_calloc\n",
191 funcname);
bellard541e0842005-11-11 00:04:19 +0000192 AUD_log (NULL, "nmemb=%d size=%zu (len=%zu)\n", nmemb, size, len);
bellardc0fe3822005-11-05 18:55:28 +0000193 return NULL;
194 }
195
196 return qemu_mallocz (len);
197}
198
bellard1d14ffa2005-10-30 18:58:22 +0000199static char *audio_alloc_prefix (const char *s)
200{
201 const char qemu_prefix[] = "QEMU_";
aliguori090f1fa2009-02-05 22:05:58 +0000202 size_t len, i;
203 char *r, *u;
bellard1d14ffa2005-10-30 18:58:22 +0000204
205 if (!s) {
206 return NULL;
207 }
208
209 len = strlen (s);
blueswir1a3772d42008-08-27 18:43:53 +0000210 r = qemu_malloc (len + sizeof (qemu_prefix));
bellard1d14ffa2005-10-30 18:58:22 +0000211
aliguori090f1fa2009-02-05 22:05:58 +0000212 u = r + sizeof (qemu_prefix) - 1;
bellard1d14ffa2005-10-30 18:58:22 +0000213
aliguori090f1fa2009-02-05 22:05:58 +0000214 pstrcpy (r, len + sizeof (qemu_prefix), qemu_prefix);
215 pstrcat (r, len + sizeof (qemu_prefix), s);
bellard1d14ffa2005-10-30 18:58:22 +0000216
aliguori090f1fa2009-02-05 22:05:58 +0000217 for (i = 0; i < len; ++i) {
218 u[i] = qemu_toupper(u[i]);
bellard1d14ffa2005-10-30 18:58:22 +0000219 }
aliguori090f1fa2009-02-05 22:05:58 +0000220
bellard1d14ffa2005-10-30 18:58:22 +0000221 return r;
222}
223
pbrook9596ebb2007-11-18 01:44:38 +0000224static const char *audio_audfmt_to_string (audfmt_e fmt)
bellard1d14ffa2005-10-30 18:58:22 +0000225{
226 switch (fmt) {
227 case AUD_FMT_U8:
228 return "U8";
229
230 case AUD_FMT_U16:
231 return "U16";
232
233 case AUD_FMT_S8:
234 return "S8";
235
236 case AUD_FMT_S16:
237 return "S16";
thsf941aa22007-02-17 22:19:29 +0000238
239 case AUD_FMT_U32:
240 return "U32";
241
242 case AUD_FMT_S32:
243 return "S32";
bellard1d14ffa2005-10-30 18:58:22 +0000244 }
245
246 dolog ("Bogus audfmt %d returning S16\n", fmt);
247 return "S16";
248}
249
pbrook9596ebb2007-11-18 01:44:38 +0000250static audfmt_e audio_string_to_audfmt (const char *s, audfmt_e defval,
251 int *defaultp)
bellard1d14ffa2005-10-30 18:58:22 +0000252{
253 if (!strcasecmp (s, "u8")) {
254 *defaultp = 0;
255 return AUD_FMT_U8;
256 }
257 else if (!strcasecmp (s, "u16")) {
258 *defaultp = 0;
259 return AUD_FMT_U16;
260 }
thsf941aa22007-02-17 22:19:29 +0000261 else if (!strcasecmp (s, "u32")) {
262 *defaultp = 0;
263 return AUD_FMT_U32;
264 }
bellard1d14ffa2005-10-30 18:58:22 +0000265 else if (!strcasecmp (s, "s8")) {
266 *defaultp = 0;
267 return AUD_FMT_S8;
268 }
269 else if (!strcasecmp (s, "s16")) {
270 *defaultp = 0;
271 return AUD_FMT_S16;
272 }
thsf941aa22007-02-17 22:19:29 +0000273 else if (!strcasecmp (s, "s32")) {
274 *defaultp = 0;
275 return AUD_FMT_S32;
276 }
bellard1d14ffa2005-10-30 18:58:22 +0000277 else {
278 dolog ("Bogus audio format `%s' using %s\n",
279 s, audio_audfmt_to_string (defval));
280 *defaultp = 1;
281 return defval;
282 }
283}
284
285static audfmt_e audio_get_conf_fmt (const char *envname,
286 audfmt_e defval,
287 int *defaultp)
288{
289 const char *var = getenv (envname);
290 if (!var) {
291 *defaultp = 1;
292 return defval;
293 }
294 return audio_string_to_audfmt (var, defval, defaultp);
295}
296
297static int audio_get_conf_int (const char *key, int defval, int *defaultp)
298{
299 int val;
bellard85571bc2004-11-07 18:04:02 +0000300 char *strval;
301
302 strval = getenv (key);
303 if (strval) {
bellard1d14ffa2005-10-30 18:58:22 +0000304 *defaultp = 0;
bellard85571bc2004-11-07 18:04:02 +0000305 val = atoi (strval);
bellard1d14ffa2005-10-30 18:58:22 +0000306 return val;
bellard85571bc2004-11-07 18:04:02 +0000307 }
bellard1d14ffa2005-10-30 18:58:22 +0000308 else {
309 *defaultp = 1;
310 return defval;
311 }
bellard85571bc2004-11-07 18:04:02 +0000312}
313
bellard1d14ffa2005-10-30 18:58:22 +0000314static const char *audio_get_conf_str (const char *key,
315 const char *defval,
316 int *defaultp)
bellard85571bc2004-11-07 18:04:02 +0000317{
318 const char *val = getenv (key);
bellard1d14ffa2005-10-30 18:58:22 +0000319 if (!val) {
320 *defaultp = 1;
bellard85571bc2004-11-07 18:04:02 +0000321 return defval;
bellard1d14ffa2005-10-30 18:58:22 +0000322 }
323 else {
324 *defaultp = 0;
bellard85571bc2004-11-07 18:04:02 +0000325 return val;
bellard1d14ffa2005-10-30 18:58:22 +0000326 }
bellard85571bc2004-11-07 18:04:02 +0000327}
328
bellard541e0842005-11-11 00:04:19 +0000329void AUD_vlog (const char *cap, const char *fmt, va_list ap)
330{
331 if (conf.log_to_monitor) {
332 if (cap) {
aliguori376253e2009-03-05 23:01:23 +0000333 monitor_printf(cur_mon, "%s: ", cap);
bellard541e0842005-11-11 00:04:19 +0000334 }
335
aliguori376253e2009-03-05 23:01:23 +0000336 monitor_vprintf(cur_mon, fmt, ap);
bellard541e0842005-11-11 00:04:19 +0000337 }
338 else {
339 if (cap) {
340 fprintf (stderr, "%s: ", cap);
341 }
342
343 vfprintf (stderr, fmt, ap);
344 }
345}
346
bellardfb065182004-11-09 23:09:44 +0000347void AUD_log (const char *cap, const char *fmt, ...)
bellard85571bc2004-11-07 18:04:02 +0000348{
349 va_list ap;
bellard85571bc2004-11-07 18:04:02 +0000350
bellard541e0842005-11-11 00:04:19 +0000351 va_start (ap, fmt);
352 AUD_vlog (cap, fmt, ap);
353 va_end (ap);
bellard85571bc2004-11-07 18:04:02 +0000354}
355
bellard1d14ffa2005-10-30 18:58:22 +0000356static void audio_print_options (const char *prefix,
357 struct audio_option *opt)
bellard85571bc2004-11-07 18:04:02 +0000358{
bellard1d14ffa2005-10-30 18:58:22 +0000359 char *uprefix;
360
361 if (!prefix) {
362 dolog ("No prefix specified\n");
363 return;
364 }
365
366 if (!opt) {
367 dolog ("No options\n");
368 return;
369 }
370
371 uprefix = audio_alloc_prefix (prefix);
372
373 for (; opt->name; opt++) {
374 const char *state = "default";
375 printf (" %s_%s: ", uprefix, opt->name);
376
thsfe8f0962007-07-12 10:59:21 +0000377 if (opt->overriddenp && *opt->overriddenp) {
bellard1d14ffa2005-10-30 18:58:22 +0000378 state = "current";
379 }
380
381 switch (opt->tag) {
382 case AUD_OPT_BOOL:
383 {
384 int *intp = opt->valp;
385 printf ("boolean, %s = %d\n", state, *intp ? 1 : 0);
386 }
387 break;
388
389 case AUD_OPT_INT:
390 {
391 int *intp = opt->valp;
392 printf ("integer, %s = %d\n", state, *intp);
393 }
394 break;
395
396 case AUD_OPT_FMT:
397 {
398 audfmt_e *fmtp = opt->valp;
399 printf (
balrogca9cc282008-01-14 04:24:29 +0000400 "format, %s = %s, (one of: U8 S8 U16 S16 U32 S32)\n",
bellard1d14ffa2005-10-30 18:58:22 +0000401 state,
402 audio_audfmt_to_string (*fmtp)
403 );
404 }
405 break;
406
407 case AUD_OPT_STR:
408 {
409 const char **strp = opt->valp;
410 printf ("string, %s = %s\n",
411 state,
412 *strp ? *strp : "(not set)");
413 }
414 break;
415
416 default:
417 printf ("???\n");
418 dolog ("Bad value tag for option %s_%s %d\n",
419 uprefix, opt->name, opt->tag);
420 break;
421 }
422 printf (" %s\n", opt->descr);
423 }
424
425 qemu_free (uprefix);
bellard85571bc2004-11-07 18:04:02 +0000426}
427
bellard1d14ffa2005-10-30 18:58:22 +0000428static void audio_process_options (const char *prefix,
429 struct audio_option *opt)
430{
431 char *optname;
432 const char qemu_prefix[] = "QEMU_";
blueswir1363a37d2008-08-21 17:58:08 +0000433 size_t preflen, optlen;
bellard1d14ffa2005-10-30 18:58:22 +0000434
435 if (audio_bug (AUDIO_FUNC, !prefix)) {
436 dolog ("prefix = NULL\n");
437 return;
438 }
439
440 if (audio_bug (AUDIO_FUNC, !opt)) {
441 dolog ("opt = NULL\n");
442 return;
443 }
444
445 preflen = strlen (prefix);
446
447 for (; opt->name; opt++) {
448 size_t len, i;
449 int def;
450
451 if (!opt->valp) {
452 dolog ("Option value pointer for `%s' is not set\n",
453 opt->name);
454 continue;
455 }
456
457 len = strlen (opt->name);
bellardc0fe3822005-11-05 18:55:28 +0000458 /* len of opt->name + len of prefix + size of qemu_prefix
459 * (includes trailing zero) + zero + underscore (on behalf of
460 * sizeof) */
blueswir1363a37d2008-08-21 17:58:08 +0000461 optlen = len + preflen + sizeof (qemu_prefix) + 1;
462 optname = qemu_malloc (optlen);
bellard1d14ffa2005-10-30 18:58:22 +0000463
blueswir1363a37d2008-08-21 17:58:08 +0000464 pstrcpy (optname, optlen, qemu_prefix);
bellardc0fe3822005-11-05 18:55:28 +0000465
466 /* copy while upper-casing, including trailing zero */
bellard1d14ffa2005-10-30 18:58:22 +0000467 for (i = 0; i <= preflen; ++i) {
blueswir1cd390082008-11-16 13:53:32 +0000468 optname[i + sizeof (qemu_prefix) - 1] = qemu_toupper(prefix[i]);
bellard1d14ffa2005-10-30 18:58:22 +0000469 }
blueswir1363a37d2008-08-21 17:58:08 +0000470 pstrcat (optname, optlen, "_");
blueswir1363a37d2008-08-21 17:58:08 +0000471 pstrcat (optname, optlen, opt->name);
bellard1d14ffa2005-10-30 18:58:22 +0000472
473 def = 1;
474 switch (opt->tag) {
475 case AUD_OPT_BOOL:
476 case AUD_OPT_INT:
477 {
478 int *intp = opt->valp;
479 *intp = audio_get_conf_int (optname, *intp, &def);
480 }
481 break;
482
483 case AUD_OPT_FMT:
484 {
485 audfmt_e *fmtp = opt->valp;
486 *fmtp = audio_get_conf_fmt (optname, *fmtp, &def);
487 }
488 break;
489
490 case AUD_OPT_STR:
491 {
492 const char **strp = opt->valp;
493 *strp = audio_get_conf_str (optname, *strp, &def);
494 }
495 break;
496
497 default:
498 dolog ("Bad value tag for option `%s' - %d\n",
499 optname, opt->tag);
500 break;
501 }
502
thsfe8f0962007-07-12 10:59:21 +0000503 if (!opt->overriddenp) {
504 opt->overriddenp = &opt->overridden;
bellard1d14ffa2005-10-30 18:58:22 +0000505 }
thsfe8f0962007-07-12 10:59:21 +0000506 *opt->overriddenp = !def;
bellard1d14ffa2005-10-30 18:58:22 +0000507 qemu_free (optname);
508 }
509}
510
malc1ea879e2008-12-03 22:48:44 +0000511static void audio_print_settings (struct audsettings *as)
bellardc0fe3822005-11-05 18:55:28 +0000512{
513 dolog ("frequency=%d nchannels=%d fmt=", as->freq, as->nchannels);
514
515 switch (as->fmt) {
516 case AUD_FMT_S8:
517 AUD_log (NULL, "S8");
518 break;
519 case AUD_FMT_U8:
520 AUD_log (NULL, "U8");
521 break;
522 case AUD_FMT_S16:
523 AUD_log (NULL, "S16");
524 break;
525 case AUD_FMT_U16:
526 AUD_log (NULL, "U16");
527 break;
malcd50997f2008-06-22 14:10:45 +0000528 case AUD_FMT_S32:
529 AUD_log (NULL, "S32");
530 break;
531 case AUD_FMT_U32:
532 AUD_log (NULL, "U32");
533 break;
bellardc0fe3822005-11-05 18:55:28 +0000534 default:
535 AUD_log (NULL, "invalid(%d)", as->fmt);
536 break;
537 }
bellardec36b692006-07-16 18:57:03 +0000538
539 AUD_log (NULL, " endianness=");
bellardd929eba2006-07-04 21:47:22 +0000540 switch (as->endianness) {
541 case 0:
542 AUD_log (NULL, "little");
543 break;
544 case 1:
545 AUD_log (NULL, "big");
546 break;
547 default:
548 AUD_log (NULL, "invalid");
549 break;
550 }
bellardc0fe3822005-11-05 18:55:28 +0000551 AUD_log (NULL, "\n");
552}
553
malc1ea879e2008-12-03 22:48:44 +0000554static int audio_validate_settings (struct audsettings *as)
bellardc0fe3822005-11-05 18:55:28 +0000555{
556 int invalid;
557
558 invalid = as->nchannels != 1 && as->nchannels != 2;
bellardd929eba2006-07-04 21:47:22 +0000559 invalid |= as->endianness != 0 && as->endianness != 1;
bellardc0fe3822005-11-05 18:55:28 +0000560
561 switch (as->fmt) {
562 case AUD_FMT_S8:
563 case AUD_FMT_U8:
564 case AUD_FMT_S16:
565 case AUD_FMT_U16:
thsf941aa22007-02-17 22:19:29 +0000566 case AUD_FMT_S32:
567 case AUD_FMT_U32:
bellardc0fe3822005-11-05 18:55:28 +0000568 break;
569 default:
570 invalid = 1;
571 break;
572 }
573
574 invalid |= as->freq <= 0;
bellardd929eba2006-07-04 21:47:22 +0000575 return invalid ? -1 : 0;
bellardc0fe3822005-11-05 18:55:28 +0000576}
577
malc1ea879e2008-12-03 22:48:44 +0000578static int audio_pcm_info_eq (struct audio_pcm_info *info, struct audsettings *as)
bellard1d14ffa2005-10-30 18:58:22 +0000579{
580 int bits = 8, sign = 0;
581
bellardc0fe3822005-11-05 18:55:28 +0000582 switch (as->fmt) {
bellard1d14ffa2005-10-30 18:58:22 +0000583 case AUD_FMT_S8:
584 sign = 1;
585 case AUD_FMT_U8:
586 break;
587
588 case AUD_FMT_S16:
589 sign = 1;
590 case AUD_FMT_U16:
591 bits = 16;
592 break;
thsf941aa22007-02-17 22:19:29 +0000593
594 case AUD_FMT_S32:
595 sign = 1;
596 case AUD_FMT_U32:
597 bits = 32;
598 break;
bellard1d14ffa2005-10-30 18:58:22 +0000599 }
bellardc0fe3822005-11-05 18:55:28 +0000600 return info->freq == as->freq
601 && info->nchannels == as->nchannels
bellard1d14ffa2005-10-30 18:58:22 +0000602 && info->sign == sign
bellardd929eba2006-07-04 21:47:22 +0000603 && info->bits == bits
604 && info->swap_endianness == (as->endianness != AUDIO_HOST_ENDIANNESS);
bellard1d14ffa2005-10-30 18:58:22 +0000605}
606
malc1ea879e2008-12-03 22:48:44 +0000607void audio_pcm_init_info (struct audio_pcm_info *info, struct audsettings *as)
bellard85571bc2004-11-07 18:04:02 +0000608{
thsf941aa22007-02-17 22:19:29 +0000609 int bits = 8, sign = 0, shift = 0;
bellard85571bc2004-11-07 18:04:02 +0000610
bellardc0fe3822005-11-05 18:55:28 +0000611 switch (as->fmt) {
bellard85571bc2004-11-07 18:04:02 +0000612 case AUD_FMT_S8:
613 sign = 1;
614 case AUD_FMT_U8:
615 break;
616
617 case AUD_FMT_S16:
618 sign = 1;
619 case AUD_FMT_U16:
620 bits = 16;
thsf941aa22007-02-17 22:19:29 +0000621 shift = 1;
622 break;
623
624 case AUD_FMT_S32:
625 sign = 1;
626 case AUD_FMT_U32:
627 bits = 32;
628 shift = 2;
bellard85571bc2004-11-07 18:04:02 +0000629 break;
630 }
631
bellardc0fe3822005-11-05 18:55:28 +0000632 info->freq = as->freq;
bellard1d14ffa2005-10-30 18:58:22 +0000633 info->bits = bits;
634 info->sign = sign;
bellardc0fe3822005-11-05 18:55:28 +0000635 info->nchannels = as->nchannels;
thsf941aa22007-02-17 22:19:29 +0000636 info->shift = (as->nchannels == 2) + shift;
bellard1d14ffa2005-10-30 18:58:22 +0000637 info->align = (1 << info->shift) - 1;
638 info->bytes_per_second = info->freq << info->shift;
bellardd929eba2006-07-04 21:47:22 +0000639 info->swap_endianness = (as->endianness != AUDIO_HOST_ENDIANNESS);
bellard85571bc2004-11-07 18:04:02 +0000640}
641
bellard1d14ffa2005-10-30 18:58:22 +0000642void audio_pcm_info_clear_buf (struct audio_pcm_info *info, void *buf, int len)
bellard85571bc2004-11-07 18:04:02 +0000643{
bellard1d14ffa2005-10-30 18:58:22 +0000644 if (!len) {
645 return;
646 }
647
648 if (info->sign) {
bellarde2f909b2006-08-03 20:39:40 +0000649 memset (buf, 0x00, len << info->shift);
bellard1d14ffa2005-10-30 18:58:22 +0000650 }
651 else {
thsf941aa22007-02-17 22:19:29 +0000652 switch (info->bits) {
653 case 8:
bellarde2f909b2006-08-03 20:39:40 +0000654 memset (buf, 0x80, len << info->shift);
thsf941aa22007-02-17 22:19:29 +0000655 break;
bellard1d14ffa2005-10-30 18:58:22 +0000656
thsf941aa22007-02-17 22:19:29 +0000657 case 16:
658 {
659 int i;
660 uint16_t *p = buf;
661 int shift = info->nchannels - 1;
662 short s = INT16_MAX;
bellard1d14ffa2005-10-30 18:58:22 +0000663
thsf941aa22007-02-17 22:19:29 +0000664 if (info->swap_endianness) {
665 s = bswap16 (s);
666 }
667
668 for (i = 0; i < len << shift; i++) {
669 p[i] = s;
670 }
bellard1d14ffa2005-10-30 18:58:22 +0000671 }
thsf941aa22007-02-17 22:19:29 +0000672 break;
673
674 case 32:
675 {
676 int i;
677 uint32_t *p = buf;
678 int shift = info->nchannels - 1;
679 int32_t s = INT32_MAX;
680
681 if (info->swap_endianness) {
682 s = bswap32 (s);
683 }
684
685 for (i = 0; i < len << shift; i++) {
686 p[i] = s;
687 }
688 }
689 break;
690
691 default:
692 AUD_log (NULL, "audio_pcm_info_clear_buf: invalid bits %d\n",
693 info->bits);
694 break;
bellard1d14ffa2005-10-30 18:58:22 +0000695 }
696 }
bellard85571bc2004-11-07 18:04:02 +0000697}
698
bellard1d14ffa2005-10-30 18:58:22 +0000699/*
bellard8ead62c2006-07-04 16:51:32 +0000700 * Capture
701 */
malc1ea879e2008-12-03 22:48:44 +0000702static void noop_conv (struct st_sample *dst, const void *src,
703 int samples, struct mixeng_volume *vol)
bellard8ead62c2006-07-04 16:51:32 +0000704{
705 (void) src;
706 (void) dst;
707 (void) samples;
708 (void) vol;
709}
710
711static CaptureVoiceOut *audio_pcm_capture_find_specific (
malc1ea879e2008-12-03 22:48:44 +0000712 struct audsettings *as
bellard8ead62c2006-07-04 16:51:32 +0000713 )
714{
715 CaptureVoiceOut *cap;
malc1a7dafc2009-05-14 03:11:35 +0400716 AudioState *s = &glob_audio_state;
bellard8ead62c2006-07-04 16:51:32 +0000717
718 for (cap = s->cap_head.lh_first; cap; cap = cap->entries.le_next) {
bellardd929eba2006-07-04 21:47:22 +0000719 if (audio_pcm_info_eq (&cap->hw.info, as)) {
bellard8ead62c2006-07-04 16:51:32 +0000720 return cap;
721 }
722 }
723 return NULL;
724}
725
bellardec36b692006-07-16 18:57:03 +0000726static void audio_notify_capture (CaptureVoiceOut *cap, audcnotification_e cmd)
727{
728 struct capture_callback *cb;
729
730#ifdef DEBUG_CAPTURE
731 dolog ("notification %d sent\n", cmd);
732#endif
733 for (cb = cap->cb_head.lh_first; cb; cb = cb->entries.le_next) {
734 cb->ops.notify (cb->opaque, cmd);
735 }
736}
737
738static void audio_capture_maybe_changed (CaptureVoiceOut *cap, int enabled)
bellard8ead62c2006-07-04 16:51:32 +0000739{
740 if (cap->hw.enabled != enabled) {
bellardec36b692006-07-16 18:57:03 +0000741 audcnotification_e cmd;
bellard8ead62c2006-07-04 16:51:32 +0000742 cap->hw.enabled = enabled;
bellardec36b692006-07-16 18:57:03 +0000743 cmd = enabled ? AUD_CNOTIFY_ENABLE : AUD_CNOTIFY_DISABLE;
744 audio_notify_capture (cap, cmd);
bellard8ead62c2006-07-04 16:51:32 +0000745 }
746}
747
748static void audio_recalc_and_notify_capture (CaptureVoiceOut *cap)
749{
750 HWVoiceOut *hw = &cap->hw;
751 SWVoiceOut *sw;
752 int enabled = 0;
753
bellardec36b692006-07-16 18:57:03 +0000754 for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) {
bellard8ead62c2006-07-04 16:51:32 +0000755 if (sw->active) {
756 enabled = 1;
757 break;
758 }
759 }
bellardec36b692006-07-16 18:57:03 +0000760 audio_capture_maybe_changed (cap, enabled);
bellard8ead62c2006-07-04 16:51:32 +0000761}
762
763static void audio_detach_capture (HWVoiceOut *hw)
764{
bellardec36b692006-07-16 18:57:03 +0000765 SWVoiceCap *sc = hw->cap_head.lh_first;
bellard8ead62c2006-07-04 16:51:32 +0000766
bellardec36b692006-07-16 18:57:03 +0000767 while (sc) {
768 SWVoiceCap *sc1 = sc->entries.le_next;
769 SWVoiceOut *sw = &sc->sw;
770 CaptureVoiceOut *cap = sc->cap;
771 int was_active = sw->active;
772
bellard8ead62c2006-07-04 16:51:32 +0000773 if (sw->rate) {
774 st_rate_stop (sw->rate);
775 sw->rate = NULL;
776 }
777
Blue Swirl72cf2d42009-09-12 07:36:22 +0000778 QLIST_REMOVE (sw, entries);
779 QLIST_REMOVE (sc, entries);
bellardec36b692006-07-16 18:57:03 +0000780 qemu_free (sc);
781 if (was_active) {
782 /* We have removed soft voice from the capture:
783 this might have changed the overall status of the capture
784 since this might have been the only active voice */
785 audio_recalc_and_notify_capture (cap);
786 }
787 sc = sc1;
bellard8ead62c2006-07-04 16:51:32 +0000788 }
789}
790
malc1a7dafc2009-05-14 03:11:35 +0400791static int audio_attach_capture (HWVoiceOut *hw)
bellard8ead62c2006-07-04 16:51:32 +0000792{
malc1a7dafc2009-05-14 03:11:35 +0400793 AudioState *s = &glob_audio_state;
bellard8ead62c2006-07-04 16:51:32 +0000794 CaptureVoiceOut *cap;
795
796 audio_detach_capture (hw);
797 for (cap = s->cap_head.lh_first; cap; cap = cap->entries.le_next) {
bellardec36b692006-07-16 18:57:03 +0000798 SWVoiceCap *sc;
bellard8ead62c2006-07-04 16:51:32 +0000799 SWVoiceOut *sw;
bellardec36b692006-07-16 18:57:03 +0000800 HWVoiceOut *hw_cap = &cap->hw;
bellard8ead62c2006-07-04 16:51:32 +0000801
bellardec36b692006-07-16 18:57:03 +0000802 sc = audio_calloc (AUDIO_FUNC, 1, sizeof (*sc));
803 if (!sc) {
bellard8ead62c2006-07-04 16:51:32 +0000804 dolog ("Could not allocate soft capture voice (%zu bytes)\n",
bellardec36b692006-07-16 18:57:03 +0000805 sizeof (*sc));
bellard8ead62c2006-07-04 16:51:32 +0000806 return -1;
807 }
808
bellardec36b692006-07-16 18:57:03 +0000809 sc->cap = cap;
810 sw = &sc->sw;
bellard8ead62c2006-07-04 16:51:32 +0000811 sw->hw = hw_cap;
bellardec36b692006-07-16 18:57:03 +0000812 sw->info = hw->info;
bellard8ead62c2006-07-04 16:51:32 +0000813 sw->empty = 1;
814 sw->active = hw->enabled;
815 sw->conv = noop_conv;
816 sw->ratio = ((int64_t) hw_cap->info.freq << 32) / sw->info.freq;
817 sw->rate = st_rate_start (sw->info.freq, hw_cap->info.freq);
818 if (!sw->rate) {
819 dolog ("Could not start rate conversion for `%s'\n", SW_NAME (sw));
820 qemu_free (sw);
821 return -1;
822 }
Blue Swirl72cf2d42009-09-12 07:36:22 +0000823 QLIST_INSERT_HEAD (&hw_cap->sw_head, sw, entries);
824 QLIST_INSERT_HEAD (&hw->cap_head, sc, entries);
bellardec36b692006-07-16 18:57:03 +0000825#ifdef DEBUG_CAPTURE
826 asprintf (&sw->name, "for %p %d,%d,%d",
827 hw, sw->info.freq, sw->info.bits, sw->info.nchannels);
828 dolog ("Added %s active = %d\n", sw->name, sw->active);
829#endif
bellard8ead62c2006-07-04 16:51:32 +0000830 if (sw->active) {
bellardec36b692006-07-16 18:57:03 +0000831 audio_capture_maybe_changed (cap, 1);
bellard8ead62c2006-07-04 16:51:32 +0000832 }
833 }
834 return 0;
835}
836
837/*
bellard1d14ffa2005-10-30 18:58:22 +0000838 * Hard voice (capture)
839 */
bellardc0fe3822005-11-05 18:55:28 +0000840static int audio_pcm_hw_find_min_in (HWVoiceIn *hw)
bellard85571bc2004-11-07 18:04:02 +0000841{
bellard1d14ffa2005-10-30 18:58:22 +0000842 SWVoiceIn *sw;
843 int m = hw->total_samples_captured;
bellard85571bc2004-11-07 18:04:02 +0000844
bellard1d14ffa2005-10-30 18:58:22 +0000845 for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) {
846 if (sw->active) {
847 m = audio_MIN (m, sw->total_hw_samples_acquired);
bellard85571bc2004-11-07 18:04:02 +0000848 }
849 }
bellard1d14ffa2005-10-30 18:58:22 +0000850 return m;
bellard85571bc2004-11-07 18:04:02 +0000851}
852
bellard1d14ffa2005-10-30 18:58:22 +0000853int audio_pcm_hw_get_live_in (HWVoiceIn *hw)
bellard85571bc2004-11-07 18:04:02 +0000854{
bellard1d14ffa2005-10-30 18:58:22 +0000855 int live = hw->total_samples_captured - audio_pcm_hw_find_min_in (hw);
856 if (audio_bug (AUDIO_FUNC, live < 0 || live > hw->samples)) {
857 dolog ("live=%d hw->samples=%d\n", live, hw->samples);
858 return 0;
859 }
860 return live;
861}
bellard85571bc2004-11-07 18:04:02 +0000862
malcddabec72009-09-18 10:59:38 +0400863int audio_pcm_hw_clip_out (HWVoiceOut *hw, void *pcm_buf,
864 int live, int pending)
865{
866 int left = hw->samples - pending;
867 int len = audio_MIN (left, live);
868 int clipped = 0;
869
870 while (len) {
871 struct st_sample *src = hw->mix_buf + hw->rpos;
872 uint8_t *dst = advance (pcm_buf, hw->rpos << hw->info.shift);
873 int samples_till_end_of_buf = hw->samples - hw->rpos;
874 int samples_to_clip = audio_MIN (len, samples_till_end_of_buf);
875
876 hw->clip (dst, src, samples_to_clip);
877
878 hw->rpos = (hw->rpos + samples_to_clip) % hw->samples;
879 len -= samples_to_clip;
880 clipped += samples_to_clip;
881 }
882 return clipped;
883}
884
bellard1d14ffa2005-10-30 18:58:22 +0000885/*
886 * Soft voice (capture)
887 */
bellard1d14ffa2005-10-30 18:58:22 +0000888static int audio_pcm_sw_get_rpos_in (SWVoiceIn *sw)
889{
890 HWVoiceIn *hw = sw->hw;
891 int live = hw->total_samples_captured - sw->total_hw_samples_acquired;
892 int rpos;
893
894 if (audio_bug (AUDIO_FUNC, live < 0 || live > hw->samples)) {
895 dolog ("live=%d hw->samples=%d\n", live, hw->samples);
896 return 0;
897 }
898
899 rpos = hw->wpos - live;
900 if (rpos >= 0) {
901 return rpos;
902 }
903 else {
904 return hw->samples + rpos;
bellard85571bc2004-11-07 18:04:02 +0000905 }
906}
907
bellard1d14ffa2005-10-30 18:58:22 +0000908int audio_pcm_sw_read (SWVoiceIn *sw, void *buf, int size)
bellard85571bc2004-11-07 18:04:02 +0000909{
bellard1d14ffa2005-10-30 18:58:22 +0000910 HWVoiceIn *hw = sw->hw;
911 int samples, live, ret = 0, swlim, isamp, osamp, rpos, total = 0;
malc1ea879e2008-12-03 22:48:44 +0000912 struct st_sample *src, *dst = sw->buf;
bellard85571bc2004-11-07 18:04:02 +0000913
bellard1d14ffa2005-10-30 18:58:22 +0000914 rpos = audio_pcm_sw_get_rpos_in (sw) % hw->samples;
bellard85571bc2004-11-07 18:04:02 +0000915
bellard1d14ffa2005-10-30 18:58:22 +0000916 live = hw->total_samples_captured - sw->total_hw_samples_acquired;
917 if (audio_bug (AUDIO_FUNC, live < 0 || live > hw->samples)) {
918 dolog ("live_in=%d hw->samples=%d\n", live, hw->samples);
919 return 0;
bellard85571bc2004-11-07 18:04:02 +0000920 }
bellard1d14ffa2005-10-30 18:58:22 +0000921
922 samples = size >> sw->info.shift;
923 if (!live) {
924 return 0;
925 }
926
927 swlim = (live * sw->ratio) >> 32;
bellard85571bc2004-11-07 18:04:02 +0000928 swlim = audio_MIN (swlim, samples);
929
bellard1d14ffa2005-10-30 18:58:22 +0000930 while (swlim) {
931 src = hw->conv_buf + rpos;
932 isamp = hw->wpos - rpos;
933 /* XXX: <= ? */
934 if (isamp <= 0) {
935 isamp = hw->samples - rpos;
936 }
937
938 if (!isamp) {
939 break;
940 }
941 osamp = swlim;
942
943 if (audio_bug (AUDIO_FUNC, osamp < 0)) {
944 dolog ("osamp=%d\n", osamp);
bellardc0fe3822005-11-05 18:55:28 +0000945 return 0;
bellard1d14ffa2005-10-30 18:58:22 +0000946 }
947
948 st_rate_flow (sw->rate, src, dst, &isamp, &osamp);
949 swlim -= osamp;
950 rpos = (rpos + isamp) % hw->samples;
951 dst += osamp;
952 ret += osamp;
953 total += isamp;
954 }
955
bellard571ec3d2005-11-20 16:24:34 +0000956 sw->clip (buf, sw->buf, ret);
bellard1d14ffa2005-10-30 18:58:22 +0000957 sw->total_hw_samples_acquired += total;
958 return ret << sw->info.shift;
959}
960
961/*
962 * Hard voice (playback)
963 */
964static int audio_pcm_hw_find_min_out (HWVoiceOut *hw, int *nb_livep)
965{
966 SWVoiceOut *sw;
967 int m = INT_MAX;
968 int nb_live = 0;
969
970 for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) {
971 if (sw->active || !sw->empty) {
972 m = audio_MIN (m, sw->total_hw_samples_mixed);
973 nb_live += 1;
974 }
975 }
976
977 *nb_livep = nb_live;
978 return m;
979}
980
malcbdff2532009-09-18 11:37:39 +0400981static int audio_pcm_hw_get_live_out (HWVoiceOut *hw, int *nb_live)
bellard1d14ffa2005-10-30 18:58:22 +0000982{
983 int smin;
malcbdff2532009-09-18 11:37:39 +0400984 int nb_live1;
bellard1d14ffa2005-10-30 18:58:22 +0000985
malcbdff2532009-09-18 11:37:39 +0400986 smin = audio_pcm_hw_find_min_out (hw, &nb_live1);
987 if (nb_live) {
988 *nb_live = nb_live1;
bellard1d14ffa2005-10-30 18:58:22 +0000989 }
malcbdff2532009-09-18 11:37:39 +0400990
991 if (nb_live1) {
bellard1d14ffa2005-10-30 18:58:22 +0000992 int live = smin;
993
994 if (audio_bug (AUDIO_FUNC, live < 0 || live > hw->samples)) {
995 dolog ("live=%d hw->samples=%d\n", live, hw->samples);
996 return 0;
997 }
998 return live;
999 }
malcbdff2532009-09-18 11:37:39 +04001000 return 0;
bellard1d14ffa2005-10-30 18:58:22 +00001001}
1002
1003/*
1004 * Soft voice (playback)
1005 */
bellard1d14ffa2005-10-30 18:58:22 +00001006int audio_pcm_sw_write (SWVoiceOut *sw, void *buf, int size)
1007{
1008 int hwsamples, samples, isamp, osamp, wpos, live, dead, left, swlim, blck;
1009 int ret = 0, pos = 0, total = 0;
1010
1011 if (!sw) {
1012 return size;
1013 }
1014
1015 hwsamples = sw->hw->samples;
1016
1017 live = sw->total_hw_samples_mixed;
1018 if (audio_bug (AUDIO_FUNC, live < 0 || live > hwsamples)){
1019 dolog ("live=%d hw->samples=%d\n", live, hwsamples);
1020 return 0;
1021 }
1022
1023 if (live == hwsamples) {
bellardec36b692006-07-16 18:57:03 +00001024#ifdef DEBUG_OUT
1025 dolog ("%s is full %d\n", sw->name, live);
1026#endif
bellard1d14ffa2005-10-30 18:58:22 +00001027 return 0;
1028 }
1029
1030 wpos = (sw->hw->rpos + live) % hwsamples;
1031 samples = size >> sw->info.shift;
1032
1033 dead = hwsamples - live;
1034 swlim = ((int64_t) dead << 32) / sw->ratio;
1035 swlim = audio_MIN (swlim, samples);
1036 if (swlim) {
1037 sw->conv (sw->buf, buf, swlim, &sw->vol);
1038 }
bellard85571bc2004-11-07 18:04:02 +00001039
1040 while (swlim) {
1041 dead = hwsamples - live;
1042 left = hwsamples - wpos;
1043 blck = audio_MIN (dead, left);
1044 if (!blck) {
bellard85571bc2004-11-07 18:04:02 +00001045 break;
1046 }
1047 isamp = swlim;
1048 osamp = blck;
bellard1d14ffa2005-10-30 18:58:22 +00001049 st_rate_flow_mix (
1050 sw->rate,
1051 sw->buf + pos,
1052 sw->hw->mix_buf + wpos,
1053 &isamp,
1054 &osamp
1055 );
bellard85571bc2004-11-07 18:04:02 +00001056 ret += isamp;
1057 swlim -= isamp;
1058 pos += isamp;
1059 live += osamp;
1060 wpos = (wpos + osamp) % hwsamples;
bellard1d14ffa2005-10-30 18:58:22 +00001061 total += osamp;
bellard85571bc2004-11-07 18:04:02 +00001062 }
1063
bellard1d14ffa2005-10-30 18:58:22 +00001064 sw->total_hw_samples_mixed += total;
1065 sw->empty = sw->total_hw_samples_mixed == 0;
1066
1067#ifdef DEBUG_OUT
1068 dolog (
bellardc0fe3822005-11-05 18:55:28 +00001069 "%s: write size %d ret %d total sw %d\n",
1070 SW_NAME (sw),
bellard1d14ffa2005-10-30 18:58:22 +00001071 size >> sw->info.shift,
1072 ret,
bellardc0fe3822005-11-05 18:55:28 +00001073 sw->total_hw_samples_mixed
bellard1d14ffa2005-10-30 18:58:22 +00001074 );
1075#endif
1076
1077 return ret << sw->info.shift;
bellard85571bc2004-11-07 18:04:02 +00001078}
1079
bellard1d14ffa2005-10-30 18:58:22 +00001080#ifdef DEBUG_AUDIO
1081static void audio_pcm_print_info (const char *cap, struct audio_pcm_info *info)
bellard85571bc2004-11-07 18:04:02 +00001082{
bellard1d14ffa2005-10-30 18:58:22 +00001083 dolog ("%s: bits %d, sign %d, freq %d, nchan %d\n",
1084 cap, info->bits, info->sign, info->freq, info->nchannels);
bellard85571bc2004-11-07 18:04:02 +00001085}
bellard1d14ffa2005-10-30 18:58:22 +00001086#endif
bellard85571bc2004-11-07 18:04:02 +00001087
bellard1d14ffa2005-10-30 18:58:22 +00001088#define DAC
1089#include "audio_template.h"
1090#undef DAC
1091#include "audio_template.h"
bellard85571bc2004-11-07 18:04:02 +00001092
malc713a98f2009-09-12 02:28:45 +04001093/*
1094 * Timer
1095 */
1096static void audio_timer (void *opaque)
1097{
1098 AudioState *s = opaque;
1099
1100 audio_run ("timer");
1101 qemu_mod_timer (s->ts, qemu_get_clock (vm_clock) + conf.period.ticks);
1102}
1103
1104
1105static int audio_is_timer_needed (void)
1106{
1107 HWVoiceIn *hwi = NULL;
1108 HWVoiceOut *hwo = NULL;
1109
1110 while ((hwo = audio_pcm_hw_find_any_enabled_out (hwo))) {
1111 if (!hwo->poll_mode) return 1;
1112 }
1113 while ((hwi = audio_pcm_hw_find_any_enabled_in (hwi))) {
1114 if (!hwi->poll_mode) return 1;
1115 }
1116 return 0;
1117}
1118
1119static void audio_reset_timer (void)
1120{
1121 AudioState *s = &glob_audio_state;
1122
1123 if (audio_is_timer_needed ()) {
1124 qemu_mod_timer (s->ts, qemu_get_clock (vm_clock) + 1);
1125 }
1126 else {
1127 qemu_del_timer (s->ts);
1128 }
1129}
1130
1131/*
1132 * Public API
1133 */
bellard1d14ffa2005-10-30 18:58:22 +00001134int AUD_write (SWVoiceOut *sw, void *buf, int size)
bellard85571bc2004-11-07 18:04:02 +00001135{
1136 int bytes;
1137
bellard1d14ffa2005-10-30 18:58:22 +00001138 if (!sw) {
1139 /* XXX: Consider options */
1140 return size;
1141 }
1142
1143 if (!sw->hw->enabled) {
bellardc0fe3822005-11-05 18:55:28 +00001144 dolog ("Writing to disabled voice %s\n", SW_NAME (sw));
bellard1d14ffa2005-10-30 18:58:22 +00001145 return 0;
1146 }
1147
bellard85571bc2004-11-07 18:04:02 +00001148 bytes = sw->hw->pcm_ops->write (sw, buf, size);
1149 return bytes;
1150}
1151
bellard1d14ffa2005-10-30 18:58:22 +00001152int AUD_read (SWVoiceIn *sw, void *buf, int size)
bellard85571bc2004-11-07 18:04:02 +00001153{
bellard1d14ffa2005-10-30 18:58:22 +00001154 int bytes;
bellard85571bc2004-11-07 18:04:02 +00001155
bellard1d14ffa2005-10-30 18:58:22 +00001156 if (!sw) {
1157 /* XXX: Consider options */
1158 return size;
bellard85571bc2004-11-07 18:04:02 +00001159 }
bellard1d14ffa2005-10-30 18:58:22 +00001160
1161 if (!sw->hw->enabled) {
bellardc0fe3822005-11-05 18:55:28 +00001162 dolog ("Reading from disabled voice %s\n", SW_NAME (sw));
bellard1d14ffa2005-10-30 18:58:22 +00001163 return 0;
1164 }
1165
1166 bytes = sw->hw->pcm_ops->read (sw, buf, size);
1167 return bytes;
bellard85571bc2004-11-07 18:04:02 +00001168}
1169
bellard1d14ffa2005-10-30 18:58:22 +00001170int AUD_get_buffer_size_out (SWVoiceOut *sw)
bellard85571bc2004-11-07 18:04:02 +00001171{
bellardc0fe3822005-11-05 18:55:28 +00001172 return sw->hw->samples << sw->hw->info.shift;
bellard85571bc2004-11-07 18:04:02 +00001173}
1174
bellard1d14ffa2005-10-30 18:58:22 +00001175void AUD_set_active_out (SWVoiceOut *sw, int on)
bellard85571bc2004-11-07 18:04:02 +00001176{
bellard1d14ffa2005-10-30 18:58:22 +00001177 HWVoiceOut *hw;
1178
1179 if (!sw) {
bellard85571bc2004-11-07 18:04:02 +00001180 return;
bellard85571bc2004-11-07 18:04:02 +00001181 }
1182
bellard85571bc2004-11-07 18:04:02 +00001183 hw = sw->hw;
bellard85571bc2004-11-07 18:04:02 +00001184 if (sw->active != on) {
malc978dd632009-02-18 20:44:04 +00001185 AudioState *s = &glob_audio_state;
bellard1d14ffa2005-10-30 18:58:22 +00001186 SWVoiceOut *temp_sw;
bellardec36b692006-07-16 18:57:03 +00001187 SWVoiceCap *sc;
bellard1d14ffa2005-10-30 18:58:22 +00001188
bellard85571bc2004-11-07 18:04:02 +00001189 if (on) {
1190 hw->pending_disable = 0;
1191 if (!hw->enabled) {
1192 hw->enabled = 1;
malc978dd632009-02-18 20:44:04 +00001193 if (s->vm_running) {
malc713a98f2009-09-12 02:28:45 +04001194 hw->pcm_ops->ctl_out (hw, VOICE_ENABLE, conf.try_poll_out);
1195 audio_reset_timer ();
malc978dd632009-02-18 20:44:04 +00001196 }
bellard1d14ffa2005-10-30 18:58:22 +00001197 }
bellard85571bc2004-11-07 18:04:02 +00001198 }
1199 else {
bellard1d14ffa2005-10-30 18:58:22 +00001200 if (hw->enabled) {
bellard85571bc2004-11-07 18:04:02 +00001201 int nb_active = 0;
bellard1d14ffa2005-10-30 18:58:22 +00001202
1203 for (temp_sw = hw->sw_head.lh_first; temp_sw;
1204 temp_sw = temp_sw->entries.le_next) {
1205 nb_active += temp_sw->active != 0;
1206 }
1207
1208 hw->pending_disable = nb_active == 1;
1209 }
1210 }
bellardec36b692006-07-16 18:57:03 +00001211
1212 for (sc = hw->cap_head.lh_first; sc; sc = sc->entries.le_next) {
1213 sc->sw.active = hw->enabled;
bellard8ead62c2006-07-04 16:51:32 +00001214 if (hw->enabled) {
bellardec36b692006-07-16 18:57:03 +00001215 audio_capture_maybe_changed (sc->cap, 1);
bellard8ead62c2006-07-04 16:51:32 +00001216 }
1217 }
bellard1d14ffa2005-10-30 18:58:22 +00001218 sw->active = on;
1219 }
1220}
1221
1222void AUD_set_active_in (SWVoiceIn *sw, int on)
1223{
1224 HWVoiceIn *hw;
1225
1226 if (!sw) {
1227 return;
1228 }
1229
1230 hw = sw->hw;
1231 if (sw->active != on) {
malc978dd632009-02-18 20:44:04 +00001232 AudioState *s = &glob_audio_state;
bellard1d14ffa2005-10-30 18:58:22 +00001233 SWVoiceIn *temp_sw;
1234
1235 if (on) {
1236 if (!hw->enabled) {
1237 hw->enabled = 1;
malc978dd632009-02-18 20:44:04 +00001238 if (s->vm_running) {
malc713a98f2009-09-12 02:28:45 +04001239 hw->pcm_ops->ctl_in (hw, VOICE_ENABLE, conf.try_poll_in);
malc978dd632009-02-18 20:44:04 +00001240 }
bellard1d14ffa2005-10-30 18:58:22 +00001241 }
1242 sw->total_hw_samples_acquired = hw->total_samples_captured;
1243 }
1244 else {
1245 if (hw->enabled) {
1246 int nb_active = 0;
1247
1248 for (temp_sw = hw->sw_head.lh_first; temp_sw;
1249 temp_sw = temp_sw->entries.le_next) {
1250 nb_active += temp_sw->active != 0;
bellard85571bc2004-11-07 18:04:02 +00001251 }
1252
1253 if (nb_active == 1) {
bellard1d14ffa2005-10-30 18:58:22 +00001254 hw->enabled = 0;
1255 hw->pcm_ops->ctl_in (hw, VOICE_DISABLE);
bellard85571bc2004-11-07 18:04:02 +00001256 }
1257 }
1258 }
1259 sw->active = on;
1260 }
1261}
1262
bellard1d14ffa2005-10-30 18:58:22 +00001263static int audio_get_avail (SWVoiceIn *sw)
bellard85571bc2004-11-07 18:04:02 +00001264{
bellard1d14ffa2005-10-30 18:58:22 +00001265 int live;
1266
1267 if (!sw) {
1268 return 0;
1269 }
1270
1271 live = sw->hw->total_samples_captured - sw->total_hw_samples_acquired;
1272 if (audio_bug (AUDIO_FUNC, live < 0 || live > sw->hw->samples)) {
1273 dolog ("live=%d sw->hw->samples=%d\n", live, sw->hw->samples);
1274 return 0;
1275 }
1276
1277 ldebug (
bellard26a76462006-06-25 18:15:32 +00001278 "%s: get_avail live %d ret %" PRId64 "\n",
bellardc0fe3822005-11-05 18:55:28 +00001279 SW_NAME (sw),
bellard1d14ffa2005-10-30 18:58:22 +00001280 live, (((int64_t) live << 32) / sw->ratio) << sw->info.shift
1281 );
1282
1283 return (((int64_t) live << 32) / sw->ratio) << sw->info.shift;
1284}
1285
1286static int audio_get_free (SWVoiceOut *sw)
1287{
1288 int live, dead;
1289
1290 if (!sw) {
1291 return 0;
1292 }
1293
1294 live = sw->total_hw_samples_mixed;
1295
1296 if (audio_bug (AUDIO_FUNC, live < 0 || live > sw->hw->samples)) {
1297 dolog ("live=%d sw->hw->samples=%d\n", live, sw->hw->samples);
bellardc0fe3822005-11-05 18:55:28 +00001298 return 0;
bellard1d14ffa2005-10-30 18:58:22 +00001299 }
1300
1301 dead = sw->hw->samples - live;
1302
1303#ifdef DEBUG_OUT
bellard26a76462006-06-25 18:15:32 +00001304 dolog ("%s: get_free live %d dead %d ret %" PRId64 "\n",
bellardc0fe3822005-11-05 18:55:28 +00001305 SW_NAME (sw),
bellard1d14ffa2005-10-30 18:58:22 +00001306 live, dead, (((int64_t) dead << 32) / sw->ratio) << sw->info.shift);
1307#endif
1308
1309 return (((int64_t) dead << 32) / sw->ratio) << sw->info.shift;
1310}
1311
bellard8ead62c2006-07-04 16:51:32 +00001312static void audio_capture_mix_and_clear (HWVoiceOut *hw, int rpos, int samples)
1313{
1314 int n;
1315
1316 if (hw->enabled) {
bellardec36b692006-07-16 18:57:03 +00001317 SWVoiceCap *sc;
bellard8ead62c2006-07-04 16:51:32 +00001318
bellardec36b692006-07-16 18:57:03 +00001319 for (sc = hw->cap_head.lh_first; sc; sc = sc->entries.le_next) {
1320 SWVoiceOut *sw = &sc->sw;
bellard8ead62c2006-07-04 16:51:32 +00001321 int rpos2 = rpos;
1322
1323 n = samples;
1324 while (n) {
1325 int till_end_of_hw = hw->samples - rpos2;
1326 int to_write = audio_MIN (till_end_of_hw, n);
1327 int bytes = to_write << hw->info.shift;
1328 int written;
1329
1330 sw->buf = hw->mix_buf + rpos2;
1331 written = audio_pcm_sw_write (sw, NULL, bytes);
1332 if (written - bytes) {
bellardec36b692006-07-16 18:57:03 +00001333 dolog ("Could not mix %d bytes into a capture "
1334 "buffer, mixed %d\n",
1335 bytes, written);
bellard8ead62c2006-07-04 16:51:32 +00001336 break;
1337 }
1338 n -= to_write;
1339 rpos2 = (rpos2 + to_write) % hw->samples;
1340 }
1341 }
1342 }
1343
1344 n = audio_MIN (samples, hw->samples - rpos);
1345 mixeng_clear (hw->mix_buf + rpos, n);
1346 mixeng_clear (hw->mix_buf, samples - n);
1347}
1348
bellardc0fe3822005-11-05 18:55:28 +00001349static void audio_run_out (AudioState *s)
bellard1d14ffa2005-10-30 18:58:22 +00001350{
1351 HWVoiceOut *hw = NULL;
1352 SWVoiceOut *sw;
1353
malc1a7dafc2009-05-14 03:11:35 +04001354 while ((hw = audio_pcm_hw_find_any_enabled_out (hw))) {
bellard1d14ffa2005-10-30 18:58:22 +00001355 int played;
bellard8ead62c2006-07-04 16:51:32 +00001356 int live, free, nb_live, cleanup_required, prev_rpos;
bellard1d14ffa2005-10-30 18:58:22 +00001357
malcbdff2532009-09-18 11:37:39 +04001358 live = audio_pcm_hw_get_live_out (hw, &nb_live);
bellard1d14ffa2005-10-30 18:58:22 +00001359 if (!nb_live) {
1360 live = 0;
bellard85571bc2004-11-07 18:04:02 +00001361 }
bellardc0fe3822005-11-05 18:55:28 +00001362
bellard1d14ffa2005-10-30 18:58:22 +00001363 if (audio_bug (AUDIO_FUNC, live < 0 || live > hw->samples)) {
1364 dolog ("live=%d hw->samples=%d\n", live, hw->samples);
bellardc0fe3822005-11-05 18:55:28 +00001365 continue;
bellard85571bc2004-11-07 18:04:02 +00001366 }
bellard1d14ffa2005-10-30 18:58:22 +00001367
1368 if (hw->pending_disable && !nb_live) {
bellardec36b692006-07-16 18:57:03 +00001369 SWVoiceCap *sc;
bellard1d14ffa2005-10-30 18:58:22 +00001370#ifdef DEBUG_OUT
1371 dolog ("Disabling voice\n");
1372#endif
1373 hw->enabled = 0;
1374 hw->pending_disable = 0;
1375 hw->pcm_ops->ctl_out (hw, VOICE_DISABLE);
bellardec36b692006-07-16 18:57:03 +00001376 for (sc = hw->cap_head.lh_first; sc; sc = sc->entries.le_next) {
1377 sc->sw.active = 0;
1378 audio_recalc_and_notify_capture (sc->cap);
bellard8ead62c2006-07-04 16:51:32 +00001379 }
bellard1d14ffa2005-10-30 18:58:22 +00001380 continue;
1381 }
1382
1383 if (!live) {
1384 for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) {
1385 if (sw->active) {
1386 free = audio_get_free (sw);
1387 if (free > 0) {
1388 sw->callback.fn (sw->callback.opaque, free);
1389 }
1390 }
1391 }
1392 continue;
1393 }
1394
bellard8ead62c2006-07-04 16:51:32 +00001395 prev_rpos = hw->rpos;
malcbdff2532009-09-18 11:37:39 +04001396 played = hw->pcm_ops->run_out (hw, live);
bellard1d14ffa2005-10-30 18:58:22 +00001397 if (audio_bug (AUDIO_FUNC, hw->rpos >= hw->samples)) {
1398 dolog ("hw->rpos=%d hw->samples=%d played=%d\n",
1399 hw->rpos, hw->samples, played);
1400 hw->rpos = 0;
1401 }
1402
1403#ifdef DEBUG_OUT
bellardc0fe3822005-11-05 18:55:28 +00001404 dolog ("played=%d\n", played);
bellard1d14ffa2005-10-30 18:58:22 +00001405#endif
1406
1407 if (played) {
1408 hw->ts_helper += played;
bellard8ead62c2006-07-04 16:51:32 +00001409 audio_capture_mix_and_clear (hw, prev_rpos, played);
bellard1d14ffa2005-10-30 18:58:22 +00001410 }
1411
bellardc0fe3822005-11-05 18:55:28 +00001412 cleanup_required = 0;
bellard1d14ffa2005-10-30 18:58:22 +00001413 for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) {
bellard1d14ffa2005-10-30 18:58:22 +00001414 if (!sw->active && sw->empty) {
1415 continue;
1416 }
1417
1418 if (audio_bug (AUDIO_FUNC, played > sw->total_hw_samples_mixed)) {
1419 dolog ("played=%d sw->total_hw_samples_mixed=%d\n",
1420 played, sw->total_hw_samples_mixed);
1421 played = sw->total_hw_samples_mixed;
1422 }
1423
1424 sw->total_hw_samples_mixed -= played;
1425
1426 if (!sw->total_hw_samples_mixed) {
1427 sw->empty = 1;
bellardc0fe3822005-11-05 18:55:28 +00001428 cleanup_required |= !sw->active && !sw->callback.fn;
bellard1d14ffa2005-10-30 18:58:22 +00001429 }
1430
1431 if (sw->active) {
1432 free = audio_get_free (sw);
1433 if (free > 0) {
1434 sw->callback.fn (sw->callback.opaque, free);
1435 }
1436 }
bellard85571bc2004-11-07 18:04:02 +00001437 }
bellardc0fe3822005-11-05 18:55:28 +00001438
1439 if (cleanup_required) {
bellardec36b692006-07-16 18:57:03 +00001440 SWVoiceOut *sw1;
1441
1442 sw = hw->sw_head.lh_first;
1443 while (sw) {
1444 sw1 = sw->entries.le_next;
bellardc0fe3822005-11-05 18:55:28 +00001445 if (!sw->active && !sw->callback.fn) {
1446#ifdef DEBUG_PLIVE
1447 dolog ("Finishing with old voice\n");
1448#endif
malc1a7dafc2009-05-14 03:11:35 +04001449 audio_close_out (sw);
bellardc0fe3822005-11-05 18:55:28 +00001450 }
bellardec36b692006-07-16 18:57:03 +00001451 sw = sw1;
bellardc0fe3822005-11-05 18:55:28 +00001452 }
1453 }
bellard85571bc2004-11-07 18:04:02 +00001454 }
bellard1d14ffa2005-10-30 18:58:22 +00001455}
1456
bellardc0fe3822005-11-05 18:55:28 +00001457static void audio_run_in (AudioState *s)
bellard1d14ffa2005-10-30 18:58:22 +00001458{
1459 HWVoiceIn *hw = NULL;
1460
malc1a7dafc2009-05-14 03:11:35 +04001461 while ((hw = audio_pcm_hw_find_any_enabled_in (hw))) {
bellard1d14ffa2005-10-30 18:58:22 +00001462 SWVoiceIn *sw;
1463 int captured, min;
1464
1465 captured = hw->pcm_ops->run_in (hw);
1466
1467 min = audio_pcm_hw_find_min_in (hw);
1468 hw->total_samples_captured += captured - min;
1469 hw->ts_helper += captured;
1470
1471 for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) {
1472 sw->total_hw_samples_acquired -= min;
1473
1474 if (sw->active) {
1475 int avail;
1476
1477 avail = audio_get_avail (sw);
1478 if (avail > 0) {
1479 sw->callback.fn (sw->callback.opaque, avail);
1480 }
1481 }
1482 }
1483 }
1484}
1485
bellard8ead62c2006-07-04 16:51:32 +00001486static void audio_run_capture (AudioState *s)
1487{
1488 CaptureVoiceOut *cap;
1489
1490 for (cap = s->cap_head.lh_first; cap; cap = cap->entries.le_next) {
1491 int live, rpos, captured;
1492 HWVoiceOut *hw = &cap->hw;
1493 SWVoiceOut *sw;
1494
malcbdff2532009-09-18 11:37:39 +04001495 captured = live = audio_pcm_hw_get_live_out (hw, NULL);
bellard8ead62c2006-07-04 16:51:32 +00001496 rpos = hw->rpos;
1497 while (live) {
1498 int left = hw->samples - rpos;
1499 int to_capture = audio_MIN (live, left);
malc1ea879e2008-12-03 22:48:44 +00001500 struct st_sample *src;
bellard8ead62c2006-07-04 16:51:32 +00001501 struct capture_callback *cb;
1502
1503 src = hw->mix_buf + rpos;
1504 hw->clip (cap->buf, src, to_capture);
1505 mixeng_clear (src, to_capture);
1506
1507 for (cb = cap->cb_head.lh_first; cb; cb = cb->entries.le_next) {
1508 cb->ops.capture (cb->opaque, cap->buf,
1509 to_capture << hw->info.shift);
1510 }
1511 rpos = (rpos + to_capture) % hw->samples;
1512 live -= to_capture;
1513 }
1514 hw->rpos = rpos;
1515
1516 for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) {
1517 if (!sw->active && sw->empty) {
1518 continue;
1519 }
1520
1521 if (audio_bug (AUDIO_FUNC, captured > sw->total_hw_samples_mixed)) {
1522 dolog ("captured=%d sw->total_hw_samples_mixed=%d\n",
1523 captured, sw->total_hw_samples_mixed);
1524 captured = sw->total_hw_samples_mixed;
1525 }
1526
1527 sw->total_hw_samples_mixed -= captured;
1528 sw->empty = sw->total_hw_samples_mixed == 0;
1529 }
1530 }
1531}
1532
malc713a98f2009-09-12 02:28:45 +04001533void audio_run (const char *msg)
bellard571ec3d2005-11-20 16:24:34 +00001534{
malc713a98f2009-09-12 02:28:45 +04001535 AudioState *s = &glob_audio_state;
bellard571ec3d2005-11-20 16:24:34 +00001536
1537 audio_run_out (s);
1538 audio_run_in (s);
bellard8ead62c2006-07-04 16:51:32 +00001539 audio_run_capture (s);
malc713a98f2009-09-12 02:28:45 +04001540#ifdef DEBUG_POLL
1541 {
1542 static double prevtime;
1543 double currtime;
1544 struct timeval tv;
bellard571ec3d2005-11-20 16:24:34 +00001545
malc713a98f2009-09-12 02:28:45 +04001546 if (gettimeofday (&tv, NULL)) {
1547 perror ("audio_run: gettimeofday");
1548 return;
1549 }
1550
1551 currtime = tv.tv_sec + tv.tv_usec * 1e-6;
1552 dolog ("Elapsed since last %s: %f\n", msg, currtime - prevtime);
1553 prevtime = currtime;
1554 }
1555#endif
bellard571ec3d2005-11-20 16:24:34 +00001556}
1557
bellard1d14ffa2005-10-30 18:58:22 +00001558static struct audio_option audio_options[] = {
1559 /* DAC */
malc98f9f482009-08-11 20:48:02 +04001560 {
1561 .name = "DAC_FIXED_SETTINGS",
1562 .tag = AUD_OPT_BOOL,
1563 .valp = &conf.fixed_out.enabled,
1564 .descr = "Use fixed settings for host DAC"
1565 },
1566 {
1567 .name = "DAC_FIXED_FREQ",
1568 .tag = AUD_OPT_INT,
1569 .valp = &conf.fixed_out.settings.freq,
1570 .descr = "Frequency for fixed host DAC"
1571 },
1572 {
1573 .name = "DAC_FIXED_FMT",
1574 .tag = AUD_OPT_FMT,
1575 .valp = &conf.fixed_out.settings.fmt,
1576 .descr = "Format for fixed host DAC"
1577 },
1578 {
1579 .name = "DAC_FIXED_CHANNELS",
1580 .tag = AUD_OPT_INT,
1581 .valp = &conf.fixed_out.settings.nchannels,
1582 .descr = "Number of channels for fixed DAC (1 - mono, 2 - stereo)"
1583 },
1584 {
1585 .name = "DAC_VOICES",
1586 .tag = AUD_OPT_INT,
1587 .valp = &conf.fixed_out.nb_voices,
1588 .descr = "Number of voices for DAC"
1589 },
malc713a98f2009-09-12 02:28:45 +04001590 {
1591 .name = "DAC_TRY_POLL",
1592 .tag = AUD_OPT_BOOL,
1593 .valp = &conf.try_poll_out,
1594 .descr = "Attempt using poll mode for DAC"
1595 },
bellard1d14ffa2005-10-30 18:58:22 +00001596 /* ADC */
malc98f9f482009-08-11 20:48:02 +04001597 {
1598 .name = "ADC_FIXED_SETTINGS",
1599 .tag = AUD_OPT_BOOL,
1600 .valp = &conf.fixed_in.enabled,
1601 .descr = "Use fixed settings for host ADC"
1602 },
1603 {
1604 .name = "ADC_FIXED_FREQ",
1605 .tag = AUD_OPT_INT,
1606 .valp = &conf.fixed_in.settings.freq,
1607 .descr = "Frequency for fixed host ADC"
1608 },
1609 {
1610 .name = "ADC_FIXED_FMT",
1611 .tag = AUD_OPT_FMT,
1612 .valp = &conf.fixed_in.settings.fmt,
1613 .descr = "Format for fixed host ADC"
1614 },
1615 {
1616 .name = "ADC_FIXED_CHANNELS",
1617 .tag = AUD_OPT_INT,
1618 .valp = &conf.fixed_in.settings.nchannels,
1619 .descr = "Number of channels for fixed ADC (1 - mono, 2 - stereo)"
1620 },
1621 {
1622 .name = "ADC_VOICES",
1623 .tag = AUD_OPT_INT,
1624 .valp = &conf.fixed_in.nb_voices,
1625 .descr = "Number of voices for ADC"
1626 },
malc713a98f2009-09-12 02:28:45 +04001627 {
1628 .name = "ADC_TRY_POLL",
1629 .tag = AUD_OPT_BOOL,
Jan Kiszka0a90e342009-09-13 22:24:46 +04001630 .valp = &conf.try_poll_in,
malc713a98f2009-09-12 02:28:45 +04001631 .descr = "Attempt using poll mode for ADC"
1632 },
bellard1d14ffa2005-10-30 18:58:22 +00001633 /* Misc */
malc98f9f482009-08-11 20:48:02 +04001634 {
1635 .name = "TIMER_PERIOD",
1636 .tag = AUD_OPT_INT,
1637 .valp = &conf.period.hertz,
1638 .descr = "Timer period in HZ (0 - use lowest possible)"
1639 },
1640 {
1641 .name = "PLIVE",
1642 .tag = AUD_OPT_BOOL,
1643 .valp = &conf.plive,
1644 .descr = "(undocumented)"
1645 },
1646 {
1647 .name = "LOG_TO_MONITOR",
1648 .tag = AUD_OPT_BOOL,
1649 .valp = &conf.log_to_monitor,
malc713a98f2009-09-12 02:28:45 +04001650 .descr = "Print logging messages to monitor instead of stderr"
malc98f9f482009-08-11 20:48:02 +04001651 },
Juan Quintela2700efa2009-08-11 02:31:16 +02001652 { /* End of list */ }
bellard1d14ffa2005-10-30 18:58:22 +00001653};
1654
bellard571ec3d2005-11-20 16:24:34 +00001655static void audio_pp_nb_voices (const char *typ, int nb)
1656{
1657 switch (nb) {
1658 case 0:
1659 printf ("Does not support %s\n", typ);
1660 break;
1661 case 1:
1662 printf ("One %s voice\n", typ);
1663 break;
1664 case INT_MAX:
1665 printf ("Theoretically supports many %s voices\n", typ);
1666 break;
1667 default:
1668 printf ("Theoretically supports upto %d %s voices\n", nb, typ);
1669 break;
1670 }
1671
1672}
1673
bellard1d14ffa2005-10-30 18:58:22 +00001674void AUD_help (void)
1675{
1676 size_t i;
1677
1678 audio_process_options ("AUDIO", audio_options);
malcb1503cd2008-12-22 20:33:55 +00001679 for (i = 0; i < ARRAY_SIZE (drvtab); i++) {
bellard1d14ffa2005-10-30 18:58:22 +00001680 struct audio_driver *d = drvtab[i];
1681 if (d->options) {
1682 audio_process_options (d->name, d->options);
1683 }
1684 }
1685
1686 printf ("Audio options:\n");
1687 audio_print_options ("AUDIO", audio_options);
1688 printf ("\n");
1689
1690 printf ("Available drivers:\n");
1691
malcb1503cd2008-12-22 20:33:55 +00001692 for (i = 0; i < ARRAY_SIZE (drvtab); i++) {
bellard1d14ffa2005-10-30 18:58:22 +00001693 struct audio_driver *d = drvtab[i];
1694
1695 printf ("Name: %s\n", d->name);
1696 printf ("Description: %s\n", d->descr);
1697
bellard571ec3d2005-11-20 16:24:34 +00001698 audio_pp_nb_voices ("playback", d->max_voices_out);
1699 audio_pp_nb_voices ("capture", d->max_voices_in);
bellard1d14ffa2005-10-30 18:58:22 +00001700
1701 if (d->options) {
1702 printf ("Options:\n");
1703 audio_print_options (d->name, d->options);
1704 }
1705 else {
1706 printf ("No options\n");
1707 }
1708 printf ("\n");
1709 }
1710
1711 printf (
1712 "Options are settable through environment variables.\n"
1713 "Example:\n"
1714#ifdef _WIN32
1715 " set QEMU_AUDIO_DRV=wav\n"
bellard571ec3d2005-11-20 16:24:34 +00001716 " set QEMU_WAV_PATH=c:\\tune.wav\n"
bellard1d14ffa2005-10-30 18:58:22 +00001717#else
1718 " export QEMU_AUDIO_DRV=wav\n"
1719 " export QEMU_WAV_PATH=$HOME/tune.wav\n"
1720 "(for csh replace export with setenv in the above)\n"
1721#endif
1722 " qemu ...\n\n"
1723 );
1724}
1725
bellardc0fe3822005-11-05 18:55:28 +00001726static int audio_driver_init (AudioState *s, struct audio_driver *drv)
bellard1d14ffa2005-10-30 18:58:22 +00001727{
1728 if (drv->options) {
1729 audio_process_options (drv->name, drv->options);
1730 }
bellardc0fe3822005-11-05 18:55:28 +00001731 s->drv_opaque = drv->init ();
bellard1d14ffa2005-10-30 18:58:22 +00001732
bellardc0fe3822005-11-05 18:55:28 +00001733 if (s->drv_opaque) {
malc1a7dafc2009-05-14 03:11:35 +04001734 audio_init_nb_voices_out (drv);
1735 audio_init_nb_voices_in (drv);
bellardc0fe3822005-11-05 18:55:28 +00001736 s->drv = drv;
bellard85571bc2004-11-07 18:04:02 +00001737 return 0;
1738 }
bellard1d14ffa2005-10-30 18:58:22 +00001739 else {
1740 dolog ("Could not init `%s' audio driver\n", drv->name);
1741 return -1;
1742 }
bellard85571bc2004-11-07 18:04:02 +00001743}
1744
aliguori9781e042009-01-22 17:15:29 +00001745static void audio_vm_change_state_handler (void *opaque, int running,
1746 int reason)
bellard85571bc2004-11-07 18:04:02 +00001747{
bellardc0fe3822005-11-05 18:55:28 +00001748 AudioState *s = opaque;
bellard1d14ffa2005-10-30 18:58:22 +00001749 HWVoiceOut *hwo = NULL;
1750 HWVoiceIn *hwi = NULL;
bellard541e0842005-11-11 00:04:19 +00001751 int op = running ? VOICE_ENABLE : VOICE_DISABLE;
bellard85571bc2004-11-07 18:04:02 +00001752
malc978dd632009-02-18 20:44:04 +00001753 s->vm_running = running;
malc1a7dafc2009-05-14 03:11:35 +04001754 while ((hwo = audio_pcm_hw_find_any_enabled_out (hwo))) {
malc713a98f2009-09-12 02:28:45 +04001755 hwo->pcm_ops->ctl_out (hwo, op, conf.try_poll_out);
bellard1d14ffa2005-10-30 18:58:22 +00001756 }
1757
malc1a7dafc2009-05-14 03:11:35 +04001758 while ((hwi = audio_pcm_hw_find_any_enabled_in (hwi))) {
malc713a98f2009-09-12 02:28:45 +04001759 hwi->pcm_ops->ctl_in (hwi, op, conf.try_poll_in);
bellard85571bc2004-11-07 18:04:02 +00001760 }
malc713a98f2009-09-12 02:28:45 +04001761 audio_reset_timer ();
bellard85571bc2004-11-07 18:04:02 +00001762}
1763
1764static void audio_atexit (void)
1765{
bellardc0fe3822005-11-05 18:55:28 +00001766 AudioState *s = &glob_audio_state;
bellard1d14ffa2005-10-30 18:58:22 +00001767 HWVoiceOut *hwo = NULL;
1768 HWVoiceIn *hwi = NULL;
bellard85571bc2004-11-07 18:04:02 +00001769
malc1a7dafc2009-05-14 03:11:35 +04001770 while ((hwo = audio_pcm_hw_find_any_enabled_out (hwo))) {
bellardec36b692006-07-16 18:57:03 +00001771 SWVoiceCap *sc;
bellard8ead62c2006-07-04 16:51:32 +00001772
bellard571ec3d2005-11-20 16:24:34 +00001773 hwo->pcm_ops->ctl_out (hwo, VOICE_DISABLE);
bellard1d14ffa2005-10-30 18:58:22 +00001774 hwo->pcm_ops->fini_out (hwo);
bellard8ead62c2006-07-04 16:51:32 +00001775
bellardec36b692006-07-16 18:57:03 +00001776 for (sc = hwo->cap_head.lh_first; sc; sc = sc->entries.le_next) {
1777 CaptureVoiceOut *cap = sc->cap;
1778 struct capture_callback *cb;
1779
1780 for (cb = cap->cb_head.lh_first; cb; cb = cb->entries.le_next) {
1781 cb->ops.destroy (cb->opaque);
1782 }
bellard8ead62c2006-07-04 16:51:32 +00001783 }
bellard1d14ffa2005-10-30 18:58:22 +00001784 }
1785
malc1a7dafc2009-05-14 03:11:35 +04001786 while ((hwi = audio_pcm_hw_find_any_enabled_in (hwi))) {
bellard571ec3d2005-11-20 16:24:34 +00001787 hwi->pcm_ops->ctl_in (hwi, VOICE_DISABLE);
bellard1d14ffa2005-10-30 18:58:22 +00001788 hwi->pcm_ops->fini_in (hwi);
bellard85571bc2004-11-07 18:04:02 +00001789 }
bellardc0fe3822005-11-05 18:55:28 +00001790
1791 if (s->drv) {
1792 s->drv->fini (s->drv_opaque);
1793 }
bellard85571bc2004-11-07 18:04:02 +00001794}
1795
Juan Quintelad959fce2009-12-02 11:49:34 +01001796static const VMStateDescription vmstate_audio = {
1797 .name = "audio",
1798 .version_id = 1,
1799 .minimum_version_id = 1,
1800 .minimum_version_id_old = 1,
1801 .fields = (VMStateField []) {
1802 VMSTATE_END_OF_LIST()
bellard1d14ffa2005-10-30 18:58:22 +00001803 }
Juan Quintelad959fce2009-12-02 11:49:34 +01001804};
bellard85571bc2004-11-07 18:04:02 +00001805
malc1a7dafc2009-05-14 03:11:35 +04001806static void audio_init (void)
bellard85571bc2004-11-07 18:04:02 +00001807{
bellard1d14ffa2005-10-30 18:58:22 +00001808 size_t i;
bellard85571bc2004-11-07 18:04:02 +00001809 int done = 0;
1810 const char *drvname;
malc713a98f2009-09-12 02:28:45 +04001811 VMChangeStateEntry *e;
bellardc0fe3822005-11-05 18:55:28 +00001812 AudioState *s = &glob_audio_state;
bellard85571bc2004-11-07 18:04:02 +00001813
Paul Brook0d9acba2009-05-12 12:02:38 +01001814 if (s->drv) {
malc1a7dafc2009-05-14 03:11:35 +04001815 return;
Paul Brook0d9acba2009-05-12 12:02:38 +01001816 }
1817
Blue Swirl72cf2d42009-09-12 07:36:22 +00001818 QLIST_INIT (&s->hw_head_out);
1819 QLIST_INIT (&s->hw_head_in);
1820 QLIST_INIT (&s->cap_head);
bellard571ec3d2005-11-20 16:24:34 +00001821 atexit (audio_atexit);
1822
1823 s->ts = qemu_new_timer (vm_clock, audio_timer, s);
1824 if (!s->ts) {
Paul Brook0d9acba2009-05-12 12:02:38 +01001825 hw_error("Could not create audio timer\n");
bellard571ec3d2005-11-20 16:24:34 +00001826 }
1827
bellard1d14ffa2005-10-30 18:58:22 +00001828 audio_process_options ("AUDIO", audio_options);
bellard85571bc2004-11-07 18:04:02 +00001829
bellardc0fe3822005-11-05 18:55:28 +00001830 s->nb_hw_voices_out = conf.fixed_out.nb_voices;
1831 s->nb_hw_voices_in = conf.fixed_in.nb_voices;
1832
bellard1d14ffa2005-10-30 18:58:22 +00001833 if (s->nb_hw_voices_out <= 0) {
bellard571ec3d2005-11-20 16:24:34 +00001834 dolog ("Bogus number of playback voices %d, setting to 1\n",
bellard1d14ffa2005-10-30 18:58:22 +00001835 s->nb_hw_voices_out);
1836 s->nb_hw_voices_out = 1;
bellard85571bc2004-11-07 18:04:02 +00001837 }
1838
bellard1d14ffa2005-10-30 18:58:22 +00001839 if (s->nb_hw_voices_in <= 0) {
bellard571ec3d2005-11-20 16:24:34 +00001840 dolog ("Bogus number of capture voices %d, setting to 0\n",
bellard1d14ffa2005-10-30 18:58:22 +00001841 s->nb_hw_voices_in);
bellard571ec3d2005-11-20 16:24:34 +00001842 s->nb_hw_voices_in = 0;
bellard1d14ffa2005-10-30 18:58:22 +00001843 }
1844
1845 {
1846 int def;
1847 drvname = audio_get_conf_str ("QEMU_AUDIO_DRV", NULL, &def);
1848 }
1849
bellard85571bc2004-11-07 18:04:02 +00001850 if (drvname) {
1851 int found = 0;
bellard1d14ffa2005-10-30 18:58:22 +00001852
malcb1503cd2008-12-22 20:33:55 +00001853 for (i = 0; i < ARRAY_SIZE (drvtab); i++) {
bellard85571bc2004-11-07 18:04:02 +00001854 if (!strcmp (drvname, drvtab[i]->name)) {
bellardc0fe3822005-11-05 18:55:28 +00001855 done = !audio_driver_init (s, drvtab[i]);
bellard85571bc2004-11-07 18:04:02 +00001856 found = 1;
1857 break;
1858 }
1859 }
bellard1d14ffa2005-10-30 18:58:22 +00001860
bellard85571bc2004-11-07 18:04:02 +00001861 if (!found) {
1862 dolog ("Unknown audio driver `%s'\n", drvname);
bellard1d14ffa2005-10-30 18:58:22 +00001863 dolog ("Run with -audio-help to list available drivers\n");
bellard85571bc2004-11-07 18:04:02 +00001864 }
1865 }
1866
bellard85571bc2004-11-07 18:04:02 +00001867 if (!done) {
malcb1503cd2008-12-22 20:33:55 +00001868 for (i = 0; !done && i < ARRAY_SIZE (drvtab); i++) {
bellard1d14ffa2005-10-30 18:58:22 +00001869 if (drvtab[i]->can_be_default) {
bellardc0fe3822005-11-05 18:55:28 +00001870 done = !audio_driver_init (s, drvtab[i]);
bellard1d14ffa2005-10-30 18:58:22 +00001871 }
bellard85571bc2004-11-07 18:04:02 +00001872 }
1873 }
1874
bellard85571bc2004-11-07 18:04:02 +00001875 if (!done) {
bellardc0fe3822005-11-05 18:55:28 +00001876 done = !audio_driver_init (s, &no_audio_driver);
1877 if (!done) {
Paul Brook0d9acba2009-05-12 12:02:38 +01001878 hw_error("Could not initialize audio subsystem\n");
bellard1d14ffa2005-10-30 18:58:22 +00001879 }
1880 else {
bellardc0fe3822005-11-05 18:55:28 +00001881 dolog ("warning: Using timer based audio emulation\n");
bellard1d14ffa2005-10-30 18:58:22 +00001882 }
bellard85571bc2004-11-07 18:04:02 +00001883 }
bellard1d14ffa2005-10-30 18:58:22 +00001884
Paul Brook0d9acba2009-05-12 12:02:38 +01001885 if (conf.period.hertz <= 0) {
1886 if (conf.period.hertz < 0) {
1887 dolog ("warning: Timer period is negative - %d "
1888 "treating as zero\n",
1889 conf.period.hertz);
bellard1d14ffa2005-10-30 18:58:22 +00001890 }
Paul Brook0d9acba2009-05-12 12:02:38 +01001891 conf.period.ticks = 1;
1892 } else {
malc4f4cc0e2009-09-18 08:16:03 +04001893 conf.period.ticks =
1894 muldiv64 (1, get_ticks_per_sec (), conf.period.hertz);
bellard1d14ffa2005-10-30 18:58:22 +00001895 }
Paul Brook0d9acba2009-05-12 12:02:38 +01001896
1897 e = qemu_add_vm_change_state_handler (audio_vm_change_state_handler, s);
1898 if (!e) {
1899 dolog ("warning: Could not register change state handler\n"
1900 "(Audio can continue looping even after stopping the VM)\n");
bellard1d14ffa2005-10-30 18:58:22 +00001901 }
1902
Blue Swirl72cf2d42009-09-12 07:36:22 +00001903 QLIST_INIT (&s->card_head);
Juan Quintelad959fce2009-12-02 11:49:34 +01001904 vmstate_register (0, &vmstate_audio, s);
bellard85571bc2004-11-07 18:04:02 +00001905}
bellard8ead62c2006-07-04 16:51:32 +00001906
malc1a7dafc2009-05-14 03:11:35 +04001907void AUD_register_card (const char *name, QEMUSoundCard *card)
1908{
1909 audio_init ();
1910 card->name = qemu_strdup (name);
1911 memset (&card->entries, 0, sizeof (card->entries));
Blue Swirl72cf2d42009-09-12 07:36:22 +00001912 QLIST_INSERT_HEAD (&glob_audio_state.card_head, card, entries);
malc1a7dafc2009-05-14 03:11:35 +04001913}
1914
1915void AUD_remove_card (QEMUSoundCard *card)
1916{
Blue Swirl72cf2d42009-09-12 07:36:22 +00001917 QLIST_REMOVE (card, entries);
malc1a7dafc2009-05-14 03:11:35 +04001918 qemu_free (card->name);
1919}
1920
1921
bellardec36b692006-07-16 18:57:03 +00001922CaptureVoiceOut *AUD_add_capture (
malc1ea879e2008-12-03 22:48:44 +00001923 struct audsettings *as,
bellard8ead62c2006-07-04 16:51:32 +00001924 struct audio_capture_ops *ops,
1925 void *cb_opaque
1926 )
1927{
malc1a7dafc2009-05-14 03:11:35 +04001928 AudioState *s = &glob_audio_state;
bellard8ead62c2006-07-04 16:51:32 +00001929 CaptureVoiceOut *cap;
1930 struct capture_callback *cb;
1931
bellardec36b692006-07-16 18:57:03 +00001932 if (audio_validate_settings (as)) {
bellard8ead62c2006-07-04 16:51:32 +00001933 dolog ("Invalid settings were passed when trying to add capture\n");
1934 audio_print_settings (as);
bellardec36b692006-07-16 18:57:03 +00001935 goto err0;
bellard8ead62c2006-07-04 16:51:32 +00001936 }
1937
1938 cb = audio_calloc (AUDIO_FUNC, 1, sizeof (*cb));
1939 if (!cb) {
1940 dolog ("Could not allocate capture callback information, size %zu\n",
1941 sizeof (*cb));
1942 goto err0;
1943 }
1944 cb->ops = *ops;
1945 cb->opaque = cb_opaque;
1946
malc1a7dafc2009-05-14 03:11:35 +04001947 cap = audio_pcm_capture_find_specific (as);
bellard8ead62c2006-07-04 16:51:32 +00001948 if (cap) {
Blue Swirl72cf2d42009-09-12 07:36:22 +00001949 QLIST_INSERT_HEAD (&cap->cb_head, cb, entries);
bellardec36b692006-07-16 18:57:03 +00001950 return cap;
bellard8ead62c2006-07-04 16:51:32 +00001951 }
1952 else {
1953 HWVoiceOut *hw;
1954 CaptureVoiceOut *cap;
1955
1956 cap = audio_calloc (AUDIO_FUNC, 1, sizeof (*cap));
1957 if (!cap) {
1958 dolog ("Could not allocate capture voice, size %zu\n",
1959 sizeof (*cap));
1960 goto err1;
1961 }
1962
1963 hw = &cap->hw;
Blue Swirl72cf2d42009-09-12 07:36:22 +00001964 QLIST_INIT (&hw->sw_head);
1965 QLIST_INIT (&cap->cb_head);
bellard8ead62c2006-07-04 16:51:32 +00001966
1967 /* XXX find a more elegant way */
1968 hw->samples = 4096 * 4;
1969 hw->mix_buf = audio_calloc (AUDIO_FUNC, hw->samples,
malc1ea879e2008-12-03 22:48:44 +00001970 sizeof (struct st_sample));
bellard8ead62c2006-07-04 16:51:32 +00001971 if (!hw->mix_buf) {
1972 dolog ("Could not allocate capture mix buffer (%d samples)\n",
1973 hw->samples);
1974 goto err2;
1975 }
1976
bellardd929eba2006-07-04 21:47:22 +00001977 audio_pcm_init_info (&hw->info, as);
bellard8ead62c2006-07-04 16:51:32 +00001978
1979 cap->buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift);
1980 if (!cap->buf) {
1981 dolog ("Could not allocate capture buffer "
1982 "(%d samples, each %d bytes)\n",
1983 hw->samples, 1 << hw->info.shift);
1984 goto err3;
1985 }
1986
1987 hw->clip = mixeng_clip
1988 [hw->info.nchannels == 2]
1989 [hw->info.sign]
bellardd929eba2006-07-04 21:47:22 +00001990 [hw->info.swap_endianness]
thsf941aa22007-02-17 22:19:29 +00001991 [audio_bits_to_index (hw->info.bits)];
bellard8ead62c2006-07-04 16:51:32 +00001992
Blue Swirl72cf2d42009-09-12 07:36:22 +00001993 QLIST_INSERT_HEAD (&s->cap_head, cap, entries);
1994 QLIST_INSERT_HEAD (&cap->cb_head, cb, entries);
bellard8ead62c2006-07-04 16:51:32 +00001995
1996 hw = NULL;
malc1a7dafc2009-05-14 03:11:35 +04001997 while ((hw = audio_pcm_hw_find_any_out (hw))) {
1998 audio_attach_capture (hw);
bellard8ead62c2006-07-04 16:51:32 +00001999 }
bellardec36b692006-07-16 18:57:03 +00002000 return cap;
bellard8ead62c2006-07-04 16:51:32 +00002001
2002 err3:
2003 qemu_free (cap->hw.mix_buf);
2004 err2:
2005 qemu_free (cap);
2006 err1:
2007 qemu_free (cb);
2008 err0:
bellardec36b692006-07-16 18:57:03 +00002009 return NULL;
2010 }
2011}
2012
2013void AUD_del_capture (CaptureVoiceOut *cap, void *cb_opaque)
2014{
2015 struct capture_callback *cb;
2016
2017 for (cb = cap->cb_head.lh_first; cb; cb = cb->entries.le_next) {
2018 if (cb->opaque == cb_opaque) {
2019 cb->ops.destroy (cb_opaque);
Blue Swirl72cf2d42009-09-12 07:36:22 +00002020 QLIST_REMOVE (cb, entries);
bellardec36b692006-07-16 18:57:03 +00002021 qemu_free (cb);
2022
2023 if (!cap->cb_head.lh_first) {
2024 SWVoiceOut *sw = cap->hw.sw_head.lh_first, *sw1;
bellarda3c25992006-07-18 21:09:59 +00002025
bellardec36b692006-07-16 18:57:03 +00002026 while (sw) {
bellarda3c25992006-07-18 21:09:59 +00002027 SWVoiceCap *sc = (SWVoiceCap *) sw;
bellardec36b692006-07-16 18:57:03 +00002028#ifdef DEBUG_CAPTURE
2029 dolog ("freeing %s\n", sw->name);
2030#endif
bellarda3c25992006-07-18 21:09:59 +00002031
bellardec36b692006-07-16 18:57:03 +00002032 sw1 = sw->entries.le_next;
2033 if (sw->rate) {
2034 st_rate_stop (sw->rate);
2035 sw->rate = NULL;
2036 }
Blue Swirl72cf2d42009-09-12 07:36:22 +00002037 QLIST_REMOVE (sw, entries);
2038 QLIST_REMOVE (sc, entries);
bellarda3c25992006-07-18 21:09:59 +00002039 qemu_free (sc);
bellardec36b692006-07-16 18:57:03 +00002040 sw = sw1;
2041 }
Blue Swirl72cf2d42009-09-12 07:36:22 +00002042 QLIST_REMOVE (cap, entries);
bellardec36b692006-07-16 18:57:03 +00002043 qemu_free (cap);
2044 }
2045 return;
2046 }
bellard8ead62c2006-07-04 16:51:32 +00002047 }
2048}
balrog683efdc2008-05-04 10:21:03 +00002049
2050void AUD_set_volume_out (SWVoiceOut *sw, int mute, uint8_t lvol, uint8_t rvol)
2051{
2052 if (sw) {
2053 sw->vol.mute = mute;
2054 sw->vol.l = nominal_volume.l * lvol / 255;
2055 sw->vol.r = nominal_volume.r * rvol / 255;
2056 }
2057}
2058
2059void AUD_set_volume_in (SWVoiceIn *sw, int mute, uint8_t lvol, uint8_t rvol)
2060{
2061 if (sw) {
2062 sw->vol.mute = mute;
2063 sw->vol.l = nominal_volume.l * lvol / 255;
2064 sw->vol.r = nominal_volume.r * rvol / 255;
2065 }
2066}