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

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

midi

开发平台：

Unix_Linux

freetype.c：源码内容
  1. /*****************************************************************************
  2.  * freetype.c : Put text on the video, using freetype2
  3.  *****************************************************************************
  4.  * Copyright (C) 2002 - 2007 the VideoLAN team
  5.  * $Id: 99b7a80304afd53d0038e167aa0edc46dd46fc35 $
  6.  *
  7.  * Authors: Sigmund Augdal Helberg <dnumgis@videolan.org>
  8.  *          Gildas Bazin <gbazin@videolan.org>
  9.  *          Bernie Purcell <bitmap@videolan.org>
  10.  *
  11.  * This program is free software; you can redistribute it and/or modify
  12.  * it under the terms of the GNU General Public License as published by
  13.  * the Free Software Foundation; either version 2 of the License, or
  14.  * (at your option) any later version.
  15.  *
  16.  * This program is distributed in the hope that it will be useful,
  17.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19.  * GNU General Public License for more details.
  20.  *
  21.  * You should have received a copy of the GNU General Public License
  22.  * along with this program; if not, write to the Free Software
  23.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  24.  *****************************************************************************/
  26. /*****************************************************************************
  27.  * Preamble
  28.  *****************************************************************************/
  30. #ifdef HAVE_CONFIG_H
  31. # include "config.h"
  32. #endif
  34. #include <vlc_common.h>
  35. #include <vlc_plugin.h>
  36. #include <vlc_osd.h>
  37. #include <vlc_filter.h>
  38. #include <vlc_stream.h>
  39. #include <vlc_xml.h>
  40. #include <vlc_input.h>
  41. #include <vlc_strings.h>
  43. #include <math.h>
  44. #include <errno.h>
  46. #include <ft2build.h>
  47. #include FT_FREETYPE_H
  48. #include FT_GLYPH_H
  49. #define FT_FLOOR(X)     ((X & -64) >> 6)
  50. #define FT_CEIL(X)      (((X + 63) & -64) >> 6)
  51. #define FT_MulFix(v, s) (((v)*(s))>>16)
  53. #ifdef __APPLE__
  54. #import <Carbon/Carbon.h>
  55. #endif
  57. #ifdef __APPLE__
  58. #define DEFAULT_FONT "/Library/Fonts/Arial Black.ttf"
  59. #define FC_DEFAULT_FONT "Arial Black"
  60. #elif defined( SYS_BEOS )
  61. #define DEFAULT_FONT "/boot/beos/etc/fonts/ttfonts/Swiss721.ttf"
  62. #define FC_DEFAULT_FONT "Swiss"
  63. #elif defined( WIN32 )
  64. #define DEFAULT_FONT "" /* Default font found at run-time */
  65. #define FC_DEFAULT_FONT "Arial"
  66. #else
  67. #define DEFAULT_FONT "/usr/share/fonts/truetype/freefont/FreeSerifBold.ttf"
  68. #define FC_DEFAULT_FONT "Serif Bold"
  69. #endif
  71. #if defined(HAVE_FRIBIDI)
  72. #include <fribidi/fribidi.h>
  73. #endif
  75. #ifdef HAVE_FONTCONFIG
  76. #include <fontconfig/fontconfig.h>
  77. #endif
  79. #include <assert.h>
  81. /*****************************************************************************
  82.  * Module descriptor
  83.  *****************************************************************************/
  84. static int  Create ( vlc_object_t * );
  85. static void Destroy( vlc_object_t * );
  87. #define FONT_TEXT N_("Font")
  88. #define FONT_LONGTEXT N_("Filename for the font you want to use")
  89. #define FONTSIZE_TEXT N_("Font size in pixels")
  90. #define FONTSIZE_LONGTEXT N_("This is the default size of the fonts " 
  91.     "that will be rendered on the video. " 
  92.     "If set to something different than 0 this option will override the " 
  93.     "relative font size." )
  94. #define OPACITY_TEXT N_("Opacity")
  95. #define OPACITY_LONGTEXT N_("The opacity (inverse of transparency) of the " 
  96.     "text that will be rendered on the video. 0 = transparent, " 
  97.     "255 = totally opaque. " )
  98. #define COLOR_TEXT N_("Text default color")
  99. #define COLOR_LONGTEXT N_("The color of the text that will be rendered on "
  100.     "the video. This must be an hexadecimal (like HTML colors). The first two "
  101.     "chars are for red, then green, then blue. #000000 = black, #FF0000 = red,"
  102.     " #00FF00 = green, #FFFF00 = yellow (red + green), #FFFFFF = white" )
  103. #define FONTSIZER_TEXT N_("Relative font size")
  104. #define FONTSIZER_LONGTEXT N_("This is the relative default size of the " 
  105.     "fonts that will be rendered on the video. If absolute font size is set, "
  106.     "relative size will be overriden." )
  108. static const int pi_sizes[] = { 20, 18, 16, 12, 6 };
  109. static const char *const ppsz_sizes_text[] = {
  110.     N_("Smaller"), N_("Small"), N_("Normal"), N_("Large"), N_("Larger") };
  111. #define YUVP_TEXT N_("Use YUVP renderer")
  112. #define YUVP_LONGTEXT N_("This renders the font using "paletized YUV". " 
  113.   "This option is only needed if you want to encode into DVB subtitles" )
  114. #define EFFECT_TEXT N_("Font Effect")
  115. #define EFFECT_LONGTEXT N_("It is possible to apply effects to the rendered " 
  116. "text to improve its readability." )
  118. #define EFFECT_BACKGROUND  1
  119. #define EFFECT_OUTLINE     2
  120. #define EFFECT_OUTLINE_FAT 3
  122. static int const pi_effects[] = { 1, 2, 3 };
  123. static const char *const ppsz_effects_text[] = {
  124.     N_("Background"),N_("Outline"), N_("Fat Outline") };
  125. static const int pi_color_values[] = {
  126.   0x00000000, 0x00808080, 0x00C0C0C0, 0x00FFFFFF, 0x00800000,
  127.   0x00FF0000, 0x00FF00FF, 0x00FFFF00, 0x00808000, 0x00008000, 0x00008080,
  128.   0x0000FF00, 0x00800080, 0x00000080, 0x000000FF, 0x0000FFFF };
  130. static const char *const ppsz_color_descriptions[] = {
  131.   N_("Black"), N_("Gray"), N_("Silver"), N_("White"), N_("Maroon"),
  132.   N_("Red"), N_("Fuchsia"), N_("Yellow"), N_("Olive"), N_("Green"), N_("Teal"),
  133.   N_("Lime"), N_("Purple"), N_("Navy"), N_("Blue"), N_("Aqua") };
  135. vlc_module_begin ()
  136.     set_shortname( N_("Text renderer"))
  137.     set_description( N_("Freetype2 font renderer") )
  138.     set_category( CAT_VIDEO )
  139.     set_subcategory( SUBCAT_VIDEO_SUBPIC )
  141.     add_file( "freetype-font", DEFAULT_FONT, NULL, FONT_TEXT, FONT_LONGTEXT,
  142.               false )
  144.     add_integer( "freetype-fontsize", 0, NULL, FONTSIZE_TEXT,
  145.                  FONTSIZE_LONGTEXT, true )
  147.     /* opacity valid on 0..255, with default 255 = fully opaque */
  148.     add_integer_with_range( "freetype-opacity", 255, 0, 255, NULL,
  149.         OPACITY_TEXT, OPACITY_LONGTEXT, true )
  151.     /* hook to the color values list, with default 0x00ffffff = white */
  152.     add_integer( "freetype-color", 0x00FFFFFF, NULL, COLOR_TEXT,
  153.                  COLOR_LONGTEXT, false )
  154.         change_integer_list( pi_color_values, ppsz_color_descriptions, NULL )
  156.     add_integer( "freetype-rel-fontsize", 16, NULL, FONTSIZER_TEXT,
  157.                  FONTSIZER_LONGTEXT, false )
  158.         change_integer_list( pi_sizes, ppsz_sizes_text, NULL )
  159.     add_integer( "freetype-effect", 2, NULL, EFFECT_TEXT,
  160.                  EFFECT_LONGTEXT, false )
  161.         change_integer_list( pi_effects, ppsz_effects_text, NULL )
  163.     add_bool( "freetype-yuvp", 0, NULL, YUVP_TEXT,
  164.               YUVP_LONGTEXT, true )
  165.     set_capability( "text renderer", 100 )
  166.     add_shortcut( "text" )
  167.     set_callbacks( Create, Destroy )
  168. vlc_module_end ()
  172. /*****************************************************************************
  173.  * Local prototypes
  174.  *****************************************************************************/
  176. /* The RenderText call maps to pf_render_string, defined in vlc_filter.h */
  177. static int RenderText( filter_t *, subpicture_region_t *,
  178.                        subpicture_region_t * );
  179. #ifdef HAVE_FONTCONFIG
  180. static int RenderHtml( filter_t *, subpicture_region_t *,
  181.                        subpicture_region_t * );
  182. static char *FontConfig_Select( FcConfig *, const char *,
  183.                                 bool, bool, int * );
  184. #endif
  187. static int LoadFontsFromAttachments( filter_t *p_filter );
  189. static int GetFontSize( filter_t *p_filter );
  190. static int SetFontSize( filter_t *, int );
  191. static void YUVFromRGB( uint32_t i_argb,
  192.                         uint8_t *pi_y, uint8_t *pi_u, uint8_t *pi_v );
  194. typedef struct line_desc_t line_desc_t;
  195. struct line_desc_t
  196. {
  197.     /** NULL-terminated list of glyphs making the string */
  198.     FT_BitmapGlyph *pp_glyphs;
  199.     /** list of relative positions for the glyphs */
  200.     FT_Vector      *p_glyph_pos;
  201.     /** list of RGB information for styled text
  202.      * -- if the rendering mode supports it (RenderYUVA) and
  203.      *  b_new_color_mode is set, then it becomes possible to
  204.      *  have multicoloured text within the subtitles. */
  205.     uint32_t       *p_fg_rgb;
  206.     uint32_t       *p_bg_rgb;
  207.     uint8_t        *p_fg_bg_ratio; /* 0x00=100% FG --> 0x7F=100% BG */
  208.     bool      b_new_color_mode;
  209.     /** underline information -- only supplied if text should be underlined */
  210.     uint16_t       *pi_underline_offset;
  211.     uint16_t       *pi_underline_thickness;
  213.     int             i_height;
  214.     int             i_width;
  215.     int             i_red, i_green, i_blue;
  216.     int             i_alpha;
  218.     line_desc_t    *p_next;
  219. };
  220. static line_desc_t *NewLine( int );
  222. typedef struct
  223. {
  224.     int         i_font_size;
  225.     uint32_t    i_font_color;         /* ARGB */
  226.     uint32_t    i_karaoke_bg_color;   /* ARGB */
  227.     bool  b_italic;
  228.     bool  b_bold;
  229.     bool  b_underline;
  230.     char       *psz_fontname;
  231. } ft_style_t;
  233. static int Render( filter_t *, subpicture_region_t *, line_desc_t *, int, int);
  234. static void FreeLines( line_desc_t * );
  235. static void FreeLine( line_desc_t * );
  237. #ifdef HAVE_FONTCONFIG
  238. static vlc_object_t *FontBuilderAttach( filter_t *p_filter );
  239. static void  FontBuilderDetach( filter_t *p_filter, vlc_object_t *p_fontbuilder );
  240. static void* FontBuilderThread( vlc_object_t *p_this);
  241. static void  FontBuilderDestructor( vlc_object_t *p_this );
  242. static void  FontBuilderGetFcConfig( filter_t *p_filter, vlc_object_t *p_fontbuilder );
  243. static int   FontBuilderDone( vlc_object_t*, const char *, vlc_value_t, vlc_value_t,
  244.                         void* );
  245. #endif
  247. /*****************************************************************************
  248.  * filter_sys_t: freetype local data
  249.  *****************************************************************************
  250.  * This structure is part of the video output thread descriptor.
  251.  * It describes the freetype specific properties of an output thread.
  252.  *****************************************************************************/
  253. struct filter_sys_t
  254. {
  255.     FT_Library     p_library;   /* handle to library     */
  256.     FT_Face        p_face;      /* handle to face object */
  257.     bool     i_use_kerning;
  258.     uint8_t        i_font_opacity;
  259.     int            i_font_color;
  260.     int            i_font_size;
  261.     int            i_effect;
  263.     int            i_default_font_size;
  264.     int            i_display_height;
  265. #ifdef HAVE_FONTCONFIG
  266.     bool           b_fontconfig_ok;
  267.     FcConfig      *p_fontconfig;
  268.     xml_t         *p_xml;
  269. #endif
  271.     input_attachment_t **pp_font_attachments;
  272.     int                  i_font_attachments;
  274.     vlc_object_t  *p_fontbuilder;
  275. };
  277. #define UCHAR uint32_t
  278. #define TR_DEFAULT_FONT FC_DEFAULT_FONT
  279. #define TR_FONT_STYLE_PTR ft_style_t *
  281. #include "text_renderer.h"
  283. /*****************************************************************************
  284.  * Create: allocates osd-text video thread output method
  285.  *****************************************************************************
  286.  * This function allocates and initializes a Clone vout method.
  287.  *****************************************************************************/
  288. static int Create( vlc_object_t *p_this )
  289. {
  290.     filter_t      *p_filter = (filter_t *)p_this;
  291.     filter_sys_t  *p_sys;
  292.     char          *psz_fontfile = NULL;
  293.     int            i_error;
  294.     vlc_value_t    val;
  296.     /* Allocate structure */
  297.     p_filter->p_sys = p_sys = malloc( sizeof( filter_sys_t ) );
  298.     if( !p_sys )
  299.         return VLC_ENOMEM;
  300.  #ifdef HAVE_FONTCONFIG
  301.     p_sys->p_xml = NULL;
  302. #endif
  303.     p_sys->p_face = 0;
  304.     p_sys->p_library = 0;
  305.     p_sys->i_font_size = 0;
  306.     p_sys->i_display_height = 0;
  308.     var_Create( p_filter, "freetype-font",
  309.                 VLC_VAR_STRING | VLC_VAR_DOINHERIT );
  310.     var_Create( p_filter, "freetype-fontsize",
  311.                 VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
  312.     var_Create( p_filter, "freetype-rel-fontsize",
  313.                 VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
  314.     var_Create( p_filter, "freetype-opacity",
  315.                 VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
  316.     var_Create( p_filter, "freetype-effect",
  317.                 VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
  318.     var_Get( p_filter, "freetype-opacity", &val );
  319.     p_sys->i_font_opacity = __MAX( __MIN( val.i_int, 255 ), 0 );
  320.     var_Create( p_filter, "freetype-color",
  321.                 VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
  322.     var_Get( p_filter, "freetype-color", &val );
  323.     p_sys->i_font_color = __MAX( __MIN( val.i_int, 0xFFFFFF ), 0 );
  324.     p_sys->i_effect = var_GetInteger( p_filter, "freetype-effect" );
  326.     /* Look what method was requested */
  327.     var_Get( p_filter, "freetype-font", &val );
  328.     psz_fontfile = val.psz_string;
  329.     if( !psz_fontfile || !*psz_fontfile )
  330.     {
  331.         free( psz_fontfile );
  332.         psz_fontfile = (char *)malloc( PATH_MAX + 1 );
  333.         if( !psz_fontfile )
  334.             goto error;
  335. #ifdef WIN32
  336.         GetWindowsDirectory( psz_fontfile, PATH_MAX + 1 );
  337.         strcat( psz_fontfile, "\fonts\arial.ttf" );
  338. #else
  339.         msg_Err( p_filter, "user didn't specify a font" );
  340.         goto error;
  341. #endif
  342.     }
  344.     i_error = FT_Init_FreeType( &p_sys->p_library );
  345.     if( i_error )
  346.     {
  347.         msg_Err( p_filter, "couldn't initialize freetype" );
  348.         goto error;
  349.     }
  350.     i_error = FT_New_Face( p_sys->p_library, psz_fontfile ? psz_fontfile : "",
  351.                            0, &p_sys->p_face );
  352.     if( i_error == FT_Err_Unknown_File_Format )
  353.     {
  354.         msg_Err( p_filter, "file %s have unknown format", psz_fontfile );
  355.         goto error;
  356.     }
  357.     else if( i_error )
  358.     {
  359.         msg_Err( p_filter, "failed to load font file %s", psz_fontfile );
  360.         goto error;
  361.     }
  363.     i_error = FT_Select_Charmap( p_sys->p_face, ft_encoding_unicode );
  364.     if( i_error )
  365.     {
  366.         msg_Err( p_filter, "font has no unicode translation table" );
  367.         goto error;
  368.     }
  370. #ifdef HAVE_FONTCONFIG
  371.     p_sys->b_fontconfig_ok = false;
  372.     p_sys->p_fontconfig    = NULL;
  373.     p_sys->p_fontbuilder   = FontBuilderAttach( p_filter );
  374. #endif
  376.     p_sys->i_use_kerning = FT_HAS_KERNING( p_sys->p_face );
  378.     var_Get( p_filter, "freetype-fontsize", &val );
  379.     p_sys->i_default_font_size = val.i_int;
  380.     if( SetFontSize( p_filter, 0 ) != VLC_SUCCESS ) goto error;
  382.     free( psz_fontfile );
  384.     p_sys->pp_font_attachments = NULL;
  385.     p_sys->i_font_attachments = 0;
  387.     p_filter->pf_render_text = RenderText;
  388. #ifdef HAVE_FONTCONFIG
  389.     p_filter->pf_render_html = RenderHtml;
  390. #else
  391.     p_filter->pf_render_html = NULL;
  392. #endif
  394.     LoadFontsFromAttachments( p_filter );
  396.     return VLC_SUCCESS;
  398.  error:
  399.     if( p_sys->p_face ) FT_Done_Face( p_sys->p_face );
  400.     if( p_sys->p_library ) FT_Done_FreeType( p_sys->p_library );
  401.     free( psz_fontfile );
  402.     free( p_sys );
  403.     return VLC_EGENERIC;
  404. }
  406. /*****************************************************************************
  407.  * Destroy: destroy Clone video thread output method
  408.  *****************************************************************************
  409.  * Clean up all data and library connections
  410.  *****************************************************************************/
  411. static void Destroy( vlc_object_t *p_this )
  412. {
  413.     filter_t *p_filter = (filter_t *)p_this;
  414.     filter_sys_t *p_sys = p_filter->p_sys;
  416.     if( p_sys->pp_font_attachments )
  417.     {
  418.         int   k;
  420.         for( k = 0; k < p_sys->i_font_attachments; k++ )
  421.             vlc_input_attachment_Delete( p_sys->pp_font_attachments[k] );
  423.         free( p_sys->pp_font_attachments );
  424.     }
  426. #ifdef HAVE_FONTCONFIG
  427.     FontBuilderDetach( p_filter, p_sys->p_fontbuilder );
  428.     if( p_sys->p_xml ) xml_Delete( p_sys->p_xml );
  429. #endif
  431.     /* FcFini asserts calling the subfunction FcCacheFini()
  432.      * even if no other library functions have been made since FcInit(),
  433.      * so don't call it. */
  435.     FT_Done_Face( p_sys->p_face );
  436.     FT_Done_FreeType( p_sys->p_library );
  437.     free( p_sys );
  438. }
  440. #ifdef HAVE_FONTCONFIG
  441. static vlc_mutex_t fb_lock = VLC_STATIC_MUTEX;
  443. static vlc_object_t *FontBuilderAttach( filter_t *p_filter )
  444. {
  445.     /* Check for an existing Fontbuilder thread */
  446.     vlc_mutex_lock( &fb_lock );
  447.     vlc_object_t *p_fontbuilder =
  448.         vlc_object_find_name( p_filter->p_libvlc,
  449.                               "fontlist builder", FIND_CHILD );
  451.     if( !p_fontbuilder )
  452.     {
  453.         /* Create the FontBuilderThread thread as a child of a top-level
  454.          * object, so that it can survive the destruction of the
  455.          * freetype object - the fontlist only needs to be built once,
  456.          * and calling the fontbuild a second time while the first is
  457.          * still in progress can cause thread instabilities.
  458.          *
  459.          * XXX The fontbuilder will be destroy as soon as it is unused.
  460.          */
  462.         p_fontbuilder = vlc_object_create( p_filter->p_libvlc,
  463.                                            sizeof(vlc_object_t) );
  464.         if( p_fontbuilder )
  465.         {
  466.             p_fontbuilder->psz_object_name = strdup( "fontlist builder" );
  467.             p_fontbuilder->p_private = NULL;
  468.             vlc_object_set_destructor( p_fontbuilder, FontBuilderDestructor );
  470.             vlc_object_attach( p_fontbuilder, p_filter->p_libvlc );
  472.             var_Create( p_fontbuilder, "build-done", VLC_VAR_BOOL );
  473.             var_SetBool( p_fontbuilder, "build-done", false );
  474.             var_Create( p_fontbuilder, "build-joined", VLC_VAR_BOOL );
  475.             var_SetBool( p_fontbuilder, "build-joined", false );
  477.             if( vlc_thread_create( p_fontbuilder,
  478.                                    "fontlist builder",
  479.                                    FontBuilderThread,
  480.                                    VLC_THREAD_PRIORITY_LOW ) )
  481.             {
  482.                 msg_Warn( p_filter, "fontconfig database builder thread can't "
  483.                         "be launched. Font styling support will be limited." );
  484.             }
  485.         }
  486.     }
  488.     if( p_fontbuilder )
  489.     {
  490.         var_AddCallback( p_fontbuilder, "build-done", FontBuilderDone, p_filter );
  491.         FontBuilderGetFcConfig( p_filter, p_fontbuilder );
  492.     }
  493.     vlc_mutex_unlock( &fb_lock );
  494.     return p_fontbuilder;
  495. }
  496. static void FontBuilderDetach( filter_t *p_filter, vlc_object_t *p_fontbuilder )
  497. {
  498.     vlc_mutex_lock( &fb_lock );
  499.     if( p_fontbuilder )
  500.     {
  501.         var_DelCallback( p_fontbuilder, "build-done", FontBuilderDone, p_filter );
  503.         /* We wait for the thread on the first FontBuilderDetach */
  504.         if( !var_GetBool( p_fontbuilder, "build-joined" ) )
  505.         {
  506.             var_SetBool( p_fontbuilder, "build-joined", true );
  507.             vlc_mutex_unlock( &fb_lock );
  508.             /* We need to unlock otherwise we may not join (the thread waiting
  509.              * for the lock). It is safe to unlock as no one else will try a
  510.              * join and we have a reference on the object) */
  511.             vlc_thread_join( p_fontbuilder );
  512.             vlc_mutex_lock( &fb_lock );
  513.         }
  514.         vlc_object_release( p_fontbuilder );
  515.     }
  516.     vlc_mutex_unlock( &fb_lock );
  517. }
  518. static void* FontBuilderThread( vlc_object_t *p_this )
  519. {
  520.     FcConfig      *p_fontconfig = FcInitLoadConfig();
  522.     if( p_fontconfig )
  523.     {
  524.         mtime_t    t1, t2;
  525.         int canc = vlc_savecancel ();
  527.         //msg_Dbg( p_this, "Building font database..." );
  528.         msg_Dbg( p_this, "Building font database..." );
  529.         t1 = mdate();
  530.         if(! FcConfigBuildFonts( p_fontconfig ))
  531.         {
  532.             /* Don't destroy the fontconfig object - we won't be able to do
  533.              * italics or bold or change the font face, but we will still
  534.              * be able to do underline and change the font size.
  535.              */
  536.             msg_Err( p_this, "fontconfig database can't be built. "
  537.                                     "Font styling won't be available" );
  538.         }
  539.         t2 = mdate();
  541.         msg_Dbg( p_this, "Finished building font database." );
  542.         msg_Dbg( p_this, "Took %ld microseconds", (long)((t2 - t1)) );
  544.         vlc_mutex_lock( &fb_lock );
  545.         p_this->p_private = p_fontconfig;
  546.         vlc_mutex_unlock( &fb_lock );
  548.         var_SetBool( p_this, "build-done", true );
  549.         vlc_restorecancel (canc);
  550.     }
  551.     return NULL;
  552. }
  553. static void FontBuilderGetFcConfig( filter_t *p_filter, vlc_object_t *p_fontbuilder )
  554. {
  555.     filter_sys_t *p_sys = p_filter->p_sys;
  557.     p_sys->p_fontconfig = p_fontbuilder->p_private;
  558.     p_sys->b_fontconfig_ok = p_fontbuilder->p_private != NULL;
  559. }
  560. static void FontBuilderDestructor( vlc_object_t *p_this )
  561. {
  562.     FcConfig *p_fontconfig = p_this->p_private;
  564.     if( p_fontconfig )
  565.         FcConfigDestroy( p_fontconfig );
  566. }
  567. static int FontBuilderDone( vlc_object_t *p_this, const char *psz_var,
  568.                        vlc_value_t oldval, vlc_value_t newval, void *param )
  569. {
  570.     filter_t *p_filter = param;
  572.     if( newval.b_bool )
  573.     {
  574.         vlc_mutex_lock( &fb_lock );
  576.         FontBuilderGetFcConfig( p_filter, p_this );
  578.         vlc_mutex_unlock( &fb_lock );
  579.     }
  581.     VLC_UNUSED(psz_var);
  582.     VLC_UNUSED(oldval);
  583.     return VLC_SUCCESS;
  584. }
  585. #endif
  587. /*****************************************************************************
  588.  * Make any TTF/OTF fonts present in the attachments of the media file
  589.  * and store them for later use by the FreeType Engine
  590.  *****************************************************************************/
  591. static int LoadFontsFromAttachments( filter_t *p_filter )
  592. {
  593.     filter_sys_t         *p_sys = p_filter->p_sys;
  594.     input_thread_t       *p_input;
  595.     input_attachment_t  **pp_attachments;
  596.     int                   i_attachments_cnt;
  597.     int                   k;
  598.     int                   rv = VLC_SUCCESS;
  600.     p_input = (input_thread_t *)vlc_object_find( p_filter, VLC_OBJECT_INPUT, FIND_PARENT );
  601.     if( ! p_input )
  602.         return VLC_EGENERIC;
  604.     if( VLC_SUCCESS != input_Control( p_input, INPUT_GET_ATTACHMENTS, &pp_attachments, &i_attachments_cnt ))
  605.     {
  606.         vlc_object_release(p_input);
  607.         return VLC_EGENERIC;
  608.     }
  610.     p_sys->i_font_attachments = 0;
  611.     p_sys->pp_font_attachments = malloc( i_attachments_cnt * sizeof( input_attachment_t * ));
  612.     if(! p_sys->pp_font_attachments )
  613.         rv = VLC_ENOMEM;
  615.     for( k = 0; k < i_attachments_cnt; k++ )
  616.     {
  617.         input_attachment_t *p_attach = pp_attachments[k];
  619.         if( p_sys->pp_font_attachments )
  620.         {
  621.             if(( !strcmp( p_attach->psz_mime, "application/x-truetype-font" ) || // TTF
  622.                  !strcmp( p_attach->psz_mime, "application/x-font-otf" ) ) &&    // OTF
  623.                ( p_attach->i_data > 0 ) &&
  624.                ( p_attach->p_data != NULL ) )
  625.             {
  626.                 p_sys->pp_font_attachments[ p_sys->i_font_attachments++ ] = p_attach;
  627.             }
  628.             else
  629.             {
  630.                 vlc_input_attachment_Delete( p_attach );
  631.             }
  632.         }
  633.         else
  634.         {
  635.             vlc_input_attachment_Delete( p_attach );
  636.         }
  637.     }
  638.     free( pp_attachments );
  640.     vlc_object_release(p_input);
  642.     return rv;
  643. }
  645. /*****************************************************************************
  646.  * Render: place string in picture
  647.  *****************************************************************************
  648.  * This function merges the previously rendered freetype glyphs into a picture
  649.  *****************************************************************************/
  650. static int Render( filter_t *p_filter, subpicture_region_t *p_region,
  651.                    line_desc_t *p_line, int i_width, int i_height )
  652. {
  653.     static const uint8_t pi_gamma[16] =
  654.         {0x00, 0x52, 0x84, 0x96, 0xb8, 0xca, 0xdc, 0xee, 0xff,
  655.           0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
  657.     uint8_t *p_dst;
  658.     video_format_t fmt;
  659.     int i, x, y, i_pitch;
  660.     uint8_t i_y; /* YUV values, derived from incoming RGB */
  661.     int8_t i_u, i_v;
  663.     /* Create a new subpicture region */
  664.     memset( &fmt, 0, sizeof(video_format_t) );
  665.     fmt.i_chroma = VLC_FOURCC('Y','U','V','P');
  666.     fmt.i_aspect = 0;
  667.     fmt.i_width = fmt.i_visible_width = i_width + 4;
  668.     fmt.i_height = fmt.i_visible_height = i_height + 4;
  669.     if( p_region->fmt.i_visible_width > 0 )
  670.         fmt.i_visible_width = p_region->fmt.i_visible_width;
  671.     if( p_region->fmt.i_visible_height > 0 )
  672.         fmt.i_visible_height = p_region->fmt.i_visible_height;
  673.     fmt.i_x_offset = fmt.i_y_offset = 0;
  675.     assert( !p_region->p_picture );
  676.     p_region->p_picture = picture_New( fmt.i_chroma, fmt.i_width, fmt.i_height, fmt.i_aspect );
  677.     if( !p_region->p_picture )
  678.         return VLC_EGENERIC;
  679.     fmt.p_palette = p_region->fmt.p_palette ? p_region->fmt.p_palette : malloc(sizeof(*fmt.p_palette));
  680.     p_region->fmt = fmt;
  682.     /* Calculate text color components */
  683.     i_y = (uint8_t)(( 66 * p_line->i_red  + 129 * p_line->i_green +
  684.                       25 * p_line->i_blue + 128) >> 8) +  16;
  685.     i_u = (int8_t)(( -38 * p_line->i_red  -  74 * p_line->i_green +
  686.                      112 * p_line->i_blue + 128) >> 8) + 128;
  687.     i_v = (int8_t)(( 112 * p_line->i_red  -  94 * p_line->i_green -
  688.                       18 * p_line->i_blue + 128) >> 8) + 128;
  690.     /* Build palette */
  691.     fmt.p_palette->i_entries = 16;
  692.     for( i = 0; i < 8; i++ )
  693.     {
  694.         fmt.p_palette->palette[i][0] = 0;
  695.         fmt.p_palette->palette[i][1] = 0x80;
  696.         fmt.p_palette->palette[i][2] = 0x80;
  697.         fmt.p_palette->palette[i][3] = pi_gamma[i];
  698.         fmt.p_palette->palette[i][3] =
  699.             (int)fmt.p_palette->palette[i][3] * (255 - p_line->i_alpha) / 255;
  700.     }
  701.     for( i = 8; i < fmt.p_palette->i_entries; i++ )
  702.     {
  703.         fmt.p_palette->palette[i][0] = i * 16 * i_y / 256;
  704.         fmt.p_palette->palette[i][1] = i_u;
  705.         fmt.p_palette->palette[i][2] = i_v;
  706.         fmt.p_palette->palette[i][3] = pi_gamma[i];
  707.         fmt.p_palette->palette[i][3] =
  708.             (int)fmt.p_palette->palette[i][3] * (255 - p_line->i_alpha) / 255;
  709.     }
  711.     p_dst = p_region->p_picture->Y_PIXELS;
  712.     i_pitch = p_region->p_picture->Y_PITCH;
  714.     /* Initialize the region pixels */
  715.     memset( p_dst, 0, i_pitch * p_region->fmt.i_height );
  717.     for( ; p_line != NULL; p_line = p_line->p_next )
  718.     {
  719.         int i_glyph_tmax = 0;
  720.         int i_bitmap_offset, i_offset, i_align_offset = 0;
  721.         for( i = 0; p_line->pp_glyphs[i] != NULL; i++ )
  722.         {
  723.             FT_BitmapGlyph p_glyph = p_line->pp_glyphs[ i ];
  724.             i_glyph_tmax = __MAX( i_glyph_tmax, p_glyph->top );
  725.         }
  727.         if( p_line->i_width < i_width )
  728.         {
  729.             if( (p_region->i_align & 0x3) == SUBPICTURE_ALIGN_RIGHT )
  730.             {
  731.                 i_align_offset = i_width - p_line->i_width;
  732.             }
  733.             else if( (p_region->i_align & 0x3) != SUBPICTURE_ALIGN_LEFT )
  734.             {
  735.                 i_align_offset = ( i_width - p_line->i_width ) / 2;
  736.             }
  737.         }
  739.         for( i = 0; p_line->pp_glyphs[i] != NULL; i++ )
  740.         {
  741.             FT_BitmapGlyph p_glyph = p_line->pp_glyphs[ i ];
  743.             i_offset = ( p_line->p_glyph_pos[ i ].y +
  744.                 i_glyph_tmax - p_glyph->top + 2 ) *
  745.                 i_pitch + p_line->p_glyph_pos[ i ].x + p_glyph->left + 2 +
  746.                 i_align_offset;
  748.             for( y = 0, i_bitmap_offset = 0; y < p_glyph->bitmap.rows; y++ )
  749.             {
  750.                 for( x = 0; x < p_glyph->bitmap.width; x++, i_bitmap_offset++ )
  751.                 {
  752.                     if( p_glyph->bitmap.buffer[i_bitmap_offset] )
  753.                         p_dst[i_offset+x] =
  754.                          ((int)p_glyph->bitmap.buffer[i_bitmap_offset] + 8)/16;
  755.                 }
  756.                 i_offset += i_pitch;
  757.             }
  758.         }
  759.     }
  761.     /* Outlining (find something better than nearest neighbour filtering ?) */
  762.     if( 1 )
  763.     {
  764.         uint8_t *p_dst = p_region->p_picture->Y_PIXELS;
  765.         uint8_t *p_top = p_dst; /* Use 1st line as a cache */
  766.         uint8_t left, current;
  768.         for( y = 1; y < (int)fmt.i_height - 1; y++ )
  769.         {
  770.             if( y > 1 ) memcpy( p_top, p_dst, fmt.i_width );
  771.             p_dst += p_region->p_picture->Y_PITCH;
  772.             left = 0;
  774.             for( x = 1; x < (int)fmt.i_width - 1; x++ )
  775.             {
  776.                 current = p_dst[x];
  777.                 p_dst[x] = ( 8 * (int)p_dst[x] + left + p_dst[x+1] + p_top[x -1]+ p_top[x] + p_top[x+1] +
  778.                              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;
  779.                 left = current;
  780.             }
  781.         }
  782.         memset( p_top, 0, fmt.i_width );
  783.     }
  785.     return VLC_SUCCESS;
  786. }
  788. static void UnderlineGlyphYUVA( int i_line_thickness, int i_line_offset, bool b_ul_next_char,
  789.                                 FT_BitmapGlyph  p_this_glyph, FT_Vector *p_this_glyph_pos,
  790.                                 FT_BitmapGlyph  p_next_glyph, FT_Vector *p_next_glyph_pos,
  791.                                 int i_glyph_tmax, int i_align_offset,
  792.                                 uint8_t i_y, uint8_t i_u, uint8_t i_v,
  793.                                 subpicture_region_t *p_region)
  794. {
  795.     int y, x, z;
  796.     int i_pitch;
  797.     uint8_t *p_dst_y,*p_dst_u,*p_dst_v,*p_dst_a;
  799.     p_dst_y = p_region->p_picture->Y_PIXELS;
  800.     p_dst_u = p_region->p_picture->U_PIXELS;
  801.     p_dst_v = p_region->p_picture->V_PIXELS;
  802.     p_dst_a = p_region->p_picture->A_PIXELS;
  803.     i_pitch = p_region->p_picture->A_PITCH;
  805.     int i_offset = ( p_this_glyph_pos->y + i_glyph_tmax + i_line_offset + 3 ) * i_pitch +
  806.                      p_this_glyph_pos->x + p_this_glyph->left + 3 + i_align_offset;
  808.     for( y = 0; y < i_line_thickness; y++ )
  809.     {
  810.         int i_extra = p_this_glyph->bitmap.width;
  812.         if( b_ul_next_char )
  813.         {
  814.             i_extra = (p_next_glyph_pos->x + p_next_glyph->left) -
  815.                       (p_this_glyph_pos->x + p_this_glyph->left);
  816.         }
  817.         for( x = 0; x < i_extra; x++ )
  818.         {
  819.             bool b_ok = true;
  821.             /* break the underline around the tails of any glyphs which cross it */
  822.             for( z = x - i_line_thickness;
  823.                  z < x + i_line_thickness && b_ok;
  824.                  z++ )
  825.             {
  826.                 if( p_next_glyph && ( z >= i_extra ) )
  827.                 {
  828.                     int i_row = i_line_offset + p_next_glyph->top + y;
  830.                     if( ( p_next_glyph->bitmap.rows > i_row ) &&
  831.                         p_next_glyph->bitmap.buffer[p_next_glyph->bitmap.width * i_row + z-i_extra] )
  832.                     {
  833.                         b_ok = false;
  834.                     }
  835.                 }
  836.                 else if ((z > 0 ) && (z < p_this_glyph->bitmap.width))
  837.                 {
  838.                     int i_row = i_line_offset + p_this_glyph->top + y;
  840.                     if( ( p_this_glyph->bitmap.rows > i_row ) &&
  841.                         p_this_glyph->bitmap.buffer[p_this_glyph->bitmap.width * i_row + z] )
  842.                     {
  843.                         b_ok = false;
  844.                     }
  845.                 }
  846.             }
  848.             if( b_ok )
  849.             {
  850.                 p_dst_y[i_offset+x] = (i_y * 255) >> 8;
  851.                 p_dst_u[i_offset+x] = i_u;
  852.                 p_dst_v[i_offset+x] = i_v;
  853.                 p_dst_a[i_offset+x] = 255;
  854.             }
  855.         }
  856.         i_offset += i_pitch;
  857.     }
  858. }
  860. static void DrawBlack( line_desc_t *p_line, int i_width, subpicture_region_t *p_region, int xoffset, int yoffset )
  861. {
  862.     uint8_t *p_dst = p_region->p_picture->A_PIXELS;
  863.     int i_pitch = p_region->p_picture->A_PITCH;
  864.     int x,y;
  866.     for( ; p_line != NULL; p_line = p_line->p_next )
  867.     {
  868.         int i_glyph_tmax=0, i = 0;
  869.         int i_bitmap_offset, i_offset, i_align_offset = 0;
  870.         for( i = 0; p_line->pp_glyphs[i] != NULL; i++ )
  871.         {
  872.             FT_BitmapGlyph p_glyph = p_line->pp_glyphs[ i ];
  873.             i_glyph_tmax = __MAX( i_glyph_tmax, p_glyph->top );
  874.         }
  876.         if( p_line->i_width < i_width )
  877.         {
  878.             if( (p_region->i_align & 0x3) == SUBPICTURE_ALIGN_RIGHT )
  879.             {
  880.                 i_align_offset = i_width - p_line->i_width;
  881.             }
  882.             else if( (p_region->i_align & 0x3) != SUBPICTURE_ALIGN_LEFT )
  883.             {
  884.                 i_align_offset = ( i_width - p_line->i_width ) / 2;
  885.             }
  886.         }
  888.         for( i = 0; p_line->pp_glyphs[i] != NULL; i++ )
  889.         {
  890.             FT_BitmapGlyph p_glyph = p_line->pp_glyphs[ i ];
  892.             i_offset = ( p_line->p_glyph_pos[ i ].y +
  893.                 i_glyph_tmax - p_glyph->top + 3 + yoffset ) *
  894.                 i_pitch + p_line->p_glyph_pos[ i ].x + p_glyph->left + 3 +
  895.                 i_align_offset +xoffset;
  897.             for( y = 0, i_bitmap_offset = 0; y < p_glyph->bitmap.rows; y++ )
  898.             {
  899.                 for( x = 0; x < p_glyph->bitmap.width; x++, i_bitmap_offset++ )
  900.                 {
  901.                     if( p_glyph->bitmap.buffer[i_bitmap_offset] )
  902.                         if( p_dst[i_offset+x] <
  903.                             ((int)p_glyph->bitmap.buffer[i_bitmap_offset]) )
  904.                             p_dst[i_offset+x] =
  905.                                 ((int)p_glyph->bitmap.buffer[i_bitmap_offset]);
  906.                 }
  907.                 i_offset += i_pitch;
  908.             }
  909.         }
  910.     }
  912. }
  914. /*****************************************************************************
  915.  * Render: place string in picture
  916.  *****************************************************************************
  917.  * This function merges the previously rendered freetype glyphs into a picture
  918.  *****************************************************************************/
  919. static int RenderYUVA( filter_t *p_filter, subpicture_region_t *p_region,
  920.                    line_desc_t *p_line, int i_width, int i_height )
  921. {
  922.     uint8_t *p_dst_y,*p_dst_u,*p_dst_v,*p_dst_a;
  923.     video_format_t fmt;
  924.     int i, x, y, i_pitch, i_alpha;
  925.     uint8_t i_y, i_u, i_v; /* YUV values, derived from incoming RGB */
  927.     if( i_width == 0 || i_height == 0 )
  928.         return VLC_SUCCESS;
  930.     /* Create a new subpicture region */
  931.     memset( &fmt, 0, sizeof(video_format_t) );
  932.     fmt.i_chroma = VLC_FOURCC('Y','U','V','A');
  933.     fmt.i_aspect = 0;
  934.     fmt.i_width = fmt.i_visible_width = i_width + 6;
  935.     fmt.i_height = fmt.i_visible_height = i_height + 6;
  936.     if( p_region->fmt.i_visible_width > 0 )
  937.         fmt.i_visible_width = p_region->fmt.i_visible_width;
  938.     if( p_region->fmt.i_visible_height > 0 )
  939.         fmt.i_visible_height = p_region->fmt.i_visible_height;
  940.     fmt.i_x_offset = fmt.i_y_offset = 0;
  942.     p_region->p_picture = picture_New( fmt.i_chroma, fmt.i_width, fmt.i_height, fmt.i_aspect );
  943.     if( !p_region->p_picture )
  944.         return VLC_EGENERIC;
  945.     p_region->fmt = fmt;
  947.     /* Calculate text color components */
  948.     YUVFromRGB( (p_line->i_red   << 16) |
  949.                 (p_line->i_green <<  8) |
  950.                 (p_line->i_blue       ),
  951.                 &i_y, &i_u, &i_v);
  952.     i_alpha = p_line->i_alpha;
  954.     p_dst_y = p_region->p_picture->Y_PIXELS;
  955.     p_dst_u = p_region->p_picture->U_PIXELS;
  956.     p_dst_v = p_region->p_picture->V_PIXELS;
  957.     p_dst_a = p_region->p_picture->A_PIXELS;
  958.     i_pitch = p_region->p_picture->A_PITCH;
  960.     /* Initialize the region pixels */
  961.     if( p_filter->p_sys->i_effect != EFFECT_BACKGROUND )
  962.     {
  963.         memset( p_dst_y, 0x00, i_pitch * p_region->fmt.i_height );
  964.         memset( p_dst_u, 0x80, i_pitch * p_region->fmt.i_height );
  965.         memset( p_dst_v, 0x80, i_pitch * p_region->fmt.i_height );
  966.         memset( p_dst_a, 0, i_pitch * p_region->fmt.i_height );
  967.     }
  968.     else
  969.     {
  970.         memset( p_dst_y, 0x0, i_pitch * p_region->fmt.i_height );
  971.         memset( p_dst_u, 0x80, i_pitch * p_region->fmt.i_height );
  972.         memset( p_dst_v, 0x80, i_pitch * p_region->fmt.i_height );
  973.         memset( p_dst_a, 0x80, i_pitch * p_region->fmt.i_height );
  974.     }
  975.     if( p_filter->p_sys->i_effect == EFFECT_OUTLINE ||
  976.         p_filter->p_sys->i_effect == EFFECT_OUTLINE_FAT )
  977.     {
  978.         DrawBlack( p_line, i_width, p_region,  0,  0);
  979.         DrawBlack( p_line, i_width, p_region, -1,  0);
  980.         DrawBlack( p_line, i_width, p_region,  0, -1);
  981.         DrawBlack( p_line, i_width, p_region,  1,  0);
  982.         DrawBlack( p_line, i_width, p_region,  0,  1);
  983.     }
  985.     if( p_filter->p_sys->i_effect == EFFECT_OUTLINE_FAT )
  986.     {
  987.         DrawBlack( p_line, i_width, p_region, -1, -1);
  988.         DrawBlack( p_line, i_width, p_region, -1,  1);
  989.         DrawBlack( p_line, i_width, p_region,  1, -1);
  990.         DrawBlack( p_line, i_width, p_region,  1,  1);
  992.         DrawBlack( p_line, i_width, p_region, -2,  0);
  993.         DrawBlack( p_line, i_width, p_region,  0, -2);
  994.         DrawBlack( p_line, i_width, p_region,  2,  0);
  995.         DrawBlack( p_line, i_width, p_region,  0,  2);
  997.         DrawBlack( p_line, i_width, p_region, -2, -2);
  998.         DrawBlack( p_line, i_width, p_region, -2,  2);
  999.         DrawBlack( p_line, i_width, p_region,  2, -2);
  1000.         DrawBlack( p_line, i_width, p_region,  2,  2);
  1002.         DrawBlack( p_line, i_width, p_region, -3,  0);
  1003.         DrawBlack( p_line, i_width, p_region,  0, -3);
  1004.         DrawBlack( p_line, i_width, p_region,  3,  0);
  1005.         DrawBlack( p_line, i_width, p_region,  0,  3);
  1006.     }
  1008.     for( ; p_line != NULL; p_line = p_line->p_next )
  1009.     {
  1010.         int i_glyph_tmax = 0;
  1011.         int i_bitmap_offset, i_offset, i_align_offset = 0;
  1012.         for( i = 0; p_line->pp_glyphs[i] != NULL; i++ )
  1013.         {
  1014.             FT_BitmapGlyph p_glyph = p_line->pp_glyphs[ i ];
  1015.             i_glyph_tmax = __MAX( i_glyph_tmax, p_glyph->top );
  1016.         }
  1018.         if( p_line->i_width < i_width )
  1019.         {
  1020.             if( (p_region->i_align & 0x3) == SUBPICTURE_ALIGN_RIGHT )
  1021.             {
  1022.                 i_align_offset = i_width - p_line->i_width;
  1023.             }
  1024.             else if( (p_region->i_align & 0x3) != SUBPICTURE_ALIGN_LEFT )
  1025.             {
  1026.                 i_align_offset = ( i_width - p_line->i_width ) / 2;
  1027.             }
  1028.         }
  1030.         for( i = 0; p_line->pp_glyphs[i] != NULL; i++ )
  1031.         {
  1032.             FT_BitmapGlyph p_glyph = p_line->pp_glyphs[ i ];
  1034.             i_offset = ( p_line->p_glyph_pos[ i ].y +
  1035.                 i_glyph_tmax - p_glyph->top + 3 ) *
  1036.                 i_pitch + p_line->p_glyph_pos[ i ].x + p_glyph->left + 3 +
  1037.                 i_align_offset;
  1039.             if( p_line->b_new_color_mode )
  1040.             {
  1041.                 /* Every glyph can (and in fact must) have its own color */
  1042.                 YUVFromRGB( p_line->p_fg_rgb[ i ], &i_y, &i_u, &i_v );
  1043.             }
  1045.             for( y = 0, i_bitmap_offset = 0; y < p_glyph->bitmap.rows; y++ )
  1046.             {
  1047.                 for( x = 0; x < p_glyph->bitmap.width; x++, i_bitmap_offset++ )
  1048.                 {
  1049.                     uint8_t i_y_local = i_y;
  1050.                     uint8_t i_u_local = i_u;
  1051.                     uint8_t i_v_local = i_v;
  1053.                     if( p_line->p_fg_bg_ratio != 0x00 )
  1054.                     {
  1055.                         int i_split = p_glyph->bitmap.width *
  1056.                                       p_line->p_fg_bg_ratio[ i ] / 0x7f;
  1058.                         if( x > i_split )
  1059.                         {
  1060.                             YUVFromRGB( p_line->p_bg_rgb[ i ],
  1061.                                         &i_y_local, &i_u_local, &i_v_local );
  1062.                         }
  1063.                     }
  1065.                     if( p_glyph->bitmap.buffer[i_bitmap_offset] )
  1066.                     {
  1067.                         p_dst_y[i_offset+x] = ((p_dst_y[i_offset+x] *(255-(int)p_glyph->bitmap.buffer[i_bitmap_offset])) +
  1068.                                               i_y * ((int)p_glyph->bitmap.buffer[i_bitmap_offset])) >> 8;
  1070.                         p_dst_u[i_offset+x] = i_u;
  1071.                         p_dst_v[i_offset+x] = i_v;
  1073.                         if( p_filter->p_sys->i_effect == EFFECT_BACKGROUND )
  1074.                             p_dst_a[i_offset+x] = 0xff;
  1075.                     }
  1076.                 }
  1077.                 i_offset += i_pitch;
  1078.             }
  1080.             if( p_line->pi_underline_thickness[ i ] )
  1081.             {
  1082.                 UnderlineGlyphYUVA( p_line->pi_underline_thickness[ i ],
  1083.                                     p_line->pi_underline_offset[ i ],
  1084.                                    (p_line->pp_glyphs[i+1] && (p_line->pi_underline_thickness[ i + 1] > 0)),
  1085.                                     p_line->pp_glyphs[i], &(p_line->p_glyph_pos[i]),
  1086.                                     p_line->pp_glyphs[i+1], &(p_line->p_glyph_pos[i+1]),
  1087.                                     i_glyph_tmax, i_align_offset,
  1088.                                     i_y, i_u, i_v,
  1089.                                     p_region);
  1090.             }
  1091.         }
  1092.     }
  1094.     /* Apply the alpha setting */
  1095.     for( i = 0; i < (int)fmt.i_height * i_pitch; i++ )
  1096.         p_dst_a[i] = p_dst_a[i] * (255 - i_alpha) / 255;
  1098.     return VLC_SUCCESS;
  1099. }
  1101. /**
  1102.  * This function renders a text subpicture region into another one.
  1103.  * It also calculates the size needed for this string, and renders the
  1104.  * needed glyphs into memory. It is used as pf_add_string callback in
  1105.  * the vout method by this module
  1106.  */
  1107. static int RenderText( filter_t *p_filter, subpicture_region_t *p_region_out,
  1108.                        subpicture_region_t *p_region_in )
  1109. {
  1110.     filter_sys_t *p_sys = p_filter->p_sys;
  1111.     line_desc_t  *p_lines = NULL, *p_line = NULL, *p_next = NULL, *p_prev = NULL;
  1112.     int i, i_pen_y, i_pen_x, i_error, i_glyph_index, i_previous;
  1113.     uint32_t *psz_unicode, *psz_unicode_orig = NULL, i_char, *psz_line_start;
  1114.     int i_string_length;
  1115.     char *psz_string;
  1116.     vlc_iconv_t iconv_handle = (vlc_iconv_t)(-1);
  1117.     int i_font_color, i_font_alpha, i_font_size, i_red, i_green, i_blue;
  1118.     vlc_value_t val;
  1119.     int i_scale = 1000;
  1121.     FT_BBox line;
  1122.     FT_BBox glyph_size;
  1123.     FT_Vector result;
  1124.     FT_Glyph tmp_glyph;
  1126.     /* Sanity check */
  1127.     if( !p_region_in || !p_region_out ) return VLC_EGENERIC;
  1128.     psz_string = p_region_in->psz_text;
  1129.     if( !psz_string || !*psz_string ) return VLC_EGENERIC;
  1131.     if( VLC_SUCCESS == var_Get( p_filter, "scale", &val ))
  1132.         i_scale = val.i_int;
  1134.     if( p_region_in->p_style )
  1135.     {
  1136.         i_font_color = __MAX( __MIN( p_region_in->p_style->i_font_color, 0xFFFFFF ), 0 );
  1137.         i_font_alpha = __MAX( __MIN( p_region_in->p_style->i_font_alpha, 255 ), 0 );
  1138.         i_font_size  = __MAX( __MIN( p_region_in->p_style->i_font_size, 255 ), 0 ) * i_scale / 1000;
  1139.     }
  1140.     else
  1141.     {
  1142.         i_font_color = p_sys->i_font_color;
  1143.         i_font_alpha = 255 - p_sys->i_font_opacity;
  1144.         i_font_size  = p_sys->i_default_font_size * i_scale / 1000;
  1145.     }
  1147.     if( i_font_color == 0xFFFFFF ) i_font_color = p_sys->i_font_color;
  1148.     if( !i_font_alpha ) i_font_alpha = 255 - p_sys->i_font_opacity;
  1149.     SetFontSize( p_filter, i_font_size );
  1151.     i_red   = ( i_font_color & 0x00FF0000 ) >> 16;
  1152.     i_green = ( i_font_color & 0x0000FF00 ) >>  8;
  1153.     i_blue  =   i_font_color & 0x000000FF;
  1155.     result.x =  result.y = 0;
  1156.     line.xMin = line.xMax = line.yMin = line.yMax = 0;
  1158.     psz_unicode = psz_unicode_orig =
  1159.         malloc( ( strlen(psz_string) + 1 ) * sizeof(uint32_t) );
  1160.     if( psz_unicode == NULL )
  1161.         goto error;
  1162. #if defined(WORDS_BIGENDIAN)
  1163.     iconv_handle = vlc_iconv_open( "UCS-4BE", "UTF-8" );
  1164. #else
  1165.     iconv_handle = vlc_iconv_open( "UCS-4LE", "UTF-8" );
  1166. #endif
  1167.     if( iconv_handle == (vlc_iconv_t)-1 )
  1168.     {
  1169.         msg_Warn( p_filter, "unable to do conversion" );
  1170.         goto error;
  1171.     }
  1173.     {
  1174.         char *p_out_buffer;
  1175.         const char *p_in_buffer = psz_string;
  1176.         size_t i_in_bytes, i_out_bytes, i_out_bytes_left, i_ret;
  1177.         i_in_bytes = strlen( psz_string );
  1178.         i_out_bytes = i_in_bytes * sizeof( uint32_t );
  1179.         i_out_bytes_left = i_out_bytes;
  1180.         p_out_buffer = (char *)psz_unicode;
  1181.         i_ret = vlc_iconv( iconv_handle, (const char**)&p_in_buffer,
  1182.                            &i_in_bytes,
  1183.                            &p_out_buffer, &i_out_bytes_left );
  1185.         vlc_iconv_close( iconv_handle );
  1187.         if( i_in_bytes )
  1188.         {
  1189.             msg_Warn( p_filter, "failed to convert string to unicode (%m), "
  1190.                       "bytes left %u", (unsigned)i_in_bytes );
  1191.             goto error;
  1192.         }
  1193.         *(uint32_t*)p_out_buffer = 0;
  1194.         i_string_length = (i_out_bytes - i_out_bytes_left) / sizeof(uint32_t);
  1195.     }
  1197. #if defined(HAVE_FRIBIDI)
  1198.     {
  1199.         uint32_t *p_fribidi_string;
  1200.         int32_t start_pos, pos = 0;
  1202.         p_fribidi_string = malloc( (i_string_length + 1) * sizeof(uint32_t) );
  1203.         if( !p_fribidi_string )
  1204.             goto error;
  1206.         /* Do bidi conversion line-by-line */
  1207.         while( pos < i_string_length )
  1208.         {
  1209.             while( pos < i_string_length ) 
  1210.             {
  1211.                 i_char = psz_unicode[pos];
  1212.                 if (i_char != 'r' && i_char != 'n')
  1213.                     break;
  1214.                 p_fribidi_string[pos] = i_char;
  1215.                 ++pos;
  1216.             }
  1217.             start_pos = pos;
  1218.             while( pos < i_string_length )
  1219.             {
  1220.                 i_char = psz_unicode[pos];
  1221.                 if (i_char == 'r' || i_char == 'n')
  1222.                     break;
  1223.                 ++pos;
  1224.             }
  1225.             if (pos > start_pos)
  1226.             {
  1227.                 FriBidiCharType base_dir = FRIBIDI_TYPE_LTR;
  1228.                 fribidi_log2vis((FriBidiChar*)psz_unicode + start_pos,
  1229.                                 pos - start_pos,
  1230.                                 &base_dir,
  1231.                                 (FriBidiChar*)p_fribidi_string + start_pos,
  1232.                                 0, 0, 0);
  1233.             }
  1234.         }
  1236.         free( psz_unicode_orig );
  1237.         psz_unicode = psz_unicode_orig = p_fribidi_string;
  1238.         p_fribidi_string[ i_string_length ] = 0;
  1239.     }
  1240. #endif
  1242.     /* Calculate relative glyph positions and a bounding box for the
  1243.      * entire string */
  1244.     if( !(p_line = NewLine( strlen( psz_string ))) )
  1245.         goto error;
  1246.     p_lines = p_line;
  1247.     i_pen_x = i_pen_y = 0;
  1248.     i_previous = i = 0;
  1249.     psz_line_start = psz_unicode;
  1251. #define face p_sys->p_face
  1252. #define glyph face->glyph
  1254.     while( *psz_unicode )
  1255.     {
  1256.         i_char = *psz_unicode++;
  1257.         if( i_char == 'r' ) /* ignore CR chars wherever they may be */
  1258.         {
  1259.             continue;
  1260.         }
  1262.         if( i_char == 'n' )
  1263.         {
  1264.             psz_line_start = psz_unicode;
  1265.             if( !(p_next = NewLine( strlen( psz_string ))) )
  1266.                 goto error;
  1267.             p_line->p_next = p_next;
  1268.             p_line->i_width = line.xMax;
  1269.             p_line->i_height = face->size->metrics.height >> 6;
  1270.             p_line->pp_glyphs[ i ] = NULL;
  1271.             p_line->i_alpha = i_font_alpha;
  1272.             p_line->i_red = i_red;
  1273.             p_line->i_green = i_green;
  1274.             p_line->i_blue = i_blue;
  1275.             p_prev = p_line;
  1276.             p_line = p_next;
  1277.             result.x = __MAX( result.x, line.xMax );
  1278.             result.y += face->size->metrics.height >> 6;
  1279.             i_pen_x = 0;
  1280.             i_previous = i = 0;
  1281.             line.xMin = line.xMax = line.yMin = line.yMax = 0;
  1282.             i_pen_y += face->size->metrics.height >> 6;
  1283. #if 0
  1284.             msg_Dbg( p_filter, "Creating new line, i is %d", i );
  1285. #endif
  1286.             continue;
  1287.         }
  1289.         i_glyph_index = FT_Get_Char_Index( face, i_char );
  1290.         if( p_sys->i_use_kerning && i_glyph_index
  1291.             && i_previous )
  1292.         {
  1293.             FT_Vector delta;
  1294.             FT_Get_Kerning( face, i_previous, i_glyph_index,
  1295.                             ft_kerning_default, &delta );
  1296.             i_pen_x += delta.x >> 6;
  1298.         }
  1299.         p_line->p_glyph_pos[ i ].x = i_pen_x;
  1300.         p_line->p_glyph_pos[ i ].y = i_pen_y;
  1301.         i_error = FT_Load_Glyph( face, i_glyph_index, FT_LOAD_DEFAULT );
  1302.         if( i_error )
  1303.         {
  1304.             msg_Err( p_filter, "unable to render text FT_Load_Glyph returned"
  1305.                                " %d", i_error );
  1306.             goto error;
  1307.         }
  1308.         i_error = FT_Get_Glyph( glyph, &tmp_glyph );
  1309.         if( i_error )
  1310.         {
  1311.             msg_Err( p_filter, "unable to render text FT_Get_Glyph returned "
  1312.                                "%d", i_error );
  1313.             goto error;
  1314.         }
  1315.         FT_Glyph_Get_CBox( tmp_glyph, ft_glyph_bbox_pixels, &glyph_size );
  1316.         i_error = FT_Glyph_To_Bitmap( &tmp_glyph, ft_render_mode_normal, 0, 1);
  1317.         if( i_error )
  1318.         {
  1319.             FT_Done_Glyph( tmp_glyph );
  1320.             continue;
  1321.         }
  1322.         p_line->pp_glyphs[ i ] = (FT_BitmapGlyph)tmp_glyph;
  1324.         /* Do rest */
  1325.         line.xMax = p_line->p_glyph_pos[i].x + glyph_size.xMax -
  1326.             glyph_size.xMin + ((FT_BitmapGlyph)tmp_glyph)->left;
  1327.         if( line.xMax > (int)p_filter->fmt_out.video.i_visible_width - 20 )
  1328.         {
  1329.             FT_Done_Glyph( (FT_Glyph)p_line->pp_glyphs[ i ] );
  1330.             p_line->pp_glyphs[ i ] = NULL;
  1331.             FreeLine( p_line );
  1332.             p_line = NewLine( strlen( psz_string ));
  1333.             if( p_prev ) p_prev->p_next = p_line;
  1334.             else p_lines = p_line;
  1336.             uint32_t *psz_unicode_saved = psz_unicode;
  1337.             while( psz_unicode > psz_line_start && *psz_unicode != ' ' )
  1338.             {
  1339.                 psz_unicode--;
  1340.             }
  1341.             if( psz_unicode == psz_line_start )
  1342.             {   /* try harder to break that line */
  1343.                 psz_unicode = psz_unicode_saved;
  1344.                 while( psz_unicode > psz_line_start &&
  1345.                     *psz_unicode != '_'  && *psz_unicode != '/' &&
  1346.                     *psz_unicode != '\' && *psz_unicode != '.' )
  1347.                 {
  1348.                     psz_unicode--;
  1349.                 }
  1350.             }
  1351.             if( psz_unicode == psz_line_start )
  1352.             {
  1353.                 msg_Warn( p_filter, "unbreakable string" );
  1354.                 goto error;
  1355.             }
  1356.             else
  1357.             {
  1358.                 *psz_unicode = 'n';
  1359.             }
  1360.             psz_unicode = psz_line_start;
  1361.             i_pen_x = 0;
  1362.             i_previous = i = 0;
  1363.             line.xMin = line.xMax = line.yMin = line.yMax = 0;
  1364.             continue;
  1365.         }
  1366.         line.yMax = __MAX( line.yMax, glyph_size.yMax );
  1367.         line.yMin = __MIN( line.yMin, glyph_size.yMin );
  1369.         i_previous = i_glyph_index;
  1370.         i_pen_x += glyph->advance.x >> 6;
  1371.         i++;
  1372.     }
  1374.     p_line->i_width = line.xMax;
  1375.     p_line->i_height = face->size->metrics.height >> 6;
  1376.     p_line->pp_glyphs[ i ] = NULL;
  1377.     p_line->i_alpha = i_font_alpha;
  1378.     p_line->i_red = i_red;
  1379.     p_line->i_green = i_green;
  1380.     p_line->i_blue = i_blue;
  1381.     result.x = __MAX( result.x, line.xMax );
  1382.     result.y += line.yMax - line.yMin;
  1384. #undef face
  1385. #undef glyph
  1387.     p_region_out->i_x = p_region_in->i_x;
  1388.     p_region_out->i_y = p_region_in->i_y;
  1390.     if( config_GetInt( p_filter, "freetype-yuvp" ) )
  1391.         Render( p_filter, p_region_out, p_lines, result.x, result.y );
  1392.     else
  1393.         RenderYUVA( p_filter, p_region_out, p_lines, result.x, result.y );
  1395.     free( psz_unicode_orig );
  1396.     FreeLines( p_lines );
  1397.     return VLC_SUCCESS;
  1399.  error:
  1400.     free( psz_unicode_orig );
  1401.     FreeLines( p_lines );
  1402.     return VLC_EGENERIC;
  1403. }
  1405. #ifdef HAVE_FONTCONFIG
  1406. static ft_style_t *CreateStyle( char *psz_fontname, int i_font_size,
  1407.         uint32_t i_font_color, uint32_t i_karaoke_bg_color, bool b_bold,
  1408.         bool b_italic, bool b_uline )
  1409. {
  1410.     ft_style_t  *p_style = malloc( sizeof( ft_style_t ));
  1412.     if( p_style )
  1413.     {
  1414.         p_style->i_font_size        = i_font_size;
  1415.         p_style->i_font_color       = i_font_color;
  1416.         p_style->i_karaoke_bg_color = i_karaoke_bg_color;
  1417.         p_style->b_italic           = b_italic;
  1418.         p_style->b_bold             = b_bold;
  1419.         p_style->b_underline        = b_uline;
  1421.         p_style->psz_fontname = strdup( psz_fontname );
  1422.     }
  1423.     return p_style;
  1424. }
  1426. static void DeleteStyle( ft_style_t *p_style )
  1427. {
  1428.     if( p_style )
  1429.     {
  1430.         free( p_style->psz_fontname );
  1431.         free( p_style );
  1432.     }
  1433. }
  1435. static bool StyleEquals( ft_style_t *s1, ft_style_t *s2 )
  1436. {
  1437.     if( !s1 || !s2 )
  1438.         return false;
  1439.     if( s1 == s2 )
  1440.         return true;
  1442.     if(( s1->i_font_size  == s2->i_font_size ) &&
  1443.        ( s1->i_font_color == s2->i_font_color ) &&
  1444.        ( s1->b_italic     == s2->b_italic ) &&
  1445.        ( s1->b_bold       == s2->b_bold ) &&
  1446.        ( s1->b_underline  == s2->b_underline ) &&
  1447.        ( !strcmp( s1->psz_fontname, s2->psz_fontname )))
  1448.     {
  1449.         return true;
  1450.     }
  1451.     return false;
  1452. }
  1454. static void IconvText( filter_t *p_filter, const char *psz_string,
  1455.                        uint32_t *i_string_length, uint32_t **ppsz_unicode )
  1456. {
  1457.     vlc_iconv_t iconv_handle = (vlc_iconv_t)(-1);
  1459.     /* If memory hasn't been allocated for our output string, allocate it here
  1460.      * - the calling function must now be responsible for freeing it.
  1461.      */
  1462.     if( !*ppsz_unicode )
  1463.         *ppsz_unicode = (uint32_t *)
  1464.             malloc( (strlen( psz_string ) + 1) * sizeof( uint32_t ));
  1466.     /* We don't need to handle a NULL pointer in *ppsz_unicode
  1467.      * if we are instead testing for a non NULL value like we are here */
  1469.     if( *ppsz_unicode )
  1470.     {
  1471. #if defined(WORDS_BIGENDIAN)
  1472.         iconv_handle = vlc_iconv_open( "UCS-4BE", "UTF-8" );
  1473. #else
  1474.         iconv_handle = vlc_iconv_open( "UCS-4LE", "UTF-8" );
  1475. #endif
  1476.         if( iconv_handle != (vlc_iconv_t)-1 )
  1477.         {
  1478.             char *p_in_buffer, *p_out_buffer;
  1479.             size_t i_in_bytes, i_out_bytes, i_out_bytes_left, i_ret;
  1480.             i_in_bytes = strlen( psz_string );
  1481.             i_out_bytes = i_in_bytes * sizeof( uint32_t );
  1482.             i_out_bytes_left = i_out_bytes;
  1483.             p_in_buffer = (char *) psz_string;
  1484.             p_out_buffer = (char *) *ppsz_unicode;
  1485.             i_ret = vlc_iconv( iconv_handle, (const char**)&p_in_buffer,
  1486.                     &i_in_bytes, &p_out_buffer, &i_out_bytes_left );
  1488.             vlc_iconv_close( iconv_handle );
  1490.             if( i_in_bytes )
  1491.             {
  1492.                 msg_Warn( p_filter, "failed to convert string to unicode (%m), "
  1493.                           "bytes left %u", (unsigned)i_in_bytes );
  1494.             }
  1495.             else
  1496.             {
  1497.                 *(uint32_t*)p_out_buffer = 0;
  1498.                 *i_string_length =
  1499.                     (i_out_bytes - i_out_bytes_left) / sizeof(uint32_t);
  1500.             }
  1501.         }
  1502.         else
  1503.         {
  1504.             msg_Warn( p_filter, "unable to do conversion" );
  1505.         }
  1506.     }
  1507. }
  1509. static ft_style_t *GetStyleFromFontStack( filter_sys_t *p_sys,
  1510.         font_stack_t **p_fonts, bool b_bold, bool b_italic,
  1511.         bool b_uline )
  1512. {
  1513.     ft_style_t   *p_style = NULL;
  1515.     char       *psz_fontname = NULL;
  1516.     uint32_t    i_font_color = p_sys->i_font_color & 0x00ffffff;
  1517.     uint32_t    i_karaoke_bg_color = i_font_color;
  1518.     int         i_font_size  = p_sys->i_font_size;
  1520.     if( VLC_SUCCESS == PeekFont( p_fonts, &psz_fontname, &i_font_size,
  1521.                                  &i_font_color, &i_karaoke_bg_color ))
  1522.     {
  1523.         p_style = CreateStyle( psz_fontname, i_font_size, i_font_color,
  1524.                 i_karaoke_bg_color, b_bold, b_italic, b_uline );
  1525.     }
  1526.     return p_style;
  1527. }
  1529. static int RenderTag( filter_t *p_filter, FT_Face p_face, int i_font_color,
  1530.                       bool b_uline, int i_karaoke_bgcolor,
  1531.                       line_desc_t *p_line, uint32_t *psz_unicode,
  1532.                       int *pi_pen_x, int i_pen_y, int *pi_start,
  1533.                       FT_Vector *p_result )
  1534. {
  1535.     FT_BBox      line;
  1536.     int          i_yMin, i_yMax;
  1537.     int          i;
  1538.     bool   b_first_on_line = true;
  1540.     int          i_previous = 0;
  1541.     int          i_pen_x_start = *pi_pen_x;
  1543.     uint32_t *psz_unicode_start = psz_unicode;
  1545.     line.xMin = line.xMax = line.yMin = line.yMax = 0;
  1547.     /* Account for part of line already in position */
  1548.     for( i=0; i<*pi_start; i++ )
  1549.     {
  1550.         FT_BBox glyph_size;
  1552.         FT_Glyph_Get_CBox( (FT_Glyph) p_line->pp_glyphs[ i ],
  1553.                             ft_glyph_bbox_pixels, &glyph_size );
  1555.         line.xMax = p_line->p_glyph_pos[ i ].x + glyph_size.xMax -
  1556.             glyph_size.xMin + p_line->pp_glyphs[ i ]->left;
  1557.         line.yMax = __MAX( line.yMax, glyph_size.yMax );
  1558.         line.yMin = __MIN( line.yMin, glyph_size.yMin );
  1559.     }
  1560.     i_yMin = line.yMin;
  1561.     i_yMax = line.yMax;
  1563.     if( line.xMax > 0 )
  1564.         b_first_on_line = false;
  1566.     while( *psz_unicode && ( *psz_unicode != 'n' ) )
  1567.     {
  1568.         FT_BBox glyph_size;
  1569.         FT_Glyph tmp_glyph;
  1570.         int i_error;
  1572.         int i_glyph_index = FT_Get_Char_Index( p_face, *psz_unicode++ );
  1573.         if( FT_HAS_KERNING( p_face ) && i_glyph_index
  1574.             && i_previous )
  1575.         {
  1576.             FT_Vector delta;
  1577.             FT_Get_Kerning( p_face, i_previous, i_glyph_index,
  1578.                             ft_kerning_default, &delta );
  1579.             *pi_pen_x += delta.x >> 6;
  1580.         }
  1581.         p_line->p_glyph_pos[ i ].x = *pi_pen_x;
  1582.         p_line->p_glyph_pos[ i ].y = i_pen_y;
  1584.         i_error = FT_Load_Glyph( p_face, i_glyph_index, FT_LOAD_DEFAULT );
  1585.         if( i_error )
  1586.         {
  1587.             msg_Err( p_filter,
  1588.                    "unable to render text FT_Load_Glyph returned %d", i_error );
  1589.             p_line->pp_glyphs[ i ] = NULL;
  1590.             return VLC_EGENERIC;
  1591.         }
  1592.         i_error = FT_Get_Glyph( p_face->glyph, &tmp_glyph );
  1593.         if( i_error )
  1594.         {
  1595.             msg_Err( p_filter,
  1596.                     "unable to render text FT_Get_Glyph returned %d", i_error );
  1597.             p_line->pp_glyphs[ i ] = NULL;
  1598.             return VLC_EGENERIC;
  1599.         }
  1600.         FT_Glyph_Get_CBox( tmp_glyph, ft_glyph_bbox_pixels, &glyph_size );
  1601.         i_error = FT_Glyph_To_Bitmap( &tmp_glyph, FT_RENDER_MODE_NORMAL, 0, 1);
  1602.         if( i_error )
  1603.         {
  1604.             FT_Done_Glyph( tmp_glyph );
  1605.             continue;
  1606.         }
  1607.         if( b_uline )
  1608.         {
  1609.             float aOffset = FT_FLOOR(FT_MulFix(p_face->underline_position,
  1610.                                                p_face->size->metrics.y_scale));
  1611.             float aSize = FT_CEIL(FT_MulFix(p_face->underline_thickness,
  1612.                                             p_face->size->metrics.y_scale));
  1614.             p_line->pi_underline_offset[ i ]  =
  1615.                                        ( aOffset < 0 ) ? -aOffset : aOffset;
  1616.             p_line->pi_underline_thickness[ i ] =
  1617.                                        ( aSize < 0 ) ? -aSize   : aSize;
  1618.         }
  1619.         p_line->pp_glyphs[ i ] = (FT_BitmapGlyph)tmp_glyph;
  1620.         p_line->p_fg_rgb[ i ] = i_font_color & 0x00ffffff;
  1621.         p_line->p_bg_rgb[ i ] = i_karaoke_bgcolor & 0x00ffffff;
  1622.         p_line->p_fg_bg_ratio[ i ] = 0x00;
  1624.         line.xMax = p_line->p_glyph_pos[i].x + glyph_size.xMax -
  1625.                     glyph_size.xMin + ((FT_BitmapGlyph)tmp_glyph)->left;
  1626.         if( line.xMax > (int)p_filter->fmt_out.video.i_visible_width - 20 )
  1627.         {
  1628.             for( ; i >= *pi_start; i-- )
  1629.                 FT_Done_Glyph( (FT_Glyph)p_line->pp_glyphs[ i ] );
  1630.             i = *pi_start;
  1632.             while( psz_unicode > psz_unicode_start && *psz_unicode != ' ' )
  1633.             {
  1634.                 psz_unicode--;
  1635.             }
  1636.             if( psz_unicode == psz_unicode_start )
  1637.             {
  1638.                 if( b_first_on_line )
  1639.                 {
  1640.                     msg_Warn( p_filter, "unbreakable string" );
  1641.                     p_line->pp_glyphs[ i ] = NULL;
  1642.                     return VLC_EGENERIC;
  1643.                 }
  1644.                 *pi_pen_x = i_pen_x_start;
  1646.                 p_line->i_width = line.xMax;
  1647.                 p_line->i_height = __MAX( p_line->i_height,
  1648.                                           p_face->size->metrics.height >> 6 );
  1649.                 p_line->pp_glyphs[ i ] = NULL;
  1651.                 p_result->x = __MAX( p_result->x, line.xMax );
  1652.                 p_result->y = __MAX( p_result->y, __MAX( p_line->i_height,
  1653.                                                          i_yMax - i_yMin ) );
  1654.                 return VLC_SUCCESS;
  1655.             }
  1656.             else
  1657.             {
  1658.                 *psz_unicode = 'n';
  1659.             }
  1660.             psz_unicode = psz_unicode_start;
  1661.             *pi_pen_x = i_pen_x_start;
  1662.             i_previous = 0;
  1664.             line.yMax = i_yMax;
  1665.             line.yMin = i_yMin;
  1667.             continue;
  1668.         }
  1669.         line.yMax = __MAX( line.yMax, glyph_size.yMax );
  1670.         line.yMin = __MIN( line.yMin, glyph_size.yMin );
  1672.         i_previous = i_glyph_index;
  1673.         *pi_pen_x += p_face->glyph->advance.x >> 6;
  1674.         i++;
  1675.     }
  1676.     p_line->i_width = line.xMax;
  1677.     p_line->i_height = __MAX( p_line->i_height,
  1678.                               p_face->size->metrics.height >> 6 );
  1679.     p_line->pp_glyphs[ i ] = NULL;
  1681.     p_result->x = __MAX( p_result->x, line.xMax );
  1682.     p_result->y = __MAX( p_result->y, __MAX( p_line->i_height,
  1683.                          line.yMax - line.yMin ) );
  1685.     *pi_start = i;
  1687.     /* Get rid of any text processed - if necessary repositioning
  1688.      * at the start of a new line of text
  1689.      */
  1690.     if( !*psz_unicode )
  1691.     {
  1692.         *psz_unicode_start = '';
  1693.     }
  1694.     else if( psz_unicode > psz_unicode_start )
  1695.     {
  1696.         for( i=0; psz_unicode[ i ]; i++ )
  1697.             psz_unicode_start[ i ] = psz_unicode[ i ];
  1698.         psz_unicode_start[ i ] = '';
  1699.     }
  1701.     return VLC_SUCCESS;
  1702. }
  1704. static void SetupLine( filter_t *p_filter, const char *psz_text_in,
  1705.                        uint32_t **psz_text_out, uint32_t *pi_runs,
  1706.                        uint32_t **ppi_run_lengths, ft_style_t ***ppp_styles,
  1707.                        ft_style_t *p_style )
  1708. {
  1709.     uint32_t      i_string_length = 0;
  1711.     IconvText( p_filter, psz_text_in, &i_string_length, psz_text_out );
  1712.     *psz_text_out += i_string_length;
  1714.     if( ppp_styles && ppi_run_lengths )
  1715.     {
  1716.         (*pi_runs)++;
  1718.         if( *ppp_styles )
  1719.         {
  1720.             *ppp_styles = (ft_style_t **)
  1721.                 realloc( *ppp_styles, *pi_runs * sizeof( ft_style_t * ) );
  1722.         }
  1723.         else if( *pi_runs == 1 )
  1724.         {
  1725.             *ppp_styles = (ft_style_t **)
  1726.                 malloc( *pi_runs * sizeof( ft_style_t * ) );
  1727.         }
  1729.         /* We have just malloc'ed this memory successfully -
  1730.          * *pi_runs HAS to be within the memory area of *ppp_styles */
  1731.         if( *ppp_styles )
  1732.         {
  1733.             (*ppp_styles)[ *pi_runs - 1 ] = p_style;
  1734.             p_style = NULL;
  1735.         }
  1737.         if( *ppi_run_lengths )
  1738.         {
  1739.             *ppi_run_lengths = (uint32_t *)
  1740.                 realloc( *ppi_run_lengths, *pi_runs * sizeof( uint32_t ) );
  1741.         }
  1742.         else if( *pi_runs == 1 )
  1743.         {
  1744.             *ppi_run_lengths = (uint32_t *)
  1745.                 malloc( *pi_runs * sizeof( uint32_t ) );
  1746.         }
  1748.         /* same remarks here */
  1749.         if( *ppi_run_lengths )
  1750.         {
  1751.             (*ppi_run_lengths)[ *pi_runs - 1 ] = i_string_length;
  1752.         }
  1753.     }
  1754.     /* If we couldn't use the p_style argument due to memory allocation
  1755.      * problems above, release it here.
  1756.      */
  1757.     if( p_style ) DeleteStyle( p_style );
  1758. }
  1760. static int CheckForEmbeddedFont( filter_sys_t *p_sys, FT_Face *pp_face, ft_style_t *p_style )
  1761. {
  1762.     int k;
  1764.     for( k=0; k < p_sys->i_font_attachments; k++ )
  1765.     {
  1766.         input_attachment_t *p_attach   = p_sys->pp_font_attachments[k];
  1767.         int                 i_font_idx = 0;
  1768.         FT_Face             p_face = NULL;
  1770.         while( 0 == FT_New_Memory_Face( p_sys->p_library,
  1771.                                         p_attach->p_data,
  1772.                                         p_attach->i_data,
  1773.                                         i_font_idx,
  1774.                                         &p_face ))
  1775.         {
  1776.             if( p_face )
  1777.             {
  1778.                 bool match = !strcasecmp( p_face->family_name,
  1779.                                                 p_style->psz_fontname );
  1781.                 if( p_face->style_flags & FT_STYLE_FLAG_BOLD )
  1782.                     match = match && p_style->b_bold;
  1783.                 else
  1784.                     match = match && !p_style->b_bold;
  1786.                 if( p_face->style_flags & FT_STYLE_FLAG_ITALIC )
  1787.                     match = match && p_style->b_italic;
  1788.                 else
  1789.                     match = match && !p_style->b_italic;
  1791.                 if(  match )
  1792.                 {
  1793.                     *pp_face = p_face;
  1794.                     return VLC_SUCCESS;
  1795.                 }
  1797.                 FT_Done_Face( p_face );
  1798.             }
  1799.             i_font_idx++;
  1800.         }
  1801.     }
  1802.     return VLC_EGENERIC;
  1803. }
  1805. static int ProcessLines( filter_t *p_filter,
  1806.                          uint32_t *psz_text,
  1807.                          int i_len,
  1809.                          uint32_t i_runs,
  1810.                          uint32_t *pi_run_lengths,
  1811.                          ft_style_t **pp_styles,
  1812.                          line_desc_t **pp_lines,
  1814.                          FT_Vector *p_result,
  1816.                          bool b_karaoke,
  1817.                          uint32_t i_k_runs,
  1818.                          uint32_t *pi_k_run_lengths,
  1819.                          uint32_t *pi_k_durations )
  1820. {
  1821.     filter_sys_t   *p_sys = p_filter->p_sys;
  1822.     ft_style_t    **pp_char_styles;
  1823.     int            *p_new_positions = NULL;
  1824.     int8_t         *p_levels = NULL;
  1825.     uint8_t        *pi_karaoke_bar = NULL;
  1826.     uint32_t        i, j, k;
  1827.     int             i_prev;
  1829.     /* Assign each character in the text string its style explicitly, so that
  1830.      * after the characters have been shuffled around by Fribidi, we can re-apply
  1831.      * the styles, and to simplify the calculation of runs within a line.
  1832.      */
  1833.     pp_char_styles = (ft_style_t **) malloc( i_len * sizeof( ft_style_t * ));
  1834.     if( !pp_char_styles )
  1835.         return VLC_ENOMEM;
  1837.     if( b_karaoke )
  1838.     {
  1839.         pi_karaoke_bar = (uint8_t *) malloc( i_len * sizeof( uint8_t ));
  1840.         /* If we can't allocate sufficient memory for karaoke, continue anyway -
  1841.          * we just won't be able to display the progress bar; at least we'll
  1842.          * get the text.
  1843.          */
  1844.     }
  1846.     i = 0;
  1847.     for( j = 0; j < i_runs; j++ )
  1848.         for( k = 0; k < pi_run_lengths[ j ]; k++ )
  1849.             pp_char_styles[ i++ ] = pp_styles[ j ];
  1851. #if defined(HAVE_FRIBIDI)
  1852.     {
  1853.         ft_style_t  **pp_char_styles_new;
  1854.         int         *p_old_positions;
  1855.         uint32_t    *p_fribidi_string;
  1856.         int start_pos, pos = 0;
  1858.         pp_char_styles_new  = (ft_style_t **)
  1859.             malloc( i_len * sizeof( ft_style_t * ));
  1861.         p_fribidi_string = (uint32_t *)
  1862.             malloc( (i_len + 1) * sizeof(uint32_t) );
  1863.         p_old_positions = (int *)
  1864.             malloc( (i_len + 1) * sizeof( int ) );
  1865.         p_new_positions = (int *)
  1866.             malloc( (i_len + 1) * sizeof( int ) );
  1867.         p_levels = (int8_t *)
  1868.             malloc( (i_len + 1) * sizeof( int8_t ) );
  1870.         if( ! pp_char_styles_new ||
  1871.             ! p_fribidi_string ||
  1872.             ! p_old_positions ||
  1873.             ! p_new_positions ||
  1874.             ! p_levels )
  1875.         {
  1876.             free( p_levels );
  1877.             free( p_old_positions );
  1878.             free( p_new_positions );
  1879.             free( p_fribidi_string );
  1880.             free( pp_char_styles_new );
  1881.             free( pi_karaoke_bar );
  1883.             free( pp_char_styles );
  1884.             return VLC_ENOMEM;
  1885.         }
  1887.         /* Do bidi conversion line-by-line */
  1888.         while(pos < i_len)
  1889.         {
  1890.             while(pos < i_len) {
  1891.                 if (psz_text[pos] != 'n')
  1892.                     break;
  1893.                 p_fribidi_string[pos] = psz_text[pos];
  1894.                 pp_char_styles_new[pos] = pp_char_styles[pos];
  1895.                 p_new_positions[pos] = pos;
  1896.                 p_levels[pos] = 0;
  1897.                 ++pos;
  1898.             }
  1899.             start_pos = pos;
  1900.             while(pos < i_len) {
  1901.                 if (psz_text[pos] == 'n')
  1902.                     break;
  1903.                 ++pos;
  1904.             }
  1905.             if (pos > start_pos)
  1906.             {
  1907.                 FriBidiCharType base_dir = FRIBIDI_TYPE_LTR;
  1908.                 fribidi_log2vis((FriBidiChar*)psz_text + start_pos,
  1909.                         pos - start_pos, &base_dir,
  1910.                         (FriBidiChar*)p_fribidi_string + start_pos,
  1911.                         p_new_positions + start_pos,
  1912.                         p_old_positions,
  1913.                         p_levels + start_pos );
  1914.                 for( j = (uint32_t) start_pos; j < (uint32_t) pos; j++ )
  1915.                 {
  1916.                     pp_char_styles_new[ j ] = pp_char_styles[ start_pos +
  1917.                                                 p_old_positions[ j - start_pos ] ];
  1918.                     p_new_positions[ j ] += start_pos;
  1919.                 }
  1920.             }
  1921.         }
  1922.         free( p_old_positions );
  1923.         free( pp_char_styles );
  1924.         pp_char_styles = pp_char_styles_new;
  1925.         psz_text = p_fribidi_string;
  1926.         p_fribidi_string[ i_len ] = 0;
  1927.     }
  1928. #endif
  1929.     /* Work out the karaoke */
  1930.     if( pi_karaoke_bar )
  1931.     {
  1932.         int64_t i_last_duration = 0;
  1933.         int64_t i_duration = 0;
  1934.         int64_t i_start_pos = 0;
  1935.         int64_t i_elapsed  = var_GetTime( p_filter, "spu-elapsed" ) / 1000;
  1937.         for( k = 0; k< i_k_runs; k++ )
  1938.         {
  1939.              double fraction = 0.0;
  1941.              i_duration += pi_k_durations[ k ];
  1943.              if( i_duration < i_elapsed )
  1944.              {
  1945.                  /* Completely finished this run-length -
  1946.                   * let it render normally */
  1948.                  fraction = 1.0;
  1949.              }
  1950.              else if( i_elapsed < i_last_duration )
  1951.              {
  1952.                  /* Haven't got up to this segment yet -
  1953.                   * render it completely in karaoke BG mode */
  1955.                  fraction = 0.0;
  1956.              }
  1957.              else
  1958.              {
  1959.                  /* Partway through this run */
  1961.                  fraction = (double)(i_elapsed - i_last_duration) /
  1962.                             (double)pi_k_durations[ k ];
  1963.              }
  1964.              for( i = 0; i < pi_k_run_lengths[ k ]; i++ )
  1965.              {
  1966.                  double shade = pi_k_run_lengths[ k ] * fraction;
  1968.                  if( p_new_positions )
  1969.                      j = p_new_positions[ i_start_pos + i ];
  1970.                  else
  1971.                      j = i_start_pos + i;
  1973.                  if( i < (uint32_t)shade )
  1974.                      pi_karaoke_bar[ j ] = 0xff;
  1975.                  else if( (double)i > shade )
  1976.                      pi_karaoke_bar[ j ] = 0x00;
  1977.                  else
  1978.                  {
  1979.                      shade -= (int)shade;
  1980.                      pi_karaoke_bar[ j ] = ((int)(shade * 128.0) & 0x7f) |
  1981.                                    ((p_levels ? (p_levels[ j ] % 2) : 0 ) << 7);
  1982.                  }
  1983.              }
  1985.              i_last_duration = i_duration;
  1986.              i_start_pos += pi_k_run_lengths[ k ];
  1987.         }
  1988.     }
  1989.     free( p_levels );
  1990.     free( p_new_positions );
  1992.     FT_Vector tmp_result;
  1994.     line_desc_t *p_line = NULL;
  1995.     line_desc_t *p_prev = NULL;
  1997.     int i_pen_x = 0;
  1998.     int i_pen_y = 0;
  1999.     int i_posn  = 0;
  2001.     p_result->x = p_result->y = 0;
  2002.     tmp_result.x = tmp_result.y = 0;
  2004.     i_prev = 0;
  2005.     for( k = 0; k <= (uint32_t) i_len; k++ )
  2006.     {
  2007.         if( ( k == (uint32_t) i_len ) ||
  2008.           ( ( k > 0 ) &&
  2009.             !StyleEquals( pp_char_styles[ k ], pp_char_styles[ k - 1] ) ) )
  2010.         {
  2011.             ft_style_t *p_style = pp_char_styles[ k - 1 ];
  2013.             /* End of the current style run */
  2014.             FT_Face p_face = NULL;
  2015.             int      i_idx = 0;
  2017.             /* Look for a match amongst our attachments first */
  2018.             CheckForEmbeddedFont( p_sys, &p_face, p_style );
  2020.             if( ! p_face )
  2021.             {
  2022.                 char *psz_fontfile = NULL;
  2024.                 vlc_mutex_lock( &fb_lock );
  2025.                 if( p_sys->b_fontconfig_ok )
  2026.                 {
  2027.                     /* FIXME Is there really a race condition between FontConfig_Select with default fontconfig(NULL)
  2028.                      * and FcConfigBuildFonts ? If not it would be better to remove the check on b_fontconfig_ok */
  2029.                     psz_fontfile = FontConfig_Select( p_sys->p_fontconfig,
  2030.                                                       p_style->psz_fontname,
  2031.                                                       p_style->b_bold,
  2032.                                                       p_style->b_italic,
  2033.                                                       &i_idx );
  2034.                 }
  2035.                 vlc_mutex_unlock( &fb_lock );
  2037.                 if( psz_fontfile && ! *psz_fontfile )
  2038.                 {
  2039.                     msg_Warn( p_filter, "Fontconfig was unable to find a font: "%s" %s"
  2040.                         " so using default font", p_style->psz_fontname,
  2041.                         ((p_style->b_bold && p_style->b_italic) ? "(Bold,Italic)" :
  2042.                                                (p_style->b_bold ? "(Bold)" :
  2043.                                              (p_style->b_italic ? "(Italic)" : ""))) );
  2044.                     free( psz_fontfile );
  2045.                     psz_fontfile = NULL;
  2046.                 }
  2048.                 if( psz_fontfile )
  2049.                 {
  2050.                     if( FT_New_Face( p_sys->p_library,
  2051.                                 psz_fontfile, i_idx, &p_face ) )
  2052.                     {
  2053.                         free( psz_fontfile );
  2054.                         free( pp_char_styles );
  2055. #if defined(HAVE_FRIBIDI)
  2056.                         free( psz_text );
  2057. #endif
  2058.                         free( pi_karaoke_bar );
  2059.                         return VLC_EGENERIC;
  2060.                     }
  2061.                     free( psz_fontfile );
  2062.                 }
  2063.             }
  2064.             if( p_face &&
  2065.                 FT_Select_Charmap( p_face, ft_encoding_unicode ) )
  2066.             {
  2067.                 /* We've loaded a font face which is unhelpful for actually
  2068.                  * rendering text - fallback to the default one.
  2069.                  */
  2070.                  FT_Done_Face( p_face );
  2071.                  p_face = NULL;
  2072.             }
  2074.             if( FT_Select_Charmap( p_face ? p_face : p_sys->p_face,
  2075.                         ft_encoding_unicode ) ||
  2076.                 FT_Set_Pixel_Sizes( p_face ? p_face : p_sys->p_face, 0,
  2077.                     p_style->i_font_size ) )
  2078.             {
  2079.                 if( p_face ) FT_Done_Face( p_face );
  2080.                 free( pp_char_styles );
  2081. #if defined(HAVE_FRIBIDI)
  2082.                 free( psz_text );
  2083. #endif
  2084.                 free( pi_karaoke_bar );
  2085.                 return VLC_EGENERIC;
  2086.             }
  2087.             p_sys->i_use_kerning =
  2088.                         FT_HAS_KERNING( ( p_face  ? p_face : p_sys->p_face ) );
  2091.             uint32_t *psz_unicode = (uint32_t *)
  2092.                               malloc( (k - i_prev + 1) * sizeof( uint32_t ));
  2093.             if( !psz_unicode )
  2094.             {
  2095.                 if( p_face ) FT_Done_Face( p_face );
  2096.                 free( pp_char_styles );
  2097.                 free( psz_unicode );
  2098. #if defined(HAVE_FRIBIDI)
  2099.                 free( psz_text );
  2100. #endif
  2101.                 free( pi_karaoke_bar );
  2102.                 return VLC_ENOMEM;
  2103.             }
  2104.             memcpy( psz_unicode, psz_text + i_prev,
  2105.                                         sizeof( uint32_t ) * ( k - i_prev ) );
  2106.             psz_unicode[ k - i_prev ] = 0;
  2107.             while( *psz_unicode )
  2108.             {
  2109.                 if( !p_line )
  2110.                 {
  2111.                     if( !(p_line = NewLine( i_len - i_prev)) )
  2112.                     {
  2113.                         if( p_face ) FT_Done_Face( p_face );
  2114.                         free( pp_char_styles );
  2115.                         free( psz_unicode );
  2116. #if defined(HAVE_FRIBIDI)
  2117.                         free( psz_text );
  2118. #endif
  2119.                         free( pi_karaoke_bar );
  2120.                         return VLC_ENOMEM;
  2121.                     }
  2122.                     /* New Color mode only works in YUVA rendering mode --
  2123.                      * (RGB mode has palette constraints on it). We therefore
  2124.                      * need to populate the legacy colour fields also.
  2125.                      */
  2126.                     p_line->b_new_color_mode = true;
  2127.                     p_line->i_alpha = ( p_style->i_font_color & 0xff000000 ) >> 24;
  2128.                     p_line->i_red   = ( p_style->i_font_color & 0x00ff0000 ) >> 16;
  2129.                     p_line->i_green = ( p_style->i_font_color & 0x0000ff00 ) >>  8;
  2130.                     p_line->i_blue  = ( p_style->i_font_color & 0x000000ff );
  2131.                     p_line->p_next = NULL;
  2132.                     i_pen_x = 0;
  2133.                     i_pen_y += tmp_result.y;
  2134.                     tmp_result.x = 0;
  2135.                     tmp_result.y = 0;
  2136.                     i_posn = 0;
  2137.                     if( p_prev ) p_prev->p_next = p_line;
  2138.                     else *pp_lines = p_line;
  2139.                 }
  2141.                 if( RenderTag( p_filter, p_face ? p_face : p_sys->p_face,
  2142.                                p_style->i_font_color, p_style->b_underline,
  2143.                                p_style->i_karaoke_bg_color,
  2144.                                p_line, psz_unicode, &i_pen_x, i_pen_y, &i_posn,
  2145.                                &tmp_result ) != VLC_SUCCESS )
  2146.                 {
  2147.                     if( p_face ) FT_Done_Face( p_face );
  2148.                     free( pp_char_styles );
  2149.                     free( psz_unicode );
  2150. #if defined(HAVE_FRIBIDI)
  2151.                     free( psz_text );
  2152. #endif
  2153.                     free( pi_karaoke_bar );
  2154.                     return VLC_EGENERIC;
  2155.                 }
  2157.                 if( *psz_unicode )
  2158.                 {
  2159.                     p_result->x = __MAX( p_result->x, tmp_result.x );
  2160.                     p_result->y += tmp_result.y;
  2162.                     p_prev = p_line;
  2163.                     p_line = NULL;
  2165.                     if( *psz_unicode == 'n')
  2166.                     {
  2167.                         uint32_t *c_ptr;
  2169.                         for( c_ptr = psz_unicode; *c_ptr; c_ptr++ )
  2170.                         {
  2171.                             *c_ptr = *(c_ptr+1);
  2172.                         }
  2173.                     }
  2174.                 }
  2175.             }
  2176.             free( psz_unicode );
  2177.             if( p_face ) FT_Done_Face( p_face );
  2178.             i_prev = k;
  2179.         }
  2180.     }
  2181.     free( pp_char_styles );
  2182. #if defined(HAVE_FRIBIDI)
  2183.     free( psz_text );
  2184. #endif
  2185.     if( p_line )
  2186.     {
  2187.         p_result->x = __MAX( p_result->x, tmp_result.x );
  2188.         p_result->y += tmp_result.y;
  2189.     }
  2191.     if( pi_karaoke_bar )
  2192.     {
  2193.         int i = 0;
  2194.         for( p_line = *pp_lines; p_line; p_line=p_line->p_next )
  2195.         {
  2196.             for( k = 0; p_line->pp_glyphs[ k ]; k++, i++ )
  2197.             {
  2198.                 if( (pi_karaoke_bar[ i ] & 0x7f) == 0x7f)
  2199.                 {
  2200.                     /* do nothing */
  2201.                 }
  2202.                 else if( (pi_karaoke_bar[ i ] & 0x7f) == 0x00)
  2203.                 {
  2204.                     /* 100% BG colour will render faster if we
  2205.                      * instead make it 100% FG colour, so leave
  2206.                      * the ratio alone and copy the value across
  2207.                      */
  2208.                     p_line->p_fg_rgb[ k ] = p_line->p_bg_rgb[ k ];
  2209.                 }
  2210.                 else
  2211.                 {
  2212.                     if( pi_karaoke_bar[ i ] & 0x80 )
  2213.                     {
  2214.                         /* Swap Left and Right sides over for Right aligned
  2215.                          * language text (eg. Arabic, Hebrew)
  2216.                          */
  2217.                         uint32_t i_tmp = p_line->p_fg_rgb[ k ];
  2219.                         p_line->p_fg_rgb[ k ] = p_line->p_bg_rgb[ k ];
  2220.                         p_line->p_bg_rgb[ k ] = i_tmp;
  2221.                     }
  2222.                     p_line->p_fg_bg_ratio[ k ] = (pi_karaoke_bar[ i ] & 0x7f);
  2223.                 }
  2224.             }
  2225.             /* Jump over the 'n' at the line-end */
  2226.             i++;
  2227.         }
  2228.         free( pi_karaoke_bar );
  2229.     }
  2231.     return VLC_SUCCESS;
  2232. }
  2234. static int RenderHtml( filter_t *p_filter, subpicture_region_t *p_region_out,
  2235.                        subpicture_region_t *p_region_in )
  2236. {
  2237.     int          rv = VLC_SUCCESS;
  2238.     stream_t     *p_sub = NULL;
  2239.     xml_reader_t *p_xml_reader = NULL;
  2241.     if( !p_region_in || !p_region_in->psz_html )
  2242.         return VLC_EGENERIC;
  2244.     /* Reset the default fontsize in case screen metrics have changed */
  2245.     p_filter->p_sys->i_font_size = GetFontSize( p_filter );
  2247.     p_sub = stream_MemoryNew( VLC_OBJECT(p_filter),
  2248.                               (uint8_t *) p_region_in->psz_html,
  2249.                               strlen( p_region_in->psz_html ),
  2250.                               true );
  2251.     if( p_sub )
  2252.     {
  2253.         if( !p_filter->p_sys->p_xml ) p_filter->p_sys->p_xml = xml_Create( p_filter );
  2254.         if( p_filter->p_sys->p_xml )
  2255.         {
  2256.             bool b_karaoke = false;
  2258.             p_xml_reader = xml_ReaderCreate( p_filter->p_sys->p_xml, p_sub );
  2259.             if( p_xml_reader )
  2260.             {
  2261.                 /* Look for Root Node */
  2262.                 if( xml_ReaderRead( p_xml_reader ) == 1 )
  2263.                 {
  2264.                     char *psz_node = xml_ReaderName( p_xml_reader );
  2266.                     if( !strcasecmp( "karaoke", psz_node ) )
  2267.                     {
  2268.                         /* We're going to have to render the text a number
  2269.                          * of times to show the progress marker on the text.
  2270.                          */
  2271.                         var_SetBool( p_filter, "text-rerender", true );
  2272.                         b_karaoke = true;
  2273.                     }
  2274.                     else if( !strcasecmp( "text", psz_node ) )
  2275.                     {
  2276.                         b_karaoke = false;
  2277.                     }
  2278.                     else
  2279.                     {
  2280.                         /* Only text and karaoke tags are supported */
  2281.                         msg_Dbg( p_filter, "Unsupported top-level tag '%s' ignored.", psz_node );
  2282.                         xml_ReaderDelete( p_filter->p_sys->p_xml, p_xml_reader );
  2283.                         p_xml_reader = NULL;
  2284.                         rv = VLC_EGENERIC;
  2285.                     }
  2287.                     free( psz_node );
  2288.                 }
  2289.             }
  2291.             if( p_xml_reader )
  2292.             {
  2293.                 uint32_t   *psz_text;
  2294.                 int         i_len = 0;
  2295.                 uint32_t    i_runs = 0;
  2296.                 uint32_t    i_k_runs = 0;
  2297.                 uint32_t   *pi_run_lengths = NULL;
  2298.                 uint32_t   *pi_k_run_lengths = NULL;
  2299.                 uint32_t   *pi_k_durations = NULL;
  2300.                 ft_style_t  **pp_styles = NULL;
  2301.                 FT_Vector    result;
  2302.                 line_desc_t  *p_lines = NULL;
  2304.                 psz_text = (uint32_t *)malloc( strlen( p_region_in->psz_html ) *
  2305.                                                 sizeof( uint32_t ) );
  2306.                 if( psz_text )
  2307.                 {
  2308.                     uint32_t k;
  2310.                     rv = ProcessNodes( p_filter, p_xml_reader,
  2311.                                   p_region_in->p_style, psz_text, &i_len,
  2312.                                   &i_runs, &pi_run_lengths, &pp_styles,
  2314.                                   b_karaoke, &i_k_runs, &pi_k_run_lengths,
  2315.                                   &pi_k_durations );
  2317.                     p_region_out->i_x = p_region_in->i_x;
  2318.                     p_region_out->i_y = p_region_in->i_y;
  2320.                     if(( rv == VLC_SUCCESS ) && ( i_len > 0 ))
  2321.                     {
  2322.                         rv = ProcessLines( p_filter, psz_text, i_len, i_runs,
  2323.                                 pi_run_lengths, pp_styles, &p_lines, &result,
  2324.                                 b_karaoke, i_k_runs, pi_k_run_lengths,
  2325.                                 pi_k_durations );
  2326.                     }
  2328.                     for( k=0; k<i_runs; k++)
  2329.                         DeleteStyle( pp_styles[k] );
  2330.                     free( pp_styles );
  2331.                     free( pi_run_lengths );
  2332.                     free( psz_text );
  2334.                     /* Don't attempt to render text that couldn't be layed out
  2335.                      * properly.
  2336.                      */
  2337.                     if(( rv == VLC_SUCCESS ) && ( i_len > 0 ))
  2338.                     {
  2339.                         if( config_GetInt( p_filter, "freetype-yuvp" ) )
  2340.                         {
  2341.                             Render( p_filter, p_region_out, p_lines,
  2342.                                     result.x, result.y );
  2343.                         }
  2344.                         else
  2345.                         {
  2346.                             RenderYUVA( p_filter, p_region_out, p_lines,
  2347.                                     result.x, result.y );
  2348.                         }
  2349.                     }
  2350.                 }
  2351.                 FreeLines( p_lines );
  2353.                 xml_ReaderDelete( p_filter->p_sys->p_xml, p_xml_reader );
  2354.             }
  2355.         }
  2356.         stream_Delete( p_sub );
  2357.     }
  2359.     return rv;
  2360. }
  2362. static char* FontConfig_Select( FcConfig* priv, const char* family,
  2363.                           bool b_bold, bool b_italic, int *i_idx )
  2364. {
  2365.     FcResult result;
  2366.     FcPattern *pat, *p_pat;
  2367.     FcChar8* val_s;
  2368.     FcBool val_b;
  2370.     pat = FcPatternCreate();
  2371.     if (!pat) return NULL;
  2373.     FcPatternAddString( pat, FC_FAMILY, (const FcChar8*)family );
  2374.     FcPatternAddBool( pat, FC_OUTLINE, FcTrue );
  2375.     FcPatternAddInteger( pat, FC_SLANT, b_italic ? FC_SLANT_ITALIC : FC_SLANT_ROMAN );
  2376.     FcPatternAddInteger( pat, FC_WEIGHT, b_bold ? FC_WEIGHT_EXTRABOLD : FC_WEIGHT_NORMAL );
  2378.     FcDefaultSubstitute( pat );
  2380.     if( !FcConfigSubstitute( priv, pat, FcMatchPattern ) )
  2381.     {
  2382.         FcPatternDestroy( pat );
  2383.         return NULL;
  2384.     }
  2386.     p_pat = FcFontMatch( priv, pat, &result );
  2387.     FcPatternDestroy( pat );
  2388.     if( !p_pat ) return NULL;
  2390.     if( ( FcResultMatch != FcPatternGetBool( p_pat, FC_OUTLINE, 0, &val_b ) )
  2391.         || ( val_b != FcTrue ) )
  2392.     {
  2393.         FcPatternDestroy( p_pat );
  2394.         return NULL;
  2395.     }
  2396.     if( FcResultMatch != FcPatternGetInteger( p_pat, FC_INDEX, 0, i_idx ) )
  2397.     {
  2398.         *i_idx = 0;
  2399.     }
  2401.     if( FcResultMatch != FcPatternGetString( p_pat, FC_FAMILY, 0, &val_s ) )
  2402.     {
  2403.         FcPatternDestroy( p_pat );
  2404.         return NULL;
  2405.     }
  2407.     /*
  2408.     if( strcasecmp((const char*)val_s, family ) != 0 )
  2409.         msg_Warn( p_filter, "fontconfig: selected font family is not"
  2410.                             "the requested one: '%s' != '%s'n",
  2411.                             (const char*)val_s, family );
  2412.     */
  2414.     if( FcResultMatch != FcPatternGetString( p_pat, FC_FILE, 0, &val_s ) )
  2415.     {
  2416.         FcPatternDestroy( p_pat );
  2417.         return NULL;
  2418.     }
  2420.     FcPatternDestroy( p_pat );
  2421.     return strdup( (const char*)val_s );
  2422. }
  2423. #else
  2425. static void SetupLine( filter_t *p_filter, const char *psz_text_in,
  2426.                        uint32_t **psz_text_out, uint32_t *pi_runs,
  2427.                        uint32_t **ppi_run_lengths, ft_style_t ***ppp_styles,
  2428.                        ft_style_t *p_style )
  2429. {
  2430.         VLC_UNUSED(p_filter);
  2431.         VLC_UNUSED(psz_text_in);
  2432.         VLC_UNUSED(psz_text_out);
  2433.         VLC_UNUSED(pi_runs);
  2434.         VLC_UNUSED(ppi_run_lengths);
  2435.         VLC_UNUSED(ppp_styles);
  2436.         VLC_UNUSED(p_style);
  2437. }
  2439. static ft_style_t *GetStyleFromFontStack( filter_sys_t *p_sys,
  2440.         font_stack_t **p_fonts, bool b_bold, bool b_italic,
  2441.         bool b_uline )
  2442. {
  2443.         VLC_UNUSED(p_sys);
  2444.         VLC_UNUSED(p_fonts);
  2445.         VLC_UNUSED(b_bold);
  2446.         VLC_UNUSED(b_italic);
  2447.         VLC_UNUSED(b_uline);
  2448.         return NULL;
  2449. }
  2450. #endif
  2452. static void FreeLine( line_desc_t *p_line )
  2453. {
  2454.     unsigned int i;
  2455.     for( i = 0; p_line->pp_glyphs[ i ] != NULL; i++ )
  2456.     {
  2457.         FT_Done_Glyph( (FT_Glyph)p_line->pp_glyphs[ i ] );
  2458.     }
  2459.     free( p_line->pp_glyphs );
  2460.     free( p_line->p_glyph_pos );
  2461.     free( p_line->p_fg_rgb );
  2462.     free( p_line->p_bg_rgb );
  2463.     free( p_line->p_fg_bg_ratio );
  2464.     free( p_line->pi_underline_offset );
  2465.     free( p_line->pi_underline_thickness );
  2466.     free( p_line );
  2467. }
  2469. static void FreeLines( line_desc_t *p_lines )
  2470. {
  2471.     line_desc_t *p_line, *p_next;
  2473.     if( !p_lines ) return;
  2475.     for( p_line = p_lines; p_line != NULL; p_line = p_next )
  2476.     {
  2477.         p_next = p_line->p_next;
  2478.         FreeLine( p_line );
  2479.     }
  2480. }
  2482. static line_desc_t *NewLine( int i_count )
  2483. {
  2484.     line_desc_t *p_line = malloc( sizeof(line_desc_t) );
  2486.     if( !p_line ) return NULL;
  2487.     p_line->i_height = 0;
  2488.     p_line->i_width = 0;
  2489.     p_line->p_next = NULL;
  2491.     p_line->pp_glyphs = malloc( sizeof(FT_BitmapGlyph) * ( i_count + 1 ) );
  2492.     p_line->p_glyph_pos = malloc( sizeof( FT_Vector ) * ( i_count + 1 ) );
  2493.     p_line->p_fg_rgb = malloc( sizeof( uint32_t ) * ( i_count + 1 ) );
  2494.     p_line->p_bg_rgb = malloc( sizeof( uint32_t ) * ( i_count + 1 ) );
  2495.     p_line->p_fg_bg_ratio = calloc( i_count + 1, sizeof( uint8_t ) );
  2496.     p_line->pi_underline_offset = calloc( i_count + 1, sizeof( uint16_t ) );
  2497.     p_line->pi_underline_thickness = calloc( i_count + 1, sizeof( uint16_t ) );
  2498.     if( ( p_line->pp_glyphs == NULL ) ||
  2499.         ( p_line->p_glyph_pos == NULL ) ||
  2500.         ( p_line->p_fg_rgb == NULL ) ||
  2501.         ( p_line->p_bg_rgb == NULL ) ||
  2502.         ( p_line->p_fg_bg_ratio == NULL ) ||
  2503.         ( p_line->pi_underline_offset == NULL ) ||
  2504.         ( p_line->pi_underline_thickness == NULL ) )
  2505.     {
  2506.         free( p_line->pi_underline_thickness );
  2507.         free( p_line->pi_underline_offset );
  2508.         free( p_line->p_fg_rgb );
  2509.         free( p_line->p_bg_rgb );
  2510.         free( p_line->p_fg_bg_ratio );
  2511.         free( p_line->p_glyph_pos );
  2512.         free( p_line->pp_glyphs );
  2513.         free( p_line );
  2514.         return NULL;
  2515.     }
  2516.     p_line->pp_glyphs[0] = NULL;
  2517.     p_line->b_new_color_mode = false;
  2519.     return p_line;
  2520. }
  2522. static int GetFontSize( filter_t *p_filter )
  2523. {
  2524.     filter_sys_t *p_sys = p_filter->p_sys;
  2525.     vlc_value_t   val;
  2526.     int           i_size = 0;
  2528.     if( p_sys->i_default_font_size )
  2529.     {
  2530.         if( VLC_SUCCESS == var_Get( p_filter, "scale", &val ))
  2531.             i_size = p_sys->i_default_font_size * val.i_int / 1000;
  2532.         else
  2533.             i_size = p_sys->i_default_font_size;
  2534.     }
  2535.     else
  2536.     {
  2537.         var_Get( p_filter, "freetype-rel-fontsize", &val );
  2538.         if( val.i_int  > 0 )
  2539.         {
  2540.             i_size = (int)p_filter->fmt_out.video.i_height / val.i_int;
  2541.             p_filter->p_sys->i_display_height =
  2542.                 p_filter->fmt_out.video.i_height;
  2543.         }
  2544.     }
  2545.     if( i_size <= 0 )
  2546.     {
  2547.         msg_Warn( p_filter, "invalid fontsize, using 12" );
  2548.         if( VLC_SUCCESS == var_Get( p_filter, "scale", &val ))
  2549.             i_size = 12 * val.i_int / 1000;
  2550.         else
  2551.             i_size = 12;
  2552.     }
  2553.     return i_size;
  2554. }
  2556. static int SetFontSize( filter_t *p_filter, int i_size )
  2557. {
  2558.     filter_sys_t *p_sys = p_filter->p_sys;
  2560.     if( !i_size )
  2561.     {
  2562.         i_size = GetFontSize( p_filter );
  2564.         msg_Dbg( p_filter, "using fontsize: %i", i_size );
  2565.     }
  2567.     p_sys->i_font_size = i_size;
  2569.     if( FT_Set_Pixel_Sizes( p_sys->p_face, 0, i_size ) )
  2570.     {
  2571.         msg_Err( p_filter, "couldn't set font size to %d", i_size );
  2572.         return VLC_EGENERIC;
  2573.     }
  2575.     return VLC_SUCCESS;
  2576. }
  2578. static void YUVFromRGB( uint32_t i_argb,
  2579.                     uint8_t *pi_y, uint8_t *pi_u, uint8_t *pi_v )
  2580. {
  2581.     int i_red   = ( i_argb & 0x00ff0000 ) >> 16;
  2582.     int i_green = ( i_argb & 0x0000ff00 ) >>  8;
  2583.     int i_blue  = ( i_argb & 0x000000ff );
  2585.     *pi_y = (uint8_t)__MIN(abs( 2104 * i_red  + 4130 * i_green +
  2586.                       802 * i_blue + 4096 + 131072 ) >> 13, 235);
  2587.     *pi_u = (uint8_t)__MIN(abs( -1214 * i_red  + -2384 * i_green +
  2588.                      3598 * i_blue + 4096 + 1048576) >> 13, 240);
  2589.     *pi_v = (uint8_t)__MIN(abs( 3598 * i_red + -3013 * i_green +
  2590.                       -585 * i_blue + 4096 + 1048576) >> 13, 240);
  2591. }