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

   1 /*****************************************************************************
   2  * vout_subpictures.c : subpicture management functions
   3  *****************************************************************************
   4  * Copyright (C) 2000-2007 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Vincent Seguin <seguin@via.ecp.fr>
   8  *          Samuel Hocevar <sam@zoy.org>
   9  *          Gildas Bazin <gbazin@videolan.org>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  24  *****************************************************************************/
  25
  26 /*****************************************************************************
  27  * Preamble
  28  *****************************************************************************/
  29 #ifdef HAVE_CONFIG_H
  30 # include "config.h"
  31 #endif
  32
  33 #include <vlc_common.h>
  34 #include <vlc_vout.h>
  35 #include <vlc_block.h>
  36 #include <vlc_filter.h>
  37 #include <vlc_osd.h>
  38 #include "../libvlc.h"
  39
  40 #include <assert.h>
  41 #include <limits.h>
  42
  43 /*****************************************************************************
  44  * Local prototypes
  45  *****************************************************************************/
  46 static void UpdateSPU   ( spu_t *, vlc_object_t * );
  47 static int  CropCallback( vlc_object_t *, char const *,
  48                           vlc_value_t, vlc_value_t, void * );
  49
  50 static int spu_vaControlDefault( spu_t *, int, va_list );
  51
  52 static subpicture_t *sub_new_buffer( filter_t * );
  53 static void sub_del_buffer( filter_t *, subpicture_t * );
  54 static subpicture_t *spu_new_buffer( filter_t * );
  55 static void spu_del_buffer( filter_t *, subpicture_t * );
  56 static picture_t *spu_new_video_buffer( filter_t * );
  57 static void spu_del_video_buffer( filter_t *, picture_t * );
  58
  59 static int spu_ParseChain( spu_t * );
  60 static int SubFilterCallback( vlc_object_t *, char const *,
  61                               vlc_value_t, vlc_value_t, void * );
  62
  63 static int SubFilterAllocationInit( filter_t *, void * );
  64 static void SubFilterAllocationClean( filter_t * );
  65 struct filter_owner_sys_t
  66 {
  67     spu_t *p_spu;
  68     int i_channel;
  69 };
  70
  71 #define SCALE_UNIT (1000)
  72
  73 /* */
  74 struct subpicture_region_private_t
  75 {
  76     video_format_t fmt;
  77     picture_t      *p_picture;
  78 };
  79
  80 static subpicture_region_private_t *SpuRegionPrivateCreate( video_format_t *p_fmt )
  81 {
  82     subpicture_region_private_t *p_private = malloc( sizeof(*p_private) );
  83
  84     if( !p_private )
  85         return NULL;
  86
  87     p_private->fmt = *p_fmt;
  88     if( p_fmt->p_palette )
  89     {
  90         p_private->fmt.p_palette = malloc( sizeof(*p_private->fmt.p_palette) );
  91         if( p_private->fmt.p_palette )
  92             *p_private->fmt.p_palette = *p_fmt->p_palette;
  93     }
  94     p_private->p_picture = NULL;
  95
  96     return p_private;
  97 }
  98 static void SpuRegionPrivateDestroy( subpicture_region_private_t *p_private )
  99 {
 100     if( p_private->p_picture )
 101         picture_Release( p_private->p_picture );
 102     free( p_private->fmt.p_palette );
 103     free( p_private );
 104 }
 105
 106 /* */
 107 static void SpuRenderCreateAndLoadText( spu_t *p_spu );
 108 static void SpuRenderCreateAndLoadScale( spu_t *p_spu );
 109 static void FilterRelease( filter_t *p_filter );
 110
 111 /**
 112  * Creates the subpicture unit
 113  *
 114  * \param p_this the parent object which creates the subpicture unit
 115  */
 116 spu_t *__spu_Create( vlc_object_t *p_this )
 117 {
 118     int i_index;
 119     spu_t *p_spu = vlc_custom_create( p_this, sizeof( spu_t ),
 120                                       VLC_OBJECT_GENERIC, "subpicture" );
 121     /* */
 122     p_spu->i_subpicture_order = 1;
 123     for( i_index = 0; i_index < VOUT_MAX_SUBPICTURES; i_index++)
 124     {
 125         p_spu->p_subpicture[i_index].i_status = FREE_SUBPICTURE;
 126     }
 127
 128     p_spu->p_blend = NULL;
 129     p_spu->p_text = NULL;
 130     p_spu->p_scale = NULL;
 131     p_spu->p_scale_yuvp = NULL;
 132     p_spu->pf_control = spu_vaControlDefault;
 133
 134     /* Register the default subpicture channel */
 135     p_spu->i_channel = 2;
 136
 137     vlc_mutex_init( &p_spu->subpicture_lock );
 138
 139     vlc_object_attach( p_spu, p_this );
 140
 141     p_spu->p_chain = filter_chain_New( p_spu, "sub filter", false,
 142                                        SubFilterAllocationInit,
 143                                        SubFilterAllocationClean,
 144                                        p_spu );
 145
 146     /* Load text and scale module */
 147     SpuRenderCreateAndLoadText( p_spu );
 148     SpuRenderCreateAndLoadScale( p_spu );
 149
 150     return p_spu;
 151 }
 152
 153 /**
 154  * Initialise the subpicture unit
 155  *
 156  * \param p_spu the subpicture unit object
 157  */
 158 int spu_Init( spu_t *p_spu )
 159 {
 160     vlc_value_t val;
 161
 162     /* If the user requested a sub margin, we force the position. */
 163     var_Create( p_spu, "sub-margin", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
 164     var_Get( p_spu, "sub-margin", &val );
 165     p_spu->i_margin = val.i_int;
 166
 167     var_Create( p_spu, "sub-filter", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 168     var_AddCallback( p_spu, "sub-filter", SubFilterCallback, p_spu );
 169
 170     spu_ParseChain( p_spu );
 171
 172     return VLC_SUCCESS;
 173 }
 174
 175 int spu_ParseChain( spu_t *p_spu )
 176 {
 177     char *psz_parser = var_GetString( p_spu, "sub-filter" );
 178     if( filter_chain_AppendFromString( p_spu->p_chain, psz_parser ) < 0 )
 179     {
 180         free( psz_parser );
 181         return VLC_EGENERIC;
 182     }
 183
 184     free( psz_parser );
 185     return VLC_SUCCESS;
 186 }
 187
 188 /**
 189  * Destroy the subpicture unit
 190  *
 191  * \param p_this the parent object which destroys the subpicture unit
 192  */
 193 void spu_Destroy( spu_t *p_spu )
 194 {
 195     int i_index;
 196
 197     /* Destroy all remaining subpictures */
 198     for( i_index = 0; i_index < VOUT_MAX_SUBPICTURES; i_index++ )
 199     {
 200         if( p_spu->p_subpicture[i_index].i_status != FREE_SUBPICTURE )
 201         {
 202             spu_DestroySubpicture( p_spu, &p_spu->p_subpicture[i_index] );
 203         }
 204     }
 205
 206     if( p_spu->p_blend )
 207         FilterRelease( p_spu->p_blend );
 208
 209     if( p_spu->p_text )
 210         FilterRelease( p_spu->p_text );
 211
 212     if( p_spu->p_scale_yuvp )
 213         FilterRelease( p_spu->p_scale_yuvp );
 214
 215     if( p_spu->p_scale )
 216         FilterRelease( p_spu->p_scale );
 217
 218     filter_chain_Delete( p_spu->p_chain );
 219
 220     vlc_mutex_destroy( &p_spu->subpicture_lock );
 221     vlc_object_release( p_spu );
 222 }
 223
 224 /**
 225  * Attach/Detach the SPU from any input
 226  *
 227  * \param p_this the object in which to destroy the subpicture unit
 228  * \param b_attach to select attach or detach
 229  */
 230 void spu_Attach( spu_t *p_spu, vlc_object_t *p_this, bool b_attach )
 231 {
 232     vlc_object_t *p_input;
 233
 234     p_input = vlc_object_find( p_this, VLC_OBJECT_INPUT, FIND_PARENT );
 235     if( !p_input ) return;
 236
 237     if( b_attach )
 238     {
 239         UpdateSPU( p_spu, VLC_OBJECT(p_input) );
 240         var_AddCallback( p_input, "highlight", CropCallback, p_spu );
 241         vlc_object_release( p_input );
 242     }
 243     else
 244     {
 245         /* Delete callback */
 246         var_DelCallback( p_input, "highlight", CropCallback, p_spu );
 247         vlc_object_release( p_input );
 248     }
 249 }
 250
 251 /**
 252  * Create a subpicture region
 253  *
 254  * \param p_this vlc_object_t
 255  * \param p_fmt the format that this subpicture region should have
 256  */
 257 subpicture_region_t *__spu_CreateRegion( vlc_object_t *p_this,
 258                                          video_format_t *p_fmt )
 259 {
 260     subpicture_region_t *p_region = calloc( 1, sizeof(*p_region ) );
 261     if( !p_region )
 262         return NULL;
 263
 264     /* FIXME is that *really* wanted? */
 265     if( p_fmt->i_chroma == VLC_FOURCC('Y','U','V','P') )
 266         p_fmt->p_palette = calloc( 1, sizeof(video_palette_t) );
 267     else
 268         p_fmt->p_palette = NULL;    /* XXX and that above all? */
 269
 270     p_region->fmt = *p_fmt;
 271     p_region->i_alpha = 0xff;
 272     p_region->p_next = NULL;
 273     p_region->p_private = NULL;
 274     p_region->psz_text = NULL;
 275     p_region->p_style = NULL;
 276     p_region->p_picture = NULL;
 277
 278     if( p_fmt->i_chroma == VLC_FOURCC('T','E','X','T') )
 279         return p_region;
 280
 281     p_region->p_picture = picture_New( p_fmt->i_chroma, p_fmt->i_width, p_fmt->i_height,
 282                                        p_fmt->i_aspect );
 283     if( !p_region->p_picture )
 284     {
 285         free( p_fmt->p_palette );
 286         free( p_region );
 287         return NULL;
 288     }
 289
 290     return p_region;
 291 }
 292
 293 /**
 294  * Destroy a subpicture region
 295  *
 296  * \param p_this vlc_object_t
 297  * \param p_region the subpicture region to destroy
 298  */
 299 void __spu_DestroyRegion( vlc_object_t *p_this, subpicture_region_t *p_region )
 300 {
 301     if( !p_region )
 302         return;
 303
 304     if( p_region->p_private )
 305         SpuRegionPrivateDestroy( p_region->p_private );
 306
 307     if( p_region->p_picture )
 308         picture_Release( p_region->p_picture );
 309
 310     free( p_region->fmt.p_palette );
 311
 312     free( p_region->psz_text );
 313     free( p_region->psz_html );
 314     //free( p_region->p_style ); FIXME --fenrir plugin does not allocate the memory for it. I think it might lead to segfault, video renderer can live longer than the decoder
 315     free( p_region );
 316 }
 317
 318 /**
 319  * Display a subpicture
 320  *
 321  * Remove the reservation flag of a subpicture, which will cause it to be
 322  * ready for display.
 323  * \param p_spu the subpicture unit object
 324  * \param p_subpic the subpicture to display
 325  */
 326 void spu_DisplaySubpicture( spu_t *p_spu, subpicture_t *p_subpic )
 327 {
 328     /* Check if status is valid */
 329     if( p_subpic->i_status != RESERVED_SUBPICTURE )
 330     {
 331         msg_Err( p_spu, "subpicture %p has invalid status #%d",
 332                  p_subpic, p_subpic->i_status );
 333     }
 334
 335     if( p_subpic->i_channel == DEFAULT_CHAN )
 336     {
 337         p_subpic->i_channel = 0xFFFF;
 338         spu_Control( p_spu, SPU_CHANNEL_CLEAR, DEFAULT_CHAN );
 339         p_subpic->i_channel = DEFAULT_CHAN;
 340     }
 341
 342     /* Remove reservation flag */
 343     p_subpic->i_status = READY_SUBPICTURE;
 344 }
 345
 346 /**
 347  * Allocate a subpicture in the spu heap.
 348  *
 349  * This function create a reserved subpicture in the spu heap.
 350  * A null pointer is returned if the function fails. This method provides an
 351  * already allocated zone of memory in the spu data fields. It needs locking
 352  * since several pictures can be created by several producers threads.
 353  * \param p_spu the subpicture unit in which to create the subpicture
 354  * \return NULL on error, a reserved subpicture otherwise
 355  */
 356 subpicture_t *spu_CreateSubpicture( spu_t *p_spu )
 357 {
 358     int                 i_subpic;                        /* subpicture index */
 359     subpicture_t *      p_subpic = NULL;            /* first free subpicture */
 360
 361     /* Get lock */
 362     vlc_mutex_lock( &p_spu->subpicture_lock );
 363
 364     /*
 365      * Look for an empty place
 366      */
 367     p_subpic = NULL;
 368     for( i_subpic = 0; i_subpic < VOUT_MAX_SUBPICTURES; i_subpic++ )
 369     {
 370         if( p_spu->p_subpicture[i_subpic].i_status == FREE_SUBPICTURE )
 371         {
 372             /* Subpicture is empty and ready for allocation */
 373             p_subpic = &p_spu->p_subpicture[i_subpic];
 374             p_spu->p_subpicture[i_subpic].i_status = RESERVED_SUBPICTURE;
 375             break;
 376         }
 377     }
 378
 379     /* If no free subpicture could be found */
 380     if( p_subpic == NULL )
 381     {
 382         msg_Err( p_spu, "subpicture heap is full" );
 383         vlc_mutex_unlock( &p_spu->subpicture_lock );
 384         return NULL;
 385     }
 386
 387     /* Copy subpicture information, set some default values */
 388     memset( p_subpic, 0, sizeof(subpicture_t) );
 389     p_subpic->i_order    = p_spu->i_subpicture_order++;
 390     p_subpic->i_status   = RESERVED_SUBPICTURE;
 391     p_subpic->b_absolute = true;
 392     p_subpic->b_fade     = false;
 393     p_subpic->b_subtitle = false;
 394     p_subpic->i_alpha    = 0xFF;
 395     p_subpic->p_region   = NULL;
 396     p_subpic->pf_render  = NULL;
 397     p_subpic->pf_destroy = NULL;
 398     p_subpic->p_sys      = NULL;
 399     vlc_mutex_unlock( &p_spu->subpicture_lock );
 400
 401     p_subpic->pf_create_region = __spu_CreateRegion;
 402     p_subpic->pf_destroy_region = __spu_DestroyRegion;
 403
 404     return p_subpic;
 405 }
 406
 407 /**
 408  * Remove a subpicture from the heap
 409  *
 410  * This function frees a previously reserved subpicture.
 411  * It is meant to be used when the construction of a picture aborted.
 412  * This function does not need locking since reserved subpictures are ignored
 413  * by the spu.
 414  */
 415 void spu_DestroySubpicture( spu_t *p_spu, subpicture_t *p_subpic )
 416 {
 417     /* Get lock */
 418     vlc_mutex_lock( &p_spu->subpicture_lock );
 419
 420     /* There can be race conditions so we need to check the status */
 421     if( p_subpic->i_status == FREE_SUBPICTURE )
 422     {
 423         vlc_mutex_unlock( &p_spu->subpicture_lock );
 424         return;
 425     }
 426
 427     /* Check if status is valid */
 428     if( ( p_subpic->i_status != RESERVED_SUBPICTURE )
 429            && ( p_subpic->i_status != READY_SUBPICTURE ) )
 430     {
 431         msg_Err( p_spu, "subpicture %p has invalid status %d",
 432                          p_subpic, p_subpic->i_status );
 433     }
 434
 435     while( p_subpic->p_region )
 436     {
 437         subpicture_region_t *p_region = p_subpic->p_region;
 438         p_subpic->p_region = p_region->p_next;
 439         spu_DestroyRegion( p_spu, p_region );
 440     }
 441
 442     if( p_subpic->pf_destroy )
 443     {
 444         p_subpic->pf_destroy( p_subpic );
 445     }
 446
 447     p_subpic->i_status = FREE_SUBPICTURE;
 448
 449     vlc_mutex_unlock( &p_spu->subpicture_lock );
 450 }
 451
 452 static void FilterRelease( filter_t *p_filter )
 453 {
 454     if( p_filter->p_module )
 455         module_Unneed( p_filter, p_filter->p_module );
 456
 457     vlc_object_detach( p_filter );
 458     vlc_object_release( p_filter );
 459 }
 460
 461 static void SpuRenderCreateBlend( spu_t *p_spu, vlc_fourcc_t i_chroma, int i_aspect )
 462 {
 463     filter_t *p_blend;
 464
 465     assert( !p_spu->p_blend );
 466
 467     p_spu->p_blend =
 468     p_blend        = vlc_custom_create( p_spu, sizeof(filter_t),
 469                                         VLC_OBJECT_GENERIC, "blend" );
 470     if( !p_blend )
 471         return;
 472
 473     es_format_Init( &p_blend->fmt_in, VIDEO_ES, 0 );
 474
 475     es_format_Init( &p_blend->fmt_out, VIDEO_ES, 0 );
 476     p_blend->fmt_out.video.i_x_offset = 0;
 477     p_blend->fmt_out.video.i_y_offset = 0;
 478     p_blend->fmt_out.video.i_chroma = i_chroma;
 479     p_blend->fmt_out.video.i_aspect = i_aspect;
 480
 481     /* The blend module will be loaded when needed with the real
 482     * input format */
 483     p_blend->p_module = NULL;
 484
 485     /* */
 486     vlc_object_attach( p_blend, p_spu );
 487 }
 488 static void SpuRenderUpdateBlend( spu_t *p_spu, int i_out_width, int i_out_height, const video_format_t *p_in_fmt )
 489 {
 490     filter_t *p_blend = p_spu->p_blend;
 491
 492     assert( p_blend );
 493
 494     /* */
 495     if( p_blend->p_module && p_blend->fmt_in.video.i_chroma != p_in_fmt->i_chroma )
 496     {
 497         /* The chroma is not the same, we need to reload the blend module
 498          * XXX to match the old behaviour just test !p_blend->fmt_in.video.i_chroma */
 499         module_Unneed( p_blend, p_blend->p_module );
 500         p_blend->p_module = NULL;
 501     }
 502
 503     /* */
 504     p_blend->fmt_in.video = *p_in_fmt;
 505
 506     /* */
 507     p_blend->fmt_out.video.i_width =
 508     p_blend->fmt_out.video.i_visible_width = i_out_width;
 509     p_blend->fmt_out.video.i_height =
 510     p_blend->fmt_out.video.i_visible_height = i_out_height;
 511
 512     /* */
 513     if( !p_blend->p_module )
 514         p_blend->p_module = module_Need( p_blend, "video blending", 0, 0 );
 515 }
 516 static void SpuRenderCreateAndLoadText( spu_t *p_spu )
 517 {
 518     filter_t *p_text;
 519
 520     assert( !p_spu->p_text );
 521
 522     p_spu->p_text =
 523     p_text        = vlc_custom_create( p_spu, sizeof(filter_t),
 524                                        VLC_OBJECT_GENERIC, "spu text" );
 525     if( !p_text )
 526         return;
 527
 528     es_format_Init( &p_text->fmt_in, VIDEO_ES, 0 );
 529
 530     es_format_Init( &p_text->fmt_out, VIDEO_ES, 0 );
 531     p_text->fmt_out.video.i_width =
 532     p_text->fmt_out.video.i_visible_width = 32;
 533     p_text->fmt_out.video.i_height =
 534     p_text->fmt_out.video.i_visible_height = 32;
 535
 536     p_text->pf_sub_buffer_new = spu_new_buffer;
 537     p_text->pf_sub_buffer_del = spu_del_buffer;
 538
 539     vlc_object_attach( p_text, p_spu );
 540
 541     /* FIXME TOCHECK shouldn't module_Need( , , psz_modulename, false ) do the
 542      * same than these 2 calls ? */
 543     char *psz_modulename = var_CreateGetString( p_spu, "text-renderer" );
 544     if( psz_modulename && *psz_modulename )
 545     {
 546         p_text->p_module = module_Need( p_text, "text renderer",
 547                                         psz_modulename, true );
 548     }
 549     free( psz_modulename );
 550
 551     if( !p_text->p_module )
 552         p_text->p_module = module_Need( p_text, "text renderer", NULL, false );
 553 }
 554
 555 static filter_t *CreateAndLoadScale( vlc_object_t *p_obj, vlc_fourcc_t i_chroma )
 556 {
 557     filter_t *p_scale;
 558
 559     p_scale = vlc_custom_create( p_obj, sizeof(filter_t),
 560                                  VLC_OBJECT_GENERIC, "scale" );
 561     if( !p_scale )
 562         return NULL;
 563
 564     es_format_Init( &p_scale->fmt_in, VIDEO_ES, 0 );
 565     p_scale->fmt_in.video.i_chroma = i_chroma;
 566     p_scale->fmt_in.video.i_width =
 567     p_scale->fmt_in.video.i_height = 32;
 568
 569     es_format_Init( &p_scale->fmt_out, VIDEO_ES, 0 );
 570     p_scale->fmt_out.video.i_chroma = i_chroma;
 571     p_scale->fmt_out.video.i_width =
 572     p_scale->fmt_out.video.i_height = 16;
 573
 574     p_scale->pf_vout_buffer_new = spu_new_video_buffer;
 575     p_scale->pf_vout_buffer_del = spu_del_video_buffer;
 576
 577     vlc_object_attach( p_scale, p_obj );
 578     p_scale->p_module = module_Need( p_scale, "video filter2", 0, 0 );
 579
 580     return p_scale;
 581 }
 582 static void SpuRenderCreateAndLoadScale( spu_t *p_spu )
 583 {
 584     /* FIXME: We'll also be using it for YUVA and RGBA blending ... */
 585
 586     assert( !p_spu->p_scale );
 587     assert( !p_spu->p_scale_yuvp );
 588     p_spu->p_scale = CreateAndLoadScale( VLC_OBJECT(p_spu), VLC_FOURCC('Y','U','V','A') );
 589     p_spu->p_scale_yuvp = p_spu->p_scale_yuvp = CreateAndLoadScale( VLC_OBJECT(p_spu), VLC_FOURCC('Y','U','V','P') );
 590 }
 591
 592 static void SpuRenderText( spu_t *p_spu, bool *pb_rerender_text,
 593                            subpicture_t *p_subpic, subpicture_region_t *p_region, int i_min_scale_ratio )
 594 {
 595     assert( p_region->fmt.i_chroma == VLC_FOURCC('T','E','X','T') );
 596
 597     if( !p_spu->p_text || !p_spu->p_text->p_module )
 598         goto exit;
 599
 600     /* Setup 3 variables which can be used to render
 601      * time-dependent text (and effects). The first indicates
 602      * the total amount of time the text will be on screen,
 603      * the second the amount of time it has already been on
 604      * screen (can be a negative value as text is layed out
 605      * before it is rendered) and the third is a feedback
 606      * variable from the renderer - if the renderer sets it
 607      * then this particular text is time-dependent, eg. the
 608      * visual progress bar inside the text in karaoke and the
 609      * text needs to be rendered multiple times in order for
 610      * the effect to work - we therefore need to return the
 611      * region to its original state at the end of the loop,
 612      * instead of leaving it in YUVA or YUVP.
 613      * Any renderer which is unaware of how to render
 614      * time-dependent text can happily ignore the variables
 615      * and render the text the same as usual - it should at
 616      * least show up on screen, but the effect won't change
 617      * the text over time.
 618      */
 619
 620     /* FIXME why these variables are recreated every time and not
 621      * when text renderer module was created ? */
 622     var_Create( p_spu->p_text, "spu-duration", VLC_VAR_TIME );
 623     var_Create( p_spu->p_text, "spu-elapsed", VLC_VAR_TIME );
 624     var_Create( p_spu->p_text, "text-rerender", VLC_VAR_BOOL );
 625     var_Create( p_spu->p_text, "scale", VLC_VAR_INTEGER );
 626
 627     var_SetTime( p_spu->p_text, "spu-duration", p_subpic->i_stop - p_subpic->i_start );
 628     var_SetTime( p_spu->p_text, "spu-elapsed", mdate() - p_subpic->i_start );
 629     var_SetBool( p_spu->p_text, "text-rerender", false );
 630     var_SetInteger( p_spu->p_text, "scale", i_min_scale_ratio );
 631
 632     if( p_spu->p_text->pf_render_html && p_region->psz_html )
 633     {
 634         p_spu->p_text->pf_render_html( p_spu->p_text,
 635                                        p_region, p_region );
 636     }
 637     else if( p_spu->p_text->pf_render_text )
 638     {
 639         p_spu->p_text->pf_render_text( p_spu->p_text,
 640                                        p_region, p_region );
 641     }
 642     *pb_rerender_text = var_GetBool( p_spu->p_text, "text-rerender" );
 643
 644     var_Destroy( p_spu->p_text, "spu-duration" );
 645     var_Destroy( p_spu->p_text, "spu-elapsed" );
 646     var_Destroy( p_spu->p_text, "text-rerender" );
 647     var_Destroy( p_spu->p_text, "scale" );
 648
 649 exit:
 650     p_region->i_align |= SUBPICTURE_RENDERED;
 651 }
 652
 653 /**
 654  * A few scale functions helpers.
 655  */
 656 typedef struct
 657 {
 658     int w;
 659     int h;
 660 } spu_scale_t;
 661
 662 static spu_scale_t spu_scale_create( int w, int h )
 663 {
 664     spu_scale_t s = { .w = w, .h = h };
 665     if( s.w <= 0 )
 666         s.w = SCALE_UNIT;
 667     if( s.h <= 0 )
 668         s.h = SCALE_UNIT;
 669     return s;
 670 }
 671 static spu_scale_t spu_scale_unit(void )
 672 {
 673     return spu_scale_create( SCALE_UNIT, SCALE_UNIT );
 674 }
 675 static spu_scale_t spu_scale_createq( int wn, int wd, int hn, int hd )
 676 {
 677     return spu_scale_create( wn * SCALE_UNIT / wd,
 678                              hn * SCALE_UNIT / hd );
 679 }
 680 static int spu_scale_w( int v, const spu_scale_t s )
 681 {
 682     return v * s.w / SCALE_UNIT;
 683 }
 684 static int spu_scale_h( int v, const spu_scale_t s )
 685 {
 686     return v * s.h / SCALE_UNIT;
 687 }
 688 static int spu_invscale_w( int v, const spu_scale_t s )
 689 {
 690     return v * SCALE_UNIT / s.w;
 691 }
 692 static int spu_invscale_h( int v, const spu_scale_t s )
 693 {
 694     return v * SCALE_UNIT / s.h;
 695 }
 696
 697 /**
 698  * A few area functions helpers
 699  */
 700
 701 typedef struct
 702 {
 703     int i_x;
 704     int i_y;
 705     int i_width;
 706     int i_height;
 707
 708     spu_scale_t scale;
 709 } spu_area_t;
 710
 711 static spu_area_t spu_area_create( int x, int y, int w, int h, spu_scale_t s )
 712 {
 713     spu_area_t a = { .i_x = x, .i_y = y, .i_width = w, .i_height = h, .scale = s };
 714     return a;
 715 }
 716 static spu_area_t spu_area_scaled( spu_area_t a )
 717 {
 718     if( a.scale.w == SCALE_UNIT && a.scale.h == SCALE_UNIT )
 719         return a;
 720
 721     a.i_x = spu_scale_w( a.i_x, a.scale );
 722     a.i_y = spu_scale_h( a.i_y, a.scale );
 723
 724     a.i_width  = spu_scale_w( a.i_width,  a.scale );
 725     a.i_height = spu_scale_h( a.i_height, a.scale );
 726
 727     a.scale = spu_scale_unit();
 728     return a;
 729 }
 730 static spu_area_t spu_area_unscaled( spu_area_t a, spu_scale_t s )
 731 {
 732     if( a.scale.w == s.w && a.scale.h == s.h )
 733         return a;
 734
 735     a = spu_area_scaled( a );
 736
 737     a.i_x = spu_invscale_w( a.i_x, s );
 738     a.i_y = spu_invscale_h( a.i_y, s );
 739
 740     a.i_width  = spu_invscale_w( a.i_width, s );
 741     a.i_height = spu_invscale_h( a.i_height, s );
 742
 743     a.scale = s;
 744     return a;
 745 }
 746 static bool spu_area_overlap( spu_area_t a, spu_area_t b )
 747 {
 748     const int i_dx = 0;
 749     const int i_dy = 0;
 750
 751     a = spu_area_scaled( a );
 752     b = spu_area_scaled( b );
 753
 754     return  __MAX( a.i_x-i_dx, b.i_x ) < __MIN( a.i_x+a.i_width +i_dx, b.i_x+b.i_width  ) &&
 755             __MAX( a.i_y-i_dy, b.i_y ) < __MIN( a.i_y+a.i_height+i_dy, b.i_y+b.i_height );
 756 }
 757
 758 /**
 759  * Avoid area overlapping
 760  */
 761 static void SpuAreaFixOverlap( spu_area_t *p_dst,
 762                                const spu_area_t *p_master,
 763                                const spu_area_t *p_sub, int i_sub, int i_align )
 764 {
 765     spu_area_t a = spu_area_scaled( *p_dst );
 766     bool b_moved = false;
 767     bool b_ok;
 768
 769     assert( p_master->i_x == 0 && p_master->i_y == 0 );
 770
 771     /* Check for overlap
 772      * XXX It is not fast O(n^2) but we should not have a lot of region */
 773     do
 774     {
 775         b_ok = true;
 776         for( int i = 0; i < i_sub; i++ )
 777         {
 778             spu_area_t sub = spu_area_scaled( p_sub[i] );
 779
 780             if( !spu_area_overlap( a, sub ) )
 781                 continue;
 782
 783             if( i_align & SUBPICTURE_ALIGN_TOP )
 784             {
 785                 /* We go down */
 786                 int i_y = sub.i_y + sub.i_height;
 787                 if( i_y + a.i_height > p_master->i_height )
 788                     break;
 789                 a.i_y = i_y;
 790                 b_moved = true;
 791             }
 792             else if( i_align & SUBPICTURE_ALIGN_BOTTOM )
 793             {
 794                 /* We go up */
 795                 int i_y = sub.i_y - a.i_height;
 796                 if( i_y < 0 )
 797                     break;
 798                 a.i_y = i_y;
 799                 b_moved = true;
 800             }
 801             else
 802             {
 803                 /* TODO what to do in this case? */
 804                 //fprintf( stderr, "Overlap with unsupported alignment\n" );
 805                 break;
 806             }
 807
 808             b_ok = false;
 809             break;
 810         }
 811     } while( !b_ok );
 812
 813     if( b_moved )
 814         *p_dst = spu_area_unscaled( a, p_dst->scale );
 815 }
 816
 817
 818 /**
 819  * Place a region
 820  */
 821 static void SpuRegionPlace( int *pi_x, int *pi_y,
 822                             const subpicture_t *p_subpic,
 823                             const subpicture_region_t *p_region,
 824                             int i_margin_y )
 825 {
 826     const int i_delta_x = p_region->i_x;
 827     const int i_delta_y = p_region->i_y;
 828     int i_x, i_y;
 829
 830     assert( p_region->i_x != INT_MAX && p_region->i_y != INT_MAX );
 831     if( p_region->i_align & SUBPICTURE_ALIGN_TOP )
 832     {
 833         i_y = i_delta_y;
 834     }
 835     else if( p_region->i_align & SUBPICTURE_ALIGN_BOTTOM )
 836     {
 837         i_y = p_subpic->i_original_picture_height - p_region->fmt.i_height - i_delta_y;
 838     }
 839     else
 840     {
 841         i_y = p_subpic->i_original_picture_height / 2 - p_region->fmt.i_height / 2;
 842     }
 843
 844     if( p_region->i_align & SUBPICTURE_ALIGN_LEFT )
 845     {
 846         i_x = i_delta_x;
 847     }
 848     else if( p_region->i_align & SUBPICTURE_ALIGN_RIGHT )
 849     {
 850         i_x = p_subpic->i_original_picture_width - p_region->fmt.i_width - i_delta_x;
 851     }
 852     else
 853     {
 854         i_x = p_subpic->i_original_picture_width / 2 - p_region->fmt.i_width / 2;
 855     }
 856
 857     if( p_subpic->b_absolute )
 858     {
 859         i_x = i_delta_x;
 860         i_y = i_delta_y;
 861     }
 862
 863     /* Margin shifts all subpictures */
 864     if( i_margin_y != 0 )
 865         i_y -= i_margin_y;
 866
 867     /* Clamp offset to not go out of the screen (when possible) */
 868     const int i_error_x = (i_x + p_region->fmt.i_width) - p_subpic->i_original_picture_width;
 869     if( i_error_x > 0 )
 870         i_x -= i_error_x;
 871     if( i_x < 0 )
 872         i_x = 0;
 873
 874     const int i_error_y = (i_y + p_region->fmt.i_height) - p_subpic->i_original_picture_height;
 875     if( i_error_y > 0 )
 876         i_y -= i_error_y;
 877     if( i_y < 0 )
 878         i_y = 0;
 879
 880     *pi_x = i_x;
 881     *pi_y = i_y;
 882 }
 883
 884 /**
 885  * This function computes the current alpha value for a given region.
 886  */
 887 static int SpuRegionAlpha( subpicture_t *p_subpic, subpicture_region_t *p_region )
 888 {
 889     /* Compute alpha blend value */
 890     int i_fade_alpha = 255;
 891     if( p_subpic->b_fade )
 892     {
 893         mtime_t i_fade_start = ( p_subpic->i_stop +
 894                                  p_subpic->i_start ) / 2;
 895         mtime_t i_now = mdate();
 896
 897         if( i_now >= i_fade_start && p_subpic->i_stop > i_fade_start )
 898         {
 899             i_fade_alpha = 255 * ( p_subpic->i_stop - i_now ) /
 900                            ( p_subpic->i_stop - i_fade_start );
 901         }
 902     }
 903     return i_fade_alpha * p_subpic->i_alpha * p_region->i_alpha / 65025;
 904 }
 905
 906 /**
 907  * It will render the provided region onto p_pic_dst.
 908  */
 909
 910 static void SpuRenderRegion( spu_t *p_spu,
 911                              picture_t *p_pic_dst, spu_area_t *p_area,
 912                              subpicture_t *p_subpic, subpicture_region_t *p_region,
 913                              const spu_scale_t scale_size,
 914                              const video_format_t *p_fmt,
 915                              const spu_area_t *p_subtitle_area, int i_subtitle_area )
 916 {
 917     video_format_t fmt_original = p_region->fmt;
 918     bool b_rerender_text = false;
 919     bool b_restore_format = false;
 920     int i_x_offset;
 921     int i_y_offset;
 922     filter_t *p_scale;
 923
 924     video_format_t *p_region_fmt;
 925     picture_t *p_region_picture;
 926
 927     vlc_assert_locked( &p_spu->subpicture_lock );
 928
 929     /* Invalidate area by default */
 930     *p_area = spu_area_create( 0,0, 0,0, scale_size );
 931
 932     /* Render text region */
 933     if( p_region->fmt.i_chroma == VLC_FOURCC('T','E','X','T') )
 934     {
 935         const int i_min_scale_ratio = SCALE_UNIT; /* FIXME what is the right value? (scale_size is not) */
 936         SpuRenderText( p_spu, &b_rerender_text, p_subpic, p_region, i_min_scale_ratio );
 937         b_restore_format = b_rerender_text;
 938
 939         /* Check if the rendering has failed ... */
 940         if( p_region->fmt.i_chroma == VLC_FOURCC('T','E','X','T') )
 941             goto exit;
 942     }
 943
 944     /* Force palette if requested
 945      * FIXME b_force_palette and b_force_crop are applied to all subpictures using palette
 946      * instead of only the right one (being the dvd spu).
 947      */
 948     const bool b_using_palette = p_region->fmt.i_chroma == VLC_FOURCC('Y','U','V','P');
 949     const bool b_force_palette = b_using_palette && p_spu->b_force_palette;
 950     const bool b_force_crop    = b_force_palette && p_spu->b_force_crop;
 951
 952
 953     /* Compute the margin which is expressed in destination pixel unit
 954      * The margin is applied only to subtitle and when no forced crop is
 955      * requested (dvd menu) */
 956     int i_margin_y = 0;
 957     if( !b_force_crop && p_subpic->b_subtitle )
 958         i_margin_y = spu_invscale_h( p_spu->i_margin, scale_size );
 959
 960     /* Place the picture
 961      * We compute the position in the rendered size */
 962     SpuRegionPlace( &i_x_offset, &i_y_offset,
 963                     p_subpic, p_region, i_margin_y );
 964
 965     /* Save this position for subtitle overlap support
 966      * it is really important that there are given without scale_size applied */
 967     *p_area = spu_area_create( i_x_offset, i_y_offset,
 968                                p_region->fmt.i_width, p_region->fmt.i_height,
 969                                scale_size );
 970
 971     /* Handle overlapping subtitles when possible */
 972     if( p_subpic->b_subtitle && !p_subpic->b_absolute )
 973     {
 974         spu_area_t display = spu_area_create( 0, 0, p_fmt->i_width, p_fmt->i_height, spu_scale_unit() );
 975
 976         SpuAreaFixOverlap( p_area, &display, p_subtitle_area, i_subtitle_area, p_region->i_align );
 977     }
 978
 979     /* Fix the position for the current scale_size */
 980     i_x_offset = spu_scale_w( p_area->i_x, p_area->scale );
 981     i_y_offset = spu_scale_h( p_area->i_y, p_area->scale );
 982
 983     /* */
 984     if( b_force_palette )
 985     {
 986         /* It looks so wrong I won't comment
 987          * p_palette->palette is [256][4] with a int i_entries
 988          * p_spu->palette is [4][4]
 989          * */
 990         p_region->fmt.p_palette->i_entries = 4;
 991         memcpy( p_region->fmt.p_palette->palette, p_spu->palette, 4*sizeof(uint32_t) );
 992     }
 993
 994     /* */
 995     p_region_fmt = &p_region->fmt;
 996     p_region_picture = p_region->p_picture;
 997
 998
 999     /* Scale from rendered size to destination size */
1000     p_scale = b_using_palette ? p_spu->p_scale_yuvp : p_spu->p_scale;
1001
1002     if( p_scale &&
1003         ( scale_size.w != SCALE_UNIT || scale_size.h != SCALE_UNIT || b_force_palette ) )
1004     {
1005         const unsigned i_dst_width  = spu_scale_w( p_region->fmt.i_width, scale_size );
1006         const unsigned i_dst_height = spu_scale_h( p_region->fmt.i_height, scale_size );
1007
1008         /* TODO when b_using_palette is true, we should first convert it to YUVA to allow
1009          * a proper rescaling */
1010
1011         /* Destroy if cache is unusable
1012          * FIXME do not always destroy the region it can sometimes be reused
1013          * if same size and same palette if present */
1014         if( p_region->p_private )
1015         {
1016             SpuRegionPrivateDestroy( p_region->p_private );
1017             p_region->p_private = NULL;
1018         }
1019
1020         /* Scale if needed into cache */
1021         if( !p_region->p_private )
1022         {
1023             picture_t *p_pic;
1024
1025             p_scale->fmt_in.video = p_region->fmt;
1026             p_scale->fmt_out.video = p_region->fmt;
1027
1028             p_scale->fmt_out.video.i_width = i_dst_width;
1029             p_scale->fmt_out.video.i_height = i_dst_height;
1030
1031             p_scale->fmt_out.video.i_visible_width =
1032                 spu_scale_w( p_region->fmt.i_visible_width, scale_size );
1033             p_scale->fmt_out.video.i_visible_height =
1034                 spu_scale_h( p_region->fmt.i_visible_height, scale_size );
1035
1036             p_region->p_private = SpuRegionPrivateCreate( &p_scale->fmt_out.video );
1037
1038             if( p_scale->p_module )
1039             {
1040                 picture_Yield( p_region->p_picture );
1041                 p_region->p_private->p_picture = p_scale->pf_video_filter( p_scale, p_region->p_picture );
1042             }
1043             if( !p_region->p_private->p_picture )
1044             {
1045                 msg_Err( p_spu, "scaling failed (module not loaded)" );
1046                 SpuRegionPrivateDestroy( p_region->p_private );
1047                 p_region->p_private = NULL;
1048             }
1049         }
1050
1051         /* And use the scaled picture */
1052         if( p_region->p_private )
1053         {
1054             p_region_fmt = &p_region->p_private->fmt;
1055             p_region_picture = p_region->p_private->p_picture;
1056         }
1057     }
1058
1059     /* Force cropping if requested */
1060     if( b_force_crop )
1061     {
1062         video_format_t *p_fmt = p_region_fmt;
1063         int i_crop_x = spu_scale_w( p_spu->i_crop_x, scale_size );
1064         int i_crop_y = spu_scale_h( p_spu->i_crop_y, scale_size );
1065         int i_crop_width = spu_scale_w( p_spu->i_crop_width, scale_size );
1066         int i_crop_height= spu_scale_h( p_spu->i_crop_height,scale_size );
1067
1068         /* Find the intersection */
1069         if( i_crop_x + i_crop_width <= i_x_offset ||
1070             i_x_offset + (int)p_fmt->i_visible_width < i_crop_x ||
1071             i_crop_y + i_crop_height <= i_y_offset ||
1072             i_y_offset + (int)p_fmt->i_visible_height < i_crop_y )
1073         {
1074             /* No intersection */
1075             p_fmt->i_visible_width = p_fmt->i_visible_height = 0;
1076         }
1077         else
1078         {
1079             int i_x, i_y, i_x_end, i_y_end;
1080             i_x = __MAX( i_crop_x, i_x_offset );
1081             i_y = __MAX( i_crop_y, i_y_offset );
1082             i_x_end = __MIN( i_crop_x + i_crop_width,
1083                            i_x_offset + (int)p_fmt->i_visible_width );
1084             i_y_end = __MIN( i_crop_y + i_crop_height,
1085                            i_y_offset + (int)p_fmt->i_visible_height );
1086
1087             p_fmt->i_x_offset = i_x - i_x_offset;
1088             p_fmt->i_y_offset = i_y - i_y_offset;
1089             p_fmt->i_visible_width = i_x_end - i_x;
1090             p_fmt->i_visible_height = i_y_end - i_y;
1091
1092             i_x_offset = __MAX( i_x, 0 );
1093             i_y_offset = __MAX( i_y, 0 );
1094         }
1095         b_restore_format = true;
1096     }
1097
1098     /* Update the blender */
1099     SpuRenderUpdateBlend( p_spu, p_fmt->i_width, p_fmt->i_height, p_region_fmt );
1100
1101     if( p_spu->p_blend->p_module )
1102     {
1103         const int i_alpha = SpuRegionAlpha( p_subpic, p_region );
1104
1105         p_spu->p_blend->pf_video_blend( p_spu->p_blend, p_pic_dst,
1106             p_region_picture, i_x_offset, i_y_offset, i_alpha );
1107     }
1108     else
1109     {
1110         msg_Err( p_spu, "blending %4.4s to %4.4s failed",
1111                  (char *)&p_spu->p_blend->fmt_out.video.i_chroma,
1112                  (char *)&p_spu->p_blend->fmt_out.video.i_chroma );
1113     }
1114
1115 exit:
1116     if( b_rerender_text )
1117     {
1118         /* Some forms of subtitles need to be re-rendered more than
1119          * once, eg. karaoke. We therefore restore the region to its
1120          * pre-rendered state, so the next time through everything is
1121          * calculated again.
1122          */
1123         picture_Release( p_region->p_picture );
1124         p_region->p_picture = NULL;
1125         if( p_region->p_private )
1126         {
1127             SpuRegionPrivateDestroy( p_region->p_private );
1128             p_region->p_private = NULL;
1129         }
1130         p_region->i_align &= ~SUBPICTURE_RENDERED;
1131     }
1132     if( b_restore_format )
1133         p_region->fmt = fmt_original;
1134 }
1135
1136 /**
1137  * This function compares two 64 bits integers.
1138  * It can be used by qsort.
1139  */
1140 static int IntegerCmp( int64_t i0, int64_t i1 )
1141 {
1142     return i0 < i1 ? -1 : i0 > i1 ? 1 : 0;
1143 }
1144 /**
1145  * This function compares 2 subpictures using the following properties
1146  * (ordered by priority)
1147  * 1. absolute positionning
1148  * 2. start time
1149  * 3. creation order
1150  *
1151  * It can be used by qsort.
1152  *
1153  * XXX spu_RenderSubpictures depends heavily on this order.
1154  */
1155 static int SubpictureCmp( const void *s0, const void *s1 )
1156 {
1157     subpicture_t *p_subpic0 = *(subpicture_t**)s0;
1158     subpicture_t *p_subpic1 = *(subpicture_t**)s1;
1159     int r;
1160
1161     r = IntegerCmp( !p_subpic0->b_absolute, !p_subpic1->b_absolute );
1162     if( !r )
1163         r = IntegerCmp( p_subpic0->i_start, p_subpic1->i_start );
1164     if( !r )
1165         r = IntegerCmp( p_subpic0->i_order, p_subpic1->i_order );
1166     return r;
1167 }
1168 /**
1169  * This function renders all sub picture units in the list.
1170  */
1171 void spu_RenderSubpictures( spu_t *p_spu,
1172                             picture_t *p_pic_dst, const video_format_t *p_fmt_dst,
1173                             subpicture_t *p_subpic_list,
1174                             const video_format_t *p_fmt_src )
1175 {
1176     const int i_source_video_width  = p_fmt_src->i_width;
1177     const int i_source_video_height = p_fmt_src->i_height;
1178     const mtime_t i_current_date = mdate();
1179
1180     unsigned int i_subpicture;
1181     subpicture_t *pp_subpicture[VOUT_MAX_SUBPICTURES];
1182
1183     unsigned int i_subtitle_region_count;
1184     spu_area_t p_subtitle_area_buffer[VOUT_MAX_SUBPICTURES];
1185     spu_area_t *p_subtitle_area;
1186     int i_subtitle_area;
1187
1188     /* Get lock */
1189     vlc_mutex_lock( &p_spu->subpicture_lock );
1190
1191     /* Preprocess subpictures */
1192     i_subpicture = 0;
1193     i_subtitle_region_count = 0;
1194     for( subpicture_t * p_subpic = p_subpic_list;
1195             p_subpic != NULL && p_subpic->i_status != FREE_SUBPICTURE; /* Check again status (as we where unlocked) */
1196                 p_subpic = p_subpic->p_next )
1197     {
1198         /* */
1199         if( p_subpic->pf_pre_render )
1200             p_subpic->pf_pre_render( p_spu, p_subpic, p_fmt_dst );
1201
1202         if( p_subpic->pf_update_regions )
1203         {
1204             video_format_t fmt_org = *p_fmt_dst;
1205             fmt_org.i_width =
1206             fmt_org.i_visible_width = i_source_video_width;
1207             fmt_org.i_height =
1208             fmt_org.i_visible_height = i_source_video_height;
1209
1210             p_subpic->pf_update_regions( p_spu, p_subpic, &fmt_org, i_current_date );
1211         }
1212
1213         /* */
1214         if( p_subpic->b_subtitle )
1215         {
1216             for( subpicture_region_t *r = p_subpic->p_region; r != NULL; r = r->p_next )
1217                 i_subtitle_region_count++;
1218         }
1219
1220         /* */
1221         pp_subpicture[i_subpicture++] = p_subpic;
1222     }
1223
1224     /* Be sure we have at least 1 picture to process */
1225     if( i_subpicture <= 0 )
1226     {
1227         vlc_mutex_unlock( &p_spu->subpicture_lock );
1228         return;
1229     }
1230
1231     /* Now order subpicture array
1232      * XXX The order is *really* important for overlap subtitles positionning */
1233     qsort( pp_subpicture, i_subpicture, sizeof(*pp_subpicture), SubpictureCmp );
1234
1235     /* Allocate area array for subtitle overlap */
1236     i_subtitle_area = 0;
1237     p_subtitle_area = p_subtitle_area_buffer;
1238     if( i_subtitle_region_count > sizeof(p_subtitle_area_buffer)/sizeof(*p_subtitle_area_buffer) )
1239         p_subtitle_area = calloc( i_subtitle_region_count, sizeof(*p_subtitle_area) );
1240
1241     /* Create the blending module */
1242     if( !p_spu->p_blend )
1243         SpuRenderCreateBlend( p_spu, p_fmt_dst->i_chroma, p_fmt_dst->i_aspect );
1244
1245     /* Process all subpictures and regions (in the right order) */
1246     for( unsigned int i_index = 0; i_index < i_subpicture; i_index++ )
1247     {
1248         subpicture_t *p_subpic = pp_subpicture[i_index];
1249         subpicture_region_t *p_region;
1250
1251         if( !p_subpic->p_region )
1252             continue;
1253
1254         /* FIXME when possible use a better rendering size than source size
1255          * (max of display size and source size for example) FIXME */
1256         int i_render_width  = p_subpic->i_original_picture_width;
1257         int i_render_height = p_subpic->i_original_picture_height;
1258         if( !i_render_width || !i_render_height )
1259         {
1260             if( i_render_width != 0 || i_render_height != 0 )
1261                 msg_Err( p_spu, "unsupported original picture size %dx%d",
1262                          i_render_width, i_render_height );
1263
1264             p_subpic->i_original_picture_width  = i_render_width = i_source_video_width;
1265             p_subpic->i_original_picture_height = i_render_height = i_source_video_height;
1266         }
1267
1268         if( p_spu->p_text )
1269         {
1270             p_spu->p_text->fmt_out.video.i_width          =
1271             p_spu->p_text->fmt_out.video.i_visible_width  = i_render_width;
1272
1273             p_spu->p_text->fmt_out.video.i_height         =
1274             p_spu->p_text->fmt_out.video.i_visible_height = i_render_height;
1275         }
1276
1277         /* Compute scaling from picture to source size */
1278         spu_scale_t scale = spu_scale_createq( i_source_video_width,  i_render_width,
1279                                                i_source_video_height, i_render_height );
1280
1281         /* Update scaling from source size to display size(p_fmt_dst) */
1282         scale.w = scale.w * p_fmt_dst->i_width  / i_source_video_width;
1283         scale.h = scale.h * p_fmt_dst->i_height / i_source_video_height;
1284
1285         /* Set default subpicture aspect ratio
1286          * FIXME if we only handle 1 aspect ratio per picture, why is it set per
1287          * region ? */
1288         p_region = p_subpic->p_region;
1289         if( !p_region->fmt.i_sar_num || !p_region->fmt.i_sar_den )
1290         {
1291             if( p_region->fmt.i_aspect != 0 )
1292             {
1293                 p_region->fmt.i_sar_den = p_region->fmt.i_aspect;
1294                 p_region->fmt.i_sar_num = VOUT_ASPECT_FACTOR;
1295             }
1296             else
1297             {
1298                 p_region->fmt.i_sar_den = p_fmt_dst->i_sar_den;
1299                 p_region->fmt.i_sar_num = p_fmt_dst->i_sar_num;
1300             }
1301         }
1302
1303         /* Take care of the aspect ratio */
1304         if( p_region->fmt.i_sar_num * p_fmt_dst->i_sar_den !=
1305             p_region->fmt.i_sar_den * p_fmt_dst->i_sar_num )
1306         {
1307             /* FIXME FIXME what about region->i_x/i_y ? */
1308             scale.w = scale.w *
1309                 (int64_t)p_region->fmt.i_sar_num * p_fmt_dst->i_sar_den /
1310                 p_region->fmt.i_sar_den / p_fmt_dst->i_sar_num;
1311         }
1312
1313         /* Render all regions
1314          * We always transform non absolute subtitle into absolute one on the
1315          * first rendering to allow good subtitle overlap support.
1316          */
1317         for( p_region = p_subpic->p_region; p_region != NULL; p_region = p_region->p_next )
1318         {
1319             spu_area_t area;
1320
1321             /* Check scale validity */
1322             if( scale.w <= 0 || scale.h <= 0 )
1323                 continue;
1324
1325             /* */
1326             SpuRenderRegion( p_spu, p_pic_dst, &area,
1327                              p_subpic, p_region, scale, p_fmt_dst,
1328                              p_subtitle_area, i_subtitle_area );
1329
1330             if( p_subpic->b_subtitle )
1331             {
1332                 area = spu_area_unscaled( area, scale );
1333                 if( !p_subpic->b_absolute && area.i_width > 0 && area.i_height > 0 )
1334                 {
1335                     p_region->i_x = area.i_x;
1336                     p_region->i_y = area.i_y;
1337                 }
1338                 if( p_subtitle_area )
1339                     p_subtitle_area[i_subtitle_area++] = area;
1340             }
1341         }
1342         if( p_subpic->b_subtitle )
1343             p_subpic->b_absolute = true;
1344     }
1345
1346     /* */
1347     if( p_subtitle_area != p_subtitle_area_buffer )
1348         free( p_subtitle_area );
1349
1350     vlc_mutex_unlock( &p_spu->subpicture_lock );
1351 }
1352
1353 /*****************************************************************************
1354  * spu_SortSubpictures: find the subpictures to display
1355  *****************************************************************************
1356  * This function parses all subpictures and decides which ones need to be
1357  * displayed. This operation does not need lock, since only READY_SUBPICTURE
1358  * are handled. If no picture has been selected, display_date will depend on
1359  * the subpicture.
1360  * We also check for ephemer DVD subpictures (subpictures that have
1361  * to be removed if a newer one is available), which makes it a lot
1362  * more difficult to guess if a subpicture has to be rendered or not.
1363  *****************************************************************************/
1364 subpicture_t *spu_SortSubpictures( spu_t *p_spu, mtime_t display_date,
1365                                    bool b_paused, bool b_subtitle_only )
1366 {
1367     int i_channel;
1368     subpicture_t *p_subpic = NULL;
1369
1370     /* Run subpicture filters */
1371     filter_chain_SubFilter( p_spu->p_chain, display_date );
1372
1373     /* We get an easily parsable chained list of subpictures which
1374      * ends with NULL since p_subpic was initialized to NULL. */
1375     for( i_channel = 0; i_channel < p_spu->i_channel; i_channel++ )
1376     {
1377         subpicture_t *p_ephemer = NULL;
1378         mtime_t      ephemer_date = 0;
1379         int i_index;
1380
1381         for( i_index = 0; i_index < VOUT_MAX_SUBPICTURES; i_index++ )
1382         {
1383             subpicture_t *p_current = &p_spu->p_subpicture[i_index];
1384
1385             if( p_current->i_channel != i_channel ||
1386                 p_current->i_status != READY_SUBPICTURE ||
1387                 ( b_subtitle_only && !p_current->b_subtitle ) )
1388             {
1389                 continue;
1390             }
1391             if( display_date &&
1392                 display_date < p_current->i_start )
1393             {
1394                 /* Too early, come back next monday */
1395                 continue;
1396             }
1397
1398             if( p_current->i_start > ephemer_date )
1399                 ephemer_date = p_current->i_start;
1400
1401             if( display_date > p_current->i_stop &&
1402                 ( !p_current->b_ephemer || p_current->i_stop > p_current->i_start ) &&
1403                 !( p_current->b_subtitle && b_paused ) ) /* XXX Assume that subtitle are pausable */
1404             {
1405                 /* Too late, destroy the subpic */
1406                 spu_DestroySubpicture( p_spu, &p_spu->p_subpicture[i_index] );
1407                 continue;
1408             }
1409
1410             /* If this is an ephemer subpic, add it to our list */
1411             if( p_current->b_ephemer )
1412             {
1413                 p_current->p_next = p_ephemer;
1414                 p_ephemer = p_current;
1415
1416                 continue;
1417             }
1418
1419             p_current->p_next = p_subpic;
1420             p_subpic = p_current;
1421         }
1422
1423         /* If we found ephemer subpictures, check if they have to be
1424          * displayed or destroyed */
1425         while( p_ephemer != NULL )
1426         {
1427             subpicture_t *p_tmp = p_ephemer;
1428             p_ephemer = p_ephemer->p_next;
1429
1430             if( p_tmp->i_start < ephemer_date )
1431             {
1432                 /* Ephemer subpicture has lived too long */
1433                 spu_DestroySubpicture( p_spu, p_tmp );
1434             }
1435             else
1436             {
1437                 /* Ephemer subpicture can still live a bit */
1438                 p_tmp->p_next = p_subpic;
1439                 p_subpic = p_tmp;
1440             }
1441         }
1442     }
1443
1444     return p_subpic;
1445 }
1446
1447 /*****************************************************************************
1448  * SpuClearChannel: clear an spu channel
1449  *****************************************************************************
1450  * This function destroys the subpictures which belong to the spu channel
1451  * corresponding to i_channel_id.
1452  *****************************************************************************/
1453 static void SpuClearChannel( spu_t *p_spu, int i_channel, bool b_locked )
1454 {
1455     int          i_subpic;                               /* subpicture index */
1456     subpicture_t *p_subpic = NULL;                  /* first free subpicture */
1457
1458     if( !b_locked )
1459         vlc_mutex_lock( &p_spu->subpicture_lock );
1460
1461     for( i_subpic = 0; i_subpic < VOUT_MAX_SUBPICTURES; i_subpic++ )
1462     {
1463         p_subpic = &p_spu->p_subpicture[i_subpic];
1464         if( p_subpic->i_status == FREE_SUBPICTURE
1465             || ( p_subpic->i_status != RESERVED_SUBPICTURE
1466                  && p_subpic->i_status != READY_SUBPICTURE ) )
1467         {
1468             continue;
1469         }
1470
1471         if( p_subpic->i_channel == i_channel )
1472         {
1473             while( p_subpic->p_region )
1474             {
1475                 subpicture_region_t *p_region = p_subpic->p_region;
1476                 p_subpic->p_region = p_region->p_next;
1477                 spu_DestroyRegion( p_spu, p_region );
1478             }
1479
1480             if( p_subpic->pf_destroy ) p_subpic->pf_destroy( p_subpic );
1481             p_subpic->i_status = FREE_SUBPICTURE;
1482         }
1483     }
1484
1485     if( !b_locked )
1486         vlc_mutex_unlock( &p_spu->subpicture_lock );
1487 }
1488
1489 /*****************************************************************************
1490  * spu_ControlDefault: default methods for the subpicture unit control.
1491  *****************************************************************************/
1492 static int spu_vaControlDefault( spu_t *p_spu, int i_query, va_list args )
1493 {
1494     int *pi, i;
1495
1496     switch( i_query )
1497     {
1498     case SPU_CHANNEL_REGISTER:
1499         pi = (int *)va_arg( args, int * );
1500         vlc_mutex_lock( &p_spu->subpicture_lock );
1501         if( pi )
1502             *pi = p_spu->i_channel++;
1503         vlc_mutex_unlock( &p_spu->subpicture_lock );
1504         break;
1505
1506     case SPU_CHANNEL_CLEAR:
1507         i = (int)va_arg( args, int );
1508         SpuClearChannel( p_spu, i, false );
1509         break;
1510
1511     default:
1512         msg_Dbg( p_spu, "control query not supported" );
1513         return VLC_EGENERIC;
1514     }
1515
1516     return VLC_SUCCESS;
1517 }
1518
1519 /*****************************************************************************
1520  * Object variables callbacks
1521  *****************************************************************************/
1522
1523 /*****************************************************************************
1524  * UpdateSPU: update subpicture settings
1525  *****************************************************************************
1526  * This function is called from CropCallback and at initialization time, to
1527  * retrieve crop information from the input.
1528  *****************************************************************************/
1529 static void UpdateSPU( spu_t *p_spu, vlc_object_t *p_object )
1530 {
1531     vlc_value_t val;
1532
1533     vlc_mutex_lock( &p_spu->subpicture_lock );
1534
1535     p_spu->b_force_palette = false;
1536     p_spu->b_force_crop = false;
1537
1538     if( var_Get( p_object, "highlight", &val ) || !val.b_bool )
1539     {
1540         vlc_mutex_unlock( &p_spu->subpicture_lock );
1541         return;
1542     }
1543
1544     p_spu->b_force_crop = true;
1545     var_Get( p_object, "x-start", &val );
1546     p_spu->i_crop_x = val.i_int;
1547     var_Get( p_object, "y-start", &val );
1548     p_spu->i_crop_y = val.i_int;
1549     var_Get( p_object, "x-end", &val );
1550     p_spu->i_crop_width = val.i_int - p_spu->i_crop_x;
1551     var_Get( p_object, "y-end", &val );
1552     p_spu->i_crop_height = val.i_int - p_spu->i_crop_y;
1553
1554     if( var_Get( p_object, "menu-palette", &val ) == VLC_SUCCESS )
1555     {
1556         memcpy( p_spu->palette, val.p_address, 16 );
1557         p_spu->b_force_palette = true;
1558     }
1559     vlc_mutex_unlock( &p_spu->subpicture_lock );
1560
1561     msg_Dbg( p_object, "crop: %i,%i,%i,%i, palette forced: %i",
1562              p_spu->i_crop_x, p_spu->i_crop_y,
1563              p_spu->i_crop_width, p_spu->i_crop_height,
1564              p_spu->b_force_palette );
1565 }
1566
1567 /*****************************************************************************
1568  * CropCallback: called when the highlight properties are changed
1569  *****************************************************************************
1570  * This callback is called from the input thread when we need cropping
1571  *****************************************************************************/
1572 static int CropCallback( vlc_object_t *p_object, char const *psz_var,
1573                          vlc_value_t oldval, vlc_value_t newval, void *p_data )
1574 {
1575     (void)psz_var; (void)oldval; (void)newval;
1576     UpdateSPU( (spu_t *)p_data, p_object );
1577     return VLC_SUCCESS;
1578 }
1579
1580 /*****************************************************************************
1581  * Buffers allocation callbacks for the filters
1582  *****************************************************************************/
1583 static subpicture_t *sub_new_buffer( filter_t *p_filter )
1584 {
1585     filter_owner_sys_t *p_sys = p_filter->p_owner;
1586     subpicture_t *p_subpicture = spu_CreateSubpicture( p_sys->p_spu );
1587     if( p_subpicture ) p_subpicture->i_channel = p_sys->i_channel;
1588     return p_subpicture;
1589 }
1590
1591 static void sub_del_buffer( filter_t *p_filter, subpicture_t *p_subpic )
1592 {
1593     filter_owner_sys_t *p_sys = p_filter->p_owner;
1594     spu_DestroySubpicture( p_sys->p_spu, p_subpic );
1595 }
1596
1597 static subpicture_t *spu_new_buffer( filter_t *p_filter )
1598 {
1599     subpicture_t *p_subpic = calloc( 1, sizeof(subpicture_t) );
1600     if( !p_subpic )
1601         return NULL;
1602
1603     p_subpic->b_absolute = true;
1604     p_subpic->i_alpha    = 0xFF;
1605
1606     p_subpic->pf_create_region = __spu_CreateRegion;
1607     p_subpic->pf_destroy_region = __spu_DestroyRegion;
1608
1609     VLC_UNUSED(p_filter);
1610     return p_subpic;
1611 }
1612
1613 static void spu_del_buffer( filter_t *p_filter, subpicture_t *p_subpic )
1614 {
1615     while( p_subpic->p_region )
1616     {
1617         subpicture_region_t *p_region = p_subpic->p_region;
1618         p_subpic->p_region = p_region->p_next;
1619         p_subpic->pf_destroy_region( VLC_OBJECT(p_filter), p_region );
1620     }
1621
1622     free( p_subpic );
1623 }
1624
1625 static picture_t *spu_new_video_buffer( filter_t *p_filter )
1626 {
1627     const video_format_t *p_fmt = &p_filter->fmt_out.video;
1628
1629     VLC_UNUSED(p_filter);
1630     return picture_New( p_fmt->i_chroma,
1631                         p_fmt->i_width, p_fmt->i_height, p_fmt->i_aspect );
1632 }
1633
1634 static void spu_del_video_buffer( filter_t *p_filter, picture_t *p_picture )
1635 {
1636     VLC_UNUSED(p_filter);
1637     picture_Release( p_picture );
1638 }
1639
1640 static int SubFilterCallback( vlc_object_t *p_object, char const *psz_var,
1641                          vlc_value_t oldval, vlc_value_t newval, void *p_data )
1642 {
1643     spu_t *p_spu = p_data;
1644
1645     VLC_UNUSED(p_object); VLC_UNUSED(oldval);
1646     VLC_UNUSED(newval); VLC_UNUSED(psz_var);
1647
1648     vlc_mutex_lock( &p_spu->subpicture_lock );
1649     filter_chain_Reset( p_spu->p_chain, NULL, NULL );
1650     spu_ParseChain( p_spu );
1651     vlc_mutex_unlock( &p_spu->subpicture_lock );
1652     return VLC_SUCCESS;
1653 }
1654
1655 static int SubFilterAllocationInit( filter_t *p_filter, void *p_data )
1656 {
1657     spu_t *p_spu = p_data;
1658
1659     filter_owner_sys_t *p_sys = malloc( sizeof(filter_owner_sys_t) );
1660     if( !p_sys )
1661         return VLC_EGENERIC;
1662
1663     p_filter->pf_sub_buffer_new = sub_new_buffer;
1664     p_filter->pf_sub_buffer_del = sub_del_buffer;
1665
1666     p_filter->p_owner = p_sys;
1667     spu_Control( p_spu, SPU_CHANNEL_REGISTER, &p_sys->i_channel );
1668     p_sys->p_spu = p_spu;
1669
1670     return VLC_SUCCESS;
1671 }
1672
1673 static void SubFilterAllocationClean( filter_t *p_filter )
1674 {
1675     filter_owner_sys_t *p_sys = p_filter->p_owner;
1676
1677     SpuClearChannel( p_sys->p_spu, p_sys->i_channel, true );
1678     free( p_filter->p_owner );
1679 }
1680