git.sesse.net Git - vlc/blob - modules/gui/fbosd.c

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