git.sesse.net Git - vlc/blob - modules/codec/kate.c

   1 /*****************************************************************************
   2  * kate.c : a decoder for the kate bitstream format
   3  *****************************************************************************
   4  * Copyright (C) 2000-2008 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Vincent Penquerc'h <ogg.k.ogg.k@googlemail.com>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27 #ifdef HAVE_CONFIG_H
  28 # include "config.h"
  29 #endif
  30
  31 #include <vlc_common.h>
  32 #include <vlc_plugin.h>
  33 #include <vlc_input.h>
  34 #include <vlc_codec.h>
  35 #include "../demux/xiph.h"
  36
  37 #include <kate/kate.h>
  38 #ifdef HAVE_TIGER
  39 # include <tiger/tiger.h>
  40 #endif
  41
  42 /* #define ENABLE_PACKETIZER */
  43 /* #define ENABLE_PROFILE */
  44
  45 #ifdef ENABLE_PROFILE
  46 # define PROFILE_START(name) int64_t profile_start_##name = mdate()
  47 # define PROFILE_STOP(name) fprintf( stderr, #name ": %f ms\n", (mdate() - profile_start_##name)/1000.0f )
  48 #else
  49 # define PROFILE_START(name) ((void)0)
  50 # define PROFILE_STOP(name) ((void)0)
  51 #endif
  52
  53 #define CHECK_TIGER_RET( statement )                                   \
  54     do                                                                 \
  55     {                                                                  \
  56         int i_ret = (statement);                                       \
  57         if( i_ret < 0 )                                                \
  58         {                                                              \
  59             msg_Dbg( p_dec, "Error in " #statement ": %d", i_ret );    \
  60         }                                                              \
  61     } while( 0 )
  62
  63 /*****************************************************************************
  64  * decoder_sys_t : decoder descriptor
  65  *****************************************************************************/
  66 struct decoder_sys_t
  67 {
  68 #ifdef ENABLE_PACKETIZER
  69     /* Module mode */
  70     bool b_packetizer;
  71 #endif
  72
  73     /*
  74      * Input properties
  75      */
  76     bool b_has_headers;
  77
  78     /*
  79      * Kate properties
  80      */
  81     bool           b_ready;
  82     kate_info      ki;
  83     kate_comment   kc;
  84     kate_state     k;
  85
  86     /*
  87      * Common properties
  88      */
  89     mtime_t i_pts;
  90     mtime_t i_max_stop;
  91
  92     /* decoder_sys_t is shared between decoder and spu units */
  93     vlc_mutex_t lock;
  94     int         i_refcount;
  95
  96 #ifdef HAVE_TIGER
  97     /*
  98      * Tiger properties
  99      */
 100     tiger_renderer    *p_tr;
 101     bool               b_dirty;
 102
 103     uint32_t           i_tiger_default_font_color;
 104     uint32_t           i_tiger_default_background_color;
 105     tiger_font_effect  e_tiger_default_font_effect;
 106     double             f_tiger_default_font_effect_strength;
 107     char              *psz_tiger_default_font_desc;
 108     double             f_tiger_quality;
 109 #endif
 110
 111     /*
 112      * Options
 113      */
 114     bool   b_formatted;
 115     bool   b_use_tiger;
 116 };
 117
 118 struct subpicture_updater_sys_t
 119 {
 120     decoder_sys_t *p_dec_sys;
 121     mtime_t        i_start;
 122 };
 123
 124
 125 /*
 126  * This is a global list of existing decoders.
 127  * The reason for this list is that:
 128  *  - I want to be able to reconfigure Tiger when user prefs change
 129  *  - User prefs are variables which are not specific to a decoder (eg, if
 130  *    there are several decoders, there will still be one set of variables)
 131  *  - A callback set on those will not be passed a pointer to the decoder
 132  *    (as the decoder isn't known, and there could be multiple ones)
 133  *  - Creating variables in the decoder will create different ones, with
 134  *    values copied from the relevant user pref, so a callback on those
 135  *    won't be called when the user pref is changed
 136  * Therefore, each decoder will register/unregister itself with this list,
 137  * callbacks will be set for the user prefs, and these will in turn walk
 138  * through this list and tell each decoder to update the relevant variable.
 139  * HOWEVER.
 140  * VLC's variable system is still in my way as I can't get the value of
 141  * the user pref variables at decoder start *unless* I create my own vars
 142  * which inherit from the user ones, but those are utterly useless after
 143  * that first use, since they'll be detached from the ones the user can
 144  * change. So, I create them, read their values, and then destroy them.
 145  */
 146 static vlc_mutex_t kate_decoder_list_mutex = VLC_STATIC_MUTEX;
 147 static size_t kate_decoder_list_size = 0;
 148 static decoder_t **kate_decoder_list = NULL;
 149
 150 /*****************************************************************************
 151  * Local prototypes
 152  *****************************************************************************/
 153 static int  OpenDecoder   ( vlc_object_t * );
 154 static void CloseDecoder  ( vlc_object_t * );
 155 #ifdef ENABLE_PACKETIZER
 156 static int OpenPacketizer( vlc_object_t *p_this );
 157 #endif
 158
 159 static subpicture_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block );
 160 static int ProcessHeaders( decoder_t *p_dec );
 161 static subpicture_t *ProcessPacket( decoder_t *p_dec, kate_packet *p_kp,
 162                             block_t **pp_block );
 163 static subpicture_t *DecodePacket( decoder_t *p_dec, kate_packet *p_kp,
 164                             block_t *p_block );
 165 static void ParseKateComments( decoder_t * );
 166 static subpicture_t *SetupSimpleKateSPU( decoder_t *p_dec, subpicture_t *p_spu,
 167                             const kate_event *ev );
 168 static void DecSysRelease( decoder_sys_t *p_sys );
 169 static void DecSysHold( decoder_sys_t *p_sys );
 170 #ifdef HAVE_TIGER
 171 static uint32_t GetTigerColor( decoder_t *p_dec, const char *psz_prefix );
 172 static char *GetTigerString( decoder_t *p_dec, const char *psz_name );
 173 static int GetTigerInteger( decoder_t *p_dec, const char *psz_name );
 174 static double GetTigerFloat( decoder_t *p_dec, const char *psz_name );
 175 static void UpdateTigerFontColor( decoder_t *p_dec );
 176 static void UpdateTigerBackgroundColor( decoder_t *p_dec );
 177 static void UpdateTigerFontEffect( decoder_t *p_dec );
 178 static void UpdateTigerQuality( decoder_t *p_dec );
 179 static void UpdateTigerFontDesc( decoder_t *p_dec );
 180 static int TigerConfigurationCallback( vlc_object_t *p_this, const char *psz_var,
 181                                        vlc_value_t oldvar, vlc_value_t newval,
 182                                        void *p_data );
 183 static int OnConfigurationChanged( decoder_t *p_dec, const char *psz_var,
 184                                    vlc_value_t oldval, vlc_value_t newval);
 185 #endif
 186
 187 #define DEFAULT_NAME "Default"
 188 #define MAX_LINE 8192
 189
 190 /*****************************************************************************
 191  * Module descriptor.
 192  *****************************************************************************/
 193
 194 #define FORMAT_TEXT N_("Formatted Subtitles")
 195 #define FORMAT_LONGTEXT N_("Kate streams allow for text formatting. " \
 196  "VLC partly implements this, but you can choose to disable all formatting." \
 197  "Note that this has no effect is rendering via Tiger is enabled.")
 198
 199 #ifdef HAVE_TIGER
 200
 201 static const tiger_font_effect pi_font_effects[] = { tiger_font_plain, tiger_font_shadow, tiger_font_outline };
 202 static const char * const ppsz_font_effect_names[] = { N_("None"), N_("Shadow"), N_("Outline") };
 203
 204 /* nicked off freetype.c */
 205 static const int pi_color_values[] = {
 206   0x00000000, 0x00808080, 0x00C0C0C0, 0x00FFFFFF, 0x00800000,
 207   0x00FF0000, 0x00FF00FF, 0x00FFFF00, 0x00808000, 0x00008000, 0x00008080,
 208   0x0000FF00, 0x00800080, 0x00000080, 0x000000FF, 0x0000FFFF };
 209 static const char *const ppsz_color_descriptions[] = {
 210   N_("Black"), N_("Gray"), N_("Silver"), N_("White"), N_("Maroon"),
 211   N_("Red"), N_("Fuchsia"), N_("Yellow"), N_("Olive"), N_("Green"), N_("Teal"),
 212   N_("Lime"), N_("Purple"), N_("Navy"), N_("Blue"), N_("Aqua") };
 213
 214 #define TIGER_TEXT N_("Use Tiger for rendering")
 215 #define TIGER_LONGTEXT N_("Kate streams can be rendered using the Tiger library. " \
 216  "Disabling this will only render static text and bitmap based streams.")
 217
 218 #define TIGER_QUALITY_DEFAULT 1.0
 219 #define TIGER_QUALITY_TEXT N_("Rendering quality")
 220 #define TIGER_QUALITY_LONGTEXT N_("Select rendering quality, at the expense of speed. " \
 221  "0 is fastest, 1 is highest quality.")
 222
 223 #define TIGER_DEFAULT_FONT_EFFECT_DEFAULT 0
 224 #define TIGER_DEFAULT_FONT_EFFECT_TEXT N_("Default font effect")
 225 #define TIGER_DEFAULT_FONT_EFFECT_LONGTEXT N_("Add a font effect to text to improve readability " \
 226  "against different backgrounds.")
 227
 228 #define TIGER_DEFAULT_FONT_EFFECT_STRENGTH_DEFAULT 0.5
 229 #define TIGER_DEFAULT_FONT_EFFECT_STRENGTH_TEXT N_("Default font effect strength")
 230 #define TIGER_DEFAULT_FONT_EFFECT_STRENGTH_LONGTEXT N_("How pronounced to make the chosen font effect " \
 231  "(effect dependent).")
 232
 233 #define TIGER_DEFAULT_FONT_DESC_DEFAULT ""
 234 #define TIGER_DEFAULT_FONT_DESC_TEXT N_("Default font description")
 235 #define TIGER_DEFAULT_FONT_DESC_LONGTEXT N_("Which font description to use if the Kate stream " \
 236  "does not specify particular font parameters (name, size, etc) to use. " \
 237  "A blank name will let Tiger choose font parameters where appropriate.")
 238
 239 #define TIGER_DEFAULT_FONT_COLOR_DEFAULT 0x00ffffff
 240 #define TIGER_DEFAULT_FONT_COLOR_TEXT N_("Default font color")
 241 #define TIGER_DEFAULT_FONT_COLOR_LONGTEXT N_("Default font color to use if the Kate stream " \
 242  "does not specify a particular font color to use.")
 243
 244 #define TIGER_DEFAULT_FONT_ALPHA_DEFAULT 0xff
 245 #define TIGER_DEFAULT_FONT_ALPHA_TEXT N_("Default font alpha")
 246 #define TIGER_DEFAULT_FONT_ALPHA_LONGTEXT N_("Transparency of the default font color if the Kate stream " \
 247  "does not specify a particular font color to use.")
 248
 249 #define TIGER_DEFAULT_BACKGROUND_COLOR_DEFAULT 0x00ffffff
 250 #define TIGER_DEFAULT_BACKGROUND_COLOR_TEXT N_("Default background color")
 251 #define TIGER_DEFAULT_BACKGROUND_COLOR_LONGTEXT N_("Default background color if the Kate stream " \
 252  "does not specify a background color to use.")
 253
 254 #define TIGER_DEFAULT_BACKGROUND_ALPHA_DEFAULT 0
 255 #define TIGER_DEFAULT_BACKGROUND_ALPHA_TEXT N_("Default background alpha")
 256 #define TIGER_DEFAULT_BACKGROUND_ALPHA_LONGTEXT N_("Transparency of the default background color if the Kate stream " \
 257  "does not specify a particular background color to use.")
 258
 259 #endif
 260
 261 #define HELP_TEXT N_( \
 262     "Kate is a codec for text and image based overlays.\n" \
 263     "The Tiger rendering library is needed to render complex Kate streams, " \
 264     "but VLC can still render static text and image based subtitles if " \
 265     "it is not available.\n" \
 266     "Note that changing settings below will not take effect until a new stream is played. " \
 267     "This will hopefully be fixed soon." \
 268     )
 269
 270 vlc_module_begin ()
 271     set_shortname( N_("Kate"))
 272     set_description( N_("Kate overlay decoder") )
 273     set_help( HELP_TEXT )
 274     set_capability( "decoder", 50 )
 275     set_callbacks( OpenDecoder, CloseDecoder )
 276     set_category( CAT_INPUT )
 277     set_subcategory( SUBCAT_INPUT_SCODEC )
 278     add_shortcut( "kate" )
 279
 280     add_bool( "kate-formatted", true, FORMAT_TEXT, FORMAT_LONGTEXT,
 281               true )
 282
 283 #ifdef HAVE_TIGER
 284     add_bool( "kate-use-tiger", true, TIGER_TEXT, TIGER_LONGTEXT,
 285               true )
 286     add_float_with_range( "kate-tiger-quality",
 287                           TIGER_QUALITY_DEFAULT, 0.0f, 1.0f,
 288                           TIGER_QUALITY_TEXT, TIGER_QUALITY_LONGTEXT,
 289                           true )
 290
 291     set_section( N_("Tiger rendering defaults"), NULL );
 292     add_string( "kate-tiger-default-font-desc", TIGER_DEFAULT_FONT_DESC_DEFAULT,
 293                 TIGER_DEFAULT_FONT_DESC_TEXT, TIGER_DEFAULT_FONT_DESC_LONGTEXT, true);
 294     add_integer_with_range( "kate-tiger-default-font-effect",
 295                             TIGER_DEFAULT_FONT_EFFECT_DEFAULT,
 296                             0, sizeof(pi_font_effects)/sizeof(pi_font_effects[0])-1,
 297                             TIGER_DEFAULT_FONT_EFFECT_TEXT, TIGER_DEFAULT_FONT_EFFECT_LONGTEXT,
 298                             true )
 299     change_integer_list( pi_font_effects, ppsz_font_effect_names );
 300     add_float_with_range( "kate-tiger-default-font-effect-strength",
 301               TIGER_DEFAULT_FONT_EFFECT_STRENGTH_DEFAULT, 0.0f, 1.0f,
 302               TIGER_DEFAULT_FONT_EFFECT_STRENGTH_TEXT, TIGER_DEFAULT_FONT_EFFECT_STRENGTH_LONGTEXT,
 303               true )
 304     add_integer_with_range( "kate-tiger-default-font-color",
 305                             TIGER_DEFAULT_FONT_COLOR_DEFAULT, 0, 0x00ffffff,
 306                             TIGER_DEFAULT_FONT_COLOR_TEXT, TIGER_DEFAULT_FONT_COLOR_LONGTEXT,
 307                             true);
 308     change_integer_list( pi_color_values, ppsz_color_descriptions );
 309     add_integer_with_range( "kate-tiger-default-font-alpha",
 310                             TIGER_DEFAULT_FONT_ALPHA_DEFAULT, 0, 255,
 311                             TIGER_DEFAULT_FONT_ALPHA_TEXT, TIGER_DEFAULT_FONT_ALPHA_LONGTEXT,
 312                             true);
 313     add_integer_with_range( "kate-tiger-default-background-color",
 314                             TIGER_DEFAULT_BACKGROUND_COLOR_DEFAULT, 0, 0x00ffffff,
 315                             TIGER_DEFAULT_BACKGROUND_COLOR_TEXT, TIGER_DEFAULT_BACKGROUND_COLOR_LONGTEXT,
 316                             true);
 317     change_integer_list( pi_color_values, ppsz_color_descriptions );
 318     add_integer_with_range( "kate-tiger-default-background-alpha",
 319                             TIGER_DEFAULT_BACKGROUND_ALPHA_DEFAULT, 0, 255,
 320                             TIGER_DEFAULT_BACKGROUND_ALPHA_TEXT, TIGER_DEFAULT_BACKGROUND_ALPHA_LONGTEXT,
 321                             true);
 322 #endif
 323
 324 #ifdef ENABLE_PACKETIZER
 325     add_submodule ()
 326     set_description( N_("Kate text subtitles packetizer") )
 327     set_capability( "packetizer", 100 )
 328     set_callbacks( OpenPacketizer, CloseDecoder )
 329     add_shortcut( "kate" )
 330 #endif
 331
 332 vlc_module_end ()
 333
 334 /*****************************************************************************
 335  * OpenDecoder: probe the decoder and return score
 336  *****************************************************************************
 337  * Tries to launch a decoder and return score so that the interface is able
 338  * to chose.
 339  *****************************************************************************/
 340 static int OpenDecoder( vlc_object_t *p_this )
 341 {
 342     decoder_t     *p_dec = (decoder_t*)p_this;
 343     decoder_sys_t *p_sys;
 344
 345     if( p_dec->fmt_in.i_codec != VLC_CODEC_KATE )
 346     {
 347         return VLC_EGENERIC;
 348     }
 349
 350     msg_Dbg( p_dec, "kate: OpenDecoder");
 351
 352     /* Set callbacks */
 353     p_dec->pf_decode_sub = (subpicture_t *(*)(decoder_t *, block_t **))
 354         DecodeBlock;
 355     p_dec->pf_packetize    = (block_t *(*)(decoder_t *, block_t **))
 356         DecodeBlock;
 357
 358     /* Allocate the memory needed to store the decoder's structure */
 359     if( ( p_dec->p_sys = p_sys = malloc(sizeof(*p_sys)) ) == NULL )
 360         return VLC_ENOMEM;
 361
 362     vlc_mutex_init( &p_sys->lock );
 363     p_sys->i_refcount = 0;
 364     DecSysHold( p_sys );
 365
 366     /* init of p_sys */
 367 #ifdef ENABLE_PACKETIZER
 368     p_sys->b_packetizer = false;
 369 #endif
 370     p_sys->b_ready = false;
 371     p_sys->i_pts =
 372     p_sys->i_max_stop = VLC_TS_INVALID;
 373
 374     kate_comment_init( &p_sys->kc );
 375     kate_info_init( &p_sys->ki );
 376
 377     p_sys->b_has_headers = false;
 378
 379     /* retrieve options */
 380     p_sys->b_formatted = var_CreateGetBool( p_dec, "kate-formatted" );
 381
 382     vlc_mutex_lock( &kate_decoder_list_mutex );
 383
 384 #ifdef HAVE_TIGER
 385
 386     p_sys->b_use_tiger = var_CreateGetBool( p_dec, "kate-use-tiger" );
 387
 388     p_sys->p_tr = NULL;
 389
 390     /* get initial value of configuration */
 391     p_sys->i_tiger_default_font_color = GetTigerColor( p_dec, "kate-tiger-default-font" );
 392     p_sys->i_tiger_default_background_color = GetTigerColor( p_dec, "kate-tiger-default-background" );
 393     p_sys->e_tiger_default_font_effect = GetTigerInteger( p_dec, "kate-tiger-default-font-effect" );
 394     p_sys->f_tiger_default_font_effect_strength = GetTigerFloat( p_dec, "kate-tiger-default-font-effect-strength" );
 395     p_sys->psz_tiger_default_font_desc = GetTigerString( p_dec, "kate-tiger-default-font-desc" );
 396     p_sys->f_tiger_quality = GetTigerFloat( p_dec, "kate-tiger-quality" );
 397
 398     if( p_sys->b_use_tiger )
 399     {
 400         int i_ret = tiger_renderer_create( &p_sys->p_tr );
 401         if( i_ret < 0 )
 402         {
 403             msg_Warn ( p_dec, "Failed to create Tiger renderer, falling back to basic rendering" );
 404             p_sys->p_tr = NULL;
 405             p_sys->b_use_tiger = false;
 406         }
 407         else {
 408             CHECK_TIGER_RET( tiger_renderer_set_surface_clear_color( p_sys->p_tr, 1, 0, 0, 0, 0 ) );
 409
 410             UpdateTigerFontEffect( p_dec );
 411             UpdateTigerFontColor( p_dec );
 412             UpdateTigerBackgroundColor( p_dec );
 413             UpdateTigerQuality( p_dec );
 414             UpdateTigerFontDesc( p_dec );
 415         }
 416     }
 417
 418 #else
 419
 420     p_sys->b_use_tiger = false;
 421
 422 #endif
 423
 424     es_format_Init( &p_dec->fmt_out, SPU_ES, 0 );
 425
 426     /* add the decoder to the global list */
 427     decoder_t **list = realloc( kate_decoder_list, (kate_decoder_list_size+1) * sizeof( *list ));
 428     if( list )
 429     {
 430         list[ kate_decoder_list_size++ ] = p_dec;
 431         kate_decoder_list = list;
 432     }
 433
 434     vlc_mutex_unlock( &kate_decoder_list_mutex );
 435
 436     return VLC_SUCCESS;
 437 }
 438
 439 #ifdef ENABLE_PACKETIZER
 440 static int OpenPacketizer( vlc_object_t *p_this )
 441 {
 442     decoder_t *p_dec = (decoder_t*)p_this;
 443
 444     int i_ret = OpenDecoder( p_this );
 445
 446     if( i_ret == VLC_SUCCESS )
 447     {
 448         p_dec->p_sys->b_packetizer = true;
 449         p_dec->fmt_out.i_codec = VLC_CODEC_KATE;
 450     }
 451
 452     return i_ret;
 453 }
 454 #endif
 455
 456 /****************************************************************************
 457  * DecodeBlock: the whole thing
 458  ****************************************************************************
 459  * This function must be fed with kate packets.
 460  ****************************************************************************/
 461 static subpicture_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
 462 {
 463     decoder_sys_t *p_sys = p_dec->p_sys;
 464     block_t *p_block;
 465     kate_packet kp;
 466
 467     if( !pp_block || !*pp_block )
 468         return NULL;
 469
 470     p_block = *pp_block;
 471
 472     if( p_block->i_flags & (BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
 473     {
 474 #ifdef HAVE_TIGER
 475         if( p_block->i_flags & BLOCK_FLAG_DISCONTINUITY)
 476         {
 477             /* Hmm, should we wait before flushing the renderer ? I think not, but not certain... */
 478             vlc_mutex_lock( &p_sys->lock );
 479             tiger_renderer_seek( p_sys->p_tr, 0 );
 480             vlc_mutex_unlock( &p_sys->lock );
 481         }
 482 #endif
 483         p_sys->i_max_stop = VLC_TS_INVALID;
 484         block_Release( p_block );
 485         return NULL;
 486     }
 487
 488     /* Block to Kate packet */
 489     kate_packet_wrap(&kp, p_block->i_buffer, p_block->p_buffer);
 490
 491     if( !p_sys->b_has_headers )
 492     {
 493         if( ProcessHeaders( p_dec ) )
 494         {
 495             block_Release( *pp_block );
 496             return NULL;
 497         }
 498         p_sys->b_has_headers = true;
 499     }
 500
 501     return ProcessPacket( p_dec, &kp, pp_block );
 502 }
 503
 504 /*****************************************************************************
 505  * ProcessHeaders: process Kate headers.
 506  *****************************************************************************/
 507 static int ProcessHeaders( decoder_t *p_dec )
 508 {
 509     decoder_sys_t *p_sys = p_dec->p_sys;
 510     kate_packet kp;
 511
 512     unsigned pi_size[XIPH_MAX_HEADER_COUNT];
 513     void     *pp_data[XIPH_MAX_HEADER_COUNT];
 514     unsigned i_count;
 515     if( xiph_SplitHeaders( pi_size, pp_data, &i_count,
 516                            p_dec->fmt_in.i_extra, p_dec->fmt_in.p_extra) )
 517         return VLC_EGENERIC;
 518     int i_ret = VLC_SUCCESS;
 519     if( i_count < 1 )
 520     {
 521         i_ret = VLC_EGENERIC;
 522         goto end;
 523     }
 524
 525     /* Take care of the initial Kate header */
 526     kp.nbytes = pi_size[0];
 527     kp.data   = pp_data[0];
 528     i_ret = kate_decode_headerin( &p_sys->ki, &p_sys->kc, &kp );
 529     if( i_ret < 0 )
 530     {
 531         msg_Err( p_dec, "this bitstream does not contain Kate data (%d)", i_ret );
 532         goto end;
 533     }
 534
 535     msg_Dbg( p_dec, "%s %s text, granule rate %f, granule shift %d",
 536              p_sys->ki.language, p_sys->ki.category,
 537              (double)p_sys->ki.gps_numerator/p_sys->ki.gps_denominator,
 538              p_sys->ki.granule_shift);
 539
 540     /* parse all remaining header packets */
 541     for( unsigned i_headeridx = 1; i_headeridx < i_count; i_headeridx++ )
 542     {
 543         kp.nbytes = pi_size[i_headeridx];
 544         kp.data   = pp_data[i_headeridx];
 545         i_ret = kate_decode_headerin( &p_sys->ki, &p_sys->kc, &kp );
 546         if( i_ret < 0 )
 547         {
 548             msg_Err( p_dec, "Kate header %d is corrupted: %d", i_headeridx, i_ret );
 549             goto end;
 550         }
 551
 552         /* header 1 is comments */
 553         if( i_headeridx == 1 )
 554         {
 555             ParseKateComments( p_dec );
 556         }
 557     }
 558
 559 #ifdef ENABLE_PACKETIZER
 560     if( !p_sys->b_packetizer )
 561 #endif
 562     {
 563         /* We have all the headers, initialize decoder */
 564         msg_Dbg( p_dec, "we have all headers, initialize libkate for decoding" );
 565         i_ret = kate_decode_init( &p_sys->k, &p_sys->ki );
 566         if (i_ret < 0)
 567         {
 568             msg_Err( p_dec, "Kate failed to initialize for decoding: %d", i_ret );
 569             return VLC_EGENERIC;
 570         }
 571         p_sys->b_ready = true;
 572     }
 573 #ifdef ENABLE_PACKETIZER
 574     else
 575     {
 576         p_dec->fmt_out.i_extra = p_dec->fmt_in.i_extra;
 577         p_dec->fmt_out.p_extra = xrealloc( p_dec->fmt_out.p_extra,
 578                                                   p_dec->fmt_out.i_extra );
 579         memcpy( p_dec->fmt_out.p_extra,
 580                 p_dec->fmt_in.p_extra, p_dec->fmt_out.i_extra );
 581     }
 582 #endif
 583
 584 end:
 585     for( unsigned i = 0; i < i_count; i++ )
 586         free( pp_data[i] );
 587     return i_ret < 0 ? VLC_EGENERIC : VLC_SUCCESS;
 588 }
 589
 590 /*****************************************************************************
 591  * ProcessPacket: processes a kate packet.
 592  *****************************************************************************/
 593 static subpicture_t *ProcessPacket( decoder_t *p_dec, kate_packet *p_kp,
 594                             block_t **pp_block )
 595 {
 596     decoder_sys_t *p_sys = p_dec->p_sys;
 597     block_t *p_block = *pp_block;
 598     subpicture_t *p_buf = NULL;
 599
 600     /* Date management */
 601     if( p_block->i_pts > VLC_TS_INVALID && p_block->i_pts != p_sys->i_pts )
 602     {
 603         p_sys->i_pts = p_block->i_pts;
 604     }
 605
 606     *pp_block = NULL; /* To avoid being fed the same packet again */
 607
 608 #ifdef ENABLE_PACKETIZER
 609     if( p_sys->b_packetizer )
 610     {
 611         /* Date management */
 612         p_block->i_dts = p_block->i_pts = p_sys->i_pts;
 613
 614         if( p_sys->i_headers >= p_sys->i_num_headers )
 615             p_block->i_length = p_sys->i_pts - p_block->i_pts;
 616         else
 617             p_block->i_length = 0;
 618
 619         p_buf = p_block;
 620     }
 621     else
 622 #endif
 623     {
 624         p_buf = DecodePacket( p_dec, p_kp, p_block );
 625
 626         if( p_block )
 627             block_Release( p_block );
 628     }
 629
 630     return p_buf;
 631 }
 632
 633 /* nicked off blend.c */
 634 static inline void rgb_to_yuv( uint8_t *y, uint8_t *u, uint8_t *v,
 635                                int r, int g, int b )
 636 {
 637     *y = ( ( (  66 * r + 129 * g +  25 * b + 128 ) >> 8 ) + 16 );
 638     *u =   ( ( -38 * r -  74 * g + 112 * b + 128 ) >> 8 ) + 128 ;
 639     *v =   ( ( 112 * r -  94 * g -  18 * b + 128 ) >> 8 ) + 128 ;
 640 }
 641
 642 /*
 643   This retrieves the size of the video.
 644   The best case is when the original video size is known, as we can then
 645   scale images to match. In this case, since VLC autoscales, we want to
 646   return the original size and let VLC scale everything.
 647   if the original size is not known, then VLC can't resize, so we return
 648   the size of the incoming video. If sizes in the Kate stream are in
 649   relative units, it works fine. If they are absolute, you get what you
 650   ask for. Images aren't rescaled.
 651 */
 652 static void GetVideoSize( decoder_t *p_dec, int *w, int *h )
 653 {
 654     /* searching for vout to get its size is frowned upon, so we don't and
 655        use a default size if the original canvas size is not specified. */
 656     decoder_sys_t *p_sys = p_dec->p_sys;
 657     if( p_sys->ki.original_canvas_width > 0 && p_sys->ki.original_canvas_height > 0 )
 658     {
 659         *w = p_sys->ki.original_canvas_width;
 660         *h = p_sys->ki.original_canvas_height;
 661         msg_Dbg( p_dec, "original canvas %zu %zu",
 662                  p_sys->ki.original_canvas_width, p_sys->ki.original_canvas_height );
 663     }
 664     else
 665     {
 666         /* nothing, leave defaults */
 667         msg_Dbg( p_dec, "original canvas size unknown");
 668     }
 669 }
 670
 671 static void CreateKateBitmap( picture_t *pic, const kate_bitmap *bitmap )
 672 {
 673     size_t y;
 674
 675     for( y=0; y<bitmap->height; ++y )
 676     {
 677         uint8_t *dest = pic->Y_PIXELS+pic->Y_PITCH*y;
 678         const uint8_t *src = bitmap->pixels+y*bitmap->width;
 679         memcpy( dest, src, bitmap->width );
 680     }
 681 }
 682
 683 static void CreateKatePalette( video_palette_t *fmt_palette, const kate_palette *palette )
 684 {
 685     size_t n;
 686
 687     fmt_palette->i_entries = palette->ncolors;
 688     for( n=0; n<palette->ncolors; ++n )
 689     {
 690         rgb_to_yuv(
 691             &fmt_palette->palette[n][0], &fmt_palette->palette[n][1], &fmt_palette->palette[n][2],
 692             palette->colors[n].r, palette->colors[n].g, palette->colors[n].b
 693         );
 694         fmt_palette->palette[n][3] = palette->colors[n].a;
 695     }
 696 }
 697
 698 static void SetupText( decoder_t *p_dec, subpicture_t *p_spu, const kate_event *ev )
 699 {
 700     decoder_sys_t *p_sys = p_dec->p_sys;
 701
 702     if( ev->text_encoding != kate_utf8 )
 703     {
 704         msg_Warn( p_dec, "Text isn't UTF-8, unsupported, ignored" );
 705         return;
 706     }
 707
 708     switch( ev->text_markup_type )
 709     {
 710         case kate_markup_none:
 711             p_spu->p_region->psz_text = strdup( ev->text ); /* no leak, this actually gets killed by the core */
 712             break;
 713         case kate_markup_simple:
 714             if( p_sys->b_formatted )
 715             {
 716                 /* the HTML renderer expects a top level text tag pair */
 717                 char *buffer = NULL;
 718                 if( asprintf( &buffer, "<text>%s</text>", ev->text ) >= 0 )
 719                 {
 720                     p_spu->p_region->psz_html = buffer;
 721                 }
 722                 break;
 723             }
 724             /* if not formatted, we fall through */
 725         default:
 726             /* we don't know about this one, so remove markup and display as text */
 727             {
 728                 char *copy = strdup( ev->text );
 729                 size_t len0 = strlen( copy ) + 1;
 730                 kate_text_remove_markup( ev->text_encoding, copy, &len0 );
 731                 p_spu->p_region->psz_text = copy;
 732             }
 733             break;
 734     }
 735 }
 736
 737 #ifdef HAVE_TIGER
 738
 739 static void TigerDestroySubpicture( subpicture_t *p_subpic )
 740 {
 741     DecSysRelease( p_subpic->updater.p_sys->p_dec_sys );
 742     free( p_subpic->updater.p_sys );
 743 }
 744 /*
 745  * We get premultiplied alpha, but VLC doesn't expect this, so we demultiply
 746  * alpha to avoid double multiply (and thus thinner text than we should)).
 747  * Best would be to have VLC be able to handle premultiplied alpha, as it
 748  * would be faster to blend as well.
 749  *
 750  * Also, we flip color components around for big endian machines, as Tiger
 751  * outputs ARGB or ABGR (the one we selected here) in host endianness.
 752  */
 753 static void PostprocessTigerImage( plane_t *p_plane, unsigned int i_width )
 754 {
 755     PROFILE_START( tiger_renderer_postprocess );
 756     int y;
 757     for( y=0; y<p_plane->i_lines; ++y )
 758     {
 759         uint8_t *p_line = (uint8_t*)(p_plane->p_pixels + y*p_plane->i_pitch);
 760         unsigned int x;
 761         for( x=0; x<i_width; ++x )
 762         {
 763             uint8_t *p_pixel = p_line+x*4;
 764 #ifdef WORDS_BIGENDIAN
 765             uint8_t a = p_pixel[0];
 766 #else
 767             uint8_t a = p_pixel[3];
 768 #endif
 769             if( a )
 770             {
 771 #ifdef WORDS_BIGENDIAN
 772                 uint8_t tmp = p_pixel[2];
 773                 p_pixel[0] = clip_uint8_vlc((p_pixel[3] * 255 + a / 2) / a);
 774                 p_pixel[3] = a;
 775                 p_pixel[2] = clip_uint8_vlc((p_pixel[1] * 255 + a / 2) / a);
 776                 p_pixel[1] = clip_uint8_vlc((tmp * 255 + a / 2) / a);
 777 #else
 778                 p_pixel[0] = clip_uint8_vlc((p_pixel[0] * 255 + a / 2) / a);
 779                 p_pixel[1] = clip_uint8_vlc((p_pixel[1] * 255 + a / 2) / a);
 780                 p_pixel[2] = clip_uint8_vlc((p_pixel[2] * 255 + a / 2) / a);
 781 #endif
 782             }
 783             else
 784             {
 785                 p_pixel[0] = 0;
 786                 p_pixel[1] = 0;
 787                 p_pixel[2] = 0;
 788                 p_pixel[3] = 0;
 789             }
 790         }
 791     }
 792     PROFILE_STOP( tiger_renderer_postprocess );
 793 }
 794
 795 static int TigerValidateSubpicture( subpicture_t *p_subpic,
 796                                     bool b_fmt_src, const video_format_t *p_fmt_src,
 797                                     bool b_fmt_dst, const video_format_t *p_fmt_dst,
 798                                     mtime_t ts )
 799 {
 800     decoder_sys_t *p_sys = p_subpic->updater.p_sys->p_dec_sys;
 801
 802     if( b_fmt_src || b_fmt_dst )
 803         return VLC_EGENERIC;
 804
 805     PROFILE_START( TigerValidateSubpicture );
 806
 807     /* time in seconds from the start of the stream */
 808     kate_float t = (p_subpic->updater.p_sys->i_start + ts - p_subpic->i_start ) / 1000000.0f;
 809
 810     /* it is likely that the current region (if any) can be kept as is; test for this */
 811     vlc_mutex_lock( &p_sys->lock );
 812     int i_ret;
 813     if( p_sys->b_dirty || tiger_renderer_is_dirty( p_sys->p_tr ) )
 814     {
 815         i_ret = VLC_EGENERIC;
 816         goto exit;
 817     }
 818     if( tiger_renderer_update( p_sys->p_tr, t, 1 ) >= 0 &&
 819         tiger_renderer_is_dirty( p_sys->p_tr ) )
 820     {
 821         i_ret = VLC_EGENERIC;
 822         goto exit;
 823     }
 824
 825     i_ret = VLC_SUCCESS;
 826 exit:
 827     vlc_mutex_unlock( &p_sys->lock );
 828     PROFILE_STOP( TigerValidateSubpicture );
 829     return i_ret;
 830 }
 831
 832 /* Tiger renders can end up looking a bit crap since they get overlaid on top of
 833    a subsampled YUV image, so there can be a fair amount of chroma bleeding.
 834    Looks good with white though since it's all luma. Hopefully that will be the
 835    common case. */
 836 static void TigerUpdateSubpicture( subpicture_t *p_subpic,
 837                                    const video_format_t *p_fmt_src,
 838                                    const video_format_t *p_fmt_dst,
 839                                    mtime_t ts )
 840 {
 841     decoder_sys_t *p_sys = p_subpic->updater.p_sys->p_dec_sys;
 842     plane_t *p_plane;
 843     kate_float t;
 844     int i_ret;
 845
 846
 847     /* time in seconds from the start of the stream */
 848     t = (p_subpic->updater.p_sys->i_start + ts - p_subpic->i_start ) / 1000000.0f;
 849
 850     PROFILE_START( TigerUpdateSubpicture );
 851
 852     /* create a full frame region - this will also tell Tiger the size of the frame */
 853     video_format_t fmt = *p_fmt_dst;
 854     fmt.i_chroma         = VLC_CODEC_RGBA;
 855     fmt.i_bits_per_pixel = 0;
 856     fmt.i_width          =
 857     fmt.i_visible_width  = p_fmt_src->i_width;
 858     fmt.i_height         =
 859     fmt.i_visible_height = p_fmt_src->i_height;
 860     fmt.i_x_offset       = fmt.i_y_offset = 0;
 861
 862     subpicture_region_t *p_r = subpicture_region_New( &fmt );
 863     if( !p_r )
 864         return;
 865
 866     p_r->i_x = 0;
 867     p_r->i_y = 0;
 868     p_r->i_align = SUBPICTURE_ALIGN_TOP | SUBPICTURE_ALIGN_LEFT;
 869
 870     vlc_mutex_lock( &p_sys->lock );
 871
 872     p_plane = &p_r->p_picture->p[0];
 873     i_ret = tiger_renderer_set_buffer( p_sys->p_tr, p_plane->p_pixels, fmt.i_width, p_plane->i_lines, p_plane->i_pitch, 1 );
 874     if( i_ret < 0 )
 875     {
 876         goto failure;
 877     }
 878
 879     PROFILE_START( tiger_renderer_update );
 880     i_ret = tiger_renderer_update( p_sys->p_tr, t, 1 );
 881     if( i_ret < 0 )
 882     {
 883         goto failure;
 884     }
 885     PROFILE_STOP( tiger_renderer_update );
 886
 887     PROFILE_START( tiger_renderer_render );
 888     i_ret = tiger_renderer_render( p_sys->p_tr );
 889     if( i_ret < 0 )
 890     {
 891         goto failure;
 892     }
 893     PROFILE_STOP( tiger_renderer_render );
 894
 895     PostprocessTigerImage( p_plane, fmt.i_width );
 896     p_subpic->p_region = p_r;
 897     p_sys->b_dirty = false;
 898
 899     PROFILE_STOP( TigerUpdateSubpicture );
 900
 901     vlc_mutex_unlock( &p_sys->lock );
 902
 903     return;
 904
 905 failure:
 906     vlc_mutex_unlock( &p_sys->lock );
 907     subpicture_region_ChainDelete( p_r );
 908 }
 909
 910 static uint32_t GetTigerColor( decoder_t *p_dec, const char *psz_prefix )
 911 {
 912     char *psz_tmp;
 913     uint32_t i_color = 0;
 914
 915     if( asprintf( &psz_tmp, "%s-color", psz_prefix ) >= 0 )
 916     {
 917         uint32_t i_rgb = var_CreateGetInteger( p_dec, psz_tmp );
 918         var_Destroy( p_dec, psz_tmp );
 919         free( psz_tmp );
 920         i_color |= i_rgb;
 921     }
 922
 923     if( asprintf( &psz_tmp, "%s-alpha", psz_prefix ) >= 0 )
 924     {
 925         uint32_t i_alpha = var_CreateGetInteger( p_dec, psz_tmp );
 926         var_Destroy( p_dec, psz_tmp );
 927         free( psz_tmp );
 928         i_color |= (i_alpha << 24);
 929     }
 930
 931     return i_color;
 932 }
 933
 934 static char *GetTigerString( decoder_t *p_dec, const char *psz_name )
 935 {
 936     char *psz_value = var_CreateGetString( p_dec, psz_name );
 937     if( psz_value)
 938     {
 939         psz_value = strdup( psz_value );
 940     }
 941     var_Destroy( p_dec, psz_name );
 942     return psz_value;
 943 }
 944
 945 static int GetTigerInteger( decoder_t *p_dec, const char *psz_name )
 946 {
 947     int i_value = var_CreateGetInteger( p_dec, psz_name );
 948     var_Destroy( p_dec, psz_name );
 949     return i_value;
 950 }
 951
 952 static double GetTigerFloat( decoder_t *p_dec, const char *psz_name )
 953 {
 954     double f_value = var_CreateGetFloat( p_dec, psz_name );
 955     var_Destroy( p_dec, psz_name );
 956     return f_value;
 957 }
 958
 959 static void UpdateTigerQuality( decoder_t *p_dec )
 960 {
 961     decoder_sys_t *p_sys = (decoder_sys_t*)p_dec->p_sys;
 962     CHECK_TIGER_RET( tiger_renderer_set_quality( p_sys->p_tr, p_sys->f_tiger_quality ) );
 963     p_sys->b_dirty = true;
 964 }
 965
 966 static void UpdateTigerFontDesc( decoder_t *p_dec )
 967 {
 968     decoder_sys_t *p_sys = (decoder_sys_t*)p_dec->p_sys;
 969     CHECK_TIGER_RET( tiger_renderer_set_default_font_description( p_sys->p_tr, p_sys->psz_tiger_default_font_desc ) );
 970     p_sys->b_dirty = true;
 971 }
 972
 973 static void UpdateTigerFontColor( decoder_t *p_dec )
 974 {
 975     decoder_sys_t *p_sys = (decoder_sys_t*)p_dec->p_sys;
 976     double f_a = ((p_sys->i_tiger_default_font_color >> 24) & 0xff) / 255.0;
 977     double f_r = ((p_sys->i_tiger_default_font_color >> 16) & 0xff) / 255.0;
 978     double f_g = ((p_sys->i_tiger_default_font_color >> 8) & 0xff) / 255.0;
 979     double f_b = (p_sys->i_tiger_default_font_color & 0xff) / 255.0;
 980     CHECK_TIGER_RET( tiger_renderer_set_default_font_color( p_sys->p_tr, f_r, f_g, f_b, f_a ) );
 981     p_sys->b_dirty = true;
 982 }
 983
 984 static void UpdateTigerBackgroundColor( decoder_t *p_dec )
 985 {
 986     decoder_sys_t *p_sys = (decoder_sys_t*)p_dec->p_sys;
 987     double f_a = ((p_sys->i_tiger_default_background_color >> 24) & 0xff) / 255.0;
 988     double f_r = ((p_sys->i_tiger_default_background_color >> 16) & 0xff) / 255.0;
 989     double f_g = ((p_sys->i_tiger_default_background_color >> 8) & 0xff) / 255.0;
 990     double f_b = (p_sys->i_tiger_default_background_color & 0xff) / 255.0;
 991     CHECK_TIGER_RET( tiger_renderer_set_default_background_fill_color( p_sys->p_tr, f_r, f_g, f_b, f_a ) );
 992     p_sys->b_dirty = true;
 993 }
 994
 995 static void UpdateTigerFontEffect( decoder_t *p_dec )
 996 {
 997     decoder_sys_t *p_sys = (decoder_sys_t*)p_dec->p_sys;
 998     CHECK_TIGER_RET( tiger_renderer_set_default_font_effect( p_sys->p_tr,
 999                                                              p_sys->e_tiger_default_font_effect,
1000                                                              p_sys->f_tiger_default_font_effect_strength ) );
1001     p_sys->b_dirty = true;
1002 }
1003
1004 static int OnConfigurationChanged( decoder_t *p_dec, const char *psz_var,
1005                                    vlc_value_t oldval, vlc_value_t newval )
1006 {
1007     decoder_sys_t *p_sys = (decoder_sys_t*)p_dec->p_sys;
1008
1009     VLC_UNUSED( oldval );
1010
1011     vlc_mutex_lock( &p_sys->lock );
1012
1013     msg_Dbg( p_dec, "OnConfigurationChanged: %s", psz_var );
1014
1015     if( !p_sys->b_use_tiger || !p_sys->p_tr )
1016     {
1017         vlc_mutex_unlock( &p_sys->lock );
1018         return VLC_SUCCESS;
1019     }
1020
1021 #define TEST_TIGER_VAR( name ) \
1022     if( !strcmp( name, psz_var ) )
1023
1024     TEST_TIGER_VAR( "kate-tiger-quality" )
1025     {
1026         p_sys->f_tiger_quality = newval.f_float;
1027         UpdateTigerQuality( p_dec );
1028     }
1029
1030     TEST_TIGER_VAR( "kate-tiger-default-font-desc" )
1031     {
1032         if( p_sys->psz_tiger_default_font_desc )
1033         {
1034             free( p_sys->psz_tiger_default_font_desc );
1035             p_sys->psz_tiger_default_font_desc = NULL;
1036         }
1037         if( newval.psz_string )
1038         {
1039             p_sys->psz_tiger_default_font_desc = strdup( newval.psz_string );
1040         }
1041         UpdateTigerFontDesc( p_dec );
1042     }
1043
1044     TEST_TIGER_VAR( "kate-tiger-default-font-color" )
1045     {
1046         p_sys->i_tiger_default_font_color = (p_sys->i_tiger_default_font_color & 0xff00000000) | newval.i_int;
1047         UpdateTigerFontColor( p_dec );
1048     }
1049
1050     TEST_TIGER_VAR( "kate-tiger-default-font-alpha" )
1051     {
1052         p_sys->i_tiger_default_font_color = (p_sys->i_tiger_default_font_color & 0x00ffffff) | (newval.i_int<<24);
1053         UpdateTigerFontColor( p_dec );
1054     }
1055
1056     TEST_TIGER_VAR( "kate-tiger-default-background-color" )
1057     {
1058         p_sys->i_tiger_default_background_color = (p_sys->i_tiger_default_background_color & 0xff00000000) | newval.i_int;
1059         UpdateTigerBackgroundColor( p_dec );
1060     }
1061
1062     TEST_TIGER_VAR( "kate-tiger-default-background-alpha" )
1063     {
1064         p_sys->i_tiger_default_background_color = (p_sys->i_tiger_default_background_color & 0x00ffffff) | (newval.i_int<<24);
1065         UpdateTigerBackgroundColor( p_dec );
1066     }
1067
1068     TEST_TIGER_VAR( "kate-tiger-default-font-effect" )
1069     {
1070         p_sys->e_tiger_default_font_effect = (tiger_font_effect)newval.i_int;
1071         UpdateTigerFontEffect( p_dec );
1072     }
1073
1074     TEST_TIGER_VAR( "kate-tiger-default-font-effect-strength" )
1075     {
1076         p_sys->f_tiger_default_font_effect_strength = newval.f_float;
1077         UpdateTigerFontEffect( p_dec );
1078     }
1079
1080 #undef TEST_TIGER_VAR
1081
1082     vlc_mutex_unlock( &p_sys->lock );
1083
1084     return VLC_SUCCESS;
1085 }
1086
1087 static int TigerConfigurationCallback( vlc_object_t *p_this, const char *psz_var,
1088                                        vlc_value_t oldval, vlc_value_t newval,
1089                                        void *p_data )
1090 {
1091     size_t i_idx;
1092
1093     VLC_UNUSED( p_this );
1094     VLC_UNUSED( oldval );
1095     VLC_UNUSED( newval );
1096     VLC_UNUSED( p_data );
1097
1098     vlc_mutex_lock( &kate_decoder_list_mutex );
1099
1100     /* Update all existing decoders from the global user prefs */
1101     for( i_idx = 0; i_idx < kate_decoder_list_size; i_idx++ )
1102     {
1103         decoder_t *p_dec = kate_decoder_list[ i_idx ];
1104         OnConfigurationChanged( p_dec, psz_var, oldval, newval );
1105     }
1106
1107     vlc_mutex_unlock( &kate_decoder_list_mutex );
1108
1109     return VLC_SUCCESS;
1110 }
1111
1112 #endif
1113
1114 /*****************************************************************************
1115  * DecodePacket: decodes a Kate packet.
1116  *****************************************************************************/
1117 static subpicture_t *DecodePacket( decoder_t *p_dec, kate_packet *p_kp, block_t *p_block )
1118 {
1119     decoder_sys_t *p_sys = p_dec->p_sys;
1120     const kate_event *ev = NULL;
1121     subpicture_t *p_spu = NULL;
1122     int i_ret;
1123
1124     if( !p_sys->b_ready )
1125     {
1126         msg_Err( p_dec, "Cannot decode Kate packet, decoder not initialized" );
1127         return NULL;
1128     }
1129
1130     i_ret = kate_decode_packetin( &p_sys->k, p_kp );
1131     if( i_ret < 0 )
1132     {
1133         msg_Err( p_dec, "Kate failed to decode packet: %d", i_ret );
1134         return NULL;
1135     }
1136
1137     i_ret = kate_decode_eventout( &p_sys->k, &ev );
1138     if( i_ret < 0 )
1139     {
1140         msg_Err( p_dec, "Kate failed to retrieve event: %d", i_ret );
1141         return NULL;
1142     }
1143     if( i_ret > 0 )
1144     {
1145         /* no event to go with this packet, this is normal */
1146         return NULL;
1147     }
1148
1149     /* we have an event */
1150
1151     /* Get a new spu */
1152     subpicture_updater_sys_t *p_spu_sys = NULL;
1153     if( p_sys->b_use_tiger)
1154     {
1155         p_spu_sys = malloc( sizeof(*p_spu_sys) );
1156         if( !p_spu_sys )
1157             return NULL;
1158     }
1159     subpicture_updater_t updater = {
1160 #ifdef HAVE_TIGER
1161         .pf_validate = TigerValidateSubpicture,
1162         .pf_update   = TigerUpdateSubpicture,
1163         .pf_destroy  = TigerDestroySubpicture,
1164 #endif
1165         .p_sys       = p_spu_sys,
1166     };
1167     p_spu = decoder_NewSubpicture( p_dec, p_sys->b_use_tiger ? &updater : NULL );
1168     if( !p_spu )
1169     {
1170         free( p_spu_sys );
1171         /* this will happen for lyrics as there is no vout - so no error */
1172         /* msg_Err( p_dec, "Failed to allocate spu buffer" ); */
1173         return NULL;
1174     }
1175
1176     p_spu->i_start = p_block->i_pts;
1177     p_spu->i_stop = p_block->i_pts + INT64_C(1000000)*ev->duration*p_sys->ki.gps_denominator/p_sys->ki.gps_numerator;
1178     p_spu->b_ephemer = false;
1179     p_spu->b_absolute = false;
1180
1181 #ifdef HAVE_TIGER
1182     if( p_sys->b_use_tiger)
1183     {
1184         p_spu_sys->p_dec_sys = p_sys;
1185         p_spu_sys->i_start   = p_block->i_pts;
1186         DecSysHold( p_sys );
1187
1188         p_spu->i_stop = __MAX( p_sys->i_max_stop, p_spu->i_stop );
1189         p_spu->b_ephemer = true;
1190         p_spu->b_absolute = true;
1191
1192         /* add the event to tiger */
1193         vlc_mutex_lock( &p_sys->lock );
1194         CHECK_TIGER_RET( tiger_renderer_add_event( p_sys->p_tr, ev->ki, ev ) );
1195         vlc_mutex_unlock( &p_sys->lock );
1196     }
1197     else
1198 #endif
1199     {
1200         p_spu = SetupSimpleKateSPU( p_dec, p_spu, ev );
1201     }
1202
1203     return p_spu;
1204 }
1205
1206 /*****************************************************************************
1207  * SetupSimpleKateSPU: creates text/bitmap regions where appropriate
1208  *****************************************************************************/
1209 static subpicture_t *SetupSimpleKateSPU( decoder_t *p_dec, subpicture_t *p_spu,
1210                                          const kate_event *ev )
1211 {
1212     decoder_sys_t *p_sys = p_dec->p_sys;
1213     video_format_t fmt;
1214     subpicture_region_t *p_bitmap_region = NULL;
1215     video_palette_t palette;
1216     kate_tracker kin;
1217     bool b_tracker_valid = false;
1218     int i_ret;
1219
1220     /* these may be 0 for "not specified" */
1221     p_spu->i_original_picture_width = p_sys->ki.original_canvas_width;
1222     p_spu->i_original_picture_height = p_sys->ki.original_canvas_height;
1223
1224     /* Create a new subpicture region */
1225     memset( &fmt, 0, sizeof(video_format_t) );
1226
1227     if (p_sys->b_formatted)
1228     {
1229         i_ret = kate_tracker_init( &kin, &p_sys->ki, ev );
1230         if( i_ret < 0)
1231         {
1232             msg_Err( p_dec, "failed to initialize kate tracker, event will be unformatted: %d", i_ret );
1233         }
1234         else
1235         {
1236             int w = 720, h = 576; /* give sensible defaults just in case we fail to get the actual size */
1237             GetVideoSize(p_dec, &w, &h);
1238             i_ret = kate_tracker_update(&kin, 0, w, h, 0, 0, w, h);
1239             if( i_ret < 0)
1240             {
1241                 kate_tracker_clear(&kin);
1242                 msg_Err( p_dec, "failed to update kate tracker, event will be unformatted: %d", i_ret );
1243             }
1244             else
1245             {
1246                 // TODO: parse tracker and set style, init fmt
1247                 b_tracker_valid = true;
1248             }
1249         }
1250     }
1251
1252     if (ev->bitmap && ev->bitmap->type==kate_bitmap_type_paletted && ev->palette) {
1253
1254         /* create a separate region for the bitmap */
1255         memset( &fmt, 0, sizeof(video_format_t) );
1256         fmt.i_chroma = VLC_CODEC_YUVP;
1257         fmt.i_width = fmt.i_visible_width = ev->bitmap->width;
1258         fmt.i_height = fmt.i_visible_height = ev->bitmap->height;
1259         fmt.i_x_offset = fmt.i_y_offset = 0;
1260         fmt.p_palette = &palette;
1261         CreateKatePalette( fmt.p_palette, ev->palette );
1262
1263         p_bitmap_region = subpicture_region_New( &fmt );
1264         if( !p_bitmap_region )
1265         {
1266             msg_Err( p_dec, "cannot allocate SPU region" );
1267             decoder_DeleteSubpicture( p_dec, p_spu );
1268             return NULL;
1269         }
1270
1271         /* create the bitmap */
1272         CreateKateBitmap( p_bitmap_region->p_picture, ev->bitmap );
1273
1274         msg_Dbg(p_dec, "Created bitmap, %zux%zu, %zu colors", ev->bitmap->width, ev->bitmap->height, ev->palette->ncolors);
1275     }
1276
1277     /* text region */
1278     fmt.i_chroma = VLC_CODEC_TEXT;
1279     fmt.i_sar_num = 0;
1280     fmt.i_sar_den = 1;
1281     fmt.i_width = fmt.i_height = 0;
1282     fmt.i_x_offset = fmt.i_y_offset = 0;
1283     p_spu->p_region = subpicture_region_New( &fmt );
1284     if( !p_spu->p_region )
1285     {
1286         msg_Err( p_dec, "cannot allocate SPU region" );
1287         decoder_DeleteSubpicture( p_dec, p_spu );
1288         return NULL;
1289     }
1290
1291     SetupText( p_dec, p_spu, ev );
1292
1293     /* default positioning */
1294     p_spu->p_region->i_align = SUBPICTURE_ALIGN_BOTTOM;
1295     if (p_bitmap_region)
1296     {
1297         p_bitmap_region->i_align = SUBPICTURE_ALIGN_BOTTOM;
1298     }
1299     p_spu->p_region->i_x = 0;
1300     p_spu->p_region->i_y = 10;
1301
1302     /* override if tracker info present */
1303     if (b_tracker_valid)
1304     {
1305         if (kin.has.region)
1306         {
1307             p_spu->p_region->i_x = kin.region_x;
1308             p_spu->p_region->i_y = kin.region_y;
1309             if (p_bitmap_region)
1310             {
1311                 p_bitmap_region->i_x = kin.region_x;
1312                 p_bitmap_region->i_y = kin.region_y;
1313             }
1314             p_spu->b_absolute = true;
1315         }
1316
1317         kate_tracker_clear(&kin);
1318     }
1319
1320     /* if we have a bitmap, chain it before the text */
1321     if (p_bitmap_region)
1322     {
1323         p_bitmap_region->p_next = p_spu->p_region;
1324         p_spu->p_region = p_bitmap_region;
1325     }
1326
1327     return p_spu;
1328 }
1329
1330 /*****************************************************************************
1331  * ParseKateComments:
1332  *****************************************************************************/
1333 static void ParseKateComments( decoder_t *p_dec )
1334 {
1335     char *psz_name, *psz_value, *psz_comment;
1336     int i = 0;
1337
1338     while ( i < p_dec->p_sys->kc.comments )
1339     {
1340         psz_comment = strdup( p_dec->p_sys->kc.user_comments[i] );
1341         if( !psz_comment )
1342             break;
1343         psz_name = psz_comment;
1344         psz_value = strchr( psz_comment, '=' );
1345         if( psz_value )
1346         {
1347             *psz_value = '\0';
1348             psz_value++;
1349
1350             if( !p_dec->p_description )
1351                 p_dec->p_description = vlc_meta_New();
1352             if( p_dec->p_description )
1353                 vlc_meta_AddExtra( p_dec->p_description, psz_name, psz_value );
1354         }
1355         free( psz_comment );
1356         i++;
1357     }
1358 }
1359
1360 /*****************************************************************************
1361  * CloseDecoder: clean up the decoder
1362  *****************************************************************************/
1363 static void CloseDecoder( vlc_object_t *p_this )
1364 {
1365     decoder_t *p_dec = (decoder_t *)p_this;
1366     size_t     i_index;
1367
1368     /* remove the decoder from the global list */
1369     vlc_mutex_lock( &kate_decoder_list_mutex );
1370     for( i_index = 0; i_index < kate_decoder_list_size; i_index++ )
1371     {
1372         if( kate_decoder_list[ i_index ] == p_dec )
1373         {
1374             kate_decoder_list[ i_index ] = kate_decoder_list[ --kate_decoder_list_size ];
1375             break;
1376         }
1377     }
1378     vlc_mutex_unlock( &kate_decoder_list_mutex );
1379
1380     msg_Dbg( p_dec, "Closing Kate decoder" );
1381     DecSysRelease( p_dec->p_sys );
1382 }
1383
1384 static void DecSysHold( decoder_sys_t *p_sys )
1385 {
1386     vlc_mutex_lock( &p_sys->lock );
1387     p_sys->i_refcount++;
1388     vlc_mutex_unlock( &p_sys->lock );
1389 }
1390
1391 static void DecSysRelease( decoder_sys_t *p_sys )
1392 {
1393     vlc_mutex_lock( &p_sys->lock );
1394     p_sys->i_refcount--;
1395     if( p_sys->i_refcount > 0)
1396     {
1397         vlc_mutex_unlock( &p_sys->lock );
1398         return;
1399     }
1400
1401     vlc_mutex_unlock( &p_sys->lock );
1402     vlc_mutex_destroy( &p_sys->lock );
1403
1404 #ifdef HAVE_TIGER
1405     if( p_sys->p_tr )
1406         tiger_renderer_destroy( p_sys->p_tr );
1407     free( p_sys->psz_tiger_default_font_desc );
1408 #endif
1409
1410     if (p_sys->b_ready)
1411         kate_clear( &p_sys->k );
1412     kate_info_clear( &p_sys->ki );
1413     kate_comment_clear( &p_sys->kc );
1414
1415     free( p_sys );
1416 }
1417