?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
skins2(Linux): check if _NET_WM_PID is supported
[vlc/asuraparaju-public.git] / modules / gui / fbosd.c
blobe55941e32f324178438f9700d2300529882e83a3
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 #include <vlc_fs.h>
35
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 /* Use PAL by default */
334 p_sys->i_width = p_sys->fmt_out.i_width = 704;
335 p_sys->i_height = p_sys->fmt_out.i_height = 576;
336
337 p_sys->i_aspect = -1;
338 psz_aspect =
339 var_CreateGetNonEmptyString( p_intf, "fbosd-aspect-ratio" );
340 if( psz_aspect )
341 {
342 char *psz_parser = strchr( psz_aspect, ':' );
343
344 if( psz_parser )
345 {
346 *psz_parser++ = '\0';
347 p_sys->i_aspect = ( atoi( psz_aspect )
348 * VOUT_ASPECT_FACTOR ) / atoi( psz_parser );
349 p_sys->fmt_out.i_sar_num = p_sys->i_aspect * p_sys->i_height;
350 p_sys->fmt_out.i_sar_den = VOUT_ASPECT_FACTOR * p_sys->i_width;
351 }
352 msg_Dbg( p_intf, "using aspect ratio %d:%d",
353 atoi( psz_aspect ), atoi( psz_parser ) );
354
355 free( psz_aspect );
356 }
357
358 psz_tmp = var_CreateGetNonEmptyStringCommand( p_intf, "fbosd-image" );
359 var_AddCallback( p_intf, "fbosd-image", OverlayCallback, NULL );
360 if( psz_tmp && *psz_tmp )
361 {
362 p_sys->render[0].i_type = FBOSD_RENDER_IMAGE;
363 p_sys->render[0].i_state = FBOSD_STATE_RENDER;
364 p_sys->render[0].psz_string = strdup( psz_tmp );
365 }
366 free( psz_tmp );
367
368 psz_tmp = var_CreateGetNonEmptyStringCommand( p_intf, "fbosd-text" );
369 var_AddCallback( p_intf, "fbosd-text", OverlayCallback, NULL );
370 if( psz_tmp && *psz_tmp )
371 {
372 p_sys->render[1].i_type = FBOSD_RENDER_TEXT;
373 p_sys->render[1].i_state = FBOSD_STATE_RENDER;
374 p_sys->render[1].psz_string = strdup( psz_tmp );
375 }
376 free( psz_tmp );
377
378 p_sys->i_pos = var_CreateGetIntegerCommand( p_intf, "fbosd-position" );
379 p_sys->i_x = var_CreateGetIntegerCommand( p_intf, "fbosd-x" );
380 p_sys->i_y = var_CreateGetIntegerCommand( p_intf, "fbosd-y" );
381
382 var_AddCallback( p_intf, "fbosd-position", OverlayCallback, NULL );
383 var_AddCallback( p_intf, "fbosd-x", OverlayCallback, NULL );
384 var_AddCallback( p_intf, "fbosd-y", OverlayCallback, NULL );
385
386 p_sys->p_style->i_font_size =
387 var_CreateGetIntegerCommand( p_intf, "fbosd-font-size" );
388 p_sys->p_style->i_font_color =
389 var_CreateGetIntegerCommand( p_intf, "fbosd-font-color" );
390 p_sys->p_style->i_font_alpha = 255 -
391 var_CreateGetIntegerCommand( p_intf, "fbosd-font-opacity" );
392
393 var_AddCallback( p_intf, "fbosd-font-color", OverlayCallback, NULL );
394 var_AddCallback( p_intf, "fbosd-font-size", OverlayCallback, NULL );
395 var_AddCallback( p_intf, "fbosd-font-opacity", OverlayCallback, NULL );
396
397 for( i = 0; i < FBOSD_RENDER_MAX; i++ )
398 p_sys->render[i].p_text_style = text_style_New();
399
400 p_sys->b_clear = var_CreateGetBoolCommand( p_intf, "fbosd-clear" );
401 p_sys->b_render = var_CreateGetBoolCommand( p_intf, "fbosd-render" );
402 p_sys->b_need_update = var_CreateGetBoolCommand( p_intf, "fbosd-display" );
403
404 var_AddCallback( p_intf, "fbosd-clear", OverlayCallback, NULL );
405 var_AddCallback( p_intf, "fbosd-render", OverlayCallback, NULL );
406 var_AddCallback( p_intf, "fbosd-display", OverlayCallback, NULL );
407
408 /* Check if picture position was overridden */
409 p_sys->b_absolute = true;
410 if( ( p_sys->i_x >= 0 ) && ( p_sys->i_y >= 0 ) )
411 {
412 p_sys->b_absolute = false;
413 p_sys->i_y = (p_sys->i_y < p_sys->i_height) ?
414 p_sys->i_y : p_sys->i_height;
415 p_sys->i_x = (p_sys->i_x < p_sys->i_width) ?
416 p_sys->i_x : p_sys->i_width;
417 }
418
419 p_sys->render[0].i_x = p_sys->render[1].i_x = p_sys->i_x;
420 p_sys->render[0].i_y = p_sys->render[1].i_y = p_sys->i_y;
421 p_sys->render[0].i_pos = p_sys->render[1].i_pos = p_sys->i_pos;
422 p_sys->render[0].i_alpha = p_sys->render[1].i_alpha = p_sys->i_alpha;
423
424 /* Initialize framebuffer */
425 if( OpenDisplay( p_intf ) )
426 {
427 Destroy( VLC_OBJECT(p_intf) );
428 return VLC_EGENERIC;
429 }
430
431 Init( p_intf );
432
433 #if defined(FBOSD_BLENDING)
434 /* Load the blending module */
435 if( OpenBlending( p_intf ) )
436 {
437 msg_Err( p_intf, "Unable to load image blending module" );
438 Destroy( VLC_OBJECT(p_intf) );
439 return VLC_EGENERIC;
440 }
441 #endif
442
443 /* Load text renderer module */
444 if( OpenTextRenderer( p_intf ) )
445 {
446 msg_Err( p_intf, "Unable to load text rendering module" );
447 Destroy( VLC_OBJECT(p_intf) );
448 return VLC_EGENERIC;
449 }
450
451 p_sys->b_render = true;
452 p_sys->b_need_update = true;
453
454 return VLC_SUCCESS;
455 }
456
457 /*****************************************************************************
458 * Destroy: destroy FB interface thread output method
459 *****************************************************************************
460 * Terminate an output method created by Create
461 *****************************************************************************/
462 static void Destroy( vlc_object_t *p_this )
463 {
464 intf_thread_t *p_intf = (intf_thread_t *)p_this;
465 intf_sys_t *p_sys = p_intf->p_sys;
466 int i;
467
468
469 p_sys->b_need_update = false;
470 p_sys->b_render = false;
471 p_sys->b_clear = false;
472
473 var_DelCallback( p_intf, "fbosd-alpha", OverlayCallback, NULL );
474 var_Destroy( p_intf, "fbosd-alpha" );
475
476 var_DelCallback( p_intf, "fbosd-x", OverlayCallback, NULL );
477 var_DelCallback( p_intf, "fbosd-y", OverlayCallback, NULL );
478 var_DelCallback( p_intf, "fbosd-position", OverlayCallback, NULL );
479 var_DelCallback( p_intf, "fbosd-image", OverlayCallback, NULL );
480 var_DelCallback( p_intf, "fbosd-text", OverlayCallback, NULL );
481 var_DelCallback( p_intf, "fbosd-font-size", OverlayCallback, NULL );
482 var_DelCallback( p_intf, "fbosd-font-color", OverlayCallback, NULL );
483 var_DelCallback( p_intf, "fbosd-font-opacity", OverlayCallback, NULL );
484 var_DelCallback( p_intf, "fbosd-clear", OverlayCallback, NULL );
485 var_DelCallback( p_intf, "fbosd-render", OverlayCallback, NULL );
486 var_DelCallback( p_intf, "fbosd-display", OverlayCallback, NULL );
487
488 var_Destroy( p_intf, "fbosd-x" );
489 var_Destroy( p_intf, "fbosd-y" );
490 var_Destroy( p_intf, "fbosd-position" );
491 var_Destroy( p_intf, "fbosd-image" );
492 var_Destroy( p_intf, "fbosd-text" );
493 var_Destroy( p_intf, "fbosd-font-size" );
494 var_Destroy( p_intf, "fbosd-font-color" );
495 var_Destroy( p_intf, "fbosd-font-opacity" );
496 var_Destroy( p_intf, "fbosd-clear" );
497 var_Destroy( p_intf, "fbosd-render" );
498 var_Destroy( p_intf, "fbosd-display" );
499
500 var_Destroy( p_intf, "fbosd-aspect-ratio" );
501
502 CloseDisplay( p_intf );
503
504 for( i = 0; i < FBOSD_RENDER_MAX; i++ )
505 {
506 free( p_sys->render[i].psz_string );
507 p_sys->render[i].i_state = FBOSD_STATE_FREE;
508 text_style_Delete( p_sys->render[i].p_text_style );
509 }
510
511 #if defined(FBOSD_BLENDING)
512 if( p_sys->p_blend ) CloseBlending( p_intf );
513 #endif
514 if( p_sys->p_text ) CloseTextRenderer( p_intf );
515
516 if( p_sys->p_image )
517 image_HandlerDelete( p_sys->p_image );
518 if( p_sys->p_overlay )
519 picture_Release( p_sys->p_overlay );
520
521 text_style_Delete( p_sys->p_style );
522 free( p_sys );
523 }
524
525 #if defined(FBOSD_BLENDING)
526 static int OpenBlending( intf_thread_t *p_intf )
527 {
528 if( p_intf->p_sys->p_blend ) return VLC_EGENERIC;
529
530 p_intf->p_sys->p_blend =
531 vlc_object_create( p_intf, sizeof(filter_t) );
532 vlc_object_attach( p_intf->p_sys->p_blend, p_intf );
533 p_intf->p_sys->p_blend->fmt_out.video.i_x_offset =
534 p_intf->p_sys->p_blend->fmt_out.video.i_y_offset = 0;
535 p_intf->p_sys->p_blend->fmt_out.video.i_sar_num =
536 p_intf->p_sys->fmt_out.i_sar_num;
537 p_intf->p_sys->p_blend->fmt_out.video.i_sar_den =
538 p_intf->p_sys->fmt_out.i_sar_den;
539 p_intf->p_sys->p_blend->fmt_out.video.i_chroma =
540 p_intf->p_sys->fmt_out.i_chroma;
541 if( var_InheritBool( p_intf, "freetype-yuvp" ) )
542 p_intf->p_sys->p_blend->fmt_in.video.i_chroma =
543 VLC_CODEC_YUVP;
544 else
545 p_intf->p_sys->p_blend->fmt_in.video.i_chroma =
546 VLC_CODEC_YUVA;
547
548 p_intf->p_sys->p_blend->p_module =
549 module_need( p_intf->p_sys->p_blend, "video blending", NULL, false );
550
551 if( !p_intf->p_sys->p_blend->p_module )
552 return VLC_EGENERIC;
553
554 return VLC_SUCCESS;
555 }
556
557 static void CloseBlending( intf_thread_t *p_intf )
558 {
559 if( p_intf->p_sys->p_blend )
560 {
561 if( p_intf->p_sys->p_blend->p_module )
562 module_unneed( p_intf->p_sys->p_blend,
563 p_intf->p_sys->p_blend->p_module );
564
565 vlc_object_release( p_intf->p_sys->p_blend );
566 }
567 }
568 #endif
569
570 static int OpenTextRenderer( intf_thread_t *p_intf )
571 {
572 char *psz_modulename = NULL;
573
574 if( p_intf->p_sys->p_text ) return VLC_EGENERIC;
575
576 p_intf->p_sys->p_text =
577 vlc_object_create( p_intf, sizeof(filter_t) );
578 vlc_object_attach( p_intf->p_sys->p_text, p_intf );
579
580 p_intf->p_sys->p_text->fmt_out.video.i_width =
581 p_intf->p_sys->p_text->fmt_out.video.i_visible_width =
582 p_intf->p_sys->i_width;
583 p_intf->p_sys->p_text->fmt_out.video.i_height =
584 p_intf->p_sys->p_text->fmt_out.video.i_visible_height =
585 p_intf->p_sys->i_height;
586
587 psz_modulename = var_CreateGetString( p_intf, "text-renderer" );
588 if( psz_modulename && *psz_modulename )
589 {
590 p_intf->p_sys->p_text->p_module =
591 module_need( p_intf->p_sys->p_text, "text renderer",
592 psz_modulename, true );
593 }
594 if( !p_intf->p_sys->p_text->p_module )
595 {
596 p_intf->p_sys->p_text->p_module =
597 module_need( p_intf->p_sys->p_text, "text renderer", NULL, false );
598 }
599 free( psz_modulename );
600
601 if( !p_intf->p_sys->p_text->p_module )
602 return VLC_EGENERIC;
603
604 return VLC_SUCCESS;
605 }
606
607 static void CloseTextRenderer( intf_thread_t *p_intf )
608 {
609 if( p_intf->p_sys->p_text )
610 {
611 if( p_intf->p_sys->p_text->p_module )
612 module_unneed( p_intf->p_sys->p_text,
613 p_intf->p_sys->p_text->p_module );
614
615 vlc_object_release( p_intf->p_sys->p_text );
616 }
617 }
618
619 /*****************************************************************************
620 * AllocatePicture:
621 * allocate a picture buffer for use with the overlay fb.
622 *****************************************************************************/
623 static picture_t *AllocatePicture( video_format_t *p_fmt )
624 {
625 picture_t *p_picture = picture_NewFromFormat( p_fmt );
626 if( !p_picture )
627 return NULL;
628
629 if( !p_fmt->p_palette &&
630 ( p_fmt->i_chroma == VLC_CODEC_YUVP ) )
631 {
632 p_fmt->p_palette = malloc( sizeof(video_palette_t) );
633 if( !p_fmt->p_palette )
634 {
635 picture_Release( p_picture );
636 return NULL;
637 }
638 }
639 else
640 {
641 p_fmt->p_palette = NULL;
642 }
643
644 return p_picture;
645 }
646
647 /*****************************************************************************
648 * DeAllocatePicture:
649 * Deallocate a picture buffer and free all associated memory.
650 *****************************************************************************/
651 static void DeAllocatePicture( picture_t *p_pic, video_format_t *p_fmt )
652 {
653 if( p_fmt )
654 {
655 free( p_fmt->p_palette );
656 p_fmt->p_palette = NULL;
657 }
658
659 if( p_pic )
660 picture_Release( p_pic );
661 }
662
663 /*****************************************************************************
664 * SetOverlayTransparency: Set the transparency for this overlay fb,
665 * - true is make transparent
666 * - false is make non tranparent
667 *****************************************************************************/
668 static void SetOverlayTransparency( intf_thread_t *p_intf,
669 bool b_transparent )
670 {
671 intf_sys_t *p_sys = p_intf->p_sys;
672 size_t i_size = p_sys->fmt_out.i_width * p_sys->fmt_out.i_height
673 * p_sys->i_bytes_per_pixel;
674 size_t i_page_size = (p_sys->i_page_size > i_size) ?
675 i_size : p_sys->i_page_size;
676
677 if( p_sys->p_overlay )
678 {
679 msg_Dbg( p_intf, "Make overlay %s",
680 b_transparent ? "transparent" : "opaque" );
681 if( b_transparent )
682 memset( p_sys->p_overlay->p[0].p_pixels, 0xFF, i_page_size );
683 else
684 memset( p_sys->p_overlay->p[0].p_pixels, 0x00, i_page_size );
685 }
686 }
687
688 #if defined(FBOSD_BLENDING)
689 /*****************************************************************************
690 * BlendPicture: Blend two pictures together..
691 *****************************************************************************/
692 static int BlendPicture( intf_thread_t *p_intf, video_format_t *p_fmt_src,
693 video_format_t *p_fmt_dst, picture_t *p_pic_src,
694 picture_t *p_pic_dst )
695 {
696 intf_sys_t *p_sys = p_intf->p_sys;
697 if( p_sys->p_blend && p_sys->p_blend->p_module )
698 {
699 int i_x_offset = p_sys->i_x;
700 int i_y_offset = p_sys->i_y;
701
702 memcpy( &p_sys->p_blend->fmt_in.video, p_fmt_src, sizeof( video_format_t ) );
703
704 /* Update the output picture size */
705 p_sys->p_blend->fmt_out.video.i_width =
706 p_sys->p_blend->fmt_out.video.i_visible_width =
707 p_fmt_dst->i_width;
708 p_sys->p_blend->fmt_out.video.i_height =
709 p_sys->p_blend->fmt_out.video.i_visible_height =
710 p_fmt_dst->i_height;
711
712 i_x_offset = __MAX( i_x_offset, 0 );
713 i_y_offset = __MAX( i_y_offset, 0 );
714
715 p_sys->p_blend->pf_video_blend( p_sys->p_blend, p_pic_dst,
716 p_pic_src, p_pic_dst, i_x_offset, i_y_offset,
717 p_sys->i_alpha );
718
719 return VLC_SUCCESS;
720 }
721 return VLC_EGENERIC;
722 }
723
724 static int InvertAlpha( intf_thread_t *p_intf, picture_t **p_pic, video_format_t fmt )
725 {
726 uint8_t *p_begin = NULL, *p_end = NULL;
727 uint8_t i_skip = 0;
728
729 if( *p_pic && ((*p_pic)->i_planes != 1) )
730 {
731 msg_Err( p_intf,
732 "cannot invert alpha channel too many planes %d (only 1 supported)",
733 (*p_pic)->i_planes );
734 return VLC_EGENERIC;
735 }
736
737 switch( fmt.i_chroma )
738 {
739 case VLC_CODEC_RGB24:
740 p_begin = (uint8_t *)(*p_pic)->p[Y_PLANE].p_pixels;
741 p_end = (uint8_t *)(*p_pic)->p[Y_PLANE].p_pixels +
742 ( fmt.i_height * (*p_pic)->p[Y_PLANE].i_pitch );
743 i_skip = 3;
744 break;
745 case VLC_CODEC_RGB32:
746 p_begin = (uint8_t *)(*p_pic)->p[Y_PLANE].p_pixels;
747 p_end = (uint8_t *)(*p_pic)->p[Y_PLANE].p_pixels +
748 ( fmt.i_height * (*p_pic)->p[Y_PLANE].i_pitch );
749 i_skip = 4;
750 break;
751 default:
752 msg_Err( p_intf, "cannot invert alpha channel chroma not supported %4.4s",
753 (char *)&fmt.i_chroma );
754 return VLC_EGENERIC;
755 }
756
757 for( ; p_begin < p_end; p_begin += i_skip )
758 {
759 uint8_t i_opacity = 0;
760
761 if( *p_begin != 0xFF )
762 i_opacity = 255 - *p_begin;
763 *p_begin = i_opacity;
764 }
765 /* end of kludge */
766 return VLC_SUCCESS;
767 }
768 #endif
769
770 /*****************************************************************************
771 * RenderPicture: Render the picture into the p_dest buffer.
772 * We don't take transparent pixels into account, so we don't have to blend
773 * the two images together.
774 *****************************************************************************/
775 static int RenderPicture( intf_thread_t *p_intf, int i_x_offset, int i_y_offset,
776 picture_t *p_src, picture_t *p_dest )
777 {
778 int i;
779 VLC_UNUSED( p_intf );
780
781 if( !p_dest && !p_src ) return VLC_EGENERIC;
782
783 for( i = 0; i < p_src->i_planes ; i++ )
784 {
785 if( p_src->p[i].i_pitch == p_dest->p[i].i_pitch )
786 {
787 /* There are margins, but with the same width : perfect ! */
788 vlc_memcpy( p_dest->p[i].p_pixels, p_src->p[i].p_pixels,
789 p_src->p[i].i_pitch * p_src->p[i].i_visible_lines );
790 }
791 else
792 {
793 /* We need to proceed line by line */
794 uint8_t *p_in = p_src->p[i].p_pixels;
795 uint8_t *p_out = p_dest->p[i].p_pixels;
796
797 int i_x = i_x_offset * p_src->p[i].i_pixel_pitch;
798 int i_x_clip, i_y_clip;
799
800 /* Check boundaries, clip the image if necessary */
801 i_x_clip = ( i_x + p_src->p[i].i_visible_pitch ) - p_dest->p[i].i_visible_pitch;
802 i_x_clip = ( i_x_clip > 0 ) ? i_x_clip : 0;
803
804 i_y_clip = ( i_y_offset + p_src->p[i].i_visible_lines ) - p_dest->p[i].i_visible_lines;
805 i_y_clip = ( i_y_clip > 0 ) ? i_y_clip : 0;
806 #if defined(FBOSD_DEBUG)
807 msg_Dbg( p_intf, "i_pitch (%d,%d), (%d,%d)/(%d,%d)",
808 p_dest->p[i].i_visible_pitch, p_src->p[i].i_visible_pitch,
809 i_x_offset, i_y_offset, i_x, i_x_clip );
810 #endif
811 if( ( i_y_offset <= p_dest->p[i].i_visible_lines ) &&
812 ( i_x <= p_dest->p[i].i_visible_pitch ) )
813 {
814 int i_line;
815
816 p_out += ( i_y_offset * p_dest->p[i].i_pitch );
817 for( i_line = 0; i_line < ( p_src->p[i].i_visible_lines - i_y_clip ); i_line++ )
818 {
819 vlc_memcpy( p_out + i_x, p_in,
820 p_src->p[i].i_visible_pitch - i_x_clip );
821 p_in += p_src->p[i].i_pitch;
822 p_out += p_dest->p[i].i_pitch;
823 }
824 }
825 }
826 }
827 return VLC_SUCCESS;
828 }
829
830 /*****************************************************************************
831 * RenderText - Render text to the desired picture format
832 *****************************************************************************/
833 static picture_t *RenderText( intf_thread_t *p_intf, const char *psz_string,
834 text_style_t *p_style, video_format_t *p_fmt )
835 {
836 intf_sys_t *p_sys = p_intf->p_sys;
837 subpicture_region_t *p_region;
838 picture_t *p_dest = NULL;
839
840 if( !psz_string ) return p_dest;
841
842 if( p_sys->p_text && p_sys->p_text->p_module )
843 {
844 video_format_t fmt;
845
846 memset( &fmt, 0, sizeof(fmt) );
847 fmt.i_chroma = VLC_CODEC_TEXT;
848 fmt.i_width = fmt.i_visible_width = 0;
849 fmt.i_height = fmt.i_visible_height = 0;
850 fmt.i_x_offset = 0;
851 fmt.i_y_offset = 0;
852
853 p_region = subpicture_region_New( &fmt );
854 if( !p_region )
855 return p_dest;
856
857 p_region->psz_text = strdup( psz_string );
858 if( !p_region->psz_text )
859 {
860 subpicture_region_Delete( p_region );
861 return NULL;
862 }
863 p_region->p_style = text_style_Duplicate( p_style );
864 p_region->i_align = SUBPICTURE_ALIGN_LEFT | SUBPICTURE_ALIGN_TOP;
865
866 if( p_sys->p_text->pf_render_text )
867 {
868 video_format_t fmt_out;
869
870 memset( &fmt_out, 0, sizeof(video_format_t) );
871
872 p_sys->p_text->pf_render_text( p_sys->p_text,
873 p_region, p_region );
874
875 #if defined(FBOSD_BLENDING)
876 fmt_out = p_region->fmt;
877 fmt_out.i_bits_per_pixel = 32;
878 vlc_memcpy( p_fmt, &fmt_out, sizeof(video_format_t) );
879
880 /* FIXME not needed to copy the picture anymore no ? */
881 p_dest = AllocatePicture( VLC_OBJECT(p_intf), &fmt_out );
882 if( !p_dest )
883 {
884 subpicture_region_Delete( p_region );
885 return NULL;
886 }
887 picture_Copy( p_dest, p_region->p_picture );
888 #else
889 fmt_out.i_chroma = p_fmt->i_chroma;
890 p_dest = ConvertImage( p_intf, p_region->p_picture,
891 &p_region->fmt, &fmt_out );
892 #endif
893 subpicture_region_Delete( p_region );
894 return p_dest;
895 }
896 subpicture_region_Delete( p_region );
897 }
898 return p_dest;
899 }
900
901 /*****************************************************************************
902 * LoadImage: Load an image from file into a picture buffer.
903 *****************************************************************************/
904 static picture_t *LoadImage( intf_thread_t *p_intf, video_format_t *p_fmt,
905 char *psz_file )
906 {
907 picture_t *p_pic = NULL;
908
909 if( psz_file && p_intf->p_sys->p_image )
910 {
911 video_format_t fmt_in, fmt_out;
912
913 memset( &fmt_in, 0, sizeof(fmt_in) );
914 memset( &fmt_out, 0, sizeof(fmt_out) );
915
916 fmt_out.i_chroma = p_fmt->i_chroma;
917 p_pic = image_ReadUrl( p_intf->p_sys->p_image, psz_file,
918 &fmt_in, &fmt_out );
919
920 msg_Dbg( p_intf, "image size %dx%d chroma %4.4s",
921 fmt_out.i_width, fmt_out.i_height,
922 (char *)&p_fmt->i_chroma );
923 }
924 return p_pic;
925 }
926
927 #if ! defined(FBOSD_BLENDING)
928 /*****************************************************************************
929 * Convertmage: Convert image to another fourcc
930 *****************************************************************************/
931 static picture_t *ConvertImage( intf_thread_t *p_intf, picture_t *p_pic,
932 video_format_t *p_fmt_in, video_format_t *p_fmt_out )
933 {
934 intf_sys_t *p_sys = p_intf->p_sys;
935 picture_t *p_old = NULL;
936
937 if( p_sys->p_image )
938 {
939 p_old = image_Convert( p_sys->p_image, p_pic, p_fmt_in, p_fmt_out );
940
941 msg_Dbg( p_intf, "converted image size %dx%d chroma %4.4s",
942 p_fmt_out->i_width, p_fmt_out->i_height,
943 (char *)&p_fmt_out->i_chroma );
944 }
945 return p_old;
946 }
947 #endif
948
949 /*****************************************************************************
950 * Init: initialize framebuffer video thread output method
951 *****************************************************************************/
952 static int Init( intf_thread_t *p_intf )
953 {
954 intf_sys_t *p_sys = p_intf->p_sys;
955
956 /* Initialize the output structure: RGB with square pixels, whatever
957 * the input format is, since it's the only format we know */
958 switch( p_sys->var_info.bits_per_pixel )
959 {
960 case 8: /* FIXME: set the palette */
961 p_sys->fmt_out.i_chroma = VLC_CODEC_RGB8; break;
962 case 15:
963 p_sys->fmt_out.i_chroma = VLC_CODEC_RGB15; break;
964 case 16:
965 p_sys->fmt_out.i_chroma = VLC_CODEC_RGB16; break;
966 case 24:
967 p_sys->fmt_out.i_chroma = VLC_CODEC_RGB24; break;
968 case 32:
969 p_sys->fmt_out.i_chroma = VLC_CODEC_RGB32; break;
970 default:
971 msg_Err( p_intf, "unknown screen depth %i",
972 p_sys->var_info.bits_per_pixel );
973 return VLC_EGENERIC;
974 }
975
976 p_sys->fmt_out.i_bits_per_pixel = p_sys->var_info.bits_per_pixel;
977 p_sys->fmt_out.i_width = p_sys->i_width;
978 p_sys->fmt_out.i_height = p_sys->i_height;
979
980 /* Assume we have square pixels */
981 if( p_sys->i_aspect < 0 )
982 {
983 p_sys->fmt_out.i_sar_num = 1;
984 p_sys->fmt_out.i_sar_den = 1;
985 }
986 else
987 {
988 p_sys->fmt_out.i_sar_num = p_sys->i_aspect * p_sys->i_height;
989 p_sys->fmt_out.i_sar_den = VOUT_ASPECT_FACTOR * p_sys->i_width;
990 }
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 = var_InheritString( 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 = vlc_open( psz_device, O_RDWR );
1063 if( p_sys->i_fd == -1 )
1064 {
1065 msg_Err( p_intf, "cannot open %s (%m)", psz_device );
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 (%m)" );
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 }