static int set_enum_item_ops(snd_mixer_elem_t *elem,
snd_mixer_selem_channel_id_t channel,
unsigned int item)
{
selem_none_t *s = snd_mixer_elem_get_private(elem);
snd_ctl_elem_value_t *ctl;
snd_hctl_elem_t *helem;
int err;
int type;
if ((unsigned int) channel >= s->str[0].channels) {
return -EINVAL;
}
type = CTL_GLOBAL_ENUM;
helem = s->ctls[type].elem;
if (!helem) {
type = CTL_PLAYBACK_ENUM;
helem = s->ctls[type].elem;
}
if (!helem) {
type = CTL_CAPTURE_ENUM;
helem = s->ctls[type].elem;
}
assert(helem);
if (item >= (unsigned int)s->ctls[type].max) {
return -EINVAL;
}
snd_ctl_elem_value_alloca(&ctl);
err = snd_hctl_elem_read(helem, ctl);
if (err < 0) {
return err;
}
snd_ctl_elem_value_set_enumerated(ctl, channel, item);
return snd_hctl_elem_write(helem, ctl);
}
int
phoneui_utils_sound_volume_mute_set(enum SoundControlType type, int mute)
{
int err;
snd_hctl_elem_t *elem;
snd_ctl_elem_value_t *control;
elem = controls[STATE_INDEX][type].mute_element;
if (!elem) {
return -1;
}
snd_ctl_elem_value_alloca(&control);
snd_ctl_elem_value_set_boolean(control, 0, !mute);
err = snd_hctl_elem_write(elem, control);
if (err) {
g_warning("%s", snd_strerror(err));
return -1;
}
g_debug("Set control %d to %d", type, mute);
return 0;
}
int
phoneui_utils_sound_volume_raw_set(enum SoundControlType type, long value)
{
int err;
unsigned int i, count;
snd_hctl_elem_t *elem;
snd_ctl_elem_value_t *control;
elem = controls[STATE_INDEX][type].element;
if (!elem) {
return -1;
}
snd_ctl_elem_value_alloca(&control);
count = controls[STATE_INDEX][type].count;
for (i = 0 ; i < count ; i++) {
snd_ctl_elem_value_set_integer(control, i, value);
}
err = snd_hctl_elem_write(elem, control);
if (err) {
g_warning("%s", snd_strerror(err));
return -1;
}
/* FIXME put it somewhere else, this is not the correct place! */
phoneui_utils_sound_volume_save(type);
return 0;
}
static int elem_write_switch_constant(selem_none_t *s, selem_ctl_type_t type, int val)
{
snd_ctl_elem_value_t *ctl;
unsigned int idx;
int err;
selem_ctl_t *c = &s->ctls[type];
snd_ctl_elem_value_alloca(&ctl);
if ((err = snd_hctl_elem_read(c->elem, ctl)) < 0)
return err;
for (idx = 0; idx < c->values; idx++)
snd_ctl_elem_value_set_integer(ctl, idx, !!val);
if ((err = snd_hctl_elem_write(c->elem, ctl)) < 0)
return err;
return 0;
}
static int elem_write_switch(selem_none_t *s, int dir, selem_ctl_type_t type)
{
snd_ctl_elem_value_t *ctl;
unsigned int idx;
int err;
selem_ctl_t *c = &s->ctls[type];
snd_ctl_elem_value_alloca(&ctl);
if ((err = snd_hctl_elem_read(c->elem, ctl)) < 0)
return err;
for (idx = 0; idx < c->values; idx++)
snd_ctl_elem_value_set_integer(ctl, idx, !!(s->str[dir].sw & (1 << idx)));
if ((err = snd_hctl_elem_write(c->elem, ctl)) < 0)
return err;
return 0;
}
static int elem_write_volume(selem_none_t *s, int dir, selem_ctl_type_t type)
{
snd_ctl_elem_value_t *ctl;
unsigned int idx;
int err;
selem_ctl_t *c = &s->ctls[type];
snd_ctl_elem_value_alloca(&ctl);
if ((err = snd_hctl_elem_read(c->elem, ctl)) < 0)
return err;
for (idx = 0; idx < c->values; idx++)
snd_ctl_elem_value_set_integer(ctl, idx, from_user(s, dir, c, s->str[dir].vol[idx]));
if ((err = snd_hctl_elem_write(c->elem, ctl)) < 0)
return err;
return 0;
}
static int setamixer(int devnum,char *param, int v1, int v2)
{
int type;
char str[100];
snd_hctl_t *hctl;
snd_ctl_elem_id_t *id;
snd_ctl_elem_value_t *control;
snd_hctl_elem_t *elem;
snd_ctl_elem_info_t *info;
sprintf(str,"hw:%d",devnum);
if (snd_hctl_open(&hctl, str, 0)) return(-1);
snd_hctl_load(hctl);
snd_ctl_elem_id_alloca(&id);
snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_MIXER);
snd_ctl_elem_id_set_name(id, param);
elem = snd_hctl_find_elem(hctl, id);
if (!elem)
{
snd_hctl_close(hctl);
return(-1);
}
snd_ctl_elem_info_alloca(&info);
snd_hctl_elem_info(elem,info);
type = snd_ctl_elem_info_get_type(info);
snd_ctl_elem_value_alloca(&control);
snd_ctl_elem_value_set_id(control, id);
switch(type)
{
case SND_CTL_ELEM_TYPE_INTEGER:
snd_ctl_elem_value_set_integer(control, 0, v1);
if (v2 > 0) snd_ctl_elem_value_set_integer(control, 1, v2);
break;
case SND_CTL_ELEM_TYPE_BOOLEAN:
snd_ctl_elem_value_set_integer(control, 0, (v1 != 0));
break;
}
if (snd_hctl_elem_write(elem, control))
{
snd_hctl_close(hctl);
return(-1);
}
snd_hctl_close(hctl);
return(0);
}
/*
Change the value of the routing control
*/
static int utils_alsa_set_route(unsigned int value)
{
if(utils_alsa_init() || !utils_alsa_route_elem || !utils_alsa_route_elem_id)
return 1;
debug("utils_alsa_set_control_enum: value=%ud\n", value);
snd_ctl_elem_value_t *control;
snd_ctl_elem_value_alloca(&control);
snd_ctl_elem_value_set_id(control, utils_alsa_route_elem_id);
snd_ctl_elem_value_set_enumerated(control, 0, value);
int err=snd_hctl_elem_write(utils_alsa_route_elem, control);
if(err<0){
error("utils_alsa_set_control_enum: write failed: %s\n", snd_strerror(err));
return 1;
}{
debug("utils_alsa_set_control_enum: success\n");
}
return 0;
}
/******************************************************************************
* setMixerInput
*****************************************************************************/
static Int setMixerControl (const Char *name, Int value)
{
Int status;
snd_hctl_t *hctl;
snd_ctl_elem_id_t *id;
snd_hctl_elem_t *elem;
snd_ctl_elem_value_t *control;
if ((status = snd_hctl_open(&hctl, AUDIO_MIXER, 0)) < 0) {
Dmai_err2("setMixerControl %s open error: %s\n", AUDIO_MIXER, snd_strerror(status));
return Dmai_EFAIL;;
}
if ((status = snd_hctl_load(hctl)) < 0) {
Dmai_err2("setMixerControl %s load error: %s\n", AUDIO_MIXER, snd_strerror(status));
return Dmai_EFAIL;;
}
snd_ctl_elem_id_alloca(&id);
snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_MIXER);
snd_ctl_elem_id_set_name(id, name);
elem = snd_hctl_find_elem(hctl, id);
if (!elem) {
Dmai_err1("setMixerControl %s find element error\n",
AUDIO_MIXER);
snd_hctl_close(hctl);
return Dmai_EFAIL;
}
snd_ctl_elem_value_alloca(&control);
snd_ctl_elem_value_set_id(control, id);
snd_ctl_elem_value_set_integer(control, 0, value);
snd_hctl_elem_write(elem, control);
snd_hctl_close(hctl);
return Dmai_EOK;
}
static int elem_write_enum(selem_none_t *s)
{
snd_ctl_elem_value_t *ctl;
unsigned int idx;
int err;
int type;
selem_ctl_t *c;
type = CTL_GLOBAL_ENUM;
if ( (s->selem.caps & (SM_CAP_CENUM | SM_CAP_PENUM) ) == (SM_CAP_CENUM | SM_CAP_PENUM) )
type = CTL_GLOBAL_ENUM;
else if (s->selem.caps & SM_CAP_PENUM)
type = CTL_PLAYBACK_ENUM;
else if (s->selem.caps & SM_CAP_CENUM)
type = CTL_CAPTURE_ENUM;
c = &s->ctls[type];
snd_ctl_elem_value_alloca(&ctl);
if ((err = snd_hctl_elem_read(c->elem, ctl)) < 0)
return err;
for (idx = 0; idx < c->values; idx++)
snd_ctl_elem_value_set_enumerated(ctl, idx, (unsigned int)s->str[0].vol[idx]);
if ((err = snd_hctl_elem_write(c->elem, ctl)) < 0)
return err;
return 0;
}
static int selem_write_main(snd_mixer_elem_t *elem)
{
selem_none_t *s;
unsigned int idx;
int err;
assert(snd_mixer_elem_get_type(elem) == SND_MIXER_ELEM_SIMPLE);
s = snd_mixer_elem_get_private(elem);
if (s->ctls[CTL_GLOBAL_ENUM].elem)
return elem_write_enum(s);
if (s->ctls[CTL_PLAYBACK_ENUM].elem)
return elem_write_enum(s);
if (s->ctls[CTL_CAPTURE_ENUM].elem)
return elem_write_enum(s);
if (s->ctls[CTL_SINGLE].elem) {
if (s->ctls[CTL_SINGLE].type == SND_CTL_ELEM_TYPE_INTEGER)
err = elem_write_volume(s, SM_PLAY, CTL_SINGLE);
else
err = elem_write_switch(s, SM_PLAY, CTL_SINGLE);
if (err < 0)
return err;
}
if (s->ctls[CTL_GLOBAL_VOLUME].elem) {
err = elem_write_volume(s, SM_PLAY, CTL_GLOBAL_VOLUME);
if (err < 0)
return err;
}
if (s->ctls[CTL_GLOBAL_SWITCH].elem) {
if (s->ctls[CTL_PLAYBACK_SWITCH].elem && s->ctls[CTL_CAPTURE_SWITCH].elem)
err = elem_write_switch_constant(s, CTL_GLOBAL_SWITCH, 1);
else
err = elem_write_switch(s, SM_PLAY, CTL_GLOBAL_SWITCH);
if (err < 0)
return err;
}
if (s->ctls[CTL_PLAYBACK_VOLUME].elem) {
err = elem_write_volume(s, SM_PLAY, CTL_PLAYBACK_VOLUME);
if (err < 0)
return err;
}
if (s->ctls[CTL_PLAYBACK_SWITCH].elem) {
err = elem_write_switch(s, SM_PLAY, CTL_PLAYBACK_SWITCH);
if (err < 0)
return err;
}
if (s->ctls[CTL_PLAYBACK_ROUTE].elem) {
err = elem_write_route(s, SM_PLAY, CTL_PLAYBACK_ROUTE);
if (err < 0)
return err;
}
if (s->ctls[CTL_CAPTURE_VOLUME].elem) {
err = elem_write_volume(s, SM_CAPT, CTL_CAPTURE_VOLUME);
if (err < 0)
return err;
}
if (s->ctls[CTL_CAPTURE_SWITCH].elem) {
err = elem_write_switch(s, SM_CAPT, CTL_CAPTURE_SWITCH);
if (err < 0)
return err;
}
if (s->ctls[CTL_CAPTURE_ROUTE].elem) {
err = elem_write_route(s, SM_CAPT, CTL_CAPTURE_ROUTE);
if (err < 0)
return err;
}
if (s->ctls[CTL_CAPTURE_SOURCE].elem) {
snd_ctl_elem_value_t *ctl;
selem_ctl_t *c = &s->ctls[CTL_CAPTURE_SOURCE];
snd_ctl_elem_value_alloca(&ctl);
if ((err = snd_hctl_elem_read(c->elem, ctl)) < 0)
return err;
for (idx = 0; idx < c->values; idx++) {
if (s->str[SM_CAPT].sw & (1 << idx))
snd_ctl_elem_value_set_enumerated(ctl, idx, s->capture_item);
}
if ((err = snd_hctl_elem_write(c->elem, ctl)) < 0)
return err;
/* update the element, don't remove */
err = selem_read(elem);
if (err < 0)
return err;
}
return 0;
}
/**
* alsa dumy codec controls interface
*/
int dummy_alsa_control_raw(char * id_string , long vol, int rw, long * value){
int err;
snd_hctl_t *hctl;
snd_ctl_elem_id_t *id;
snd_hctl_elem_t *elem;
snd_ctl_elem_value_t *control;
snd_ctl_elem_info_t *info;
snd_ctl_elem_type_t type;
unsigned int idx = 0, count;
long tmp, min, max;
char dev[10] = {0};
int card = alsa_get_aml_card();
int port = alsa_get_spdif_port();
adec_print("card = %d, port = %d\n", card, port);
sprintf(dev, "hw:%d,%d", (card >= 0) ? card : 0, (port >= 0) ? port : 0);
if ((err = snd_hctl_open(&hctl, dev, 0)) < 0) {
printf("Control %s open error: %s\n", dev, snd_strerror(err));
return err;
}
if (err = snd_hctl_load(hctl)< 0) {
printf("Control %s open error: %s\n", dev, snd_strerror(err));
return err;
}
snd_ctl_elem_id_alloca(&id);
snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_MIXER);
snd_ctl_elem_id_set_name(id, id_string);
elem = snd_hctl_find_elem(hctl, id);
snd_ctl_elem_value_alloca(&control);
snd_ctl_elem_value_set_id(control, id);
snd_ctl_elem_info_alloca(&info);
if ((err = snd_hctl_elem_info(elem, info)) < 0) {
printf("Control %s snd_hctl_elem_info error: %s\n", dev, snd_strerror(err));
return err;
}
count = snd_ctl_elem_info_get_count(info);
type = snd_ctl_elem_info_get_type(info);
for (idx = 0; idx < count; idx++) {
switch (type) {
case SND_CTL_ELEM_TYPE_BOOLEAN:
if(rw){
tmp = 0;
if (vol >= 1) {
tmp = 1;
}
snd_ctl_elem_value_set_boolean(control, idx, tmp);
err = snd_hctl_elem_write(elem, control);
}else
*value = snd_ctl_elem_value_get_boolean(control, idx);
break;
case SND_CTL_ELEM_TYPE_INTEGER:
if(rw){
min = snd_ctl_elem_info_get_min(info);
max = snd_ctl_elem_info_get_max(info);
if ((vol >= min) && (vol <= max))
tmp = vol;
else if (vol < min)
tmp = min;
else if (vol > max)
tmp = max;
snd_ctl_elem_value_set_integer(control, idx, tmp);
err = snd_hctl_elem_write(elem, control);
}else
*value = snd_ctl_elem_value_get_integer(control, idx);
break;
default:
printf("?");
break;
}
if (err < 0){
printf ("control%s access error=%s,close control device\n", dev, snd_strerror(err));
snd_hctl_close(hctl);
return err;
}
}
return 0;
}
/**************************************************************************
* ALSA_CheckSetVolume [internal]
*
* Helper function for Alsa volume queries. This tries to simplify
* the process of managing the volume. All parameters are optional
* (pass NULL to ignore or not use).
* Return values are MMSYSERR_NOERROR on success, or !0 on failure;
* error codes are normalized into the possible documented return
* values from waveOutGetVolume.
*/
int ALSA_CheckSetVolume(snd_hctl_t *hctl, int *out_left, int *out_right,
int *out_min, int *out_max, int *out_step,
int *new_left, int *new_right)
{
int rc = MMSYSERR_NOERROR;
int value_count = 0;
snd_hctl_elem_t * elem = NULL;
snd_ctl_elem_info_t * eleminfop = NULL;
snd_ctl_elem_value_t * elemvaluep = NULL;
snd_ctl_elem_id_t * elemidp = NULL;
const char *names[] = {"PCM Playback Volume", "Line Playback Volume", NULL};
const char **name;
#define EXIT_ON_ERROR(f,txt,exitcode) do \
{ \
int err; \
if ( (err = (f) ) < 0) \
{ \
ERR(txt " failed: %s\n", snd_strerror(err)); \
rc = exitcode; \
goto out; \
} \
} while(0)
if (! hctl)
return MMSYSERR_NOTSUPPORTED;
/* Allocate areas to return information about the volume */
EXIT_ON_ERROR(snd_ctl_elem_id_malloc(&elemidp), "snd_ctl_elem_id_malloc", MMSYSERR_NOMEM);
EXIT_ON_ERROR(snd_ctl_elem_value_malloc (&elemvaluep), "snd_ctl_elem_value_malloc", MMSYSERR_NOMEM);
EXIT_ON_ERROR(snd_ctl_elem_info_malloc (&eleminfop), "snd_ctl_elem_info_malloc", MMSYSERR_NOMEM);
snd_ctl_elem_id_clear(elemidp);
snd_ctl_elem_value_clear(elemvaluep);
snd_ctl_elem_info_clear(eleminfop);
/* Setup and find an element id that exactly matches the characteristic we want
** FIXME: It is probably short sighted to hard code and fixate on PCM Playback Volume */
for( name = names; *name; name++ )
{
snd_ctl_elem_id_set_name(elemidp, *name);
snd_ctl_elem_id_set_interface(elemidp, SND_CTL_ELEM_IFACE_MIXER);
elem = snd_hctl_find_elem(hctl, elemidp);
if (elem)
{
/* Read and return volume information */
EXIT_ON_ERROR(snd_hctl_elem_info(elem, eleminfop), "snd_hctl_elem_info", MMSYSERR_NOTSUPPORTED);
value_count = snd_ctl_elem_info_get_count(eleminfop);
if (out_min || out_max || out_step)
{
if (!snd_ctl_elem_info_is_readable(eleminfop))
{
ERR("snd_ctl_elem_info_is_readable returned false; cannot return info\n");
rc = MMSYSERR_NOTSUPPORTED;
goto out;
}
if (out_min)
*out_min = snd_ctl_elem_info_get_min(eleminfop);
if (out_max)
*out_max = snd_ctl_elem_info_get_max(eleminfop);
if (out_step)
*out_step = snd_ctl_elem_info_get_step(eleminfop);
}
if (out_left || out_right)
{
EXIT_ON_ERROR(snd_hctl_elem_read(elem, elemvaluep), "snd_hctl_elem_read", MMSYSERR_NOTSUPPORTED);
if (out_left)
*out_left = snd_ctl_elem_value_get_integer(elemvaluep, 0);
if (out_right)
{
if (value_count == 1)
*out_right = snd_ctl_elem_value_get_integer(elemvaluep, 0);
else if (value_count == 2)
*out_right = snd_ctl_elem_value_get_integer(elemvaluep, 1);
else
{
ERR("Unexpected value count %d from snd_ctl_elem_info_get_count while getting volume info\n", value_count);
rc = -1;
goto out;
}
}
}
/* Set the volume */
if (new_left || new_right)
{
EXIT_ON_ERROR(snd_hctl_elem_read(elem, elemvaluep), "snd_hctl_elem_read", MMSYSERR_NOTSUPPORTED);
if (new_left)
snd_ctl_elem_value_set_integer(elemvaluep, 0, *new_left);
if (new_right)
{
if (value_count == 1)
snd_ctl_elem_value_set_integer(elemvaluep, 0, *new_right);
else if (value_count == 2)
snd_ctl_elem_value_set_integer(elemvaluep, 1, *new_right);
else
{
ERR("Unexpected value count %d from snd_ctl_elem_info_get_count while setting volume info\n", value_count);
rc = -1;
goto out;
}
}
EXIT_ON_ERROR(snd_hctl_elem_write(elem, elemvaluep), "snd_hctl_elem_write", MMSYSERR_NOTSUPPORTED);
}
break;
}
}
if( !*name )
{
ERR("Could not find '{PCM,Line} Playback Volume' element\n");
rc = MMSYSERR_NOTSUPPORTED;
}
#undef EXIT_ON_ERROR
out:
if (elemvaluep)
snd_ctl_elem_value_free(elemvaluep);
if (eleminfop)
snd_ctl_elem_info_free(eleminfop);
if (elemidp)
snd_ctl_elem_id_free(elemidp);
return rc;
}
