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