/**
* \file control/tlv.c
* \brief dB conversion functions from control TLV information
* \author Takashi Iwai <tiwai@suse.de>
* \date 2007
*/
/*
* Control Interface - dB conversion functions from control TLV information
*
* Copyright (c) 2007 Takashi Iwai <tiwai@suse.de>
*
*
* 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 <unistd.h>
#include <string.h>
#ifndef HAVE_SOFT_FLOAT
#include <math.h>
#endif
#include "control_local.h"
#ifndef DOC_HIDDEN
/* convert to index of integer array */
#define int_index(size) (((size) + sizeof(int) - 1) / sizeof(int))
/* max size of a TLV entry for dB information (including compound one) */
#define MAX_TLV_RANGE_SIZE 256
#endif
/**
* \brief Parse TLV stream and retrieve dB information
* \param tlv the TLV source
* \param tlv_size the byte size of TLV source
* \param db_tlvp the pointer stored the dB TLV information
* \return the byte size of dB TLV information if found in the given
* TLV source, or a negative error code.
*
* This function parses the given TLV source and stores the TLV start
* point if the TLV information regarding dB conversion is found.
* The stored TLV pointer can be passed to the convesion functions
* #snd_tlv_convert_to_dB(), #snd_tlv_convert_from_dB() and
* #snd_tlv_get_dB_range().
*/
int snd_tlv_parse_dB_info(unsigned int *tlv,
unsigned int tlv_size,
unsigned int **db_tlvp)
{
unsigned int type;
unsigned int size;
int err;
*db_tlvp = NULL;
type = tlv[SNDRV_CTL_TLVO_TYPE];
size = tlv[SNDRV_CTL_TLVO_LEN];
tlv_size -= 2 * sizeof(int);
if (size > tlv_size) {
SNDERR("TLV size error");
return -EINVAL;
}
switch (type) {
case SND_CTL_TLVT_CONTAINER:
size = int_index(size) * sizeof(int);
tlv += 2;
while (size > 0) {
unsigned int len;
err = snd_tlv_parse_dB_info(tlv, size, db_tlvp);
if (err < 0)
return err; /* error */
if (err > 0)
return err; /* found */
len = int_index(tlv[SNDRV_CTL_TLVO_LEN]) + 2;
size -= len * sizeof(int);
tlv += len;
}
break;
case SND_CTL_TLVT_DB_SCALE:
case SND_CTL_TLVT_DB_MINMAX:
case SND_CTL_TLVT_DB_MINMAX_MUTE:
#ifndef HAVE_SOFT_FLOAT
case SND_CTL_TLVT_DB_LINEAR:
#endif
case SND_CTL_TLVT_DB_RANGE: {
unsigned int minsize;
if (type == SND_CTL_TLVT_DB_RANGE)
minsize = 4 * sizeof(int);
else
minsize = 2 * sizeof(int);
if (size < minsize) {
SNDERR("Invalid dB_scale TLV size");
return -EINVAL;
}
if (size > MAX_TLV_RANGE_SIZE) {
SNDERR("Too big dB_scale TLV size: %d", size);
return -EINVAL;
}
*db_tlvp = tlv;
return size + sizeof(int) * 2;
}
default:
break;
}
return -EINVAL; /* not found */
}
/**
* \brief Get the dB min/max values
* \param tlv the TLV source returned by #snd_tlv_parse_dB_info()
* \param rangemin the minimum value of the raw volume
* \param rangemax the maximum value of the raw volume
* \param min the pointer to store the minimum dB value (in 0.01dB unit)
* \param max the pointer to store the maximum dB value (in 0.01dB unit)
* \return 0 if successful, or a negative error code
*/
int snd_tlv_get_dB_range(unsigned int *tlv, long rangemin, long rangemax,
long *min, long *max)
{
int err;
switch (tlv[SNDRV_CTL_TLVO_TYPE]) {
case SND_CTL_TLVT_DB_RANGE: {
unsigned int pos, len;
len = int_index(tlv[SNDRV_CTL_TLVO_LEN]);
if (len > MAX_TLV_RANGE_SIZE)
return -EINVAL;
pos = 2;
while (pos + 4 <= len) {
long rmin, rmax;
long submin, submax;
submin = (int)tlv[pos];
submax = (int)tlv[pos + 1];
if (rangemax < submax)
submax = rangemax;
err = snd_tlv_get_dB_range(tlv + pos + 2,
submin, submax,
&rmin, &rmax);
if (err < 0)
return err;
if (pos > 2) {
if (rmin < *min)
*min = rmin;
if (rmax > *max)
*max = rmax;
} else {
*min = rmin;
*max = rmax;
}
if (rangemax == submax)
return 0;
pos += int_index(tlv[pos + 3]) + 4;
}
return 0;
}
case SND_CTL_TLVT_DB_SCALE: {
int step;
if (tlv[SNDRV_CTL_TLVO_DB_SCALE_MUTE_AND_STEP] & 0x10000)
*min = SND_CTL_TLV_DB_GAIN_MUTE;
else
*min = (int)tlv[SNDRV_CTL_TLVO_DB_SCALE_MIN];
step = (tlv[SNDRV_CTL_TLVO_DB_SCALE_MUTE_AND_STEP] & 0xffff);
*max = (int)tlv[SNDRV_CTL_TLVO_DB_SCALE_MIN] +
step * (rangemax - rangemin);
return 0;
}
case SND_CTL_TLVT_DB_MINMAX:
case SND_CTL_TLVT_DB_LINEAR:
*min = (int)tlv[SNDRV_CTL_TLVO_DB_LINEAR_MIN];
*max = (int)tlv[SNDRV_CTL_TLVO_DB_LINEAR_MAX];
return 0;
case SND_CTL_TLVT_DB_MINMAX_MUTE:
*min = SND_CTL_TLV_DB_GAIN_MUTE;
*max = (int)tlv[SNDRV_CTL_TLVO_DB_MINMAX_MAX];
return 0;
}
return -EINVAL;
}
/**
* \brief Convert the given raw volume value to a dB gain
* \param tlv the TLV source returned by #snd_tlv_parse_dB_info()
* \param rangemin the minimum value of the raw volume
* \param rangemax the maximum value of the raw volume
* \param volume the raw volume value to convert
* \param db_gain the dB gain (in 0.01dB unit)
* \return 0 if successful, or a negative error code
*/
int snd_tlv_convert_to_dB(unsigned int *tlv, long rangemin, long rangemax,
long volume, long *db_gain)
{
unsigned int type = tlv[SNDRV_CTL_TLVO_TYPE];
switch (type) {
case SND_CTL_TLVT_DB_RANGE: {
unsigned int pos, len;
len = int_index(tlv[SNDRV_CTL_TLVO_LEN]);
if (len > MAX_TLV_RANGE_SIZE)
return -EINVAL;
pos = 2;
while (pos + 4 <= len) {
rangemin = (int)tlv[pos];
rangemax = (int)tlv[pos + 1];
if (volume >= rangemin && volume <= rangemax)
return snd_tlv_convert_to_dB(tlv + pos + 2,
rangemin, rangemax,
volume, db_gain);
pos += int_index(tlv[pos + 3]) + 4;
}
return -EINVAL;
}
case SND_CTL_TLVT_DB_SCALE: {
int min, step, mute;
min = tlv[SNDRV_CTL_TLVO_DB_SCALE_MIN];
step = (tlv[SNDRV_CTL_TLVO_DB_SCALE_MUTE_AND_STEP] & 0xffff);
mute = (tlv[SNDRV_CTL_TLVO_DB_SCALE_MUTE_AND_STEP] >> 16) & 1;
if (mute && volume <= rangemin)
*db_gain = SND_CTL_TLV_DB_GAIN_MUTE;
else
*db_gain = (volume - rangemin) * step + min;
return 0;
}
case SND_CTL_TLVT_DB_MINMAX:
case SND_CTL_TLVT_DB_MINMAX_MUTE: {
int mindb, maxdb;
mindb = tlv[SNDRV_CTL_TLVO_DB_MINMAX_MIN];
maxdb = tlv[SNDRV_CTL_TLVO_DB_MINMAX_MAX];
if (volume <= rangemin || rangemax <= rangemin) {
if (type == SND_CTL_TLVT_DB_MINMAX_MUTE)
*db_gain = SND_CTL_TLV_DB_GAIN_MUTE;
else
*db_gain = mindb;
} else if (volume >= rangemax)
*db_gain = maxdb;
else
*db_gain = (maxdb - mindb) * (volume - rangemin) /
(rangemax - rangemin) + mindb;
return 0;
}
#ifndef HAVE_SOFT_FLOAT
case SND_CTL_TLVT_DB_LINEAR: {
int mindb = tlv[SNDRV_CTL_TLVO_DB_LINEAR_MIN];
int maxdb = tlv[SNDRV_CTL_TLVO_DB_LINEAR_MAX];
if (volume <= rangemin || rangemax <= rangemin)
*db_gain = mindb;
else if (volume >= rangemax)
*db_gain = maxdb;
else {
double val = (double)(volume - rangemin) /
(double)(rangemax - rangemin);
if (mindb <= SND_CTL_TLV_DB_GAIN_MUTE)
*db_gain = (long)(100.0 * 20.0 * log10(val)) +
maxdb;
else {
/* FIXME: precalculate and cache these values */
double lmin = pow(10.0, mindb/2000.0);
double lmax = pow(10.0, maxdb/2000.0);
val = (lmax - lmin) * val + lmin;
*db_gain = (long)(100.0 * 20.0 * log10(val));
}
}
return 0;
}
#endif
}
return -EINVAL;
}
/**
* \brief Convert from dB gain to the corresponding raw value
* \param tlv the TLV source returned by #snd_tlv_parse_dB_info()
* \param rangemin the minimum value of the raw volume
* \param rangemax the maximum value of the raw volume
* \param db_gain the dB gain to convert (in 0.01dB unit)
* \param value the pointer to store the converted raw volume value
* \param xdir the direction for round-up. The value is round up
* when this is positive. A negative value means round down.
* Zero means round-up to nearest.
* \return 0 if successful, or a negative error code
*/
int snd_tlv_convert_from_dB(unsigned int *tlv, long rangemin, long rangemax,
long db_gain, long *value, int xdir)
{
unsigned int type = tlv[SNDRV_CTL_TLVO_TYPE];
switch (type) {
case SND_CTL_TLVT_DB_RANGE: {
long dbmin, dbmax, prev_submax;
unsigned int pos, len;
len = int_index(tlv[SNDRV_CTL_TLVO_LEN]);
if (len < 6 || len > MAX_TLV_RANGE_SIZE)
return -EINVAL;
pos = 2;
prev_submax = 0;
while (pos + 4 <= len) {
long submin, submax;
submin = (int)tlv[pos];
submax = (int)tlv[pos + 1];
if (rangemax < submax)
submax = rangemax;
if (!snd_tlv_get_dB_range(tlv + pos + 2,
submin, submax,
&dbmin, &dbmax) &&
db_gain >= dbmin && db_gain <= dbmax)
return snd_tlv_convert_from_dB(tlv + pos + 2,
submin, submax,
db_gain, value, xdir);
else if (db_gain < dbmin) {
*value = xdir > 0 || pos == 2 ? submin : prev_submax;
return 0;
}
prev_submax = submax;
if (rangemax == submax)
break;
pos += int_index(tlv[pos + 3]) + 4;
}
*value = prev_submax;
return 0;
}
case SND_CTL_TLVT_DB_SCALE: {
int min, step, max, mute;
min = tlv[SNDRV_CTL_TLVO_DB_SCALE_MIN];
step = tlv[SNDRV_CTL_TLVO_DB_SCALE_MUTE_AND_STEP] & 0xffff;
mute = tlv[SNDRV_CTL_TLVO_DB_SCALE_MUTE_AND_STEP] & 0x10000;
max = min + (int)(step * (rangemax - rangemin));
if (db_gain <= min)
if (db_gain > SND_CTL_TLV_DB_GAIN_MUTE && xdir > 0 &&
mute)
*value = rangemin + 1;
else
*value = rangemin;
else if (db_gain >= max)
*value = rangemax;
else {
long v = (db_gain - min) * (rangemax - rangemin);
if (xdir > 0)
v += (max - min) - 1;
else if (xdir == 0)
v += ((max - min) + 1) / 2;
v = v / (max - min) + rangemin;
*value = v;
}
return 0;
}
case SND_CTL_TLVT_DB_MINMAX:
case SND_CTL_TLVT_DB_MINMAX_MUTE: {
int min, max;
min = tlv[SNDRV_CTL_TLVO_DB_MINMAX_MIN];
max = tlv[SNDRV_CTL_TLVO_DB_MINMAX_MAX];
if (db_gain <= min)
if (db_gain > SND_CTL_TLV_DB_GAIN_MUTE && xdir > 0 &&
type == SND_CTL_TLVT_DB_MINMAX_MUTE)
*value = rangemin + 1;
else
*value = rangemin;
else if (db_gain >= max)
*value = rangemax;
else {
long v = (db_gain - min) * (rangemax - rangemin);
if (xdir > 0)
v += (max - min) - 1;
else if (xdir == 0)
v += ((max - min) + 1) / 2;
v = v / (max - min) + rangemin;
*value = v;
}
return 0;
}
#ifndef HAVE_SOFT_FLOAT
case SND_CTL_TLVT_DB_LINEAR: {
int min, max;
min = tlv[SNDRV_CTL_TLVO_DB_LINEAR_MIN];
max = tlv[SNDRV_CTL_TLVO_DB_LINEAR_MAX];
if (db_gain <= min)
*value = rangemin;
else if (db_gain >= max)
*value = rangemax;
else {
/* FIXME: precalculate and cache vmin and vmax */
double vmin, vmax, v;
vmin = (min <= SND_CTL_TLV_DB_GAIN_MUTE) ? 0.0 :
pow(10.0, (double)min / 2000.0);
vmax = !max ? 1.0 : pow(10.0, (double)max / 2000.0);
v = pow(10.0, (double)db_gain / 2000.0);
v = (v - vmin) * (rangemax - rangemin) / (vmax - vmin);
if (xdir > 0)
v = ceil(v);
else if (xdir == 0)
v = lrint(v);
*value = (long)v + rangemin;
}
return 0;
}
#endif
default:
break;
}
return -EINVAL;
}
#ifndef DOC_HIDDEN
#define TEMP_TLV_SIZE 4096
struct tlv_info {
long minval, maxval;
unsigned int *tlv;
unsigned int buf[TEMP_TLV_SIZE];
};
#endif
static int get_tlv_info(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id,
struct tlv_info *rec)
{
snd_ctl_elem_info_t info = {0};
int err;
snd_ctl_elem_info_set_id(&info, id);
err = snd_ctl_elem_info(ctl, &info);
if (err < 0)
return err;
if (!snd_ctl_elem_info_is_tlv_readable(&info))
return -EINVAL;
if (snd_ctl_elem_info_get_type(&info) != SND_CTL_ELEM_TYPE_INTEGER)
return -EINVAL;
rec->minval = snd_ctl_elem_info_get_min(&info);
rec->maxval = snd_ctl_elem_info_get_max(&info);
err = snd_ctl_elem_tlv_read(ctl, id, rec->buf, sizeof(rec->buf));
if (err < 0)
return err;
err = snd_tlv_parse_dB_info(rec->buf, sizeof(rec->buf), &rec->tlv);
if (err < 0)
return err;
return 0;
}
/**
* \brief Get the dB min/max values on the given control element
* \param ctl the control handler
* \param id the element id
* \param min the pointer to store the minimum dB value (in 0.01dB unit)
* \param max the pointer to store the maximum dB value (in 0.01dB unit)
* \return 0 if successful, or a negative error code
*/
int snd_ctl_get_dB_range(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id,
long *min, long *max)
{
struct tlv_info info;
int err;
err = get_tlv_info(ctl, id, &info);
if (err < 0)
return err;
return snd_tlv_get_dB_range(info.tlv, info.minval, info.maxval,
min, max);
}
/**
* \brief Convert the volume value to dB on the given control element
* \param ctl the control handler
* \param id the element id
* \param volume the raw volume value to convert
* \param db_gain the dB gain (in 0.01dB unit)
* \return 0 if successful, or a negative error code
*/
int snd_ctl_convert_to_dB(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id,
long volume, long *db_gain)
{
struct tlv_info info;
int err;
err = get_tlv_info(ctl, id, &info);
if (err < 0)
return err;
return snd_tlv_convert_to_dB(info.tlv, info.minval, info.maxval,
volume, db_gain);
}
/**
* \brief Convert from dB gain to the raw volume value on the given control element
* \param ctl the control handler
* \param id the element id
* \param db_gain the dB gain to convert (in 0.01dB unit)
* \param value the pointer to store the converted raw volume value
* \param xdir the direction for round-up. The value is round up
* when this is positive.
* \return 0 if successful, or a negative error code
*/
int snd_ctl_convert_from_dB(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id,
long db_gain, long *value, int xdir)
{
struct tlv_info info;
int err;
err = get_tlv_info(ctl, id, &info);
if (err < 0)
return err;
return snd_tlv_convert_from_dB(info.tlv, info.minval, info.maxval,
db_gain, value, xdir);
}