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
  55 /*****************************************************************************
  56  * Local prototypes
  57  *****************************************************************************/
  58 static void     *Thread(void *);
  59 static void     vout_Destructor(vlc_object_t *);
  60
  61 /* Object variables callbacks */
  62 static int FilterCallback( vlc_object_t *, char const *,
  63                            vlc_value_t, vlc_value_t, void * );
  64 static int VideoFilter2Callback( vlc_object_t *, char const *,
  65                                  vlc_value_t, vlc_value_t, void * );
  66
  67 /* */
  68 static void PrintVideoFormat(vout_thread_t *, const char *, const video_format_t *);
  69
  70 /* Maximum delay between 2 displayed pictures.
  71  * XXX it is needed for now but should be removed in the long term.
  72  */
  73 #define VOUT_REDISPLAY_DELAY (INT64_C(80000))
  74
  75 /**
  76  * Late pictures having a delay higher than this value are thrashed.
  77  */
  78 #define VOUT_DISPLAY_LATE_THRESHOLD (INT64_C(20000))
  79
  80 /* Better be in advance when awakening than late... */
  81 #define VOUT_MWAIT_TOLERANCE (INT64_C(1000))
  82
  83 /*****************************************************************************
  84  * Video Filter2 functions
  85  *****************************************************************************/
  86 static picture_t *video_new_buffer_filter( filter_t *p_filter )
  87 {
  88     vout_thread_t *p_vout = (vout_thread_t*)p_filter->p_owner;
  89     return picture_pool_Get(p_vout->p->private_pool);
  90 }
  91
  92 static void video_del_buffer_filter( filter_t *p_filter, picture_t *p_pic )
  93 {
  94     VLC_UNUSED(p_filter);
  95     picture_Release(p_pic);
  96 }
  97
  98 static int video_filter_buffer_allocation_init( filter_t *p_filter, void *p_data )
  99 {
 100     p_filter->pf_video_buffer_new = video_new_buffer_filter;
 101     p_filter->pf_video_buffer_del = video_del_buffer_filter;
 102     p_filter->p_owner = p_data; /* p_vout */
 103     return VLC_SUCCESS;
 104 }
 105
 106 #undef vout_Request
 107 /*****************************************************************************
 108  * vout_Request: find a video output thread, create one, or destroy one.
 109  *****************************************************************************
 110  * This function looks for a video output thread matching the current
 111  * properties. If not found, it spawns a new one.
 112  *****************************************************************************/
 113 vout_thread_t *vout_Request( vlc_object_t *p_this, vout_thread_t *p_vout,
 114                              video_format_t *p_fmt )
 115 {
 116     if( !p_fmt )
 117     {
 118         /* Video output is no longer used.
 119          * TODO: support for reusing video outputs with proper _thread-safe_
 120          * reference handling. */
 121         if( p_vout )
 122             vout_CloseAndRelease( p_vout );
 123         return NULL;
 124     }
 125
 126     /* If a video output was provided, lock it, otherwise look for one. */
 127     if( p_vout )
 128     {
 129         vlc_object_hold( p_vout );
 130     }
 131
 132     /* TODO: find a suitable unused video output */
 133
 134     /* If we now have a video output, check it has the right properties */
 135     if( p_vout )
 136     {
 137         vlc_mutex_lock( &p_vout->p->change_lock );
 138
 139         /* We don't directly check for the "vout-filter" variable for obvious
 140          * performance reasons. */
 141         if( p_vout->p->b_filter_change )
 142         {
 143             char *psz_filter_chain = var_GetString( p_vout, "vout-filter" );
 144
 145             if( psz_filter_chain && !*psz_filter_chain )
 146             {
 147                 free( psz_filter_chain );
 148                 psz_filter_chain = NULL;
 149             }
 150             if( p_vout->p->psz_filter_chain && !*p_vout->p->psz_filter_chain )
 151             {
 152                 free( p_vout->p->psz_filter_chain );
 153                 p_vout->p->psz_filter_chain = NULL;
 154             }
 155
 156             if( !psz_filter_chain && !p_vout->p->psz_filter_chain )
 157             {
 158                 p_vout->p->b_filter_change = false;
 159             }
 160
 161             free( psz_filter_chain );
 162         }
 163
 164 #warning "FIXME: Check RGB masks in vout_Request"
 165         /* FIXME: check RGB masks */
 166         if( p_vout->fmt_render.i_chroma != vlc_fourcc_GetCodec( VIDEO_ES, p_fmt->i_chroma ) ||
 167             p_vout->fmt_render.i_width != p_fmt->i_width ||
 168             p_vout->fmt_render.i_height != p_fmt->i_height ||
 169             p_vout->p->b_filter_change )
 170         {
 171             vlc_mutex_unlock( &p_vout->p->change_lock );
 172
 173             /* We are not interested in this format, close this vout */
 174             vout_CloseAndRelease( p_vout );
 175             vlc_object_release( p_vout );
 176             p_vout = NULL;
 177         }
 178         else
 179         {
 180             /* This video output is cool! Hijack it. */
 181             /* Correct aspect ratio on change
 182              * FIXME factorize this code with other aspect ration related code */
 183             unsigned int i_sar_num;
 184             unsigned int i_sar_den;
 185             vlc_ureduce( &i_sar_num, &i_sar_den,
 186                          p_fmt->i_sar_num, p_fmt->i_sar_den, 50000 );
 187 #if 0
 188             /* What's that, it does not seems to be used correcly everywhere */
 189             if( p_vout->i_par_num > 0 && p_vout->i_par_den > 0 )
 190             {
 191                 i_sar_num *= p_vout->i_par_den;
 192                 i_sar_den *= p_vout->i_par_num;
 193             }
 194 #endif
 195
 196             if( i_sar_num > 0 && i_sar_den > 0 &&
 197                 ( i_sar_num != p_vout->fmt_render.i_sar_num ||
 198                   i_sar_den != p_vout->fmt_render.i_sar_den ) )
 199             {
 200                 p_vout->fmt_in.i_sar_num = i_sar_num;
 201                 p_vout->fmt_in.i_sar_den = i_sar_den;
 202
 203                 p_vout->fmt_render.i_sar_num = i_sar_num;
 204                 p_vout->fmt_render.i_sar_den = i_sar_den;
 205                 p_vout->p->i_changes |= VOUT_ASPECT_CHANGE;
 206             }
 207             vlc_mutex_unlock( &p_vout->p->change_lock );
 208
 209             vlc_object_release( p_vout );
 210         }
 211
 212         if( p_vout )
 213         {
 214             msg_Dbg( p_this, "reusing provided vout" );
 215
 216             spu_Attach( p_vout->p->p_spu, VLC_OBJECT(p_vout), false );
 217             vlc_object_detach( p_vout );
 218
 219             vlc_object_attach( p_vout, p_this );
 220             spu_Attach( p_vout->p->p_spu, VLC_OBJECT(p_vout), true );
 221         }
 222     }
 223
 224     if( !p_vout )
 225     {
 226         msg_Dbg( p_this, "no usable vout present, spawning one" );
 227
 228         p_vout = vout_Create( p_this, p_fmt );
 229     }
 230
 231     return p_vout;
 232 }
 233
 234 /*****************************************************************************
 235  * vout_Create: creates a new video output thread
 236  *****************************************************************************
 237  * This function creates a new video output thread, and returns a pointer
 238  * to its description. On error, it returns NULL.
 239  *****************************************************************************/
 240 vout_thread_t * (vout_Create)( vlc_object_t *p_parent, video_format_t *p_fmt )
 241 {
 242     vout_thread_t  *p_vout;                            /* thread descriptor */
 243     vlc_value_t     text;
 244
 245
 246     config_chain_t *p_cfg;
 247     char *psz_parser;
 248     char *psz_name;
 249
 250     if( p_fmt->i_width <= 0 || p_fmt->i_height <= 0 )
 251         return NULL;
 252     const vlc_fourcc_t i_chroma = vlc_fourcc_GetCodec( VIDEO_ES, p_fmt->i_chroma );
 253
 254     vlc_ureduce( &p_fmt->i_sar_num, &p_fmt->i_sar_den,
 255                  p_fmt->i_sar_num, p_fmt->i_sar_den, 50000 );
 256     if( p_fmt->i_sar_num <= 0 || p_fmt->i_sar_den <= 0 )
 257         return NULL;
 258
 259     /* Allocate descriptor */
 260     static const char typename[] = "video output";
 261     p_vout = vlc_custom_create( p_parent, sizeof( *p_vout ), VLC_OBJECT_VOUT,
 262                                 typename );
 263     if( p_vout == NULL )
 264         return NULL;
 265
 266     /* */
 267     p_vout->p = calloc( 1, sizeof(*p_vout->p) );
 268     if( !p_vout->p )
 269     {
 270         vlc_object_release( p_vout );
 271         return NULL;
 272     }
 273
 274     /* */
 275     p_vout->fmt_render        = *p_fmt;   /* FIXME palette */
 276     p_vout->fmt_in            = *p_fmt;   /* FIXME palette */
 277
 278     p_vout->fmt_render.i_chroma =
 279     p_vout->fmt_in.i_chroma     = i_chroma;
 280     video_format_FixRgb( &p_vout->fmt_render );
 281     video_format_FixRgb( &p_vout->fmt_in );
 282
 283     /* Initialize misc stuff */
 284     vout_control_Init( &p_vout->p->control );
 285     p_vout->p->i_changes    = 0;
 286     p_vout->p->b_fullscreen = 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 void vout_FixLeaks( 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 = picture_pool_Get(vout->p->decoder_pool);
 523     }
 524
 525     if (picture) {
 526         picture_Release(picture);
 527         /* Not all pictures has been displayed yet or some are
 528          * free */
 529         vlc_mutex_unlock(&vout->p->picture_lock);
 530         return;
 531     }
 532
 533     /* There is no reason that no pictures are available, force one
 534      * from the pool, becarefull with it though */
 535     msg_Err(vout, "pictures leaked, trying to workaround");
 536
 537     /* */
 538     picture_pool_NonEmpty(vout->p->decoder_pool, false);
 539
 540     vlc_mutex_unlock(&vout->p->picture_lock);
 541 }
 542 void vout_NextPicture(vout_thread_t *vout, mtime_t *duration)
 543 {
 544     vout_control_cmd_t cmd;
 545     vout_control_cmd_Init(&cmd, VOUT_CONTROL_STEP);
 546     cmd.u.time_ptr = duration;
 547
 548     vout_control_Push(&vout->p->control, &cmd);
 549     vout_control_WaitEmpty(&vout->p->control);
 550 }
 551
 552 void vout_DisplayTitle(vout_thread_t *vout, const char *title)
 553 {
 554     assert(title);
 555     vout_control_PushString(&vout->p->control, VOUT_CONTROL_OSD_TITLE, title);
 556 }
 557
 558 spu_t *vout_GetSpu( vout_thread_t *p_vout )
 559 {
 560     return p_vout->p->p_spu;
 561 }
 562
 563 /*****************************************************************************
 564  * InitThread: initialize video output thread
 565  *****************************************************************************
 566  * This function is called from Thread and performs the second step of the
 567  * initialization. It returns 0 on success. Note that the thread's flag are not
 568  * modified inside this function.
 569  * XXX You have to enter it with change_lock taken.
 570  *****************************************************************************/
 571 static int ThreadInit(vout_thread_t *vout)
 572 {
 573     /* Initialize output method, it allocates direct buffers for us */
 574     if (vout_InitWrapper(vout))
 575         return VLC_EGENERIC;
 576     assert(vout->p->decoder_pool);
 577
 578     vout->p->displayed.decoded = NULL;
 579
 580     /* print some usefull debug info about different vout formats
 581      */
 582     PrintVideoFormat(vout, "pic render", &vout->fmt_render);
 583     PrintVideoFormat(vout, "pic in",     &vout->fmt_in);
 584     PrintVideoFormat(vout, "pic out",    &vout->fmt_out);
 585
 586     assert(vout->fmt_out.i_width  == vout->fmt_render.i_width &&
 587            vout->fmt_out.i_height == vout->fmt_render.i_height &&
 588            vout->fmt_out.i_chroma == vout->fmt_render.i_chroma);
 589     return VLC_SUCCESS;
 590 }
 591
 592 /*****************************************************************************
 593  * CleanThread: clean up after InitThread
 594  *****************************************************************************
 595  * This function is called after a sucessful
 596  * initialization. It frees all resources allocated by InitThread.
 597  * XXX You have to enter it with change_lock taken.
 598  *****************************************************************************/
 599 static void ThreadClean(vout_thread_t *vout)
 600 {
 601     /* Destroy translation tables */
 602     if (!vout->p->b_error) {
 603         picture_fifo_Flush(vout->p->decoder_fifo, INT64_MAX, false);
 604         vout_EndWrapper(vout);
 605     }
 606 }
 607
 608 static int ThreadDisplayPicture(vout_thread_t *vout,
 609                                 bool now, mtime_t *deadline)
 610 {
 611     int displayed_count = 0;
 612     int lost_count = 0;
 613
 614     for (;;) {
 615         const mtime_t date = mdate();
 616         const bool is_paused = vout->p->pause.is_on;
 617         bool redisplay = is_paused && !now && vout->p->displayed.decoded;
 618         bool is_forced;
 619
 620         /* FIXME/XXX we must redisplay the last decoded picture (because
 621          * of potential vout updated, or filters update or SPU update)
 622          * For now a high update period is needed but it coulmd be removed
 623          * if and only if:
 624          * - vout module emits events from theselves.
 625          * - *and* SPU is modified to emit an event or a deadline when needed.
 626          *
 627          * So it will be done latter.
 628          */
 629         if (!redisplay) {
 630             picture_t *peek = picture_fifo_Peek(vout->p->decoder_fifo);
 631             if (peek) {
 632                 is_forced = peek->b_force || is_paused || now;
 633                 *deadline = (is_forced ? date : peek->date) - vout_chrono_GetHigh(&vout->p->render);
 634                 picture_Release(peek);
 635             } else {
 636                 redisplay = true;
 637             }
 638         }
 639         if (redisplay) {
 640              /* FIXME a better way for this delay is needed */
 641             const mtime_t date_update = vout->p->displayed.date + VOUT_REDISPLAY_DELAY;
 642             if (date_update > date || !vout->p->displayed.decoded) {
 643                 *deadline = vout->p->displayed.decoded ? date_update : VLC_TS_INVALID;
 644                 break;
 645             }
 646             /* */
 647             is_forced = true;
 648             *deadline = date - vout_chrono_GetHigh(&vout->p->render);
 649         }
 650         if (*deadline > VOUT_MWAIT_TOLERANCE)
 651             *deadline -= VOUT_MWAIT_TOLERANCE;
 652
 653         /* If we are too early and can wait, do it */
 654         if (date < *deadline && !now)
 655             break;
 656
 657         picture_t *decoded;
 658         if (redisplay) {
 659             decoded = vout->p->displayed.decoded;
 660             vout->p->displayed.decoded = NULL;
 661         } else {
 662             decoded = picture_fifo_Pop(vout->p->decoder_fifo);
 663             assert(decoded);
 664             if (!is_forced && !vout->p->is_late_dropped) {
 665                 const mtime_t predicted = date + vout_chrono_GetLow(&vout->p->render);
 666                 const mtime_t late = predicted - decoded->date;
 667                 if (late > 0) {
 668                     msg_Dbg(vout, "picture might be displayed late (missing %d ms)", (int)(late/1000));
 669                     if (late > VOUT_DISPLAY_LATE_THRESHOLD) {
 670                         msg_Warn(vout, "rejected picture because of render time");
 671                         /* TODO */
 672                         picture_Release(decoded);
 673                         lost_count++;
 674                         break;
 675                     }
 676                 }
 677             }
 678
 679             vout->p->displayed.is_interlaced = !decoded->b_progressive;
 680             vout->p->displayed.qtype         = decoded->i_qtype;
 681         }
 682         vout->p->displayed.timestamp = decoded->date;
 683
 684         /* */
 685         if (vout->p->displayed.decoded)
 686             picture_Release(vout->p->displayed.decoded);
 687         picture_Hold(decoded);
 688         vout->p->displayed.decoded = decoded;
 689
 690         /* */
 691         vout_chrono_Start(&vout->p->render);
 692
 693         picture_t *filtered = NULL;
 694         if (decoded) {
 695             vlc_mutex_lock(&vout->p->vfilter_lock);
 696             filtered = filter_chain_VideoFilter(vout->p->p_vf2_chain, decoded);
 697             //assert(filtered == decoded); // TODO implement
 698             vlc_mutex_unlock(&vout->p->vfilter_lock);
 699             if (!filtered)
 700                 continue;
 701         }
 702
 703         /*
 704          * Check for subpictures to display
 705          */
 706         const bool do_snapshot = vout_snapshot_IsRequested(&vout->p->snapshot);
 707         mtime_t spu_render_time = is_forced ? mdate() : filtered->date;
 708         if (vout->p->pause.is_on)
 709             spu_render_time = vout->p->pause.date;
 710         else
 711             spu_render_time = filtered->date > 1 ? filtered->date : mdate();
 712
 713         subpicture_t *subpic = spu_SortSubpictures(vout->p->p_spu,
 714                                                    spu_render_time,
 715                                                    do_snapshot);
 716         /*
 717          * Perform rendering
 718          *
 719          * We have to:
 720          * - be sure to end up with a direct buffer.
 721          * - blend subtitles, and in a fast access buffer
 722          */
 723         picture_t *direct = NULL;
 724         if (filtered &&
 725             (vout->p->decoder_pool != vout->p->display_pool || subpic)) {
 726             picture_t *render;
 727             if (vout->p->is_decoder_pool_slow)
 728                 render = picture_NewFromFormat(&vout->fmt_out);
 729             else if (vout->p->decoder_pool != vout->p->display_pool)
 730                 render = picture_pool_Get(vout->p->display_pool);
 731             else
 732                 render = picture_pool_Get(vout->p->private_pool);
 733
 734             if (render) {
 735                 picture_Copy(render, filtered);
 736
 737                 spu_RenderSubpictures(vout->p->p_spu,
 738                                       render, &vout->fmt_out,
 739                                       subpic, &vout->fmt_in, spu_render_time);
 740             }
 741             if (vout->p->is_decoder_pool_slow) {
 742                 direct = picture_pool_Get(vout->p->display_pool);
 743                 if (direct)
 744                     picture_Copy(direct, render);
 745                 picture_Release(render);
 746
 747             } else {
 748                 direct = render;
 749             }
 750             picture_Release(filtered);
 751             filtered = NULL;
 752         } else {
 753             direct = filtered;
 754         }
 755
 756         /*
 757          * Take a snapshot if requested
 758          */
 759         if (direct && do_snapshot)
 760             vout_snapshot_Set(&vout->p->snapshot, &vout->fmt_out, direct);
 761
 762         /* Render the direct buffer returned by vout_RenderPicture */
 763         if (direct) {
 764             vout_RenderWrapper(vout, direct);
 765
 766             vout_chrono_Stop(&vout->p->render);
 767 #if 0
 768             {
 769             static int i = 0;
 770             if (((i++)%10) == 0)
 771                 msg_Info(vout, "render: avg %d ms var %d ms",
 772                          (int)(vout->p->render.avg/1000), (int)(vout->p->render.var/1000));
 773             }
 774 #endif
 775         }
 776
 777         /* Wait the real date (for rendering jitter) */
 778         if (!is_forced)
 779             mwait(decoded->date);
 780
 781         /* Display the direct buffer returned by vout_RenderPicture */
 782         vout->p->displayed.date = mdate();
 783         if (direct)
 784             vout_DisplayWrapper(vout, direct);
 785
 786         displayed_count++;
 787         break;
 788     }
 789
 790     vout_statistic_Update(&vout->p->statistic, displayed_count, lost_count);
 791     if (displayed_count <= 0)
 792         return VLC_EGENERIC;
 793     return VLC_SUCCESS;
 794 }
 795
 796 static int ThreadManage(vout_thread_t *vout,
 797                         mtime_t *deadline,
 798                         vout_interlacing_support_t *interlacing,
 799                         vout_postprocessing_support_t *postprocessing)
 800 {
 801     vlc_mutex_lock(&vout->p->picture_lock);
 802
 803     *deadline = VLC_TS_INVALID;
 804     ThreadDisplayPicture(vout, false, deadline);
 805
 806     const int  picture_qtype      = vout->p->displayed.qtype;
 807     const bool picture_interlaced = vout->p->displayed.is_interlaced;
 808
 809     vlc_mutex_unlock(&vout->p->picture_lock);
 810
 811     /* Post processing */
 812     vout_SetPostProcessingState(vout, postprocessing, picture_qtype);
 813
 814     /* Deinterlacing */
 815     vout_SetInterlacingState(vout, interlacing, picture_interlaced);
 816
 817     if (vout_ManageWrapper(vout)) {
 818         /* A fatal error occurred, and the thread must terminate
 819          * immediately, without displaying anything - setting b_error to 1
 820          * causes the immediate end of the main while() loop. */
 821         // FIXME pf_end
 822         return VLC_EGENERIC;
 823     }
 824     return VLC_SUCCESS;
 825 }
 826
 827 static void ThreadDisplayOsdTitle(vout_thread_t *vout, const char *string)
 828 {
 829     if( !var_InheritBool(vout, "osd"))
 830         return;
 831     if (!vout->p->title.show)
 832         return;
 833
 834     vlc_assert_locked(&vout->p->change_lock);
 835
 836     const mtime_t start = mdate();
 837     const mtime_t stop = start +
 838                          INT64_C(1000) * vout->p->title.timeout;
 839
 840     if (stop > start)
 841         vout_ShowTextAbsolute(vout, DEFAULT_CHAN,
 842                               string, NULL,
 843                               vout->p->title.position,
 844                               30 + vout->fmt_in.i_width
 845                                  - vout->fmt_in.i_visible_width
 846                                  - vout->fmt_in.i_x_offset,
 847                               20 + vout->fmt_in.i_y_offset,
 848                               start, stop);
 849 }
 850
 851 static void ThreadChangeFilters(vout_thread_t *vout, const char *filters)
 852 {
 853     es_format_t fmt;
 854     es_format_Init(&fmt, VIDEO_ES, vout->fmt_render.i_chroma);
 855     fmt.video = vout->fmt_render;
 856
 857     vlc_mutex_lock(&vout->p->vfilter_lock);
 858
 859     filter_chain_Reset(vout->p->p_vf2_chain, &fmt, &fmt);
 860     if (filter_chain_AppendFromString(vout->p->p_vf2_chain,
 861                                       filters) < 0)
 862         msg_Err(vout, "Video filter chain creation failed");
 863
 864     vlc_mutex_unlock(&vout->p->vfilter_lock);
 865 }
 866
 867 static void ThreadChangePause(vout_thread_t *vout, bool is_paused, mtime_t date)
 868 {
 869     vlc_assert_locked(&vout->p->change_lock);
 870     assert(!vout->p->pause.is_on || !is_paused);
 871
 872     if (vout->p->pause.is_on) {
 873         const mtime_t duration = date - vout->p->pause.date;
 874
 875         if (vout->p->step.timestamp > VLC_TS_INVALID)
 876             vout->p->step.timestamp += duration;
 877         if (vout->p->step.last > VLC_TS_INVALID)
 878             vout->p->step.last += duration;
 879         picture_fifo_OffsetDate(vout->p->decoder_fifo, duration);
 880         if (vout->p->displayed.decoded)
 881             vout->p->displayed.decoded->date += duration;
 882
 883         spu_OffsetSubtitleDate(vout->p->p_spu, duration);
 884     } else {
 885         vout->p->step.timestamp = VLC_TS_INVALID;
 886         vout->p->step.last      = VLC_TS_INVALID;
 887     }
 888     vout->p->pause.is_on = is_paused;
 889     vout->p->pause.date  = date;
 890 }
 891
 892 static void ThreadFlush(vout_thread_t *vout, bool below, mtime_t date)
 893 {
 894     vout->p->step.timestamp = VLC_TS_INVALID;
 895     vout->p->step.last      = VLC_TS_INVALID;
 896
 897     picture_t *last = vout->p->displayed.decoded;
 898     if (last) {
 899         if (( below && last->date <= date) ||
 900             (!below && last->date >= date)) {
 901             picture_Release(last);
 902
 903             vout->p->displayed.decoded   = NULL;
 904             vout->p->displayed.date      = VLC_TS_INVALID;
 905             vout->p->displayed.timestamp = VLC_TS_INVALID;
 906         }
 907     }
 908     picture_fifo_Flush(vout->p->decoder_fifo, date, below);
 909 }
 910
 911 static void ThreadReset(vout_thread_t *vout)
 912 {
 913     ThreadFlush(vout, true, INT64_MAX);
 914     if (vout->p->decoder_pool)
 915         picture_pool_NonEmpty(vout->p->decoder_pool, true);
 916     vout->p->pause.is_on = false;
 917     vout->p->pause.date  = mdate();
 918 }
 919
 920 static void ThreadStep(vout_thread_t *vout, mtime_t *duration)
 921 {
 922     *duration = 0;
 923
 924     if (vout->p->step.last <= VLC_TS_INVALID)
 925         vout->p->step.last = vout->p->displayed.timestamp;
 926
 927     mtime_t dummy;
 928     if (ThreadDisplayPicture(vout, true, &dummy))
 929         return;
 930
 931     vout->p->step.timestamp = vout->p->displayed.timestamp;
 932
 933     if (vout->p->step.last > VLC_TS_INVALID &&
 934         vout->p->step.timestamp > vout->p->step.last) {
 935         *duration = vout->p->step.timestamp - vout->p->step.last;
 936         vout->p->step.last = vout->p->step.timestamp;
 937         /* TODO advance subpicture by the duration ... */
 938     }
 939 }
 940
 941
 942 /*****************************************************************************
 943  * Thread: video output thread
 944  *****************************************************************************
 945  * Video output thread. This function does only returns when the thread is
 946  * terminated. It handles the pictures arriving in the video heap and the
 947  * display device events.
 948  *****************************************************************************/
 949 static void *Thread(void *object)
 950 {
 951     vout_thread_t *vout = object;
 952     bool          has_wrapper;
 953
 954     /*
 955      * Initialize thread
 956      */
 957     has_wrapper = !vout_OpenWrapper(vout, vout->p->psz_module_name);
 958
 959     vlc_mutex_lock(&vout->p->change_lock);
 960
 961     if (has_wrapper)
 962         vout->p->b_error = ThreadInit(vout);
 963     else
 964         vout->p->b_error = true;
 965
 966     /* signal the creation of the vout */
 967     vout->p->b_ready = true;
 968     vlc_cond_signal(&vout->p->change_wait);
 969
 970     if (vout->p->b_error)
 971         goto exit_thread;
 972
 973     /* */
 974     vout_interlacing_support_t interlacing = {
 975         .is_interlaced = false,
 976         .date = mdate(),
 977     };
 978     vout_postprocessing_support_t postprocessing = {
 979         .qtype = QTYPE_NONE,
 980     };
 981
 982     /*
 983      * Main loop - it is not executed if an error occurred during
 984      * initialization
 985      */
 986     mtime_t deadline = VLC_TS_INVALID;
 987     while (!vout->p->b_done && !vout->p->b_error) {
 988         vout_control_cmd_t cmd;
 989
 990         vlc_mutex_unlock(&vout->p->change_lock);
 991         /* FIXME remove thoses ugly timeouts
 992          */
 993         while (!vout_control_Pop(&vout->p->control, &cmd, deadline, 100000)) {
 994             /* TODO remove the lock when possible (ie when
 995              * vout->fmt_* are not protected by it anymore) */
 996             vlc_mutex_lock(&vout->p->change_lock);
 997             switch(cmd.type) {
 998             case VOUT_CONTROL_OSD_TITLE:
 999                 ThreadDisplayOsdTitle(vout, cmd.u.string);
1000                 break;
1001             case VOUT_CONTROL_CHANGE_FILTERS:
1002                 ThreadChangeFilters(vout, cmd.u.string);
1003                 break;
1004             case VOUT_CONTROL_PAUSE:
1005                 ThreadChangePause(vout, cmd.u.pause.is_on, cmd.u.pause.date);
1006                 break;
1007             case VOUT_CONTROL_FLUSH:
1008                 ThreadFlush(vout, false, cmd.u.time);
1009                 break;
1010             case VOUT_CONTROL_RESET:
1011                 ThreadReset(vout);
1012                 break;
1013             case VOUT_CONTROL_STEP:
1014                 ThreadStep(vout, cmd.u.time_ptr);
1015                 break;
1016             default:
1017                 break;
1018             }
1019             vlc_mutex_unlock(&vout->p->change_lock);
1020             vout_control_cmd_Clean(&cmd);
1021         }
1022         vlc_mutex_lock(&vout->p->change_lock);
1023
1024         /* */
1025         if (ThreadManage(vout, &deadline,
1026                          &interlacing, &postprocessing)) {
1027             vout->p->b_error = true;
1028             break;
1029         }
1030     }
1031
1032     /*
1033      * Error loop - wait until the thread destruction is requested
1034      *
1035      * XXX I wonder if we should periodically clean the decoder_fifo
1036      * or have a way to prevent it filling up.
1037      */
1038     while (vout->p->b_error && !vout->p->b_done)
1039         vlc_cond_wait(&vout->p->change_wait, &vout->p->change_lock);
1040
1041     /* Clean thread */
1042     ThreadClean(vout);
1043
1044 exit_thread:
1045     /* Detach subpicture unit from both input and vout */
1046     spu_Attach(vout->p->p_spu, VLC_OBJECT(vout), false);
1047     vlc_object_detach(vout->p->p_spu);
1048
1049     vlc_mutex_unlock(&vout->p->change_lock);
1050
1051     if (has_wrapper)
1052         vout_CloseWrapper(vout);
1053     vout_control_Dead(&vout->p->control);
1054
1055     /* Destroy the video filters2 */
1056     filter_chain_Delete(vout->p->p_vf2_chain);
1057
1058     return NULL;
1059 }
1060
1061 /*****************************************************************************
1062  * object variables callbacks: a bunch of object variables are used by the
1063  * interfaces to interact with the vout.
1064  *****************************************************************************/
1065 static int FilterCallback( vlc_object_t *p_this, char const *psz_cmd,
1066                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
1067 {
1068     vout_thread_t *p_vout = (vout_thread_t *)p_this;
1069     input_thread_t *p_input;
1070     (void)psz_cmd; (void)oldval; (void)p_data;
1071
1072     p_input = (input_thread_t *)vlc_object_find( p_this, VLC_OBJECT_INPUT,
1073                                                  FIND_PARENT );
1074     if (!p_input)
1075     {
1076         msg_Err( p_vout, "Input not found" );
1077         return VLC_EGENERIC;
1078     }
1079
1080     var_SetBool( p_vout, "intf-change", true );
1081
1082     /* Modify input as well because the vout might have to be restarted */
1083     var_Create( p_input, "vout-filter", VLC_VAR_STRING );
1084     var_SetString( p_input, "vout-filter", newval.psz_string );
1085
1086     /* Now restart current video stream */
1087     input_Control( p_input, INPUT_RESTART_ES, -VIDEO_ES );
1088     vlc_object_release( p_input );
1089
1090     return VLC_SUCCESS;
1091 }
1092
1093 /*****************************************************************************
1094  * Video Filter2 stuff
1095  *****************************************************************************/
1096 static int VideoFilter2Callback(vlc_object_t *object, char const *cmd,
1097                                 vlc_value_t oldval, vlc_value_t newval,
1098                                 void *data)
1099 {
1100     vout_thread_t *vout = (vout_thread_t *)object;
1101     (void)cmd; (void)oldval; (void)data;
1102
1103     vout_control_PushString(&vout->p->control, VOUT_CONTROL_CHANGE_FILTERS,
1104                             newval.psz_string);
1105     return VLC_SUCCESS;
1106 }
1107
1108 /* */
1109 static void PrintVideoFormat(vout_thread_t *vout,
1110                              const char *description,
1111                              const video_format_t *fmt)
1112 {
1113     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",
1114             description,
1115             fmt->i_width, fmt->i_height, fmt->i_x_offset, fmt->i_y_offset,
1116             fmt->i_visible_width, fmt->i_visible_height,
1117             (char*)&fmt->i_chroma,
1118             fmt->i_sar_num, fmt->i_sar_den,
1119             fmt->i_rmask, fmt->i_gmask, fmt->i_bmask);
1120 }
1121