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  *          Laurent Aimar <fenrir _AT_ videolan _DOT_ org>
  14  *
  15  * This program is free software; you can redistribute it and/or modify
  16  * it under the terms of the GNU General Public License as published by
  17  * the Free Software Foundation; either version 2 of the License, or
  18  * (at your option) any later version.
  19  *
  20  * This program is distributed in the hope that it will be useful,
  21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23  * GNU General Public License for more details.
  24  *
  25  * You should have received a copy of the GNU General Public License
  26  * along with this program; if not, write to the Free Software
  27  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  28  *****************************************************************************/
  29
  30 /*****************************************************************************
  31  * Preamble
  32  *****************************************************************************/
  33 #ifdef HAVE_CONFIG_H
  34 # include "config.h"
  35 #endif
  36
  37 #include <vlc_common.h>
  38
  39 #include <stdlib.h>                                                /* free() */
  40 #include <string.h>
  41 #include <assert.h>
  42
  43 #include <vlc_vout.h>
  44
  45 #include <vlc_filter.h>
  46 #include <vlc_osd.h>
  47
  48 #include <libvlc.h>
  49 #include <vlc_input.h>
  50 #include "vout_pictures.h"
  51 #include "vout_internal.h"
  52 #include "interlacing.h"
  53 #include "postprocessing.h"
  54 #include "display.h"
  55
  56 /*****************************************************************************
  57  * Local prototypes
  58  *****************************************************************************/
  59 static void     *Thread(void *);
  60 static void     vout_Destructor(vlc_object_t *);
  61
  62 /* Object variables callbacks */
  63 static int FilterCallback( vlc_object_t *, char const *,
  64                            vlc_value_t, vlc_value_t, void * );
  65 static int VideoFilter2Callback( vlc_object_t *, char const *,
  66                                  vlc_value_t, vlc_value_t, void * );
  67
  68 /* */
  69 static void PrintVideoFormat(vout_thread_t *, const char *, const video_format_t *);
  70
  71 /* Maximum delay between 2 displayed pictures.
  72  * XXX it is needed for now but should be removed in the long term.
  73  */
  74 #define VOUT_REDISPLAY_DELAY (INT64_C(80000))
  75
  76 /**
  77  * Late pictures having a delay higher than this value are thrashed.
  78  */
  79 #define VOUT_DISPLAY_LATE_THRESHOLD (INT64_C(20000))
  80
  81 /* Better be in advance when awakening than late... */
  82 #define VOUT_MWAIT_TOLERANCE (INT64_C(1000))
  83
  84 /*****************************************************************************
  85  * Video Filter2 functions
  86  *****************************************************************************/
  87 static picture_t *video_new_buffer_filter( filter_t *p_filter )
  88 {
  89     vout_thread_t *p_vout = (vout_thread_t*)p_filter->p_owner;
  90     return picture_pool_Get(p_vout->p->private_pool);
  91 }
  92
  93 static void video_del_buffer_filter( filter_t *p_filter, picture_t *p_pic )
  94 {
  95     VLC_UNUSED(p_filter);
  96     picture_Release(p_pic);
  97 }
  98
  99 static int video_filter_buffer_allocation_init( filter_t *p_filter, void *p_data )
 100 {
 101     p_filter->pf_video_buffer_new = video_new_buffer_filter;
 102     p_filter->pf_video_buffer_del = video_del_buffer_filter;
 103     p_filter->p_owner = p_data; /* p_vout */
 104     return VLC_SUCCESS;
 105 }
 106
 107 #undef vout_Request
 108 /*****************************************************************************
 109  * vout_Request: find a video output thread, create one, or destroy one.
 110  *****************************************************************************
 111  * This function looks for a video output thread matching the current
 112  * properties. If not found, it spawns a new one.
 113  *****************************************************************************/
 114 vout_thread_t *vout_Request( vlc_object_t *p_this, vout_thread_t *p_vout,
 115                              video_format_t *p_fmt )
 116 {
 117     if( !p_fmt )
 118     {
 119         /* Video output is no longer used.
 120          * TODO: support for reusing video outputs with proper _thread-safe_
 121          * reference handling. */
 122         if( p_vout )
 123             vout_CloseAndRelease( p_vout );
 124         return NULL;
 125     }
 126
 127     /* If a video output was provided, lock it, otherwise look for one. */
 128     if( p_vout )
 129     {
 130         vlc_object_hold( p_vout );
 131     }
 132
 133     /* TODO: find a suitable unused video output */
 134
 135     /* If we now have a video output, check it has the right properties */
 136     if( p_vout )
 137     {
 138         vlc_mutex_lock( &p_vout->p->change_lock );
 139
 140         /* We don't directly check for the "vout-filter" variable for obvious
 141          * performance reasons. */
 142         if( p_vout->p->b_filter_change )
 143         {
 144             char *psz_filter_chain = var_GetString( p_vout, "vout-filter" );
 145
 146             if( psz_filter_chain && !*psz_filter_chain )
 147             {
 148                 free( psz_filter_chain );
 149                 psz_filter_chain = NULL;
 150             }
 151             if( p_vout->p->psz_filter_chain && !*p_vout->p->psz_filter_chain )
 152             {
 153                 free( p_vout->p->psz_filter_chain );
 154                 p_vout->p->psz_filter_chain = NULL;
 155             }
 156
 157             if( !psz_filter_chain && !p_vout->p->psz_filter_chain )
 158             {
 159                 p_vout->p->b_filter_change = false;
 160             }
 161
 162             free( psz_filter_chain );
 163         }
 164
 165 #warning "FIXME: Check RGB masks in vout_Request"
 166         /* FIXME: check RGB masks */
 167         if( p_vout->p->fmt_render.i_chroma != vlc_fourcc_GetCodec( VIDEO_ES, p_fmt->i_chroma ) ||
 168             p_vout->p->fmt_render.i_width != p_fmt->i_width ||
 169             p_vout->p->fmt_render.i_height != p_fmt->i_height ||
 170             p_vout->p->b_filter_change )
 171         {
 172             vlc_mutex_unlock( &p_vout->p->change_lock );
 173
 174             /* We are not interested in this format, close this vout */
 175             vout_CloseAndRelease( p_vout );
 176             vlc_object_release( p_vout );
 177             p_vout = NULL;
 178         }
 179         else
 180         {
 181             /* This video output is cool! Hijack it. */
 182             /* Correct aspect ratio on change
 183              * FIXME factorize this code with other aspect ration related code */
 184             unsigned int i_sar_num;
 185             unsigned int i_sar_den;
 186             vlc_ureduce( &i_sar_num, &i_sar_den,
 187                          p_fmt->i_sar_num, p_fmt->i_sar_den, 50000 );
 188 #if 0
 189             /* What's that, it does not seems to be used correcly everywhere */
 190             if( p_vout->i_par_num > 0 && p_vout->i_par_den > 0 )
 191             {
 192                 i_sar_num *= p_vout->i_par_den;
 193                 i_sar_den *= p_vout->i_par_num;
 194             }
 195 #endif
 196
 197             if( i_sar_num > 0 && i_sar_den > 0 &&
 198                 ( i_sar_num != p_vout->p->fmt_render.i_sar_num ||
 199                   i_sar_den != p_vout->p->fmt_render.i_sar_den ) )
 200             {
 201                 p_vout->p->fmt_in.i_sar_num = i_sar_num;
 202                 p_vout->p->fmt_in.i_sar_den = i_sar_den;
 203
 204                 p_vout->p->fmt_render.i_sar_num = i_sar_num;
 205                 p_vout->p->fmt_render.i_sar_den = i_sar_den;
 206                 p_vout->p->i_changes |= VOUT_ASPECT_CHANGE;
 207             }
 208             vlc_mutex_unlock( &p_vout->p->change_lock );
 209
 210             vlc_object_release( p_vout );
 211         }
 212
 213         if( p_vout )
 214         {
 215             msg_Dbg( p_this, "reusing provided vout" );
 216
 217             spu_Attach( p_vout->p->p_spu, VLC_OBJECT(p_vout), false );
 218             vlc_object_detach( p_vout );
 219
 220             vlc_object_attach( p_vout, p_this );
 221             spu_Attach( p_vout->p->p_spu, VLC_OBJECT(p_vout), true );
 222         }
 223     }
 224
 225     if( !p_vout )
 226     {
 227         msg_Dbg( p_this, "no usable vout present, spawning one" );
 228
 229         p_vout = vout_Create( p_this, p_fmt );
 230     }
 231
 232     return p_vout;
 233 }
 234
 235 /*****************************************************************************
 236  * vout_Create: creates a new video output thread
 237  *****************************************************************************
 238  * This function creates a new video output thread, and returns a pointer
 239  * to its description. On error, it returns NULL.
 240  *****************************************************************************/
 241 vout_thread_t * (vout_Create)( vlc_object_t *p_parent, video_format_t *p_fmt )
 242 {
 243     vout_thread_t  *p_vout;                            /* thread descriptor */
 244     vlc_value_t     text;
 245
 246
 247     config_chain_t *p_cfg;
 248     char *psz_parser;
 249     char *psz_name;
 250
 251     if( p_fmt->i_width <= 0 || p_fmt->i_height <= 0 )
 252         return NULL;
 253     const vlc_fourcc_t i_chroma = vlc_fourcc_GetCodec( VIDEO_ES, p_fmt->i_chroma );
 254
 255     vlc_ureduce( &p_fmt->i_sar_num, &p_fmt->i_sar_den,
 256                  p_fmt->i_sar_num, p_fmt->i_sar_den, 50000 );
 257     if( p_fmt->i_sar_num <= 0 || p_fmt->i_sar_den <= 0 )
 258         return NULL;
 259
 260     /* Allocate descriptor */
 261     static const char typename[] = "video output";
 262     p_vout = vlc_custom_create( p_parent, sizeof( *p_vout ), VLC_OBJECT_VOUT,
 263                                 typename );
 264     if( p_vout == NULL )
 265         return NULL;
 266
 267     /* */
 268     p_vout->p = calloc( 1, sizeof(*p_vout->p) );
 269     if( !p_vout->p )
 270     {
 271         vlc_object_release( p_vout );
 272         return NULL;
 273     }
 274
 275     /* */
 276     p_vout->p->fmt_render        = *p_fmt;   /* FIXME palette */
 277     p_vout->p->fmt_in            = *p_fmt;   /* FIXME palette */
 278
 279     p_vout->p->fmt_render.i_chroma =
 280     p_vout->p->fmt_in.i_chroma     = i_chroma;
 281     video_format_FixRgb( &p_vout->p->fmt_render );
 282     video_format_FixRgb( &p_vout->p->fmt_in );
 283
 284     /* Initialize misc stuff */
 285     vout_control_Init( &p_vout->p->control );
 286     p_vout->p->i_changes    = 0;
 287     vout_chrono_Init( &p_vout->p->render, 5, 10000 ); /* Arbitrary initial time */
 288     vout_statistic_Init( &p_vout->p->statistic );
 289     p_vout->p->b_filter_change = 0;
 290     p_vout->p->i_par_num =
 291     p_vout->p->i_par_den = 1;
 292     p_vout->p->displayed.date = VLC_TS_INVALID;
 293     p_vout->p->displayed.decoded = NULL;
 294     p_vout->p->displayed.timestamp = VLC_TS_INVALID;
 295     p_vout->p->displayed.qtype = QTYPE_NONE;
 296     p_vout->p->displayed.is_interlaced = false;
 297
 298     p_vout->p->step.last         = VLC_TS_INVALID;
 299     p_vout->p->step.timestamp    = VLC_TS_INVALID;
 300
 301     p_vout->p->pause.is_on  = false;
 302     p_vout->p->pause.date   = VLC_TS_INVALID;
 303
 304     p_vout->p->decoder_fifo = picture_fifo_New();
 305     p_vout->p->decoder_pool = NULL;
 306
 307     vlc_mouse_Init( &p_vout->p->mouse );
 308
 309     vout_snapshot_Init( &p_vout->p->snapshot );
 310
 311     p_vout->p->p_vf2_chain = filter_chain_New( p_vout, "video filter2",
 312         false, video_filter_buffer_allocation_init, NULL, p_vout );
 313
 314     /* Initialize locks */
 315     vlc_mutex_init( &p_vout->p->picture_lock );
 316     vlc_mutex_init( &p_vout->p->change_lock );
 317     vlc_mutex_init( &p_vout->p->vfilter_lock );
 318
 319     /* Mouse coordinates */
 320     var_Create( p_vout, "mouse-button-down", VLC_VAR_INTEGER );
 321     var_Create( p_vout, "mouse-moved", VLC_VAR_COORDS );
 322     var_Create( p_vout, "mouse-clicked", VLC_VAR_COORDS );
 323     /* Mouse object (area of interest in a video filter) */
 324     var_Create( p_vout, "mouse-object", VLC_VAR_BOOL );
 325
 326     /* Attach the new object now so we can use var inheritance below */
 327     vlc_object_attach( p_vout, p_parent );
 328
 329     /* Initialize subpicture unit */
 330     p_vout->p->p_spu = spu_Create( p_vout );
 331
 332     /* */
 333     spu_Init( p_vout->p->p_spu );
 334
 335     spu_Attach( p_vout->p->p_spu, VLC_OBJECT(p_vout), true );
 336
 337     p_vout->p->is_late_dropped = var_InheritBool( p_vout, "drop-late-frames" );
 338
 339     /* Take care of some "interface/control" related initialisations */
 340     vout_IntfInit( p_vout );
 341
 342     /* Look for the default filter configuration */
 343     p_vout->p->psz_filter_chain =
 344         var_CreateGetStringCommand( p_vout, "vout-filter" );
 345
 346     /* Apply video filter2 objects on the first vout */
 347     var_Create( p_vout, "video-filter",
 348                 VLC_VAR_STRING | VLC_VAR_DOINHERIT | VLC_VAR_ISCOMMAND );
 349     var_AddCallback( p_vout, "video-filter", VideoFilter2Callback, NULL );
 350     var_TriggerCallback( p_vout, "video-filter" );
 351
 352     /* Choose the video output module */
 353     if( !p_vout->p->psz_filter_chain || !*p_vout->p->psz_filter_chain )
 354     {
 355         psz_parser = NULL;
 356     }
 357     else
 358     {
 359         psz_parser = strdup( p_vout->p->psz_filter_chain );
 360         p_vout->p->title.show = false;
 361     }
 362
 363     /* Create the vout thread */
 364     char *psz_tmp = config_ChainCreate( &psz_name, &p_cfg, psz_parser );
 365     free( psz_parser );
 366     free( psz_tmp );
 367     p_vout->p->p_cfg = p_cfg;
 368
 369     /* Create a few object variables for interface interaction */
 370     var_Create( p_vout, "vout-filter", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 371     text.psz_string = _("Filters");
 372     var_Change( p_vout, "vout-filter", VLC_VAR_SETTEXT, &text, NULL );
 373     var_AddCallback( p_vout, "vout-filter", FilterCallback, NULL );
 374
 375     /* */
 376     vout_InitInterlacingSupport( p_vout, p_vout->p->displayed.is_interlaced );
 377
 378     if( p_vout->p->psz_filter_chain && *p_vout->p->psz_filter_chain )
 379     {
 380         char *psz_tmp;
 381         if( asprintf( &psz_tmp, "%s,none", psz_name ) < 0 )
 382             psz_tmp = strdup( "" );
 383         free( psz_name );
 384         psz_name = psz_tmp;
 385     }
 386     p_vout->p->psz_module_name = psz_name;
 387
 388     /* */
 389     vlc_object_set_destructor( p_vout, vout_Destructor );
 390
 391     /* */
 392     vlc_cond_init( &p_vout->p->change_wait );
 393     if( vlc_clone( &p_vout->p->thread, Thread, p_vout,
 394                    VLC_THREAD_PRIORITY_OUTPUT ) )
 395     {
 396         spu_Attach( p_vout->p->p_spu, VLC_OBJECT(p_vout), false );
 397         spu_Destroy( p_vout->p->p_spu );
 398         p_vout->p->p_spu = NULL;
 399         vlc_object_release( p_vout );
 400         return NULL;
 401     }
 402
 403     vlc_mutex_lock( &p_vout->p->change_lock );
 404     while( !p_vout->p->b_ready )
 405     {   /* We are (ab)using the same condition in opposite directions for
 406          * b_ready and b_done. This works because of the strict ordering. */
 407         assert( !p_vout->p->b_done );
 408         vlc_cond_wait( &p_vout->p->change_wait, &p_vout->p->change_lock );
 409     }
 410     vlc_mutex_unlock( &p_vout->p->change_lock );
 411
 412     if( p_vout->p->b_error )
 413     {
 414         msg_Err( p_vout, "video output creation failed" );
 415         vout_CloseAndRelease( p_vout );
 416         return NULL;
 417     }
 418
 419     return p_vout;
 420 }
 421
 422 /*****************************************************************************
 423  * vout_Close: Close a vout created by vout_Create.
 424  *****************************************************************************
 425  * You HAVE to call it on vout created by vout_Create before vlc_object_release.
 426  * You should NEVER call it on vout not obtained through vout_Create
 427  * (like with vout_Request or vlc_object_find.)
 428  * You can use vout_CloseAndRelease() as a convenience method.
 429  *****************************************************************************/
 430 void vout_Close( vout_thread_t *p_vout )
 431 {
 432     assert( p_vout );
 433
 434     vlc_mutex_lock( &p_vout->p->change_lock );
 435     p_vout->p->b_done = true;
 436     vlc_cond_signal( &p_vout->p->change_wait );
 437     vlc_mutex_unlock( &p_vout->p->change_lock );
 438
 439     vout_snapshot_End( &p_vout->p->snapshot );
 440
 441     vlc_join( p_vout->p->thread, NULL );
 442 }
 443
 444 /* */
 445 static void vout_Destructor( vlc_object_t * p_this )
 446 {
 447     vout_thread_t *p_vout = (vout_thread_t *)p_this;
 448
 449     /* Make sure the vout was stopped first */
 450     //assert( !p_vout->p_module );
 451
 452     free( p_vout->p->psz_module_name );
 453
 454     /* */
 455     if( p_vout->p->p_spu )
 456         spu_Destroy( p_vout->p->p_spu );
 457
 458     vout_chrono_Clean( &p_vout->p->render );
 459
 460     if( p_vout->p->decoder_fifo )
 461         picture_fifo_Delete( p_vout->p->decoder_fifo );
 462     assert( !p_vout->p->decoder_pool );
 463
 464     /* Destroy the locks */
 465     vlc_cond_destroy( &p_vout->p->change_wait );
 466     vlc_mutex_destroy( &p_vout->p->picture_lock );
 467     vlc_mutex_destroy( &p_vout->p->change_lock );
 468     vlc_mutex_destroy( &p_vout->p->vfilter_lock );
 469     vout_control_Clean( &p_vout->p->control );
 470
 471     /* */
 472     vout_statistic_Clean( &p_vout->p->statistic );
 473
 474     /* */
 475     vout_snapshot_Clean( &p_vout->p->snapshot );
 476
 477     /* */
 478     free( p_vout->p->psz_filter_chain );
 479
 480     config_ChainDestroy( p_vout->p->p_cfg );
 481
 482     free( p_vout->p );
 483
 484 }
 485
 486 /* */
 487 void vout_ChangePause(vout_thread_t *vout, bool is_paused, mtime_t date)
 488 {
 489     vout_control_cmd_t cmd;
 490     vout_control_cmd_Init(&cmd, VOUT_CONTROL_PAUSE);
 491     cmd.u.pause.is_on = is_paused;
 492     cmd.u.pause.date  = date;
 493     vout_control_Push(&vout->p->control, &cmd);
 494
 495     vout_control_WaitEmpty(&vout->p->control);
 496 }
 497
 498 void vout_GetResetStatistic( vout_thread_t *p_vout, int *pi_displayed, int *pi_lost )
 499 {
 500     vout_statistic_GetReset( &p_vout->p->statistic,
 501                              pi_displayed, pi_lost );
 502 }
 503
 504 void vout_Flush(vout_thread_t *vout, mtime_t date)
 505 {
 506     vout_control_PushTime(&vout->p->control, VOUT_CONTROL_FLUSH, date);
 507     vout_control_WaitEmpty(&vout->p->control);
 508 }
 509
 510 void vout_Reset(vout_thread_t *vout)
 511 {
 512     vout_control_PushVoid(&vout->p->control, VOUT_CONTROL_RESET);
 513     vout_control_WaitEmpty(&vout->p->control);
 514 }
 515
 516 bool vout_IsEmpty(vout_thread_t *vout)
 517 {
 518     vlc_mutex_lock(&vout->p->picture_lock);
 519
 520     picture_t *picture = picture_fifo_Peek(vout->p->decoder_fifo);
 521     if (picture)
 522         picture_Release(picture);
 523
 524     vlc_mutex_unlock(&vout->p->picture_lock);
 525
 526     return !picture;
 527 }
 528
 529 void vout_FixLeaks( vout_thread_t *vout )
 530 {
 531     vlc_mutex_lock(&vout->p->picture_lock);
 532
 533     picture_t *picture = picture_fifo_Peek(vout->p->decoder_fifo);
 534     if (!picture) {
 535         picture = picture_pool_Get(vout->p->decoder_pool);
 536     }
 537
 538     if (picture) {
 539         picture_Release(picture);
 540         /* Not all pictures has been displayed yet or some are
 541          * free */
 542         vlc_mutex_unlock(&vout->p->picture_lock);
 543         return;
 544     }
 545
 546     /* There is no reason that no pictures are available, force one
 547      * from the pool, becarefull with it though */
 548     msg_Err(vout, "pictures leaked, trying to workaround");
 549
 550     /* */
 551     picture_pool_NonEmpty(vout->p->decoder_pool, false);
 552
 553     vlc_mutex_unlock(&vout->p->picture_lock);
 554 }
 555 void vout_NextPicture(vout_thread_t *vout, mtime_t *duration)
 556 {
 557     vout_control_cmd_t cmd;
 558     vout_control_cmd_Init(&cmd, VOUT_CONTROL_STEP);
 559     cmd.u.time_ptr = duration;
 560
 561     vout_control_Push(&vout->p->control, &cmd);
 562     vout_control_WaitEmpty(&vout->p->control);
 563 }
 564
 565 void vout_DisplayTitle(vout_thread_t *vout, const char *title)
 566 {
 567     assert(title);
 568     vout_control_PushString(&vout->p->control, VOUT_CONTROL_OSD_TITLE, title);
 569 }
 570
 571 spu_t *vout_GetSpu( vout_thread_t *p_vout )
 572 {
 573     return p_vout->p->p_spu;
 574 }
 575
 576 /* vout_Control* are usable by anyone at anytime */
 577 void vout_ControlChangeFullscreen(vout_thread_t *vout, bool fullscreen)
 578 {
 579     vout_control_PushBool(&vout->p->control, VOUT_CONTROL_FULLSCREEN,
 580                           fullscreen);
 581 }
 582 void vout_ControlChangeOnTop(vout_thread_t *vout, bool is_on_top)
 583 {
 584     vout_control_PushBool(&vout->p->control, VOUT_CONTROL_ON_TOP,
 585                           is_on_top);
 586 }
 587 void vout_ControlChangeDisplayFilled(vout_thread_t *vout, bool is_filled)
 588 {
 589     vout_control_PushBool(&vout->p->control, VOUT_CONTROL_DISPLAY_FILLED,
 590                           is_filled);
 591 }
 592 void vout_ControlChangeZoom(vout_thread_t *vout, int num, int den)
 593 {
 594     vout_control_PushPair(&vout->p->control, VOUT_CONTROL_ZOOM,
 595                           num, den);
 596 }
 597
 598 /*****************************************************************************
 599  * InitThread: initialize video output thread
 600  *****************************************************************************
 601  * This function is called from Thread and performs the second step of the
 602  * initialization. It returns 0 on success. Note that the thread's flag are not
 603  * modified inside this function.
 604  * XXX You have to enter it with change_lock taken.
 605  *****************************************************************************/
 606 static int ThreadInit(vout_thread_t *vout)
 607 {
 608     /* Initialize output method, it allocates direct buffers for us */
 609     if (vout_InitWrapper(vout))
 610         return VLC_EGENERIC;
 611     assert(vout->p->decoder_pool);
 612
 613     vout->p->displayed.decoded = NULL;
 614
 615     /* print some usefull debug info about different vout formats
 616      */
 617     PrintVideoFormat(vout, "pic render", &vout->p->fmt_render);
 618     PrintVideoFormat(vout, "pic in",     &vout->p->fmt_in);
 619     PrintVideoFormat(vout, "pic out",    &vout->p->fmt_out);
 620
 621     assert(vout->p->fmt_out.i_width  == vout->p->fmt_render.i_width &&
 622            vout->p->fmt_out.i_height == vout->p->fmt_render.i_height &&
 623            vout->p->fmt_out.i_chroma == vout->p->fmt_render.i_chroma);
 624     return VLC_SUCCESS;
 625 }
 626
 627 static int ThreadDisplayPicture(vout_thread_t *vout,
 628                                 bool now, mtime_t *deadline)
 629 {
 630     int displayed_count = 0;
 631     int lost_count = 0;
 632
 633     for (;;) {
 634         const mtime_t date = mdate();
 635         const bool is_paused = vout->p->pause.is_on;
 636         bool redisplay = is_paused && !now && vout->p->displayed.decoded;
 637         bool is_forced;
 638
 639         /* FIXME/XXX we must redisplay the last decoded picture (because
 640          * of potential vout updated, or filters update or SPU update)
 641          * For now a high update period is needed but it coulmd be removed
 642          * if and only if:
 643          * - vout module emits events from theselves.
 644          * - *and* SPU is modified to emit an event or a deadline when needed.
 645          *
 646          * So it will be done latter.
 647          */
 648         if (!redisplay) {
 649             picture_t *peek = picture_fifo_Peek(vout->p->decoder_fifo);
 650             if (peek) {
 651                 is_forced = peek->b_force || is_paused || now;
 652                 *deadline = (is_forced ? date : peek->date) - vout_chrono_GetHigh(&vout->p->render);
 653                 picture_Release(peek);
 654             } else {
 655                 redisplay = true;
 656             }
 657         }
 658         if (redisplay) {
 659              /* FIXME a better way for this delay is needed */
 660             const mtime_t date_update = vout->p->displayed.date + VOUT_REDISPLAY_DELAY;
 661             if (date_update > date || !vout->p->displayed.decoded) {
 662                 *deadline = vout->p->displayed.decoded ? date_update : VLC_TS_INVALID;
 663                 break;
 664             }
 665             /* */
 666             is_forced = true;
 667             *deadline = date - vout_chrono_GetHigh(&vout->p->render);
 668         }
 669         if (*deadline > VOUT_MWAIT_TOLERANCE)
 670             *deadline -= VOUT_MWAIT_TOLERANCE;
 671
 672         /* If we are too early and can wait, do it */
 673         if (date < *deadline && !now)
 674             break;
 675
 676         picture_t *decoded;
 677         if (redisplay) {
 678             decoded = vout->p->displayed.decoded;
 679             vout->p->displayed.decoded = NULL;
 680         } else {
 681             decoded = picture_fifo_Pop(vout->p->decoder_fifo);
 682             assert(decoded);
 683             if (!is_forced && !vout->p->is_late_dropped) {
 684                 const mtime_t predicted = date + vout_chrono_GetLow(&vout->p->render);
 685                 const mtime_t late = predicted - decoded->date;
 686                 if (late > 0) {
 687                     msg_Dbg(vout, "picture might be displayed late (missing %d ms)", (int)(late/1000));
 688                     if (late > VOUT_DISPLAY_LATE_THRESHOLD) {
 689                         msg_Warn(vout, "rejected picture because of render time");
 690                         /* TODO */
 691                         picture_Release(decoded);
 692                         lost_count++;
 693                         break;
 694                     }
 695                 }
 696             }
 697
 698             vout->p->displayed.is_interlaced = !decoded->b_progressive;
 699             vout->p->displayed.qtype         = decoded->i_qtype;
 700         }
 701         vout->p->displayed.timestamp = decoded->date;
 702
 703         /* */
 704         if (vout->p->displayed.decoded)
 705             picture_Release(vout->p->displayed.decoded);
 706         picture_Hold(decoded);
 707         vout->p->displayed.decoded = decoded;
 708
 709         /* */
 710         vout_chrono_Start(&vout->p->render);
 711
 712         picture_t *filtered = NULL;
 713         if (decoded) {
 714             vlc_mutex_lock(&vout->p->vfilter_lock);
 715             filtered = filter_chain_VideoFilter(vout->p->p_vf2_chain, decoded);
 716             //assert(filtered == decoded); // TODO implement
 717             vlc_mutex_unlock(&vout->p->vfilter_lock);
 718             if (!filtered)
 719                 continue;
 720         }
 721
 722         /*
 723          * Check for subpictures to display
 724          */
 725         const bool do_snapshot = vout_snapshot_IsRequested(&vout->p->snapshot);
 726         mtime_t spu_render_time = is_forced ? mdate() : filtered->date;
 727         if (vout->p->pause.is_on)
 728             spu_render_time = vout->p->pause.date;
 729         else
 730             spu_render_time = filtered->date > 1 ? filtered->date : mdate();
 731
 732         subpicture_t *subpic = spu_SortSubpictures(vout->p->p_spu,
 733                                                    spu_render_time,
 734                                                    do_snapshot);
 735         /*
 736          * Perform rendering
 737          *
 738          * We have to:
 739          * - be sure to end up with a direct buffer.
 740          * - blend subtitles, and in a fast access buffer
 741          */
 742         picture_t *direct = NULL;
 743         if (filtered &&
 744             (vout->p->decoder_pool != vout->p->display_pool || subpic)) {
 745             picture_t *render;
 746             if (vout->p->is_decoder_pool_slow)
 747                 render = picture_NewFromFormat(&vout->p->fmt_out);
 748             else if (vout->p->decoder_pool != vout->p->display_pool)
 749                 render = picture_pool_Get(vout->p->display_pool);
 750             else
 751                 render = picture_pool_Get(vout->p->private_pool);
 752
 753             if (render) {
 754                 picture_Copy(render, filtered);
 755
 756                 spu_RenderSubpictures(vout->p->p_spu,
 757                                       render, &vout->p->fmt_out,
 758                                       subpic, &vout->p->fmt_in, spu_render_time);
 759             }
 760             if (vout->p->is_decoder_pool_slow) {
 761                 direct = picture_pool_Get(vout->p->display_pool);
 762                 if (direct)
 763                     picture_Copy(direct, render);
 764                 picture_Release(render);
 765
 766             } else {
 767                 direct = render;
 768             }
 769             picture_Release(filtered);
 770             filtered = NULL;
 771         } else {
 772             direct = filtered;
 773         }
 774
 775         /*
 776          * Take a snapshot if requested
 777          */
 778         if (direct && do_snapshot)
 779             vout_snapshot_Set(&vout->p->snapshot, &vout->p->fmt_out, direct);
 780
 781         /* Render the direct buffer returned by vout_RenderPicture */
 782         if (direct) {
 783             vout_RenderWrapper(vout, direct);
 784
 785             vout_chrono_Stop(&vout->p->render);
 786 #if 0
 787             {
 788             static int i = 0;
 789             if (((i++)%10) == 0)
 790                 msg_Info(vout, "render: avg %d ms var %d ms",
 791                          (int)(vout->p->render.avg/1000), (int)(vout->p->render.var/1000));
 792             }
 793 #endif
 794         }
 795
 796         /* Wait the real date (for rendering jitter) */
 797         if (!is_forced)
 798             mwait(decoded->date);
 799
 800         /* Display the direct buffer returned by vout_RenderPicture */
 801         vout->p->displayed.date = mdate();
 802         if (direct)
 803             vout_DisplayWrapper(vout, direct);
 804
 805         displayed_count++;
 806         break;
 807     }
 808
 809     vout_statistic_Update(&vout->p->statistic, displayed_count, lost_count);
 810     if (displayed_count <= 0)
 811         return VLC_EGENERIC;
 812     return VLC_SUCCESS;
 813 }
 814
 815 static int ThreadManage(vout_thread_t *vout,
 816                         mtime_t *deadline,
 817                         vout_interlacing_support_t *interlacing,
 818                         vout_postprocessing_support_t *postprocessing)
 819 {
 820     vlc_mutex_lock(&vout->p->picture_lock);
 821
 822     *deadline = VLC_TS_INVALID;
 823     ThreadDisplayPicture(vout, false, deadline);
 824
 825     const int  picture_qtype      = vout->p->displayed.qtype;
 826     const bool picture_interlaced = vout->p->displayed.is_interlaced;
 827
 828     vlc_mutex_unlock(&vout->p->picture_lock);
 829
 830     /* Post processing */
 831     vout_SetPostProcessingState(vout, postprocessing, picture_qtype);
 832
 833     /* Deinterlacing */
 834     vout_SetInterlacingState(vout, interlacing, picture_interlaced);
 835
 836     if (vout_ManageWrapper(vout)) {
 837         /* A fatal error occurred, and the thread must terminate
 838          * immediately, without displaying anything - setting b_error to 1
 839          * causes the immediate end of the main while() loop. */
 840         // FIXME pf_end
 841         return VLC_EGENERIC;
 842     }
 843     return VLC_SUCCESS;
 844 }
 845
 846 static void ThreadDisplayOsdTitle(vout_thread_t *vout, const char *string)
 847 {
 848     if( !var_InheritBool(vout, "osd"))
 849         return;
 850     if (!vout->p->title.show)
 851         return;
 852
 853     vlc_assert_locked(&vout->p->change_lock);
 854
 855     const mtime_t start = mdate();
 856     const mtime_t stop = start +
 857                          INT64_C(1000) * vout->p->title.timeout;
 858
 859     if (stop > start)
 860         vout_ShowTextAbsolute(vout, SPU_DEFAULT_CHANNEL,
 861                               string, NULL,
 862                               vout->p->title.position,
 863                               30 + vout->p->fmt_in.i_width
 864                                  - vout->p->fmt_in.i_visible_width
 865                                  - vout->p->fmt_in.i_x_offset,
 866                               20 + vout->p->fmt_in.i_y_offset,
 867                               start, stop);
 868 }
 869
 870 static void ThreadChangeFilters(vout_thread_t *vout, const char *filters)
 871 {
 872     es_format_t fmt;
 873     es_format_Init(&fmt, VIDEO_ES, vout->p->fmt_render.i_chroma);
 874     fmt.video = vout->p->fmt_render;
 875
 876     vlc_mutex_lock(&vout->p->vfilter_lock);
 877
 878     filter_chain_Reset(vout->p->p_vf2_chain, &fmt, &fmt);
 879     if (filter_chain_AppendFromString(vout->p->p_vf2_chain,
 880                                       filters) < 0)
 881         msg_Err(vout, "Video filter chain creation failed");
 882
 883     vlc_mutex_unlock(&vout->p->vfilter_lock);
 884 }
 885
 886 static void ThreadChangePause(vout_thread_t *vout, bool is_paused, mtime_t date)
 887 {
 888     vlc_assert_locked(&vout->p->change_lock);
 889     assert(!vout->p->pause.is_on || !is_paused);
 890
 891     if (vout->p->pause.is_on) {
 892         const mtime_t duration = date - vout->p->pause.date;
 893
 894         if (vout->p->step.timestamp > VLC_TS_INVALID)
 895             vout->p->step.timestamp += duration;
 896         if (vout->p->step.last > VLC_TS_INVALID)
 897             vout->p->step.last += duration;
 898         picture_fifo_OffsetDate(vout->p->decoder_fifo, duration);
 899         if (vout->p->displayed.decoded)
 900             vout->p->displayed.decoded->date += duration;
 901
 902         spu_OffsetSubtitleDate(vout->p->p_spu, duration);
 903     } else {
 904         vout->p->step.timestamp = VLC_TS_INVALID;
 905         vout->p->step.last      = VLC_TS_INVALID;
 906     }
 907     vout->p->pause.is_on = is_paused;
 908     vout->p->pause.date  = date;
 909 }
 910
 911 static void ThreadFlush(vout_thread_t *vout, bool below, mtime_t date)
 912 {
 913     vout->p->step.timestamp = VLC_TS_INVALID;
 914     vout->p->step.last      = VLC_TS_INVALID;
 915
 916     picture_t *last = vout->p->displayed.decoded;
 917     if (last) {
 918         if (( below && last->date <= date) ||
 919             (!below && last->date >= date)) {
 920             picture_Release(last);
 921
 922             vout->p->displayed.decoded   = NULL;
 923             vout->p->displayed.date      = VLC_TS_INVALID;
 924             vout->p->displayed.timestamp = VLC_TS_INVALID;
 925         }
 926     }
 927     picture_fifo_Flush(vout->p->decoder_fifo, date, below);
 928 }
 929
 930 static void ThreadReset(vout_thread_t *vout)
 931 {
 932     ThreadFlush(vout, true, INT64_MAX);
 933     if (vout->p->decoder_pool)
 934         picture_pool_NonEmpty(vout->p->decoder_pool, true);
 935     vout->p->pause.is_on = false;
 936     vout->p->pause.date  = mdate();
 937 }
 938
 939 static void ThreadStep(vout_thread_t *vout, mtime_t *duration)
 940 {
 941     *duration = 0;
 942
 943     if (vout->p->step.last <= VLC_TS_INVALID)
 944         vout->p->step.last = vout->p->displayed.timestamp;
 945
 946     mtime_t dummy;
 947     if (ThreadDisplayPicture(vout, true, &dummy))
 948         return;
 949
 950     vout->p->step.timestamp = vout->p->displayed.timestamp;
 951
 952     if (vout->p->step.last > VLC_TS_INVALID &&
 953         vout->p->step.timestamp > vout->p->step.last) {
 954         *duration = vout->p->step.timestamp - vout->p->step.last;
 955         vout->p->step.last = vout->p->step.timestamp;
 956         /* TODO advance subpicture by the duration ... */
 957     }
 958 }
 959
 960 static void ThreadChangeFullscreen(vout_thread_t *vout, bool fullscreen)
 961 {
 962     /* FIXME not sure setting "fullscreen" is good ... */
 963     var_SetBool(vout, "fullscreen", fullscreen);
 964     vout_SetDisplayFullscreen(vout->p->display.vd, fullscreen);
 965 }
 966
 967 static void ThreadChangeOnTop(vout_thread_t *vout, bool is_on_top)
 968 {
 969     vout_SetWindowState(vout->p->display.vd,
 970                         is_on_top ? VOUT_WINDOW_STATE_ABOVE :
 971                                     VOUT_WINDOW_STATE_NORMAL);
 972 }
 973
 974 static void ThreadChangeDisplayFilled(vout_thread_t *vout, bool is_filled)
 975 {
 976     vout_SetDisplayFilled(vout->p->display.vd, is_filled);
 977 }
 978
 979 static void ThreadChangeZoom(vout_thread_t *vout, int num, int den)
 980 {
 981     if (num * 10 < den) {
 982         num = den;
 983         den *= 10;
 984     } else if (num > den * 10) {
 985         num = den * 10;
 986     }
 987
 988     vout_SetDisplayZoom(vout->p->display.vd, num, den);
 989 }
 990
 991 static void ThreadClean(vout_thread_t *vout)
 992 {
 993     /* Destroy translation tables */
 994     if (!vout->p->b_error) {
 995         ThreadFlush(vout, true, INT64_MAX);
 996         vout_EndWrapper(vout);
 997     }
 998 }
 999
1000 /*****************************************************************************
1001  * Thread: video output thread
1002  *****************************************************************************
1003  * Video output thread. This function does only returns when the thread is
1004  * terminated. It handles the pictures arriving in the video heap and the
1005  * display device events.
1006  *****************************************************************************/
1007 static void *Thread(void *object)
1008 {
1009     vout_thread_t *vout = object;
1010     bool          has_wrapper;
1011
1012     /*
1013      * Initialize thread
1014      */
1015     has_wrapper = !vout_OpenWrapper(vout, vout->p->psz_module_name);
1016
1017     vlc_mutex_lock(&vout->p->change_lock);
1018
1019     if (has_wrapper)
1020         vout->p->b_error = ThreadInit(vout);
1021     else
1022         vout->p->b_error = true;
1023
1024     /* signal the creation of the vout */
1025     vout->p->b_ready = true;
1026     vlc_cond_signal(&vout->p->change_wait);
1027
1028     if (vout->p->b_error)
1029         goto exit_thread;
1030
1031     /* */
1032     vout_interlacing_support_t interlacing = {
1033         .is_interlaced = false,
1034         .date = mdate(),
1035     };
1036     vout_postprocessing_support_t postprocessing = {
1037         .qtype = QTYPE_NONE,
1038     };
1039
1040     /*
1041      * Main loop - it is not executed if an error occurred during
1042      * initialization
1043      */
1044     mtime_t deadline = VLC_TS_INVALID;
1045     while (!vout->p->b_done && !vout->p->b_error) {
1046         vout_control_cmd_t cmd;
1047
1048         vlc_mutex_unlock(&vout->p->change_lock);
1049         /* FIXME remove thoses ugly timeouts
1050          */
1051         while (!vout_control_Pop(&vout->p->control, &cmd, deadline, 100000)) {
1052             /* TODO remove the lock when possible (ie when
1053              * vout->p->fmt_* are not protected by it anymore) */
1054             vlc_mutex_lock(&vout->p->change_lock);
1055             switch(cmd.type) {
1056             case VOUT_CONTROL_OSD_TITLE:
1057                 ThreadDisplayOsdTitle(vout, cmd.u.string);
1058                 break;
1059             case VOUT_CONTROL_CHANGE_FILTERS:
1060                 ThreadChangeFilters(vout, cmd.u.string);
1061                 break;
1062             case VOUT_CONTROL_PAUSE:
1063                 ThreadChangePause(vout, cmd.u.pause.is_on, cmd.u.pause.date);
1064                 break;
1065             case VOUT_CONTROL_FLUSH:
1066                 ThreadFlush(vout, false, cmd.u.time);
1067                 break;
1068             case VOUT_CONTROL_RESET:
1069                 ThreadReset(vout);
1070                 break;
1071             case VOUT_CONTROL_STEP:
1072                 ThreadStep(vout, cmd.u.time_ptr);
1073                 break;
1074             case VOUT_CONTROL_FULLSCREEN:
1075                 ThreadChangeFullscreen(vout, cmd.u.boolean);
1076                 break;
1077             case VOUT_CONTROL_ON_TOP:
1078                 ThreadChangeOnTop(vout, cmd.u.boolean);
1079                 break;
1080             case VOUT_CONTROL_DISPLAY_FILLED:
1081                 ThreadChangeDisplayFilled(vout, cmd.u.boolean);
1082                 break;
1083             case VOUT_CONTROL_ZOOM:
1084                 ThreadChangeZoom(vout, cmd.u.pair.a, cmd.u.pair.b);
1085                 break;
1086             default:
1087                 break;
1088             }
1089             vlc_mutex_unlock(&vout->p->change_lock);
1090             vout_control_cmd_Clean(&cmd);
1091         }
1092         vlc_mutex_lock(&vout->p->change_lock);
1093
1094         /* */
1095         if (ThreadManage(vout, &deadline,
1096                          &interlacing, &postprocessing)) {
1097             vout->p->b_error = true;
1098             break;
1099         }
1100     }
1101
1102     /*
1103      * Error loop - wait until the thread destruction is requested
1104      *
1105      * XXX I wonder if we should periodically clean the decoder_fifo
1106      * or have a way to prevent it filling up.
1107      */
1108     while (vout->p->b_error && !vout->p->b_done)
1109         vlc_cond_wait(&vout->p->change_wait, &vout->p->change_lock);
1110
1111     /* Clean thread */
1112     ThreadClean(vout);
1113
1114 exit_thread:
1115     /* Detach subpicture unit from both input and vout */
1116     spu_Attach(vout->p->p_spu, VLC_OBJECT(vout), false);
1117     vlc_object_detach(vout->p->p_spu);
1118
1119     vlc_mutex_unlock(&vout->p->change_lock);
1120
1121     if (has_wrapper)
1122         vout_CloseWrapper(vout);
1123     vout_control_Dead(&vout->p->control);
1124
1125     /* Destroy the video filters2 */
1126     filter_chain_Delete(vout->p->p_vf2_chain);
1127
1128     return NULL;
1129 }
1130
1131 /*****************************************************************************
1132  * object variables callbacks: a bunch of object variables are used by the
1133  * interfaces to interact with the vout.
1134  *****************************************************************************/
1135 static int FilterCallback( vlc_object_t *p_this, char const *psz_cmd,
1136                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
1137 {
1138     vout_thread_t *p_vout = (vout_thread_t *)p_this;
1139     input_thread_t *p_input;
1140     (void)psz_cmd; (void)oldval; (void)p_data;
1141
1142     p_input = (input_thread_t *)vlc_object_find( p_this, VLC_OBJECT_INPUT,
1143                                                  FIND_PARENT );
1144     if (!p_input)
1145     {
1146         msg_Err( p_vout, "Input not found" );
1147         return VLC_EGENERIC;
1148     }
1149
1150     /* Modify input as well because the vout might have to be restarted */
1151     var_Create( p_input, "vout-filter", VLC_VAR_STRING );
1152     var_SetString( p_input, "vout-filter", newval.psz_string );
1153
1154     /* Now restart current video stream */
1155     input_Control( p_input, INPUT_RESTART_ES, -VIDEO_ES );
1156     vlc_object_release( p_input );
1157
1158     return VLC_SUCCESS;
1159 }
1160
1161 /*****************************************************************************
1162  * Video Filter2 stuff
1163  *****************************************************************************/
1164 static int VideoFilter2Callback(vlc_object_t *object, char const *cmd,
1165                                 vlc_value_t oldval, vlc_value_t newval,
1166                                 void *data)
1167 {
1168     vout_thread_t *vout = (vout_thread_t *)object;
1169     (void)cmd; (void)oldval; (void)data;
1170
1171     vout_control_PushString(&vout->p->control, VOUT_CONTROL_CHANGE_FILTERS,
1172                             newval.psz_string);
1173     return VLC_SUCCESS;
1174 }
1175
1176 /* */
1177 static void PrintVideoFormat(vout_thread_t *vout,
1178                              const char *description,
1179                              const video_format_t *fmt)
1180 {
1181     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",
1182             description,
1183             fmt->i_width, fmt->i_height, fmt->i_x_offset, fmt->i_y_offset,
1184             fmt->i_visible_width, fmt->i_visible_height,
1185             (char*)&fmt->i_chroma,
1186             fmt->i_sar_num, fmt->i_sar_den,
1187             fmt->i_rmask, fmt->i_gmask, fmt->i_bmask);
1188 }
1189