Finish strings review in misc/ (Refs:#438)
[vlc.git] / modules / misc / win32text.c
1 /*****************************************************************************
2  * win32text.c : Text drawing routines using the TextOut win32 API
3  *****************************************************************************
4  * Copyright (C) 2002 - 2005 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Gildas Bazin <gbazin@videolan.org>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22  *****************************************************************************/
23
24 /*****************************************************************************
25  * Preamble
26  *****************************************************************************/
27 #include <stdlib.h>                                      /* malloc(), free() */
28 #include <string.h>
29
30 #include <vlc/vlc.h>
31 #include <vlc/vout.h>
32 #include "vlc_osd.h"
33 #include "vlc_block.h"
34 #include "vlc_filter.h"
35
36 #include <math.h>
37
38 /*****************************************************************************
39  * Local prototypes
40  *****************************************************************************/
41 static int  Create ( vlc_object_t * );
42 static void Destroy( vlc_object_t * );
43
44 /* The RenderText call maps to pf_render_string, defined in vlc_filter.h */
45 static int RenderText( filter_t *, subpicture_region_t *,
46                        subpicture_region_t * );
47
48 static int Render( filter_t *, subpicture_region_t *, uint8_t *, int, int);
49 static int SetFont( filter_t *, int );
50
51 /*****************************************************************************
52  * Module descriptor
53  *****************************************************************************/
54 #define FONT_TEXT N_("Font")
55 #define FONT_LONGTEXT N_("Filename for the font you want to use")
56 #define FONTSIZE_TEXT N_("Font size in pixels")
57 #define FONTSIZE_LONGTEXT N_("This is the default size of the fonts " \
58      "that will be rendered on the video. " \
59      "If set to something different than 0 this option will override the " \
60      "relative font size. " )
61 #define OPACITY_TEXT N_("Opacity")
62 #define OPACITY_LONGTEXT N_("The opacity (inverse of transparency) of the " \
63      "text that will be rendered on the video. 0 = transparent, " \
64      "255 = totally opaque. " )
65 #define COLOR_TEXT N_("Text default color")
66 #define COLOR_LONGTEXT N_("The color of the text that will be rendered on "\
67   "the video. This must be an hexadecimal (like HTML colors). The first two "\    "chars are for red, then green, then blue. #000000 = black, #FF0000 = red,"\    " #00FF00 = green, #FFFF00 = yellow (red + green), #FFFFFF = white" )
68 #define FONTSIZER_TEXT N_("Relative font size")
69 #define FONTSIZER_LONGTEXT N_("This is the relative default size of the " \
70   "fonts that will be rendered on the video. If absolute font size is set, "\
71    "relative size will be overriden." )
72
73 static int   pi_sizes[] = { 20, 18, 16, 12, 6 };
74 static char *ppsz_sizes_text[] = { N_("Smaller"), N_("Small"), N_("Normal"),
75                                    N_("Large"), N_("Larger") };
76 static int pi_color_values[] = {
77   0x00000000, 0x00808080, 0x00C0C0C0, 0x00FFFFFF, 0x00800000,
78   0x00FF0000, 0x00FF00FF, 0x00FFFF00, 0x00808000, 0x00008000, 0x00008080,
79   0x0000FF00, 0x00800080, 0x00000080, 0x000000FF, 0x0000FFFF };
80
81 static char *ppsz_color_descriptions[] = {
82   N_("Black"), N_("Gray"), N_("Silver"), N_("White"), N_("Maroon"),
83   N_("Red"), N_("Fuchsia"), N_("Yellow"), N_("Olive"), N_("Green"), N_("Teal"),
84   N_("Lime"), N_("Purple"), N_("Navy"), N_("Blue"), N_("Aqua") };
85
86 vlc_module_begin();
87     set_shortname( _("Text renderer"));
88     set_description( _("Win32 font renderer") );
89     set_category( CAT_VIDEO );
90     set_subcategory( SUBCAT_VIDEO_SUBPIC );
91
92     add_integer( "win32text-fontsize", 0, NULL, FONTSIZE_TEXT,
93                  FONTSIZE_LONGTEXT, VLC_TRUE );
94
95     /* opacity valid on 0..255, with default 255 = fully opaque */
96     add_integer_with_range( "win32-opacity", 255, 0, 255, NULL,
97         OPACITY_TEXT, OPACITY_LONGTEXT, VLC_FALSE );
98
99     /* hook to the color values list, with default 0x00ffffff = white */
100     add_integer( "win32text-color", 0x00FFFFFF, NULL, COLOR_TEXT,
101                  COLOR_LONGTEXT, VLC_TRUE );
102         change_integer_list( pi_color_values, ppsz_color_descriptions, 0 );
103
104     add_integer( "win32text-rel-fontsize", 16, NULL, FONTSIZER_TEXT,
105                  FONTSIZER_LONGTEXT, VLC_FALSE );
106         change_integer_list( pi_sizes, ppsz_sizes_text, 0 );
107
108     set_capability( "text renderer", 50 );
109     add_shortcut( "text" );
110     set_callbacks( Create, Destroy );
111 vlc_module_end();
112
113 /*****************************************************************************
114  * filter_sys_t: win32text local data
115  *****************************************************************************/
116 struct filter_sys_t
117 {
118     uint8_t        i_font_opacity;
119     int            i_font_color;
120     int            i_font_size;
121
122     int            i_default_font_size;
123     int            i_display_height;
124
125     HDC hcdc;
126     HFONT hfont;
127     HFONT hfont_bak;
128     int i_logpy;
129 };
130
131 static uint8_t pi_gamma[16] =
132   {0x00, 0x41, 0x52, 0x63, 0x84, 0x85, 0x96, 0xa7, 0xb8, 0xc9,
133    0xca, 0xdb, 0xdc, 0xed, 0xee, 0xff};
134
135 /*****************************************************************************
136  * Create: creates the module
137  *****************************************************************************/
138 static int Create( vlc_object_t *p_this )
139 {
140     filter_t *p_filter = (filter_t *)p_this;
141     filter_sys_t *p_sys;
142     char *psz_fontfile = NULL;
143     vlc_value_t val;
144     HDC hdc;
145
146     /* Allocate structure */
147     p_filter->p_sys = p_sys = malloc( sizeof( filter_sys_t ) );
148     if( !p_sys )
149     {
150         msg_Err( p_filter, "out of memory" );
151         return VLC_ENOMEM;
152     }
153     p_sys->i_font_size = 0;
154     p_sys->i_display_height = 0;
155
156     var_Create( p_filter, "win32text-font",
157                 VLC_VAR_STRING | VLC_VAR_DOINHERIT );
158     var_Create( p_filter, "win32text-fontsize",
159                 VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
160     var_Create( p_filter, "win32text-rel-fontsize",
161                 VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
162     var_Create( p_filter, "win32text-opacity",
163                 VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
164     var_Get( p_filter, "win32text-opacity", &val );
165     p_sys->i_font_opacity = __MAX( __MIN( val.i_int, 255 ), 0 );
166     var_Create( p_filter, "win32text-color",
167                 VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
168     var_Get( p_filter, "win32text-color", &val );
169     p_sys->i_font_color = __MAX( __MIN( val.i_int, 0xFFFFFF ), 0 );
170
171     p_sys->hfont = p_sys->hfont_bak = 0;
172     hdc = GetDC( NULL );
173     p_sys->hcdc = CreateCompatibleDC( hdc );
174     p_sys->i_logpy = GetDeviceCaps( hdc, LOGPIXELSY );
175     ReleaseDC( NULL, hdc );
176     SetBkMode( p_sys->hcdc, TRANSPARENT );
177
178     var_Get( p_filter, "win32text-fontsize", &val );
179     p_sys->i_default_font_size = val.i_int;
180     if( SetFont( p_filter, 0 ) != VLC_SUCCESS ) goto error;
181
182     if( psz_fontfile ) free( psz_fontfile );
183     p_filter->pf_render_text = RenderText;
184     return VLC_SUCCESS;
185
186  error:
187     if( psz_fontfile ) free( psz_fontfile );
188     free( p_sys );
189     return VLC_EGENERIC;
190 }
191
192 /*****************************************************************************
193  * Destroy: destroy the module
194  *****************************************************************************/
195 static void Destroy( vlc_object_t *p_this )
196 {
197     filter_t *p_filter = (filter_t *)p_this;
198     filter_sys_t *p_sys = p_filter->p_sys;
199
200     if( p_sys->hfont_bak ) SelectObject( p_sys->hcdc, p_sys->hfont_bak );
201     if( p_sys->hfont ) DeleteObject( p_sys->hfont );
202     DeleteDC( p_sys->hcdc );
203     free( p_sys );
204 }
205
206 /*****************************************************************************
207  * Render: place string in picture
208  *****************************************************************************
209  * This function merges the previously rendered win32text glyphs into a picture
210  *****************************************************************************/
211 static int Render( filter_t *p_filter, subpicture_region_t *p_region,
212                    uint8_t *p_bitmap, int i_width, int i_height )
213 {
214     uint8_t *p_dst;
215     video_format_t fmt;
216     int i, i_pitch;
217     subpicture_region_t *p_region_tmp;
218     vlc_bool_t b_outline = VLC_TRUE;
219
220     /* Create a new subpicture region */
221     memset( &fmt, 0, sizeof(video_format_t) );
222     fmt.i_chroma = VLC_FOURCC('Y','U','V','P');
223     fmt.i_width = fmt.i_visible_width = i_width + (b_outline ? 4 : 0);
224     fmt.i_height = fmt.i_visible_height = i_height + (b_outline ? 4 : 0);
225     fmt.i_x_offset = fmt.i_y_offset = 0;
226     p_region_tmp = spu_CreateRegion( p_filter, &fmt );
227     if( !p_region_tmp )
228     {
229         msg_Err( p_filter, "cannot allocate SPU region" );
230         return VLC_EGENERIC;
231     }
232
233     /* Build palette */
234     fmt.p_palette->i_entries = 16;
235     for( i = 0; i < fmt.p_palette->i_entries; i++ )
236     {
237         fmt.p_palette->palette[i][0] = pi_gamma[i];
238         fmt.p_palette->palette[i][1] = 128;
239         fmt.p_palette->palette[i][2] = 128;
240         fmt.p_palette->palette[i][3] = pi_gamma[i];
241     }
242
243     p_region->fmt = p_region_tmp->fmt;
244     p_region->picture = p_region_tmp->picture;
245     free( p_region_tmp );
246
247     p_dst = p_region->picture.Y_PIXELS;
248     i_pitch = p_region->picture.Y_PITCH;
249
250     if( b_outline )
251     {
252         memset( p_dst, 0, i_pitch * fmt.i_height );
253         p_dst += p_region->picture.Y_PITCH * 2 + 2;
254     }
255
256     for( i = 0; i < i_height; i++ )
257     {
258         memcpy( p_dst, p_bitmap, i_width );
259         p_bitmap += (i_width+3) & ~3;
260         p_dst += i_pitch;
261     }
262
263     /* Outlining (find something better than nearest neighbour filtering ?) */
264     if( b_outline )
265     {
266         uint8_t *p_top = p_dst; /* Use 1st line as a cache */
267         uint8_t left, current;
268         int x, y;
269
270         p_dst = p_region->picture.Y_PIXELS;
271
272         for( y = 1; y < (int)fmt.i_height - 1; y++ )
273         {
274             memcpy( p_top, p_dst, fmt.i_width );
275             p_dst += i_pitch;
276             left = 0;
277
278             for( x = 1; x < (int)fmt.i_width - 1; x++ )
279             {
280                 current = p_dst[x];
281                 p_dst[x] = ( 4 * (int)p_dst[x] + left + p_top[x] + p_dst[x+1] +
282                              p_dst[x + i_pitch]) / 8;
283                 left = current;
284             }
285         }
286         memset( p_top, 0, fmt.i_width );
287     }
288
289     return VLC_SUCCESS;
290 }
291
292 static int RenderText( filter_t *p_filter, subpicture_region_t *p_region_out,
293                        subpicture_region_t *p_region_in )
294 {
295     filter_sys_t *p_sys = p_filter->p_sys;
296     int i_font_color, i_font_alpha, i_font_size;
297     uint8_t *p_bitmap;
298     TCHAR *psz_string;
299     int i, i_width, i_height;
300     HBITMAP bitmap, bitmap_bak;
301     BITMAPINFO *p_bmi;
302     RECT rect = {0};
303     SIZE size;
304
305     /* Sanity check */
306     if( !p_region_in || !p_region_out ) return VLC_EGENERIC;
307 #ifdef UNICODE
308     psz_string = malloc( (strlen( p_region_in->psz_text )+1) * sizeof(TCHAR) );
309     if( mbstowcs( psz_string, p_region_in->psz_text,
310                   strlen( p_region_in->psz_text ) * sizeof(TCHAR) ) < 0 )
311     {
312         free( psz_string );
313         return VLC_EGENERIC;
314     }
315 #else
316     psz_string = strdup( p_region_in->psz_text );
317 #endif
318     if( !psz_string || !*psz_string ) return VLC_EGENERIC;
319
320     if( p_region_in->p_style )
321     {
322         i_font_color = __MAX( __MIN( p_region_in->p_style->i_font_color, 0xFFFFFF ), 0 );
323         i_font_alpha = __MAX( __MIN( p_region_in->p_style->i_font_alpha, 255 ), 0 );
324         i_font_size  = __MAX( __MIN( p_region_in->p_style->i_font_size, 255 ), 0 );
325     }
326     else
327     {
328         i_font_color = p_sys->i_font_color;
329         i_font_alpha = 255 - p_sys->i_font_opacity;
330         i_font_size = p_sys->i_default_font_size;
331     }
332
333     SetFont( p_filter, i_font_size );
334
335     SetTextColor( p_sys->hcdc, RGB( (i_font_color >> 16) & 0xff,
336                   (i_font_color >> 8) & 0xff, i_font_color & 0xff) );
337
338     GetTextExtentExPoint( p_sys->hcdc, psz_string, _tcslen(psz_string),
339                           0, 0, 0, &size );
340     i_width = rect.right = size.cx; i_height = rect.bottom = size.cy;
341
342     p_bmi = malloc(sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD)*16);
343     memset( p_bmi, 0, sizeof(BITMAPINFOHEADER) );
344     p_bmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
345     p_bmi->bmiHeader.biWidth = (i_width+3) & ~3;
346     p_bmi->bmiHeader.biHeight = - i_height;
347     p_bmi->bmiHeader.biPlanes = 1;
348     p_bmi->bmiHeader.biBitCount = 8;
349     p_bmi->bmiHeader.biCompression = BI_RGB;
350     p_bmi->bmiHeader.biClrUsed = 16;
351
352     for( i = 0; i < 16; i++ )
353     {
354         p_bmi->bmiColors[i].rgbBlue =
355             p_bmi->bmiColors[i].rgbGreen =
356                 p_bmi->bmiColors[i].rgbRed = pi_gamma[i];
357     }
358
359     bitmap = CreateDIBSection( p_sys->hcdc, p_bmi, DIB_RGB_COLORS,
360                                (void **)&p_bitmap, NULL, 0 );
361     if( !bitmap )
362     {
363         msg_Err( p_filter, "could not create bitmap" );
364         return VLC_EGENERIC;
365     }
366
367     bitmap_bak = SelectObject( p_sys->hcdc, bitmap );
368     FillRect( p_sys->hcdc, &rect, (HBRUSH)GetStockObject(BLACK_BRUSH) );
369
370     //TextOut( p_sys->hcdc, 0, 0, psz_string, strlen(psz_string) );
371     if( !DrawText( p_sys->hcdc, psz_string, -1, &rect, 0 ) )
372     {
373         msg_Err( p_filter, "could not draw text" );
374     }
375
376     p_region_out->i_x = p_region_in->i_x;
377     p_region_out->i_y = p_region_in->i_y;
378     Render( p_filter, p_region_out, p_bitmap, i_width, i_height );
379
380     SelectObject( p_sys->hcdc, bitmap_bak );
381     DeleteObject( bitmap );
382     return VLC_SUCCESS;
383 }
384
385 static int SetFont( filter_t *p_filter, int i_size )
386 {
387     filter_sys_t *p_sys = p_filter->p_sys;
388     LOGFONT logfont;
389
390     if( i_size && i_size == p_sys->i_font_size ) return VLC_SUCCESS;
391
392     if( !i_size )
393     {
394         vlc_value_t val;
395
396         if( !p_sys->i_default_font_size &&
397             p_sys->i_display_height == (int)p_filter->fmt_out.video.i_height )
398             return VLC_SUCCESS;
399
400         if( p_sys->i_default_font_size )
401         {
402             i_size = p_sys->i_default_font_size;
403         }
404         else
405         {
406             var_Get( p_filter, "win32text-rel-fontsize", &val );
407             i_size = (int)p_filter->fmt_out.video.i_height / val.i_int;
408             p_filter->p_sys->i_display_height =
409                 p_filter->fmt_out.video.i_height;
410         }
411         if( i_size <= 0 )
412         {
413             msg_Warn( p_filter, "Invalid fontsize, using 12" );
414             i_size = 12;
415         }
416
417         msg_Dbg( p_filter, "Using fontsize: %i", i_size );
418     }
419
420     p_sys->i_font_size = i_size;
421
422     if( p_sys->hfont_bak ) SelectObject( p_sys->hcdc, p_sys->hfont_bak );
423     if( p_sys->hfont ) DeleteObject( p_sys->hfont );
424
425     i_size = i_size * (int64_t)p_sys->i_logpy / 72;
426
427     logfont.lfHeight = i_size;
428     logfont.lfWidth = 0;
429     logfont.lfEscapement = 0;
430     logfont.lfOrientation = 0;
431     logfont.lfWeight = 0;
432     logfont.lfItalic = FALSE;
433     logfont.lfUnderline = FALSE;
434     logfont.lfStrikeOut = FALSE;
435     logfont.lfCharSet = ANSI_CHARSET;
436     logfont.lfOutPrecision = OUT_DEFAULT_PRECIS;
437     logfont.lfClipPrecision = CLIP_DEFAULT_PRECIS;
438     logfont.lfQuality = ANTIALIASED_QUALITY;
439     logfont.lfPitchAndFamily = DEFAULT_PITCH;
440     memcpy( logfont.lfFaceName, _T("Arial"), sizeof(_T("Arial")) );
441
442     p_sys->hfont = CreateFontIndirect( &logfont );
443
444     p_sys->hfont_bak = SelectObject( p_sys->hcdc, p_sys->hfont );
445
446     return VLC_SUCCESS;
447 }