VLC_API void aout_FormatPrint( aout_instance_t * p_aout, const char * psz_text, const audio_sample_format_t * p_format );
VLC_API const char * aout_FormatPrintChannels( const audio_sample_format_t * ) VLC_USED;
-VLC_API mtime_t aout_FifoFirstDate( aout_instance_t *, aout_fifo_t * ) VLC_USED;
-VLC_API aout_buffer_t * aout_FifoPop( aout_instance_t * p_aout, aout_fifo_t * p_fifo ) VLC_USED;
+VLC_API mtime_t aout_FifoFirstDate( const aout_fifo_t * ) VLC_USED;
+VLC_API aout_buffer_t *aout_FifoPop( aout_fifo_t * p_fifo ) VLC_USED;
/* From intf.c : */
VLC_API void aout_VolumeSoftInit( aout_instance_t * );
p_out += i_available_words;
/* Next buffer */
- p_old_buffer = aout_FifoPop( NULL, &p_input->fifo );
+ p_old_buffer = aout_FifoPop( &p_input->fifo );
aout_BufferFree( p_old_buffer );
if( p_input->fifo.p_first == NULL )
{
float multiplier )
{
aout_mixer_input_t * p_input = p_mixer->input;
- aout_buffer_t * p_old_buffer = aout_FifoPop( NULL, &p_input->fifo );
+ aout_buffer_t * p_old_buffer = aout_FifoPop( &p_input->fifo );
(void) samples; (void) multiplier;
return p_old_buffer;
p_out += avail;
/* Next buffer */
- aout_buffer_t *p_old_buffer = aout_FifoPop( NULL, &p_input->fifo );
+ aout_buffer_t *p_old_buffer = aout_FifoPop( &p_input->fifo );
aout_BufferFree( p_old_buffer );
if ( p_input->fifo.p_first == NULL )
{
p_aout->output.pf_play = PlayIgnore;
/* get the playing date of the first aout buffer */
- p_aout->output.p_sys->start_date =
- aout_FifoFirstDate( p_aout, &p_aout->output.fifo );
+ p_aout->output.p_sys->start_date = aout_FifoFirstDate( &p_aout->output.fifo );
/* wake up the audio output thread */
sem_post( &p_aout->output.p_sys->wait );
aout_sys_t *sys = aout->output.p_sys;
block_t *block;
- while ((block = aout_FifoPop(aout, &aout->output.fifo)) != NULL)
+ while ((block = aout_FifoPop(&aout->output.fifo)) != NULL)
{
sys->play (sys->opaque, block->p_buffer, block->i_nb_samples,
block->i_pts);
if (p_aout) {
vlc_mutex_lock( &p_aout->output_fifo_lock );
- p_buffer = aout_FifoPop( p_aout, &p_aout->output.fifo );
+ p_buffer = aout_FifoPop( &p_aout->output.fifo );
vlc_mutex_unlock( &p_aout->output_fifo_lock );
}
/* get the playing date of the first aout buffer */
p_aout->output.p_sys->p_notif->start_date =
- aout_FifoFirstDate( p_aout, &p_aout->output.fifo );
+ aout_FifoFirstDate( &p_aout->output.fifo );
/* fill in the first samples */
for( int i = 0; i < FRAMES_NUM; i++ )
{
- p_buffer = aout_FifoPop( p_aout, &p_aout->output.fifo );
+ p_buffer = aout_FifoPop( &p_aout->output.fifo );
if( !p_buffer ) break;
FillBuffer( p_aout, i, p_buffer );
}
{
aout_buffer_t * p_buffer;
- p_buffer = aout_FifoPop( p_aout, &p_aout->output.fifo );
+ p_buffer = aout_FifoPop( &p_aout->output.fifo );
if( fwrite( p_buffer->p_buffer, p_buffer->i_buffer, 1,
p_aout->output.p_sys->p_file ) != 1 )
if (pa_context_errno(sys->context) != PA_ERR_NODATA)
error(aout, "cannot determine latency", sys->context);
} else {
- mtime_t gap = aout_FifoFirstDate(aout, &aout->output.fifo) - mdate()
+ mtime_t gap = aout_FifoFirstDate(&aout->output.fifo) - mdate()
- latency;
if (gap > AOUT_PTS_TOLERANCE)
* If this function is changed to not always dequeue blocks, be sure to
* limit the queue size to a reasonable limit to avoid huge leaks. */
for (;;) {
- block_t *block = aout_FifoPop(aout, &aout->output.fifo);
+ block_t *block = aout_FifoPop(&aout->output.fifo);
if (block == NULL)
break;
* it at SDL's face. Nah. */
vlc_mutex_lock( &p_aout->output_fifo_lock );
- p_buffer = aout_FifoPop( p_aout, &p_aout->output.fifo );
+ p_buffer = aout_FifoPop( &p_aout->output.fifo );
vlc_mutex_unlock( &p_aout->output_fifo_lock );
if ( p_buffer != NULL )
/* get the playing date of the first aout buffer */
_p_aout->output.p_sys->start_date =
- aout_FifoFirstDate( _p_aout, &_p_aout->output.fifo );
+ aout_FifoFirstDate( &_p_aout->output.fifo );
msg_Dbg( _p_aout, "Wakeup sleeping output thread.");
#endif
// means we are too early to request a new buffer?
waveout_warn("waiting...")
- next_date = aout_FifoFirstDate( p_aout, &p_aout->output.fifo );
+ next_date = aout_FifoFirstDate( &p_aout->output.fifo );
mwait( next_date - AOUT_PTS_TOLERANCE/4 );
next_date = mdate();
p_buffer = aout_OutputNextBuffer( p_aout, next_date,
*****************************************************************************/
static void Play( aout_instance_t * p_aout )
{
- aout_buffer_t * p_buffer = aout_FifoPop( p_aout, &p_aout->output.fifo );
+ aout_buffer_t * p_buffer = aout_FifoPop( &p_aout->output.fifo );
aout_BufferFree( p_buffer );
}
/* Release with vlc_object_release() */
aout_instance_t * __aout_New ( vlc_object_t * );
-void aout_FifoInit( aout_instance_t *, aout_fifo_t *, uint32_t );
-mtime_t aout_FifoNextStart( aout_instance_t *, aout_fifo_t * );
-void aout_FifoPush( aout_instance_t *, aout_fifo_t *, aout_buffer_t * );
-void aout_FifoSet( aout_instance_t *, aout_fifo_t *, mtime_t );
-void aout_FifoMoveDates( aout_instance_t *, aout_fifo_t *, mtime_t );
-void aout_FifoDestroy( aout_instance_t * p_aout, aout_fifo_t * p_fifo );
+void aout_FifoInit( vlc_object_t *, aout_fifo_t *, uint32_t );
+#define aout_FifoInit(o, f, r) aout_FifoInit(VLC_OBJECT(o), f, r)
+mtime_t aout_FifoNextStart( const aout_fifo_t * ) VLC_USED;
+void aout_FifoPush( aout_fifo_t *, aout_buffer_t * );
+void aout_FifoSet( aout_fifo_t *, mtime_t );
+void aout_FifoMoveDates( aout_fifo_t *, mtime_t );
+void aout_FifoDestroy( aout_fifo_t * p_fifo );
void aout_FormatsPrint( aout_instance_t * p_aout, const char * psz_text, const audio_sample_format_t * p_format1, const audio_sample_format_t * p_format2 );
bool aout_ChangeFilterString( vlc_object_t *, aout_instance_t *, const char *psz_variable, const char *psz_name, bool b_add );
* Instances management (internal and external)
*/
-#define AOUT_ASSERT_FIFO_LOCKED aout_assert_fifo_locked(p_aout, p_fifo)
-static inline void aout_assert_fifo_locked( aout_instance_t * p_aout, aout_fifo_t * p_fifo )
-{
-#ifndef NDEBUG
- if( !p_aout )
- return;
-
- if( p_fifo == &p_aout->output.fifo )
- vlc_assert_locked( &p_aout->output_fifo_lock );
- else
- if( p_aout->p_input != NULL
- && p_fifo == &p_aout->p_input->mixer.fifo )
- vlc_assert_locked( &p_aout->input_fifos_lock );
- else
- vlc_assert_locked( &p_aout->mixer_lock );
-#else
- (void)p_aout;
- (void)p_fifo;
-#endif
-}
-
/* Local functions */
static void aout_Destructor( vlc_object_t * p_this );
* before calling any of these functions.
*/
+#undef aout_FifoInit
/*****************************************************************************
* aout_FifoInit : initialize the members of a FIFO
*****************************************************************************/
-void aout_FifoInit( aout_instance_t * p_aout, aout_fifo_t * p_fifo,
- uint32_t i_rate )
+void aout_FifoInit( vlc_object_t *obj, aout_fifo_t * p_fifo, uint32_t i_rate )
{
- AOUT_ASSERT_FIFO_LOCKED;
-
- if( i_rate == 0 )
- {
- msg_Err( p_aout, "initialising fifo with zero divider" );
- }
+ if( unlikely(i_rate == 0) )
+ msg_Err( obj, "initialising fifo with zero divider" );
p_fifo->p_first = NULL;
p_fifo->pp_last = &p_fifo->p_first;
/*****************************************************************************
* aout_FifoPush : push a packet into the FIFO
*****************************************************************************/
-void aout_FifoPush( aout_instance_t * p_aout, aout_fifo_t * p_fifo,
- aout_buffer_t * p_buffer )
+void aout_FifoPush( aout_fifo_t * p_fifo, aout_buffer_t * p_buffer )
{
- (void)p_aout;
- AOUT_ASSERT_FIFO_LOCKED;
-
*p_fifo->pp_last = p_buffer;
p_fifo->pp_last = &p_buffer->p_next;
*p_fifo->pp_last = NULL;
* aout_FifoSet : set end_date and trash all buffers (because they aren't
* properly dated)
*****************************************************************************/
-void aout_FifoSet( aout_instance_t * p_aout, aout_fifo_t * p_fifo,
- mtime_t date )
+void aout_FifoSet( aout_fifo_t * p_fifo, mtime_t date )
{
aout_buffer_t * p_buffer;
- (void)p_aout;
- AOUT_ASSERT_FIFO_LOCKED;
date_Set( &p_fifo->end_date, date );
p_buffer = p_fifo->p_first;
/*****************************************************************************
* aout_FifoMoveDates : Move forwards or backwards all dates in the FIFO
*****************************************************************************/
-void aout_FifoMoveDates( aout_instance_t * p_aout, aout_fifo_t * p_fifo,
- mtime_t difference )
+void aout_FifoMoveDates( aout_fifo_t * p_fifo, mtime_t difference )
{
aout_buffer_t * p_buffer;
- (void)p_aout;
- AOUT_ASSERT_FIFO_LOCKED;
date_Move( &p_fifo->end_date, difference );
p_buffer = p_fifo->p_first;
/*****************************************************************************
* aout_FifoNextStart : return the current end_date
*****************************************************************************/
-mtime_t aout_FifoNextStart( aout_instance_t * p_aout, aout_fifo_t * p_fifo )
+mtime_t aout_FifoNextStart( const aout_fifo_t *p_fifo )
{
- (void)p_aout;
- AOUT_ASSERT_FIFO_LOCKED;
return date_Get( &p_fifo->end_date );
}
* aout_FifoFirstDate : return the playing date of the first buffer in the
* FIFO
*****************************************************************************/
-mtime_t aout_FifoFirstDate( aout_instance_t * p_aout, aout_fifo_t * p_fifo )
+mtime_t aout_FifoFirstDate( const aout_fifo_t *p_fifo )
{
- (void)p_aout;
- AOUT_ASSERT_FIFO_LOCKED;
- return p_fifo->p_first ? p_fifo->p_first->i_pts : 0;
+ return (p_fifo->p_first != NULL) ? p_fifo->p_first->i_pts : 0;
}
/*****************************************************************************
* aout_FifoPop : get the next buffer out of the FIFO
*****************************************************************************/
-aout_buffer_t * aout_FifoPop( aout_instance_t * p_aout, aout_fifo_t * p_fifo )
+aout_buffer_t *aout_FifoPop( aout_fifo_t * p_fifo )
{
- aout_buffer_t * p_buffer;
- (void)p_aout;
- AOUT_ASSERT_FIFO_LOCKED;
-
- p_buffer = p_fifo->p_first;
- if ( p_buffer == NULL ) return NULL;
- p_fifo->p_first = p_buffer->p_next;
- if ( p_fifo->p_first == NULL )
+ aout_buffer_t *p_buffer = p_fifo->p_first;
+ if( p_buffer != NULL )
{
- p_fifo->pp_last = &p_fifo->p_first;
+ p_fifo->p_first = p_buffer->p_next;
+ if( p_fifo->p_first == NULL )
+ p_fifo->pp_last = &p_fifo->p_first;
}
-
return p_buffer;
}
/*****************************************************************************
* aout_FifoDestroy : destroy a FIFO and its buffers
*****************************************************************************/
-void aout_FifoDestroy( aout_instance_t * p_aout, aout_fifo_t * p_fifo )
+void aout_FifoDestroy( aout_fifo_t * p_fifo )
{
aout_buffer_t * p_buffer;
- (void)p_aout;
- AOUT_ASSERT_FIFO_LOCKED;
p_buffer = p_fifo->p_first;
while ( p_buffer != NULL )
{
aout_lock_input_fifos( p_aout );
- aout_FifoSet( p_aout, &p_input->mixer.fifo, 0 );
+ aout_FifoSet( &p_input->mixer.fifo, 0 );
p_input->mixer.begin = NULL;
aout_unlock_input_fifos( p_aout );
aout_FiltersDestroyPipeline( p_input->pp_resamplers,
p_input->i_nb_resamplers );
p_input->i_nb_resamplers = 0;
- aout_FifoDestroy( p_aout, &p_input->mixer.fifo );
+ aout_FifoDestroy( &p_input->mixer.fifo );
return 0;
}
* this. We'll deal with that when pushing the buffer, and compensate
* with the next incoming buffer. */
aout_lock_input_fifos( p_aout );
- start_date = aout_FifoNextStart( p_aout, &p_input->mixer.fifo );
+ start_date = aout_FifoNextStart( &p_input->mixer.fifo );
aout_unlock_input_fifos( p_aout );
if ( start_date != 0 && start_date < mdate() )
msg_Warn( p_aout, "computed PTS is out of range (%"PRId64"), "
"clearing out", mdate() - start_date );
aout_lock_input_fifos( p_aout );
- aout_FifoSet( p_aout, &p_input->mixer.fifo, 0 );
+ aout_FifoSet( &p_input->mixer.fifo, 0 );
p_input->mixer.begin = NULL;
aout_unlock_input_fifos( p_aout );
if ( p_input->i_resampling_type != AOUT_RESAMPLING_NONE )
msg_Warn( p_aout, "audio drift is too big (%"PRId64"), clearing out",
start_date - p_buffer->i_pts );
aout_lock_input_fifos( p_aout );
- aout_FifoSet( p_aout, &p_input->mixer.fifo, 0 );
+ aout_FifoSet( &p_input->mixer.fifo, 0 );
p_input->mixer.begin = NULL;
aout_unlock_input_fifos( p_aout );
if ( p_input->i_resampling_type != AOUT_RESAMPLING_NONE )
p_buffer->i_pts = start_date;
aout_lock_input_fifos( p_aout );
- aout_FifoPush( p_aout, &p_input->mixer.fifo, p_buffer );
+ aout_FifoPush( &p_input->mixer.fifo, p_buffer );
aout_unlock_input_fifos( p_aout );
return 0;
}
aout_FiltersDestroyPipeline( p_input->pp_filters, p_input->i_nb_filters );
aout_FiltersDestroyPipeline( p_input->pp_resamplers,
p_input->i_nb_resamplers );
- aout_FifoDestroy( p_aout, &p_input->mixer.fifo );
+ aout_FifoDestroy( &p_input->mixer.fifo );
var_Destroy( p_aout, "visual" );
var_Destroy( p_aout, "equalizer" );
var_Destroy( p_aout, "audio-filter" );
* happen :). */
msg_Warn( p_mixer, "output PTS is out of range (%"PRId64"), clearing out",
mdate() - start_date );
- aout_FifoSet( p_aout, &p_aout->output.fifo, 0 );
+ aout_FifoSet( &p_aout->output.fifo, 0 );
date_Set( &exact_start_date, 0 );
start_date = 0;
}
msg_Warn( p_mixer, "input PTS is out of range (%"PRId64"), "
"trashing", now - p_buffer->i_pts );
- aout_BufferFree( aout_FifoPop( p_aout, p_fifo ) );
+ aout_BufferFree( aout_FifoPop( p_fifo ) );
p_input->begin = NULL;
}
* regularly. */
msg_Warn( p_mixer, "the mixer got a packet in the past (%"PRId64")",
start_date - prev_date );
- aout_BufferFree( aout_FifoPop( p_aout, p_fifo ) );
+ aout_BufferFree( aout_FifoPop( p_fifo ) );
p_input->begin = NULL;
p_buffer = p_fifo->p_first;
}
aout_buffer_t *p_deleted;
while( (p_deleted = p_fifo->p_first) != p_buffer )
- aout_BufferFree( aout_FifoPop( p_aout, p_fifo ) );
+ aout_BufferFree( aout_FifoPop( p_fifo ) );
}
prev_date = p_buffer->i_pts + p_buffer->i_length;
{
/* Is it really the best way to do it ? */
aout_lock_output_fifo( p_aout );
- aout_FifoSet( p_aout, &p_aout->output.fifo, 0 );
+ aout_FifoSet( &p_aout->output.fifo, 0 );
date_Set( &exact_start_date, 0 );
aout_unlock_output_fifo( p_aout );
goto giveup;
aout_lock_output_fifo( p_aout );
/* Prepare FIFO. */
- aout_FifoInit( p_aout, &p_aout->output.fifo,
- p_aout->output.output.i_rate );
+ aout_FifoInit( p_aout, &p_aout->output.fifo, p_aout->output.output.i_rate );
aout_unlock_output_fifo( p_aout );
p_aout->output.i_nb_filters );
aout_lock_output_fifo( p_aout );
- aout_FifoDestroy( p_aout, &p_aout->output.fifo );
+ aout_FifoDestroy( &p_aout->output.fifo );
aout_unlock_output_fifo( p_aout );
}
}
aout_lock_output_fifo( p_aout );
- aout_FifoPush( p_aout, &p_aout->output.fifo, p_buffer );
+ aout_FifoPush( &p_aout->output.fifo, p_buffer );
p_aout->output.pf_play( p_aout );
aout_unlock_output_fifo( p_aout );
}
* to deal with this kind of starvation. */
/* Set date to 0, to allow the mixer to send a new buffer ASAP */
- aout_FifoSet( p_aout, &p_aout->output.fifo, 0 );
+ aout_FifoSet( &p_aout->output.fifo, 0 );
if ( !p_aout->output.b_starving )
msg_Dbg( p_aout,
"audio output is starving (no input), playing silence" );
msg_Warn( p_aout, "output date isn't PTS date, requesting "
"resampling (%"PRId64")", difference );
- aout_FifoMoveDates( p_aout, &p_aout->output.fifo, difference );
+ aout_FifoMoveDates( &p_aout->output.fifo, difference );
aout_unlock_output_fifo( p_aout );
aout_lock_input_fifos( p_aout );
aout_fifo_t *p_fifo = &p_aout->p_input->mixer.fifo;
- aout_FifoMoveDates( p_aout, p_fifo, difference );
+ aout_FifoMoveDates( p_fifo, difference );
aout_unlock_input_fifos( p_aout );
return p_buffer;
}