static int
_phoneui_utils_sound_volume_mute_changed_cb(snd_hctl_elem_t *elem, unsigned int mask)
{
snd_ctl_elem_value_t *control;
enum SoundControlType type;
int mute;
if (mask == SND_CTL_EVENT_MASK_REMOVE)
return 0;
if (mask & SND_CTL_EVENT_MASK_VALUE) {
snd_ctl_elem_value_alloca(&control);
snd_hctl_elem_read(elem, control);
type = _phoneui_utils_sound_volume_mute_element_to_type(elem);
if (type != CONTROL_END) {
mute = phoneui_utils_sound_volume_mute_get(type);
g_debug("Got alsa mute change for control type '%d', new value: %d",
type, mute);
if (_phoneui_utils_sound_volume_mute_changed_callback) {
_phoneui_utils_sound_volume_mute_changed_callback(type, mute, _phoneui_utils_sound_volume_mute_changed_userdata);
}
}
}
return 0;
}
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;
}
static int
hammerfall_set_input_monitor_mask (jack_hardware_t *hw, unsigned long mask)
{
hammerfall_t *h = (hammerfall_t *) hw->private_hw;
snd_ctl_elem_value_t *ctl;
snd_ctl_elem_id_t *ctl_id;
int err;
int i;
snd_ctl_elem_value_alloca (&ctl);
snd_ctl_elem_id_alloca (&ctl_id);
set_control_id (ctl_id, "Channels Thru");
snd_ctl_elem_value_set_id (ctl, ctl_id);
for (i = 0; i < 26; i++) {
snd_ctl_elem_value_set_integer (ctl, i, (mask & (1<<i)) ? 1 : 0);
}
if ((err = snd_ctl_elem_write (h->driver->ctl_handle, ctl)) != 0) {
jack_error ("ALSA/Hammerfall: cannot set input monitoring (%s)", snd_strerror (err));
return -1;
}
hw->input_monitor_mask = mask;
return 0;
}
long
phoneui_utils_sound_volume_raw_get(enum SoundControlType type)
{
int err;
long value;
unsigned int i,count;
snd_ctl_elem_value_t *control;
snd_ctl_elem_value_alloca(&control);
snd_hctl_elem_t *elem;
count = controls[STATE_INDEX][type].count;
elem = controls[STATE_INDEX][type].element;
if (!elem || !count) {
return 0;
}
err = snd_hctl_elem_read(elem, control);
if (err < 0) {
g_warning("%s", snd_strerror(err));
return -1;
}
value = 0;
/* FIXME: possible long overflow */
for (i = 0 ; i < count ; i++) {
value += snd_ctl_elem_value_get_integer(control, i);
}
value /= count;
return value;
}
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;
}
void patchbay_init(void)
{
int i;
int nb_active_channels;
snd_ctl_elem_value_t *val;
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, ANALOG_PLAYBACK_ROUTE_NAME);
memset (stream_active, 0, (MAX_OUTPUT_CHANNELS + MAX_SPDIF_CHANNELS) * sizeof(int));
nb_active_channels = 0;
for (i = 0; i < output_channels; i++) {
snd_ctl_elem_value_set_numid(val, 0);
snd_ctl_elem_value_set_index(val, i);
if (snd_ctl_elem_read(ctl, val) < 0)
continue;
stream_active[i] = 1;
nb_active_channels++;
}
output_channels = nb_active_channels;
snd_ctl_elem_value_set_name(val, SPDIF_PLAYBACK_ROUTE_NAME);
nb_active_channels = 0;
for (i = 0; i < spdif_channels; i++) {
snd_ctl_elem_value_set_numid(val, 0);
snd_ctl_elem_value_set_index(val, i);
if (snd_ctl_elem_read(ctl, val) < 0)
continue;
stream_active[i + MAX_OUTPUT_CHANNELS] = 1;
nb_active_channels++;
}
spdif_channels = nb_active_channels;
}
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 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));
}
static int get_toggle_index(int stream)
{
int err, out;
snd_ctl_elem_value_t *val;
stream--;
if (stream < 0 || stream > 9) {
g_print("get_toggle_index (1)\n");
return 0;
}
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);
}
if ((err = snd_ctl_elem_read(ctl, val)) < 0)
return 0;
out = snd_ctl_elem_value_get_enumerated(val, 0);
if (out >= MAX_INPUT_CHANNELS + MAX_SPDIF_CHANNELS + 1) {
if (stream >= MAX_PCM_OUTPUT_CHANNELS || stream < MAX_SPDIF_CHANNELS)
return 1; /* digital mixer */
} else if (out >= MAX_INPUT_CHANNELS + 1)
return out - (MAX_INPUT_CHANNELS + 1) + 2; /* spdif left (=2) / right (=3) */
else if (out >= 1)
return out + spdif_channels + 1; /* analog (4-) */
return 0; /* pcm */
}
void ipga_volume_update(int idx)
{
snd_ctl_elem_value_t *val;
int err, ipga_vol;
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, IPGA_VOLUME_NAME);
snd_ctl_elem_value_set_index(val, idx);
if ((err = snd_ctl_elem_read(ctl, val)) < 0) {
g_print("Unable to read ipga volume: %s\n", snd_strerror(err));
return;
}
gtk_adjustment_set_value(GTK_ADJUSTMENT(av_ipga_volume_adj[idx]),
-(ipga_vol = snd_ctl_elem_value_get_integer(val, 0)));
snd_ctl_elem_value_set_name(val, ADC_VOLUME_NAME);
snd_ctl_elem_value_set_index(val, idx);
if ((err = snd_ctl_elem_read(ctl, val)) < 0) {
g_print("Unable to read adc volume: %s\n", snd_strerror(err));
return;
}
// set ADC volume to max if IPGA volume greater 0
if (ipga_vol)
gtk_adjustment_set_value(GTK_ADJUSTMENT(av_adc_volume_adj[idx]),
-adc_max);
}
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 int elem_read_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 < s->str[0].channels; idx++) {
unsigned int idx1 = idx;
if (idx >= c->values)
idx1 = 0;
s->str[0].vol[idx] = snd_ctl_elem_value_get_enumerated(ctl, idx1);
}
return 0;
}
void audio_set_default_levels() {
int err;
snd_ctl_t *ctl;
snd_ctl_elem_value_t *val;
snd_ctl_elem_value_alloca(&val);
if (snd_ctl_open(&ctl, ALSA_DEVICE, 0)) {
fprintf(stderr, "can't open audio device");
return;
}
/* unmute microphone */
snd_ctl_elem_value_set_interface(val, SND_CTL_ELEM_IFACE_MIXER);
snd_ctl_elem_value_set_name(val, "Mic Capture Switch");
snd_ctl_elem_value_set_integer(val, 0, 1);
err = snd_ctl_elem_write(ctl, val);
if (err)
fprintf(stderr, "can't unmute microphone: %s\n", snd_strerror(err));
/* unmute speaker */
snd_ctl_elem_value_clear(val);
snd_ctl_elem_value_set_interface(val, SND_CTL_ELEM_IFACE_MIXER);
snd_ctl_elem_value_set_name(val, "Speaker Playback Switch");
snd_ctl_elem_value_set_integer(val, 0, 1);
err = snd_ctl_elem_write(ctl, val);
if (err)
fprintf(stderr, "can't unmute speaker: %s\n", snd_strerror(err));
/* set mic volume */
snd_ctl_elem_value_clear(val);
snd_ctl_elem_value_set_interface(val, SND_CTL_ELEM_IFACE_MIXER);
snd_ctl_elem_value_set_name(val, "Mic Capture Volume");
snd_ctl_elem_value_set_integer(val, 0, DEFAULT_MIC_VOL);
err = snd_ctl_elem_write(ctl, val);
if (err)
fprintf(stderr, "can't set microphone volume: %s\n", snd_strerror(err));
/* set speaker volume */
snd_ctl_elem_value_clear(val);
snd_ctl_elem_value_set_interface(val, SND_CTL_ELEM_IFACE_MIXER);
snd_ctl_elem_value_set_name(val, "Speaker Playback Volume");
snd_ctl_elem_value_set_integer(val, 0, DEFAULT_SPKR_VOL);
snd_ctl_elem_value_set_integer(val, 1, DEFAULT_SPKR_VOL);
err = snd_ctl_elem_write(ctl, val);
if (err)
fprintf(stderr, "can't set speaker volume: %s\n", snd_strerror(err));
/* set capture source */
snd_ctl_elem_value_clear(val);
snd_ctl_elem_value_set_interface(val, SND_CTL_ELEM_IFACE_MIXER);
snd_ctl_elem_value_set_name(val, "PCM Capture Source");
snd_ctl_elem_value_set_integer(val, 0, 0);
err = snd_ctl_elem_write(ctl, val);
if (err)
fprintf(stderr, "can't set capture source: %s\n", snd_strerror(err));
snd_ctl_close(ctl);
}
int V4LRadioControl::volume() const
{
const QString ctlName("Line DAC Playback Volume");
const QString card("hw:0");
int volume = 0;
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;
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 */
snd_ctl_elem_id_set_name(id, ctlName.toAscii());
if ((err = snd_ctl_open(&handle, card.toAscii(), 0)) < 0) {
return 0;
}
snd_ctl_elem_info_set_id(info, id);
if ((err = snd_ctl_elem_info(handle, info)) < 0) {
snd_ctl_close(handle);
handle = NULL;
return 0;
}
snd_ctl_elem_info_get_id(info, id); /* FIXME: Remove it when hctl find works ok !!! */
snd_ctl_elem_value_set_id(control, id);
snd_ctl_close(handle);
handle = NULL;
snd_hctl_t *hctl;
snd_hctl_elem_t *elem;
if ((err = snd_hctl_open(&hctl, card.toAscii(), 0)) < 0) {
return 0;
}
if ((err = snd_hctl_load(hctl)) < 0) {
return 0;
}
elem = snd_hctl_find_elem(hctl, id);
if (elem)
volume = vol(elem);
snd_hctl_close(hctl);
return (volume/118.0) * 100;
}
bool CAESinkALSA::GetELD(snd_hctl_t *hctl, int device, CAEDeviceInfo& info, bool& badHDMI)
{
badHDMI = false;
snd_ctl_elem_id_t *id;
snd_ctl_elem_info_t *einfo;
snd_ctl_elem_value_t *control;
snd_hctl_elem_t *elem;
snd_ctl_elem_id_alloca(&id);
memset(id, 0, snd_ctl_elem_id_sizeof());
snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_PCM);
snd_ctl_elem_id_set_name (id, "ELD" );
snd_ctl_elem_id_set_device (id, device);
elem = snd_hctl_find_elem(hctl, id);
if (!elem)
return false;
snd_ctl_elem_info_alloca(&einfo);
memset(einfo, 0, snd_ctl_elem_info_sizeof());
if (snd_hctl_elem_info(elem, einfo) < 0)
return false;
if (!snd_ctl_elem_info_is_readable(einfo))
return false;
if (snd_ctl_elem_info_get_type(einfo) != SND_CTL_ELEM_TYPE_BYTES)
return false;
snd_ctl_elem_value_alloca(&control);
memset(control, 0, snd_ctl_elem_value_sizeof());
if (snd_hctl_elem_read(elem, control) < 0)
return false;
int dataLength = snd_ctl_elem_info_get_count(einfo);
/* if there is no ELD data, then its a bad HDMI device, either nothing attached OR an invalid nVidia HDMI device
* OR the driver doesn't properly support ELD (notably ATI/AMD, 2012-05) */
if (!dataLength)
badHDMI = true;
else
CAEELDParser::Parse(
(const uint8_t*)snd_ctl_elem_value_get_bytes(control),
dataLength,
info
);
info.m_deviceType = AE_DEVTYPE_HDMI;
return true;
}
int get_gain(int idx, int src, int dst)
{
int err;
int val = HDSPMM_ERROR_NO_CARD;
snd_ctl_elem_id_t *id;
snd_ctl_elem_value_t *ctl;
snd_ctl_t *handle;
if(idx >= HDSPMM_MAX_CARDS || idx < 0)
return HDSPMM_ERROR_WRONG_IDX;
snd_ctl_elem_value_alloca(&ctl);
snd_ctl_elem_id_alloca(&id);
snd_ctl_elem_id_set_name(id, "Mixer");
snd_ctl_elem_id_set_numid(id, 0);
snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_HWDEP);
snd_ctl_elem_id_set_device(id, 0);
snd_ctl_elem_id_set_subdevice(id, 0);
snd_ctl_elem_id_set_index(id, 0);
snd_ctl_elem_value_set_id(ctl, id);
if ((err = snd_ctl_open(&handle, card_name[cardid], SND_CTL_NONBLOCK)) < 0) {
#ifndef QUIET
fprintf(stderr, "Alsa error: %s\n", snd_strerror(err));
#endif
return HDSPMM_ERROR_ALSA_OPEN;
}
snd_ctl_elem_value_set_integer(ctl, 0, src);
snd_ctl_elem_value_set_integer(ctl, 1, dst);
if ((err = snd_ctl_elem_read(handle, ctl)) < 0) {
#ifndef QUIET
fprintf(stderr, "Alsa error: %s\n", snd_strerror(err));
#endif
return HDSPMM_ERROR_ALSA_READ;
}
val = snd_ctl_elem_value_get_integer(ctl, 2);
snd_ctl_close(handle);
return val;
SETFLOAT(x->x_at+1, delta);
SETFLOAT(x->x_at+2, phi);
outlet_list(x->x_out_para, &s_list, 3, x->x_at);
outlet_anything(x->x_obj.ob_outlet, s, x->x_size2d+1, x->x_at);
}
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;
}
void dac_volume_update(int idx)
{
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, DAC_VOLUME_NAME);
snd_ctl_elem_value_set_index(val, idx);
if ((err = snd_ctl_elem_read(ctl, val)) < 0) {
g_print("Unable to read dac volume: %s\n", snd_strerror(err));
return;
}
gtk_adjustment_set_value(GTK_ADJUSTMENT(av_dac_volume_adj[idx]),
-snd_ctl_elem_value_get_integer(val, 0));
}
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));
}
void adc_sense_update(int idx)
{
snd_ctl_elem_value_t *val;
int err;
int state;
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);
if ((err = snd_ctl_elem_read(ctl, val)) < 0) {
g_print("Unable to read adc sense: %s\n", snd_strerror(err));
return;
}
state = snd_ctl_elem_value_get_enumerated(val, 0);
toggle_set(av_adc_sense_radio[idx][state], TRUE);
}
static int elem_read_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 < s->str[dir].channels; idx++) {
unsigned int idx1 = idx;
if (idx >= c->values)
idx1 = 0;
s->str[dir].vol[idx] = to_user(s, dir, c, snd_ctl_elem_value_get_integer(ctl, idx1));
}
return 0;
}
void ipga_volume_adjust(GtkAdjustment *adj, gpointer data)
{
int idx = (int)(long)data;
snd_ctl_elem_value_t *val;
int err, ival = -(int)adj->value;
char text[16];
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, IPGA_VOLUME_NAME);
snd_ctl_elem_value_set_index(val, idx);
snd_ctl_elem_value_set_integer(val, 0, ival);
sprintf(text, "%03i", ival);
gtk_label_set_text(av_ipga_volume_label[idx], text);
if ((err = snd_ctl_elem_write(ctl, val)) < 0)
g_print("Unable to write ipga volume: %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 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);
}
int set_gain(int idx, int src, int dst, int val)
{
int err;
snd_ctl_elem_id_t *id;
snd_ctl_elem_value_t *ctl;
snd_ctl_t *handle;
if(idx >= HDSPMM_MAX_CARDS || idx < 0)
return HDSPMM_ERROR_WRONG_IDX;
snd_ctl_elem_value_alloca(&ctl);
snd_ctl_elem_id_alloca(&id);
snd_ctl_elem_id_set_name(id, "Mixer");
snd_ctl_elem_id_set_numid(id, 0);
snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_HWDEP);
snd_ctl_elem_id_set_device(id, 0);
snd_ctl_elem_id_set_subdevice(id, 0);
snd_ctl_elem_id_set_index(id, 0);
snd_ctl_elem_value_set_id(ctl, id);
if ((err = snd_ctl_open(&handle, card_name[idx], SND_CTL_NONBLOCK)) < 0) {
#ifndef QUIET
fprintf(stderr, "Alsa error: %s\n", snd_strerror(err));
#endif
return HDSPMM_ERROR_ALSA_OPEN;
}
snd_ctl_elem_value_set_integer(ctl, 0, src);
snd_ctl_elem_value_set_integer(ctl, 1, dst);
snd_ctl_elem_value_set_integer(ctl, 2, val);
if ((err = snd_ctl_elem_write(handle, ctl)) < 0) {
#ifndef QUIET
fprintf(stderr, "Alsa error: %s\n", snd_strerror(err));
#endif
return HDSPMM_ERROR_ALSA_WRITE;
}
val = snd_ctl_elem_value_get_integer(ctl, 2);
snd_ctl_close(handle);
return val;
}
static int elem_read_route(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 < s->str[dir].channels; idx++) {
unsigned int idx1 = idx;
if (idx >= c->values)
idx1 = 0;
if (!snd_ctl_elem_value_get_integer(ctl, idx1 * c->values + idx1))
s->str[dir].sw &= ~(1 << idx);
}
return 0;
}
int V4LRadioControl::vol(snd_hctl_elem_t *elem) const
{
const QString card("hw:0");
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);
if ((err = snd_hctl_elem_info(elem, info)) < 0) {
return 0;
}
snd_hctl_elem_get_id(elem, id);
snd_hctl_elem_read(elem, control);
return snd_ctl_elem_value_get_integer(control, 0);
}
static int get_enum_item_ops(snd_mixer_elem_t *elem,
snd_mixer_selem_channel_id_t channel,
unsigned int *itemp)
{
selem_none_t *s = snd_mixer_elem_get_private(elem);
snd_ctl_elem_value_t *ctl;
snd_hctl_elem_t *helem;
int err;
if ((unsigned int) channel >= s->str[0].channels)
return -EINVAL;
helem = s->ctls[CTL_GLOBAL_ENUM].elem;
if (!helem) helem = s->ctls[CTL_PLAYBACK_ENUM].elem;
if (!helem) helem = s->ctls[CTL_CAPTURE_ENUM].elem;
assert(helem);
snd_ctl_elem_value_alloca(&ctl);
err = snd_hctl_elem_read(helem, ctl);
if (! err)
*itemp = snd_ctl_elem_value_get_enumerated(ctl, channel);
return err;
}
