开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
kate.c
资源名称：vlc-1.0.5.zip　[点击查看]
上传用户：kjfoods
上传日期：2020-07-06
资源大小：29949k
文件大小：50k
源码类别：

midi

开发平台：

Unix_Linux

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