INT32 PORT_GetIntValue(void* controlIDV) {
PortControl* portControl = (PortControl*) controlIDV;
int value = 0;
snd_mixer_selem_channel_id_t channel;
if (portControl != NULL) {
switch (portControl->channel) {
case CHANNELS_MONO:
channel = SND_MIXER_SCHN_MONO;
break;
case CHANNELS_STEREO:
channel = SND_MIXER_SCHN_FRONT_LEFT;
break;
default:
channel = portControl->channel;
}
if (portControl->controlType == CONTROL_TYPE_MUTE ||
portControl->controlType == CONTROL_TYPE_SELECT) {
if (isPlaybackFunction(portControl->portType)) {
snd_mixer_selem_get_playback_switch(portControl->elem, channel, &value);
} else {
snd_mixer_selem_get_capture_switch(portControl->elem, channel, &value);
}
if (portControl->controlType == CONTROL_TYPE_MUTE) {
value = ! value;
}
} else {
ERROR1("PORT_GetIntValue(): inappropriate control type: %s\n",
portControl->controlType);
}
}
return (INT32) value;
}
static int get_current_input_source(px_mixer *Px)
{
PxInfo *info = (PxInfo *)Px->info;
snd_mixer_elem_t *elem;
int sw;
int i, j;
if (!info->capture.handle) {
return -1;
}
for (i = 0; i < info->capture.numselems; i++) {
elem = info->capture.selems[i].elem;
for (j = 0; j <= SND_MIXER_SCHN_LAST; j++) {
if (snd_mixer_selem_has_capture_switch(elem)) {
snd_mixer_selem_get_capture_switch(elem, j, &sw);
if (sw) {
return i;
}
}
}
}
return -1; /* none */
}
static gboolean alsa_mixer_is_muted(snd_mixer_elem_t *elem, gboolean *need_reset) {
int sw;
long Rvol, Lvol, min, max;
if(need_reset)
*need_reset = FALSE;
/**if switch is available, get switch status directly*/
if(snd_mixer_selem_has_playback_switch(elem)) {
snd_mixer_selem_get_playback_switch(elem, 0, &sw);
return sw ? FALSE: TRUE;
} else if(snd_mixer_selem_has_capture_switch(elem)) {
snd_mixer_selem_get_capture_switch(elem, 0, &sw);
return sw ? FALSE: TRUE;
}
if(snd_mixer_selem_has_playback_volume(elem)) {
snd_mixer_selem_get_playback_volume(elem, 0, &Rvol);
snd_mixer_selem_get_playback_volume(elem, 1, &Lvol);
snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
if(need_reset)
*need_reset = !!(max - Rvol);
return (Rvol + Lvol) ? FALSE: TRUE;
} else if(snd_mixer_selem_has_capture_volume(elem)) {
snd_mixer_selem_get_capture_volume_range(elem, &min, &max);
snd_mixer_selem_get_capture_volume(elem, 0, &Rvol);
snd_mixer_selem_get_capture_volume(elem, 1, &Lvol);
if(need_reset)
*need_reset = !!(max - Rvol);
return (Rvol + Lvol) ? FALSE: TRUE;
}
}
static void _get_switch(snd_mixer_elem_t *elem, int playback, int n, int *val)
{
if (playback) {
snd_mixer_selem_get_playback_switch(elem, n, val);
} else {
snd_mixer_selem_get_capture_switch(elem, n, val);
*val = !*val;
}
}
static int elem_get_status(snd_mixer_elem_t *elem)
{
int i, psw = -1;
for (i = 0; i <= SND_MIXER_SCHN_LAST; i++) {
if (snd_mixer_selem_has_playback_channel(elem, i) &&
snd_mixer_selem_has_playback_switch(elem))
snd_mixer_selem_get_playback_switch(elem, i, &psw);
else if (snd_mixer_selem_has_capture_channel(elem, i) &&
snd_mixer_selem_has_capture_switch(elem))
snd_mixer_selem_get_capture_switch(elem, i, &psw);
}
return psw;
}
static int lamixer_volbox_change(snd_mixer_elem_t *elem, unsigned int mask)
{
long rangevalue=0;
int mutesw;
MixerElem *mixer_elem;
if (mask == SND_CTL_EVENT_MASK_REMOVE)
return 0;
if (mask & SND_CTL_EVENT_MASK_VALUE) {
mixer_elem = snd_mixer_elem_get_callback_private(elem);
if(mixer_elem->playback != NULL) {
snd_mixer_selem_get_playback_volume(elem, SND_MIXER_SCHN_FRONT_LEFT, &rangevalue);
lamixer_volbox_check(mixer_elem->playback->volbar, mixer_elem->playback->hsignalid, rangevalue, &mixer_elem->playback->curval);
if(mixer_elem->playback->rvolbar != NULL)
{
rangevalue=0;
snd_mixer_selem_get_playback_volume(elem, SND_MIXER_SCHN_FRONT_RIGHT, &rangevalue);
lamixer_volbox_check(mixer_elem->playback->rvolbar, mixer_elem->playback->hsignalidr, rangevalue, &mixer_elem->playback->rcurval);
}
if(mixer_elem->playback->muteswitch != NULL) {
snd_mixer_selem_get_playback_switch (elem, SND_MIXER_SCHN_FRONT_LEFT, &mutesw);
lamixer_switch_checkvalue(mixer_elem->playback->muteswitch, mutesw, mixer_elem->playback->hmutesignalid);
}
}
if(mixer_elem->capture != NULL) {
rangevalue=0;
snd_mixer_selem_get_capture_volume(elem, SND_MIXER_SCHN_FRONT_LEFT, &rangevalue);
lamixer_volbox_check(mixer_elem->capture->volbar, mixer_elem->capture->hsignalid, rangevalue, &mixer_elem->capture->curval);
if(mixer_elem->capture->rvolbar != NULL)
{
rangevalue=0;
snd_mixer_selem_get_capture_volume(elem, SND_MIXER_SCHN_FRONT_RIGHT, &rangevalue);
lamixer_volbox_check(mixer_elem->capture->rvolbar, mixer_elem->capture->hsignalidr, rangevalue, &mixer_elem->capture->rcurval);
}
if(mixer_elem->capture->muteswitch != NULL) {
snd_mixer_selem_get_capture_switch (elem, SND_MIXER_SCHN_FRONT_LEFT, &mutesw);
lamixer_switch_checkvalue(mixer_elem->capture->muteswitch, mutesw, mixer_elem->capture->hmutesignalid);
}
}
}
return 0;
}
bool AlsaMixer::GetChannelSwitch( const char* channel, bool* on )
{
bool success = false;
snd_mixer_elem_t *elem;
snd_mixer_selem_id_t *sid;
snd_mixer_selem_id_alloca(&sid);
snd_mixer_selem_id_set_index( sid, 0);
snd_mixer_selem_id_set_name( sid, channel);
elem = snd_mixer_find_selem(_handle, sid);
if (!elem) {
LOG( Logger::LOG_ERROR, "Unable to find simple control '%s',%i\n", snd_mixer_selem_id_get_name(sid), snd_mixer_selem_id_get_index(sid));
goto end;
}
if( snd_mixer_selem_has_playback_switch(elem) )
{
for (int chn = 0; chn <= SND_MIXER_SCHN_LAST; chn++) {
int value;
if (snd_mixer_selem_get_playback_switch(elem, (snd_mixer_selem_channel_id_t)chn, &value) >= 0)
{
*on = value != 0;
success = true;
break;
}
}
}else if( snd_mixer_selem_has_capture_switch(elem) )
{
for (int chn = 0; chn <= SND_MIXER_SCHN_LAST; chn++) {
int value;
if (snd_mixer_selem_get_capture_switch(elem, (snd_mixer_selem_channel_id_t)chn, &value ) >= 0)
{
*on = value != 0;
success = true;
break;
}
}
}
if( !success )
{
LOG( Logger::LOG_ERROR, "Error getting control '%s',%i\n", snd_mixer_selem_id_get_name(sid), snd_mixer_selem_id_get_index(sid));
}
end:
return success;
}
gboolean
gam_toggle_get_state (GamToggle *gam_toggle)
{
GamTogglePrivate *priv;
gint value = 0;
priv = GAM_TOGGLE_GET_PRIVATE (gam_toggle);
if (snd_mixer_selem_has_playback_switch (priv->elem)) {
snd_mixer_selem_get_playback_switch (priv->elem, 0, &value);
} else if (snd_mixer_selem_has_capture_switch (priv->elem)) {
snd_mixer_selem_get_capture_switch (priv->elem, 0, &value);
} else {
g_warning ("%s (). No idea what to do for mixer element \"%s\"!",
__FUNCTION__, snd_mixer_selem_get_name (priv->elem));
}
return value;
}
/*
* Class: org_tritonus_lowlevel_alsa_AlsaMixerElement
* Method: getCaptureSwitch
* Signature: (I)Z
*/
JNIEXPORT jboolean JNICALL
Java_org_tritonus_lowlevel_alsa_AlsaMixerElement_getCaptureSwitch
(JNIEnv* env, jobject obj, jint nChannelType)
{
snd_mixer_elem_t* handle;
int nReturn;
int nValue;
if (debug_flag) {
(void) fprintf(debug_file, "Java_org_tritonus_lowlevel_alsa_AlsaMixerElement_getCaptureSwitch(): begin\n");
}
handle = getHandle(env, obj);
nReturn = snd_mixer_selem_get_capture_switch(handle, (snd_mixer_selem_channel_id_t) nChannelType, &nValue);
if (nReturn < 0)
{
throwRuntimeException(env, snd_strerror(nReturn));
}
if (debug_flag) {
(void) fprintf(debug_file, "Java_org_tritonus_lowlevel_alsa_AlsaMixerElement_getCaptureSwitch(): end\n");
}
return (jboolean) nValue;
}
void
gst_alsa_mixer_track_update (GstAlsaMixerTrack * alsa_track)
{
GstMixerTrack *track = (GstMixerTrack *) alsa_track;
gint i;
gint audible = !(track->flags & GST_MIXER_TRACK_MUTE);
if (alsa_track_has_cap (alsa_track, GST_ALSA_MIXER_TRACK_PVOLUME)) {
/* update playback volume */
for (i = 0; i < track->num_channels; i++) {
long vol = 0;
snd_mixer_selem_get_playback_volume (alsa_track->element, i, &vol);
alsa_track->volumes[i] = (gint) vol;
}
}
if (alsa_track_has_cap (alsa_track, GST_ALSA_MIXER_TRACK_CVOLUME)) {
/* update capture volume */
for (i = 0; i < track->num_channels; i++) {
long vol = 0;
snd_mixer_selem_get_capture_volume (alsa_track->element, i, &vol);
alsa_track->volumes[i] = (gint) vol;
}
}
/* Any updates in flags? */
if (alsa_track_has_cap (alsa_track, GST_ALSA_MIXER_TRACK_PSWITCH)) {
int v = 0;
audible = 0;
for (i = 0; i < alsa_track->alsa_channels; ++i) {
snd_mixer_selem_get_playback_switch (alsa_track->element, i, &v);
audible += v;
}
} else if (alsa_track_has_cap (alsa_track, GST_ALSA_MIXER_TRACK_PVOLUME) &&
track->flags & GST_MIXER_TRACK_MUTE) {
/* check if user has raised volume with a parallel running application */
for (i = 0; i < track->num_channels; i++) {
long vol = 0;
snd_mixer_selem_get_playback_volume (alsa_track->element, i, &vol);
if (vol > track->min_volume) {
audible = 1;
break;
}
}
}
if (!!(audible) != !(track->flags & GST_MIXER_TRACK_MUTE)) {
if (audible) {
track->flags &= ~GST_MIXER_TRACK_MUTE;
if (alsa_track->shared_mute)
((GstMixerTrack *) (alsa_track->shared_mute))->flags &=
~GST_MIXER_TRACK_MUTE;
} else {
track->flags |= GST_MIXER_TRACK_MUTE;
if (alsa_track->shared_mute)
((GstMixerTrack *) (alsa_track->shared_mute))->flags |=
GST_MIXER_TRACK_MUTE;
}
}
if (track->flags & GST_MIXER_TRACK_INPUT) {
gint recording = track->flags & GST_MIXER_TRACK_RECORD;
if (alsa_track_has_cap (alsa_track, GST_ALSA_MIXER_TRACK_CSWITCH)) {
int v = 0;
recording = 0;
for (i = 0; i < alsa_track->alsa_channels; ++i) {
snd_mixer_selem_get_capture_switch (alsa_track->element, i, &v);
recording += v;
}
} else if (alsa_track_has_cap (alsa_track, GST_ALSA_MIXER_TRACK_CVOLUME) &&
!(track->flags & GST_MIXER_TRACK_RECORD)) {
/* check if user has raised volume with a parallel running application */
for (i = 0; i < track->num_channels; i++) {
long vol = 0;
snd_mixer_selem_get_capture_volume (alsa_track->element, i, &vol);
if (vol > track->min_volume) {
recording = 1;
break;
}
}
}
if (recording)
track->flags |= GST_MIXER_TRACK_RECORD;
else
track->flags &= ~GST_MIXER_TRACK_RECORD;
}
}
