Skip to content

V
vlc-gpu
Commit 67333b50 authored by Rémi Denis-Courmont's avatar Rémi Denis-Courmont
Browse files
Options

Clarify audio volume interface code (kill doVolumeChanges)

parent 1f224a54
Hide whitespace changes
Inline Side-by-side
Showing with 143 additions and 187 deletions
src/audio_output/intf.c
View file @ 67333b50
...@@ -58,230 +58,186 @@ static aout_instance_t *findAout (vlc_object_t *obj) ...@@ -58,230 +58,186 @@ static aout_instance_t *findAout (vlc_object_t *obj)
} }
#define findAout(o) findAout(VLC_OBJECT(o)) #define findAout(o) findAout(VLC_OBJECT(o))
enum { /** Start a volume change transaction. */
SET_MUTE=1, static void prepareVolume (vlc_object_t *obj, aout_instance_t **aoutp,
SET_VOLUME=2, audio_volume_t *volp, bool *mutep)
INCREMENT_VOLUME=4,
TOGGLE_MUTE=8
};
/*****************************************************************************
* doVolumeChanges : handle all volume changes. Internal use only to ease
* variables locking.
*****************************************************************************/
static
int doVolumeChanges( unsigned action, vlc_object_t * p_object, int i_nb_steps,
audio_volume_t i_volume, audio_volume_t * i_return_volume,
bool b_mute )
{ {
int i_result = VLC_SUCCESS; aout_instance_t *aout = findAout (obj);
int i_volume_step = 1, i_new_volume = 0;
bool b_var_mute = false; /* FIXME: we need interlocking even if aout does not exist! */
aout_instance_t *p_aout = findAout( p_object ); *aoutp = aout;
if (aout != NULL)
if ( p_aout ) aout_lock_volume( p_aout ); aout_lock_volume (aout);
if (volp != NULL)
b_var_mute = var_GetBool( p_object, "volume-muted"); *volp = config_GetInt (obj, "volume");
if (mutep != NULL)
const bool b_unmute_condition = ( b_var_mute *mutep = var_GetBool (obj, "volume-muted");
&& ( /* Unmute: on increments */ }
( action == INCREMENT_VOLUME )
|| /* On explicit unmute */
( ( action == SET_MUTE ) && !b_mute )
|| /* On toggle from muted */
( action == TOGGLE_MUTE )
));
const bool b_mute_condition = ( !b_var_mute
&& ( /* explicit */
( ( action == SET_MUTE ) && b_mute )
|| /* or toggle */
( action == TOGGLE_MUTE )
));
/* If muting or unmuting when play hasn't started */
if ( action == SET_MUTE && !b_unmute_condition && !b_mute_condition )
{
if ( p_aout )
{
aout_unlock_volume( p_aout );
vlc_object_release( p_aout );
}
return i_result;
}
/* On UnMute */
if ( b_unmute_condition )
{
/* Restore saved volume */
i_volume = var_GetInteger( p_object, "saved-volume" );
var_SetBool( p_object, "volume-muted", false );
}
else if ( b_mute_condition )
{
/* We need an initial value to backup later */
i_volume = config_GetInt( p_object, "volume" );
}
if ( action == INCREMENT_VOLUME )
{
i_volume_step = var_InheritInteger( p_object, "volume-step" );
if ( !b_unmute_condition )
i_volume = config_GetInt( p_object, "volume" );
i_new_volume = (int) i_volume + i_volume_step * i_nb_steps;
if ( i_new_volume > AOUT_VOLUME_MAX )
i_volume = AOUT_VOLUME_MAX;
else if ( i_new_volume < AOUT_VOLUME_MIN )
i_volume = AOUT_VOLUME_MIN;
else
i_volume = i_new_volume;
}
var_SetInteger( p_object, "saved-volume" , i_volume );
/* On Mute */ /** Commit a volume change transaction. */
if ( b_mute_condition ) static int commitVolume (vlc_object_t *obj, aout_instance_t *aout,
{ audio_volume_t volume, bool mute)
i_volume = AOUT_VOLUME_MIN; {
var_SetBool( p_object, "volume-muted", true ); int ret = 0;
}
/* Commit volume changes */ config_PutInt (obj, "volume", volume);
config_PutInt( p_object, "volume", i_volume ); if (mute)
volume = AOUT_VOLUME_MIN;
var_SetBool (obj, "volume-muted", mute);
if ( p_aout ) if (aout != NULL)
{ {
aout_lock_mixer( p_aout ); aout_lock_mixer (aout);
aout_lock_input_fifos( p_aout ); aout_lock_input_fifos (aout);
if ( p_aout->p_mixer ) if (aout->p_mixer != NULL)
i_result = p_aout->output.pf_volume_set( p_aout, i_volume ); ret = aout->output.pf_volume_set (aout, volume);
aout_unlock_input_fifos( p_aout ); aout_unlock_input_fifos (aout);
aout_unlock_mixer( p_aout ); aout_unlock_mixer (aout);
if (ret == 0)
var_SetBool (aout, "intf-change", true);
aout_unlock_volume (aout);
vlc_object_release (aout);
} }
/* trigger callbacks */ /* trigger callbacks */
var_TriggerCallback( p_object, "volume-change" ); var_TriggerCallback (obj, "volume-change");
if ( p_aout )
{
var_SetBool( p_aout, "intf-change", true );
aout_unlock_volume( p_aout );
vlc_object_release( p_aout );
}
if ( i_return_volume != NULL ) return ret;
*i_return_volume = i_volume;
return i_result;
} }
#undef aout_VolumeGet #if 0
/***************************************************************************** /** Cancel a volume change transaction. */
* aout_VolumeGet : get the volume of the output device static void cancelVolume (vlc_object_t *obj, aout_instance_t *aout)
*****************************************************************************/
int aout_VolumeGet( vlc_object_t * p_object, audio_volume_t * pi_volume )
{ {
int i_result = 0; (void) obj;
aout_instance_t * p_aout = findAout( p_object ); if (aout != NULL)
if ( p_aout == NULL )
{
*pi_volume = (audio_volume_t)config_GetInt( p_object, "volume" );
return 0;
}
aout_lock_volume( p_aout );
aout_lock_mixer( p_aout );
if ( p_aout->p_mixer )
{ {
i_result = p_aout->output.pf_volume_get( p_aout, pi_volume ); aout_unlock_volume (aout);
vlc_object_release (aout);
} }
else }
{ #endif
*pi_volume = (audio_volume_t)config_GetInt( p_object, "volume" );
}
aout_unlock_mixer( p_aout );
aout_unlock_volume( p_aout );
vlc_object_release( p_aout ); #undef aout_VolumeGet
return i_result; /**
* Gets the volume of the output device (independent of mute).
*/
int aout_VolumeGet (vlc_object_t *obj, audio_volume_t *volp)
{
#if 0
aout_instance_t *aout;
int ret;
audio_volume_t volume;
bool mute;
prepareVolume (obj, &aout, &volume, &mute);
cancelVolume (obj, aout);
mute = !mute;
ret = commitVolume (obj, aout, volume, mute);
if (volp != NULL)
*volp = mute ? AOUT_VOLUME_MIN : volume;
return ret;
#else
*volp = config_GetInt (obj, "volume");
return 0;
#endif
} }
#undef aout_VolumeSet #undef aout_VolumeSet
/***************************************************************************** /**
* aout_VolumeSet : set the volume of the output device * Sets the volume of the output device.
*****************************************************************************/ * The mute status is not changed.
int aout_VolumeSet( vlc_object_t * p_object, audio_volume_t i_volume ) */
int aout_VolumeSet (vlc_object_t *obj, audio_volume_t volume)
{ {
return doVolumeChanges( SET_VOLUME, p_object, 1, i_volume, NULL, true ); aout_instance_t *aout;
bool mute;
prepareVolume (obj, &aout, NULL, &mute);
return commitVolume (obj, aout, volume, mute);
} }
#undef aout_VolumeUp #undef aout_VolumeUp
/***************************************************************************** /**
* aout_VolumeUp : raise the output volume * Raises the volume.
***************************************************************************** * \param volp if non-NULL, will contain contain the resulting volume
* If pi_volume != NULL, *pi_volume will contain the volume at the end of the */
* function. int aout_VolumeUp (vlc_object_t *obj, int steps, audio_volume_t *volp)
*****************************************************************************/
int aout_VolumeUp( vlc_object_t * p_object, int i_nb_steps,
audio_volume_t * pi_volume )
{ {
return doVolumeChanges( INCREMENT_VOLUME, p_object, i_nb_steps, 0, pi_volume, true ); aout_instance_t *aout;
int ret;
int stepsize = var_InheritInteger (obj, "volume-step");
audio_volume_t volume;
bool mute;
prepareVolume (obj, &aout, &volume, &mute);
volume += stepsize * steps;
ret = commitVolume (obj, aout, volume, mute);
if (volp != NULL)
*volp = volume;
return ret;
} }
#undef aout_VolumeDown #undef aout_VolumeDown
/***************************************************************************** /**
* aout_VolumeDown : lower the output volume * Lowers the volume. See aout_VolumeUp().
***************************************************************************** */
* If pi_volume != NULL, *pi_volume will contain the volume at the end of the int aout_VolumeDown (vlc_object_t *obj, int steps, audio_volume_t *volp)
* function.
*****************************************************************************/
int aout_VolumeDown( vlc_object_t * p_object, int i_nb_steps,
audio_volume_t * pi_volume )
{ {
return aout_VolumeUp( p_object, -i_nb_steps, pi_volume ); return aout_VolumeUp (obj, -steps, volp);
} }
#undef aout_ToggleMute #undef aout_ToggleMute
/***************************************************************************** /**
* aout_ToggleMute : Mute/un-mute the output volume * Toggles the mute state.
***************************************************************************** */
* If pi_volume != NULL, *pi_volume will contain the volume at the end of the int aout_ToggleMute (vlc_object_t *obj, audio_volume_t *volp)
* function (muted => 0).
*****************************************************************************/
int aout_ToggleMute( vlc_object_t * p_object, audio_volume_t * pi_volume )
{ {
return doVolumeChanges( TOGGLE_MUTE, p_object, 1, 0, pi_volume, true ); aout_instance_t *aout;
int ret;
audio_volume_t volume;
bool mute;
prepareVolume (obj, &aout, &volume, &mute);
mute = !mute;
ret = commitVolume (obj, aout, volume, mute);
if (volp != NULL)
*volp = mute ? AOUT_VOLUME_MIN : volume;
return ret;
} }
/***************************************************************************** /**
* aout_IsMuted : Get the output volume mute status * Gets the output mute status.
*****************************************************************************/ */
bool aout_IsMuted( vlc_object_t * p_object ) bool aout_IsMuted (vlc_object_t *obj)
{ {
bool b_return_val; #if 0
aout_instance_t * p_aout = findAout( p_object ); aout_instance_t *aout;
if ( p_aout ) aout_lock_volume( p_aout ); bool mute;
b_return_val = var_GetBool( p_object, "volume-muted");
if ( p_aout ) prepareVolume (obj, &aout, NULL, &mute);
{ cancelVolume (obj, aout);
aout_unlock_volume( p_aout ); return mute;
vlc_object_release( p_aout ); #else
} return var_GetBool (obj, "volume-muted");
return b_return_val; #endif
} }
/***************************************************************************** /**
* aout_SetMute : Sets mute status * Sets mute status.
***************************************************************************** */
* If pi_volume != NULL, *pi_volume will contain the volume at the end of the int aout_SetMute (vlc_object_t *obj, audio_volume_t *volp, bool mute)
* function (muted => 0).
*****************************************************************************/
int aout_SetMute( vlc_object_t * p_object, audio_volume_t * pi_volume,
bool b_mute )
{ {
return doVolumeChanges( SET_MUTE, p_object, 1, 0, pi_volume, b_mute ); aout_instance_t *aout;
int ret;
audio_volume_t volume;
prepareVolume (obj, &aout, &volume, NULL);
ret = commitVolume (obj, aout, volume, mute);
if (volp != NULL)
*volp = mute ? AOUT_VOLUME_MIN : volume;
return ret;
} }
/* /*
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment