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