?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
NEWS updates
[vlc/solaris.git] / modules / misc / quartztext.c
blob732f276f2c1d90a2af50fafd6e513ef089f332e6
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 overriden." )
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, NULL, FONT_TEXT, FONT_LONGTEXT,
113 false )
114 add_integer( "quartztext-rel-fontsize", DEFAULT_REL_FONT_SIZE, NULL, FONTSIZER_TEXT,
115 FONTSIZER_LONGTEXT, false )
116 change_integer_list( pi_sizes, ppsz_sizes_text, NULL );
117 add_integer( "quartztext-color", 0x00FFFFFF, NULL, COLOR_TEXT,
118 COLOR_LONGTEXT, false )
119 change_integer_list( pi_color_values, ppsz_color_descriptions, NULL );
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_thread_t *p_input;
236 input_attachment_t **pp_attachments;
237 int i_attachments_cnt;
238 int k;
239 int rv = VLC_SUCCESS;
240
241 p_input = (input_thread_t *)vlc_object_find( p_filter, VLC_OBJECT_INPUT, FIND_PARENT );
242 if( ! p_input )
243 return VLC_EGENERIC;
244
245 if( VLC_SUCCESS != input_Control( p_input, INPUT_GET_ATTACHMENTS, &pp_attachments, &i_attachments_cnt ))
246 {
247 vlc_object_release(p_input);
248 return VLC_EGENERIC;
249 }
250
251 p_sys->i_fonts = 0;
252 p_sys->p_fonts = malloc( i_attachments_cnt * sizeof( ATSFontContainerRef ) );
253 if(! p_sys->p_fonts )
254 rv = VLC_ENOMEM;
255
256 for( k = 0; k < i_attachments_cnt; k++ )
257 {
258 input_attachment_t *p_attach = pp_attachments[k];
259
260 if( p_sys->p_fonts )
261 {
262 if(( !strcmp( p_attach->psz_mime, "application/x-truetype-font" ) || // TTF
263 !strcmp( p_attach->psz_mime, "application/x-font-otf" ) ) && // OTF
264 ( p_attach->i_data > 0 ) &&
265 ( p_attach->p_data != NULL ) )
266 {
267 ATSFontContainerRef container;
268
269 if( noErr == ATSFontActivateFromMemory( p_attach->p_data,
270 p_attach->i_data,
271 kATSFontContextLocal,
272 kATSFontFormatUnspecified,
273 NULL,
274 kATSOptionFlagsDefault,
275 &container ))
276 {
277 p_sys->p_fonts[ p_sys->i_fonts++ ] = container;
278 }
279 }
280 }
281 vlc_input_attachment_Delete( p_attach );
282 }
283 free( pp_attachments );
284
285 vlc_object_release(p_input);
286
287 return rv;
288 }
289
290 static char *EliminateCRLF( char *psz_string )
291 {
292 char *p;
293 char *q;
294
295 for( p = psz_string; p && *p; p++ )
296 {
297 if( ( *p == '\r' ) && ( *(p+1) == '\n' ) )
298 {
299 for( q = p + 1; *q; q++ )
300 *( q - 1 ) = *q;
301
302 *( q - 1 ) = '\0';
303 }
304 }
305 return psz_string;
306 }
307
308 // Renders a text subpicture region into another one.
309 // It is used as pf_add_string callback in the vout method by this module
310 static int RenderText( filter_t *p_filter, subpicture_region_t *p_region_out,
311 subpicture_region_t *p_region_in )
312 {
313 filter_sys_t *p_sys = p_filter->p_sys;
314 char *psz_string;
315 int i_font_alpha, i_font_size;
316 uint32_t i_font_color;
317 bool b_bold, b_uline, b_italic;
318 vlc_value_t val;
319 int i_scale = 1000;
320 b_bold = b_uline = b_italic = FALSE;
321
322 p_sys->i_font_size = GetFontSize( p_filter );
323
324 // Sanity check
325 if( !p_region_in || !p_region_out ) return VLC_EGENERIC;
326 psz_string = p_region_in->psz_text;
327 if( !psz_string || !*psz_string ) return VLC_EGENERIC;
328
329 if( VLC_SUCCESS == var_Get( p_filter, "scale", &val ))
330 i_scale = val.i_int;
331
332 if( p_region_in->p_style )
333 {
334 i_font_color = __MAX( __MIN( p_region_in->p_style->i_font_color, 0xFFFFFF ), 0 );
335 i_font_alpha = __MAX( __MIN( p_region_in->p_style->i_font_alpha, 255 ), 0 );
336 i_font_size = __MAX( __MIN( p_region_in->p_style->i_font_size, 255 ), 0 ) * i_scale / 1000;
337 if( p_region_in->p_style->i_style_flags )
338 {
339 if( p_region_in->p_style->i_style_flags & STYLE_BOLD )
340 b_bold = TRUE;
341 if( p_region_in->p_style->i_style_flags & STYLE_ITALIC )
342 b_italic = TRUE;
343 if( p_region_in->p_style->i_style_flags & STYLE_UNDERLINE )
344 b_uline = TRUE;
345 }
346 }
347 else
348 {
349 i_font_color = p_sys->i_font_color;
350 i_font_alpha = 255 - p_sys->i_font_opacity;
351 i_font_size = p_sys->i_font_size;
352 }
353
354 if( !i_font_alpha ) i_font_alpha = 255 - p_sys->i_font_opacity;
355
356 if( i_font_size <= 0 )
357 {
358 msg_Warn( p_filter, "invalid fontsize, using 12" );
359 if( VLC_SUCCESS == var_Get( p_filter, "scale", &val ))
360 i_font_size = 12 * val.i_int / 1000;
361 else
362 i_font_size = 12;
363 }
364
365 p_region_out->i_x = p_region_in->i_x;
366 p_region_out->i_y = p_region_in->i_y;
367
368 CFMutableAttributedStringRef p_attrString = CFAttributedStringCreateMutable(kCFAllocatorDefault, 0);
369
370 if( p_attrString )
371 {
372 CFStringRef p_cfString;
373 int len;
374
375 EliminateCRLF( psz_string);
376 p_cfString = CFStringCreateWithCString( NULL, psz_string, kCFStringEncodingUTF8 );
377 CFAttributedStringReplaceString( p_attrString, CFRangeMake(0, 0), p_cfString );
378 CFRelease( p_cfString );
379 len = CFAttributedStringGetLength( p_attrString );
380
381 setFontAttibutes( p_sys->psz_font_name, i_font_size, i_font_color, b_bold, b_italic, b_uline,
382 CFRangeMake( 0, len ), p_attrString);
383
384 RenderYUVA( p_filter, p_region_out, p_attrString );
385 }
386 CFRelease(p_attrString);
387
388 return VLC_SUCCESS;
389 }
390
391
392 static int PushFont( font_stack_t **p_font, const char *psz_name, int i_size,
393 uint32_t i_color )
394 {
395 font_stack_t *p_new;
396
397 if( !p_font )
398 return VLC_EGENERIC;
399
400 p_new = malloc( sizeof( font_stack_t ) );
401 if( ! p_new )
402 return VLC_ENOMEM;
403
404 p_new->p_next = NULL;
405
406 if( psz_name )
407 p_new->psz_name = strdup( psz_name );
408 else
409 p_new->psz_name = NULL;
410
411 p_new->i_size = i_size;
412 p_new->i_color = i_color;
413
414 if( !*p_font )
415 {
416 *p_font = p_new;
417 }
418 else
419 {
420 font_stack_t *p_last;
421
422 for( p_last = *p_font;
423 p_last->p_next;
424 p_last = p_last->p_next )
425 ;
426
427 p_last->p_next = p_new;
428 }
429 return VLC_SUCCESS;
430 }
431
432 static int PopFont( font_stack_t **p_font )
433 {
434 font_stack_t *p_last, *p_next_to_last;
435
436 if( !p_font || !*p_font )
437 return VLC_EGENERIC;
438
439 p_next_to_last = NULL;
440 for( p_last = *p_font;
441 p_last->p_next;
442 p_last = p_last->p_next )
443 {
444 p_next_to_last = p_last;
445 }
446
447 if( p_next_to_last )
448 p_next_to_last->p_next = NULL;
449 else
450 *p_font = NULL;
451
452 free( p_last->psz_name );
453 free( p_last );
454
455 return VLC_SUCCESS;
456 }
457
458 static int PeekFont( font_stack_t **p_font, char **psz_name, int *i_size,
459 uint32_t *i_color )
460 {
461 font_stack_t *p_last;
462
463 if( !p_font || !*p_font )
464 return VLC_EGENERIC;
465
466 for( p_last=*p_font;
467 p_last->p_next;
468 p_last=p_last->p_next )
469 ;
470
471 *psz_name = p_last->psz_name;
472 *i_size = p_last->i_size;
473 *i_color = p_last->i_color;
474
475 return VLC_SUCCESS;
476 }
477
478 static int HandleFontAttributes( xml_reader_t *p_xml_reader,
479 font_stack_t **p_fonts, int i_scale )
480 {
481 int rv;
482 char *psz_fontname = NULL;
483 uint32_t i_font_color = 0xffffff;
484 int i_font_alpha = 0;
485 int i_font_size = 24;
486
487 // Default all attributes to the top font in the stack -- in case not
488 // all attributes are specified in the sub-font
489 if( VLC_SUCCESS == PeekFont( p_fonts,
490 &psz_fontname,
491 &i_font_size,
492 &i_font_color ))
493 {
494 psz_fontname = strdup( psz_fontname );
495 i_font_size = i_font_size * 1000 / i_scale;
496 }
497 i_font_alpha = (i_font_color >> 24) & 0xff;
498 i_font_color &= 0x00ffffff;
499
500 while ( xml_ReaderNextAttr( p_xml_reader ) == VLC_SUCCESS )
501 {
502 char *psz_name = xml_ReaderName( p_xml_reader );
503 char *psz_value = xml_ReaderValue( p_xml_reader );
504
505 if( psz_name && psz_value )
506 {
507 if( !strcasecmp( "face", psz_name ) )
508 {
509 free( psz_fontname );
510 psz_fontname = strdup( psz_value );
511 }
512 else if( !strcasecmp( "size", psz_name ) )
513 {
514 if( ( *psz_value == '+' ) || ( *psz_value == '-' ) )
515 {
516 int i_value = atoi( psz_value );
517
518 if( ( i_value >= -5 ) && ( i_value <= 5 ) )
519 i_font_size += ( i_value * i_font_size ) / 10;
520 else if( i_value < -5 )
521 i_font_size = - i_value;
522 else if( i_value > 5 )
523 i_font_size = i_value;
524 }
525 else
526 i_font_size = atoi( psz_value );
527 }
528 else if( !strcasecmp( "color", psz_name ) &&
529 ( psz_value[0] == '#' ) )
530 {
531 i_font_color = strtol( psz_value + 1, NULL, 16 );
532 i_font_color &= 0x00ffffff;
533 }
534 else if( !strcasecmp( "alpha", psz_name ) &&
535 ( psz_value[0] == '#' ) )
536 {
537 i_font_alpha = strtol( psz_value + 1, NULL, 16 );
538 i_font_alpha &= 0xff;
539 }
540 free( psz_name );
541 free( psz_value );
542 }
543 }
544 rv = PushFont( p_fonts,
545 psz_fontname,
546 i_font_size * i_scale / 1000,
547 (i_font_color & 0xffffff) | ((i_font_alpha & 0xff) << 24) );
548
549 free( psz_fontname );
550
551 return rv;
552 }
553
554 static void setFontAttibutes( char *psz_fontname, int i_font_size, uint32_t i_font_color,
555 bool b_bold, bool b_italic, bool b_underline,
556 CFRange p_range, CFMutableAttributedStringRef p_attrString )
557 {
558 CFStringRef p_cfString;
559 CTFontRef p_font;
560
561 // Handle font name and size
562 p_cfString = CFStringCreateWithCString( NULL,
563 psz_fontname,
564 kCFStringEncodingUTF8 );
565 p_font = CTFontCreateWithName( p_cfString,
566 (float)i_font_size,
567 NULL );
568 CFRelease( p_cfString );
569 CFAttributedStringSetAttribute( p_attrString,
570 p_range,
571 kCTFontAttributeName,
572 p_font );
573 CFRelease( p_font );
574
575 // Handle Underline
576 SInt32 _uline;
577 if( b_underline )
578 _uline = kCTUnderlineStyleSingle;
579 else
580 _uline = kCTUnderlineStyleNone;
581
582 CFNumberRef underline = CFNumberCreate(NULL, kCFNumberSInt32Type, &_uline);
583 CFAttributedStringSetAttribute( p_attrString,
584 p_range,
585 kCTUnderlineStyleAttributeName,
586 underline );
587 CFRelease( underline );
588
589 // Handle Bold
590 float _weight;
591 if( b_bold )
592 _weight = 0.5;
593 else
594 _weight = 0.0;
595
596 CFNumberRef weight = CFNumberCreate(NULL, kCFNumberFloatType, &_weight);
597 CFAttributedStringSetAttribute( p_attrString,
598 p_range,
599 kCTFontWeightTrait,
600 weight );
601 CFRelease( weight );
602
603 // Handle Italic
604 float _slant;
605 if( b_italic )
606 _slant = 1.0;
607 else
608 _slant = 0.0;
609
610 CFNumberRef slant = CFNumberCreate(NULL, kCFNumberFloatType, &_slant);
611 CFAttributedStringSetAttribute( p_attrString,
612 p_range,
613 kCTFontSlantTrait,
614 slant );
615 CFRelease( slant );
616
617 // Handle foreground colour
618 CGColorSpaceRef rgbColorSpace = CGColorSpaceCreateDeviceRGB();
619 CGFloat components[] = { (float)((i_font_color & 0x00ff0000) >> 16) / 255.0,
620 (float)((i_font_color & 0x0000ff00) >> 8) / 255.0,
621 (float)((i_font_color & 0x000000ff) ) / 255.0,
622 (float)(255-((i_font_color & 0xff000000) >> 24)) / 255.0 };
623 CGColorRef fg_text = CGColorCreate(rgbColorSpace, components);
624 CGColorSpaceRelease(rgbColorSpace);
625
626 CFAttributedStringSetAttribute( p_attrString,
627 p_range,
628 kCTForegroundColorAttributeName,
629 fg_text );
630 CFRelease( fg_text );
631
632 }
633
634 static void GetAttrStrFromFontStack( font_stack_t **p_fonts,
635 bool b_bold, bool b_italic, bool b_uline,
636 CFRange p_range, CFMutableAttributedStringRef p_attrString )
637 {
638 char *psz_fontname = NULL;
639 int i_font_size = 0;
640 uint32_t i_font_color = 0;
641
642 if( VLC_SUCCESS == PeekFont( p_fonts, &psz_fontname, &i_font_size,
643 &i_font_color ))
644 {
645 setFontAttibutes( psz_fontname,
646 i_font_size,
647 i_font_color,
648 b_bold, b_italic, b_uline,
649 p_range,
650 p_attrString );
651 }
652 }
653
654 static int ProcessNodes( filter_t *p_filter,
655 xml_reader_t *p_xml_reader,
656 text_style_t *p_font_style,
657 CFMutableAttributedStringRef p_attrString )
658 {
659 int rv = VLC_SUCCESS;
660 filter_sys_t *p_sys = p_filter->p_sys;
661 font_stack_t *p_fonts = NULL;
662 vlc_value_t val;
663 int i_scale = 1000;
664
665 char *psz_node = NULL;
666
667 bool b_italic = false;
668 bool b_bold = false;
669 bool b_uline = false;
670
671 if( VLC_SUCCESS == var_Get( p_filter, "scale", &val ))
672 i_scale = val.i_int;
673
674 if( p_font_style )
675 {
676 rv = PushFont( &p_fonts,
677 p_font_style->psz_fontname,
678 p_font_style->i_font_size * i_scale / 1000,
679 (p_font_style->i_font_color & 0xffffff) |
680 ((p_font_style->i_font_alpha & 0xff) << 24) );
681
682 if( p_font_style->i_style_flags & STYLE_BOLD )
683 b_bold = true;
684 if( p_font_style->i_style_flags & STYLE_ITALIC )
685 b_italic = true;
686 if( p_font_style->i_style_flags & STYLE_UNDERLINE )
687 b_uline = true;
688 }
689 else
690 {
691 rv = PushFont( &p_fonts,
692 p_sys->psz_font_name,
693 p_sys->i_font_size,
694 p_sys->i_font_color );
695 }
696 if( rv != VLC_SUCCESS )
697 return rv;
698
699 while ( ( xml_ReaderRead( p_xml_reader ) == 1 ) )
700 {
701 switch ( xml_ReaderNodeType( p_xml_reader ) )
702 {
703 case XML_READER_NONE:
704 break;
705 case XML_READER_ENDELEM:
706 psz_node = xml_ReaderName( p_xml_reader );
707
708 if( psz_node )
709 {
710 if( !strcasecmp( "font", psz_node ) )
711 PopFont( &p_fonts );
712 else if( !strcasecmp( "b", psz_node ) )
713 b_bold = false;
714 else if( !strcasecmp( "i", psz_node ) )
715 b_italic = false;
716 else if( !strcasecmp( "u", psz_node ) )
717 b_uline = false;
718
719 free( psz_node );
720 }
721 break;
722 case XML_READER_STARTELEM:
723 psz_node = xml_ReaderName( p_xml_reader );
724 if( psz_node )
725 {
726 if( !strcasecmp( "font", psz_node ) )
727 rv = HandleFontAttributes( p_xml_reader, &p_fonts, i_scale );
728 else if( !strcasecmp( "b", psz_node ) )
729 b_bold = true;
730 else if( !strcasecmp( "i", psz_node ) )
731 b_italic = true;
732 else if( !strcasecmp( "u", psz_node ) )
733 b_uline = true;
734 else if( !strcasecmp( "br", psz_node ) )
735 {
736 CFMutableAttributedStringRef p_attrnode = CFAttributedStringCreateMutable(kCFAllocatorDefault, 0);
737 CFAttributedStringReplaceString( p_attrnode, CFRangeMake(0, 0), CFSTR("\n") );
738
739 GetAttrStrFromFontStack( &p_fonts, b_bold, b_italic, b_uline,
740 CFRangeMake( 0, 1 ),
741 p_attrnode );
742 CFAttributedStringReplaceAttributedString( p_attrString,
743 CFRangeMake(CFAttributedStringGetLength(p_attrString), 0),
744 p_attrnode);
745 CFRelease( p_attrnode );
746 }
747 free( psz_node );
748 }
749 break;
750 case XML_READER_TEXT:
751 psz_node = xml_ReaderValue( p_xml_reader );
752 if( psz_node )
753 {
754 CFStringRef p_cfString;
755 int len;
756
757 // Turn any multiple-whitespaces into single spaces
758 char *s = strpbrk( psz_node, "\t\r\n " );
759 while( s )
760 {
761 int i_whitespace = strspn( s, "\t\r\n " );
762
763 if( i_whitespace > 1 )
764 memmove( &s[1],
765 &s[i_whitespace],
766 strlen( s ) - i_whitespace + 1 );
767 *s++ = ' ';
768
769 s = strpbrk( s, "\t\r\n " );
770 }
771
772
773 CFMutableAttributedStringRef p_attrnode = CFAttributedStringCreateMutable(kCFAllocatorDefault, 0);
774 p_cfString = CFStringCreateWithCString( NULL, psz_node, kCFStringEncodingUTF8 );
775 CFAttributedStringReplaceString( p_attrnode, CFRangeMake(0, 0), p_cfString );
776 CFRelease( p_cfString );
777 len = CFAttributedStringGetLength( p_attrnode );
778
779 GetAttrStrFromFontStack( &p_fonts, b_bold, b_italic, b_uline,
780 CFRangeMake( 0, len ),
781 p_attrnode );
782
783 CFAttributedStringReplaceAttributedString( p_attrString,
784 CFRangeMake(CFAttributedStringGetLength(p_attrString), 0),
785 p_attrnode);
786 CFRelease( p_attrnode );
787 free( psz_node );
788 }
789 break;
790 }
791 }
792
793 while( VLC_SUCCESS == PopFont( &p_fonts ) );
794
795 return rv;
796 }
797
798 static int RenderHtml( filter_t *p_filter, subpicture_region_t *p_region_out,
799 subpicture_region_t *p_region_in )
800 {
801 int rv = VLC_SUCCESS;
802 stream_t *p_sub = NULL;
803 xml_t *p_xml = NULL;
804 xml_reader_t *p_xml_reader = NULL;
805
806 if( !p_region_in || !p_region_in->psz_html )
807 return VLC_EGENERIC;
808
809 /* Reset the default fontsize in case screen metrics have changed */
810 p_filter->p_sys->i_font_size = GetFontSize( p_filter );
811
812 p_sub = stream_MemoryNew( VLC_OBJECT(p_filter),
813 (uint8_t *) p_region_in->psz_html,
814 strlen( p_region_in->psz_html ),
815 true );
816 if( p_sub )
817 {
818 p_xml = xml_Create( p_filter );
819 if( p_xml )
820 {
821 bool b_karaoke = false;
822
823 p_xml_reader = xml_ReaderCreate( p_xml, p_sub );
824 if( p_xml_reader )
825 {
826 /* Look for Root Node */
827 if( xml_ReaderRead( p_xml_reader ) == 1 )
828 {
829 char *psz_node = xml_ReaderName( p_xml_reader );
830
831 if( !strcasecmp( "karaoke", psz_node ) )
832 {
833 /* We're going to have to render the text a number
834 * of times to show the progress marker on the text.
835 */
836 var_SetBool( p_filter, "text-rerender", true );
837 b_karaoke = true;
838 }
839 else if( !strcasecmp( "text", psz_node ) )
840 {
841 b_karaoke = false;
842 }
843 else
844 {
845 /* Only text and karaoke tags are supported */
846 xml_ReaderDelete( p_xml, p_xml_reader );
847 p_xml_reader = NULL;
848 rv = VLC_EGENERIC;
849 }
850
851 free( psz_node );
852 }
853 }
854
855 if( p_xml_reader )
856 {
857 int i_len;
858
859 CFMutableAttributedStringRef p_attrString = CFAttributedStringCreateMutable(kCFAllocatorDefault, 0);
860 rv = ProcessNodes( p_filter, p_xml_reader,
861 p_region_in->p_style, p_attrString );
862
863 i_len = CFAttributedStringGetLength( p_attrString );
864
865 p_region_out->i_x = p_region_in->i_x;
866 p_region_out->i_y = p_region_in->i_y;
867
868 if(( rv == VLC_SUCCESS ) && ( i_len > 0 ))
869 {
870 RenderYUVA( p_filter, p_region_out, p_attrString );
871 }
872 CFRelease(p_attrString);
873
874 xml_ReaderDelete( p_xml, p_xml_reader );
875 }
876 xml_Delete( p_xml );
877 }
878 stream_Delete( p_sub );
879 }
880
881 return rv;
882 }
883
884 static CGContextRef CreateOffScreenContext( int i_width, int i_height,
885 offscreen_bitmap_t **pp_memory, CGColorSpaceRef *pp_colorSpace )
886 {
887 offscreen_bitmap_t *p_bitmap;
888 CGContextRef p_context = NULL;
889
890 p_bitmap = (offscreen_bitmap_t *) malloc( sizeof( offscreen_bitmap_t ));
891 if( p_bitmap )
892 {
893 p_bitmap->i_bitsPerChannel = 8;
894 p_bitmap->i_bitsPerPixel = 4 * p_bitmap->i_bitsPerChannel; // A,R,G,B
895 p_bitmap->i_bytesPerPixel = p_bitmap->i_bitsPerPixel / 8;
896 p_bitmap->i_bytesPerRow = i_width * p_bitmap->i_bytesPerPixel;
897
898 p_bitmap->p_data = calloc( i_height, p_bitmap->i_bytesPerRow );
899
900 *pp_colorSpace = CGColorSpaceCreateWithName( kCGColorSpaceGenericRGB );
901
902 if( p_bitmap->p_data && *pp_colorSpace )
903 {
904 p_context = CGBitmapContextCreate( p_bitmap->p_data, i_width, i_height,
905 p_bitmap->i_bitsPerChannel, p_bitmap->i_bytesPerRow,
906 *pp_colorSpace, kCGImageAlphaPremultipliedFirst);
907 }
908 if( p_context )
909 {
910 if( CGContextSetAllowsAntialiasing != NULL )
911 {
912 CGContextSetAllowsAntialiasing( p_context, true );
913 }
914 }
915 *pp_memory = p_bitmap;
916 }
917
918 return p_context;
919 }
920
921 static offscreen_bitmap_t *Compose( int i_text_align,
922 CFMutableAttributedStringRef p_attrString,
923 unsigned i_width,
924 unsigned i_height,
925 unsigned *pi_textblock_height )
926 {
927 offscreen_bitmap_t *p_offScreen = NULL;
928 CGColorSpaceRef p_colorSpace = NULL;
929 CGContextRef p_context = NULL;
930
931 p_context = CreateOffScreenContext( i_width, i_height, &p_offScreen, &p_colorSpace );
932
933 *pi_textblock_height = 0;
934 if( p_context )
935 {
936 float horiz_flush;
937
938 CGContextSetTextMatrix( p_context, CGAffineTransformIdentity );
939
940 if( i_text_align == SUBPICTURE_ALIGN_RIGHT )
941 horiz_flush = 1.0;
942 else if( i_text_align != SUBPICTURE_ALIGN_LEFT )
943 horiz_flush = 0.5;
944 else
945 horiz_flush = 0.0;
946
947 // Create the framesetter with the attributed string.
948 CTFramesetterRef framesetter = CTFramesetterCreateWithAttributedString(p_attrString);
949 if( framesetter )
950 {
951 CTFrameRef frame;
952 CGMutablePathRef p_path = CGPathCreateMutable();
953 CGRect p_bounds = CGRectMake( (float)HORIZONTAL_MARGIN,
954 (float)VERTICAL_MARGIN,
955 (float)(i_width - HORIZONTAL_MARGIN*2),
956 (float)(i_height - VERTICAL_MARGIN *2));
957 CGPathAddRect( p_path, NULL, p_bounds );
958
959 // Create the frame and draw it into the graphics context
960 frame = CTFramesetterCreateFrame(framesetter, CFRangeMake(0, 0), p_path, NULL);
961
962 CGPathRelease(p_path);
963
964 // Set up black outlining of the text --
965 CGContextSetRGBStrokeColor( p_context, 0, 0, 0, 0.5 );
966 CGContextSetTextDrawingMode( p_context, kCGTextFillStroke );
967
968 if( frame != NULL )
969 {
970 CFArrayRef lines;
971 CGPoint penPosition;
972
973 lines = CTFrameGetLines( frame );
974 penPosition.y = i_height;
975 for (int i=0; i<CFArrayGetCount( lines ); i++)
976 {
977 CGFloat ascent, descent, leading;
978
979 CTLineRef line = (CTLineRef)CFArrayGetValueAtIndex(lines, i);
980 CTLineGetTypographicBounds(line, &ascent, &descent, &leading);
981
982 // Set the outlining for this line to be dependant on the size of the line -
983 // make it about 5% of the ascent, with a minimum at 1.0
984 float f_thickness = ascent * 0.05;
985 CGContextSetLineWidth( p_context, (( f_thickness > 1.0 ) ? 1.0 : f_thickness ));
986
987 double penOffset = CTLineGetPenOffsetForFlush(line, horiz_flush, (i_width - HORIZONTAL_MARGIN*2));
988 penPosition.x = HORIZONTAL_MARGIN + penOffset;
989 penPosition.y -= ascent;
990 CGContextSetTextPosition( p_context, penPosition.x, penPosition.y );
991 CTLineDraw( line, p_context );
992 penPosition.y -= descent + leading;
993
994 }
995 *pi_textblock_height = i_height - penPosition.y;
996
997 CFRelease(frame);
998 }
999 CFRelease(framesetter);
1000 }
1001 CGContextFlush( p_context );
1002 CGContextRelease( p_context );
1003 }
1004 if( p_colorSpace ) CGColorSpaceRelease( p_colorSpace );
1005
1006 return p_offScreen;
1007 }
1008
1009 static int GetFontSize( filter_t *p_filter )
1010 {
1011 return p_filter->fmt_out.video.i_height / DEFAULT_REL_FONT_SIZE;
1012 }
1013
1014 static int RenderYUVA( filter_t *p_filter, subpicture_region_t *p_region,
1015 CFMutableAttributedStringRef p_attrString )
1016 {
1017 offscreen_bitmap_t *p_offScreen = NULL;
1018 unsigned i_textblock_height = 0;
1019
1020 unsigned i_width = p_filter->fmt_out.video.i_visible_width;
1021 unsigned i_height = p_filter->fmt_out.video.i_visible_height;
1022 unsigned i_text_align = p_region->i_align & 0x3;
1023
1024 if( !p_attrString )
1025 {
1026 msg_Err( p_filter, "Invalid argument to RenderYUVA" );
1027 return VLC_EGENERIC;
1028 }
1029
1030 p_offScreen = Compose( i_text_align, p_attrString,
1031 i_width, i_height, &i_textblock_height );
1032
1033 if( !p_offScreen )
1034 {
1035 msg_Err( p_filter, "No offscreen buffer" );
1036 return VLC_EGENERIC;
1037 }
1038
1039 uint8_t *p_dst_y,*p_dst_u,*p_dst_v,*p_dst_a;
1040 video_format_t fmt;
1041 int i_offset;
1042 unsigned x, y, i_pitch;
1043 uint8_t i_y, i_u, i_v; // YUV values, derived from incoming RGB
1044
1045 // Create a new subpicture region
1046 memset( &fmt, 0, sizeof(video_format_t) );
1047 fmt.i_chroma = VLC_CODEC_YUVA;
1048 fmt.i_width = fmt.i_visible_width = i_width;
1049 fmt.i_height = fmt.i_visible_height = __MIN( i_height, i_textblock_height + VERTICAL_MARGIN * 2);
1050 fmt.i_x_offset = fmt.i_y_offset = 0;
1051
1052 p_region->p_picture = picture_NewFromFormat( &fmt );
1053 if( !p_region->p_picture )
1054 return VLC_EGENERIC;
1055 p_region->fmt = fmt;
1056
1057 p_dst_y = p_region->p_picture->Y_PIXELS;
1058 p_dst_u = p_region->p_picture->U_PIXELS;
1059 p_dst_v = p_region->p_picture->V_PIXELS;
1060 p_dst_a = p_region->p_picture->A_PIXELS;
1061 i_pitch = p_region->p_picture->A_PITCH;
1062
1063 i_offset = (i_height + VERTICAL_MARGIN < fmt.i_height) ? VERTICAL_MARGIN *i_pitch : 0 ;
1064 for( y = 0; y < fmt.i_height; y++)
1065 {
1066 for( x = 0; x < fmt.i_width; x++)
1067 {
1068 int i_alpha = p_offScreen->p_data[ y * p_offScreen->i_bytesPerRow + x * p_offScreen->i_bytesPerPixel ];
1069 int i_red = p_offScreen->p_data[ y * p_offScreen->i_bytesPerRow + x * p_offScreen->i_bytesPerPixel + 1 ];
1070 int i_green = p_offScreen->p_data[ y * p_offScreen->i_bytesPerRow + x * p_offScreen->i_bytesPerPixel + 2 ];
1071 int i_blue = p_offScreen->p_data[ y * p_offScreen->i_bytesPerRow + x * p_offScreen->i_bytesPerPixel + 3 ];
1072
1073 i_y = (uint8_t)__MIN(abs( 2104 * i_red + 4130 * i_green +
1074 802 * i_blue + 4096 + 131072 ) >> 13, 235);
1075 i_u = (uint8_t)__MIN(abs( -1214 * i_red + -2384 * i_green +
1076 3598 * i_blue + 4096 + 1048576) >> 13, 240);
1077 i_v = (uint8_t)__MIN(abs( 3598 * i_red + -3013 * i_green +
1078 -585 * i_blue + 4096 + 1048576) >> 13, 240);
1079
1080 p_dst_y[ i_offset + x ] = i_y;
1081 p_dst_u[ i_offset + x ] = i_u;
1082 p_dst_v[ i_offset + x ] = i_v;
1083 p_dst_a[ i_offset + x ] = i_alpha;
1084 }
1085 i_offset += i_pitch;
1086 }
1087
1088 free( p_offScreen->p_data );
1089 free( p_offScreen );
1090
1091 return VLC_SUCCESS;
1092 }
VLC Solaris and OpenSolaris fixes