]> git.sesse.net Git - vlc/blob - modules/misc/freetype.c
1a7ebd815b343c9cf0fd28d749a39440c19f03a8
[vlc] / modules / misc / freetype.c
1 /*****************************************************************************
2  * freetype.c : Put text on the video, using freetype2
3  *****************************************************************************
4  * Copyright (C) 2002 - 2005 VideoLAN
5  * $Id$
6  *
7  * Authors: Sigmund Augdal <sigmunau@idi.ntnu.no>
8  *          Gildas Bazin <gbazin@videolan.org>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
23  *****************************************************************************/
24
25 /*****************************************************************************
26  * Preamble
27  *****************************************************************************/
28 #include <stdlib.h>                                      /* malloc(), free() */
29 #include <string.h>
30
31 #ifdef HAVE_LINUX_LIMITS_H
32 #   include <linux/limits.h>
33 #endif
34
35 #include <vlc/vlc.h>
36 #include <vlc/vout.h>
37 #include "osd.h"
38 #include "vlc_block.h"
39 #include "vlc_filter.h"
40
41 #include <math.h>
42
43 #ifdef HAVE_ERRNO_H
44 #   include <errno.h>
45 #endif
46
47 #include <ft2build.h>
48 #include FT_FREETYPE_H
49 #include FT_GLYPH_H
50
51 #ifdef SYS_DARWIN
52 #define DEFAULT_FONT "/System/Library/Fonts/LucidaGrande.dfont"
53 #elif defined( SYS_BEOS )
54 #define DEFAULT_FONT "/boot/beos/etc/fonts/ttfonts/Swiss721.ttf"
55 #elif defined( WIN32 )
56 #define DEFAULT_FONT "" /* Default font found at run-time */
57 #else
58 #define DEFAULT_FONT "/usr/share/fonts/truetype/freefont/FreeSerifBold.ttf"
59 #endif
60
61 #if defined(HAVE_FRIBIDI)
62 #include <fribidi/fribidi.h>
63 #endif
64
65 typedef struct line_desc_t line_desc_t;
66
67 /*****************************************************************************
68  * Local prototypes
69  *****************************************************************************/
70 static int  Create ( vlc_object_t * );
71 static void Destroy( vlc_object_t * );
72
73 /* The RenderText call maps to pf_render_string, defined in vlc_filter.h */
74 static int RenderText( filter_t *, subpicture_region_t *,
75                        subpicture_region_t * );
76 static line_desc_t *NewLine( byte_t * );
77
78 /*****************************************************************************
79  * Module descriptor
80  *****************************************************************************/
81 #define FONT_TEXT N_("Font")
82 #define FONT_LONGTEXT N_("Font filename")
83 #define FONTSIZE_TEXT N_("Font size in pixels")
84 #define FONTSIZE_LONGTEXT N_("The size of the fonts used by the osd module. " \
85     "If set to something different than 0 this option will override the " \
86     "relative font size " )
87 #define OPACITY_TEXT N_("Opacity, 0..255")
88 #define OPACITY_LONGTEXT N_("The opacity (inverse of transparency) of " \
89     "overlay text. 0 = transparent, 255 = totally opaque. " )
90 #define COLOR_TEXT N_("Text Default Color")
91 #define COLOR_LONGTEXT N_("The color of overlay text. 1 byte for each color, "\
92     "hexadecimal. #000000 = all colors off, 0xFF0000 = just Red, " \
93     "0xFFFFFF = all color on [White]" )
94 #define FONTSIZER_TEXT N_("Font size")
95 #define FONTSIZER_LONGTEXT N_("The size of the fonts used by the osd module" )
96
97 static int   pi_sizes[] = { 20, 18, 16, 12, 6 };
98 static char *ppsz_sizes_text[] = { N_("Smaller"), N_("Small"), N_("Normal"),
99                                    N_("Large"), N_("Larger") };
100 static int pi_color_values[] = {
101   0x00000000, 0x00808080, 0x00C0C0C0, 0x00FFFFFF, 0x00800000,
102   0x00FF0000, 0x00FF00FF, 0x00FFFF00, 0x00808000, 0x00008000, 0x00008080, 
103   0x0000FF00, 0x00800080, 0x00000080, 0x000000FF, 0x0000FFFF }; 
104
105 static char *ppsz_color_descriptions[] = {
106   N_("Black"), N_("Gray"), N_("Silver"), N_("White"), N_("Maroon"),
107   N_("Red"), N_("Fuchsia"), N_("Yellow"), N_("Olive"), N_("Green"), N_("Teal"),
108   N_("Lime"), N_("Purple"), N_("Navy"), N_("Blue"), N_("Aqua") };
109
110 vlc_module_begin();
111     set_shortname( _("Freetype"));
112     set_description( _("Freetype2 font renderer") );
113     set_category( CAT_VIDEO );
114     set_subcategory( SUBCAT_VIDEO_TEXT );
115
116     add_file( "freetype-font", DEFAULT_FONT, NULL, FONT_TEXT, FONT_LONGTEXT,
117               VLC_FALSE );
118
119     add_integer( "freetype-fontsize", 0, NULL, FONTSIZE_TEXT,
120                  FONTSIZE_LONGTEXT, VLC_TRUE );
121
122     /* opacity valid on 0..255, with default 255 = fully opaque */
123     add_integer_with_range( "freetype-opacity", 255, 0, 255, NULL,
124         OPACITY_TEXT, OPACITY_LONGTEXT, VLC_FALSE );
125
126     /* hook to the color values list, with default 0x00ffffff = white */
127     add_integer( "freetype-color", 0x00FFFFFF, NULL, COLOR_TEXT,
128                  COLOR_LONGTEXT, VLC_TRUE );
129         change_integer_list( pi_color_values, ppsz_color_descriptions, 0 );
130
131     add_integer( "freetype-rel-fontsize", 16, NULL, FONTSIZER_TEXT,
132                  FONTSIZER_LONGTEXT, VLC_FALSE );
133         change_integer_list( pi_sizes, ppsz_sizes_text, 0 );
134
135     set_capability( "text renderer", 100 );
136     add_shortcut( "text" );
137     set_callbacks( Create, Destroy );
138 vlc_module_end();
139
140 struct line_desc_t
141 {
142     /** NULL-terminated list of glyphs making the string */
143     FT_BitmapGlyph *pp_glyphs;
144     /** list of relative positions for the glyphs */
145     FT_Vector      *p_glyph_pos;
146
147     int             i_height;
148     int             i_width;
149     int             i_red, i_green, i_blue;
150     int             i_alpha;
151
152     line_desc_t    *p_next;
153 };
154
155 static int Render( filter_t *, subpicture_region_t *, line_desc_t *, int, int);
156 static void FreeLines( line_desc_t * );
157 static void FreeLine( line_desc_t * );
158
159 /*****************************************************************************
160  * filter_sys_t: freetype local data
161  *****************************************************************************
162  * This structure is part of the video output thread descriptor.
163  * It describes the freetype specific properties of an output thread.
164  *****************************************************************************/
165 struct filter_sys_t
166 {
167     FT_Library     p_library;   /* handle to library     */
168     FT_Face        p_face;      /* handle to face object */
169     vlc_bool_t     i_use_kerning;
170     uint8_t        i_font_opacity;
171     int            i_font_color;
172     int            i_font_size;
173 };
174
175 /*****************************************************************************
176  * Create: allocates osd-text video thread output method
177  *****************************************************************************
178  * This function allocates and initializes a Clone vout method.
179  *****************************************************************************/
180 static int Create( vlc_object_t *p_this )
181 {
182     filter_t *p_filter = (filter_t *)p_this;
183     filter_sys_t *p_sys;
184     char *psz_fontfile = NULL;
185     int i_error;
186     vlc_value_t val;
187
188     /* Allocate structure */
189     p_sys = malloc( sizeof( filter_sys_t ) );
190     if( !p_sys )
191     {
192         msg_Err( p_filter, "out of memory" );
193         return VLC_ENOMEM;
194     }
195     p_sys->p_face = 0;
196     p_sys->p_library = 0;
197     p_sys->i_font_size = 0;
198
199     var_Create( p_filter, "freetype-font",
200                 VLC_VAR_STRING | VLC_VAR_DOINHERIT );
201     var_Create( p_filter, "freetype-fontsize",
202                 VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
203     var_Create( p_filter, "freetype-rel-fontsize",
204                 VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
205     var_Create( p_filter, "freetype-opacity",
206                 VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
207     var_Get( p_filter, "freetype-opacity", &val );
208     p_sys->i_font_opacity = __MAX( __MIN( val.i_int, 255 ), 0 );
209     var_Create( p_filter, "freetype-color",
210                 VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
211     var_Get( p_filter, "freetype-color", &val );
212     p_sys->i_font_color = __MAX( __MIN( val.i_int, 0xFFFFFF ), 0 );
213
214     /* Look what method was requested */
215     var_Get( p_filter, "freetype-font", &val );
216     psz_fontfile = val.psz_string;
217     if( !psz_fontfile || !*psz_fontfile )
218     {
219         if( psz_fontfile ) free( psz_fontfile );
220         psz_fontfile = (char *)malloc( PATH_MAX + 1 );
221 #ifdef WIN32
222         GetWindowsDirectory( psz_fontfile, PATH_MAX + 1 );
223         strcat( psz_fontfile, "\\fonts\\arial.ttf" );
224 #elif SYS_DARWIN
225         strcpy( psz_fontfile, DEFAULT_FONT );
226 #else
227         msg_Err( p_filter, "user didn't specify a font" );
228         goto error;
229 #endif
230     }
231
232     i_error = FT_Init_FreeType( &p_sys->p_library );
233     if( i_error )
234     {
235         msg_Err( p_filter, "couldn't initialize freetype" );
236         goto error;
237     }
238
239     i_error = FT_New_Face( p_sys->p_library, psz_fontfile ? psz_fontfile : "",
240                            0, &p_sys->p_face );
241     if( i_error == FT_Err_Unknown_File_Format )
242     {
243         msg_Err( p_filter, "file %s have unknown format", psz_fontfile );
244         goto error;
245     }
246     else if( i_error )
247     {
248         msg_Err( p_filter, "failed to load font file %s", psz_fontfile );
249         goto error;
250     }
251
252     i_error = FT_Select_Charmap( p_sys->p_face, ft_encoding_unicode );
253     if( i_error )
254     {
255         msg_Err( p_filter, "Font has no unicode translation table" );
256         goto error;
257     }
258
259     p_sys->i_use_kerning = FT_HAS_KERNING( p_sys->p_face );
260
261     
262     var_Get( p_filter, "freetype-fontsize", &val );
263     if( val.i_int )
264     {
265         p_sys->i_font_size = val.i_int;
266     }
267     else
268     {
269         var_Get( p_filter, "freetype-rel-fontsize", &val );
270         p_sys->i_font_size = (int)p_filter->fmt_out.video.i_height / val.i_int;
271     }
272     if( p_sys->i_font_size <= 0 )
273     {
274         msg_Warn( p_filter, "Invalid fontsize, using 12" );
275         p_sys->i_font_size = 12;
276     }
277     msg_Dbg( p_filter, "Using fontsize: %i", p_sys->i_font_size );
278
279     i_error = FT_Set_Pixel_Sizes( p_sys->p_face, 0, p_sys->i_font_size );
280     if( i_error )
281     {
282         msg_Err( p_filter, "couldn't set font size to %d", p_sys->i_font_size );
283         goto error;
284     }
285
286     if( psz_fontfile ) free( psz_fontfile );
287     p_filter->pf_render_text = RenderText;
288     p_filter->p_sys = p_sys;
289     return VLC_SUCCESS;
290
291  error:
292     if( p_sys->p_face ) FT_Done_Face( p_sys->p_face );
293     if( p_sys->p_library ) FT_Done_FreeType( p_sys->p_library );
294     if( psz_fontfile ) free( psz_fontfile );
295     free( p_sys );
296     return VLC_EGENERIC;
297 }
298
299 /*****************************************************************************
300  * Destroy: destroy Clone video thread output method
301  *****************************************************************************
302  * Clean up all data and library connections
303  *****************************************************************************/
304 static void Destroy( vlc_object_t *p_this )
305 {
306     filter_t *p_filter = (filter_t *)p_this;
307     filter_sys_t *p_sys = p_filter->p_sys;
308
309     FT_Done_Face( p_sys->p_face );
310     FT_Done_FreeType( p_sys->p_library );
311     free( p_sys );
312 }
313
314 /*****************************************************************************
315  * Render: place string in picture
316  *****************************************************************************
317  * This function merges the previously rendered freetype glyphs into a picture
318  *****************************************************************************/
319 static int Render( filter_t *p_filter, subpicture_region_t *p_region,
320                    line_desc_t *p_line, int i_width, int i_height )
321 {
322     uint8_t *p_dst;
323     video_format_t fmt;
324     int i, x, y, i_pitch;
325     uint8_t i_y; /* YUV values, derived from incoming RGB */
326     int8_t i_u, i_v;
327     subpicture_region_t *p_region_tmp;
328
329     /* Create a new subpicture region */
330     memset( &fmt, 0, sizeof(video_format_t) );
331     fmt.i_chroma = VLC_FOURCC('Y','U','V','P');
332     fmt.i_aspect = VOUT_ASPECT_FACTOR;
333     fmt.i_width = fmt.i_visible_width = i_width + 2;
334     fmt.i_height = fmt.i_visible_height = i_height + 2;
335     fmt.i_x_offset = fmt.i_y_offset = 0;
336     p_region_tmp = spu_CreateRegion( p_filter, &fmt );
337     if( !p_region_tmp )
338     {
339         msg_Err( p_filter, "cannot allocate SPU region" );
340         return VLC_EGENERIC;
341     }
342
343     p_region->fmt = p_region_tmp->fmt;
344     p_region->picture = p_region_tmp->picture;
345     free( p_region_tmp );
346
347     /* Calculate text color components */
348     i_y = (uint8_t)(( 66 * p_line->i_red  + 129 * p_line->i_green +
349                       25 * p_line->i_blue + 128) >> 8) +  16;
350     i_u = (int8_t)(( -38 * p_line->i_red  -  74 * p_line->i_green +
351                      112 * p_line->i_blue + 128) >> 8) + 128;
352     i_v = (int8_t)(( 112 * p_line->i_red  -  94 * p_line->i_green -
353                       18 * p_line->i_blue + 128) >> 8) + 128;
354
355     /* Build palette */
356     fmt.p_palette->i_entries = 256;
357     for( i = 0; i < fmt.p_palette->i_entries; i++ )
358     {
359         fmt.p_palette->palette[i][0] = i * i_y / 256;
360         fmt.p_palette->palette[i][1] = i_u;
361         fmt.p_palette->palette[i][2] = i_v;
362         fmt.p_palette->palette[i][3] = i + (255 - i) / 16;
363         fmt.p_palette->palette[i][3] =
364             (int)fmt.p_palette->palette[i][3] * (255 - p_line->i_alpha) / 255;
365     }
366     fmt.p_palette->palette[0][3] = 0;
367
368     p_dst = p_region->picture.Y_PIXELS;
369     i_pitch = p_region->picture.Y_PITCH;
370
371     /* Initialize the region pixels */
372     memset( p_dst, 0, i_pitch * p_region->fmt.i_height );
373
374     for( ; p_line != NULL; p_line = p_line->p_next )
375     {
376         int i_glyph_tmax = 0;
377         int i_bitmap_offset, i_offset;
378         for( i = 0; p_line->pp_glyphs[i] != NULL; i++ )
379         {
380             FT_BitmapGlyph p_glyph = p_line->pp_glyphs[ i ];
381             i_glyph_tmax = __MAX( i_glyph_tmax, p_glyph->top );
382         }
383
384         for( i = 0; p_line->pp_glyphs[i] != NULL; i++ )
385         {
386             FT_BitmapGlyph p_glyph = p_line->pp_glyphs[ i ];
387
388             i_offset = ( p_line->p_glyph_pos[ i ].y +
389                 i_glyph_tmax - p_glyph->top + 1 ) *
390                 i_pitch + p_line->p_glyph_pos[ i ].x + p_glyph->left + 1;
391
392             for( y = 0, i_bitmap_offset = 0; y < p_glyph->bitmap.rows; y++ )
393             {
394                 for( x = 0; x < p_glyph->bitmap.width; x++, i_bitmap_offset++ )
395                 {
396                     if( !p_glyph->bitmap.buffer[i_bitmap_offset] )
397                         continue;
398
399                     i_offset -= i_pitch;
400                     p_dst[i_offset + x] = ((uint16_t)p_dst[i_offset + x]*2 +
401                       p_glyph->bitmap.buffer[i_bitmap_offset])/3;
402                     i_offset += i_pitch; x--;
403                     p_dst[i_offset + x] = ((uint16_t)p_dst[i_offset + x]*2 +
404                       p_glyph->bitmap.buffer[i_bitmap_offset])/3;
405                     x += 2;
406                     p_dst[i_offset + x] = ((uint16_t)p_dst[i_offset + x]*2 +
407                       p_glyph->bitmap.buffer[i_bitmap_offset])/3;
408                     i_offset += i_pitch; x--;
409                     p_dst[i_offset + x] = ((uint16_t)p_dst[i_offset + x]*2 +
410                       p_glyph->bitmap.buffer[i_bitmap_offset])/3;
411                     i_offset -= i_pitch;
412                 }
413                 i_offset += i_pitch;
414             }
415
416             i_offset = ( p_line->p_glyph_pos[ i ].y +
417                 i_glyph_tmax - p_glyph->top + 1 ) *
418                 i_pitch + p_line->p_glyph_pos[ i ].x + p_glyph->left + 1;
419
420             for( y = 0, i_bitmap_offset = 0; y < p_glyph->bitmap.rows; y++ )
421             {
422                for( x = 0; x < p_glyph->bitmap.width; x++, i_bitmap_offset++ )
423                {
424                  if( p_glyph->bitmap.buffer[i_bitmap_offset] > 16 )
425                    p_dst[i_offset+x] = p_glyph->bitmap.buffer[i_bitmap_offset];
426                }
427                i_offset += i_pitch;
428             }
429         }
430     }
431
432     return VLC_SUCCESS;
433 }
434
435 /**
436  * This function renders a text subpicture region into another one.
437  * It also calculates the size needed for this string, and renders the
438  * needed glyphs into memory. It is used as pf_add_string callback in
439  * the vout method by this module
440  */
441 static int RenderText( filter_t *p_filter, subpicture_region_t *p_region_out,
442                        subpicture_region_t *p_region_in )
443 {
444     filter_sys_t *p_sys = p_filter->p_sys;
445     line_desc_t  *p_lines = 0, *p_line = 0, *p_next = 0, *p_prev = 0;
446     int i, i_pen_y, i_pen_x, i_error, i_glyph_index, i_previous;
447     uint32_t *psz_unicode, *psz_unicode_orig = 0, i_char, *psz_line_start;
448     int i_string_length;
449     char *psz_string;
450     vlc_iconv_t iconv_handle = (vlc_iconv_t)(-1);
451     int i_font_color, i_font_alpha, i_font_size, i_red, i_green, i_blue;
452
453     FT_BBox line;
454     FT_BBox glyph_size;
455     FT_Vector result;
456     FT_Glyph tmp_glyph;
457
458     /* Sanity check */
459     if( !p_region_in || !p_region_out ) return VLC_EGENERIC;
460     psz_string = p_region_in->psz_text;
461     if( !psz_string || !*psz_string ) return VLC_EGENERIC;
462
463     i_font_color = __MAX( __MIN( p_region_in->i_text_color, 0xFFFFFF ), 0 );
464     if( i_font_color == 0xFFFFFF ) i_font_color = p_sys->i_font_color;
465
466     i_font_alpha = __MAX( __MIN( p_region_in->i_text_alpha, 255 ), 0 );
467     if( !i_font_alpha ) i_font_alpha = 255 - p_sys->i_font_opacity;
468
469     i_font_size  = __MAX( __MIN( p_region_in->i_text_size, 255 ), 0 );
470     if( !i_font_size ) i_font_size  = p_sys->i_font_size;
471
472     i_red   = ( i_font_color & 0x00FF0000 ) >> 16;
473     i_green = ( i_font_color & 0x0000FF00 ) >>  8;
474     i_blue  =   i_font_color & 0x000000FF;
475
476     result.x =  result.y = 0;
477     line.xMin = line.xMax = line.yMin = line.yMax = 0;
478
479     psz_unicode = psz_unicode_orig =
480         malloc( ( strlen(psz_string) + 1 ) * sizeof(uint32_t) );
481     if( psz_unicode == NULL )
482     {
483         msg_Err( p_filter, "out of memory" );
484         goto error;
485     }
486 #if defined(WORDS_BIGENDIAN)
487     iconv_handle = vlc_iconv_open( "UCS-4BE", "UTF-8" );
488 #else
489     iconv_handle = vlc_iconv_open( "UCS-4LE", "UTF-8" );
490 #endif
491     if( iconv_handle == (vlc_iconv_t)-1 )
492     {
493         msg_Warn( p_filter, "unable to do conversion" );
494         goto error;
495     }
496
497     /* Set up the glyphs for the desired font size.  By definition,
498        p_sys->i_font_size is a valid value, else the initial Create would
499        have failed. Using -1 as a flag to use the freetype-fontsize */
500     if ( i_font_size < 0 )  
501     {
502             FT_Set_Pixel_Sizes( p_sys->p_face, 0, p_sys->i_font_size );
503     }
504     else
505     {
506         i_error = FT_Set_Pixel_Sizes( p_sys->p_face, 0, i_font_size );
507         if( i_error )
508         {
509             msg_Warn( p_filter, "Invalid font size to RenderText, using %d", 
510                       p_sys->i_font_size );
511             FT_Set_Pixel_Sizes( p_sys->p_face, 0, p_sys->i_font_size );
512         }
513     }
514
515     {
516         char *p_in_buffer, *p_out_buffer;
517         size_t i_in_bytes, i_out_bytes, i_out_bytes_left, i_ret;
518         i_in_bytes = strlen( psz_string );
519         i_out_bytes = i_in_bytes * sizeof( uint32_t );
520         i_out_bytes_left = i_out_bytes;
521         p_in_buffer = psz_string;
522         p_out_buffer = (char *)psz_unicode;
523         i_ret = vlc_iconv( iconv_handle, &p_in_buffer, &i_in_bytes,
524                            &p_out_buffer, &i_out_bytes_left );
525
526         vlc_iconv_close( iconv_handle );
527
528         if( i_in_bytes )
529         {
530             msg_Warn( p_filter, "failed to convert string to unicode (%s), "
531                       "bytes left %d", strerror(errno), i_in_bytes );
532             goto error;
533         }
534         *(uint32_t*)p_out_buffer = 0;
535         i_string_length = (i_out_bytes - i_out_bytes_left) / sizeof(uint32_t);
536     }
537
538 #if defined(HAVE_FRIBIDI)
539     {
540         uint32_t *p_fribidi_string;
541         FriBidiCharType base_dir = FRIBIDI_TYPE_ON;
542         p_fribidi_string = malloc( (i_string_length + 1) * sizeof(uint32_t) );
543         fribidi_log2vis( (FriBidiChar*)psz_unicode, i_string_length,
544                          &base_dir, (FriBidiChar*)p_fribidi_string, 0, 0, 0 );
545         free( psz_unicode_orig );
546         psz_unicode = psz_unicode_orig = p_fribidi_string;
547         p_fribidi_string[ i_string_length ] = 0;
548     }
549 #endif
550
551     /* Calculate relative glyph positions and a bounding box for the
552      * entire string */
553     if( !(p_line = NewLine( psz_string )) )
554     {
555         msg_Err( p_filter, "out of memory" );
556         goto error;
557     }
558     p_lines = p_line;
559     i_pen_x = i_pen_y = 0;
560     i_previous = i = 0;
561     psz_line_start = psz_unicode;
562
563 #define face p_sys->p_face
564 #define glyph face->glyph
565
566     while( *psz_unicode )
567     {
568         i_char = *psz_unicode++;
569         if( i_char == '\r' ) /* ignore CR chars wherever they may be */
570         {
571             continue;
572         }
573
574         if( i_char == '\n' )
575         {
576             psz_line_start = psz_unicode;
577             if( !(p_next = NewLine( psz_string )) )
578             {
579                 msg_Err( p_filter, "out of memory" );
580                 goto error;
581             }
582             p_line->p_next = p_next;
583             p_line->i_width = line.xMax;
584             p_line->i_height = face->size->metrics.height >> 6;
585             p_line->pp_glyphs[ i ] = NULL;
586             p_line->i_alpha = i_font_alpha;
587             p_line->i_red = i_red;
588             p_line->i_green = i_green;
589             p_line->i_blue = i_blue;
590             p_prev = p_line;
591             p_line = p_next;
592             result.x = __MAX( result.x, line.xMax );
593             result.y += face->size->metrics.height >> 6;
594             i_pen_x = 0;
595             i_previous = i = 0;
596             line.xMin = line.xMax = line.yMin = line.yMax = 0;
597             i_pen_y += face->size->metrics.height >> 6;
598 #if 0
599             msg_Dbg( p_filter, "Creating new line, i is %d", i );
600 #endif
601             continue;
602         }
603
604         i_glyph_index = FT_Get_Char_Index( face, i_char );
605         if( p_sys->i_use_kerning && i_glyph_index
606             && i_previous )
607         {
608             FT_Vector delta;
609             FT_Get_Kerning( face, i_previous, i_glyph_index,
610                             ft_kerning_default, &delta );
611             i_pen_x += delta.x >> 6;
612
613         }
614         p_line->p_glyph_pos[ i ].x = i_pen_x;
615         p_line->p_glyph_pos[ i ].y = i_pen_y;
616         i_error = FT_Load_Glyph( face, i_glyph_index, FT_LOAD_DEFAULT );
617         if( i_error )
618         {
619             msg_Err( p_filter, "FT_Load_Glyph returned %d", i_error );
620             goto error;
621         }
622         i_error = FT_Get_Glyph( glyph, &tmp_glyph );
623         if( i_error )
624         {
625             msg_Err( p_filter, "FT_Get_Glyph returned %d", i_error );
626             goto error;
627         }
628         FT_Glyph_Get_CBox( tmp_glyph, ft_glyph_bbox_pixels, &glyph_size );
629         i_error = FT_Glyph_To_Bitmap( &tmp_glyph, ft_render_mode_normal, 0, 1);
630         if( i_error ) continue;
631         p_line->pp_glyphs[ i ] = (FT_BitmapGlyph)tmp_glyph;
632
633         /* Do rest */
634         line.xMax = p_line->p_glyph_pos[i].x + glyph_size.xMax -
635             glyph_size.xMin + ((FT_BitmapGlyph)tmp_glyph)->left;
636         if( line.xMax > (int)p_filter->fmt_out.video.i_visible_width - 20 )
637         {
638             p_line->pp_glyphs[ i ] = NULL;
639             FreeLine( p_line );
640             p_line = NewLine( psz_string );
641             if( p_prev ) p_prev->p_next = p_line;
642             else p_lines = p_line;
643
644             while( psz_unicode > psz_line_start && *psz_unicode != ' ' )
645             {
646                 psz_unicode--;
647             }
648             if( psz_unicode == psz_line_start )
649             {
650                 msg_Warn( p_filter, "unbreakable string" );
651                 goto error;
652             }
653             else
654             {
655                 *psz_unicode = '\n';
656             }
657             psz_unicode = psz_line_start;
658             i_pen_x = 0;
659             i_previous = i = 0;
660             line.xMin = line.xMax = line.yMin = line.yMax = 0;
661             continue;
662         }
663         line.yMax = __MAX( line.yMax, glyph_size.yMax );
664         line.yMin = __MIN( line.yMin, glyph_size.yMin );
665
666         i_previous = i_glyph_index;
667         i_pen_x += glyph->advance.x >> 6;
668         i++;
669     }
670
671     p_line->i_width = line.xMax;
672     p_line->i_height = face->size->metrics.height >> 6;
673     p_line->pp_glyphs[ i ] = NULL;
674     p_line->i_alpha = i_font_alpha;
675     p_line->i_red = i_red;
676     p_line->i_green = i_green;
677     p_line->i_blue = i_blue;
678     result.x = __MAX( result.x, line.xMax );
679     result.y += line.yMax - line.yMin;
680
681 #undef face
682 #undef glyph
683
684     p_region_out->i_x = p_region_in->i_x;
685     p_region_out->i_y = p_region_in->i_y;
686
687     Render( p_filter, p_region_out, p_lines, result.x, result.y );
688
689     if( psz_unicode_orig ) free( psz_unicode_orig );
690     FreeLines( p_lines );
691     return VLC_SUCCESS;
692
693  error:
694     if( psz_unicode_orig ) free( psz_unicode_orig );
695     FreeLines( p_lines );
696     return VLC_EGENERIC;
697 }
698
699 static void FreeLine( line_desc_t *p_line )
700 {
701     unsigned int i;
702     for( i = 0; p_line->pp_glyphs[ i ] != NULL; i++ )
703     {
704         FT_Done_Glyph( (FT_Glyph)p_line->pp_glyphs[ i ] );
705     }
706     free( p_line->pp_glyphs );
707     free( p_line->p_glyph_pos );
708     free( p_line );
709 }
710
711 static void FreeLines( line_desc_t *p_lines )
712 {
713     line_desc_t *p_line, *p_next;
714
715     if( !p_lines ) return;
716
717     for( p_line = p_lines; p_line != NULL; p_line = p_next )
718     {
719         p_next = p_line->p_next;
720         FreeLine( p_line );
721     }
722 }
723
724 static line_desc_t *NewLine( byte_t *psz_string )
725 {
726     int i_count;
727     line_desc_t *p_line = malloc( sizeof(line_desc_t) );
728
729     if( !p_line ) return NULL;
730     p_line->i_height = 0;
731     p_line->i_width = 0;
732     p_line->p_next = NULL;
733
734     /* We don't use CountUtf8Characters() here because we are not acutally
735      * sure the string is utf8. Better be safe than sorry. */
736     i_count = strlen( psz_string );
737
738     p_line->pp_glyphs = malloc( sizeof(FT_BitmapGlyph) * ( i_count + 1 ) );
739     if( p_line->pp_glyphs == NULL )
740     {
741         free( p_line );
742         return NULL;
743     }
744     p_line->pp_glyphs[0] = NULL;
745
746     p_line->p_glyph_pos = malloc( sizeof( FT_Vector ) * i_count + 1 );
747     if( p_line->p_glyph_pos == NULL )
748     {
749         free( p_line->pp_glyphs );
750         free( p_line );
751         return NULL;
752     }
753
754     return p_line;
755 }