void
gam_toggle_set_state (GamToggle *gam_toggle, gboolean state)
{
GamTogglePrivate *priv;
const gboolean internal_state = gam_toggle_get_state (gam_toggle);
int err;
priv = GAM_TOGGLE_GET_PRIVATE (gam_toggle);
if (state == internal_state) return;
if (snd_mixer_selem_has_playback_switch (priv->elem)) {
err = snd_mixer_selem_set_playback_switch_all (priv->elem, state);
} else if (snd_mixer_selem_has_capture_switch (priv->elem)) {
err = snd_mixer_selem_set_capture_switch_all (priv->elem, state);
} else {
g_warning ("%s (). No idea what to do for mixer element \"%s\"!",
__FUNCTION__, snd_mixer_selem_get_name (priv->elem));
err = 0;
}
if (err)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (gam_toggle),
internal_state);
}
void
gst_alsa_mixer_set_record (GstAlsaMixer * mixer,
GstMixerTrack * track, gboolean record)
{
GstAlsaMixerTrack *alsa_track = GST_ALSA_MIXER_TRACK (track);
g_return_if_fail (mixer->handle != NULL);
g_static_rec_mutex_lock (mixer->rec_mutex);
gst_alsa_mixer_track_update (alsa_track);
if (!!(record) == !!(track->flags & GST_MIXER_TRACK_RECORD)) {
g_static_rec_mutex_unlock (mixer->rec_mutex);
return;
}
if (record) {
track->flags |= GST_MIXER_TRACK_RECORD;
} else {
track->flags &= ~GST_MIXER_TRACK_RECORD;
}
if (alsa_track->alsa_flags & GST_ALSA_MIXER_TRACK_CSWITCH) {
snd_mixer_selem_set_capture_switch_all (alsa_track->element,
record ? 1 : 0);
/* update all tracks in same exlusive cswitch group */
if (alsa_track->alsa_flags & GST_ALSA_MIXER_TRACK_CSWITCH_EXCL) {
GList *item;
for (item = mixer->tracklist; item != NULL; item = item->next) {
if (GST_IS_ALSA_MIXER_TRACK (item->data)) {
GstAlsaMixerTrack *item_alsa_track =
GST_ALSA_MIXER_TRACK (item->data);
if (item_alsa_track->alsa_flags & GST_ALSA_MIXER_TRACK_CSWITCH_EXCL &&
item_alsa_track->capture_group == alsa_track->capture_group) {
gst_alsa_mixer_track_update (item_alsa_track);
}
}
}
}
} else {
gint i;
for (i = 0; i < track->num_channels; i++) {
long vol = record ? alsa_track->volumes[i] : track->min_volume;
snd_mixer_selem_set_capture_volume (alsa_track->element, i, vol);
}
}
g_static_rec_mutex_unlock (mixer->rec_mutex);
}
static void set_mixer_element(snd_mixer_t *mixer,const char *name, int level,MixerAction action){
const char *elemname;
snd_mixer_elem_t *elem;
long sndMixerPMin=0;
long sndMixerPMax=0;
long newvol=0;
elem=snd_mixer_first_elem(mixer);
while (elem!=NULL){
elemname=snd_mixer_selem_get_name(elem);
//ms_message("Found alsa mixer element %s.",elemname);
if (strcmp(elemname,name)==0){
switch(action){
case CAPTURE:
if (snd_mixer_selem_has_capture_volume(elem)){
snd_mixer_selem_get_capture_volume_range(elem, &sndMixerPMin, &sndMixerPMax);
newvol=(((sndMixerPMax-sndMixerPMin)*level)/100)+sndMixerPMin;
snd_mixer_selem_set_capture_volume_all(elem,newvol);
//ms_message("Successfully set capture level for %s.",elemname);
return;
}
break;
case PLAYBACK:
if (snd_mixer_selem_has_playback_volume(elem)){
snd_mixer_selem_get_playback_volume_range(elem, &sndMixerPMin, &sndMixerPMax);
newvol=(((sndMixerPMax-sndMixerPMin)*level)/100)+sndMixerPMin;
snd_mixer_selem_set_playback_volume_all(elem,newvol);
//ms_message("Successfully set playback level for %s.",elemname);
return;
}
break;
case CAPTURE_SWITCH:
if (snd_mixer_selem_has_capture_switch(elem)){
snd_mixer_selem_set_capture_switch_all(elem,level);
//ms_message("Successfully set capture switch for %s.",elemname);
}
break;
case PLAYBACK_SWITCH:
if (snd_mixer_selem_has_playback_switch(elem)){
snd_mixer_selem_set_playback_switch_all(elem,level);
//ms_message("Successfully set capture switch for %s.",elemname);
}
break;
}
}
elem=snd_mixer_elem_next(elem);
}
return ;
}
/*
* Class: org_tritonus_lowlevel_alsa_AlsaMixerElement
* Method: setCaptureSwitchAll
* Signature: (Z)V
*/
JNIEXPORT void JNICALL
Java_org_tritonus_lowlevel_alsa_AlsaMixerElement_setCaptureSwitchAll
(JNIEnv* env, jobject obj, jboolean bValue)
{
snd_mixer_elem_t* handle;
int nReturn;
if (debug_flag) {
(void) fprintf(debug_file, "Java_org_tritonus_lowlevel_alsa_AlsaMixerElement_setCaptureSwitchAll(): begin\n");
}
handle = getHandle(env, obj);
nReturn = snd_mixer_selem_set_capture_switch_all(handle, bValue);
if (nReturn < 0)
{
throwRuntimeException(env, snd_strerror(nReturn));
}
if (debug_flag) {
(void) fprintf(debug_file, "Java_org_tritonus_lowlevel_alsa_AlsaMixerElement_setCaptureSwitchAll(): end\n");
}
}
void PORT_SetIntValue(void* controlIDV, INT32 value) {
PortControl* portControl = (PortControl*) controlIDV;
snd_mixer_selem_channel_id_t channel;
if (portControl != NULL) {
if (portControl->controlType == CONTROL_TYPE_MUTE) {
value = ! value;
}
if (portControl->controlType == CONTROL_TYPE_MUTE ||
portControl->controlType == CONTROL_TYPE_SELECT) {
if (isPlaybackFunction(portControl->portType)) {
snd_mixer_selem_set_playback_switch_all(portControl->elem, value);
} else {
snd_mixer_selem_set_capture_switch_all(portControl->elem, value);
}
} else {
ERROR1("PORT_SetIntValue(): inappropriate control type: %s\n",
portControl->controlType);
}
}
}
status_t ALSAMixer::setCaptureMuteState(uint32_t device, bool state)
{
for (int j = 0; mixerProp[j][SND_PCM_STREAM_CAPTURE].device; j++)
if (mixerProp[j][SND_PCM_STREAM_CAPTURE].device & device) {
mixer_info_t *info = mixerProp[j][SND_PCM_STREAM_CAPTURE].mInfo;
if (!info || !info->elem) return INVALID_OPERATION;
if (snd_mixer_selem_has_capture_switch (info->elem)) {
int err = snd_mixer_selem_set_capture_switch_all (info->elem, static_cast<int>(!state));
if (err < 0) {
ALOGE("Unable to %s capture mixer switch %s",
state ? "enable" : "disable", info->name);
return INVALID_OPERATION;
}
}
info->mute = state;
}
return NO_ERROR;
}
static int
setlevels(const char *dev)
{
snd_mixer_t *handle;
snd_mixer_selem_id_t *sid;
snd_mixer_elem_t *elem;
int err;
char *mixer_dev, *c;
/* Basically we just want to turn on Mic capture. */
if ((err = snd_mixer_open(&handle, 0)) < 0) {
fprintf(stderr, "Mixer open failed: %s\n", snd_strerror(err));
return -1;
}
mixer_dev = strdup(dev);
if (strncmp(mixer_dev, "plug", 4) == 0)
memmove(mixer_dev, mixer_dev + 4, strlen(mixer_dev) - 4 + 1);
if ((c = strchr(mixer_dev, ',')))
*c = '\0';
if ((err = snd_mixer_attach(handle, mixer_dev)) < 0) {
fprintf(stderr, "Mixer attach to %s failed: %s\n",
mixer_dev, snd_strerror(err));
free(mixer_dev);
snd_mixer_close(handle);
return -1;
}
free(mixer_dev);
if ((err = snd_mixer_selem_register(handle, NULL, NULL)) < 0) {
fprintf(stderr, "Mixer register failed: %s\n", snd_strerror(err));
snd_mixer_close(handle);
return -1;
}
if ((err = snd_mixer_load(handle)) < 0) {
fprintf(stderr, "Mixer load failed: %s\n", snd_strerror(err));
snd_mixer_close(handle);
return -1;
}
snd_mixer_selem_id_alloca(&sid);
snd_mixer_selem_id_set_name(sid, "Mic");
if ((elem = snd_mixer_find_selem(handle, sid)) == NULL) {
fprintf(stderr, "Warning: Could not find Mic element\n");
}
else {
if ((err = snd_mixer_selem_set_capture_switch_all(elem, 1)) < 0) {
fprintf(stderr,
"Failed to enable microphone capture: %s\n",
snd_strerror(err));
snd_mixer_close(handle);
return -1;
}
}
snd_mixer_selem_id_set_name(sid, "Capture");
if ((elem = snd_mixer_find_selem(handle, sid)) == NULL) {
fprintf(stderr, "Warning: Could not find Capture element\n");
}
else {
if ((err = snd_mixer_selem_set_capture_switch_all(elem, 1)) < 0) {
fprintf(stderr,
"Failed to enable microphone capture: %s\n",
snd_strerror(err));
snd_mixer_close(handle);
return -1;
}
}
return 0;
}
