/**
* \file control/setup.c
* \brief Routines to setup control primitives from configuration
* \author Abramo Bagnara <abramo@alsa-project.org>
* \author Jaroslav Kysela <perex@perex.cz>
* \date 2001
*
* Routines to setup control primitives from configuration
*/
/*
* Control Interface - routines for setup from configuration
* Copyright (c) 2001 by Abramo Bagnara <abramo@alsa-project.org>
* Jaroslav Kysela <perex@perex.cz>
*
*
* This library is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <unistd.h>
#include <string.h>
#include <ctype.h>
#include "local.h"
#ifndef DOC_HIDDEN
typedef struct {
unsigned int lock: 1;
unsigned int preserve: 1;
snd_ctl_elem_id_t *id;
snd_ctl_elem_info_t *info;
snd_ctl_elem_value_t *val;
snd_ctl_elem_value_t *mask;
snd_ctl_elem_value_t *old;
struct list_head list;
} snd_sctl_elem_t;
struct _snd_sctl {
int mode;
snd_ctl_t *ctl;
struct list_head elems;
};
#endif /* DOC_HIDDEN */
static int free_elems(snd_sctl_t *h)
{
int err = 0;
while (!list_empty(&h->elems)) {
snd_sctl_elem_t *elem = list_entry(h->elems.next, snd_sctl_elem_t, list);
snd_ctl_elem_id_free(elem->id);
snd_ctl_elem_info_free(elem->info);
snd_ctl_elem_value_free(elem->val);
snd_ctl_elem_value_free(elem->mask);
snd_ctl_elem_value_free(elem->old);
list_del(&elem->list);
free(elem);
}
if ((h->mode & SND_SCTL_NOFREE) == 0)
err = snd_ctl_close(h->ctl);
free(h);
return err;
}
/**
* \brief Install given values to control elements
* \param h Setup control handle
* \result zero if success, otherwise a negative error code
*/
int snd_sctl_install(snd_sctl_t *h)
{
struct list_head *pos;
int err;
unsigned int k;
assert(h);
list_for_each(pos, &h->elems) {
snd_sctl_elem_t *elem = list_entry(pos, snd_sctl_elem_t, list);
unsigned int count;
snd_ctl_elem_type_t type;
if (elem->lock) {
err = snd_ctl_elem_lock(h->ctl, elem->id);
if (err < 0) {
SNDERR("Cannot lock ctl elem");
return err;
}
}
err = snd_ctl_elem_read(h->ctl, elem->old);
if (err < 0) {
SNDERR("Cannot read ctl elem");
return err;
}
count = snd_ctl_elem_info_get_count(elem->info);
type = snd_ctl_elem_info_get_type(elem->info);
switch (type) {
case SND_CTL_ELEM_TYPE_BOOLEAN:
for (k = 0; k < count; ++k) {
int old, val, mask;
old = snd_ctl_elem_value_get_boolean(elem->old, k);
mask = snd_ctl_elem_value_get_boolean(elem->mask, k);
old &= ~mask;
if (old) {
val = snd_ctl_elem_value_get_boolean(elem->val, k);
val |= old;
snd_ctl_elem_value_set_boolean(elem->val, k, val);
}
}
break;
case SND_CTL_ELEM_TYPE_INTEGER:
for (k = 0; k < count; ++k) {
long old, val, mask;
old = snd_ctl_elem_value_get_integer(elem->old, k);
mask = snd_ctl_elem_value_get_integer(elem->mask, k);
old &= ~mask;
if (old) {
val = snd_ctl_elem_value_get_integer(elem->val, k);
val |= old;
snd_ctl_elem_value_set_integer(elem->val, k, val);
}
}
break;
case SND_CTL_ELEM_TYPE_ENUMERATED:
for (k = 0; k < count; ++k) {
unsigned int old, val, mask;
old = snd_ctl_elem_value_get_enumerated(elem->old, k);
mask = snd_ctl_elem_value_get_enumerated(elem->mask, k);
old &= ~mask;
if (old) {
val = snd_ctl_elem_value_get_enumerated(elem->val, k);
val |= old;
snd_ctl_elem_value_set_enumerated(elem->val, k, val);
}
}
break;
case SND_CTL_ELEM_TYPE_IEC958:
count = sizeof(snd_aes_iec958_t);
/* Fall through */
case SND_CTL_ELEM_TYPE_BYTES:
for (k = 0; k < count; ++k) {
unsigned char old, val, mask;
old = snd_ctl_elem_value_get_byte(elem->old, k);
mask = snd_ctl_elem_value_get_byte(elem->mask, k);
old &= ~mask;
if (old) {
val = snd_ctl_elem_value_get_byte(elem->val, k);
val |= old;
snd_ctl_elem_value_set_byte(elem->val, k, val);
}
}
break;
default:
assert(0);
break;
}
err = snd_ctl_elem_write(h->ctl, elem->val);
if (err < 0) {
SNDERR("Cannot write ctl elem");
return err;
}
}
return 0;
}
/**
* \brief Remove (restore) previous values from control elements
* \param h Setup control handle
* \result zero if success, otherwise a negative error code
*/
int snd_sctl_remove(snd_sctl_t *h)
{
struct list_head *pos;
int err;
assert(h);
list_for_each(pos, &h->elems) {
snd_sctl_elem_t *elem = list_entry(pos, snd_sctl_elem_t, list);
if (elem->lock) {
err = snd_ctl_elem_unlock(h->ctl, elem->id);
if (err < 0) {
SNDERR("Cannot unlock ctl elem");
return err;
}
}
/* Only restore the old value if it differs from the requested
* value, because if it has changed restoring the old value
* overrides the change. Take for example, a voice modem with
* a .conf that sets preserve off-hook. Start playback (on-hook
* to off-hook), start record (off-hook to off-hook), stop
* playback (off-hook to restore on-hook), stop record (on-hook
* to restore off-hook), Clearly you don't want to leave the
* modem "on the phone" now that there isn't any playback or
* recording active.
*/
if (elem->preserve && snd_ctl_elem_value_compare(elem->val, elem->old)) {
err = snd_ctl_elem_write(h->ctl, elem->old);
if (err < 0) {
SNDERR("Cannot restore ctl elem");
return err;
}
}
}
return 0;
}
static int snd_config_get_ctl_elem_enumerated(snd_config_t *n, snd_ctl_t *ctl,
snd_ctl_elem_info_t *info)
{
const char *str;
long val;
unsigned int idx, items;
switch (snd_config_get_type(n)) {
case SND_CONFIG_TYPE_INTEGER:
snd_config_get_integer(n, &val);
return val;
case SND_CONFIG_TYPE_STRING:
snd_config_get_string(n, &str);
break;
default:
return -1;
}
items = snd_ctl_elem_info_get_items(info);
for (idx = 0; idx < items; idx++) {
int err;
snd_ctl_elem_info_set_item(info, idx);
err = snd_ctl_elem_info(ctl, info);
if (err < 0) {
SNDERR("Cannot obtain info for CTL elem");
return err;
}
if (strcmp(str, snd_ctl_elem_info_get_item_name(info)) == 0)
return idx;
}
return -1;
}
static int snd_config_get_ctl_elem_value(snd_config_t *conf,
snd_ctl_t *ctl,
snd_ctl_elem_value_t *val,
snd_ctl_elem_value_t *mask,
snd_ctl_elem_info_t *info)
{
int err;
snd_config_iterator_t i, next;
snd_ctl_elem_id_t id = {0};
snd_ctl_elem_type_t type;
unsigned int count;
long v;
long idx;
snd_ctl_elem_value_get_id(val, &id);
count = snd_ctl_elem_info_get_count(info);
type = snd_ctl_elem_info_get_type(info);
if (count == 1) {
switch (type) {
case SND_CTL_ELEM_TYPE_BOOLEAN:
v = snd_config_get_bool(conf);
if (v >= 0) {
snd_ctl_elem_value_set_boolean(val, 0, v);
if (mask)
snd_ctl_elem_value_set_boolean(mask, 0, 1);
return 0;
}
break;
case SND_CTL_ELEM_TYPE_INTEGER:
err = snd_config_get_integer(conf, &v);
if (err == 0) {
snd_ctl_elem_value_set_integer(val, 0, v);
if (mask)
snd_ctl_elem_value_set_integer(mask, 0, ~0L);
return 0;
}
break;
case SND_CTL_ELEM_TYPE_ENUMERATED:
v = snd_config_get_ctl_elem_enumerated(conf, ctl, info);
if (v >= 0) {
snd_ctl_elem_value_set_enumerated(val, 0, v);
if (mask)
snd_ctl_elem_value_set_enumerated(mask, 0, ~0);
return 0;
}
break;
case SND_CTL_ELEM_TYPE_BYTES:
case SND_CTL_ELEM_TYPE_IEC958:
break;
default:
SNDERR("Unknown control type: %d", type);
return -EINVAL;
}
}
switch (type) {
case SND_CTL_ELEM_TYPE_IEC958:
count = sizeof(snd_aes_iec958_t);
/* Fall through */
case SND_CTL_ELEM_TYPE_BYTES:
{
const char *buf;
err = snd_config_get_string(conf, &buf);
if (err >= 0) {
int c1 = 0;
unsigned int len = strlen(buf);
unsigned int idx = 0;
if (len % 2 != 0 || len > count * 2) {
_bad_content:
SNDERR("bad value content\n");
return -EINVAL;
}
while (*buf) {
int c = *buf++;
if (c >= '0' && c <= '9')
c -= '0';
else if (c >= 'a' && c <= 'f')
c = c - 'a' + 10;
else if (c >= 'A' && c <= 'F')
c = c - 'A' + 10;
else {
goto _bad_content;
}
if (idx % 2 == 1) {
snd_ctl_elem_value_set_byte(val, idx / 2, c1 << 4 | c);
if (mask)
snd_ctl_elem_value_set_byte(mask, idx / 2, 0xff);
} else
c1 = c;
idx++;
}
return 0;
}
}
default:
break;
}
if (snd_config_get_type(conf) != SND_CONFIG_TYPE_COMPOUND) {
SNDERR("bad value type");
return -EINVAL;
}
snd_config_for_each(i, next, conf) {
snd_config_t *n = snd_config_iterator_entry(i);
const char *id;
if (snd_config_get_id(n, &id) < 0)
continue;
err = safe_strtol(id, &idx);
if (err < 0 || idx < 0 || (unsigned int) idx >= count) {
SNDERR("bad value index");
return -EINVAL;
}
switch (type) {
case SND_CTL_ELEM_TYPE_BOOLEAN:
v = snd_config_get_bool(n);
if (v < 0)
goto _bad_content;
snd_ctl_elem_value_set_boolean(val, idx, v);
if (mask)
snd_ctl_elem_value_set_boolean(mask, idx, 1);
break;
case SND_CTL_ELEM_TYPE_INTEGER:
err = snd_config_get_integer(n, &v);
if (err < 0)
goto _bad_content;
snd_ctl_elem_value_set_integer(val, idx, v);
if (mask)
snd_ctl_elem_value_set_integer(mask, idx, ~0L);
break;
case SND_CTL_ELEM_TYPE_ENUMERATED:
v = snd_config_get_ctl_elem_enumerated(n, ctl, info);
if (v < 0)
goto _bad_content;
snd_ctl_elem_value_set_enumerated(val, idx, v);
if (mask)
snd_ctl_elem_value_set_enumerated(mask, idx, ~0);
break;
case SND_CTL_ELEM_TYPE_BYTES:
case SND_CTL_ELEM_TYPE_IEC958:
err = snd_config_get_integer(n, &v);
if (err < 0 || v < 0 || v > 255)
goto _bad_content;
snd_ctl_elem_value_set_byte(val, idx, v);
if (mask)
snd_ctl_elem_value_set_byte(mask, idx, 0xff);
break;
default:
break;
}
}
return 0;
}
static int add_elem(snd_sctl_t *h, snd_config_t *_conf, snd_config_t *private_data, int *quit)
{
snd_config_t *conf;
snd_config_iterator_t i, next;
int iface = SND_CTL_ELEM_IFACE_MIXER;
const char *name = NULL;
long index = 0;
long device = -1;
long subdevice = -1;
int lock = 0;
int preserve = 0;
int optional = 0;
int skip_rest = 0;
snd_config_t *value = NULL, *mask = NULL;
snd_sctl_elem_t *elem = NULL;
int err;
err = snd_config_expand(_conf, _conf, NULL, private_data, &conf);
if (err < 0)
return err;
snd_config_for_each(i, next, conf) {
snd_config_t *n = snd_config_iterator_entry(i);
const char *id;
if (snd_config_get_id(n, &id) < 0)
continue;
if (strcmp(id, "comment") == 0)
continue;
if (strcmp(id, "iface") == 0 || strcmp(id, "interface") == 0) {
const char *ptr;
if ((err = snd_config_get_string(n, &ptr)) < 0) {
SNDERR("field %s is not a string", id);
goto _err;
}
if ((err = snd_config_get_ctl_iface_ascii(ptr)) < 0) {
SNDERR("Invalid value for '%s'", id);
goto _err;
}
iface = err;
continue;
}
if (strcmp(id, "name") == 0) {
if ((err = snd_config_get_string(n, &name)) < 0) {
SNDERR("field %s is not a string", id);
goto _err;
}
continue;
}
if (strcmp(id, "index") == 0) {
if ((err = snd_config_get_integer(n, &index)) < 0) {
SNDERR("field %s is not an integer", id);
goto _err;
}
continue;
}
if (strcmp(id, "device") == 0) {
if ((err = snd_config_get_integer(n, &device)) < 0) {
SNDERR("field %s is not an integer", id);
goto _err;
}
continue;
}
if (strcmp(id, "subdevice") == 0) {
if ((err = snd_config_get_integer(n, &subdevice)) < 0) {
SNDERR("field %s is not an integer", id);
goto _err;
}
continue;
}
if (strcmp(id, "lock") == 0) {
err = snd_config_get_bool(n);
if (err < 0)
goto _err;
lock = err;
continue;
}
if (strcmp(id, "preserve") == 0) {
err = snd_config_get_bool(n);
if (err < 0)
goto _err;
preserve = err;
continue;
}
if (strcmp(id, "value") == 0) {
value = n;
continue;
}
if (strcmp(id, "mask") == 0) {
mask = n;
continue;
}
if (strcmp(id, "optional") == 0) {
err = snd_config_get_bool(n);
if (err < 0)
goto _err;
optional = err;
continue;
}
if (strcmp(id, "skip_rest") == 0) {
err = snd_config_get_bool(n);
if (err < 0)
goto _err;
skip_rest = err;
continue;
}
SNDERR("Unknown field %s", id);
return -EINVAL;
}
if (name == NULL) {
SNDERR("Missing control name");
err = -EINVAL;
goto _err;
}
if (value == NULL) {
SNDERR("Missing control value");
err = -EINVAL;
goto _err;
}
if (device < 0)
device = 0;
if (subdevice < 0)
subdevice = 0;
elem = calloc(1, sizeof(*elem));
if (!elem)
return -ENOMEM;
err = snd_ctl_elem_id_malloc(&elem->id);
if (err < 0)
goto _err;
err = snd_ctl_elem_info_malloc(&elem->info);
if (err < 0)
goto _err;
err = snd_ctl_elem_value_malloc(&elem->val);
if (err < 0)
goto _err;
err = snd_ctl_elem_value_malloc(&elem->mask);
if (err < 0)
goto _err;
err = snd_ctl_elem_value_malloc(&elem->old);
if (err < 0)
goto _err;
elem->lock = lock;
elem->preserve = preserve;
snd_ctl_elem_id_set_interface(elem->id, iface);
snd_ctl_elem_id_set_name(elem->id, name);
snd_ctl_elem_id_set_index(elem->id, index);
snd_ctl_elem_id_set_device(elem->id, device);
snd_ctl_elem_id_set_subdevice(elem->id, subdevice);
snd_ctl_elem_info_set_id(elem->info, elem->id);
err = snd_ctl_elem_info(h->ctl, elem->info);
if (err < 0) {
if (! optional)
SNDERR("Cannot obtain info for CTL elem (%s,'%s',%li,%li,%li): %s", snd_ctl_elem_iface_name(iface), name, index, device, subdevice, snd_strerror(err));
goto _err;
} else {
if (skip_rest)
*quit = 1;
}
snd_ctl_elem_value_set_id(elem->val, elem->id);
snd_ctl_elem_value_set_id(elem->old, elem->id);
if (mask) {
err = snd_config_get_ctl_elem_value(value, h->ctl, elem->val, NULL, elem->info);
if (err < 0)
goto _err;
err = snd_config_get_ctl_elem_value(mask, h->ctl, elem->mask, NULL, elem->info);
if (err < 0)
goto _err;
} else {
err = snd_config_get_ctl_elem_value(value, h->ctl, elem->val, elem->mask, elem->info);
if (err < 0)
goto _err;
}
err = snd_config_get_ctl_elem_value(value, h->ctl, elem->val, elem->mask, elem->info);
if (err < 0)
goto _err;
list_add_tail(&elem->list, &h->elems);
_err:
if (err < 0 && elem) {
if (elem->id)
snd_ctl_elem_id_free(elem->id);
if (elem->info)
snd_ctl_elem_info_free(elem->info);
if (elem->val)
snd_ctl_elem_value_free(elem->val);
if (elem->mask)
snd_ctl_elem_value_free(elem->mask);
if (elem->old)
snd_ctl_elem_value_free(elem->old);
free(elem);
if (err != -ENOMEM && optional)
err = 0; /* ignore the error */
}
if (conf)
snd_config_delete(conf);
return err;
}
/**
* \brief Build setup control handle
* \param sctl Result - setup control handle
* \param handle Master control handle
* \param conf Setup configuration
* \param private_data Private data for runtime evaluation
* \param mode Build mode - SND_SCTL_xxxx
* \result zero if success, otherwise a negative error code
*/
int snd_sctl_build(snd_sctl_t **sctl, snd_ctl_t *handle, snd_config_t *conf, snd_config_t *private_data, int mode)
{
snd_sctl_t *h;
snd_config_iterator_t i, next;
int err, quit = 0;
assert(sctl);
assert(handle);
assert(conf);
*sctl = NULL;
if (snd_config_get_type(conf) != SND_CONFIG_TYPE_COMPOUND)
return -EINVAL;
h = calloc(1, sizeof(*h));
if (!h) {
if (mode & SND_SCTL_NOFREE)
return -ENOMEM;
snd_ctl_close(handle);
return -ENOMEM;
}
h->mode = mode;
h->ctl = handle;
INIT_LIST_HEAD(&h->elems);
snd_config_for_each(i, next, conf) {
snd_config_t *n = snd_config_iterator_entry(i);
err = add_elem(h, n, private_data, &quit);
if (err < 0) {
free_elems(h);
return err;
}
if (quit)
break;
}
*sctl = h;
return 0;
}
/**
* \brief Free setup control handle
* \param sctl Setup control handle
* \result zero if success, otherwise a negative error code
*/
int snd_sctl_free(snd_sctl_t *sctl)
{
assert(sctl);
return free_elems(sctl);
}