NEON vectorized fi32->s16l audio filter
[vlc.git] / modules / gui / fbosd.c
1 /*****************************************************************************
2  * fbosd.c : framebuffer osd plugin for vlc
3  *****************************************************************************
4  * Copyright (C) 2007-2008, the VideoLAN team
5  * $Id$
6  *
7  * Authors: Jean-Paul Saman
8  * Copied from modules/video_output/fb.c by Samuel Hocevar <sam@zoy.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., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23  *****************************************************************************/
24
25 /*****************************************************************************
26  * Preamble
27  *****************************************************************************/
28 #ifdef HAVE_CONFIG_H
29 # include "config.h"
30 #endif
31
32 #include <vlc_common.h>
33 #include <vlc_plugin.h>
34
35 #include <errno.h>
36 #include <stdlib.h>                                                /* free() */
37 #include <string.h>                                            /* strerror() */
38 #include <fcntl.h>                                                 /* open() */
39 #include <unistd.h>                                               /* close() */
40
41 #include <sys/ioctl.h>
42 #include <sys/mman.h>                                              /* mmap() */
43
44 #include <linux/fb.h>
45
46 #include <vlc_image.h>
47 #include <vlc_interface.h>
48 #include <vlc_input.h>
49 #include <vlc_vout.h>
50 #include <vlc_filter.h>
51 #include <vlc_osd.h>
52 #include <vlc_strings.h>
53
54 #undef FBOSD_BLENDING
55 #undef FBOSD_DEBUG
56
57 /*****************************************************************************
58  * Local prototypes
59  *****************************************************************************/
60 static int  Create    ( vlc_object_t * );
61 static void Destroy   ( vlc_object_t * );
62 static void Run       ( intf_thread_t * );
63
64 static int  Init      ( intf_thread_t * );
65 static void End       ( intf_thread_t * );
66
67 static int  OpenDisplay    ( intf_thread_t * );
68 static void CloseDisplay   ( intf_thread_t * );
69
70 /* Load modules needed for rendering and blending */
71 #if defined(FBOSD_BLENDING)
72 static int  OpenBlending     ( intf_thread_t * );
73 static void CloseBlending    ( intf_thread_t * );
74 #endif
75 static int  OpenTextRenderer ( intf_thread_t * );
76 static void CloseTextRenderer( intf_thread_t * );
77
78 /* Manipulate the overlay buffer */
79 static int  OverlayCallback( vlc_object_t *, char const *,
80                              vlc_value_t, vlc_value_t, void * );
81
82 static picture_t *AllocatePicture( video_format_t * );
83 static void DeAllocatePicture( picture_t *, video_format_t * );
84 static void SetOverlayTransparency( intf_thread_t *,
85                                     bool );
86 static picture_t *LoadImage( intf_thread_t *, video_format_t *,
87                              char * );
88
89 #if defined(FBOSD_BLENDING)
90 static int BlendPicture( intf_thread_t *, video_format_t *,
91                          video_format_t *, picture_t *, picture_t * );
92 #else
93 static picture_t *ConvertImage( intf_thread_t *, picture_t *,
94                                 video_format_t *, video_format_t * );
95 #endif
96 static int RenderPicture( intf_thread_t *, int, int,
97                           picture_t *, picture_t * );
98 static picture_t *RenderText( intf_thread_t *, const char *,
99                               text_style_t *, video_format_t * );
100
101 #define DEVICE_TEXT N_("Framebuffer device")
102 #define DEVICE_LONGTEXT N_( \
103     "Framebuffer device to use for rendering (usually /dev/fb0).")
104
105 #define ASPECT_RATIO_TEXT N_("Video aspect ratio")
106 #define ASPECT_RATIO_LONGTEXT N_( \
107     "Aspect ratio of the video image (4:3, 16:9). Default is square pixels." )
108
109 #define FBOSD_IMAGE_TEXT N_("Image file")
110 #define FBOSD_IMAGE_LONGTEXT N_( \
111     "Filename of image file to use on the overlay framebuffer." )
112
113 #define ALPHA_TEXT N_("Transparency of the image")
114 #define ALPHA_LONGTEXT N_( "Transparency value of the new image " \
115     "used in blending. By default it set to fully opaque (255). " \
116     "(from 0 for full transparency to 255 for full opacity)" )
117
118 #define FBOSD_TEXT N_("Text")
119 #define FBOSD_LONGTEXT N_( "Text to display on the overlay framebuffer." )
120
121 #define POSX_TEXT N_("X coordinate")
122 #define POSX_LONGTEXT N_("X coordinate of the rendered image")
123
124 #define POSY_TEXT N_("Y coordinate")
125 #define POSY_LONGTEXT N_("Y coordinate of the rendered image")
126
127 #define POS_TEXT N_("Position")
128 #define POS_LONGTEXT N_( \
129   "You can enforce the picture position on the overlay " \
130   "(0=center, 1=left, 2=right, 4=top, 8=bottom, you can " \
131   "also use combinations of these values, e.g. 6=top-right).")
132
133 #define OPACITY_TEXT N_("Opacity")
134 #define OPACITY_LONGTEXT N_("Opacity (inverse of transparency) of " \
135     "overlayed text. 0 = transparent, 255 = totally opaque. " )
136
137 #define SIZE_TEXT N_("Font size, pixels")
138 #define SIZE_LONGTEXT N_("Font size, in pixels. Default is -1 (use default " \
139     "font size)." )
140
141 #define COLOR_TEXT N_("Color")
142 #define COLOR_LONGTEXT N_("Color of the text that will be rendered on "\
143     "the video. This must be an hexadecimal (like HTML colors). The first two "\
144     "chars are for red, then green, then blue. #000000 = black, #FF0000 = red,"\
145     " #00FF00 = green, #FFFF00 = yellow (red + green), #FFFFFF = white" )
146
147 #define CLEAR_TEXT N_( "Clear overlay framebuffer" )
148 #define CLEAR_LONGTEXT N_( "The displayed overlay images is cleared by " \
149     "making the overlay completely transparent. All previously rendered " \
150     "images and text will be cleared from the cache." )
151
152 #define RENDER_TEXT N_( "Render text or image" )
153 #define RENDER_LONGTEXT N_( "Render the image or text in current overlay " \
154     "buffer." )
155
156 #define DISPLAY_TEXT N_( "Display on overlay framebuffer" )
157 #define DISPLAY_LONGTEXT N_( "All rendered images and text will be " \
158     "displayed on the overlay framebuffer." )
159
160 static const int pi_pos_values[] = { 0, 1, 2, 4, 8, 5, 6, 9, 10 };
161 static const char *const ppsz_pos_descriptions[] =
162 { N_("Center"), N_("Left"), N_("Right"), N_("Top"), N_("Bottom"),
163   N_("Top-Left"), N_("Top-Right"), N_("Bottom-Left"), N_("Bottom-Right") };
164
165 static const int pi_color_values[] = {
166                0xf0000000, 0x00000000, 0x00808080, 0x00C0C0C0,
167                0x00FFFFFF, 0x00800000, 0x00FF0000, 0x00FF00FF, 0x00FFFF00,
168                0x00808000, 0x00008000, 0x00008080, 0x0000FF00, 0x00800080,
169                0x00000080, 0x000000FF, 0x0000FFFF};
170 static const char *const ppsz_color_descriptions[] = {
171                N_("Default"), N_("Black"),
172                N_("Gray"), N_("Silver"), N_("White"), N_("Maroon"), N_("Red"),
173                N_("Fuchsia"), N_("Yellow"), N_("Olive"), N_("Green"),
174                N_("Teal"), N_("Lime"), N_("Purple"), N_("Navy"), N_("Blue"),
175                N_("Aqua") };
176
177 vlc_module_begin ()
178     set_shortname( "fbosd" )
179     set_category( CAT_INTERFACE )
180     set_subcategory( SUBCAT_INTERFACE_MAIN )
181
182     add_file( "fbosd-dev", "/dev/fb0", NULL, DEVICE_TEXT, DEVICE_LONGTEXT,
183               false )
184     add_string( "fbosd-aspect-ratio", "", NULL, ASPECT_RATIO_TEXT,
185                 ASPECT_RATIO_LONGTEXT, true )
186
187     add_string( "fbosd-image", NULL, NULL, FBOSD_IMAGE_TEXT,
188                 FBOSD_IMAGE_LONGTEXT, true )
189     add_string( "fbosd-text", NULL, NULL, FBOSD_TEXT,
190                 FBOSD_LONGTEXT, true )
191
192     add_integer_with_range( "fbosd-alpha", 255, 0, 255, NULL, ALPHA_TEXT,
193                             ALPHA_LONGTEXT, true )
194
195     set_section( N_("Position"), NULL )
196     add_integer( "fbosd-x", 0, NULL, POSX_TEXT,
197                  POSX_LONGTEXT, false )
198     add_integer( "fbosd-y", 0, NULL, POSY_TEXT,
199                  POSY_LONGTEXT, false )
200     add_integer( "fbosd-position", 8, NULL, POS_TEXT, POS_LONGTEXT, true )
201         change_integer_list( pi_pos_values, ppsz_pos_descriptions, NULL );
202
203     set_section( N_("Font"), NULL )
204     add_integer_with_range( "fbosd-font-opacity", 255, 0, 255, NULL,
205         OPACITY_TEXT, OPACITY_LONGTEXT, false )
206     add_integer( "fbosd-font-color", 0x00FFFFFF, NULL, COLOR_TEXT, COLOR_LONGTEXT,
207                  false )
208         change_integer_list( pi_color_values, ppsz_color_descriptions, NULL );
209     add_integer( "fbosd-font-size", -1, NULL, SIZE_TEXT, SIZE_LONGTEXT,
210                  false )
211
212     set_section( N_("Commands"), NULL )
213     add_bool( "fbosd-clear", false, NULL, CLEAR_TEXT, CLEAR_LONGTEXT, true )
214     add_bool( "fbosd-render", false, NULL, RENDER_TEXT, RENDER_LONGTEXT, true )
215     add_bool( "fbosd-display", false, NULL, DISPLAY_TEXT, DISPLAY_LONGTEXT, true )
216
217     set_description( N_("GNU/Linux osd/overlay framebuffer interface") )
218     set_capability( "interface", 10 )
219     set_callbacks( Create, Destroy )
220 vlc_module_end ()
221
222 /*****************************************************************************
223  * fbosd_render_t: render descriptor
224  *****************************************************************************/
225 struct fbosd_render_t
226 {
227 #define FBOSD_RENDER_IMAGE 0
228 #define FBOSD_RENDER_TEXT  1
229     int             i_type;
230
231 #define FBOSD_STATE_FREE     0
232 #define FBOSD_STATE_RESERVED 1
233 #define FBOSD_STATE_RENDER   2
234     int             i_state;
235
236     /* Font style */
237     text_style_t*   p_text_style;                            /* font control */
238     char            *psz_string;
239
240     /* Position */
241     bool            b_absolute;
242     int             i_x;
243     int             i_y;
244     int             i_pos;
245     int             i_alpha;                      /* transparency for images */
246 };
247 #define FBOSD_RENDER_MAX 10
248
249 /*****************************************************************************
250  * intf_sys_t: interface framebuffer method descriptor
251  *****************************************************************************/
252 struct intf_sys_t
253 {
254     /* Framebuffer information */
255     int                         i_fd;                       /* device handle */
256     struct fb_var_screeninfo    var_info;        /* current mode information */
257     bool                  b_pan;     /* does device supports panning ? */
258     struct fb_cmap              fb_cmap;                /* original colormap */
259     uint16_t                    *p_palette;              /* original palette */
260
261     /* Overlay framebuffer format */
262     video_format_t  fmt_out;
263     picture_t       *p_overlay;
264     size_t          i_page_size;                                /* page size */
265     int             i_width;
266     int             i_height;
267     int             i_aspect;
268     int             i_bytes_per_pixel;
269
270     /* Image and Picture rendering */
271     image_handler_t *p_image;
272 #if defined(FBOSD_BLENDING)
273     filter_t *p_blend;                              /* alpha blending module */
274 #endif
275     filter_t *p_text;                                /* text renderer module */
276
277     /* Render */
278     struct fbosd_render_t render[FBOSD_RENDER_MAX];
279
280     /* Font style */
281     text_style_t    *p_style;                                /* font control */
282
283     /* Position */
284     bool      b_absolute;
285     int       i_x;
286     int       i_y;
287     int       i_pos;
288
289     int       i_alpha;                      /* transparency for images */
290
291     /* commands control */
292     bool      b_need_update;    /* update display with \overlay buffer */
293     bool      b_clear;      /* clear overlay buffer make it tranparent */
294     bool      b_render;   /* render an image or text in overlay buffer */
295 };
296
297 /*****************************************************************************
298  * Create: allocates FB interface thread output method
299  *****************************************************************************/
300 static int Create( vlc_object_t *p_this )
301 {
302     intf_thread_t *p_intf = (intf_thread_t *)p_this;
303     intf_sys_t    *p_sys;
304     char          *psz_aspect;
305     char          *psz_tmp;
306     int i;
307
308     /* Allocate instance and initialize some members */
309     p_intf->p_sys = p_sys = calloc( 1, sizeof( intf_sys_t ) );
310     if( !p_intf->p_sys )
311         return VLC_ENOMEM;
312
313     p_sys->p_style = text_style_New();
314     if( !p_sys->p_style )
315     {
316         free( p_intf->p_sys );
317         return VLC_ENOMEM;
318     }
319
320     p_intf->pf_run = Run;
321
322     p_sys->p_image = image_HandlerCreate( p_this );
323     if( !p_sys->p_image )
324     {
325         text_style_Delete( p_sys->p_style );
326         free( p_sys );
327         return VLC_ENOMEM;
328     }
329
330     p_sys->i_alpha = var_CreateGetIntegerCommand( p_intf, "fbosd-alpha" );
331     var_AddCallback( p_intf, "fbosd-alpha", OverlayCallback, NULL );
332
333     p_sys->i_aspect = -1;
334     psz_aspect =
335             var_CreateGetNonEmptyString( p_intf, "fbosd-aspect-ratio" );
336     if( psz_aspect )
337     {
338         char *psz_parser = strchr( psz_aspect, ':' );
339
340         if( psz_parser )
341         {
342             *psz_parser++ = '\0';
343             p_sys->i_aspect = ( atoi( psz_aspect )
344                               * VOUT_ASPECT_FACTOR ) / atoi( psz_parser );
345             p_sys->fmt_out.i_aspect = p_sys->i_aspect;
346         }
347         msg_Dbg( p_intf, "using aspect ratio %d:%d",
348                   atoi( psz_aspect ), atoi( psz_parser ) );
349
350         free( psz_aspect );
351     }
352
353     /* Use PAL by default */
354     p_sys->i_width  = p_sys->fmt_out.i_width  = 704;
355     p_sys->i_height = p_sys->fmt_out.i_height = 576;
356
357     psz_tmp = var_CreateGetNonEmptyStringCommand( p_intf, "fbosd-image" );
358     var_AddCallback( p_intf, "fbosd-image", OverlayCallback, NULL );
359     if( psz_tmp && *psz_tmp )
360     {
361         p_sys->render[0].i_type = FBOSD_RENDER_IMAGE;
362         p_sys->render[0].i_state = FBOSD_STATE_RENDER;
363         p_sys->render[0].psz_string = strdup( psz_tmp );
364     }
365     free( psz_tmp );
366
367     psz_tmp = var_CreateGetNonEmptyStringCommand( p_intf, "fbosd-text" );
368     var_AddCallback( p_intf, "fbosd-text", OverlayCallback, NULL );
369     if( psz_tmp && *psz_tmp )
370     {
371         p_sys->render[1].i_type = FBOSD_RENDER_TEXT;
372         p_sys->render[1].i_state = FBOSD_STATE_RENDER;
373         p_sys->render[1].psz_string = strdup( psz_tmp );
374     }
375     free( psz_tmp );
376
377     p_sys->i_pos = var_CreateGetIntegerCommand( p_intf, "fbosd-position" );
378     p_sys->i_x = var_CreateGetIntegerCommand( p_intf, "fbosd-x" );
379     p_sys->i_y = var_CreateGetIntegerCommand( p_intf, "fbosd-y" );
380
381     var_AddCallback( p_intf, "fbosd-position", OverlayCallback, NULL );
382     var_AddCallback( p_intf, "fbosd-x", OverlayCallback, NULL );
383     var_AddCallback( p_intf, "fbosd-y", OverlayCallback, NULL );
384
385     p_sys->p_style->i_font_size =
386             var_CreateGetIntegerCommand( p_intf, "fbosd-font-size" );
387     p_sys->p_style->i_font_color =
388             var_CreateGetIntegerCommand( p_intf, "fbosd-font-color" );
389     p_sys->p_style->i_font_alpha = 255 -
390             var_CreateGetIntegerCommand( p_intf, "fbosd-font-opacity" );
391
392     var_AddCallback( p_intf, "fbosd-font-color", OverlayCallback, NULL );
393     var_AddCallback( p_intf, "fbosd-font-size", OverlayCallback, NULL );
394     var_AddCallback( p_intf, "fbosd-font-opacity", OverlayCallback, NULL );
395
396     for( i = 0; i < FBOSD_RENDER_MAX; i++ )
397         p_sys->render[i].p_text_style = text_style_New();
398
399     p_sys->b_clear = var_CreateGetBoolCommand( p_intf, "fbosd-clear" );
400     p_sys->b_render = var_CreateGetBoolCommand( p_intf, "fbosd-render" );
401     p_sys->b_need_update = var_CreateGetBoolCommand( p_intf, "fbosd-display" );
402
403     var_AddCallback( p_intf, "fbosd-clear", OverlayCallback, NULL );
404     var_AddCallback( p_intf, "fbosd-render", OverlayCallback, NULL );
405     var_AddCallback( p_intf, "fbosd-display", OverlayCallback, NULL );
406
407     /* Check if picture position was overridden */
408     p_sys->b_absolute = true;
409     if( ( p_sys->i_x >= 0 ) && ( p_sys->i_y >= 0 ) )
410     {
411         p_sys->b_absolute = false;
412         p_sys->i_y = (p_sys->i_y < p_sys->i_height) ?
413                         p_sys->i_y : p_sys->i_height;
414         p_sys->i_x = (p_sys->i_x < p_sys->i_width) ?
415                         p_sys->i_x : p_sys->i_width;
416     }
417
418     p_sys->render[0].i_x = p_sys->render[1].i_x = p_sys->i_x;
419     p_sys->render[0].i_y = p_sys->render[1].i_y = p_sys->i_y;
420     p_sys->render[0].i_pos = p_sys->render[1].i_pos = p_sys->i_pos;
421     p_sys->render[0].i_alpha = p_sys->render[1].i_alpha = p_sys->i_alpha;
422
423     /* Initialize framebuffer */
424     if( OpenDisplay( p_intf ) )
425     {
426         Destroy( VLC_OBJECT(p_intf) );
427         return VLC_EGENERIC;
428     }
429
430     Init( p_intf );
431
432 #if defined(FBOSD_BLENDING)
433     /* Load the blending module */
434     if( OpenBlending( p_intf ) )
435     {
436         msg_Err( p_intf, "Unable to load image blending module" );
437         Destroy( VLC_OBJECT(p_intf) );
438         return VLC_EGENERIC;
439     }
440 #endif
441
442     /* Load text renderer module */
443     if( OpenTextRenderer( p_intf ) )
444     {
445         msg_Err( p_intf, "Unable to load text rendering module" );
446         Destroy( VLC_OBJECT(p_intf) );
447         return VLC_EGENERIC;
448     }
449
450     p_sys->b_render = true;
451     p_sys->b_need_update = true;
452
453     return VLC_SUCCESS;
454 }
455
456 /*****************************************************************************
457  * Destroy: destroy FB interface thread output method
458  *****************************************************************************
459  * Terminate an output method created by Create
460  *****************************************************************************/
461 static void Destroy( vlc_object_t *p_this )
462 {
463     intf_thread_t *p_intf = (intf_thread_t *)p_this;
464     intf_sys_t *p_sys = p_intf->p_sys;
465     int i;
466
467
468     p_sys->b_need_update = false;
469     p_sys->b_render = false;
470     p_sys->b_clear = false;
471
472     var_DelCallback( p_intf, "fbosd-alpha", OverlayCallback, NULL );
473     var_Destroy( p_intf, "fbosd-alpha" );
474
475     var_DelCallback( p_intf, "fbosd-x", OverlayCallback, NULL );
476     var_DelCallback( p_intf, "fbosd-y", OverlayCallback, NULL );
477     var_DelCallback( p_intf, "fbosd-position", OverlayCallback, NULL );
478     var_DelCallback( p_intf, "fbosd-image", OverlayCallback, NULL );
479     var_DelCallback( p_intf, "fbosd-text", OverlayCallback, NULL );
480     var_DelCallback( p_intf, "fbosd-font-size", OverlayCallback, NULL );
481     var_DelCallback( p_intf, "fbosd-font-color", OverlayCallback, NULL );
482     var_DelCallback( p_intf, "fbosd-font-opacity", OverlayCallback, NULL );
483     var_DelCallback( p_intf, "fbosd-clear", OverlayCallback, NULL );
484     var_DelCallback( p_intf, "fbosd-render", OverlayCallback, NULL );
485     var_DelCallback( p_intf, "fbosd-display", OverlayCallback, NULL );
486
487     var_Destroy( p_intf, "fbosd-x" );
488     var_Destroy( p_intf, "fbosd-y" );
489     var_Destroy( p_intf, "fbosd-position" );
490     var_Destroy( p_intf, "fbosd-image" );
491     var_Destroy( p_intf, "fbosd-text" );
492     var_Destroy( p_intf, "fbosd-font-size" );
493     var_Destroy( p_intf, "fbosd-font-color" );
494     var_Destroy( p_intf, "fbosd-font-opacity" );
495     var_Destroy( p_intf, "fbosd-clear" );
496     var_Destroy( p_intf, "fbosd-render" );
497     var_Destroy( p_intf, "fbosd-display" );
498
499     var_Destroy( p_intf, "fbosd-aspect-ratio" );
500
501     CloseDisplay( p_intf );
502
503     for( i = 0; i < FBOSD_RENDER_MAX; i++ )
504     {
505         free( p_sys->render[i].psz_string );
506         p_sys->render[i].i_state = FBOSD_STATE_FREE;
507         text_style_Delete( p_sys->render[i].p_text_style );
508     }
509
510 #if defined(FBOSD_BLENDING)
511     if( p_sys->p_blend ) CloseBlending( p_intf );
512 #endif
513     if( p_sys->p_text )  CloseTextRenderer( p_intf );
514
515     if( p_sys->p_image )
516         image_HandlerDelete( p_sys->p_image );
517     if( p_sys->p_overlay )
518         picture_Release( p_sys->p_overlay );
519
520     text_style_Delete( p_sys->p_style );
521     free( p_sys );
522 }
523
524 #if defined(FBOSD_BLENDING)
525 static int OpenBlending( intf_thread_t *p_intf )
526 {
527     if( p_intf->p_sys->p_blend ) return VLC_EGENERIC;
528
529     p_intf->p_sys->p_blend =
530             vlc_object_create( p_intf, sizeof(filter_t) );
531     vlc_object_attach( p_intf->p_sys->p_blend, p_intf );
532     p_intf->p_sys->p_blend->fmt_out.video.i_x_offset =
533         p_intf->p_sys->p_blend->fmt_out.video.i_y_offset = 0;
534     p_intf->p_sys->p_blend->fmt_out.video.i_aspect =
535             p_intf->p_sys->fmt_out.i_aspect;
536     p_intf->p_sys->p_blend->fmt_out.video.i_chroma =
537             p_intf->p_sys->fmt_out.i_chroma;
538     if( config_GetInt( p_intf, "freetype-yuvp" ) )
539         p_intf->p_sys->p_blend->fmt_in.video.i_chroma =
540                 VLC_CODEC_YUVP;
541     else
542         p_intf->p_sys->p_blend->fmt_in.video.i_chroma =
543                 VLC_CODEC_YUVA;
544
545     p_intf->p_sys->p_blend->p_module =
546         module_need( p_intf->p_sys->p_blend, "video blending", NULL, false );
547
548     if( !p_intf->p_sys->p_blend->p_module )
549         return VLC_EGENERIC;
550
551     return VLC_SUCCESS;
552 }
553
554 static void CloseBlending( intf_thread_t *p_intf )
555 {
556     if( p_intf->p_sys->p_blend )
557     {
558         if( p_intf->p_sys->p_blend->p_module )
559             module_unneed( p_intf->p_sys->p_blend,
560                            p_intf->p_sys->p_blend->p_module );
561
562         vlc_object_detach( p_intf->p_sys->p_blend );
563         vlc_object_release( p_intf->p_sys->p_blend );
564     }
565 }
566 #endif
567
568 static int OpenTextRenderer( intf_thread_t *p_intf )
569 {
570     char *psz_modulename = NULL;
571
572     if( p_intf->p_sys->p_text ) return VLC_EGENERIC;
573
574     p_intf->p_sys->p_text =
575             vlc_object_create( p_intf, sizeof(filter_t) );
576     vlc_object_attach( p_intf->p_sys->p_text, p_intf );
577
578     p_intf->p_sys->p_text->fmt_out.video.i_width =
579         p_intf->p_sys->p_text->fmt_out.video.i_visible_width =
580         p_intf->p_sys->i_width;
581     p_intf->p_sys->p_text->fmt_out.video.i_height =
582         p_intf->p_sys->p_text->fmt_out.video.i_visible_height =
583         p_intf->p_sys->i_height;
584
585     psz_modulename = var_CreateGetString( p_intf, "text-renderer" );
586     if( psz_modulename && *psz_modulename )
587     {
588         p_intf->p_sys->p_text->p_module =
589             module_need( p_intf->p_sys->p_text, "text renderer",
590                             psz_modulename, true );
591     }
592     if( !p_intf->p_sys->p_text->p_module )
593     {
594         p_intf->p_sys->p_text->p_module =
595             module_need( p_intf->p_sys->p_text, "text renderer", NULL, false );
596     }
597     free( psz_modulename );
598
599     if( !p_intf->p_sys->p_text->p_module )
600         return VLC_EGENERIC;
601
602     return VLC_SUCCESS;
603 }
604
605 static void CloseTextRenderer( intf_thread_t *p_intf )
606 {
607     if( p_intf->p_sys->p_text )
608     {
609         if( p_intf->p_sys->p_text->p_module )
610             module_unneed( p_intf->p_sys->p_text,
611                            p_intf->p_sys->p_text->p_module );
612
613         vlc_object_detach( p_intf->p_sys->p_text );
614         vlc_object_release( p_intf->p_sys->p_text );
615     }
616 }
617
618 /*****************************************************************************
619  * AllocatePicture:
620  * allocate a picture buffer for use with the overlay fb.
621  *****************************************************************************/
622 static picture_t *AllocatePicture( video_format_t *p_fmt )
623 {
624     picture_t *p_picture = picture_New( p_fmt->i_chroma,
625                                         p_fmt->i_width, p_fmt->i_height,
626                                         p_fmt->i_aspect );
627     if( !p_picture )
628         return NULL;
629
630     if( !p_fmt->p_palette &&
631         ( p_fmt->i_chroma == VLC_CODEC_YUVP ) )
632     {
633         p_fmt->p_palette = malloc( sizeof(video_palette_t) );
634         if( !p_fmt->p_palette )
635         {
636             picture_Release( p_picture );
637             return NULL;
638         }
639     }
640     else
641     {
642         p_fmt->p_palette = NULL;
643     }
644
645     return p_picture;
646 }
647
648 /*****************************************************************************
649  * DeAllocatePicture:
650  * Deallocate a picture buffer and free all associated memory.
651  *****************************************************************************/
652 static void DeAllocatePicture( picture_t *p_pic, video_format_t *p_fmt )
653 {
654     if( p_fmt )
655     {
656         free( p_fmt->p_palette );
657         p_fmt->p_palette = NULL;
658     }
659
660     if( p_pic )
661         picture_Release( p_pic );
662 }
663
664 /*****************************************************************************
665  * SetOverlayTransparency: Set the transparency for this overlay fb,
666  * - true is make transparent
667  * - false is make non tranparent
668  *****************************************************************************/
669 static void SetOverlayTransparency( intf_thread_t *p_intf,
670                                     bool b_transparent )
671 {
672     intf_sys_t *p_sys = p_intf->p_sys;
673     size_t i_size = p_sys->fmt_out.i_width * p_sys->fmt_out.i_height
674                         * p_sys->i_bytes_per_pixel;
675     size_t i_page_size = (p_sys->i_page_size > i_size) ?
676                             i_size : p_sys->i_page_size;
677
678     if( p_sys->p_overlay )
679     {
680         msg_Dbg( p_intf, "Make overlay %s",
681                  b_transparent ? "transparent" : "opaque" );
682         if( b_transparent )
683             memset( p_sys->p_overlay->p[0].p_pixels, 0xFF, i_page_size );
684         else
685             memset( p_sys->p_overlay->p[0].p_pixels, 0x00, i_page_size );
686     }
687 }
688
689 #if defined(FBOSD_BLENDING)
690 /*****************************************************************************
691  * BlendPicture: Blend two pictures together..
692  *****************************************************************************/
693 static int BlendPicture( intf_thread_t *p_intf, video_format_t *p_fmt_src,
694                          video_format_t *p_fmt_dst, picture_t *p_pic_src,
695                          picture_t *p_pic_dst )
696 {
697     intf_sys_t *p_sys = p_intf->p_sys;
698     if( p_sys->p_blend && p_sys->p_blend->p_module )
699     {
700         int i_x_offset = p_sys->i_x;
701         int i_y_offset = p_sys->i_y;
702
703         memcpy( &p_sys->p_blend->fmt_in.video, p_fmt_src, sizeof( video_format_t ) );
704
705         /* Update the output picture size */
706         p_sys->p_blend->fmt_out.video.i_width =
707             p_sys->p_blend->fmt_out.video.i_visible_width =
708                 p_fmt_dst->i_width;
709         p_sys->p_blend->fmt_out.video.i_height =
710             p_sys->p_blend->fmt_out.video.i_visible_height =
711                 p_fmt_dst->i_height;
712
713         i_x_offset = __MAX( i_x_offset, 0 );
714         i_y_offset = __MAX( i_y_offset, 0 );
715
716         p_sys->p_blend->pf_video_blend( p_sys->p_blend, p_pic_dst,
717             p_pic_src, p_pic_dst, i_x_offset, i_y_offset,
718             p_sys->i_alpha );
719
720         return VLC_SUCCESS;
721     }
722     return VLC_EGENERIC;
723 }
724
725 static int InvertAlpha( intf_thread_t *p_intf, picture_t **p_pic, video_format_t fmt )
726 {
727     uint8_t *p_begin = NULL, *p_end = NULL;
728     uint8_t i_skip = 0;
729
730     if( *p_pic && ((*p_pic)->i_planes != 1) )
731     {
732         msg_Err( p_intf,
733                  "cannot invert alpha channel too many planes %d (only 1 supported)",
734                  (*p_pic)->i_planes );
735         return VLC_EGENERIC;
736     }
737
738     switch( fmt.i_chroma )
739     {
740         case VLC_CODEC_RGB24:
741             p_begin = (uint8_t *)(*p_pic)->p[Y_PLANE].p_pixels;
742             p_end   = (uint8_t *)(*p_pic)->p[Y_PLANE].p_pixels +
743                       ( fmt.i_height * (*p_pic)->p[Y_PLANE].i_pitch );
744             i_skip = 3;
745             break;
746         case VLC_CODEC_RGB32:
747             p_begin = (uint8_t *)(*p_pic)->p[Y_PLANE].p_pixels;
748             p_end   = (uint8_t *)(*p_pic)->p[Y_PLANE].p_pixels +
749                       ( fmt.i_height * (*p_pic)->p[Y_PLANE].i_pitch );
750             i_skip = 4;
751             break;
752         default:
753             msg_Err( p_intf, "cannot invert alpha channel chroma not supported %4.4s",
754                     (char *)&fmt.i_chroma );
755             return VLC_EGENERIC;
756     }
757
758     for( ; p_begin < p_end; p_begin += i_skip )
759     {
760         uint8_t i_opacity = 0;
761
762         if( *p_begin != 0xFF )
763             i_opacity = 255 - *p_begin;
764         *p_begin = i_opacity;
765     }
766     /* end of kludge */
767     return VLC_SUCCESS;
768 }
769 #endif
770
771 /*****************************************************************************
772  * RenderPicture: Render the picture into the p_dest buffer.
773  * We don't take transparent pixels into account, so we don't have to blend
774  * the two images together.
775  *****************************************************************************/
776 static int RenderPicture( intf_thread_t *p_intf, int i_x_offset, int i_y_offset,
777                           picture_t *p_src, picture_t *p_dest )
778 {
779     int i;
780     VLC_UNUSED( p_intf );
781
782     if( !p_dest && !p_src ) return VLC_EGENERIC;
783
784     for( i = 0; i < p_src->i_planes ; i++ )
785     {
786         if( p_src->p[i].i_pitch == p_dest->p[i].i_pitch )
787         {
788             /* There are margins, but with the same width : perfect ! */
789             vlc_memcpy( p_dest->p[i].p_pixels, p_src->p[i].p_pixels,
790                         p_src->p[i].i_pitch * p_src->p[i].i_visible_lines );
791         }
792         else
793         {
794             /* We need to proceed line by line */
795             uint8_t *p_in  = p_src->p[i].p_pixels;
796             uint8_t *p_out = p_dest->p[i].p_pixels;
797
798             int i_x = i_x_offset * p_src->p[i].i_pixel_pitch;
799             int i_x_clip, i_y_clip;
800
801             /* Check boundaries, clip the image if necessary */
802             i_x_clip = ( i_x + p_src->p[i].i_visible_pitch ) - p_dest->p[i].i_visible_pitch;
803             i_x_clip = ( i_x_clip > 0 ) ? i_x_clip : 0;
804
805             i_y_clip = ( i_y_offset + p_src->p[i].i_visible_lines ) - p_dest->p[i].i_visible_lines;
806             i_y_clip = ( i_y_clip > 0 ) ? i_y_clip : 0;
807 #if defined(FBOSD_DEBUG)
808             msg_Dbg( p_intf, "i_pitch (%d,%d), (%d,%d)/(%d,%d)",
809                      p_dest->p[i].i_visible_pitch, p_src->p[i].i_visible_pitch,
810                      i_x_offset, i_y_offset, i_x, i_x_clip );
811 #endif
812             if( ( i_y_offset <= p_dest->p[i].i_visible_lines ) &&
813                 ( i_x <= p_dest->p[i].i_visible_pitch ) )
814             {
815                 int i_line;
816
817                 p_out += ( i_y_offset * p_dest->p[i].i_pitch );
818                 for( i_line = 0; i_line < ( p_src->p[i].i_visible_lines - i_y_clip ); i_line++ )
819                 {
820                     vlc_memcpy( p_out + i_x, p_in,
821                                 p_src->p[i].i_visible_pitch - i_x_clip );
822                     p_in += p_src->p[i].i_pitch;
823                     p_out += p_dest->p[i].i_pitch;
824                 }
825             }
826         }
827     }
828     return VLC_SUCCESS;
829 }
830
831 /*****************************************************************************
832  * RenderText - Render text to the desired picture format
833  *****************************************************************************/
834 static picture_t *RenderText( intf_thread_t *p_intf, const char *psz_string,
835                               text_style_t *p_style, video_format_t *p_fmt )
836 {
837     intf_sys_t *p_sys = p_intf->p_sys;
838     subpicture_region_t *p_region;
839     picture_t *p_dest = NULL;
840
841     if( !psz_string ) return p_dest;
842
843     if( p_sys->p_text && p_sys->p_text->p_module )
844     {
845         video_format_t fmt;
846
847         memset( &fmt, 0, sizeof(fmt) );
848         fmt.i_chroma = VLC_CODEC_TEXT;
849         fmt.i_aspect = 0;
850         fmt.i_width  = fmt.i_visible_width = 0;
851         fmt.i_height = fmt.i_visible_height = 0;
852         fmt.i_x_offset = 0;
853         fmt.i_y_offset = 0;
854
855         p_region = subpicture_region_New( &fmt );
856         if( !p_region )
857             return p_dest;
858
859         p_region->psz_text = strdup( psz_string );
860         if( !p_region->psz_text )
861         {
862             subpicture_region_Delete( p_region );
863             return NULL;
864         }
865         p_region->p_style = text_style_Duplicate( p_style );
866         p_region->i_align = OSD_ALIGN_LEFT | OSD_ALIGN_TOP;
867
868         if( p_sys->p_text->pf_render_text )
869         {
870             video_format_t fmt_out;
871
872             memset( &fmt_out, 0, sizeof(video_format_t) );
873
874             p_sys->p_text->pf_render_text( p_sys->p_text,
875                                            p_region, p_region );
876
877 #if defined(FBOSD_BLENDING)
878             fmt_out = p_region->fmt;
879             fmt_out.i_bits_per_pixel = 32;
880             vlc_memcpy( p_fmt, &fmt_out, sizeof(video_format_t) );
881
882             /* FIXME not needed to copy the picture anymore no ? */
883             p_dest = AllocatePicture( VLC_OBJECT(p_intf), &fmt_out );
884             if( !p_dest )
885             {
886                 subpicture_region_Delete( p_region );
887                 return NULL;
888             }
889             picture_Copy( p_dest, p_region->p_picture );
890 #else
891             fmt_out.i_chroma = p_fmt->i_chroma;
892             p_dest = ConvertImage( p_intf, p_region->p_picture,
893                                    &p_region->fmt, &fmt_out );
894 #endif
895             subpicture_region_Delete( p_region );
896             return p_dest;
897         }
898         subpicture_region_Delete( p_region );
899     }
900     return p_dest;
901 }
902
903 /*****************************************************************************
904  * LoadImage: Load an image from file into a picture buffer.
905  *****************************************************************************/
906 static picture_t *LoadImage( intf_thread_t *p_intf, video_format_t *p_fmt,
907                              char *psz_file )
908 {
909     picture_t  *p_pic = NULL;
910
911     if( psz_file && p_intf->p_sys->p_image )
912     {
913         video_format_t fmt_in, fmt_out;
914
915         memset( &fmt_in, 0, sizeof(fmt_in) );
916         memset( &fmt_out, 0, sizeof(fmt_out) );
917
918         fmt_out.i_chroma = p_fmt->i_chroma;
919         p_pic = image_ReadUrl( p_intf->p_sys->p_image, psz_file,
920                                &fmt_in, &fmt_out );
921
922         msg_Dbg( p_intf, "image size %dx%d chroma %4.4s",
923                  fmt_out.i_width, fmt_out.i_height,
924                  (char *)&p_fmt->i_chroma );
925     }
926     return p_pic;
927 }
928
929 #if ! defined(FBOSD_BLENDING)
930 /*****************************************************************************
931  * Convertmage: Convert image to another fourcc
932  *****************************************************************************/
933 static picture_t *ConvertImage( intf_thread_t *p_intf, picture_t *p_pic,
934                          video_format_t *p_fmt_in, video_format_t *p_fmt_out )
935 {
936     intf_sys_t *p_sys = p_intf->p_sys;
937     picture_t  *p_old = NULL;
938
939     if( p_sys->p_image )
940     {
941         p_old = image_Convert( p_sys->p_image, p_pic, p_fmt_in, p_fmt_out );
942
943         msg_Dbg( p_intf, "converted image size %dx%d chroma %4.4s",
944                  p_fmt_out->i_width, p_fmt_out->i_height,
945                  (char *)&p_fmt_out->i_chroma );
946     }
947     return p_old;
948 }
949 #endif
950
951 /*****************************************************************************
952  * Init: initialize framebuffer video thread output method
953  *****************************************************************************/
954 static int Init( intf_thread_t *p_intf )
955 {
956     intf_sys_t *p_sys = p_intf->p_sys;
957
958     /* Initialize the output structure: RGB with square pixels, whatever
959      * the input format is, since it's the only format we know */
960     switch( p_sys->var_info.bits_per_pixel )
961     {
962     case 8: /* FIXME: set the palette */
963         p_sys->fmt_out.i_chroma = VLC_CODEC_RGB8; break;
964     case 15:
965         p_sys->fmt_out.i_chroma = VLC_CODEC_RGB15; break;
966     case 16:
967         p_sys->fmt_out.i_chroma = VLC_CODEC_RGB16; break;
968     case 24:
969         p_sys->fmt_out.i_chroma = VLC_CODEC_RGB24; break;
970     case 32:
971         p_sys->fmt_out.i_chroma = VLC_CODEC_RGB32; break;
972     default:
973         msg_Err( p_intf, "unknown screen depth %i",
974                  p_sys->var_info.bits_per_pixel );
975         return VLC_EGENERIC;
976     }
977
978     p_sys->fmt_out.i_bits_per_pixel = p_sys->var_info.bits_per_pixel;
979     p_sys->fmt_out.i_width  = p_sys->i_width;
980     p_sys->fmt_out.i_height = p_sys->i_height;
981
982     /* Assume we have square pixels */
983     if( p_sys->i_aspect < 0 )
984     {
985         p_sys->fmt_out.i_aspect = ( p_sys->i_width
986                                   * VOUT_ASPECT_FACTOR ) / p_sys->i_height;
987     }
988     else p_sys->fmt_out.i_aspect = p_sys->i_aspect;
989
990     p_sys->fmt_out.i_sar_num = p_sys->fmt_out.i_sar_den = 1;
991
992     /* Allocate overlay buffer */
993     p_sys->p_overlay = AllocatePicture( &p_sys->fmt_out );
994     if( !p_sys->p_overlay ) return VLC_EGENERIC;
995
996     SetOverlayTransparency( p_intf, true );
997
998     /* We know the chroma, allocate a buffer which will be used
999      * to write to the overlay framebuffer */
1000     p_sys->p_overlay->p->i_pixel_pitch = p_sys->i_bytes_per_pixel;
1001     p_sys->p_overlay->p->i_lines = p_sys->var_info.yres;
1002     p_sys->p_overlay->p->i_visible_lines = p_sys->var_info.yres;
1003
1004     if( p_sys->var_info.xres_virtual )
1005     {
1006         p_sys->p_overlay->p->i_pitch = p_sys->var_info.xres_virtual
1007                              * p_sys->i_bytes_per_pixel;
1008     }
1009     else
1010     {
1011         p_sys->p_overlay->p->i_pitch = p_sys->var_info.xres
1012                              * p_sys->i_bytes_per_pixel;
1013     }
1014
1015     p_sys->p_overlay->p->i_visible_pitch = p_sys->var_info.xres
1016                                  * p_sys->i_bytes_per_pixel;
1017
1018     p_sys->p_overlay->i_planes = 1;
1019
1020     return VLC_SUCCESS;
1021 }
1022
1023 /*****************************************************************************
1024  * End: terminate framebuffer interface
1025  *****************************************************************************/
1026 static void End( intf_thread_t *p_intf )
1027 {
1028     intf_sys_t *p_sys = p_intf->p_sys;
1029
1030     /* CleanUp */
1031     SetOverlayTransparency( p_intf, false );
1032     if( p_sys->p_overlay )
1033     {
1034         int ret;
1035         ret = write( p_sys->i_fd, p_sys->p_overlay->p[0].p_pixels,
1036                      p_sys->i_page_size );
1037         if( ret < 0 )
1038             msg_Err( p_intf, "unable to clear overlay" );
1039     }
1040
1041     DeAllocatePicture( p_intf->p_sys->p_overlay,
1042                        &p_intf->p_sys->fmt_out );
1043     p_intf->p_sys->p_overlay = NULL;
1044 }
1045
1046 /*****************************************************************************
1047  * OpenDisplay: initialize framebuffer
1048  *****************************************************************************/
1049 static int OpenDisplay( intf_thread_t *p_intf )
1050 {
1051     intf_sys_t *p_sys = p_intf->p_sys;
1052     char *psz_device;                             /* framebuffer device path */
1053     struct fb_fix_screeninfo    fix_info;     /* framebuffer fix information */
1054
1055     /* Open framebuffer device */
1056     if( !(psz_device = config_GetPsz( p_intf, "fbosd-dev" )) )
1057     {
1058         msg_Err( p_intf, "don't know which fb osd/overlay device to open" );
1059         return VLC_EGENERIC;
1060     }
1061
1062     p_sys->i_fd = open( psz_device, O_RDWR );
1063     if( p_sys->i_fd == -1 )
1064     {
1065         msg_Err( p_intf, "cannot open %s (%s)", psz_device, strerror(errno) );
1066         free( psz_device );
1067         return VLC_EGENERIC;
1068     }
1069     free( psz_device );
1070
1071     /* Get framebuffer device information */
1072     if( ioctl( p_sys->i_fd, FBIOGET_VSCREENINFO, &p_sys->var_info ) )
1073     {
1074         msg_Err( p_intf, "cannot get fb info (%s)", strerror(errno) );
1075         close( p_sys->i_fd );
1076         return VLC_EGENERIC;
1077     }
1078
1079     /* Get some info on the framebuffer itself */
1080     if( ioctl( p_sys->i_fd, FBIOGET_FSCREENINFO, &fix_info ) == 0 )
1081     {
1082         p_sys->i_width = p_sys->fmt_out.i_width = p_sys->var_info.xres;
1083         p_sys->i_height = p_sys->fmt_out.i_height = p_sys->var_info.yres;
1084     }
1085
1086     /* FIXME: if the image is full-size, it gets cropped on the left
1087      * because of the xres / xres_virtual slight difference */
1088     msg_Dbg( p_intf, "%ix%i (virtual %ix%i)",
1089              p_sys->var_info.xres, p_sys->var_info.yres,
1090              p_sys->var_info.xres_virtual,
1091              p_sys->var_info.yres_virtual );
1092
1093     p_sys->fmt_out.i_width = p_sys->i_width;
1094     p_sys->fmt_out.i_height = p_sys->i_height;
1095
1096     p_sys->p_palette = NULL;
1097     p_sys->b_pan = ( fix_info.ypanstep || fix_info.ywrapstep );
1098
1099     switch( p_sys->var_info.bits_per_pixel )
1100     {
1101     case 8:
1102         p_sys->p_palette = malloc( 8 * 256 * sizeof( uint16_t ) );
1103         if( !p_sys->p_palette )
1104         {
1105             close( p_sys->i_fd );
1106             return VLC_ENOMEM;
1107         }
1108         p_sys->fb_cmap.start = 0;
1109         p_sys->fb_cmap.len = 256;
1110         p_sys->fb_cmap.red = p_sys->p_palette;
1111         p_sys->fb_cmap.green  = p_sys->p_palette + 256 * sizeof( uint16_t );
1112         p_sys->fb_cmap.blue   = p_sys->p_palette + 2 * 256 * sizeof( uint16_t );
1113         p_sys->fb_cmap.transp = p_sys->p_palette + 3 * 256 * sizeof( uint16_t );
1114
1115         /* Save the colormap */
1116         ioctl( p_sys->i_fd, FBIOGETCMAP, &p_sys->fb_cmap );
1117
1118         p_sys->i_bytes_per_pixel = 1;
1119         break;
1120
1121     case 15:
1122     case 16:
1123         p_sys->i_bytes_per_pixel = 2;
1124         break;
1125
1126     case 24:
1127         p_sys->i_bytes_per_pixel = 3;
1128         break;
1129
1130     case 32:
1131         p_sys->i_bytes_per_pixel = 4;
1132         break;
1133
1134     default:
1135         msg_Err( p_intf, "screen depth %d is not supported",
1136                          p_sys->var_info.bits_per_pixel );
1137
1138         close( p_sys->i_fd );
1139         return VLC_EGENERIC;
1140     }
1141
1142     p_sys->i_page_size = p_sys->i_width * p_sys->i_height
1143                          * p_sys->i_bytes_per_pixel;
1144
1145     msg_Dbg( p_intf, "framebuffer type=%d, visual=%d, ypanstep=%d, "
1146              "ywrap=%d, accel=%d", fix_info.type, fix_info.visual,
1147              fix_info.ypanstep, fix_info.ywrapstep, fix_info.accel );
1148     return VLC_SUCCESS;
1149 }
1150
1151 /*****************************************************************************
1152  * CloseDisplay: terminate FB interface thread
1153  *****************************************************************************/
1154 static void CloseDisplay( intf_thread_t *p_intf )
1155 {
1156     intf_sys_t *p_sys = p_intf->p_sys;
1157
1158     /* Restore palette */
1159     if( p_sys->var_info.bits_per_pixel == 8 )
1160     {
1161         ioctl( p_sys->i_fd, FBIOPUTCMAP, &p_sys->fb_cmap );
1162         free( p_sys->p_palette );
1163         p_sys->p_palette = NULL;
1164     }
1165
1166     /* Close fb */
1167     close( p_sys->i_fd );
1168 }
1169
1170 static void Render( intf_thread_t *p_intf, struct fbosd_render_t *render )
1171 {
1172     intf_sys_t *p_sys = p_intf->p_sys;
1173
1174     if( render->i_state != FBOSD_STATE_RENDER ) return;
1175     if( !render->psz_string ) return;
1176
1177     if( render->i_type == FBOSD_RENDER_IMAGE )
1178     {
1179         picture_t *p_pic;
1180         p_pic = LoadImage( p_intf, &p_sys->fmt_out, render->psz_string );
1181         if( p_pic )
1182         {
1183             RenderPicture( p_intf, render->i_x, render->i_y,
1184                            p_pic, p_sys->p_overlay );
1185             picture_Release( p_pic );
1186         }
1187     }
1188     else if( render->i_type == FBOSD_RENDER_TEXT )
1189     {
1190         picture_t *p_text;
1191 #if defined(FBOSD_BLENDING)
1192         video_format_t fmt_in;
1193         memset( &fmt_in, 0, sizeof(video_format_t) );
1194         p_text = RenderText( p_intf, render->psz_string, render->p_text_style,
1195                              &fmt_in );
1196         if( p_text )
1197         {
1198             BlendPicture( p_intf, &fmt_in, &p_sys->fmt_out,
1199                           p_text, p_sys->p_overlay );
1200             msg_Dbg( p_intf, "releasing picture" );
1201             DeAllocatePicture( p_text, &fmt_in );
1202         }
1203 #else
1204         p_text = RenderText( p_intf, render->psz_string, render->p_text_style,
1205                              &p_sys->fmt_out );
1206         if( p_text )
1207         {
1208             RenderPicture( p_intf, render->i_x, render->i_y,
1209                            p_text, p_sys->p_overlay );
1210             picture_Release( p_text );
1211         }
1212 #endif
1213     }
1214 }
1215
1216 static void RenderClear( intf_thread_t *p_intf, struct fbosd_render_t *render )
1217 {
1218     intf_sys_t *p_sys = p_intf->p_sys;
1219
1220     text_style_Delete( render->p_text_style );
1221     render->p_text_style = text_style_New();
1222     free( render->psz_string );
1223     render->psz_string = NULL;
1224
1225     render->i_x = p_sys->i_x;
1226     render->i_y = p_sys->i_y;
1227     render->i_pos = p_sys->i_pos;
1228     render->i_alpha = p_sys->i_alpha;
1229     render->b_absolute = p_sys->b_absolute;
1230     render->i_state = FBOSD_STATE_FREE;
1231 }
1232
1233 static bool isRendererReady( intf_thread_t *p_intf )
1234 {
1235     intf_sys_t *p_sys = p_intf->p_sys;
1236     int i;
1237
1238     /* Check if there are more items to render */
1239     for( i = 0; i < FBOSD_RENDER_MAX; i++ )
1240     {
1241         if( p_sys->render[i].i_state == FBOSD_STATE_RESERVED )
1242             return false;
1243     }
1244     return true;
1245 }
1246
1247 /*****************************************************************************
1248  * Run: thread
1249  *****************************************************************************
1250  * This part of the interface is in a separate thread so that we can call
1251  * exec() from within it without annoying the rest of the program.
1252  *****************************************************************************/
1253 static void Run( intf_thread_t *p_intf )
1254 {
1255     intf_sys_t *p_sys = p_intf->p_sys;
1256     int canc = vlc_savecancel();
1257
1258     while( vlc_object_alive( p_intf ) )
1259     {
1260         int i;
1261
1262         /* Is there somthing to render? */
1263         for( i = 0; i < FBOSD_RENDER_MAX; i++ )
1264         {
1265             if( p_sys->render[i].i_state == FBOSD_STATE_RENDER )
1266             {
1267                 Render( p_intf, &p_sys->render[i] );
1268                 RenderClear( p_intf, &p_sys->render[i] );
1269             }
1270         }
1271
1272         if( p_sys->b_clear )
1273         {
1274             SetOverlayTransparency( p_intf, true );
1275
1276             var_SetString( p_intf, "fbosd-image", "" );
1277             var_SetString( p_intf, "fbosd-text", "" );
1278
1279             p_sys->b_clear = false;
1280             p_sys->b_need_update = true;
1281         }
1282
1283         if( p_sys->b_need_update && p_sys->p_overlay &&
1284             isRendererReady( p_intf ) )
1285         {
1286             int ret;
1287 #if defined(FBOSD_BLENDING)
1288             /* Reverse alpha channel to work around FPGA bug */
1289             InvertAlpha( p_intf, &p_sys->p_overlay, p_sys->fmt_out );
1290 #endif
1291             ret = write( p_sys->i_fd, p_sys->p_overlay->p[0].p_pixels,
1292                          p_sys->i_page_size );
1293             if( ret < 0 )
1294                 msg_Err( p_intf, "unable to write to overlay" );
1295             lseek( p_sys->i_fd, 0, SEEK_SET );
1296
1297             /* clear the picture */
1298             memset( p_sys->p_overlay->p[0].p_pixels, 0xFF, p_sys->i_page_size );
1299             p_sys->b_need_update = false;
1300         }
1301
1302         msleep( INTF_IDLE_SLEEP );
1303     }
1304
1305     End( p_intf );
1306     vlc_restorecancel( canc );
1307 }
1308
1309 static int OverlayCallback( vlc_object_t *p_this, char const *psz_cmd,
1310                  vlc_value_t oldval, vlc_value_t newval, void *p_data )
1311 {
1312     intf_thread_t *p_intf = (intf_thread_t *) p_this;
1313     intf_sys_t *p_sys = p_intf->p_sys;
1314     VLC_UNUSED(oldval); VLC_UNUSED(p_data);
1315
1316     if( !strncmp( psz_cmd, "fbosd-display", 13 ) )
1317     {
1318         p_sys->b_need_update = true;
1319     }
1320     else if( !strncmp( psz_cmd, "fbosd-clear", 11 ) )
1321     {
1322         int i;
1323         /* Clear the entire render list */
1324         for( i = 0; i < FBOSD_RENDER_MAX; i++ )
1325         {
1326             RenderClear( p_intf, &p_sys->render[i] );
1327         }
1328         p_sys->b_clear = true;
1329     }
1330     else if( !strncmp( psz_cmd, "fbosd-render", 12 ) )
1331     {
1332         int i;
1333         /* Are we already busy with on slot ? */
1334         for( i = 0; i < FBOSD_RENDER_MAX; i++ )
1335         {
1336             if( p_sys->render[i].i_state == FBOSD_STATE_RESERVED )
1337             {
1338                 p_sys->render[i].i_state = FBOSD_STATE_RENDER;
1339                 break;
1340             }
1341         }
1342     }
1343     else
1344     {
1345         int i;
1346         /* Are we already busy with on slot ? */
1347         for( i = 0; i < FBOSD_RENDER_MAX; i++ )
1348         {
1349             if( p_sys->render[i].i_state == FBOSD_STATE_RESERVED )
1350                 break;
1351         }
1352         /* No, then find first FREE slot */
1353         if( p_sys->render[i].i_state != FBOSD_STATE_RESERVED )
1354         {
1355             for( i = 0; i < FBOSD_RENDER_MAX; i++ )
1356             {
1357                 if( p_sys->render[i].i_state == FBOSD_STATE_FREE )
1358                     break;
1359             }
1360             if( p_sys->render[i].i_state != FBOSD_STATE_FREE )
1361             {
1362                 msg_Warn( p_this, "render space depleated" );
1363                 return VLC_SUCCESS;
1364             }
1365         }
1366         /* Found a free slot */
1367         p_sys->render[i].i_state = FBOSD_STATE_RESERVED;
1368         if( !strncmp( psz_cmd, "fbosd-image", 11 ) )
1369         {
1370             free( p_sys->render[i].psz_string );
1371             p_sys->render[i].psz_string = strdup( newval.psz_string );
1372             p_sys->render[i].i_type = FBOSD_RENDER_IMAGE;
1373         }
1374         else if( !strncmp( psz_cmd, "fbosd-text", 10 ) )
1375         {
1376             free( p_sys->render[i].psz_string );
1377             p_sys->render[i].psz_string = strdup( newval.psz_string );
1378             p_sys->render[i].i_type = FBOSD_RENDER_TEXT;
1379         }
1380         else if( !strncmp( psz_cmd, "fbosd-x", 7 ) )
1381         {
1382             p_sys->render[i].b_absolute = false;
1383             p_sys->render[i].i_x = (newval.i_int < p_sys->i_width) ?
1384                                     newval.i_int : p_sys->i_width;
1385         }
1386         else if( !strncmp( psz_cmd, "fbosd-y", 7 ) )
1387         {
1388             p_sys->render[i].b_absolute = false;
1389             p_sys->render[i].i_y = (newval.i_int < p_sys->i_height) ?
1390                                     newval.i_int : p_sys->i_height;
1391         }
1392         else if( !strncmp( psz_cmd, "fbosd-position", 14 ) )
1393         {
1394             p_sys->render[i].b_absolute = true;
1395             p_sys->render[i].i_pos = newval.i_int;
1396         }
1397         else if( !strncmp( psz_cmd, "fbosd-font-size", 15 ) )
1398         {
1399             p_sys->render[i].p_text_style->i_font_size = newval.i_int;
1400         }
1401         else if( !strncmp( psz_cmd, "fbosd-font-color", 16 ) )
1402         {
1403             p_sys->render[i].p_text_style->i_font_color = newval.i_int;
1404         }
1405         else if( !strncmp( psz_cmd, "fbosd-font-opacity", 18 ) )
1406         {
1407             p_sys->render[i].p_text_style->i_font_alpha = 255 - newval.i_int;
1408         }
1409         else if( !strncmp( psz_cmd, "fbosd-alpha", 11 ) )
1410         {
1411             p_sys->render[i].i_alpha = newval.i_int;
1412         }
1413     }
1414     return VLC_SUCCESS;
1415 }