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 }