/*
** Copyright 2010, The Android Open-Source Project
** Copyright (c) 2011-2012, Code Aurora Forum. All rights reserved.
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
**
** http://www.apache.org/licenses/LICENSE-2.0
**
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <stdint.h>
#include <fcntl.h>
#include <errno.h>
#include <ctype.h>
#include <math.h>
#include <linux/ioctl.h>
#define __force
#define __bitwise
#define __user
#include <sound/asound.h>
#include <sound/tlv.h>
#include "alsa_audio.h"
#define LOG_TAG "alsa_mixer"
#define LOG_NDEBUG 1
#ifdef ANDROID
/* definitions for Android logging */
#include <utils/Log.h>
#else /* ANDROID */
#include <math.h>
#define ALOGI(...) fprintf(stdout, __VA_ARGS__)
#define ALOGE(...) fprintf(stderr, __VA_ARGS__)
#define ALOGV(...) fprintf(stderr, __VA_ARGS__)
#endif /* ANDROID */
#define check_range(val, min, max) \
(((val < min) ? (min) : (val > max) ? (max) : (val)))
/* .5 for rounding before casting to non-decmal value */
/* Should not be used if you need decmal values */
/* or are expecting negitive indexes */
#define percent_to_index(val, min, max) \
((val) * ((max) - (min)) * 0.01 + (min) + .5)
#define DEFAULT_TLV_SIZE 4096
#define SPDIF_CHANNEL_STATUS_SIZE 24
enum ctl_type {
CTL_GLOBAL_VOLUME,
CTL_PLAYBACK_VOLUME,
CTL_CAPTURE_VOLUME,
};
static const struct suf {
const char *suffix;
snd_ctl_elem_iface_t type;
} suffixes[] = {
{" Playback Volume", CTL_PLAYBACK_VOLUME},
{" Capture Volume", CTL_CAPTURE_VOLUME},
{" Volume", CTL_GLOBAL_VOLUME},
{NULL, 0}
};
static int is_volume(const char *name, enum ctl_type *type)
{
const struct suf *p;
size_t nlen = strlen(name);
p = suffixes;
while (p->suffix) {
size_t slen = strnlen(p->suffix, 44);
size_t l;
if (nlen > slen) {
l = nlen - slen;
if (strncmp(name + l, p->suffix, slen) == 0 &&
(l < 1 || name[l-1] != '-')) { /* 3D Control - Switch */
*type = p->type;
return l;
}
}
p++;
}
return 0;
}
static const char *elem_iface_name(snd_ctl_elem_iface_t n)
{
switch (n) {
case SNDRV_CTL_ELEM_IFACE_CARD: return "CARD";
case SNDRV_CTL_ELEM_IFACE_HWDEP: return "HWDEP";
case SNDRV_CTL_ELEM_IFACE_MIXER: return "MIXER";
case SNDRV_CTL_ELEM_IFACE_PCM: return "PCM";
case SNDRV_CTL_ELEM_IFACE_RAWMIDI: return "MIDI";
case SNDRV_CTL_ELEM_IFACE_TIMER: return "TIMER";
case SNDRV_CTL_ELEM_IFACE_SEQUENCER: return "SEQ";
default: return "???";
}
}
static const char *elem_type_name(snd_ctl_elem_type_t n)
{
switch (n) {
case SNDRV_CTL_ELEM_TYPE_NONE: return "NONE";
case SNDRV_CTL_ELEM_TYPE_BOOLEAN: return "BOOL";
case SNDRV_CTL_ELEM_TYPE_INTEGER: return "INT32";
case SNDRV_CTL_ELEM_TYPE_ENUMERATED: return "ENUM";
case SNDRV_CTL_ELEM_TYPE_BYTES: return "BYTES";
case SNDRV_CTL_ELEM_TYPE_IEC958: return "IEC958";
case SNDRV_CTL_ELEM_TYPE_INTEGER64: return "INT64";
default: return "???";
}
}
void mixer_close(struct mixer *mixer)
{
unsigned n,m;
if (mixer->fd >= 0)
close(mixer->fd);
if (mixer->ctl) {
for (n = 0; n < mixer->count; n++) {
if (mixer->ctl[n].ename) {
unsigned max = mixer->ctl[n].info->value.enumerated.items;
for (m = 0; m < max; m++)
free(mixer->ctl[n].ename[m]);
free(mixer->ctl[n].ename);
}
}
free(mixer->ctl);
}
if (mixer->info)
free(mixer->info);
free(mixer);
}
struct mixer *mixer_open(const char *device)
{
struct snd_ctl_elem_list elist;
struct snd_ctl_elem_info tmp;
struct snd_ctl_elem_id *eid = NULL;
struct mixer *mixer = NULL;
unsigned n, m;
int fd;
fd = open(device, O_RDWR);
if (fd < 0) {
ALOGE("Control open failed\n");
return 0;
}
memset(&elist, 0, sizeof(elist));
if (ioctl(fd, SNDRV_CTL_IOCTL_ELEM_LIST, &elist) < 0) {
ALOGE("SNDRV_CTL_IOCTL_ELEM_LIST failed\n");
goto fail;
}
mixer = calloc(1, sizeof(*mixer));
if (!mixer)
goto fail;
mixer->ctl = calloc(elist.count, sizeof(struct mixer_ctl));
mixer->info = calloc(elist.count, sizeof(struct snd_ctl_elem_info));
if (!mixer->ctl || !mixer->info)
goto fail;
eid = calloc(elist.count, sizeof(struct snd_ctl_elem_id));
if (!eid)
goto fail;
mixer->count = elist.count;
mixer->fd = fd;
elist.space = mixer->count;
elist.pids = eid;
if (ioctl(fd, SNDRV_CTL_IOCTL_ELEM_LIST, &elist) < 0)
goto fail;
for (n = 0; n < mixer->count; n++) {
struct snd_ctl_elem_info *ei = mixer->info + n;
ei->id.numid = eid[n].numid;
if (ioctl(fd, SNDRV_CTL_IOCTL_ELEM_INFO, ei) < 0)
goto fail;
mixer->ctl[n].info = ei;
mixer->ctl[n].mixer = mixer;
if (ei->type == SNDRV_CTL_ELEM_TYPE_ENUMERATED) {
char **enames = calloc(ei->value.enumerated.items, sizeof(char*));
if (!enames)
goto fail;
mixer->ctl[n].ename = enames;
for (m = 0; m < ei->value.enumerated.items; m++) {
memset(&tmp, 0, sizeof(tmp));
tmp.id.numid = ei->id.numid;
tmp.value.enumerated.item = m;
if (ioctl(fd, SNDRV_CTL_IOCTL_ELEM_INFO, &tmp) < 0)
goto fail;
enames[m] = strdup(tmp.value.enumerated.name);
if (!enames[m])
goto fail;
}
}
}
free(eid);
return mixer;
fail:
if (eid)
free(eid);
if (mixer)
mixer_close(mixer);
else if (fd >= 0)
close(fd);
return 0;
}
void mixer_dump(struct mixer *mixer)
{
unsigned n, m;
ALOGV(" id iface dev sub idx num perms type isvolume name\n");
for (n = 0; n < mixer->count; n++) {
enum ctl_type type;
struct snd_ctl_elem_info *ei = mixer->info + n;
ALOGV("%4d %5s %3d %3d %3d %3d %c%c%c%c%c%c%c%c%c %-6s %8d %s",
ei->id.numid, elem_iface_name(ei->id.iface),
ei->id.device, ei->id.subdevice, ei->id.index,
ei->count,
(ei->access & SNDRV_CTL_ELEM_ACCESS_READ) ? 'r' : ' ',
(ei->access & SNDRV_CTL_ELEM_ACCESS_WRITE) ? 'w' : ' ',
(ei->access & SNDRV_CTL_ELEM_ACCESS_VOLATILE) ? 'V' : ' ',
(ei->access & SNDRV_CTL_ELEM_ACCESS_TIMESTAMP) ? 'T' : ' ',
(ei->access & SNDRV_CTL_ELEM_ACCESS_TLV_READ) ? 'R' : ' ',
(ei->access & SNDRV_CTL_ELEM_ACCESS_TLV_WRITE) ? 'W' : ' ',
(ei->access & SNDRV_CTL_ELEM_ACCESS_TLV_COMMAND) ? 'C' : ' ',
(ei->access & SNDRV_CTL_ELEM_ACCESS_INACTIVE) ? 'I' : ' ',
(ei->access & SNDRV_CTL_ELEM_ACCESS_LOCK) ? 'L' : ' ',
elem_type_name(ei->type),
(is_volume(ei->id.name, &type)) ? 1 : 0,
ei->id.name);
switch (ei->type) {
case SNDRV_CTL_ELEM_TYPE_INTEGER:
ALOGV(ei->value.integer.step ?
" { %ld-%ld, %ld }\n" : " { %ld-%ld }",
ei->value.integer.min,
ei->value.integer.max,
ei->value.integer.step);
break;
case SNDRV_CTL_ELEM_TYPE_INTEGER64:
ALOGV(ei->value.integer64.step ?
" { %lld-%lld, %lld }\n" : " { %lld-%lld }",
ei->value.integer64.min,
ei->value.integer64.max,
ei->value.integer64.step);
break;
case SNDRV_CTL_ELEM_TYPE_ENUMERATED: {
unsigned m;
ALOGV(" { %s=0", mixer->ctl[n].ename[0]);
for (m = 1; m < ei->value.enumerated.items; m++)
ALOGV(", %s=%d", mixer->ctl[n].ename[m],m);
ALOGV(" }");
break;
}
}
ALOGV("\n");
}
}
struct mixer_ctl *mixer_get_control(struct mixer *mixer,
const char *name, unsigned index)
{
unsigned n;
for (n = 0; n < mixer->count; n++) {
if (mixer->info[n].id.index == index) {
if (!strncmp(name, (char*) mixer->info[n].id.name,
sizeof(mixer->info[n].id.name))) {
return mixer->ctl + n;
}
}
}
return 0;
}
struct mixer_ctl *mixer_get_nth_control(struct mixer *mixer, unsigned n)
{
if (n < mixer->count)
return mixer->ctl + n;
return 0;
}
static void print_dB(long dB)
{
ALOGV("%li.%02lidB", dB / 100, (dB < 0 ? -dB : dB) % 100);
}
int mixer_ctl_read_tlv(struct mixer_ctl *ctl,
unsigned int *tlv,
long *min, long *max, unsigned int *tlv_type)
{
unsigned int tlv_size = DEFAULT_TLV_SIZE;
unsigned int type;
unsigned int size;
if(!!(ctl->info->access & SNDRV_CTL_ELEM_ACCESS_TLV_READ)) {
struct snd_ctl_tlv *xtlv;
tlv[0] = -1;
tlv[1] = 0;
xtlv = calloc(1, sizeof(struct snd_ctl_tlv) + tlv_size);
if (xtlv == NULL)
return -ENOMEM;
xtlv->numid = ctl->info->id.numid;
xtlv->length = tlv_size;
memcpy(xtlv->tlv, tlv, tlv_size);
if (ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_TLV_READ, xtlv) < 0) {
fprintf( stderr, "SNDRV_CTL_IOCTL_TLV_READ failed\n");
free(xtlv);
return -errno;
}
if (xtlv->tlv[1] + 2 * sizeof(unsigned int) > tlv_size) {
free(xtlv);
return -EFAULT;
}
memcpy(tlv, xtlv->tlv, xtlv->tlv[1] + 2 * sizeof(unsigned int));
free(xtlv);
type = tlv[0];
*tlv_type = type;
size = tlv[1];
switch (type) {
case SNDRV_CTL_TLVT_DB_SCALE: {
int idx = 2;
int step;
ALOGV("dBscale-");
if (size != 2 * sizeof(unsigned int)) {
while (size > 0) {
ALOGV("0x%08x,", tlv[idx++]);
size -= sizeof(unsigned int);
}
} else {
ALOGV(" min=");
print_dB((int)tlv[2]);
*min = (long)tlv[2];
ALOGV(" step=");
step = (tlv[3] & 0xffff);
print_dB(tlv[3] & 0xffff);
ALOGV(" max=");
*max = (ctl->info->value.integer.max);
print_dB((long)ctl->info->value.integer.max);
ALOGV(" mute=%i\n", (tlv[3] >> 16) & 1);
}
break;
}
case SNDRV_CTL_TLVT_DB_LINEAR: {
int idx = 2;
ALOGV("dBLiner-");
if (size != 2 * sizeof(unsigned int)) {
while (size > 0) {
ALOGV("0x%08x,", tlv[idx++]);
size -= sizeof(unsigned int);
}
} else {
ALOGV(" min=");
*min = tlv[2];
print_dB(tlv[2]);
ALOGV(" max=");
*max = tlv[3];
print_dB(tlv[3]);
}
break;
}
default:
break;
}
return 0;
}
return -EINVAL;
}
void mixer_ctl_get(struct mixer_ctl *ctl, unsigned *value)
{
struct snd_ctl_elem_value ev;
unsigned int n;
unsigned int *tlv = NULL;
enum ctl_type type;
unsigned int *tlv_type;
long min, max;
if (is_volume(ctl->info->id.name, &type)) {
ALOGV("capability: volume\n");
tlv = calloc(1, DEFAULT_TLV_SIZE);
if (tlv == NULL) {
ALOGE("failed to allocate memory\n");
} else {
mixer_ctl_read_tlv(ctl, tlv, &min, &max, &tlv_type);
free(tlv);
}
}
memset(&ev, 0, sizeof(ev));
ev.id.numid = ctl->info->id.numid;
if (ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_READ, &ev))
return;
ALOGV("%s:", ctl->info->id.name);
switch (ctl->info->type) {
case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
for (n = 0; n < ctl->info->count; n++)
ALOGV(" %s", ev.value.integer.value[n] ? "on" : "off");
*value = ev.value.integer.value[0];
break;
case SNDRV_CTL_ELEM_TYPE_INTEGER: {
for (n = 0; n < ctl->info->count; n++)
ALOGV(" %ld", ev.value.integer.value[n]);
*value = ev.value.integer.value[0];
break;
}
case SNDRV_CTL_ELEM_TYPE_INTEGER64:
for (n = 0; n < ctl->info->count; n++)
ALOGV(" %lld", ev.value.integer64.value[n]);
*value = ev.value.integer64.value[0];
break;
case SNDRV_CTL_ELEM_TYPE_ENUMERATED:
for (n = 0; n < ctl->info->count; n++) {
unsigned v = ev.value.enumerated.item[n];
ALOGV(" %d (%s)", v,
(v < ctl->info->value.enumerated.items) ? ctl->ename[v] : "???");
*value = ev.value.enumerated.item[0];
}
break;
default:
ALOGV(" ???");
}
ALOGV("\n");
}
static long scale_int(struct snd_ctl_elem_info *ei, unsigned _percent)
{
long percent;
if (_percent > 100)
percent = 100;
else
percent = (long) _percent;
return (long)percent_to_index(percent, ei->value.integer.min, ei->value.integer.max);
}
static long long scale_int64(struct snd_ctl_elem_info *ei, unsigned _percent)
{
long long percent;
if (_percent > 100)
percent = 100;
else
percent = (long) _percent;
return (long long)percent_to_index(percent, ei->value.integer.min, ei->value.integer.max);
}
/*
* Add support for controls taking more than one parameter as input value
* This is useful for volume controls which take two parameters as input value.
*/
int mixer_ctl_mulvalues(struct mixer_ctl *ctl, int count, char ** argv)
{
struct snd_ctl_elem_value ev;
unsigned n;
if (!ctl) {
ALOGV("can't find control\n");
return -1;
}
if (count < ctl->info->count || count > ctl->info->count)
return -EINVAL;
memset(&ev, 0, sizeof(ev));
ev.id.numid = ctl->info->id.numid;
switch (ctl->info->type) {
case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
for (n = 0; n < ctl->info->count; n++)
ev.value.integer.value[n] = !!atoi(argv[n]);
break;
case SNDRV_CTL_ELEM_TYPE_INTEGER: {
for (n = 0; n < ctl->info->count; n++) {
fprintf( stderr, "Value: %d idx:%d\n", atoi(argv[n]), n);
ev.value.integer.value[n] = atoi(argv[n]);
}
break;
}
case SNDRV_CTL_ELEM_TYPE_INTEGER64: {
for (n = 0; n < ctl->info->count; n++) {
long long value_ll = scale_int64(ctl->info, atoi(argv[n]));
fprintf( stderr, "ll_value = %lld\n", value_ll);
ev.value.integer64.value[n] = value_ll;
}
break;
}
default:
errno = EINVAL;
return errno;
}
return ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_WRITE, &ev);
}
int mixer_ctl_set(struct mixer_ctl *ctl, unsigned percent)
{
struct snd_ctl_elem_value ev;
unsigned n;
long min, max;
unsigned int *tlv = NULL;
enum ctl_type type;
int volume = 0;
unsigned int tlv_type;
if (!ctl) {
ALOGV("can't find control\n");
return -1;
}
if (is_volume(ctl->info->id.name, &type)) {
ALOGV("capability: volume\n");
tlv = calloc(1, DEFAULT_TLV_SIZE);
if (tlv == NULL) {
ALOGE("failed to allocate memory\n");
} else if (!mixer_ctl_read_tlv(ctl, tlv, &min, &max, &tlv_type)) {
switch(tlv_type) {
case SNDRV_CTL_TLVT_DB_LINEAR:
ALOGV("tlv db linear: b4 %d\n", percent);
if (min < 0) {
max = max - min;
min = 0;
}
percent = check_range(percent, min, max);
ALOGV("tlv db linear: %d %d %d\n", percent, min, max);
volume = 1;
break;
default:
percent = (long)percent_to_index(percent, min, max);
percent = check_range(percent, min, max);
volume = 1;
break;
}
} else
ALOGV("mixer_ctl_read_tlv failed\n");
free(tlv);
}
memset(&ev, 0, sizeof(ev));
ev.id.numid = ctl->info->id.numid;
switch (ctl->info->type) {
case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
for (n = 0; n < ctl->info->count; n++)
ev.value.integer.value[n] = !!percent;
break;
case SNDRV_CTL_ELEM_TYPE_INTEGER: {
int value;
if (!volume)
value = scale_int(ctl->info, percent);
else
value = (int) percent;
for (n = 0; n < ctl->info->count; n++)
ev.value.integer.value[n] = value;
break;
}
case SNDRV_CTL_ELEM_TYPE_INTEGER64: {
long long value;
if (!volume)
value = scale_int64(ctl->info, percent);
else
value = (long long)percent;
for (n = 0; n < ctl->info->count; n++)
ev.value.integer64.value[n] = value;
break;
}
case SNDRV_CTL_ELEM_TYPE_IEC958: {
struct snd_aes_iec958 *iec958;
iec958 = (struct snd_aes_iec958 *)percent;
memcpy(ev.value.iec958.status,iec958->status,SPDIF_CHANNEL_STATUS_SIZE);
break;
}
default:
errno = EINVAL;
return errno;
}
return ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_WRITE, &ev);
}
/* the api parses the mixer control input to extract
* the value of volume in any one of the following format
* <volume><%>
* <volume><dB>
* All remaining formats are currently ignored.
*/
static int set_volume_simple(struct mixer_ctl *ctl,
char **ptr, long pmin, long pmax, int count)
{
long val, orig;
char *p = *ptr, *s;
struct snd_ctl_elem_value ev;
unsigned n;
if (*p == ':')
p++;
if (*p == '\0' || (!isdigit(*p) && *p != '-'))
goto skip;
s = p;
val = strtol(s, &p, 10);
if (*p == '.') {
p++;
strtol(p, &p, 10);
}
if (*p == '%') {
val = (long)percent_to_index(strtod(s, NULL), pmin, pmax);
p++;
} else if (p[0] == 'd' && p[1] == 'B') {
val = (long)(strtod(s, NULL) * 100.0);
p += 2;
} else {
if (pmin < 0) {
pmax = pmax - pmin;
pmin = 0;
}
}
val = check_range(val, pmin, pmax);
ALOGV("val = %x", val);
if (!ctl) {
ALOGV("can't find control\n");
return -EPERM;
}
if (count < ctl->info->count || count > ctl->info->count)
return -EINVAL;
ALOGV("Value = ");
memset(&ev, 0, sizeof(ev));
ev.id.numid = ctl->info->id.numid;
switch (ctl->info->type) {
case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
for (n = 0; n < ctl->info->count; n++)
ev.value.integer.value[n] = !!val;
print_dB(val);
break;
case SNDRV_CTL_ELEM_TYPE_INTEGER: {
for (n = 0; n < ctl->info->count; n++)
ev.value.integer.value[n] = val;
print_dB(val);
break;
}
case SNDRV_CTL_ELEM_TYPE_INTEGER64: {
for (n = 0; n < ctl->info->count; n++) {
long long value_ll = scale_int64(ctl->info, val);
print_dB(value_ll);
ev.value.integer64.value[n] = value_ll;
}
break;
}
default:
errno = EINVAL;
return errno;
}
ALOGV("\n");
return ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_WRITE, &ev);
skip:
if (*p == ',')
p++;
*ptr = p;
return 0;
}
int mixer_ctl_set_value(struct mixer_ctl *ctl, int count, char ** argv)
{
unsigned int size;
unsigned int *tlv = NULL;
long min, max;
enum ctl_type type;
unsigned int tlv_type;
if (is_volume(ctl->info->id.name, &type)) {
ALOGV("capability: volume\n");
tlv = calloc(1, DEFAULT_TLV_SIZE);
if (tlv == NULL) {
ALOGE("failed to allocate memory\n");
} else if (!mixer_ctl_read_tlv(ctl, tlv, &min, &max, &tlv_type)) {
ALOGV("min = %x max = %x", min, max);
if (set_volume_simple(ctl, argv, min, max, count))
mixer_ctl_mulvalues(ctl, count, argv);
} else
ALOGV("mixer_ctl_read_tlv failed\n");
free(tlv);
} else {
mixer_ctl_mulvalues(ctl, count, argv);
}
return 0;
}
int mixer_ctl_select(struct mixer_ctl *ctl, const char *value)
{
unsigned n, max;
struct snd_ctl_elem_value ev;
unsigned int input_str_len, str_len;
if (ctl->info->type != SNDRV_CTL_ELEM_TYPE_ENUMERATED) {
errno = EINVAL;
return -1;
}
input_str_len = strnlen(value,64);
max = ctl->info->value.enumerated.items;
for (n = 0; n < max; n++) {
str_len = strnlen(ctl->ename[n], 64);
if (str_len < input_str_len)
str_len = input_str_len;
if (!strncmp(value, ctl->ename[n], str_len)) {
memset(&ev, 0, sizeof(ev));
ev.value.enumerated.item[0] = n;
ev.id.numid = ctl->info->id.numid;
if (ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_WRITE, &ev) < 0)
return -1;
return 0;
}
}
errno = EINVAL;
return errno;
}