/**
* Adjusts the current volume and sends a notification (if enabled).
*
* @param vol new volume value
* @param dir select direction (-1 = accurate or first bellow, 0 = accurate,
* 1 = accurate or first above)
* @param notify whether to send notification
* @return 0 on success otherwise negative error code
*/
int
setvol(int vol, int dir, gboolean notify)
{
long min = 0, max = 0, value;
int cur_perc = getvol();
double dvol = 0.01 * vol;
int err = snd_mixer_selem_get_playback_dB_range(elem, &min, &max);
if (err < 0 || min >= max || !normalize_vol()) {
err = snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
value = lrint_dir(dvol * (max - min), dir) + min;
snd_mixer_selem_set_playback_volume_all(elem, value);
if (enable_noti && notify && cur_perc != getvol())
do_notify_volume(getvol(), FALSE);
// intentionally set twice
return snd_mixer_selem_set_playback_volume_all(elem, value);
}
if (use_linear_dB_scale(min, max)) {
value = lrint_dir(dvol * (max - min), dir) + min;
return snd_mixer_selem_set_playback_dB_all(elem, value, dir);
}
if (min != SND_CTL_TLV_DB_GAIN_MUTE) {
double min_norm = exp10((min - max) / 6000.0);
dvol = dvol * (1 - min_norm) + min_norm;
}
value = lrint_dir(6000.0 * log10(dvol), dir) + max;
snd_mixer_selem_set_playback_dB_all(elem, value, dir);
if (enable_noti && notify && cur_perc != getvol())
do_notify_volume(getvol(), FALSE);
// intentionally set twice
return snd_mixer_selem_set_playback_dB_all(elem, value, dir);
}
static bool
alsa_mixer_set_volume(struct mixer *mixer, unsigned volume, GError **error_r)
{
struct alsa_mixer *am = (struct alsa_mixer *)mixer;
float vol;
long level;
int err;
assert(am->handle != NULL);
vol = volume;
am->volume_set = vol + 0.5;
level = (long)(((vol / 100.0) * (am->volume_max - am->volume_min) +
am->volume_min) + 0.5);
level = level > am->volume_max ? am->volume_max : level;
level = level < am->volume_min ? am->volume_min : level;
err = snd_mixer_selem_set_playback_volume_all(am->elem, level);
if (err < 0) {
g_set_error(error_r, alsa_mixer_quark(), err,
"failed to set ALSA volume: %s",
snd_strerror(err));
return false;
}
return true;
}
static void alsa_set_mixer (int vol)
{
if (mixer_handle) {
int err;
long vol_alsa;
long mixer_max, mixer_min;
int *real_vol;
if (mixer_elem_curr == mixer_elem1) {
volume1 = vol;
mixer_max = mixer1_max;
mixer_min = mixer1_min;
real_vol = &real_volume1;
}
else {
volume2 = vol;
mixer_max = mixer2_max;
mixer_min = mixer2_min;
real_vol = &real_volume2;
}
vol_alsa = vol * (mixer_max - mixer_min) / 100;
debug ("Setting vol to %ld", vol_alsa);
if ((err = snd_mixer_selem_set_playback_volume_all(
mixer_elem_curr, vol_alsa)) < 0)
error ("Can't set mixer: %s", snd_strerror(err));
else
*real_vol = vol_alsa;
}
}
int volume_up(int vol_min, int vol_max)
{
long min, max;
snd_mixer_t *handle;
snd_mixer_selem_id_t *sid;
const char *card = "default";
const char *selem_name = "Master";
snd_mixer_open(&handle, 0);
snd_mixer_attach(handle, card);
snd_mixer_selem_register(handle, NULL, NULL);
snd_mixer_load(handle);
snd_mixer_selem_id_alloca(&sid);
snd_mixer_selem_id_set_index(sid, 0);
snd_mixer_selem_id_set_name(sid, selem_name);
snd_mixer_elem_t* elem = snd_mixer_find_selem(handle, sid);
snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
for (int i = vol_min; i<vol_max; i++) {
int v = i*max /100;
snd_mixer_selem_set_playback_volume_all(elem, v);
//printf("min = %d, max= %d, volume = %d\n", min, max, volume);
usleep(50000);
}
snd_mixer_close(handle);
}
void set_volume(int vol)
{
long min, max;
snd_mixer_t *handlev;
snd_mixer_selem_id_t *sid;
const char *card = "default";
const char *selem_name = "Master";
if (vol < 1 || vol > 100) {
printf("ERROR: Volume out of range [0,100] %%\n");
printf("\tSetting volume to 50%%...\n");
vol = 50;
}
snd_mixer_open(&handlev, 0);
snd_mixer_attach(handlev, card);
snd_mixer_selem_register(handlev, NULL, NULL);
snd_mixer_load(handlev);
snd_mixer_selem_id_alloca(&sid);
snd_mixer_selem_id_set_index(sid, 0);
snd_mixer_selem_id_set_name(sid, selem_name);
snd_mixer_elem_t *elem = snd_mixer_find_selem(handlev, sid);
snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
snd_mixer_selem_set_playback_volume_all(elem, vol * max / 100 + min);
snd_mixer_close(handlev);
}
static void
laudio_alsa_set_volume(int vol)
{
int pcm_vol;
if (!mixer_hdl || !vol_elem)
return;
snd_mixer_handle_events(mixer_hdl);
if (!snd_mixer_selem_is_active(vol_elem))
return;
switch (vol)
{
case 0:
pcm_vol = vol_min;
break;
case 100:
pcm_vol = vol_max;
break;
default:
pcm_vol = vol_min + (vol * (vol_max - vol_min)) / 100;
break;
}
DPRINTF(E_DBG, L_LAUDIO, "Setting PCM volume to %d (%d)\n", pcm_vol, vol);
snd_mixer_selem_set_playback_volume_all(vol_elem, pcm_vol);
}
int volume_set(int volume)
{
long min, max;
snd_mixer_t *handle;
snd_mixer_selem_id_t *sid;
const char *card = "default";
//const char *selem_name = "Master";
const char *selem_name = "Digital";
snd_mixer_open(&handle, 0);
snd_mixer_attach(handle, card);
snd_mixer_selem_register(handle, NULL, NULL);
snd_mixer_load(handle);
snd_mixer_selem_id_alloca(&sid);
snd_mixer_selem_id_set_index(sid, 0);
snd_mixer_selem_id_set_name(sid, selem_name);
snd_mixer_elem_t* elem = snd_mixer_find_selem(handle, sid);
snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
int v = volume*max /100;
snd_mixer_selem_set_playback_volume_all(elem, v);
snd_mixer_close(handle);
return v;
}
void eDVBVolumecontrol::volumeUnMute()
{
#ifdef HAVE_ALSA
if (mainVolume) snd_mixer_selem_set_playback_volume_all(mainVolume, leftVol);
muted = false;
#else
int fd = openMixer();
#ifdef HAVE_DVB_API_VERSION
ioctl(fd, AUDIO_SET_MUTE, false);
#endif
closeMixer(fd);
muted = false;
//HACK?
FILE *f;
if((f = fopen("/proc/stb/audio/j1_mute", "wb")) == NULL) {
eDebug("cannot open /proc/stb/audio/j1_mute(%m)");
return;
}
fprintf(f, "%d", 0);
fclose(f);
#endif
}
void set_volume(GtkAdjustment *adjustment, gpointer user_data)
{
int value = (int) 100 - gtk_adjustment_get_value(adjustment);
g_debug("Setting master volume to: %d", value);
if(value == 0)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(s_mute), TRUE);
else
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(s_mute), FALSE);
long min, max;
snd_mixer_t *mix;
snd_mixer_selem_id_t *sid;
const char *card = "default";
const char *selem_name = "Master";
snd_mixer_open(&mix, 0);
snd_mixer_attach(mix, card);
snd_mixer_selem_register(mix, NULL, NULL);
snd_mixer_load(mix);
snd_mixer_selem_id_alloca(&sid);
snd_mixer_selem_id_set_index(sid, 0);
snd_mixer_selem_id_set_name(sid, selem_name);
snd_mixer_elem_t* elem = snd_mixer_find_selem(mix, sid);
snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
snd_mixer_selem_set_playback_volume_all(elem, value * max / 100);
snd_mixer_close(mix);
}
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 int _event_volume_set(Openmoko * openmoko, gdouble level)
{
#ifdef __linux__
if(openmoko->mixer_elem == NULL)
return 0;
snd_mixer_selem_set_playback_volume_all(openmoko->mixer_elem, level);
#endif
return 0;
}
void SetAlsaVolume(long volume) {
const char *card = "default";
const char *selem_name = "Master";
// snd_mixer_selem_set_playback_volume_all(elem, volume * max / 100);
struct alsa_control_struct c_struct = GetStruct(card,selem_name);
snd_mixer_selem_set_playback_volume_all(c_struct.elem, volume);
snd_mixer_close(c_struct.handle);
}
void eDVBVolumecontrol::setVolume(int left, int right)
{
/* left, right is 0..100 */
leftVol = checkVolume(left);
rightVol = checkVolume(right);
#ifdef HAVE_ALSA
if (mainVolume) snd_mixer_selem_set_playback_volume_all(mainVolume, muted ? 0 : leftVol);
#else
/* convert to -1dB steps */
left = 63 - leftVol * 63 / 100;
right = 63 - rightVol * 63 / 100;
/* now range is 63..0, where 0 is loudest */
#if HAVE_DVB_API_VERSION < 3
audioMixer_t mixer;
#else
audio_mixer_t mixer;
#endif
#if HAVE_DVB_API_VERSION < 3
/* convert to linear scale. 0 = loudest, ..63 */
mixer.volume_left = 63.0-pow(1.068241, 63-left);
mixer.volume_right = 63.0-pow(1.068241, 63-right);
#else
mixer.volume_left = left;
mixer.volume_right = right;
#endif
eDebug("Setvolume: %d %d (raw)", leftVol, rightVol);
eDebug("Setvolume: %d %d (-1db)", left, right);
#if HAVE_DVB_API_VERSION < 3
eDebug("Setvolume: %d %d (lin)", mixer.volume_left, mixer.volume_right);
#endif
int fd = openMixer();
if (fd >= 0)
{
#ifdef HAVE_DVB_API_VERSION
ioctl(fd, AUDIO_SET_MIXER, &mixer);
#endif
closeMixer(fd);
return;
}
//HACK?
FILE *f;
if((f = fopen("/proc/stb/avs/0/volume", "wb")) == NULL) {
eDebug("cannot open /proc/stb/avs/0/volume(%m)");
return;
}
fprintf(f, "%d", left); /* in -1dB */
fclose(f);
#endif
}
void asound_set_volume(int volume)
{
assert(m_elem != NULL);
assert(volume >= 0 && volume <= 100);
long pmin, pmax;
snd_mixer_selem_get_playback_volume_range(m_elem, &pmin, &pmax);
long value = pmax * volume / 100;
snd_mixer_selem_set_playback_volume_all(m_elem, value);
}
bool SIDInfo::setRealVolume(long val)
{
if (!hasVolume || !_sid) return false;
snd_mixer_elem_t* elem = snd_mixer_find_selem(_handle, _sid);
if (!elem) return false;
snd_mixer_selem_set_playback_volume_all(elem, val);
return true;
}
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 ;
}
/* Set volume with given volume_type.
* round_direction: >0 to round up, <0 to round down, 0 to use default lrint
* rounding direction (see fsetround(3)).*/
void set_vol(
snd_mixer_elem_t* elem,
enum Volume_type volume_type,
long int new_vol,
int round_direction)
{
// TODO: possibly add new_vol range check
int err = 0;
if (volume_type == hardware) {
err = snd_mixer_selem_set_playback_volume_all(elem, new_vol);
}
else if (volume_type == decibels) {
err = snd_mixer_selem_set_playback_dB_all(elem, new_vol, round_direction);
}
else if (volume_type == alsa_percentage) {
double new_vol_norm = (double) new_vol / 100;
PD_M("Setting alsa_percentage volume: %g\n", new_vol_norm);
err = set_normalized_playback_volume(elem, SND_MIXER_SCHN_FRONT_LEFT, new_vol_norm, round_direction);
if (err == 0) {
err = set_normalized_playback_volume(elem, SND_MIXER_SCHN_FRONT_RIGHT, new_vol_norm, round_direction);
}
}
else if (volume_type == hardware_percentage) {
long int min, max;
snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
change_range(&new_vol, 0, 100, min, max, false);
err = snd_mixer_selem_set_playback_volume_all(elem, new_vol);
}
else {
fprintf(stderr, "avolt ERROR: set_vol: Unknown volume_type '%i'.\n", volume_type);
err = -1;
}
if (err != 0) {
fprintf(stderr, "avolt ERROR: snd mixer set playback volume failed with new vol '%li' and volume type '%i'.\n", new_vol, volume_type);
}
}
static void linear_volume(double vol) {
set_volume = vol;
double vol_setting = vol2attn(vol, 0, alsa_mix_mindb)/2000;
// debug(1,"Adjusted volume is %f.",vol_setting);
double linear_volume = pow(10, vol_setting);
// debug(1,"Linear volume is %f.",linear_volume);
long int_vol = alsa_mix_minv + (alsa_mix_maxv - alsa_mix_minv) * linear_volume;
// debug(1,"Setting volume to %ld, for volume input of %f.",int_vol,vol);
if (snd_mixer_selem_set_playback_volume_all(alsa_mix_elem, int_vol) != 0)
die("Failed to set playback volume");
if (has_mute)
snd_mixer_selem_set_playback_switch_all(alsa_mix_elem, (vol != -144.0));
}
int
sa_stream_set_volume_abs(sa_stream_t *s, float vol) {
snd_mixer_t* mixer = 0;
snd_mixer_elem_t* elem = 0;
if (s == NULL || s->output_unit == NULL) {
return SA_ERROR_NO_INIT;
}
if (snd_mixer_open(&mixer, 0) < 0) {
return SA_ERROR_SYSTEM;
}
if (snd_mixer_attach(mixer, "default") < 0) {
snd_mixer_close(mixer);
return SA_ERROR_SYSTEM;
}
if (snd_mixer_selem_register(mixer, NULL, NULL) < 0) {
snd_mixer_close(mixer);
return SA_ERROR_SYSTEM;
}
if (snd_mixer_load(mixer) < 0) {
snd_mixer_close(mixer);
return SA_ERROR_SYSTEM;
}
#if 0
snd_mixer_elem_t* elem = 0;
for (elem = snd_mixer_first_elem(mixer); elem != NULL; elem = snd_mixer_elem_next(elem)) {
if (snd_mixer_selem_has_playback_volume(elem)) {
printf("Playback %s\n", snd_mixer_selem_get_name(elem));
}
else {
printf("No Playback: %s\n", snd_mixer_selem_get_name(elem));
}
}
#endif
elem = snd_mixer_first_elem(mixer);
if (elem && snd_mixer_selem_has_playback_volume(elem)) {
long min = 0;
long max = 0;
if (snd_mixer_selem_get_playback_volume_range(elem, &min, &max) >= 0) {
snd_mixer_selem_set_playback_volume_all(elem, (max-min)*vol + min);
}
}
snd_mixer_close(mixer);
return SA_SUCCESS;
}
static PyObject* ALSAAudio_set_volume(output_ALSAAudio *self, PyObject *args)
{
double new_volume_d;
long new_volume;
if (!PyArg_ParseTuple(args, "d", &new_volume_d))
return NULL;
new_volume = round(new_volume_d * self->volume_max);
snd_mixer_selem_set_playback_volume_all(self->mixer_elem, new_volume);
Py_INCREF(Py_None);
return Py_None;
}
void asound_set_volume(int volume)
{
if(m_elem == NULL) {
return;
}
volume = (volume < 0 ? 0 : (volume > 100 ? 100 : volume));
if(config_get_decibel_scale())
{
long pmin, pmax;
snd_mixer_selem_get_playback_volume_range(m_elem, &pmin, &pmax);
long value = pmin + (pmax-pmin) * volume / 100;
snd_mixer_selem_set_playback_volume_all(m_elem, value);
}
else
set_normalized_playback_volume_all(m_elem, volume / 100.0, 0);
}
status_t ALSAMixer::setMasterVolume(float volume)
{
mixer_info_t *info = mixerMasterProp[SND_PCM_STREAM_PLAYBACK].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 + volume * (maxVol - minVol);
if (vol > maxVol) vol = maxVol;
if (vol < minVol) vol = minVol;
info->volume = vol;
snd_mixer_selem_set_playback_volume_all (info->elem, vol);
return NO_ERROR;
}
int audio_set_volume( long volume )
{
// int infos[3];
// int infos;
long min, max;
snd_mixer_t *handle;
snd_mixer_selem_id_t *sid;
const char *card = "default";//Ensoniq AudioPCI
const char *selem_name = "Master";
char response[255] = { 0 };
snd_mixer_open(&handle, 0);
snd_mixer_attach(handle, card);
snd_mixer_selem_register(handle, NULL, NULL);
snd_mixer_load(handle);
snd_mixer_selem_id_alloca(&sid);
snd_mixer_selem_id_set_index(sid, 0);
snd_mixer_selem_id_set_name(sid, selem_name);
snd_mixer_elem_t* elem = snd_mixer_find_selem(handle, sid);
snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
snd_mixer_selem_set_playback_volume_all(elem, volume * max / 100);
snd_mixer_close(handle);
snprintf( response , 255 , "OK");
sendVoid( ( void * )response , strlen( response ) );
//Sending the info to the remote
// infos[0] = CURRENTVOL;
// infos[1] = ( int )volume;
// infos[2] = END;
// infos = CURRENTVOL;
// sendVoid( ( void * )&infos , sizeof( infos ) );
// infos = ( int )volume;
// sendVoid( ( void * )&infos , sizeof( infos ) );
// infos = END;
// sendVoid( ( void * )&infos , sizeof( infos ) );
}
/* API: set capability */
static pj_status_t alsa_stream_set_cap(pjmedia_aud_stream *strm,
pjmedia_aud_dev_cap cap,
const void *value)
{
struct alsa_factory *af = ((struct alsa_stream*)strm)->af;
if (cap==PJMEDIA_AUD_DEV_CAP_OUTPUT_VOLUME_SETTING &&
pj_ansi_strlen(af->pb_mixer_name))
{
pj_ssize_t min, max;
snd_mixer_t *handle;
snd_mixer_selem_id_t *sid;
snd_mixer_elem_t* elem;
unsigned vol = *(unsigned*)value;
if (snd_mixer_open(&handle, 0) < 0)
return PJMEDIA_EAUD_SYSERR;
if (snd_mixer_attach(handle, "default") < 0)
return PJMEDIA_EAUD_SYSERR;
if (snd_mixer_selem_register(handle, NULL, NULL) < 0)
return PJMEDIA_EAUD_SYSERR;
if (snd_mixer_load(handle) < 0)
return PJMEDIA_EAUD_SYSERR;
snd_mixer_selem_id_alloca(&sid);
snd_mixer_selem_id_set_index(sid, 0);
snd_mixer_selem_id_set_name(sid, af->pb_mixer_name);
elem = snd_mixer_find_selem(handle, sid);
if (!elem)
return PJMEDIA_EAUD_SYSERR;
snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
if (snd_mixer_selem_set_playback_volume_all(elem, vol * max / 100) < 0)
return PJMEDIA_EAUD_SYSERR;
snd_mixer_close(handle);
return PJ_SUCCESS;
}
return PJMEDIA_EAUD_INVCAP;
}
void eDVBVolumecontrol::setVolume(int left, int right)
{
/* left, right is 0..100 */
leftVol = checkVolume(left);
rightVol = checkVolume(right);
#ifdef HAVE_ALSA
eDebug("[eDVBVolumecontrol] Setvolume: ALSA leftVol=%d", leftVol);
if (mainVolume)
snd_mixer_selem_set_playback_volume_all(mainVolume, muted ? 0 : leftVol);
#else
/* convert to -1dB steps */
left = 63 - leftVol * 63 / 100;
right = 63 - rightVol * 63 / 100;
/* now range is 63..0, where 0 is loudest */
#if 0
audio_mixer_t mixer;
mixer.volume_left = left;
mixer.volume_right = right;
eDebug("[eDVBVolumecontrol] Setvolume: raw: %d %d, -1db: %d %d", leftVol, rightVol, left, right);
int fd = openMixer();
if (fd >= 0)
{
#ifdef DVB_API_VERSION
if (ioctl(fd, AUDIO_SET_MIXER, &mixer) < 0) {
eDebug("[eDVBVolumecontrol] Setvolume failed: %m");
}
#endif
closeMixer(fd);
return;
}
else {
eDebug("[eDVBVolumecontrol] SetVolume failed to open mixer: %m");
}
#endif
//HACK?
CFile::writeInt("/proc/stb/avs/0/volume", left); /* in -1dB */
#endif
}
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: setPlaybackVolumeAll
* Signature: (I)V
*/
JNIEXPORT void JNICALL
Java_org_tritonus_lowlevel_alsa_AlsaMixerElement_setPlaybackVolumeAll
(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_setPlaybackVolumeAll(): begin\n");
}
handle = getHandle(env, obj);
nReturn = snd_mixer_selem_set_playback_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_setPlaybackVolumeAll(): end\n");
}
}
void eDVBVolumecontrol::volumeUnMute()
{
#ifdef HAVE_ALSA
if (mainVolume) snd_mixer_selem_set_playback_volume_all(mainVolume, leftVol);
muted = false;
#else
int fd = openMixer();
if (fd >= 0)
{
#ifdef HAVE_DVB_API_VERSION
ioctl(fd, AUDIO_SET_MUTE, false);
#endif
closeMixer(fd);
}
muted = false;
//HACK?
CFile::writeInt("/proc/stb/audio/j1_mute", 0);
#endif
}
status_t ALSAMixer::setVolume(uint32_t device, float left, float right)
{
for (int j = 0; mixerProp[j][SND_PCM_STREAM_PLAYBACK].device; j++)
if (mixerProp[j][SND_PCM_STREAM_PLAYBACK].device & device) {
mixer_info_t *info = mixerProp[j][SND_PCM_STREAM_PLAYBACK].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 + left * (maxVol - minVol);
if (vol > maxVol) vol = maxVol;
if (vol < minVol) vol = minVol;
info->volume = vol;
snd_mixer_selem_set_playback_volume_all (info->elem, vol);
}
return NO_ERROR;
}
void eDVBVolumecontrol::volumeMute()
{
#ifdef HAVE_ALSA
eDebug("[eDVBVolumecontrol] Setvolume: ALSA Mute");
if (mainVolume)
snd_mixer_selem_set_playback_volume_all(mainVolume, 0);
muted = true;
#else
int fd = openMixer();
if (fd >= 0)
{
#ifdef DVB_API_VERSION
ioctl(fd, AUDIO_SET_MUTE, true);
#endif
closeMixer(fd);
}
muted = true;
//HACK?
CFile::writeInt("/proc/stb/audio/j1_mute", 1);
#endif
}
