qemu/audio/audio_legacy.c
<<
>>
Prefs
   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
  36static 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 */
  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, 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
  77static 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
  96static 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
 105static 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
 113static 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
 123static 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
 130static 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
 140static 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
 147static 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 */
 159static 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
 194static 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 */
 205static 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 */
 218static 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 */
 233static 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
 247static 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 */
 261static void handle_pa_per_direction(
 262    AudiodevPaPerDirectionOptions *ppdo, const char *env)
 263{
 264    get_str(env, &ppdo->name, &ppdo->has_name);
 265}
 266
 267static 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 */
 285static 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 */
 294static 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 */
 306static 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
 329static 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
 386AudiodevListHead 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 */
 418typedef struct {
 419    Visitor visitor;
 420
 421    bool comma;
 422    GList *path;
 423} LegacyPrintVisitor;
 424
 425static 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
 433static 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
 439static 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
 458static 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
 466static 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
 474static 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
 481static 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
 495static void lv_complete(Visitor *v, void *opaque)
 496{
 497    LegacyPrintVisitor *lv = (LegacyPrintVisitor *) v;
 498    assert(lv->path == NULL);
 499}
 500
 501static 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
 509static 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
 528void 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}
 556