1 /*****************************************************************************
2 * fbosd.c : framebuffer osd plugin for vlc
3 *****************************************************************************
4 * Copyright (C) 2007-2008, the VideoLAN team
7 * Authors: Jean-Paul Saman
8 * Copied from modules/video_output/fb.c by Samuel Hocevar <sam@zoy.org>
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.
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.
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 *****************************************************************************/
25 /*****************************************************************************
27 *****************************************************************************/
32 #include <vlc_common.h>
33 #include <vlc_plugin.h>
36 #include <stdlib.h> /* free() */
37 #include <string.h> /* strerror() */
38 #include <fcntl.h> /* open() */
39 #include <unistd.h> /* close() */
41 #include <sys/ioctl.h>
42 #include <sys/mman.h> /* mmap() */
46 #include <vlc_image.h>
47 #include <vlc_interface.h>
48 #include <vlc_input.h>
50 #include <vlc_filter.h>
52 #include <vlc_strings.h>
57 /*****************************************************************************
59 *****************************************************************************/
60 static int Create ( vlc_object_t * );
61 static void Destroy ( vlc_object_t * );
62 static void Run ( intf_thread_t * );
64 static int Init ( intf_thread_t * );
65 static void End ( intf_thread_t * );
67 static int OpenDisplay ( intf_thread_t * );
68 static void CloseDisplay ( intf_thread_t * );
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 * );
75 static int OpenTextRenderer ( intf_thread_t * );
76 static void CloseTextRenderer( intf_thread_t * );
78 /* Manipulate the overlay buffer */
79 static int OverlayCallback( vlc_object_t *, char const *,
80 vlc_value_t, vlc_value_t, void * );
82 static picture_t *AllocatePicture( video_format_t * );
83 static void DeAllocatePicture( picture_t *, video_format_t * );
84 static void SetOverlayTransparency( intf_thread_t *,
86 static picture_t *LoadImage( intf_thread_t *, video_format_t *,
89 #if defined(FBOSD_BLENDING)
90 static int BlendPicture( intf_thread_t *, video_format_t *,
91 video_format_t *, picture_t *, picture_t * );
93 static picture_t *ConvertImage( intf_thread_t *, picture_t *,
94 video_format_t *, video_format_t * );
96 static int RenderPicture( intf_thread_t *, int, int,
97 picture_t *, picture_t * );
98 static picture_t *RenderText( intf_thread_t *, const char *,
99 text_style_t *, video_format_t * );
101 #define DEVICE_TEXT N_("Framebuffer device")
102 #define DEVICE_LONGTEXT N_( \
103 "Framebuffer device to use for rendering (usually /dev/fb0).")
105 #define ASPECT_RATIO_TEXT N_("Video aspect ratio")
106 #define ASPECT_RATIO_LONGTEXT N_( \
107 "Aspect ratio of the video image (4:3, 16:9). Default is square pixels." )
109 #define FBOSD_IMAGE_TEXT N_("Image file")
110 #define FBOSD_IMAGE_LONGTEXT N_( \
111 "Filename of image file to use on the overlay framebuffer." )
113 #define ALPHA_TEXT N_("Transparency of the image")
114 #define ALPHA_LONGTEXT N_( "Transparency value of the new image " \
115 "used in blending. By default it set to fully opaque (255). " \
116 "(from 0 for full transparency to 255 for full opacity)" )
118 #define FBOSD_TEXT N_("Text")
119 #define FBOSD_LONGTEXT N_( "Text to display on the overlay framebuffer." )
121 #define POSX_TEXT N_("X coordinate")
122 #define POSX_LONGTEXT N_("X coordinate of the rendered image")
124 #define POSY_TEXT N_("Y coordinate")
125 #define POSY_LONGTEXT N_("Y coordinate of the rendered image")
127 #define POS_TEXT N_("Position")
128 #define POS_LONGTEXT N_( \
129 "You can enforce the picture position on the overlay " \
130 "(0=center, 1=left, 2=right, 4=top, 8=bottom, you can " \
131 "also use combinations of these values, e.g. 6=top-right).")
133 #define OPACITY_TEXT N_("Opacity")
134 #define OPACITY_LONGTEXT N_("Opacity (inverse of transparency) of " \
135 "overlayed text. 0 = transparent, 255 = totally opaque. " )
137 #define SIZE_TEXT N_("Font size, pixels")
138 #define SIZE_LONGTEXT N_("Font size, in pixels. Default is -1 (use default " \
141 #define COLOR_TEXT N_("Color")
142 #define COLOR_LONGTEXT N_("Color of the text that will be rendered on "\
143 "the video. This must be an hexadecimal (like HTML colors). The first two "\
144 "chars are for red, then green, then blue. #000000 = black, #FF0000 = red,"\
145 " #00FF00 = green, #FFFF00 = yellow (red + green), #FFFFFF = white" )
147 #define CLEAR_TEXT N_( "Clear overlay framebuffer" )
148 #define CLEAR_LONGTEXT N_( "The displayed overlay images is cleared by " \
149 "making the overlay completely transparent. All previously rendered " \
150 "images and text will be cleared from the cache." )
152 #define RENDER_TEXT N_( "Render text or image" )
153 #define RENDER_LONGTEXT N_( "Render the image or text in current overlay " \
156 #define DISPLAY_TEXT N_( "Display on overlay framebuffer" )
157 #define DISPLAY_LONGTEXT N_( "All rendered images and text will be " \
158 "displayed on the overlay framebuffer." )
160 static const int pi_pos_values[] = { 0, 1, 2, 4, 8, 5, 6, 9, 10 };
161 static const char *const ppsz_pos_descriptions[] =
162 { N_("Center"), N_("Left"), N_("Right"), N_("Top"), N_("Bottom"),
163 N_("Top-Left"), N_("Top-Right"), N_("Bottom-Left"), N_("Bottom-Right") };
165 static const int pi_color_values[] = {
166 0xf0000000, 0x00000000, 0x00808080, 0x00C0C0C0,
167 0x00FFFFFF, 0x00800000, 0x00FF0000, 0x00FF00FF, 0x00FFFF00,
168 0x00808000, 0x00008000, 0x00008080, 0x0000FF00, 0x00800080,
169 0x00000080, 0x000000FF, 0x0000FFFF};
170 static const char *const ppsz_color_descriptions[] = {
171 N_("Default"), N_("Black"),
172 N_("Gray"), N_("Silver"), N_("White"), N_("Maroon"), N_("Red"),
173 N_("Fuchsia"), N_("Yellow"), N_("Olive"), N_("Green"),
174 N_("Teal"), N_("Lime"), N_("Purple"), N_("Navy"), N_("Blue"),
178 set_shortname( "fbosd" )
179 set_category( CAT_INTERFACE )
180 set_subcategory( SUBCAT_INTERFACE_MAIN )
182 add_file( "fbosd-dev", "/dev/fb0", NULL, DEVICE_TEXT, DEVICE_LONGTEXT,
184 add_string( "fbosd-aspect-ratio", "", NULL, ASPECT_RATIO_TEXT,
185 ASPECT_RATIO_LONGTEXT, true )
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 )
192 add_integer_with_range( "fbosd-alpha", 255, 0, 255, NULL, ALPHA_TEXT,
193 ALPHA_LONGTEXT, true )
195 set_section( N_("Position"), NULL )
196 add_integer( "fbosd-x", 0, NULL, POSX_TEXT,
197 POSX_LONGTEXT, false )
198 add_integer( "fbosd-y", 0, NULL, POSY_TEXT,
199 POSY_LONGTEXT, false )
200 add_integer( "fbosd-position", 8, NULL, POS_TEXT, POS_LONGTEXT, true )
201 change_integer_list( pi_pos_values, ppsz_pos_descriptions, NULL );
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,
208 change_integer_list( pi_color_values, ppsz_color_descriptions, NULL );
209 add_integer( "fbosd-font-size", -1, NULL, SIZE_TEXT, SIZE_LONGTEXT,
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 )
217 set_description( N_("GNU/Linux osd/overlay framebuffer interface") )
218 set_capability( "interface", 10 )
219 set_callbacks( Create, Destroy )
222 /*****************************************************************************
223 * fbosd_render_t: render descriptor
224 *****************************************************************************/
225 struct fbosd_render_t
227 #define FBOSD_RENDER_IMAGE 0
228 #define FBOSD_RENDER_TEXT 1
231 #define FBOSD_STATE_FREE 0
232 #define FBOSD_STATE_RESERVED 1
233 #define FBOSD_STATE_RENDER 2
237 text_style_t* p_text_style; /* font control */
245 int i_alpha; /* transparency for images */
247 #define FBOSD_RENDER_MAX 10
249 /*****************************************************************************
250 * intf_sys_t: interface framebuffer method descriptor
251 *****************************************************************************/
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 */
261 /* Overlay framebuffer format */
262 video_format_t fmt_out;
263 picture_t *p_overlay;
264 size_t i_page_size; /* page size */
268 int i_bytes_per_pixel;
270 /* Image and Picture rendering */
271 image_handler_t *p_image;
272 #if defined(FBOSD_BLENDING)
273 filter_t *p_blend; /* alpha blending module */
275 filter_t *p_text; /* text renderer module */
278 struct fbosd_render_t render[FBOSD_RENDER_MAX];
281 text_style_t *p_style; /* font control */
289 int i_alpha; /* transparency for images */
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 */
297 /*****************************************************************************
298 * Create: allocates FB interface thread output method
299 *****************************************************************************/
300 static int Create( vlc_object_t *p_this )
302 intf_thread_t *p_intf = (intf_thread_t *)p_this;
308 /* Allocate instance and initialize some members */
309 p_intf->p_sys = p_sys = calloc( 1, sizeof( intf_sys_t ) );
313 p_sys->p_style = text_style_New();
314 if( !p_sys->p_style )
316 free( p_intf->p_sys );
320 p_intf->pf_run = Run;
322 p_sys->p_image = image_HandlerCreate( p_this );
323 if( !p_sys->p_image )
325 text_style_Delete( p_sys->p_style );
330 p_sys->i_alpha = var_CreateGetIntegerCommand( p_intf, "fbosd-alpha" );
331 var_AddCallback( p_intf, "fbosd-alpha", OverlayCallback, NULL );
333 p_sys->i_aspect = -1;
335 var_CreateGetNonEmptyString( p_intf, "fbosd-aspect-ratio" );
338 char *psz_parser = strchr( psz_aspect, ':' );
342 *psz_parser++ = '\0';
343 p_sys->i_aspect = ( atoi( psz_aspect )
344 * VOUT_ASPECT_FACTOR ) / atoi( psz_parser );
345 p_sys->fmt_out.i_aspect = p_sys->i_aspect;
347 msg_Dbg( p_intf, "using aspect ratio %d:%d",
348 atoi( psz_aspect ), atoi( psz_parser ) );
353 /* Use PAL by default */
354 p_sys->i_width = p_sys->fmt_out.i_width = 704;
355 p_sys->i_height = p_sys->fmt_out.i_height = 576;
357 psz_tmp = var_CreateGetNonEmptyStringCommand( p_intf, "fbosd-image" );
358 var_AddCallback( p_intf, "fbosd-image", OverlayCallback, NULL );
359 if( psz_tmp && *psz_tmp )
361 p_sys->render[0].i_type = FBOSD_RENDER_IMAGE;
362 p_sys->render[0].i_state = FBOSD_STATE_RENDER;
363 p_sys->render[0].psz_string = strdup( psz_tmp );
367 psz_tmp = var_CreateGetNonEmptyStringCommand( p_intf, "fbosd-text" );
368 var_AddCallback( p_intf, "fbosd-text", OverlayCallback, NULL );
369 if( psz_tmp && *psz_tmp )
371 p_sys->render[1].i_type = FBOSD_RENDER_TEXT;
372 p_sys->render[1].i_state = FBOSD_STATE_RENDER;
373 p_sys->render[1].psz_string = strdup( psz_tmp );
377 p_sys->i_pos = var_CreateGetIntegerCommand( p_intf, "fbosd-position" );
378 p_sys->i_x = var_CreateGetIntegerCommand( p_intf, "fbosd-x" );
379 p_sys->i_y = var_CreateGetIntegerCommand( p_intf, "fbosd-y" );
381 var_AddCallback( p_intf, "fbosd-position", OverlayCallback, NULL );
382 var_AddCallback( p_intf, "fbosd-x", OverlayCallback, NULL );
383 var_AddCallback( p_intf, "fbosd-y", OverlayCallback, NULL );
385 p_sys->p_style->i_font_size =
386 var_CreateGetIntegerCommand( p_intf, "fbosd-font-size" );
387 p_sys->p_style->i_font_color =
388 var_CreateGetIntegerCommand( p_intf, "fbosd-font-color" );
389 p_sys->p_style->i_font_alpha = 255 -
390 var_CreateGetIntegerCommand( p_intf, "fbosd-font-opacity" );
392 var_AddCallback( p_intf, "fbosd-font-color", OverlayCallback, NULL );
393 var_AddCallback( p_intf, "fbosd-font-size", OverlayCallback, NULL );
394 var_AddCallback( p_intf, "fbosd-font-opacity", OverlayCallback, NULL );
396 for( i = 0; i < FBOSD_RENDER_MAX; i++ )
397 p_sys->render[i].p_text_style = text_style_New();
399 p_sys->b_clear = var_CreateGetBoolCommand( p_intf, "fbosd-clear" );
400 p_sys->b_render = var_CreateGetBoolCommand( p_intf, "fbosd-render" );
401 p_sys->b_need_update = var_CreateGetBoolCommand( p_intf, "fbosd-display" );
403 var_AddCallback( p_intf, "fbosd-clear", OverlayCallback, NULL );
404 var_AddCallback( p_intf, "fbosd-render", OverlayCallback, NULL );
405 var_AddCallback( p_intf, "fbosd-display", OverlayCallback, NULL );
407 /* Check if picture position was overridden */
408 p_sys->b_absolute = true;
409 if( ( p_sys->i_x >= 0 ) && ( p_sys->i_y >= 0 ) )
411 p_sys->b_absolute = false;
412 p_sys->i_y = (p_sys->i_y < p_sys->i_height) ?
413 p_sys->i_y : p_sys->i_height;
414 p_sys->i_x = (p_sys->i_x < p_sys->i_width) ?
415 p_sys->i_x : p_sys->i_width;
418 p_sys->render[0].i_x = p_sys->render[1].i_x = p_sys->i_x;
419 p_sys->render[0].i_y = p_sys->render[1].i_y = p_sys->i_y;
420 p_sys->render[0].i_pos = p_sys->render[1].i_pos = p_sys->i_pos;
421 p_sys->render[0].i_alpha = p_sys->render[1].i_alpha = p_sys->i_alpha;
423 /* Initialize framebuffer */
424 if( OpenDisplay( p_intf ) )
426 Destroy( VLC_OBJECT(p_intf) );
432 #if defined(FBOSD_BLENDING)
433 /* Load the blending module */
434 if( OpenBlending( p_intf ) )
436 msg_Err( p_intf, "Unable to load image blending module" );
437 Destroy( VLC_OBJECT(p_intf) );
442 /* Load text renderer module */
443 if( OpenTextRenderer( p_intf ) )
445 msg_Err( p_intf, "Unable to load text rendering module" );
446 Destroy( VLC_OBJECT(p_intf) );
450 p_sys->b_render = true;
451 p_sys->b_need_update = true;
456 /*****************************************************************************
457 * Destroy: destroy FB interface thread output method
458 *****************************************************************************
459 * Terminate an output method created by Create
460 *****************************************************************************/
461 static void Destroy( vlc_object_t *p_this )
463 intf_thread_t *p_intf = (intf_thread_t *)p_this;
464 intf_sys_t *p_sys = p_intf->p_sys;
468 p_sys->b_need_update = false;
469 p_sys->b_render = false;
470 p_sys->b_clear = false;
472 var_DelCallback( p_intf, "fbosd-alpha", OverlayCallback, NULL );
473 var_Destroy( p_intf, "fbosd-alpha" );
475 var_DelCallback( p_intf, "fbosd-x", OverlayCallback, NULL );
476 var_DelCallback( p_intf, "fbosd-y", OverlayCallback, NULL );
477 var_DelCallback( p_intf, "fbosd-position", OverlayCallback, NULL );
478 var_DelCallback( p_intf, "fbosd-image", OverlayCallback, NULL );
479 var_DelCallback( p_intf, "fbosd-text", OverlayCallback, NULL );
480 var_DelCallback( p_intf, "fbosd-font-size", OverlayCallback, NULL );
481 var_DelCallback( p_intf, "fbosd-font-color", OverlayCallback, NULL );
482 var_DelCallback( p_intf, "fbosd-font-opacity", OverlayCallback, NULL );
483 var_DelCallback( p_intf, "fbosd-clear", OverlayCallback, NULL );
484 var_DelCallback( p_intf, "fbosd-render", OverlayCallback, NULL );
485 var_DelCallback( p_intf, "fbosd-display", OverlayCallback, NULL );
487 var_Destroy( p_intf, "fbosd-x" );
488 var_Destroy( p_intf, "fbosd-y" );
489 var_Destroy( p_intf, "fbosd-position" );
490 var_Destroy( p_intf, "fbosd-image" );
491 var_Destroy( p_intf, "fbosd-text" );
492 var_Destroy( p_intf, "fbosd-font-size" );
493 var_Destroy( p_intf, "fbosd-font-color" );
494 var_Destroy( p_intf, "fbosd-font-opacity" );
495 var_Destroy( p_intf, "fbosd-clear" );
496 var_Destroy( p_intf, "fbosd-render" );
497 var_Destroy( p_intf, "fbosd-display" );
499 var_Destroy( p_intf, "fbosd-aspect-ratio" );
501 CloseDisplay( p_intf );
503 for( i = 0; i < FBOSD_RENDER_MAX; i++ )
505 free( p_sys->render[i].psz_string );
506 p_sys->render[i].i_state = FBOSD_STATE_FREE;
507 text_style_Delete( p_sys->render[i].p_text_style );
510 #if defined(FBOSD_BLENDING)
511 if( p_sys->p_blend ) CloseBlending( p_intf );
513 if( p_sys->p_text ) CloseTextRenderer( p_intf );
516 image_HandlerDelete( p_sys->p_image );
517 if( p_sys->p_overlay )
518 picture_Release( p_sys->p_overlay );
520 text_style_Delete( p_sys->p_style );
524 #if defined(FBOSD_BLENDING)
525 static int OpenBlending( intf_thread_t *p_intf )
527 if( p_intf->p_sys->p_blend ) return VLC_EGENERIC;
529 p_intf->p_sys->p_blend =
530 vlc_object_create( p_intf, sizeof(filter_t) );
531 vlc_object_attach( p_intf->p_sys->p_blend, p_intf );
532 p_intf->p_sys->p_blend->fmt_out.video.i_x_offset =
533 p_intf->p_sys->p_blend->fmt_out.video.i_y_offset = 0;
534 p_intf->p_sys->p_blend->fmt_out.video.i_aspect =
535 p_intf->p_sys->fmt_out.i_aspect;
536 p_intf->p_sys->p_blend->fmt_out.video.i_chroma =
537 p_intf->p_sys->fmt_out.i_chroma;
538 if( config_GetInt( p_intf, "freetype-yuvp" ) )
539 p_intf->p_sys->p_blend->fmt_in.video.i_chroma =
540 VLC_FOURCC('Y','U','V','P');
542 p_intf->p_sys->p_blend->fmt_in.video.i_chroma =
543 VLC_FOURCC('Y','U','V','A');
545 p_intf->p_sys->p_blend->p_module =
546 module_need( p_intf->p_sys->p_blend, "video blending", NULL, false );
548 if( !p_intf->p_sys->p_blend->p_module )
554 static void CloseBlending( intf_thread_t *p_intf )
556 if( p_intf->p_sys->p_blend )
558 if( p_intf->p_sys->p_blend->p_module )
559 module_unneed( p_intf->p_sys->p_blend,
560 p_intf->p_sys->p_blend->p_module );
562 vlc_object_detach( p_intf->p_sys->p_blend );
563 vlc_object_release( p_intf->p_sys->p_blend );
568 static int OpenTextRenderer( intf_thread_t *p_intf )
570 char *psz_modulename = NULL;
572 if( p_intf->p_sys->p_text ) return VLC_EGENERIC;
574 p_intf->p_sys->p_text =
575 vlc_object_create( p_intf, sizeof(filter_t) );
576 vlc_object_attach( p_intf->p_sys->p_text, p_intf );
578 p_intf->p_sys->p_text->fmt_out.video.i_width =
579 p_intf->p_sys->p_text->fmt_out.video.i_visible_width =
580 p_intf->p_sys->i_width;
581 p_intf->p_sys->p_text->fmt_out.video.i_height =
582 p_intf->p_sys->p_text->fmt_out.video.i_visible_height =
583 p_intf->p_sys->i_height;
585 psz_modulename = var_CreateGetString( p_intf, "text-renderer" );
586 if( psz_modulename && *psz_modulename )
588 p_intf->p_sys->p_text->p_module =
589 module_need( p_intf->p_sys->p_text, "text renderer",
590 psz_modulename, true );
592 if( !p_intf->p_sys->p_text->p_module )
594 p_intf->p_sys->p_text->p_module =
595 module_need( p_intf->p_sys->p_text, "text renderer", NULL, false );
597 free( psz_modulename );
599 if( !p_intf->p_sys->p_text->p_module )
605 static void CloseTextRenderer( intf_thread_t *p_intf )
607 if( p_intf->p_sys->p_text )
609 if( p_intf->p_sys->p_text->p_module )
610 module_unneed( p_intf->p_sys->p_text,
611 p_intf->p_sys->p_text->p_module );
613 vlc_object_detach( p_intf->p_sys->p_text );
614 vlc_object_release( p_intf->p_sys->p_text );
618 /*****************************************************************************
620 * allocate a picture buffer for use with the overlay fb.
621 *****************************************************************************/
622 static picture_t *AllocatePicture( video_format_t *p_fmt )
624 picture_t *p_picture = picture_New( p_fmt->i_chroma,
625 p_fmt->i_width, p_fmt->i_height,
630 if( !p_fmt->p_palette &&
631 ( p_fmt->i_chroma == VLC_FOURCC('Y','U','V','P') ) )
633 p_fmt->p_palette = malloc( sizeof(video_palette_t) );
634 if( !p_fmt->p_palette )
636 picture_Release( p_picture );
642 p_fmt->p_palette = NULL;
648 /*****************************************************************************
650 * Deallocate a picture buffer and free all associated memory.
651 *****************************************************************************/
652 static void DeAllocatePicture( picture_t *p_pic, video_format_t *p_fmt )
656 free( p_fmt->p_palette );
657 p_fmt->p_palette = NULL;
661 picture_Release( p_pic );
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,
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;
678 if( p_sys->p_overlay )
680 msg_Dbg( p_intf, "Make overlay %s",
681 b_transparent ? "transparent" : "opaque" );
683 memset( p_sys->p_overlay->p[0].p_pixels, 0xFF, i_page_size );
685 memset( p_sys->p_overlay->p[0].p_pixels, 0x00, i_page_size );
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 )
697 intf_sys_t *p_sys = p_intf->p_sys;
698 if( p_sys->p_blend && p_sys->p_blend->p_module )
700 int i_x_offset = p_sys->i_x;
701 int i_y_offset = p_sys->i_y;
703 memcpy( &p_sys->p_blend->fmt_in.video, p_fmt_src, sizeof( video_format_t ) );
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 =
709 p_sys->p_blend->fmt_out.video.i_height =
710 p_sys->p_blend->fmt_out.video.i_visible_height =
713 i_x_offset = __MAX( i_x_offset, 0 );
714 i_y_offset = __MAX( i_y_offset, 0 );
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,
725 static int InvertAlpha( intf_thread_t *p_intf, picture_t **p_pic, video_format_t fmt )
727 uint8_t *p_begin = NULL, *p_end = NULL;
730 if( *p_pic && ((*p_pic)->i_planes != 1) )
733 "cannot invert alpha channel too many planes %d (only 1 supported)",
734 (*p_pic)->i_planes );
738 switch( fmt.i_chroma )
740 case VLC_FOURCC('R','V','2','4'):
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 );
746 case VLC_FOURCC('R','V','3','2'):
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 );
753 msg_Err( p_intf, "cannot invert alpha channel chroma not supported %4.4s",
754 (char *)&fmt.i_chroma );
758 for( ; p_begin < p_end; p_begin += i_skip )
760 uint8_t i_opacity = 0;
762 if( *p_begin != 0xFF )
763 i_opacity = 255 - *p_begin;
764 *p_begin = i_opacity;
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 )
780 VLC_UNUSED( p_intf );
782 if( !p_dest && !p_src ) return VLC_EGENERIC;
784 for( i = 0; i < p_src->i_planes ; i++ )
786 if( p_src->p[i].i_pitch == p_dest->p[i].i_pitch )
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 );
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;
798 int i_x = i_x_offset * p_src->p[i].i_pixel_pitch;
799 int i_x_clip, i_y_clip;
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;
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 );
812 if( ( i_y_offset <= p_dest->p[i].i_visible_lines ) &&
813 ( i_x <= p_dest->p[i].i_visible_pitch ) )
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++ )
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;
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 )
837 intf_sys_t *p_sys = p_intf->p_sys;
838 subpicture_region_t *p_region;
839 picture_t *p_dest = NULL;
841 if( !psz_string ) return p_dest;
843 if( p_sys->p_text && p_sys->p_text->p_module )
847 memset( &fmt, 0, sizeof(fmt) );
848 fmt.i_chroma = VLC_FOURCC('T','E','X','T');
850 fmt.i_width = fmt.i_visible_width = 0;
851 fmt.i_height = fmt.i_visible_height = 0;
855 p_region = subpicture_region_New( &fmt );
859 p_region->psz_text = strdup( psz_string );
860 if( !p_region->psz_text )
862 subpicture_region_Delete( p_region );
865 p_region->p_style = text_style_Duplicate( p_style );
866 p_region->i_align = OSD_ALIGN_LEFT | OSD_ALIGN_TOP;
868 if( p_sys->p_text->pf_render_text )
870 video_format_t fmt_out;
872 memset( &fmt_out, 0, sizeof(video_format_t) );
874 p_sys->p_text->pf_render_text( p_sys->p_text,
875 p_region, p_region );
877 #if defined(FBOSD_BLENDING)
878 fmt_out = p_region->fmt;
879 fmt_out.i_bits_per_pixel = 32;
880 vlc_memcpy( p_fmt, &fmt_out, sizeof(video_format_t) );
882 /* FIXME not needed to copy the picture anymore no ? */
883 p_dest = AllocatePicture( VLC_OBJECT(p_intf), &fmt_out );
886 subpicture_region_Delete( p_region );
889 picture_Copy( p_dest, p_region->p_picture );
891 fmt_out.i_chroma = p_fmt->i_chroma;
892 p_dest = ConvertImage( p_intf, p_region->p_picture,
893 &p_region->fmt, &fmt_out );
895 subpicture_region_Delete( p_region );
898 subpicture_region_Delete( p_region );
903 /*****************************************************************************
904 * LoadImage: Load an image from file into a picture buffer.
905 *****************************************************************************/
906 static picture_t *LoadImage( intf_thread_t *p_intf, video_format_t *p_fmt,
909 picture_t *p_pic = NULL;
911 if( psz_file && p_intf->p_sys->p_image )
913 video_format_t fmt_in, fmt_out;
915 memset( &fmt_in, 0, sizeof(fmt_in) );
916 memset( &fmt_out, 0, sizeof(fmt_out) );
918 fmt_out.i_chroma = p_fmt->i_chroma;
919 p_pic = image_ReadUrl( p_intf->p_sys->p_image, psz_file,
922 msg_Dbg( p_intf, "image size %dx%d chroma %4.4s",
923 fmt_out.i_width, fmt_out.i_height,
924 (char *)&p_fmt->i_chroma );
929 #if ! defined(FBOSD_BLENDING)
930 /*****************************************************************************
931 * Convertmage: Convert image to another fourcc
932 *****************************************************************************/
933 static picture_t *ConvertImage( intf_thread_t *p_intf, picture_t *p_pic,
934 video_format_t *p_fmt_in, video_format_t *p_fmt_out )
936 intf_sys_t *p_sys = p_intf->p_sys;
937 picture_t *p_old = NULL;
941 p_old = image_Convert( p_sys->p_image, p_pic, p_fmt_in, p_fmt_out );
943 msg_Dbg( p_intf, "converted image size %dx%d chroma %4.4s",
944 p_fmt_out->i_width, p_fmt_out->i_height,
945 (char *)&p_fmt_out->i_chroma );
951 /*****************************************************************************
952 * Init: initialize framebuffer video thread output method
953 *****************************************************************************/
954 static int Init( intf_thread_t *p_intf )
956 intf_sys_t *p_sys = p_intf->p_sys;
958 /* Initialize the output structure: RGB with square pixels, whatever
959 * the input format is, since it's the only format we know */
960 switch( p_sys->var_info.bits_per_pixel )
962 case 8: /* FIXME: set the palette */
963 p_sys->fmt_out.i_chroma = VLC_FOURCC('R','G','B','2'); break;
965 p_sys->fmt_out.i_chroma = VLC_FOURCC('R','V','1','5'); break;
967 p_sys->fmt_out.i_chroma = VLC_FOURCC('R','V','1','6'); break;
969 p_sys->fmt_out.i_chroma = VLC_FOURCC('R','V','2','4'); break;
971 p_sys->fmt_out.i_chroma = VLC_FOURCC('R','V','3','2'); break;
973 msg_Err( p_intf, "unknown screen depth %i",
974 p_sys->var_info.bits_per_pixel );
978 p_sys->fmt_out.i_bits_per_pixel = p_sys->var_info.bits_per_pixel;
979 p_sys->fmt_out.i_width = p_sys->i_width;
980 p_sys->fmt_out.i_height = p_sys->i_height;
982 /* Assume we have square pixels */
983 if( p_sys->i_aspect < 0 )
985 p_sys->fmt_out.i_aspect = ( p_sys->i_width
986 * VOUT_ASPECT_FACTOR ) / p_sys->i_height;
988 else p_sys->fmt_out.i_aspect = p_sys->i_aspect;
990 p_sys->fmt_out.i_sar_num = p_sys->fmt_out.i_sar_den = 1;
992 /* Allocate overlay buffer */
993 p_sys->p_overlay = AllocatePicture( &p_sys->fmt_out );
994 if( !p_sys->p_overlay ) return VLC_EGENERIC;
996 SetOverlayTransparency( p_intf, true );
998 /* We know the chroma, allocate a buffer which will be used
999 * to write to the overlay framebuffer */
1000 p_sys->p_overlay->p->i_pixel_pitch = p_sys->i_bytes_per_pixel;
1001 p_sys->p_overlay->p->i_lines = p_sys->var_info.yres;
1002 p_sys->p_overlay->p->i_visible_lines = p_sys->var_info.yres;
1004 if( p_sys->var_info.xres_virtual )
1006 p_sys->p_overlay->p->i_pitch = p_sys->var_info.xres_virtual
1007 * p_sys->i_bytes_per_pixel;
1011 p_sys->p_overlay->p->i_pitch = p_sys->var_info.xres
1012 * p_sys->i_bytes_per_pixel;
1015 p_sys->p_overlay->p->i_visible_pitch = p_sys->var_info.xres
1016 * p_sys->i_bytes_per_pixel;
1018 p_sys->p_overlay->i_planes = 1;
1023 /*****************************************************************************
1024 * End: terminate framebuffer interface
1025 *****************************************************************************/
1026 static void End( intf_thread_t *p_intf )
1028 intf_sys_t *p_sys = p_intf->p_sys;
1031 SetOverlayTransparency( p_intf, false );
1032 if( p_sys->p_overlay )
1035 ret = write( p_sys->i_fd, p_sys->p_overlay->p[0].p_pixels,
1036 p_sys->i_page_size );
1038 msg_Err( p_intf, "unable to clear overlay" );
1041 DeAllocatePicture( p_intf->p_sys->p_overlay,
1042 &p_intf->p_sys->fmt_out );
1043 p_intf->p_sys->p_overlay = NULL;
1046 /*****************************************************************************
1047 * OpenDisplay: initialize framebuffer
1048 *****************************************************************************/
1049 static int OpenDisplay( intf_thread_t *p_intf )
1051 intf_sys_t *p_sys = p_intf->p_sys;
1052 char *psz_device; /* framebuffer device path */
1053 struct fb_fix_screeninfo fix_info; /* framebuffer fix information */
1055 /* Open framebuffer device */
1056 if( !(psz_device = config_GetPsz( p_intf, "fbosd-dev" )) )
1058 msg_Err( p_intf, "don't know which fb osd/overlay device to open" );
1059 return VLC_EGENERIC;
1062 p_sys->i_fd = open( psz_device, O_RDWR );
1063 if( p_sys->i_fd == -1 )
1065 msg_Err( p_intf, "cannot open %s (%s)", psz_device, strerror(errno) );
1067 return VLC_EGENERIC;
1071 /* Get framebuffer device information */
1072 if( ioctl( p_sys->i_fd, FBIOGET_VSCREENINFO, &p_sys->var_info ) )
1074 msg_Err( p_intf, "cannot get fb info (%s)", strerror(errno) );
1075 close( p_sys->i_fd );
1076 return VLC_EGENERIC;
1079 /* Get some info on the framebuffer itself */
1080 if( ioctl( p_sys->i_fd, FBIOGET_FSCREENINFO, &fix_info ) == 0 )
1082 p_sys->i_width = p_sys->fmt_out.i_width = p_sys->var_info.xres;
1083 p_sys->i_height = p_sys->fmt_out.i_height = p_sys->var_info.yres;
1086 /* FIXME: if the image is full-size, it gets cropped on the left
1087 * because of the xres / xres_virtual slight difference */
1088 msg_Dbg( p_intf, "%ix%i (virtual %ix%i)",
1089 p_sys->var_info.xres, p_sys->var_info.yres,
1090 p_sys->var_info.xres_virtual,
1091 p_sys->var_info.yres_virtual );
1093 p_sys->fmt_out.i_width = p_sys->i_width;
1094 p_sys->fmt_out.i_height = p_sys->i_height;
1096 p_sys->p_palette = NULL;
1097 p_sys->b_pan = ( fix_info.ypanstep || fix_info.ywrapstep );
1099 switch( p_sys->var_info.bits_per_pixel )
1102 p_sys->p_palette = malloc( 8 * 256 * sizeof( uint16_t ) );
1103 if( !p_sys->p_palette )
1105 close( p_sys->i_fd );
1108 p_sys->fb_cmap.start = 0;
1109 p_sys->fb_cmap.len = 256;
1110 p_sys->fb_cmap.red = p_sys->p_palette;
1111 p_sys->fb_cmap.green = p_sys->p_palette + 256 * sizeof( uint16_t );
1112 p_sys->fb_cmap.blue = p_sys->p_palette + 2 * 256 * sizeof( uint16_t );
1113 p_sys->fb_cmap.transp = p_sys->p_palette + 3 * 256 * sizeof( uint16_t );
1115 /* Save the colormap */
1116 ioctl( p_sys->i_fd, FBIOGETCMAP, &p_sys->fb_cmap );
1118 p_sys->i_bytes_per_pixel = 1;
1123 p_sys->i_bytes_per_pixel = 2;
1127 p_sys->i_bytes_per_pixel = 3;
1131 p_sys->i_bytes_per_pixel = 4;
1135 msg_Err( p_intf, "screen depth %d is not supported",
1136 p_sys->var_info.bits_per_pixel );
1138 close( p_sys->i_fd );
1139 return VLC_EGENERIC;
1142 p_sys->i_page_size = p_sys->i_width * p_sys->i_height
1143 * p_sys->i_bytes_per_pixel;
1145 msg_Dbg( p_intf, "framebuffer type=%d, visual=%d, ypanstep=%d, "
1146 "ywrap=%d, accel=%d", fix_info.type, fix_info.visual,
1147 fix_info.ypanstep, fix_info.ywrapstep, fix_info.accel );
1151 /*****************************************************************************
1152 * CloseDisplay: terminate FB interface thread
1153 *****************************************************************************/
1154 static void CloseDisplay( intf_thread_t *p_intf )
1156 intf_sys_t *p_sys = p_intf->p_sys;
1158 /* Restore palette */
1159 if( p_sys->var_info.bits_per_pixel == 8 )
1161 ioctl( p_sys->i_fd, FBIOPUTCMAP, &p_sys->fb_cmap );
1162 free( p_sys->p_palette );
1163 p_sys->p_palette = NULL;
1167 close( p_sys->i_fd );
1170 static void Render( intf_thread_t *p_intf, struct fbosd_render_t *render )
1172 intf_sys_t *p_sys = p_intf->p_sys;
1174 if( render->i_state != FBOSD_STATE_RENDER ) return;
1175 if( !render->psz_string ) return;
1177 if( render->i_type == FBOSD_RENDER_IMAGE )
1180 p_pic = LoadImage( p_intf, &p_sys->fmt_out, render->psz_string );
1183 RenderPicture( p_intf, render->i_x, render->i_y,
1184 p_pic, p_sys->p_overlay );
1185 picture_Release( p_pic );
1188 else if( render->i_type == FBOSD_RENDER_TEXT )
1191 #if defined(FBOSD_BLENDING)
1192 video_format_t fmt_in;
1193 memset( &fmt_in, 0, sizeof(video_format_t) );
1194 p_text = RenderText( p_intf, render->psz_string, render->p_text_style,
1198 BlendPicture( p_intf, &fmt_in, &p_sys->fmt_out,
1199 p_text, p_sys->p_overlay );
1200 msg_Dbg( p_intf, "releasing picture" );
1201 DeAllocatePicture( p_text, &fmt_in );
1204 p_text = RenderText( p_intf, render->psz_string, render->p_text_style,
1208 RenderPicture( p_intf, render->i_x, render->i_y,
1209 p_text, p_sys->p_overlay );
1210 picture_Release( p_text );
1216 static void RenderClear( intf_thread_t *p_intf, struct fbosd_render_t *render )
1218 intf_sys_t *p_sys = p_intf->p_sys;
1220 text_style_Delete( render->p_text_style );
1221 render->p_text_style = text_style_New();
1222 free( render->psz_string );
1223 render->psz_string = NULL;
1225 render->i_x = p_sys->i_x;
1226 render->i_y = p_sys->i_y;
1227 render->i_pos = p_sys->i_pos;
1228 render->i_alpha = p_sys->i_alpha;
1229 render->b_absolute = p_sys->b_absolute;
1230 render->i_state = FBOSD_STATE_FREE;
1233 static bool isRendererReady( intf_thread_t *p_intf )
1235 intf_sys_t *p_sys = p_intf->p_sys;
1238 /* Check if there are more items to render */
1239 for( i = 0; i < FBOSD_RENDER_MAX; i++ )
1241 if( p_sys->render[i].i_state == FBOSD_STATE_RESERVED )
1247 /*****************************************************************************
1249 *****************************************************************************
1250 * This part of the interface is in a separate thread so that we can call
1251 * exec() from within it without annoying the rest of the program.
1252 *****************************************************************************/
1253 static void Run( intf_thread_t *p_intf )
1255 intf_sys_t *p_sys = p_intf->p_sys;
1256 int canc = vlc_savecancel();
1258 while( vlc_object_alive( p_intf ) )
1262 /* Is there somthing to render? */
1263 for( i = 0; i < FBOSD_RENDER_MAX; i++ )
1265 if( p_sys->render[i].i_state == FBOSD_STATE_RENDER )
1267 Render( p_intf, &p_sys->render[i] );
1268 RenderClear( p_intf, &p_sys->render[i] );
1272 if( p_sys->b_clear )
1274 SetOverlayTransparency( p_intf, true );
1276 var_SetString( p_intf, "fbosd-image", "" );
1277 var_SetString( p_intf, "fbosd-text", "" );
1279 p_sys->b_clear = false;
1280 p_sys->b_need_update = true;
1283 if( p_sys->b_need_update && p_sys->p_overlay &&
1284 isRendererReady( p_intf ) )
1287 #if defined(FBOSD_BLENDING)
1288 /* Reverse alpha channel to work around FPGA bug */
1289 InvertAlpha( p_intf, &p_sys->p_overlay, p_sys->fmt_out );
1291 ret = write( p_sys->i_fd, p_sys->p_overlay->p[0].p_pixels,
1292 p_sys->i_page_size );
1294 msg_Err( p_intf, "unable to write to overlay" );
1295 lseek( p_sys->i_fd, 0, SEEK_SET );
1297 /* clear the picture */
1298 memset( p_sys->p_overlay->p[0].p_pixels, 0xFF, p_sys->i_page_size );
1299 p_sys->b_need_update = false;
1302 msleep( INTF_IDLE_SLEEP );
1306 vlc_restorecancel( canc );
1309 static int OverlayCallback( vlc_object_t *p_this, char const *psz_cmd,
1310 vlc_value_t oldval, vlc_value_t newval, void *p_data )
1312 intf_thread_t *p_intf = (intf_thread_t *) p_this;
1313 intf_sys_t *p_sys = p_intf->p_sys;
1314 VLC_UNUSED(oldval); VLC_UNUSED(p_data);
1316 if( !strncmp( psz_cmd, "fbosd-display", 13 ) )
1318 p_sys->b_need_update = true;
1320 else if( !strncmp( psz_cmd, "fbosd-clear", 11 ) )
1323 /* Clear the entire render list */
1324 for( i = 0; i < FBOSD_RENDER_MAX; i++ )
1326 RenderClear( p_intf, &p_sys->render[i] );
1328 p_sys->b_clear = true;
1330 else if( !strncmp( psz_cmd, "fbosd-render", 12 ) )
1333 /* Are we already busy with on slot ? */
1334 for( i = 0; i < FBOSD_RENDER_MAX; i++ )
1336 if( p_sys->render[i].i_state == FBOSD_STATE_RESERVED )
1338 p_sys->render[i].i_state = FBOSD_STATE_RENDER;
1346 /* Are we already busy with on slot ? */
1347 for( i = 0; i < FBOSD_RENDER_MAX; i++ )
1349 if( p_sys->render[i].i_state == FBOSD_STATE_RESERVED )
1352 /* No, then find first FREE slot */
1353 if( p_sys->render[i].i_state != FBOSD_STATE_RESERVED )
1355 for( i = 0; i < FBOSD_RENDER_MAX; i++ )
1357 if( p_sys->render[i].i_state == FBOSD_STATE_FREE )
1360 if( p_sys->render[i].i_state != FBOSD_STATE_FREE )
1362 msg_Warn( p_this, "render space depleated" );
1366 /* Found a free slot */
1367 p_sys->render[i].i_state = FBOSD_STATE_RESERVED;
1368 if( !strncmp( psz_cmd, "fbosd-image", 11 ) )
1370 free( p_sys->render[i].psz_string );
1371 p_sys->render[i].psz_string = strdup( newval.psz_string );
1372 p_sys->render[i].i_type = FBOSD_RENDER_IMAGE;
1374 else if( !strncmp( psz_cmd, "fbosd-text", 10 ) )
1376 free( p_sys->render[i].psz_string );
1377 p_sys->render[i].psz_string = strdup( newval.psz_string );
1378 p_sys->render[i].i_type = FBOSD_RENDER_TEXT;
1380 else if( !strncmp( psz_cmd, "fbosd-x", 7 ) )
1382 p_sys->render[i].b_absolute = false;
1383 p_sys->render[i].i_x = (newval.i_int < p_sys->i_width) ?
1384 newval.i_int : p_sys->i_width;
1386 else if( !strncmp( psz_cmd, "fbosd-y", 7 ) )
1388 p_sys->render[i].b_absolute = false;
1389 p_sys->render[i].i_y = (newval.i_int < p_sys->i_height) ?
1390 newval.i_int : p_sys->i_height;
1392 else if( !strncmp( psz_cmd, "fbosd-position", 14 ) )
1394 p_sys->render[i].b_absolute = true;
1395 p_sys->render[i].i_pos = newval.i_int;
1397 else if( !strncmp( psz_cmd, "fbosd-font-size", 15 ) )
1399 p_sys->render[i].p_text_style->i_font_size = newval.i_int;
1401 else if( !strncmp( psz_cmd, "fbosd-font-color", 16 ) )
1403 p_sys->render[i].p_text_style->i_font_color = newval.i_int;
1405 else if( !strncmp( psz_cmd, "fbosd-font-opacity", 18 ) )
1407 p_sys->render[i].p_text_style->i_font_alpha = 255 - newval.i_int;
1409 else if( !strncmp( psz_cmd, "fbosd-alpha", 11 ) )
1411 p_sys->render[i].i_alpha = newval.i_int;