static int Del( sout_stream_t *p_stream, sout_stream_id_t *id )
{
sout_stream_sys_t *p_sys = p_stream->p_sys;
if( id->b_transcode )
{
switch( id->p_decoder->fmt_in.i_cat )
{
case AUDIO_ES:
Send( p_stream, id, NULL );
transcode_audio_close( id );
break;
case VIDEO_ES:
Send( p_stream, id, NULL );
transcode_video_close( p_stream, id );
break;
case SPU_ES:
if( p_sys->b_osd )
transcode_osd_close( p_stream, id );
else
transcode_spu_close( p_stream, id );
break;
}
}
if( id->id ) sout_StreamIdDel( p_stream->p_next, (sout_stream_id_t *)id->id ); // sunqueen modify
if( id->p_decoder )
{
vlc_object_release( id->p_decoder );
id->p_decoder = NULL;
}
if( id->p_encoder )
{
es_format_Clean( &id->p_encoder->fmt_out );
vlc_object_release( id->p_encoder );
id->p_encoder = NULL;
}
free( id );
return VLC_SUCCESS;
}
int transcode_video_process( sout_stream_t *p_stream, sout_stream_id_t *id,
block_t *in, block_t **out )
{
sout_stream_sys_t *p_sys = p_stream->p_sys;
bool b_need_duplicate = false;
picture_t *p_pic, *p_pic2 = NULL;
*out = NULL;
if( in == NULL )
{
if( p_sys->i_threads == 0 )
{
block_t *p_block;
do {
video_timer_start( id->p_encoder );
p_block = id->p_encoder->pf_encode_video(id->p_encoder, NULL );
video_timer_stop( id->p_encoder );
block_ChainAppend( out, p_block );
} while( p_block );
}
else
{
/*
* FIXME: we need EncoderThread() to flush buffers and signal us
* when it's done so we can send the last frames to the chain
*/
}
return VLC_SUCCESS;
}
while( (p_pic = id->p_decoder->pf_decode_video( id->p_decoder, &in )) )
{
if( p_stream->p_sout->i_out_pace_nocontrol && p_sys->b_hurry_up )
{
mtime_t current_date = mdate();
if( current_date + 50000 > p_pic->date )
{
msg_Dbg( p_stream, "late picture skipped (%"PRId64")",
current_date + 50000 - p_pic->date );
picture_Release( p_pic );
continue;
}
}
if( p_sys->b_master_sync )
{
mtime_t i_video_drift;
mtime_t i_master_drift = p_sys->i_master_drift;
mtime_t i_pts;
i_pts = date_Get( &id->interpolated_pts ) + 1;
if ( p_pic->date - i_pts > MASTER_SYNC_MAX_DRIFT
|| p_pic->date - i_pts < -MASTER_SYNC_MAX_DRIFT )
{
msg_Dbg( p_stream, "drift is too high, resetting master sync" );
date_Set( &id->interpolated_pts, p_pic->date );
i_pts = p_pic->date + 1;
}
i_video_drift = p_pic->date - i_pts;
b_need_duplicate = false;
/* Set the pts of the frame being encoded */
p_pic->date = i_pts;
if( i_video_drift < (i_master_drift - 50000) )
{
#if 0
msg_Dbg( p_stream, "dropping frame (%i)",
(int)(i_video_drift - i_master_drift) );
#endif
picture_Release( p_pic );
continue;
}
else if( i_video_drift > (i_master_drift + 50000) )
{
#if 0
msg_Dbg( p_stream, "adding frame (%i)",
(int)(i_video_drift - i_master_drift) );
#endif
b_need_duplicate = true;
}
}
if( unlikely( !id->p_encoder->p_module ) )
{
transcode_video_encoder_init( p_stream, id );
transcode_video_filter_init( p_stream, id );
if( transcode_video_encoder_open( p_stream, id ) != VLC_SUCCESS )
{
picture_Release( p_pic );
transcode_video_close( p_stream, id );
id->b_transcode = false;
return VLC_EGENERIC;
}
}
/* Run filter chain */
if( id->p_f_chain )
p_pic = filter_chain_VideoFilter( id->p_f_chain, p_pic );
/*
* Encoding
*/
/* Check if we have a subpicture to overlay */
if( p_sys->p_spu )
{
video_format_t fmt;
if( filter_chain_GetLength( id->p_f_chain ) > 0 )
fmt = filter_chain_GetFmtOut( id->p_f_chain )->video;
else
fmt = id->p_decoder->fmt_out.video;
subpicture_t *p_subpic = spu_Render( p_sys->p_spu, NULL, &fmt, &fmt,
p_pic->date, p_pic->date, false );
/* Overlay subpicture */
if( p_subpic )
{
if( picture_IsReferenced( p_pic ) && !filter_chain_GetLength( id->p_f_chain ) )
{
/* We can't modify the picture, we need to duplicate it */
picture_t *p_tmp = video_new_buffer_decoder( id->p_decoder );
if( p_tmp )
{
picture_Copy( p_tmp, p_pic );
picture_Release( p_pic );
p_pic = p_tmp;
}
}
if( !p_sys->p_spu_blend )
p_sys->p_spu_blend = filter_NewBlend( VLC_OBJECT( p_sys->p_spu ), &fmt );
if( p_sys->p_spu_blend )
picture_BlendSubpicture( p_pic, p_sys->p_spu_blend, p_subpic );
subpicture_Delete( p_subpic );
}
}
/* Run user specified filter chain */
if( id->p_uf_chain )
p_pic = filter_chain_VideoFilter( id->p_uf_chain, p_pic );
if( p_sys->i_threads == 0 )
{
block_t *p_block;
video_timer_start( id->p_encoder );
p_block = id->p_encoder->pf_encode_video( id->p_encoder, p_pic );
video_timer_stop( id->p_encoder );
block_ChainAppend( out, p_block );
}
if( p_sys->b_master_sync )
{
mtime_t i_pts = date_Get( &id->interpolated_pts ) + 1;
if ( p_pic->date - i_pts > MASTER_SYNC_MAX_DRIFT
|| p_pic->date - i_pts < -MASTER_SYNC_MAX_DRIFT )
{
msg_Dbg( p_stream, "drift is too high, resetting master sync" );
date_Set( &id->interpolated_pts, p_pic->date );
i_pts = p_pic->date + 1;
}
date_Increment( &id->interpolated_pts, 1 );
if( unlikely( b_need_duplicate ) )
{
if( p_sys->i_threads >= 1 )
{
/* We can't modify the picture, we need to duplicate it */
p_pic2 = video_new_buffer_decoder( id->p_decoder );
if( p_pic2 != NULL )
{
picture_Copy( p_pic2, p_pic );
p_pic2->date = i_pts;
}
}
else
{
block_t *p_block;
p_pic->date = i_pts;
video_timer_start( id->p_encoder );
p_block = id->p_encoder->pf_encode_video(id->p_encoder, p_pic);
video_timer_stop( id->p_encoder );
block_ChainAppend( out, p_block );
}
}
}
if( p_sys->i_threads == 0 )
{
picture_Release( p_pic );
}
else
{
vlc_mutex_lock( &p_sys->lock_out );
p_sys->pp_pics[p_sys->i_last_pic++] = p_pic;
p_sys->i_last_pic %= PICTURE_RING_SIZE;
*out = p_sys->p_buffers;
p_sys->p_buffers = NULL;
if( p_pic2 != NULL )
{
p_sys->pp_pics[p_sys->i_last_pic++] = p_pic2;
p_sys->i_last_pic %= PICTURE_RING_SIZE;
}
vlc_cond_signal( &p_sys->cond );
vlc_mutex_unlock( &p_sys->lock_out );
}
}
return VLC_SUCCESS;
}
int transcode_video_process( sout_stream_t *p_stream, sout_stream_id_t *id,
block_t *in, block_t **out )
{
sout_stream_sys_t *p_sys = p_stream->p_sys;
bool b_need_duplicate = false;
picture_t *p_pic;
*out = NULL;
if( unlikely( in == NULL ) )
{
if( p_sys->i_threads == 0 )
{
block_t *p_block;
do {
p_block = id->p_encoder->pf_encode_video(id->p_encoder, NULL );
block_ChainAppend( out, p_block );
} while( p_block );
}
else
{
/*
* FIXME: we need EncoderThread() to flush buffers and signal us
* when it's done so we can send the last frames to the chain
*/
}
return VLC_SUCCESS;
}
while( (p_pic = id->p_decoder->pf_decode_video( id->p_decoder, &in )) )
{
if( p_stream->p_sout->i_out_pace_nocontrol && p_sys->b_hurry_up )
{
mtime_t current_date = mdate();
if( unlikely( current_date + 50000 > p_pic->date ) )
{
msg_Dbg( p_stream, "late picture skipped (%"PRId64")",
current_date + 50000 - p_pic->date );
picture_Release( p_pic );
continue;
}
}
if( p_sys->b_master_sync )
{
mtime_t i_master_drift = p_sys->i_master_drift;
mtime_t i_pts = date_Get( &id->interpolated_pts ) + 1;
mtime_t i_video_drift = p_pic->date - i_pts;
if ( unlikely( i_video_drift > MASTER_SYNC_MAX_DRIFT
|| i_video_drift < -MASTER_SYNC_MAX_DRIFT ) )
{
msg_Dbg( p_stream,
"drift is too high (%"PRId64", resetting master sync",
i_video_drift );
date_Set( &id->interpolated_pts, p_pic->date );
i_pts = p_pic->date + 1;
}
i_video_drift = p_pic->date - i_pts;
b_need_duplicate = false;
/* Set the pts of the frame being encoded */
p_pic->date = i_pts;
if( unlikely( i_video_drift < (i_master_drift - 50000) ) )
{
#if 0
msg_Dbg( p_stream, "dropping frame (%i)",
(int)(i_video_drift - i_master_drift) );
#endif
picture_Release( p_pic );
continue;
}
else if( unlikely( i_video_drift > (i_master_drift + 50000) ) )
{
#if 0
msg_Dbg( p_stream, "adding frame (%i)",
(int)(i_video_drift - i_master_drift) );
#endif
b_need_duplicate = true;
}
}
if( unlikely (
id->p_encoder->p_module &&
!video_format_IsSimilar( &p_sys->fmt_input_video, &id->p_decoder->fmt_out.video )
)
)
{
msg_Info( p_stream, "aspect-ratio changed, reiniting. %i -> %i : %i -> %i.",
p_sys->fmt_input_video.i_sar_num, id->p_decoder->fmt_out.video.i_sar_num,
p_sys->fmt_input_video.i_sar_den, id->p_decoder->fmt_out.video.i_sar_den
);
/* Close filters */
if( id->p_f_chain )
filter_chain_Delete( id->p_f_chain );
id->p_f_chain = NULL;
if( id->p_uf_chain )
filter_chain_Delete( id->p_uf_chain );
id->p_uf_chain = NULL;
/* Reinitialize filters */
id->p_encoder->fmt_out.video.i_width = p_sys->i_width & ~1;
id->p_encoder->fmt_out.video.i_height = p_sys->i_height & ~1;
id->p_encoder->fmt_out.video.i_sar_num = id->p_encoder->fmt_out.video.i_sar_den = 0;
transcode_video_filter_init( p_stream, id );
transcode_video_encoder_init( p_stream, id );
conversion_video_filter_append( id );
memcpy( &p_sys->fmt_input_video, &id->p_decoder->fmt_out.video, sizeof(video_format_t));
}
if( unlikely( !id->p_encoder->p_module ) )
{
if( id->p_f_chain )
filter_chain_Delete( id->p_f_chain );
if( id->p_uf_chain )
filter_chain_Delete( id->p_uf_chain );
id->p_f_chain = id->p_uf_chain = NULL;
transcode_video_filter_init( p_stream, id );
transcode_video_encoder_init( p_stream, id );
conversion_video_filter_append( id );
memcpy( &p_sys->fmt_input_video, &id->p_decoder->fmt_out.video, sizeof(video_format_t));
if( transcode_video_encoder_open( p_stream, id ) != VLC_SUCCESS )
{
picture_Release( p_pic );
transcode_video_close( p_stream, id );
id->b_transcode = false;
return VLC_EGENERIC;
}
}
/* Run the filter and output chains; first with the picture,
* and then with NULL as many times as we need until they
* stop outputting frames.
*/
for ( ;; ) {
picture_t *p_filtered_pic = p_pic;
/* Run filter chain */
if( id->p_f_chain )
p_filtered_pic = filter_chain_VideoFilter( id->p_f_chain, p_filtered_pic );
if( !p_filtered_pic )
break;
for ( ;; ) {
picture_t *p_user_filtered_pic = p_filtered_pic;
/* Run user specified filter chain */
if( id->p_uf_chain )
p_user_filtered_pic = filter_chain_VideoFilter( id->p_uf_chain, p_user_filtered_pic );
if( !p_user_filtered_pic )
break;
OutputFrame( p_sys, p_user_filtered_pic, b_need_duplicate, p_stream, id, out );
b_need_duplicate = false;
p_filtered_pic = NULL;
}
p_pic = NULL;
}
}
if( p_sys->i_threads >= 1 )
{
/* Pick up any return data the encoder thread wants to output. */
vlc_mutex_lock( &p_sys->lock_out );
*out = p_sys->p_buffers;
p_sys->p_buffers = NULL;
vlc_mutex_unlock( &p_sys->lock_out );
}
return VLC_SUCCESS;
}
int transcode_video_process( sout_stream_t *p_stream, sout_stream_id_t *id,
block_t *in, block_t **out )
{
sout_stream_sys_t *p_sys = p_stream->p_sys;
picture_t *p_pic = NULL;
*out = NULL;
if( unlikely( in == NULL ) )
{
if( p_sys->i_threads == 0 )
{
block_t *p_block;
do {
p_block = id->p_encoder->pf_encode_video(id->p_encoder, NULL );
block_ChainAppend( out, p_block );
} while( p_block );
}
else
{
msg_Dbg( p_stream, "Flushing thread and waiting that");
vlc_mutex_lock( &p_stream->p_sys->lock_out );
p_stream->p_sys->b_abort = true;
vlc_cond_signal( &p_stream->p_sys->cond );
vlc_mutex_unlock( &p_stream->p_sys->lock_out );
vlc_join( p_stream->p_sys->thread, NULL );
vlc_mutex_lock( &p_sys->lock_out );
*out = p_sys->p_buffers;
p_sys->p_buffers = NULL;
vlc_mutex_unlock( &p_sys->lock_out );
msg_Dbg( p_stream, "Flushing done");
}
return VLC_SUCCESS;
}
while( (p_pic = id->p_decoder->pf_decode_video( id->p_decoder, &in )) )
{
if( p_stream->p_sout->i_out_pace_nocontrol && p_sys->b_hurry_up )
{
mtime_t current_date = mdate();
if( unlikely( (current_date - 50000) > p_pic->date ) )
{
msg_Dbg( p_stream, "late picture skipped (%"PRId64")",
current_date - 50000 - p_pic->date );
picture_Release( p_pic );
continue;
}
}
if( unlikely (
id->p_encoder->p_module &&
!video_format_IsSimilar( &p_sys->fmt_input_video, &id->p_decoder->fmt_out.video )
)
)
{
msg_Info( p_stream, "aspect-ratio changed, reiniting. %i -> %i : %i -> %i.",
p_sys->fmt_input_video.i_sar_num, id->p_decoder->fmt_out.video.i_sar_num,
p_sys->fmt_input_video.i_sar_den, id->p_decoder->fmt_out.video.i_sar_den
);
/* Close filters */
if( id->p_f_chain )
filter_chain_Delete( id->p_f_chain );
id->p_f_chain = NULL;
if( id->p_uf_chain )
filter_chain_Delete( id->p_uf_chain );
id->p_uf_chain = NULL;
/* Reinitialize filters */
id->p_encoder->fmt_out.video.i_visible_width = p_sys->i_width & ~1;
id->p_encoder->fmt_out.video.i_visible_height = p_sys->i_height & ~1;
id->p_encoder->fmt_out.video.i_sar_num = id->p_encoder->fmt_out.video.i_sar_den = 0;
transcode_video_filter_init( p_stream, id );
transcode_video_encoder_init( p_stream, id );
conversion_video_filter_append( id );
memcpy( &p_sys->fmt_input_video, &id->p_decoder->fmt_out.video, sizeof(video_format_t));
}
if( unlikely( !id->p_encoder->p_module ) )
{
if( id->p_f_chain )
filter_chain_Delete( id->p_f_chain );
if( id->p_uf_chain )
filter_chain_Delete( id->p_uf_chain );
id->p_f_chain = id->p_uf_chain = NULL;
transcode_video_filter_init( p_stream, id );
transcode_video_encoder_init( p_stream, id );
conversion_video_filter_append( id );
memcpy( &p_sys->fmt_input_video, &id->p_decoder->fmt_out.video, sizeof(video_format_t));
if( transcode_video_encoder_open( p_stream, id ) != VLC_SUCCESS )
{
picture_Release( p_pic );
transcode_video_close( p_stream, id );
id->b_transcode = false;
return VLC_EGENERIC;
}
}
/*Input lipsync and drop check */
if( p_sys->b_master_sync )
{
/* How much audio has drifted */
mtime_t i_master_drift = p_sys->i_master_drift;
/* This is the pts input should have now with constant frame rate */
mtime_t i_pts = date_Get( &id->interpolated_pts );
/* How much video pts is ahead of calculated pts */
mtime_t i_video_drift = p_pic->date - i_pts;
/* Check that we are having lipsync with input here */
if( unlikely ( ( (i_video_drift - i_master_drift ) > MASTER_SYNC_MAX_DRIFT
|| (i_video_drift + i_master_drift ) < -MASTER_SYNC_MAX_DRIFT ) ) )
{
msg_Warn( p_stream,
"video drift too big, resetting sync %"PRId64" to %"PRId64,
(i_video_drift + i_master_drift),
p_pic->date
);
date_Set( &id->interpolated_pts, p_pic->date );
date_Set( &id->next_output_pts, p_pic->date );
i_pts = date_Get( &id->interpolated_pts );
}
/* Set the pts of the frame being encoded */
p_pic->date = i_pts;
/* now take next input pts, pts dates are only enabled if p_module is set*/
date_Increment( &id->interpolated_pts, id->p_decoder->fmt_out.video.i_frame_rate_base );
/* If input pts + input_frame_interval is lower than next_output_pts - output_frame_interval
* Then the future input frame should fit better and we can drop this one
*
* Duplication need is checked in OutputFrame */
if( ( p_pic->date + (mtime_t)id->i_input_frame_interval ) <
( date_Get( &id->next_output_pts ) ) )
{
#if 0
msg_Dbg( p_stream, "dropping frame (%"PRId64" + %"PRId64" vs %"PRId64")",
p_pic->date, id->i_input_frame_interval, date_Get(&id->next_output_pts) );
#endif
picture_Release( p_pic );
continue;
}
#if 0
msg_Dbg( p_stream, "not dropping frame");
#endif
/* input calculated pts isn't necessary what pts output should be, so use output pts*/
p_pic->date = date_Get( &id->next_output_pts );
}
/* Run the filter and output chains; first with the picture,
* and then with NULL as many times as we need until they
* stop outputting frames.
*/
for ( ;; ) {
picture_t *p_filtered_pic = p_pic;
/* Run filter chain */
if( id->p_f_chain )
p_filtered_pic = filter_chain_VideoFilter( id->p_f_chain, p_filtered_pic );
if( !p_filtered_pic )
break;
for ( ;; ) {
picture_t *p_user_filtered_pic = p_filtered_pic;
/* Run user specified filter chain */
if( id->p_uf_chain )
p_user_filtered_pic = filter_chain_VideoFilter( id->p_uf_chain, p_user_filtered_pic );
if( !p_user_filtered_pic )
break;
OutputFrame( p_sys, p_user_filtered_pic, p_stream, id, out );
p_filtered_pic = NULL;
}
p_pic = NULL;
}
}
if( p_sys->i_threads >= 1 )
{
/* Pick up any return data the encoder thread wants to output. */
vlc_mutex_lock( &p_sys->lock_out );
*out = p_sys->p_buffers;
p_sys->p_buffers = NULL;
vlc_mutex_unlock( &p_sys->lock_out );
}
return VLC_SUCCESS;
}
int transcode_video_process( sout_stream_t *p_stream, sout_stream_id_sys_t *id,
block_t *in, block_t **out )
{
sout_stream_sys_t *p_sys = p_stream->p_sys;
picture_t *p_pic = NULL;
*out = NULL;
if( unlikely( in == NULL ) )
{
if( p_sys->i_threads == 0 )
{
block_t *p_block;
do {
p_block = id->p_encoder->pf_encode_video(id->p_encoder, NULL );
block_ChainAppend( out, p_block );
} while( p_block );
}
else
{
msg_Dbg( p_stream, "Flushing thread and waiting that");
vlc_mutex_lock( &p_stream->p_sys->lock_out );
p_stream->p_sys->b_abort = true;
vlc_cond_signal( &p_stream->p_sys->cond );
vlc_mutex_unlock( &p_stream->p_sys->lock_out );
vlc_join( p_stream->p_sys->thread, NULL );
vlc_mutex_lock( &p_sys->lock_out );
*out = p_sys->p_buffers;
p_sys->p_buffers = NULL;
vlc_mutex_unlock( &p_sys->lock_out );
msg_Dbg( p_stream, "Flushing done");
}
return VLC_SUCCESS;
}
while( (p_pic = id->p_decoder->pf_decode_video( id->p_decoder, &in )) )
{
if( unlikely (
id->p_encoder->p_module &&
!video_format_IsSimilar( &p_sys->fmt_input_video, &id->p_decoder->fmt_out.video )
)
)
{
msg_Info( p_stream, "aspect-ratio changed, reiniting. %i -> %i : %i -> %i.",
p_sys->fmt_input_video.i_sar_num, id->p_decoder->fmt_out.video.i_sar_num,
p_sys->fmt_input_video.i_sar_den, id->p_decoder->fmt_out.video.i_sar_den
);
/* Close filters */
if( id->p_f_chain )
filter_chain_Delete( id->p_f_chain );
id->p_f_chain = NULL;
if( id->p_uf_chain )
filter_chain_Delete( id->p_uf_chain );
id->p_uf_chain = NULL;
/* Reinitialize filters */
id->p_encoder->fmt_out.video.i_visible_width = p_sys->i_width & ~1;
id->p_encoder->fmt_out.video.i_visible_height = p_sys->i_height & ~1;
id->p_encoder->fmt_out.video.i_sar_num = id->p_encoder->fmt_out.video.i_sar_den = 0;
transcode_video_filter_init( p_stream, id );
transcode_video_encoder_init( p_stream, id );
conversion_video_filter_append( id );
memcpy( &p_sys->fmt_input_video, &id->p_decoder->fmt_out.video, sizeof(video_format_t));
}
if( unlikely( !id->p_encoder->p_module ) )
{
if( id->p_f_chain )
filter_chain_Delete( id->p_f_chain );
if( id->p_uf_chain )
filter_chain_Delete( id->p_uf_chain );
id->p_f_chain = id->p_uf_chain = NULL;
transcode_video_filter_init( p_stream, id );
transcode_video_encoder_init( p_stream, id );
conversion_video_filter_append( id );
memcpy( &p_sys->fmt_input_video, &id->p_decoder->fmt_out.video, sizeof(video_format_t));
if( transcode_video_encoder_open( p_stream, id ) != VLC_SUCCESS )
{
picture_Release( p_pic );
transcode_video_close( p_stream, id );
id->b_transcode = false;
return VLC_EGENERIC;
}
date_Set( &id->next_output_pts, p_pic->date );
}
/*Input lipsync and drop check */
if( p_sys->b_master_sync )
{
/* If input pts lower than next_output_pts - output_frame_interval
* Then the future input frame should fit better and we can drop this one
*
* We check this here as we don't need to run video filter at all for pictures
* we are going to drop anyway
*
* Duplication need is checked in OutputFrame */
if( ( p_pic->date ) <
( date_Get( &id->next_output_pts ) - (mtime_t)id->i_output_frame_interval ) )
{
#if 0
msg_Dbg( p_stream, "dropping frame (%"PRId64" + %"PRId64" vs %"PRId64")",
p_pic->date, id->i_input_frame_interval, date_Get(&id->next_output_pts) );
#endif
picture_Release( p_pic );
continue;
}
#if 0
msg_Dbg( p_stream, "not dropping frame");
#endif
}
/* Run the filter and output chains; first with the picture,
* and then with NULL as many times as we need until they
* stop outputting frames.
*/
for ( ;; ) {
picture_t *p_filtered_pic = p_pic;
/* Run filter chain */
if( id->p_f_chain )
p_filtered_pic = filter_chain_VideoFilter( id->p_f_chain, p_filtered_pic );
if( !p_filtered_pic )
break;
for ( ;; ) {
picture_t *p_user_filtered_pic = p_filtered_pic;
/* Run user specified filter chain */
if( id->p_uf_chain )
p_user_filtered_pic = filter_chain_VideoFilter( id->p_uf_chain, p_user_filtered_pic );
if( !p_user_filtered_pic )
break;
OutputFrame( p_stream, p_user_filtered_pic, id, out );
p_filtered_pic = NULL;
}
p_pic = NULL;
}
}
if( p_sys->i_threads >= 1 )
{
/* Pick up any return data the encoder thread wants to output. */
vlc_mutex_lock( &p_sys->lock_out );
*out = p_sys->p_buffers;
p_sys->p_buffers = NULL;
vlc_mutex_unlock( &p_sys->lock_out );
}
return VLC_SUCCESS;
}
