?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Qt: synchronization: subtitles duration parameter
[vlc/vlc-skelet.git] / modules / codec / kate.c
blob49177da9c82947b1df87c1fbe8af3759e09fa506
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
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 #else
418
419 p_sys->b_use_tiger = false;
420
421 #endif
422
423 es_format_Init( &p_dec->fmt_out, SPU_ES, 0 );
424
425 /* add the decoder to the global list */
426 decoder_t **list = realloc( kate_decoder_list, (kate_decoder_list_size+1) * sizeof( *list ));
427 if( list )
428 {
429 list[ kate_decoder_list_size++ ] = p_dec;
430 kate_decoder_list = list;
431 }
432
433 vlc_mutex_unlock( &kate_decoder_list_mutex );
434
435 return VLC_SUCCESS;
436 }
437
438 #ifdef ENABLE_PACKETIZER
439 static int OpenPacketizer( vlc_object_t *p_this )
440 {
441 decoder_t *p_dec = (decoder_t*)p_this;
442
443 int i_ret = OpenDecoder( p_this );
444
445 if( i_ret == VLC_SUCCESS )
446 {
447 p_dec->p_sys->b_packetizer = true;
448 p_dec->fmt_out.i_codec = VLC_CODEC_KATE;
449 }
450
451 return i_ret;
452 }
453 #endif
454
455 /****************************************************************************
456 * DecodeBlock: the whole thing
457 ****************************************************************************
458 * This function must be fed with kate packets.
459 ****************************************************************************/
460 static subpicture_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
461 {
462 decoder_sys_t *p_sys = p_dec->p_sys;
463 block_t *p_block;
464 kate_packet kp;
465
466 if( !pp_block || !*pp_block )
467 return NULL;
468
469 p_block = *pp_block;
470
471 if( p_block->i_flags & (BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
472 {
473 #ifdef HAVE_TIGER
474 if( p_block->i_flags & BLOCK_FLAG_DISCONTINUITY)
475 {
476 /* Hmm, should we wait before flushing the renderer ? I think not, but not certain... */
477 vlc_mutex_lock( &p_sys->lock );
478 tiger_renderer_seek( p_sys->p_tr, 0 );
479 vlc_mutex_unlock( &p_sys->lock );
480 }
481 #endif
482 p_sys->i_max_stop = VLC_TS_INVALID;
483 block_Release( p_block );
484 return NULL;
485 }
486
487 /* Block to Kate packet */
488 kate_packet_wrap(&kp, p_block->i_buffer, p_block->p_buffer);
489
490 if( !p_sys->b_has_headers )
491 {
492 if( ProcessHeaders( p_dec ) )
493 {
494 block_Release( *pp_block );
495 return NULL;
496 }
497 p_sys->b_has_headers = true;
498 }
499
500 return ProcessPacket( p_dec, &kp, pp_block );
501 }
502
503 /*****************************************************************************
504 * ProcessHeaders: process Kate headers.
505 *****************************************************************************/
506 static int ProcessHeaders( decoder_t *p_dec )
507 {
508 decoder_sys_t *p_sys = p_dec->p_sys;
509 kate_packet kp;
510
511 unsigned pi_size[XIPH_MAX_HEADER_COUNT];
512 void *pp_data[XIPH_MAX_HEADER_COUNT];
513 unsigned i_count;
514 if( xiph_SplitHeaders( pi_size, pp_data, &i_count,
515 p_dec->fmt_in.i_extra, p_dec->fmt_in.p_extra) )
516 return VLC_EGENERIC;
517 int i_ret = VLC_SUCCESS;
518 if( i_count < 1 )
519 {
520 i_ret = VLC_EGENERIC;
521 goto end;
522 }
523
524 /* Take care of the initial Kate header */
525 kp.nbytes = pi_size[0];
526 kp.data = pp_data[0];
527 i_ret = kate_decode_headerin( &p_sys->ki, &p_sys->kc, &kp );
528 if( i_ret < 0 )
529 {
530 msg_Err( p_dec, "this bitstream does not contain Kate data (%d)", i_ret );
531 goto end;
532 }
533
534 msg_Dbg( p_dec, "%s %s text, granule rate %f, granule shift %d",
535 p_sys->ki.language, p_sys->ki.category,
536 (double)p_sys->ki.gps_numerator/p_sys->ki.gps_denominator,
537 p_sys->ki.granule_shift);
538
539 /* parse all remaining header packets */
540 for( unsigned i_headeridx = 1; i_headeridx < i_count; i_headeridx++ )
541 {
542 kp.nbytes = pi_size[i_headeridx];
543 kp.data = pp_data[i_headeridx];
544 i_ret = kate_decode_headerin( &p_sys->ki, &p_sys->kc, &kp );
545 if( i_ret < 0 )
546 {
547 msg_Err( p_dec, "Kate header %d is corrupted: %d", i_headeridx, i_ret );
548 goto end;
549 }
550
551 /* header 1 is comments */
552 if( i_headeridx == 1 )
553 {
554 ParseKateComments( p_dec );
555 }
556 }
557
558 #ifdef ENABLE_PACKETIZER
559 if( !p_sys->b_packetizer )
560 #endif
561 {
562 /* We have all the headers, initialize decoder */
563 msg_Dbg( p_dec, "we have all headers, initialize libkate for decoding" );
564 i_ret = kate_decode_init( &p_sys->k, &p_sys->ki );
565 if (i_ret < 0)
566 {
567 msg_Err( p_dec, "Kate failed to initialize for decoding: %d", i_ret );
568 return VLC_EGENERIC;
569 }
570 p_sys->b_ready = true;
571 }
572 #ifdef ENABLE_PACKETIZER
573 else
574 {
575 p_dec->fmt_out.i_extra = p_dec->fmt_in.i_extra;
576 p_dec->fmt_out.p_extra = xrealloc( p_dec->fmt_out.p_extra,
577 p_dec->fmt_out.i_extra );
578 memcpy( p_dec->fmt_out.p_extra,
579 p_dec->fmt_in.p_extra, p_dec->fmt_out.i_extra );
580 }
581 #endif
582
583 end:
584 for( unsigned i = 0; i < i_count; i++ )
585 free( pp_data[i] );
586 return i_ret < 0 ? VLC_EGENERIC : VLC_SUCCESS;
587 }
588
589 /*****************************************************************************
590 * ProcessPacket: processes a kate packet.
591 *****************************************************************************/
592 static subpicture_t *ProcessPacket( decoder_t *p_dec, kate_packet *p_kp,
593 block_t **pp_block )
594 {
595 decoder_sys_t *p_sys = p_dec->p_sys;
596 block_t *p_block = *pp_block;
597 subpicture_t *p_buf = NULL;
598
599 /* Date management */
600 if( p_block->i_pts > VLC_TS_INVALID && p_block->i_pts != p_sys->i_pts )
601 {
602 p_sys->i_pts = p_block->i_pts;
603 }
604
605 *pp_block = NULL; /* To avoid being fed the same packet again */
606
607 #ifdef ENABLE_PACKETIZER
608 if( p_sys->b_packetizer )
609 {
610 /* Date management */
611 p_block->i_dts = p_block->i_pts = p_sys->i_pts;
612
613 if( p_sys->i_headers >= p_sys->i_num_headers )
614 p_block->i_length = p_sys->i_pts - p_block->i_pts;
615 else
616 p_block->i_length = 0;
617
618 p_buf = p_block;
619 }
620 else
621 #endif
622 {
623 p_buf = DecodePacket( p_dec, p_kp, p_block );
624
625 if( p_block )
626 block_Release( p_block );
627 }
628
629 return p_buf;
630 }
631
632 /* nicked off blend.c */
633 static inline void rgb_to_yuv( uint8_t *y, uint8_t *u, uint8_t *v,
634 int r, int g, int b )
635 {
636 *y = ( ( ( 66 * r + 129 * g + 25 * b + 128 ) >> 8 ) + 16 );
637 *u = ( ( -38 * r - 74 * g + 112 * b + 128 ) >> 8 ) + 128 ;
638 *v = ( ( 112 * r - 94 * g - 18 * b + 128 ) >> 8 ) + 128 ;
639 }
640
641 /*
642 This retrieves the size of the video.
643 The best case is when the original video size is known, as we can then
644 scale images to match. In this case, since VLC autoscales, we want to
645 return the original size and let VLC scale everything.
646 if the original size is not known, then VLC can't resize, so we return
647 the size of the incoming video. If sizes in the Kate stream are in
648 relative units, it works fine. If they are absolute, you get what you
649 ask for. Images aren't rescaled.
650 */
651 static void GetVideoSize( decoder_t *p_dec, int *w, int *h )
652 {
653 /* searching for vout to get its size is frowned upon, so we don't and
654 use a default size if the original canvas size is not specified. */
655 decoder_sys_t *p_sys = p_dec->p_sys;
656 if( p_sys->ki.original_canvas_width > 0 && p_sys->ki.original_canvas_height > 0 )
657 {
658 *w = p_sys->ki.original_canvas_width;
659 *h = p_sys->ki.original_canvas_height;
660 msg_Dbg( p_dec, "original canvas %zu %zu",
661 p_sys->ki.original_canvas_width, p_sys->ki.original_canvas_height );
662 }
663 else
664 {
665 /* nothing, leave defaults */
666 msg_Dbg( p_dec, "original canvas size unknown");
667 }
668 }
669
670 static void CreateKateBitmap( picture_t *pic, const kate_bitmap *bitmap )
671 {
672 size_t y;
673
674 for( y=0; y<bitmap->height; ++y )
675 {
676 uint8_t *dest = pic->Y_PIXELS+pic->Y_PITCH*y;
677 const uint8_t *src = bitmap->pixels+y*bitmap->width;
678 memcpy( dest, src, bitmap->width );
679 }
680 }
681
682 static void CreateKatePalette( video_palette_t *fmt_palette, const kate_palette *palette )
683 {
684 size_t n;
685
686 fmt_palette->i_entries = palette->ncolors;
687 for( n=0; n<palette->ncolors; ++n )
688 {
689 rgb_to_yuv(
690 &fmt_palette->palette[n][0], &fmt_palette->palette[n][1], &fmt_palette->palette[n][2],
691 palette->colors[n].r, palette->colors[n].g, palette->colors[n].b
692 );
693 fmt_palette->palette[n][3] = palette->colors[n].a;
694 }
695 }
696
697 static void SetupText( decoder_t *p_dec, subpicture_t *p_spu, const kate_event *ev )
698 {
699 decoder_sys_t *p_sys = p_dec->p_sys;
700
701 if( ev->text_encoding != kate_utf8 )
702 {
703 msg_Warn( p_dec, "Text isn't UTF-8, unsupported, ignored" );
704 return;
705 }
706
707 switch( ev->text_markup_type )
708 {
709 case kate_markup_none:
710 p_spu->p_region->psz_text = strdup( ev->text ); /* no leak, this actually gets killed by the core */
711 break;
712 case kate_markup_simple:
713 if( p_sys->b_formatted )
714 {
715 /* the HTML renderer expects a top level text tag pair */
716 char *buffer = NULL;
717 if( asprintf( &buffer, "<text>%s</text>", ev->text ) >= 0 )
718 {
719 p_spu->p_region->psz_html = buffer;
720 }
721 break;
722 }
723 /* if not formatted, we fall through */
724 default:
725 /* we don't know about this one, so remove markup and display as text */
726 {
727 char *copy = strdup( ev->text );
728 size_t len0 = strlen( copy ) + 1;
729 kate_text_remove_markup( ev->text_encoding, copy, &len0 );
730 p_spu->p_region->psz_text = copy;
731 }
732 break;
733 }
734 }
735
736 #ifdef HAVE_TIGER
737
738 static void TigerDestroySubpicture( subpicture_t *p_subpic )
739 {
740 DecSysRelease( p_subpic->updater.p_sys->p_dec_sys );
741 free( p_subpic->updater.p_sys );
742 }
743 /*
744 * We get premultiplied alpha, but VLC doesn't expect this, so we demultiply
745 * alpha to avoid double multiply (and thus thinner text than we should)).
746 * Best would be to have VLC be able to handle premultiplied alpha, as it
747 * would be faster to blend as well.
748 *
749 * Also, we flip color components around for big endian machines, as Tiger
750 * outputs ARGB or ABGR (the one we selected here) in host endianness.
751 */
752 static void PostprocessTigerImage( plane_t *p_plane, unsigned int i_width )
753 {
754 PROFILE_START( tiger_renderer_postprocess );
755 int y;
756 for( y=0; y<p_plane->i_lines; ++y )
757 {
758 uint8_t *p_line = (uint8_t*)(p_plane->p_pixels + y*p_plane->i_pitch);
759 unsigned int x;
760 for( x=0; x<i_width; ++x )
761 {
762 uint8_t *p_pixel = p_line+x*4;
763 #ifdef WORDS_BIGENDIAN
764 uint8_t a = p_pixel[0];
765 #else
766 uint8_t a = p_pixel[3];
767 #endif
768 if( a )
769 {
770 #ifdef WORDS_BIGENDIAN
771 uint8_t tmp = p_pixel[2];
772 p_pixel[0] = clip_uint8_vlc((p_pixel[3] * 255 + a / 2) / a);
773 p_pixel[3] = a;
774 p_pixel[2] = clip_uint8_vlc((p_pixel[1] * 255 + a / 2) / a);
775 p_pixel[1] = clip_uint8_vlc((tmp * 255 + a / 2) / a);
776 #else
777 p_pixel[0] = clip_uint8_vlc((p_pixel[0] * 255 + a / 2) / a);
778 p_pixel[1] = clip_uint8_vlc((p_pixel[1] * 255 + a / 2) / a);
779 p_pixel[2] = clip_uint8_vlc((p_pixel[2] * 255 + a / 2) / a);
780 #endif
781 }
782 else
783 {
784 p_pixel[0] = 0;
785 p_pixel[1] = 0;
786 p_pixel[2] = 0;
787 p_pixel[3] = 0;
788 }
789 }
790 }
791 PROFILE_STOP( tiger_renderer_postprocess );
792 }
793
794 static int TigerValidateSubpicture( subpicture_t *p_subpic,
795 bool b_fmt_src, const video_format_t *p_fmt_src,
796 bool b_fmt_dst, const video_format_t *p_fmt_dst,
797 mtime_t ts )
798 {
799 decoder_sys_t *p_sys = p_subpic->updater.p_sys->p_dec_sys;
800
801 if( b_fmt_src || b_fmt_dst )
802 return VLC_EGENERIC;
803
804 PROFILE_START( TigerValidateSubpicture );
805
806 /* time in seconds from the start of the stream */
807 kate_float t = (p_subpic->updater.p_sys->i_start + ts - p_subpic->i_start ) / 1000000.0f;
808
809 /* it is likely that the current region (if any) can be kept as is; test for this */
810 vlc_mutex_lock( &p_sys->lock );
811 int i_ret;
812 if( p_sys->b_dirty || tiger_renderer_is_dirty( p_sys->p_tr ) )
813 {
814 i_ret = VLC_EGENERIC;
815 goto exit;
816 }
817 if( tiger_renderer_update( p_sys->p_tr, t, 1 ) >= 0 &&
818 tiger_renderer_is_dirty( p_sys->p_tr ) )
819 {
820 i_ret = VLC_EGENERIC;
821 goto exit;
822 }
823
824 i_ret = VLC_SUCCESS;
825 exit:
826 vlc_mutex_unlock( &p_sys->lock );
827 PROFILE_STOP( TigerValidateSubpicture );
828 return i_ret;
829 }
830
831 /* Tiger renders can end up looking a bit crap since they get overlaid on top of
832 a subsampled YUV image, so there can be a fair amount of chroma bleeding.
833 Looks good with white though since it's all luma. Hopefully that will be the
834 common case. */
835 static void TigerUpdateSubpicture( subpicture_t *p_subpic,
836 const video_format_t *p_fmt_src,
837 const video_format_t *p_fmt_dst,
838 mtime_t ts )
839 {
840 decoder_sys_t *p_sys = p_subpic->updater.p_sys->p_dec_sys;
841 plane_t *p_plane;
842 kate_float t;
843 int i_ret;
844
845
846 /* time in seconds from the start of the stream */
847 t = (p_subpic->updater.p_sys->i_start + ts - p_subpic->i_start ) / 1000000.0f;
848
849 PROFILE_START( TigerUpdateSubpicture );
850
851 /* create a full frame region - this will also tell Tiger the size of the frame */
852 video_format_t fmt = *p_fmt_dst;
853 fmt.i_chroma = VLC_CODEC_RGBA;
854 fmt.i_bits_per_pixel = 0;
855 fmt.i_width =
856 fmt.i_visible_width = p_fmt_src->i_width;
857 fmt.i_height =
858 fmt.i_visible_height = p_fmt_src->i_height;
859 fmt.i_x_offset = fmt.i_y_offset = 0;
860
861 subpicture_region_t *p_r = subpicture_region_New( &fmt );
862 if( !p_r )
863 return;
864
865 p_r->i_x = 0;
866 p_r->i_y = 0;
867 p_r->i_align = SUBPICTURE_ALIGN_TOP | SUBPICTURE_ALIGN_LEFT;
868
869 vlc_mutex_lock( &p_sys->lock );
870
871 p_plane = &p_r->p_picture->p[0];
872 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 );
873 if( i_ret < 0 )
874 {
875 goto failure;
876 }
877
878 PROFILE_START( tiger_renderer_update );
879 i_ret = tiger_renderer_update( p_sys->p_tr, t, 1 );
880 if( i_ret < 0 )
881 {
882 goto failure;
883 }
884 PROFILE_STOP( tiger_renderer_update );
885
886 PROFILE_START( tiger_renderer_render );
887 i_ret = tiger_renderer_render( p_sys->p_tr );
888 if( i_ret < 0 )
889 {
890 goto failure;
891 }
892 PROFILE_STOP( tiger_renderer_render );
893
894 PostprocessTigerImage( p_plane, fmt.i_width );
895 p_subpic->p_region = p_r;
896 p_sys->b_dirty = false;
897
898 PROFILE_STOP( TigerUpdateSubpicture );
899
900 vlc_mutex_unlock( &p_sys->lock );
901
902 return;
903
904 failure:
905 vlc_mutex_unlock( &p_sys->lock );
906 subpicture_region_ChainDelete( p_r );
907 }
908
909 static uint32_t GetTigerColor( decoder_t *p_dec, const char *psz_prefix )
910 {
911 char *psz_tmp;
912 uint32_t i_color = 0;
913
914 if( asprintf( &psz_tmp, "%s-color", psz_prefix ) >= 0 )
915 {
916 uint32_t i_rgb = var_CreateGetInteger( p_dec, psz_tmp );
917 var_Destroy( p_dec, psz_tmp );
918 free( psz_tmp );
919 i_color |= i_rgb;
920 }
921
922 if( asprintf( &psz_tmp, "%s-alpha", psz_prefix ) >= 0 )
923 {
924 uint32_t i_alpha = var_CreateGetInteger( p_dec, psz_tmp );
925 var_Destroy( p_dec, psz_tmp );
926 free( psz_tmp );
927 i_color |= (i_alpha << 24);
928 }
929
930 return i_color;
931 }
932
933 static char *GetTigerString( decoder_t *p_dec, const char *psz_name )
934 {
935 char *psz_value = var_CreateGetString( p_dec, psz_name );
936 if( psz_value)
937 {
938 psz_value = strdup( psz_value );
939 }
940 var_Destroy( p_dec, psz_name );
941 return psz_value;
942 }
943
944 static int GetTigerInteger( decoder_t *p_dec, const char *psz_name )
945 {
946 int i_value = var_CreateGetInteger( p_dec, psz_name );
947 var_Destroy( p_dec, psz_name );
948 return i_value;
949 }
950
951 static double GetTigerFloat( decoder_t *p_dec, const char *psz_name )
952 {
953 double f_value = var_CreateGetFloat( p_dec, psz_name );
954 var_Destroy( p_dec, psz_name );
955 return f_value;
956 }
957
958 static void UpdateTigerQuality( decoder_t *p_dec )
959 {
960 decoder_sys_t *p_sys = (decoder_sys_t*)p_dec->p_sys;
961 CHECK_TIGER_RET( tiger_renderer_set_quality( p_sys->p_tr, p_sys->f_tiger_quality ) );
962 p_sys->b_dirty = true;
963 }
964
965 static void UpdateTigerFontDesc( decoder_t *p_dec )
966 {
967 decoder_sys_t *p_sys = (decoder_sys_t*)p_dec->p_sys;
968 CHECK_TIGER_RET( tiger_renderer_set_default_font_description( p_sys->p_tr, p_sys->psz_tiger_default_font_desc ) );
969 p_sys->b_dirty = true;
970 }
971
972 static void UpdateTigerFontColor( decoder_t *p_dec )
973 {
974 decoder_sys_t *p_sys = (decoder_sys_t*)p_dec->p_sys;
975 double f_a = ((p_sys->i_tiger_default_font_color >> 24) & 0xff) / 255.0;
976 double f_r = ((p_sys->i_tiger_default_font_color >> 16) & 0xff) / 255.0;
977 double f_g = ((p_sys->i_tiger_default_font_color >> 8) & 0xff) / 255.0;
978 double f_b = (p_sys->i_tiger_default_font_color & 0xff) / 255.0;
979 CHECK_TIGER_RET( tiger_renderer_set_default_font_color( p_sys->p_tr, f_r, f_g, f_b, f_a ) );
980 p_sys->b_dirty = true;
981 }
982
983 static void UpdateTigerBackgroundColor( decoder_t *p_dec )
984 {
985 decoder_sys_t *p_sys = (decoder_sys_t*)p_dec->p_sys;
986 double f_a = ((p_sys->i_tiger_default_background_color >> 24) & 0xff) / 255.0;
987 double f_r = ((p_sys->i_tiger_default_background_color >> 16) & 0xff) / 255.0;
988 double f_g = ((p_sys->i_tiger_default_background_color >> 8) & 0xff) / 255.0;
989 double f_b = (p_sys->i_tiger_default_background_color & 0xff) / 255.0;
990 CHECK_TIGER_RET( tiger_renderer_set_default_background_fill_color( p_sys->p_tr, f_r, f_g, f_b, f_a ) );
991 p_sys->b_dirty = true;
992 }
993
994 static void UpdateTigerFontEffect( decoder_t *p_dec )
995 {
996 decoder_sys_t *p_sys = (decoder_sys_t*)p_dec->p_sys;
997 CHECK_TIGER_RET( tiger_renderer_set_default_font_effect( p_sys->p_tr,
998 p_sys->e_tiger_default_font_effect,
999 p_sys->f_tiger_default_font_effect_strength ) );
1000 p_sys->b_dirty = true;
1001 }
1002
1003 static int OnConfigurationChanged( decoder_t *p_dec, const char *psz_var,
1004 vlc_value_t oldval, vlc_value_t newval )
1005 {
1006 decoder_sys_t *p_sys = (decoder_sys_t*)p_dec->p_sys;
1007
1008 VLC_UNUSED( oldval );
1009
1010 vlc_mutex_lock( &p_sys->lock );
1011
1012 msg_Dbg( p_dec, "OnConfigurationChanged: %s", psz_var );
1013
1014 if( !p_sys->b_use_tiger || !p_sys->p_tr )
1015 {
1016 vlc_mutex_unlock( &p_sys->lock );
1017 return VLC_SUCCESS;
1018 }
1019
1020 #define TEST_TIGER_VAR( name ) \
1021 if( !strcmp( name, psz_var ) )
1022
1023 TEST_TIGER_VAR( "kate-tiger-quality" )
1024 {
1025 p_sys->f_tiger_quality = newval.f_float;
1026 UpdateTigerQuality( p_dec );
1027 }
1028
1029 TEST_TIGER_VAR( "kate-tiger-default-font-desc" )
1030 {
1031 if( p_sys->psz_tiger_default_font_desc )
1032 {
1033 free( p_sys->psz_tiger_default_font_desc );
1034 p_sys->psz_tiger_default_font_desc = NULL;
1035 }
1036 if( newval.psz_string )
1037 {
1038 p_sys->psz_tiger_default_font_desc = strdup( newval.psz_string );
1039 }
1040 UpdateTigerFontDesc( p_dec );
1041 }
1042
1043 TEST_TIGER_VAR( "kate-tiger-default-font-color" )
1044 {
1045 p_sys->i_tiger_default_font_color = (p_sys->i_tiger_default_font_color & 0xff00000000) | newval.i_int;
1046 UpdateTigerFontColor( p_dec );
1047 }
1048
1049 TEST_TIGER_VAR( "kate-tiger-default-font-alpha" )
1050 {
1051 p_sys->i_tiger_default_font_color = (p_sys->i_tiger_default_font_color & 0x00ffffff) | (newval.i_int<<24);
1052 UpdateTigerFontColor( p_dec );
1053 }
1054
1055 TEST_TIGER_VAR( "kate-tiger-default-background-color" )
1056 {
1057 p_sys->i_tiger_default_background_color = (p_sys->i_tiger_default_background_color & 0xff00000000) | newval.i_int;
1058 UpdateTigerBackgroundColor( p_dec );
1059 }
1060
1061 TEST_TIGER_VAR( "kate-tiger-default-background-alpha" )
1062 {
1063 p_sys->i_tiger_default_background_color = (p_sys->i_tiger_default_background_color & 0x00ffffff) | (newval.i_int<<24);
1064 UpdateTigerBackgroundColor( p_dec );
1065 }
1066
1067 TEST_TIGER_VAR( "kate-tiger-default-font-effect" )
1068 {
1069 p_sys->e_tiger_default_font_effect = (tiger_font_effect)newval.i_int;
1070 UpdateTigerFontEffect( p_dec );
1071 }
1072
1073 TEST_TIGER_VAR( "kate-tiger-default-font-effect-strength" )
1074 {
1075 p_sys->f_tiger_default_font_effect_strength = newval.f_float;
1076 UpdateTigerFontEffect( p_dec );
1077 }
1078
1079 #undef TEST_TIGER_VAR
1080
1081 vlc_mutex_unlock( &p_sys->lock );
1082
1083 return VLC_SUCCESS;
1084 }
1085
1086 static int TigerConfigurationCallback( vlc_object_t *p_this, const char *psz_var,
1087 vlc_value_t oldval, vlc_value_t newval,
1088 void *p_data )
1089 {
1090 size_t i_idx;
1091
1092 VLC_UNUSED( p_this );
1093 VLC_UNUSED( oldval );
1094 VLC_UNUSED( newval );
1095 VLC_UNUSED( p_data );
1096
1097 vlc_mutex_lock( &kate_decoder_list_mutex );
1098
1099 /* Update all existing decoders from the global user prefs */
1100 for( i_idx = 0; i_idx < kate_decoder_list_size; i_idx++ )
1101 {
1102 decoder_t *p_dec = kate_decoder_list[ i_idx ];
1103 OnConfigurationChanged( p_dec, psz_var, oldval, newval );
1104 }
1105
1106 vlc_mutex_unlock( &kate_decoder_list_mutex );
1107
1108 return VLC_SUCCESS;
1109 }
1110
1111 #endif
1112
1113 /*****************************************************************************
1114 * DecodePacket: decodes a Kate packet.
1115 *****************************************************************************/
1116 static subpicture_t *DecodePacket( decoder_t *p_dec, kate_packet *p_kp, block_t *p_block )
1117 {
1118 decoder_sys_t *p_sys = p_dec->p_sys;
1119 const kate_event *ev = NULL;
1120 subpicture_t *p_spu = NULL;
1121 int i_ret;
1122
1123 if( !p_sys->b_ready )
1124 {
1125 msg_Err( p_dec, "Cannot decode Kate packet, decoder not initialized" );
1126 return NULL;
1127 }
1128
1129 i_ret = kate_decode_packetin( &p_sys->k, p_kp );
1130 if( i_ret < 0 )
1131 {
1132 msg_Err( p_dec, "Kate failed to decode packet: %d", i_ret );
1133 return NULL;
1134 }
1135
1136 i_ret = kate_decode_eventout( &p_sys->k, &ev );
1137 if( i_ret < 0 )
1138 {
1139 msg_Err( p_dec, "Kate failed to retrieve event: %d", i_ret );
1140 return NULL;
1141 }
1142 if( i_ret > 0 )
1143 {
1144 /* no event to go with this packet, this is normal */
1145 return NULL;
1146 }
1147
1148 /* we have an event */
1149
1150 /* Get a new spu */
1151 subpicture_updater_sys_t *p_spu_sys = NULL;
1152 if( p_sys->b_use_tiger)
1153 {
1154 p_spu_sys = malloc( sizeof(*p_spu_sys) );
1155 if( !p_spu_sys )
1156 return NULL;
1157 }
1158 subpicture_updater_t updater = {
1159 #ifdef HAVE_TIGER
1160 .pf_validate = TigerValidateSubpicture,
1161 .pf_update = TigerUpdateSubpicture,
1162 .pf_destroy = TigerDestroySubpicture,
1163 #endif
1164 .p_sys = p_spu_sys,
1165 };
1166 p_spu = decoder_NewSubpicture( p_dec, p_sys->b_use_tiger ? &updater : NULL );
1167 if( !p_spu )
1168 {
1169 free( p_spu_sys );
1170 /* this will happen for lyrics as there is no vout - so no error */
1171 /* msg_Err( p_dec, "Failed to allocate spu buffer" ); */
1172 return NULL;
1173 }
1174
1175 p_spu->i_start = p_block->i_pts;
1176 p_spu->i_stop = p_block->i_pts + INT64_C(1000000)*ev->duration*p_sys->ki.gps_denominator/p_sys->ki.gps_numerator;
1177 p_spu->b_ephemer = false;
1178 p_spu->b_absolute = false;
1179
1180 #ifdef HAVE_TIGER
1181 if( p_sys->b_use_tiger)
1182 {
1183 p_spu_sys->p_dec_sys = p_sys;
1184 p_spu_sys->i_start = p_block->i_pts;
1185 DecSysHold( p_sys );
1186
1187 p_spu->i_stop = __MAX( p_sys->i_max_stop, p_spu->i_stop );
1188 p_spu->b_ephemer = true;
1189 p_spu->b_absolute = true;
1190
1191 /* add the event to tiger */
1192 vlc_mutex_lock( &p_sys->lock );
1193 CHECK_TIGER_RET( tiger_renderer_add_event( p_sys->p_tr, ev->ki, ev ) );
1194 vlc_mutex_unlock( &p_sys->lock );
1195 }
1196 else
1197 #endif
1198 {
1199 p_spu = SetupSimpleKateSPU( p_dec, p_spu, ev );
1200 }
1201
1202 return p_spu;
1203 }
1204
1205 /*****************************************************************************
1206 * SetupSimpleKateSPU: creates text/bitmap regions where appropriate
1207 *****************************************************************************/
1208 static subpicture_t *SetupSimpleKateSPU( decoder_t *p_dec, subpicture_t *p_spu,
1209 const kate_event *ev )
1210 {
1211 decoder_sys_t *p_sys = p_dec->p_sys;
1212 video_format_t fmt;
1213 subpicture_region_t *p_bitmap_region = NULL;
1214 video_palette_t palette;
1215 kate_tracker kin;
1216 bool b_tracker_valid = false;
1217 int i_ret;
1218
1219 /* these may be 0 for "not specified" */
1220 p_spu->i_original_picture_width = p_sys->ki.original_canvas_width;
1221 p_spu->i_original_picture_height = p_sys->ki.original_canvas_height;
1222
1223 /* Create a new subpicture region */
1224 memset( &fmt, 0, sizeof(video_format_t) );
1225
1226 if (p_sys->b_formatted)
1227 {
1228 i_ret = kate_tracker_init( &kin, &p_sys->ki, ev );
1229 if( i_ret < 0)
1230 {
1231 msg_Err( p_dec, "failed to initialize kate tracker, event will be unformatted: %d", i_ret );
1232 }
1233 else
1234 {
1235 int w = 720, h = 576; /* give sensible defaults just in case we fail to get the actual size */
1236 GetVideoSize(p_dec, &w, &h);
1237 i_ret = kate_tracker_update(&kin, 0, w, h, 0, 0, w, h);
1238 if( i_ret < 0)
1239 {
1240 kate_tracker_clear(&kin);
1241 msg_Err( p_dec, "failed to update kate tracker, event will be unformatted: %d", i_ret );
1242 }
1243 else
1244 {
1245 // TODO: parse tracker and set style, init fmt
1246 b_tracker_valid = true;
1247 }
1248 }
1249 }
1250
1251 if (ev->bitmap && ev->bitmap->type==kate_bitmap_type_paletted && ev->palette) {
1252
1253 /* create a separate region for the bitmap */
1254 memset( &fmt, 0, sizeof(video_format_t) );
1255 fmt.i_chroma = VLC_CODEC_YUVP;
1256 fmt.i_width = fmt.i_visible_width = ev->bitmap->width;
1257 fmt.i_height = fmt.i_visible_height = ev->bitmap->height;
1258 fmt.i_x_offset = fmt.i_y_offset = 0;
1259 fmt.p_palette = &palette;
1260 CreateKatePalette( fmt.p_palette, ev->palette );
1261
1262 p_bitmap_region = subpicture_region_New( &fmt );
1263 if( !p_bitmap_region )
1264 {
1265 msg_Err( p_dec, "cannot allocate SPU region" );
1266 decoder_DeleteSubpicture( p_dec, p_spu );
1267 return NULL;
1268 }
1269
1270 /* create the bitmap */
1271 CreateKateBitmap( p_bitmap_region->p_picture, ev->bitmap );
1272
1273 msg_Dbg(p_dec, "Created bitmap, %zux%zu, %zu colors", ev->bitmap->width, ev->bitmap->height, ev->palette->ncolors);
1274 }
1275
1276 /* text region */
1277 fmt.i_chroma = VLC_CODEC_TEXT;
1278 fmt.i_sar_num = 0;
1279 fmt.i_sar_den = 1;
1280 fmt.i_width = fmt.i_height = 0;
1281 fmt.i_x_offset = fmt.i_y_offset = 0;
1282 p_spu->p_region = subpicture_region_New( &fmt );
1283 if( !p_spu->p_region )
1284 {
1285 msg_Err( p_dec, "cannot allocate SPU region" );
1286 decoder_DeleteSubpicture( p_dec, p_spu );
1287 return NULL;
1288 }
1289
1290 SetupText( p_dec, p_spu, ev );
1291
1292 /* default positioning */
1293 p_spu->p_region->i_align = SUBPICTURE_ALIGN_BOTTOM;
1294 if (p_bitmap_region)
1295 {
1296 p_bitmap_region->i_align = SUBPICTURE_ALIGN_BOTTOM;
1297 }
1298 p_spu->p_region->i_x = 0;
1299 p_spu->p_region->i_y = 10;
1300
1301 /* override if tracker info present */
1302 if (b_tracker_valid)
1303 {
1304 if (kin.has.region)
1305 {
1306 p_spu->p_region->i_x = kin.region_x;
1307 p_spu->p_region->i_y = kin.region_y;
1308 if (p_bitmap_region)
1309 {
1310 p_bitmap_region->i_x = kin.region_x;
1311 p_bitmap_region->i_y = kin.region_y;
1312 }
1313 p_spu->b_absolute = true;
1314 }
1315
1316 kate_tracker_clear(&kin);
1317 }
1318
1319 /* if we have a bitmap, chain it before the text */
1320 if (p_bitmap_region)
1321 {
1322 p_bitmap_region->p_next = p_spu->p_region;
1323 p_spu->p_region = p_bitmap_region;
1324 }
1325
1326 return p_spu;
1327 }
1328
1329 /*****************************************************************************
1330 * ParseKateComments:
1331 *****************************************************************************/
1332 static void ParseKateComments( decoder_t *p_dec )
1333 {
1334 char *psz_name, *psz_value, *psz_comment;
1335 int i = 0;
1336
1337 while ( i < p_dec->p_sys->kc.comments )
1338 {
1339 psz_comment = strdup( p_dec->p_sys->kc.user_comments[i] );
1340 if( !psz_comment )
1341 break;
1342 psz_name = psz_comment;
1343 psz_value = strchr( psz_comment, '=' );
1344 if( psz_value )
1345 {
1346 *psz_value = '\0';
1347 psz_value++;
1348
1349 if( !p_dec->p_description )
1350 p_dec->p_description = vlc_meta_New();
1351 if( p_dec->p_description )
1352 vlc_meta_AddExtra( p_dec->p_description, psz_name, psz_value );
1353 }
1354 free( psz_comment );
1355 i++;
1356 }
1357 }
1358
1359 /*****************************************************************************
1360 * CloseDecoder: clean up the decoder
1361 *****************************************************************************/
1362 static void CloseDecoder( vlc_object_t *p_this )
1363 {
1364 decoder_t *p_dec = (decoder_t *)p_this;
1365 size_t i_index;
1366
1367 /* remove the decoder from the global list */
1368 vlc_mutex_lock( &kate_decoder_list_mutex );
1369 for( i_index = 0; i_index < kate_decoder_list_size; i_index++ )
1370 {
1371 if( kate_decoder_list[ i_index ] == p_dec )
1372 {
1373 kate_decoder_list[ i_index ] = kate_decoder_list[ --kate_decoder_list_size ];
1374 break;
1375 }
1376 }
1377 vlc_mutex_unlock( &kate_decoder_list_mutex );
1378
1379 msg_Dbg( p_dec, "Closing Kate decoder" );
1380 DecSysRelease( p_dec->p_sys );
1381 }
1382
1383 static void DecSysHold( decoder_sys_t *p_sys )
1384 {
1385 vlc_mutex_lock( &p_sys->lock );
1386 p_sys->i_refcount++;
1387 vlc_mutex_unlock( &p_sys->lock );
1388 }
1389
1390 static void DecSysRelease( decoder_sys_t *p_sys )
1391 {
1392 vlc_mutex_lock( &p_sys->lock );
1393 p_sys->i_refcount--;
1394 if( p_sys->i_refcount > 0)
1395 {
1396 vlc_mutex_unlock( &p_sys->lock );
1397 return;
1398 }
1399
1400 vlc_mutex_unlock( &p_sys->lock );
1401 vlc_mutex_destroy( &p_sys->lock );
1402
1403 #ifdef HAVE_TIGER
1404 if( p_sys->p_tr )
1405 tiger_renderer_destroy( p_sys->p_tr );
1406 free( p_sys->psz_tiger_default_font_desc );
1407 #endif
1408
1409 if (p_sys->b_ready)
1410 kate_clear( &p_sys->k );
1411 kate_info_clear( &p_sys->ki );
1412 kate_comment_clear( &p_sys->kc );
1413
1414 free( p_sys );
1415 }
1416
[GSoC_2011] OpenGL Interface for VLC