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

   1 /*****************************************************************************
   2  * video_output.c : video output thread
   3  * (c)2000 VideoLAN
   4  *****************************************************************************
   5  * This module describes the programming interface for video output threads.
   6  * It includes functions allowing to open a new thread, send pictures to a
   7  * thread, and destroy a previously oppenned video output thread.
   8  *****************************************************************************/
   9
  10 /*****************************************************************************
  11  * Preamble
  12  *****************************************************************************/
  13 #include <errno.h>
  14 #include <stdlib.h>
  15 #include <stdio.h>
  16 #include <string.h>
  17
  18 #include "common.h"
  19 #include "config.h"
  20 #include "mtime.h"
  21 #include "vlc_thread.h"
  22 #include "video.h"
  23 #include "video_output.h"
  24 #include "video_text.h"
  25 #include "video_sys.h"
  26 #include "video_yuv.h"
  27 #include "intf_msg.h"
  28 #include "main.h"
  29
  30 /*****************************************************************************
  31  * Local prototypes
  32  *****************************************************************************/
  33 static int      BinaryLog         ( u32 i );
  34 static void     MaskToShift       ( int *pi_left, int *pi_right, u32 i_mask );
  35 static int      InitThread        ( vout_thread_t *p_vout );
  36 static void     RunThread         ( vout_thread_t *p_vout );
  37 static void     ErrorThread       ( vout_thread_t *p_vout );
  38 static void     EndThread         ( vout_thread_t *p_vout );
  39 static void     DestroyThread     ( vout_thread_t *p_vout, int i_status );
  40 static void     Print             ( vout_thread_t *p_vout, int i_x, int i_y,
  41                                     int i_h_align, int i_v_align,
  42                                     unsigned char *psz_text );
  43 static void     SetBufferArea     ( vout_thread_t *p_vout, int i_x, int i_y,
  44                                     int i_w, int i_h );
  45 static void     SetBufferPicture  ( vout_thread_t *p_vout, picture_t *p_pic );
  46 static void     RenderPicture     ( vout_thread_t *p_vout, picture_t *p_pic );
  47 static void     RenderPictureInfo ( vout_thread_t *p_vout, picture_t *p_pic );
  48 static void     RenderSubPicture  ( vout_thread_t *p_vout,
  49                                     subpicture_t *p_subpic );
  50 static void     RenderInterface   ( vout_thread_t *p_vout );
  51 static int      RenderIdle        ( vout_thread_t *p_vout );
  52 static void     RenderInfo        ( vout_thread_t *p_vout );
  53 static void     Synchronize       ( vout_thread_t *p_vout, s64 i_delay );
  54 static int      Manage            ( vout_thread_t *p_vout );
  55 static int      Align             ( vout_thread_t *p_vout, int *pi_x,
  56                                     int *pi_y, int i_width, int i_height,
  57                                     int i_h_align, int i_v_align );
  58 static void     SetPalette        ( p_vout_thread_t p_vout, u16 *red,
  59                                     u16 *green, u16 *blue, u16 *transp );
  60
  61 /*****************************************************************************
  62  * vout_CreateThread: creates a new video output thread
  63  *****************************************************************************
  64  * This function creates a new video output thread, and returns a pointer
  65  * to its description. On error, it returns NULL.
  66  * If pi_status is NULL, then the function will block until the thread is ready.
  67  * If not, it will be updated using one of the THREAD_* constants.
  68  *****************************************************************************/
  69 vout_thread_t * vout_CreateThread   ( char *psz_display, int i_root_window,
  70                           int i_width, int i_height, int *pi_status, int i_method )
  71 {
  72     vout_thread_t * p_vout;                             /* thread descriptor */
  73     int             i_status;                               /* thread status */
  74     int             i_index;               /* index for array initialization */
  75
  76     /* Allocate descriptor */
  77     intf_DbgMsg("\n");
  78     p_vout = (vout_thread_t *) malloc( sizeof(vout_thread_t) );
  79     if( p_vout == NULL )
  80     {
  81         intf_ErrMsg("error: %s\n", strerror(ENOMEM));
  82         return( NULL );
  83     }
  84
  85     /* Sets method-specific functions */
  86     switch( i_method )
  87     {
  88 #ifdef VIDEO_DUMMY
  89         case VOUT_DUMMY_METHOD:
  90             p_vout->p_sys_create =    vout_DummySysCreate;
  91             p_vout->p_sys_init =      vout_DummySysInit;
  92             p_vout->p_sys_end =       vout_DummySysEnd;
  93             p_vout->p_sys_destroy =   vout_DummySysDestroy;
  94             p_vout->p_sys_manage =    vout_DummySysManage;
  95             p_vout->p_sys_display =   vout_DummySysDisplay;
  96             break;
  97 #endif
  98 #ifdef VIDEO_X11
  99         case VOUT_X11_METHOD:
 100             p_vout->p_sys_create =    vout_X11SysCreate;
 101             p_vout->p_sys_init =      vout_X11SysInit;
 102             p_vout->p_sys_end =       vout_X11SysEnd;
 103             p_vout->p_sys_destroy =   vout_X11SysDestroy;
 104             p_vout->p_sys_manage =    vout_X11SysManage;
 105             p_vout->p_sys_display =   vout_X11SysDisplay;
 106             break;
 107 #endif
 108 #ifdef VIDEO_FB
 109         case VOUT_FB_METHOD:
 110             p_vout->p_sys_create =    vout_FBSysCreate;
 111             p_vout->p_sys_init =      vout_FBSysInit;
 112             p_vout->p_sys_end =       vout_FBSysEnd;
 113             p_vout->p_sys_destroy =   vout_FBSysDestroy;
 114             p_vout->p_sys_manage =    vout_FBSysManage;
 115             p_vout->p_sys_display =   vout_FBSysDisplay;
 116             break;
 117 #endif
 118 #ifdef VIDEO_GLIDE
 119         case VOUT_GLIDE_METHOD:
 120             p_vout->p_sys_create =    vout_GlideSysCreate;
 121             p_vout->p_sys_init =      vout_GlideSysInit;
 122             p_vout->p_sys_end =       vout_GlideSysEnd;
 123             p_vout->p_sys_destroy =   vout_GlideSysDestroy;
 124             p_vout->p_sys_manage =    vout_GlideSysManage;
 125             p_vout->p_sys_display =   vout_GlideSysDisplay;
 126             break;
 127 #endif
 128 #ifdef VIDEO_DGA
 129         case VOUT_DGA_METHOD:
 130             p_vout->p_sys_create =    vout_DGASysCreate;
 131             p_vout->p_sys_init =      vout_DGASysInit;
 132             p_vout->p_sys_end =       vout_DGASysEnd;
 133             p_vout->p_sys_destroy =   vout_DGASysDestroy;
 134             p_vout->p_sys_manage =    vout_DGASysManage;
 135             p_vout->p_sys_display =   vout_DGASysDisplay;
 136             break;
 137 #endif
 138 #ifdef VIDEO_GGI
 139         case VOUT_GGI_METHOD:
 140             p_vout->p_sys_create =    vout_GGISysCreate;
 141             p_vout->p_sys_init =      vout_GGISysInit;
 142             p_vout->p_sys_end =       vout_GGISysEnd;
 143             p_vout->p_sys_destroy =   vout_GGISysDestroy;
 144             p_vout->p_sys_manage =    vout_GGISysManage;
 145             p_vout->p_sys_display =   vout_GGISysDisplay;
 146             break;
 147 #endif
 148 #ifdef VIDEO_BEOS
 149         case VOUT_BEOS_METHOD:
 150             p_vout->p_sys_create =    vout_BSysCreate;
 151             p_vout->p_sys_init =      vout_BSysInit;
 152             p_vout->p_sys_end =       vout_BSysEnd;
 153             p_vout->p_sys_destroy =   vout_BSysDestroy;
 154             p_vout->p_sys_manage =    vout_BSysManage;
 155             p_vout->p_sys_display =   vout_BSysDisplay;
 156             break;
 157 #endif
 158         default:
 159             intf_ErrMsg( "error: video output method not available\n" );
 160             free( p_vout );
 161             return( NULL );
 162     }
 163
 164     /* Initialize thread properties - thread id and locks will be initialized
 165      * later */
 166     p_vout->b_die               = 0;
 167     p_vout->b_error             = 0;
 168     p_vout->b_active            = 0;
 169     p_vout->pi_status           = (pi_status != NULL) ? pi_status : &i_status;
 170     *p_vout->pi_status          = THREAD_CREATE;
 171
 172     /* Initialize some fields used by the system-dependant method - these fields will
 173      * probably be modified by the method, and are only preferences */
 174     p_vout->i_changes           = 0;
 175     p_vout->i_width             = i_width;
 176     p_vout->i_height            = i_height;
 177     p_vout->i_bytes_per_line    = i_width * 2;
 178     p_vout->i_screen_depth      = 15;
 179     p_vout->i_bytes_per_pixel   = 2;
 180     p_vout->f_gamma             = VOUT_GAMMA;
 181
 182     p_vout->b_grayscale         = main_GetIntVariable( VOUT_GRAYSCALE_VAR, VOUT_GRAYSCALE_DEFAULT );
 183     p_vout->b_info              = 0;
 184     p_vout->b_interface         = 0;
 185     p_vout->b_scale             = 0;
 186
 187     p_vout->p_set_palette       = SetPalette;
 188
 189     intf_DbgMsg("wished configuration: %dx%d, %d/%d bpp (%d Bpl)\n",
 190                 p_vout->i_width, p_vout->i_height, p_vout->i_screen_depth,
 191                 p_vout->i_bytes_per_pixel * 8, p_vout->i_bytes_per_line );
 192
 193     /* Initialize idle screen */
 194     p_vout->last_display_date   = mdate();
 195     p_vout->last_display_date   = 0;
 196     p_vout->last_idle_date      = 0;
 197
 198 #ifdef STATS
 199     /* Initialize statistics fields */
 200     p_vout->render_time         = 0;
 201     p_vout->c_fps_samples       = 0;
 202 #endif
 203
 204     /* Initialize buffer index */
 205     p_vout->i_buffer_index      = 0;
 206
 207     /* Initialize pictures and subpictures - translation tables and functions
 208      * will be initialized later in InitThread */
 209     for( i_index = 0; i_index < VOUT_MAX_PICTURES; i_index++)
 210     {
 211         p_vout->p_picture[i_index].i_type   =   EMPTY_PICTURE;
 212         p_vout->p_picture[i_index].i_status =   FREE_PICTURE;
 213         p_vout->p_subpicture[i_index].i_type  = EMPTY_SUBPICTURE;
 214         p_vout->p_subpicture[i_index].i_status= FREE_SUBPICTURE;
 215     }
 216     p_vout->i_pictures = 0;
 217
 218     /* Initialize synchronization informations */
 219     p_vout->i_synchro_level     = VOUT_SYNCHRO_LEVEL_START;
 220
 221     /* Create and initialize system-dependant method - this function issues its
 222      * own error messages */
 223     if( p_vout->p_sys_create( p_vout, psz_display, i_root_window ) )
 224     {
 225       free( p_vout );
 226       return( NULL );
 227     }
 228     intf_DbgMsg("actual configuration: %dx%d, %d/%d bpp (%d Bpl), masks: 0x%x/0x%x/0x%x\n",
 229                 p_vout->i_width, p_vout->i_height, p_vout->i_screen_depth,
 230                 p_vout->i_bytes_per_pixel * 8, p_vout->i_bytes_per_line,
 231                 p_vout->i_red_mask, p_vout->i_green_mask, p_vout->i_blue_mask );
 232
 233     /* Calculate shifts from system-updated masks */
 234     MaskToShift( &p_vout->i_red_lshift,   &p_vout->i_red_rshift,   p_vout->i_red_mask );
 235     MaskToShift( &p_vout->i_green_lshift, &p_vout->i_green_rshift, p_vout->i_green_mask );
 236     MaskToShift( &p_vout->i_blue_lshift,  &p_vout->i_blue_rshift,  p_vout->i_blue_mask );
 237
 238     /* Set some useful colors */
 239     p_vout->i_white_pixel = RGB2PIXEL( p_vout, 255, 255, 255 );
 240     p_vout->i_black_pixel = RGB2PIXEL( p_vout, 0, 0, 0 );
 241     p_vout->i_gray_pixel  = RGB2PIXEL( p_vout, 128, 128, 128 );
 242     p_vout->i_blue_pixel  = RGB2PIXEL( p_vout, 0, 0, 50 );
 243
 244     /* Load fonts - fonts must be initialized after the system method since
 245      * they may be dependant on screen depth and other thread properties */
 246     p_vout->p_default_font      = vout_LoadFont( VOUT_DEFAULT_FONT );
 247     if( p_vout->p_default_font == NULL )
 248     {
 249         p_vout->p_sys_destroy( p_vout );
 250         free( p_vout );
 251         return( NULL );
 252     }
 253     p_vout->p_large_font        = vout_LoadFont( VOUT_LARGE_FONT );
 254     if( p_vout->p_large_font == NULL )
 255     {
 256         vout_UnloadFont( p_vout->p_default_font );
 257         p_vout->p_sys_destroy( p_vout );
 258         free( p_vout );
 259         return( NULL );
 260     }
 261
 262     /* Create thread and set locks */
 263     vlc_mutex_init( &p_vout->picture_lock );
 264     vlc_mutex_init( &p_vout->subpicture_lock );
 265     vlc_mutex_init( &p_vout->change_lock );
 266     vlc_mutex_lock( &p_vout->change_lock );
 267     if( vlc_thread_create( &p_vout->thread_id, "video output", (void *) RunThread, (void *) p_vout) )
 268     {
 269         intf_ErrMsg("error: %s\n", strerror(ENOMEM));
 270         vout_UnloadFont( p_vout->p_default_font );
 271         vout_UnloadFont( p_vout->p_large_font );
 272         p_vout->p_sys_destroy( p_vout );
 273         free( p_vout );
 274         return( NULL );
 275     }
 276
 277     intf_Msg("Video display initialized (%dx%d, %d/%d bpp)\n", p_vout->i_width,
 278              p_vout->i_height, p_vout->i_screen_depth, p_vout->i_bytes_per_pixel * 8 );
 279
 280     /* If status is NULL, wait until the thread is created */
 281     if( pi_status == NULL )
 282     {
 283         do
 284         {
 285             msleep( THREAD_SLEEP );
 286         }while( (i_status != THREAD_READY) && (i_status != THREAD_ERROR)
 287                 && (i_status != THREAD_FATAL) );
 288         if( i_status != THREAD_READY )
 289         {
 290             return( NULL );
 291         }
 292     }
 293     return( p_vout );
 294 }
 295
 296 /*****************************************************************************
 297  * vout_DestroyThread: destroys a previously created thread
 298  *****************************************************************************
 299  * Destroy a terminated thread.
 300  * The function will request a destruction of the specified thread. If pi_error
 301  * is NULL, it will return once the thread is destroyed. Else, it will be
 302  * update using one of the THREAD_* constants.
 303  *****************************************************************************/
 304 void vout_DestroyThread( vout_thread_t *p_vout, int *pi_status )
 305 {
 306     int     i_status;                                       /* thread status */
 307
 308     /* Set status */
 309     intf_DbgMsg("\n");
 310     p_vout->pi_status = (pi_status != NULL) ? pi_status : &i_status;
 311     *p_vout->pi_status = THREAD_DESTROY;
 312
 313     /* Request thread destruction */
 314     p_vout->b_die = 1;
 315
 316     /* If status is NULL, wait until thread has been destroyed */
 317     if( pi_status == NULL )
 318     {
 319         do
 320         {
 321             msleep( THREAD_SLEEP );
 322         }while( (i_status != THREAD_OVER) && (i_status != THREAD_ERROR)
 323                 && (i_status != THREAD_FATAL) );
 324     }
 325 }
 326
 327 /*****************************************************************************
 328  * vout_DisplaySubPicture: display a subpicture unit
 329  *****************************************************************************
 330  * Remove the reservation flag of an subpicture, which will cause it to be ready
 331  * for display. The picture does not need to be locked, since it is ignored by
 332  * the output thread if is reserved.
 333  *****************************************************************************/
 334 void  vout_DisplaySubPicture( vout_thread_t *p_vout, subpicture_t *p_subpic )
 335 {
 336 #ifdef DEBUG_VIDEO
 337     char        psz_begin_date[MSTRTIME_MAX_SIZE]; /* buffer for date string */
 338     char        psz_end_date[MSTRTIME_MAX_SIZE];   /* buffer for date string */
 339 #endif
 340
 341 #ifdef DEBUG
 342     /* Check if status is valid */
 343     if( p_subpic->i_status != RESERVED_SUBPICTURE )
 344     {
 345         intf_DbgMsg("error: subpicture %p has invalid status %d\n", p_subpic,
 346                     p_subpic->i_status );
 347     }
 348 #endif
 349
 350     /* Remove reservation flag */
 351     p_subpic->i_status = READY_SUBPICTURE;
 352
 353 #ifdef DEBUG_VIDEO
 354     /* Send subpicture informations */
 355     intf_DbgMsg("subpicture %p: type=%d, begin date=%s, end date=%s\n",
 356                 p_subpic, p_subpic->i_type,
 357                 mstrtime( psz_begin_date, p_subpic->begin_date ),
 358                 mstrtime( psz_end_date, p_subpic->end_date ) );
 359 #endif
 360 }
 361
 362 /*****************************************************************************
 363  * vout_CreateSubPicture: allocate an subpicture in the video output heap.
 364  *****************************************************************************
 365  * This function create a reserved subpicture in the video output heap.
 366  * A null pointer is returned if the function fails. This method provides an
 367  * already allocated zone of memory in the spu data fields. It needs locking
 368  * since several pictures can be created by several producers threads.
 369  *****************************************************************************/
 370 subpicture_t *vout_CreateSubPicture( vout_thread_t *p_vout, int i_type,
 371                                      int i_size )
 372 {
 373     int                 i_subpic;                        /* subpicture index */
 374     subpicture_t *      p_free_subpic = NULL;       /* first free subpicture */
 375     subpicture_t *      p_destroyed_subpic = NULL; /* first destroyed subpic */
 376
 377     /* Get lock */
 378     vlc_mutex_lock( &p_vout->subpicture_lock );
 379
 380     /*
 381      * Look for an empty place
 382      */
 383     for( i_subpic = 0; i_subpic < VOUT_MAX_PICTURES; i_subpic++ )
 384     {
 385         if( p_vout->p_subpicture[i_subpic].i_status == DESTROYED_SUBPICTURE )
 386         {
 387             /* Subpicture is marked for destruction, but is still allocated */
 388             if( (p_vout->p_subpicture[i_subpic].i_type  == i_type)   &&
 389                 (p_vout->p_subpicture[i_subpic].i_size  >= i_size) )
 390             {
 391                 /* Memory size do match or is smaller : memory will not be reallocated,
 392                  * and function can end immediately - this is the best possible case,
 393                  * since no memory allocation needs to be done */
 394                 p_vout->p_subpicture[i_subpic].i_status = RESERVED_SUBPICTURE;
 395 #ifdef DEBUG_VIDEO
 396                 intf_DbgMsg("subpicture %p (in destroyed subpicture slot)\n",
 397                             &p_vout->p_subpicture[i_subpic] );
 398 #endif
 399                 vlc_mutex_unlock( &p_vout->subpicture_lock );
 400                 return( &p_vout->p_subpicture[i_subpic] );
 401             }
 402             else if( p_destroyed_subpic == NULL )
 403             {
 404                 /* Memory size do not match, but subpicture index will be kept in
 405                  * case no other place are left */
 406                 p_destroyed_subpic = &p_vout->p_subpicture[i_subpic];
 407             }
 408         }
 409         else if( (p_free_subpic == NULL) &&
 410                  (p_vout->p_subpicture[i_subpic].i_status == FREE_SUBPICTURE ))
 411         {
 412             /* Subpicture is empty and ready for allocation */
 413             p_free_subpic = &p_vout->p_subpicture[i_subpic];
 414         }
 415     }
 416
 417     /* If no free subpicture is available, use a destroyed subpicture */
 418     if( (p_free_subpic == NULL) && (p_destroyed_subpic != NULL ) )
 419     {
 420         /* No free subpicture or matching destroyed subpicture has been found, but
 421          * a destroyed subpicture is still avalaible */
 422         free( p_destroyed_subpic->p_data );
 423         p_free_subpic = p_destroyed_subpic;
 424     }
 425
 426     /*
 427      * Prepare subpicture
 428      */
 429     if( p_free_subpic != NULL )
 430     {
 431         /* Allocate memory */
 432         switch( i_type )
 433         {
 434         case TEXT_SUBPICTURE:                             /* text subpicture */
 435             p_free_subpic->p_data = malloc( i_size + 1 );
 436             break;
 437 #ifdef DEBUG
 438         default:
 439             intf_DbgMsg("error: unknown subpicture type %d\n", i_type );
 440             p_free_subpic->p_data   =  NULL;
 441             break;
 442 #endif
 443         }
 444
 445         if( p_free_subpic->p_data != NULL )
 446         {                    /* Copy subpicture informations, set some default values */
 447             p_free_subpic->i_type                      = i_type;
 448             p_free_subpic->i_status                    = RESERVED_SUBPICTURE;
 449             p_free_subpic->i_size                      = i_size;
 450             p_free_subpic->i_x                         = 0;
 451             p_free_subpic->i_y                         = 0;
 452             p_free_subpic->i_width                     = 0;
 453             p_free_subpic->i_height                    = 0;
 454             p_free_subpic->i_horizontal_align          = CENTER_RALIGN;
 455             p_free_subpic->i_vertical_align            = CENTER_RALIGN;
 456         }
 457         else
 458         {
 459             /* Memory allocation failed : set subpicture as empty */
 460             p_free_subpic->i_type   =  EMPTY_SUBPICTURE;
 461             p_free_subpic->i_status =  FREE_SUBPICTURE;
 462             p_free_subpic =            NULL;
 463             intf_ErrMsg("warning: %s\n", strerror( ENOMEM ) );
 464         }
 465
 466 #ifdef DEBUG_VIDEO
 467         intf_DbgMsg("subpicture %p (in free subpicture slot)\n", p_free_subpic );
 468 #endif
 469         vlc_mutex_unlock( &p_vout->subpicture_lock );
 470         return( p_free_subpic );
 471     }
 472
 473     /* No free or destroyed subpicture could be found */
 474     intf_DbgMsg( "warning: heap is full\n" );
 475     vlc_mutex_unlock( &p_vout->subpicture_lock );
 476     return( NULL );
 477 }
 478
 479 /*****************************************************************************
 480  * vout_DestroySubPicture: remove a subpicture from the heap
 481  *****************************************************************************
 482  * This function frees a previously reserved subpicture.
 483  * It is meant to be used when the construction of a picture aborted.
 484  * This function does not need locking since reserved subpictures are ignored
 485  * by the output thread.
 486  *****************************************************************************/
 487 void vout_DestroySubPicture( vout_thread_t *p_vout, subpicture_t *p_subpic )
 488 {
 489 #ifdef DEBUG
 490    /* Check if status is valid */
 491    if( p_subpic->i_status != RESERVED_SUBPICTURE )
 492    {
 493        intf_DbgMsg("error: subpicture %p has invalid status %d\n",
 494                    p_subpic, p_subpic->i_status );
 495    }
 496 #endif
 497
 498     p_subpic->i_status = DESTROYED_SUBPICTURE;
 499
 500 #ifdef DEBUG_VIDEO
 501     intf_DbgMsg("subpicture %p\n", p_subpic);
 502 #endif
 503 }
 504
 505 /*****************************************************************************
 506  * vout_DisplayPicture: display a picture
 507  *****************************************************************************
 508  * Remove the reservation flag of a picture, which will cause it to be ready for
 509  * display. The picture won't be displayed until vout_DatePicture has been
 510  * called.
 511  *****************************************************************************/
 512 void  vout_DisplayPicture( vout_thread_t *p_vout, picture_t *p_pic )
 513 {
 514     vlc_mutex_lock( &p_vout->picture_lock );
 515     switch( p_pic->i_status )
 516     {
 517     case RESERVED_PICTURE:
 518         p_pic->i_status = RESERVED_DISP_PICTURE;
 519         break;
 520     case RESERVED_DATED_PICTURE:
 521         p_pic->i_status = READY_PICTURE;
 522         break;
 523 #ifdef DEBUG
 524     default:
 525         intf_DbgMsg("error: picture %p has invalid status %d\n", p_pic, p_pic->i_status );
 526         break;
 527 #endif
 528     }
 529
 530 #ifdef DEBUG_VIDEO
 531     intf_DbgMsg("picture %p\n", p_pic);
 532 #endif
 533     vlc_mutex_unlock( &p_vout->picture_lock );
 534 }
 535
 536 /*****************************************************************************
 537  * vout_DatePicture: date a picture
 538  *****************************************************************************
 539  * Remove the reservation flag of a picture, which will cause it to be ready for
 540  * display. The picture won't be displayed until vout_DisplayPicture has been
 541  * called.
 542  *****************************************************************************/
 543 void  vout_DatePicture( vout_thread_t *p_vout, picture_t *p_pic, mtime_t date )
 544 {
 545 #ifdef DEBUG_VIDEO
 546     char        psz_date[MSTRTIME_MAX_SIZE];                         /* date */
 547 #endif
 548
 549     vlc_mutex_lock( &p_vout->picture_lock );
 550     p_pic->date = date;
 551     switch( p_pic->i_status )
 552     {
 553     case RESERVED_PICTURE:
 554         p_pic->i_status = RESERVED_DATED_PICTURE;
 555         break;
 556     case RESERVED_DISP_PICTURE:
 557         p_pic->i_status = READY_PICTURE;
 558         break;
 559 #ifdef DEBUG
 560     default:
 561         intf_DbgMsg("error: picture %p has invalid status %d\n", p_pic, p_pic->i_status );
 562         break;
 563 #endif
 564     }
 565
 566 #ifdef DEBUG_VIDEO
 567     intf_DbgMsg("picture %p, display date: %s\n", p_pic, mstrtime( psz_date, p_pic->date) );
 568 #endif
 569     vlc_mutex_unlock( &p_vout->picture_lock );
 570 }
 571
 572 /*****************************************************************************
 573  * vout_CreatePicture: allocate a picture in the video output heap.
 574  *****************************************************************************
 575  * This function create a reserved image in the video output heap.
 576  * A null pointer is returned if the function fails. This method provides an
 577  * already allocated zone of memory in the picture data fields. It needs locking
 578  * since several pictures can be created by several producers threads.
 579  *****************************************************************************/
 580 picture_t *vout_CreatePicture( vout_thread_t *p_vout, int i_type,
 581                                int i_width, int i_height )
 582 {
 583     int         i_picture;                                  /* picture index */
 584     int         i_chroma_width = 0;                          /* chroma width */
 585     picture_t * p_free_picture = NULL;                 /* first free picture */
 586     picture_t * p_destroyed_picture = NULL;       /* first destroyed picture */
 587
 588     /* Get lock */
 589     vlc_mutex_lock( &p_vout->picture_lock );
 590
 591     /*
 592      * Look for an empty place
 593      */
 594     for( i_picture = 0; i_picture < VOUT_MAX_PICTURES; i_picture++ )
 595     {
 596         if( p_vout->p_picture[i_picture].i_status == DESTROYED_PICTURE )
 597         {
 598             /* Picture is marked for destruction, but is still allocated - note
 599              * that if width and type are the same for two pictures, chroma_width
 600              * should also be the same */
 601             if( (p_vout->p_picture[i_picture].i_type           == i_type)   &&
 602                 (p_vout->p_picture[i_picture].i_height         == i_height) &&
 603                 (p_vout->p_picture[i_picture].i_width          == i_width) )
 604             {
 605                 /* Memory size do match : memory will not be reallocated, and function
 606                  * can end immediately - this is the best possible case, since no
 607                  * memory allocation needs to be done */
 608                 p_vout->p_picture[i_picture].i_status = RESERVED_PICTURE;
 609                 p_vout->i_pictures++;
 610 #ifdef DEBUG_VIDEO
 611                 intf_DbgMsg("picture %p (in destroyed picture slot)\n",
 612                             &p_vout->p_picture[i_picture] );
 613 #endif
 614                 vlc_mutex_unlock( &p_vout->picture_lock );
 615                 return( &p_vout->p_picture[i_picture] );
 616             }
 617             else if( p_destroyed_picture == NULL )
 618             {
 619                 /* Memory size do not match, but picture index will be kept in
 620                  * case no other place are left */
 621                 p_destroyed_picture = &p_vout->p_picture[i_picture];
 622             }
 623         }
 624         else if( (p_free_picture == NULL) &&
 625                  (p_vout->p_picture[i_picture].i_status == FREE_PICTURE ))
 626         {
 627             /* Picture is empty and ready for allocation */
 628             p_free_picture = &p_vout->p_picture[i_picture];
 629         }
 630     }
 631
 632     /* If no free picture is available, use a destroyed picture */
 633     if( (p_free_picture == NULL) && (p_destroyed_picture != NULL ) )
 634     {
 635         /* No free picture or matching destroyed picture has been found, but
 636          * a destroyed picture is still avalaible */
 637         free( p_destroyed_picture->p_data );
 638         p_free_picture = p_destroyed_picture;
 639     }
 640
 641     /*
 642      * Prepare picture
 643      */
 644     if( p_free_picture != NULL )
 645     {
 646         /* Allocate memory */
 647         switch( i_type )
 648         {
 649         case YUV_420_PICTURE:        /* YUV 420: 1,1/4,1/4 samples per pixel */
 650             i_chroma_width = i_width / 2;
 651             p_free_picture->p_data = malloc( i_height * i_chroma_width * 3 * sizeof( yuv_data_t ) );
 652             p_free_picture->p_y = (yuv_data_t *)p_free_picture->p_data;
 653             p_free_picture->p_u = (yuv_data_t *)p_free_picture->p_data +i_height*i_chroma_width*4/2;
 654             p_free_picture->p_v = (yuv_data_t *)p_free_picture->p_data +i_height*i_chroma_width*5/2;
 655             break;
 656         case YUV_422_PICTURE:        /* YUV 422: 1,1/2,1/2 samples per pixel */
 657             i_chroma_width = i_width / 2;
 658             p_free_picture->p_data = malloc( i_height * i_chroma_width * 4 * sizeof( yuv_data_t ) );
 659             p_free_picture->p_y = (yuv_data_t *)p_free_picture->p_data;
 660             p_free_picture->p_u = (yuv_data_t *)p_free_picture->p_data +i_height*i_chroma_width*2;
 661             p_free_picture->p_v = (yuv_data_t *)p_free_picture->p_data +i_height*i_chroma_width*3;
 662             break;
 663         case YUV_444_PICTURE:            /* YUV 444: 1,1,1 samples per pixel */
 664             i_chroma_width = i_width;
 665             p_free_picture->p_data = malloc( i_height * i_chroma_width * 3 * sizeof( yuv_data_t ) );
 666             p_free_picture->p_y = (yuv_data_t *)p_free_picture->p_data;
 667             p_free_picture->p_u = (yuv_data_t *)p_free_picture->p_data +i_height*i_chroma_width;
 668             p_free_picture->p_v = (yuv_data_t *)p_free_picture->p_data +i_height*i_chroma_width*2;
 669             break;
 670 #ifdef DEBUG
 671         default:
 672             intf_DbgMsg("error: unknown picture type %d\n", i_type );
 673             p_free_picture->p_data   =  NULL;
 674             break;
 675 #endif
 676         }
 677
 678         if( p_free_picture->p_data != NULL )
 679         {
 680             /* Copy picture informations, set some default values */
 681             p_free_picture->i_type                      = i_type;
 682             p_free_picture->i_status                    = RESERVED_PICTURE;
 683             p_free_picture->i_matrix_coefficients       = 1;
 684             p_free_picture->i_width                     = i_width;
 685             p_free_picture->i_height                    = i_height;
 686             p_free_picture->i_chroma_width              = i_chroma_width;
 687             p_free_picture->i_display_horizontal_offset = 0;
 688             p_free_picture->i_display_vertical_offset   = 0;
 689             p_free_picture->i_display_width             = i_width;
 690             p_free_picture->i_display_height            = i_height;
 691             p_free_picture->i_aspect_ratio              = AR_SQUARE_PICTURE;
 692             p_free_picture->i_refcount                  = 0;
 693             p_vout->i_pictures++;
 694         }
 695         else
 696         {
 697             /* Memory allocation failed : set picture as empty */
 698             p_free_picture->i_type   =  EMPTY_PICTURE;
 699             p_free_picture->i_status =  FREE_PICTURE;
 700             p_free_picture =            NULL;
 701             intf_ErrMsg("warning: %s\n", strerror( ENOMEM ) );
 702         }
 703
 704 #ifdef DEBUG_VIDEO
 705         intf_DbgMsg("picture %p (in free picture slot)\n", p_free_picture );
 706 #endif
 707         vlc_mutex_unlock( &p_vout->picture_lock );
 708         return( p_free_picture );
 709     }
 710
 711     /* No free or destroyed picture could be found */
 712     intf_DbgMsg( "warning: heap is full\n" );
 713     vlc_mutex_unlock( &p_vout->picture_lock );
 714     return( NULL );
 715 }
 716
 717 /*****************************************************************************
 718  * vout_DestroyPicture: remove a permanent or reserved picture from the heap
 719  *****************************************************************************
 720  * This function frees a previously reserved picture or a permanent
 721  * picture. It is meant to be used when the construction of a picture aborted.
 722  * Note that the picture will be destroyed even if it is linked !
 723  *****************************************************************************/
 724 void vout_DestroyPicture( vout_thread_t *p_vout, picture_t *p_pic )
 725 {
 726    vlc_mutex_lock( &p_vout->picture_lock );
 727
 728 #ifdef DEBUG
 729    /* Check if picture status is valid */
 730    if( (p_pic->i_status != RESERVED_PICTURE) &&
 731        (p_pic->i_status != RESERVED_DATED_PICTURE) &&
 732        (p_pic->i_status != RESERVED_DISP_PICTURE) )
 733    {
 734        intf_DbgMsg("error: picture %p has invalid status %d\n", p_pic, p_pic->i_status );
 735    }
 736 #endif
 737
 738    p_pic->i_status = DESTROYED_PICTURE;
 739    p_vout->i_pictures--;
 740
 741 #ifdef DEBUG_VIDEO
 742    intf_DbgMsg("picture %p\n", p_pic);
 743 #endif
 744    vlc_mutex_unlock( &p_vout->picture_lock );
 745 }
 746
 747 /*****************************************************************************
 748  * vout_LinkPicture: increment reference counter of a picture
 749  *****************************************************************************
 750  * This function increment the reference counter of a picture in the video
 751  * heap. It needs a lock since several producer threads can access the picture.
 752  *****************************************************************************/
 753 void vout_LinkPicture( vout_thread_t *p_vout, picture_t *p_pic )
 754 {
 755     vlc_mutex_lock( &p_vout->picture_lock );
 756     p_pic->i_refcount++;
 757
 758 #ifdef DEBUG_VIDEO
 759     intf_DbgMsg("picture %p refcount=%d\n", p_pic, p_pic->i_refcount );
 760 #endif
 761
 762     vlc_mutex_unlock( &p_vout->picture_lock );
 763 }
 764
 765 /*****************************************************************************
 766  * vout_UnlinkPicture: decrement reference counter of a picture
 767  *****************************************************************************
 768  * This function decrement the reference counter of a picture in the video heap.
 769  *****************************************************************************/
 770 void vout_UnlinkPicture( vout_thread_t *p_vout, picture_t *p_pic )
 771 {
 772     vlc_mutex_lock( &p_vout->picture_lock );
 773     p_pic->i_refcount--;
 774
 775 #ifdef DEBUG_VIDEO
 776     if( p_pic->i_refcount < 0 )
 777     {
 778         intf_DbgMsg("error: refcount < 0\n");
 779         p_pic->i_refcount = 0;
 780     }
 781 #endif
 782
 783     if( (p_pic->i_refcount == 0) && (p_pic->i_status == DISPLAYED_PICTURE) )
 784     {
 785         p_pic->i_status = DESTROYED_PICTURE;
 786         p_vout->i_pictures--;
 787     }
 788
 789 #ifdef DEBUG_VIDEO
 790     intf_DbgMsg("picture %p refcount=%d\n", p_pic, p_pic->i_refcount );
 791 #endif
 792
 793     vlc_mutex_unlock( &p_vout->picture_lock );
 794 }
 795
 796 /*****************************************************************************
 797  * vout_SetBuffers: set buffers adresses
 798  *****************************************************************************
 799  * This function is called by system drivers to set buffers video memory
 800  * adresses.
 801  *****************************************************************************/
 802 void vout_SetBuffers( vout_thread_t *p_vout, void *p_buf1, void *p_buf2 )
 803 {
 804     /* No picture previously */
 805     p_vout->p_buffer[0].i_pic_x =         0;
 806     p_vout->p_buffer[0].i_pic_y =         0;
 807     p_vout->p_buffer[0].i_pic_width =     0;
 808     p_vout->p_buffer[0].i_pic_height =    0;
 809     p_vout->p_buffer[1].i_pic_x =         0;
 810     p_vout->p_buffer[1].i_pic_y =         0;
 811     p_vout->p_buffer[1].i_pic_width =     0;
 812     p_vout->p_buffer[1].i_pic_height =    0;
 813
 814     /* The first area covers all the screen */
 815     p_vout->p_buffer[0].i_areas =                 1;
 816     p_vout->p_buffer[0].pi_area_begin[0] =        0;
 817     p_vout->p_buffer[0].pi_area_end[0] =          p_vout->i_height - 1;
 818     p_vout->p_buffer[1].i_areas =                 1;
 819     p_vout->p_buffer[1].pi_area_begin[0] =        0;
 820     p_vout->p_buffer[1].pi_area_end[0] =          p_vout->i_height - 1;
 821
 822     /* Set adresses */
 823     p_vout->p_buffer[0].p_data = p_buf1;
 824     p_vout->p_buffer[1].p_data = p_buf2;
 825 }
 826
 827 /*****************************************************************************
 828  * vout_Pixel2RGB: return red, green and blue from pixel value
 829  *****************************************************************************
 830  * Return color values, in 0-255 range, of the decomposition of a pixel. This
 831  * is a slow routine and should only be used for initialization phase.
 832  *****************************************************************************/
 833 void vout_Pixel2RGB( vout_thread_t *p_vout, u32 i_pixel, int *pi_red, int *pi_green, int *pi_blue )
 834 {
 835     *pi_red =   i_pixel & p_vout->i_red_mask;
 836     *pi_green = i_pixel & p_vout->i_green_mask;
 837     *pi_blue =  i_pixel & p_vout->i_blue_mask;
 838 }
 839
 840 /* following functions are local */
 841
 842 /*****************************************************************************
 843  * BinaryLog: computes the base 2 log of a binary value
 844  *****************************************************************************
 845  * This functions is used by MaskToShift, to get a bit index from a binary
 846  * value.
 847  *****************************************************************************/
 848 static int BinaryLog(u32 i)
 849 {
 850     int i_log;
 851
 852     i_log = 0;
 853     if (i & 0xffff0000)
 854     {
 855         i_log = 16;
 856     }
 857     if (i & 0xff00ff00)
 858     {
 859         i_log += 8;
 860     }
 861     if (i & 0xf0f0f0f0)
 862     {
 863         i_log += 4;
 864     }
 865     if (i & 0xcccccccc)
 866     {
 867         i_log += 2;
 868     }
 869     if (i & 0xaaaaaaaa)
 870     {
 871         i_log++;
 872     }
 873     if (i != ((u32)1 << i_log))
 874     {
 875         intf_ErrMsg("internal error: binary log overflow\n");
 876     }
 877
 878     return( i_log );
 879 }
 880
 881 /*****************************************************************************
 882  * MaskToShift: transform a color mask into right and left shifts
 883  *****************************************************************************
 884  * This function is used for obtaining color shifts from masks.
 885  *****************************************************************************/
 886 static void MaskToShift( int *pi_left, int *pi_right, u32 i_mask )
 887 {
 888     u32 i_low, i_high;                 /* lower hand higher bits of the mask */
 889
 890     /* Get bits */
 891     i_low =  i_mask & (- i_mask);                   /* lower bit of the mask */
 892     i_high = i_mask + i_low;                       /* higher bit of the mask */
 893
 894     /* Transform bits into an index */
 895     i_low =  BinaryLog (i_low);
 896     i_high = BinaryLog (i_high);
 897
 898     /* Update pointers and return */
 899     *pi_left =   i_low;
 900     *pi_right = (8 - i_high + i_low);
 901 }
 902
 903 /*****************************************************************************
 904  * InitThread: initialize video output thread
 905  *****************************************************************************
 906  * This function is called from RunThread and performs the second step of the
 907  * initialization. It returns 0 on success. Note that the thread's flag are not
 908  * modified inside this function.
 909  *****************************************************************************/
 910 static int InitThread( vout_thread_t *p_vout )
 911 {
 912     /* Update status */
 913     intf_DbgMsg("\n");
 914     *p_vout->pi_status = THREAD_START;
 915
 916    /* Initialize output method - this function issues its own error messages */
 917     if( p_vout->p_sys_init( p_vout ) )
 918     {
 919         return( 1 );
 920     }
 921
 922     /* Initialize convertion tables and functions */
 923     if( vout_InitYUV( p_vout ) )
 924     {
 925         intf_ErrMsg("error: can't allocate YUV translation tables\n");
 926         return( 1 );
 927     }
 928
 929     /* Mark thread as running and return */
 930     p_vout->b_active =          1;
 931     *p_vout->pi_status =        THREAD_READY;
 932     intf_DbgMsg("thread ready\n");
 933     return( 0 );
 934 }
 935
 936 /*****************************************************************************
 937  * RunThread: video output thread
 938  *****************************************************************************
 939  * Video output thread. This function does only returns when the thread is
 940  * terminated. It handles the pictures arriving in the video heap and the
 941  * display device events.
 942  *****************************************************************************/
 943 static void RunThread( vout_thread_t *p_vout)
 944 {
 945     //?? welcome to gore land
 946     static int i_trash_count = 0;
 947     static mtime_t last_display_date = 0;
 948
 949     int             i_index;                                /* index in heap */
 950     mtime_t         current_date;                            /* current date */
 951     mtime_t         display_date;                            /* display date */
 952     boolean_t       b_display;                               /* display flag */
 953     picture_t *     p_pic;                                /* picture pointer */
 954     subpicture_t *  p_subpic;                          /* subpicture pointer */
 955
 956     /*
 957      * Initialize thread
 958      */
 959     p_vout->b_error = InitThread( p_vout );
 960     if( p_vout->b_error )
 961     {
 962         DestroyThread( p_vout, THREAD_ERROR );
 963         return;
 964     }
 965     intf_DbgMsg("\n");
 966
 967     /*
 968      * Main loop - it is not executed if an error occured during
 969      * initialization
 970      */
 971     while( (!p_vout->b_die) && (!p_vout->b_error) )
 972     {
 973         /* Initialize loop variables */
 974         p_pic =         NULL;
 975         p_subpic =      NULL;
 976         display_date =  0;
 977         current_date =  mdate();
 978
 979         /*
 980          * Find the picture to display - this operation does not need lock,
 981          * since only READY_PICTUREs are handled
 982          */
 983         for( i_index = 0; i_index < VOUT_MAX_PICTURES; i_index++ )
 984         {
 985             if( (p_vout->p_picture[i_index].i_status == READY_PICTURE) &&
 986             ( (p_pic == NULL) ||
 987               (p_vout->p_picture[i_index].date < display_date) ) )
 988             {
 989                 p_pic = &p_vout->p_picture[i_index];
 990                 display_date = p_pic->date;
 991             }
 992         }
 993
 994         if( p_pic )
 995         {
 996 #ifdef STATS
 997             /* Computes FPS rate */
 998             p_vout->p_fps_sample[ p_vout->c_fps_samples++ % VOUT_FPS_SAMPLES ] = display_date;
 999 #endif
1000 // ???
1001 i_trash_count++;
1002 fprintf( stderr, "gap : %Ld\n", display_date-last_display_date );
1003 last_display_date = display_date;
1004 #if 1
1005             if( display_date < current_date && i_trash_count > 4 )
1006             {
1007                 /* Picture is late: it will be destroyed and the thread will sleep and
1008                  * go to next picture */
1009
1010                 vlc_mutex_lock( &p_vout->picture_lock );
1011                 if( p_pic->i_refcount )
1012                 {
1013                     p_pic->i_status = DISPLAYED_PICTURE;
1014                 }
1015                 else
1016                 {
1017                     p_pic->i_status = DESTROYED_PICTURE;
1018                     p_vout->i_pictures--;
1019                 }
1020                 intf_DbgMsg( "warning: late picture %p skipped refcount=%d\n", p_pic, p_pic->i_refcount );
1021                 vlc_mutex_unlock( &p_vout->picture_lock );
1022
1023                 /* Update synchronization information as if display delay
1024                  * was 0 */
1025                 Synchronize( p_vout, display_date - current_date );
1026
1027                 p_pic =         NULL;
1028                 display_date =  0;
1029                 i_trash_count = 0;
1030             }
1031             else
1032 #endif
1033                 if( display_date > current_date + VOUT_DISPLAY_DELAY )
1034             {
1035                 /* A picture is ready to be rendered, but its rendering date is
1036                  * far from the current one so the thread will perform an empty loop
1037                  * as if no picture were found. The picture state is unchanged */
1038                 p_pic =         NULL;
1039                 display_date =  0;
1040             }
1041             else
1042             {
1043                 /* Picture will be displayed, update synchronization
1044                  * information */
1045                 Synchronize( p_vout, display_date - current_date );
1046             }
1047         }
1048         /*
1049          * Find the subpicture to display - this operation does not need lock, since
1050          * only READY_SUBPICTURES are handled. If no picture has been selected,
1051          * display_date will depend on the subpicture
1052          */
1053         //??
1054
1055         /*
1056          * Perform rendering, sleep and display rendered picture
1057          */
1058         if( p_pic )                        /* picture and perhaps subpicture */
1059         {
1060             b_display = p_vout->b_active;
1061             p_vout->last_display_date = display_date;
1062
1063             if( b_display )
1064             {
1065                 /* Set picture dimensions and clear buffer */
1066                 SetBufferPicture( p_vout, p_pic );
1067
1068                 /* Render picture and informations */
1069                 RenderPicture( p_vout, p_pic );
1070                 if( p_vout->b_info )
1071                 {
1072                     RenderPictureInfo( p_vout, p_pic );
1073                     RenderInfo( p_vout );
1074                 }
1075             }
1076
1077             /* Remove picture from heap */
1078             vlc_mutex_lock( &p_vout->picture_lock );
1079             if( p_pic->i_refcount )
1080             {
1081                 p_pic->i_status = DISPLAYED_PICTURE;
1082             }
1083             else
1084             {
1085                 p_pic->i_status = DESTROYED_PICTURE;
1086                 p_vout->i_pictures--;
1087             }
1088             vlc_mutex_unlock( &p_vout->picture_lock );
1089
1090             /* Render interface and subpicture */
1091             if( b_display && p_vout->b_interface )
1092             {
1093                 RenderInterface( p_vout );
1094             }
1095             if( p_subpic )
1096             {
1097                 if( b_display )
1098                 {
1099                     RenderSubPicture( p_vout, p_subpic );
1100                 }
1101
1102                 /* Remove subpicture from heap */
1103                 vlc_mutex_lock( &p_vout->subpicture_lock );
1104                 p_subpic->i_status = DESTROYED_SUBPICTURE;
1105                 vlc_mutex_unlock( &p_vout->subpicture_lock );
1106             }
1107
1108         }
1109         else if( p_subpic )                              /* subpicture alone */
1110         {
1111             b_display = p_vout->b_active;
1112             p_vout->last_display_date = display_date;
1113
1114             if( b_display )
1115             {
1116                 /* Clear buffer */
1117                 SetBufferPicture( p_vout, NULL );
1118
1119                 /* Render informations, interface and subpicture */
1120                 if( p_vout->b_info )
1121                 {
1122                     RenderInfo( p_vout );
1123                 }
1124                 if( p_vout->b_interface )
1125                 {
1126                     RenderInterface( p_vout );
1127                 }
1128                 RenderSubPicture( p_vout, p_subpic );
1129             }
1130
1131             /* Remove subpicture from heap */
1132             vlc_mutex_lock( &p_vout->subpicture_lock );
1133             p_subpic->i_status = DESTROYED_SUBPICTURE;
1134             vlc_mutex_unlock( &p_vout->subpicture_lock );
1135         }
1136         else if( p_vout->b_active )        /* idle or interface screen alone */
1137         {
1138             if( p_vout->b_interface && 0 /* && ?? intf_change */ )
1139             {
1140                 /* Interface has changed, so a new rendering is required - force
1141                  * it by setting last idle date to 0 */
1142                 p_vout->last_idle_date = 0;
1143             }
1144
1145             /* Render idle screen and update idle date, then render interface if
1146              * required */
1147             b_display = RenderIdle( p_vout );
1148             if( b_display )
1149             {
1150                 p_vout->last_idle_date = current_date;
1151                 if( p_vout->b_interface )
1152                 {
1153                     RenderInterface( p_vout );
1154                 }
1155             }
1156
1157         }
1158         else
1159         {
1160             b_display = 0;
1161         }
1162
1163         /*
1164          * Sleep, wake up and display rendered picture
1165          */
1166
1167 #ifdef STATS
1168         /* Store render time */
1169         p_vout->render_time = mdate() - current_date;
1170 #endif
1171
1172         /* Give back change lock */
1173         vlc_mutex_unlock( &p_vout->change_lock );
1174
1175         /* Sleep a while or until a given date */
1176         if( display_date != 0 )
1177         {
1178             mwait( display_date );
1179         }
1180         else
1181         {
1182             msleep( VOUT_IDLE_SLEEP );
1183         }
1184
1185         /* On awakening, take back lock and send immediately picture to display,
1186          * then swap buffers */
1187         vlc_mutex_lock( &p_vout->change_lock );
1188 #ifdef DEBUG_VIDEO
1189         intf_DbgMsg( "picture %p, subpicture %p in buffer %d, display=%d\n", p_pic, p_subpic,
1190                      p_vout->i_buffer_index, b_display && !(p_vout->i_changes & VOUT_NODISPLAY_CHANGE) );
1191 #endif
1192         if( b_display && !(p_vout->i_changes & VOUT_NODISPLAY_CHANGE) )
1193         {
1194             p_vout->p_sys_display( p_vout );
1195             p_vout->i_buffer_index = ++p_vout->i_buffer_index & 1;
1196         }
1197
1198         /*
1199          * Check events and manage thread
1200          */
1201         if( p_vout->p_sys_manage( p_vout ) | Manage( p_vout ) )
1202         {
1203             /* A fatal error occured, and the thread must terminate immediately,
1204              * without displaying anything - setting b_error to 1 cause the
1205              * immediate end of the main while() loop. */
1206             p_vout->b_error = 1;
1207         }
1208     }
1209
1210     /*
1211      * Error loop - wait until the thread destruction is requested
1212      */
1213     if( p_vout->b_error )
1214     {
1215         ErrorThread( p_vout );
1216     }
1217
1218     /* End of thread */
1219     EndThread( p_vout );
1220     DestroyThread( p_vout, THREAD_OVER );
1221     intf_DbgMsg( "thread end\n" );
1222 }
1223
1224 /*****************************************************************************
1225  * ErrorThread: RunThread() error loop
1226  *****************************************************************************
1227  * This function is called when an error occured during thread main's loop. The
1228  * thread can still receive feed, but must be ready to terminate as soon as
1229  * possible.
1230  *****************************************************************************/
1231 static void ErrorThread( vout_thread_t *p_vout )
1232 {
1233     /* Wait until a `die' order */
1234     intf_DbgMsg("\n");
1235     while( !p_vout->b_die )
1236     {
1237         /* Sleep a while */
1238         msleep( VOUT_IDLE_SLEEP );
1239     }
1240 }
1241
1242 /*****************************************************************************
1243  * EndThread: thread destruction
1244  *****************************************************************************
1245  * This function is called when the thread ends after a sucessfull
1246  * initialization. It frees all ressources allocated by InitThread.
1247  *****************************************************************************/
1248 static void EndThread( vout_thread_t *p_vout )
1249 {
1250     int     i_index;                                        /* index in heap */
1251
1252     /* Store status */
1253     intf_DbgMsg("\n");
1254     *p_vout->pi_status = THREAD_END;
1255
1256     /* Destroy all remaining pictures and subpictures */
1257     for( i_index = 0; i_index < VOUT_MAX_PICTURES; i_index++ )
1258     {
1259         if( p_vout->p_picture[i_index].i_status != FREE_PICTURE )
1260         {
1261             free( p_vout->p_picture[i_index].p_data );
1262         }
1263         if( p_vout->p_subpicture[i_index].i_status != FREE_SUBPICTURE )
1264         {
1265             free( p_vout->p_subpicture[i_index].p_data );
1266         }
1267     }
1268
1269     /* Destroy translation tables */
1270     vout_EndYUV( p_vout );
1271     p_vout->p_sys_end( p_vout );
1272 }
1273
1274 /*****************************************************************************
1275  * DestroyThread: thread destruction
1276  *****************************************************************************
1277  * This function is called when the thread ends. It frees all ressources
1278  * allocated by CreateThread. Status is available at this stage.
1279  *****************************************************************************/
1280 static void DestroyThread( vout_thread_t *p_vout, int i_status )
1281 {
1282     int *pi_status;                                         /* status adress */
1283
1284     /* Store status adress */
1285     intf_DbgMsg("\n");
1286     pi_status = p_vout->pi_status;
1287
1288     /* Destroy thread structures allocated by Create and InitThread */
1289     vout_UnloadFont( p_vout->p_default_font );
1290     vout_UnloadFont( p_vout->p_large_font );
1291     p_vout->p_sys_destroy( p_vout );
1292     free( p_vout );
1293     *pi_status = i_status;
1294 }
1295
1296 /*****************************************************************************
1297  * Print: print simple text on a picture
1298  *****************************************************************************
1299  * This function will print a simple text on the picture. It is designed to
1300  * print debugging or general informations.
1301  *****************************************************************************/
1302 void Print( vout_thread_t *p_vout, int i_x, int i_y, int i_h_align, int i_v_align, unsigned char *psz_text )
1303 {
1304     int                 i_text_height;                  /* total text height */
1305     int                 i_text_width;                    /* total text width */
1306
1307     /* Update upper left coordinates according to alignment */
1308     vout_TextSize( p_vout->p_default_font, 0, psz_text, &i_text_width, &i_text_height );
1309     if( !Align( p_vout, &i_x, &i_y, i_text_width, i_text_height, i_h_align, i_v_align ) )
1310     {
1311         /* Set area and print text */
1312         SetBufferArea( p_vout, i_x, i_y, i_text_width, i_text_height );
1313         vout_Print( p_vout->p_default_font, p_vout->p_buffer[ p_vout->i_buffer_index ].p_data +
1314                     i_y * p_vout->i_bytes_per_line + i_x * p_vout->i_bytes_per_pixel,
1315                     p_vout->i_bytes_per_pixel, p_vout->i_bytes_per_line,
1316                     p_vout->i_white_pixel, 0, 0,
1317                     0, psz_text );
1318     }
1319 }
1320
1321 /*****************************************************************************
1322  * SetBufferArea: activate an area in current buffer
1323  *****************************************************************************
1324  * This function is called when something is rendered on the current buffer.
1325  * It set the area as active and prepare it to be cleared on next rendering.
1326  * Pay attention to the fact that in this functions, i_h is in fact the end y
1327  * coordinate of the new area.
1328  *****************************************************************************/
1329 static void SetBufferArea( vout_thread_t *p_vout, int i_x, int i_y, int i_w, int i_h )
1330 {
1331     vout_buffer_t *     p_buffer;                          /* current buffer */
1332     int                 i_area_begin, i_area_end; /* area vertical extension */
1333     int                 i_area, i_area_copy;                   /* area index */
1334     int                 i_area_shift;            /* shift distance for areas */
1335
1336     /* Choose buffer and modify h to end of area position */
1337     p_buffer =  &p_vout->p_buffer[ p_vout->i_buffer_index ];
1338     i_h +=      i_y - 1;
1339
1340     /*
1341      * Remove part of the area which is inside the picture - this is done
1342      * by calling again SetBufferArea with the correct areas dimensions.
1343      */
1344     if( (i_x >= p_buffer->i_pic_x) && (i_x + i_w <= p_buffer->i_pic_x + p_buffer->i_pic_width) )
1345     {
1346         i_area_begin =  p_buffer->i_pic_y;
1347         i_area_end =    i_area_begin + p_buffer->i_pic_height - 1;
1348
1349         if( ((i_y >= i_area_begin) && (i_y <= i_area_end)) ||
1350             ((i_h >= i_area_begin) && (i_h <= i_area_end)) ||
1351             ((i_y <  i_area_begin) && (i_h > i_area_end)) )
1352         {
1353             /* Keep the stripe above the picture, if any */
1354             if( i_y < i_area_begin )
1355             {
1356                 SetBufferArea( p_vout, i_x, i_y, i_w, i_area_begin - i_y );
1357             }
1358             /* Keep the stripe below the picture, if any */
1359             if( i_h > i_area_end )
1360             {
1361                 SetBufferArea( p_vout, i_x, i_area_end, i_w, i_h - i_area_end );
1362             }
1363             return;
1364         }
1365     }
1366
1367     /* Skip some extensions until interesting areas */
1368     for( i_area = 0;
1369          (i_area < p_buffer->i_areas) &&
1370              (p_buffer->pi_area_end[i_area] + 1 <= i_y);
1371          i_area++ )
1372     {
1373         ;
1374     }
1375
1376     if( i_area == p_buffer->i_areas )
1377     {
1378         /* New area is below all existing ones: just add it at the end of the
1379          * array, if possible - else, append it to the last one */
1380         if( i_area < VOUT_MAX_AREAS )
1381         {
1382             p_buffer->pi_area_begin[i_area] = i_y;
1383             p_buffer->pi_area_end[i_area] = i_h;
1384             p_buffer->i_areas++;
1385         }
1386         else
1387         {
1388 #ifdef DEBUG_VIDEO
1389             intf_DbgMsg("areas overflow\n");
1390 #endif
1391             p_buffer->pi_area_end[VOUT_MAX_AREAS - 1] = i_h;
1392         }
1393     }
1394     else
1395     {
1396         i_area_begin =  p_buffer->pi_area_begin[i_area];
1397         i_area_end =    p_buffer->pi_area_end[i_area];
1398
1399         if( i_y < i_area_begin )
1400         {
1401             if( i_h >= i_area_begin - 1 )
1402             {
1403                 /* Extend area above */
1404                 p_buffer->pi_area_begin[i_area] = i_y;
1405             }
1406             else
1407             {
1408                 /* Create a new area above : merge last area if overflow, then
1409                  * move all old areas down */
1410                 if( p_buffer->i_areas == VOUT_MAX_AREAS )
1411                 {
1412 #ifdef DEBUG_VIDEO
1413                     intf_DbgMsg("areas overflow\n");
1414 #endif
1415                     p_buffer->pi_area_end[VOUT_MAX_AREAS - 2] = p_buffer->pi_area_end[VOUT_MAX_AREAS - 1];
1416                 }
1417                 else
1418                 {
1419                     p_buffer->i_areas++;
1420                 }
1421                 for( i_area_copy = p_buffer->i_areas - 1; i_area_copy > i_area; i_area_copy-- )
1422                 {
1423                     p_buffer->pi_area_begin[i_area_copy] = p_buffer->pi_area_begin[i_area_copy - 1];
1424                     p_buffer->pi_area_end[i_area_copy] =   p_buffer->pi_area_end[i_area_copy - 1];
1425                 }
1426                 p_buffer->pi_area_begin[i_area] = i_y;
1427                 p_buffer->pi_area_end[i_area] = i_h;
1428                 return;
1429             }
1430         }
1431         if( i_h > i_area_end )
1432         {
1433             /* Find further areas which can be merged with the new one */
1434             for( i_area_copy = i_area + 1;
1435                  (i_area_copy < p_buffer->i_areas) &&
1436                      (p_buffer->pi_area_begin[i_area] <= i_h);
1437                  i_area_copy++ )
1438             {
1439                 ;
1440             }
1441             i_area_copy--;
1442
1443             if( i_area_copy != i_area )
1444             {
1445                 /* Merge with last possible areas */
1446                 p_buffer->pi_area_end[i_area] = MAX( i_h, p_buffer->pi_area_end[i_area_copy] );
1447
1448                 /* Shift lower areas upward */
1449                 i_area_shift = i_area_copy - i_area;
1450                 p_buffer->i_areas -= i_area_shift;
1451                 for( i_area_copy = i_area + 1; i_area_copy < p_buffer->i_areas; i_area_copy++ )
1452                 {
1453                     p_buffer->pi_area_begin[i_area_copy] = p_buffer->pi_area_begin[i_area_copy + i_area_shift];
1454                     p_buffer->pi_area_end[i_area_copy] =   p_buffer->pi_area_end[i_area_copy + i_area_shift];
1455                 }
1456             }
1457             else
1458             {
1459                 /* Extend area below */
1460                 p_buffer->pi_area_end[i_area] = i_h;
1461             }
1462         }
1463     }
1464 }
1465
1466 /*****************************************************************************
1467  * SetBufferPicture: clear buffer and set picture area
1468  *****************************************************************************
1469  * This function is called before any rendering. It clears the current
1470  * rendering buffer and set the new picture area. If the picture pointer is
1471  * NULL, then no picture area is defined. Floating operations are avoided since
1472  * some MMX calculations may follow.
1473  *****************************************************************************/
1474 static void SetBufferPicture( vout_thread_t *p_vout, picture_t *p_pic )
1475 {
1476     vout_buffer_t *     p_buffer;                          /* current buffer */
1477     int                 i_pic_x, i_pic_y;                /* picture position */
1478     int                 i_pic_width, i_pic_height;     /* picture dimensions */
1479     int                 i_old_pic_y, i_old_pic_height;   /* old picture area */
1480     int                 i_vout_width, i_vout_height;   /* display dimensions */
1481     int                 i_area;                                /* area index */
1482     int                 i_data_index;                     /* area data index */
1483     int                 i_data_size;   /* area data size, in 256 bytes blocs */
1484     u64 *               p_data;                   /* area data, for clearing */
1485     byte_t *            p_data8;           /* area data, for clearing (slow) */
1486
1487     /* Choose buffer and set display dimensions */
1488     p_buffer =          &p_vout->p_buffer[ p_vout->i_buffer_index ];
1489     i_vout_width =      p_vout->i_width;
1490     i_vout_height =     p_vout->i_height;
1491
1492     /*
1493      * Computes new picture size
1494      */
1495     if( p_pic != NULL )
1496     {
1497         /* Try horizontal scaling first - width must be a mutiple of 16 */
1498         i_pic_width = (( p_vout->b_scale || (p_pic->i_width > i_vout_width)) ?
1499                        i_vout_width : p_pic->i_width) & ~0xf;
1500         switch( p_pic->i_aspect_ratio )
1501         {
1502         case AR_3_4_PICTURE:
1503             i_pic_height = i_pic_width * 3 / 4;
1504             break;
1505         case AR_16_9_PICTURE:
1506             i_pic_height = i_pic_width * 9 / 16;
1507             break;
1508         case AR_221_1_PICTURE:
1509             i_pic_height = i_pic_width * 100 / 221;
1510             break;
1511         case AR_SQUARE_PICTURE:
1512         default:
1513             i_pic_height = p_pic->i_height * i_pic_width / p_pic->i_width;
1514             break;
1515         }
1516
1517         /* If picture dimensions using horizontal scaling are too large, use
1518          * vertical scaling. Since width must be a multiple of 16, height is
1519          * adjusted again after. */
1520         if( i_pic_height > i_vout_height )
1521         {
1522             i_pic_height = ( p_vout->b_scale || (p_pic->i_height > i_vout_height)) ?
1523                 i_vout_height : p_pic->i_height;
1524             switch( p_pic->i_aspect_ratio )
1525             {
1526             case AR_3_4_PICTURE:
1527                 i_pic_width = (i_pic_height * 4 / 3) & ~0xf;
1528                 i_pic_height = i_pic_width * 3 / 4;
1529                 break;
1530             case AR_16_9_PICTURE:
1531                 i_pic_width = (i_pic_height * 16 / 9) & ~0xf;
1532                 i_pic_height = i_pic_width * 9 / 16;
1533                 break;
1534             case AR_221_1_PICTURE:
1535                 i_pic_width = (i_pic_height * 221 / 100) & ~0xf;
1536                 i_pic_height = i_pic_width * 100 / 221;
1537                 break;
1538             case AR_SQUARE_PICTURE:
1539             default:
1540                 i_pic_width = (p_pic->i_width * i_pic_height / p_pic->i_height) & ~0xf;
1541                 i_pic_height = p_pic->i_height * i_pic_width / p_pic->i_width;
1542                 break;
1543             }
1544         }
1545
1546         /* Set picture position */
1547         i_pic_x = (p_vout->i_width - i_pic_width) / 2;
1548         i_pic_y = (p_vout->i_height - i_pic_height) / 2;
1549     }
1550     else
1551     {
1552         /* No picture: size is 0 */
1553         i_pic_x =       0;
1554         i_pic_y =       0;
1555         i_pic_width =   0;
1556         i_pic_height =  0;
1557     }
1558
1559     /*
1560      * Set new picture size - if is is smaller than the previous one, clear
1561      * around it. Since picture are centered, only their size is tested.
1562      */
1563     if( (p_buffer->i_pic_width > i_pic_width) || (p_buffer->i_pic_height > i_pic_height) )
1564     {
1565         i_old_pic_y =            p_buffer->i_pic_y;
1566         i_old_pic_height =       p_buffer->i_pic_height;
1567         p_buffer->i_pic_x =      i_pic_x;
1568         p_buffer->i_pic_y =      i_pic_y;
1569         p_buffer->i_pic_width =  i_pic_width;
1570         p_buffer->i_pic_height = i_pic_height;
1571         SetBufferArea( p_vout, 0, i_old_pic_y, p_vout->i_width, i_old_pic_height );
1572     }
1573     else
1574     {
1575         p_buffer->i_pic_x =      i_pic_x;
1576         p_buffer->i_pic_y =      i_pic_y;
1577         p_buffer->i_pic_width =  i_pic_width;
1578         p_buffer->i_pic_height = i_pic_height;
1579     }
1580
1581     /*
1582      * Clear areas
1583      */
1584     for( i_area = 0; i_area < p_buffer->i_areas; i_area++ )
1585     {
1586 #ifdef DEBUG_VIDEO
1587         intf_DbgMsg("clearing picture %p area in buffer %d: %d-%d\n", p_pic,
1588                     p_vout->i_buffer_index, p_buffer->pi_area_begin[i_area], p_buffer->pi_area_end[i_area] );
1589 #endif
1590         i_data_size = (p_buffer->pi_area_end[i_area] - p_buffer->pi_area_begin[i_area] + 1) * p_vout->i_bytes_per_line;
1591         p_data = (u64*) (p_buffer->p_data + p_vout->i_bytes_per_line * p_buffer->pi_area_begin[i_area]);
1592         for( i_data_index = i_data_size / 256; i_data_index-- ; )
1593         {
1594             /* Clear 256 bytes block */
1595             *p_data++ = 0;  *p_data++ = 0;  *p_data++ = 0;  *p_data++ = 0;
1596             *p_data++ = 0;  *p_data++ = 0;  *p_data++ = 0;  *p_data++ = 0;
1597             *p_data++ = 0;  *p_data++ = 0;  *p_data++ = 0;  *p_data++ = 0;
1598             *p_data++ = 0;  *p_data++ = 0;  *p_data++ = 0;  *p_data++ = 0;
1599             *p_data++ = 0;  *p_data++ = 0;  *p_data++ = 0;  *p_data++ = 0;
1600             *p_data++ = 0;  *p_data++ = 0;  *p_data++ = 0;  *p_data++ = 0;
1601             *p_data++ = 0;  *p_data++ = 0;  *p_data++ = 0;  *p_data++ = 0;
1602             *p_data++ = 0;  *p_data++ = 0;  *p_data++ = 0;  *p_data++ = 0;
1603         }
1604         for( i_data_index = (i_data_size % 256) / 16; i_data_index--; )
1605         {
1606             /* Clear remaining 16 bytes blocks */
1607             *p_data++ = 0;  *p_data++ = 0;
1608         }
1609         p_data8 = (byte_t *)p_data;
1610         for( i_data_index = i_data_size % 16; i_data_index--; )
1611         {
1612             /* Clear remaining bytes */
1613             *p_data8++ = 0;
1614         }
1615     }
1616
1617     /*
1618      * Clear areas array
1619      */
1620     p_buffer->i_areas = 0;
1621 }
1622
1623 /*****************************************************************************
1624  * RenderPicture: render a picture
1625  *****************************************************************************
1626  * This function convert a picture from a video heap to a pixel-encoded image
1627  * and copy it to the current rendering buffer. No lock is required, since the
1628  * rendered picture has been determined as existant, and will only be destroyed
1629  * by the vout thread later.
1630  *****************************************************************************/
1631 static void RenderPicture( vout_thread_t *p_vout, picture_t *p_pic )
1632 {
1633 #ifdef DEBUG_VIDEO
1634     char                psz_date[MSTRTIME_MAX_SIZE];         /* picture date */
1635     mtime_t             render_time;               /* picture rendering time */
1636 #endif
1637     vout_buffer_t *     p_buffer;                        /* rendering buffer */
1638     byte_t *            p_pic_data;                /* convertion destination */
1639
1640     /* Get and set rendering informations */
1641     p_buffer =          &p_vout->p_buffer[ p_vout->i_buffer_index ];
1642     p_pic_data =        p_buffer->p_data +
1643         p_buffer->i_pic_x * p_vout->i_bytes_per_pixel +
1644         p_buffer->i_pic_y * p_vout->i_bytes_per_line;
1645 #ifdef DEBUG_VIDEO
1646     render_time = mdate();
1647 #endif
1648
1649     /*
1650      * Choose appropriate rendering function and render picture
1651      */
1652     switch( p_pic->i_type )
1653     {
1654     case YUV_420_PICTURE:
1655         p_vout->yuv.p_Convert420( p_vout, p_pic_data,
1656                                   p_pic->p_y, p_pic->p_u, p_pic->p_v,
1657                                   p_pic->i_width, p_pic->i_height,
1658                                   p_buffer->i_pic_width, p_buffer->i_pic_height,
1659                                   p_vout->i_bytes_per_line / p_vout->i_bytes_per_pixel,
1660                                   p_pic->i_matrix_coefficients );
1661         break;
1662     case YUV_422_PICTURE:
1663         p_vout->yuv.p_Convert422( p_vout, p_pic_data,
1664                                   p_pic->p_y, p_pic->p_u, p_pic->p_v,
1665                                   p_pic->i_width, p_pic->i_height,
1666                                   p_buffer->i_pic_width, p_buffer->i_pic_height,
1667                                   p_vout->i_bytes_per_line / p_vout->i_bytes_per_pixel,
1668                                   p_pic->i_matrix_coefficients );
1669         break;
1670     case YUV_444_PICTURE:
1671         p_vout->yuv.p_Convert444( p_vout, p_pic_data,
1672                                   p_pic->p_y, p_pic->p_u, p_pic->p_v,
1673                                   p_pic->i_width, p_pic->i_height,
1674                                   p_buffer->i_pic_width, p_buffer->i_pic_height,
1675                                   p_vout->i_bytes_per_line / p_vout->i_bytes_per_pixel,
1676                                   p_pic->i_matrix_coefficients );
1677         break;
1678 #ifdef DEBUG
1679     default:
1680         intf_DbgMsg("error: unknown picture type %d\n", p_pic->i_type );
1681         break;
1682 #endif
1683     }
1684
1685 #ifdef DEBUG_VIDEO
1686     /* Print picture date and rendering time */
1687     intf_DbgMsg("picture %p rendered in buffer %d (%ld us), display date: %s\n", p_pic,
1688                 p_vout->i_buffer_index, (long) (mdate() - render_time),
1689                 mstrtime( psz_date, p_pic->date ));
1690 #endif
1691 }
1692
1693 /*****************************************************************************
1694  * RenderPictureInfo: print additionnal informations on a picture
1695  *****************************************************************************
1696  * This function will print informations such as fps and other picture
1697  * dependant informations.
1698  *****************************************************************************/
1699 static void RenderPictureInfo( vout_thread_t *p_vout, picture_t *p_pic )
1700 {
1701 #if defined(STATS) || defined(DEBUG)
1702     char        psz_buffer[256];                            /* string buffer */
1703 #endif
1704
1705 #ifdef STATS
1706     /*
1707      * Print FPS rate in upper right corner
1708      */
1709     if( p_vout->c_fps_samples > VOUT_FPS_SAMPLES )
1710     {
1711         sprintf( psz_buffer, "%.2f fps", (double) VOUT_FPS_SAMPLES * 1000000 /
1712                  ( p_vout->p_fps_sample[ (p_vout->c_fps_samples - 1) % VOUT_FPS_SAMPLES ] -
1713                    p_vout->p_fps_sample[ p_vout->c_fps_samples % VOUT_FPS_SAMPLES ] ) );
1714         Print( p_vout, 0, 0, RIGHT_RALIGN, TOP_RALIGN, psz_buffer );
1715     }
1716
1717     /*
1718      * Print frames count and loop time in upper left corner
1719      */
1720     sprintf( psz_buffer, "%ld frames   rendering: %ld us",
1721              (long) p_vout->c_fps_samples, (long) p_vout->render_time );
1722     Print( p_vout, 0, 0, LEFT_RALIGN, TOP_RALIGN, psz_buffer );
1723 #endif
1724
1725 #ifdef DEBUG
1726     /*
1727      * Print picture information in lower right corner
1728      */
1729     sprintf( psz_buffer, "%s picture %dx%d (%dx%d%+d%+d %s) -> %dx%d+%d+%d",
1730              (p_pic->i_type == YUV_420_PICTURE) ? "4:2:0" :
1731              ((p_pic->i_type == YUV_422_PICTURE) ? "4:2:2" :
1732               ((p_pic->i_type == YUV_444_PICTURE) ? "4:4:4" : "ukn-type")),
1733              p_pic->i_width, p_pic->i_height,
1734              p_pic->i_display_width, p_pic->i_display_height,
1735              p_pic->i_display_horizontal_offset, p_pic->i_display_vertical_offset,
1736              (p_pic->i_aspect_ratio == AR_SQUARE_PICTURE) ? "sq" :
1737              ((p_pic->i_aspect_ratio == AR_3_4_PICTURE) ? "4:3" :
1738               ((p_pic->i_aspect_ratio == AR_16_9_PICTURE) ? "16:9" :
1739                ((p_pic->i_aspect_ratio == AR_221_1_PICTURE) ? "2.21:1" : "ukn-ar" ))),
1740              p_vout->p_buffer[ p_vout->i_buffer_index ].i_pic_width,
1741              p_vout->p_buffer[ p_vout->i_buffer_index ].i_pic_height,
1742              p_vout->p_buffer[ p_vout->i_buffer_index ].i_pic_x,
1743              p_vout->p_buffer[ p_vout->i_buffer_index ].i_pic_y );
1744     Print( p_vout, 0, 0, RIGHT_RALIGN, BOTTOM_RALIGN, psz_buffer );
1745 #endif
1746 }
1747
1748 /*****************************************************************************
1749  * RenderIdle: render idle picture
1750  *****************************************************************************
1751  * This function will print something on the screen. It will return 0 if
1752  * nothing has been rendered, or 1 if something has been changed on the screen.
1753  * Note that if you absolutely want something to be printed, you will have
1754  * to force it by setting the last idle date to 0.
1755  * Unlike other rendering functions, this one calls the SetBufferPicture
1756  * function when needed.
1757  *****************************************************************************/
1758 static int RenderIdle( vout_thread_t *p_vout )
1759 {
1760     int         i_x = 0, i_y = 0;                           /* text position */
1761     int         i_width, i_height;                              /* text size */
1762     mtime_t     current_date;                                /* current date */
1763     const char *psz_text = "waiting for stream ...";      /* text to display */
1764
1765
1766     current_date = mdate();
1767     if( (current_date - p_vout->last_display_date) > VOUT_IDLE_DELAY &&
1768         (current_date - p_vout->last_idle_date) > VOUT_IDLE_DELAY )
1769     {
1770         SetBufferPicture( p_vout, NULL );
1771         vout_TextSize( p_vout->p_large_font, WIDE_TEXT | OUTLINED_TEXT, psz_text,
1772                        &i_width, &i_height );
1773         if( !Align( p_vout, &i_x, &i_y, i_width, i_height, CENTER_RALIGN, CENTER_RALIGN ) )
1774         {
1775             vout_Print( p_vout->p_large_font,
1776                         p_vout->p_buffer[ p_vout->i_buffer_index ].p_data +
1777                         i_x * p_vout->i_bytes_per_pixel + i_y * p_vout->i_bytes_per_line,
1778                         p_vout->i_bytes_per_pixel, p_vout->i_bytes_per_line,
1779                         p_vout->i_white_pixel, p_vout->i_gray_pixel, 0,
1780                         WIDE_TEXT | OUTLINED_TEXT, psz_text );
1781             SetBufferArea( p_vout, i_x, i_y, i_width, i_height );
1782         }
1783         return( 1 );
1784     }
1785     return( 0 );
1786 }
1787
1788 /*****************************************************************************
1789  * RenderInfo: render additionnal informations
1790  *****************************************************************************
1791  * This function render informations which do not depend of the current picture
1792  * rendered.
1793  *****************************************************************************/
1794 static void RenderInfo( vout_thread_t *p_vout )
1795 {
1796 #ifdef DEBUG
1797     char        psz_buffer[256];                            /* string buffer */
1798     int         i_ready_pic = 0;                           /* ready pictures */
1799     int         i_reserved_pic = 0;                     /* reserved pictures */
1800     int         i_picture;                                  /* picture index */
1801 #endif
1802
1803 #ifdef DEBUG
1804     /*
1805      * Print thread state in lower left corner
1806      */
1807     for( i_picture = 0; i_picture < VOUT_MAX_PICTURES; i_picture++ )
1808     {
1809         switch( p_vout->p_picture[i_picture].i_status )
1810         {
1811         case RESERVED_PICTURE:
1812         case RESERVED_DATED_PICTURE:
1813         case RESERVED_DISP_PICTURE:
1814             i_reserved_pic++;
1815             break;
1816         case READY_PICTURE:
1817             i_ready_pic++;
1818             break;
1819         }
1820     }
1821     sprintf( psz_buffer, "pic: %d (%d/%d)/%d",
1822              p_vout->i_pictures, i_reserved_pic, i_ready_pic, VOUT_MAX_PICTURES );
1823     Print( p_vout, 0, 0, LEFT_RALIGN, BOTTOM_RALIGN, psz_buffer );
1824 #endif
1825 }
1826
1827 /*****************************************************************************
1828  * RenderSubPicture: render a subpicture
1829  *****************************************************************************
1830  * This function render a sub picture unit.
1831  *****************************************************************************/
1832 static void RenderSubPicture( vout_thread_t *p_vout, subpicture_t *p_subpic )
1833 {
1834     p_vout_font_t       p_font;                                 /* text font */
1835     int                 i_width, i_height;          /* subpicture dimensions */
1836
1837     switch( p_subpic->i_type )
1838     {
1839     case TEXT_SUBPICTURE:                                /* single line text */
1840         /* Select default font if not specified */
1841         p_font = p_subpic->type.text.p_font;
1842         if( p_font == NULL )
1843         {
1844             p_font = p_vout->p_default_font;
1845         }
1846
1847         /* Computes text size (width and height fields are ignored) and print it */
1848         vout_TextSize( p_font, p_subpic->type.text.i_style, p_subpic->p_data, &i_width, &i_height );
1849         if( !Align( p_vout, &p_subpic->i_x, &p_subpic->i_y, i_width, i_height,
1850                     p_subpic->i_horizontal_align, p_subpic->i_vertical_align ) )
1851         {
1852             vout_Print( p_font, p_vout->p_buffer[ p_vout->i_buffer_index ].p_data +
1853                         p_subpic->i_x * p_vout->i_bytes_per_pixel +
1854                         p_subpic->i_y * p_vout->i_bytes_per_line,
1855                         p_vout->i_bytes_per_pixel, p_vout->i_bytes_per_line,
1856                         p_subpic->type.text.i_char_color, p_subpic->type.text.i_border_color,
1857                         p_subpic->type.text.i_bg_color, p_subpic->type.text.i_style,
1858                         p_subpic->p_data );
1859             SetBufferArea( p_vout, p_subpic->i_x, p_subpic->i_y, i_width, i_height );
1860         }
1861         break;
1862
1863 #ifdef DEBUG
1864     default:
1865         intf_DbgMsg("error: unknown subpicture %p type %d\n", p_subpic, p_subpic->i_type );
1866 #endif
1867     }
1868 }
1869
1870 /*****************************************************************************
1871  * RenderInterface: render the interface
1872  *****************************************************************************
1873  * This function render the interface, if any.
1874  *****************************************************************************/
1875 static void RenderInterface( vout_thread_t *p_vout )
1876 {
1877     int         i_height, i_text_height;            /* total and text height */
1878     int         i_width_1, i_width_2;                          /* text width */
1879     int         i_byte;                                        /* byte index */
1880     const char *psz_text_1 = "[1-9] Channel   [i]nfo   [c]olor     [g/G]amma";
1881     const char *psz_text_2 = "[+/-] Volume    [m]ute   [s]caling   [Q]uit";
1882
1883     /* Get text size */
1884     vout_TextSize( p_vout->p_large_font, OUTLINED_TEXT, psz_text_1, &i_width_1, &i_height );
1885     vout_TextSize( p_vout->p_large_font, OUTLINED_TEXT, psz_text_2, &i_width_2, &i_text_height );
1886     i_height += i_text_height;
1887
1888     /* Render background */
1889     for( i_byte = (p_vout->i_height - i_height) * p_vout->i_bytes_per_line;
1890          i_byte < p_vout->i_height * p_vout->i_bytes_per_line;
1891          i_byte++ )
1892     {
1893         //?? noooo !
1894         p_vout->p_buffer[ p_vout->i_buffer_index ].p_data[ i_byte ] = p_vout->i_blue_pixel;
1895     }
1896
1897     /* Render text, if not larger than screen */
1898     if( i_width_1 < p_vout->i_width )
1899     {
1900         vout_Print( p_vout->p_large_font, p_vout->p_buffer[ p_vout->i_buffer_index ].p_data +
1901                     (p_vout->i_height - i_height) * p_vout->i_bytes_per_line,
1902                     p_vout->i_bytes_per_pixel, p_vout->i_bytes_per_line,
1903                     p_vout->i_white_pixel, p_vout->i_black_pixel, 0,
1904                     OUTLINED_TEXT, psz_text_1 );
1905     }
1906     if( i_width_2 < p_vout->i_width )
1907     {
1908         vout_Print( p_vout->p_large_font, p_vout->p_buffer[ p_vout->i_buffer_index ].p_data +
1909                     (p_vout->i_height - i_height + i_text_height) * p_vout->i_bytes_per_line,
1910                     p_vout->i_bytes_per_pixel, p_vout->i_bytes_per_line,
1911                     p_vout->i_white_pixel, p_vout->i_black_pixel, 0,
1912                     OUTLINED_TEXT, psz_text_2 );
1913     }
1914
1915     /* Activate modified area */
1916     SetBufferArea( p_vout, 0, p_vout->i_height - i_height, p_vout->i_width, i_height );
1917 }
1918
1919 /*****************************************************************************
1920  * Synchronize: update synchro level depending of heap state
1921  *****************************************************************************
1922  * This function is called during the main vout loop.
1923  *****************************************************************************/
1924 static void Synchronize( vout_thread_t *p_vout, s64 i_delay )
1925 {
1926     int i_synchro_inc = 0;
1927     //???? gore following
1928     static int i_panic_count = 0;
1929     static int i_last_synchro_inc = 0;
1930     static float r_synchro_level = VOUT_SYNCHRO_LEVEL_START;
1931     static int i_truc = 10;
1932
1933     if( i_delay < 0 )
1934     {
1935         fprintf( stderr, "PANIC %d\n", i_panic_count );
1936         i_panic_count++;
1937     }
1938
1939     i_truc *= 2;
1940
1941     if( p_vout->i_pictures > VOUT_SYNCHRO_HEAP_IDEAL_SIZE+1 )
1942     {
1943         i_truc = 40;
1944         i_synchro_inc += p_vout->i_pictures - VOUT_SYNCHRO_HEAP_IDEAL_SIZE - 1;
1945
1946     }
1947     else
1948     {
1949         if( p_vout->i_pictures < VOUT_SYNCHRO_HEAP_IDEAL_SIZE )
1950         {
1951             i_truc = 32;
1952             //i_synchro_inc += p_vout->i_pictures - VOUT_SYNCHRO_HEAP_IDEAL_SIZE;
1953         }
1954
1955         if( i_delay < 1000 )
1956         {
1957             //i_truc = 4;
1958         }
1959     }
1960
1961     if( i_truc > VOUT_SYNCHRO_LEVEL_MAX*2*2*2*2*2 ||
1962         i_synchro_inc*i_last_synchro_inc < 0 )
1963     {
1964         i_truc = 32;
1965     }
1966
1967     if( i_delay < 6000 )
1968     {
1969         i_truc = 16;
1970         i_synchro_inc -= 2;
1971     }
1972     else if( i_delay < 70000 )
1973     {
1974         i_truc = 24+(24*i_delay)/70000;
1975         if( i_truc < 16 )
1976             i_truc = 16;
1977         i_synchro_inc -= 1+(5*(70000-i_delay))/70000;
1978     }
1979     else if( i_delay > 100000 )
1980     {
1981         r_synchro_level += 1;
1982         if( i_delay > 130000 )
1983             r_synchro_level += 1;
1984     }
1985
1986     r_synchro_level += (float)i_synchro_inc / i_truc;
1987     p_vout->i_synchro_level = (int)(r_synchro_level+0.5);
1988
1989     if( r_synchro_level > VOUT_SYNCHRO_LEVEL_MAX )
1990     {
1991         r_synchro_level = VOUT_SYNCHRO_LEVEL_MAX;
1992     }
1993
1994     fprintf( stderr, "synchro level : %d, heap : %d (%d, %d) (%d, %f) - %Ld\n", p_vout->i_synchro_level,
1995             p_vout->i_pictures, i_last_synchro_inc, i_synchro_inc, i_truc, r_synchro_level, i_delay );
1996     i_last_synchro_inc = i_synchro_inc;
1997 }
1998
1999 /*****************************************************************************
2000  * Manage: manage thread
2001  *****************************************************************************
2002  * This function will handle changes in thread configuration.
2003  *****************************************************************************/
2004 static int Manage( vout_thread_t *p_vout )
2005 {
2006 #ifdef DEBUG_VIDEO
2007     if( p_vout->i_changes )
2008     {
2009         intf_DbgMsg("changes: 0x%x (no display: 0x%x)\n", p_vout->i_changes,
2010                     p_vout->i_changes & VOUT_NODISPLAY_CHANGE );
2011     }
2012 #endif
2013
2014     /* On gamma or grayscale change, rebuild tables */
2015     if( p_vout->i_changes & (VOUT_GAMMA_CHANGE | VOUT_GRAYSCALE_CHANGE |
2016                              VOUT_YUV_CHANGE) )
2017     {
2018         if( vout_ResetYUV( p_vout ) )
2019         {
2020             intf_ErrMsg("error: can't rebuild convertion tables\n");
2021             return( 1 );
2022         }
2023     }
2024
2025     /* Clear changes flags which does not need management or have been
2026      * handled */
2027     p_vout->i_changes &= ~(VOUT_GAMMA_CHANGE | VOUT_GRAYSCALE_CHANGE |
2028                            VOUT_YUV_CHANGE   | VOUT_INFO_CHANGE |
2029                            VOUT_INTF_CHANGE  | VOUT_SCALE_CHANGE );
2030
2031     /* Detect unauthorized changes */
2032     if( p_vout->i_changes )
2033     {
2034         /* Some changes were not acknowledged by p_vout->p_sys_manage or this
2035          * function, it means they should not be authorized */
2036         intf_ErrMsg( "error: unauthorized changes in the video output thread\n" );
2037         return( 1 );
2038     }
2039
2040     return( 0 );
2041 }
2042
2043 /*****************************************************************************
2044  * Align: align a subpicture in the screen
2045  *****************************************************************************
2046  * This function is used for rendering text or subpictures. It returns non 0
2047  * it the final aera is not fully included in display area. Return coordinates
2048  * are absolute.
2049  *****************************************************************************/
2050 static int Align( vout_thread_t *p_vout, int *pi_x, int *pi_y,
2051                    int i_width, int i_height, int i_h_align, int i_v_align )
2052 {
2053     /* Align horizontally */
2054     switch( i_h_align )
2055     {
2056     case CENTER_ALIGN:
2057         *pi_x -= i_width / 2;
2058         break;
2059     case CENTER_RALIGN:
2060         *pi_x += (p_vout->i_width - i_width) / 2;
2061         break;
2062     case RIGHT_ALIGN:
2063         *pi_x -= i_width;
2064         break;
2065     case RIGHT_RALIGN:
2066         *pi_x += p_vout->i_width - i_width;
2067         break;
2068     }
2069
2070     /* Align vertically */
2071     switch( i_v_align )
2072     {
2073     case CENTER_ALIGN:
2074         *pi_y -= i_height / 2;
2075         break;
2076     case CENTER_RALIGN:
2077         *pi_y += (p_vout->i_height - i_height) / 2;
2078         break;
2079     case BOTTOM_ALIGN:
2080         *pi_y -= i_height;
2081         break;
2082     case BOTTOM_RALIGN:
2083         *pi_y += p_vout->i_height - i_height;
2084         break;
2085     case SUBTITLE_RALIGN:
2086         *pi_y += (p_vout->i_height + p_vout->p_buffer[ p_vout->i_buffer_index ].i_pic_y +
2087                   p_vout->p_buffer[ p_vout->i_buffer_index ].i_pic_height - i_height) / 2;
2088         break;
2089     }
2090
2091     /* Return non 0 if clipping failed */
2092     return( (*pi_x < 0) || (*pi_y < 0) ||
2093             (*pi_x + i_width > p_vout->i_width) || (*pi_y + i_height > p_vout->i_height) );
2094 }
2095
2096 /*****************************************************************************
2097  * SetPalette: sets an 8 bpp palette
2098  *****************************************************************************
2099  * This function is just a prototype that does nothing. Architectures that
2100  * support palette allocation should override it.
2101  *****************************************************************************/
2102 static void     SetPalette        ( p_vout_thread_t p_vout, u16 *red,
2103                                     u16 *green, u16 *blue, u16 *transp )
2104 {
2105     intf_ErrMsg( "SetPalette: method does not support palette changing\n" );
2106 }
2107