void aout_OutputPause( audio_output_t * p_aout, bool, mtime_t );
void aout_OutputFlush( audio_output_t * p_aout, bool );
void aout_OutputDelete( audio_output_t * p_aout );
+void aout_OutputLock(audio_output_t *);
+void aout_OutputUnlock(audio_output_t *);
/* From common.c : */
aout_RequestRestart(aout, AOUT_RESTART_FILTERS);
}
-/* Audio output locking */
-static inline void aout_lock( audio_output_t *p_aout )
-{
- vlc_mutex_lock( &aout_owner(p_aout)->lock );
-}
-
-static inline void aout_unlock( audio_output_t *p_aout )
-{
- vlc_mutex_unlock( &aout_owner(p_aout)->lock );
-}
-
-#define aout_assert_locked( aout ) \
- vlc_assert_locked( &aout_owner(aout)->lock )
-
#endif /* !LIBVLC_AOUT_INTERNAL_H */
aout_owner_t *owner = aout_owner(p_aout);
/* TODO: reduce lock scope depending on decoder's real need */
- aout_lock( p_aout );
+ aout_OutputLock (p_aout);
var_Destroy( p_aout, "stereo-mode" );
aout_OutputDelete (p_aout);
error:
aout_volume_Delete (owner->volume);
- aout_unlock (p_aout);
+ aout_OutputUnlock (p_aout);
return -1;
}
owner->sync.end = VLC_TS_INVALID;
owner->sync.resamp_type = AOUT_RESAMPLING_NONE;
owner->sync.discontinuity = true;
- aout_unlock( p_aout );
+ aout_OutputUnlock (p_aout);
atomic_init (&owner->buffers_lost, 0);
return 0;
{
aout_owner_t *owner = aout_owner (aout);
- aout_lock (aout);
+ aout_OutputLock (aout);
if (owner->mixer_format.i_format)
{
aout_FiltersDelete (aout);
aout_OutputDelete (aout);
}
aout_volume_Delete (owner->volume);
- aout_unlock (aout);
+ aout_OutputUnlock (aout);
var_Destroy (aout, "stereo-mode");
}
{
aout_owner_t *owner = aout_owner (aout);
- aout_assert_locked (aout);
-
int restart = atomic_exchange (&owner->restart, 0);
if (unlikely(restart))
{
block->i_length = CLOCK_FREQ * block->i_nb_samples
/ owner->input_format.i_rate;
- aout_lock (aout);
+ aout_OutputLock (aout);
if (unlikely(aout_CheckReady (aout)))
goto drop; /* Pipeline is unrecoverably broken :-( */
owner->sync.discontinuity = false;
aout_OutputPlay (aout, block);
out:
- aout_unlock (aout);
+ aout_OutputUnlock (aout);
return 0;
drop:
owner->sync.discontinuity = true;
{
aout_owner_t *owner = aout_owner (aout);
- aout_lock (aout);
+ aout_OutputLock (aout);
if (owner->sync.end != VLC_TS_INVALID)
{
if (paused)
}
if (owner->mixer_format.i_format)
aout_OutputPause (aout, paused, date);
- aout_unlock (aout);
+ aout_OutputUnlock (aout);
}
void aout_DecFlush (audio_output_t *aout)
{
aout_owner_t *owner = aout_owner (aout);
- aout_lock (aout);
+ aout_OutputLock (aout);
owner->sync.end = VLC_TS_INVALID;
if (owner->mixer_format.i_format)
aout_OutputFlush (aout, false);
- aout_unlock (aout);
+ aout_OutputUnlock (aout);
}
bool aout_DecIsEmpty (audio_output_t *aout)
mtime_t now = mdate ();
bool empty = true;
- aout_lock (aout);
+ aout_OutputLock (aout);
if (owner->sync.end != VLC_TS_INVALID)
empty = owner->sync.end <= now;
if (empty && owner->mixer_format.i_format)
* buffer should be empty or almost. Thus draining should be fast
* and will not block the caller too long. */
aout_OutputFlush (aout, true);
- aout_unlock (aout);
+ aout_OutputUnlock (aout);
return empty;
}
#include "aout_internal.h"
/* Local functions */
+static void aout_OutputAssertLocked (audio_output_t *aout)
+{
+ aout_owner_t *owner = aout_owner (aout);
+
+ vlc_assert_locked (&owner->lock);
+}
+
static void aout_Destructor( vlc_object_t * p_this );
static int var_Copy (vlc_object_t *src, const char *name, vlc_value_t prev,
{
aout_owner_t *owner = aout_owner (aout);
- aout_assert_locked (aout);
+ aout_OutputAssertLocked (aout);
aout_volume_SetVolume (owner->volume, gain);
/* XXX: ideally, return -1 if format cannot be amplified */
return 0;
{
aout_owner_t *owner = aout_owner (aout);
- aout_lock (aout);
+ aout_OutputLock (aout);
module_unneed (aout, owner->module);
/* Protect against late call from intf.c */
aout->volume_set = NULL;
aout->mute_set = NULL;
- aout_unlock (aout);
+ aout_OutputUnlock (aout);
var_DelCallback (aout, "mute", var_Copy, aout->p_parent);
var_SetFloat (aout, "volume", -1.f);
{
int ret = -1;
- aout_lock (aout);
+ aout_OutputLock (aout);
if (aout->volume_set != NULL)
ret = aout->volume_set (aout, vol);
- aout_unlock (aout);
+ aout_OutputUnlock (aout);
return ret;
}
{
int ret = -1;
- aout_lock (aout);
+ aout_OutputLock (aout);
if (aout->mute_set != NULL)
ret = aout->mute_set (aout, mute);
- aout_unlock (aout);
+ aout_OutputUnlock (aout);
return ret;
}
{
int ret = -1;
- aout_lock (aout);
+ aout_OutputLock (aout);
if (aout->device_select != NULL)
ret = aout->device_select (aout, id);
- aout_unlock (aout);
+ aout_OutputUnlock (aout);
return ret;
}
{
int ret = -1;
- aout_lock (aout);
+ aout_OutputLock (aout);
if (aout->device_enum != NULL)
ret = aout->device_enum (aout, ids, names);
- aout_unlock (aout);
+ aout_OutputUnlock (aout);
return ret;
}
*/
int aout_OutputNew (audio_output_t *aout, audio_sample_format_t *restrict fmt)
{
- aout_assert_locked (aout);
+ aout_OutputAssertLocked (aout);
/* Ideally, the audio filters would be created before the audio output,
* and the ideal audio format would be the output of the filters chain.
*/
void aout_OutputDelete (audio_output_t *aout)
{
- aout_assert_locked (aout);
+ aout_OutputAssertLocked (aout);
var_DelCallback (aout, "stereo-mode", aout_ChannelsRestart, NULL);
if (aout->stop != NULL)
int aout_OutputTimeGet (audio_output_t *aout, mtime_t *delay)
{
- aout_assert_locked (aout);
+ aout_OutputAssertLocked (aout);
if (aout->time_get == NULL)
return -1;
*/
void aout_OutputPlay (audio_output_t *aout, block_t *block)
{
- aout_assert_locked (aout);
+ aout_OutputAssertLocked (aout);
aout->play (aout, block);
}
*/
void aout_OutputPause( audio_output_t *aout, bool pause, mtime_t date )
{
- aout_assert_locked (aout);
+ aout_OutputAssertLocked (aout);
((aout->pause != NULL) ? aout->pause : PauseDefault) (aout, pause, date);
}
*/
void aout_OutputFlush( audio_output_t *aout, bool wait )
{
- aout_assert_locked( aout );
+ aout_OutputAssertLocked( aout );
aout->flush (aout, wait);
}
+
+void aout_OutputLock (audio_output_t *aout)
+{
+ aout_owner_t *owner = aout_owner (aout);
+
+ vlc_mutex_lock (&owner->lock);
+}
+
+void aout_OutputUnlock (audio_output_t *aout)
+{
+ aout_owner_t *owner = aout_owner (aout);
+
+ vlc_mutex_unlock (&owner->lock);
+}