static void aout_CheckRestart (audio_output_t *aout)
{
aout_owner_t *owner = aout_owner (aout);
aout_assert_locked (aout);
int restart = vlc_atomic_swap (&owner->restart, 0);
if (likely(restart == 0))
return;
assert (restart & AOUT_RESTART_INPUT);
const aout_request_vout_t request_vout = owner->input->request_vout;
if (likely(owner->input != NULL))
aout_InputDelete (aout, owner->input);
owner->input = NULL;
/* Reinitializes the output */
if (restart & AOUT_RESTART_OUTPUT)
{
aout_MixerDelete (owner->volume.mixer);
owner->volume.mixer = NULL;
aout_OutputDelete (aout);
if (aout_OutputNew (aout, &owner->input_format))
return; /* we are officially screwed */
owner->volume.mixer = aout_MixerNew (aout,
owner->mixer_format.i_format);
}
owner->input = aout_InputNew (aout, &owner->input_format,
&owner->mixer_format, &request_vout);
}
/*****************************************************************************
* aout_InputCheckAndRestart : restart an input
*****************************************************************************
* This function must be entered with the input and mixer lock.
*****************************************************************************/
void aout_InputCheckAndRestart( aout_instance_t * p_aout, aout_input_t * p_input )
{
AOUT_ASSERT_MIXER_LOCKED;
AOUT_ASSERT_INPUT_LOCKED;
if( !p_input->b_restart )
return;
aout_lock_input_fifos( p_aout );
/* A little trick to avoid loosing our input fifo and properties */
uint8_t *p_first_byte_to_mix = p_input->mixer.begin;
aout_fifo_t fifo = p_input->mixer.fifo;
bool b_paused = p_input->b_paused;
mtime_t i_pause_date = p_input->i_pause_date;
aout_FifoInit( p_aout, &p_input->mixer.fifo, p_aout->mixer_format.i_rate );
aout_InputDelete( p_aout, p_input );
aout_InputNew( p_aout, p_input, &p_input->request_vout );
p_input->mixer.begin = p_first_byte_to_mix;
p_input->mixer.fifo = fifo;
p_input->b_paused = b_paused;
p_input->i_pause_date = i_pause_date;
p_input->b_restart = false;
aout_unlock_input_fifos( p_aout );
}
/**
* Stops all plugins involved in the audio output.
*/
void aout_Shutdown (audio_output_t *p_aout)
{
aout_owner_t *owner = aout_owner (p_aout);
aout_input_t *input;
struct audio_mixer *mixer;
aout_lock( p_aout );
/* Remove the input. */
input = owner->input;
if (likely(input != NULL))
aout_InputDelete (p_aout, input);
owner->input = NULL;
mixer = owner->volume.mixer;
owner->volume.mixer = NULL;
var_DelCallback (p_aout, "audio-replay-gain-mode",
ReplayGainCallback, owner);
aout_OutputDelete( p_aout );
var_Destroy( p_aout, "audio-device" );
var_Destroy( p_aout, "audio-channels" );
aout_unlock( p_aout );
aout_MixerDelete (mixer);
free (input);
}
/*****************************************************************************
* aout_DecDelete : delete a decoder
*****************************************************************************/
int aout_DecDelete( aout_instance_t * p_aout, aout_input_t * p_input )
{
int i_input;
/* This function can only be called by the decoder itself, so no need
* to lock p_input->lock. */
vlc_mutex_lock( &p_aout->mixer_lock );
for ( i_input = 0; i_input < p_aout->i_nb_inputs; i_input++ )
{
if ( p_aout->pp_inputs[i_input] == p_input )
{
break;
}
}
if ( i_input == p_aout->i_nb_inputs )
{
msg_Err( p_aout, "cannot find an input to delete" );
return -1;
}
/* Remove the input from the list. */
memmove( &p_aout->pp_inputs[i_input], &p_aout->pp_inputs[i_input + 1],
(AOUT_MAX_INPUTS - i_input - 1) * sizeof(aout_input_t *) );
p_aout->i_nb_inputs--;
aout_InputDelete( p_aout, p_input );
vlc_mutex_destroy( &p_input->lock );
free( p_input );
if ( !p_aout->i_nb_inputs )
{
aout_OutputDelete( p_aout );
aout_MixerDelete( p_aout );
if ( var_Type( p_aout, "audio-device" ) != 0 )
{
var_Destroy( p_aout, "audio-device" );
}
if ( var_Type( p_aout, "audio-channels" ) != 0 )
{
var_Destroy( p_aout, "audio-channels" );
}
}
vlc_mutex_unlock( &p_aout->mixer_lock );
return 0;
}
/*****************************************************************************
* aout_DecNew : create a decoder
*****************************************************************************/
static aout_input_t * DecNew( vlc_object_t * p_this, aout_instance_t * p_aout,
audio_sample_format_t * p_format )
{
aout_input_t * p_input;
input_thread_t * p_input_thread;
vlc_value_t val;
/* We can only be called by the decoder, so no need to lock
* p_input->lock. */
vlc_mutex_lock( &p_aout->mixer_lock );
if ( p_aout->i_nb_inputs >= AOUT_MAX_INPUTS )
{
msg_Err( p_aout, "too many inputs already (%d)", p_aout->i_nb_inputs );
return NULL;
}
p_input = malloc(sizeof(aout_input_t));
if ( p_input == NULL )
{
msg_Err( p_aout, "out of memory" );
return NULL;
}
vlc_mutex_init( p_aout, &p_input->lock );
p_input->b_changed = 0;
p_input->b_error = 1;
aout_FormatPrepare( p_format );
memcpy( &p_input->input, p_format,
sizeof(audio_sample_format_t) );
p_aout->pp_inputs[p_aout->i_nb_inputs] = p_input;
p_aout->i_nb_inputs++;
if ( p_aout->mixer.b_error )
{
int i;
var_Destroy( p_aout, "audio-device" );
var_Destroy( p_aout, "audio-channels" );
/* Recreate the output using the new format. */
if ( aout_OutputNew( p_aout, p_format ) < 0 )
{
for ( i = 0; i < p_aout->i_nb_inputs - 1; i++ )
{
vlc_mutex_lock( &p_aout->pp_inputs[i]->lock );
aout_InputDelete( p_aout, p_aout->pp_inputs[i] );
vlc_mutex_unlock( &p_aout->pp_inputs[i]->lock );
}
vlc_mutex_unlock( &p_aout->mixer_lock );
return p_input;
}
/* Create other input streams. */
for ( i = 0; i < p_aout->i_nb_inputs - 1; i++ )
{
vlc_mutex_lock( &p_aout->pp_inputs[i]->lock );
aout_InputDelete( p_aout, p_aout->pp_inputs[i] );
aout_InputNew( p_aout, p_aout->pp_inputs[i] );
vlc_mutex_unlock( &p_aout->pp_inputs[i]->lock );
}
}
else
{
aout_MixerDelete( p_aout );
}
if ( aout_MixerNew( p_aout ) == -1 )
{
aout_OutputDelete( p_aout );
vlc_mutex_unlock( &p_aout->mixer_lock );
return NULL;
}
aout_InputNew( p_aout, p_input );
vlc_mutex_unlock( &p_aout->mixer_lock );
var_Create( p_this, "audio-desync", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
var_Get( p_this, "audio-desync", &val );
p_input->i_desync = val.i_int * 1000;
p_input_thread = (input_thread_t *)vlc_object_find( p_this,
VLC_OBJECT_INPUT, FIND_PARENT );
if( p_input_thread )
{
p_input->i_pts_delay = p_input_thread->i_pts_delay;
p_input->i_pts_delay += p_input->i_desync;
vlc_object_release( p_input_thread );
}
else
{
p_input->i_pts_delay = DEFAULT_PTS_DELAY;
p_input->i_pts_delay += p_input->i_desync;
}
return p_input;
}
/*****************************************************************************
* aout_Restart : re-open the output device and rebuild the input and output
* pipelines
*****************************************************************************
* This function is used whenever the parameters of the output plug-in are
* changed (eg. selecting S/PDIF or PCM).
*****************************************************************************/
static int aout_Restart( aout_instance_t * p_aout )
{
int i;
bool b_error = 0;
aout_lock_mixer( p_aout );
if ( p_aout->i_nb_inputs == 0 )
{
aout_unlock_mixer( p_aout );
msg_Err( p_aout, "no decoder thread" );
return -1;
}
/* Lock all inputs. */
aout_lock_input_fifos( p_aout );
for ( i = 0; i < p_aout->i_nb_inputs; i++ )
{
aout_lock_input( p_aout, p_aout->pp_inputs[i] );
aout_InputDelete( p_aout, p_aout->pp_inputs[i] );
}
aout_MixerDelete( p_aout );
/* Re-open the output plug-in. */
aout_OutputDelete( p_aout );
if ( aout_OutputNew( p_aout, &p_aout->pp_inputs[0]->input ) == -1 )
{
/* Release all locks and report the error. */
for ( i = 0; i < p_aout->i_nb_inputs; i++ )
{
vlc_mutex_unlock( &p_aout->pp_inputs[i]->lock );
}
aout_unlock_input_fifos( p_aout );
aout_unlock_mixer( p_aout );
return -1;
}
if ( aout_MixerNew( p_aout ) == -1 )
{
aout_OutputDelete( p_aout );
for ( i = 0; i < p_aout->i_nb_inputs; i++ )
{
vlc_mutex_unlock( &p_aout->pp_inputs[i]->lock );
}
aout_unlock_input_fifos( p_aout );
aout_unlock_mixer( p_aout );
return -1;
}
/* Re-open all inputs. */
for ( i = 0; i < p_aout->i_nb_inputs; i++ )
{
aout_input_t * p_input = p_aout->pp_inputs[i];
b_error |= aout_InputNew( p_aout, p_input );
p_input->b_changed = 1;
aout_unlock_input( p_aout, p_input );
}
aout_unlock_input_fifos( p_aout );
aout_unlock_mixer( p_aout );
return b_error;
}
/*****************************************************************************
* aout_InputPlay : play a buffer
*****************************************************************************
* This function must be entered with the input lock.
*****************************************************************************/
int aout_InputPlay( aout_instance_t * p_aout, aout_input_t * p_input,
aout_buffer_t * p_buffer )
{
mtime_t start_date;
if( p_input->b_restart )
{
aout_fifo_t fifo, dummy_fifo;
byte_t *p_first_byte_to_mix;
vlc_mutex_lock( &p_aout->mixer_lock );
/* A little trick to avoid loosing our input fifo */
aout_FifoInit( p_aout, &dummy_fifo, p_aout->mixer.mixer.i_rate );
p_first_byte_to_mix = p_input->p_first_byte_to_mix;
fifo = p_input->fifo;
p_input->fifo = dummy_fifo;
aout_InputDelete( p_aout, p_input );
aout_InputNew( p_aout, p_input );
p_input->p_first_byte_to_mix = p_first_byte_to_mix;
p_input->fifo = fifo;
vlc_mutex_unlock( &p_aout->mixer_lock );
}
/* We don't care if someone changes the start date behind our back after
* this. We'll deal with that when pushing the buffer, and compensate
* with the next incoming buffer. */
vlc_mutex_lock( &p_aout->input_fifos_lock );
start_date = aout_FifoNextStart( p_aout, &p_input->fifo );
vlc_mutex_unlock( &p_aout->input_fifos_lock );
if ( start_date != 0 && start_date < mdate() )
{
/* The decoder is _very_ late. This can only happen if the user
* pauses the stream (or if the decoder is buggy, which cannot
* happen :). */
msg_Warn( p_aout, "computed PTS is out of range ("I64Fd"), "
"clearing out", mdate() - start_date );
vlc_mutex_lock( &p_aout->input_fifos_lock );
aout_FifoSet( p_aout, &p_input->fifo, 0 );
p_input->p_first_byte_to_mix = NULL;
vlc_mutex_unlock( &p_aout->input_fifos_lock );
if ( p_input->i_resampling_type != AOUT_RESAMPLING_NONE )
msg_Warn( p_aout, "timing screwed, stopping resampling" );
p_input->i_resampling_type = AOUT_RESAMPLING_NONE;
if ( p_input->i_nb_resamplers != 0 )
{
p_input->pp_resamplers[0]->input.i_rate = p_input->input.i_rate;
p_input->pp_resamplers[0]->b_continuity = VLC_FALSE;
}
start_date = 0;
if( p_input->p_input_thread )
{
stats_UpdateInteger( p_input->p_input_thread, STATS_LOST_ABUFFERS, 1,
NULL );
}
}
if ( p_buffer->start_date < mdate() + AOUT_MIN_PREPARE_TIME )
{
/* The decoder gives us f*cked up PTS. It's its business, but we
* can't present it anyway, so drop the buffer. */
msg_Warn( p_aout, "PTS is out of range ("I64Fd"), dropping buffer",
mdate() - p_buffer->start_date );
if( p_input->p_input_thread )
{
stats_UpdateInteger( p_input->p_input_thread, STATS_LOST_ABUFFERS,
1, NULL );
}
aout_BufferFree( p_buffer );
p_input->i_resampling_type = AOUT_RESAMPLING_NONE;
if ( p_input->i_nb_resamplers != 0 )
{
p_input->pp_resamplers[0]->input.i_rate = p_input->input.i_rate;
p_input->pp_resamplers[0]->b_continuity = VLC_FALSE;
}
return 0;
}
/* If the audio drift is too big then it's not worth trying to resample
* the audio. */
if ( start_date != 0 &&
( start_date < p_buffer->start_date - 3 * AOUT_PTS_TOLERANCE ) )
{
msg_Warn( p_aout, "audio drift is too big ("I64Fd"), clearing out",
start_date - p_buffer->start_date );
vlc_mutex_lock( &p_aout->input_fifos_lock );
aout_FifoSet( p_aout, &p_input->fifo, 0 );
p_input->p_first_byte_to_mix = NULL;
vlc_mutex_unlock( &p_aout->input_fifos_lock );
if ( p_input->i_resampling_type != AOUT_RESAMPLING_NONE )
msg_Warn( p_aout, "timing screwed, stopping resampling" );
p_input->i_resampling_type = AOUT_RESAMPLING_NONE;
if ( p_input->i_nb_resamplers != 0 )
{
p_input->pp_resamplers[0]->input.i_rate = p_input->input.i_rate;
p_input->pp_resamplers[0]->b_continuity = VLC_FALSE;
}
start_date = 0;
}
else if ( start_date != 0 &&
( start_date > p_buffer->start_date + 3 * AOUT_PTS_TOLERANCE ) )
{
msg_Warn( p_aout, "audio drift is too big ("I64Fd"), dropping buffer",
start_date - p_buffer->start_date );
aout_BufferFree( p_buffer );
if( p_input->p_input_thread )
{
stats_UpdateInteger( p_input->p_input_thread, STATS_LOST_ABUFFERS,
1, NULL );
}
return 0;
}
if ( start_date == 0 ) start_date = p_buffer->start_date;
/* Run pre-filters. */
aout_FiltersPlay( p_aout, p_input->pp_filters, p_input->i_nb_filters,
&p_buffer );
/* Run the resampler if needed.
* We first need to calculate the output rate of this resampler. */
if ( ( p_input->i_resampling_type == AOUT_RESAMPLING_NONE ) &&
( start_date < p_buffer->start_date - AOUT_PTS_TOLERANCE
|| start_date > p_buffer->start_date + AOUT_PTS_TOLERANCE ) &&
p_input->i_nb_resamplers > 0 )
{
/* Can happen in several circumstances :
* 1. A problem at the input (clock drift)
* 2. A small pause triggered by the user
* 3. Some delay in the output stage, causing a loss of lip
* synchronization
* Solution : resample the buffer to avoid a scratch.
*/
mtime_t drift = p_buffer->start_date - start_date;
p_input->i_resamp_start_date = mdate();
p_input->i_resamp_start_drift = (int)drift;
if ( drift > 0 )
p_input->i_resampling_type = AOUT_RESAMPLING_DOWN;
else
p_input->i_resampling_type = AOUT_RESAMPLING_UP;
msg_Warn( p_aout, "buffer is "I64Fd" %s, triggering %ssampling",
drift > 0 ? drift : -drift,
drift > 0 ? "in advance" : "late",
drift > 0 ? "down" : "up");
}
if ( p_input->i_resampling_type != AOUT_RESAMPLING_NONE )
{
/* Resampling has been triggered previously (because of dates
* mismatch). We want the resampling to happen progressively so
* it isn't too audible to the listener. */
if( p_input->i_resampling_type == AOUT_RESAMPLING_UP )
{
p_input->pp_resamplers[0]->input.i_rate += 2; /* Hz */
}
else
{
p_input->pp_resamplers[0]->input.i_rate -= 2; /* Hz */
}
/* Check if everything is back to normal, in which case we can stop the
* resampling */
if( p_input->pp_resamplers[0]->input.i_rate ==
p_input->input.i_rate )
{
p_input->i_resampling_type = AOUT_RESAMPLING_NONE;
msg_Warn( p_aout, "resampling stopped after "I64Fi" usec "
"(drift: "I64Fi")",
mdate() - p_input->i_resamp_start_date,
p_buffer->start_date - start_date);
}
else if( abs( (int)(p_buffer->start_date - start_date) ) <
abs( p_input->i_resamp_start_drift ) / 2 )
{
/* if we reduced the drift from half, then it is time to switch
* back the resampling direction. */
if( p_input->i_resampling_type == AOUT_RESAMPLING_UP )
p_input->i_resampling_type = AOUT_RESAMPLING_DOWN;
else
p_input->i_resampling_type = AOUT_RESAMPLING_UP;
p_input->i_resamp_start_drift = 0;
}
else if( p_input->i_resamp_start_drift &&
( abs( (int)(p_buffer->start_date - start_date) ) >
abs( p_input->i_resamp_start_drift ) * 3 / 2 ) )
{
/* If the drift is increasing and not decreasing, than something
* is bad. We'd better stop the resampling right now. */
msg_Warn( p_aout, "timing screwed, stopping resampling" );
p_input->i_resampling_type = AOUT_RESAMPLING_NONE;
p_input->pp_resamplers[0]->input.i_rate = p_input->input.i_rate;
}
}
/* Adding the start date will be managed by aout_FifoPush(). */
p_buffer->end_date = start_date +
(p_buffer->end_date - p_buffer->start_date);
p_buffer->start_date = start_date;
/* Actually run the resampler now. */
if ( p_input->i_nb_resamplers > 0 )
{
aout_FiltersPlay( p_aout, p_input->pp_resamplers,
p_input->i_nb_resamplers,
&p_buffer );
}
vlc_mutex_lock( &p_aout->input_fifos_lock );
aout_FifoPush( p_aout, &p_input->fifo, p_buffer );
vlc_mutex_unlock( &p_aout->input_fifos_lock );
return 0;
}