#include <vlc_vout.h>
#include <vlc_filter.h>
-#include <vlc_osd.h>
+#include <vlc_vout_osd.h>
#include <libvlc.h>
-#include <vlc_input.h>
-#include "vout_pictures.h"
#include "vout_internal.h"
#include "interlacing.h"
#include "postprocessing.h"
+#include "display.h"
/*****************************************************************************
* Local prototypes
*****************************************************************************/
-static void *Thread(void *);
-static void vout_Destructor(vlc_object_t *);
-
-/* Object variables callbacks */
-static int FilterCallback( vlc_object_t *, char const *,
- vlc_value_t, vlc_value_t, void * );
-static int VideoFilter2Callback( vlc_object_t *, char const *,
- vlc_value_t, vlc_value_t, void * );
-
-/* Display media title in OSD */
-static void DisplayTitleOnOSD( vout_thread_t *p_vout );
-
-/* */
-static void PrintVideoFormat(vout_thread_t *, const char *, const video_format_t *);
+static void *Thread(void *);
+static void VoutDestructor(vlc_object_t *);
/* Maximum delay between 2 displayed pictures.
* XXX it is needed for now but should be removed in the long term.
/* Better be in advance when awakening than late... */
#define VOUT_MWAIT_TOLERANCE (INT64_C(1000))
-/*****************************************************************************
- * Video Filter2 functions
- *****************************************************************************/
-static picture_t *video_new_buffer_filter( filter_t *p_filter )
-{
- vout_thread_t *p_vout = (vout_thread_t*)p_filter->p_owner;
- return picture_pool_Get(p_vout->p->private_pool);
-}
-
-static void video_del_buffer_filter( filter_t *p_filter, picture_t *p_pic )
+/* */
+static int VoutValidateFormat(video_format_t *dst,
+ const video_format_t *src)
{
- VLC_UNUSED(p_filter);
- picture_Release(p_pic);
-}
+ if (src->i_width <= 0 || src->i_height <= 0)
+ return VLC_EGENERIC;
+ if (src->i_sar_num <= 0 || src->i_sar_den <= 0)
+ return VLC_EGENERIC;
-static int video_filter_buffer_allocation_init( filter_t *p_filter, void *p_data )
-{
- p_filter->pf_video_buffer_new = video_new_buffer_filter;
- p_filter->pf_video_buffer_del = video_del_buffer_filter;
- p_filter->p_owner = p_data; /* p_vout */
+ /* */
+ video_format_Copy(dst, src);
+ dst->i_chroma = vlc_fourcc_GetCodec(VIDEO_ES, src->i_chroma);
+ vlc_ureduce( &dst->i_sar_num, &dst->i_sar_den,
+ src->i_sar_num, src->i_sar_den, 50000 );
+ if (dst->i_sar_num <= 0 || dst->i_sar_den <= 0) {
+ dst->i_sar_num = 1;
+ dst->i_sar_den = 1;
+ }
+ video_format_FixRgb(dst);
return VLC_SUCCESS;
}
/* If we now have a video output, check it has the right properties */
if( p_vout )
{
- vlc_mutex_lock( &p_vout->p->change_lock );
-
- /* We don't directly check for the "vout-filter" variable for obvious
- * performance reasons. */
- if( p_vout->p->b_filter_change )
+ if( !video_format_IsSimilar( &p_vout->p->original, p_fmt ) )
{
- char *psz_filter_chain = var_GetString( p_vout, "vout-filter" );
-
- if( psz_filter_chain && !*psz_filter_chain )
- {
- free( psz_filter_chain );
- psz_filter_chain = NULL;
- }
- if( p_vout->p->psz_filter_chain && !*p_vout->p->psz_filter_chain )
- {
- free( p_vout->p->psz_filter_chain );
- p_vout->p->psz_filter_chain = NULL;
- }
-
- if( !psz_filter_chain && !p_vout->p->psz_filter_chain )
- {
- p_vout->p->b_filter_change = false;
- }
-
- free( psz_filter_chain );
- }
-
-#warning "FIXME: Check RGB masks in vout_Request"
- /* FIXME: check RGB masks */
- if( p_vout->fmt_render.i_chroma != vlc_fourcc_GetCodec( VIDEO_ES, p_fmt->i_chroma ) ||
- p_vout->fmt_render.i_width != p_fmt->i_width ||
- p_vout->fmt_render.i_height != p_fmt->i_height ||
- p_vout->p->b_filter_change )
- {
- vlc_mutex_unlock( &p_vout->p->change_lock );
-
/* We are not interested in this format, close this vout */
vout_CloseAndRelease( p_vout );
vlc_object_release( p_vout );
else
{
/* This video output is cool! Hijack it. */
- /* Correct aspect ratio on change
- * FIXME factorize this code with other aspect ration related code */
- unsigned int i_sar_num;
- unsigned int i_sar_den;
- vlc_ureduce( &i_sar_num, &i_sar_den,
- p_fmt->i_sar_num, p_fmt->i_sar_den, 50000 );
-#if 0
- /* What's that, it does not seems to be used correcly everywhere */
- if( p_vout->i_par_num > 0 && p_vout->i_par_den > 0 )
- {
- i_sar_num *= p_vout->i_par_den;
- i_sar_den *= p_vout->i_par_num;
- }
-#endif
-
- if( i_sar_num > 0 && i_sar_den > 0 &&
- ( i_sar_num != p_vout->fmt_render.i_sar_num ||
- i_sar_den != p_vout->fmt_render.i_sar_den ) )
- {
- p_vout->fmt_in.i_sar_num = i_sar_num;
- p_vout->fmt_in.i_sar_den = i_sar_den;
-
- p_vout->fmt_render.i_sar_num = i_sar_num;
- p_vout->fmt_render.i_sar_den = i_sar_den;
- p_vout->p->i_changes |= VOUT_ASPECT_CHANGE;
- }
- vlc_mutex_unlock( &p_vout->p->change_lock );
-
vlc_object_release( p_vout );
}
*****************************************************************************/
vout_thread_t * (vout_Create)( vlc_object_t *p_parent, video_format_t *p_fmt )
{
- vout_thread_t *p_vout; /* thread descriptor */
- vlc_value_t text;
-
-
- config_chain_t *p_cfg;
- char *psz_parser;
- char *psz_name;
-
- if( p_fmt->i_width <= 0 || p_fmt->i_height <= 0 )
- return NULL;
- const vlc_fourcc_t i_chroma = vlc_fourcc_GetCodec( VIDEO_ES, p_fmt->i_chroma );
-
- vlc_ureduce( &p_fmt->i_sar_num, &p_fmt->i_sar_den,
- p_fmt->i_sar_num, p_fmt->i_sar_den, 50000 );
- if( p_fmt->i_sar_num <= 0 || p_fmt->i_sar_den <= 0 )
+ video_format_t original;
+ if (VoutValidateFormat(&original, p_fmt))
return NULL;
/* Allocate descriptor */
- static const char typename[] = "video output";
- p_vout = vlc_custom_create( p_parent, sizeof( *p_vout ), VLC_OBJECT_VOUT,
- typename );
- if( p_vout == NULL )
- return NULL;
-
- /* */
- p_vout->p = calloc( 1, sizeof(*p_vout->p) );
- if( !p_vout->p )
- {
- vlc_object_release( p_vout );
+ vout_thread_t *p_vout = vlc_custom_create(p_parent,
+ sizeof(*p_vout) + sizeof(*p_vout->p),
+ VLC_OBJECT_VOUT, "video output");
+ if (!p_vout) {
+ video_format_Clean(&original);
return NULL;
}
/* */
- p_vout->fmt_render = *p_fmt; /* FIXME palette */
- p_vout->fmt_in = *p_fmt; /* FIXME palette */
-
- p_vout->fmt_render.i_chroma =
- p_vout->fmt_in.i_chroma = i_chroma;
- video_format_FixRgb( &p_vout->fmt_render );
- video_format_FixRgb( &p_vout->fmt_in );
-
- /* Initialize misc stuff */
- p_vout->p->i_changes = 0;
- p_vout->p->b_fullscreen = 0;
- vout_chrono_Init( &p_vout->p->render, 5, 10000 ); /* Arbitrary initial time */
- vout_statistic_Init( &p_vout->p->statistic );
- p_vout->p->b_filter_change = 0;
- p_vout->p->i_par_num =
- p_vout->p->i_par_den = 1;
- p_vout->p->b_picture_empty = false;
- p_vout->p->displayed.date = VLC_TS_INVALID;
- p_vout->p->displayed.decoded = NULL;
- p_vout->p->displayed.timestamp = VLC_TS_INVALID;
- p_vout->p->displayed.qtype = QTYPE_NONE;
- p_vout->p->displayed.is_interlaced = false;
+ p_vout->p = (vout_thread_sys_t*)&p_vout[1];
- p_vout->p->step.is_requested = false;
- p_vout->p->step.last = VLC_TS_INVALID;
- p_vout->p->step.timestamp = VLC_TS_INVALID;
+ p_vout->p->original = original;
- p_vout->p->pause.is_on = false;
- p_vout->p->pause.date = VLC_TS_INVALID;
+ vout_control_Init( &p_vout->p->control );
+ vout_control_PushVoid( &p_vout->p->control, VOUT_CONTROL_INIT );
- p_vout->p->decoder_fifo = picture_fifo_New();
- p_vout->p->decoder_pool = NULL;
-
- vlc_mouse_Init( &p_vout->p->mouse );
+ vout_statistic_Init( &p_vout->p->statistic );
+ p_vout->p->i_par_num =
+ p_vout->p->i_par_den = 1;
vout_snapshot_Init( &p_vout->p->snapshot );
/* Initialize locks */
vlc_mutex_init( &p_vout->p->picture_lock );
- vlc_cond_init( &p_vout->p->picture_wait );
- vlc_mutex_init( &p_vout->p->change_lock );
vlc_mutex_init( &p_vout->p->vfilter_lock );
- /* Mouse coordinates */
- var_Create( p_vout, "mouse-button-down", VLC_VAR_INTEGER );
- var_Create( p_vout, "mouse-moved", VLC_VAR_COORDS );
- var_Create( p_vout, "mouse-clicked", VLC_VAR_COORDS );
- /* Mouse object (area of interest in a video filter) */
- var_Create( p_vout, "mouse-object", VLC_VAR_BOOL );
-
/* Attach the new object now so we can use var inheritance below */
vlc_object_attach( p_vout, p_parent );
/* */
spu_Init( p_vout->p->p_spu );
- spu_Attach( p_vout->p->p_spu, VLC_OBJECT(p_vout), true );
-
- p_vout->p->is_late_dropped = var_InheritBool( p_vout, "drop-late-frames" );
-
/* Take care of some "interface/control" related initialisations */
vout_IntfInit( p_vout );
- /* Look for the default filter configuration */
- p_vout->p->psz_filter_chain =
- var_CreateGetStringCommand( p_vout, "vout-filter" );
-
- /* Apply video filter2 objects on the first vout */
- p_vout->p->psz_vf2 =
- var_CreateGetStringCommand( p_vout, "video-filter" );
-
- var_AddCallback( p_vout, "video-filter", VideoFilter2Callback, NULL );
- p_vout->p->p_vf2_chain = filter_chain_New( p_vout, "video filter2",
- false, video_filter_buffer_allocation_init, NULL, p_vout );
-
- /* Choose the video output module */
- if( !p_vout->p->psz_filter_chain || !*p_vout->p->psz_filter_chain )
- {
- psz_parser = NULL;
- }
- else
- {
- psz_parser = strdup( p_vout->p->psz_filter_chain );
- p_vout->p->title.show = false;
+ /* Get splitter name if present */
+ char *splitter_name = var_GetNonEmptyString(p_vout, "vout-filter");
+ if (splitter_name) {
+ if (asprintf(&p_vout->p->splitter_name, "%s,none", splitter_name) < 0)
+ p_vout->p->splitter_name = NULL;
+ free(splitter_name);
+ } else {
+ p_vout->p->splitter_name = NULL;
}
- /* Create the vout thread */
- char *psz_tmp = config_ChainCreate( &psz_name, &p_cfg, psz_parser );
- free( psz_parser );
- free( psz_tmp );
- p_vout->p->p_cfg = p_cfg;
-
- /* Create a few object variables for interface interaction */
- var_Create( p_vout, "vout-filter", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
- text.psz_string = _("Filters");
- var_Change( p_vout, "vout-filter", VLC_VAR_SETTEXT, &text, NULL );
- var_AddCallback( p_vout, "vout-filter", FilterCallback, NULL );
-
/* */
vout_InitInterlacingSupport( p_vout, p_vout->p->displayed.is_interlaced );
- if( p_vout->p->psz_filter_chain && *p_vout->p->psz_filter_chain )
- {
- char *psz_tmp;
- if( asprintf( &psz_tmp, "%s,none", psz_name ) < 0 )
- psz_tmp = strdup( "" );
- free( psz_name );
- psz_name = psz_tmp;
- }
- p_vout->p->psz_module_name = psz_name;
-
/* */
- vlc_object_set_destructor( p_vout, vout_Destructor );
+ vlc_object_set_destructor( p_vout, VoutDestructor );
/* */
- vlc_cond_init( &p_vout->p->change_wait );
if( vlc_clone( &p_vout->p->thread, Thread, p_vout,
VLC_THREAD_PRIORITY_OUTPUT ) )
{
- spu_Attach( p_vout->p->p_spu, VLC_OBJECT(p_vout), false );
- spu_Destroy( p_vout->p->p_spu );
- p_vout->p->p_spu = NULL;
vlc_object_release( p_vout );
return NULL;
}
+ spu_Attach( p_vout->p->p_spu, VLC_OBJECT(p_vout), true );
- vlc_mutex_lock( &p_vout->p->change_lock );
- while( !p_vout->p->b_ready )
- { /* We are (ab)using the same condition in opposite directions for
- * b_ready and b_done. This works because of the strict ordering. */
- assert( !p_vout->p->b_done );
- vlc_cond_wait( &p_vout->p->change_wait, &p_vout->p->change_lock );
- }
- vlc_mutex_unlock( &p_vout->p->change_lock );
+ vout_control_WaitEmpty( &p_vout->p->control );
- if( p_vout->p->b_error )
+ if (p_vout->p->dead )
{
msg_Err( p_vout, "video output creation failed" );
vout_CloseAndRelease( p_vout );
{
assert( p_vout );
- vlc_mutex_lock( &p_vout->p->change_lock );
- p_vout->p->b_done = true;
- vlc_cond_signal( &p_vout->p->change_wait );
- vlc_mutex_unlock( &p_vout->p->change_lock );
+ spu_Attach( p_vout->p->p_spu, VLC_OBJECT(p_vout), false );
vout_snapshot_End( &p_vout->p->snapshot );
+ vout_control_PushVoid( &p_vout->p->control, VOUT_CONTROL_CLEAN );
vlc_join( p_vout->p->thread, NULL );
}
/* */
-static void vout_Destructor( vlc_object_t * p_this )
+static void VoutDestructor( vlc_object_t * p_this )
{
vout_thread_t *p_vout = (vout_thread_t *)p_this;
/* Make sure the vout was stopped first */
//assert( !p_vout->p_module );
- free( p_vout->p->psz_module_name );
+ free( p_vout->p->splitter_name );
/* */
- if( p_vout->p->p_spu )
- spu_Destroy( p_vout->p->p_spu );
-
- vout_chrono_Clean( &p_vout->p->render );
-
- if( p_vout->p->decoder_fifo )
- picture_fifo_Delete( p_vout->p->decoder_fifo );
- assert( !p_vout->p->decoder_pool );
+ spu_Destroy( p_vout->p->p_spu );
/* Destroy the locks */
- vlc_cond_destroy( &p_vout->p->change_wait );
- vlc_cond_destroy( &p_vout->p->picture_wait );
vlc_mutex_destroy( &p_vout->p->picture_lock );
- vlc_mutex_destroy( &p_vout->p->change_lock );
vlc_mutex_destroy( &p_vout->p->vfilter_lock );
+ vout_control_Clean( &p_vout->p->control );
/* */
vout_statistic_Clean( &p_vout->p->statistic );
/* */
vout_snapshot_Clean( &p_vout->p->snapshot );
- /* */
- free( p_vout->p->psz_filter_chain );
- free( p_vout->p->title.value );
-
- config_ChainDestroy( p_vout->p->p_cfg );
-
- free( p_vout->p );
-
+ video_format_Clean( &p_vout->p->original );
}
/* */
-void vout_ChangePause( vout_thread_t *p_vout, bool b_paused, mtime_t i_date )
+void vout_ChangePause(vout_thread_t *vout, bool is_paused, mtime_t date)
{
- vlc_mutex_lock( &p_vout->p->change_lock );
-
- assert( !p_vout->p->pause.is_on || !b_paused );
-
- vlc_mutex_lock( &p_vout->p->picture_lock );
+ vout_control_cmd_t cmd;
+ vout_control_cmd_Init(&cmd, VOUT_CONTROL_PAUSE);
+ cmd.u.pause.is_on = is_paused;
+ cmd.u.pause.date = date;
+ vout_control_Push(&vout->p->control, &cmd);
- if( p_vout->p->pause.is_on )
- {
- const mtime_t i_duration = i_date - p_vout->p->pause.date;
-
- if (p_vout->p->step.timestamp > VLC_TS_INVALID)
- p_vout->p->step.timestamp += i_duration;
- if (!b_paused)
- p_vout->p->step.last = p_vout->p->step.timestamp;
- picture_fifo_OffsetDate( p_vout->p->decoder_fifo, i_duration );
- if (p_vout->p->displayed.decoded)
- p_vout->p->displayed.decoded->date += i_duration;
-
- vlc_cond_signal( &p_vout->p->picture_wait );
- vlc_mutex_unlock( &p_vout->p->picture_lock );
-
- spu_OffsetSubtitleDate( p_vout->p->p_spu, i_duration );
- }
- else
- {
- if (b_paused)
- p_vout->p->step.last = p_vout->p->step.timestamp;
- vlc_mutex_unlock( &p_vout->p->picture_lock );
- }
- p_vout->p->pause.is_on = b_paused;
- p_vout->p->pause.date = i_date;
-
- vlc_mutex_unlock( &p_vout->p->change_lock );
+ vout_control_WaitEmpty(&vout->p->control);
}
void vout_GetResetStatistic( vout_thread_t *p_vout, int *pi_displayed, int *pi_lost )
pi_displayed, pi_lost );
}
-static void Flush(vout_thread_t *vout, mtime_t date, bool reset, bool below)
+void vout_Flush(vout_thread_t *vout, mtime_t date)
{
- vlc_assert_locked(&vout->p->picture_lock);
- vout->p->step.timestamp = VLC_TS_INVALID;
- vout->p->step.last = VLC_TS_INVALID;
-
- picture_t *last = vout->p->displayed.decoded;
- if (last) {
- if (reset) {
- picture_Release(last);
- vout->p->displayed.decoded = NULL;
- } else if (( below && last->date <= date) ||
- (!below && last->date >= date)) {
- vout->p->step.is_requested = true;
- }
- }
- picture_fifo_Flush( vout->p->decoder_fifo, date, below );
+ vout_control_PushTime(&vout->p->control, VOUT_CONTROL_FLUSH, date);
+ vout_control_WaitEmpty(&vout->p->control);
}
-void vout_Flush(vout_thread_t *vout, mtime_t date)
+void vout_Reset(vout_thread_t *vout)
{
- vlc_mutex_lock(&vout->p->picture_lock);
-
- Flush(vout, date, false, false);
-
- vlc_cond_signal(&vout->p->picture_wait);
- vlc_mutex_unlock(&vout->p->picture_lock);
+ vout_control_PushVoid(&vout->p->control, VOUT_CONTROL_RESET);
+ vout_control_WaitEmpty(&vout->p->control);
}
-void vout_Reset(vout_thread_t *vout)
+bool vout_IsEmpty(vout_thread_t *vout)
{
vlc_mutex_lock(&vout->p->picture_lock);
- Flush(vout, INT64_MAX, true, true);
- if (vout->p->decoder_pool)
- picture_pool_NonEmpty(vout->p->decoder_pool, true);
- vout->p->pause.is_on = false;
- vout->p->pause.date = mdate();
+ picture_t *picture = picture_fifo_Peek(vout->p->decoder_fifo);
+ if (picture)
+ picture_Release(picture);
- vlc_cond_signal( &vout->p->picture_wait );
vlc_mutex_unlock(&vout->p->picture_lock);
+
+ return !picture;
}
void vout_FixLeaks( vout_thread_t *vout )
/* */
picture_pool_NonEmpty(vout->p->decoder_pool, false);
- vlc_cond_signal(&vout->p->picture_wait);
vlc_mutex_unlock(&vout->p->picture_lock);
}
void vout_NextPicture(vout_thread_t *vout, mtime_t *duration)
{
- vlc_mutex_lock(&vout->p->picture_lock);
-
- vout->p->b_picture_empty = false;
- vout->p->step.is_requested = true;
-
- /* FIXME I highly doubt that it can works with only one cond_t FIXME */
- vlc_cond_signal(&vout->p->picture_wait);
-
- while (vout->p->step.is_requested && !vout->p->b_picture_empty)
- vlc_cond_wait(&vout->p->picture_wait, &vout->p->picture_lock);
-
- if (vout->p->step.last > VLC_TS_INVALID &&
- vout->p->step.timestamp > vout->p->step.last) {
- *duration = vout->p->step.timestamp - vout->p->step.last;
- vout->p->step.last = vout->p->step.timestamp;
- } else {
- *duration = 0;
- }
+ vout_control_cmd_t cmd;
+ vout_control_cmd_Init(&cmd, VOUT_CONTROL_STEP);
+ cmd.u.time_ptr = duration;
- /* TODO advance subpicture by the duration ... */
- vlc_mutex_unlock(&vout->p->picture_lock);
+ vout_control_Push(&vout->p->control, &cmd);
+ vout_control_WaitEmpty(&vout->p->control);
}
-void vout_DisplayTitle( vout_thread_t *p_vout, const char *psz_title )
+void vout_DisplayTitle(vout_thread_t *vout, const char *title)
{
- assert( psz_title );
-
- if( !var_InheritBool( p_vout, "osd" ) )
- return;
+ assert(title);
+ vout_control_PushString(&vout->p->control, VOUT_CONTROL_OSD_TITLE, title);
+}
- vlc_mutex_lock( &p_vout->p->change_lock );
- free( p_vout->p->title.value );
- p_vout->p->title.value = strdup( psz_title );
- vlc_mutex_unlock( &p_vout->p->change_lock );
+void vout_PutSubpicture( vout_thread_t *vout, subpicture_t *subpic )
+{
+ spu_DisplaySubpicture(vout->p->p_spu, subpic);
+}
+int vout_RegisterSubpictureChannel( vout_thread_t *vout )
+{
+ return spu_RegisterChannel(vout->p->p_spu);
+}
+void vout_FlushSubpictureChannel( vout_thread_t *vout, int channel )
+{
+ spu_ClearChannel(vout->p->p_spu, channel);
}
spu_t *vout_GetSpu( vout_thread_t *p_vout )
return p_vout->p->p_spu;
}
-/*****************************************************************************
- * InitThread: initialize video output thread
- *****************************************************************************
- * This function is called from Thread and performs the second step of the
- * initialization. It returns 0 on success. Note that the thread's flag are not
- * modified inside this function.
- * XXX You have to enter it with change_lock taken.
- *****************************************************************************/
-static int ThreadInit(vout_thread_t *vout)
+/* vout_Control* are usable by anyone at anytime */
+void vout_ControlChangeFullscreen(vout_thread_t *vout, bool fullscreen)
{
- /* Initialize output method, it allocates direct buffers for us */
- if (vout_InitWrapper(vout))
- return VLC_EGENERIC;
- assert(vout->p->decoder_pool);
-
- vout->p->displayed.decoded = NULL;
-
- /* print some usefull debug info about different vout formats
- */
- PrintVideoFormat(vout, "pic render", &vout->fmt_render);
- PrintVideoFormat(vout, "pic in", &vout->fmt_in);
- PrintVideoFormat(vout, "pic out", &vout->fmt_out);
-
- assert(vout->fmt_out.i_width == vout->fmt_render.i_width &&
- vout->fmt_out.i_height == vout->fmt_render.i_height &&
- vout->fmt_out.i_chroma == vout->fmt_render.i_chroma);
- return VLC_SUCCESS;
+ vout_control_PushBool(&vout->p->control, VOUT_CONTROL_FULLSCREEN,
+ fullscreen);
+}
+void vout_ControlChangeOnTop(vout_thread_t *vout, bool is_on_top)
+{
+ vout_control_PushBool(&vout->p->control, VOUT_CONTROL_ON_TOP,
+ is_on_top);
+}
+void vout_ControlChangeDisplayFilled(vout_thread_t *vout, bool is_filled)
+{
+ vout_control_PushBool(&vout->p->control, VOUT_CONTROL_DISPLAY_FILLED,
+ is_filled);
+}
+void vout_ControlChangeZoom(vout_thread_t *vout, int num, int den)
+{
+ vout_control_PushPair(&vout->p->control, VOUT_CONTROL_ZOOM,
+ num, den);
+}
+void vout_ControlChangeSampleAspectRatio(vout_thread_t *vout,
+ unsigned num, unsigned den)
+{
+ vout_control_PushPair(&vout->p->control, VOUT_CONTROL_ASPECT_RATIO,
+ num, den);
+}
+void vout_ControlChangeCropRatio(vout_thread_t *vout,
+ unsigned num, unsigned den)
+{
+ vout_control_PushPair(&vout->p->control, VOUT_CONTROL_CROP_RATIO,
+ num, den);
+}
+void vout_ControlChangeCropWindow(vout_thread_t *vout,
+ int x, int y, int width, int height)
+{
+ vout_control_cmd_t cmd;
+ vout_control_cmd_Init(&cmd, VOUT_CONTROL_CROP_WINDOW);
+ cmd.u.window.x = x;
+ cmd.u.window.y = y;
+ cmd.u.window.width = width;
+ cmd.u.window.height = height;
+
+ vout_control_Push(&vout->p->control, &cmd);
+}
+void vout_ControlChangeCropBorder(vout_thread_t *vout,
+ int left, int top, int right, int bottom)
+{
+ vout_control_cmd_t cmd;
+ vout_control_cmd_Init(&cmd, VOUT_CONTROL_CROP_BORDER);
+ cmd.u.border.left = left;
+ cmd.u.border.top = top;
+ cmd.u.border.right = right;
+ cmd.u.border.bottom = bottom;
+
+ vout_control_Push(&vout->p->control, &cmd);
+}
+void vout_ControlChangeFilters(vout_thread_t *vout, const char *filters)
+{
+ vout_control_PushString(&vout->p->control, VOUT_CONTROL_CHANGE_FILTERS,
+ filters);
}
-/*****************************************************************************
- * CleanThread: clean up after InitThread
- *****************************************************************************
- * This function is called after a sucessful
- * initialization. It frees all resources allocated by InitThread.
- * XXX You have to enter it with change_lock taken.
- *****************************************************************************/
-static void ThreadClean(vout_thread_t *vout)
+/* */
+static picture_t *VoutVideoFilterNewPicture(filter_t *filter)
{
- /* Destroy translation tables */
- if (!vout->p->b_error) {
- picture_fifo_Flush(vout->p->decoder_fifo, INT64_MAX, false);
- vout_EndWrapper(vout);
- }
+ vout_thread_t *vout = (vout_thread_t*)filter->p_owner;
+ return picture_pool_Get(vout->p->private_pool);
+}
+static void VoutVideoFilterDelPicture(filter_t *filter, picture_t *picture)
+{
+ VLC_UNUSED(filter);
+ picture_Release(picture);
+}
+static int VoutVideoFilterAllocationSetup(filter_t *filter, void *data)
+{
+ filter->pf_video_buffer_new = VoutVideoFilterNewPicture;
+ filter->pf_video_buffer_del = VoutVideoFilterDelPicture;
+ filter->p_owner = data; /* vout */
+ return VLC_SUCCESS;
}
+/* */
static int ThreadDisplayPicture(vout_thread_t *vout,
bool now, mtime_t *deadline)
{
+ vout_display_t *vd = vout->p->display.vd;
int displayed_count = 0;
int lost_count = 0;
for (;;) {
const mtime_t date = mdate();
const bool is_paused = vout->p->pause.is_on;
- bool redisplay = is_paused && !now;
+ bool redisplay = is_paused && !now && vout->p->displayed.decoded;
bool is_forced;
/* FIXME/XXX we must redisplay the last decoded picture (because
picture_t *filtered = NULL;
if (decoded) {
vlc_mutex_lock(&vout->p->vfilter_lock);
- filtered = filter_chain_VideoFilter(vout->p->p_vf2_chain, decoded);
+ filtered = filter_chain_VideoFilter(vout->p->vfilter_chain, decoded);
//assert(filtered == decoded); // TODO implement
vlc_mutex_unlock(&vout->p->vfilter_lock);
if (!filtered)
(vout->p->decoder_pool != vout->p->display_pool || subpic)) {
picture_t *render;
if (vout->p->is_decoder_pool_slow)
- render = picture_NewFromFormat(&vout->fmt_out);
+ render = picture_NewFromFormat(&vd->source);
else if (vout->p->decoder_pool != vout->p->display_pool)
render = picture_pool_Get(vout->p->display_pool);
else
picture_Copy(render, filtered);
spu_RenderSubpictures(vout->p->p_spu,
- render, &vout->fmt_out,
- subpic, &vout->fmt_in, spu_render_time);
+ render, &vd->source,
+ subpic, &vd->source, spu_render_time);
}
if (vout->p->is_decoder_pool_slow) {
direct = picture_pool_Get(vout->p->display_pool);
* Take a snapshot if requested
*/
if (direct && do_snapshot)
- vout_snapshot_Set(&vout->p->snapshot, &vout->fmt_out, direct);
+ vout_snapshot_Set(&vout->p->snapshot, &vd->source, direct);
/* Render the direct buffer returned by vout_RenderPicture */
if (direct) {
return VLC_SUCCESS;
}
-/*****************************************************************************
- * Thread: video output thread
- *****************************************************************************
- * Video output thread. This function does only returns when the thread is
- * terminated. It handles the pictures arriving in the video heap and the
- * display device events.
- *****************************************************************************/
-static void *Thread(void *object)
+static void ThreadManage(vout_thread_t *vout,
+ mtime_t *deadline,
+ vout_interlacing_support_t *interlacing,
+ vout_postprocessing_support_t *postprocessing)
{
- vout_thread_t *vout = object;
- bool has_wrapper;
+ vlc_mutex_lock(&vout->p->picture_lock);
- /*
- * Initialize thread
- */
- has_wrapper = !vout_OpenWrapper(vout, vout->p->psz_module_name);
+ *deadline = VLC_TS_INVALID;
+ ThreadDisplayPicture(vout, false, deadline);
- vlc_mutex_lock(&vout->p->change_lock);
+ const int picture_qtype = vout->p->displayed.qtype;
+ const bool picture_interlaced = vout->p->displayed.is_interlaced;
- if (has_wrapper)
- vout->p->b_error = ThreadInit(vout);
- else
- vout->p->b_error = true;
+ vlc_mutex_unlock(&vout->p->picture_lock);
- /* signal the creation of the vout */
- vout->p->b_ready = true;
- vlc_cond_signal(&vout->p->change_wait);
+ /* Post processing */
+ vout_SetPostProcessingState(vout, postprocessing, picture_qtype);
- if (vout->p->b_error)
- goto exit_thread;
+ /* Deinterlacing */
+ vout_SetInterlacingState(vout, interlacing, picture_interlaced);
- /* */
- vout_interlacing_support_t interlacing = {
- .is_interlaced = false,
- .date = mdate(),
- };
- vout_postprocessing_support_t postprocessing = {
- .qtype = QTYPE_NONE,
- };
+ vout_ManageWrapper(vout);
+}
- /*
- * Main loop - it is not executed if an error occurred during
- * initialization
- */
- while (!vout->p->b_done && !vout->p->b_error) {
- /* */
- if(vout->p->title.show && vout->p->title.value)
- DisplayTitleOnOSD(vout);
+static void ThreadDisplayOsdTitle(vout_thread_t *vout, const char *string)
+{
+ if (!vout->p->title.show)
+ return;
- vlc_mutex_lock(&vout->p->picture_lock);
+ vout_OSDText(vout, SPU_DEFAULT_CHANNEL,
+ vout->p->title.position, INT64_C(1000) * vout->p->title.timeout,
+ string);
+}
- mtime_t deadline = VLC_TS_INVALID;
- bool has_displayed = !ThreadDisplayPicture(vout, vout->p->step.is_requested, &deadline);
+static void ThreadChangeFilters(vout_thread_t *vout, const char *filters)
+{
+ es_format_t fmt;
+ es_format_Init(&fmt, VIDEO_ES, vout->p->original.i_chroma);
+ fmt.video = vout->p->original;
- if (has_displayed) {
- vout->p->step.timestamp = vout->p->displayed.timestamp;
- if (vout->p->step.last <= VLC_TS_INVALID)
- vout->p->step.last = vout->p->step.timestamp;
- }
- if (vout->p->step.is_requested) {
- if (!has_displayed && !vout->p->b_picture_empty) {
- picture_t *peek = picture_fifo_Peek(vout->p->decoder_fifo);
- if (peek)
- picture_Release(peek);
- if (!peek) {
- vout->p->b_picture_empty = true;
- vlc_cond_signal(&vout->p->picture_wait);
- }
- }
- if (has_displayed) {
- vout->p->step.is_requested = false;
- vlc_cond_signal(&vout->p->picture_wait);
- }
- }
+ vlc_mutex_lock(&vout->p->vfilter_lock);
- const int picture_qtype = vout->p->displayed.qtype;
- const bool picture_interlaced = vout->p->displayed.is_interlaced;
+ filter_chain_Reset(vout->p->vfilter_chain, &fmt, &fmt);
+ if (filter_chain_AppendFromString(vout->p->vfilter_chain,
+ filters) < 0)
+ msg_Err(vout, "Video filter chain creation failed");
- vlc_mutex_unlock(&vout->p->picture_lock);
+ vlc_mutex_unlock(&vout->p->vfilter_lock);
+}
- if (vout_ManageWrapper(vout)) {
- /* A fatal error occurred, and the thread must terminate
- * immediately, without displaying anything - setting b_error to 1
- * causes the immediate end of the main while() loop. */
- // FIXME pf_end
- vout->p->b_error = true;
- break;
- }
+static void ThreadChangePause(vout_thread_t *vout, bool is_paused, mtime_t date)
+{
+ assert(!vout->p->pause.is_on || !is_paused);
- /* Post processing */
- vout_SetPostProcessingState(vout, &postprocessing, picture_qtype);
+ if (vout->p->pause.is_on) {
+ const mtime_t duration = date - vout->p->pause.date;
- /* Deinterlacing */
- vout_SetInterlacingState(vout, &interlacing, picture_interlaced);
+ if (vout->p->step.timestamp > VLC_TS_INVALID)
+ vout->p->step.timestamp += duration;
+ if (vout->p->step.last > VLC_TS_INVALID)
+ vout->p->step.last += duration;
+ picture_fifo_OffsetDate(vout->p->decoder_fifo, duration);
+ if (vout->p->displayed.decoded)
+ vout->p->displayed.decoded->date += duration;
- /* Check for "video filter2" changes */
- vlc_mutex_lock(&vout->p->vfilter_lock);
- if (vout->p->psz_vf2) {
- es_format_t fmt;
+ spu_OffsetSubtitleDate(vout->p->p_spu, duration);
+ } else {
+ vout->p->step.timestamp = VLC_TS_INVALID;
+ vout->p->step.last = VLC_TS_INVALID;
+ }
+ vout->p->pause.is_on = is_paused;
+ vout->p->pause.date = date;
+}
- es_format_Init(&fmt, VIDEO_ES, vout->fmt_render.i_chroma);
- fmt.video = vout->fmt_render;
- filter_chain_Reset(vout->p->p_vf2_chain, &fmt, &fmt);
+static void ThreadFlush(vout_thread_t *vout, bool below, mtime_t date)
+{
+ vout->p->step.timestamp = VLC_TS_INVALID;
+ vout->p->step.last = VLC_TS_INVALID;
- if (filter_chain_AppendFromString(vout->p->p_vf2_chain,
- vout->p->psz_vf2) < 0)
- msg_Err(vout, "Video filter chain creation failed");
+ picture_t *last = vout->p->displayed.decoded;
+ if (last) {
+ if (( below && last->date <= date) ||
+ (!below && last->date >= date)) {
+ picture_Release(last);
- free(vout->p->psz_vf2);
- vout->p->psz_vf2 = NULL;
+ vout->p->displayed.decoded = NULL;
+ vout->p->displayed.date = VLC_TS_INVALID;
+ vout->p->displayed.timestamp = VLC_TS_INVALID;
}
- vlc_mutex_unlock(&vout->p->vfilter_lock);
+ }
+ picture_fifo_Flush(vout->p->decoder_fifo, date, below);
+}
- vlc_mutex_unlock(&vout->p->change_lock);
+static void ThreadReset(vout_thread_t *vout)
+{
+ ThreadFlush(vout, true, INT64_MAX);
+ if (vout->p->decoder_pool)
+ picture_pool_NonEmpty(vout->p->decoder_pool, true);
+ vout->p->pause.is_on = false;
+ vout->p->pause.date = mdate();
+}
- if (deadline > VLC_TS_INVALID) {
- vlc_mutex_lock(&vout->p->picture_lock);
- vlc_cond_timedwait(&vout->p->picture_wait, &vout->p->picture_lock, deadline);
- vlc_mutex_unlock(&vout->p->picture_lock);
- }
+static void ThreadStep(vout_thread_t *vout, mtime_t *duration)
+{
+ *duration = 0;
+
+ if (vout->p->step.last <= VLC_TS_INVALID)
+ vout->p->step.last = vout->p->displayed.timestamp;
+
+ mtime_t dummy;
+ if (ThreadDisplayPicture(vout, true, &dummy))
+ return;
+
+ vout->p->step.timestamp = vout->p->displayed.timestamp;
- vlc_mutex_lock(&vout->p->change_lock);
+ if (vout->p->step.last > VLC_TS_INVALID &&
+ vout->p->step.timestamp > vout->p->step.last) {
+ *duration = vout->p->step.timestamp - vout->p->step.last;
+ vout->p->step.last = vout->p->step.timestamp;
+ /* TODO advance subpicture by the duration ... */
}
+}
- /*
- * Error loop - wait until the thread destruction is requested
- *
- * XXX I wonder if we should periodically clean the decoder_fifo
- * or have a way to prevent it filling up.
- */
- while (vout->p->b_error && !vout->p->b_done)
- vlc_cond_wait(&vout->p->change_wait, &vout->p->change_lock);
-
- /* Clean thread */
- ThreadClean(vout);
-
-exit_thread:
- /* Detach subpicture unit from both input and vout */
- spu_Attach(vout->p->p_spu, VLC_OBJECT(vout), false);
- vlc_object_detach(vout->p->p_spu);
+static void ThreadChangeFullscreen(vout_thread_t *vout, bool fullscreen)
+{
+ /* FIXME not sure setting "fullscreen" is good ... */
+ var_SetBool(vout, "fullscreen", fullscreen);
+ vout_SetDisplayFullscreen(vout->p->display.vd, fullscreen);
+}
- /* Destroy the video filters2 */
- filter_chain_Delete(vout->p->p_vf2_chain);
+static void ThreadChangeOnTop(vout_thread_t *vout, bool is_on_top)
+{
+ vout_SetWindowState(vout->p->display.vd,
+ is_on_top ? VOUT_WINDOW_STATE_ABOVE :
+ VOUT_WINDOW_STATE_NORMAL);
+}
- vlc_mutex_unlock(&vout->p->change_lock);
+static void ThreadChangeDisplayFilled(vout_thread_t *vout, bool is_filled)
+{
+ vout_SetDisplayFilled(vout->p->display.vd, is_filled);
+}
- if (has_wrapper)
- vout_CloseWrapper(vout);
+static void ThreadChangeZoom(vout_thread_t *vout, int num, int den)
+{
+ if (num * 10 < den) {
+ num = den;
+ den *= 10;
+ } else if (num > den * 10) {
+ num = den * 10;
+ }
- return NULL;
+ vout_SetDisplayZoom(vout->p->display.vd, num, den);
}
-/*****************************************************************************
- * object variables callbacks: a bunch of object variables are used by the
- * interfaces to interact with the vout.
- *****************************************************************************/
-static int FilterCallback( vlc_object_t *p_this, char const *psz_cmd,
- vlc_value_t oldval, vlc_value_t newval, void *p_data )
+static void ThreadChangeAspectRatio(vout_thread_t *vout,
+ unsigned num, unsigned den)
{
- vout_thread_t *p_vout = (vout_thread_t *)p_this;
- input_thread_t *p_input;
- (void)psz_cmd; (void)oldval; (void)p_data;
+ const video_format_t *source = &vout->p->original;
- p_input = (input_thread_t *)vlc_object_find( p_this, VLC_OBJECT_INPUT,
- FIND_PARENT );
- if (!p_input)
- {
- msg_Err( p_vout, "Input not found" );
- return VLC_EGENERIC;
+ if (num > 0 && den > 0) {
+ num *= source->i_visible_height;
+ den *= source->i_visible_width;
+ vlc_ureduce(&num, &den, num, den, 0);
}
+ vout_SetDisplayAspect(vout->p->display.vd, num, den);
+}
- var_SetBool( p_vout, "intf-change", true );
- /* Modify input as well because the vout might have to be restarted */
- var_Create( p_input, "vout-filter", VLC_VAR_STRING );
- var_SetString( p_input, "vout-filter", newval.psz_string );
+static void ThreadExecuteCropWindow(vout_thread_t *vout,
+ unsigned crop_num, unsigned crop_den,
+ unsigned x, unsigned y,
+ unsigned width, unsigned height)
+{
+ const video_format_t *source = &vout->p->original;
- /* Now restart current video stream */
- input_Control( p_input, INPUT_RESTART_ES, -VIDEO_ES );
- vlc_object_release( p_input );
+ vout_SetDisplayCrop(vout->p->display.vd,
+ crop_num, crop_den,
+ source->i_x_offset + x,
+ source->i_y_offset + y,
+ width, height);
+}
+static void ThreadExecuteCropBorder(vout_thread_t *vout,
+ unsigned left, unsigned top,
+ unsigned right, unsigned bottom)
+{
+ const video_format_t *source = &vout->p->original;
+ ThreadExecuteCropWindow(vout, 0, 0,
+ left,
+ top,
+ /* At worst, it becomes < 0 (but unsigned) and will be rejected */
+ source->i_visible_width - (left + right),
+ source->i_visible_height - (top + bottom));
+}
- return VLC_SUCCESS;
+static void ThreadExecuteCropRatio(vout_thread_t *vout,
+ unsigned num, unsigned den)
+{
+ const video_format_t *source = &vout->p->original;
+
+ int x, y;
+ int width, height;
+ if (num <= 0 || den <= 0) {
+ num = 0;
+ den = 0;
+ x = 0;
+ y = 0;
+ width = source->i_visible_width;
+ height = source->i_visible_height;
+ } else {
+ unsigned scaled_width = (uint64_t)source->i_visible_height * num * source->i_sar_den / den / source->i_sar_num;
+ unsigned scaled_height = (uint64_t)source->i_visible_width * den * source->i_sar_num / num / source->i_sar_den;
+
+ if (scaled_width < source->i_visible_width) {
+ x = (source->i_visible_width - scaled_width) / 2;
+ y = 0;
+ width = scaled_width;
+ height = source->i_visible_height;
+ } else {
+ x = 0;
+ y = (source->i_visible_height - scaled_height) / 2;
+ width = source->i_visible_width;
+ height = scaled_height;
+ }
+ }
+ ThreadExecuteCropWindow(vout, num, den, x, y, width, height);
}
-/*****************************************************************************
- * Video Filter2 stuff
- *****************************************************************************/
-static int VideoFilter2Callback( vlc_object_t *p_this, char const *psz_cmd,
- vlc_value_t oldval, vlc_value_t newval, void *p_data )
+static int ThreadInit(vout_thread_t *vout)
{
- vout_thread_t *p_vout = (vout_thread_t *)p_this;
- (void)psz_cmd; (void)oldval; (void)p_data;
+ vout->p->dead = false;
+ vout->p->is_late_dropped = var_InheritBool(vout, "drop-late-frames");
+ vlc_mouse_Init(&vout->p->mouse);
+ vout->p->decoder_fifo = picture_fifo_New();
+ vout->p->decoder_pool = NULL;
+ vout->p->display_pool = NULL;
+ vout->p->private_pool = NULL;
+
+ vout->p->vfilter_chain =
+ filter_chain_New( vout, "video filter2", false,
+ VoutVideoFilterAllocationSetup, NULL, vout);
+
+ if (vout_OpenWrapper(vout, vout->p->splitter_name))
+ return VLC_EGENERIC;
+ if (vout_InitWrapper(vout))
+ return VLC_EGENERIC;
+ assert(vout->p->decoder_pool);
+
+ vout_chrono_Init(&vout->p->render, 5, 10000); /* Arbitrary initial time */
+
+ vout->p->displayed.decoded = NULL;
+ vout->p->displayed.date = VLC_TS_INVALID;
+ vout->p->displayed.decoded = NULL;
+ vout->p->displayed.timestamp = VLC_TS_INVALID;
+ vout->p->displayed.qtype = QTYPE_NONE;
+ vout->p->displayed.is_interlaced = false;
- vlc_mutex_lock( &p_vout->p->vfilter_lock );
- p_vout->p->psz_vf2 = strdup( newval.psz_string );
- vlc_mutex_unlock( &p_vout->p->vfilter_lock );
+ vout->p->step.last = VLC_TS_INVALID;
+ vout->p->step.timestamp = VLC_TS_INVALID;
+ vout->p->pause.is_on = false;
+ vout->p->pause.date = VLC_TS_INVALID;
+
+ video_format_Print(VLC_OBJECT(vout), "original format", &vout->p->original);
return VLC_SUCCESS;
}
-static void DisplayTitleOnOSD( vout_thread_t *p_vout )
+static void ThreadClean(vout_thread_t *vout)
{
- const mtime_t i_start = mdate();
- const mtime_t i_stop = i_start + INT64_C(1000) * p_vout->p->title.timeout;
-
- if( i_stop <= i_start )
- return;
+ /* Destroy the video filters2 */
+ filter_chain_Delete(vout->p->vfilter_chain);
- vlc_assert_locked( &p_vout->p->change_lock );
+ /* Destroy translation tables */
+ if (vout->p->display.vd) {
+ if (vout->p->decoder_pool) {
+ ThreadFlush(vout, true, INT64_MAX);
+ vout_EndWrapper(vout);
+ }
+ vout_CloseWrapper(vout);
+ }
- vout_ShowTextAbsolute( p_vout, DEFAULT_CHAN,
- p_vout->p->title.value, NULL,
- p_vout->p->title.position,
- 30 + p_vout->fmt_in.i_width
- - p_vout->fmt_in.i_visible_width
- - p_vout->fmt_in.i_x_offset,
- 20 + p_vout->fmt_in.i_y_offset,
- i_start, i_stop );
+ /* Detach subpicture unit from vout */
+ vlc_object_detach(vout->p->p_spu);
- free( p_vout->p->title.value );
+ if (vout->p->decoder_fifo)
+ picture_fifo_Delete(vout->p->decoder_fifo);
+ assert(!vout->p->decoder_pool);
+ vout_chrono_Clean(&vout->p->render);
- p_vout->p->title.value = NULL;
+ vout->p->dead = true;
+ vout_control_Dead(&vout->p->control);
}
-/* */
-static void PrintVideoFormat(vout_thread_t *vout,
- const char *description,
- const video_format_t *fmt)
+/*****************************************************************************
+ * Thread: video output thread
+ *****************************************************************************
+ * Video output thread. This function does only returns when the thread is
+ * terminated. It handles the pictures arriving in the video heap and the
+ * display device events.
+ *****************************************************************************/
+static void *Thread(void *object)
{
- msg_Dbg(vout, "%s sz %ix%i, of (%i,%i), vsz %ix%i, 4cc %4.4s, sar %i:%i, msk r0x%x g0x%x b0x%x",
- description,
- fmt->i_width, fmt->i_height, fmt->i_x_offset, fmt->i_y_offset,
- fmt->i_visible_width, fmt->i_visible_height,
- (char*)&fmt->i_chroma,
- fmt->i_sar_num, fmt->i_sar_den,
- fmt->i_rmask, fmt->i_gmask, fmt->i_bmask);
+ vout_thread_t *vout = object;
+
+ vout_interlacing_support_t interlacing = {
+ .is_interlaced = false,
+ .date = mdate(),
+ };
+ vout_postprocessing_support_t postprocessing = {
+ .qtype = QTYPE_NONE,
+ };
+
+ mtime_t deadline = VLC_TS_INVALID;
+ for (;;) {
+ vout_control_cmd_t cmd;
+
+ /* FIXME remove thoses ugly timeouts
+ */
+ while (!vout_control_Pop(&vout->p->control, &cmd, deadline, 100000)) {
+ switch(cmd.type) {
+ case VOUT_CONTROL_INIT:
+ if (ThreadInit(vout)) {
+ ThreadClean(vout);
+ return NULL;
+ }
+ break;
+ case VOUT_CONTROL_CLEAN:
+ ThreadClean(vout);
+ return NULL;
+ case VOUT_CONTROL_OSD_TITLE:
+ ThreadDisplayOsdTitle(vout, cmd.u.string);
+ break;
+ case VOUT_CONTROL_CHANGE_FILTERS:
+ ThreadChangeFilters(vout, cmd.u.string);
+ break;
+ case VOUT_CONTROL_PAUSE:
+ ThreadChangePause(vout, cmd.u.pause.is_on, cmd.u.pause.date);
+ break;
+ case VOUT_CONTROL_FLUSH:
+ ThreadFlush(vout, false, cmd.u.time);
+ break;
+ case VOUT_CONTROL_RESET:
+ ThreadReset(vout);
+ break;
+ case VOUT_CONTROL_STEP:
+ ThreadStep(vout, cmd.u.time_ptr);
+ break;
+ case VOUT_CONTROL_FULLSCREEN:
+ ThreadChangeFullscreen(vout, cmd.u.boolean);
+ break;
+ case VOUT_CONTROL_ON_TOP:
+ ThreadChangeOnTop(vout, cmd.u.boolean);
+ break;
+ case VOUT_CONTROL_DISPLAY_FILLED:
+ ThreadChangeDisplayFilled(vout, cmd.u.boolean);
+ break;
+ case VOUT_CONTROL_ZOOM:
+ ThreadChangeZoom(vout, cmd.u.pair.a, cmd.u.pair.b);
+ break;
+ case VOUT_CONTROL_ASPECT_RATIO:
+ ThreadChangeAspectRatio(vout, cmd.u.pair.a, cmd.u.pair.b);
+ break;
+ case VOUT_CONTROL_CROP_RATIO:
+ ThreadExecuteCropRatio(vout, cmd.u.pair.a, cmd.u.pair.b);
+ break;
+ case VOUT_CONTROL_CROP_WINDOW:
+ ThreadExecuteCropWindow(vout, 0, 0,
+ cmd.u.window.x, cmd.u.window.y,
+ cmd.u.window.width, cmd.u.window.height);
+ break;
+ case VOUT_CONTROL_CROP_BORDER:
+ ThreadExecuteCropBorder(vout,
+ cmd.u.border.left, cmd.u.border.top,
+ cmd.u.border.right, cmd.u.border.bottom);
+ break;
+ default:
+ break;
+ }
+ vout_control_cmd_Clean(&cmd);
+ }
+
+ ThreadManage(vout, &deadline, &interlacing, &postprocessing);
+ }
}
projects / vlc / blobdiff