/** FIXME This is quite ugly but needed while we don't have counters
* helpers */
-#include "input/input_internal.h"
+//#include "input/input_internal.h"
-#include "modules/modules.h"
+#include <libvlc.h>
+#include <vlc_input.h>
#include "vout_pictures.h"
#include "vout_internal.h"
/* Display media title in OSD */
static void DisplayTitleOnOSD( vout_thread_t *p_vout );
-/* */
-static void DropPicture( vout_thread_t *p_vout, picture_t *p_picture );
+/* Time during which the thread will sleep if it has nothing to
+ * display (in micro-seconds) */
+#define VOUT_IDLE_SLEEP ((int)(0.020*CLOCK_FREQ))
+
+/* Maximum lap of time allowed between the beginning of rendering and
+ * display. If, compared to the current date, the next image is too
+ * late, the thread will perform an idle loop. This time should be
+ * at least VOUT_IDLE_SLEEP plus the time required to render a few
+ * images, to avoid trashing of decoded images */
+#define VOUT_DISPLAY_DELAY ((int)(0.200*CLOCK_FREQ))
+
+/* Better be in advance when awakening than late... */
+#define VOUT_MWAIT_TOLERANCE ((mtime_t)(0.020*CLOCK_FREQ))
/*****************************************************************************
* Video Filter2 functions
{
vout_thread_t *p_vout = (vout_thread_t*)p_filter->p_owner;
- DropPicture( p_vout, p_pic );
+ vlc_mutex_lock( &p_vout->picture_lock );
+ vout_UsePictureLocked( p_vout, p_pic );
+ vlc_mutex_unlock( &p_vout->picture_lock );
}
static int video_filter_buffer_allocation_init( filter_t *p_filter, void *p_data )
vout_thread_t * __vout_Create( vlc_object_t *p_parent, video_format_t *p_fmt )
{
vout_thread_t * p_vout; /* thread descriptor */
- input_thread_t * p_input_thread;
int i_index; /* loop variable */
vlc_value_t val, text;
return NULL;
/* */
- p_vout->p = calloc( 1, sizeof(p_vout->p) );
+ p_vout->p = calloc( 1, sizeof(*p_vout->p) );
if( !p_vout->p )
{
vlc_object_release( p_vout );
p_vout->i_alignment = 0;
p_vout->p->render_time = 10;
p_vout->p->c_fps_samples = 0;
+ p_vout->p->i_picture_lost = 0;
+ p_vout->p->i_picture_displayed = 0;
p_vout->p->b_filter_change = 0;
+ p_vout->p->b_paused = false;
+ p_vout->p->i_pause_date = 0;
p_vout->pf_control = NULL;
p_vout->p_window = NULL;
p_vout->p->i_par_num =
p_vout->p->i_par_den = 1;
+ p_vout->p->p_picture_displayed = NULL;
+ p_vout->p->i_picture_displayed_date = 0;
+ p_vout->p->b_picture_displayed = false;
+ p_vout->p->b_picture_empty = false;
/* Initialize locks */
vlc_mutex_init( &p_vout->picture_lock );
+ vlc_cond_init( &p_vout->p->picture_wait );
vlc_mutex_init( &p_vout->change_lock );
vlc_mutex_init( &p_vout->p->vfilter_lock );
if( p_vout->p_module == NULL )
{
msg_Err( p_vout, "no suitable vout module" );
- // FIXME it's ugly but that's exactly the function that need to be called.
- EndThread( p_vout );
- vlc_object_detach( p_vout );
+ vlc_object_set_destructor( p_vout, vout_Destructor );
vlc_object_release( p_vout );
return NULL;
}
var_Change( p_vout, "vout-filter", VLC_VAR_SETTEXT, &text, NULL );
var_AddCallback( p_vout, "vout-filter", FilterCallback, NULL );
- /* Calculate delay created by internal caching */
- p_input_thread = (input_thread_t *)vlc_object_find( p_vout,
- VLC_OBJECT_INPUT, FIND_ANYWHERE );
- if( p_input_thread )
- {
- p_vout->p->i_pts_delay = p_input_thread->i_pts_delay;
- vlc_object_release( p_input_thread );
- }
- else
- {
- p_vout->p->i_pts_delay = DEFAULT_PTS_DELAY;
- }
-
if( vlc_thread_create( p_vout, "video output", RunThread,
VLC_THREAD_PRIORITY_OUTPUT, true ) )
{
module_unneed( p_vout, p_vout->p_module );
+ p_vout->p_module = NULL;
+ vlc_object_set_destructor( p_vout, vout_Destructor );
vlc_object_release( p_vout );
return NULL;
}
/* Make sure the vout was stopped first */
assert( !p_vout->p_module );
+ /* */
+ spu_Destroy( p_vout->p_spu );
+
/* Destroy the locks */
+ vlc_cond_destroy( &p_vout->p->picture_wait );
vlc_mutex_destroy( &p_vout->picture_lock );
vlc_mutex_destroy( &p_vout->change_lock );
vlc_mutex_destroy( &p_vout->p->vfilter_lock );
#endif
}
+/* */
+void vout_ChangePause( vout_thread_t *p_vout, bool b_paused, mtime_t i_date )
+{
+ vlc_object_lock( p_vout );
+
+ assert( !p_vout->p->b_paused || !b_paused );
+
+ vlc_mutex_lock( &p_vout->picture_lock );
+
+ p_vout->p->i_picture_displayed_date = 0;
+
+ if( p_vout->p->b_paused )
+ {
+ const mtime_t i_duration = i_date - p_vout->p->i_pause_date;
+
+ for( int i_index = 0; i_index < I_RENDERPICTURES; i_index++ )
+ {
+ picture_t *p_pic = PP_RENDERPICTURE[i_index];
+
+ if( p_pic->i_status == READY_PICTURE )
+ p_pic->date += i_duration;
+ }
+ vlc_cond_signal( &p_vout->p->picture_wait );
+ vlc_mutex_unlock( &p_vout->picture_lock );
+
+ spu_OffsetSubtitleDate( p_vout->p_spu, i_duration );
+ }
+ else
+ {
+ vlc_mutex_unlock( &p_vout->picture_lock );
+ }
+ p_vout->p->b_paused = b_paused;
+ p_vout->p->i_pause_date = i_date;
+
+ vlc_object_unlock( p_vout );
+}
+void vout_GetResetStatistic( vout_thread_t *p_vout, int *pi_displayed, int *pi_lost )
+{
+ vlc_object_lock( p_vout );
+
+ *pi_displayed = p_vout->p->i_picture_displayed;
+ *pi_lost = p_vout->p->i_picture_lost;
+
+ p_vout->p->i_picture_displayed = 0;
+ p_vout->p->i_picture_lost = 0;
+
+ vlc_object_unlock( p_vout );
+}
+void vout_Flush( vout_thread_t *p_vout, mtime_t i_date )
+{
+ vlc_mutex_lock( &p_vout->picture_lock );
+ p_vout->p->i_picture_displayed_date = 0;
+ for( int i = 0; i < p_vout->render.i_pictures; i++ )
+ {
+ picture_t *p_pic = p_vout->render.pp_picture[i];
+
+ if( p_pic->i_status == READY_PICTURE ||
+ p_pic->i_status == DISPLAYED_PICTURE )
+ {
+ /* We cannot change picture status if it is in READY_PICTURE state,
+ * Just make sure they won't be displayed */
+ if( p_pic->date > i_date )
+ p_pic->date = i_date;
+ }
+ }
+ vlc_cond_signal( &p_vout->p->picture_wait );
+ vlc_mutex_unlock( &p_vout->picture_lock );
+}
+void vout_FixLeaks( vout_thread_t *p_vout, bool b_forced )
+{
+ int i_pic, i_ready_pic;
+
+ vlc_mutex_lock( &p_vout->picture_lock );
+
+ for( i_pic = 0, i_ready_pic = 0; i_pic < p_vout->render.i_pictures && !b_forced; i_pic++ )
+ {
+ const picture_t *p_pic = p_vout->render.pp_picture[i_pic];
+
+ if( p_pic->i_status == READY_PICTURE )
+ {
+ i_ready_pic++;
+ /* If we have at least 2 ready pictures, wait for the vout thread to
+ * process one */
+ if( i_ready_pic >= 2 )
+ break;
+
+ continue;
+ }
+
+ if( p_pic->i_status == DISPLAYED_PICTURE )
+ {
+ /* If at least one displayed picture is not referenced
+ * let vout free it */
+ if( p_pic->i_refcount == 0 )
+ break;
+ }
+ }
+ if( i_pic < p_vout->render.i_pictures && !b_forced )
+ {
+ vlc_mutex_unlock( &p_vout->picture_lock );
+ return;
+ }
+
+ /* Too many pictures are still referenced, there is probably a bug
+ * with the decoder */
+ if( !b_forced )
+ msg_Err( p_vout, "pictures leaked, resetting the heap" );
+
+ /* Just free all the pictures */
+ for( i_pic = 0; i_pic < p_vout->render.i_pictures; i_pic++ )
+ {
+ picture_t *p_pic = p_vout->render.pp_picture[i_pic];
+
+ msg_Dbg( p_vout, "[%d] %d %d", i_pic, p_pic->i_status, p_pic->i_refcount );
+ p_pic->i_refcount = 0;
+ vout_UsePictureLocked( p_vout, p_pic );
+ }
+ vlc_cond_signal( &p_vout->p->picture_wait );
+ vlc_mutex_unlock( &p_vout->picture_lock );
+}
+void vout_NextPicture( vout_thread_t *p_vout, mtime_t *pi_duration )
+{
+ vlc_mutex_lock( &p_vout->picture_lock );
+
+ const mtime_t i_displayed_date = p_vout->p->i_picture_displayed_date;
+
+ p_vout->p->b_picture_displayed = false;
+ p_vout->p->b_picture_empty = false;
+ if( p_vout->p->p_picture_displayed )
+ {
+ p_vout->p->p_picture_displayed->date = 1;
+ vlc_cond_signal( &p_vout->p->picture_wait );
+ }
+
+ while( !p_vout->p->b_picture_displayed && !p_vout->p->b_picture_empty )
+ vlc_cond_wait( &p_vout->p->picture_wait, &p_vout->picture_lock );
+
+ *pi_duration = __MAX( p_vout->p->i_picture_displayed_date - i_displayed_date, 0 );
+
+ /* TODO advance subpicture by the duration ... */
+
+ vlc_mutex_unlock( &p_vout->picture_lock );
+}
+
/*****************************************************************************
* InitThread: initialize video output thread
*****************************************************************************
{
int i, i_aspect_x, i_aspect_y;
-#ifdef STATS
- p_vout->c_loops = 0;
-#endif
-
/* Initialize output method, it allocates direct buffers for us */
if( p_vout->pf_init( p_vout ) )
return VLC_EGENERIC;
+ p_vout->p->p_picture_displayed = NULL;
+
if( !I_OUTPUTPICTURES )
{
msg_Err( p_vout, "plugin was unable to allocate at least "
vout_thread_t *p_vout = (vout_thread_t *)p_this;
int i_idle_loops = 0; /* loops without displaying a picture */
- picture_t * p_last_picture = NULL; /* last picture */
-
- subpicture_t * p_subpic = NULL; /* subpicture pointer */
-
bool b_drop_late;
- int i_displayed = 0, i_lost = 0;
- int canc = vlc_savecancel ();
+ int canc = vlc_savecancel();
/*
* Initialize thread
{
EndThread( p_vout );
vlc_mutex_unlock( &p_vout->change_lock );
- vlc_restorecancel (canc);
+ vlc_restorecancel( canc );
return NULL;
}
{
/* Initialize loop variables */
const mtime_t current_date = mdate();
- picture_t *p_picture = NULL;
+ picture_t *p_picture;
picture_t *p_filtered_picture;
- mtime_t display_date = 0;
+ mtime_t display_date;
picture_t *p_directbuffer;
- input_thread_t *p_input;
int i_index;
-#if 0
- p_vout->c_loops++;
- if( !(p_vout->c_loops % VOUT_STATS_NB_LOOPS) )
- {
- msg_Dbg( p_vout, "picture heap: %d/%d",
- I_RENDERPICTURES, p_vout->i_heap_size );
- }
-#endif
+ vlc_mutex_lock( &p_vout->picture_lock );
- /* Update statistics */
- p_input = vlc_object_find( p_vout, VLC_OBJECT_INPUT, FIND_PARENT );
- if( p_input )
- {
- vlc_mutex_lock( &p_input->p->counters.counters_lock );
- stats_UpdateInteger( p_vout, p_input->p->counters.p_lost_pictures,
- i_lost , NULL);
- stats_UpdateInteger( p_vout,
- p_input->p->counters.p_displayed_pictures,
- i_displayed , NULL);
- i_displayed = i_lost = 0;
- vlc_mutex_unlock( &p_input->p->counters.counters_lock );
- vlc_object_release( p_input );
- }
+ /* Look for the earliest picture but after the last displayed one */
+ picture_t *p_last = p_vout->p->p_picture_displayed;;
- /*
- * Find the picture to display (the one with the earliest date).
- * This operation does not need lock, since only READY_PICTUREs
- * are handled. */
+ p_picture = NULL;
for( i_index = 0; i_index < I_RENDERPICTURES; i_index++ )
{
picture_t *p_pic = PP_RENDERPICTURE[i_index];
- if( p_pic->i_status == READY_PICTURE &&
- ( p_picture == NULL || p_pic->date < display_date ) )
+ if( p_pic->i_status != READY_PICTURE )
+ continue;
+
+ if( p_vout->p->b_paused && p_last && p_last->date > 1 )
+ continue;
+
+ if( p_last && p_pic != p_last && p_pic->date <= p_last->date )
{
- p_picture = p_pic;
- display_date = p_picture->date;
+ /* Drop old picture */
+ vout_UsePictureLocked( p_vout, p_pic );
}
- }
-
- if( p_picture )
- {
- /* If we met the last picture, parse again to see whether there is
- * a more appropriate one. */
- if( p_picture == p_last_picture )
+ else if( !p_vout->p->b_paused && !p_pic->b_force && p_pic != p_last &&
+ p_pic->date < current_date + p_vout->p->render_time &&
+ b_drop_late )
{
- for( i_index = 0; i_index < I_RENDERPICTURES; i_index++ )
- {
- picture_t *p_pic = PP_RENDERPICTURE[i_index];
+ /* Picture is late: it will be destroyed and the thread
+ * will directly choose the next picture */
+ vout_UsePictureLocked( p_vout, p_pic );
+ p_vout->p->i_picture_lost++;
- if( p_pic->i_status == READY_PICTURE &&
- p_pic != p_last_picture &&
- ( p_picture == p_last_picture || p_pic->date < display_date ) )
- {
- p_picture = p_pic;
- display_date = p_picture->date;
- }
- }
+ msg_Warn( p_vout, "late picture skipped (%"PRId64")",
+ current_date - p_pic->date );
}
-
- /* If we found better than the last picture, destroy it */
- if( p_last_picture && p_picture != p_last_picture )
+ else if( ( !p_last || p_last->date < p_pic->date ) &&
+ ( p_picture == NULL || p_pic->date < p_picture->date ) )
{
- DropPicture( p_vout, p_last_picture );
- p_last_picture = NULL;
+ p_picture = p_pic;
}
+ }
+ if( !p_picture )
+ {
+ p_picture = p_last;
- /* Compute FPS rate */
- p_vout->p->p_fps_sample[ p_vout->p->c_fps_samples++ % VOUT_FPS_SAMPLES ]
- = display_date;
-
- if( !p_picture->b_force &&
- p_picture != p_last_picture &&
- display_date < current_date + p_vout->p->render_time &&
- b_drop_late )
+ if( !p_vout->p->b_picture_empty )
{
- /* Picture is late: it will be destroyed and the thread
- * will directly choose the next picture */
- DropPicture( p_vout, p_picture );
- i_lost++;
- msg_Warn( p_vout, "late picture skipped (%"PRId64")",
- current_date - display_date );
- continue;
+ p_vout->p->b_picture_empty = true;
+ vlc_cond_signal( &p_vout->p->picture_wait );
}
+ }
+
+ display_date = 0;
+ if( p_picture )
+ {
+ display_date = p_picture->date;
- if( display_date >
- current_date + p_vout->p->i_pts_delay + VOUT_BOGUS_DELAY )
+ /* If we found better than the last picture, destroy it */
+ if( p_last && p_picture != p_last )
{
- /* Picture is waaay too early: it will be destroyed */
- DropPicture( p_vout, p_picture );
- i_lost++;
- msg_Warn( p_vout, "vout warning: early picture skipped "
- "(%"PRId64")", display_date - current_date
- - p_vout->p->i_pts_delay );
- continue;
+ vout_UsePictureLocked( p_vout, p_last );
+ p_vout->p->p_picture_displayed = p_last = NULL;
}
- if( display_date > current_date + VOUT_DISPLAY_DELAY )
+ /* Compute FPS rate */
+ p_vout->p->p_fps_sample[ p_vout->p->c_fps_samples++ % VOUT_FPS_SAMPLES ] = display_date;
+
+ if( display_date > current_date + VOUT_DISPLAY_DELAY && !p_vout->p->b_paused )
{
/* A picture is ready to be rendered, but its rendering date
* is far from the current one so the thread will perform an
p_picture = NULL;
display_date = 0;
}
- else if( p_picture == p_last_picture )
+ else if( p_picture == p_last )
{
/* We are asked to repeat the previous picture, but we first
* wait for a couple of idle loops */
display_date = current_date + p_vout->p->render_time;
}
}
+ if( p_picture )
+ {
+ if( p_picture->date > 1 )
+ {
+ p_vout->p->i_picture_displayed_date = p_picture->date;
+ if( p_picture != p_last && !p_vout->p->b_picture_displayed )
+ {
+ p_vout->p->b_picture_displayed = true;
+ vlc_cond_signal( &p_vout->p->picture_wait );
+ }
+ }
+ p_vout->p->p_picture_displayed = p_picture;
+ }
}
+ vlc_mutex_unlock( &p_vout->picture_lock );
if( p_picture == NULL )
i_idle_loops++;
/*
* Check for subpictures to display
*/
- bool b_paused = false;
+ subpicture_t *p_subpic = NULL;
if( display_date > 0 )
- {
- p_input = vlc_object_find( p_vout, VLC_OBJECT_INPUT, FIND_PARENT );
- b_paused = p_input && var_GetInteger( p_input, "state" ) == PAUSE_S;
- if( p_input )
- vlc_object_release( p_input );
-
- p_subpic = spu_SortSubpictures( p_vout->p_spu, display_date, b_paused, b_snapshot );
- }
+ p_subpic = spu_SortSubpictures( p_vout->p_spu, display_date,
+ p_vout->p->b_paused, b_snapshot );
/*
* Perform rendering
*/
- i_displayed++;
- p_directbuffer = vout_RenderPicture( p_vout, p_filtered_picture, p_subpic, b_paused );
+ p_vout->p->i_picture_displayed++;
+ p_directbuffer = vout_RenderPicture( p_vout, p_filtered_picture,
+ p_subpic, p_vout->p->b_paused );
/*
* Take a snapshot if requested
/* Sleep a while or until a given date */
if( display_date != 0 )
{
- /* If there are filters in the chain, better give them the picture
+ /* If there are *vout* filters in the chain, better give them the picture
* in advance */
if( !p_vout->p->psz_filter_chain || !*p_vout->p->psz_filter_chain )
{
}
else
{
- msleep( VOUT_IDLE_SLEEP );
+ /* Wait until a frame is being sent or a supurious wakeup (not a problem here) */
+ vlc_mutex_lock( &p_vout->picture_lock );
+ vlc_cond_timedwait( &p_vout->p->picture_wait, &p_vout->picture_lock, current_date + VOUT_IDLE_SLEEP );
+ vlc_mutex_unlock( &p_vout->picture_lock );
}
/* On awakening, take back lock and send immediately picture
/* Tell the vout this was the last picture and that it does not
* need to be forced anymore. */
- p_last_picture = p_picture;
- p_last_picture->b_force = false;
+ p_picture->b_force = false;
}
/* Drop the filtered picture if created by video filters */
if( p_filtered_picture != NULL && p_filtered_picture != p_picture )
- DropPicture( p_vout, p_filtered_picture );
+ {
+ vlc_mutex_lock( &p_vout->picture_lock );
+ vout_UsePictureLocked( p_vout, p_filtered_picture );
+ vlc_mutex_unlock( &p_vout->picture_lock );
+ }
if( p_picture != NULL )
{
p_vout->pf_end( p_vout );
+ p_vout->p->p_picture_displayed = NULL;
for( i = 0; i < I_OUTPUTPICTURES; i++ )
p_vout->p_picture[ i ].i_status = FREE_PICTURE;
+ vlc_cond_signal( &p_vout->p->picture_wait );
I_OUTPUTPICTURES = 0;
if( p_vout->b_error )
msg_Err( p_vout, "InitThread after VOUT_PICTURE_BUFFERS_CHANGE failed\n" );
+ vlc_cond_signal( &p_vout->p->picture_wait );
vlc_mutex_unlock( &p_vout->picture_lock );
if( p_vout->b_error )
vlc_mutex_unlock( &p_vout->change_lock );
vlc_object_unlock( p_vout );
- vlc_restorecancel (canc);
+ vlc_restorecancel( canc );
return NULL;
}
/* Destroy subpicture unit */
spu_Attach( p_vout->p_spu, VLC_OBJECT(p_vout), false );
- spu_Destroy( p_vout->p_spu );
/* Destroy the video filters2 */
filter_chain_Delete( p_vout->p->p_vf2_chain );
p_vout->p->p_chroma = NULL;
}
-static void DropPicture( vout_thread_t *p_vout, picture_t *p_picture )
-{
- vlc_mutex_lock( &p_vout->picture_lock );
- if( p_picture->i_refcount )
- {
- /* Pretend we displayed the picture, but don't destroy
- * it since the decoder might still need it. */
- p_picture->i_status = DISPLAYED_PICTURE;
- }
- else
- {
- /* Destroy the picture without displaying it */
- p_picture->i_status = DESTROYED_PICTURE;
- p_vout->i_heap_size--;
- picture_CleanupQuant( p_picture );
- }
- vlc_mutex_unlock( &p_vout->picture_lock );
-}
-
-
-
/* following functions are local */
-
static int ReduceHeight( int i_ratio )
{
int i_dummy = VOUT_ASPECT_FACTOR;
{
psz_filter = realloc( psz_filter, strlen( psz_filter ) +
sizeof(":deinterlace") );
- if( psz_filter && *psz_filter ) strcat( psz_filter, ":" );
- strcat( psz_filter, "deinterlace" );
+ if( psz_filter )
+ {
+ if( *psz_filter )
+ strcat( psz_filter, ":" );
+ strcat( psz_filter, "deinterlace" );
+ }
}
p_input = (input_thread_t *)vlc_object_find( p_this, VLC_OBJECT_INPUT,
FIND_PARENT );
- if( !p_input ) return VLC_EGENERIC;
+ if( !p_input )
+ {
+ free( psz_filter );
+ return VLC_EGENERIC;
+ }
if( psz_mode && *psz_mode )
{
projects / vlc / blobdiff