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; }