[qemu.git] / audio / audio_legacy.c

/*
 * QEMU Audio subsystem: legacy configuration handling
 *
 * Copyright (c) 2015-2019 Zoltán Kővágó <[email protected]>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#include "qemu/osdep.h"
#include "audio.h"
#include "audio_int.h"
#include "qemu/cutils.h"
#include "qemu/timer.h"
#include "qapi/error.h"
#include "qapi/qapi-visit-audio.h"
#include "qapi/visitor-impl.h"

#define AUDIO_CAP "audio-legacy"
#include "audio_int.h"

static uint32_t toui32(const char *str)
{
    unsigned long long ret;
    if (parse_uint_full(str, &ret, 10) || ret > UINT32_MAX) {
        dolog("Invalid integer value `%s'\n", str);
        exit(1);
    }
    return ret;
}

/* helper functions to convert env variables */
static void get_bool(const char *env, bool *dst, bool *has_dst)
{
    const char *val = getenv(env);
    if (val) {
        *dst = toui32(val) != 0;
        *has_dst = true;
    }
}

static void get_int(const char *env, uint32_t *dst, bool *has_dst)
{
    const char *val = getenv(env);
    if (val) {
        *dst = toui32(val);
        *has_dst = true;
    }
}

static void get_str(const char *env, char **dst, bool *has_dst)
{
    const char *val = getenv(env);
    if (val) {
        if (*has_dst) {
            g_free(*dst);
        }
        *dst = g_strdup(val);
        *has_dst = true;
    }
}

static void get_fmt(const char *env, AudioFormat *dst, bool *has_dst)
{
    const char *val = getenv(env);
    if (val) {
        size_t i;
        for (i = 0; AudioFormat_lookup.size; ++i) {
            if (strcasecmp(val, AudioFormat_lookup.array[i]) == 0) {
                *dst = i;
                *has_dst = true;
                return;
            }
        }

        dolog("Invalid audio format `%s'\n", val);
        exit(1);
    }
}


static void get_millis_to_usecs(const char *env, uint32_t *dst, bool *has_dst)
{
    const char *val = getenv(env);
    if (val) {
        *dst = toui32(val) * 1000;
        *has_dst = true;
    }
}

static uint32_t frames_to_usecs(uint32_t frames,
                                AudiodevPerDirectionOptions *pdo)
{
    uint32_t freq = pdo->has_frequency ? pdo->frequency : 44100;
    return (frames * 1000000 + freq / 2) / freq;
}


static void get_frames_to_usecs(const char *env, uint32_t *dst, bool *has_dst,
                                AudiodevPerDirectionOptions *pdo)
{
    const char *val = getenv(env);
    if (val) {
        *dst = frames_to_usecs(toui32(val), pdo);
        *has_dst = true;
    }
}

static uint32_t samples_to_usecs(uint32_t samples,
                                 AudiodevPerDirectionOptions *pdo)
{
    uint32_t channels = pdo->has_channels ? pdo->channels : 2;
    return frames_to_usecs(samples / channels, pdo);
}

static void get_samples_to_usecs(const char *env, uint32_t *dst, bool *has_dst,
                                 AudiodevPerDirectionOptions *pdo)
{
    const char *val = getenv(env);
    if (val) {
        *dst = samples_to_usecs(toui32(val), pdo);
        *has_dst = true;
    }
}

static uint32_t bytes_to_usecs(uint32_t bytes, AudiodevPerDirectionOptions *pdo)
{
    AudioFormat fmt = pdo->has_format ? pdo->format : AUDIO_FORMAT_S16;
    uint32_t bytes_per_sample = audioformat_bytes_per_sample(fmt);
    return samples_to_usecs(bytes / bytes_per_sample, pdo);
}

static void get_bytes_to_usecs(const char *env, uint32_t *dst, bool *has_dst,
                               AudiodevPerDirectionOptions *pdo)
{
    const char *val = getenv(env);
    if (val) {
        *dst = bytes_to_usecs(toui32(val), pdo);
        *has_dst = true;
    }
}

/* backend specific functions */
/* ALSA */
static void handle_alsa_per_direction(
    AudiodevAlsaPerDirectionOptions *apdo, const char *prefix)
{
    char buf[64];
    size_t len = strlen(prefix);
    bool size_in_usecs = false;
    bool dummy;

    memcpy(buf, prefix, len);
    strcpy(buf + len, "TRY_POLL");
    get_bool(buf, &apdo->try_poll, &apdo->has_try_poll);

    strcpy(buf + len, "DEV");
    get_str(buf, &apdo->dev, &apdo->has_dev);

    strcpy(buf + len, "SIZE_IN_USEC");
    get_bool(buf, &size_in_usecs, &dummy);

    strcpy(buf + len, "PERIOD_SIZE");
    get_int(buf, &apdo->period_length, &apdo->has_period_length);
    if (apdo->has_period_length && !size_in_usecs) {
        apdo->period_length = frames_to_usecs(
            apdo->period_length,
            qapi_AudiodevAlsaPerDirectionOptions_base(apdo));
    }

    strcpy(buf + len, "BUFFER_SIZE");
    get_int(buf, &apdo->buffer_length, &apdo->has_buffer_length);
    if (apdo->has_buffer_length && !size_in_usecs) {
        apdo->buffer_length = frames_to_usecs(
            apdo->buffer_length,
            qapi_AudiodevAlsaPerDirectionOptions_base(apdo));
    }
}

static void handle_alsa(Audiodev *dev)
{
    AudiodevAlsaOptions *aopt = &dev->u.alsa;
    handle_alsa_per_direction(aopt->in, "QEMU_ALSA_ADC_");
    handle_alsa_per_direction(aopt->out, "QEMU_ALSA_DAC_");

    get_millis_to_usecs("QEMU_ALSA_THRESHOLD",
                        &aopt->threshold, &aopt->has_threshold);
}

/* coreaudio */
static void handle_coreaudio(Audiodev *dev)
{
    get_frames_to_usecs(
        "QEMU_COREAUDIO_BUFFER_SIZE",
        &dev->u.coreaudio.out->buffer_length,
        &dev->u.coreaudio.out->has_buffer_length,
        qapi_AudiodevCoreaudioPerDirectionOptions_base(dev->u.coreaudio.out));
    get_int("QEMU_COREAUDIO_BUFFER_COUNT",
            &dev->u.coreaudio.out->buffer_count,
            &dev->u.coreaudio.out->has_buffer_count);
}

/* dsound */
static void handle_dsound(Audiodev *dev)
{
    get_millis_to_usecs("QEMU_DSOUND_LATENCY_MILLIS",
                        &dev->u.dsound.latency, &dev->u.dsound.has_latency);
    get_bytes_to_usecs("QEMU_DSOUND_BUFSIZE_OUT",
                       &dev->u.dsound.out->buffer_length,
                       &dev->u.dsound.out->has_buffer_length,
                       dev->u.dsound.out);
    get_bytes_to_usecs("QEMU_DSOUND_BUFSIZE_IN",
                       &dev->u.dsound.in->buffer_length,
                       &dev->u.dsound.in->has_buffer_length,
                       dev->u.dsound.in);
}

/* OSS */
static void handle_oss_per_direction(
    AudiodevOssPerDirectionOptions *opdo, const char *try_poll_env,
    const char *dev_env)
{
    get_bool(try_poll_env, &opdo->try_poll, &opdo->has_try_poll);
    get_str(dev_env, &opdo->dev, &opdo->has_dev);

    get_bytes_to_usecs("QEMU_OSS_FRAGSIZE",
                       &opdo->buffer_length, &opdo->has_buffer_length,
                       qapi_AudiodevOssPerDirectionOptions_base(opdo));
    get_int("QEMU_OSS_NFRAGS", &opdo->buffer_count,
            &opdo->has_buffer_count);
}

static void handle_oss(Audiodev *dev)
{
    AudiodevOssOptions *oopt = &dev->u.oss;
    handle_oss_per_direction(oopt->in, "QEMU_AUDIO_ADC_TRY_POLL",
                             "QEMU_OSS_ADC_DEV");
    handle_oss_per_direction(oopt->out, "QEMU_AUDIO_DAC_TRY_POLL",
                             "QEMU_OSS_DAC_DEV");

    get_bool("QEMU_OSS_MMAP", &oopt->try_mmap, &oopt->has_try_mmap);
    get_bool("QEMU_OSS_EXCLUSIVE", &oopt->exclusive, &oopt->has_exclusive);
    get_int("QEMU_OSS_POLICY", &oopt->dsp_policy, &oopt->has_dsp_policy);
}

/* pulseaudio */
static void handle_pa_per_direction(
    AudiodevPaPerDirectionOptions *ppdo, const char *env)
{
    get_str(env, &ppdo->name, &ppdo->has_name);
}

static void handle_pa(Audiodev *dev)
{
    handle_pa_per_direction(dev->u.pa.in, "QEMU_PA_SOURCE");
    handle_pa_per_direction(dev->u.pa.out, "QEMU_PA_SINK");

    get_samples_to_usecs(
        "QEMU_PA_SAMPLES", &dev->u.pa.in->buffer_length,
        &dev->u.pa.in->has_buffer_length,
        qapi_AudiodevPaPerDirectionOptions_base(dev->u.pa.in));
    get_samples_to_usecs(
        "QEMU_PA_SAMPLES", &dev->u.pa.out->buffer_length,
        &dev->u.pa.out->has_buffer_length,
        qapi_AudiodevPaPerDirectionOptions_base(dev->u.pa.out));

    get_str("QEMU_PA_SERVER", &dev->u.pa.server, &dev->u.pa.has_server);
}

/* SDL */
static void handle_sdl(Audiodev *dev)
{
    /* SDL is output only */
    get_samples_to_usecs("QEMU_SDL_SAMPLES", &dev->u.sdl.out->buffer_length,
                         &dev->u.sdl.out->has_buffer_length, dev->u.sdl.out);
}

/* wav */
static void handle_wav(Audiodev *dev)
{
    get_int("QEMU_WAV_FREQUENCY",
            &dev->u.wav.out->frequency, &dev->u.wav.out->has_frequency);
    get_fmt("QEMU_WAV_FORMAT", &dev->u.wav.out->format,
            &dev->u.wav.out->has_format);
    get_int("QEMU_WAV_DAC_FIXED_CHANNELS",
            &dev->u.wav.out->channels, &dev->u.wav.out->has_channels);
    get_str("QEMU_WAV_PATH", &dev->u.wav.path, &dev->u.wav.has_path);
}

/* general */
static void handle_per_direction(
    AudiodevPerDirectionOptions *pdo, const char *prefix)
{
    char buf[64];
    size_t len = strlen(prefix);

    memcpy(buf, prefix, len);
    strcpy(buf + len, "FIXED_SETTINGS");
    get_bool(buf, &pdo->fixed_settings, &pdo->has_fixed_settings);

    strcpy(buf + len, "FIXED_FREQ");
    get_int(buf, &pdo->frequency, &pdo->has_frequency);

    strcpy(buf + len, "FIXED_FMT");
    get_fmt(buf, &pdo->format, &pdo->has_format);

    strcpy(buf + len, "FIXED_CHANNELS");
    get_int(buf, &pdo->channels, &pdo->has_channels);

    strcpy(buf + len, "VOICES");
    get_int(buf, &pdo->voices, &pdo->has_voices);
}

static AudiodevListEntry *legacy_opt(const char *drvname)
{
    AudiodevListEntry *e = g_malloc0(sizeof(AudiodevListEntry));
    e->dev = g_malloc0(sizeof(Audiodev));
    e->dev->id = g_strdup(drvname);
    e->dev->driver = qapi_enum_parse(
        &AudiodevDriver_lookup, drvname, -1, &error_abort);

    audio_create_pdos(e->dev);

    handle_per_direction(audio_get_pdo_in(e->dev), "QEMU_AUDIO_ADC_");
    handle_per_direction(audio_get_pdo_out(e->dev), "QEMU_AUDIO_DAC_");

    /* Original description: Timer period in HZ (0 - use lowest possible) */
    get_int("QEMU_AUDIO_TIMER_PERIOD",
            &e->dev->timer_period, &e->dev->has_timer_period);
    if (e->dev->has_timer_period && e->dev->timer_period) {
        e->dev->timer_period = NANOSECONDS_PER_SECOND / 1000 /
                               e->dev->timer_period;
    }

    switch (e->dev->driver) {
    case AUDIODEV_DRIVER_ALSA:
        handle_alsa(e->dev);
        break;

    case AUDIODEV_DRIVER_COREAUDIO:
        handle_coreaudio(e->dev);
        break;

    case AUDIODEV_DRIVER_DSOUND:
        handle_dsound(e->dev);
        break;

    case AUDIODEV_DRIVER_OSS:
        handle_oss(e->dev);
        break;

    case AUDIODEV_DRIVER_PA:
        handle_pa(e->dev);
        break;

    case AUDIODEV_DRIVER_SDL:
        handle_sdl(e->dev);
        break;

    case AUDIODEV_DRIVER_WAV:
        handle_wav(e->dev);
        break;

    default:
        break;
    }

    return e;
}

AudiodevListHead audio_handle_legacy_opts(void)
{
    const char *drvname = getenv("QEMU_AUDIO_DRV");
    AudiodevListHead head = QSIMPLEQ_HEAD_INITIALIZER(head);

    if (drvname) {
        AudiodevListEntry *e;
        audio_driver *driver = audio_driver_lookup(drvname);
        if (!driver) {
            dolog("Unknown audio driver `%s'\n", drvname);
            exit(1);
        }
        e = legacy_opt(drvname);
        QSIMPLEQ_INSERT_TAIL(&head, e, next);
    } else {
        for (int i = 0; audio_prio_list[i]; i++) {
            audio_driver *driver = audio_driver_lookup(audio_prio_list[i]);
            if (driver && driver->can_be_default) {
                AudiodevListEntry *e = legacy_opt(driver->name);
                QSIMPLEQ_INSERT_TAIL(&head, e, next);
            }
        }
        if (QSIMPLEQ_EMPTY(&head)) {
            dolog("Internal error: no default audio driver available\n");
            exit(1);
        }
    }

    return head;
}

/* visitor to print -audiodev option */
typedef struct {
    Visitor visitor;

    bool comma;
    GList *path;
} LegacyPrintVisitor;

static void lv_start_struct(Visitor *v, const char *name, void **obj,
                            size_t size, Error **errp)
{
    LegacyPrintVisitor *lv = (LegacyPrintVisitor *) v;
    lv->path = g_list_append(lv->path, g_strdup(name));
}

static void lv_end_struct(Visitor *v, void **obj)
{
    LegacyPrintVisitor *lv = (LegacyPrintVisitor *) v;
    lv->path = g_list_delete_link(lv->path, g_list_last(lv->path));
}

static void lv_print_key(Visitor *v, const char *name)
{
    GList *e;
    LegacyPrintVisitor *lv = (LegacyPrintVisitor *) v;
    if (lv->comma) {
        putchar(',');
    } else {
        lv->comma = true;
    }

    for (e = lv->path; e; e = e->next) {
        if (e->data) {
            printf("%s.", (const char *) e->data);
        }
    }

    printf("%s=", name);
}

static void lv_type_int64(Visitor *v, const char *name, int64_t *obj,
                          Error **errp)
{
    lv_print_key(v, name);
    printf("%" PRIi64, *obj);
}

static void lv_type_uint64(Visitor *v, const char *name, uint64_t *obj,
                           Error **errp)
{
    lv_print_key(v, name);
    printf("%" PRIu64, *obj);
}

static void lv_type_bool(Visitor *v, const char *name, bool *obj, Error **errp)
{
    lv_print_key(v, name);
    printf("%s", *obj ? "on" : "off");
}

static void lv_type_str(Visitor *v, const char *name, char **obj, Error **errp)
{
    const char *str = *obj;
    lv_print_key(v, name);

    while (*str) {
        if (*str == ',') {
            putchar(',');
        }
        putchar(*str++);
    }
}

static void lv_complete(Visitor *v, void *opaque)
{
    LegacyPrintVisitor *lv = (LegacyPrintVisitor *) v;
    assert(lv->path == NULL);
}

static void lv_free(Visitor *v)
{
    LegacyPrintVisitor *lv = (LegacyPrintVisitor *) v;

    g_list_free_full(lv->path, g_free);
    g_free(lv);
}

static Visitor *legacy_visitor_new(void)
{
    LegacyPrintVisitor *lv = g_malloc0(sizeof(LegacyPrintVisitor));

    lv->visitor.start_struct = lv_start_struct;
    lv->visitor.end_struct = lv_end_struct;
    /* lists not supported */
    lv->visitor.type_int64 = lv_type_int64;
    lv->visitor.type_uint64 = lv_type_uint64;
    lv->visitor.type_bool = lv_type_bool;
    lv->visitor.type_str = lv_type_str;

    lv->visitor.type = VISITOR_OUTPUT;
    lv->visitor.complete = lv_complete;
    lv->visitor.free = lv_free;

    return &lv->visitor;
}

void audio_legacy_help(void)
{
    AudiodevListHead head;
    AudiodevListEntry *e;

    printf("Environment variable based configuration deprecated.\n");
    printf("Please use the new -audiodev option.\n");

    head = audio_handle_legacy_opts();
    printf("\nEquivalent -audiodev to your current environment variables:\n");
    if (!getenv("QEMU_AUDIO_DRV")) {
        printf("(Since you didn't specify QEMU_AUDIO_DRV, I'll list all "
               "possibilities)\n");
    }

    QSIMPLEQ_FOREACH(e, &head, next) {
        Visitor *v;
        Audiodev *dev = e->dev;
        printf("-audiodev ");

        v = legacy_visitor_new();
        visit_type_Audiodev(v, NULL, &dev, &error_abort);
        visit_free(v);

        printf("\n");
    }
    audio_free_audiodev_list(&head);
}
Commit	Line	Data
71830221 KZ	1	/*
	2	* QEMU Audio subsystem: legacy configuration handling
	3	*
	4	* Copyright (c) 2015-2019 Zoltán Kővágó <[email protected]>
	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"
71830221	27	#include "qemu/cutils.h"
be1092af	28	#include "qemu/timer.h"
71830221 KZ	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
a93f3281 KZ	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
71830221 KZ	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
a93f3281 KZ	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
17c56dc1 KZ	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
4a3b8b34 KZ	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
2c324b28 KZ	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
4a3b8b34 KZ	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
71830221	157	/* backend specific functions */
a93f3281 KZ	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	}
71830221	203
17c56dc1 KZ	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
4a3b8b34 KZ	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
baf6c7f4 KZ	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
2c324b28 KZ	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
57dea553 KZ	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
0927d166 KZ	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
71830221 KZ	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
be1092af	341	/* Original description: Timer period in HZ (0 - use lowest possible) */
71830221 KZ	342	get_int("QEMU_AUDIO_TIMER_PERIOD",
71830221 KZ	343	&e->dev->timer_period, &e->dev->has_timer_period);
be1092af VR	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	}
71830221	348
a93f3281 KZ	349	switch (e->dev->driver) {
	350	case AUDIODEV_DRIVER_ALSA:
	351	handle_alsa(e->dev);
	352	break;
	353
17c56dc1 KZ	354	case AUDIODEV_DRIVER_COREAUDIO:
	355	handle_coreaudio(e->dev);
	356	break;
	357
4a3b8b34 KZ	358	case AUDIODEV_DRIVER_DSOUND:
	359	handle_dsound(e->dev);
	360	break;
	361
baf6c7f4 KZ	362	case AUDIODEV_DRIVER_OSS:
	363	handle_oss(e->dev);
	364	break;
	365
2c324b28 KZ	366	case AUDIODEV_DRIVER_PA:
	367	handle_pa(e->dev);
	368	break;
	369
57dea553 KZ	370	case AUDIODEV_DRIVER_SDL:
	371	handle_sdl(e->dev);
	372	break;
	373
0927d166 KZ	374	case AUDIODEV_DRIVER_WAV:
	375	handle_wav(e->dev);
	376	break;
	377
a93f3281 KZ	378	default:
	379	break;
	380	}
	381
71830221 KZ	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 void 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	}
	430
	431	static void lv_end_struct(Visitor v, void *obj)
	432	{
	433	LegacyPrintVisitor lv = (LegacyPrintVisitor ) v;
	434	lv->path = g_list_delete_link(lv->path, g_list_last(lv->path));
	435	}
	436
	437	static void lv_print_key(Visitor v, const char name)
	438	{
	439	GList *e;
	440	LegacyPrintVisitor lv = (LegacyPrintVisitor ) v;
	441	if (lv->comma) {
	442	putchar(',');
	443	} else {
	444	lv->comma = true;
	445	}
446
447	for (e = lv->path; e; e = e->next) {
448	if (e->data) {
449	printf("%s.", (const char *) e->data);
450	}
451	}
452
453	printf("%s=", name);
454	}
455
456	static void lv_type_int64(Visitor v, const char name, int64_t *obj,
457	Error **errp)
458	{
459	lv_print_key(v, name);
460	printf("%" PRIi64, *obj);
461	}
462
463	static void lv_type_uint64(Visitor v, const char name, uint64_t *obj,
464	Error **errp)
465	{
466	lv_print_key(v, name);
467	printf("%" PRIu64, *obj);
468	}
469
470	static void lv_type_bool(Visitor v, const char name, bool obj, Error *errp)
471	{
472	lv_print_key(v, name);
473	printf("%s", *obj ? "on" : "off");
474	}
475
476	static void lv_type_str(Visitor v, const char name, char obj, Error errp)
477	{
478	const char str = obj;
479	lv_print_key(v, name);
480
481	while (*str) {
482	if (*str == ',') {
483	putchar(',');
484	}
485	putchar(*str++);
486	}
487	}
488
489	static void lv_complete(Visitor v, void opaque)
490	{
491	LegacyPrintVisitor lv = (LegacyPrintVisitor ) v;
492	assert(lv->path == NULL);
493	}
494
495	static void lv_free(Visitor *v)
496	{
497	LegacyPrintVisitor lv = (LegacyPrintVisitor ) v;
498
499	g_list_free_full(lv->path, g_free);
500	g_free(lv);
501	}
502
503	static Visitor *legacy_visitor_new(void)
504	{
505	LegacyPrintVisitor *lv = g_malloc0(sizeof(LegacyPrintVisitor));
506
507	lv->visitor.start_struct = lv_start_struct;
508	lv->visitor.end_struct = lv_end_struct;
509	/* lists not supported */
510	lv->visitor.type_int64 = lv_type_int64;
511	lv->visitor.type_uint64 = lv_type_uint64;
512	lv->visitor.type_bool = lv_type_bool;
513	lv->visitor.type_str = lv_type_str;
514
515	lv->visitor.type = VISITOR_OUTPUT;
516	lv->visitor.complete = lv_complete;
517	lv->visitor.free = lv_free;
518
519	return &lv->visitor;
520	}
521
522	void audio_legacy_help(void)
523	{
524	AudiodevListHead head;
525	AudiodevListEntry *e;
526
527	printf("Environment variable based configuration deprecated.\n");
528	printf("Please use the new -audiodev option.\n");
529
530	head = audio_handle_legacy_opts();
531	printf("\nEquivalent -audiodev to your current environment variables:\n");
532	if (!getenv("QEMU_AUDIO_DRV")) {
533	printf("(Since you didn't specify QEMU_AUDIO_DRV, I'll list all "
534	"possibilities)\n");
535	}
536
537	QSIMPLEQ_FOREACH(e, &head, next) {
538	Visitor *v;
539	Audiodev *dev = e->dev;
540	printf("-audiodev ");
541
542	v = legacy_visitor_new();
543	visit_type_Audiodev(v, NULL, &dev, &error_abort);
544	visit_free(v);
545
546	printf("\n");
547	}
548	audio_free_audiodev_list(&head);
549	}