1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include "qemu/osdep.h"
25#include "audio.h"
26#include "audio_int.h"
27#include "qemu/cutils.h"
28#include "qemu/timer.h"
29#include "qapi/error.h"
30#include "qapi/qapi-visit-audio.h"
31#include "qapi/visitor-impl.h"
32
33#define AUDIO_CAP "audio-legacy"
34#include "audio_int.h"
35
36static uint32_t toui32(const char *str)
37{
38 uint64_t ret;
39 if (parse_uint_full(str, 10, &ret) || ret > UINT32_MAX) {
40 dolog("Invalid integer value `%s'\n", str);
41 exit(1);
42 }
43 return ret;
44}
45
46
47static void get_bool(const char *env, bool *dst, bool *has_dst)
48{
49 const char *val = getenv(env);
50 if (val) {
51 *dst = toui32(val) != 0;
52 *has_dst = true;
53 }
54}
55
56static void get_int(const char *env, uint32_t *dst, bool *has_dst)
57{
58 const char *val = getenv(env);
59 if (val) {
60 *dst = toui32(val);
61 *has_dst = true;
62 }
63}
64
65static void get_str(const char *env, char **dst)
66{
67 const char *val = getenv(env);
68 if (val) {
69 g_free(*dst);
70 *dst = g_strdup(val);
71 }
72}
73
74static void get_fmt(const char *env, AudioFormat *dst, bool *has_dst)
75{
76 const char *val = getenv(env);
77 if (val) {
78 size_t i;
79 for (i = 0; AudioFormat_lookup.size; ++i) {
80 if (strcasecmp(val, AudioFormat_lookup.array[i]) == 0) {
81 *dst = i;
82 *has_dst = true;
83 return;
84 }
85 }
86
87 dolog("Invalid audio format `%s'\n", val);
88 exit(1);
89 }
90}
91
92
93#if defined(CONFIG_AUDIO_ALSA) || defined(CONFIG_AUDIO_DSOUND)
94static void get_millis_to_usecs(const char *env, uint32_t *dst, bool *has_dst)
95{
96 const char *val = getenv(env);
97 if (val) {
98 *dst = toui32(val) * 1000;
99 *has_dst = true;
100 }
101}
102#endif
103
104#if defined(CONFIG_AUDIO_ALSA) || defined(CONFIG_AUDIO_COREAUDIO) || \
105 defined(CONFIG_AUDIO_PA) || defined(CONFIG_AUDIO_SDL) || \
106 defined(CONFIG_AUDIO_DSOUND) || defined(CONFIG_AUDIO_OSS)
107static uint32_t frames_to_usecs(uint32_t frames,
108 AudiodevPerDirectionOptions *pdo)
109{
110 uint32_t freq = pdo->has_frequency ? pdo->frequency : 44100;
111 return (frames * 1000000 + freq / 2) / freq;
112}
113#endif
114
115#ifdef CONFIG_AUDIO_COREAUDIO
116static void get_frames_to_usecs(const char *env, uint32_t *dst, bool *has_dst,
117 AudiodevPerDirectionOptions *pdo)
118{
119 const char *val = getenv(env);
120 if (val) {
121 *dst = frames_to_usecs(toui32(val), pdo);
122 *has_dst = true;
123 }
124}
125#endif
126
127#if defined(CONFIG_AUDIO_PA) || defined(CONFIG_AUDIO_SDL) || \
128 defined(CONFIG_AUDIO_DSOUND) || defined(CONFIG_AUDIO_OSS)
129static uint32_t samples_to_usecs(uint32_t samples,
130 AudiodevPerDirectionOptions *pdo)
131{
132 uint32_t channels = pdo->has_channels ? pdo->channels : 2;
133 return frames_to_usecs(samples / channels, pdo);
134}
135#endif
136
137#if defined(CONFIG_AUDIO_PA) || defined(CONFIG_AUDIO_SDL)
138static void get_samples_to_usecs(const char *env, uint32_t *dst, bool *has_dst,
139 AudiodevPerDirectionOptions *pdo)
140{
141 const char *val = getenv(env);
142 if (val) {
143 *dst = samples_to_usecs(toui32(val), pdo);
144 *has_dst = true;
145 }
146}
147#endif
148
149#if defined(CONFIG_AUDIO_DSOUND) || defined(CONFIG_AUDIO_OSS)
150static uint32_t bytes_to_usecs(uint32_t bytes, AudiodevPerDirectionOptions *pdo)
151{
152 AudioFormat fmt = pdo->has_format ? pdo->format : AUDIO_FORMAT_S16;
153 uint32_t bytes_per_sample = audioformat_bytes_per_sample(fmt);
154 return samples_to_usecs(bytes / bytes_per_sample, pdo);
155}
156
157static void get_bytes_to_usecs(const char *env, uint32_t *dst, bool *has_dst,
158 AudiodevPerDirectionOptions *pdo)
159{
160 const char *val = getenv(env);
161 if (val) {
162 *dst = bytes_to_usecs(toui32(val), pdo);
163 *has_dst = true;
164 }
165}
166#endif
167
168
169
170#ifdef CONFIG_AUDIO_ALSA
171
172static void handle_alsa_per_direction(
173 AudiodevAlsaPerDirectionOptions *apdo, const char *prefix)
174{
175 char buf[64];
176 size_t len = strlen(prefix);
177 bool size_in_usecs = false;
178 bool dummy;
179
180 memcpy(buf, prefix, len);
181 strcpy(buf + len, "TRY_POLL");
182 get_bool(buf, &apdo->try_poll, &apdo->has_try_poll);
183
184 strcpy(buf + len, "DEV");
185 get_str(buf, &apdo->dev);
186
187 strcpy(buf + len, "SIZE_IN_USEC");
188 get_bool(buf, &size_in_usecs, &dummy);
189
190 strcpy(buf + len, "PERIOD_SIZE");
191 get_int(buf, &apdo->period_length, &apdo->has_period_length);
192 if (apdo->has_period_length && !size_in_usecs) {
193 apdo->period_length = frames_to_usecs(
194 apdo->period_length,
195 qapi_AudiodevAlsaPerDirectionOptions_base(apdo));
196 }
197
198 strcpy(buf + len, "BUFFER_SIZE");
199 get_int(buf, &apdo->buffer_length, &apdo->has_buffer_length);
200 if (apdo->has_buffer_length && !size_in_usecs) {
201 apdo->buffer_length = frames_to_usecs(
202 apdo->buffer_length,
203 qapi_AudiodevAlsaPerDirectionOptions_base(apdo));
204 }
205}
206
207static void handle_alsa(Audiodev *dev)
208{
209 AudiodevAlsaOptions *aopt = &dev->u.alsa;
210 handle_alsa_per_direction(aopt->in, "QEMU_ALSA_ADC_");
211 handle_alsa_per_direction(aopt->out, "QEMU_ALSA_DAC_");
212
213 get_millis_to_usecs("QEMU_ALSA_THRESHOLD",
214 &aopt->threshold, &aopt->has_threshold);
215}
216#endif
217
218#ifdef CONFIG_AUDIO_COREAUDIO
219
220static void handle_coreaudio(Audiodev *dev)
221{
222 get_frames_to_usecs(
223 "QEMU_COREAUDIO_BUFFER_SIZE",
224 &dev->u.coreaudio.out->buffer_length,
225 &dev->u.coreaudio.out->has_buffer_length,
226 qapi_AudiodevCoreaudioPerDirectionOptions_base(dev->u.coreaudio.out));
227 get_int("QEMU_COREAUDIO_BUFFER_COUNT",
228 &dev->u.coreaudio.out->buffer_count,
229 &dev->u.coreaudio.out->has_buffer_count);
230}
231#endif
232
233#ifdef CONFIG_AUDIO_DSOUND
234
235static void handle_dsound(Audiodev *dev)
236{
237 get_millis_to_usecs("QEMU_DSOUND_LATENCY_MILLIS",
238 &dev->u.dsound.latency, &dev->u.dsound.has_latency);
239 get_bytes_to_usecs("QEMU_DSOUND_BUFSIZE_OUT",
240 &dev->u.dsound.out->buffer_length,
241 &dev->u.dsound.out->has_buffer_length,
242 dev->u.dsound.out);
243 get_bytes_to_usecs("QEMU_DSOUND_BUFSIZE_IN",
244 &dev->u.dsound.in->buffer_length,
245 &dev->u.dsound.in->has_buffer_length,
246 dev->u.dsound.in);
247}
248#endif
249
250#ifdef CONFIG_AUDIO_OSS
251
252static void handle_oss_per_direction(
253 AudiodevOssPerDirectionOptions *opdo, const char *try_poll_env,
254 const char *dev_env)
255{
256 get_bool(try_poll_env, &opdo->try_poll, &opdo->has_try_poll);
257 get_str(dev_env, &opdo->dev);
258
259 get_bytes_to_usecs("QEMU_OSS_FRAGSIZE",
260 &opdo->buffer_length, &opdo->has_buffer_length,
261 qapi_AudiodevOssPerDirectionOptions_base(opdo));
262 get_int("QEMU_OSS_NFRAGS", &opdo->buffer_count,
263 &opdo->has_buffer_count);
264}
265
266static void handle_oss(Audiodev *dev)
267{
268 AudiodevOssOptions *oopt = &dev->u.oss;
269 handle_oss_per_direction(oopt->in, "QEMU_AUDIO_ADC_TRY_POLL",
270 "QEMU_OSS_ADC_DEV");
271 handle_oss_per_direction(oopt->out, "QEMU_AUDIO_DAC_TRY_POLL",
272 "QEMU_OSS_DAC_DEV");
273
274 get_bool("QEMU_OSS_MMAP", &oopt->try_mmap, &oopt->has_try_mmap);
275 get_bool("QEMU_OSS_EXCLUSIVE", &oopt->exclusive, &oopt->has_exclusive);
276 get_int("QEMU_OSS_POLICY", &oopt->dsp_policy, &oopt->has_dsp_policy);
277}
278#endif
279
280#ifdef CONFIG_AUDIO_PA
281
282static void handle_pa_per_direction(
283 AudiodevPaPerDirectionOptions *ppdo, const char *env)
284{
285 get_str(env, &ppdo->name);
286}
287
288static void handle_pa(Audiodev *dev)
289{
290 handle_pa_per_direction(dev->u.pa.in, "QEMU_PA_SOURCE");
291 handle_pa_per_direction(dev->u.pa.out, "QEMU_PA_SINK");
292
293 get_samples_to_usecs(
294 "QEMU_PA_SAMPLES", &dev->u.pa.in->buffer_length,
295 &dev->u.pa.in->has_buffer_length,
296 qapi_AudiodevPaPerDirectionOptions_base(dev->u.pa.in));
297 get_samples_to_usecs(
298 "QEMU_PA_SAMPLES", &dev->u.pa.out->buffer_length,
299 &dev->u.pa.out->has_buffer_length,
300 qapi_AudiodevPaPerDirectionOptions_base(dev->u.pa.out));
301
302 get_str("QEMU_PA_SERVER", &dev->u.pa.server);
303}
304#endif
305
306#ifdef CONFIG_AUDIO_SDL
307
308static void handle_sdl(Audiodev *dev)
309{
310
311 get_samples_to_usecs("QEMU_SDL_SAMPLES", &dev->u.sdl.out->buffer_length,
312 &dev->u.sdl.out->has_buffer_length,
313 qapi_AudiodevSdlPerDirectionOptions_base(dev->u.sdl.out));
314}
315#endif
316
317
318static void handle_wav(Audiodev *dev)
319{
320 get_int("QEMU_WAV_FREQUENCY",
321 &dev->u.wav.out->frequency, &dev->u.wav.out->has_frequency);
322 get_fmt("QEMU_WAV_FORMAT", &dev->u.wav.out->format,
323 &dev->u.wav.out->has_format);
324 get_int("QEMU_WAV_DAC_FIXED_CHANNELS",
325 &dev->u.wav.out->channels, &dev->u.wav.out->has_channels);
326 get_str("QEMU_WAV_PATH", &dev->u.wav.path);
327}
328
329
330static void handle_per_direction(
331 AudiodevPerDirectionOptions *pdo, const char *prefix)
332{
333 char buf[64];
334 size_t len = strlen(prefix);
335
336 memcpy(buf, prefix, len);
337 strcpy(buf + len, "FIXED_SETTINGS");
338 get_bool(buf, &pdo->fixed_settings, &pdo->has_fixed_settings);
339
340 strcpy(buf + len, "FIXED_FREQ");
341 get_int(buf, &pdo->frequency, &pdo->has_frequency);
342
343 strcpy(buf + len, "FIXED_FMT");
344 get_fmt(buf, &pdo->format, &pdo->has_format);
345
346 strcpy(buf + len, "FIXED_CHANNELS");
347 get_int(buf, &pdo->channels, &pdo->has_channels);
348
349 strcpy(buf + len, "VOICES");
350 get_int(buf, &pdo->voices, &pdo->has_voices);
351}
352
353static AudiodevListEntry *legacy_opt(const char *drvname)
354{
355 AudiodevListEntry *e = g_new0(AudiodevListEntry, 1);
356 e->dev = g_new0(Audiodev, 1);
357 e->dev->id = g_strdup(drvname);
358 e->dev->driver = qapi_enum_parse(
359 &AudiodevDriver_lookup, drvname, -1, &error_abort);
360
361 audio_create_pdos(e->dev);
362
363 handle_per_direction(audio_get_pdo_in(e->dev), "QEMU_AUDIO_ADC_");
364 handle_per_direction(audio_get_pdo_out(e->dev), "QEMU_AUDIO_DAC_");
365
366
367 get_int("QEMU_AUDIO_TIMER_PERIOD",
368 &e->dev->timer_period, &e->dev->has_timer_period);
369 if (e->dev->has_timer_period && e->dev->timer_period) {
370 e->dev->timer_period = NANOSECONDS_PER_SECOND / 1000 /
371 e->dev->timer_period;
372 }
373
374 switch (e->dev->driver) {
375#ifdef CONFIG_AUDIO_ALSA
376 case AUDIODEV_DRIVER_ALSA:
377 handle_alsa(e->dev);
378 break;
379#endif
380
381#ifdef CONFIG_AUDIO_COREAUDIO
382 case AUDIODEV_DRIVER_COREAUDIO:
383 handle_coreaudio(e->dev);
384 break;
385#endif
386
387#ifdef CONFIG_AUDIO_DSOUND
388 case AUDIODEV_DRIVER_DSOUND:
389 handle_dsound(e->dev);
390 break;
391#endif
392
393#ifdef CONFIG_AUDIO_OSS
394 case AUDIODEV_DRIVER_OSS:
395 handle_oss(e->dev);
396 break;
397#endif
398
399#ifdef CONFIG_AUDIO_PA
400 case AUDIODEV_DRIVER_PA:
401 handle_pa(e->dev);
402 break;
403#endif
404
405#ifdef CONFIG_AUDIO_SDL
406 case AUDIODEV_DRIVER_SDL:
407 handle_sdl(e->dev);
408 break;
409#endif
410
411 case AUDIODEV_DRIVER_WAV:
412 handle_wav(e->dev);
413 break;
414
415 default:
416 break;
417 }
418
419 return e;
420}
421
422AudiodevListHead audio_handle_legacy_opts(void)
423{
424 const char *drvname = getenv("QEMU_AUDIO_DRV");
425 AudiodevListHead head = QSIMPLEQ_HEAD_INITIALIZER(head);
426
427 if (drvname) {
428 AudiodevListEntry *e;
429 audio_driver *driver = audio_driver_lookup(drvname);
430 if (!driver) {
431 dolog("Unknown audio driver `%s'\n", drvname);
432 exit(1);
433 }
434 e = legacy_opt(drvname);
435 QSIMPLEQ_INSERT_TAIL(&head, e, next);
436 } else {
437 for (int i = 0; audio_prio_list[i]; i++) {
438 audio_driver *driver = audio_driver_lookup(audio_prio_list[i]);
439 if (driver && driver->can_be_default) {
440 AudiodevListEntry *e = legacy_opt(driver->name);
441 QSIMPLEQ_INSERT_TAIL(&head, e, next);
442 }
443 }
444 if (QSIMPLEQ_EMPTY(&head)) {
445 dolog("Internal error: no default audio driver available\n");
446 exit(1);
447 }
448 }
449
450 return head;
451}
452
453
454typedef struct {
455 Visitor visitor;
456
457 bool comma;
458 GList *path;
459} LegacyPrintVisitor;
460
461static bool lv_start_struct(Visitor *v, const char *name, void **obj,
462 size_t size, Error **errp)
463{
464 LegacyPrintVisitor *lv = (LegacyPrintVisitor *) v;
465 lv->path = g_list_append(lv->path, g_strdup(name));
466 return true;
467}
468
469static void lv_end_struct(Visitor *v, void **obj)
470{
471 LegacyPrintVisitor *lv = (LegacyPrintVisitor *) v;
472 lv->path = g_list_delete_link(lv->path, g_list_last(lv->path));
473}
474
475static void lv_print_key(Visitor *v, const char *name)
476{
477 GList *e;
478 LegacyPrintVisitor *lv = (LegacyPrintVisitor *) v;
479 if (lv->comma) {
480 putchar(',');
481 } else {
482 lv->comma = true;
483 }
484
485 for (e = lv->path; e; e = e->next) {
486 if (e->data) {
487 printf("%s.", (const char *) e->data);
488 }
489 }
490
491 printf("%s=", name);
492}
493
494static bool lv_type_int64(Visitor *v, const char *name, int64_t *obj,
495 Error **errp)
496{
497 lv_print_key(v, name);
498 printf("%" PRIi64, *obj);
499 return true;
500}
501
502static bool lv_type_uint64(Visitor *v, const char *name, uint64_t *obj,
503 Error **errp)
504{
505 lv_print_key(v, name);
506 printf("%" PRIu64, *obj);
507 return true;
508}
509
510static bool lv_type_bool(Visitor *v, const char *name, bool *obj, Error **errp)
511{
512 lv_print_key(v, name);
513 printf("%s", *obj ? "on" : "off");
514 return true;
515}
516
517static bool lv_type_str(Visitor *v, const char *name, char **obj, Error **errp)
518{
519 const char *str = *obj;
520 lv_print_key(v, name);
521
522 while (*str) {
523 if (*str == ',') {
524 putchar(',');
525 }
526 putchar(*str++);
527 }
528 return true;
529}
530
531static void lv_complete(Visitor *v, void *opaque)
532{
533 LegacyPrintVisitor *lv = (LegacyPrintVisitor *) v;
534 assert(lv->path == NULL);
535}
536
537static void lv_free(Visitor *v)
538{
539 LegacyPrintVisitor *lv = (LegacyPrintVisitor *) v;
540
541 g_list_free_full(lv->path, g_free);
542 g_free(lv);
543}
544
545static Visitor *legacy_visitor_new(void)
546{
547 LegacyPrintVisitor *lv = g_new0(LegacyPrintVisitor, 1);
548
549 lv->visitor.start_struct = lv_start_struct;
550 lv->visitor.end_struct = lv_end_struct;
551
552 lv->visitor.type_int64 = lv_type_int64;
553 lv->visitor.type_uint64 = lv_type_uint64;
554 lv->visitor.type_bool = lv_type_bool;
555 lv->visitor.type_str = lv_type_str;
556
557 lv->visitor.type = VISITOR_OUTPUT;
558 lv->visitor.complete = lv_complete;
559 lv->visitor.free = lv_free;
560
561 return &lv->visitor;
562}
563
564void audio_legacy_help(void)
565{
566 AudiodevListHead head;
567 AudiodevListEntry *e;
568
569 printf("Environment variable based configuration deprecated.\n");
570 printf("Please use the new -audiodev option.\n");
571
572 head = audio_handle_legacy_opts();
573 printf("\nEquivalent -audiodev to your current environment variables:\n");
574 if (!getenv("QEMU_AUDIO_DRV")) {
575 printf("(Since you didn't specify QEMU_AUDIO_DRV, I'll list all "
576 "possibilities)\n");
577 }
578
579 QSIMPLEQ_FOREACH(e, &head, next) {
580 Visitor *v;
581 Audiodev *dev = e->dev;
582 printf("-audiodev ");
583
584 v = legacy_visitor_new();
585 visit_type_Audiodev(v, NULL, &dev, &error_abort);
586 visit_free(v);
587
588 printf("\n");
589 }
590 audio_free_audiodev_list(&head);
591}
592
