开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 查看源码
logo.c
资源名称：vlc-0.8.1.tar.gz　[点击查看]
上传用户：riyaled888
上传日期：2009-03-27
资源大小：7338k
文件大小：23k
源码类别：

多媒体

开发平台：

MultiPlatform

logo.c：源码内容
  1. /*****************************************************************************
  2.  * logo.c : logo video plugin for vlc
  3.  *****************************************************************************
  4.  * Copyright (C) 2003-2004 VideoLAN
  5.  * $Id: logo.c 9268 2004-11-10 13:01:48Z gbazin $
  6.  *
  7.  * Authors: Gildas Bazin <gbazin@videolan.org>
  8.  *          Simon Latapie <garf@videolan.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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  23.  *****************************************************************************/
  25. /*****************************************************************************
  26.  * Preamble
  27.  *****************************************************************************/
  28. #include <stdlib.h>                                      /* malloc(), free() */
  29. #include <string.h>
  31. #include <png.h>
  33. #include <vlc/vlc.h>
  34. #include <vlc/vout.h>
  36. #include "vlc_filter.h"
  37. #include "filter_common.h"
  39. /*****************************************************************************
  40.  * Local prototypes
  41.  *****************************************************************************/
  42. static int  Create    ( vlc_object_t * );
  43. static void Destroy   ( vlc_object_t * );
  45. static int  Init      ( vout_thread_t * );
  46. static void End       ( vout_thread_t * );
  47. static void Render    ( vout_thread_t *, picture_t * );
  49. static int  SendEvents( vlc_object_t *, char const *,
  50.                         vlc_value_t, vlc_value_t, void * );
  51. static int MouseEvent ( vlc_object_t *, char const *,
  52.                         vlc_value_t , vlc_value_t , void * );
  53. static int Control    ( vout_thread_t *, int, va_list );
  55. static int  CreateFilter ( vlc_object_t * );
  56. static void DestroyFilter( vlc_object_t * );
  58. /*****************************************************************************
  59.  * Module descriptor
  60.  *****************************************************************************/
  61. #define FILE_TEXT N_("Logo filename")
  62. #define FILE_LONGTEXT N_("Full path of the PNG file to use.")
  63. #define POSX_TEXT N_("X coordinate of the logo")
  64. #define POSX_LONGTEXT N_("You can move the logo by left-clicking on it." )
  65. #define POSY_TEXT N_("Y coordinate of the logo")
  66. #define POSY_LONGTEXT N_("You can move the logo by left-clicking on it." )
  67. #define TRANS_TEXT N_("Transparency of the logo")
  68. #define TRANS_LONGTEXT N_("You can set the logo transparency value here " 
  69.   "(from 0 for full transparency to 255 for full opacity)." )
  70. #define POS_TEXT N_("Logo position")
  71. #define POS_LONGTEXT N_( 
  72.   "You can enforce the logo position on the video " 
  73.   "(0=center, 1=left, 2=right, 4=top, 8=bottom, you can " 
  74.   "also use combinations of these values).")
  76. static int pi_pos_values[] = { 0, 1, 2, 4, 8, 5, 6, 9, 10 };
  77. static char *ppsz_pos_descriptions[] =
  78. { N_("Center"), N_("Left"), N_("Right"), N_("Top"), N_("Bottom"),
  79.   N_("Top-Left"), N_("Top-Right"), N_("Bottom-Left"), N_("Bottom-Right") };
  81. vlc_module_begin();
  82.     set_description( _("Logo video filter") );
  83.     set_capability( "video filter", 0 );
  84.     add_shortcut( "logo" );
  85.     set_callbacks( Create, Destroy );
  87.     add_file( "logo-file", NULL, NULL, FILE_TEXT, FILE_LONGTEXT, VLC_FALSE );
  88.     add_integer( "logo-x", -1, NULL, POSX_TEXT, POSX_LONGTEXT, VLC_FALSE );
  89.     add_integer( "logo-y", -1, NULL, POSY_TEXT, POSY_LONGTEXT, VLC_FALSE );
  90.     add_integer_with_range( "logo-transparency", 255, 0, 255, NULL,
  91.         TRANS_TEXT, TRANS_LONGTEXT, VLC_FALSE );
  92.     add_integer( "logo-position", 6, NULL, POS_TEXT, POS_LONGTEXT, VLC_TRUE );
  93.         change_integer_list( pi_pos_values, ppsz_pos_descriptions, 0 );
  95.     /* subpicture filter submodule */
  96.     add_submodule();
  97.     set_capability( "sub filter", 0 );
  98.     set_callbacks( CreateFilter, DestroyFilter );
  99.     set_description( _("Logo sub filter") );
  100.     add_shortcut( "logo" );
  101. vlc_module_end();
  103. /*****************************************************************************
  104.  * LoadPNG: loads the PNG logo into memory
  105.  *****************************************************************************/
  106. static picture_t *LoadPNG( vlc_object_t *p_this )
  107. {
  108.     picture_t *p_pic;
  109.     char *psz_filename;
  110.     vlc_value_t val;
  111.     FILE *file;
  112.     int i, j, i_trans;
  113.     vlc_bool_t b_alpha = VLC_TRUE;
  115.     png_uint_32 i_width, i_height;
  116.     int i_color_type, i_interlace_type, i_compression_type, i_filter_type;
  117.     int i_bit_depth;
  118.     png_bytep *p_row_pointers;
  119.     png_structp p_png;
  120.     png_infop p_info, p_end_info;
  122.     var_Create( p_this, "logo-file", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
  123.     var_Get( p_this, "logo-file", &val );
  124.     psz_filename = val.psz_string;
  125.     if( !psz_filename || !*psz_filename )
  126.     {
  127.         msg_Err( p_this, "logo file not specified" );
  128.         return 0;
  129.     }
  131.     if( !(file = fopen( psz_filename , "rb" )) )
  132.     {
  133.         msg_Err( p_this, "logo file (%s) not found", psz_filename );
  134.         free( psz_filename );
  135.         return 0;
  136.     }
  137.     free( psz_filename );
  139.     p_png = png_create_read_struct( PNG_LIBPNG_VER_STRING, 0, 0, 0 );
  140.     p_info = png_create_info_struct( p_png );
  141.     p_end_info = png_create_info_struct( p_png );
  142.     png_init_io( p_png, file );
  143.     png_read_info( p_png, p_info );
  144.     png_get_IHDR( p_png, p_info, &i_width, &i_height,
  145.                   &i_bit_depth, &i_color_type, &i_interlace_type,
  146.                   &i_compression_type, &i_filter_type);
  148.     if( i_color_type == PNG_COLOR_TYPE_PALETTE )
  149.         png_set_palette_to_rgb( p_png );
  151.     if( i_color_type == PNG_COLOR_TYPE_GRAY ||
  152.         i_color_type == PNG_COLOR_TYPE_GRAY_ALPHA )
  153.           png_set_gray_to_rgb( p_png );
  155.     if( png_get_valid( p_png, p_info, PNG_INFO_tRNS ) )
  156.     {
  157.         png_set_tRNS_to_alpha( p_png );
  158.     }
  159.     else if( !(i_color_type & PNG_COLOR_MASK_ALPHA) )
  160.     {
  161.         b_alpha = VLC_FALSE;
  162.     }
  164.     p_row_pointers = malloc( sizeof(png_bytep) * i_height );
  165.     for( i = 0; i < (int)i_height; i++ )
  166.         p_row_pointers[i] = malloc( 4 * ( i_bit_depth + 7 ) / 8 * i_width );
  168.     png_read_image( p_png, p_row_pointers );
  169.     png_read_end( p_png, p_end_info );
  171.     fclose( file );
  172.     png_destroy_read_struct( &p_png, &p_info, &p_end_info );
  174.     /* Convert to YUVA */
  175.     p_pic = malloc( sizeof(picture_t) );
  176.     if( vout_AllocatePicture( p_this, p_pic, VLC_FOURCC('Y','U','V','A'),
  177.                               i_width, i_height, VOUT_ASPECT_FACTOR ) !=
  178.         VLC_SUCCESS )
  179.     {
  180.         for( i = 0; i < (int)i_height; i++ ) free( p_row_pointers[i] );
  181.         free( p_row_pointers );
  182.         return 0;
  183.     }
  185.     var_Create(p_this, "logo-transparency", VLC_VAR_INTEGER|VLC_VAR_DOINHERIT);
  186.     var_Get( p_this, "logo-transparency", &val );
  187.     i_trans = __MAX( __MIN( val.i_int, 255 ), 0 );
  189.     for( j = 0; j < (int)i_height ; j++ )
  190.     {
  191.         uint8_t *p = (uint8_t *)p_row_pointers[j];
  193.         for( i = 0; i < (int)i_width ; i++ )
  194.         {
  195.             int i_offset = i + j * p_pic->p[Y_PLANE].i_pitch;
  197.             p_pic->p[Y_PLANE].p_pixels[i_offset] =
  198.                 (p[0] * 257L + p[1] * 504 + p[2] * 98)/1000 + 16;
  199.             p_pic->p[U_PLANE].p_pixels[i_offset] =
  200.                 (p[2] * 439L - p[0] * 148 - p[1] * 291)/1000 + 128;
  201.             p_pic->p[V_PLANE].p_pixels[i_offset] =
  202.                 (p[0] * 439L - p[1] * 368 - p[2] * 71)/1000 + 128;
  203.             p_pic->p[A_PLANE].p_pixels[i_offset] =
  204.                 b_alpha ? (p[3] * i_trans) / 255 : i_trans;
  206.             p += (b_alpha ? 4 : 3);
  207.         }
  208.     }
  210.     for( i = 0; i < (int)i_height; i++ ) free( p_row_pointers[i] );
  211.     free( p_row_pointers );
  212.     return p_pic;
  213. }
  215. /*****************************************************************************
  216.  * vout_sys_t: logo video output method descriptor
  217.  *****************************************************************************
  218.  * This structure is part of the video output thread descriptor.
  219.  * It describes the Invert specific properties of an output thread.
  220.  *****************************************************************************/
  221. struct vout_sys_t
  222. {
  223.     vout_thread_t *p_vout;
  225.     filter_t *p_blend;
  226.     picture_t *p_pic;
  228.     int i_width, i_height;
  229.     int pos, posx, posy;
  230. };
  232. /*****************************************************************************
  233.  * Create: allocates logo video thread output method
  234.  *****************************************************************************/
  235. static int Create( vlc_object_t *p_this )
  236. {
  237.     vout_thread_t *p_vout = (vout_thread_t *)p_this;
  238.     vout_sys_t *p_sys;
  239.     vlc_value_t val;
  241.     /* Allocate structure */
  242.     p_sys = p_vout->p_sys = malloc( sizeof( vout_sys_t ) );
  243.     if( p_sys == NULL )
  244.     {
  245.         msg_Err( p_vout, "out of memory" );
  246.         return VLC_ENOMEM;
  247.     }
  249.     p_vout->pf_init = Init;
  250.     p_vout->pf_end = End;
  251.     p_vout->pf_manage = NULL;
  252.     p_vout->pf_render = Render;
  253.     p_vout->pf_display = NULL;
  254.     p_vout->pf_control = Control;
  256.     var_Create( p_this, "logo-position", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
  257.     var_Get( p_this, "logo-position", &val );
  258.     p_sys->pos = val.i_int;
  259.     var_Create( p_this, "logo-x", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
  260.     var_Get( p_this, "logo-x", &val );
  261.     p_sys->posx = val.i_int;
  262.     var_Create( p_this, "logo-y", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
  263.     var_Get( p_this, "logo-y", &val );
  264.     p_sys->posy = val.i_int;
  266.     p_sys->p_pic = LoadPNG( p_this );
  267.     if( !p_sys->p_pic )
  268.     {
  269.         free( p_sys );
  270.         return VLC_EGENERIC;
  271.     }
  273.     p_sys->i_width = p_sys->p_pic->p[Y_PLANE].i_visible_pitch;
  274.     p_sys->i_height = p_sys->p_pic->p[Y_PLANE].i_visible_lines;
  276.     return VLC_SUCCESS;
  277. }
  279. /*****************************************************************************
  280.  * Init: initialize logo video thread output method
  281.  *****************************************************************************/
  282. static int Init( vout_thread_t *p_vout )
  283. {
  284.     vout_sys_t *p_sys = p_vout->p_sys;
  285.     picture_t *p_pic;
  286.     int i_index;
  288.     I_OUTPUTPICTURES = 0;
  290.     /* Initialize the output structure */
  291.     p_vout->output.i_chroma = p_vout->render.i_chroma;
  292.     p_vout->output.i_width  = p_vout->render.i_width;
  293.     p_vout->output.i_height = p_vout->render.i_height;
  294.     p_vout->output.i_aspect = p_vout->render.i_aspect;
  296.     /* Load the video blending filter */
  297.     p_sys->p_blend = vlc_object_create( p_vout, sizeof(filter_t) );
  298.     vlc_object_attach( p_sys->p_blend, p_vout );
  299.     p_sys->p_blend->fmt_out.video.i_x_offset =
  300.         p_sys->p_blend->fmt_out.video.i_y_offset = 0;
  301.     p_sys->p_blend->fmt_in.video.i_x_offset =
  302.         p_sys->p_blend->fmt_in.video.i_y_offset = 0;
  303.     p_sys->p_blend->fmt_out.video.i_aspect = p_vout->render.i_aspect;
  304.     p_sys->p_blend->fmt_out.video.i_chroma = p_vout->output.i_chroma;
  305.     p_sys->p_blend->fmt_in.video.i_chroma = VLC_FOURCC('Y','U','V','A');
  306.     p_sys->p_blend->fmt_in.video.i_aspect = VOUT_ASPECT_FACTOR;
  307.     p_sys->p_blend->fmt_in.video.i_width =
  308.         p_sys->p_blend->fmt_in.video.i_visible_width =
  309.             p_sys->p_pic->p[Y_PLANE].i_visible_pitch;
  310.     p_sys->p_blend->fmt_in.video.i_height =
  311.         p_sys->p_blend->fmt_in.video.i_visible_height =
  312.             p_sys->p_pic->p[Y_PLANE].i_visible_lines;
  313.     p_sys->p_blend->fmt_out.video.i_width =
  314.         p_sys->p_blend->fmt_out.video.i_visible_width =
  315.            p_vout->output.i_width;
  316.     p_sys->p_blend->fmt_out.video.i_height =
  317.         p_sys->p_blend->fmt_out.video.i_visible_height =
  318.             p_vout->output.i_height;
  320.     p_sys->p_blend->p_module =
  321.         module_Need( p_sys->p_blend, "video blending", 0, 0 );
  322.     if( !p_sys->p_blend->p_module )
  323.     {
  324.         msg_Err( p_vout, "can't open blending filter, aborting" );
  325.         vlc_object_detach( p_sys->p_blend );
  326.         vlc_object_destroy( p_sys->p_blend );
  327.         return VLC_EGENERIC;
  328.     }
  330.     if( p_sys->posx < 0 || p_sys->posy < 0 )
  331.     {
  332.         p_sys->posx = 0; p_sys->posy = 0;
  334.         if( p_sys->pos & SUBPICTURE_ALIGN_BOTTOM )
  335.         {
  336.             p_sys->posy = p_vout->render.i_height - p_sys->i_height;
  337.         }
  338.         else if ( !(p_sys->pos & SUBPICTURE_ALIGN_TOP) )
  339.         {
  340.             p_sys->posy = p_vout->render.i_height / 2 - p_sys->i_height / 2;
  341.         }
  343.         if( p_sys->pos & SUBPICTURE_ALIGN_RIGHT )
  344.         {
  345.             p_sys->posx = p_vout->render.i_width - p_sys->i_width;
  346.         }
  347.         else if ( !(p_sys->pos & SUBPICTURE_ALIGN_LEFT) )
  348.         {
  349.             p_sys->posx = p_vout->render.i_width / 2 - p_sys->i_width / 2;
  350.         }
  351.     }
  353.     /* Try to open the real video output */
  354.     msg_Dbg( p_vout, "spawning the real video output" );
  356.     p_sys->p_vout =
  357.         vout_Create( p_vout, p_vout->render.i_width, p_vout->render.i_height,
  358.                      p_vout->render.i_chroma, p_vout->render.i_aspect );
  360.     /* Everything failed */
  361.     if( p_sys->p_vout == NULL )
  362.     {
  363.         msg_Err( p_vout, "can't open vout, aborting" );
  364.         return VLC_EGENERIC;
  365.     }
  367.     var_AddCallback( p_sys->p_vout, "mouse-x", MouseEvent, p_vout);
  368.     var_AddCallback( p_sys->p_vout, "mouse-y", MouseEvent, p_vout);
  370.     ALLOCATE_DIRECTBUFFERS( VOUT_MAX_PICTURES );
  371.     ADD_CALLBACKS( p_sys->p_vout, SendEvents );
  372.     ADD_PARENT_CALLBACKS( SendEventsToChild );
  374.     return VLC_SUCCESS;
  375. }
  377. /*****************************************************************************
  378.  * End: terminate logo video thread output method
  379.  *****************************************************************************/
  380. static void End( vout_thread_t *p_vout )
  381. {
  382.     vout_sys_t *p_sys = p_vout->p_sys;
  383.     int i_index;
  385.     /* Free the fake output buffers we allocated */
  386.     for( i_index = I_OUTPUTPICTURES ; i_index ; )
  387.     {
  388.         i_index--;
  389.         free( PP_OUTPUTPICTURE[ i_index ]->p_data_orig );
  390.     }
  392.     var_DelCallback( p_sys->p_vout, "mouse-x", MouseEvent, p_vout);
  393.     var_DelCallback( p_sys->p_vout, "mouse-y", MouseEvent, p_vout);
  395.     if( p_sys->p_vout )
  396.     {
  397.         DEL_CALLBACKS( p_sys->p_vout, SendEvents );
  398.         vlc_object_detach( p_sys->p_vout );
  399.         vout_Destroy( p_sys->p_vout );
  400.     }
  402.     if( p_sys->p_blend->p_module )
  403.         module_Unneed( p_sys->p_blend, p_sys->p_blend->p_module );
  404.     vlc_object_detach( p_sys->p_blend );
  405.     vlc_object_destroy( p_sys->p_blend );
  406. }
  408. /*****************************************************************************
  409.  * Destroy: destroy logo video thread output method
  410.  *****************************************************************************/
  411. static void Destroy( vlc_object_t *p_this )
  412. {
  413.     vout_thread_t *p_vout = (vout_thread_t *)p_this;
  414.     vout_sys_t *p_sys = p_vout->p_sys;
  416.     DEL_PARENT_CALLBACKS( SendEventsToChild );
  418.     if( p_sys->p_pic && p_sys->p_pic->p_data_orig )
  419.         free( p_sys->p_pic->p_data_orig );
  420.     if( p_sys->p_pic ) free( p_sys->p_pic );
  422.     free( p_sys );
  423. }
  425. /*****************************************************************************
  426.  * Render: render the logo onto the video
  427.  *****************************************************************************/
  428. static void Render( vout_thread_t *p_vout, picture_t *p_pic )
  429. {
  430.     vout_sys_t *p_sys = p_vout->p_sys;
  431.     picture_t *p_outpic;
  433.     /* This is a new frame. Get a structure from the video_output. */
  434.     while( !(p_outpic = vout_CreatePicture( p_sys->p_vout, 0, 0, 0 )) )
  435.     {
  436.         if( p_vout->b_die || p_vout->b_error ) return;
  437.         msleep( VOUT_OUTMEM_SLEEP );
  438.     }
  440.     vout_CopyPicture( p_vout, p_outpic, p_pic );
  441.     vout_DatePicture( p_sys->p_vout, p_outpic, p_pic->date );
  443.     p_sys->p_blend->pf_video_blend( p_sys->p_blend, p_outpic, p_outpic,
  444.                                     p_sys->p_pic, p_sys->posx, p_sys->posy,
  445.                                     255 );
  447.     vout_DisplayPicture( p_sys->p_vout, p_outpic );
  448. }
  450. /*****************************************************************************
  451.  * SendEvents: forward mouse and keyboard events to the parent p_vout
  452.  *****************************************************************************/
  453. static int SendEvents( vlc_object_t *p_this, char const *psz_var,
  454.                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
  455. {
  456.     var_Set( (vlc_object_t *)p_data, psz_var, newval );
  457.     return VLC_SUCCESS;
  458. }
  460. /*****************************************************************************
  461.  * MouseEvent: callback for mouse events
  462.  *****************************************************************************/
  463. static int MouseEvent( vlc_object_t *p_this, char const *psz_var,
  464.                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
  465. {
  466.     vout_thread_t *p_vout = (vout_thread_t*)p_data;
  467.     vout_sys_t *p_sys = p_vout->p_sys;
  468.     vlc_value_t valb;
  469.     int i_delta;
  471.     var_Get( p_vout->p_sys->p_vout, "mouse-button-down", &valb );
  473.     i_delta = newval.i_int - oldval.i_int;
  475.     if( (valb.i_int & 0x1) == 0 )
  476.     {
  477.         return VLC_SUCCESS;
  478.     }
  480.     if( psz_var[6] == 'x' )
  481.     {
  482.         vlc_value_t valy;
  483.         var_Get( p_vout->p_sys->p_vout, "mouse-y", &valy );
  484.         if( newval.i_int >= (int)p_sys->posx &&
  485.             valy.i_int >= (int)p_sys->posy &&
  486.             newval.i_int <= (int)(p_sys->posx + p_sys->i_width) &&
  487.             valy.i_int <= (int)(p_sys->posy + p_sys->i_height) )
  488.         {
  489.             p_sys->posx = __MIN( __MAX( p_sys->posx + i_delta, 0 ),
  490.                           p_vout->output.i_width - p_sys->i_width );
  491.         }
  492.     }
  493.     else if( psz_var[6] == 'y' )
  494.     {
  495.         vlc_value_t valx;
  496.         var_Get( p_vout->p_sys->p_vout, "mouse-x", &valx );
  497.         if( valx.i_int >= (int)p_sys->posx &&
  498.             newval.i_int >= (int)p_sys->posy &&
  499.             valx.i_int <= (int)(p_sys->posx + p_sys->i_width) &&
  500.             newval.i_int <= (int)(p_sys->posy + p_sys->i_height) )
  501.         {
  502.             p_sys->posy = __MIN( __MAX( p_sys->posy + i_delta, 0 ),
  503.                           p_vout->output.i_height - p_sys->i_height );
  504.         }
  505.     }
  507.     return VLC_SUCCESS;
  508. }
  510. /*****************************************************************************
  511.  * Control: control facility for the vout (forwards to child vout)
  512.  *****************************************************************************/
  513. static int Control( vout_thread_t *p_vout, int i_query, va_list args )
  514. {
  515.     return vout_vaControl( p_vout->p_sys->p_vout, i_query, args );
  516. }
  518. /*****************************************************************************
  519.  * SendEventsToChild: forward events to the child/children vout
  520.  *****************************************************************************/
  521. static int SendEventsToChild( vlc_object_t *p_this, char const *psz_var,
  522.                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
  523. {
  524.     vout_thread_t *p_vout = (vout_thread_t *)p_this;
  525.     var_Set( p_vout->p_sys->p_vout, psz_var, newval );
  526.     return VLC_SUCCESS;
  527. }
  529. /*****************************************************************************
  530.  * filter_sys_t: logo filter descriptor
  531.  *****************************************************************************/
  532. struct filter_sys_t
  533. {
  534.     picture_t *p_pic;
  536.     int i_width, i_height;
  537.     int pos, posx, posy;
  539.     vlc_bool_t b_absolute;
  541.     mtime_t i_last_date;
  542. };
  544. static subpicture_t *Filter( filter_t *, mtime_t );
  546. /*****************************************************************************
  547.  * CreateFilter: allocates logo video filter
  548.  *****************************************************************************/
  549. static int CreateFilter( vlc_object_t *p_this )
  550. {
  551.     filter_t *p_filter = (filter_t *)p_this;
  552.     filter_sys_t *p_sys;
  553.     vlc_value_t val;
  555.     /* Allocate structure */
  556.     p_sys = p_filter->p_sys = malloc( sizeof( filter_sys_t ) );
  557.     if( p_sys == NULL )
  558.     {
  559.         msg_Err( p_filter, "out of memory" );
  560.         return VLC_ENOMEM;
  561.     }
  563.     var_Create( p_this, "logo-position", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
  564.     var_Get( p_this, "logo-position", &val );
  565.     p_sys->pos = val.i_int;
  566.     var_Create( p_this, "logo-x", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
  567.     var_Get( p_this, "logo-x", &val );
  568.     p_sys->posx = val.i_int;
  569.     var_Create( p_this, "logo-y", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
  570.     var_Get( p_this, "logo-y", &val );
  571.     p_sys->posy = val.i_int;
  573.     p_sys->b_absolute = VLC_TRUE;
  574.     if( p_sys->posx < 0 || p_sys->posy < 0 )
  575.     {
  576.         p_sys->b_absolute = VLC_FALSE;
  577.         p_sys->posx = 0; p_sys->posy = 0;
  578.     }
  580.     p_sys->p_pic = LoadPNG( p_this );
  581.     if( !p_sys->p_pic )
  582.     {
  583.         free( p_sys );
  584.         return VLC_EGENERIC;
  585.     }
  587.     p_sys->i_width = p_sys->p_pic->p[Y_PLANE].i_visible_pitch;
  588.     p_sys->i_height = p_sys->p_pic->p[Y_PLANE].i_visible_lines;
  589.     p_sys->i_last_date = 0;
  591.     /* Misc init */
  592.     p_filter->pf_sub_filter = Filter;
  594.     return VLC_SUCCESS;
  595. }
  597. /*****************************************************************************
  598.  * DestroyFilter: destroy logo video filter
  599.  *****************************************************************************/
  600. static void DestroyFilter( vlc_object_t *p_this )
  601. {
  602.     filter_t *p_filter = (filter_t *)p_this;
  603.     filter_sys_t *p_sys = p_filter->p_sys;
  605.     if( p_sys->p_pic && p_sys->p_pic->p_data_orig )
  606.         free( p_sys->p_pic->p_data_orig );
  607.     if( p_sys->p_pic ) free( p_sys->p_pic );
  609.     free( p_sys );
  610. }
  612. /****************************************************************************
  613.  * Filter: the whole thing
  614.  ****************************************************************************
  615.  * This function outputs subpictures at regular time intervals.
  616.  ****************************************************************************/
  617. static subpicture_t *Filter( filter_t *p_filter, mtime_t date )
  618. {
  619.     filter_sys_t *p_sys = p_filter->p_sys;
  620.     subpicture_t *p_spu;
  621.     subpicture_region_t *p_region;
  622.     video_format_t fmt;
  624.     if( p_sys->i_last_date && p_sys->i_last_date + 5000000 > date ) return 0;
  626.     /* Allocate the subpicture internal data. */
  627.     p_spu = p_filter->pf_sub_buffer_new( p_filter );
  628.     if( !p_spu ) return NULL;
  630.     /* Create new SPU region */
  631.     memset( &fmt, 0, sizeof(video_format_t) );
  632.     fmt.i_chroma = VLC_FOURCC('Y','U','V','A');
  633.     fmt.i_aspect = VOUT_ASPECT_FACTOR;
  634.     fmt.i_sar_num = fmt.i_sar_den = 1;
  635.     fmt.i_width = fmt.i_visible_width = p_sys->i_width;
  636.     fmt.i_height = fmt.i_visible_height = p_sys->i_height;
  637.     fmt.i_x_offset = fmt.i_y_offset = 0;
  638.     p_region = p_spu->pf_create_region( VLC_OBJECT(p_filter), &fmt );
  639.     if( !p_region )
  640.     {
  641.         msg_Err( p_filter, "cannot allocate SPU region" );
  642.         p_filter->pf_sub_buffer_del( p_filter, p_spu );
  643.         return NULL;
  644.     }
  646.     vout_CopyPicture( p_filter, &p_region->picture, p_sys->p_pic );
  647.     p_region->i_x = 0;
  648.     p_region->i_y = 0;
  649.     p_spu->i_x = p_sys->posx;
  650.     p_spu->i_y = p_sys->posy;
  651.     p_spu->i_flags = p_sys->pos;
  652.     p_spu->b_absolute = p_sys->b_absolute;
  654.     p_spu->p_region = p_region;
  656.     p_spu->i_start = p_sys->i_last_date = date;
  657.     p_spu->i_stop = 0;
  658.     p_spu->b_ephemer = VLC_TRUE;
  660.     return p_spu;
  661. }