git.sesse.net Git - vlc/blob - modules/text_renderer/freetype.c

   1 /*****************************************************************************
   2  * freetype.c : Put text on the video, using freetype2
   3  *****************************************************************************
   4  * Copyright (C) 2002 - 2011 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Sigmund Augdal Helberg <dnumgis@videolan.org>
   8  *          Gildas Bazin <gbazin@videolan.org>
   9  *          Bernie Purcell <bitmap@videolan.org>
  10  *          Jean-Baptiste Kempf <jb@videolan.org>
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software Foundation, Inc.,
  24  * 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  25  *****************************************************************************/
  26
  27 /*****************************************************************************
  28  * Preamble
  29  *****************************************************************************/
  30
  31 #ifdef HAVE_CONFIG_H
  32 # include "config.h"
  33 #endif
  34 #include <math.h>
  35
  36 #include <vlc_common.h>
  37 #include <vlc_plugin.h>
  38 #include <vlc_stream.h>                        /* stream_MemoryNew */
  39 #include <vlc_input.h>                         /* vlc_input_attachment_* */
  40 #include <vlc_xml.h>                           /* xml_reader */
  41 #include <vlc_strings.h>                       /* resolve_xml_special_chars */
  42 #include <vlc_charset.h>                       /* ToCharset */
  43 #include <vlc_dialog.h>                        /* FcCache dialog */
  44 #include <vlc_filter.h>                                      /* filter_sys_t */
  45 #include <vlc_text_style.h>                                   /* text_style_t*/
  46
  47 /* Default fonts */
  48 #ifdef __APPLE__
  49 # define DEFAULT_FONT_FILE "/Library/Fonts/Arial Unicode.ttf"
  50 # define DEFAULT_FAMILY "Arial Unicode MS"
  51 #elif defined( WIN32 )
  52 # define DEFAULT_FONT_FILE "arial.ttf" /* Default path font found at run-time */
  53 # define DEFAULT_FAMILY "Arial"
  54 #elif defined( __OS2__ )
  55 # define DEFAULT_FONT_FILE "/psfonts/tnrwt_k.ttf"
  56 # define DEFAULT_FAMILY "Times New Roman WT K"
  57 #elif defined( HAVE_MAEMO )
  58 # define DEFAULT_FONT_FILE "/usr/share/fonts/nokia/nosnb.ttf"
  59 # define DEFAULT_FAMILY "Nokia Sans Bold"
  60 #else
  61 # define DEFAULT_FONT_FILE "/usr/share/fonts/truetype/freefont/FreeSerifBold.ttf"
  62 # define DEFAULT_FAMILY "Serif Bold"
  63 #endif
  64
  65 /* Freetype */
  66 #include <freetype/ftsynth.h>
  67 #include FT_FREETYPE_H
  68 #include FT_GLYPH_H
  69 #include FT_STROKER_H
  70
  71 #define FT_FLOOR(X)     ((X & -64) >> 6)
  72 #define FT_CEIL(X)      (((X + 63) & -64) >> 6)
  73 #ifndef FT_MulFix
  74  #define FT_MulFix(v, s) (((v)*(s))>>16)
  75 #endif
  76
  77 /* RTL */
  78 #if defined(HAVE_FRIBIDI)
  79 # include <fribidi/fribidi.h>
  80 #endif
  81
  82 /* Win32 GDI */
  83 #ifdef WIN32
  84 # include <windows.h>
  85 # include <shlobj.h>
  86 # define HAVE_STYLES
  87 # undef HAVE_FONTCONFIG
  88 #endif
  89
  90 /* FontConfig */
  91 #ifdef HAVE_FONTCONFIG
  92 # include <fontconfig/fontconfig.h>
  93 # define HAVE_STYLES
  94 #endif
  95
  96 #include <assert.h>
  97
  98 #ifdef __OS2__
  99 typedef uint16_t uni_char_t;
 100 # define FREETYPE_TO_UCS    "UCS-2LE"
 101 #else
 102 typedef uint32_t uni_char_t;
 103 # if defined(WORDS_BIGENDIAN)
 104 #  define FREETYPE_TO_UCS   "UCS-4BE"
 105 # else
 106 #  define FREETYPE_TO_UCS   "UCS-4LE"
 107 # endif
 108 #endif
 109
 110 /*****************************************************************************
 111  * Module descriptor
 112  *****************************************************************************/
 113 static int  Create ( vlc_object_t * );
 114 static void Destroy( vlc_object_t * );
 115
 116 #define FONT_TEXT N_("Font")
 117
 118 #define FAMILY_LONGTEXT N_("Font family for the font you want to use")
 119 #define FONT_LONGTEXT N_("Font file for the font you want to use")
 120
 121 #define FONTSIZE_TEXT N_("Font size in pixels")
 122 #define FONTSIZE_LONGTEXT N_("This is the default size of the fonts " \
 123     "that will be rendered on the video. " \
 124     "If set to something different than 0 this option will override the " \
 125     "relative font size." )
 126 #define OPACITY_TEXT N_("Text opacity")
 127 #define OPACITY_LONGTEXT N_("The opacity (inverse of transparency) of the " \
 128     "text that will be rendered on the video. 0 = transparent, " \
 129     "255 = totally opaque. " )
 130 #define COLOR_TEXT N_("Text default color")
 131 #define COLOR_LONGTEXT N_("The color of the text that will be rendered on "\
 132     "the video. This must be an hexadecimal (like HTML colors). The first two "\
 133     "chars are for red, then green, then blue. #000000 = black, #FF0000 = red,"\
 134     " #00FF00 = green, #FFFF00 = yellow (red + green), #FFFFFF = white" )
 135 #define FONTSIZER_TEXT N_("Relative font size")
 136 #define FONTSIZER_LONGTEXT N_("This is the relative default size of the " \
 137     "fonts that will be rendered on the video. If absolute font size is set, "\
 138     "relative size will be overridden." )
 139 #define BOLD_TEXT N_("Force bold")
 140
 141 #define BG_OPACITY_TEXT N_("Background opacity")
 142 #define BG_COLOR_TEXT N_("Background color")
 143
 144 #define OUTLINE_OPACITY_TEXT N_("Outline opacity")
 145 #define OUTLINE_COLOR_TEXT N_("Outline color")
 146 #define OUTLINE_THICKNESS_TEXT N_("Outline thickness")
 147
 148 #define SHADOW_OPACITY_TEXT N_("Shadow opacity")
 149 #define SHADOW_COLOR_TEXT N_("Shadow color")
 150 #define SHADOW_ANGLE_TEXT N_("Shadow angle")
 151 #define SHADOW_DISTANCE_TEXT N_("Shadow distance")
 152
 153
 154 static const int pi_sizes[] = { 20, 18, 16, 12, 6 };
 155 static const char *const ppsz_sizes_text[] = {
 156     N_("Smaller"), N_("Small"), N_("Normal"), N_("Large"), N_("Larger") };
 157 #define YUVP_TEXT N_("Use YUVP renderer")
 158 #define YUVP_LONGTEXT N_("This renders the font using \"paletized YUV\". " \
 159   "This option is only needed if you want to encode into DVB subtitles" )
 160
 161 static const int pi_color_values[] = {
 162   0x00000000, 0x00808080, 0x00C0C0C0, 0x00FFFFFF, 0x00800000,
 163   0x00FF0000, 0x00FF00FF, 0x00FFFF00, 0x00808000, 0x00008000, 0x00008080,
 164   0x0000FF00, 0x00800080, 0x00000080, 0x000000FF, 0x0000FFFF };
 165
 166 static const char *const ppsz_color_descriptions[] = {
 167   N_("Black"), N_("Gray"), N_("Silver"), N_("White"), N_("Maroon"),
 168   N_("Red"), N_("Fuchsia"), N_("Yellow"), N_("Olive"), N_("Green"), N_("Teal"),
 169   N_("Lime"), N_("Purple"), N_("Navy"), N_("Blue"), N_("Aqua") };
 170
 171 static const int pi_outline_thickness[] = {
 172     0, 2, 4, 6,
 173 };
 174 static const char *const ppsz_outline_thickness[] = {
 175     N_("None"), N_("Thin"), N_("Normal"), N_("Thick"),
 176 };
 177
 178 vlc_module_begin ()
 179     set_shortname( N_("Text renderer"))
 180     set_description( N_("Freetype2 font renderer") )
 181     set_category( CAT_VIDEO )
 182     set_subcategory( SUBCAT_VIDEO_SUBPIC )
 183
 184 #ifdef HAVE_STYLES
 185     add_font( "freetype-font", DEFAULT_FAMILY, FONT_TEXT, FAMILY_LONGTEXT, false )
 186 #else
 187     add_loadfile( "freetype-font", DEFAULT_FONT_FILE, FONT_TEXT, FONT_LONGTEXT, false )
 188 #endif
 189
 190     add_integer( "freetype-fontsize", 0, FONTSIZE_TEXT,
 191                  FONTSIZE_LONGTEXT, true )
 192         change_integer_range( 0, 4096)
 193         change_safe()
 194
 195     add_integer( "freetype-rel-fontsize", 16, FONTSIZER_TEXT,
 196                  FONTSIZER_LONGTEXT, false )
 197         change_integer_list( pi_sizes, ppsz_sizes_text )
 198         change_safe()
 199
 200     /* opacity valid on 0..255, with default 255 = fully opaque */
 201     add_integer_with_range( "freetype-opacity", 255, 0, 255,
 202         OPACITY_TEXT, OPACITY_LONGTEXT, false )
 203         change_safe()
 204
 205     /* hook to the color values list, with default 0x00ffffff = white */
 206     add_rgb( "freetype-color", 0x00FFFFFF, COLOR_TEXT,
 207                  COLOR_LONGTEXT, false )
 208         change_integer_list( pi_color_values, ppsz_color_descriptions )
 209         change_safe()
 210
 211     add_bool( "freetype-bold", false, BOLD_TEXT, NULL, false )
 212         change_safe()
 213
 214     add_integer_with_range( "freetype-background-opacity", 0, 0, 255,
 215                             BG_OPACITY_TEXT, NULL, false )
 216         change_safe()
 217     add_rgb( "freetype-background-color", 0x00000000, BG_COLOR_TEXT,
 218              NULL, false )
 219         change_integer_list( pi_color_values, ppsz_color_descriptions )
 220         change_safe()
 221
 222     add_integer_with_range( "freetype-outline-opacity", 255, 0, 255,
 223                             OUTLINE_OPACITY_TEXT, NULL, false )
 224         change_safe()
 225     add_rgb( "freetype-outline-color", 0x00000000, OUTLINE_COLOR_TEXT,
 226              NULL, false )
 227         change_integer_list( pi_color_values, ppsz_color_descriptions )
 228         change_safe()
 229     add_integer_with_range( "freetype-outline-thickness", 4, 0, 50, OUTLINE_THICKNESS_TEXT,
 230              NULL, false )
 231         change_integer_list( pi_outline_thickness, ppsz_outline_thickness )
 232         change_safe()
 233
 234     add_integer_with_range( "freetype-shadow-opacity", 128, 0, 255,
 235                             SHADOW_OPACITY_TEXT, NULL, false )
 236         change_safe()
 237     add_rgb( "freetype-shadow-color", 0x00000000, SHADOW_COLOR_TEXT,
 238              NULL, false )
 239         change_integer_list( pi_color_values, ppsz_color_descriptions )
 240         change_safe()
 241     add_float_with_range( "freetype-shadow-angle", -45, -360, 360,
 242                           SHADOW_ANGLE_TEXT, NULL, false )
 243         change_safe()
 244     add_float_with_range( "freetype-shadow-distance", 0.06, 0.0, 1.0,
 245                           SHADOW_DISTANCE_TEXT, NULL, false )
 246         change_safe()
 247
 248     add_obsolete_integer( "freetype-effect" );
 249
 250     add_bool( "freetype-yuvp", false, YUVP_TEXT,
 251               YUVP_LONGTEXT, true )
 252     set_capability( "text renderer", 100 )
 253     add_shortcut( "text" )
 254     set_callbacks( Create, Destroy )
 255 vlc_module_end ()
 256
 257
 258 /*****************************************************************************
 259  * Local prototypes
 260  *****************************************************************************/
 261
 262 typedef struct
 263 {
 264     FT_BitmapGlyph p_glyph;
 265     FT_BitmapGlyph p_outline;
 266     FT_BitmapGlyph p_shadow;
 267     uint32_t       i_color;             /* ARGB color */
 268     int            i_line_offset;       /* underline/strikethrough offset */
 269     int            i_line_thickness;    /* underline/strikethrough thickness */
 270 } line_character_t;
 271
 272 typedef struct line_desc_t line_desc_t;
 273 struct line_desc_t
 274 {
 275     line_desc_t      *p_next;
 276
 277     int              i_width;
 278     int              i_base_line;
 279     int              i_character_count;
 280     line_character_t *p_character;
 281 };
 282
 283 typedef struct font_stack_t font_stack_t;
 284 struct font_stack_t
 285 {
 286     char          *psz_name;
 287     int            i_size;
 288     uint32_t       i_color;            /* ARGB */
 289     uint32_t       i_karaoke_bg_color; /* ARGB */
 290
 291     font_stack_t  *p_next;
 292 };
 293
 294 /*****************************************************************************
 295  * filter_sys_t: freetype local data
 296  *****************************************************************************
 297  * This structure is part of the video output thread descriptor.
 298  * It describes the freetype specific properties of an output thread.
 299  *****************************************************************************/
 300 struct filter_sys_t
 301 {
 302     FT_Library     p_library;   /* handle to library     */
 303     FT_Face        p_face;      /* handle to face object */
 304     FT_Stroker     p_stroker;
 305     uint8_t        i_font_opacity;
 306     int            i_font_color;
 307     int            i_font_size;
 308     bool           b_font_bold;
 309
 310     uint8_t        i_background_opacity;
 311     int            i_background_color;
 312
 313     double         f_outline_thickness;
 314     uint8_t        i_outline_opacity;
 315     int            i_outline_color;
 316
 317     float          f_shadow_vector_x;
 318     float          f_shadow_vector_y;
 319     uint8_t        i_shadow_opacity;
 320     int            i_shadow_color;
 321
 322     int            i_default_font_size;
 323     int            i_display_height;
 324     char*          psz_fontfamily;
 325 #ifdef HAVE_STYLES
 326     xml_reader_t  *p_xml;
 327 #ifdef WIN32
 328     char*          psz_win_fonts_path;
 329 #endif
 330 #endif
 331
 332     input_attachment_t **pp_font_attachments;
 333     int                  i_font_attachments;
 334 };
 335
 336 /* */
 337 static void YUVFromRGB( uint32_t i_argb,
 338                     uint8_t *pi_y, uint8_t *pi_u, uint8_t *pi_v )
 339 {
 340     int i_red   = ( i_argb & 0x00ff0000 ) >> 16;
 341     int i_green = ( i_argb & 0x0000ff00 ) >>  8;
 342     int i_blue  = ( i_argb & 0x000000ff );
 343
 344     *pi_y = (uint8_t)__MIN(abs( 2104 * i_red  + 4130 * i_green +
 345                       802 * i_blue + 4096 + 131072 ) >> 13, 235);
 346     *pi_u = (uint8_t)__MIN(abs( -1214 * i_red  + -2384 * i_green +
 347                      3598 * i_blue + 4096 + 1048576) >> 13, 240);
 348     *pi_v = (uint8_t)__MIN(abs( 3598 * i_red + -3013 * i_green +
 349                       -585 * i_blue + 4096 + 1048576) >> 13, 240);
 350 }
 351 static void RGBFromRGB( uint32_t i_argb,
 352                         uint8_t *pi_r, uint8_t *pi_g, uint8_t *pi_b )
 353 {
 354     *pi_r = ( i_argb & 0x00ff0000 ) >> 16;
 355     *pi_g = ( i_argb & 0x0000ff00 ) >>  8;
 356     *pi_b = ( i_argb & 0x000000ff );
 357 }
 358 /*****************************************************************************
 359  * Make any TTF/OTF fonts present in the attachments of the media file
 360  * and store them for later use by the FreeType Engine
 361  *****************************************************************************/
 362 static int LoadFontsFromAttachments( filter_t *p_filter )
 363 {
 364     filter_sys_t         *p_sys = p_filter->p_sys;
 365     input_attachment_t  **pp_attachments;
 366     int                   i_attachments_cnt;
 367
 368     if( filter_GetInputAttachments( p_filter, &pp_attachments, &i_attachments_cnt ) )
 369         return VLC_EGENERIC;
 370
 371     p_sys->i_font_attachments = 0;
 372     p_sys->pp_font_attachments = malloc( i_attachments_cnt * sizeof(*p_sys->pp_font_attachments));
 373     if( !p_sys->pp_font_attachments )
 374         return VLC_ENOMEM;
 375
 376     for( int k = 0; k < i_attachments_cnt; k++ )
 377     {
 378         input_attachment_t *p_attach = pp_attachments[k];
 379
 380         if( ( !strcmp( p_attach->psz_mime, "application/x-truetype-font" ) || // TTF
 381               !strcmp( p_attach->psz_mime, "application/x-font-otf" ) ) &&    // OTF
 382             p_attach->i_data > 0 && p_attach->p_data )
 383         {
 384             p_sys->pp_font_attachments[ p_sys->i_font_attachments++ ] = p_attach;
 385         }
 386         else
 387         {
 388             vlc_input_attachment_Delete( p_attach );
 389         }
 390     }
 391     free( pp_attachments );
 392
 393     return VLC_SUCCESS;
 394 }
 395
 396 static int GetFontSize( filter_t *p_filter )
 397 {
 398     filter_sys_t *p_sys = p_filter->p_sys;
 399     int           i_size = 0;
 400
 401     if( p_sys->i_default_font_size )
 402     {
 403         i_size = p_sys->i_default_font_size;
 404     }
 405     else
 406     {
 407         int i_ratio = var_GetInteger( p_filter, "freetype-rel-fontsize" );
 408         if( i_ratio > 0 )
 409         {
 410             i_size = (int)p_filter->fmt_out.video.i_height / i_ratio;
 411             p_filter->p_sys->i_display_height = p_filter->fmt_out.video.i_height;
 412         }
 413     }
 414     if( i_size <= 0 )
 415     {
 416         msg_Warn( p_filter, "invalid fontsize, using 12" );
 417         i_size = 12;
 418     }
 419     return i_size;
 420 }
 421
 422 static int SetFontSize( filter_t *p_filter, int i_size )
 423 {
 424     filter_sys_t *p_sys = p_filter->p_sys;
 425
 426     if( !i_size )
 427     {
 428         i_size = GetFontSize( p_filter );
 429
 430         msg_Dbg( p_filter, "using fontsize: %i", i_size );
 431     }
 432
 433     p_sys->i_font_size = i_size;
 434
 435     if( FT_Set_Pixel_Sizes( p_sys->p_face, 0, i_size ) )
 436     {
 437         msg_Err( p_filter, "couldn't set font size to %d", i_size );
 438         return VLC_EGENERIC;
 439     }
 440
 441     return VLC_SUCCESS;
 442 }
 443
 444 #ifdef HAVE_STYLES
 445 #ifdef HAVE_FONTCONFIG
 446 static void FontConfig_BuildCache( filter_t *p_filter )
 447 {
 448     /* */
 449     msg_Dbg( p_filter, "Building font databases.");
 450     mtime_t t1, t2;
 451     t1 = mdate();
 452
 453 #ifdef __OS2__
 454     FcInit();
 455 #endif
 456
 457 #if defined( WIN32 ) || defined( __APPLE__ )
 458     dialog_progress_bar_t *p_dialog = NULL;
 459     FcConfig *fcConfig = FcInitLoadConfig();
 460
 461     p_dialog = dialog_ProgressCreate( p_filter,
 462             _("Building font cache"),
 463             _("Please wait while your font cache is rebuilt.\n"
 464                 "This should take less than a few minutes."), NULL );
 465
 466 /*    if( p_dialog )
 467         dialog_ProgressSet( p_dialog, NULL, 0.5 ); */
 468
 469     FcConfigBuildFonts( fcConfig );
 470 #if defined( __APPLE__ )
 471     // By default, scan only the directory /System/Library/Fonts.
 472     // So build the set of available fonts under another directories,
 473     // and add the set to the current configuration.
 474     FcConfigAppFontAddDir( NULL, "~/Library/Fonts" );
 475     FcConfigAppFontAddDir( NULL, "/Library/Fonts" );
 476     FcConfigAppFontAddDir( NULL, "/Network/Library/Fonts" );
 477     //FcConfigAppFontAddDir( NULL, "/System/Library/Fonts" );
 478 #endif
 479     if( p_dialog )
 480     {
 481 //        dialog_ProgressSet( p_dialog, NULL, 1.0 );
 482         dialog_ProgressDestroy( p_dialog );
 483         p_dialog = NULL;
 484     }
 485 #endif
 486     t2 = mdate();
 487     msg_Dbg( p_filter, "Took %ld microseconds", (long)((t2 - t1)) );
 488 }
 489
 490 /***
 491  * \brief Selects a font matching family, bold, italic provided
 492  ***/
 493 static char* FontConfig_Select( FcConfig* config, const char* family,
 494                           bool b_bold, bool b_italic, int i_size, int *i_idx )
 495 {
 496     FcResult result = FcResultMatch;
 497     FcPattern *pat, *p_pat;
 498     FcChar8* val_s;
 499     FcBool val_b;
 500
 501     /* Create a pattern and fills it */
 502     pat = FcPatternCreate();
 503     if (!pat) return NULL;
 504
 505     /* */
 506     FcPatternAddString( pat, FC_FAMILY, (const FcChar8*)family );
 507     FcPatternAddBool( pat, FC_OUTLINE, FcTrue );
 508     FcPatternAddInteger( pat, FC_SLANT, b_italic ? FC_SLANT_ITALIC : FC_SLANT_ROMAN );
 509     FcPatternAddInteger( pat, FC_WEIGHT, b_bold ? FC_WEIGHT_EXTRABOLD : FC_WEIGHT_NORMAL );
 510     if( i_size != -1 )
 511     {
 512         char *psz_fontsize;
 513         if( asprintf( &psz_fontsize, "%d", i_size ) != -1 )
 514         {
 515             FcPatternAddString( pat, FC_SIZE, (const FcChar8 *)psz_fontsize );
 516             free( psz_fontsize );
 517         }
 518     }
 519
 520     /* */
 521     FcDefaultSubstitute( pat );
 522     if( !FcConfigSubstitute( config, pat, FcMatchPattern ) )
 523     {
 524         FcPatternDestroy( pat );
 525         return NULL;
 526     }
 527
 528     /* Find the best font for the pattern, destroy the pattern */
 529     p_pat = FcFontMatch( config, pat, &result );
 530     FcPatternDestroy( pat );
 531     if( !p_pat || result == FcResultNoMatch ) return NULL;
 532
 533     /* Check the new pattern */
 534     if( ( FcResultMatch != FcPatternGetBool( p_pat, FC_OUTLINE, 0, &val_b ) )
 535         || ( val_b != FcTrue ) )
 536     {
 537         FcPatternDestroy( p_pat );
 538         return NULL;
 539     }
 540     if( FcResultMatch != FcPatternGetInteger( p_pat, FC_INDEX, 0, i_idx ) )
 541     {
 542         *i_idx = 0;
 543     }
 544
 545     if( FcResultMatch != FcPatternGetString( p_pat, FC_FAMILY, 0, &val_s ) )
 546     {
 547         FcPatternDestroy( p_pat );
 548         return NULL;
 549     }
 550
 551     /* if( strcasecmp((const char*)val_s, family ) != 0 )
 552         msg_Warn( p_filter, "fontconfig: selected font family is not"
 553                             "the requested one: '%s' != '%s'\n",
 554                             (const char*)val_s, family );   */
 555
 556     if( FcResultMatch != FcPatternGetString( p_pat, FC_FILE, 0, &val_s ) )
 557     {
 558         FcPatternDestroy( p_pat );
 559         return NULL;
 560     }
 561
 562     FcPatternDestroy( p_pat );
 563     return strdup( (const char*)val_s );
 564 }
 565 #endif
 566
 567 #ifdef WIN32
 568 #define FONT_DIR_NT "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Fonts"
 569
 570 static int GetFileFontByName( const char *font_name, char **psz_filename )
 571 {
 572     HKEY hKey;
 573     wchar_t vbuffer[MAX_PATH];
 574     wchar_t dbuffer[256];
 575
 576     if( RegOpenKeyEx(HKEY_LOCAL_MACHINE, FONT_DIR_NT, 0, KEY_READ, &hKey)
 577             != ERROR_SUCCESS )
 578         return 1;
 579
 580     MultiByteToWideChar( CP_ACP, 0, font_name, -1, dbuffer, 256 );
 581     char *font_name_temp = FromWide( dbuffer );
 582     size_t fontname_len = strlen( font_name_temp );
 583
 584     for( int index = 0;; index++ )
 585     {
 586         DWORD vbuflen = MAX_PATH - 1;
 587         DWORD dbuflen = 255;
 588
 589         LONG i_result = RegEnumValueW( hKey, index, vbuffer, &vbuflen,
 590                                        NULL, NULL, (LPBYTE)dbuffer, &dbuflen);
 591         if( i_result != ERROR_SUCCESS )
 592         {
 593             RegCloseKey( hKey );
 594             return i_result;
 595         }
 596
 597         char *psz_value = FromWide( vbuffer );
 598
 599         char *s = strchr( psz_value,'(' );
 600         if( s != NULL && s != psz_value ) s[-1] = '\0';
 601
 602         /* Manage concatenated font names */
 603         if( strchr( psz_value, '&') ) {
 604             if( strcasestr( psz_value, font_name_temp ) != NULL )
 605             {
 606                 free( psz_value );
 607                 break;
 608             }
 609         }
 610         else {
 611             if( strncasecmp( psz_value, font_name_temp, fontname_len ) == 0 )
 612             {
 613                 free( psz_value );
 614                 break;
 615             }
 616         }
 617
 618         free( psz_value );
 619     }
 620
 621     *psz_filename = FromWide( dbuffer );
 622     free( font_name_temp );
 623     RegCloseKey( hKey );
 624     return 0;
 625 }
 626
 627
 628 static int CALLBACK EnumFontCallback(const ENUMLOGFONTEX *lpelfe, const NEWTEXTMETRICEX *metric,
 629                                      DWORD type, LPARAM lParam)
 630 {
 631     VLC_UNUSED( metric );
 632     if( (type & RASTER_FONTTYPE) ) return 1;
 633     // if( lpelfe->elfScript ) FIXME
 634
 635     return GetFileFontByName( (const char *)lpelfe->elfFullName, (char **)lParam );
 636 }
 637
 638 static char* Win32_Select( filter_t *p_filter, const char* family,
 639                            bool b_bold, bool b_italic, int i_size, int *i_idx )
 640 {
 641     VLC_UNUSED( i_size );
 642
 643     if( !family || strlen( family ) < 1 )
 644         goto fail;
 645
 646     /* */
 647     LOGFONT lf;
 648     lf.lfCharSet = DEFAULT_CHARSET;
 649     if( b_italic )
 650         lf.lfItalic = true;
 651     if( b_bold )
 652         lf.lfWeight = FW_BOLD;
 653
 654     char facename[32];
 655     wchar_t* psz_fbuffer = ToWide( family );
 656     WideCharToMultiByte( CP_ACP, 0, psz_fbuffer, -1, facename, 32, " ", 0 );
 657     strncpy( (LPSTR)&lf.lfFaceName, facename, 32 );
 658     free( psz_fbuffer );
 659
 660     /* */
 661     char *psz_filename = NULL;
 662     HDC hDC = GetDC( NULL );
 663     EnumFontFamiliesEx(hDC, &lf, (FONTENUMPROC)&EnumFontCallback, (LPARAM)&psz_filename, 0);
 664     ReleaseDC(NULL, hDC);
 665
 666     /* */
 667     if( psz_filename != NULL )
 668     {
 669         /* FIXME: increase i_idx, when concatenated strings  */
 670         i_idx = 0;
 671
 672         /* Prepend the Windows Font path, when only a filename was provided */
 673         if( strchr( psz_filename, DIR_SEP_CHAR ) )
 674             return psz_filename;
 675         else
 676         {
 677             char *psz_tmp;
 678             if( asprintf( &psz_tmp, "%s\\%s", p_filter->p_sys->psz_win_fonts_path, psz_filename ) == -1 )
 679             {
 680                 free( psz_filename );
 681                 return NULL;
 682             }
 683             free( psz_filename );
 684             return psz_tmp;
 685         }
 686     }
 687     else /* Let's take any font we can */
 688 fail:
 689     {
 690         char *psz_tmp;
 691         if( asprintf( &psz_tmp, "%s\\%s", p_filter->p_sys->psz_win_fonts_path, "arial.ttf" ) == -1 )
 692             return NULL;
 693         else
 694             return psz_tmp;
 695     }
 696 }
 697 #endif /* HAVE_WIN32 */
 698
 699 #endif /* HAVE_STYLES */
 700
 701
 702 /*****************************************************************************
 703  * RenderYUVP: place string in picture
 704  *****************************************************************************
 705  * This function merges the previously rendered freetype glyphs into a picture
 706  *****************************************************************************/
 707 static int RenderYUVP( filter_t *p_filter, subpicture_region_t *p_region,
 708                        line_desc_t *p_line,
 709                        FT_BBox *p_bbox )
 710 {
 711     VLC_UNUSED(p_filter);
 712     static const uint8_t pi_gamma[16] =
 713         {0x00, 0x52, 0x84, 0x96, 0xb8, 0xca, 0xdc, 0xee, 0xff,
 714           0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 715
 716     uint8_t *p_dst;
 717     video_format_t fmt;
 718     int i, x, y, i_pitch;
 719     uint8_t i_y, i_u, i_v; /* YUV values, derived from incoming RGB */
 720
 721     /* Create a new subpicture region */
 722     video_format_Init( &fmt, VLC_CODEC_YUVP );
 723     fmt.i_width          =
 724     fmt.i_visible_width  = p_bbox->xMax - p_bbox->xMin + 4;
 725     fmt.i_height         =
 726     fmt.i_visible_height = p_bbox->yMax - p_bbox->yMin + 4;
 727
 728     assert( !p_region->p_picture );
 729     p_region->p_picture = picture_NewFromFormat( &fmt );
 730     if( !p_region->p_picture )
 731         return VLC_EGENERIC;
 732     fmt.p_palette = p_region->fmt.p_palette ? p_region->fmt.p_palette : malloc(sizeof(*fmt.p_palette));
 733     p_region->fmt = fmt;
 734
 735     /* Calculate text color components
 736      * Only use the first color */
 737     int i_alpha = (p_line->p_character[0].i_color >> 24) & 0xff;
 738     YUVFromRGB( p_line->p_character[0].i_color, &i_y, &i_u, &i_v );
 739
 740     /* Build palette */
 741     fmt.p_palette->i_entries = 16;
 742     for( i = 0; i < 8; i++ )
 743     {
 744         fmt.p_palette->palette[i][0] = 0;
 745         fmt.p_palette->palette[i][1] = 0x80;
 746         fmt.p_palette->palette[i][2] = 0x80;
 747         fmt.p_palette->palette[i][3] = pi_gamma[i];
 748         fmt.p_palette->palette[i][3] =
 749             (int)fmt.p_palette->palette[i][3] * i_alpha / 255;
 750     }
 751     for( i = 8; i < fmt.p_palette->i_entries; i++ )
 752     {
 753         fmt.p_palette->palette[i][0] = i * 16 * i_y / 256;
 754         fmt.p_palette->palette[i][1] = i_u;
 755         fmt.p_palette->palette[i][2] = i_v;
 756         fmt.p_palette->palette[i][3] = pi_gamma[i];
 757         fmt.p_palette->palette[i][3] =
 758             (int)fmt.p_palette->palette[i][3] * i_alpha / 255;
 759     }
 760
 761     p_dst = p_region->p_picture->Y_PIXELS;
 762     i_pitch = p_region->p_picture->Y_PITCH;
 763
 764     /* Initialize the region pixels */
 765     memset( p_dst, 0, i_pitch * p_region->fmt.i_height );
 766
 767     for( ; p_line != NULL; p_line = p_line->p_next )
 768     {
 769         int i_align_left = 0;
 770         if( p_line->i_width < (int)fmt.i_visible_width )
 771         {
 772             if( (p_region->i_align & 0x3) == SUBPICTURE_ALIGN_RIGHT )
 773                 i_align_left = ( fmt.i_visible_width - p_line->i_width );
 774             else if( (p_region->i_align & 0x3) != SUBPICTURE_ALIGN_LEFT )
 775                 i_align_left = ( fmt.i_visible_width - p_line->i_width ) / 2;
 776         }
 777         int i_align_top = 0;
 778
 779         for( i = 0; i < p_line->i_character_count; i++ )
 780         {
 781             const line_character_t *ch = &p_line->p_character[i];
 782             FT_BitmapGlyph p_glyph = ch->p_glyph;
 783
 784             int i_glyph_y = i_align_top  - p_glyph->top  + p_bbox->yMax + p_line->i_base_line;
 785             int i_glyph_x = i_align_left + p_glyph->left - p_bbox->xMin;
 786
 787             for( y = 0; y < p_glyph->bitmap.rows; y++ )
 788             {
 789                 for( x = 0; x < p_glyph->bitmap.width; x++ )
 790                 {
 791                     if( p_glyph->bitmap.buffer[y * p_glyph->bitmap.width + x] )
 792                         p_dst[(i_glyph_y + y) * i_pitch + (i_glyph_x + x)] =
 793                             (p_glyph->bitmap.buffer[y * p_glyph->bitmap.width + x] + 8)/16;
 794                 }
 795             }
 796         }
 797     }
 798
 799     /* Outlining (find something better than nearest neighbour filtering ?) */
 800     if( 1 )
 801     {
 802         uint8_t *p_dst = p_region->p_picture->Y_PIXELS;
 803         uint8_t *p_top = p_dst; /* Use 1st line as a cache */
 804         uint8_t left, current;
 805
 806         for( y = 1; y < (int)fmt.i_height - 1; y++ )
 807         {
 808             if( y > 1 ) memcpy( p_top, p_dst, fmt.i_width );
 809             p_dst += p_region->p_picture->Y_PITCH;
 810             left = 0;
 811
 812             for( x = 1; x < (int)fmt.i_width - 1; x++ )
 813             {
 814                 current = p_dst[x];
 815                 p_dst[x] = ( 8 * (int)p_dst[x] + left + p_dst[x+1] + p_top[x -1]+ p_top[x] + p_top[x+1] +
 816                              p_dst[x -1 + p_region->p_picture->Y_PITCH ] + p_dst[x + p_region->p_picture->Y_PITCH] + p_dst[x + 1 + p_region->p_picture->Y_PITCH]) / 16;
 817                 left = current;
 818             }
 819         }
 820         memset( p_top, 0, fmt.i_width );
 821     }
 822
 823     return VLC_SUCCESS;
 824 }
 825
 826 /*****************************************************************************
 827  * RenderYUVA: place string in picture
 828  *****************************************************************************
 829  * This function merges the previously rendered freetype glyphs into a picture
 830  *****************************************************************************/
 831 static void FillYUVAPicture( picture_t *p_picture,
 832                              int i_a, int i_y, int i_u, int i_v )
 833 {
 834     memset( p_picture->p[0].p_pixels, i_y,
 835             p_picture->p[0].i_pitch * p_picture->p[0].i_lines );
 836     memset( p_picture->p[1].p_pixels, i_u,
 837             p_picture->p[1].i_pitch * p_picture->p[1].i_lines );
 838     memset( p_picture->p[2].p_pixels, i_v,
 839             p_picture->p[2].i_pitch * p_picture->p[2].i_lines );
 840     memset( p_picture->p[3].p_pixels, i_a,
 841             p_picture->p[3].i_pitch * p_picture->p[3].i_lines );
 842 }
 843
 844 static inline void BlendYUVAPixel( picture_t *p_picture,
 845                                    int i_picture_x, int i_picture_y,
 846                                    int i_a, int i_y, int i_u, int i_v,
 847                                    int i_alpha )
 848 {
 849     int i_an = i_a * i_alpha / 255;
 850
 851     uint8_t *p_y = &p_picture->p[0].p_pixels[i_picture_y * p_picture->p[0].i_pitch + i_picture_x];
 852     uint8_t *p_u = &p_picture->p[1].p_pixels[i_picture_y * p_picture->p[1].i_pitch + i_picture_x];
 853     uint8_t *p_v = &p_picture->p[2].p_pixels[i_picture_y * p_picture->p[2].i_pitch + i_picture_x];
 854     uint8_t *p_a = &p_picture->p[3].p_pixels[i_picture_y * p_picture->p[3].i_pitch + i_picture_x];
 855
 856     int i_ao = *p_a;
 857     if( i_ao == 0 )
 858     {
 859         *p_y = i_y;
 860         *p_u = i_u;
 861         *p_v = i_v;
 862         *p_a = i_an;
 863     }
 864     else
 865     {
 866         *p_a = 255 - (255 - *p_a) * (255 - i_an) / 255;
 867         if( *p_a != 0 )
 868         {
 869             *p_y = ( *p_y * i_ao * (255 - i_an) / 255 + i_y * i_an ) / *p_a;
 870             *p_u = ( *p_u * i_ao * (255 - i_an) / 255 + i_u * i_an ) / *p_a;
 871             *p_v = ( *p_v * i_ao * (255 - i_an) / 255 + i_v * i_an ) / *p_a;
 872         }
 873     }
 874 }
 875
 876 static void FillRGBAPicture( picture_t *p_picture,
 877                              int i_a, int i_r, int i_g, int i_b )
 878 {
 879     for( int dy = 0; dy < p_picture->p[0].i_visible_lines; dy++ )
 880     {
 881         for( int dx = 0; dx < p_picture->p[0].i_visible_pitch; dx += 4 )
 882         {
 883             uint8_t *p_rgba = &p_picture->p->p_pixels[dy * p_picture->p->i_pitch + dx];
 884             p_rgba[0] = i_r;
 885             p_rgba[1] = i_g;
 886             p_rgba[2] = i_b;
 887             p_rgba[3] = i_a;
 888         }
 889     }
 890 }
 891
 892 static inline void BlendRGBAPixel( picture_t *p_picture,
 893                                    int i_picture_x, int i_picture_y,
 894                                    int i_a, int i_r, int i_g, int i_b,
 895                                    int i_alpha )
 896 {
 897     int i_an = i_a * i_alpha / 255;
 898
 899     uint8_t *p_rgba = &p_picture->p->p_pixels[i_picture_y * p_picture->p->i_pitch + 4 * i_picture_x];
 900
 901     int i_ao = p_rgba[3];
 902     if( i_ao == 0 )
 903     {
 904         p_rgba[0] = i_r;
 905         p_rgba[1] = i_g;
 906         p_rgba[2] = i_b;
 907         p_rgba[3] = i_an;
 908     }
 909     else
 910     {
 911         p_rgba[3] = 255 - (255 - p_rgba[3]) * (255 - i_an) / 255;
 912         if( p_rgba[3] != 0 )
 913         {
 914             p_rgba[0] = ( p_rgba[0] * i_ao * (255 - i_an) / 255 + i_r * i_an ) / p_rgba[3];
 915             p_rgba[1] = ( p_rgba[1] * i_ao * (255 - i_an) / 255 + i_g * i_an ) / p_rgba[3];
 916             p_rgba[2] = ( p_rgba[2] * i_ao * (255 - i_an) / 255 + i_b * i_an ) / p_rgba[3];
 917         }
 918     }
 919 }
 920
 921 static inline void BlendAXYZGlyph( picture_t *p_picture,
 922                                    int i_picture_x, int i_picture_y,
 923                                    int i_a, int i_x, int i_y, int i_z,
 924                                    FT_BitmapGlyph p_glyph,
 925                                    void (*BlendPixel)(picture_t *, int, int, int, int, int, int, int) )
 926
 927 {
 928     for( int dy = 0; dy < p_glyph->bitmap.rows; dy++ )
 929     {
 930         for( int dx = 0; dx < p_glyph->bitmap.width; dx++ )
 931             BlendPixel( p_picture, i_picture_x + dx, i_picture_y + dy,
 932                         i_a, i_x, i_y, i_z,
 933                         p_glyph->bitmap.buffer[dy * p_glyph->bitmap.width + dx] );
 934     }
 935 }
 936
 937 static inline void BlendAXYZLine( picture_t *p_picture,
 938                                   int i_picture_x, int i_picture_y,
 939                                   int i_a, int i_x, int i_y, int i_z,
 940                                   const line_character_t *p_current,
 941                                   const line_character_t *p_next,
 942                                   void (*BlendPixel)(picture_t *, int, int, int, int, int, int, int) )
 943 {
 944     int i_line_width = p_current->p_glyph->bitmap.width;
 945     if( p_next )
 946         i_line_width = p_next->p_glyph->left - p_current->p_glyph->left;
 947
 948     for( int dx = 0; dx < i_line_width; dx++ )
 949     {
 950         for( int dy = 0; dy < p_current->i_line_thickness; dy++ )
 951             BlendPixel( p_picture,
 952                         i_picture_x + dx,
 953                         i_picture_y + p_current->i_line_offset + dy,
 954                         i_a, i_x, i_y, i_z, 0xff );
 955     }
 956 }
 957
 958 static inline int RenderAXYZ( filter_t *p_filter,
 959                               subpicture_region_t *p_region,
 960                               line_desc_t *p_line_head,
 961                               FT_BBox *p_bbox,
 962                               int i_margin,
 963                               vlc_fourcc_t i_chroma,
 964                               void (*ExtractComponents)( uint32_t, uint8_t *, uint8_t *, uint8_t * ),
 965                               void (*FillPicture)( picture_t *p_picture, int, int, int, int ),
 966                               void (*BlendPixel)(picture_t *, int, int, int, int, int, int, int) )
 967 {
 968     filter_sys_t *p_sys = p_filter->p_sys;
 969
 970     /* Create a new subpicture region */
 971     const int i_text_width  = p_bbox->xMax - p_bbox->xMin;
 972     const int i_text_height = p_bbox->yMax - p_bbox->yMin;
 973     video_format_t fmt;
 974     video_format_Init( &fmt, i_chroma );
 975     fmt.i_width          =
 976     fmt.i_visible_width  = i_text_width  + 2 * i_margin;
 977     fmt.i_height         =
 978     fmt.i_visible_height = i_text_height + 2 * i_margin;
 979
 980     picture_t *p_picture = p_region->p_picture = picture_NewFromFormat( &fmt );
 981     if( !p_region->p_picture )
 982         return VLC_EGENERIC;
 983     p_region->fmt = fmt;
 984
 985     /* Initialize the picture background */
 986     uint8_t i_a = p_sys->i_background_opacity;
 987     uint8_t i_x, i_y, i_z;
 988     ExtractComponents( p_sys->i_background_color, &i_x, &i_y, &i_z );
 989
 990     FillPicture( p_picture, i_a, i_x, i_y, i_z );
 991
 992     /* Render shadow then outline and then normal glyphs */
 993     for( int g = 0; g < 3; g++ )
 994     {
 995         /* Render all lines */
 996         for( line_desc_t *p_line = p_line_head; p_line != NULL; p_line = p_line->p_next )
 997         {
 998             int i_align_left = i_margin;
 999             if( p_line->i_width < i_text_width )
1000             {
1001                 /* Left offset to take into account alignment */
1002                 if( (p_region->i_align & 0x3) == SUBPICTURE_ALIGN_RIGHT )
1003                     i_align_left += ( i_text_width - p_line->i_width );
1004                 else if( (p_region->i_align & 0x3) != SUBPICTURE_ALIGN_LEFT )
1005                     i_align_left += ( i_text_width - p_line->i_width ) / 2;
1006             }
1007             int i_align_top = i_margin;
1008
1009             /* Render all glyphs and underline/strikethrough */
1010             for( int i = 0; i < p_line->i_character_count; i++ )
1011             {
1012                 const line_character_t *ch = &p_line->p_character[i];
1013                 FT_BitmapGlyph p_glyph = g == 0 ? ch->p_shadow : g == 1 ? ch->p_outline : ch->p_glyph;
1014                 if( !p_glyph )
1015                     continue;
1016
1017                 i_a = (ch->i_color >> 24) & 0xff;
1018                 uint32_t i_color;
1019                 switch (g) {
1020                 case 0:
1021                     i_a     = i_a * p_sys->i_shadow_opacity / 255;
1022                     i_color = p_sys->i_shadow_color;
1023                     break;
1024                 case 1:
1025                     i_a     = i_a * p_sys->i_outline_opacity / 255;
1026                     i_color = p_sys->i_outline_color;
1027                     break;
1028                 default:
1029                     i_color = ch->i_color;
1030                     break;
1031                 }
1032                 ExtractComponents( i_color, &i_x, &i_y, &i_z );
1033
1034                 int i_glyph_y = i_align_top  - p_glyph->top  + p_bbox->yMax + p_line->i_base_line;
1035                 int i_glyph_x = i_align_left + p_glyph->left - p_bbox->xMin;
1036
1037                 BlendAXYZGlyph( p_picture,
1038                                 i_glyph_x, i_glyph_y,
1039                                 i_a, i_x, i_y, i_z,
1040                                 p_glyph,
1041                                 BlendPixel );
1042
1043                 /* underline/strikethrough are only rendered for the normal glyph */
1044                 if( g == 2 && ch->i_line_thickness > 0 )
1045                     BlendAXYZLine( p_picture,
1046                                    i_glyph_x, i_glyph_y + p_glyph->top,
1047                                    i_a, i_x, i_y, i_z,
1048                                    &ch[0],
1049                                    i + 1 < p_line->i_character_count ? &ch[1] : NULL,
1050                                    BlendPixel );
1051             }
1052         }
1053     }
1054
1055     return VLC_SUCCESS;
1056 }
1057
1058 static text_style_t *CreateStyle( char *psz_fontname, int i_font_size,
1059                                   uint32_t i_font_color, uint32_t i_karaoke_bg_color,
1060                                   int i_style_flags )
1061 {
1062     text_style_t *p_style = text_style_New();
1063     if( !p_style )
1064         return NULL;
1065
1066     p_style->psz_fontname = psz_fontname ? strdup( psz_fontname ) : NULL;
1067     p_style->i_font_size  = i_font_size;
1068     p_style->i_font_color = (i_font_color & 0x00ffffff) >>  0;
1069     p_style->i_font_alpha = (i_font_color & 0xff000000) >> 24;
1070     p_style->i_karaoke_background_color = (i_karaoke_bg_color & 0x00ffffff) >>  0;
1071     p_style->i_karaoke_background_alpha = (i_karaoke_bg_color & 0xff000000) >> 24;
1072     p_style->i_style_flags |= i_style_flags;
1073     return p_style;
1074 }
1075
1076 static int PushFont( font_stack_t **p_font, const char *psz_name, int i_size,
1077                      uint32_t i_color, uint32_t i_karaoke_bg_color )
1078 {
1079     if( !p_font )
1080         return VLC_EGENERIC;
1081
1082     font_stack_t *p_new = malloc( sizeof(*p_new) );
1083     if( !p_new )
1084         return VLC_ENOMEM;
1085
1086     p_new->p_next = NULL;
1087
1088     if( psz_name )
1089         p_new->psz_name = strdup( psz_name );
1090     else
1091         p_new->psz_name = NULL;
1092
1093     p_new->i_size              = i_size;
1094     p_new->i_color             = i_color;
1095     p_new->i_karaoke_bg_color  = i_karaoke_bg_color;
1096
1097     if( !*p_font )
1098     {
1099         *p_font = p_new;
1100     }
1101     else
1102     {
1103         font_stack_t *p_last;
1104
1105         for( p_last = *p_font;
1106              p_last->p_next;
1107              p_last = p_last->p_next )
1108         ;
1109
1110         p_last->p_next = p_new;
1111     }
1112     return VLC_SUCCESS;
1113 }
1114
1115 static int PopFont( font_stack_t **p_font )
1116 {
1117     font_stack_t *p_last, *p_next_to_last;
1118
1119     if( !p_font || !*p_font )
1120         return VLC_EGENERIC;
1121
1122     p_next_to_last = NULL;
1123     for( p_last = *p_font;
1124          p_last->p_next;
1125          p_last = p_last->p_next )
1126     {
1127         p_next_to_last = p_last;
1128     }
1129
1130     if( p_next_to_last )
1131         p_next_to_last->p_next = NULL;
1132     else
1133         *p_font = NULL;
1134
1135     free( p_last->psz_name );
1136     free( p_last );
1137
1138     return VLC_SUCCESS;
1139 }
1140
1141 static int PeekFont( font_stack_t **p_font, char **psz_name, int *i_size,
1142                      uint32_t *i_color, uint32_t *i_karaoke_bg_color )
1143 {
1144     font_stack_t *p_last;
1145
1146     if( !p_font || !*p_font )
1147         return VLC_EGENERIC;
1148
1149     for( p_last=*p_font;
1150          p_last->p_next;
1151          p_last=p_last->p_next )
1152     ;
1153
1154     *psz_name            = p_last->psz_name;
1155     *i_size              = p_last->i_size;
1156     *i_color             = p_last->i_color;
1157     *i_karaoke_bg_color  = p_last->i_karaoke_bg_color;
1158
1159     return VLC_SUCCESS;
1160 }
1161
1162 static const struct {
1163     const char *psz_name;
1164     uint32_t   i_value;
1165 } p_html_colors[] = {
1166     /* Official html colors */
1167     { "Aqua",    0x00FFFF },
1168     { "Black",   0x000000 },
1169     { "Blue",    0x0000FF },
1170     { "Fuchsia", 0xFF00FF },
1171     { "Gray",    0x808080 },
1172     { "Green",   0x008000 },
1173     { "Lime",    0x00FF00 },
1174     { "Maroon",  0x800000 },
1175     { "Navy",    0x000080 },
1176     { "Olive",   0x808000 },
1177     { "Purple",  0x800080 },
1178     { "Red",     0xFF0000 },
1179     { "Silver",  0xC0C0C0 },
1180     { "Teal",    0x008080 },
1181     { "White",   0xFFFFFF },
1182     { "Yellow",  0xFFFF00 },
1183
1184     /* Common ones */
1185     { "AliceBlue", 0xF0F8FF },
1186     { "AntiqueWhite", 0xFAEBD7 },
1187     { "Aqua", 0x00FFFF },
1188     { "Aquamarine", 0x7FFFD4 },
1189     { "Azure", 0xF0FFFF },
1190     { "Beige", 0xF5F5DC },
1191     { "Bisque", 0xFFE4C4 },
1192     { "Black", 0x000000 },
1193     { "BlanchedAlmond", 0xFFEBCD },
1194     { "Blue", 0x0000FF },
1195     { "BlueViolet", 0x8A2BE2 },
1196     { "Brown", 0xA52A2A },
1197     { "BurlyWood", 0xDEB887 },
1198     { "CadetBlue", 0x5F9EA0 },
1199     { "Chartreuse", 0x7FFF00 },
1200     { "Chocolate", 0xD2691E },
1201     { "Coral", 0xFF7F50 },
1202     { "CornflowerBlue", 0x6495ED },
1203     { "Cornsilk", 0xFFF8DC },
1204     { "Crimson", 0xDC143C },
1205     { "Cyan", 0x00FFFF },
1206     { "DarkBlue", 0x00008B },
1207     { "DarkCyan", 0x008B8B },
1208     { "DarkGoldenRod", 0xB8860B },
1209     { "DarkGray", 0xA9A9A9 },
1210     { "DarkGrey", 0xA9A9A9 },
1211     { "DarkGreen", 0x006400 },
1212     { "DarkKhaki", 0xBDB76B },
1213     { "DarkMagenta", 0x8B008B },
1214     { "DarkOliveGreen", 0x556B2F },
1215     { "Darkorange", 0xFF8C00 },
1216     { "DarkOrchid", 0x9932CC },
1217     { "DarkRed", 0x8B0000 },
1218     { "DarkSalmon", 0xE9967A },
1219     { "DarkSeaGreen", 0x8FBC8F },
1220     { "DarkSlateBlue", 0x483D8B },
1221     { "DarkSlateGray", 0x2F4F4F },
1222     { "DarkSlateGrey", 0x2F4F4F },
1223     { "DarkTurquoise", 0x00CED1 },
1224     { "DarkViolet", 0x9400D3 },
1225     { "DeepPink", 0xFF1493 },
1226     { "DeepSkyBlue", 0x00BFFF },
1227     { "DimGray", 0x696969 },
1228     { "DimGrey", 0x696969 },
1229     { "DodgerBlue", 0x1E90FF },
1230     { "FireBrick", 0xB22222 },
1231     { "FloralWhite", 0xFFFAF0 },
1232     { "ForestGreen", 0x228B22 },
1233     { "Fuchsia", 0xFF00FF },
1234     { "Gainsboro", 0xDCDCDC },
1235     { "GhostWhite", 0xF8F8FF },
1236     { "Gold", 0xFFD700 },
1237     { "GoldenRod", 0xDAA520 },
1238     { "Gray", 0x808080 },
1239     { "Grey", 0x808080 },
1240     { "Green", 0x008000 },
1241     { "GreenYellow", 0xADFF2F },
1242     { "HoneyDew", 0xF0FFF0 },
1243     { "HotPink", 0xFF69B4 },
1244     { "IndianRed", 0xCD5C5C },
1245     { "Indigo", 0x4B0082 },
1246     { "Ivory", 0xFFFFF0 },
1247     { "Khaki", 0xF0E68C },
1248     { "Lavender", 0xE6E6FA },
1249     { "LavenderBlush", 0xFFF0F5 },
1250     { "LawnGreen", 0x7CFC00 },
1251     { "LemonChiffon", 0xFFFACD },
1252     { "LightBlue", 0xADD8E6 },
1253     { "LightCoral", 0xF08080 },
1254     { "LightCyan", 0xE0FFFF },
1255     { "LightGoldenRodYellow", 0xFAFAD2 },
1256     { "LightGray", 0xD3D3D3 },
1257     { "LightGrey", 0xD3D3D3 },
1258     { "LightGreen", 0x90EE90 },
1259     { "LightPink", 0xFFB6C1 },
1260     { "LightSalmon", 0xFFA07A },
1261     { "LightSeaGreen", 0x20B2AA },
1262     { "LightSkyBlue", 0x87CEFA },
1263     { "LightSlateGray", 0x778899 },
1264     { "LightSlateGrey", 0x778899 },
1265     { "LightSteelBlue", 0xB0C4DE },
1266     { "LightYellow", 0xFFFFE0 },
1267     { "Lime", 0x00FF00 },
1268     { "LimeGreen", 0x32CD32 },
1269     { "Linen", 0xFAF0E6 },
1270     { "Magenta", 0xFF00FF },
1271     { "Maroon", 0x800000 },
1272     { "MediumAquaMarine", 0x66CDAA },
1273     { "MediumBlue", 0x0000CD },
1274     { "MediumOrchid", 0xBA55D3 },
1275     { "MediumPurple", 0x9370D8 },
1276     { "MediumSeaGreen", 0x3CB371 },
1277     { "MediumSlateBlue", 0x7B68EE },
1278     { "MediumSpringGreen", 0x00FA9A },
1279     { "MediumTurquoise", 0x48D1CC },
1280     { "MediumVioletRed", 0xC71585 },
1281     { "MidnightBlue", 0x191970 },
1282     { "MintCream", 0xF5FFFA },
1283     { "MistyRose", 0xFFE4E1 },
1284     { "Moccasin", 0xFFE4B5 },
1285     { "NavajoWhite", 0xFFDEAD },
1286     { "Navy", 0x000080 },
1287     { "OldLace", 0xFDF5E6 },
1288     { "Olive", 0x808000 },
1289     { "OliveDrab", 0x6B8E23 },
1290     { "Orange", 0xFFA500 },
1291     { "OrangeRed", 0xFF4500 },
1292     { "Orchid", 0xDA70D6 },
1293     { "PaleGoldenRod", 0xEEE8AA },
1294     { "PaleGreen", 0x98FB98 },
1295     { "PaleTurquoise", 0xAFEEEE },
1296     { "PaleVioletRed", 0xD87093 },
1297     { "PapayaWhip", 0xFFEFD5 },
1298     { "PeachPuff", 0xFFDAB9 },
1299     { "Peru", 0xCD853F },
1300     { "Pink", 0xFFC0CB },
1301     { "Plum", 0xDDA0DD },
1302     { "PowderBlue", 0xB0E0E6 },
1303     { "Purple", 0x800080 },
1304     { "Red", 0xFF0000 },
1305     { "RosyBrown", 0xBC8F8F },
1306     { "RoyalBlue", 0x4169E1 },
1307     { "SaddleBrown", 0x8B4513 },
1308     { "Salmon", 0xFA8072 },
1309     { "SandyBrown", 0xF4A460 },
1310     { "SeaGreen", 0x2E8B57 },
1311     { "SeaShell", 0xFFF5EE },
1312     { "Sienna", 0xA0522D },
1313     { "Silver", 0xC0C0C0 },
1314     { "SkyBlue", 0x87CEEB },
1315     { "SlateBlue", 0x6A5ACD },
1316     { "SlateGray", 0x708090 },
1317     { "SlateGrey", 0x708090 },
1318     { "Snow", 0xFFFAFA },
1319     { "SpringGreen", 0x00FF7F },
1320     { "SteelBlue", 0x4682B4 },
1321     { "Tan", 0xD2B48C },
1322     { "Teal", 0x008080 },
1323     { "Thistle", 0xD8BFD8 },
1324     { "Tomato", 0xFF6347 },
1325     { "Turquoise", 0x40E0D0 },
1326     { "Violet", 0xEE82EE },
1327     { "Wheat", 0xF5DEB3 },
1328     { "White", 0xFFFFFF },
1329     { "WhiteSmoke", 0xF5F5F5 },
1330     { "Yellow", 0xFFFF00 },
1331     { "YellowGreen", 0x9ACD32 },
1332
1333     { NULL, 0 }
1334 };
1335
1336 static int HandleFontAttributes( xml_reader_t *p_xml_reader,
1337                                  font_stack_t **p_fonts )
1338 {
1339     int        rv;
1340     char      *psz_fontname = NULL;
1341     uint32_t   i_font_color = 0xffffff;
1342     int        i_font_alpha = 255;
1343     uint32_t   i_karaoke_bg_color = 0x00ffffff;
1344     int        i_font_size  = 24;
1345
1346     /* Default all attributes to the top font in the stack -- in case not
1347      * all attributes are specified in the sub-font
1348      */
1349     if( VLC_SUCCESS == PeekFont( p_fonts,
1350                                  &psz_fontname,
1351                                  &i_font_size,
1352                                  &i_font_color,
1353                                  &i_karaoke_bg_color ))
1354     {
1355         psz_fontname = strdup( psz_fontname );
1356     }
1357     i_font_alpha = (i_font_color >> 24) & 0xff;
1358     i_font_color &= 0x00ffffff;
1359
1360     const char *name, *value;
1361     while( (name = xml_ReaderNextAttr( p_xml_reader, &value )) != NULL )
1362     {
1363         if( !strcasecmp( "face", name ) )
1364         {
1365             free( psz_fontname );
1366             psz_fontname = strdup( value );
1367         }
1368         else if( !strcasecmp( "size", name ) )
1369         {
1370             if( ( *value == '+' ) || ( *value == '-' ) )
1371             {
1372                 int i_value = atoi( value );
1373
1374                 if( ( i_value >= -5 ) && ( i_value <= 5 ) )
1375                     i_font_size += ( i_value * i_font_size ) / 10;
1376                 else if( i_value < -5 )
1377                     i_font_size = - i_value;
1378                 else if( i_value > 5 )
1379                     i_font_size = i_value;
1380             }
1381             else
1382                 i_font_size = atoi( value );
1383         }
1384         else if( !strcasecmp( "color", name ) )
1385         {
1386             if( value[0] == '#' )
1387             {
1388                 i_font_color = strtol( value + 1, NULL, 16 );
1389                 i_font_color &= 0x00ffffff;
1390             }
1391             else
1392             {
1393                 char *end;
1394                 uint32_t i_value = strtol( value, &end, 16 );
1395                 if( *end == '\0' || *end == ' ' )
1396                     i_font_color = i_value & 0x00ffffff;
1397
1398                 for( int i = 0; p_html_colors[i].psz_name != NULL; i++ )
1399                 {
1400                     if( !strncasecmp( value, p_html_colors[i].psz_name, strlen(p_html_colors[i].psz_name) ) )
1401                     {
1402                         i_font_color = p_html_colors[i].i_value;
1403                         break;
1404                     }
1405                 }
1406             }
1407         }
1408         else if( !strcasecmp( "alpha", name ) && ( value[0] == '#' ) )
1409         {
1410             i_font_alpha = strtol( value + 1, NULL, 16 );
1411             i_font_alpha &= 0xff;
1412         }
1413     }
1414     rv = PushFont( p_fonts,
1415                    psz_fontname,
1416                    i_font_size,
1417                    (i_font_color & 0xffffff) | ((i_font_alpha & 0xff) << 24),
1418                    i_karaoke_bg_color );
1419
1420     free( psz_fontname );
1421
1422     return rv;
1423 }
1424
1425 /* Turn any multiple-whitespaces into single spaces */
1426 static void HandleWhiteSpace( char *psz_node )
1427 {
1428     char *s = strpbrk( psz_node, "\t\r\n " );
1429     while( s )
1430     {
1431         int i_whitespace = strspn( s, "\t\r\n " );
1432
1433         if( i_whitespace > 1 )
1434             memmove( &s[1],
1435                      &s[i_whitespace],
1436                      strlen( s ) - i_whitespace + 1 );
1437         *s++ = ' ';
1438
1439         s = strpbrk( s, "\t\r\n " );
1440     }
1441 }
1442
1443
1444 static text_style_t *GetStyleFromFontStack( filter_sys_t *p_sys,
1445                                             font_stack_t **p_fonts,
1446                                             int i_style_flags )
1447 {
1448     char       *psz_fontname = NULL;
1449     uint32_t    i_font_color = p_sys->i_font_color & 0x00ffffff;
1450     uint32_t    i_karaoke_bg_color = i_font_color;
1451     int         i_font_size  = p_sys->i_font_size;
1452
1453     if( PeekFont( p_fonts, &psz_fontname, &i_font_size,
1454                   &i_font_color, &i_karaoke_bg_color ) )
1455         return NULL;
1456
1457     return CreateStyle( psz_fontname, i_font_size, i_font_color,
1458                         i_karaoke_bg_color,
1459                         i_style_flags );
1460 }
1461
1462 static unsigned SetupText( filter_t *p_filter,
1463                            uni_char_t *psz_text_out,
1464                            text_style_t **pp_styles,
1465                            uint32_t *pi_k_dates,
1466
1467                            const char *psz_text_in,
1468                            text_style_t *p_style,
1469                            uint32_t i_k_date )
1470 {
1471     size_t i_string_length;
1472
1473     size_t i_string_bytes;
1474     uni_char_t *psz_tmp = ToCharset( FREETYPE_TO_UCS, psz_text_in, &i_string_bytes );
1475     if( psz_tmp )
1476     {
1477         memcpy( psz_text_out, psz_tmp, i_string_bytes );
1478         i_string_length = i_string_bytes / sizeof( *psz_tmp );
1479         free( psz_tmp );
1480     }
1481     else
1482     {
1483         msg_Warn( p_filter, "failed to convert string to unicode (%m)" );
1484         i_string_length = 0;
1485     }
1486
1487     if( i_string_length > 0 )
1488     {
1489         for( unsigned i = 0; i < i_string_length; i++ )
1490             pp_styles[i] = p_style;
1491     }
1492     else
1493     {
1494         text_style_Delete( p_style );
1495     }
1496     if( i_string_length > 0 && pi_k_dates )
1497     {
1498         for( unsigned i = 0; i < i_string_length; i++ )
1499             pi_k_dates[i] = i_k_date;
1500     }
1501     return i_string_length;
1502 }
1503
1504 static int ProcessNodes( filter_t *p_filter,
1505                          uni_char_t *psz_text,
1506                          text_style_t **pp_styles,
1507                          uint32_t *pi_k_dates,
1508                          int *pi_len,
1509                          xml_reader_t *p_xml_reader,
1510                          text_style_t *p_font_style )
1511 {
1512     int           rv      = VLC_SUCCESS;
1513     filter_sys_t *p_sys   = p_filter->p_sys;
1514     int i_text_length     = 0;
1515     font_stack_t *p_fonts = NULL;
1516     uint32_t i_k_date     = 0;
1517
1518     int i_style_flags = 0;
1519
1520     if( p_font_style )
1521     {
1522         rv = PushFont( &p_fonts,
1523                p_font_style->psz_fontname,
1524                p_font_style->i_font_size > 0 ? p_font_style->i_font_size
1525                                              : p_sys->i_font_size,
1526                (p_font_style->i_font_color & 0xffffff) |
1527                    ((p_font_style->i_font_alpha & 0xff) << 24),
1528                (p_font_style->i_karaoke_background_color & 0xffffff) |
1529                    ((p_font_style->i_karaoke_background_alpha & 0xff) << 24));
1530
1531         i_style_flags = p_font_style->i_style_flags & (STYLE_BOLD |
1532                                                        STYLE_ITALIC |
1533                                                        STYLE_UNDERLINE |
1534                                                        STYLE_STRIKEOUT);
1535     }
1536 #ifdef HAVE_STYLES
1537     else
1538     {
1539         rv = PushFont( &p_fonts,
1540                        p_sys->psz_fontfamily,
1541                        p_sys->i_font_size,
1542                        (p_sys->i_font_color & 0xffffff) |
1543                           ((p_sys->i_font_opacity & 0xff) << 24),
1544                        0x00ffffff );
1545     }
1546 #endif
1547     if( p_sys->b_font_bold )
1548         i_style_flags |= STYLE_BOLD;
1549
1550     if( rv != VLC_SUCCESS )
1551         return rv;
1552
1553     const char *node;
1554     int type;
1555
1556     while ( (type = xml_ReaderNextNode( p_xml_reader, &node )) > 0 )
1557     {
1558         switch ( type )
1559         {
1560             case XML_READER_ENDELEM:
1561                 if( !strcasecmp( "font", node ) )
1562                     PopFont( &p_fonts );
1563                 else if( !strcasecmp( "b", node ) )
1564                     i_style_flags &= ~STYLE_BOLD;
1565                else if( !strcasecmp( "i", node ) )
1566                     i_style_flags &= ~STYLE_ITALIC;
1567                 else if( !strcasecmp( "u", node ) )
1568                     i_style_flags &= ~STYLE_UNDERLINE;
1569                 else if( !strcasecmp( "s", node ) )
1570                     i_style_flags &= ~STYLE_STRIKEOUT;
1571                 break;
1572
1573             case XML_READER_STARTELEM:
1574                 if( !strcasecmp( "font", node ) )
1575                     HandleFontAttributes( p_xml_reader, &p_fonts );
1576                 else if( !strcasecmp( "b", node ) )
1577                     i_style_flags |= STYLE_BOLD;
1578                 else if( !strcasecmp( "i", node ) )
1579                     i_style_flags |= STYLE_ITALIC;
1580                 else if( !strcasecmp( "u", node ) )
1581                     i_style_flags |= STYLE_UNDERLINE;
1582                 else if( !strcasecmp( "s", node ) )
1583                     i_style_flags |= STYLE_STRIKEOUT;
1584                 else if( !strcasecmp( "br", node ) )
1585                 {
1586                     i_text_length += SetupText( p_filter,
1587                                                 &psz_text[i_text_length],
1588                                                 &pp_styles[i_text_length],
1589                                                 pi_k_dates ? &pi_k_dates[i_text_length] : NULL,
1590                                                 "\n",
1591                                                 GetStyleFromFontStack( p_sys,
1592                                                                        &p_fonts,
1593                                                                        i_style_flags ),
1594                                                 i_k_date );
1595                 }
1596                 else if( !strcasecmp( "k", node ) )
1597                 {
1598                     /* Karaoke tags */
1599                     const char *name, *value;
1600                     while( (name = xml_ReaderNextAttr( p_xml_reader, &value )) != NULL )
1601                     {
1602                         if( !strcasecmp( "t", name ) && value )
1603                             i_k_date += atoi( value );
1604                     }
1605                 }
1606                 break;
1607
1608             case XML_READER_TEXT:
1609             {
1610                 char *psz_node = strdup( node );
1611                 if( unlikely(!psz_node) )
1612                     break;
1613
1614                 HandleWhiteSpace( psz_node );
1615                 resolve_xml_special_chars( psz_node );
1616
1617                 i_text_length += SetupText( p_filter,
1618                                             &psz_text[i_text_length],
1619                                             &pp_styles[i_text_length],
1620                                             pi_k_dates ? &pi_k_dates[i_text_length] : NULL,
1621                                             psz_node,
1622                                             GetStyleFromFontStack( p_sys,
1623                                                                    &p_fonts,
1624                                                                    i_style_flags ),
1625                                             i_k_date );
1626                 free( psz_node );
1627                 break;
1628             }
1629         }
1630     }
1631
1632     *pi_len = i_text_length;
1633
1634     while( VLC_SUCCESS == PopFont( &p_fonts ) );
1635
1636     return VLC_SUCCESS;
1637 }
1638
1639 static void FreeLine( line_desc_t *p_line )
1640 {
1641     for( int i = 0; i < p_line->i_character_count; i++ )
1642     {
1643         line_character_t *ch = &p_line->p_character[i];
1644         FT_Done_Glyph( (FT_Glyph)ch->p_glyph );
1645         if( ch->p_outline )
1646             FT_Done_Glyph( (FT_Glyph)ch->p_outline );
1647         if( ch->p_shadow )
1648             FT_Done_Glyph( (FT_Glyph)ch->p_shadow );
1649     }
1650
1651     free( p_line->p_character );
1652     free( p_line );
1653 }
1654
1655 static void FreeLines( line_desc_t *p_lines )
1656 {
1657     for( line_desc_t *p_line = p_lines; p_line != NULL; )
1658     {
1659         line_desc_t *p_next = p_line->p_next;
1660         FreeLine( p_line );
1661         p_line = p_next;
1662     }
1663 }
1664
1665 static line_desc_t *NewLine( int i_count )
1666 {
1667     line_desc_t *p_line = malloc( sizeof(*p_line) );
1668
1669     if( !p_line )
1670         return NULL;
1671
1672     p_line->p_next = NULL;
1673     p_line->i_width = 0;
1674     p_line->i_base_line = 0;
1675     p_line->i_character_count = 0;
1676
1677     p_line->p_character = calloc( i_count, sizeof(*p_line->p_character) );
1678     if( !p_line->p_character )
1679     {
1680         free( p_line );
1681         return NULL;
1682     }
1683     return p_line;
1684 }
1685
1686 static FT_Face LoadEmbeddedFace( filter_sys_t *p_sys, const text_style_t *p_style )
1687 {
1688     for( int k = 0; k < p_sys->i_font_attachments; k++ )
1689     {
1690         input_attachment_t *p_attach   = p_sys->pp_font_attachments[k];
1691         int                 i_font_idx = 0;
1692         FT_Face             p_face = NULL;
1693
1694         while( 0 == FT_New_Memory_Face( p_sys->p_library,
1695                                         p_attach->p_data,
1696                                         p_attach->i_data,
1697                                         i_font_idx,
1698                                         &p_face ))
1699         {
1700             if( p_face )
1701             {
1702                 int i_style_received = ((p_face->style_flags & FT_STYLE_FLAG_BOLD)    ? STYLE_BOLD   : 0) |
1703                                        ((p_face->style_flags & FT_STYLE_FLAG_ITALIC ) ? STYLE_ITALIC : 0);
1704                 if( !strcasecmp( p_face->family_name, p_style->psz_fontname ) &&
1705                     (p_style->i_style_flags & (STYLE_BOLD | STYLE_ITALIC)) == i_style_received )
1706                     return p_face;
1707
1708                 FT_Done_Face( p_face );
1709             }
1710             i_font_idx++;
1711         }
1712     }
1713     return NULL;
1714 }
1715
1716 static FT_Face LoadFace( filter_t *p_filter,
1717                          const text_style_t *p_style )
1718 {
1719     filter_sys_t *p_sys = p_filter->p_sys;
1720
1721     /* Look for a match amongst our attachments first */
1722     FT_Face p_face = LoadEmbeddedFace( p_sys, p_style );
1723
1724     /* Load system wide font otheriwse */
1725     if( !p_face )
1726     {
1727         int  i_idx = 0;
1728         char *psz_fontfile;
1729 #ifdef HAVE_FONTCONFIG
1730         psz_fontfile = FontConfig_Select( NULL,
1731                                           p_style->psz_fontname,
1732                                           (p_style->i_style_flags & STYLE_BOLD) != 0,
1733                                           (p_style->i_style_flags & STYLE_ITALIC) != 0,
1734                                           -1,
1735                                           &i_idx );
1736 #elif defined( WIN32 )
1737         psz_fontfile = Win32_Select( p_filter,
1738                                     p_style->psz_fontname,
1739                                     (p_style->i_style_flags & STYLE_BOLD) != 0,
1740                                     (p_style->i_style_flags & STYLE_ITALIC) != 0,
1741                                     -1,
1742                                     &i_idx );
1743 #else
1744         psz_fontfile = NULL;
1745 #endif
1746         if( !psz_fontfile )
1747             return NULL;
1748
1749         if( *psz_fontfile == '\0' )
1750         {
1751             msg_Warn( p_filter,
1752                       "We were not able to find a matching font: \"%s\" (%s %s),"
1753                       " so using default font",
1754                       p_style->psz_fontname,
1755                       (p_style->i_style_flags & STYLE_BOLD)   ? "Bold" : "",
1756                       (p_style->i_style_flags & STYLE_ITALIC) ? "Italic" : "" );
1757             p_face = NULL;
1758         }
1759         else
1760         {
1761             if( FT_New_Face( p_sys->p_library, psz_fontfile, i_idx, &p_face ) )
1762                 p_face = NULL;
1763         }
1764         free( psz_fontfile );
1765     }
1766     if( !p_face )
1767         return NULL;
1768
1769     if( FT_Select_Charmap( p_face, ft_encoding_unicode ) )
1770     {
1771         /* We've loaded a font face which is unhelpful for actually
1772          * rendering text - fallback to the default one.
1773          */
1774         FT_Done_Face( p_face );
1775         return NULL;
1776     }
1777     return p_face;
1778 }
1779
1780 static bool FaceStyleEquals( const text_style_t *p_style1,
1781                              const text_style_t *p_style2 )
1782 {
1783     if( !p_style1 || !p_style2 )
1784         return false;
1785     if( p_style1 == p_style2 )
1786         return true;
1787
1788     const int i_style_mask = STYLE_BOLD | STYLE_ITALIC;
1789     return (p_style1->i_style_flags & i_style_mask) == (p_style2->i_style_flags & i_style_mask) &&
1790            !strcmp( p_style1->psz_fontname, p_style2->psz_fontname );
1791 }
1792
1793 static int GetGlyph( filter_t *p_filter,
1794                      FT_Glyph *pp_glyph,   FT_BBox *p_glyph_bbox,
1795                      FT_Glyph *pp_outline, FT_BBox *p_outline_bbox,
1796                      FT_Glyph *pp_shadow,  FT_BBox *p_shadow_bbox,
1797
1798                      FT_Face  p_face,
1799                      int i_glyph_index,
1800                      int i_style_flags,
1801                      FT_Vector *p_pen,
1802                      FT_Vector *p_pen_shadow )
1803 {
1804     if( FT_Load_Glyph( p_face, i_glyph_index, FT_LOAD_NO_BITMAP | FT_LOAD_DEFAULT ) &&
1805         FT_Load_Glyph( p_face, i_glyph_index, FT_LOAD_DEFAULT ) )
1806     {
1807         msg_Err( p_filter, "unable to render text FT_Load_Glyph failed" );
1808         return VLC_EGENERIC;
1809     }
1810
1811     /* Do synthetic styling now that Freetype supports it;
1812      * ie. if the font we have loaded is NOT already in the
1813      * style that the tags want, then switch it on; if they
1814      * are then don't. */
1815     if ((i_style_flags & STYLE_BOLD) && !(p_face->style_flags & FT_STYLE_FLAG_BOLD))
1816         FT_GlyphSlot_Embolden( p_face->glyph );
1817     if ((i_style_flags & STYLE_ITALIC) && !(p_face->style_flags & FT_STYLE_FLAG_ITALIC))
1818         FT_GlyphSlot_Oblique( p_face->glyph );
1819
1820     FT_Glyph glyph;
1821     if( FT_Get_Glyph( p_face->glyph, &glyph ) )
1822     {
1823         msg_Err( p_filter, "unable to render text FT_Get_Glyph failed" );
1824         return VLC_EGENERIC;
1825     }
1826
1827     FT_Glyph outline = NULL;
1828     if( p_filter->p_sys->p_stroker )
1829     {
1830         outline = glyph;
1831         if( FT_Glyph_StrokeBorder( &outline, p_filter->p_sys->p_stroker, 0, 0 ) )
1832             outline = NULL;
1833     }
1834
1835     FT_Glyph shadow = NULL;
1836     if( p_filter->p_sys->i_shadow_opacity > 0 )
1837     {
1838         shadow = outline ? outline : glyph;
1839         if( FT_Glyph_To_Bitmap( &shadow, FT_RENDER_MODE_NORMAL, p_pen_shadow, 0  ) )
1840         {
1841             shadow = NULL;
1842         }
1843         else
1844         {
1845             FT_Glyph_Get_CBox( shadow, ft_glyph_bbox_pixels, p_shadow_bbox );
1846         }
1847     }
1848     *pp_shadow = shadow;
1849
1850     if( FT_Glyph_To_Bitmap( &glyph, FT_RENDER_MODE_NORMAL, p_pen, 1) )
1851     {
1852         FT_Done_Glyph( glyph );
1853         if( outline )
1854             FT_Done_Glyph( outline );
1855         if( shadow )
1856             FT_Done_Glyph( shadow );
1857         return VLC_EGENERIC;
1858     }
1859     FT_Glyph_Get_CBox( glyph, ft_glyph_bbox_pixels, p_glyph_bbox );
1860     *pp_glyph = glyph;
1861
1862     if( outline )
1863     {
1864         FT_Glyph_To_Bitmap( &outline, FT_RENDER_MODE_NORMAL, p_pen, 1 );
1865         FT_Glyph_Get_CBox( outline, ft_glyph_bbox_pixels, p_outline_bbox );
1866     }
1867     *pp_outline = outline;
1868
1869     return VLC_SUCCESS;
1870 }
1871
1872 static void FixGlyph( FT_Glyph glyph, FT_BBox *p_bbox, FT_Face face, const FT_Vector *p_pen )
1873 {
1874     FT_BitmapGlyph glyph_bmp = (FT_BitmapGlyph)glyph;
1875     if( p_bbox->xMin >= p_bbox->xMax )
1876     {
1877         p_bbox->xMin = FT_CEIL(p_pen->x);
1878         p_bbox->xMax = FT_CEIL(p_pen->x + face->glyph->advance.x);
1879         glyph_bmp->left = p_bbox->xMin;
1880     }
1881     if( p_bbox->yMin >= p_bbox->yMax )
1882     {
1883         p_bbox->yMax = FT_CEIL(p_pen->y);
1884         p_bbox->yMin = FT_CEIL(p_pen->y + face->glyph->advance.y);
1885         glyph_bmp->top  = p_bbox->yMax;
1886     }
1887 }
1888
1889 static void BBoxEnlarge( FT_BBox *p_max, const FT_BBox *p )
1890 {
1891     p_max->xMin = __MIN(p_max->xMin, p->xMin);
1892     p_max->yMin = __MIN(p_max->yMin, p->yMin);
1893     p_max->xMax = __MAX(p_max->xMax, p->xMax);
1894     p_max->yMax = __MAX(p_max->yMax, p->yMax);
1895 }
1896
1897 static int ProcessLines( filter_t *p_filter,
1898                          line_desc_t **pp_lines,
1899                          FT_BBox     *p_bbox,
1900                          int         *pi_max_face_height,
1901
1902                          uni_char_t *psz_text,
1903                          text_style_t **pp_styles,
1904                          uint32_t *pi_k_dates,
1905                          int i_len )
1906 {
1907     filter_sys_t   *p_sys = p_filter->p_sys;
1908     uni_char_t     *p_fribidi_string = NULL;
1909     text_style_t   **pp_fribidi_styles = NULL;
1910     int            *p_new_positions = NULL;
1911
1912 #if defined(HAVE_FRIBIDI)
1913     {
1914         int    *p_old_positions;
1915         int start_pos, pos = 0;
1916
1917         pp_fribidi_styles = calloc( i_len, sizeof(*pp_fribidi_styles) );
1918
1919         p_fribidi_string  = malloc( (i_len + 1) * sizeof(*p_fribidi_string) );
1920         p_old_positions   = malloc( (i_len + 1) * sizeof(*p_old_positions) );
1921         p_new_positions   = malloc( (i_len + 1) * sizeof(*p_new_positions) );
1922
1923         if( ! pp_fribidi_styles ||
1924             ! p_fribidi_string ||
1925             ! p_old_positions ||
1926             ! p_new_positions )
1927         {
1928             free( p_old_positions );
1929             free( p_new_positions );
1930             free( p_fribidi_string );
1931             free( pp_fribidi_styles );
1932             return VLC_ENOMEM;
1933         }
1934
1935         /* Do bidi conversion line-by-line */
1936         while(pos < i_len)
1937         {
1938             while(pos < i_len) {
1939                 if (psz_text[pos] != '\n')
1940                     break;
1941                 p_fribidi_string[pos] = psz_text[pos];
1942                 pp_fribidi_styles[pos] = pp_styles[pos];
1943                 p_new_positions[pos] = pos;
1944                 ++pos;
1945             }
1946             start_pos = pos;
1947             while(pos < i_len) {
1948                 if (psz_text[pos] == '\n')
1949                     break;
1950                 ++pos;
1951             }
1952             if (pos > start_pos)
1953             {
1954 #if (FRIBIDI_MINOR_VERSION < 19) && (FRIBIDI_MAJOR_VERSION == 0)
1955                 FriBidiCharType base_dir = FRIBIDI_TYPE_LTR;
1956 #else
1957                 FriBidiParType base_dir = FRIBIDI_PAR_LTR;
1958 #endif
1959                 fribidi_log2vis((FriBidiChar*)psz_text + start_pos,
1960                         pos - start_pos, &base_dir,
1961                         (FriBidiChar*)p_fribidi_string + start_pos,
1962                         p_new_positions + start_pos,
1963                         p_old_positions,
1964                         NULL );
1965                 for( int j = start_pos; j < pos; j++ )
1966                 {
1967                     pp_fribidi_styles[ j ] = pp_styles[ start_pos + p_old_positions[j - start_pos] ];
1968                     p_new_positions[ j ] += start_pos;
1969                 }
1970             }
1971         }
1972         p_fribidi_string[ i_len ] = 0;
1973         free( p_old_positions );
1974
1975         pp_styles = pp_fribidi_styles;
1976         psz_text = p_fribidi_string;
1977     }
1978 #endif
1979     /* Work out the karaoke */
1980     uint8_t *pi_karaoke_bar = NULL;
1981     if( pi_k_dates )
1982     {
1983         pi_karaoke_bar = malloc( i_len * sizeof(*pi_karaoke_bar));
1984         if( pi_karaoke_bar )
1985         {
1986             int64_t i_elapsed  = var_GetTime( p_filter, "spu-elapsed" ) / 1000;
1987             for( int i = 0; i < i_len; i++ )
1988             {
1989                 unsigned i_bar = p_new_positions ? p_new_positions[i] : i;
1990                 pi_karaoke_bar[i_bar] = pi_k_dates[i] >= i_elapsed;
1991             }
1992         }
1993     }
1994     free( p_new_positions );
1995
1996     *pi_max_face_height = 0;
1997     *pp_lines = NULL;
1998     line_desc_t **pp_line_next = pp_lines;
1999
2000     FT_BBox bbox = {
2001         .xMin = INT_MAX,
2002         .yMin = INT_MAX,
2003         .xMax = INT_MIN,
2004         .yMax = INT_MIN,
2005     };
2006     int i_face_height_previous = 0;
2007     int i_base_line = 0;
2008     const text_style_t *p_previous_style = NULL;
2009     FT_Face p_face = NULL;
2010     for( int i_start = 0; i_start < i_len; )
2011     {
2012         /* Compute the length of the current text line */
2013         int i_length = 0;
2014         while( i_start + i_length < i_len && psz_text[i_start + i_length] != '\n' )
2015             i_length++;
2016
2017         /* Render the text line (or the begining if too long) into 0 or 1 glyph line */
2018         line_desc_t *p_line = i_length > 0 ? NewLine( i_length ) : NULL;
2019         int i_index = i_start;
2020         FT_Vector pen = {
2021             .x = 0,
2022             .y = 0,
2023         };
2024         int i_face_height = 0;
2025         FT_BBox line_bbox = {
2026             .xMin = INT_MAX,
2027             .yMin = INT_MAX,
2028             .xMax = INT_MIN,
2029             .yMax = INT_MIN,
2030         };
2031         int i_ul_offset = 0;
2032         int i_ul_thickness = 0;
2033         typedef struct {
2034             int       i_index;
2035             FT_Vector pen;
2036             FT_BBox   line_bbox;
2037             int i_face_height;
2038             int i_ul_offset;
2039             int i_ul_thickness;
2040         } break_point_t;
2041         break_point_t break_point;
2042         break_point_t break_point_fallback;
2043
2044 #define SAVE_BP(dst) do { \
2045         dst.i_index = i_index; \
2046         dst.pen = pen; \
2047         dst.line_bbox = line_bbox; \
2048         dst.i_face_height = i_face_height; \
2049         dst.i_ul_offset = i_ul_offset; \
2050         dst.i_ul_thickness = i_ul_thickness; \
2051     } while(0)
2052
2053         SAVE_BP( break_point );
2054         SAVE_BP( break_point_fallback );
2055
2056         while( i_index < i_start + i_length )
2057         {
2058             /* Split by common FT_Face + Size */
2059             const text_style_t *p_current_style = pp_styles[i_index];
2060             int i_part_length = 0;
2061             while( i_index + i_part_length < i_start + i_length )
2062             {
2063                 const text_style_t *p_style = pp_styles[i_index + i_part_length];
2064                 if( !FaceStyleEquals( p_style, p_current_style ) ||
2065                     p_style->i_font_size != p_current_style->i_font_size )
2066                     break;
2067                 i_part_length++;
2068             }
2069
2070             /* (Re)load/reconfigure the face if needed */
2071             if( !FaceStyleEquals( p_current_style, p_previous_style ) )
2072             {
2073                 if( p_face )
2074                     FT_Done_Face( p_face );
2075                 p_previous_style = NULL;
2076
2077                 p_face = LoadFace( p_filter, p_current_style );
2078             }
2079             FT_Face p_current_face = p_face ? p_face : p_sys->p_face;
2080             if( !p_previous_style || p_previous_style->i_font_size != p_current_style->i_font_size )
2081             {
2082                 if( FT_Set_Pixel_Sizes( p_current_face, 0, p_current_style->i_font_size ) )
2083                     msg_Err( p_filter, "Failed to set font size to %d", p_current_style->i_font_size );
2084                 if( p_sys->p_stroker )
2085                 {
2086                     int i_radius = (p_current_style->i_font_size << 6) * p_sys->f_outline_thickness;
2087                     FT_Stroker_Set( p_sys->p_stroker,
2088                                     i_radius,
2089                                     FT_STROKER_LINECAP_ROUND,
2090                                     FT_STROKER_LINEJOIN_ROUND, 0 );
2091                 }
2092             }
2093             p_previous_style = p_current_style;
2094
2095             i_face_height = __MAX(i_face_height, FT_CEIL(FT_MulFix(p_current_face->height,
2096                                                                    p_current_face->size->metrics.y_scale)));
2097
2098             /* Render the part */
2099             bool b_break_line = false;
2100             int i_glyph_last = 0;
2101             while( i_part_length > 0 )
2102             {
2103                 const text_style_t *p_glyph_style = pp_styles[i_index];
2104                 uni_char_t character = psz_text[i_index];
2105                 int i_glyph_index = FT_Get_Char_Index( p_current_face, character );
2106
2107                 /* Get kerning vector */
2108                 FT_Vector kerning = { .x = 0, .y = 0 };
2109                 if( FT_HAS_KERNING( p_current_face ) && i_glyph_last != 0 && i_glyph_index != 0 )
2110                     FT_Get_Kerning( p_current_face, i_glyph_last, i_glyph_index, ft_kerning_default, &kerning );
2111
2112                 /* Get the glyph bitmap and its bounding box and all the associated properties */
2113                 FT_Vector pen_new = {
2114                     .x = pen.x + kerning.x,
2115                     .y = pen.y + kerning.y,
2116                 };
2117                 FT_Vector pen_shadow_new = {
2118                     .x = pen_new.x + p_sys->f_shadow_vector_x * (p_current_style->i_font_size << 6),
2119                     .y = pen_new.y + p_sys->f_shadow_vector_y * (p_current_style->i_font_size << 6),
2120                 };
2121                 FT_Glyph glyph;
2122                 FT_BBox  glyph_bbox;
2123                 FT_Glyph outline;
2124                 FT_BBox  outline_bbox;
2125                 FT_Glyph shadow;
2126                 FT_BBox  shadow_bbox;
2127
2128                 if( GetGlyph( p_filter,
2129                               &glyph, &glyph_bbox,
2130                               &outline, &outline_bbox,
2131                               &shadow, &shadow_bbox,
2132                               p_current_face, i_glyph_index, p_glyph_style->i_style_flags,
2133                               &pen_new, &pen_shadow_new ) )
2134                     goto next;
2135
2136                 FixGlyph( glyph, &glyph_bbox, p_current_face, &pen_new );
2137                 if( outline )
2138                     FixGlyph( outline, &outline_bbox, p_current_face, &pen_new );
2139                 if( shadow )
2140                     FixGlyph( shadow, &shadow_bbox, p_current_face, &pen_shadow_new );
2141
2142                 /* FIXME and what about outline */
2143
2144                 bool     b_karaoke = pi_karaoke_bar && pi_karaoke_bar[i_index] != 0;
2145                 uint32_t i_color = b_karaoke ? (p_glyph_style->i_karaoke_background_color |
2146                                                 (p_glyph_style->i_karaoke_background_alpha << 24))
2147                                              : (p_glyph_style->i_font_color |
2148                                                 (p_glyph_style->i_font_alpha << 24));
2149                 int i_line_offset    = 0;
2150                 int i_line_thickness = 0;
2151                 if( p_glyph_style->i_style_flags & (STYLE_UNDERLINE | STYLE_STRIKEOUT) )
2152                 {
2153                     i_line_offset = abs( FT_FLOOR(FT_MulFix(p_current_face->underline_position,
2154                                                             p_current_face->size->metrics.y_scale)) );
2155
2156                     i_line_thickness = abs( FT_CEIL(FT_MulFix(p_current_face->underline_thickness,
2157                                                               p_current_face->size->metrics.y_scale)) );
2158
2159                     if( p_glyph_style->i_style_flags & STYLE_STRIKEOUT )
2160                     {
2161                         /* Move the baseline to make it strikethrough instead of
2162                          * underline. That means that strikethrough takes precedence
2163                          */
2164                         i_line_offset -= abs( FT_FLOOR(FT_MulFix(p_current_face->descender*2,
2165                                                                  p_current_face->size->metrics.y_scale)) );
2166                     }
2167                     else if( i_line_thickness > 0 )
2168                     {
2169                         glyph_bbox.yMin = __MIN( glyph_bbox.yMin, - i_line_offset - i_line_thickness );
2170
2171                         /* The real underline thickness and position are
2172                          * updated once the whole line has been parsed */
2173                         i_ul_offset = __MAX( i_ul_offset, i_line_offset );
2174                         i_ul_thickness = __MAX( i_ul_thickness, i_line_thickness );
2175                         i_line_thickness = -1;
2176                     }
2177                 }
2178                 FT_BBox line_bbox_new = line_bbox;
2179                 BBoxEnlarge( &line_bbox_new, &glyph_bbox );
2180                 if( outline )
2181                     BBoxEnlarge( &line_bbox_new, &outline_bbox );
2182                 if( shadow )
2183                     BBoxEnlarge( &line_bbox_new, &shadow_bbox );
2184
2185                 b_break_line = i_index > i_start &&
2186                                line_bbox_new.xMax - line_bbox_new.xMin >= (int)p_filter->fmt_out.video.i_visible_width;
2187                 if( b_break_line )
2188                 {
2189                     FT_Done_Glyph( glyph );
2190                     if( outline )
2191                         FT_Done_Glyph( outline );
2192                     if( shadow )
2193                         FT_Done_Glyph( shadow );
2194
2195                     break_point_t *p_bp = NULL;
2196                     if( break_point.i_index > i_start )
2197                         p_bp = &break_point;
2198                     else if( break_point_fallback.i_index > i_start )
2199                         p_bp = &break_point_fallback;
2200
2201                     if( p_bp )
2202                     {
2203                         msg_Dbg( p_filter, "Breaking line");
2204                         for( int i = p_bp->i_index; i < i_index; i++ )
2205                         {
2206                             line_character_t *ch = &p_line->p_character[i - i_start];
2207                             FT_Done_Glyph( (FT_Glyph)ch->p_glyph );
2208                             if( ch->p_outline )
2209                                 FT_Done_Glyph( (FT_Glyph)ch->p_outline );
2210                             if( ch->p_shadow )
2211                                 FT_Done_Glyph( (FT_Glyph)ch->p_shadow );
2212                         }
2213                         p_line->i_character_count = p_bp->i_index - i_start;
2214
2215                         i_index = p_bp->i_index;
2216                         pen = p_bp->pen;
2217                         line_bbox = p_bp->line_bbox;
2218                         i_face_height = p_bp->i_face_height;
2219                         i_ul_offset = p_bp->i_ul_offset;
2220                         i_ul_thickness = p_bp->i_ul_thickness;
2221                     }
2222                     else
2223                     {
2224                         msg_Err( p_filter, "Breaking unbreakable line");
2225                     }
2226                     break;
2227                 }
2228
2229                 assert( p_line->i_character_count == i_index - i_start);
2230                 p_line->p_character[p_line->i_character_count++] = (line_character_t){
2231                     .p_glyph = (FT_BitmapGlyph)glyph,
2232                     .p_outline = (FT_BitmapGlyph)outline,
2233                     .p_shadow = (FT_BitmapGlyph)shadow,
2234                     .i_color = i_color,
2235                     .i_line_offset = i_line_offset,
2236                     .i_line_thickness = i_line_thickness,
2237                 };
2238
2239                 pen.x = pen_new.x + p_current_face->glyph->advance.x;
2240                 pen.y = pen_new.y + p_current_face->glyph->advance.y;
2241                 line_bbox = line_bbox_new;
2242             next:
2243                 i_glyph_last = i_glyph_index;
2244                 i_part_length--;
2245                 i_index++;
2246
2247                 if( character == ' ' || character == '\t' )
2248                     SAVE_BP( break_point );
2249                 else if( character == 160 )
2250                     SAVE_BP( break_point_fallback );
2251             }
2252             if( b_break_line )
2253                 break;
2254         }
2255 #undef SAVE_BP
2256         /* Update our baseline */
2257         if( i_face_height_previous > 0 )
2258             i_base_line += __MAX(i_face_height, i_face_height_previous);
2259         if( i_face_height > 0 )
2260             i_face_height_previous = i_face_height;
2261
2262         /* Update the line bbox with the actual base line */
2263         if (line_bbox.yMax > line_bbox.yMin) {
2264             line_bbox.yMin -= i_base_line;
2265             line_bbox.yMax -= i_base_line;
2266         }
2267         BBoxEnlarge( &bbox, &line_bbox );
2268
2269         /* Terminate and append the line */
2270         if( p_line )
2271         {
2272             p_line->i_width  = __MAX(line_bbox.xMax - line_bbox.xMin, 0);
2273             p_line->i_base_line = i_base_line;
2274             if( i_ul_thickness > 0 )
2275             {
2276                 for( int i = 0; i < p_line->i_character_count; i++ )
2277                 {
2278                     line_character_t *ch = &p_line->p_character[i];
2279                     if( ch->i_line_thickness < 0 )
2280                     {
2281                         ch->i_line_offset    = i_ul_offset;
2282                         ch->i_line_thickness = i_ul_thickness;
2283                     }
2284                 }
2285             }
2286
2287             *pp_line_next = p_line;
2288             pp_line_next = &p_line->p_next;
2289         }
2290
2291         *pi_max_face_height = __MAX( *pi_max_face_height, i_face_height );
2292
2293         /* Skip what we have rendered and the line delimitor if present */
2294         i_start = i_index;
2295         if( i_start < i_len && psz_text[i_start] == '\n' )
2296             i_start++;
2297
2298         if( bbox.yMax - bbox.yMin >= (int)p_filter->fmt_out.video.i_visible_height )
2299         {
2300             msg_Err( p_filter, "Truncated too high subtitle" );
2301             break;
2302         }
2303     }
2304     if( p_face )
2305         FT_Done_Face( p_face );
2306
2307     free( pp_fribidi_styles );
2308     free( p_fribidi_string );
2309     free( pi_karaoke_bar );
2310
2311     *p_bbox = bbox;
2312     return VLC_SUCCESS;
2313 }
2314
2315 /**
2316  * This function renders a text subpicture region into another one.
2317  * It also calculates the size needed for this string, and renders the
2318  * needed glyphs into memory. It is used as pf_add_string callback in
2319  * the vout method by this module
2320  */
2321 static int RenderCommon( filter_t *p_filter, subpicture_region_t *p_region_out,
2322                          subpicture_region_t *p_region_in, bool b_html,
2323                          const vlc_fourcc_t *p_chroma_list )
2324 {
2325     filter_sys_t *p_sys = p_filter->p_sys;
2326
2327     if( !p_region_in )
2328         return VLC_EGENERIC;
2329     if( b_html && !p_region_in->psz_html )
2330         return VLC_EGENERIC;
2331     if( !b_html && !p_region_in->psz_text )
2332         return VLC_EGENERIC;
2333
2334     const size_t i_text_max = strlen( b_html ? p_region_in->psz_html
2335                                              : p_region_in->psz_text );
2336
2337     uni_char_t *psz_text = calloc( i_text_max, sizeof( *psz_text ) );
2338     text_style_t **pp_styles = calloc( i_text_max, sizeof( *pp_styles ) );
2339     if( !psz_text || !pp_styles )
2340     {
2341         free( psz_text );
2342         free( pp_styles );
2343         return VLC_EGENERIC;
2344     }
2345
2346     /* Reset the default fontsize in case screen metrics have changed */
2347     p_filter->p_sys->i_font_size = GetFontSize( p_filter );
2348
2349     /* */
2350     int rv = VLC_SUCCESS;
2351     int i_text_length = 0;
2352     FT_BBox bbox;
2353     int i_max_face_height;
2354     line_desc_t *p_lines = NULL;
2355
2356     uint32_t *pi_k_durations   = NULL;
2357
2358 #ifdef HAVE_STYLES
2359     if( b_html )
2360     {
2361         stream_t *p_sub = stream_MemoryNew( VLC_OBJECT(p_filter),
2362                                             (uint8_t *) p_region_in->psz_html,
2363                                             strlen( p_region_in->psz_html ),
2364                                             true );
2365         if( unlikely(p_sub == NULL) )
2366             return VLC_SUCCESS;
2367
2368         xml_reader_t *p_xml_reader = p_filter->p_sys->p_xml;
2369         if( !p_xml_reader )
2370             p_xml_reader = xml_ReaderCreate( p_filter, p_sub );
2371         else
2372             p_xml_reader = xml_ReaderReset( p_xml_reader, p_sub );
2373         p_filter->p_sys->p_xml = p_xml_reader;
2374
2375         if( !p_xml_reader )
2376             rv = VLC_EGENERIC;
2377
2378         if( !rv )
2379         {
2380             /* Look for Root Node */
2381             const char *node;
2382
2383             if( xml_ReaderNextNode( p_xml_reader, &node ) == XML_READER_STARTELEM )
2384             {
2385                 if( strcasecmp( "karaoke", node ) == 0 )
2386                 {
2387                     pi_k_durations = calloc( i_text_max, sizeof( *pi_k_durations ) );
2388                 }
2389                 else if( strcasecmp( "text", node ) != 0 )
2390                 {
2391                     /* Only text and karaoke tags are supported */
2392                     msg_Dbg( p_filter, "Unsupported top-level tag <%s> ignored.",
2393                              node );
2394                     rv = VLC_EGENERIC;
2395                 }
2396             }
2397             else
2398             {
2399                 msg_Err( p_filter, "Malformed HTML subtitle" );
2400                 rv = VLC_EGENERIC;
2401             }
2402         }
2403         if( !rv )
2404         {
2405             rv = ProcessNodes( p_filter,
2406                                psz_text, pp_styles, pi_k_durations, &i_text_length,
2407                                p_xml_reader, p_region_in->p_style );
2408         }
2409
2410         if( p_xml_reader )
2411             p_filter->p_sys->p_xml = xml_ReaderReset( p_xml_reader, NULL );
2412
2413         stream_Delete( p_sub );
2414     }
2415     else
2416 #endif
2417     {
2418         text_style_t *p_style;
2419         if( p_region_in->p_style )
2420             p_style = CreateStyle( p_region_in->p_style->psz_fontname,
2421                                    p_region_in->p_style->i_font_size > 0 ? p_region_in->p_style->i_font_size
2422                                                                          : p_sys->i_font_size,
2423                                    (p_region_in->p_style->i_font_color & 0xffffff) |
2424                                    ((p_region_in->p_style->i_font_alpha & 0xff) << 24),
2425                                    0x00ffffff,
2426                                    p_region_in->p_style->i_style_flags & (STYLE_BOLD |
2427                                                                           STYLE_ITALIC |
2428                                                                           STYLE_UNDERLINE |
2429                                                                           STYLE_STRIKEOUT) );
2430         else
2431             p_style = CreateStyle( p_sys->psz_fontfamily,
2432                                    p_sys->i_font_size,
2433                                    (p_sys->i_font_color & 0xffffff) |
2434                                    ((p_sys->i_font_opacity & 0xff) << 24),
2435                                    0x00ffffff, 0);
2436         if( p_sys->b_font_bold )
2437             p_style->i_style_flags |= STYLE_BOLD;
2438
2439         i_text_length = SetupText( p_filter,
2440                                    psz_text,
2441                                    pp_styles,
2442                                    NULL,
2443                                    p_region_in->psz_text, p_style, 0 );
2444     }
2445
2446     if( !rv && i_text_length > 0 )
2447     {
2448         rv = ProcessLines( p_filter,
2449                            &p_lines, &bbox, &i_max_face_height,
2450                            psz_text, pp_styles, pi_k_durations, i_text_length );
2451     }
2452
2453     p_region_out->i_x = p_region_in->i_x;
2454     p_region_out->i_y = p_region_in->i_y;
2455
2456     /* Don't attempt to render text that couldn't be layed out
2457      * properly. */
2458     if( !rv && i_text_length > 0 && bbox.xMin < bbox.xMax && bbox.yMin < bbox.yMax )
2459     {
2460         const vlc_fourcc_t p_chroma_list_yuvp[] = { VLC_CODEC_YUVP, 0 };
2461         const vlc_fourcc_t p_chroma_list_rgba[] = { VLC_CODEC_RGBA, 0 };
2462
2463         if( var_InheritBool( p_filter, "freetype-yuvp" ) )
2464             p_chroma_list = p_chroma_list_yuvp;
2465         else if( !p_chroma_list || *p_chroma_list == 0 )
2466             p_chroma_list = p_chroma_list_rgba;
2467
2468         const int i_margin = p_sys->i_background_opacity > 0 ? i_max_face_height / 4 : 0;
2469         for( const vlc_fourcc_t *p_chroma = p_chroma_list; *p_chroma != 0; p_chroma++ )
2470         {
2471             rv = VLC_EGENERIC;
2472             if( *p_chroma == VLC_CODEC_YUVP )
2473                 rv = RenderYUVP( p_filter, p_region_out, p_lines, &bbox );
2474             else if( *p_chroma == VLC_CODEC_YUVA )
2475                 rv = RenderAXYZ( p_filter, p_region_out, p_lines, &bbox, i_margin,
2476                                  VLC_CODEC_YUVA,
2477                                  YUVFromRGB,
2478                                  FillYUVAPicture,
2479                                  BlendYUVAPixel );
2480             else if( *p_chroma == VLC_CODEC_RGBA )
2481                 rv = RenderAXYZ( p_filter, p_region_out, p_lines, &bbox, i_margin,
2482                                  VLC_CODEC_RGBA,
2483                                  RGBFromRGB,
2484                                  FillRGBAPicture,
2485                                  BlendRGBAPixel );
2486             if( !rv )
2487                 break;
2488         }
2489
2490         /* With karaoke, we're going to have to render the text a number
2491          * of times to show the progress marker on the text.
2492          */
2493         if( pi_k_durations )
2494             var_SetBool( p_filter, "text-rerender", true );
2495     }
2496
2497     FreeLines( p_lines );
2498
2499     free( psz_text );
2500     for( int i = 0; i < i_text_length; i++ )
2501     {
2502         if( pp_styles[i] && ( i + 1 == i_text_length || pp_styles[i] != pp_styles[i + 1] ) )
2503             text_style_Delete( pp_styles[i] );
2504     }
2505     free( pp_styles );
2506     free( pi_k_durations );
2507
2508     return rv;
2509 }
2510
2511 static int RenderText( filter_t *p_filter, subpicture_region_t *p_region_out,
2512                        subpicture_region_t *p_region_in,
2513                        const vlc_fourcc_t *p_chroma_list )
2514 {
2515     return RenderCommon( p_filter, p_region_out, p_region_in, false, p_chroma_list );
2516 }
2517
2518 #ifdef HAVE_STYLES
2519
2520 static int RenderHtml( filter_t *p_filter, subpicture_region_t *p_region_out,
2521                        subpicture_region_t *p_region_in,
2522                        const vlc_fourcc_t *p_chroma_list )
2523 {
2524     return RenderCommon( p_filter, p_region_out, p_region_in, true, p_chroma_list );
2525 }
2526
2527 #endif
2528
2529 /*****************************************************************************
2530  * Create: allocates osd-text video thread output method
2531  *****************************************************************************
2532  * This function allocates and initializes a Clone vout method.
2533  *****************************************************************************/
2534 static int Create( vlc_object_t *p_this )
2535 {
2536     filter_t      *p_filter = (filter_t *)p_this;
2537     filter_sys_t  *p_sys;
2538     char          *psz_fontfile   = NULL;
2539     char          *psz_fontfamily = NULL;
2540     int            i_error = 0, fontindex = 0;
2541
2542     /* Allocate structure */
2543     p_filter->p_sys = p_sys = malloc( sizeof(*p_sys) );
2544     if( !p_sys )
2545         return VLC_ENOMEM;
2546
2547     p_sys->psz_fontfamily   = NULL;
2548 #ifdef HAVE_STYLES
2549     p_sys->p_xml            = NULL;
2550 #endif
2551     p_sys->p_face           = 0;
2552     p_sys->p_library        = 0;
2553     p_sys->i_font_size      = 0;
2554     p_sys->i_display_height = 0;
2555
2556     var_Create( p_filter, "freetype-rel-fontsize",
2557                 VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
2558
2559     psz_fontfamily = var_InheritString( p_filter, "freetype-font" );
2560     p_sys->i_default_font_size = var_InheritInteger( p_filter, "freetype-fontsize" );
2561     p_sys->i_font_opacity = var_InheritInteger( p_filter,"freetype-opacity" );
2562     p_sys->i_font_opacity = VLC_CLIP( p_sys->i_font_opacity, 0, 255 );
2563     p_sys->i_font_color = var_InheritInteger( p_filter, "freetype-color" );
2564     p_sys->i_font_color = VLC_CLIP( p_sys->i_font_color, 0, 0xFFFFFF );
2565     p_sys->b_font_bold = var_InheritBool( p_filter, "freetype-bold" );
2566
2567     p_sys->i_background_opacity = var_InheritInteger( p_filter,"freetype-background-opacity" );;
2568     p_sys->i_background_opacity = VLC_CLIP( p_sys->i_background_opacity, 0, 255 );
2569     p_sys->i_background_color = var_InheritInteger( p_filter, "freetype-background-color" );
2570     p_sys->i_background_color = VLC_CLIP( p_sys->i_background_color, 0, 0xFFFFFF );
2571
2572     p_sys->f_outline_thickness = var_InheritInteger( p_filter, "freetype-outline-thickness" ) / 100.0;
2573     p_sys->f_outline_thickness = VLC_CLIP( p_sys->f_outline_thickness, 0.0, 0.5 );
2574     p_sys->i_outline_opacity = var_InheritInteger( p_filter, "freetype-outline-opacity" );
2575     p_sys->i_outline_opacity = VLC_CLIP( p_sys->i_outline_opacity, 0, 255 );
2576     p_sys->i_outline_color = var_InheritInteger( p_filter, "freetype-outline-color" );
2577     p_sys->i_outline_color = VLC_CLIP( p_sys->i_outline_color, 0, 0xFFFFFF );
2578
2579     p_sys->i_shadow_opacity = var_InheritInteger( p_filter, "freetype-shadow-opacity" );
2580     p_sys->i_shadow_opacity = VLC_CLIP( p_sys->i_shadow_opacity, 0, 255 );
2581     p_sys->i_shadow_color = var_InheritInteger( p_filter, "freetype-shadow-color" );
2582     p_sys->i_shadow_color = VLC_CLIP( p_sys->i_shadow_color, 0, 0xFFFFFF );
2583     float f_shadow_angle = var_InheritFloat( p_filter, "freetype-shadow-angle" );
2584     float f_shadow_distance = var_InheritFloat( p_filter, "freetype-shadow-distance" );
2585     f_shadow_distance = VLC_CLIP( f_shadow_distance, 0, 1 );
2586     p_sys->f_shadow_vector_x = f_shadow_distance * cos(2 * M_PI * f_shadow_angle / 360);
2587     p_sys->f_shadow_vector_y = f_shadow_distance * sin(2 * M_PI * f_shadow_angle / 360);
2588
2589 #ifdef WIN32
2590     /* Get Windows Font folder */
2591     wchar_t wdir[MAX_PATH];
2592     if( S_OK != SHGetFolderPathW( NULL, CSIDL_FONTS, NULL, SHGFP_TYPE_CURRENT, wdir ) )
2593     {
2594         GetWindowsDirectoryW( wdir, MAX_PATH );
2595         wcscat( wdir, L"\\fonts" );
2596     }
2597     p_sys->psz_win_fonts_path = FromWide( wdir );
2598 #endif
2599
2600     /* Set default psz_fontfamily */
2601     if( !psz_fontfamily || !*psz_fontfamily )
2602     {
2603         free( psz_fontfamily );
2604 #ifdef HAVE_STYLES
2605         psz_fontfamily = strdup( DEFAULT_FAMILY );
2606 #else
2607 # ifdef WIN32
2608         if( asprintf( &psz_fontfamily, "%s"DEFAULT_FONT_FILE, p_sys->psz_win_fonts_path ) == -1 )
2609             goto error;
2610 # else
2611         psz_fontfamily = strdup( DEFAULT_FONT_FILE );
2612 # endif
2613         msg_Err( p_filter,"User specified an empty fontfile, using %s", psz_fontfamily );
2614 #endif
2615     }
2616
2617     /* Set the current font file */
2618     p_sys->psz_fontfamily = psz_fontfamily;
2619 #ifdef HAVE_STYLES
2620 #ifdef HAVE_FONTCONFIG
2621     FontConfig_BuildCache( p_filter );
2622
2623     /* */
2624     psz_fontfile = FontConfig_Select( NULL, psz_fontfamily, false, false,
2625                                       p_sys->i_default_font_size, &fontindex );
2626 #elif defined(WIN32)
2627     psz_fontfile = Win32_Select( p_filter, psz_fontfamily, false, false,
2628                                  p_sys->i_default_font_size, &fontindex );
2629
2630 #endif
2631     msg_Dbg( p_filter, "Using %s as font from file %s", psz_fontfamily, psz_fontfile );
2632
2633     /* If nothing is found, use the default family */
2634     if( !psz_fontfile )
2635         psz_fontfile = strdup( psz_fontfamily );
2636
2637 #else /* !HAVE_STYLES */
2638     /* Use the default file */
2639     psz_fontfile = psz_fontfamily;
2640 #endif
2641
2642     /* */
2643     i_error = FT_Init_FreeType( &p_sys->p_library );
2644     if( i_error )
2645     {
2646         msg_Err( p_filter, "couldn't initialize freetype" );
2647         goto error;
2648     }
2649
2650     i_error = FT_New_Face( p_sys->p_library, psz_fontfile ? psz_fontfile : "",
2651                            fontindex, &p_sys->p_face );
2652
2653     if( i_error == FT_Err_Unknown_File_Format )
2654     {
2655         msg_Err( p_filter, "file %s have unknown format",
2656                  psz_fontfile ? psz_fontfile : "(null)" );
2657         goto error;
2658     }
2659     else if( i_error )
2660     {
2661         msg_Err( p_filter, "failed to load font file %s",
2662                  psz_fontfile ? psz_fontfile : "(null)" );
2663         goto error;
2664     }
2665
2666     i_error = FT_Select_Charmap( p_sys->p_face, ft_encoding_unicode );
2667     if( i_error )
2668     {
2669         msg_Err( p_filter, "font has no unicode translation table" );
2670         goto error;
2671     }
2672
2673     if( SetFontSize( p_filter, 0 ) != VLC_SUCCESS ) goto error;
2674
2675     p_sys->p_stroker = NULL;
2676     if( p_sys->f_outline_thickness > 0.001 )
2677     {
2678         i_error = FT_Stroker_New( p_sys->p_library, &p_sys->p_stroker );
2679         if( i_error )
2680             msg_Err( p_filter, "Failed to create stroker for outlining" );
2681     }
2682
2683     p_sys->pp_font_attachments = NULL;
2684     p_sys->i_font_attachments = 0;
2685
2686     p_filter->pf_render_text = RenderText;
2687 #ifdef HAVE_STYLES
2688     p_filter->pf_render_html = RenderHtml;
2689 #else
2690     p_filter->pf_render_html = NULL;
2691 #endif
2692
2693     LoadFontsFromAttachments( p_filter );
2694
2695 #ifdef HAVE_STYLES
2696     free( psz_fontfile );
2697 #endif
2698
2699     return VLC_SUCCESS;
2700
2701 error:
2702     if( p_sys->p_face ) FT_Done_Face( p_sys->p_face );
2703     if( p_sys->p_library ) FT_Done_FreeType( p_sys->p_library );
2704 #ifdef HAVE_STYLES
2705     free( psz_fontfile );
2706 #endif
2707     free( psz_fontfamily );
2708     free( p_sys );
2709     return VLC_EGENERIC;
2710 }
2711
2712 /*****************************************************************************
2713  * Destroy: destroy Clone video thread output method
2714  *****************************************************************************
2715  * Clean up all data and library connections
2716  *****************************************************************************/
2717 static void Destroy( vlc_object_t *p_this )
2718 {
2719     filter_t *p_filter = (filter_t *)p_this;
2720     filter_sys_t *p_sys = p_filter->p_sys;
2721
2722     if( p_sys->pp_font_attachments )
2723     {
2724         for( int k = 0; k < p_sys->i_font_attachments; k++ )
2725             vlc_input_attachment_Delete( p_sys->pp_font_attachments[k] );
2726
2727         free( p_sys->pp_font_attachments );
2728     }
2729
2730 #ifdef HAVE_STYLES
2731     if( p_sys->p_xml ) xml_ReaderDelete( p_sys->p_xml );
2732 #endif
2733     free( p_sys->psz_fontfamily );
2734
2735     /* FcFini asserts calling the subfunction FcCacheFini()
2736      * even if no other library functions have been made since FcInit(),
2737      * so don't call it. */
2738
2739     if( p_sys->p_stroker )
2740         FT_Stroker_Done( p_sys->p_stroker );
2741     FT_Done_Face( p_sys->p_face );
2742     FT_Done_FreeType( p_sys->p_library );
2743     free( p_sys );
2744 }
2745
2746