]> git.sesse.net Git - vlc/blobdiff - src/video_output/video_output.c
Gives the input_thread_t to use to vout_Request().
[vlc] / src / video_output / video_output.c
index cc706c6ae7dfafc8d307364362a01965fe201bb5..d827b41db8816593d6fbed133a6c463cdfc116fd 100644 (file)
@@ -46,7 +46,6 @@
 #include <vlc_vout_osd.h>
 
 #include <libvlc.h>
-#include <vlc_input.h>
 #include "vout_internal.h"
 #include "interlacing.h"
 #include "postprocessing.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 * );
-
-/* */
-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.
@@ -80,345 +70,196 @@ static void PrintVideoFormat(vout_thread_t *, const char *, const video_format_t
 /* 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 )
-{
-    VLC_UNUSED(p_filter);
-    picture_Release(p_pic);
-}
-
-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 */
-    return VLC_SUCCESS;
-}
-
-#undef vout_Request
-/*****************************************************************************
- * vout_Request: find a video output thread, create one, or destroy one.
- *****************************************************************************
- * This function looks for a video output thread matching the current
- * properties. If not found, it spawns a new one.
- *****************************************************************************/
-vout_thread_t *vout_Request( vlc_object_t *p_this, vout_thread_t *p_vout,
-                             video_format_t *p_fmt )
+/* */
+static int VoutValidateFormat(video_format_t *dst,
+                              const video_format_t *src)
 {
-    if( !p_fmt )
-    {
-        /* Video output is no longer used.
-         * TODO: support for reusing video outputs with proper _thread-safe_
-         * reference handling. */
-        if( p_vout )
-            vout_CloseAndRelease( p_vout );
-        return NULL;
-    }
-
-    /* If a video output was provided, lock it, otherwise look for one. */
-    if( p_vout )
-    {
-        vlc_object_hold( p_vout );
-    }
-
-    /* TODO: find a suitable unused video output */
-
-    /* If we now have a video output, check it has the right properties */
-    if( p_vout )
-    {
-        vlc_mutex_lock( &p_vout->p->change_lock );
-
-        if( !video_format_IsSimilar( &p_vout->p->original, p_fmt ) )
-        {
-            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 );
-            p_vout = NULL;
-        }
-        else
-        {
-            /* This video output is cool! Hijack it. */
-            vlc_mutex_unlock( &p_vout->p->change_lock );
-
-            vlc_object_release( p_vout );
-        }
-
-        if( p_vout )
-        {
-            msg_Dbg( p_this, "reusing provided vout" );
-
-            spu_Attach( p_vout->p->p_spu, VLC_OBJECT(p_vout), false );
-            vlc_object_detach( p_vout );
-
-            vlc_object_attach( p_vout, p_this );
-            spu_Attach( p_vout->p->p_spu, VLC_OBJECT(p_vout), true );
-        }
-    }
-
-    if( !p_vout )
-    {
-        msg_Dbg( p_this, "no usable vout present, spawning one" );
+    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;
 
-        p_vout = vout_Create( p_this, p_fmt );
+    /* */
+    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;
     }
-
-    return p_vout;
+    video_format_FixRgb(dst);
+    return VLC_SUCCESS;
 }
 
-/*****************************************************************************
- * vout_Create: creates a new video output thread
- *****************************************************************************
- * This function creates a new video output thread, and returns a pointer
- * to its description. On error, it returns NULL.
- *****************************************************************************/
-vout_thread_t * (vout_Create)( vlc_object_t *p_parent, video_format_t *p_fmt )
+static vout_thread_t *VoutCreate(vlc_object_t *object,
+                                 const vout_configuration_t *cfg)
 {
-    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, cfg->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 *vout = vlc_custom_create(object,
+                                            sizeof(*vout) + sizeof(*vout->p),
+                                            VLC_OBJECT_VOUT, "video output");
+    if (!vout) {
+        video_format_Clean(&original);
         return NULL;
     }
 
     /* */
-    p_vout->p->original = *p_fmt;   /* FIXME palette */
-    p_vout->p->original.i_chroma = i_chroma;
-    video_format_FixRgb( &p_vout->p->original );
-
-    /* Initialize misc stuff */
-    vout_control_Init( &p_vout->p->control );
-    vout_chrono_Init( &p_vout->p->render, 5, 10000 ); /* Arbitrary initial time */
-    vout_statistic_Init( &p_vout->p->statistic );
-    p_vout->p->i_par_num =
-    p_vout->p->i_par_den = 1;
-    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;
+    vout->p = (vout_thread_sys_t*)&vout[1];
 
-    p_vout->p->step.last         = VLC_TS_INVALID;
-    p_vout->p->step.timestamp    = VLC_TS_INVALID;
+    vout->p->original = original;
 
-    p_vout->p->pause.is_on  = false;
-    p_vout->p->pause.date   = VLC_TS_INVALID;
+    vout_control_Init(&vout->p->control);
+    vout_control_PushVoid(&vout->p->control, VOUT_CONTROL_INIT);
 
-    p_vout->p->decoder_fifo = picture_fifo_New();
-    p_vout->p->decoder_pool = NULL;
+    vout_statistic_Init(&vout->p->statistic);
+    vout->p->i_par_num =
+    vout->p->i_par_den = 1;
 
-    vlc_mouse_Init( &p_vout->p->mouse );
-
-    vout_snapshot_Init( &p_vout->p->snapshot );
-
-    p_vout->p->vfilter_chain =
-        filter_chain_New( p_vout, "video filter2", false,
-                          video_filter_buffer_allocation_init, NULL, p_vout );
+    vout_snapshot_Init(&vout->p->snapshot);
 
     /* Initialize locks */
-    vlc_mutex_init( &p_vout->p->picture_lock );
-    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 );
+    vlc_mutex_init(&vout->p->picture_lock);
+    vlc_mutex_init(&vout->p->vfilter_lock);
 
     /* Attach the new object now so we can use var inheritance below */
-    vlc_object_attach( p_vout, p_parent );
+    vlc_object_attach(vout, object);
 
     /* Initialize subpicture unit */
-    p_vout->p->p_spu = spu_Create( p_vout );
-
-    /* */
-    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" );
+    vout->p->p_spu = spu_Create(vout);
 
     /* 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 */
-    var_Create( p_vout, "video-filter",
-                VLC_VAR_STRING | VLC_VAR_DOINHERIT | VLC_VAR_ISCOMMAND );
-    var_AddCallback( p_vout, "video-filter", VideoFilter2Callback, NULL );
-    var_TriggerCallback( p_vout, "video-filter" );
-
-    /* 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;
+    vout_IntfInit(vout);
+
+    /* Get splitter name if present */
+    char *splitter_name = var_GetNonEmptyString(vout, "vout-filter");
+    if (splitter_name) {
+        if (asprintf(&vout->p->splitter_name, "%s,none", splitter_name) < 0)
+            vout->p->splitter_name = NULL;
+        free(splitter_name);
+    } else {
+        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;
+    vout_InitInterlacingSupport(vout, vout->p->displayed.is_interlaced);
 
     /* */
-    vlc_object_set_destructor( p_vout, vout_Destructor );
+    vlc_object_set_destructor(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 );
+    if (vlc_clone(&vout->p->thread, Thread, vout,
+                  VLC_THREAD_PRIORITY_OUTPUT)) {
+        vlc_object_release(vout);
         return NULL;
     }
 
-    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 );
+    vout_control_WaitEmpty(&vout->p->control);
+
+    if (vout->p->dead) {
+        msg_Err(vout, "video output creation failed");
+        vout_CloseAndRelease(vout);
+        return NULL;
     }
-    vlc_mutex_unlock( &p_vout->p->change_lock );
 
-    if( p_vout->p->b_error )
-    {
-        msg_Err( p_vout, "video output creation failed" );
-        vout_CloseAndRelease( p_vout );
+    vout->p->input = cfg->input;
+    if (vout->p->input)
+        spu_Attach(vout->p->p_spu, vout->p->input, true);
+
+    return vout;
+}
+
+vout_thread_t *(vout_Request)(vlc_object_t *object,
+                              const vout_configuration_t *cfg)
+{
+    vout_thread_t *vout = cfg->vout;
+    if (!cfg->fmt) {
+        if (vout)
+            vout_CloseAndRelease(vout);
         return NULL;
     }
 
-    return p_vout;
+    /* If a vout is provided, try reusing it */
+    if (vout) {
+        vlc_object_detach(vout);
+        vlc_object_attach(vout, object);
+
+        if (vout->p->input != cfg->input) {
+            if (vout->p->input)
+                spu_Attach(vout->p->p_spu, vout->p->input, false);
+            vout->p->input = cfg->input;
+            if (vout->p->input)
+                spu_Attach(vout->p->p_spu, vout->p->input, true);
+        }
+
+        vout_control_cmd_t cmd;
+        vout_control_cmd_Init(&cmd, VOUT_CONTROL_REINIT);
+        cmd.u.cfg = cfg;
+
+        vout_control_Push(&vout->p->control, &cmd);
+        vout_control_WaitEmpty(&vout->p->control);
+        if (!vout->p->dead) {
+            msg_Dbg(object, "reusing provided vout");
+            return vout;
+        }
+        vout_CloseAndRelease(vout);
+
+        msg_Warn(object, "cannot reuse provided vout");
+    }
+    return VoutCreate(object, cfg);
 }
 
 /*****************************************************************************
- * vout_Close: Close a vout created by vout_Create.
+ * vout_Close: Close a vout created by VoutCreate.
  *****************************************************************************
- * You HAVE to call it on vout created by vout_Create before vlc_object_release.
- * You should NEVER call it on vout not obtained through vout_Create
+ * You HAVE to call it on vout created by VoutCreate before vlc_object_release.
+ * You should NEVER call it on vout not obtained through VoutCreate
  * (like with vout_Request or vlc_object_find.)
  * You can use vout_CloseAndRelease() as a convenience method.
  *****************************************************************************/
-void vout_Close( vout_thread_t *p_vout )
+void vout_Close(vout_thread_t *vout)
 {
-    assert( p_vout );
+    assert(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 );
+    if (vout->p->input)
+        spu_Attach(vout->p->p_spu, vout->p->input, false);
+    vlc_object_detach(vout->p->p_spu);
 
-    vout_snapshot_End( &p_vout->p->snapshot );
+    vout_snapshot_End(&vout->p->snapshot);
 
-    vlc_join( p_vout->p->thread, NULL );
+    vout_control_PushVoid(&vout->p->control, VOUT_CONTROL_CLEAN);
+    vlc_join(vout->p->thread, NULL);
 }
 
 /* */
-static void vout_Destructor( vlc_object_t * p_this )
+static void VoutDestructor(vlc_object_t *object)
 {
-    vout_thread_t *p_vout = (vout_thread_t *)p_this;
+    vout_thread_t *vout = (vout_thread_t *)object;
 
     /* Make sure the vout was stopped first */
-    //assert( !p_vout->p_module );
+    //assert(!vout->p_module);
 
-    free( p_vout->p->psz_module_name );
+    free(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(vout->p->p_spu);
 
     /* Destroy the locks */
-    vlc_cond_destroy( &p_vout->p->change_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 );
+    vlc_mutex_destroy(&vout->p->picture_lock);
+    vlc_mutex_destroy(&vout->p->vfilter_lock);
+    vout_control_Clean(&vout->p->control);
 
     /* */
-    vout_snapshot_Clean( &p_vout->p->snapshot );
+    vout_statistic_Clean(&vout->p->statistic);
 
     /* */
-    free( p_vout->p->psz_filter_chain );
-
-    config_ChainDestroy( p_vout->p->p_cfg );
-
-    free( p_vout->p );
+    vout_snapshot_Clean(&vout->p->snapshot);
 
+    video_format_Clean(&vout->p->original);
 }
 
 /* */
@@ -433,10 +274,9 @@ void vout_ChangePause(vout_thread_t *vout, bool is_paused, mtime_t date)
     vout_control_WaitEmpty(&vout->p->control);
 }
 
-void vout_GetResetStatistic( vout_thread_t *p_vout, int *pi_displayed, int *pi_lost )
+void vout_GetResetStatistic(vout_thread_t *vout, int *displayed, int *lost)
 {
-    vout_statistic_GetReset( &p_vout->p->statistic,
-                             pi_displayed, pi_lost );
+    vout_statistic_GetReset( &vout->p->statistic, displayed, lost );
 }
 
 void vout_Flush(vout_thread_t *vout, mtime_t date)
@@ -519,11 +359,6 @@ 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;
-}
-
 /* vout_Control* are usable by anyone at anytime */
 void vout_ControlChangeFullscreen(vout_thread_t *vout, bool fullscreen)
 {
@@ -581,30 +416,125 @@ void vout_ControlChangeCropBorder(vout_thread_t *vout,
 
     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);
+}
+void vout_ControlChangeSubFilters(vout_thread_t *vout, const char *filters)
+{
+    vout_control_PushString(&vout->p->control, VOUT_CONTROL_CHANGE_SUB_FILTERS,
+                            filters);
+}
 
-/*****************************************************************************
- * 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)
+/* */
+static void VoutGetDisplayCfg(vout_thread_t *vout, vout_display_cfg_t *cfg, const char *title)
 {
-    /* Initialize output method, it allocates direct buffers for us */
-    if (vout_InitWrapper(vout))
-        return VLC_EGENERIC;
-    assert(vout->p->decoder_pool);
+    /* Load configuration */
+    cfg->is_fullscreen = var_CreateGetBool(vout, "fullscreen");
+    cfg->display.title = title;
+    const int display_width = var_CreateGetInteger(vout, "width");
+    const int display_height = var_CreateGetInteger(vout, "height");
+    cfg->display.width   = display_width > 0  ? display_width  : 0;
+    cfg->display.height  = display_height > 0 ? display_height : 0;
+    cfg->is_display_filled  = var_CreateGetBool(vout, "autoscale");
+    cfg->display.sar.num = 1; /* TODO monitor AR */
+    cfg->display.sar.den = 1;
+    unsigned zoom_den = 1000;
+    unsigned zoom_num = zoom_den * var_CreateGetFloat(vout, "scale");
+    vlc_ureduce(&zoom_num, &zoom_den, zoom_num, zoom_den, 0);
+    cfg->zoom.num = zoom_num;
+    cfg->zoom.den = zoom_den;
+    cfg->align.vertical = VOUT_DISPLAY_ALIGN_CENTER;
+    cfg->align.horizontal = VOUT_DISPLAY_ALIGN_CENTER;
+    const int align_mask = var_CreateGetInteger(vout, "align");
+    if (align_mask & 0x1)
+        cfg->align.horizontal = VOUT_DISPLAY_ALIGN_LEFT;
+    else if (align_mask & 0x2)
+        cfg->align.horizontal = VOUT_DISPLAY_ALIGN_RIGHT;
+    if (align_mask & 0x4)
+        cfg->align.horizontal = VOUT_DISPLAY_ALIGN_TOP;
+    else if (align_mask & 0x8)
+        cfg->align.horizontal = VOUT_DISPLAY_ALIGN_BOTTOM;
+}
+
+vout_window_t * vout_NewDisplayWindow(vout_thread_t *vout, vout_display_t *vd,
+                                      const vout_window_cfg_t *cfg)
+{
+    VLC_UNUSED(vd);
+    vout_window_cfg_t cfg_override = *cfg;
+
+    if (!var_InheritBool( vout, "embedded-video"))
+        cfg_override.is_standalone = true;
+
+    if (vout->p->window.is_unused && vout->p->window.object) {
+        assert(!vout->p->splitter_name);
+        if (!cfg_override.is_standalone == !vout->p->window.cfg.is_standalone &&
+            cfg_override.type           == vout->p->window.cfg.type) {
+            /* Reuse the stored window */
+            msg_Dbg(vout, "Reusing previous vout window");
+            vout_window_t *window = vout->p->window.object;
+            if (cfg_override.width  != vout->p->window.cfg.width ||
+                cfg_override.height != vout->p->window.cfg.height)
+                vout_window_SetSize(window,
+                                    cfg_override.width, cfg_override.height);
+            vout->p->window.is_unused = false;
+            vout->p->window.cfg       = cfg_override;
+            return window;
+        }
 
-    vout->p->displayed.decoded = NULL;
+        vout_window_Delete(vout->p->window.object);
+        vout->p->window.is_unused = true;
+        vout->p->window.object    = NULL;
+    }
 
-    /* print some usefull debug info about different vout formats
-     */
-    PrintVideoFormat(vout, "pic render", &vout->p->original);
+    vout_window_t *window = vout_window_New(VLC_OBJECT(vout), NULL,
+                                            &cfg_override);
+    if (!window)
+        return NULL;
+    if (!vout->p->splitter_name) {
+        vout->p->window.is_unused = false;
+        vout->p->window.cfg       = cfg_override;
+        vout->p->window.object    = window;
+    }
+    return window;
+}
+
+void vout_DeleteDisplayWindow(vout_thread_t *vout, vout_display_t *vd,
+                              vout_window_t *window)
+{
+    VLC_UNUSED(vd);
+    if (!vout->p->window.is_unused && vout->p->window.object == window) {
+        vout->p->window.is_unused = true;
+    } else if (vout->p->window.is_unused && vout->p->window.object && !window) {
+        vout_window_Delete(vout->p->window.object);
+        vout->p->window.is_unused = true;
+        vout->p->window.object    = NULL;
+    } else if (window) {
+        vout_window_Delete(window);
+    }
+}
+
+/* */
+static picture_t *VoutVideoFilterNewPicture(filter_t *filter)
+{
+    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)
 {
@@ -794,10 +724,10 @@ static int ThreadDisplayPicture(vout_thread_t *vout,
     return VLC_SUCCESS;
 }
 
-static int ThreadManage(vout_thread_t *vout,
-                        mtime_t *deadline,
-                        vout_interlacing_support_t *interlacing,
-                        vout_postprocessing_support_t *postprocessing)
+static void ThreadManage(vout_thread_t *vout,
+                         mtime_t *deadline,
+                         vout_interlacing_support_t *interlacing,
+                         vout_postprocessing_support_t *postprocessing)
 {
     vlc_mutex_lock(&vout->p->picture_lock);
 
@@ -815,14 +745,7 @@ static int ThreadManage(vout_thread_t *vout,
     /* Deinterlacing */
     vout_SetInterlacingState(vout, interlacing, picture_interlaced);
 
-    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
-        return VLC_EGENERIC;
-    }
-    return VLC_SUCCESS;
+    vout_ManageWrapper(vout);
 }
 
 static void ThreadDisplayOsdTitle(vout_thread_t *vout, const char *string)
@@ -830,8 +753,6 @@ static void ThreadDisplayOsdTitle(vout_thread_t *vout, const char *string)
     if (!vout->p->title.show)
         return;
 
-    vlc_assert_locked(&vout->p->change_lock);
-
     vout_OSDText(vout, SPU_DEFAULT_CHANNEL,
                  vout->p->title.position, INT64_C(1000) * vout->p->title.timeout,
                  string);
@@ -853,9 +774,13 @@ static void ThreadChangeFilters(vout_thread_t *vout, const char *filters)
     vlc_mutex_unlock(&vout->p->vfilter_lock);
 }
 
+static void ThreadChangeSubFilters(vout_thread_t *vout, const char *filters)
+{
+    spu_ChangeFilters(vout->p->p_spu, filters);
+}
+
 static void ThreadChangePause(vout_thread_t *vout, bool is_paused, mtime_t date)
 {
-    vlc_assert_locked(&vout->p->change_lock);
     assert(!vout->p->pause.is_on || !is_paused);
 
     if (vout->p->pause.is_on) {
@@ -1002,42 +927,129 @@ static void ThreadExecuteCropRatio(vout_thread_t *vout,
                                    unsigned num, unsigned den)
 {
     const video_format_t *source = &vout->p->original;
+    ThreadExecuteCropWindow(vout, num, den,
+                            0, 0,
+                            source->i_visible_width,
+                            source->i_visible_height);
+}
 
-    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;
+static int ThreadStart(vout_thread_t *vout, const vout_display_state_t *state)
+{
+    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);
+
+    vout_display_state_t state_default;
+    if (!state) {
+        VoutGetDisplayCfg(vout, &state_default.cfg, vout->p->display.title);
+        state_default.wm_state = var_CreateGetBool(vout, "video-on-top") ? VOUT_WINDOW_STATE_ABOVE :
+                                                                           VOUT_WINDOW_STATE_NORMAL;
+        state_default.sar.num = 0;
+        state_default.sar.den = 0;
+
+        state = &state_default;
+    }
+
+    if (vout_OpenWrapper(vout, vout->p->splitter_name, state))
+        return VLC_EGENERIC;
+    if (vout_InitWrapper(vout))
+        return VLC_EGENERIC;
+    assert(vout->p->decoder_pool);
+
+    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;
+
+    vout->p->step.last               = VLC_TS_INVALID;
+    vout->p->step.timestamp          = VLC_TS_INVALID;
+
+    video_format_Print(VLC_OBJECT(vout), "original format", &vout->p->original);
+    return VLC_SUCCESS;
+}
+
+static void ThreadStop(vout_thread_t *vout, vout_display_state_t *state)
+{
+    /* Destroy the video filters2 */
+    filter_chain_Delete(vout->p->vfilter_chain);
+
+    /* Destroy translation tables */
+    if (vout->p->display.vd) {
+        if (vout->p->decoder_pool) {
+            ThreadFlush(vout, true, INT64_MAX);
+            vout_EndWrapper(vout);
         }
+        vout_CloseWrapper(vout, state);
     }
-    ThreadExecuteCropWindow(vout, num, den, x, y, width, height);
+
+    if (vout->p->decoder_fifo)
+        picture_fifo_Delete(vout->p->decoder_fifo);
+    assert(!vout->p->decoder_pool);
+}
+
+static void ThreadInit(vout_thread_t *vout)
+{
+    vout->p->window.is_unused = true;
+    vout->p->window.object    = NULL;
+    vout->p->dead             = false;
+    vout->p->is_late_dropped  = var_InheritBool(vout, "drop-late-frames");
+    vout->p->pause.is_on      = false;
+    vout->p->pause.date       = VLC_TS_INVALID;
+
+    vout_chrono_Init(&vout->p->render, 5, 10000); /* Arbitrary initial time */
 }
 
 static void ThreadClean(vout_thread_t *vout)
 {
-    /* Destroy translation tables */
-    if (!vout->p->b_error) {
-        ThreadFlush(vout, true, INT64_MAX);
-        vout_EndWrapper(vout);
+    if (vout->p->window.object) {
+        assert(vout->p->window.is_unused);
+        vout_window_Delete(vout->p->window.object);
     }
+    vout_chrono_Clean(&vout->p->render);
+    vout->p->dead = true;
+    vout_control_Dead(&vout->p->control);
+}
+
+static int ThreadReinit(vout_thread_t *vout,
+                        const vout_configuration_t *cfg)
+{
+    video_format_t original;
+    if (VoutValidateFormat(&original, cfg->fmt)) {
+        ThreadStop(vout, NULL);
+        ThreadClean(vout);
+        return VLC_EGENERIC;
+    }
+    if (video_format_IsSimilar(&original, &vout->p->original))
+        return VLC_SUCCESS;
+
+    vout_display_state_t state;
+    memset(&state, 0, sizeof(state));
+
+    ThreadStop(vout, &state);
+
+    if (!state.cfg.is_fullscreen) {
+        state.cfg.display.width  = 0;
+        state.cfg.display.height = 0;
+    }
+    state.sar.num = 0;
+    state.sar.den = 0;
+    /* FIXME current vout "variables" are not in sync here anymore
+     * and I am not sure what to do */
+
+    vout->p->original = original;
+    if (ThreadStart(vout, &state)) {
+        ThreadClean(vout);
+        return VLC_EGENERIC;
+    }
+    return VLC_SUCCESS;
 }
 
 /*****************************************************************************
@@ -1050,28 +1062,7 @@ static void ThreadClean(vout_thread_t *vout)
 static void *Thread(void *object)
 {
     vout_thread_t *vout = object;
-    bool          has_wrapper;
-
-    /*
-     * Initialize thread
-     */
-    has_wrapper = !vout_OpenWrapper(vout, vout->p->psz_module_name);
 
-    vlc_mutex_lock(&vout->p->change_lock);
-
-    if (has_wrapper)
-        vout->p->b_error = ThreadInit(vout);
-    else
-        vout->p->b_error = true;
-
-    /* signal the creation of the vout */
-    vout->p->b_ready = true;
-    vlc_cond_signal(&vout->p->change_wait);
-
-    if (vout->p->b_error)
-        goto exit_thread;
-
-    /* */
     vout_interlacing_support_t interlacing = {
         .is_interlaced = false,
         .date = mdate(),
@@ -1080,28 +1071,39 @@ static void *Thread(void *object)
         .qtype = QTYPE_NONE,
     };
 
-    /*
-     * Main loop - it is not executed if an error occurred during
-     * initialization
-     */
     mtime_t deadline = VLC_TS_INVALID;
-    while (!vout->p->b_done && !vout->p->b_error) {
+    for (;;) {
         vout_control_cmd_t cmd;
 
-        vlc_mutex_unlock(&vout->p->change_lock);
         /* FIXME remove thoses ugly timeouts
          */
         while (!vout_control_Pop(&vout->p->control, &cmd, deadline, 100000)) {
-            /* TODO remove the lock when possible (ie when
-             * vout->p->fmt_* are not protected by it anymore) */
-            vlc_mutex_lock(&vout->p->change_lock);
             switch(cmd.type) {
+            case VOUT_CONTROL_INIT:
+                ThreadInit(vout);
+                if (ThreadStart(vout, NULL)) {
+                    ThreadStop(vout, NULL);
+                    ThreadClean(vout);
+                    return NULL;
+                }
+                break;
+            case VOUT_CONTROL_CLEAN:
+                ThreadStop(vout, NULL);
+                ThreadClean(vout);
+                return NULL;
+            case VOUT_CONTROL_REINIT:
+                if (ThreadReinit(vout, cmd.u.cfg))
+                    return NULL;
+                break;
             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_CHANGE_SUB_FILTERS:
+                ThreadChangeSubFilters(vout, cmd.u.string);
+                break;
             case VOUT_CONTROL_PAUSE:
                 ThreadChangePause(vout, cmd.u.pause.is_on, cmd.u.pause.date);
                 break;
@@ -1145,104 +1147,10 @@ static void *Thread(void *object)
             default:
                 break;
             }
-            vlc_mutex_unlock(&vout->p->change_lock);
             vout_control_cmd_Clean(&cmd);
         }
-        vlc_mutex_lock(&vout->p->change_lock);
 
-        /* */
-        if (ThreadManage(vout, &deadline,
-                         &interlacing, &postprocessing)) {
-            vout->p->b_error = true;
-            break;
-        }
+        ThreadManage(vout, &deadline, &interlacing, &postprocessing);
     }
-
-    /*
-     * 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);
-
-    vlc_mutex_unlock(&vout->p->change_lock);
-
-    if (has_wrapper)
-        vout_CloseWrapper(vout);
-    vout_control_Dead(&vout->p->control);
-
-    /* Destroy the video filters2 */
-    filter_chain_Delete(vout->p->vfilter_chain);
-
-    return NULL;
-}
-
-/*****************************************************************************
- * 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 )
-{
-    vout_thread_t *p_vout = (vout_thread_t *)p_this;
-    input_thread_t *p_input;
-    (void)psz_cmd; (void)oldval; (void)p_data;
-
-    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;
-    }
-
-    /* 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 );
-
-    /* Now restart current video stream */
-    input_Control( p_input, INPUT_RESTART_ES, -VIDEO_ES );
-    vlc_object_release( p_input );
-
-    return VLC_SUCCESS;
-}
-
-/*****************************************************************************
- * Video Filter2 stuff
- *****************************************************************************/
-static int VideoFilter2Callback(vlc_object_t *object, char const *cmd,
-                                vlc_value_t oldval, vlc_value_t newval,
-                                void *data)
-{
-    vout_thread_t *vout = (vout_thread_t *)object;
-    (void)cmd; (void)oldval; (void)data;
-
-    vout_control_PushString(&vout->p->control, VOUT_CONTROL_CHANGE_FILTERS,
-                            newval.psz_string);
-    return VLC_SUCCESS;
-}
-
-/* */
-static void PrintVideoFormat(vout_thread_t *vout,
-                             const char *description,
-                             const video_format_t *fmt)
-{
-    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);
 }