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