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     p_vout->p->i_changes    = 0;
 285     p_vout->p->b_fullscreen = 0;
 286     vout_chrono_Init( &p_vout->p->render, 5, 10000 ); /* Arbitrary initial time */
 287     vout_statistic_Init( &p_vout->p->statistic );
 288     p_vout->p->b_filter_change = 0;
 289     p_vout->p->i_par_num =
 290     p_vout->p->i_par_den = 1;
 291     p_vout->p->b_picture_empty = false;
 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.is_requested = false;
 299     p_vout->p->step.last         = VLC_TS_INVALID;
 300     p_vout->p->step.timestamp    = VLC_TS_INVALID;
 301
 302     p_vout->p->pause.is_on  = false;
 303     p_vout->p->pause.date   = VLC_TS_INVALID;
 304
 305     p_vout->p->decoder_fifo = picture_fifo_New();
 306     p_vout->p->decoder_pool = NULL;
 307
 308     vlc_mouse_Init( &p_vout->p->mouse );
 309
 310     vout_snapshot_Init( &p_vout->p->snapshot );
 311
 312     /* Initialize locks */
 313     vlc_mutex_init( &p_vout->p->picture_lock );
 314     vlc_cond_init( &p_vout->p->picture_wait );
 315     vlc_mutex_init( &p_vout->p->change_lock );
 316     vlc_mutex_init( &p_vout->p->vfilter_lock );
 317
 318     /* Mouse coordinates */
 319     var_Create( p_vout, "mouse-button-down", VLC_VAR_INTEGER );
 320     var_Create( p_vout, "mouse-moved", VLC_VAR_COORDS );
 321     var_Create( p_vout, "mouse-clicked", VLC_VAR_COORDS );
 322     /* Mouse object (area of interest in a video filter) */
 323     var_Create( p_vout, "mouse-object", VLC_VAR_BOOL );
 324
 325     /* Attach the new object now so we can use var inheritance below */
 326     vlc_object_attach( p_vout, p_parent );
 327
 328     /* Initialize subpicture unit */
 329     p_vout->p->p_spu = spu_Create( p_vout );
 330
 331     /* */
 332     spu_Init( p_vout->p->p_spu );
 333
 334     spu_Attach( p_vout->p->p_spu, VLC_OBJECT(p_vout), true );
 335
 336     p_vout->p->is_late_dropped = var_InheritBool( p_vout, "drop-late-frames" );
 337
 338     /* Take care of some "interface/control" related initialisations */
 339     vout_IntfInit( p_vout );
 340
 341     /* Look for the default filter configuration */
 342     p_vout->p->psz_filter_chain =
 343         var_CreateGetStringCommand( p_vout, "vout-filter" );
 344
 345     /* Apply video filter2 objects on the first vout */
 346     p_vout->p->psz_vf2 =
 347         var_CreateGetStringCommand( p_vout, "video-filter" );
 348
 349     var_AddCallback( p_vout, "video-filter", VideoFilter2Callback, NULL );
 350     p_vout->p->p_vf2_chain = filter_chain_New( p_vout, "video filter2",
 351         false, video_filter_buffer_allocation_init, NULL, p_vout );
 352
 353     /* Choose the video output module */
 354     if( !p_vout->p->psz_filter_chain || !*p_vout->p->psz_filter_chain )
 355     {
 356         psz_parser = NULL;
 357     }
 358     else
 359     {
 360         psz_parser = strdup( p_vout->p->psz_filter_chain );
 361         p_vout->p->title.show = false;
 362     }
 363
 364     /* Create the vout thread */
 365     char *psz_tmp = config_ChainCreate( &psz_name, &p_cfg, psz_parser );
 366     free( psz_parser );
 367     free( psz_tmp );
 368     p_vout->p->p_cfg = p_cfg;
 369
 370     /* Create a few object variables for interface interaction */
 371     var_Create( p_vout, "vout-filter", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 372     text.psz_string = _("Filters");
 373     var_Change( p_vout, "vout-filter", VLC_VAR_SETTEXT, &text, NULL );
 374     var_AddCallback( p_vout, "vout-filter", FilterCallback, NULL );
 375
 376     /* */
 377     vout_InitInterlacingSupport( p_vout, p_vout->p->displayed.is_interlaced );
 378
 379     if( p_vout->p->psz_filter_chain && *p_vout->p->psz_filter_chain )
 380     {
 381         char *psz_tmp;
 382         if( asprintf( &psz_tmp, "%s,none", psz_name ) < 0 )
 383             psz_tmp = strdup( "" );
 384         free( psz_name );
 385         psz_name = psz_tmp;
 386     }
 387     p_vout->p->psz_module_name = psz_name;
 388
 389     /* */
 390     vlc_object_set_destructor( p_vout, vout_Destructor );
 391
 392     /* */
 393     vlc_cond_init( &p_vout->p->change_wait );
 394     if( vlc_clone( &p_vout->p->thread, Thread, p_vout,
 395                    VLC_THREAD_PRIORITY_OUTPUT ) )
 396     {
 397         spu_Attach( p_vout->p->p_spu, VLC_OBJECT(p_vout), false );
 398         spu_Destroy( p_vout->p->p_spu );
 399         p_vout->p->p_spu = NULL;
 400         vlc_object_release( p_vout );
 401         return NULL;
 402     }
 403
 404     vlc_mutex_lock( &p_vout->p->change_lock );
 405     while( !p_vout->p->b_ready )
 406     {   /* We are (ab)using the same condition in opposite directions for
 407          * b_ready and b_done. This works because of the strict ordering. */
 408         assert( !p_vout->p->b_done );
 409         vlc_cond_wait( &p_vout->p->change_wait, &p_vout->p->change_lock );
 410     }
 411     vlc_mutex_unlock( &p_vout->p->change_lock );
 412
 413     if( p_vout->p->b_error )
 414     {
 415         msg_Err( p_vout, "video output creation failed" );
 416         vout_CloseAndRelease( p_vout );
 417         return NULL;
 418     }
 419
 420     return p_vout;
 421 }
 422
 423 /*****************************************************************************
 424  * vout_Close: Close a vout created by vout_Create.
 425  *****************************************************************************
 426  * You HAVE to call it on vout created by vout_Create before vlc_object_release.
 427  * You should NEVER call it on vout not obtained through vout_Create
 428  * (like with vout_Request or vlc_object_find.)
 429  * You can use vout_CloseAndRelease() as a convenience method.
 430  *****************************************************************************/
 431 void vout_Close( vout_thread_t *p_vout )
 432 {
 433     assert( p_vout );
 434
 435     vlc_mutex_lock( &p_vout->p->change_lock );
 436     p_vout->p->b_done = true;
 437     vlc_cond_signal( &p_vout->p->change_wait );
 438     vlc_mutex_unlock( &p_vout->p->change_lock );
 439
 440     vout_snapshot_End( &p_vout->p->snapshot );
 441
 442     vlc_join( p_vout->p->thread, NULL );
 443 }
 444
 445 /* */
 446 static void vout_Destructor( vlc_object_t * p_this )
 447 {
 448     vout_thread_t *p_vout = (vout_thread_t *)p_this;
 449
 450     /* Make sure the vout was stopped first */
 451     //assert( !p_vout->p_module );
 452
 453     free( p_vout->p->psz_module_name );
 454
 455     /* */
 456     if( p_vout->p->p_spu )
 457         spu_Destroy( p_vout->p->p_spu );
 458
 459     vout_chrono_Clean( &p_vout->p->render );
 460
 461     if( p_vout->p->decoder_fifo )
 462         picture_fifo_Delete( p_vout->p->decoder_fifo );
 463     assert( !p_vout->p->decoder_pool );
 464
 465     /* Destroy the locks */
 466     vlc_cond_destroy( &p_vout->p->change_wait );
 467     vlc_cond_destroy( &p_vout->p->picture_wait );
 468     vlc_mutex_destroy( &p_vout->p->picture_lock );
 469     vlc_mutex_destroy( &p_vout->p->change_lock );
 470     vlc_mutex_destroy( &p_vout->p->vfilter_lock );
 471
 472     /* */
 473     vout_statistic_Clean( &p_vout->p->statistic );
 474
 475     /* */
 476     vout_snapshot_Clean( &p_vout->p->snapshot );
 477
 478     /* */
 479     free( p_vout->p->psz_filter_chain );
 480     free( p_vout->p->title.value );
 481
 482     config_ChainDestroy( p_vout->p->p_cfg );
 483
 484     free( p_vout->p );
 485
 486 }
 487
 488 /* */
 489 void vout_ChangePause( vout_thread_t *p_vout, bool b_paused, mtime_t i_date )
 490 {
 491     vlc_mutex_lock( &p_vout->p->change_lock );
 492
 493     assert( !p_vout->p->pause.is_on || !b_paused );
 494
 495     vlc_mutex_lock( &p_vout->p->picture_lock );
 496
 497     if( p_vout->p->pause.is_on )
 498     {
 499         const mtime_t i_duration = i_date - p_vout->p->pause.date;
 500
 501         if (p_vout->p->step.timestamp > VLC_TS_INVALID)
 502             p_vout->p->step.timestamp += i_duration;
 503         if (!b_paused)
 504             p_vout->p->step.last = p_vout->p->step.timestamp;
 505         picture_fifo_OffsetDate( p_vout->p->decoder_fifo, i_duration );
 506         if (p_vout->p->displayed.decoded)
 507             p_vout->p->displayed.decoded->date += i_duration;
 508
 509         vlc_cond_signal( &p_vout->p->picture_wait );
 510         vlc_mutex_unlock( &p_vout->p->picture_lock );
 511
 512         spu_OffsetSubtitleDate( p_vout->p->p_spu, i_duration );
 513     }
 514     else
 515     {
 516         if (b_paused)
 517             p_vout->p->step.last = p_vout->p->step.timestamp;
 518         vlc_mutex_unlock( &p_vout->p->picture_lock );
 519     }
 520     p_vout->p->pause.is_on = b_paused;
 521     p_vout->p->pause.date  = i_date;
 522
 523     vlc_mutex_unlock( &p_vout->p->change_lock );
 524 }
 525
 526 void vout_GetResetStatistic( vout_thread_t *p_vout, int *pi_displayed, int *pi_lost )
 527 {
 528     vout_statistic_GetReset( &p_vout->p->statistic,
 529                              pi_displayed, pi_lost );
 530 }
 531
 532 static void Flush(vout_thread_t *vout, mtime_t date, bool reset, bool below)
 533 {
 534     vlc_assert_locked(&vout->p->picture_lock);
 535     vout->p->step.timestamp = VLC_TS_INVALID;
 536     vout->p->step.last      = VLC_TS_INVALID;
 537
 538     picture_t *last = vout->p->displayed.decoded;
 539     if (last) {
 540         if (reset) {
 541             picture_Release(last);
 542             vout->p->displayed.decoded = NULL;
 543         } else if (( below  && last->date <= date) ||
 544                    (!below && last->date >= date)) {
 545             vout->p->step.is_requested = true;
 546         }
 547     }
 548     picture_fifo_Flush( vout->p->decoder_fifo, date, below );
 549 }
 550
 551 void vout_Flush(vout_thread_t *vout, mtime_t date)
 552 {
 553     vlc_mutex_lock(&vout->p->picture_lock);
 554
 555     Flush(vout, date, false, false);
 556
 557     vlc_cond_signal(&vout->p->picture_wait);
 558     vlc_mutex_unlock(&vout->p->picture_lock);
 559 }
 560
 561 void vout_Reset(vout_thread_t *vout)
 562 {
 563     vlc_mutex_lock(&vout->p->picture_lock);
 564
 565     Flush(vout, INT64_MAX, true, true);
 566     if (vout->p->decoder_pool)
 567         picture_pool_NonEmpty(vout->p->decoder_pool, true);
 568     vout->p->pause.is_on = false;
 569     vout->p->pause.date  = mdate();
 570
 571     vlc_cond_signal( &vout->p->picture_wait );
 572     vlc_mutex_unlock(&vout->p->picture_lock);
 573 }
 574
 575 void vout_FixLeaks( vout_thread_t *vout )
 576 {
 577     vlc_mutex_lock(&vout->p->picture_lock);
 578
 579     picture_t *picture = picture_fifo_Peek(vout->p->decoder_fifo);
 580     if (!picture) {
 581         picture = picture_pool_Get(vout->p->decoder_pool);
 582     }
 583
 584     if (picture) {
 585         picture_Release(picture);
 586         /* Not all pictures has been displayed yet or some are
 587          * free */
 588         vlc_mutex_unlock(&vout->p->picture_lock);
 589         return;
 590     }
 591
 592     /* There is no reason that no pictures are available, force one
 593      * from the pool, becarefull with it though */
 594     msg_Err(vout, "pictures leaked, trying to workaround");
 595
 596     /* */
 597     picture_pool_NonEmpty(vout->p->decoder_pool, false);
 598
 599     vlc_cond_signal(&vout->p->picture_wait);
 600     vlc_mutex_unlock(&vout->p->picture_lock);
 601 }
 602 void vout_NextPicture(vout_thread_t *vout, mtime_t *duration)
 603 {
 604     vlc_mutex_lock(&vout->p->picture_lock);
 605
 606     vout->p->b_picture_empty = false;
 607     vout->p->step.is_requested = true;
 608
 609     /* FIXME I highly doubt that it can works with only one cond_t FIXME */
 610     vlc_cond_signal(&vout->p->picture_wait);
 611
 612     while (vout->p->step.is_requested && !vout->p->b_picture_empty)
 613         vlc_cond_wait(&vout->p->picture_wait, &vout->p->picture_lock);
 614
 615     if (vout->p->step.last > VLC_TS_INVALID &&
 616         vout->p->step.timestamp > vout->p->step.last) {
 617         *duration = vout->p->step.timestamp - vout->p->step.last;
 618         vout->p->step.last = vout->p->step.timestamp;
 619     } else {
 620         *duration = 0;
 621     }
 622
 623     /* TODO advance subpicture by the duration ... */
 624     vlc_mutex_unlock(&vout->p->picture_lock);
 625 }
 626
 627 void vout_DisplayTitle( vout_thread_t *p_vout, const char *psz_title )
 628 {
 629     assert( psz_title );
 630
 631     if( !var_InheritBool( p_vout, "osd" ) )
 632         return;
 633
 634     vlc_mutex_lock( &p_vout->p->change_lock );
 635     free( p_vout->p->title.value );
 636     p_vout->p->title.value = strdup( psz_title );
 637     vlc_mutex_unlock( &p_vout->p->change_lock );
 638 }
 639
 640 spu_t *vout_GetSpu( vout_thread_t *p_vout )
 641 {
 642     return p_vout->p->p_spu;
 643 }
 644
 645 /*****************************************************************************
 646  * InitThread: initialize video output thread
 647  *****************************************************************************
 648  * This function is called from Thread and performs the second step of the
 649  * initialization. It returns 0 on success. Note that the thread's flag are not
 650  * modified inside this function.
 651  * XXX You have to enter it with change_lock taken.
 652  *****************************************************************************/
 653 static int ThreadInit(vout_thread_t *vout)
 654 {
 655     /* Initialize output method, it allocates direct buffers for us */
 656     if (vout_InitWrapper(vout))
 657         return VLC_EGENERIC;
 658     assert(vout->p->decoder_pool);
 659
 660     vout->p->displayed.decoded = NULL;
 661
 662     /* print some usefull debug info about different vout formats
 663      */
 664     PrintVideoFormat(vout, "pic render", &vout->fmt_render);
 665     PrintVideoFormat(vout, "pic in",     &vout->fmt_in);
 666     PrintVideoFormat(vout, "pic out",    &vout->fmt_out);
 667
 668     assert(vout->fmt_out.i_width  == vout->fmt_render.i_width &&
 669            vout->fmt_out.i_height == vout->fmt_render.i_height &&
 670            vout->fmt_out.i_chroma == vout->fmt_render.i_chroma);
 671     return VLC_SUCCESS;
 672 }
 673
 674 /*****************************************************************************
 675  * CleanThread: clean up after InitThread
 676  *****************************************************************************
 677  * This function is called after a sucessful
 678  * initialization. It frees all resources allocated by InitThread.
 679  * XXX You have to enter it with change_lock taken.
 680  *****************************************************************************/
 681 static void ThreadClean(vout_thread_t *vout)
 682 {
 683     /* Destroy translation tables */
 684     if (!vout->p->b_error) {
 685         picture_fifo_Flush(vout->p->decoder_fifo, INT64_MAX, false);
 686         vout_EndWrapper(vout);
 687     }
 688 }
 689
 690 static int ThreadDisplayPicture(vout_thread_t *vout,
 691                                 bool now, mtime_t *deadline)
 692 {
 693     int displayed_count = 0;
 694     int lost_count = 0;
 695
 696     for (;;) {
 697         const mtime_t date = mdate();
 698         const bool is_paused = vout->p->pause.is_on;
 699         bool redisplay = is_paused && !now;
 700         bool is_forced;
 701
 702         /* FIXME/XXX we must redisplay the last decoded picture (because
 703          * of potential vout updated, or filters update or SPU update)
 704          * For now a high update period is needed but it coulmd be removed
 705          * if and only if:
 706          * - vout module emits events from theselves.
 707          * - *and* SPU is modified to emit an event or a deadline when needed.
 708          *
 709          * So it will be done latter.
 710          */
 711         if (!redisplay) {
 712             picture_t *peek = picture_fifo_Peek(vout->p->decoder_fifo);
 713             if (peek) {
 714                 is_forced = peek->b_force || is_paused || now;
 715                 *deadline = (is_forced ? date : peek->date) - vout_chrono_GetHigh(&vout->p->render);
 716                 picture_Release(peek);
 717             } else {
 718                 redisplay = true;
 719             }
 720         }
 721         if (redisplay) {
 722              /* FIXME a better way for this delay is needed */
 723             const mtime_t date_update = vout->p->displayed.date + VOUT_REDISPLAY_DELAY;
 724             if (date_update > date || !vout->p->displayed.decoded) {
 725                 *deadline = vout->p->displayed.decoded ? date_update : VLC_TS_INVALID;
 726                 break;
 727             }
 728             /* */
 729             is_forced = true;
 730             *deadline = date - vout_chrono_GetHigh(&vout->p->render);
 731         }
 732         if (*deadline > VOUT_MWAIT_TOLERANCE)
 733             *deadline -= VOUT_MWAIT_TOLERANCE;
 734
 735         /* If we are too early and can wait, do it */
 736         if (date < *deadline && !now)
 737             break;
 738
 739         picture_t *decoded;
 740         if (redisplay) {
 741             decoded = vout->p->displayed.decoded;
 742             vout->p->displayed.decoded = NULL;
 743         } else {
 744             decoded = picture_fifo_Pop(vout->p->decoder_fifo);
 745             assert(decoded);
 746             if (!is_forced && !vout->p->is_late_dropped) {
 747                 const mtime_t predicted = date + vout_chrono_GetLow(&vout->p->render);
 748                 const mtime_t late = predicted - decoded->date;
 749                 if (late > 0) {
 750                     msg_Dbg(vout, "picture might be displayed late (missing %d ms)", (int)(late/1000));
 751                     if (late > VOUT_DISPLAY_LATE_THRESHOLD) {
 752                         msg_Warn(vout, "rejected picture because of render time");
 753                         /* TODO */
 754                         picture_Release(decoded);
 755                         lost_count++;
 756                         break;
 757                     }
 758                 }
 759             }
 760
 761             vout->p->displayed.is_interlaced = !decoded->b_progressive;
 762             vout->p->displayed.qtype         = decoded->i_qtype;
 763         }
 764         vout->p->displayed.timestamp = decoded->date;
 765
 766         /* */
 767         if (vout->p->displayed.decoded)
 768             picture_Release(vout->p->displayed.decoded);
 769         picture_Hold(decoded);
 770         vout->p->displayed.decoded = decoded;
 771
 772         /* */
 773         vout_chrono_Start(&vout->p->render);
 774
 775         picture_t *filtered = NULL;
 776         if (decoded) {
 777             vlc_mutex_lock(&vout->p->vfilter_lock);
 778             filtered = filter_chain_VideoFilter(vout->p->p_vf2_chain, decoded);
 779             //assert(filtered == decoded); // TODO implement
 780             vlc_mutex_unlock(&vout->p->vfilter_lock);
 781             if (!filtered)
 782                 continue;
 783         }
 784
 785         /*
 786          * Check for subpictures to display
 787          */
 788         const bool do_snapshot = vout_snapshot_IsRequested(&vout->p->snapshot);
 789         mtime_t spu_render_time = is_forced ? mdate() : filtered->date;
 790         if (vout->p->pause.is_on)
 791             spu_render_time = vout->p->pause.date;
 792         else
 793             spu_render_time = filtered->date > 1 ? filtered->date : mdate();
 794
 795         subpicture_t *subpic = spu_SortSubpictures(vout->p->p_spu,
 796                                                    spu_render_time,
 797                                                    do_snapshot);
 798         /*
 799          * Perform rendering
 800          *
 801          * We have to:
 802          * - be sure to end up with a direct buffer.
 803          * - blend subtitles, and in a fast access buffer
 804          */
 805         picture_t *direct = NULL;
 806         if (filtered &&
 807             (vout->p->decoder_pool != vout->p->display_pool || subpic)) {
 808             picture_t *render;
 809             if (vout->p->is_decoder_pool_slow)
 810                 render = picture_NewFromFormat(&vout->fmt_out);
 811             else if (vout->p->decoder_pool != vout->p->display_pool)
 812                 render = picture_pool_Get(vout->p->display_pool);
 813             else
 814                 render = picture_pool_Get(vout->p->private_pool);
 815
 816             if (render) {
 817                 picture_Copy(render, filtered);
 818
 819                 spu_RenderSubpictures(vout->p->p_spu,
 820                                       render, &vout->fmt_out,
 821                                       subpic, &vout->fmt_in, spu_render_time);
 822             }
 823             if (vout->p->is_decoder_pool_slow) {
 824                 direct = picture_pool_Get(vout->p->display_pool);
 825                 if (direct)
 826                     picture_Copy(direct, render);
 827                 picture_Release(render);
 828
 829             } else {
 830                 direct = render;
 831             }
 832             picture_Release(filtered);
 833             filtered = NULL;
 834         } else {
 835             direct = filtered;
 836         }
 837
 838         /*
 839          * Take a snapshot if requested
 840          */
 841         if (direct && do_snapshot)
 842             vout_snapshot_Set(&vout->p->snapshot, &vout->fmt_out, direct);
 843
 844         /* Render the direct buffer returned by vout_RenderPicture */
 845         if (direct) {
 846             vout_RenderWrapper(vout, direct);
 847
 848             vout_chrono_Stop(&vout->p->render);
 849 #if 0
 850             {
 851             static int i = 0;
 852             if (((i++)%10) == 0)
 853                 msg_Info(vout, "render: avg %d ms var %d ms",
 854                          (int)(vout->p->render.avg/1000), (int)(vout->p->render.var/1000));
 855             }
 856 #endif
 857         }
 858
 859         /* Wait the real date (for rendering jitter) */
 860         if (!is_forced)
 861             mwait(decoded->date);
 862
 863         /* Display the direct buffer returned by vout_RenderPicture */
 864         vout->p->displayed.date = mdate();
 865         if (direct)
 866             vout_DisplayWrapper(vout, direct);
 867
 868         displayed_count++;
 869         break;
 870     }
 871
 872     vout_statistic_Update(&vout->p->statistic, displayed_count, lost_count);
 873     if (displayed_count <= 0)
 874         return VLC_EGENERIC;
 875     return VLC_SUCCESS;
 876 }
 877
 878 static int ThreadManage(vout_thread_t *vout,
 879                         mtime_t *deadline,
 880                         vout_interlacing_support_t *interlacing,
 881                         vout_postprocessing_support_t *postprocessing)
 882 {
 883     vlc_mutex_lock(&vout->p->picture_lock);
 884
 885     *deadline = VLC_TS_INVALID;
 886     bool has_displayed = !ThreadDisplayPicture(vout, vout->p->step.is_requested, deadline);
 887
 888     if (has_displayed) {
 889         vout->p->step.timestamp = vout->p->displayed.timestamp;
 890         if (vout->p->step.last <= VLC_TS_INVALID)
 891             vout->p->step.last = vout->p->step.timestamp;
 892     }
 893     if (vout->p->step.is_requested) {
 894         if (!has_displayed && !vout->p->b_picture_empty) {
 895             picture_t *peek = picture_fifo_Peek(vout->p->decoder_fifo);
 896             if (peek)
 897                 picture_Release(peek);
 898             if (!peek) {
 899                 vout->p->b_picture_empty = true;
 900                 vlc_cond_signal(&vout->p->picture_wait);
 901             }
 902         }
 903         if (has_displayed) {
 904             vout->p->step.is_requested = false;
 905             vlc_cond_signal(&vout->p->picture_wait);
 906         }
 907     }
 908
 909     const int  picture_qtype      = vout->p->displayed.qtype;
 910     const bool picture_interlaced = vout->p->displayed.is_interlaced;
 911
 912     vlc_mutex_unlock(&vout->p->picture_lock);
 913
 914     /* Post processing */
 915     vout_SetPostProcessingState(vout, postprocessing, picture_qtype);
 916
 917     /* Deinterlacing */
 918     vout_SetInterlacingState(vout, interlacing, picture_interlaced);
 919
 920     if (vout_ManageWrapper(vout)) {
 921         /* A fatal error occurred, and the thread must terminate
 922          * immediately, without displaying anything - setting b_error to 1
 923          * causes the immediate end of the main while() loop. */
 924         // FIXME pf_end
 925         return VLC_EGENERIC;
 926     }
 927     return VLC_SUCCESS;
 928 }
 929
 930 static void ThreadDisplayOsdTitle(vout_thread_t *vout)
 931 {
 932     if (!vout->p->title.show || !vout->p->title.value)
 933         return;
 934
 935     vlc_assert_locked(&vout->p->change_lock);
 936
 937     const mtime_t start = mdate();
 938     const mtime_t stop = start +
 939                          INT64_C(1000) * vout->p->title.timeout;
 940
 941     if (stop > start)
 942         vout_ShowTextAbsolute(vout, DEFAULT_CHAN,
 943                               vout->p->title.value, NULL,
 944                               vout->p->title.position,
 945                               30 + vout->fmt_in.i_width
 946                                  - vout->fmt_in.i_visible_width
 947                                  - vout->fmt_in.i_x_offset,
 948                               20 + vout->fmt_in.i_y_offset,
 949                               start, stop);
 950
 951     free(vout->p->title.value);
 952     vout->p->title.value = NULL;
 953 }
 954
 955 static void ThreadChangeFilter(vout_thread_t *vout)
 956 {
 957     /* Check for "video filter2" changes */
 958     vlc_mutex_lock(&vout->p->vfilter_lock);
 959     if (vout->p->psz_vf2) {
 960         es_format_t fmt;
 961
 962         es_format_Init(&fmt, VIDEO_ES, vout->fmt_render.i_chroma);
 963         fmt.video = vout->fmt_render;
 964         filter_chain_Reset(vout->p->p_vf2_chain, &fmt, &fmt);
 965
 966         if (filter_chain_AppendFromString(vout->p->p_vf2_chain,
 967                                           vout->p->psz_vf2) < 0)
 968             msg_Err(vout, "Video filter chain creation failed");
 969
 970         free(vout->p->psz_vf2);
 971         vout->p->psz_vf2 = NULL;
 972     }
 973     vlc_mutex_unlock(&vout->p->vfilter_lock);
 974 }
 975
 976 /*****************************************************************************
 977  * Thread: video output thread
 978  *****************************************************************************
 979  * Video output thread. This function does only returns when the thread is
 980  * terminated. It handles the pictures arriving in the video heap and the
 981  * display device events.
 982  *****************************************************************************/
 983 static void *Thread(void *object)
 984 {
 985     vout_thread_t *vout = object;
 986     bool          has_wrapper;
 987
 988     /*
 989      * Initialize thread
 990      */
 991     has_wrapper = !vout_OpenWrapper(vout, vout->p->psz_module_name);
 992
 993     vlc_mutex_lock(&vout->p->change_lock);
 994
 995     if (has_wrapper)
 996         vout->p->b_error = ThreadInit(vout);
 997     else
 998         vout->p->b_error = true;
 999
1000     /* signal the creation of the vout */
1001     vout->p->b_ready = true;
1002     vlc_cond_signal(&vout->p->change_wait);
1003
1004     if (vout->p->b_error)
1005         goto exit_thread;
1006
1007     /* */
1008     vout_interlacing_support_t interlacing = {
1009         .is_interlaced = false,
1010         .date = mdate(),
1011     };
1012     vout_postprocessing_support_t postprocessing = {
1013         .qtype = QTYPE_NONE,
1014     };
1015
1016     /*
1017      * Main loop - it is not executed if an error occurred during
1018      * initialization
1019      */
1020     while (!vout->p->b_done && !vout->p->b_error) {
1021         /* */
1022         mtime_t deadline;
1023         if (ThreadManage(vout, &deadline,
1024                          &interlacing, &postprocessing)) {
1025             vout->p->b_error = true;
1026             break;
1027         }
1028
1029         ThreadDisplayOsdTitle(vout);
1030         ThreadChangeFilter(vout);
1031
1032         vlc_mutex_unlock(&vout->p->change_lock);
1033
1034         if (deadline > VLC_TS_INVALID) {
1035             vlc_mutex_lock(&vout->p->picture_lock);
1036             vlc_cond_timedwait(&vout->p->picture_wait, &vout->p->picture_lock, deadline);
1037             vlc_mutex_unlock(&vout->p->picture_lock);
1038         }
1039
1040         vlc_mutex_lock(&vout->p->change_lock);
1041     }
1042
1043     /*
1044      * Error loop - wait until the thread destruction is requested
1045      *
1046      * XXX I wonder if we should periodically clean the decoder_fifo
1047      * or have a way to prevent it filling up.
1048      */
1049     while (vout->p->b_error && !vout->p->b_done)
1050         vlc_cond_wait(&vout->p->change_wait, &vout->p->change_lock);
1051
1052     /* Clean thread */
1053     ThreadClean(vout);
1054
1055 exit_thread:
1056     /* Detach subpicture unit from both input and vout */
1057     spu_Attach(vout->p->p_spu, VLC_OBJECT(vout), false);
1058     vlc_object_detach(vout->p->p_spu);
1059
1060     /* Destroy the video filters2 */
1061     filter_chain_Delete(vout->p->p_vf2_chain);
1062
1063     vlc_mutex_unlock(&vout->p->change_lock);
1064
1065     if (has_wrapper)
1066         vout_CloseWrapper(vout);
1067
1068     return NULL;
1069 }
1070
1071 /*****************************************************************************
1072  * object variables callbacks: a bunch of object variables are used by the
1073  * interfaces to interact with the vout.
1074  *****************************************************************************/
1075 static int FilterCallback( vlc_object_t *p_this, char const *psz_cmd,
1076                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
1077 {
1078     vout_thread_t *p_vout = (vout_thread_t *)p_this;
1079     input_thread_t *p_input;
1080     (void)psz_cmd; (void)oldval; (void)p_data;
1081
1082     p_input = (input_thread_t *)vlc_object_find( p_this, VLC_OBJECT_INPUT,
1083                                                  FIND_PARENT );
1084     if (!p_input)
1085     {
1086         msg_Err( p_vout, "Input not found" );
1087         return VLC_EGENERIC;
1088     }
1089
1090     var_SetBool( p_vout, "intf-change", true );
1091
1092     /* Modify input as well because the vout might have to be restarted */
1093     var_Create( p_input, "vout-filter", VLC_VAR_STRING );
1094     var_SetString( p_input, "vout-filter", newval.psz_string );
1095
1096     /* Now restart current video stream */
1097     input_Control( p_input, INPUT_RESTART_ES, -VIDEO_ES );
1098     vlc_object_release( p_input );
1099
1100     return VLC_SUCCESS;
1101 }
1102
1103 /*****************************************************************************
1104  * Video Filter2 stuff
1105  *****************************************************************************/
1106 static int VideoFilter2Callback( vlc_object_t *p_this, char const *psz_cmd,
1107                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
1108 {
1109     vout_thread_t *p_vout = (vout_thread_t *)p_this;
1110     (void)psz_cmd; (void)oldval; (void)p_data;
1111
1112     vlc_mutex_lock( &p_vout->p->vfilter_lock );
1113     p_vout->p->psz_vf2 = strdup( newval.psz_string );
1114     vlc_mutex_unlock( &p_vout->p->vfilter_lock );
1115
1116     return VLC_SUCCESS;
1117 }
1118
1119 /* */
1120 static void PrintVideoFormat(vout_thread_t *vout,
1121                              const char *description,
1122                              const video_format_t *fmt)
1123 {
1124     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",
1125             description,
1126             fmt->i_width, fmt->i_height, fmt->i_x_offset, fmt->i_y_offset,
1127             fmt->i_visible_width, fmt->i_visible_height,
1128             (char*)&fmt->i_chroma,
1129             fmt->i_sar_num, fmt->i_sar_den,
1130             fmt->i_rmask, fmt->i_gmask, fmt->i_bmask);
1131 }
1132