/*****************************************************************************
* aout_DecPlay : filter & mix the decoded buffer
*****************************************************************************/
int aout_DecPlay (audio_output_t *aout, block_t *block, int input_rate)
{
aout_owner_t *owner = aout_owner (aout);
assert (input_rate >= INPUT_RATE_DEFAULT / AOUT_MAX_INPUT_RATE);
assert (input_rate <= INPUT_RATE_DEFAULT * AOUT_MAX_INPUT_RATE);
assert (block->i_pts >= VLC_TS_0);
block->i_length = CLOCK_FREQ * block->i_nb_samples
/ owner->input_format.i_rate;
aout_OutputLock (aout);
int ret = aout_CheckReady (aout);
if (unlikely(ret == AOUT_DEC_FAILED))
goto drop; /* Pipeline is unrecoverably broken :-( */
const mtime_t now = mdate (), advance = block->i_pts - now;
if (advance < -AOUT_MAX_PTS_DELAY)
{ /* Late buffer can be caused by bugs in the decoder, by scheduling
* latency spikes (excessive load, SIGSTOP, etc.) or if buffering is
* insufficient. We assume the PTS is wrong and play the buffer anyway:
* Hopefully video has encountered a similar PTS problem as audio. */
msg_Warn (aout, "buffer too late (%"PRId64" us): dropped", advance);
goto drop;
}
if (advance > AOUT_MAX_ADVANCE_TIME)
{ /* Early buffers can only be caused by bugs in the decoder. */
msg_Err (aout, "buffer too early (%"PRId64" us): dropped", advance);
goto drop;
}
if (block->i_flags & BLOCK_FLAG_DISCONTINUITY)
owner->sync.discontinuity = true;
block = aout_FiltersPlay (owner->filters, block, input_rate);
if (block == NULL)
goto lost;
/* Software volume */
aout_volume_Amplify (owner->volume, block);
/* Drift correction */
aout_DecSynchronize (aout, block->i_pts, input_rate);
/* Output */
owner->sync.end = block->i_pts + block->i_length + 1;
owner->sync.discontinuity = false;
aout_OutputPlay (aout, block);
atomic_fetch_add(&owner->buffers_played, 1);
out:
aout_OutputUnlock (aout);
return ret;
drop:
owner->sync.discontinuity = true;
block_Release (block);
lost:
atomic_fetch_add(&owner->buffers_lost, 1);
goto out;
}
void aout_DecFlush (audio_output_t *aout)
{
aout_owner_t *owner = aout_owner (aout);
aout_OutputLock (aout);
owner->sync.end = VLC_TS_INVALID;
if (owner->mixer_format.i_format)
aout_OutputFlush (aout, false);
aout_OutputUnlock (aout);
}
/**
* Stops all plugins involved in the audio output.
*/
void aout_DecDelete (audio_output_t *aout)
{
aout_owner_t *owner = aout_owner (aout);
aout_OutputLock (aout);
if (owner->mixer_format.i_format)
{
aout_FiltersDelete (aout, owner->filters);
aout_OutputDelete (aout);
}
aout_volume_Delete (owner->volume);
aout_OutputUnlock (aout);
var_Destroy (aout, "stereo-mode");
}
void aout_DecChangePause (audio_output_t *aout, bool paused, mtime_t date)
{
aout_owner_t *owner = aout_owner (aout);
aout_OutputLock (aout);
if (owner->sync.end != VLC_TS_INVALID)
{
if (paused)
owner->sync.end -= date;
else
owner->sync.end += date;
}
if (owner->mixer_format.i_format)
aout_OutputPause (aout, paused, date);
aout_OutputUnlock (aout);
}
/**
* Deinitializes an audio output module and destroys an audio output object.
*/
void aout_Destroy (audio_output_t *aout)
{
aout_owner_t *owner = aout_owner (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_OutputUnlock (aout);
var_DelCallback (aout, "mute", var_Copy, aout->p_parent);
var_SetFloat (aout, "volume", -1.f);
var_DelCallback (aout, "volume", var_Copy, aout->p_parent);
vlc_object_release (aout);
}
bool aout_DecIsEmpty (audio_output_t *aout)
{
aout_owner_t *owner = aout_owner (aout);
mtime_t now = mdate ();
bool empty = true;
aout_OutputLock (aout);
if (owner->sync.end != VLC_TS_INVALID)
empty = owner->sync.end <= now;
if (empty && owner->mixer_format.i_format)
/* The last PTS has elapsed already. So the underlying audio output
* buffer should be empty or almost. Thus draining should be fast
* and will not block the caller too long. */
aout_OutputFlush (aout, true);
aout_OutputUnlock (aout);
return empty;
}
/**
* Creates an audio output
*/
int aout_DecNew( audio_output_t *p_aout,
const audio_sample_format_t *p_format,
const audio_replay_gain_t *p_replay_gain,
const aout_request_vout_t *p_request_vout )
{
/* Sanitize audio format */
unsigned i_channels = aout_FormatNbChannels( p_format );
if( i_channels != p_format->i_channels && AOUT_FMT_LINEAR( p_format ) )
{
msg_Err( p_aout, "incompatible audio channels count with layout mask" );
return -1;
}
if( p_format->i_rate > 352800 )
{
msg_Err( p_aout, "excessive audio sample frequency (%u)",
p_format->i_rate );
return -1;
}
if( p_format->i_rate < 4000 )
{
msg_Err( p_aout, "too low audio sample frequency (%u)",
p_format->i_rate );
return -1;
}
var_Create (p_aout, "stereo-mode", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
vlc_value_t txt;
txt.psz_string = _("Stereo audio mode");
var_Change (p_aout, "stereo-mode", VLC_VAR_SETTEXT, &txt, NULL);
aout_owner_t *owner = aout_owner(p_aout);
/* TODO: reduce lock scope depending on decoder's real need */
aout_OutputLock (p_aout);
/* Create the audio output stream */
owner->volume = aout_volume_New (p_aout, p_replay_gain);
atomic_store (&owner->restart, 0);
owner->input_format = *p_format;
owner->mixer_format = owner->input_format;
owner->request_vout = *p_request_vout;
if (aout_OutputNew (p_aout, &owner->mixer_format))
goto error;
aout_volume_SetFormat (owner->volume, owner->mixer_format.i_format);
/* Create the audio filtering "input" pipeline */
owner->filters = aout_FiltersNew (p_aout, p_format, &owner->mixer_format,
&owner->request_vout);
if (owner->filters == NULL)
{
aout_OutputDelete (p_aout);
error:
aout_volume_Delete (owner->volume);
owner->volume = NULL;
aout_OutputUnlock (p_aout);
var_Destroy (p_aout, "stereo-mode");
return -1;
}
owner->sync.end = VLC_TS_INVALID;
owner->sync.resamp_type = AOUT_RESAMPLING_NONE;
owner->sync.discontinuity = true;
aout_OutputUnlock (p_aout);
atomic_init (&owner->buffers_lost, 0);
atomic_init (&owner->buffers_played, 0);
return 0;
}
/**
* Creates an audio output
*/
int aout_DecNew( audio_output_t *p_aout,
const audio_sample_format_t *p_format,
const audio_replay_gain_t *p_replay_gain,
const aout_request_vout_t *p_request_vout )
{
/* Sanitize audio format */
if( p_format->i_channels != aout_FormatNbChannels( p_format ) )
{
msg_Err( p_aout, "incompatible audio channels count with layout mask" );
return -1;
}
if( p_format->i_rate > 352800 )
{
msg_Err( p_aout, "excessive audio sample frequency (%u)",
p_format->i_rate );
return -1;
}
if( p_format->i_rate < 4000 )
{
msg_Err( p_aout, "too low audio sample frequency (%u)",
p_format->i_rate );
return -1;
}
aout_owner_t *owner = aout_owner(p_aout);
/* TODO: reduce lock scope depending on decoder's real need */
aout_OutputLock (p_aout);
var_Destroy( p_aout, "stereo-mode" );
/* Create the audio output stream */
owner->volume = aout_volume_New (p_aout, p_replay_gain);
atomic_store (&owner->restart, (atomic_uchar)0); // sunqueen modify
owner->input_format = *p_format;
owner->mixer_format = owner->input_format;
owner->request_vout = *p_request_vout;
if (aout_OutputNew (p_aout, &owner->mixer_format))
goto error;
aout_volume_SetFormat (owner->volume, owner->mixer_format.i_format);
/* Create the audio filtering "input" pipeline */
owner->filters = aout_FiltersNew (p_aout, p_format, &owner->mixer_format,
&owner->request_vout);
if (owner->filters == NULL)
{
aout_OutputDelete (p_aout);
error:
aout_volume_Delete (owner->volume);
aout_OutputUnlock (p_aout);
return -1;
}
owner->sync.end = VLC_TS_INVALID;
owner->sync.resamp_type = AOUT_RESAMPLING_NONE;
owner->sync.discontinuity = true;
aout_OutputUnlock (p_aout);
atomic_init (&owner->buffers_lost, 0);
return 0;
}
