static int
hammerfall_change_sample_clock (jack_hardware_t *hw, SampleClockMode mode)
{
hammerfall_t *h = (hammerfall_t *) hw->private_hw;
snd_ctl_elem_value_t *ctl;
snd_ctl_elem_id_t *ctl_id;
int err;
snd_ctl_elem_value_alloca (&ctl);
snd_ctl_elem_id_alloca (&ctl_id);
set_control_id (ctl_id, "Sync Mode");
snd_ctl_elem_value_set_id (ctl, ctl_id);
switch (mode) {
case AutoSync:
snd_ctl_elem_value_set_enumerated (ctl, 0, 0);
break;
case ClockMaster:
snd_ctl_elem_value_set_enumerated (ctl, 0, 1);
break;
case WordClock:
snd_ctl_elem_value_set_enumerated (ctl, 0, 2);
break;
}
if ((err = snd_ctl_elem_write (h->driver->ctl_handle, ctl)) < 0) {
jack_error ("ALSA-Hammerfall: cannot set clock mode");
}
return 0;
}
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);
}
static void set_routes(int stream, int idx)
{
int err;
unsigned int out;
snd_ctl_elem_value_t *val;
stream--;
if (stream < 0 || stream > 9) {
g_print("set_routes (1)\n");
return;
}
if (! stream_active[stream])
return;
out = 0;
if (idx == 1)
out = MAX_INPUT_CHANNELS + MAX_SPDIF_CHANNELS + 1;
else if (idx == 2 || idx == 3) /* S/PDIF left & right */
out = idx + 7; /* 9-10 */
else if (idx >= 4) /* analog */
out = idx - 3; /* 1-8 */
snd_ctl_elem_value_alloca(&val);
snd_ctl_elem_value_set_interface(val, SND_CTL_ELEM_IFACE_MIXER);
if (stream >= MAX_OUTPUT_CHANNELS) {
snd_ctl_elem_value_set_name(val, SPDIF_PLAYBACK_ROUTE_NAME);
snd_ctl_elem_value_set_index(val, stream - MAX_OUTPUT_CHANNELS);
} else {
snd_ctl_elem_value_set_name(val, ANALOG_PLAYBACK_ROUTE_NAME);
snd_ctl_elem_value_set_index(val, stream);
}
snd_ctl_elem_value_set_enumerated(val, 0, out);
if ((err = snd_ctl_elem_write(ctl, val)) < 0)
g_print("Multi track route write error: %s\n", snd_strerror(err));
}
int configure_T2_DAC2_AnalogR_Playback_Volume(snd_ctl_t *ctl,char on_off_status)
{
snd_ctl_elem_value_t *value;
snd_ctl_elem_value_alloca(&value);
snd_ctl_elem_value_set_interface(value, SND_CTL_ELEM_IFACE_MIXER);
snd_ctl_elem_value_set_name(value, control_elements_of_interest[6]);
if (on_off_status) {
g_t2_default_dac2_analogr = snd_ctl_elem_value_get_enumerated(value,0);
snd_ctl_elem_value_set_enumerated(value,0, on_off_status);
} else {
snd_ctl_elem_value_set_enumerated(value,0, g_t2_default_dac2_analogr);
}
return(snd_ctl_elem_write(ctl, value));
}
static void change_enum_elem_members(struct elem_set_trial *trial,
snd_ctl_elem_value_t *elem_data)
{
unsigned int val;
unsigned int i;
for (i = 0; i < trial->member_count; ++i) {
val = snd_ctl_elem_value_get_enumerated(elem_data, i);
snd_ctl_elem_value_set_enumerated(elem_data, i, ++val);
}
}
void adc_sense_toggled(GtkWidget *togglebutton, gpointer data)
{
int idx = (long)data >> 8;
int state = (long)data & 0xff;
snd_ctl_elem_value_t *val;
int err;
snd_ctl_elem_value_alloca(&val);
snd_ctl_elem_value_set_interface(val, SND_CTL_ELEM_IFACE_MIXER);
snd_ctl_elem_value_set_name(val, ADC_SENSE_NAME);
snd_ctl_elem_value_set_index(val, idx);
snd_ctl_elem_value_set_enumerated(val, 0, state);
if ((err = snd_ctl_elem_write(ctl, val)) < 0)
g_print("Unable to write adc sense: %s\n", snd_strerror(err));
}
/*
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;
}
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 amixer_control(t_amixer *x, int argc, t_atom *argv, int roflag)
{
int err;
snd_ctl_t *handle;
snd_ctl_elem_info_t *info;
snd_ctl_elem_id_t *id;
snd_ctl_elem_value_t *control;
char *ptr;
unsigned int idx, count;
long tmp;
snd_ctl_elem_type_t type;
snd_ctl_elem_info_alloca(&info);
snd_ctl_elem_id_alloca(&id);
snd_ctl_elem_value_alloca(&control);
if (argc < 1) {
error("Specify a full control identifier: [[iface=<iface>,][name='name',][index=<index>,][device=<device>,][subdevice=<subdevice>]]|[numid=<numid>]\n");
return -EINVAL;
}
if(A_FLOAT==argv->a_type){
snd_ctl_elem_id_set_numid(id, atom_getint(argv));
if(0)
{
error("Wrong control identifier: %d\n", atom_getint(argv));
return -EINVAL;
}
} else {
if (parse_control_id(atom_getsymbol(argv)->s_name, id)) {
error("Wrong control identifier: %s\n", atom_getsymbol(argv)->s_name);
return -EINVAL;
}
}
if ((err = snd_ctl_open(&handle, x->card, 0)) < 0) {
error("Control %s open error: %s\n", x->card, snd_strerror(err));
return err;
}
snd_ctl_elem_info_set_id(info, id);
if ((err = snd_ctl_elem_info(handle, info)) < 0) {
error("Control %s cinfo error: %s\n", x->card, snd_strerror(err));
return err;
}
snd_ctl_elem_info_get_id(info, id); /* FIXME: Remove it when hctl find works ok !!! */
type = snd_ctl_elem_info_get_type(info);
count = snd_ctl_elem_info_get_count(info);
snd_ctl_elem_value_set_id(control, id);
if (!roflag) {
t_float atom_float = atom_getfloat(argv+1);
int atom_isfloat = (A_FLOAT==(argv+1)->a_type);
post("now setting");
ptr = atom_getsymbol(argv+1)->s_name;
for (idx = 0; idx < count && idx < 128 && ptr && *ptr; idx++) {
switch (type) {
case SND_CTL_ELEM_TYPE_BOOLEAN:
tmp = 0;
if(atom_isfloat){
tmp=(atom_float>0)?1:0;
} else if (!strncasecmp(ptr, "on", 2) || !strncasecmp(ptr, "up", 2)) {
tmp = 1;
ptr += 2;
} else if (!strncasecmp(ptr, "yes", 3)) {
tmp = 1;
ptr += 3;
} else if (!strncasecmp(ptr, "toggle", 6)) {
tmp = snd_ctl_elem_value_get_boolean(control, idx);
tmp = tmp > 0 ? 0 : 1;
ptr += 6;
} else if (isdigit(*ptr)) {
tmp = atoi(ptr) > 0 ? 1 : 0;
while (isdigit(*ptr))
ptr++;
} else {
while (*ptr && *ptr != ',')
ptr++;
}
snd_ctl_elem_value_set_boolean(control, idx, tmp);
break;
case SND_CTL_ELEM_TYPE_INTEGER:
tmp = atom_isfloat?((int)atom_float):get_integer(&ptr,
snd_ctl_elem_info_get_min(info),
snd_ctl_elem_info_get_max(info));
snd_ctl_elem_value_set_integer(control, idx, tmp);
break;
case SND_CTL_ELEM_TYPE_INTEGER64:
tmp = atom_isfloat?((int)atom_float):get_integer64(&ptr,
snd_ctl_elem_info_get_min64(info),
snd_ctl_elem_info_get_max64(info));
snd_ctl_elem_value_set_integer64(control, idx, tmp);
break;
case SND_CTL_ELEM_TYPE_ENUMERATED:
tmp = atom_isfloat?((int)atom_float):get_integer(&ptr, 0, snd_ctl_elem_info_get_items(info) - 1);
snd_ctl_elem_value_set_enumerated(control, idx, tmp);
break;
case SND_CTL_ELEM_TYPE_BYTES:
tmp = atom_isfloat?((int)atom_float):get_integer(&ptr, 0, 255);
snd_ctl_elem_value_set_byte(control, idx, tmp);
break;
default:
break;
}
if (!strchr(atom_getsymbol(argv+1)->s_name, ','))
ptr = atom_getsymbol(argv+1)->s_name;
else if (*ptr == ',')
ptr++;
}
if ((err = snd_ctl_elem_write(handle, control)) < 0) {
error("Control %s element write error: %s\n", x->card, snd_strerror(err));
return err;
}
}
snd_ctl_close(handle);
if (1) {
snd_hctl_t *hctl;
snd_hctl_elem_t *elem;
if ((err = snd_hctl_open(&hctl, x->card, 0)) < 0) {
error("Control %s open error: %s\n", x->card, snd_strerror(err));
return err;
}
if ((err = snd_hctl_load(hctl)) < 0) {
error("Control %s load error: %s\n", x->card, snd_strerror(err));
return err;
}
elem = snd_hctl_find_elem(hctl, id);
if (elem)
show_control(x->card, " ", elem, LEVEL_BASIC | LEVEL_ID);
else
printf("Could not find the specified element\n");
snd_hctl_close(hctl);
}
}
static int cset(int argc, char *argv[], int roflag, int keep_handle)
{
int err;
static snd_ctl_t *handle = NULL;
snd_ctl_elem_info_t *info;
snd_ctl_elem_id_t *id;
snd_ctl_elem_value_t *control;
char *ptr;
unsigned int idx, count;
long tmp;
snd_ctl_elem_type_t type;
snd_ctl_elem_info_alloca(&info);
snd_ctl_elem_id_alloca(&id);
snd_ctl_elem_value_alloca(&control);
if (argc < 1)
return -EINVAL;
if (parse_control_id(argv[0], id))
return -EINVAL;
if (handle == NULL && (err = snd_ctl_open(&handle, card, 0)) < 0)
return err;
snd_ctl_elem_info_set_id(info, id);
if ((err = snd_ctl_elem_info(handle, info)) < 0)
{
if (!keep_handle)
{
snd_ctl_close(handle);
handle = NULL;
}
return err;
}
snd_ctl_elem_info_get_id(info, id);
type = snd_ctl_elem_info_get_type(info);
count = snd_ctl_elem_info_get_count(info);
snd_ctl_elem_value_set_id(control, id);
if (!roflag)
{
ptr = argv[1];
for (idx = 0; idx < count && idx < 128 && ptr && *ptr; idx++)
{
switch (type)
{
case SND_CTL_ELEM_TYPE_BOOLEAN:
tmp = 0;
if (!strncasecmp(ptr, "on", 2) || !strncasecmp(ptr, "up", 2))
{
tmp = 1;
ptr += 2;
}
else if (!strncasecmp(ptr, "yes", 3))
{
tmp = 1;
ptr += 3;
}
else if (!strncasecmp(ptr, "toggle", 6))
{
tmp = snd_ctl_elem_value_get_boolean(control, idx);
tmp = tmp > 0 ? 0 : 1;
ptr += 6;
}
else if (isdigit(*ptr))
{
tmp = atoi(ptr) > 0 ? 1 : 0;
while (isdigit(*ptr))
ptr++;
}
else
{
while (*ptr && *ptr != ',')
ptr++;
}
snd_ctl_elem_value_set_boolean(control, idx, tmp);
break;
case SND_CTL_ELEM_TYPE_INTEGER:
tmp = get_integer(&ptr,
snd_ctl_elem_info_get_min(info),
snd_ctl_elem_info_get_max(info));
snd_ctl_elem_value_set_integer(control, idx, tmp);
break;
case SND_CTL_ELEM_TYPE_INTEGER64:
tmp = get_integer64(&ptr,
snd_ctl_elem_info_get_min64(info),
snd_ctl_elem_info_get_max64(info));
snd_ctl_elem_value_set_integer64(control, idx, tmp);
break;
case SND_CTL_ELEM_TYPE_ENUMERATED:
tmp = get_ctl_enum_item_index(handle, info, &ptr);
if (tmp < 0)
tmp = get_integer(&ptr, 0, snd_ctl_elem_info_get_items(info) - 1);
snd_ctl_elem_value_set_enumerated(control, idx, tmp);
break;
case SND_CTL_ELEM_TYPE_BYTES:
tmp = get_integer(&ptr, 0, 255);
snd_ctl_elem_value_set_byte(control, idx, tmp);
break;
default:
break;
}
if (!strchr(argv[1], ','))
ptr = argv[1];
else if (*ptr == ',')
ptr++;
}
if ((err = snd_ctl_elem_write(handle, control)) < 0)
{
if (!keep_handle)
{
snd_ctl_close(handle);
handle = NULL;
}
return err;
}
}
if (! keep_handle)
{
snd_ctl_close(handle);
handle = NULL;
}
if (!quiet)
{
snd_hctl_t *hctl;
snd_hctl_elem_t *elem;
if ((err = snd_hctl_open(&hctl, card, 0)) < 0)
return err;
if ((err = snd_hctl_load(hctl)) < 0)
return err;
elem = snd_hctl_find_elem(hctl, id);
if (elem)
show_control(" ", elem, LEVEL_BASIC | LEVEL_ID);
snd_hctl_close(hctl);
}
return 0;
}
/**
* \brief parse ASCII string as CTL element value
* \param handle CTL handle
* \param dst destination CTL element value
* \param info CTL element info structure
* \param value source ASCII string
* \return zero on success, otherwise a negative error code
*
* Note: For toggle command, the dst must contain previous (current)
* state (do the #snd_ctl_elem_read call to obtain it).
*/
int snd_ctl_ascii_value_parse(snd_ctl_t *handle,
snd_ctl_elem_value_t *dst,
snd_ctl_elem_info_t *info,
const char *value)
{
const char *ptr = value;
snd_ctl_elem_id_t myid = {0};
snd_ctl_elem_type_t type;
unsigned int idx, count;
long tmp;
long long tmp64;
snd_ctl_elem_info_get_id(info, &myid);
type = snd_ctl_elem_info_get_type(info);
count = snd_ctl_elem_info_get_count(info);
snd_ctl_elem_value_set_id(dst, &myid);
for (idx = 0; idx < count && idx < 128 && ptr && *ptr; idx++) {
if (*ptr == ',')
goto skip;
switch (type) {
case SND_CTL_ELEM_TYPE_BOOLEAN:
tmp = 0;
if (!strncasecmp(ptr, "on", 2) ||
!strncasecmp(ptr, "up", 2)) {
tmp = 1;
ptr += 2;
} else if (!strncasecmp(ptr, "yes", 3)) {
tmp = 1;
ptr += 3;
} else if (!strncasecmp(ptr, "toggle", 6)) {
tmp = snd_ctl_elem_value_get_boolean(dst, idx);
tmp = tmp > 0 ? 0 : 1;
ptr += 6;
} else if (isdigit(*ptr)) {
tmp = atoi(ptr) > 0 ? 1 : 0;
while (isdigit(*ptr))
ptr++;
} else {
while (*ptr && *ptr != ',')
ptr++;
}
snd_ctl_elem_value_set_boolean(dst, idx, tmp);
break;
case SND_CTL_ELEM_TYPE_INTEGER:
tmp = get_integer(&ptr,
snd_ctl_elem_info_get_min(info),
snd_ctl_elem_info_get_max(info));
snd_ctl_elem_value_set_integer(dst, idx, tmp);
break;
case SND_CTL_ELEM_TYPE_INTEGER64:
tmp64 = get_integer64(&ptr,
snd_ctl_elem_info_get_min64(info),
snd_ctl_elem_info_get_max64(info));
snd_ctl_elem_value_set_integer64(dst, idx, tmp64);
break;
case SND_CTL_ELEM_TYPE_ENUMERATED:
tmp = get_ctl_enum_item_index(handle, info, &ptr);
if (tmp < 0)
tmp = get_integer(&ptr, 0,
snd_ctl_elem_info_get_items(info) - 1);
snd_ctl_elem_value_set_enumerated(dst, idx, tmp);
break;
case SND_CTL_ELEM_TYPE_BYTES:
tmp = get_integer(&ptr, 0, 255);
snd_ctl_elem_value_set_byte(dst, idx, tmp);
break;
default:
break;
}
skip:
if (!strchr(value, ','))
ptr = value;
else if (*ptr == ',')
ptr++;
}
return 0;
}
bool LegacyAmixerControl::accessHW(bool receive, string &error)
{
CAutoLog autoLog(getConfigurableElement(), "ALSA", isDebugEnabled());
#ifdef SIMULATION
if (receive) {
memset(getBlackboardLocation(), 0, getSize());
}
log_info("%s ALSA Element Instance: %s\t\t(Control Element: %s)",
receive ? "Reading" : "Writing",
getConfigurableElement()->getPath().c_str(),
getControlName().c_str());
return true;
#endif
int ret;
// Mixer handle
snd_ctl_t *sndCtrl;
uint32_t value;
uint32_t index;
uint32_t elementCount;
snd_ctl_elem_id_t *id;
snd_ctl_elem_info_t *info;
snd_ctl_elem_value_t *control;
logControlInfo(receive);
// Check parameter type is ok (deferred error, no exceptions available :-()
if (!isTypeSupported()) {
error = "Parameter type not supported.";
return false;
}
int cardNumber = getCardNumber();
if (cardNumber < 0) {
error = "Card " + getCardName() + " not found. Error: " + strerror(cardNumber);
return false;
}
#ifdef ANDROID
if ((ret = snd_ctl_hw_open(&sndCtrl, NULL, cardNumber, 0)) < 0) {
error = snd_strerror(ret);
return false;
}
#else
// Create device name
ostringstream deviceName;
deviceName << "hw:" << cardNumber;
// Open sound control
if ((ret = snd_ctl_open(&sndCtrl, deviceName.str().c_str(), 0)) < 0) {
error = snd_strerror(ret);
return false;
}
#endif
// Allocate in stack
snd_ctl_elem_id_alloca(&id);
snd_ctl_elem_info_alloca(&info);
snd_ctl_elem_value_alloca(&control);
// Set interface
snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_MIXER);
string controlName = getControlName();
// Set name or id
if (isdigit(controlName[0])) {
snd_ctl_elem_id_set_numid(id, asInteger(controlName));
} else {
snd_ctl_elem_id_set_name(id, controlName.c_str());
}
// Init info id
snd_ctl_elem_info_set_id(info, id);
// Get info
if ((ret = snd_ctl_elem_info(sndCtrl, info)) < 0) {
error = "ALSA: Unable to get element info " + controlName +
": " + snd_strerror(ret);
// Close sound control
snd_ctl_close(sndCtrl);
return false;
}
// Get type
snd_ctl_elem_type_t eType = snd_ctl_elem_info_get_type(info);
// Get element count
elementCount = snd_ctl_elem_info_get_count(info);
uint32_t scalarSize = getScalarSize();
// If size defined in the PFW different from alsa mixer control size, return an error
if (elementCount * scalarSize != getSize()) {
error = "ALSA: Control element count (" + asString(elementCount) +
") and configurable scalar element count (" +
asString(getSize() / scalarSize) + ") mismatch";
// Close sound control
snd_ctl_close(sndCtrl);
return false;
}
// Set value id
snd_ctl_elem_value_set_id(control, id);
if (receive) {
// Read element
if ((ret = snd_ctl_elem_read(sndCtrl, control)) < 0) {
error = "ALSA: Unable to read element " + controlName +
": " + snd_strerror(ret);
// Close sound control
snd_ctl_close(sndCtrl);
return false;
}
// Go through all indexes
for (index = 0; index < elementCount; index++) {
switch (eType) {
case SND_CTL_ELEM_TYPE_BOOLEAN:
value = snd_ctl_elem_value_get_boolean(control, index);
break;
case SND_CTL_ELEM_TYPE_INTEGER:
value = snd_ctl_elem_value_get_integer(control, index);
break;
case SND_CTL_ELEM_TYPE_INTEGER64:
value = snd_ctl_elem_value_get_integer64(control, index);
break;
case SND_CTL_ELEM_TYPE_ENUMERATED:
value = snd_ctl_elem_value_get_enumerated(control, index);
break;
case SND_CTL_ELEM_TYPE_BYTES:
value = snd_ctl_elem_value_get_byte(control, index);
break;
default:
error = "ALSA: Unknown control element type while reading alsa element " +
controlName;
return false;
}
if (isDebugEnabled()) {
log_info("Reading alsa element %s, index %u with value %u",
controlName.c_str(), index, value);
}
// Write data to blackboard (beware this code is OK on Little Endian machines only)
toBlackboard(value);
}
} else {
// Go through all indexes
for (index = 0; index < elementCount; index++) {
// Read data from blackboard (beware this code is OK on Little Endian machines only)
value = fromBlackboard();
if (isDebugEnabled()) {
log_info("Writing alsa element %s, index %u with value %u",
controlName.c_str(), index, value);
}
switch (eType) {
case SND_CTL_ELEM_TYPE_BOOLEAN:
snd_ctl_elem_value_set_boolean(control, index, value);
break;
case SND_CTL_ELEM_TYPE_INTEGER:
snd_ctl_elem_value_set_integer(control, index, value);
break;
case SND_CTL_ELEM_TYPE_INTEGER64:
snd_ctl_elem_value_set_integer64(control, index, value);
break;
case SND_CTL_ELEM_TYPE_ENUMERATED:
snd_ctl_elem_value_set_enumerated(control, index, value);
break;
case SND_CTL_ELEM_TYPE_BYTES:
snd_ctl_elem_value_set_byte(control, index, value);
break;
default:
error = "ALSA: Unknown control element type while writing alsa element " +
controlName;
return false;
}
}
// Write element
if ((ret = snd_ctl_elem_write(sndCtrl, control)) < 0) {
error = "ALSA: Unable to write element " + controlName +
": " + snd_strerror(ret);
// Close sound control
snd_ctl_close(sndCtrl);
return false;
}
}
// Close sound control
snd_ctl_close(sndCtrl);
return true;
}
int hw_audio_set(const char *name, int value)
{
static snd_ctl_t *handle = NULL;
int err;
snd_ctl_elem_id_t *id;
snd_ctl_elem_info_t *info;
snd_ctl_elem_value_t *control;
snd_ctl_elem_id_alloca(&id);
snd_ctl_elem_info_alloca(&info);
snd_ctl_elem_value_alloca(&control);
snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_MIXER);
snd_ctl_elem_id_set_name(id, name);
snd_ctl_elem_info_set_id(info, id);
if (handle == NULL &&
(err = snd_ctl_open(&handle, "default", 0)) < 0)
{
LOGE("Control default open error: %s\n", snd_strerror(err));
return 0;
}
int ret = snd_ctl_elem_info(handle, info);
if (ret < 0)
{
LOGE("Cannot find the given element from control default ret=%d %s ",
ret, snd_strerror(ret));
return 0;
}
snd_ctl_elem_type_t type = snd_ctl_elem_info_get_type(info);
snd_ctl_elem_info_get_id(info, id);
snd_ctl_elem_value_set_id(control, id);
switch (type) {
case SND_CTL_ELEM_TYPE_BOOLEAN:
snd_ctl_elem_value_set_boolean(control, 0, value);
break;
case SND_CTL_ELEM_TYPE_INTEGER:
snd_ctl_elem_value_set_integer(control, 0, value);
break;
case SND_CTL_ELEM_TYPE_INTEGER64:
snd_ctl_elem_value_set_integer64(control, 0, value);
break;
case SND_CTL_ELEM_TYPE_ENUMERATED:
snd_ctl_elem_value_set_enumerated(control, 0, value);
break;
case SND_CTL_ELEM_TYPE_BYTES:
snd_ctl_elem_value_set_byte(control, 0, value);
break;
default:
break;
}
ret = snd_ctl_elem_write(handle, control);
if(ret <0)
{
LOGE("Control default load error: %s\n", snd_strerror(ret));
}
return 1;
}
static int check_audio_route()
{
int err, idx, i;
snd_ctl_t *handle;
const char *route_ctrl_name = "Speaker Function";
snd_ctl_elem_value_t * elem_value;
snd_ctl_elem_info_t *info;
snd_ctl_elem_list_t elist;
snd_ctl_elem_id_t *eid;
snd_ctl_elem_value_alloca(&elem_value);
snd_ctl_elem_info_alloca(&info);
//snd_ctl_elem_value_set_numid(elem_value, 54);
if ((err = snd_ctl_open(&handle, "hw:0", 0)) < 0) {
db_msg("Open control error: %s\n", snd_strerror(err));
goto check_audio_route_err;
}
db_msg("card=%d\n", handle->card);
memset(&elist, 0, sizeof(elist));
if (snd_ctl_elem_list(handle, &elist) < 0) {
db_msg("snd_ctl_elem_list 1 failed\n");
goto check_audio_route_err;
}
eid = calloc(elist.count, sizeof(snd_ctl_elem_id_t));
elist.space = elist.count;
elist.pids = eid;
if (snd_ctl_elem_list(handle, &elist) < 0) {
db_msg("snd_ctl_elem_list 2 failed\n");
goto check_audio_route_err;
}
for (i = 0; i < elist.count; ++i) {
info->id.numid = eid[i].numid;
if ((err = snd_ctl_elem_info(handle, info)) < 0) {
db_msg("Cannot find the given element from control\n");
goto check_audio_route_err;
}
//db_msg("name[%d]=%s\n", i, snd_ctl_elem_info_get_name(info));
if (!strcmp(snd_ctl_elem_info_get_name(info), route_ctrl_name)) {
db_msg("route ctrl found!!!\n");
break;
}
}
snd_ctl_elem_value_set_numid(elem_value, info->id.numid);
if ((err = snd_ctl_elem_read(handle,elem_value)) < 0) {
db_msg("snd_ctl_elem_read error: %s\n", snd_strerror(err));
goto check_audio_route_err;
}
db_msg("numid=%d\n", snd_ctl_elem_value_get_numid(elem_value));
db_msg("name=%s\n", snd_ctl_elem_value_get_name(elem_value));
//to set the new value
snd_ctl_elem_value_set_enumerated(elem_value,0, 1);
if ((err = snd_ctl_elem_write(handle,elem_value)) < 0) {
db_msg("snd_ctl_elem_write error: %s\n", snd_strerror(err));
goto check_audio_route_err;
}
//read it out again to check if we did set the registers.
if ((err = snd_ctl_elem_read(handle,elem_value)) < 0) {
db_msg("snd_ctl_elem_read error: %s\n", snd_strerror(err));
goto check_audio_route_err;
}
db_msg("after: %d\n", snd_ctl_elem_value_get_enumerated(elem_value, 0));
snd_ctl_close(handle);
return 0;
check_audio_route_err:
snd_ctl_close(handle);
return -1;
}
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;
}
status_t ALSAControl::set(const char *name, unsigned int value, int index)
{
if (!mHandle) {
ALOGE("Control not initialized");
return NO_INIT;
}
snd_ctl_elem_id_t *id;
snd_ctl_elem_info_t *info;
snd_ctl_elem_id_alloca(&id);
snd_ctl_elem_info_alloca(&info);
snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_MIXER);
snd_ctl_elem_id_set_name(id, name);
snd_ctl_elem_info_set_id(info, id);
int ret = snd_ctl_elem_info(mHandle, info);
if (ret < 0) {
ALOGE("Control '%s' cannot get element info: %d", name, ret);
return BAD_VALUE;
}
int count = snd_ctl_elem_info_get_count(info);
if (index >= count) {
ALOGE("Control '%s' index is out of range (%d >= %d)", name, index, count);
return BAD_VALUE;
}
if (index == -1)
index = 0; // Range over all of them
else
count = index + 1; // Just do the one specified
snd_ctl_elem_type_t type = snd_ctl_elem_info_get_type(info);
snd_ctl_elem_value_t *control;
snd_ctl_elem_value_alloca(&control);
snd_ctl_elem_info_get_id(info, id);
snd_ctl_elem_value_set_id(control, id);
for (int i = index; i < count; i++)
switch (type) {
case SND_CTL_ELEM_TYPE_BOOLEAN:
snd_ctl_elem_value_set_boolean(control, i, value);
break;
case SND_CTL_ELEM_TYPE_INTEGER:
snd_ctl_elem_value_set_integer(control, i, value);
break;
case SND_CTL_ELEM_TYPE_INTEGER64:
snd_ctl_elem_value_set_integer64(control, i, value);
break;
case SND_CTL_ELEM_TYPE_ENUMERATED:
snd_ctl_elem_value_set_enumerated(control, i, value);
break;
case SND_CTL_ELEM_TYPE_BYTES:
snd_ctl_elem_value_set_byte(control, i, value);
break;
default:
break;
}
ret = snd_ctl_elem_write(mHandle, control);
return (ret < 0) ? BAD_VALUE : NO_ERROR;
}
void V4LRadioControl::callAmixer(const QString& target, const QString& value)
{
int err;
long tmp;
unsigned int count;
static snd_ctl_t *handle = NULL;
QString card("hw:0");
snd_ctl_elem_info_t *info;
snd_ctl_elem_id_t *id;
snd_ctl_elem_value_t *control;
snd_ctl_elem_type_t type;
snd_ctl_elem_info_alloca(&info);
snd_ctl_elem_id_alloca(&id);
snd_ctl_elem_value_alloca(&control);
snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_MIXER); /* MIXER */
// in amixer parse func
// char target[64];
// e.g. PGA CAPTure Switch
snd_ctl_elem_id_set_name(id, target.toAscii());
if (handle == NULL && (err = snd_ctl_open(&handle, card.toAscii(), 0)) < 0)
{
return;
}
snd_ctl_elem_info_set_id(info, id);
if ((err = snd_ctl_elem_info(handle, info)) < 0)
{
snd_ctl_close(handle);
handle = NULL;
return;
}
snd_ctl_elem_info_get_id(info, id); /* FIXME: Remove it when hctl find works ok !!! */
type = snd_ctl_elem_info_get_type(info);
count = snd_ctl_elem_info_get_count(info);
snd_ctl_elem_value_set_id(control, id);
tmp = 0;
for (uint idx = 0; idx < count && idx < 128; idx++)
{
switch (type)
{
case SND_CTL_ELEM_TYPE_BOOLEAN:
#ifdef MULTIMEDIA_MAEMO_DEBUG
qDebug() << "SND_CTL_ELEM_TYPE_BOOLEAN" << SND_CTL_ELEM_TYPE_BOOLEAN;
#endif
if ((value == "on") ||(value == "1"))
{
tmp = 1;
}
snd_ctl_elem_value_set_boolean(control, idx, tmp);
break;
case SND_CTL_ELEM_TYPE_ENUMERATED:
tmp = getEnumItemIndex(handle, info, value);
snd_ctl_elem_value_set_enumerated(control, idx, tmp);
break;
case SND_CTL_ELEM_TYPE_INTEGER:
#ifdef MULTIMEDIA_MAEMO_DEBUG
qDebug() << "SND_CTL_ELEM_TYPE_INTEGER" << SND_CTL_ELEM_TYPE_INTEGER;
#endif
tmp = atoi(value.toAscii());
if (tmp < snd_ctl_elem_info_get_min(info))
tmp = snd_ctl_elem_info_get_min(info);
else if (tmp > snd_ctl_elem_info_get_max(info))
tmp = snd_ctl_elem_info_get_max(info);
snd_ctl_elem_value_set_integer(control, idx, tmp);
break;
default:
break;
}
}
if ((err = snd_ctl_elem_write(handle, control)) < 0) {
snd_ctl_close(handle);
handle = NULL;
return;
}
snd_ctl_close(handle);
handle = NULL;
}
