void
gst_alsa_mixer_set_volume (GstAlsaMixer * mixer, GstMixerTrack * track,
gint * volumes)
{
GstAlsaMixerTrack *alsa_track = GST_ALSA_MIXER_TRACK (track);
gint i;
g_return_if_fail (mixer->handle != NULL);
g_static_rec_mutex_lock (mixer->rec_mutex);
gst_alsa_mixer_track_update (alsa_track);
if (track->flags & GST_MIXER_TRACK_OUTPUT) {
/* Is emulated mute flag activated? */
if (track->flags & GST_MIXER_TRACK_MUTE &&
!(alsa_track->alsa_flags & GST_ALSA_MIXER_TRACK_PSWITCH)) {
for (i = 0; i < track->num_channels; i++)
alsa_track->volumes[i] = volumes[i];
} else {
if (check_if_volumes_are_the_same (track->num_channels, volumes)) {
snd_mixer_selem_set_playback_volume_all (alsa_track->element,
volumes[0]);
for (i = 0; i < track->num_channels; i++)
alsa_track->volumes[i] = volumes[0];
} else {
for (i = 0; i < track->num_channels; i++) {
alsa_track->volumes[i] = volumes[i];
snd_mixer_selem_set_playback_volume (alsa_track->element, i,
volumes[i]);
}
}
}
} else if (track->flags & GST_MIXER_TRACK_INPUT) {
/* Is emulated record flag activated? */
if (track->flags & GST_MIXER_TRACK_RECORD ||
alsa_track->alsa_flags & GST_ALSA_MIXER_TRACK_CSWITCH) {
if (check_if_volumes_are_the_same (track->num_channels, volumes)) {
snd_mixer_selem_set_capture_volume_all (alsa_track->element,
volumes[0]);
for (i = 0; i < track->num_channels; i++)
alsa_track->volumes[i] = volumes[0];
} else {
for (i = 0; i < track->num_channels; i++) {
alsa_track->volumes[i] = volumes[i];
snd_mixer_selem_set_capture_volume (alsa_track->element, i,
volumes[i]);
}
}
} else {
for (i = 0; i < track->num_channels; i++)
alsa_track->volumes[i] = volumes[i];
}
}
g_static_rec_mutex_unlock (mixer->rec_mutex);
}
static void set_volume(AudioCapture *capture, int level) {
snd_mixer_t *mixer=NULL;
int err;
err=snd_mixer_open(&mixer,0);
if(err < 0) {
fprintf(stderr, "Could not open alsa mixer: %s\r\n",snd_strerror(err));
exit(1);
}
char hw_id[100];
snprintf(hw_id, sizeof(hw_id), "hw:%d", capture->pcm_id);
if ((err = snd_mixer_attach (mixer, hw_id)) < 0){
fprintf(stderr, "Could not attach mixer to card(%s): %s\r\n", hw_id, snd_strerror(err));
snd_mixer_close(mixer);
exit(1);
}
if ((err = snd_mixer_selem_register (mixer, NULL, NULL)) < 0){
fprintf(stderr, "snd_mixer_selem_register: %s\r\n",snd_strerror(err));
snd_mixer_close(mixer);
exit(1);
}
if ((err = snd_mixer_load (mixer)) < 0){
fprintf(stderr, "snd_mixer_load: %s\r\n",snd_strerror(err));
snd_mixer_close(mixer);
exit(1);
}
snd_mixer_elem_t *elem;
elem = snd_mixer_first_elem(mixer);
while(elem) {
const char *elemname = snd_mixer_selem_get_name(elem);
if(strcmp(elemname, "Capture") && strcmp(elemname, "Mic")) {
fprintf(stderr, "Skip setting volume for %s\r\n", elemname);
elem=snd_mixer_elem_next(elem);
continue;
}
if (snd_mixer_selem_has_capture_volume(elem)){
fprintf(stderr, "Set volume for %s\r\n", elemname);
long sndMixerPMin;
long sndMixerPMax;
long newvol;
snd_mixer_selem_get_playback_volume_range(elem, &sndMixerPMin, &sndMixerPMax);
newvol=(((sndMixerPMax-sndMixerPMin)*level)/100)+sndMixerPMin;
snd_mixer_selem_set_capture_volume_all(elem,newvol);
elem=snd_mixer_elem_next(elem);
} else {
fprintf(stderr, "Can't set capture volume\r\n");
exit(1);
}
}
}
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 ;
}
status_t ALSAMixer::setMasterGain(float gain)
{
mixer_info_t *info = mixerMasterProp[SND_PCM_STREAM_CAPTURE].mInfo;
if (!info || !info->elem) return INVALID_OPERATION;
long minVol = info->min;
long maxVol = info->max;
// Make sure volume is between bounds.
long vol = minVol + gain * (maxVol - minVol);
if (vol > maxVol) vol = maxVol;
if (vol < minVol) vol = minVol;
info->volume = vol;
snd_mixer_selem_set_capture_volume_all (info->elem, vol);
return NO_ERROR;
}
static enum MixerCode alsaMixerChangeVolume(struct MixerSystem* system, int change, int* result) {
struct AlsaMixerCard* card = (struct AlsaMixerCard*)system->active;
if ( !card ) {
return MIXER_CODE_NO_ACTIVE_CARD;
}
struct AlsaMixerElement* element = (struct AlsaMixerElement*)card->active;
if ( !element ) {
return MIXER_CODE_NO_ACTIVE_ELEMENT;
}
long range = element->rangemax - element->rangemin;
long precentage = (element->volume - element->rangemin) / range;
if ( range <= 100 ) {
element->volume += change;
if ( element->volume < element->rangemin ) {
element->volume = element->rangemin;
} else if ( element->volume > element->rangemax ) {
element->volume = element->rangemax;
}
precentage = (element->volume - element->rangemin) / range;
} else {
precentage += change;
if ( precentage < 0 ) {
precentage = 0;
} else if ( precentage > 100 ) {
precentage = 100;
}
element->volume = element->rangemin + (range * precentage / 100);
}
if ( result ) {
*result = (int)precentage;
}
if ( element->type == MIXER_ELEMENT_PLAYBACK
&& snd_mixer_selem_set_playback_volume_all(element->sndelement, element->volume) < 0 ) {
return MIXER_CODE_CANNOT_SET_VOLUME;
} else if ( element->type == MIXER_ELEMENT_CAPTURE
&& snd_mixer_selem_set_capture_volume_all(element->sndelement, element->volume) < 0 ) {
return MIXER_CODE_CANNOT_SET_VOLUME;
}
return MIXER_CODE_OK;
}
/*
* Class: org_tritonus_lowlevel_alsa_AlsaMixerElement
* Method: setCaptureVolumeAll
* Signature: (I)V
*/
JNIEXPORT void JNICALL
Java_org_tritonus_lowlevel_alsa_AlsaMixerElement_setCaptureVolumeAll
(JNIEnv* env, jobject obj, jint nValue)
{
snd_mixer_elem_t* handle;
int nReturn;
if (debug_flag) {
(void) fprintf(debug_file, "Java_org_tritonus_lowlevel_alsa_AlsaMixerElement_setCaptureVolumeAll(): begin\n");
}
handle = getHandle(env, obj);
nReturn = snd_mixer_selem_set_capture_volume_all(handle, nValue);
if (nReturn < 0)
{
throwRuntimeException(env, snd_strerror(nReturn));
}
if (debug_flag) {
(void) fprintf(debug_file, "Java_org_tritonus_lowlevel_alsa_AlsaMixerElement_setCaptureVolumeAll(): end\n");
}
}
status_t ALSAMixer::setGain(uint32_t device, float gain)
{
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;
long minVol = info->min;
long maxVol = info->max;
// Make sure volume is between bounds.
long vol = minVol + gain * (maxVol - minVol);
if (vol > maxVol) vol = maxVol;
if (vol < minVol) vol = minVol;
info->volume = vol;
snd_mixer_selem_set_capture_volume_all (info->elem, vol);
}
return NO_ERROR;
}
void
moko_alsa_volume_control_set_volume (MokoAlsaVolumeControl *control,
gdouble volume)
{
MokoAlsaVolumeControlPrivate *priv =
ALSA_VOLUME_CONTROL_PRIVATE (control);
if (!priv->mixer_elem) return;
volume = (long)(volume * (gdouble)(priv->max-priv->min)) + priv->min;
switch (priv->control_type) {
case PLAYBACK :
snd_mixer_selem_set_playback_volume_all (
priv->mixer_elem, volume);
break;
case CAPTURE :
snd_mixer_selem_set_capture_volume_all (
priv->mixer_elem, volume);
break;
default :
g_warning ("Unhandled control type");
}
}
