audio_legacy.c (16159B)
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, 290 qapi_AudiodevSdlPerDirectionOptions_base(dev->u.sdl.out)); 291 } 292 293 /* wav */ 294 static void handle_wav(Audiodev *dev) 295 { 296 get_int("QEMU_WAV_FREQUENCY", 297 &dev->u.wav.out->frequency, &dev->u.wav.out->has_frequency); 298 get_fmt("QEMU_WAV_FORMAT", &dev->u.wav.out->format, 299 &dev->u.wav.out->has_format); 300 get_int("QEMU_WAV_DAC_FIXED_CHANNELS", 301 &dev->u.wav.out->channels, &dev->u.wav.out->has_channels); 302 get_str("QEMU_WAV_PATH", &dev->u.wav.path, &dev->u.wav.has_path); 303 } 304 305 /* general */ 306 static void handle_per_direction( 307 AudiodevPerDirectionOptions *pdo, const char *prefix) 308 { 309 char buf[64]; 310 size_t len = strlen(prefix); 311 312 memcpy(buf, prefix, len); 313 strcpy(buf + len, "FIXED_SETTINGS"); 314 get_bool(buf, &pdo->fixed_settings, &pdo->has_fixed_settings); 315 316 strcpy(buf + len, "FIXED_FREQ"); 317 get_int(buf, &pdo->frequency, &pdo->has_frequency); 318 319 strcpy(buf + len, "FIXED_FMT"); 320 get_fmt(buf, &pdo->format, &pdo->has_format); 321 322 strcpy(buf + len, "FIXED_CHANNELS"); 323 get_int(buf, &pdo->channels, &pdo->has_channels); 324 325 strcpy(buf + len, "VOICES"); 326 get_int(buf, &pdo->voices, &pdo->has_voices); 327 } 328 329 static AudiodevListEntry *legacy_opt(const char *drvname) 330 { 331 AudiodevListEntry *e = g_new0(AudiodevListEntry, 1); 332 e->dev = g_new0(Audiodev, 1); 333 e->dev->id = g_strdup(drvname); 334 e->dev->driver = qapi_enum_parse( 335 &AudiodevDriver_lookup, drvname, -1, &error_abort); 336 337 audio_create_pdos(e->dev); 338 339 handle_per_direction(audio_get_pdo_in(e->dev), "QEMU_AUDIO_ADC_"); 340 handle_per_direction(audio_get_pdo_out(e->dev), "QEMU_AUDIO_DAC_"); 341 342 /* Original description: Timer period in HZ (0 - use lowest possible) */ 343 get_int("QEMU_AUDIO_TIMER_PERIOD", 344 &e->dev->timer_period, &e->dev->has_timer_period); 345 if (e->dev->has_timer_period && e->dev->timer_period) { 346 e->dev->timer_period = NANOSECONDS_PER_SECOND / 1000 / 347 e->dev->timer_period; 348 } 349 350 switch (e->dev->driver) { 351 case AUDIODEV_DRIVER_ALSA: 352 handle_alsa(e->dev); 353 break; 354 355 case AUDIODEV_DRIVER_COREAUDIO: 356 handle_coreaudio(e->dev); 357 break; 358 359 case AUDIODEV_DRIVER_DSOUND: 360 handle_dsound(e->dev); 361 break; 362 363 case AUDIODEV_DRIVER_OSS: 364 handle_oss(e->dev); 365 break; 366 367 case AUDIODEV_DRIVER_PA: 368 handle_pa(e->dev); 369 break; 370 371 case AUDIODEV_DRIVER_SDL: 372 handle_sdl(e->dev); 373 break; 374 375 case AUDIODEV_DRIVER_WAV: 376 handle_wav(e->dev); 377 break; 378 379 default: 380 break; 381 } 382 383 return e; 384 } 385 386 AudiodevListHead audio_handle_legacy_opts(void) 387 { 388 const char *drvname = getenv("QEMU_AUDIO_DRV"); 389 AudiodevListHead head = QSIMPLEQ_HEAD_INITIALIZER(head); 390 391 if (drvname) { 392 AudiodevListEntry *e; 393 audio_driver *driver = audio_driver_lookup(drvname); 394 if (!driver) { 395 dolog("Unknown audio driver `%s'\n", drvname); 396 exit(1); 397 } 398 e = legacy_opt(drvname); 399 QSIMPLEQ_INSERT_TAIL(&head, e, next); 400 } else { 401 for (int i = 0; audio_prio_list[i]; i++) { 402 audio_driver *driver = audio_driver_lookup(audio_prio_list[i]); 403 if (driver && driver->can_be_default) { 404 AudiodevListEntry *e = legacy_opt(driver->name); 405 QSIMPLEQ_INSERT_TAIL(&head, e, next); 406 } 407 } 408 if (QSIMPLEQ_EMPTY(&head)) { 409 dolog("Internal error: no default audio driver available\n"); 410 exit(1); 411 } 412 } 413 414 return head; 415 } 416 417 /* visitor to print -audiodev option */ 418 typedef struct { 419 Visitor visitor; 420 421 bool comma; 422 GList *path; 423 } LegacyPrintVisitor; 424 425 static bool lv_start_struct(Visitor *v, const char *name, void **obj, 426 size_t size, Error **errp) 427 { 428 LegacyPrintVisitor *lv = (LegacyPrintVisitor *) v; 429 lv->path = g_list_append(lv->path, g_strdup(name)); 430 return true; 431 } 432 433 static void lv_end_struct(Visitor *v, void **obj) 434 { 435 LegacyPrintVisitor *lv = (LegacyPrintVisitor *) v; 436 lv->path = g_list_delete_link(lv->path, g_list_last(lv->path)); 437 } 438 439 static void lv_print_key(Visitor *v, const char *name) 440 { 441 GList *e; 442 LegacyPrintVisitor *lv = (LegacyPrintVisitor *) v; 443 if (lv->comma) { 444 putchar(','); 445 } else { 446 lv->comma = true; 447 } 448 449 for (e = lv->path; e; e = e->next) { 450 if (e->data) { 451 printf("%s.", (const char *) e->data); 452 } 453 } 454 455 printf("%s=", name); 456 } 457 458 static bool lv_type_int64(Visitor *v, const char *name, int64_t *obj, 459 Error **errp) 460 { 461 lv_print_key(v, name); 462 printf("%" PRIi64, *obj); 463 return true; 464 } 465 466 static bool lv_type_uint64(Visitor *v, const char *name, uint64_t *obj, 467 Error **errp) 468 { 469 lv_print_key(v, name); 470 printf("%" PRIu64, *obj); 471 return true; 472 } 473 474 static bool lv_type_bool(Visitor *v, const char *name, bool *obj, Error **errp) 475 { 476 lv_print_key(v, name); 477 printf("%s", *obj ? "on" : "off"); 478 return true; 479 } 480 481 static bool lv_type_str(Visitor *v, const char *name, char **obj, Error **errp) 482 { 483 const char *str = *obj; 484 lv_print_key(v, name); 485 486 while (*str) { 487 if (*str == ',') { 488 putchar(','); 489 } 490 putchar(*str++); 491 } 492 return true; 493 } 494 495 static void lv_complete(Visitor *v, void *opaque) 496 { 497 LegacyPrintVisitor *lv = (LegacyPrintVisitor *) v; 498 assert(lv->path == NULL); 499 } 500 501 static void lv_free(Visitor *v) 502 { 503 LegacyPrintVisitor *lv = (LegacyPrintVisitor *) v; 504 505 g_list_free_full(lv->path, g_free); 506 g_free(lv); 507 } 508 509 static Visitor *legacy_visitor_new(void) 510 { 511 LegacyPrintVisitor *lv = g_new0(LegacyPrintVisitor, 1); 512 513 lv->visitor.start_struct = lv_start_struct; 514 lv->visitor.end_struct = lv_end_struct; 515 /* lists not supported */ 516 lv->visitor.type_int64 = lv_type_int64; 517 lv->visitor.type_uint64 = lv_type_uint64; 518 lv->visitor.type_bool = lv_type_bool; 519 lv->visitor.type_str = lv_type_str; 520 521 lv->visitor.type = VISITOR_OUTPUT; 522 lv->visitor.complete = lv_complete; 523 lv->visitor.free = lv_free; 524 525 return &lv->visitor; 526 } 527 528 void audio_legacy_help(void) 529 { 530 AudiodevListHead head; 531 AudiodevListEntry *e; 532 533 printf("Environment variable based configuration deprecated.\n"); 534 printf("Please use the new -audiodev option.\n"); 535 536 head = audio_handle_legacy_opts(); 537 printf("\nEquivalent -audiodev to your current environment variables:\n"); 538 if (!getenv("QEMU_AUDIO_DRV")) { 539 printf("(Since you didn't specify QEMU_AUDIO_DRV, I'll list all " 540 "possibilities)\n"); 541 } 542 543 QSIMPLEQ_FOREACH(e, &head, next) { 544 Visitor *v; 545 Audiodev *dev = e->dev; 546 printf("-audiodev "); 547 548 v = legacy_visitor_new(); 549 visit_type_Audiodev(v, NULL, &dev, &error_abort); 550 visit_free(v); 551 552 printf("\n"); 553 } 554 audio_free_audiodev_list(&head); 555 }