556 lines
16 KiB
C
556 lines
16 KiB
C
/*
|
|
* QEMU Audio subsystem: legacy configuration handling
|
|
*
|
|
* Copyright (c) 2015-2019 Zoltán Kővágó <DirtY.iCE.hu@gmail.com>
|
|
*
|
|
* 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,
|
|
qapi_AudiodevSdlPerDirectionOptions_base(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 bool 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));
|
|
return true;
|
|
}
|
|
|
|
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 bool lv_type_int64(Visitor *v, const char *name, int64_t *obj,
|
|
Error **errp)
|
|
{
|
|
lv_print_key(v, name);
|
|
printf("%" PRIi64, *obj);
|
|
return true;
|
|
}
|
|
|
|
static bool lv_type_uint64(Visitor *v, const char *name, uint64_t *obj,
|
|
Error **errp)
|
|
{
|
|
lv_print_key(v, name);
|
|
printf("%" PRIu64, *obj);
|
|
return true;
|
|
}
|
|
|
|
static bool lv_type_bool(Visitor *v, const char *name, bool *obj, Error **errp)
|
|
{
|
|
lv_print_key(v, name);
|
|
printf("%s", *obj ? "on" : "off");
|
|
return true;
|
|
}
|
|
|
|
static bool 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++);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
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);
|
|
}
|