configure: move accelerator logic to meson
[qemu.git] / audio / audio_legacy.c
1 /*
2 * QEMU Audio subsystem: legacy configuration handling
3 *
4 * Copyright (c) 2015-2019 Zoltán Kővágó <DirtY.iCE.hu@gmail.com>
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24 #include "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
36 static uint32_t toui32(const char *str)
37 {
38 unsigned long long ret;
39 if (parse_uint_full(str, &ret, 10) || ret > UINT32_MAX) {
40 dolog("Invalid integer value `%s'\n", str);
41 exit(1);
42 }
43 return ret;
44 }
45
46 /* helper functions to convert env variables */
47 static 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
56 static 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
65 static void get_str(const char *env, char **dst, bool *has_dst)
66 {
67 const char *val = getenv(env);
68 if (val) {
69 if (*has_dst) {
70 g_free(*dst);
71 }
72 *dst = g_strdup(val);
73 *has_dst = true;
74 }
75 }
76
77 static void get_fmt(const char *env, AudioFormat *dst, bool *has_dst)
78 {
79 const char *val = getenv(env);
80 if (val) {
81 size_t i;
82 for (i = 0; AudioFormat_lookup.size; ++i) {
83 if (strcasecmp(val, AudioFormat_lookup.array[i]) == 0) {
84 *dst = i;
85 *has_dst = true;
86 return;
87 }
88 }
89
90 dolog("Invalid audio format `%s'\n", val);
91 exit(1);
92 }
93 }
94
95
96 static void get_millis_to_usecs(const char *env, uint32_t *dst, bool *has_dst)
97 {
98 const char *val = getenv(env);
99 if (val) {
100 *dst = toui32(val) * 1000;
101 *has_dst = true;
102 }
103 }
104
105 static uint32_t frames_to_usecs(uint32_t frames,
106 AudiodevPerDirectionOptions *pdo)
107 {
108 uint32_t freq = pdo->has_frequency ? pdo->frequency : 44100;
109 return (frames * 1000000 + freq / 2) / freq;
110 }
111
112
113 static void get_frames_to_usecs(const char *env, uint32_t *dst, bool *has_dst,
114 AudiodevPerDirectionOptions *pdo)
115 {
116 const char *val = getenv(env);
117 if (val) {
118 *dst = frames_to_usecs(toui32(val), pdo);
119 *has_dst = true;
120 }
121 }
122
123 static uint32_t samples_to_usecs(uint32_t samples,
124 AudiodevPerDirectionOptions *pdo)
125 {
126 uint32_t channels = pdo->has_channels ? pdo->channels : 2;
127 return frames_to_usecs(samples / channels, pdo);
128 }
129
130 static void get_samples_to_usecs(const char *env, uint32_t *dst, bool *has_dst,
131 AudiodevPerDirectionOptions *pdo)
132 {
133 const char *val = getenv(env);
134 if (val) {
135 *dst = samples_to_usecs(toui32(val), pdo);
136 *has_dst = true;
137 }
138 }
139
140 static uint32_t bytes_to_usecs(uint32_t bytes, AudiodevPerDirectionOptions *pdo)
141 {
142 AudioFormat fmt = pdo->has_format ? pdo->format : AUDIO_FORMAT_S16;
143 uint32_t bytes_per_sample = audioformat_bytes_per_sample(fmt);
144 return samples_to_usecs(bytes / bytes_per_sample, pdo);
145 }
146
147 static void get_bytes_to_usecs(const char *env, uint32_t *dst, bool *has_dst,
148 AudiodevPerDirectionOptions *pdo)
149 {
150 const char *val = getenv(env);
151 if (val) {
152 *dst = bytes_to_usecs(toui32(val), pdo);
153 *has_dst = true;
154 }
155 }
156
157 /* backend specific functions */
158 /* ALSA */
159 static void handle_alsa_per_direction(
160 AudiodevAlsaPerDirectionOptions *apdo, const char *prefix)
161 {
162 char buf[64];
163 size_t len = strlen(prefix);
164 bool size_in_usecs = false;
165 bool dummy;
166
167 memcpy(buf, prefix, len);
168 strcpy(buf + len, "TRY_POLL");
169 get_bool(buf, &apdo->try_poll, &apdo->has_try_poll);
170
171 strcpy(buf + len, "DEV");
172 get_str(buf, &apdo->dev, &apdo->has_dev);
173
174 strcpy(buf + len, "SIZE_IN_USEC");
175 get_bool(buf, &size_in_usecs, &dummy);
176
177 strcpy(buf + len, "PERIOD_SIZE");
178 get_int(buf, &apdo->period_length, &apdo->has_period_length);
179 if (apdo->has_period_length && !size_in_usecs) {
180 apdo->period_length = frames_to_usecs(
181 apdo->period_length,
182 qapi_AudiodevAlsaPerDirectionOptions_base(apdo));
183 }
184
185 strcpy(buf + len, "BUFFER_SIZE");
186 get_int(buf, &apdo->buffer_length, &apdo->has_buffer_length);
187 if (apdo->has_buffer_length && !size_in_usecs) {
188 apdo->buffer_length = frames_to_usecs(
189 apdo->buffer_length,
190 qapi_AudiodevAlsaPerDirectionOptions_base(apdo));
191 }
192 }
193
194 static void handle_alsa(Audiodev *dev)
195 {
196 AudiodevAlsaOptions *aopt = &dev->u.alsa;
197 handle_alsa_per_direction(aopt->in, "QEMU_ALSA_ADC_");
198 handle_alsa_per_direction(aopt->out, "QEMU_ALSA_DAC_");
199
200 get_millis_to_usecs("QEMU_ALSA_THRESHOLD",
201 &aopt->threshold, &aopt->has_threshold);
202 }
203
204 /* coreaudio */
205 static void handle_coreaudio(Audiodev *dev)
206 {
207 get_frames_to_usecs(
208 "QEMU_COREAUDIO_BUFFER_SIZE",
209 &dev->u.coreaudio.out->buffer_length,
210 &dev->u.coreaudio.out->has_buffer_length,
211 qapi_AudiodevCoreaudioPerDirectionOptions_base(dev->u.coreaudio.out));
212 get_int("QEMU_COREAUDIO_BUFFER_COUNT",
213 &dev->u.coreaudio.out->buffer_count,
214 &dev->u.coreaudio.out->has_buffer_count);
215 }
216
217 /* dsound */
218 static void handle_dsound(Audiodev *dev)
219 {
220 get_millis_to_usecs("QEMU_DSOUND_LATENCY_MILLIS",
221 &dev->u.dsound.latency, &dev->u.dsound.has_latency);
222 get_bytes_to_usecs("QEMU_DSOUND_BUFSIZE_OUT",
223 &dev->u.dsound.out->buffer_length,
224 &dev->u.dsound.out->has_buffer_length,
225 dev->u.dsound.out);
226 get_bytes_to_usecs("QEMU_DSOUND_BUFSIZE_IN",
227 &dev->u.dsound.in->buffer_length,
228 &dev->u.dsound.in->has_buffer_length,
229 dev->u.dsound.in);
230 }
231
232 /* OSS */
233 static void handle_oss_per_direction(
234 AudiodevOssPerDirectionOptions *opdo, const char *try_poll_env,
235 const char *dev_env)
236 {
237 get_bool(try_poll_env, &opdo->try_poll, &opdo->has_try_poll);
238 get_str(dev_env, &opdo->dev, &opdo->has_dev);
239
240 get_bytes_to_usecs("QEMU_OSS_FRAGSIZE",
241 &opdo->buffer_length, &opdo->has_buffer_length,
242 qapi_AudiodevOssPerDirectionOptions_base(opdo));
243 get_int("QEMU_OSS_NFRAGS", &opdo->buffer_count,
244 &opdo->has_buffer_count);
245 }
246
247 static void handle_oss(Audiodev *dev)
248 {
249 AudiodevOssOptions *oopt = &dev->u.oss;
250 handle_oss_per_direction(oopt->in, "QEMU_AUDIO_ADC_TRY_POLL",
251 "QEMU_OSS_ADC_DEV");
252 handle_oss_per_direction(oopt->out, "QEMU_AUDIO_DAC_TRY_POLL",
253 "QEMU_OSS_DAC_DEV");
254
255 get_bool("QEMU_OSS_MMAP", &oopt->try_mmap, &oopt->has_try_mmap);
256 get_bool("QEMU_OSS_EXCLUSIVE", &oopt->exclusive, &oopt->has_exclusive);
257 get_int("QEMU_OSS_POLICY", &oopt->dsp_policy, &oopt->has_dsp_policy);
258 }
259
260 /* pulseaudio */
261 static void handle_pa_per_direction(
262 AudiodevPaPerDirectionOptions *ppdo, const char *env)
263 {
264 get_str(env, &ppdo->name, &ppdo->has_name);
265 }
266
267 static void handle_pa(Audiodev *dev)
268 {
269 handle_pa_per_direction(dev->u.pa.in, "QEMU_PA_SOURCE");
270 handle_pa_per_direction(dev->u.pa.out, "QEMU_PA_SINK");
271
272 get_samples_to_usecs(
273 "QEMU_PA_SAMPLES", &dev->u.pa.in->buffer_length,
274 &dev->u.pa.in->has_buffer_length,
275 qapi_AudiodevPaPerDirectionOptions_base(dev->u.pa.in));
276 get_samples_to_usecs(
277 "QEMU_PA_SAMPLES", &dev->u.pa.out->buffer_length,
278 &dev->u.pa.out->has_buffer_length,
279 qapi_AudiodevPaPerDirectionOptions_base(dev->u.pa.out));
280
281 get_str("QEMU_PA_SERVER", &dev->u.pa.server, &dev->u.pa.has_server);
282 }
283
284 /* SDL */
285 static void handle_sdl(Audiodev *dev)
286 {
287 /* SDL is output only */
288 get_samples_to_usecs("QEMU_SDL_SAMPLES", &dev->u.sdl.out->buffer_length,
289 &dev->u.sdl.out->has_buffer_length, dev->u.sdl.out);
290 }
291
292 /* wav */
293 static void handle_wav(Audiodev *dev)
294 {
295 get_int("QEMU_WAV_FREQUENCY",
296 &dev->u.wav.out->frequency, &dev->u.wav.out->has_frequency);
297 get_fmt("QEMU_WAV_FORMAT", &dev->u.wav.out->format,
298 &dev->u.wav.out->has_format);
299 get_int("QEMU_WAV_DAC_FIXED_CHANNELS",
300 &dev->u.wav.out->channels, &dev->u.wav.out->has_channels);
301 get_str("QEMU_WAV_PATH", &dev->u.wav.path, &dev->u.wav.has_path);
302 }
303
304 /* general */
305 static void handle_per_direction(
306 AudiodevPerDirectionOptions *pdo, const char *prefix)
307 {
308 char buf[64];
309 size_t len = strlen(prefix);
310
311 memcpy(buf, prefix, len);
312 strcpy(buf + len, "FIXED_SETTINGS");
313 get_bool(buf, &pdo->fixed_settings, &pdo->has_fixed_settings);
314
315 strcpy(buf + len, "FIXED_FREQ");
316 get_int(buf, &pdo->frequency, &pdo->has_frequency);
317
318 strcpy(buf + len, "FIXED_FMT");
319 get_fmt(buf, &pdo->format, &pdo->has_format);
320
321 strcpy(buf + len, "FIXED_CHANNELS");
322 get_int(buf, &pdo->channels, &pdo->has_channels);
323
324 strcpy(buf + len, "VOICES");
325 get_int(buf, &pdo->voices, &pdo->has_voices);
326 }
327
328 static AudiodevListEntry *legacy_opt(const char *drvname)
329 {
330 AudiodevListEntry *e = g_malloc0(sizeof(AudiodevListEntry));
331 e->dev = g_malloc0(sizeof(Audiodev));
332 e->dev->id = g_strdup(drvname);
333 e->dev->driver = qapi_enum_parse(
334 &AudiodevDriver_lookup, drvname, -1, &error_abort);
335
336 audio_create_pdos(e->dev);
337
338 handle_per_direction(audio_get_pdo_in(e->dev), "QEMU_AUDIO_ADC_");
339 handle_per_direction(audio_get_pdo_out(e->dev), "QEMU_AUDIO_DAC_");
340
341 /* Original description: Timer period in HZ (0 - use lowest possible) */
342 get_int("QEMU_AUDIO_TIMER_PERIOD",
343 &e->dev->timer_period, &e->dev->has_timer_period);
344 if (e->dev->has_timer_period && e->dev->timer_period) {
345 e->dev->timer_period = NANOSECONDS_PER_SECOND / 1000 /
346 e->dev->timer_period;
347 }
348
349 switch (e->dev->driver) {
350 case AUDIODEV_DRIVER_ALSA:
351 handle_alsa(e->dev);
352 break;
353
354 case AUDIODEV_DRIVER_COREAUDIO:
355 handle_coreaudio(e->dev);
356 break;
357
358 case AUDIODEV_DRIVER_DSOUND:
359 handle_dsound(e->dev);
360 break;
361
362 case AUDIODEV_DRIVER_OSS:
363 handle_oss(e->dev);
364 break;
365
366 case AUDIODEV_DRIVER_PA:
367 handle_pa(e->dev);
368 break;
369
370 case AUDIODEV_DRIVER_SDL:
371 handle_sdl(e->dev);
372 break;
373
374 case AUDIODEV_DRIVER_WAV:
375 handle_wav(e->dev);
376 break;
377
378 default:
379 break;
380 }
381
382 return e;
383 }
384
385 AudiodevListHead audio_handle_legacy_opts(void)
386 {
387 const char *drvname = getenv("QEMU_AUDIO_DRV");
388 AudiodevListHead head = QSIMPLEQ_HEAD_INITIALIZER(head);
389
390 if (drvname) {
391 AudiodevListEntry *e;
392 audio_driver *driver = audio_driver_lookup(drvname);
393 if (!driver) {
394 dolog("Unknown audio driver `%s'\n", drvname);
395 exit(1);
396 }
397 e = legacy_opt(drvname);
398 QSIMPLEQ_INSERT_TAIL(&head, e, next);
399 } else {
400 for (int i = 0; audio_prio_list[i]; i++) {
401 audio_driver *driver = audio_driver_lookup(audio_prio_list[i]);
402 if (driver && driver->can_be_default) {
403 AudiodevListEntry *e = legacy_opt(driver->name);
404 QSIMPLEQ_INSERT_TAIL(&head, e, next);
405 }
406 }
407 if (QSIMPLEQ_EMPTY(&head)) {
408 dolog("Internal error: no default audio driver available\n");
409 exit(1);
410 }
411 }
412
413 return head;
414 }
415
416 /* visitor to print -audiodev option */
417 typedef struct {
418 Visitor visitor;
419
420 bool comma;
421 GList *path;
422 } LegacyPrintVisitor;
423
424 static bool lv_start_struct(Visitor *v, const char *name, void **obj,
425 size_t size, Error **errp)
426 {
427 LegacyPrintVisitor *lv = (LegacyPrintVisitor *) v;
428 lv->path = g_list_append(lv->path, g_strdup(name));
429 return true;
430 }
431
432 static void lv_end_struct(Visitor *v, void **obj)
433 {
434 LegacyPrintVisitor *lv = (LegacyPrintVisitor *) v;
435 lv->path = g_list_delete_link(lv->path, g_list_last(lv->path));
436 }
437
438 static void lv_print_key(Visitor *v, const char *name)
439 {
440 GList *e;
441 LegacyPrintVisitor *lv = (LegacyPrintVisitor *) v;
442 if (lv->comma) {
443 putchar(',');
444 } else {
445 lv->comma = true;
446 }
447
448 for (e = lv->path; e; e = e->next) {
449 if (e->data) {
450 printf("%s.", (const char *) e->data);
451 }
452 }
453
454 printf("%s=", name);
455 }
456
457 static bool lv_type_int64(Visitor *v, const char *name, int64_t *obj,
458 Error **errp)
459 {
460 lv_print_key(v, name);
461 printf("%" PRIi64, *obj);
462 return true;
463 }
464
465 static bool lv_type_uint64(Visitor *v, const char *name, uint64_t *obj,
466 Error **errp)
467 {
468 lv_print_key(v, name);
469 printf("%" PRIu64, *obj);
470 return true;
471 }
472
473 static bool lv_type_bool(Visitor *v, const char *name, bool *obj, Error **errp)
474 {
475 lv_print_key(v, name);
476 printf("%s", *obj ? "on" : "off");
477 return true;
478 }
479
480 static bool lv_type_str(Visitor *v, const char *name, char **obj, Error **errp)
481 {
482 const char *str = *obj;
483 lv_print_key(v, name);
484
485 while (*str) {
486 if (*str == ',') {
487 putchar(',');
488 }
489 putchar(*str++);
490 }
491 return true;
492 }
493
494 static void lv_complete(Visitor *v, void *opaque)
495 {
496 LegacyPrintVisitor *lv = (LegacyPrintVisitor *) v;
497 assert(lv->path == NULL);
498 }
499
500 static void lv_free(Visitor *v)
501 {
502 LegacyPrintVisitor *lv = (LegacyPrintVisitor *) v;
503
504 g_list_free_full(lv->path, g_free);
505 g_free(lv);
506 }
507
508 static Visitor *legacy_visitor_new(void)
509 {
510 LegacyPrintVisitor *lv = g_malloc0(sizeof(LegacyPrintVisitor));
511
512 lv->visitor.start_struct = lv_start_struct;
513 lv->visitor.end_struct = lv_end_struct;
514 /* lists not supported */
515 lv->visitor.type_int64 = lv_type_int64;
516 lv->visitor.type_uint64 = lv_type_uint64;
517 lv->visitor.type_bool = lv_type_bool;
518 lv->visitor.type_str = lv_type_str;
519
520 lv->visitor.type = VISITOR_OUTPUT;
521 lv->visitor.complete = lv_complete;
522 lv->visitor.free = lv_free;
523
524 return &lv->visitor;
525 }
526
527 void audio_legacy_help(void)
528 {
529 AudiodevListHead head;
530 AudiodevListEntry *e;
531
532 printf("Environment variable based configuration deprecated.\n");
533 printf("Please use the new -audiodev option.\n");
534
535 head = audio_handle_legacy_opts();
536 printf("\nEquivalent -audiodev to your current environment variables:\n");
537 if (!getenv("QEMU_AUDIO_DRV")) {
538 printf("(Since you didn't specify QEMU_AUDIO_DRV, I'll list all "
539 "possibilities)\n");
540 }
541
542 QSIMPLEQ_FOREACH(e, &head, next) {
543 Visitor *v;
544 Audiodev *dev = e->dev;
545 printf("-audiodev ");
546
547 v = legacy_visitor_new();
548 visit_type_Audiodev(v, NULL, &dev, &error_abort);
549 visit_free(v);
550
551 printf("\n");
552 }
553 audio_free_audiodev_list(&head);
554 }