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 /*****************************************************************************
 432  * spu_RenderSubpictures: render a subpicture list
 433  *****************************************************************************
 434  * This function renders all sub picture units in the list.
 435  *****************************************************************************/
 436 static void FilterRelease( filter_t *p_filter )
 437 {
 438     if( p_filter->p_module )
 439         module_Unneed( p_filter, p_filter->p_module );
 440
 441     vlc_object_detach( p_filter );
 442     vlc_object_release( p_filter );
 443 }
 444
 445 static void SpuRenderCreateBlend( spu_t *p_spu, vlc_fourcc_t i_chroma, int i_aspect )
 446 {
 447     filter_t *p_blend;
 448
 449     assert( !p_spu->p_blend );
 450
 451     p_spu->p_blend =
 452     p_blend        = vlc_custom_create( p_spu, sizeof(filter_t),
 453                                         VLC_OBJECT_GENERIC, "blend" );
 454     if( !p_blend )
 455         return;
 456
 457     es_format_Init( &p_blend->fmt_in, VIDEO_ES, 0 );
 458
 459     es_format_Init( &p_blend->fmt_out, VIDEO_ES, 0 );
 460     p_blend->fmt_out.video.i_x_offset = 0;
 461     p_blend->fmt_out.video.i_y_offset = 0;
 462     p_blend->fmt_out.video.i_chroma = i_chroma;
 463     p_blend->fmt_out.video.i_aspect = i_aspect;
 464
 465     /* The blend module will be loaded when needed with the real
 466     * input format */
 467     p_blend->p_module = NULL;
 468
 469     /* */
 470     vlc_object_attach( p_blend, p_spu );
 471 }
 472 static void SpuRenderUpdateBlend( spu_t *p_spu, int i_out_width, int i_out_height, const video_format_t *p_in_fmt )
 473 {
 474     filter_t *p_blend = p_spu->p_blend;
 475
 476     assert( p_blend );
 477
 478     /* */
 479     if( p_blend->p_module && p_blend->fmt_in.video.i_chroma != p_in_fmt->i_chroma )
 480     {
 481         /* The chroma is not the same, we need to reload the blend module
 482          * XXX to match the old behaviour just test !p_blend->fmt_in.video.i_chroma */
 483         module_Unneed( p_blend, p_blend->p_module );
 484         p_blend->p_module = NULL;
 485     }
 486
 487     /* */
 488     p_blend->fmt_in.video = *p_in_fmt;
 489
 490     /* */
 491     p_blend->fmt_out.video.i_width =
 492     p_blend->fmt_out.video.i_visible_width = i_out_width;
 493     p_blend->fmt_out.video.i_height =
 494     p_blend->fmt_out.video.i_visible_height = i_out_height;
 495
 496     /* */
 497     if( !p_blend->p_module )
 498         p_blend->p_module = module_Need( p_blend, "video blending", 0, 0 );
 499 }
 500 static void SpuRenderCreateAndLoadText( spu_t *p_spu )
 501 {
 502     filter_t *p_text;
 503
 504     assert( !p_spu->p_text );
 505
 506     p_spu->p_text =
 507     p_text        = vlc_custom_create( p_spu, sizeof(filter_t),
 508                                        VLC_OBJECT_GENERIC, "spu text" );
 509     if( !p_text )
 510         return;
 511
 512     es_format_Init( &p_text->fmt_in, VIDEO_ES, 0 );
 513
 514     es_format_Init( &p_text->fmt_out, VIDEO_ES, 0 );
 515     p_text->fmt_out.video.i_width =
 516     p_text->fmt_out.video.i_visible_width = 32;
 517     p_text->fmt_out.video.i_height =
 518     p_text->fmt_out.video.i_visible_height = 32;
 519
 520     p_text->pf_sub_buffer_new = spu_new_buffer;
 521     p_text->pf_sub_buffer_del = spu_del_buffer;
 522
 523     vlc_object_attach( p_text, p_spu );
 524
 525     /* FIXME TOCHECK shouldn't module_Need( , , psz_modulename, false ) do the
 526      * same than these 2 calls ? */
 527     char *psz_modulename = var_CreateGetString( p_spu, "text-renderer" );
 528     if( psz_modulename && *psz_modulename )
 529     {
 530         p_text->p_module = module_Need( p_text, "text renderer",
 531                                         psz_modulename, true );
 532     }
 533     free( psz_modulename );
 534
 535     if( !p_text->p_module )
 536         p_text->p_module = module_Need( p_text, "text renderer", NULL, false );
 537 }
 538
 539 static filter_t *CreateAndLoadScale( vlc_object_t *p_obj, vlc_fourcc_t i_chroma )
 540 {
 541     filter_t *p_scale;
 542
 543     p_scale = vlc_custom_create( p_obj, sizeof(filter_t),
 544                                  VLC_OBJECT_GENERIC, "scale" );
 545     if( !p_scale )
 546         return NULL;
 547
 548     es_format_Init( &p_scale->fmt_in, VIDEO_ES, 0 );
 549     p_scale->fmt_in.video.i_chroma = i_chroma;
 550     p_scale->fmt_in.video.i_width =
 551     p_scale->fmt_in.video.i_height = 32;
 552
 553     es_format_Init( &p_scale->fmt_out, VIDEO_ES, 0 );
 554     p_scale->fmt_out.video.i_chroma = i_chroma;
 555     p_scale->fmt_out.video.i_width =
 556     p_scale->fmt_out.video.i_height = 16;
 557
 558     p_scale->pf_vout_buffer_new = spu_new_video_buffer;
 559     p_scale->pf_vout_buffer_del = spu_del_video_buffer;
 560
 561     vlc_object_attach( p_scale, p_obj );
 562     p_scale->p_module = module_Need( p_scale, "video filter2", 0, 0 );
 563
 564     return p_scale;
 565 }
 566 static void SpuRenderCreateAndLoadScale( spu_t *p_spu )
 567 {
 568     /* FIXME: We'll also be using it for YUVA and RGBA blending ... */
 569
 570     assert( !p_spu->p_scale );
 571     assert( !p_spu->p_scale_yuvp );
 572     p_spu->p_scale = CreateAndLoadScale( VLC_OBJECT(p_spu), VLC_FOURCC('Y','U','V','A') );
 573     p_spu->p_scale_yuvp = p_spu->p_scale_yuvp = CreateAndLoadScale( VLC_OBJECT(p_spu), VLC_FOURCC('Y','U','V','P') );
 574 }
 575
 576 static void SpuRenderText( spu_t *p_spu, bool *pb_rerender_text,
 577                            subpicture_t *p_subpic, subpicture_region_t *p_region, int i_min_scale_ratio )
 578 {
 579     assert( p_region->fmt.i_chroma == VLC_FOURCC('T','E','X','T') );
 580
 581     if( !p_spu->p_text || !p_spu->p_text->p_module )
 582         goto exit;
 583
 584     /* Setup 3 variables which can be used to render
 585      * time-dependent text (and effects). The first indicates
 586      * the total amount of time the text will be on screen,
 587      * the second the amount of time it has already been on
 588      * screen (can be a negative value as text is layed out
 589      * before it is rendered) and the third is a feedback
 590      * variable from the renderer - if the renderer sets it
 591      * then this particular text is time-dependent, eg. the
 592      * visual progress bar inside the text in karaoke and the
 593      * text needs to be rendered multiple times in order for
 594      * the effect to work - we therefore need to return the
 595      * region to its original state at the end of the loop,
 596      * instead of leaving it in YUVA or YUVP.
 597      * Any renderer which is unaware of how to render
 598      * time-dependent text can happily ignore the variables
 599      * and render the text the same as usual - it should at
 600      * least show up on screen, but the effect won't change
 601      * the text over time.
 602      */
 603
 604     /* FIXME why these variables are recreated every time and not
 605      * when text renderer module was created ? */
 606     var_Create( p_spu->p_text, "spu-duration", VLC_VAR_TIME );
 607     var_Create( p_spu->p_text, "spu-elapsed", VLC_VAR_TIME );
 608     var_Create( p_spu->p_text, "text-rerender", VLC_VAR_BOOL );
 609     var_Create( p_spu->p_text, "scale", VLC_VAR_INTEGER );
 610
 611     var_SetTime( p_spu->p_text, "spu-duration", p_subpic->i_stop - p_subpic->i_start );
 612     var_SetTime( p_spu->p_text, "spu-elapsed", mdate() - p_subpic->i_start );
 613     var_SetBool( p_spu->p_text, "text-rerender", false );
 614     var_SetInteger( p_spu->p_text, "scale", i_min_scale_ratio );
 615
 616     if( p_spu->p_text->pf_render_html && p_region->psz_html )
 617     {
 618         p_spu->p_text->pf_render_html( p_spu->p_text,
 619                                        p_region, p_region );
 620     }
 621     else if( p_spu->p_text->pf_render_text )
 622     {
 623         p_spu->p_text->pf_render_text( p_spu->p_text,
 624                                        p_region, p_region );
 625     }
 626     *pb_rerender_text = var_GetBool( p_spu->p_text, "text-rerender" );
 627
 628     var_Destroy( p_spu->p_text, "spu-duration" );
 629     var_Destroy( p_spu->p_text, "spu-elapsed" );
 630     var_Destroy( p_spu->p_text, "text-rerender" );
 631     var_Destroy( p_spu->p_text, "scale" );
 632
 633 exit:
 634     p_region->i_align |= SUBPICTURE_RENDERED;
 635 }
 636
 637 /**
 638  * A few scale functions helpers.
 639  */
 640 typedef struct
 641 {
 642     int w;
 643     int h;
 644 } spu_scale_t;
 645
 646 static spu_scale_t spu_scale_create( int w, int h )
 647 {
 648     spu_scale_t s = { .w = w, .h = h };
 649     if( s.w <= 0 )
 650         s.w = SCALE_UNIT;
 651     if( s.h <= 0 )
 652         s.h = SCALE_UNIT;
 653     return s;
 654 }
 655 static spu_scale_t spu_scale_createq( int wn, int wd, int hn, int hd )
 656 {
 657     return spu_scale_create( wn * SCALE_UNIT / wd,
 658                              hn * SCALE_UNIT / hd );
 659 }
 660 static int spu_scale_w( int v, const spu_scale_t s )
 661 {
 662     return v * s.w / SCALE_UNIT;
 663 }
 664 static int spu_scale_h( int v, const spu_scale_t s )
 665 {
 666     return v * s.h / SCALE_UNIT;
 667 }
 668 static int spu_invscale_h( int v, const spu_scale_t s )
 669 {
 670     return v * SCALE_UNIT / s.h;
 671 }
 672
 673 /**
 674  * Place a region
 675  */
 676 static void SpuRegionPlace( int *pi_x, int *pi_y,
 677                             const subpicture_t *p_subpic,
 678                             const subpicture_region_t *p_region,
 679                             int i_margin_y )
 680 {
 681     const int i_delta_x = p_region->i_x;
 682     const int i_delta_y = p_region->i_y;
 683     int i_x, i_y;
 684
 685     assert( p_region->i_x != INT_MAX && p_region->i_y != INT_MAX );
 686     if( p_region->i_align & SUBPICTURE_ALIGN_TOP )
 687     {
 688         i_y = i_delta_y;
 689     }
 690     else if( p_region->i_align & SUBPICTURE_ALIGN_BOTTOM )
 691     {
 692         i_y = p_subpic->i_original_picture_height - p_region->fmt.i_height - i_delta_y;
 693     }
 694     else
 695     {
 696         i_y = p_subpic->i_original_picture_height / 2 - p_region->fmt.i_height / 2;
 697     }
 698
 699     if( p_region->i_align & SUBPICTURE_ALIGN_LEFT )
 700     {
 701         i_x = i_delta_x;
 702     }
 703     else if( p_region->i_align & SUBPICTURE_ALIGN_RIGHT )
 704     {
 705         i_x = p_subpic->i_original_picture_width - p_region->fmt.i_width - i_delta_x;
 706     }
 707     else
 708     {
 709         i_x = p_subpic->i_original_picture_width / 2 - p_region->fmt.i_width / 2;
 710     }
 711
 712     if( p_subpic->b_absolute )
 713     {
 714         i_x = i_delta_x;
 715         i_y = i_delta_y;
 716     }
 717
 718     /* Margin shifts all subpictures */
 719     if( i_margin_y != 0 )
 720         i_y -= i_margin_y;
 721
 722     /* Clamp offset to not go out of the screen (when possible) */
 723     const int i_error_x = (i_x + p_region->fmt.i_width) - p_subpic->i_original_picture_width;
 724     if( i_error_x > 0 )
 725         i_x -= i_error_x;
 726     if( i_x < 0 )
 727         i_x = 0;
 728
 729     const int i_error_y = (i_y + p_region->fmt.i_height) - p_subpic->i_original_picture_height;
 730     if( i_error_y > 0 )
 731         i_y -= i_error_y;
 732     if( i_y < 0 )
 733         i_y = 0;
 734
 735     *pi_x = i_x;
 736     *pi_y = i_y;
 737 }
 738
 739 /**
 740  * This function computes the current alpha value for a given region.
 741  */
 742 static int SpuRegionAlpha( subpicture_t *p_subpic, subpicture_region_t *p_region )
 743 {
 744     /* Compute alpha blend value */
 745     int i_fade_alpha = 255;
 746     if( p_subpic->b_fade )
 747     {
 748         mtime_t i_fade_start = ( p_subpic->i_stop +
 749                                  p_subpic->i_start ) / 2;
 750         mtime_t i_now = mdate();
 751
 752         if( i_now >= i_fade_start && p_subpic->i_stop > i_fade_start )
 753         {
 754             i_fade_alpha = 255 * ( p_subpic->i_stop - i_now ) /
 755                            ( p_subpic->i_stop - i_fade_start );
 756         }
 757     }
 758     return i_fade_alpha * p_subpic->i_alpha * p_region->i_alpha / 65025;
 759 }
 760
 761 static void SpuRenderRegion( spu_t *p_spu,
 762                              picture_t *p_pic_dst,
 763                              subpicture_t *p_subpic, subpicture_region_t *p_region,
 764                              const spu_scale_t scale_size,
 765                              const video_format_t *p_fmt )
 766 {
 767     video_format_t fmt_original;
 768     bool b_rerender_text;
 769     bool b_restore_format = false;
 770     int i_x_offset;
 771     int i_y_offset;
 772     filter_t *p_scale;
 773
 774     vlc_assert_locked( &p_spu->subpicture_lock );
 775
 776     fmt_original = p_region->fmt;
 777     b_rerender_text = false;
 778     if( p_region->fmt.i_chroma == VLC_FOURCC('T','E','X','T') )
 779     {
 780         const int i_min_scale_ratio = __MIN( scale_size.w, scale_size.h );
 781         SpuRenderText( p_spu, &b_rerender_text, p_subpic, p_region, i_min_scale_ratio );
 782         b_restore_format = b_rerender_text;
 783
 784         /* Check if the rendering has failed ... */
 785         if( p_region->fmt.i_chroma == VLC_FOURCC('T','E','X','T') )
 786             goto exit;
 787     }
 788
 789     /* Force palette if requested
 790      * FIXME b_force_palette and b_force_crop are applied to all subpictures using palette
 791      * instead of only the right one (being the dvd spu).
 792      */
 793     const bool b_using_palette = p_region->fmt.i_chroma == VLC_FOURCC('Y','U','V','P');
 794     const bool b_force_palette = b_using_palette && p_spu->b_force_palette;
 795     const bool b_force_crop    = b_force_palette && p_spu->b_force_crop;
 796
 797
 798     /* Compute the margin which is expressed in destination pixel unit
 799      * The margin is applied only to subtitle and when no forced crop is
 800      * requested (dvd menu) */
 801     int i_margin_y = 0;
 802     if( !b_force_crop && p_subpic->b_subtitle )
 803         i_margin_y = spu_invscale_h( p_spu->i_margin, scale_size );
 804
 805     /* Place the picture
 806      * We compute the position in the rendered size */
 807     SpuRegionPlace( &i_x_offset, &i_y_offset,
 808                     p_subpic, p_region, i_margin_y );
 809
 810     /* TODO save this position for subtitle overlap support */
 811
 812     /* Fix the position for the current scale_size */
 813     i_x_offset = spu_scale_w( i_x_offset, scale_size );
 814     i_y_offset = spu_scale_h( i_y_offset, scale_size );
 815
 816     if( b_force_palette )
 817     {
 818         /* It looks so wrong I won't comment
 819          * p_palette->palette is [256][4] with a int i_entries
 820          * p_spu->palette is [4][4]
 821          * */
 822         p_region->fmt.p_palette->i_entries = 4;
 823         memcpy( p_region->fmt.p_palette->palette, p_spu->palette, 4*sizeof(uint32_t) );
 824     }
 825
 826     if( b_using_palette )
 827         p_scale = p_spu->p_scale_yuvp;
 828     else
 829         p_scale = p_spu->p_scale;
 830
 831     /* Scale from rendered size to destination size */
 832     if( p_scale &&
 833         ( scale_size.w != SCALE_UNIT || scale_size.h != SCALE_UNIT || b_force_palette ) )
 834     {
 835         const unsigned i_dst_width  = spu_scale_w( p_region->fmt.i_width, scale_size );
 836         const unsigned i_dst_height = spu_scale_h( p_region->fmt.i_height, scale_size );
 837
 838         /* TODO when b_using_palette is true, we should first convert it to YUVA to allow
 839          * a proper rescaling */
 840
 841         /* Destroy if cache is unusable */
 842         if( p_region->p_cache )
 843         {
 844             if( p_region->p_cache->fmt.i_width  != i_dst_width ||
 845                 p_region->p_cache->fmt.i_height != i_dst_height ||
 846                 b_force_palette )
 847             {
 848                 p_subpic->pf_destroy_region( VLC_OBJECT(p_spu),
 849                                              p_region->p_cache );
 850                 p_region->p_cache = NULL;
 851             }
 852         }
 853
 854         /* Scale if needed into cache */
 855         if( !p_region->p_cache )
 856         {
 857             picture_t *p_pic;
 858
 859             p_scale->fmt_in.video = p_region->fmt;
 860             p_scale->fmt_out.video = p_region->fmt;
 861
 862             if( p_scale->fmt_out.video.p_palette )
 863                 *p_scale->fmt_out.video.p_palette =
 864                     *p_region->fmt.p_palette;
 865
 866             p_scale->fmt_out.video.i_width = i_dst_width;
 867             p_scale->fmt_out.video.i_height = i_dst_height;
 868
 869             p_scale->fmt_out.video.i_visible_width =
 870                 spu_scale_w( p_region->fmt.i_visible_width, scale_size );
 871             p_scale->fmt_out.video.i_visible_height =
 872                 spu_scale_h( p_region->fmt.i_visible_height, scale_size );
 873
 874             p_region->p_cache =
 875                 p_subpic->pf_create_region( VLC_OBJECT(p_spu),
 876                                             &p_scale->fmt_out.video );
 877
 878             p_pic = NULL;
 879             if( p_scale->p_module )
 880             {
 881                 picture_Yield( &p_region->picture );
 882                 p_pic = p_scale->pf_video_filter( p_scale, &p_region->picture );
 883             }
 884             if( p_pic )
 885             {
 886                 picture_Copy( &p_region->p_cache->picture, p_pic );
 887                 picture_Release( p_pic );
 888
 889                 p_region->p_cache->fmt = p_scale->fmt_out.video;
 890                 /* i_x/i_y of cached region should NOT be used. I set them to
 891                  * an invalid value to catch it (assert) */
 892                 p_region->p_cache->i_x = INT_MAX;
 893                 p_region->p_cache->i_y = INT_MAX;
 894                 p_region->p_cache->i_align = p_region->i_align;
 895                 p_region->p_cache->i_alpha = p_region->i_alpha;
 896             }
 897             else
 898             {
 899                 msg_Err( p_spu, "scaling failed (module not loaded)" );
 900                 p_subpic->pf_destroy_region( VLC_OBJECT(p_spu),
 901                                              p_region->p_cache );
 902                 p_region->p_cache = NULL;
 903             }
 904         }
 905
 906         /* And use the scaled picture */
 907         if( p_region->p_cache )
 908         {
 909             p_region = p_region->p_cache;
 910             fmt_original = p_region->fmt;
 911         }
 912     }
 913
 914     /* Force cropping if requested */
 915     if( b_force_crop )
 916     {
 917         video_format_t *p_fmt = &p_region->fmt;
 918         int i_crop_x = spu_scale_w( p_spu->i_crop_x, scale_size );
 919         int i_crop_y = spu_scale_h( p_spu->i_crop_y, scale_size );
 920         int i_crop_width = spu_scale_w( p_spu->i_crop_width, scale_size );
 921         int i_crop_height= spu_scale_h( p_spu->i_crop_height,scale_size );
 922
 923         /* Find the intersection */
 924         if( i_crop_x + i_crop_width <= i_x_offset ||
 925             i_x_offset + (int)p_fmt->i_visible_width < i_crop_x ||
 926             i_crop_y + i_crop_height <= i_y_offset ||
 927             i_y_offset + (int)p_fmt->i_visible_height < i_crop_y )
 928         {
 929             /* No intersection */
 930             p_fmt->i_visible_width = p_fmt->i_visible_height = 0;
 931         }
 932         else
 933         {
 934             int i_x, i_y, i_x_end, i_y_end;
 935             i_x = __MAX( i_crop_x, i_x_offset );
 936             i_y = __MAX( i_crop_y, i_y_offset );
 937             i_x_end = __MIN( i_crop_x + i_crop_width,
 938                            i_x_offset + (int)p_fmt->i_visible_width );
 939             i_y_end = __MIN( i_crop_y + i_crop_height,
 940                            i_y_offset + (int)p_fmt->i_visible_height );
 941
 942             p_fmt->i_x_offset = i_x - i_x_offset;
 943             p_fmt->i_y_offset = i_y - i_y_offset;
 944             p_fmt->i_visible_width = i_x_end - i_x;
 945             p_fmt->i_visible_height = i_y_end - i_y;
 946
 947             i_x_offset = __MAX( i_x, 0 );
 948             i_y_offset = __MAX( i_y, 0 );
 949         }
 950         b_restore_format = true;
 951     }
 952
 953     /* Update the blender */
 954     SpuRenderUpdateBlend( p_spu, p_fmt->i_width, p_fmt->i_height, &p_region->fmt );
 955
 956     if( p_spu->p_blend->p_module )
 957     {
 958         const int i_alpha = SpuRegionAlpha( p_subpic, p_region );
 959
 960         p_spu->p_blend->pf_video_blend( p_spu->p_blend, p_pic_dst,
 961             &p_region->picture, i_x_offset, i_y_offset, i_alpha );
 962     }
 963     else
 964     {
 965         msg_Err( p_spu, "blending %4.4s to %4.4s failed",
 966                  (char *)&p_spu->p_blend->fmt_out.video.i_chroma,
 967                  (char *)&p_spu->p_blend->fmt_out.video.i_chroma );
 968     }
 969
 970 exit:
 971     if( b_rerender_text )
 972     {
 973         /* Some forms of subtitles need to be re-rendered more than
 974          * once, eg. karaoke. We therefore restore the region to its
 975          * pre-rendered state, so the next time through everything is
 976          * calculated again.
 977          */
 978         p_region->picture.pf_release( &p_region->picture );
 979         memset( &p_region->picture, 0, sizeof( picture_t ) );
 980         p_region->i_align &= ~SUBPICTURE_RENDERED;
 981     }
 982     if( b_restore_format )
 983         p_region->fmt = fmt_original;
 984 }
 985
 986 void spu_RenderSubpictures( spu_t *p_spu,
 987                             picture_t *p_pic_dst, const video_format_t *p_fmt_dst,
 988                             subpicture_t *p_subpic_list,
 989                             const video_format_t *p_fmt_src )
 990 {
 991     const int i_source_video_width  = p_fmt_src->i_width;
 992     const int i_source_video_height = p_fmt_src->i_height;
 993     const mtime_t i_current_date = mdate();
 994
 995     subpicture_t *p_subpic;
 996
 997     /* Get lock */
 998     vlc_mutex_lock( &p_spu->subpicture_lock );
 999
1000     /* Be sure we have at least 1 picture to process */
1001     if( !p_subpic_list || p_subpic_list->i_status == FREE_SUBPICTURE )
1002     {
1003         vlc_mutex_unlock( &p_spu->subpicture_lock );
1004         return;
1005     }
1006
1007     /* */
1008     for( p_subpic = p_subpic_list;
1009             p_subpic != NULL && p_subpic->i_status != FREE_SUBPICTURE; /* Check again status (as we where unlocked) */
1010                 p_subpic = p_subpic->p_next )
1011     {
1012         /* */
1013         if( p_subpic->pf_pre_render )
1014             p_subpic->pf_pre_render( p_spu, p_subpic, p_fmt_dst );
1015
1016         if( p_subpic->pf_update_regions )
1017         {
1018             video_format_t fmt_org = *p_fmt_dst;
1019             fmt_org.i_width =
1020             fmt_org.i_visible_width = i_source_video_width;
1021             fmt_org.i_height =
1022             fmt_org.i_visible_height = i_source_video_height;
1023
1024             p_subpic->pf_update_regions( p_spu, p_subpic, &fmt_org, i_current_date );
1025         }
1026     }
1027
1028     /* Create the blending module */
1029     if( !p_spu->p_blend )
1030         SpuRenderCreateBlend( p_spu, p_fmt_dst->i_chroma, p_fmt_dst->i_aspect );
1031
1032     /* */
1033     for( p_subpic = p_subpic_list; ; p_subpic = p_subpic->p_next )
1034     {
1035         subpicture_region_t *p_region;
1036
1037         if( !p_subpic || p_subpic->i_status == FREE_SUBPICTURE )
1038             break;
1039
1040         if( !p_subpic->p_region )
1041             continue;
1042
1043         /* FIXME when possible use a better rendering size than source size
1044          * (max of display size and source size for example) FIXME */
1045         int i_render_width  = p_subpic->i_original_picture_width;
1046         int i_render_height = p_subpic->i_original_picture_height;
1047         if( !i_render_width || !i_render_height )
1048         {
1049             if( i_render_width != 0 || i_render_height != 0 )
1050                 msg_Err( p_spu, "unsupported original picture size %dx%d",
1051                          i_render_width, i_render_height );
1052
1053             p_subpic->i_original_picture_width  = i_render_width = i_source_video_width;
1054             p_subpic->i_original_picture_height = i_render_height = i_source_video_height;
1055         }
1056
1057         if( p_spu->p_text )
1058         {
1059             p_spu->p_text->fmt_out.video.i_width          =
1060             p_spu->p_text->fmt_out.video.i_visible_width  = i_render_width;
1061
1062             p_spu->p_text->fmt_out.video.i_height         =
1063             p_spu->p_text->fmt_out.video.i_visible_height = i_render_height;
1064         }
1065
1066         /* Compute scaling from picture to source size */
1067         spu_scale_t scale = spu_scale_createq( i_source_video_width,  i_render_width,
1068                                                i_source_video_height, i_render_height );
1069
1070         /* Update scaling from source size to display size(p_fmt_dst) */
1071         scale.w = scale.w * p_fmt_dst->i_width  / i_source_video_width;
1072         scale.h = scale.h * p_fmt_dst->i_height / i_source_video_height;
1073
1074         /* Set default subpicture aspect ratio
1075          * FIXME if we only handle 1 aspect ratio per picture, why is it set per
1076          * region ? */
1077         p_region = p_subpic->p_region;
1078         if( !p_region->fmt.i_sar_num || !p_region->fmt.i_sar_den )
1079         {
1080             if( p_region->fmt.i_aspect != 0 )
1081             {
1082                 p_region->fmt.i_sar_den = p_region->fmt.i_aspect;
1083                 p_region->fmt.i_sar_num = VOUT_ASPECT_FACTOR;
1084             }
1085             else
1086             {
1087                 p_region->fmt.i_sar_den = p_fmt_dst->i_sar_den;
1088                 p_region->fmt.i_sar_num = p_fmt_dst->i_sar_num;
1089             }
1090         }
1091
1092         /* Take care of the aspect ratio */
1093         if( p_region->fmt.i_sar_num * p_fmt_dst->i_sar_den !=
1094             p_region->fmt.i_sar_den * p_fmt_dst->i_sar_num )
1095         {
1096             /* FIXME FIXME what about region->i_x/i_y ? */
1097             scale.w = scale.w *
1098                 (int64_t)p_region->fmt.i_sar_num * p_fmt_dst->i_sar_den /
1099                 p_region->fmt.i_sar_den / p_fmt_dst->i_sar_num;
1100         }
1101
1102         /* Render all regions */
1103         for( p_region = p_subpic->p_region; p_region != NULL; p_region = p_region->p_next )
1104         {
1105             /* Check scale validity */
1106             if( scale.w <= 0 || scale.h <= 0 )
1107                 continue;
1108
1109             /* */
1110             SpuRenderRegion( p_spu, p_pic_dst, p_subpic, p_region,
1111                              scale, p_fmt_dst );
1112         }
1113     }
1114
1115     vlc_mutex_unlock( &p_spu->subpicture_lock );
1116 }
1117
1118 /*****************************************************************************
1119  * spu_SortSubpictures: find the subpictures to display
1120  *****************************************************************************
1121  * This function parses all subpictures and decides which ones need to be
1122  * displayed. This operation does not need lock, since only READY_SUBPICTURE
1123  * are handled. If no picture has been selected, display_date will depend on
1124  * the subpicture.
1125  * We also check for ephemer DVD subpictures (subpictures that have
1126  * to be removed if a newer one is available), which makes it a lot
1127  * more difficult to guess if a subpicture has to be rendered or not.
1128  *****************************************************************************/
1129 subpicture_t *spu_SortSubpictures( spu_t *p_spu, mtime_t display_date,
1130                                    bool b_paused, bool b_subtitle_only )
1131 {
1132     int i_channel;
1133     subpicture_t *p_subpic = NULL;
1134
1135     /* Run subpicture filters */
1136     filter_chain_SubFilter( p_spu->p_chain, display_date );
1137
1138     /* We get an easily parsable chained list of subpictures which
1139      * ends with NULL since p_subpic was initialized to NULL. */
1140     for( i_channel = 0; i_channel < p_spu->i_channel; i_channel++ )
1141     {
1142         subpicture_t *p_ephemer = NULL;
1143         mtime_t      ephemer_date = 0;
1144         int i_index;
1145
1146         for( i_index = 0; i_index < VOUT_MAX_SUBPICTURES; i_index++ )
1147         {
1148             subpicture_t *p_current = &p_spu->p_subpicture[i_index];
1149
1150             if( p_current->i_channel != i_channel ||
1151                 p_current->i_status != READY_SUBPICTURE ||
1152                 ( b_subtitle_only && !p_current->b_subtitle ) )
1153             {
1154                 continue;
1155             }
1156             if( display_date &&
1157                 display_date < p_current->i_start )
1158             {
1159                 /* Too early, come back next monday */
1160                 continue;
1161             }
1162
1163             if( p_current->i_start > ephemer_date )
1164                 ephemer_date = p_current->i_start;
1165
1166             if( display_date > p_current->i_stop &&
1167                 ( !p_current->b_ephemer || p_current->i_stop > p_current->i_start ) &&
1168                 !( p_current->b_subtitle && b_paused ) ) /* XXX Assume that subtitle are pausable */
1169             {
1170                 /* Too late, destroy the subpic */
1171                 spu_DestroySubpicture( p_spu, &p_spu->p_subpicture[i_index] );
1172                 continue;
1173             }
1174
1175             /* If this is an ephemer subpic, add it to our list */
1176             if( p_current->b_ephemer )
1177             {
1178                 p_current->p_next = p_ephemer;
1179                 p_ephemer = p_current;
1180
1181                 continue;
1182             }
1183
1184             p_current->p_next = p_subpic;
1185             p_subpic = p_current;
1186         }
1187
1188         /* If we found ephemer subpictures, check if they have to be
1189          * displayed or destroyed */
1190         while( p_ephemer != NULL )
1191         {
1192             subpicture_t *p_tmp = p_ephemer;
1193             p_ephemer = p_ephemer->p_next;
1194
1195             if( p_tmp->i_start < ephemer_date )
1196             {
1197                 /* Ephemer subpicture has lived too long */
1198                 spu_DestroySubpicture( p_spu, p_tmp );
1199             }
1200             else
1201             {
1202                 /* Ephemer subpicture can still live a bit */
1203                 p_tmp->p_next = p_subpic;
1204                 p_subpic = p_tmp;
1205             }
1206         }
1207     }
1208
1209     return p_subpic;
1210 }
1211
1212 /*****************************************************************************
1213  * SpuClearChannel: clear an spu channel
1214  *****************************************************************************
1215  * This function destroys the subpictures which belong to the spu channel
1216  * corresponding to i_channel_id.
1217  *****************************************************************************/
1218 static void SpuClearChannel( spu_t *p_spu, int i_channel, bool b_locked )
1219 {
1220     int          i_subpic;                               /* subpicture index */
1221     subpicture_t *p_subpic = NULL;                  /* first free subpicture */
1222
1223     if( !b_locked )
1224         vlc_mutex_lock( &p_spu->subpicture_lock );
1225
1226     for( i_subpic = 0; i_subpic < VOUT_MAX_SUBPICTURES; i_subpic++ )
1227     {
1228         p_subpic = &p_spu->p_subpicture[i_subpic];
1229         if( p_subpic->i_status == FREE_SUBPICTURE
1230             || ( p_subpic->i_status != RESERVED_SUBPICTURE
1231                  && p_subpic->i_status != READY_SUBPICTURE ) )
1232         {
1233             continue;
1234         }
1235
1236         if( p_subpic->i_channel == i_channel )
1237         {
1238             while( p_subpic->p_region )
1239             {
1240                 subpicture_region_t *p_region = p_subpic->p_region;
1241                 p_subpic->p_region = p_region->p_next;
1242                 spu_DestroyRegion( p_spu, p_region );
1243             }
1244
1245             if( p_subpic->pf_destroy ) p_subpic->pf_destroy( p_subpic );
1246             p_subpic->i_status = FREE_SUBPICTURE;
1247         }
1248     }
1249
1250     if( !b_locked )
1251         vlc_mutex_unlock( &p_spu->subpicture_lock );
1252 }
1253
1254 /*****************************************************************************
1255  * spu_ControlDefault: default methods for the subpicture unit control.
1256  *****************************************************************************/
1257 static int spu_vaControlDefault( spu_t *p_spu, int i_query, va_list args )
1258 {
1259     int *pi, i;
1260
1261     switch( i_query )
1262     {
1263     case SPU_CHANNEL_REGISTER:
1264         pi = (int *)va_arg( args, int * );
1265         vlc_mutex_lock( &p_spu->subpicture_lock );
1266         if( pi )
1267             *pi = p_spu->i_channel++;
1268         vlc_mutex_unlock( &p_spu->subpicture_lock );
1269         break;
1270
1271     case SPU_CHANNEL_CLEAR:
1272         i = (int)va_arg( args, int );
1273         SpuClearChannel( p_spu, i, false );
1274         break;
1275
1276     default:
1277         msg_Dbg( p_spu, "control query not supported" );
1278         return VLC_EGENERIC;
1279     }
1280
1281     return VLC_SUCCESS;
1282 }
1283
1284 /*****************************************************************************
1285  * Object variables callbacks
1286  *****************************************************************************/
1287
1288 /*****************************************************************************
1289  * UpdateSPU: update subpicture settings
1290  *****************************************************************************
1291  * This function is called from CropCallback and at initialization time, to
1292  * retrieve crop information from the input.
1293  *****************************************************************************/
1294 static void UpdateSPU( spu_t *p_spu, vlc_object_t *p_object )
1295 {
1296     vlc_value_t val;
1297
1298     vlc_mutex_lock( &p_spu->subpicture_lock );
1299
1300     p_spu->b_force_palette = false;
1301     p_spu->b_force_crop = false;
1302
1303     if( var_Get( p_object, "highlight", &val ) || !val.b_bool )
1304     {
1305         vlc_mutex_unlock( &p_spu->subpicture_lock );
1306         return;
1307     }
1308
1309     p_spu->b_force_crop = true;
1310     var_Get( p_object, "x-start", &val );
1311     p_spu->i_crop_x = val.i_int;
1312     var_Get( p_object, "y-start", &val );
1313     p_spu->i_crop_y = val.i_int;
1314     var_Get( p_object, "x-end", &val );
1315     p_spu->i_crop_width = val.i_int - p_spu->i_crop_x;
1316     var_Get( p_object, "y-end", &val );
1317     p_spu->i_crop_height = val.i_int - p_spu->i_crop_y;
1318
1319     if( var_Get( p_object, "menu-palette", &val ) == VLC_SUCCESS )
1320     {
1321         memcpy( p_spu->palette, val.p_address, 16 );
1322         p_spu->b_force_palette = true;
1323     }
1324     vlc_mutex_unlock( &p_spu->subpicture_lock );
1325
1326     msg_Dbg( p_object, "crop: %i,%i,%i,%i, palette forced: %i",
1327              p_spu->i_crop_x, p_spu->i_crop_y,
1328              p_spu->i_crop_width, p_spu->i_crop_height,
1329              p_spu->b_force_palette );
1330 }
1331
1332 /*****************************************************************************
1333  * CropCallback: called when the highlight properties are changed
1334  *****************************************************************************
1335  * This callback is called from the input thread when we need cropping
1336  *****************************************************************************/
1337 static int CropCallback( vlc_object_t *p_object, char const *psz_var,
1338                          vlc_value_t oldval, vlc_value_t newval, void *p_data )
1339 {
1340     (void)psz_var; (void)oldval; (void)newval;
1341     UpdateSPU( (spu_t *)p_data, p_object );
1342     return VLC_SUCCESS;
1343 }
1344
1345 /*****************************************************************************
1346  * Buffers allocation callbacks for the filters
1347  *****************************************************************************/
1348 static subpicture_t *sub_new_buffer( filter_t *p_filter )
1349 {
1350     filter_owner_sys_t *p_sys = p_filter->p_owner;
1351     subpicture_t *p_subpicture = spu_CreateSubpicture( p_sys->p_spu );
1352     if( p_subpicture ) p_subpicture->i_channel = p_sys->i_channel;
1353     return p_subpicture;
1354 }
1355
1356 static void sub_del_buffer( filter_t *p_filter, subpicture_t *p_subpic )
1357 {
1358     filter_owner_sys_t *p_sys = p_filter->p_owner;
1359     spu_DestroySubpicture( p_sys->p_spu, p_subpic );
1360 }
1361
1362 static subpicture_t *spu_new_buffer( filter_t *p_filter )
1363 {
1364     subpicture_t *p_subpic = calloc( 1, sizeof(subpicture_t) );
1365     if( !p_subpic )
1366         return NULL;
1367
1368     p_subpic->b_absolute = true;
1369     p_subpic->i_alpha    = 0xFF;
1370
1371     p_subpic->pf_create_region = __spu_CreateRegion;
1372     p_subpic->pf_destroy_region = __spu_DestroyRegion;
1373
1374     VLC_UNUSED(p_filter);
1375     return p_subpic;
1376 }
1377
1378 static void spu_del_buffer( filter_t *p_filter, subpicture_t *p_subpic )
1379 {
1380     while( p_subpic->p_region )
1381     {
1382         subpicture_region_t *p_region = p_subpic->p_region;
1383         p_subpic->p_region = p_region->p_next;
1384         p_subpic->pf_destroy_region( VLC_OBJECT(p_filter), p_region );
1385     }
1386
1387     free( p_subpic );
1388 }
1389
1390 static picture_t *spu_new_video_buffer( filter_t *p_filter )
1391 {
1392     const video_format_t *p_fmt = &p_filter->fmt_out.video;
1393
1394     VLC_UNUSED(p_filter);
1395     return picture_New( p_fmt->i_chroma,
1396                         p_fmt->i_width, p_fmt->i_height, p_fmt->i_aspect );
1397 }
1398
1399 static void spu_del_video_buffer( filter_t *p_filter, picture_t *p_picture )
1400 {
1401     VLC_UNUSED(p_filter);
1402     picture_Release( p_picture );
1403 }
1404
1405 static int SubFilterCallback( vlc_object_t *p_object, char const *psz_var,
1406                          vlc_value_t oldval, vlc_value_t newval, void *p_data )
1407 {
1408     spu_t *p_spu = p_data;
1409
1410     VLC_UNUSED(p_object); VLC_UNUSED(oldval);
1411     VLC_UNUSED(newval); VLC_UNUSED(psz_var);
1412
1413     vlc_mutex_lock( &p_spu->subpicture_lock );
1414     filter_chain_Reset( p_spu->p_chain, NULL, NULL );
1415     spu_ParseChain( p_spu );
1416     vlc_mutex_unlock( &p_spu->subpicture_lock );
1417     return VLC_SUCCESS;
1418 }
1419
1420 static int SubFilterAllocationInit( filter_t *p_filter, void *p_data )
1421 {
1422     spu_t *p_spu = p_data;
1423
1424     filter_owner_sys_t *p_sys = malloc( sizeof(filter_owner_sys_t) );
1425     if( !p_sys )
1426         return VLC_EGENERIC;
1427
1428     p_filter->pf_sub_buffer_new = sub_new_buffer;
1429     p_filter->pf_sub_buffer_del = sub_del_buffer;
1430
1431     p_filter->p_owner = p_sys;
1432     spu_Control( p_spu, SPU_CHANNEL_REGISTER, &p_sys->i_channel );
1433     p_sys->p_spu = p_spu;
1434
1435     return VLC_SUCCESS;
1436 }
1437
1438 static void SubFilterAllocationClean( filter_t *p_filter )
1439 {
1440     filter_owner_sys_t *p_sys = p_filter->p_owner;
1441
1442     SpuClearChannel( p_sys->p_spu, p_sys->i_channel, true );
1443     free( p_filter->p_owner );
1444 }
1445