git.sesse.net Git - vlc/blob - src/video_output/video_output.c

   1 /*****************************************************************************
   2  * video_output.c : video output thread
   3  *
   4  * This module describes the programming interface for video output threads.
   5  * It includes functions allowing to open a new thread, send pictures to a
   6  * thread, and destroy a previously oppened video output thread.
   7  *****************************************************************************
   8  * Copyright (C) 2000-2007 the VideoLAN team
   9  * $Id$
  10  *
  11  * Authors: Vincent Seguin <seguin@via.ecp.fr>
  12  *          Gildas Bazin <gbazin@videolan.org>
  13  *
  14  * This program is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License as published by
  16  * the Free Software Foundation; either version 2 of the License, or
  17  * (at your option) any later version.
  18  *
  19  * This program is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU General Public License
  25  * along with this program; if not, write to the Free Software
  26  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  27  *****************************************************************************/
  28
  29 /*****************************************************************************
  30  * Preamble
  31  *****************************************************************************/
  32 #ifdef HAVE_CONFIG_H
  33 # include "config.h"
  34 #endif
  35
  36 #include <vlc_common.h>
  37
  38 #include <stdlib.h>                                                /* free() */
  39 #include <string.h>
  40
  41 #include <vlc_vout.h>
  42
  43 #include <vlc_filter.h>
  44 #include <vlc_osd.h>
  45 #include <assert.h>
  46
  47 #if defined( __APPLE__ )
  48 /* Include darwin_specific.h here if needed */
  49 #endif
  50
  51 /** FIXME This is quite ugly but needed while we don't have counters
  52  * helpers */
  53 //#include "input/input_internal.h"
  54
  55 #include <libvlc.h>
  56 #include <vlc_input.h>
  57 #include "vout_pictures.h"
  58 #include "vout_internal.h"
  59
  60 /*****************************************************************************
  61  * Local prototypes
  62  *****************************************************************************/
  63 static int      InitThread        ( vout_thread_t * );
  64 static void*    RunThread         ( void *  );
  65 static void     ErrorThread       ( vout_thread_t * );
  66 static void     CleanThread       ( vout_thread_t * );
  67 static void     EndThread         ( vout_thread_t * );
  68
  69 static void     vout_Destructor   ( vlc_object_t * p_this );
  70
  71 /* Object variables callbacks */
  72 static int FilterCallback( vlc_object_t *, char const *,
  73                            vlc_value_t, vlc_value_t, void * );
  74 static int VideoFilter2Callback( vlc_object_t *, char const *,
  75                                  vlc_value_t, vlc_value_t, void * );
  76
  77 /* */
  78 static void PostProcessEnable( vout_thread_t * );
  79 static void PostProcessDisable( vout_thread_t * );
  80 static void PostProcessSetFilterQuality( vout_thread_t *p_vout );
  81 static int  PostProcessCallback( vlc_object_t *, char const *,
  82                                  vlc_value_t, vlc_value_t, void * );
  83 /* */
  84 static void DeinterlaceEnable( vout_thread_t * );
  85 static void DeinterlaceNeeded( vout_thread_t *, bool );
  86
  87 /* From vout_intf.c */
  88 int vout_Snapshot( vout_thread_t *, picture_t * );
  89
  90 /* Display media title in OSD */
  91 static void DisplayTitleOnOSD( vout_thread_t *p_vout );
  92
  93 /* Time during which the thread will sleep if it has nothing to
  94  * display (in micro-seconds) */
  95 #define VOUT_IDLE_SLEEP                 ((int)(0.020*CLOCK_FREQ))
  96
  97 /* Maximum lap of time allowed between the beginning of rendering and
  98  * display. If, compared to the current date, the next image is too
  99  * late, the thread will perform an idle loop. This time should be
 100  * at least VOUT_IDLE_SLEEP plus the time required to render a few
 101  * images, to avoid trashing of decoded images */
 102 #define VOUT_DISPLAY_DELAY              ((int)(0.200*CLOCK_FREQ))
 103
 104 /* Better be in advance when awakening than late... */
 105 #define VOUT_MWAIT_TOLERANCE            ((mtime_t)(0.020*CLOCK_FREQ))
 106
 107 /* Minimum number of direct pictures the video output will accept without
 108  * creating additional pictures in system memory */
 109 #ifdef OPTIMIZE_MEMORY
 110 #   define VOUT_MIN_DIRECT_PICTURES        (VOUT_MAX_PICTURES/2)
 111 #else
 112 #   define VOUT_MIN_DIRECT_PICTURES        (3*VOUT_MAX_PICTURES/4)
 113 #endif
 114
 115 /*****************************************************************************
 116  * Video Filter2 functions
 117  *****************************************************************************/
 118 static picture_t *video_new_buffer_filter( filter_t *p_filter )
 119 {
 120     vout_thread_t *p_vout = (vout_thread_t*)p_filter->p_owner;
 121     picture_t *p_picture = vout_CreatePicture( p_vout, 0, 0, 0 );
 122
 123     p_picture->i_status = READY_PICTURE;
 124
 125     return p_picture;
 126 }
 127
 128 static void video_del_buffer_filter( filter_t *p_filter, picture_t *p_pic )
 129 {
 130     vout_thread_t *p_vout = (vout_thread_t*)p_filter->p_owner;
 131
 132     vlc_mutex_lock( &p_vout->picture_lock );
 133     vout_UsePictureLocked( p_vout, p_pic );
 134     vlc_mutex_unlock( &p_vout->picture_lock );
 135 }
 136
 137 static int video_filter_buffer_allocation_init( filter_t *p_filter, void *p_data )
 138 {
 139     p_filter->pf_video_buffer_new = video_new_buffer_filter;
 140     p_filter->pf_video_buffer_del = video_del_buffer_filter;
 141     p_filter->p_owner = p_data; /* p_vout */
 142     return VLC_SUCCESS;
 143 }
 144
 145 #undef vout_Request
 146 /*****************************************************************************
 147  * vout_Request: find a video output thread, create one, or destroy one.
 148  *****************************************************************************
 149  * This function looks for a video output thread matching the current
 150  * properties. If not found, it spawns a new one.
 151  *****************************************************************************/
 152 vout_thread_t *vout_Request( vlc_object_t *p_this, vout_thread_t *p_vout,
 153                              video_format_t *p_fmt )
 154 {
 155     if( !p_fmt )
 156     {
 157         /* Video output is no longer used.
 158          * TODO: support for reusing video outputs with proper _thread-safe_
 159          * reference handling. */
 160         if( p_vout )
 161             vout_CloseAndRelease( p_vout );
 162         return NULL;
 163     }
 164
 165     /* If a video output was provided, lock it, otherwise look for one. */
 166     if( p_vout )
 167     {
 168         vlc_object_hold( p_vout );
 169     }
 170
 171     /* TODO: find a suitable unused video output */
 172
 173     /* If we now have a video output, check it has the right properties */
 174     if( p_vout )
 175     {
 176         vlc_mutex_lock( &p_vout->change_lock );
 177
 178         /* We don't directly check for the "vout-filter" variable for obvious
 179          * performance reasons. */
 180         if( p_vout->p->b_filter_change )
 181         {
 182             char *psz_filter_chain = var_GetString( p_vout, "vout-filter" );
 183
 184             if( psz_filter_chain && !*psz_filter_chain )
 185             {
 186                 free( psz_filter_chain );
 187                 psz_filter_chain = NULL;
 188             }
 189             if( p_vout->p->psz_filter_chain && !*p_vout->p->psz_filter_chain )
 190             {
 191                 free( p_vout->p->psz_filter_chain );
 192                 p_vout->p->psz_filter_chain = NULL;
 193             }
 194
 195             if( !psz_filter_chain && !p_vout->p->psz_filter_chain )
 196             {
 197                 p_vout->p->b_filter_change = false;
 198             }
 199
 200             free( psz_filter_chain );
 201         }
 202
 203 #warning "FIXME: Check RGB masks in vout_Request"
 204         /* FIXME: check RGB masks */
 205         if( p_vout->fmt_render.i_chroma != vlc_fourcc_GetCodec( VIDEO_ES, p_fmt->i_chroma ) ||
 206             p_vout->fmt_render.i_width != p_fmt->i_width ||
 207             p_vout->fmt_render.i_height != p_fmt->i_height ||
 208             p_vout->p->b_filter_change )
 209         {
 210             vlc_mutex_unlock( &p_vout->change_lock );
 211
 212             /* We are not interested in this format, close this vout */
 213             vout_CloseAndRelease( p_vout );
 214             vlc_object_release( p_vout );
 215             p_vout = NULL;
 216         }
 217         else
 218         {
 219             /* This video output is cool! Hijack it. */
 220             /* Correct aspect ratio on change
 221              * FIXME factorize this code with other aspect ration related code */
 222             unsigned int i_sar_num;
 223             unsigned int i_sar_den;
 224             vlc_ureduce( &i_sar_num, &i_sar_den,
 225                          p_fmt->i_sar_num, p_fmt->i_sar_den, 50000 );
 226 #if 0
 227             /* What's that, it does not seems to be used correcly everywhere */
 228             if( p_vout->i_par_num > 0 && p_vout->i_par_den > 0 )
 229             {
 230                 i_sar_num *= p_vout->i_par_den;
 231                 i_sar_den *= p_vout->i_par_num;
 232             }
 233 #endif
 234
 235             if( i_sar_num > 0 && i_sar_den > 0 &&
 236                 ( i_sar_num != p_vout->fmt_render.i_sar_num ||
 237                   i_sar_den != p_vout->fmt_render.i_sar_den ) )
 238             {
 239                 p_vout->fmt_in.i_sar_num = i_sar_num;
 240                 p_vout->fmt_in.i_sar_den = i_sar_den;
 241
 242                 p_vout->fmt_render.i_sar_num = i_sar_num;
 243                 p_vout->fmt_render.i_sar_den = i_sar_den;
 244
 245                 p_vout->render.i_aspect = (int64_t)i_sar_num *
 246                                                    p_vout->fmt_render.i_width *
 247                                                    VOUT_ASPECT_FACTOR /
 248                                                    i_sar_den /
 249                                                    p_vout->fmt_render.i_height;
 250                 p_vout->i_changes |= VOUT_ASPECT_CHANGE;
 251             }
 252             vlc_mutex_unlock( &p_vout->change_lock );
 253
 254             vlc_object_release( p_vout );
 255         }
 256
 257         if( p_vout )
 258         {
 259             msg_Dbg( p_this, "reusing provided vout" );
 260
 261             spu_Attach( p_vout->p->p_spu, VLC_OBJECT(p_vout), false );
 262             vlc_object_detach( p_vout );
 263
 264             vlc_object_attach( p_vout, p_this );
 265             spu_Attach( p_vout->p->p_spu, VLC_OBJECT(p_vout), true );
 266         }
 267     }
 268
 269     if( !p_vout )
 270     {
 271         msg_Dbg( p_this, "no usable vout present, spawning one" );
 272
 273         p_vout = vout_Create( p_this, p_fmt );
 274     }
 275
 276     return p_vout;
 277 }
 278
 279 #undef vout_Create
 280 /*****************************************************************************
 281  * vout_Create: creates a new video output thread
 282  *****************************************************************************
 283  * This function creates a new video output thread, and returns a pointer
 284  * to its description. On error, it returns NULL.
 285  *****************************************************************************/
 286 vout_thread_t * vout_Create( vlc_object_t *p_parent, video_format_t *p_fmt )
 287 {
 288     vout_thread_t  * p_vout;                            /* thread descriptor */
 289     int              i_index;                               /* loop variable */
 290     vlc_value_t      text;
 291
 292     unsigned int i_width = p_fmt->i_width;
 293     unsigned int i_height = p_fmt->i_height;
 294     vlc_fourcc_t i_chroma = vlc_fourcc_GetCodec( VIDEO_ES, p_fmt->i_chroma );
 295
 296     config_chain_t *p_cfg;
 297     char *psz_parser;
 298     char *psz_name;
 299
 300     if( i_width <= 0 || i_height <= 0 )
 301         return NULL;
 302
 303     vlc_ureduce( &p_fmt->i_sar_num, &p_fmt->i_sar_den,
 304                  p_fmt->i_sar_num, p_fmt->i_sar_den, 50000 );
 305     if( p_fmt->i_sar_num <= 0 || p_fmt->i_sar_den <= 0 )
 306         return NULL;
 307     unsigned int i_aspect = (int64_t)p_fmt->i_sar_num *
 308                                      i_width *
 309                                      VOUT_ASPECT_FACTOR /
 310                                      p_fmt->i_sar_den /
 311                                      i_height;
 312
 313     /* Allocate descriptor */
 314     static const char typename[] = "video output";
 315     p_vout = vlc_custom_create( p_parent, sizeof( *p_vout ), VLC_OBJECT_VOUT,
 316                                 typename );
 317     if( p_vout == NULL )
 318         return NULL;
 319
 320     /* */
 321     p_vout->p = calloc( 1, sizeof(*p_vout->p) );
 322     if( !p_vout->p )
 323     {
 324         vlc_object_release( p_vout );
 325         return NULL;
 326     }
 327
 328     /* Initialize pictures - translation tables and functions
 329      * will be initialized later in InitThread */
 330     for( i_index = 0; i_index < 2 * VOUT_MAX_PICTURES + 1; i_index++)
 331     {
 332         p_vout->p_picture[i_index].i_status = FREE_PICTURE;
 333         p_vout->p_picture[i_index].i_type   = EMPTY_PICTURE;
 334         p_vout->p_picture[i_index].b_slow   = 0;
 335     }
 336
 337     /* Initialize the rendering heap */
 338     I_RENDERPICTURES = 0;
 339
 340     p_vout->fmt_render        = *p_fmt;   /* FIXME palette */
 341     p_vout->fmt_in            = *p_fmt;   /* FIXME palette */
 342
 343     video_format_FixRgb( &p_vout->fmt_render );
 344     video_format_FixRgb( &p_vout->fmt_in );
 345
 346     p_vout->render.i_width    = i_width;
 347     p_vout->render.i_height   = i_height;
 348     p_vout->render.i_chroma   = i_chroma;
 349     p_vout->render.i_aspect   = i_aspect;
 350
 351     p_vout->render.i_last_used_pic = -1;
 352
 353     /* Zero the output heap */
 354     I_OUTPUTPICTURES = 0;
 355     p_vout->output.i_width    = 0;
 356     p_vout->output.i_height   = 0;
 357     p_vout->output.i_chroma   = 0;
 358     p_vout->output.i_aspect   = 0;
 359
 360     /* Initialize misc stuff */
 361     p_vout->i_changes    = 0;
 362     p_vout->b_fullscreen = 0;
 363     p_vout->p->render_time  = 10;
 364     p_vout->p->c_fps_samples = 0;
 365     vout_statistic_Init( &p_vout->p->statistic );
 366     p_vout->p->b_filter_change = 0;
 367     p_vout->p->b_paused = false;
 368     p_vout->p->i_pause_date = 0;
 369     p_vout->p->i_par_num =
 370     p_vout->p->i_par_den = 1;
 371     p_vout->p->p_picture_displayed = NULL;
 372     p_vout->p->i_picture_displayed_date = 0;
 373     p_vout->p->b_picture_displayed = false;
 374     p_vout->p->b_picture_empty = false;
 375     p_vout->p->i_picture_qtype = QTYPE_NONE;
 376     p_vout->p->b_picture_interlaced = false;
 377
 378     vlc_mouse_Init( &p_vout->p->mouse );
 379
 380     vout_snapshot_Init( &p_vout->p->snapshot );
 381
 382     /* Initialize locks */
 383     vlc_mutex_init( &p_vout->picture_lock );
 384     vlc_cond_init( &p_vout->p->picture_wait );
 385     vlc_mutex_init( &p_vout->change_lock );
 386     vlc_mutex_init( &p_vout->p->vfilter_lock );
 387
 388     /* Mouse coordinates */
 389     var_Create( p_vout, "mouse-button-down", VLC_VAR_INTEGER );
 390     var_Create( p_vout, "mouse-moved", VLC_VAR_COORDS );
 391     var_Create( p_vout, "mouse-clicked", VLC_VAR_COORDS );
 392     /* Mouse object (area of interest in a video filter) */
 393     var_Create( p_vout, "mouse-object", VLC_VAR_BOOL );
 394
 395     /* Attach the new object now so we can use var inheritance below */
 396     vlc_object_attach( p_vout, p_parent );
 397
 398     /* Initialize subpicture unit */
 399     p_vout->p->p_spu = spu_Create( p_vout );
 400
 401     /* */
 402     spu_Init( p_vout->p->p_spu );
 403
 404     spu_Attach( p_vout->p->p_spu, VLC_OBJECT(p_vout), true );
 405
 406     /* Take care of some "interface/control" related initialisations */
 407     vout_IntfInit( p_vout );
 408
 409     /* If the parent is not a VOUT object, that means we are at the start of
 410      * the video output pipe */
 411     if( vlc_internals( p_parent )->i_object_type != VLC_OBJECT_VOUT )
 412     {
 413         /* Look for the default filter configuration */
 414         p_vout->p->psz_filter_chain =
 415             var_CreateGetStringCommand( p_vout, "vout-filter" );
 416
 417         /* Apply video filter2 objects on the first vout */
 418         p_vout->p->psz_vf2 =
 419             var_CreateGetStringCommand( p_vout, "video-filter" );
 420
 421         p_vout->p->b_first_vout = true;
 422     }
 423     else
 424     {
 425         /* continue the parent's filter chain */
 426         char *psz_tmp;
 427
 428         /* Ugly hack to jump to our configuration chain */
 429         p_vout->p->psz_filter_chain
 430             = ((vout_thread_t *)p_parent)->p->psz_filter_chain;
 431         p_vout->p->psz_filter_chain
 432             = config_ChainCreate( &psz_tmp, &p_cfg, p_vout->p->psz_filter_chain );
 433         config_ChainDestroy( p_cfg );
 434         free( psz_tmp );
 435
 436         /* Create a video filter2 var ... but don't inherit values */
 437         var_Create( p_vout, "video-filter",
 438                     VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
 439         p_vout->p->psz_vf2 = var_GetString( p_vout, "video-filter" );
 440
 441         /* */
 442         p_vout->p->b_first_vout = false;
 443     }
 444
 445     var_AddCallback( p_vout, "video-filter", VideoFilter2Callback, NULL );
 446     p_vout->p->p_vf2_chain = filter_chain_New( p_vout, "video filter2",
 447         false, video_filter_buffer_allocation_init, NULL, p_vout );
 448
 449     /* Choose the video output module */
 450     if( !p_vout->p->psz_filter_chain || !*p_vout->p->psz_filter_chain )
 451     {
 452         psz_parser = NULL;
 453     }
 454     else
 455     {
 456         psz_parser = strdup( p_vout->p->psz_filter_chain );
 457         p_vout->p->b_title_show = false;
 458     }
 459
 460     /* Create the vout thread */
 461     char *psz_tmp = config_ChainCreate( &psz_name, &p_cfg, psz_parser );
 462     free( psz_parser );
 463     free( psz_tmp );
 464     p_vout->p->p_cfg = p_cfg;
 465
 466     /* Create a few object variables for interface interaction */
 467     var_Create( p_vout, "vout-filter", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 468     text.psz_string = _("Filters");
 469     var_Change( p_vout, "vout-filter", VLC_VAR_SETTEXT, &text, NULL );
 470     var_AddCallback( p_vout, "vout-filter", FilterCallback, NULL );
 471
 472     /* */
 473     DeinterlaceEnable( p_vout );
 474
 475     if( p_vout->p->psz_filter_chain && *p_vout->p->psz_filter_chain )
 476     {
 477         char *psz_tmp;
 478         if( asprintf( &psz_tmp, "%s,none", psz_name ) < 0 )
 479             psz_tmp = strdup( "" );
 480         free( psz_name );
 481         psz_name = psz_tmp;
 482     }
 483     p_vout->p->psz_module_name = psz_name;
 484
 485     /* */
 486     vlc_object_set_destructor( p_vout, vout_Destructor );
 487
 488     /* */
 489     vlc_cond_init( &p_vout->p->change_wait );
 490     if( vlc_clone( &p_vout->p->thread, RunThread, p_vout,
 491                    VLC_THREAD_PRIORITY_OUTPUT ) )
 492     {
 493         spu_Attach( p_vout->p->p_spu, VLC_OBJECT(p_vout), false );
 494         spu_Destroy( p_vout->p->p_spu );
 495         p_vout->p->p_spu = NULL;
 496         vlc_object_release( p_vout );
 497         return NULL;
 498     }
 499
 500     vlc_mutex_lock( &p_vout->change_lock );
 501     while( !p_vout->p->b_ready )
 502     {   /* We are (ab)using the same condition in opposite directions for
 503          * b_ready and b_done. This works because of the strict ordering. */
 504         assert( !p_vout->p->b_done );
 505         vlc_cond_wait( &p_vout->p->change_wait, &p_vout->change_lock );
 506     }
 507     vlc_mutex_unlock( &p_vout->change_lock );
 508
 509     if( p_vout->p->b_error )
 510     {
 511         msg_Err( p_vout, "video output creation failed" );
 512         vout_CloseAndRelease( p_vout );
 513         return NULL;
 514     }
 515
 516     return p_vout;
 517 }
 518
 519 /*****************************************************************************
 520  * vout_Close: Close a vout created by vout_Create.
 521  *****************************************************************************
 522  * You HAVE to call it on vout created by vout_Create before vlc_object_release.
 523  * You should NEVER call it on vout not obtained through vout_Create
 524  * (like with vout_Request or vlc_object_find.)
 525  * You can use vout_CloseAndRelease() as a convenience method.
 526  *****************************************************************************/
 527 void vout_Close( vout_thread_t *p_vout )
 528 {
 529     assert( p_vout );
 530
 531     vlc_mutex_lock( &p_vout->change_lock );
 532     p_vout->p->b_done = true;
 533     vlc_cond_signal( &p_vout->p->change_wait );
 534     vlc_mutex_unlock( &p_vout->change_lock );
 535
 536     vout_snapshot_End( &p_vout->p->snapshot );
 537
 538     vlc_join( p_vout->p->thread, NULL );
 539 }
 540
 541 /* */
 542 static void vout_Destructor( vlc_object_t * p_this )
 543 {
 544     vout_thread_t *p_vout = (vout_thread_t *)p_this;
 545
 546     /* Make sure the vout was stopped first */
 547     //assert( !p_vout->p_module );
 548
 549     free( p_vout->p->psz_module_name );
 550
 551     /* */
 552     if( p_vout->p->p_spu )
 553         spu_Destroy( p_vout->p->p_spu );
 554
 555     /* Destroy the locks */
 556     vlc_cond_destroy( &p_vout->p->change_wait );
 557     vlc_cond_destroy( &p_vout->p->picture_wait );
 558     vlc_mutex_destroy( &p_vout->picture_lock );
 559     vlc_mutex_destroy( &p_vout->change_lock );
 560     vlc_mutex_destroy( &p_vout->p->vfilter_lock );
 561
 562     /* */
 563     vout_statistic_Clean( &p_vout->p->statistic );
 564
 565     /* */
 566     vout_snapshot_Clean( &p_vout->p->snapshot );
 567
 568     /* */
 569     free( p_vout->p->psz_filter_chain );
 570     free( p_vout->p->psz_title );
 571
 572     config_ChainDestroy( p_vout->p->p_cfg );
 573
 574     free( p_vout->p );
 575
 576 }
 577
 578 /* */
 579 void vout_ChangePause( vout_thread_t *p_vout, bool b_paused, mtime_t i_date )
 580 {
 581     vlc_mutex_lock( &p_vout->change_lock );
 582
 583     assert( !p_vout->p->b_paused || !b_paused );
 584
 585     vlc_mutex_lock( &p_vout->picture_lock );
 586
 587     p_vout->p->i_picture_displayed_date = 0;
 588
 589     if( p_vout->p->b_paused )
 590     {
 591         const mtime_t i_duration = i_date - p_vout->p->i_pause_date;
 592
 593         for( int i_index = 0; i_index < I_RENDERPICTURES; i_index++ )
 594         {
 595             picture_t *p_pic = PP_RENDERPICTURE[i_index];
 596
 597             if( p_pic->i_status == READY_PICTURE )
 598                 p_pic->date += i_duration;
 599         }
 600         vlc_cond_signal( &p_vout->p->picture_wait );
 601         vlc_mutex_unlock( &p_vout->picture_lock );
 602
 603         spu_OffsetSubtitleDate( p_vout->p->p_spu, i_duration );
 604     }
 605     else
 606     {
 607         vlc_mutex_unlock( &p_vout->picture_lock );
 608     }
 609     p_vout->p->b_paused = b_paused;
 610     p_vout->p->i_pause_date = i_date;
 611
 612     vlc_mutex_unlock( &p_vout->change_lock );
 613 }
 614
 615 void vout_GetResetStatistic( vout_thread_t *p_vout, int *pi_displayed, int *pi_lost )
 616 {
 617     vout_statistic_GetReset( &p_vout->p->statistic,
 618                              pi_displayed, pi_lost );
 619 }
 620
 621 void vout_Flush( vout_thread_t *p_vout, mtime_t i_date )
 622 {
 623     vlc_mutex_lock( &p_vout->picture_lock );
 624     p_vout->p->i_picture_displayed_date = 0;
 625     for( int i = 0; i < p_vout->render.i_pictures; i++ )
 626     {
 627         picture_t *p_pic = p_vout->render.pp_picture[i];
 628
 629         if( p_pic->i_status == READY_PICTURE ||
 630             p_pic->i_status == DISPLAYED_PICTURE )
 631         {
 632             /* We cannot change picture status if it is in READY_PICTURE state,
 633              * Just make sure they won't be displayed */
 634             if( p_pic->date > i_date )
 635                 p_pic->date = i_date;
 636         }
 637     }
 638     vlc_cond_signal( &p_vout->p->picture_wait );
 639     vlc_mutex_unlock( &p_vout->picture_lock );
 640 }
 641
 642 void vout_FixLeaks( vout_thread_t *p_vout, bool b_forced )
 643 {
 644     int i_pic, i_ready_pic;
 645
 646     vlc_mutex_lock( &p_vout->picture_lock );
 647
 648     for( i_pic = 0, i_ready_pic = 0; i_pic < p_vout->render.i_pictures && !b_forced; i_pic++ )
 649     {
 650         const picture_t *p_pic = p_vout->render.pp_picture[i_pic];
 651
 652         if( p_pic->i_status == READY_PICTURE )
 653         {
 654             i_ready_pic++;
 655             /* If we have at least 2 ready pictures, wait for the vout thread to
 656              * process one */
 657             if( i_ready_pic >= 2 )
 658                 break;
 659
 660             continue;
 661         }
 662
 663         if( p_pic->i_status == DISPLAYED_PICTURE )
 664         {
 665             /* If at least one displayed picture is not referenced
 666              * let vout free it */
 667             if( p_pic->i_refcount == 0 )
 668                 break;
 669         }
 670     }
 671     if( i_pic < p_vout->render.i_pictures && !b_forced )
 672     {
 673         vlc_mutex_unlock( &p_vout->picture_lock );
 674         return;
 675     }
 676
 677     /* Too many pictures are still referenced, there is probably a bug
 678      * with the decoder */
 679     if( !b_forced )
 680         msg_Err( p_vout, "pictures leaked, resetting the heap" );
 681
 682     /* Just free all the pictures */
 683     for( i_pic = 0; i_pic < p_vout->render.i_pictures; i_pic++ )
 684     {
 685         picture_t *p_pic = p_vout->render.pp_picture[i_pic];
 686
 687         msg_Dbg( p_vout, "[%d] %d %d", i_pic, p_pic->i_status, p_pic->i_refcount );
 688         p_pic->i_refcount = 0;
 689
 690         switch( p_pic->i_status )
 691         {
 692         case READY_PICTURE:
 693         case DISPLAYED_PICTURE:
 694         case RESERVED_PICTURE:
 695             if( p_pic != p_vout->p->p_picture_displayed )
 696                 vout_UsePictureLocked( p_vout, p_pic );
 697             break;
 698         }
 699     }
 700     vlc_cond_signal( &p_vout->p->picture_wait );
 701     vlc_mutex_unlock( &p_vout->picture_lock );
 702 }
 703 void vout_NextPicture( vout_thread_t *p_vout, mtime_t *pi_duration )
 704 {
 705     vlc_mutex_lock( &p_vout->picture_lock );
 706
 707     const mtime_t i_displayed_date = p_vout->p->i_picture_displayed_date;
 708
 709     p_vout->p->b_picture_displayed = false;
 710     p_vout->p->b_picture_empty = false;
 711     if( p_vout->p->p_picture_displayed )
 712     {
 713         p_vout->p->p_picture_displayed->date = 1;
 714         vlc_cond_signal( &p_vout->p->picture_wait );
 715     }
 716
 717     while( !p_vout->p->b_picture_displayed && !p_vout->p->b_picture_empty )
 718         vlc_cond_wait( &p_vout->p->picture_wait, &p_vout->picture_lock );
 719
 720     *pi_duration = __MAX( p_vout->p->i_picture_displayed_date - i_displayed_date, 0 );
 721
 722     /* TODO advance subpicture by the duration ... */
 723
 724     vlc_mutex_unlock( &p_vout->picture_lock );
 725 }
 726
 727 void vout_DisplayTitle( vout_thread_t *p_vout, const char *psz_title )
 728 {
 729     assert( psz_title );
 730
 731     if( !var_InheritBool( p_vout, "osd" ) )
 732         return;
 733
 734     vlc_mutex_lock( &p_vout->change_lock );
 735     free( p_vout->p->psz_title );
 736     p_vout->p->psz_title = strdup( psz_title );
 737     vlc_mutex_unlock( &p_vout->change_lock );
 738 }
 739
 740 spu_t *vout_GetSpu( vout_thread_t *p_vout )
 741 {
 742     return p_vout->p->p_spu;
 743 }
 744
 745 /*****************************************************************************
 746  * InitThread: initialize video output thread
 747  *****************************************************************************
 748  * This function is called from RunThread and performs the second step of the
 749  * initialization. It returns 0 on success. Note that the thread's flag are not
 750  * modified inside this function.
 751  * XXX You have to enter it with change_lock taken.
 752  *****************************************************************************/
 753 static int InitThread( vout_thread_t *p_vout )
 754 {
 755     int i;
 756
 757     /* Initialize output method, it allocates direct buffers for us */
 758     if( vout_InitWrapper( p_vout ) )
 759         return VLC_EGENERIC;
 760
 761     p_vout->p->p_picture_displayed = NULL;
 762
 763     if( !I_OUTPUTPICTURES )
 764     {
 765         msg_Err( p_vout, "plugin was unable to allocate at least "
 766                          "one direct buffer" );
 767         vout_EndWrapper( p_vout );
 768         return VLC_EGENERIC;
 769     }
 770
 771     if( I_OUTPUTPICTURES > VOUT_MAX_PICTURES )
 772     {
 773         msg_Err( p_vout, "plugin allocated too many direct buffers, "
 774                          "our internal buffers must have overflown." );
 775         vout_EndWrapper( p_vout );
 776         return VLC_EGENERIC;
 777     }
 778
 779     msg_Dbg( p_vout, "got %i direct buffer(s)", I_OUTPUTPICTURES );
 780
 781     if( !p_vout->fmt_out.i_width || !p_vout->fmt_out.i_height )
 782     {
 783         p_vout->fmt_out.i_width = p_vout->fmt_out.i_visible_width =
 784             p_vout->output.i_width;
 785         p_vout->fmt_out.i_height = p_vout->fmt_out.i_visible_height =
 786             p_vout->output.i_height;
 787         p_vout->fmt_out.i_x_offset =  p_vout->fmt_out.i_y_offset = 0;
 788
 789         p_vout->fmt_out.i_chroma = p_vout->output.i_chroma;
 790     }
 791     if( !p_vout->fmt_out.i_sar_num || !p_vout->fmt_out.i_sar_num )
 792     {
 793         p_vout->fmt_out.i_sar_num = p_vout->output.i_aspect *
 794             p_vout->fmt_out.i_height;
 795         p_vout->fmt_out.i_sar_den = VOUT_ASPECT_FACTOR *
 796             p_vout->fmt_out.i_width;
 797     }
 798
 799     vlc_ureduce( &p_vout->fmt_out.i_sar_num, &p_vout->fmt_out.i_sar_den,
 800                  p_vout->fmt_out.i_sar_num, p_vout->fmt_out.i_sar_den, 0 );
 801
 802     /* FIXME removed the need of both fmt_* and heap infos */
 803     /* Calculate shifts from system-updated masks */
 804     video_format_FixRgb( &p_vout->fmt_render );
 805     video_format_FixRgb( &p_vout->fmt_out );
 806
 807     /* print some usefull debug info about different vout formats
 808      */
 809     msg_Dbg( p_vout, "pic render sz %ix%i, of (%i,%i), vsz %ix%i, 4cc %4.4s, sar %i:%i, msk r0x%x g0x%x b0x%x",
 810              p_vout->fmt_render.i_width, p_vout->fmt_render.i_height,
 811              p_vout->fmt_render.i_x_offset, p_vout->fmt_render.i_y_offset,
 812              p_vout->fmt_render.i_visible_width,
 813              p_vout->fmt_render.i_visible_height,
 814              (char*)&p_vout->fmt_render.i_chroma,
 815              p_vout->fmt_render.i_sar_num, p_vout->fmt_render.i_sar_den,
 816              p_vout->fmt_render.i_rmask, p_vout->fmt_render.i_gmask, p_vout->fmt_render.i_bmask );
 817
 818     msg_Dbg( p_vout, "pic in sz %ix%i, of (%i,%i), vsz %ix%i, 4cc %4.4s, sar %i:%i, msk r0x%x g0x%x b0x%x",
 819              p_vout->fmt_in.i_width, p_vout->fmt_in.i_height,
 820              p_vout->fmt_in.i_x_offset, p_vout->fmt_in.i_y_offset,
 821              p_vout->fmt_in.i_visible_width,
 822              p_vout->fmt_in.i_visible_height,
 823              (char*)&p_vout->fmt_in.i_chroma,
 824              p_vout->fmt_in.i_sar_num, p_vout->fmt_in.i_sar_den,
 825              p_vout->fmt_in.i_rmask, p_vout->fmt_in.i_gmask, p_vout->fmt_in.i_bmask );
 826
 827     msg_Dbg( p_vout, "pic out sz %ix%i, of (%i,%i), vsz %ix%i, 4cc %4.4s, sar %i:%i, msk r0x%x g0x%x b0x%x",
 828              p_vout->fmt_out.i_width, p_vout->fmt_out.i_height,
 829              p_vout->fmt_out.i_x_offset, p_vout->fmt_out.i_y_offset,
 830              p_vout->fmt_out.i_visible_width,
 831              p_vout->fmt_out.i_visible_height,
 832              (char*)&p_vout->fmt_out.i_chroma,
 833              p_vout->fmt_out.i_sar_num, p_vout->fmt_out.i_sar_den,
 834              p_vout->fmt_out.i_rmask, p_vout->fmt_out.i_gmask, p_vout->fmt_out.i_bmask );
 835
 836     assert( p_vout->output.i_width == p_vout->render.i_width &&
 837             p_vout->output.i_height == p_vout->render.i_height &&
 838             p_vout->output.i_chroma == p_vout->render.i_chroma );
 839     /* Check whether we managed to create direct buffers similar to
 840      * the render buffers, ie same size and chroma */
 841
 842     /* Cool ! We have direct buffers, we can ask the decoder to
 843      * directly decode into them ! Map the first render buffers to
 844      * the first direct buffers, but keep the first direct buffer
 845      * for memcpy operations */
 846     for( i = 1; i < VOUT_MAX_PICTURES; i++ )
 847     {
 848         if( p_vout->p_picture[ i ].i_type != DIRECT_PICTURE &&
 849             I_RENDERPICTURES >= VOUT_MIN_DIRECT_PICTURES - 1 &&
 850             p_vout->p_picture[ i - 1 ].i_type == DIRECT_PICTURE )
 851         {
 852             /* We have enough direct buffers so there's no need to
 853              * try to use system memory buffers. */
 854             break;
 855         }
 856         PP_RENDERPICTURE[ I_RENDERPICTURES ] = &p_vout->p_picture[ i ];
 857         I_RENDERPICTURES++;
 858     }
 859
 860     msg_Dbg( p_vout, "direct render, mapping "
 861              "render pictures 0-%i to system pictures 1-%i",
 862              VOUT_MAX_PICTURES - 2, VOUT_MAX_PICTURES - 1 );
 863
 864     return VLC_SUCCESS;
 865 }
 866
 867 /*****************************************************************************
 868  * RunThread: video output thread
 869  *****************************************************************************
 870  * Video output thread. This function does only returns when the thread is
 871  * terminated. It handles the pictures arriving in the video heap and the
 872  * display device events.
 873  *****************************************************************************/
 874 static void* RunThread( void *p_this )
 875 {
 876     vout_thread_t *p_vout = p_this;
 877     bool            b_has_wrapper;
 878     int             i_idle_loops = 0;  /* loops without displaying a picture */
 879     int             i_picture_qtype_last = QTYPE_NONE;
 880     bool            b_picture_interlaced_last = false;
 881     mtime_t         i_picture_interlaced_last_date;
 882
 883     /*
 884      * Initialize thread
 885      */
 886     b_has_wrapper = !vout_OpenWrapper( p_vout, p_vout->p->psz_module_name );
 887
 888     vlc_mutex_lock( &p_vout->change_lock );
 889
 890     if( b_has_wrapper )
 891         p_vout->p->b_error = InitThread( p_vout );
 892     else
 893         p_vout->p->b_error = true;
 894
 895     /* signal the creation of the vout */
 896     p_vout->p->b_ready = true;
 897     vlc_cond_signal( &p_vout->p->change_wait );
 898
 899     if( p_vout->p->b_error )
 900         goto exit_thread;
 901
 902     /* */
 903     const bool b_drop_late = var_CreateGetBool( p_vout, "drop-late-frames" );
 904     i_picture_interlaced_last_date = mdate();
 905
 906     /*
 907      * Main loop - it is not executed if an error occurred during
 908      * initialization
 909      */
 910     while( !p_vout->p->b_done && !p_vout->p->b_error )
 911     {
 912         /* Initialize loop variables */
 913         const mtime_t current_date = mdate();
 914         picture_t *p_picture;
 915         picture_t *p_filtered_picture;
 916         mtime_t display_date;
 917         picture_t *p_directbuffer;
 918         int i_index;
 919
 920         if( p_vout->p->b_title_show && p_vout->p->psz_title )
 921             DisplayTitleOnOSD( p_vout );
 922
 923         vlc_mutex_lock( &p_vout->picture_lock );
 924
 925         /* Look for the earliest picture but after the last displayed one */
 926         picture_t *p_last = p_vout->p->p_picture_displayed;;
 927
 928         p_picture = NULL;
 929         for( i_index = 0; i_index < I_RENDERPICTURES; i_index++ )
 930         {
 931             picture_t *p_pic = PP_RENDERPICTURE[i_index];
 932
 933             if( p_pic->i_status != READY_PICTURE )
 934                 continue;
 935
 936             if( p_vout->p->b_paused && p_last && p_last->date > 1 )
 937                 continue;
 938
 939             if( p_last && p_pic != p_last && p_pic->date <= p_last->date )
 940             {
 941                 /* Drop old picture */
 942                 vout_UsePictureLocked( p_vout, p_pic );
 943             }
 944             else if( !p_vout->p->b_paused && !p_pic->b_force && p_pic != p_last &&
 945                      p_pic->date < current_date + p_vout->p->render_time &&
 946                      b_drop_late )
 947             {
 948                 /* Picture is late: it will be destroyed and the thread
 949                  * will directly choose the next picture */
 950                 vout_UsePictureLocked( p_vout, p_pic );
 951                 vout_statistic_Update( &p_vout->p->statistic, 0, 1 );
 952
 953                 msg_Warn( p_vout, "late picture skipped (%"PRId64" > %d)",
 954                                   current_date - p_pic->date, - p_vout->p->render_time );
 955             }
 956             else if( ( !p_last || p_last->date < p_pic->date ) &&
 957                      ( p_picture == NULL || p_pic->date < p_picture->date ) )
 958             {
 959                 p_picture = p_pic;
 960             }
 961         }
 962         if( !p_picture )
 963         {
 964             p_picture = p_last;
 965
 966             if( !p_vout->p->b_picture_empty )
 967             {
 968                 p_vout->p->b_picture_empty = true;
 969                 vlc_cond_signal( &p_vout->p->picture_wait );
 970             }
 971         }
 972
 973         display_date = 0;
 974         if( p_picture )
 975         {
 976             display_date = p_picture->date;
 977
 978             /* If we found better than the last picture, destroy it */
 979             if( p_last && p_picture != p_last )
 980             {
 981                 vout_UsePictureLocked( p_vout, p_last );
 982                 p_vout->p->p_picture_displayed = p_last = NULL;
 983             }
 984
 985             /* Compute FPS rate */
 986             p_vout->p->p_fps_sample[ p_vout->p->c_fps_samples++ % VOUT_FPS_SAMPLES ] = display_date;
 987
 988             if( !p_vout->p->b_paused && display_date > current_date + VOUT_DISPLAY_DELAY )
 989             {
 990                 /* A picture is ready to be rendered, but its rendering date
 991                  * is far from the current one so the thread will perform an
 992                  * empty loop as if no picture were found. The picture state
 993                  * is unchanged */
 994                 p_picture    = NULL;
 995                 display_date = 0;
 996             }
 997             else if( p_picture == p_last )
 998             {
 999                 /* We are asked to repeat the previous picture, but we first
1000                  * wait for a couple of idle loops */
1001                 if( i_idle_loops < 4 )
1002                 {
1003                     p_picture    = NULL;
1004                     display_date = 0;
1005                 }
1006                 else
1007                 {
1008                     /* We set the display date to something high, otherwise
1009                      * we'll have lots of problems with late pictures */
1010                     display_date = current_date + p_vout->p->render_time;
1011                 }
1012             }
1013             else if( p_vout->p->b_paused && display_date > current_date + VOUT_DISPLAY_DELAY )
1014             {
1015                 display_date = current_date + VOUT_DISPLAY_DELAY;
1016             }
1017
1018             if( p_picture )
1019             {
1020                 if( p_picture->date > 1 )
1021                 {
1022                     p_vout->p->i_picture_displayed_date = p_picture->date;
1023                     if( p_picture != p_last && !p_vout->p->b_picture_displayed )
1024                     {
1025                         p_vout->p->b_picture_displayed = true;
1026                         vlc_cond_signal( &p_vout->p->picture_wait );
1027                     }
1028                 }
1029                 p_vout->p->p_picture_displayed = p_picture;
1030             }
1031         }
1032
1033         /* */
1034         const int i_postproc_type = p_vout->p->i_picture_qtype;
1035         const int i_postproc_state = (p_vout->p->i_picture_qtype != QTYPE_NONE) - (i_picture_qtype_last != QTYPE_NONE);
1036
1037         const bool b_picture_interlaced = p_vout->p->b_picture_interlaced;
1038         const int  i_picture_interlaced_state = (!!p_vout->p->b_picture_interlaced) - (!!b_picture_interlaced_last);
1039
1040         vlc_mutex_unlock( &p_vout->picture_lock );
1041
1042         if( p_picture == NULL )
1043             i_idle_loops++;
1044
1045         p_filtered_picture = NULL;
1046         if( p_picture )
1047         {
1048             vlc_mutex_lock( &p_vout->p->vfilter_lock );
1049             p_filtered_picture = filter_chain_VideoFilter( p_vout->p->p_vf2_chain,
1050                                                            p_picture );
1051             vlc_mutex_unlock( &p_vout->p->vfilter_lock );
1052         }
1053
1054         const bool b_snapshot = vout_snapshot_IsRequested( &p_vout->p->snapshot );
1055
1056         /*
1057          * Check for subpictures to display
1058          */
1059         mtime_t spu_render_time;
1060         if( p_vout->p->b_paused )
1061             spu_render_time = p_vout->p->i_pause_date;
1062         else if( p_picture )
1063             spu_render_time = p_picture->date > 1 ? p_picture->date : mdate();
1064         else
1065             spu_render_time = 0;
1066
1067         subpicture_t *p_subpic = spu_SortSubpictures( p_vout->p->p_spu,
1068                                                       spu_render_time,
1069                                                       b_snapshot );
1070         /*
1071          * Perform rendering
1072          */
1073         vout_statistic_Update( &p_vout->p->statistic, 1, 0 );
1074         p_directbuffer = vout_RenderPicture( p_vout,
1075                                              p_filtered_picture, p_subpic,
1076                                              spu_render_time );
1077
1078         /*
1079          * Take a snapshot if requested
1080          */
1081         if( p_directbuffer && b_snapshot )
1082             vout_snapshot_Set( &p_vout->p->snapshot,
1083                                &p_vout->fmt_out, p_directbuffer );
1084
1085         /*
1086          * Call the plugin-specific rendering method if there is one
1087          */
1088         if( p_filtered_picture != NULL && p_directbuffer != NULL )
1089         {
1090             /* Render the direct buffer returned by vout_RenderPicture */
1091             vout_RenderWrapper( p_vout, p_directbuffer );
1092         }
1093
1094         /*
1095          * Sleep, wake up
1096          */
1097         if( display_date != 0 && p_directbuffer != NULL )
1098         {
1099             mtime_t current_render_time = mdate() - current_date;
1100             /* if render time is very large we don't include it in the mean */
1101             if( current_render_time < p_vout->p->render_time +
1102                 VOUT_DISPLAY_DELAY )
1103             {
1104                 /* Store render time using a sliding mean weighting to
1105                  * current value in a 3 to 1 ratio*/
1106                 p_vout->p->render_time *= 3;
1107                 p_vout->p->render_time += current_render_time;
1108                 p_vout->p->render_time >>= 2;
1109             }
1110             else
1111                 msg_Dbg( p_vout, "skipped big render time %d > %d", (int) current_render_time,
1112                  (int) (p_vout->p->render_time +VOUT_DISPLAY_DELAY ) ) ;
1113         }
1114
1115         /* Give back change lock */
1116         vlc_mutex_unlock( &p_vout->change_lock );
1117
1118         /* Sleep a while or until a given date */
1119         if( display_date != 0 )
1120         {
1121             /* If there are *vout* filters in the chain, better give them the picture
1122              * in advance */
1123             if( !p_vout->p->psz_filter_chain || !*p_vout->p->psz_filter_chain )
1124             {
1125                 mwait( display_date - VOUT_MWAIT_TOLERANCE );
1126             }
1127         }
1128         else
1129         {
1130             /* Wait until a frame is being sent or a spurious wakeup (not a problem here) */
1131             vlc_mutex_lock( &p_vout->picture_lock );
1132             vlc_cond_timedwait( &p_vout->p->picture_wait, &p_vout->picture_lock, current_date + VOUT_IDLE_SLEEP );
1133             vlc_mutex_unlock( &p_vout->picture_lock );
1134         }
1135
1136         /* On awakening, take back lock and send immediately picture
1137          * to display. */
1138         /* Note: p_vout->p->b_done could be true here and now */
1139         vlc_mutex_lock( &p_vout->change_lock );
1140
1141         /*
1142          * Display the previously rendered picture
1143          */
1144         if( p_filtered_picture != NULL && p_directbuffer != NULL )
1145         {
1146             /* Display the direct buffer returned by vout_RenderPicture */
1147             vout_DisplayWrapper( p_vout, p_directbuffer );
1148
1149             /* Tell the vout this was the last picture and that it does not
1150              * need to be forced anymore. */
1151             p_picture->b_force = false;
1152         }
1153
1154         /* Drop the filtered picture if created by video filters */
1155         if( p_filtered_picture != NULL && p_filtered_picture != p_picture )
1156         {
1157             vlc_mutex_lock( &p_vout->picture_lock );
1158             vout_UsePictureLocked( p_vout, p_filtered_picture );
1159             vlc_mutex_unlock( &p_vout->picture_lock );
1160         }
1161
1162         if( p_picture != NULL )
1163         {
1164             /* Reinitialize idle loop count */
1165             i_idle_loops = 0;
1166         }
1167
1168         /*
1169          * Check events and manage thread
1170          */
1171         if( vout_ManageWrapper( p_vout ) )
1172         {
1173             /* A fatal error occurred, and the thread must terminate
1174              * immediately, without displaying anything - setting b_error to 1
1175              * causes the immediate end of the main while() loop. */
1176             // FIXME pf_end
1177             p_vout->p->b_error = 1;
1178             break;
1179         }
1180
1181         if( p_vout->i_changes & VOUT_ON_TOP_CHANGE )
1182             p_vout->i_changes &= ~VOUT_ON_TOP_CHANGE;
1183
1184         if( p_vout->i_changes & VOUT_PICTURE_BUFFERS_CHANGE )
1185         {
1186             /* This happens when the picture buffers need to be recreated.
1187              * This is useful on multimonitor displays for instance.
1188              *
1189              * Warning: This only works when the vout creates only 1 picture
1190              * buffer!! */
1191             p_vout->i_changes &= ~VOUT_PICTURE_BUFFERS_CHANGE;
1192
1193             vlc_mutex_lock( &p_vout->picture_lock );
1194
1195             vout_EndWrapper( p_vout );
1196
1197             I_OUTPUTPICTURES = I_RENDERPICTURES = 0;
1198
1199             p_vout->p->b_error = InitThread( p_vout );
1200             if( p_vout->p->b_error )
1201                 msg_Err( p_vout, "InitThread after VOUT_PICTURE_BUFFERS_CHANGE failed" );
1202
1203             vlc_cond_signal( &p_vout->p->picture_wait );
1204             vlc_mutex_unlock( &p_vout->picture_lock );
1205
1206             if( p_vout->p->b_error )
1207                 break;
1208         }
1209
1210         /* Post processing */
1211         if( i_postproc_state == 1 )
1212             PostProcessEnable( p_vout );
1213         else if( i_postproc_state == -1 )
1214             PostProcessDisable( p_vout );
1215         if( i_postproc_state != 0 )
1216             i_picture_qtype_last = i_postproc_type;
1217
1218         /* Deinterlacing
1219          * Wait 30s before quiting interlacing mode */
1220         if( ( i_picture_interlaced_state == 1 ) ||
1221             ( i_picture_interlaced_state == -1 && i_picture_interlaced_last_date + 30000000 < current_date ) )
1222         {
1223             DeinterlaceNeeded( p_vout, b_picture_interlaced );
1224             b_picture_interlaced_last = b_picture_interlaced;
1225         }
1226         if( b_picture_interlaced )
1227             i_picture_interlaced_last_date = current_date;
1228
1229
1230         /* Check for "video filter2" changes */
1231         vlc_mutex_lock( &p_vout->p->vfilter_lock );
1232         if( p_vout->p->psz_vf2 )
1233         {
1234             es_format_t fmt;
1235
1236             es_format_Init( &fmt, VIDEO_ES, p_vout->fmt_render.i_chroma );
1237             fmt.video = p_vout->fmt_render;
1238             filter_chain_Reset( p_vout->p->p_vf2_chain, &fmt, &fmt );
1239
1240             if( filter_chain_AppendFromString( p_vout->p->p_vf2_chain,
1241                                                p_vout->p->psz_vf2 ) < 0 )
1242                 msg_Err( p_vout, "Video filter chain creation failed" );
1243
1244             free( p_vout->p->psz_vf2 );
1245             p_vout->p->psz_vf2 = NULL;
1246
1247             if( i_picture_qtype_last != QTYPE_NONE )
1248                 PostProcessSetFilterQuality( p_vout );
1249         }
1250         vlc_mutex_unlock( &p_vout->p->vfilter_lock );
1251     }
1252
1253     /*
1254      * Error loop - wait until the thread destruction is requested
1255      */
1256     if( p_vout->p->b_error )
1257         ErrorThread( p_vout );
1258
1259     /* Clean thread */
1260     CleanThread( p_vout );
1261
1262 exit_thread:
1263     /* End of thread */
1264     EndThread( p_vout );
1265     vlc_mutex_unlock( &p_vout->change_lock );
1266
1267     if( b_has_wrapper )
1268         vout_CloseWrapper( p_vout );
1269
1270     return NULL;
1271 }
1272
1273 /*****************************************************************************
1274  * ErrorThread: RunThread() error loop
1275  *****************************************************************************
1276  * This function is called when an error occurred during thread main's loop.
1277  * The thread can still receive feed, but must be ready to terminate as soon
1278  * as possible.
1279  *****************************************************************************/
1280 static void ErrorThread( vout_thread_t *p_vout )
1281 {
1282     /* Wait until a `close' order */
1283     while( !p_vout->p->b_done )
1284         vlc_cond_wait( &p_vout->p->change_wait, &p_vout->change_lock );
1285 }
1286
1287 /*****************************************************************************
1288  * CleanThread: clean up after InitThread
1289  *****************************************************************************
1290  * This function is called after a sucessful
1291  * initialization. It frees all resources allocated by InitThread.
1292  * XXX You have to enter it with change_lock taken.
1293  *****************************************************************************/
1294 static void CleanThread( vout_thread_t *p_vout )
1295 {
1296     int     i_index;                                        /* index in heap */
1297
1298     /* Destroy all remaining pictures */
1299     for( i_index = 0; i_index < 2 * VOUT_MAX_PICTURES + 1; i_index++ )
1300     {
1301         if ( p_vout->p_picture[i_index].i_type == MEMORY_PICTURE )
1302         {
1303             free( p_vout->p_picture[i_index].p_data_orig );
1304         }
1305     }
1306
1307     /* Destroy translation tables */
1308     if( !p_vout->p->b_error )
1309         vout_EndWrapper( p_vout );
1310 }
1311
1312 /*****************************************************************************
1313  * EndThread: thread destruction
1314  *****************************************************************************
1315  * This function is called when the thread ends.
1316  * It frees all resources not allocated by InitThread.
1317  * XXX You have to enter it with change_lock taken.
1318  *****************************************************************************/
1319 static void EndThread( vout_thread_t *p_vout )
1320 {
1321     /* FIXME does that function *really* need to be called inside the thread ? */
1322
1323     /* Detach subpicture unit from both input and vout */
1324     spu_Attach( p_vout->p->p_spu, VLC_OBJECT(p_vout), false );
1325     vlc_object_detach( p_vout->p->p_spu );
1326
1327     /* Destroy the video filters2 */
1328     filter_chain_Delete( p_vout->p->p_vf2_chain );
1329 }
1330
1331 /* following functions are local */
1332
1333 /*****************************************************************************
1334  * object variables callbacks: a bunch of object variables are used by the
1335  * interfaces to interact with the vout.
1336  *****************************************************************************/
1337 static int FilterCallback( vlc_object_t *p_this, char const *psz_cmd,
1338                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
1339 {
1340     vout_thread_t *p_vout = (vout_thread_t *)p_this;
1341     input_thread_t *p_input;
1342     (void)psz_cmd; (void)oldval; (void)p_data;
1343
1344     p_input = (input_thread_t *)vlc_object_find( p_this, VLC_OBJECT_INPUT,
1345                                                  FIND_PARENT );
1346     if (!p_input)
1347     {
1348         msg_Err( p_vout, "Input not found" );
1349         return VLC_EGENERIC;
1350     }
1351
1352     var_SetBool( p_vout, "intf-change", true );
1353
1354     /* Modify input as well because the vout might have to be restarted */
1355     var_Create( p_input, "vout-filter", VLC_VAR_STRING );
1356     var_SetString( p_input, "vout-filter", newval.psz_string );
1357
1358     /* Now restart current video stream */
1359     input_Control( p_input, INPUT_RESTART_ES, -VIDEO_ES );
1360     vlc_object_release( p_input );
1361
1362     return VLC_SUCCESS;
1363 }
1364
1365 /*****************************************************************************
1366  * Video Filter2 stuff
1367  *****************************************************************************/
1368 static int VideoFilter2Callback( vlc_object_t *p_this, char const *psz_cmd,
1369                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
1370 {
1371     vout_thread_t *p_vout = (vout_thread_t *)p_this;
1372     (void)psz_cmd; (void)oldval; (void)p_data;
1373
1374     vlc_mutex_lock( &p_vout->p->vfilter_lock );
1375     p_vout->p->psz_vf2 = strdup( newval.psz_string );
1376     vlc_mutex_unlock( &p_vout->p->vfilter_lock );
1377
1378     return VLC_SUCCESS;
1379 }
1380
1381 /*****************************************************************************
1382  * Post-processing
1383  *****************************************************************************/
1384 static bool PostProcessIsPresent( const char *psz_filter )
1385 {
1386     const char  *psz_pp = "postproc";
1387     const size_t i_pp = strlen(psz_pp);
1388     return psz_filter &&
1389            !strncmp( psz_filter, psz_pp, strlen(psz_pp) ) &&
1390            ( psz_filter[i_pp] == '\0' || psz_filter[i_pp] == ':' );
1391 }
1392
1393 static int PostProcessCallback( vlc_object_t *p_this, char const *psz_cmd,
1394                                 vlc_value_t oldval, vlc_value_t newval, void *p_data )
1395 {
1396     vout_thread_t *p_vout = (vout_thread_t *)p_this;
1397     VLC_UNUSED(psz_cmd); VLC_UNUSED(oldval); VLC_UNUSED(p_data);
1398
1399     static const char *psz_pp = "postproc";
1400
1401     char *psz_vf2 = var_GetString( p_vout, "video-filter" );
1402
1403     if( newval.i_int <= 0 )
1404     {
1405         if( PostProcessIsPresent( psz_vf2 ) )
1406         {
1407             strcpy( psz_vf2, &psz_vf2[strlen(psz_pp)] );
1408             if( *psz_vf2 == ':' )
1409                 strcpy( psz_vf2, &psz_vf2[1] );
1410         }
1411     }
1412     else
1413     {
1414         if( !PostProcessIsPresent( psz_vf2 ) )
1415         {
1416             if( psz_vf2 )
1417             {
1418                 char *psz_tmp = psz_vf2;
1419                 if( asprintf( &psz_vf2, "%s:%s", psz_pp, psz_tmp ) < 0 )
1420                     psz_vf2 = psz_tmp;
1421                 else
1422                     free( psz_tmp );
1423             }
1424             else
1425             {
1426                 psz_vf2 = strdup( psz_pp );
1427             }
1428         }
1429     }
1430     if( psz_vf2 )
1431     {
1432         var_SetString( p_vout, "video-filter", psz_vf2 );
1433         free( psz_vf2 );
1434     }
1435
1436     return VLC_SUCCESS;
1437 }
1438 static void PostProcessEnable( vout_thread_t *p_vout )
1439 {
1440     vlc_value_t text;
1441     msg_Dbg( p_vout, "Post-processing available" );
1442     var_Create( p_vout, "postprocess", VLC_VAR_INTEGER | VLC_VAR_HASCHOICE );
1443     text.psz_string = _("Post processing");
1444     var_Change( p_vout, "postprocess", VLC_VAR_SETTEXT, &text, NULL );
1445
1446     for( int i = 0; i <= 6; i++ )
1447     {
1448         vlc_value_t val;
1449         vlc_value_t text;
1450         char psz_text[1+1];
1451
1452         val.i_int = i;
1453         snprintf( psz_text, sizeof(psz_text), "%d", i );
1454         if( i == 0 )
1455             text.psz_string = _("Disable");
1456         else
1457             text.psz_string = psz_text;
1458         var_Change( p_vout, "postprocess", VLC_VAR_ADDCHOICE, &val, &text );
1459     }
1460     var_AddCallback( p_vout, "postprocess", PostProcessCallback, NULL );
1461
1462     /* */
1463     char *psz_filter = var_GetNonEmptyString( p_vout, "video-filter" );
1464     int i_postproc_q = 0;
1465     if( PostProcessIsPresent( psz_filter ) )
1466         i_postproc_q = var_CreateGetInteger( p_vout, "postproc-q" );
1467
1468     var_SetInteger( p_vout, "postprocess", i_postproc_q );
1469
1470     free( psz_filter );
1471 }
1472 static void PostProcessDisable( vout_thread_t *p_vout )
1473 {
1474     msg_Dbg( p_vout, "Post-processing no more available" );
1475     var_Destroy( p_vout, "postprocess" );
1476 }
1477 static void PostProcessSetFilterQuality( vout_thread_t *p_vout )
1478 {
1479     vlc_object_t *p_pp = vlc_object_find_name( p_vout, "postproc", FIND_CHILD );
1480     if( !p_pp )
1481         return;
1482
1483     var_SetInteger( p_pp, "postproc-q", var_GetInteger( p_vout, "postprocess" ) );
1484     vlc_object_release( p_pp );
1485 }
1486
1487
1488 static void DisplayTitleOnOSD( vout_thread_t *p_vout )
1489 {
1490     const mtime_t i_start = mdate();
1491     const mtime_t i_stop = i_start + INT64_C(1000) * p_vout->p->i_title_timeout;
1492
1493     if( i_stop <= i_start )
1494         return;
1495
1496     vlc_assert_locked( &p_vout->change_lock );
1497
1498     vout_ShowTextAbsolute( p_vout, DEFAULT_CHAN,
1499                            p_vout->p->psz_title, NULL,
1500                            p_vout->p->i_title_position,
1501                            30 + p_vout->fmt_in.i_width
1502                               - p_vout->fmt_in.i_visible_width
1503                               - p_vout->fmt_in.i_x_offset,
1504                            20 + p_vout->fmt_in.i_y_offset,
1505                            i_start, i_stop );
1506
1507     free( p_vout->p->psz_title );
1508
1509     p_vout->p->psz_title = NULL;
1510 }
1511
1512 /*****************************************************************************
1513  * Deinterlacing
1514  *****************************************************************************/
1515 typedef struct
1516 {
1517     const char *psz_mode;
1518     bool       b_vout_filter;
1519 } deinterlace_mode_t;
1520
1521 /* XXX
1522  * You can use the non vout filter if and only if the video properties stay the
1523  * same (width/height/chroma/fps), at least for now.
1524  */
1525 static const deinterlace_mode_t p_deinterlace_mode[] = {
1526     { "",        false },
1527     //{ "discard", true },
1528     { "blend",   false },
1529     //{ "mean",    true  },
1530     //{ "bob",     true },
1531     //{ "linear",  true },
1532     { "x",       false },
1533     //{ "yadif",   true },
1534     //{ "yadif2x", true },
1535     { NULL,      false }
1536 };
1537 static const deinterlace_mode_t *DeinterlaceGetMode( const char *psz_mode )
1538 {
1539     for( const deinterlace_mode_t *p_mode = &p_deinterlace_mode[0]; p_mode->psz_mode; p_mode++ )
1540     {
1541         if( !strcmp( p_mode->psz_mode, psz_mode ) )
1542             return p_mode;
1543     }
1544     return NULL;
1545 }
1546
1547 static char *FilterFind( char *psz_filter_base, const char *psz_module )
1548 {
1549     const size_t i_module = strlen( psz_module );
1550     const char *psz_filter = psz_filter_base;
1551
1552     if( !psz_filter || i_module <= 0 )
1553         return NULL;
1554
1555     for( ;; )
1556     {
1557         char *psz_find = strstr( psz_filter, psz_module );
1558         if( !psz_find )
1559             return NULL;
1560         if( psz_find[i_module] == '\0' || psz_find[i_module] == ':' )
1561             return psz_find;
1562         psz_filter = &psz_find[i_module];
1563     }
1564 }
1565
1566 static bool DeinterlaceIsPresent( vout_thread_t *p_vout, bool b_vout_filter )
1567 {
1568     char *psz_filter = var_GetNonEmptyString( p_vout, b_vout_filter ? "vout-filter" : "video-filter" );
1569
1570     bool b_found = FilterFind( psz_filter, "deinterlace" ) != NULL;
1571
1572     free( psz_filter );
1573
1574     return b_found;
1575 }
1576
1577 static void DeinterlaceRemove( vout_thread_t *p_vout, bool b_vout_filter )
1578 {
1579     const char *psz_variable = b_vout_filter ? "vout-filter" : "video-filter";
1580     char *psz_filter = var_GetNonEmptyString( p_vout, psz_variable );
1581
1582     char *psz = FilterFind( psz_filter, "deinterlace" );
1583     if( !psz )
1584     {
1585         free( psz_filter );
1586         return;
1587     }
1588
1589     /* */
1590     strcpy( &psz[0], &psz[strlen("deinterlace")] );
1591     if( *psz == ':' )
1592         strcpy( &psz[0], &psz[1] );
1593
1594     var_SetString( p_vout, psz_variable, psz_filter );
1595     free( psz_filter );
1596 }
1597 static void DeinterlaceAdd( vout_thread_t *p_vout, bool b_vout_filter )
1598 {
1599     const char *psz_variable = b_vout_filter ? "vout-filter" : "video-filter";
1600
1601     char *psz_filter = var_GetNonEmptyString( p_vout, psz_variable );
1602
1603     if( FilterFind( psz_filter, "deinterlace" ) )
1604     {
1605         free( psz_filter );
1606         return;
1607     }
1608
1609     /* */
1610     if( psz_filter )
1611     {
1612         char *psz_tmp = psz_filter;
1613         if( asprintf( &psz_filter, "%s:%s", psz_tmp, "deinterlace" ) < 0 )
1614             psz_filter = psz_tmp;
1615         else
1616             free( psz_tmp );
1617     }
1618     else
1619     {
1620         psz_filter = strdup( "deinterlace" );
1621     }
1622
1623     if( psz_filter )
1624     {
1625         var_SetString( p_vout, psz_variable, psz_filter );
1626         free( psz_filter );
1627     }
1628 }
1629
1630 static void DeinterlaceSave( vout_thread_t *p_vout, int i_deinterlace, const char *psz_mode, bool is_needed )
1631 {
1632     /* We have to set input variable to ensure restart support
1633      * XXX it is only needed because of vout-filter but must be done
1634      * for non video filter anyway */
1635     vlc_object_t *p_input = vlc_object_find( p_vout, VLC_OBJECT_INPUT, FIND_PARENT );
1636     if( !p_input )
1637         return;
1638
1639     /* Another hack for "vout filter" mode */
1640     if( i_deinterlace < 0 )
1641         i_deinterlace = is_needed ? -2 : -3;
1642
1643     var_Create( p_input, "deinterlace", VLC_VAR_INTEGER );
1644     var_SetInteger( p_input, "deinterlace", i_deinterlace );
1645
1646     static const char * const ppsz_variable[] = {
1647         "deinterlace-mode",
1648         "filter-deinterlace-mode",
1649         "sout-deinterlace-mode",
1650         NULL
1651     };
1652     for( int i = 0; ppsz_variable[i]; i++ )
1653     {
1654         var_Create( p_input, ppsz_variable[i], VLC_VAR_STRING );
1655         var_SetString( p_input, ppsz_variable[i], psz_mode );
1656     }
1657
1658     vlc_object_release( p_input );
1659 }
1660 static int DeinterlaceCallback( vlc_object_t *p_this, char const *psz_cmd,
1661                                 vlc_value_t oldval, vlc_value_t newval, void *p_data )
1662 {
1663     VLC_UNUSED(psz_cmd); VLC_UNUSED(oldval); VLC_UNUSED(newval); VLC_UNUSED(p_data);
1664     vout_thread_t *p_vout = (vout_thread_t *)p_this;
1665
1666     /* */
1667     const int  i_deinterlace = var_GetInteger( p_this, "deinterlace" );
1668     char       *psz_mode     = var_GetString( p_this, "deinterlace-mode" );
1669     const bool is_needed     = var_GetBool( p_this, "deinterlace-needed" );
1670     if( !psz_mode )
1671         return VLC_EGENERIC;
1672
1673     DeinterlaceSave( p_vout, i_deinterlace, psz_mode, is_needed );
1674
1675     /* */
1676     bool b_vout_filter = false;
1677     const deinterlace_mode_t *p_mode = DeinterlaceGetMode( psz_mode );
1678     if( p_mode )
1679         b_vout_filter = p_mode->b_vout_filter;
1680
1681     /* */
1682     char *psz_old;
1683     if( b_vout_filter )
1684     {
1685         psz_old = var_CreateGetString( p_vout, "filter-deinterlace-mode" );
1686     }
1687     else
1688     {
1689         psz_old = var_CreateGetString( p_vout, "sout-deinterlace-mode" );
1690         var_SetString( p_vout, "sout-deinterlace-mode", psz_mode );
1691     }
1692
1693     msg_Dbg( p_vout, "deinterlace %d, mode %s, is_needed %d", i_deinterlace, psz_mode, is_needed );
1694     if( i_deinterlace == 0 || ( i_deinterlace == -1 && !is_needed ) )
1695     {
1696         DeinterlaceRemove( p_vout, false );
1697         DeinterlaceRemove( p_vout, true );
1698     }
1699     else
1700     {
1701         if( !DeinterlaceIsPresent( p_vout, b_vout_filter ) )
1702         {
1703             DeinterlaceRemove( p_vout, !b_vout_filter );
1704             DeinterlaceAdd( p_vout, b_vout_filter );
1705         }
1706         else
1707         {
1708             /* The deinterlace filter was already inserted but we have changed the mode */
1709             DeinterlaceRemove( p_vout, !b_vout_filter );
1710             if( psz_old && strcmp( psz_old, psz_mode ) )
1711                 var_TriggerCallback( p_vout, b_vout_filter ? "vout-filter" : "video-filter" );
1712         }
1713     }
1714
1715     /* */
1716     free( psz_old );
1717     free( psz_mode );
1718     return VLC_SUCCESS;
1719 }
1720
1721 static void DeinterlaceEnable( vout_thread_t *p_vout )
1722 {
1723     vlc_value_t val, text;
1724
1725     if( !p_vout->p->b_first_vout )
1726         return;
1727
1728     msg_Dbg( p_vout, "Deinterlacing available" );
1729
1730     /* Create the configuration variables */
1731     /* */
1732     var_Create( p_vout, "deinterlace", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT | VLC_VAR_HASCHOICE );
1733     int i_deinterlace = var_GetInteger( p_vout, "deinterlace" );
1734
1735     text.psz_string = _("Deinterlace");
1736     var_Change( p_vout, "deinterlace", VLC_VAR_SETTEXT, &text, NULL );
1737
1738     const module_config_t *p_optd = config_FindConfig( VLC_OBJECT(p_vout), "deinterlace" );
1739     var_Change( p_vout, "deinterlace", VLC_VAR_CLEARCHOICES, NULL, NULL );
1740     for( int i = 0; p_optd && i < p_optd->i_list; i++ )
1741     {
1742         val.i_int  = p_optd->pi_list[i];
1743         text.psz_string = (char*)vlc_gettext(p_optd->ppsz_list_text[i]);
1744         var_Change( p_vout, "deinterlace", VLC_VAR_ADDCHOICE, &val, &text );
1745     }
1746     var_AddCallback( p_vout, "deinterlace", DeinterlaceCallback, NULL );
1747     /* */
1748     var_Create( p_vout, "deinterlace-mode", VLC_VAR_STRING | VLC_VAR_DOINHERIT | VLC_VAR_HASCHOICE );
1749     char *psz_deinterlace = var_GetNonEmptyString( p_vout, "deinterlace-mode" );
1750
1751     text.psz_string = _("Deinterlace mode");
1752     var_Change( p_vout, "deinterlace-mode", VLC_VAR_SETTEXT, &text, NULL );
1753
1754     const module_config_t *p_optm = config_FindConfig( VLC_OBJECT(p_vout), "deinterlace-mode" );
1755     var_Change( p_vout, "deinterlace-mode", VLC_VAR_CLEARCHOICES, NULL, NULL );
1756     for( int i = 0; p_optm && i < p_optm->i_list; i++ )
1757     {
1758         if( !DeinterlaceGetMode( p_optm->ppsz_list[i] ) )
1759             continue;
1760
1761         val.psz_string  = p_optm->ppsz_list[i];
1762         text.psz_string = (char*)vlc_gettext(p_optm->ppsz_list_text[i]);
1763         var_Change( p_vout, "deinterlace-mode", VLC_VAR_ADDCHOICE, &val, &text );
1764     }
1765     var_AddCallback( p_vout, "deinterlace-mode", DeinterlaceCallback, NULL );
1766     /* */
1767     var_Create( p_vout, "deinterlace-needed", VLC_VAR_BOOL );
1768     var_AddCallback( p_vout, "deinterlace-needed", DeinterlaceCallback, NULL );
1769
1770     /* Override the initial value from filters if present */
1771     char *psz_filter_mode = NULL;
1772     if( DeinterlaceIsPresent( p_vout, true ) )
1773         psz_filter_mode = var_CreateGetNonEmptyString( p_vout, "filter-deinterlace-mode" );
1774     else if( DeinterlaceIsPresent( p_vout, false ) )
1775         psz_filter_mode = var_CreateGetNonEmptyString( p_vout, "sout-deinterlace-mode" );
1776     if( psz_filter_mode )
1777     {
1778         free( psz_deinterlace );
1779         if( i_deinterlace >= -1 )
1780             i_deinterlace = 1;
1781         psz_deinterlace = psz_filter_mode;
1782     }
1783
1784     /* */
1785     if( i_deinterlace == -2 )
1786         p_vout->p->b_picture_interlaced = true;
1787     else if( i_deinterlace == -3 )
1788         p_vout->p->b_picture_interlaced = false;
1789     if( i_deinterlace < 0 )
1790         i_deinterlace = -1;
1791
1792     /* */
1793     val.psz_string = psz_deinterlace ? psz_deinterlace : p_optm->orig.psz;
1794     var_Change( p_vout, "deinterlace-mode", VLC_VAR_SETVALUE, &val, NULL );
1795     val.b_bool = p_vout->p->b_picture_interlaced;
1796     var_Change( p_vout, "deinterlace-needed", VLC_VAR_SETVALUE, &val, NULL );
1797
1798     var_SetInteger( p_vout, "deinterlace", i_deinterlace );
1799     free( psz_deinterlace );
1800 }
1801
1802 static void DeinterlaceNeeded( vout_thread_t *p_vout, bool is_interlaced )
1803 {
1804     msg_Dbg( p_vout, "Detected %s video",
1805              is_interlaced ? "interlaced" : "progressive" );
1806     var_SetBool( p_vout, "deinterlace-needed", is_interlaced );
1807 }
1808