?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
add_integer: remove callback parameter
[vlc/asuraparaju-public.git] / modules / misc / quartztext.c
blobd3e91c929a7e95d6c0a50c632c32a0c8b6914456
1 /*****************************************************************************
2 * quartztext.c : Put text on the video, using Mac OS X Quartz Engine
3 *****************************************************************************
4 * Copyright (C) 2007, 2009 the VideoLAN team
5 * $Id$
6 *
7 * Authors: Bernie Purcell <bitmap@videolan.org>
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
28 #ifdef HAVE_CONFIG_H
29 # include "config.h"
30 #endif
31
32 #include <vlc_common.h>
33 #include <vlc_plugin.h>
34 #include <vlc_osd.h>
35 #include <vlc_stream.h>
36 #include <vlc_xml.h>
37 #include <vlc_input.h>
38
39 // Fix ourselves ColorSync headers that gets included in ApplicationServices.
40 #define DisposeCMProfileIterateUPP(a) DisposeCMProfileIterateUPP(CMProfileIterateUPP userUPP __attribute__((unused)))
41 #define DisposeCMMIterateUPP(a) DisposeCMMIterateUPP(CMProfileIterateUPP userUPP __attribute__((unused)))
42 #define __MACHINEEXCEPTIONS__
43 #include <ApplicationServices/ApplicationServices.h>
44
45 #define DEFAULT_FONT "Arial Black"
46 #define DEFAULT_FONT_COLOR 0xffffff
47 #define DEFAULT_REL_FONT_SIZE 16
48
49 #define VERTICAL_MARGIN 3
50 #define HORIZONTAL_MARGIN 10
51
52 //////////////////////////////////////////////////////////////////////////////
53 // Local prototypes
54 //////////////////////////////////////////////////////////////////////////////
55 static int Create ( vlc_object_t * );
56 static void Destroy( vlc_object_t * );
57
58 static int LoadFontsFromAttachments( filter_t *p_filter );
59
60 static int RenderText( filter_t *, subpicture_region_t *,
61 subpicture_region_t * );
62 static int RenderHtml( filter_t *, subpicture_region_t *,
63 subpicture_region_t * );
64
65 static int GetFontSize( filter_t *p_filter );
66 static int RenderYUVA( filter_t *p_filter, subpicture_region_t *p_region,
67 CFMutableAttributedStringRef p_attrString );
68
69 static void setFontAttibutes( char *psz_fontname, int i_font_size, uint32_t i_font_color,
70 bool b_bold, bool b_italic, bool b_underline,
71 CFRange p_range, CFMutableAttributedStringRef p_attrString );
72
73 //////////////////////////////////////////////////////////////////////////////
74 // Module descriptor
75 //////////////////////////////////////////////////////////////////////////////
76
77 // The preferred way to set font style information is for it to come from the
78 // subtitle file, and for it to be rendered with RenderHtml instead of
79 // RenderText.
80 #define FONT_TEXT N_("Font")
81 #define FONT_LONGTEXT N_("Name for the font you want to use")
82 #define FONTSIZER_TEXT N_("Relative font size")
83 #define FONTSIZER_LONGTEXT N_("This is the relative default size of the " \
84 "fonts that will be rendered on the video. If absolute font size is set, "\
85 "relative size will be overridden." )
86 #define COLOR_TEXT N_("Text default color")
87 #define COLOR_LONGTEXT N_("The color of the text that will be rendered on "\
88 "the video. This must be an hexadecimal (like HTML colors). The first two "\
89 "chars are for red, then green, then blue. #000000 = black, #FF0000 = red,"\
90 " #00FF00 = green, #FFFF00 = yellow (red + green), #FFFFFF = white" )
91
92 static const int pi_color_values[] = {
93 0x00000000, 0x00808080, 0x00C0C0C0, 0x00FFFFFF, 0x00800000,
94 0x00FF0000, 0x00FF00FF, 0x00FFFF00, 0x00808000, 0x00008000, 0x00008080,
95 0x0000FF00, 0x00800080, 0x00000080, 0x000000FF, 0x0000FFFF };
96
97 static const char *const ppsz_color_descriptions[] = {
98 N_("Black"), N_("Gray"), N_("Silver"), N_("White"), N_("Maroon"),
99 N_("Red"), N_("Fuchsia"), N_("Yellow"), N_("Olive"), N_("Green"), N_("Teal"),
100 N_("Lime"), N_("Purple"), N_("Navy"), N_("Blue"), N_("Aqua") };
101
102 static const int pi_sizes[] = { 20, 18, 16, 12, 6 };
103 static const char *const ppsz_sizes_text[] = {
104 N_("Smaller"), N_("Small"), N_("Normal"), N_("Large"), N_("Larger") };
105
106 vlc_module_begin ()
107 set_shortname( N_("Text renderer for Mac"))
108 set_description( N_("CoreText font renderer") )
109 set_category( CAT_VIDEO )
110 set_subcategory( SUBCAT_VIDEO_SUBPIC )
111
112 add_string( "quartztext-font", DEFAULT_FONT, FONT_TEXT, FONT_LONGTEXT,
113 false )
114 add_integer( "quartztext-rel-fontsize", DEFAULT_REL_FONT_SIZE, FONTSIZER_TEXT,
115 FONTSIZER_LONGTEXT, false )
116 change_integer_list( pi_sizes, ppsz_sizes_text )
117 add_integer( "quartztext-color", 0x00FFFFFF, COLOR_TEXT,
118 COLOR_LONGTEXT, false )
119 change_integer_list( pi_color_values, ppsz_color_descriptions )
120 set_capability( "text renderer", 150 )
121 add_shortcut( "text" )
122 set_callbacks( Create, Destroy )
123 vlc_module_end ()
124
125 typedef struct font_stack_t font_stack_t;
126 struct font_stack_t
127 {
128 char *psz_name;
129 int i_size;
130 uint32_t i_color; // ARGB
131
132 font_stack_t *p_next;
133 };
134
135 typedef struct
136 {
137 int i_font_size;
138 uint32_t i_font_color; /* ARGB */
139 bool b_italic;
140 bool b_bold;
141 bool b_underline;
142 char *psz_fontname;
143 } ft_style_t;
144
145 typedef struct offscreen_bitmap_t offscreen_bitmap_t;
146 struct offscreen_bitmap_t
147 {
148 uint8_t *p_data;
149 int i_bitsPerChannel;
150 int i_bitsPerPixel;
151 int i_bytesPerPixel;
152 int i_bytesPerRow;
153 };
154
155 //////////////////////////////////////////////////////////////////////////////
156 // filter_sys_t: quartztext local data
157 //////////////////////////////////////////////////////////////////////////////
158 // This structure is part of the video output thread descriptor.
159 // It describes the freetype specific properties of an output thread.
160 //////////////////////////////////////////////////////////////////////////////
161 struct filter_sys_t
162 {
163 char *psz_font_name;
164 uint8_t i_font_opacity;
165 int i_font_color;
166 int i_font_size;
167
168 ATSFontContainerRef *p_fonts;
169 int i_fonts;
170 };
171
172 //////////////////////////////////////////////////////////////////////////////
173 // Create: allocates osd-text video thread output method
174 //////////////////////////////////////////////////////////////////////////////
175 // This function allocates and initializes a Clone vout method.
176 //////////////////////////////////////////////////////////////////////////////
177 static int Create( vlc_object_t *p_this )
178 {
179 filter_t *p_filter = (filter_t *)p_this;
180 filter_sys_t *p_sys;
181
182 // Allocate structure
183 p_filter->p_sys = p_sys = malloc( sizeof( filter_sys_t ) );
184 if( !p_sys )
185 return VLC_ENOMEM;
186 p_sys->psz_font_name = var_CreateGetString( p_this, "quartztext-font" );
187 p_sys->i_font_opacity = 255;
188 p_sys->i_font_color = __MAX( __MIN( var_CreateGetInteger( p_this, "quartztext-color" ) , 0xFFFFFF ), 0 );
189 p_sys->i_font_size = GetFontSize( p_filter );
190
191 p_filter->pf_render_text = RenderText;
192 p_filter->pf_render_html = RenderHtml;
193
194 p_sys->p_fonts = NULL;
195 p_sys->i_fonts = 0;
196
197 LoadFontsFromAttachments( p_filter );
198
199 return VLC_SUCCESS;
200 }
201
202 //////////////////////////////////////////////////////////////////////////////
203 // Destroy: destroy Clone video thread output method
204 //////////////////////////////////////////////////////////////////////////////
205 // Clean up all data and library connections
206 //////////////////////////////////////////////////////////////////////////////
207 static void Destroy( vlc_object_t *p_this )
208 {
209 filter_t *p_filter = (filter_t *)p_this;
210 filter_sys_t *p_sys = p_filter->p_sys;
211
212 if( p_sys->p_fonts )
213 {
214 int k;
215
216 for( k = 0; k < p_sys->i_fonts; k++ )
217 {
218 ATSFontDeactivate( p_sys->p_fonts[k], NULL, kATSOptionFlagsDefault );
219 }
220
221 free( p_sys->p_fonts );
222 }
223
224 free( p_sys->psz_font_name );
225 free( p_sys );
226 }
227
228 //////////////////////////////////////////////////////////////////////////////
229 // Make any TTF/OTF fonts present in the attachments of the media file
230 // available to the Quartz engine for text rendering
231 //////////////////////////////////////////////////////////////////////////////
232 static int LoadFontsFromAttachments( filter_t *p_filter )
233 {
234 filter_sys_t *p_sys = p_filter->p_sys;
235 input_attachment_t **pp_attachments;
236 int i_attachments_cnt;
237
238 if( filter_GetInputAttachments( p_filter, &pp_attachments, &i_attachments_cnt ) )
239 return VLC_EGENERIC;
240
241 p_sys->i_fonts = 0;
242 p_sys->p_fonts = malloc( i_attachments_cnt * sizeof( ATSFontContainerRef ) );
243 if(! p_sys->p_fonts )
244 return VLC_ENOMEM;
245
246 for( int k = 0; k < i_attachments_cnt; k++ )
247 {
248 input_attachment_t *p_attach = pp_attachments[k];
249
250 if( ( !strcmp( p_attach->psz_mime, "application/x-truetype-font" ) || // TTF
251 !strcmp( p_attach->psz_mime, "application/x-font-otf" ) ) && // OTF
252 p_attach->i_data > 0 && p_attach->p_data )
253 {
254 ATSFontContainerRef container;
255
256 if( noErr == ATSFontActivateFromMemory( p_attach->p_data,
257 p_attach->i_data,
258 kATSFontContextLocal,
259 kATSFontFormatUnspecified,
260 NULL,
261 kATSOptionFlagsDefault,
262 &container ))
263 {
264 p_sys->p_fonts[ p_sys->i_fonts++ ] = container;
265 }
266 }
267 vlc_input_attachment_Delete( p_attach );
268 }
269 free( pp_attachments );
270
271 return VLC_SUCCESS;
272 }
273
274 static char *EliminateCRLF( char *psz_string )
275 {
276 char *p;
277 char *q;
278
279 for( p = psz_string; p && *p; p++ )
280 {
281 if( ( *p == '\r' ) && ( *(p+1) == '\n' ) )
282 {
283 for( q = p + 1; *q; q++ )
284 *( q - 1 ) = *q;
285
286 *( q - 1 ) = '\0';
287 }
288 }
289 return psz_string;
290 }
291
292 // Renders a text subpicture region into another one.
293 // It is used as pf_add_string callback in the vout method by this module
294 static int RenderText( filter_t *p_filter, subpicture_region_t *p_region_out,
295 subpicture_region_t *p_region_in )
296 {
297 filter_sys_t *p_sys = p_filter->p_sys;
298 char *psz_string;
299 int i_font_alpha, i_font_size;
300 uint32_t i_font_color;
301 bool b_bold, b_uline, b_italic;
302 vlc_value_t val;
303 int i_scale = 1000;
304 b_bold = b_uline = b_italic = FALSE;
305
306 p_sys->i_font_size = GetFontSize( p_filter );
307
308 // Sanity check
309 if( !p_region_in || !p_region_out ) return VLC_EGENERIC;
310 psz_string = p_region_in->psz_text;
311 if( !psz_string || !*psz_string ) return VLC_EGENERIC;
312
313 if( VLC_SUCCESS == var_Get( p_filter, "scale", &val ))
314 i_scale = val.i_int;
315
316 if( p_region_in->p_style )
317 {
318 i_font_color = __MAX( __MIN( p_region_in->p_style->i_font_color, 0xFFFFFF ), 0 );
319 i_font_alpha = __MAX( __MIN( p_region_in->p_style->i_font_alpha, 255 ), 0 );
320 i_font_size = __MAX( __MIN( p_region_in->p_style->i_font_size, 255 ), 0 ) * i_scale / 1000;
321 if( p_region_in->p_style->i_style_flags )
322 {
323 if( p_region_in->p_style->i_style_flags & STYLE_BOLD )
324 b_bold = TRUE;
325 if( p_region_in->p_style->i_style_flags & STYLE_ITALIC )
326 b_italic = TRUE;
327 if( p_region_in->p_style->i_style_flags & STYLE_UNDERLINE )
328 b_uline = TRUE;
329 }
330 }
331 else
332 {
333 i_font_color = p_sys->i_font_color;
334 i_font_alpha = 255 - p_sys->i_font_opacity;
335 i_font_size = p_sys->i_font_size;
336 }
337
338 if( !i_font_alpha ) i_font_alpha = 255 - p_sys->i_font_opacity;
339
340 if( i_font_size <= 0 )
341 {
342 msg_Warn( p_filter, "invalid fontsize, using 12" );
343 if( VLC_SUCCESS == var_Get( p_filter, "scale", &val ))
344 i_font_size = 12 * val.i_int / 1000;
345 else
346 i_font_size = 12;
347 }
348
349 p_region_out->i_x = p_region_in->i_x;
350 p_region_out->i_y = p_region_in->i_y;
351
352 CFMutableAttributedStringRef p_attrString = CFAttributedStringCreateMutable(kCFAllocatorDefault, 0);
353
354 if( p_attrString )
355 {
356 CFStringRef p_cfString;
357 int len;
358
359 EliminateCRLF( psz_string);
360 p_cfString = CFStringCreateWithCString( NULL, psz_string, kCFStringEncodingUTF8 );
361 CFAttributedStringReplaceString( p_attrString, CFRangeMake(0, 0), p_cfString );
362 CFRelease( p_cfString );
363 len = CFAttributedStringGetLength( p_attrString );
364
365 setFontAttibutes( p_sys->psz_font_name, i_font_size, i_font_color, b_bold, b_italic, b_uline,
366 CFRangeMake( 0, len ), p_attrString);
367
368 RenderYUVA( p_filter, p_region_out, p_attrString );
369 CFRelease( p_attrString );
370 }
371
372 return VLC_SUCCESS;
373 }
374
375
376 static int PushFont( font_stack_t **p_font, const char *psz_name, int i_size,
377 uint32_t i_color )
378 {
379 font_stack_t *p_new;
380
381 if( !p_font )
382 return VLC_EGENERIC;
383
384 p_new = malloc( sizeof( font_stack_t ) );
385 if( ! p_new )
386 return VLC_ENOMEM;
387
388 p_new->p_next = NULL;
389
390 if( psz_name )
391 p_new->psz_name = strdup( psz_name );
392 else
393 p_new->psz_name = NULL;
394
395 p_new->i_size = i_size;
396 p_new->i_color = i_color;
397
398 if( !*p_font )
399 {
400 *p_font = p_new;
401 }
402 else
403 {
404 font_stack_t *p_last;
405
406 for( p_last = *p_font;
407 p_last->p_next;
408 p_last = p_last->p_next )
409 ;
410
411 p_last->p_next = p_new;
412 }
413 return VLC_SUCCESS;
414 }
415
416 static int PopFont( font_stack_t **p_font )
417 {
418 font_stack_t *p_last, *p_next_to_last;
419
420 if( !p_font || !*p_font )
421 return VLC_EGENERIC;
422
423 p_next_to_last = NULL;
424 for( p_last = *p_font;
425 p_last->p_next;
426 p_last = p_last->p_next )
427 {
428 p_next_to_last = p_last;
429 }
430
431 if( p_next_to_last )
432 p_next_to_last->p_next = NULL;
433 else
434 *p_font = NULL;
435
436 free( p_last->psz_name );
437 free( p_last );
438
439 return VLC_SUCCESS;
440 }
441
442 static int PeekFont( font_stack_t **p_font, char **psz_name, int *i_size,
443 uint32_t *i_color )
444 {
445 font_stack_t *p_last;
446
447 if( !p_font || !*p_font )
448 return VLC_EGENERIC;
449
450 for( p_last=*p_font;
451 p_last->p_next;
452 p_last=p_last->p_next )
453 ;
454
455 *psz_name = p_last->psz_name;
456 *i_size = p_last->i_size;
457 *i_color = p_last->i_color;
458
459 return VLC_SUCCESS;
460 }
461
462 static int HandleFontAttributes( xml_reader_t *p_xml_reader,
463 font_stack_t **p_fonts, int i_scale )
464 {
465 int rv;
466 char *psz_fontname = NULL;
467 uint32_t i_font_color = 0xffffff;
468 int i_font_alpha = 0;
469 int i_font_size = 24;
470
471 // Default all attributes to the top font in the stack -- in case not
472 // all attributes are specified in the sub-font
473 if( VLC_SUCCESS == PeekFont( p_fonts,
474 &psz_fontname,
475 &i_font_size,
476 &i_font_color ))
477 {
478 psz_fontname = strdup( psz_fontname );
479 i_font_size = i_font_size * 1000 / i_scale;
480 }
481 i_font_alpha = (i_font_color >> 24) & 0xff;
482 i_font_color &= 0x00ffffff;
483
484 while ( xml_ReaderNextAttr( p_xml_reader ) == VLC_SUCCESS )
485 {
486 char *psz_name = xml_ReaderName( p_xml_reader );
487 char *psz_value = xml_ReaderValue( p_xml_reader );
488
489 if( psz_name && psz_value )
490 {
491 if( !strcasecmp( "face", psz_name ) )
492 {
493 free( psz_fontname );
494 psz_fontname = strdup( psz_value );
495 }
496 else if( !strcasecmp( "size", psz_name ) )
497 {
498 if( ( *psz_value == '+' ) || ( *psz_value == '-' ) )
499 {
500 int i_value = atoi( psz_value );
501
502 if( ( i_value >= -5 ) && ( i_value <= 5 ) )
503 i_font_size += ( i_value * i_font_size ) / 10;
504 else if( i_value < -5 )
505 i_font_size = - i_value;
506 else if( i_value > 5 )
507 i_font_size = i_value;
508 }
509 else
510 i_font_size = atoi( psz_value );
511 }
512 else if( !strcasecmp( "color", psz_name ) &&
513 ( psz_value[0] == '#' ) )
514 {
515 i_font_color = strtol( psz_value + 1, NULL, 16 );
516 i_font_color &= 0x00ffffff;
517 }
518 else if( !strcasecmp( "alpha", psz_name ) &&
519 ( psz_value[0] == '#' ) )
520 {
521 i_font_alpha = strtol( psz_value + 1, NULL, 16 );
522 i_font_alpha &= 0xff;
523 }
524 free( psz_name );
525 free( psz_value );
526 }
527 }
528 rv = PushFont( p_fonts,
529 psz_fontname,
530 i_font_size * i_scale / 1000,
531 (i_font_color & 0xffffff) | ((i_font_alpha & 0xff) << 24) );
532
533 free( psz_fontname );
534
535 return rv;
536 }
537
538 static void setFontAttibutes( char *psz_fontname, int i_font_size, uint32_t i_font_color,
539 bool b_bold, bool b_italic, bool b_underline,
540 CFRange p_range, CFMutableAttributedStringRef p_attrString )
541 {
542 CFStringRef p_cfString;
543 CTFontRef p_font;
544
545 // Handle font name and size
546 p_cfString = CFStringCreateWithCString( NULL,
547 psz_fontname,
548 kCFStringEncodingUTF8 );
549 p_font = CTFontCreateWithName( p_cfString,
550 (float)i_font_size,
551 NULL );
552 CFRelease( p_cfString );
553 CFAttributedStringSetAttribute( p_attrString,
554 p_range,
555 kCTFontAttributeName,
556 p_font );
557 CFRelease( p_font );
558
559 // Handle Underline
560 SInt32 _uline;
561 if( b_underline )
562 _uline = kCTUnderlineStyleSingle;
563 else
564 _uline = kCTUnderlineStyleNone;
565
566 CFNumberRef underline = CFNumberCreate(NULL, kCFNumberSInt32Type, &_uline);
567 CFAttributedStringSetAttribute( p_attrString,
568 p_range,
569 kCTUnderlineStyleAttributeName,
570 underline );
571 CFRelease( underline );
572
573 // Handle Bold
574 float _weight;
575 if( b_bold )
576 _weight = 0.5;
577 else
578 _weight = 0.0;
579
580 CFNumberRef weight = CFNumberCreate(NULL, kCFNumberFloatType, &_weight);
581 CFAttributedStringSetAttribute( p_attrString,
582 p_range,
583 kCTFontWeightTrait,
584 weight );
585 CFRelease( weight );
586
587 // Handle Italic
588 float _slant;
589 if( b_italic )
590 _slant = 1.0;
591 else
592 _slant = 0.0;
593
594 CFNumberRef slant = CFNumberCreate(NULL, kCFNumberFloatType, &_slant);
595 CFAttributedStringSetAttribute( p_attrString,
596 p_range,
597 kCTFontSlantTrait,
598 slant );
599 CFRelease( slant );
600
601 // Handle foreground colour
602 CGColorSpaceRef rgbColorSpace = CGColorSpaceCreateDeviceRGB();
603 CGFloat components[] = { (float)((i_font_color & 0x00ff0000) >> 16) / 255.0,
604 (float)((i_font_color & 0x0000ff00) >> 8) / 255.0,
605 (float)((i_font_color & 0x000000ff) ) / 255.0,
606 (float)(255-((i_font_color & 0xff000000) >> 24)) / 255.0 };
607 CGColorRef fg_text = CGColorCreate(rgbColorSpace, components);
608 CGColorSpaceRelease(rgbColorSpace);
609
610 CFAttributedStringSetAttribute( p_attrString,
611 p_range,
612 kCTForegroundColorAttributeName,
613 fg_text );
614 CFRelease( fg_text );
615
616 }
617
618 static void GetAttrStrFromFontStack( font_stack_t **p_fonts,
619 bool b_bold, bool b_italic, bool b_uline,
620 CFRange p_range, CFMutableAttributedStringRef p_attrString )
621 {
622 char *psz_fontname = NULL;
623 int i_font_size = 0;
624 uint32_t i_font_color = 0;
625
626 if( VLC_SUCCESS == PeekFont( p_fonts, &psz_fontname, &i_font_size,
627 &i_font_color ))
628 {
629 setFontAttibutes( psz_fontname,
630 i_font_size,
631 i_font_color,
632 b_bold, b_italic, b_uline,
633 p_range,
634 p_attrString );
635 }
636 }
637
638 static int ProcessNodes( filter_t *p_filter,
639 xml_reader_t *p_xml_reader,
640 text_style_t *p_font_style,
641 CFMutableAttributedStringRef p_attrString )
642 {
643 int rv = VLC_SUCCESS;
644 filter_sys_t *p_sys = p_filter->p_sys;
645 font_stack_t *p_fonts = NULL;
646 vlc_value_t val;
647 int i_scale = 1000;
648
649 char *psz_node = NULL;
650
651 bool b_italic = false;
652 bool b_bold = false;
653 bool b_uline = false;
654
655 if( VLC_SUCCESS == var_Get( p_filter, "scale", &val ))
656 i_scale = val.i_int;
657
658 if( p_font_style )
659 {
660 rv = PushFont( &p_fonts,
661 p_font_style->psz_fontname,
662 p_font_style->i_font_size * i_scale / 1000,
663 (p_font_style->i_font_color & 0xffffff) |
664 ((p_font_style->i_font_alpha & 0xff) << 24) );
665
666 if( p_font_style->i_style_flags & STYLE_BOLD )
667 b_bold = true;
668 if( p_font_style->i_style_flags & STYLE_ITALIC )
669 b_italic = true;
670 if( p_font_style->i_style_flags & STYLE_UNDERLINE )
671 b_uline = true;
672 }
673 else
674 {
675 rv = PushFont( &p_fonts,
676 p_sys->psz_font_name,
677 p_sys->i_font_size,
678 p_sys->i_font_color );
679 }
680 if( rv != VLC_SUCCESS )
681 return rv;
682
683 while ( ( xml_ReaderRead( p_xml_reader ) == 1 ) )
684 {
685 switch ( xml_ReaderNodeType( p_xml_reader ) )
686 {
687 case XML_READER_NONE:
688 break;
689 case XML_READER_ENDELEM:
690 psz_node = xml_ReaderName( p_xml_reader );
691
692 if( psz_node )
693 {
694 if( !strcasecmp( "font", psz_node ) )
695 PopFont( &p_fonts );
696 else if( !strcasecmp( "b", psz_node ) )
697 b_bold = false;
698 else if( !strcasecmp( "i", psz_node ) )
699 b_italic = false;
700 else if( !strcasecmp( "u", psz_node ) )
701 b_uline = false;
702
703 free( psz_node );
704 }
705 break;
706 case XML_READER_STARTELEM:
707 psz_node = xml_ReaderName( p_xml_reader );
708 if( psz_node )
709 {
710 if( !strcasecmp( "font", psz_node ) )
711 rv = HandleFontAttributes( p_xml_reader, &p_fonts, i_scale );
712 else if( !strcasecmp( "b", psz_node ) )
713 b_bold = true;
714 else if( !strcasecmp( "i", psz_node ) )
715 b_italic = true;
716 else if( !strcasecmp( "u", psz_node ) )
717 b_uline = true;
718 else if( !strcasecmp( "br", psz_node ) )
719 {
720 CFMutableAttributedStringRef p_attrnode = CFAttributedStringCreateMutable(kCFAllocatorDefault, 0);
721 CFAttributedStringReplaceString( p_attrnode, CFRangeMake(0, 0), CFSTR("\n") );
722
723 GetAttrStrFromFontStack( &p_fonts, b_bold, b_italic, b_uline,
724 CFRangeMake( 0, 1 ),
725 p_attrnode );
726 CFAttributedStringReplaceAttributedString( p_attrString,
727 CFRangeMake(CFAttributedStringGetLength(p_attrString), 0),
728 p_attrnode);
729 CFRelease( p_attrnode );
730 }
731 free( psz_node );
732 }
733 break;
734 case XML_READER_TEXT:
735 psz_node = xml_ReaderValue( p_xml_reader );
736 if( psz_node )
737 {
738 CFStringRef p_cfString;
739 int len;
740
741 // Turn any multiple-whitespaces into single spaces
742 char *s = strpbrk( psz_node, "\t\r\n " );
743 while( s )
744 {
745 int i_whitespace = strspn( s, "\t\r\n " );
746
747 if( i_whitespace > 1 )
748 memmove( &s[1],
749 &s[i_whitespace],
750 strlen( s ) - i_whitespace + 1 );
751 *s++ = ' ';
752
753 s = strpbrk( s, "\t\r\n " );
754 }
755
756
757 CFMutableAttributedStringRef p_attrnode = CFAttributedStringCreateMutable(kCFAllocatorDefault, 0);
758 p_cfString = CFStringCreateWithCString( NULL, psz_node, kCFStringEncodingUTF8 );
759 CFAttributedStringReplaceString( p_attrnode, CFRangeMake(0, 0), p_cfString );
760 CFRelease( p_cfString );
761 len = CFAttributedStringGetLength( p_attrnode );
762
763 GetAttrStrFromFontStack( &p_fonts, b_bold, b_italic, b_uline,
764 CFRangeMake( 0, len ),
765 p_attrnode );
766
767 CFAttributedStringReplaceAttributedString( p_attrString,
768 CFRangeMake(CFAttributedStringGetLength(p_attrString), 0),
769 p_attrnode);
770 CFRelease( p_attrnode );
771 free( psz_node );
772 }
773 break;
774 }
775 }
776
777 while( VLC_SUCCESS == PopFont( &p_fonts ) );
778
779 return rv;
780 }
781
782 static int RenderHtml( filter_t *p_filter, subpicture_region_t *p_region_out,
783 subpicture_region_t *p_region_in )
784 {
785 int rv = VLC_SUCCESS;
786 stream_t *p_sub = NULL;
787 xml_t *p_xml = NULL;
788 xml_reader_t *p_xml_reader = NULL;
789
790 if( !p_region_in || !p_region_in->psz_html )
791 return VLC_EGENERIC;
792
793 /* Reset the default fontsize in case screen metrics have changed */
794 p_filter->p_sys->i_font_size = GetFontSize( p_filter );
795
796 p_sub = stream_MemoryNew( VLC_OBJECT(p_filter),
797 (uint8_t *) p_region_in->psz_html,
798 strlen( p_region_in->psz_html ),
799 true );
800 if( p_sub )
801 {
802 p_xml = xml_Create( p_filter );
803 if( p_xml )
804 {
805 bool b_karaoke = false;
806
807 p_xml_reader = xml_ReaderCreate( p_xml, p_sub );
808 if( p_xml_reader )
809 {
810 /* Look for Root Node */
811 if( xml_ReaderRead( p_xml_reader ) == 1 )
812 {
813 char *psz_node = xml_ReaderName( p_xml_reader );
814
815 if( !strcasecmp( "karaoke", psz_node ) )
816 {
817 /* We're going to have to render the text a number
818 * of times to show the progress marker on the text.
819 */
820 var_SetBool( p_filter, "text-rerender", true );
821 b_karaoke = true;
822 }
823 else if( !strcasecmp( "text", psz_node ) )
824 {
825 b_karaoke = false;
826 }
827 else
828 {
829 /* Only text and karaoke tags are supported */
830 xml_ReaderDelete( p_xml_reader );
831 p_xml_reader = NULL;
832 rv = VLC_EGENERIC;
833 }
834
835 free( psz_node );
836 }
837 }
838
839 if( p_xml_reader )
840 {
841 int i_len;
842
843 CFMutableAttributedStringRef p_attrString = CFAttributedStringCreateMutable(kCFAllocatorDefault, 0);
844 rv = ProcessNodes( p_filter, p_xml_reader,
845 p_region_in->p_style, p_attrString );
846
847 i_len = CFAttributedStringGetLength( p_attrString );
848
849 p_region_out->i_x = p_region_in->i_x;
850 p_region_out->i_y = p_region_in->i_y;
851
852 if(( rv == VLC_SUCCESS ) && ( i_len > 0 ))
853 {
854 RenderYUVA( p_filter, p_region_out, p_attrString );
855 }
856 CFRelease(p_attrString);
857
858 xml_ReaderDelete( p_xml_reader );
859 }
860 xml_Delete( p_xml );
861 }
862 stream_Delete( p_sub );
863 }
864
865 return rv;
866 }
867
868 static CGContextRef CreateOffScreenContext( int i_width, int i_height,
869 offscreen_bitmap_t **pp_memory, CGColorSpaceRef *pp_colorSpace )
870 {
871 offscreen_bitmap_t *p_bitmap;
872 CGContextRef p_context = NULL;
873
874 p_bitmap = (offscreen_bitmap_t *) malloc( sizeof( offscreen_bitmap_t ));
875 if( p_bitmap )
876 {
877 p_bitmap->i_bitsPerChannel = 8;
878 p_bitmap->i_bitsPerPixel = 4 * p_bitmap->i_bitsPerChannel; // A,R,G,B
879 p_bitmap->i_bytesPerPixel = p_bitmap->i_bitsPerPixel / 8;
880 p_bitmap->i_bytesPerRow = i_width * p_bitmap->i_bytesPerPixel;
881
882 p_bitmap->p_data = calloc( i_height, p_bitmap->i_bytesPerRow );
883
884 *pp_colorSpace = CGColorSpaceCreateWithName( kCGColorSpaceGenericRGB );
885
886 if( p_bitmap->p_data && *pp_colorSpace )
887 {
888 p_context = CGBitmapContextCreate( p_bitmap->p_data, i_width, i_height,
889 p_bitmap->i_bitsPerChannel, p_bitmap->i_bytesPerRow,
890 *pp_colorSpace, kCGImageAlphaPremultipliedFirst);
891 }
892 if( p_context )
893 {
894 if( CGContextSetAllowsAntialiasing != NULL )
895 {
896 CGContextSetAllowsAntialiasing( p_context, true );
897 }
898 }
899 *pp_memory = p_bitmap;
900 }
901
902 return p_context;
903 }
904
905 static offscreen_bitmap_t *Compose( int i_text_align,
906 CFMutableAttributedStringRef p_attrString,
907 unsigned i_width,
908 unsigned i_height,
909 unsigned *pi_textblock_height )
910 {
911 offscreen_bitmap_t *p_offScreen = NULL;
912 CGColorSpaceRef p_colorSpace = NULL;
913 CGContextRef p_context = NULL;
914
915 p_context = CreateOffScreenContext( i_width, i_height, &p_offScreen, &p_colorSpace );
916
917 *pi_textblock_height = 0;
918 if( p_context )
919 {
920 float horiz_flush;
921
922 CGContextSetTextMatrix( p_context, CGAffineTransformIdentity );
923
924 if( i_text_align == SUBPICTURE_ALIGN_RIGHT )
925 horiz_flush = 1.0;
926 else if( i_text_align != SUBPICTURE_ALIGN_LEFT )
927 horiz_flush = 0.5;
928 else
929 horiz_flush = 0.0;
930
931 // Create the framesetter with the attributed string.
932 CTFramesetterRef framesetter = CTFramesetterCreateWithAttributedString(p_attrString);
933 if( framesetter )
934 {
935 CTFrameRef frame;
936 CGMutablePathRef p_path = CGPathCreateMutable();
937 CGRect p_bounds = CGRectMake( (float)HORIZONTAL_MARGIN,
938 (float)VERTICAL_MARGIN,
939 (float)(i_width - HORIZONTAL_MARGIN*2),
940 (float)(i_height - VERTICAL_MARGIN *2));
941 CGPathAddRect( p_path, NULL, p_bounds );
942
943 // Create the frame and draw it into the graphics context
944 frame = CTFramesetterCreateFrame(framesetter, CFRangeMake(0, 0), p_path, NULL);
945
946 CGPathRelease(p_path);
947
948 // Set up black outlining of the text --
949 CGContextSetRGBStrokeColor( p_context, 0, 0, 0, 0.5 );
950 CGContextSetTextDrawingMode( p_context, kCGTextFillStroke );
951
952 if( frame != NULL )
953 {
954 CFArrayRef lines;
955 CGPoint penPosition;
956
957 lines = CTFrameGetLines( frame );
958 penPosition.y = i_height;
959 for (int i=0; i<CFArrayGetCount( lines ); i++)
960 {
961 CGFloat ascent, descent, leading;
962
963 CTLineRef line = (CTLineRef)CFArrayGetValueAtIndex(lines, i);
964 CTLineGetTypographicBounds(line, &ascent, &descent, &leading);
965
966 // Set the outlining for this line to be dependant on the size of the line -
967 // make it about 5% of the ascent, with a minimum at 1.0
968 float f_thickness = ascent * 0.05;
969 CGContextSetLineWidth( p_context, (( f_thickness > 1.0 ) ? 1.0 : f_thickness ));
970
971 double penOffset = CTLineGetPenOffsetForFlush(line, horiz_flush, (i_width - HORIZONTAL_MARGIN*2));
972 penPosition.x = HORIZONTAL_MARGIN + penOffset;
973 penPosition.y -= ascent;
974 CGContextSetTextPosition( p_context, penPosition.x, penPosition.y );
975 CTLineDraw( line, p_context );
976 penPosition.y -= descent + leading;
977
978 }
979 *pi_textblock_height = i_height - penPosition.y;
980
981 CFRelease(frame);
982 }
983 CFRelease(framesetter);
984 }
985 CGContextFlush( p_context );
986 CGContextRelease( p_context );
987 }
988 if( p_colorSpace ) CGColorSpaceRelease( p_colorSpace );
989
990 return p_offScreen;
991 }
992
993 static int GetFontSize( filter_t *p_filter )
994 {
995 return p_filter->fmt_out.video.i_height / DEFAULT_REL_FONT_SIZE;
996 }
997
998 static int RenderYUVA( filter_t *p_filter, subpicture_region_t *p_region,
999 CFMutableAttributedStringRef p_attrString )
1000 {
1001 offscreen_bitmap_t *p_offScreen = NULL;
1002 unsigned i_textblock_height = 0;
1003
1004 unsigned i_width = p_filter->fmt_out.video.i_visible_width;
1005 unsigned i_height = p_filter->fmt_out.video.i_visible_height;
1006 unsigned i_text_align = p_region->i_align & 0x3;
1007
1008 if( !p_attrString )
1009 {
1010 msg_Err( p_filter, "Invalid argument to RenderYUVA" );
1011 return VLC_EGENERIC;
1012 }
1013
1014 p_offScreen = Compose( i_text_align, p_attrString,
1015 i_width, i_height, &i_textblock_height );
1016
1017 if( !p_offScreen )
1018 {
1019 msg_Err( p_filter, "No offscreen buffer" );
1020 return VLC_EGENERIC;
1021 }
1022
1023 uint8_t *p_dst_y,*p_dst_u,*p_dst_v,*p_dst_a;
1024 video_format_t fmt;
1025 int i_offset;
1026 unsigned x, y, i_pitch;
1027 uint8_t i_y, i_u, i_v; // YUV values, derived from incoming RGB
1028
1029 // Create a new subpicture region
1030 memset( &fmt, 0, sizeof(video_format_t) );
1031 fmt.i_chroma = VLC_CODEC_YUVA;
1032 fmt.i_width = fmt.i_visible_width = i_width;
1033 fmt.i_height = fmt.i_visible_height = __MIN( i_height, i_textblock_height + VERTICAL_MARGIN * 2);
1034 fmt.i_x_offset = fmt.i_y_offset = 0;
1035
1036 p_region->p_picture = picture_NewFromFormat( &fmt );
1037 if( !p_region->p_picture )
1038 return VLC_EGENERIC;
1039 p_region->fmt = fmt;
1040
1041 p_dst_y = p_region->p_picture->Y_PIXELS;
1042 p_dst_u = p_region->p_picture->U_PIXELS;
1043 p_dst_v = p_region->p_picture->V_PIXELS;
1044 p_dst_a = p_region->p_picture->A_PIXELS;
1045 i_pitch = p_region->p_picture->A_PITCH;
1046
1047 i_offset = (i_height + VERTICAL_MARGIN < fmt.i_height) ? VERTICAL_MARGIN *i_pitch : 0 ;
1048 for( y = 0; y < fmt.i_height; y++)
1049 {
1050 for( x = 0; x < fmt.i_width; x++)
1051 {
1052 int i_alpha = p_offScreen->p_data[ y * p_offScreen->i_bytesPerRow + x * p_offScreen->i_bytesPerPixel ];
1053 int i_red = p_offScreen->p_data[ y * p_offScreen->i_bytesPerRow + x * p_offScreen->i_bytesPerPixel + 1 ];
1054 int i_green = p_offScreen->p_data[ y * p_offScreen->i_bytesPerRow + x * p_offScreen->i_bytesPerPixel + 2 ];
1055 int i_blue = p_offScreen->p_data[ y * p_offScreen->i_bytesPerRow + x * p_offScreen->i_bytesPerPixel + 3 ];
1056
1057 i_y = (uint8_t)__MIN(abs( 2104 * i_red + 4130 * i_green +
1058 802 * i_blue + 4096 + 131072 ) >> 13, 235);
1059 i_u = (uint8_t)__MIN(abs( -1214 * i_red + -2384 * i_green +
1060 3598 * i_blue + 4096 + 1048576) >> 13, 240);
1061 i_v = (uint8_t)__MIN(abs( 3598 * i_red + -3013 * i_green +
1062 -585 * i_blue + 4096 + 1048576) >> 13, 240);
1063
1064 p_dst_y[ i_offset + x ] = i_y;
1065 p_dst_u[ i_offset + x ] = i_u;
1066 p_dst_v[ i_offset + x ] = i_v;
1067 p_dst_a[ i_offset + x ] = i_alpha;
1068 }
1069 i_offset += i_pitch;
1070 }
1071
1072 free( p_offScreen->p_data );
1073 free( p_offScreen );
1074
1075 return VLC_SUCCESS;
1076 }