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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
dynamicoverlay_commands.c
资源名称：vlc-1.0.5.zip　[点击查看]
上传用户：kjfoods
上传日期：2020-07-06
资源大小：29949k
文件大小：29k
源码类别：

midi

开发平台：

Unix_Linux

dynamicoverlay_commands.c：源码内容
  1. /*****************************************************************************
  2.  * dynamicoverlay_commands.c : dynamic overlay plugin commands
  3.  *****************************************************************************
  4.  * Copyright (C) 2008 the VideoLAN team
  5.  * $Id: d847aaf8e4be308f91a9a1cb59b149994e6f1041 $
  6.  *
  7.  * Author: Søren Bøg <avacore@videolan.org>
  8.  *         Jean-Paul Saman <jpsaman@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., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23.  *****************************************************************************/
  25. #ifdef HAVE_CONFIG_H
  26. # include "config.h"
  27. #endif
  29. #include <vlc_common.h>
  30. #include <vlc_arrays.h>
  31. #include <vlc_vout.h>
  32. #include <vlc_filter.h>
  33. #include <vlc_osd.h>
  35. #include <string.h>
  36. #include <ctype.h>
  38. #if defined(HAVE_SYS_SHM_H)
  39. #include <sys/shm.h>
  40. #endif
  42. #include "dynamicoverlay.h"
  45. /*****************************************************************************
  46.  * overlay_t: Overlay descriptor
  47.  *****************************************************************************/
  49. overlay_t *OverlayCreate( void )
  50. {
  51.     overlay_t *p_ovl = malloc( sizeof( overlay_t ) );
  52.     if( p_ovl == NULL )
  53.        return NULL;
  54.     memset( p_ovl, 0, sizeof( overlay_t ) );
  56.     p_ovl->i_x = p_ovl->i_y = 0;
  57.     p_ovl->i_alpha = 0xFF;
  58.     p_ovl->b_active = false;
  59.     vout_InitFormat( &p_ovl->format, VLC_FOURCC( '','','','') , 0, 0,
  60.                      VOUT_ASPECT_FACTOR );
  61.     memcpy( &p_ovl->fontstyle, &default_text_style, sizeof(struct text_style_t) );
  62.     p_ovl->data.p_text = NULL;
  64.     return p_ovl;
  65. }
  67. int OverlayDestroy( overlay_t *p_ovl )
  68. {
  69.     if( p_ovl->data.p_text != NULL )
  70.         free( p_ovl->data.p_text );
  72.     return VLC_SUCCESS;
  73. }
  75. /*****************************************************************************
  76.  * Command parsers
  77.  *****************************************************************************/
  78. static int skip_space( char **psz_command )
  79. {
  80.     char *psz_temp = *psz_command;
  82.     while( isspace( *psz_temp ) )
  83.     {
  84.         ++psz_temp;
  85.     }
  86.     if( psz_temp == *psz_command )
  87.     {
  88.         return VLC_EGENERIC;
  89.     }
  90.     *psz_command = psz_temp;
  91.     return VLC_SUCCESS;
  92. }
  94. static int parse_digit( char **psz_command, int32_t *value )
  95. {
  96.     char *psz_temp;
  97.     *value = strtol( *psz_command, &psz_temp, 10 );
  98.     if( psz_temp == *psz_command )
  99.     {
  100.         return VLC_EGENERIC;
  101.     }
  102.     *psz_command = psz_temp;
  103.     return VLC_SUCCESS;
  104. }
  106. static int parse_char( char **psz_command, char **psz_end,
  107.                        int count, char *psz_value )
  108. {
  109.     if( *psz_end - *psz_command < count )
  110.     {
  111.         return VLC_EGENERIC;
  112.     }
  113.     memcpy( psz_value, *psz_command, count );
  114.     *psz_command += count;
  115.     return VLC_SUCCESS;
  116. }
  118. static int parser_DataSharedMem( char *psz_command,
  119.                                  char *psz_end,
  120.                                  commandparams_t *p_params )
  121. {
  122.     /* Parse: 0 128 128 RGBA 9404459 */
  123.     skip_space( &psz_command );
  124.     if( isdigit( *psz_command ) )
  125.     {
  126.         if( parse_digit( &psz_command, &p_params->i_id ) == VLC_EGENERIC )
  127.             return VLC_EGENERIC;
  128.     }
  129.     skip_space( &psz_command );
  130.     if( isdigit( *psz_command ) )
  131.     {
  132.         if( parse_digit( &psz_command, &p_params->i_width ) == VLC_EGENERIC )
  133.             return VLC_EGENERIC;
  134.     }
  135.     skip_space( &psz_command );
  136.     if( isdigit( *psz_command ) )
  137.     {
  138.         if( parse_digit( &psz_command, &p_params->i_height ) == VLC_EGENERIC )
  139.             return VLC_EGENERIC;
  140.     }
  141.     skip_space( &psz_command );
  142.     if( isascii( *psz_command ) )
  143.     {
  144.         if( parse_char( &psz_command, &psz_end, 4, (char*)&p_params->fourcc )
  145.             == VLC_EGENERIC )
  146.             return VLC_EGENERIC;
  147.     }
  148.     skip_space( &psz_command );
  149.     if( isdigit( *psz_command ) )
  150.     {
  151.         if( parse_digit( &psz_command, &p_params->i_shmid ) == VLC_EGENERIC )
  152.             return VLC_EGENERIC;
  153.     }
  154.     return VLC_SUCCESS;
  155. }
  157. static int parser_Id( char *psz_command, char *psz_end,
  158.                       commandparams_t *p_params )
  159. {
  160.     VLC_UNUSED(psz_end);
  161.     skip_space( &psz_command );
  162.     if( isdigit( *psz_command ) )
  163.     {
  164.         if( parse_digit( &psz_command, &p_params->i_id ) == VLC_EGENERIC )
  165.             return VLC_EGENERIC;
  166.     }
  167.     return VLC_SUCCESS;
  168. }
  170. static int parser_None( char *psz_command, char *psz_end,
  171.                         commandparams_t *p_params )
  172. {
  173.     VLC_UNUSED(psz_command);
  174.     VLC_UNUSED(psz_end);
  175.     VLC_UNUSED(p_params);
  176.     return VLC_SUCCESS;
  177. }
  179. static int parser_SetAlpha( char *psz_command, char *psz_end,
  180.                             commandparams_t *p_params )
  181. {
  182.     VLC_UNUSED(psz_end);
  183.     skip_space( &psz_command );
  184.     if( isdigit( *psz_command ) )
  185.     {
  186.         if( parse_digit( &psz_command, &p_params->i_id ) == VLC_EGENERIC  )
  187.             return VLC_EGENERIC;
  188.     }
  189.     skip_space( &psz_command );
  190.     if( isdigit( *psz_command ) )
  191.     {
  192.         if( parse_digit( &psz_command, &p_params->i_alpha ) == VLC_EGENERIC )
  193.             return VLC_EGENERIC;
  194.     }
  195.     return VLC_SUCCESS;
  196. }
  198. static int parser_SetPosition( char *psz_command, char *psz_end,
  199.                                commandparams_t *p_params )
  200. {
  201.     VLC_UNUSED(psz_end);
  202.     skip_space( &psz_command );
  203.     if( isdigit( *psz_command ) )
  204.     {
  205.         if( parse_digit( &psz_command, &p_params->i_id ) == VLC_EGENERIC )
  206.             return VLC_EGENERIC;
  207.     }
  208.     skip_space( &psz_command );
  209.     if( isdigit( *psz_command ) )
  210.     {
  211.         if( parse_digit( &psz_command, &p_params->i_x ) == VLC_EGENERIC )
  212.             return VLC_EGENERIC;
  213.     }
  214.     skip_space( &psz_command );
  215.     if( isdigit( *psz_command ) )
  216.     {
  217.         if( parse_digit( &psz_command, &p_params->i_y ) == VLC_EGENERIC )
  218.             return VLC_EGENERIC;
  219.     }
  220.     return VLC_SUCCESS;
  221. }
  223. static int parser_SetTextAlpha( char *psz_command, char *psz_end,
  224.                                 commandparams_t *p_params )
  225. {
  226.     VLC_UNUSED(psz_end);
  227.     skip_space( &psz_command );
  228.     if( isdigit( *psz_command ) )
  229.     {
  230.         if( parse_digit( &psz_command, &p_params->i_id ) == VLC_EGENERIC )
  231.             return VLC_EGENERIC;
  232.     }
  233.     skip_space( &psz_command );
  234.     if( isdigit( *psz_command ) )
  235.     {
  236.         if( parse_digit( &psz_command, &p_params->fontstyle.i_font_alpha ) == VLC_EGENERIC )
  237.             return VLC_EGENERIC;
  238.     }
  239.     return VLC_SUCCESS;
  240. }
  242. static int parser_SetTextColor( char *psz_command, char *psz_end,
  243.                                 commandparams_t *p_params )
  244. {
  245.     int r = 0, g = 0, b = 0;
  246.     VLC_UNUSED(psz_end);
  248.     skip_space( &psz_command );
  249.     if( isdigit( *psz_command ) )
  250.     {
  251.         if( parse_digit( &psz_command, &p_params->i_id ) == VLC_EGENERIC )
  252.             return VLC_EGENERIC;
  253.     }
  254.     skip_space( &psz_command );
  255.     if( isdigit( *psz_command ) )
  256.     {
  257.         if( parse_digit( &psz_command, &r ) == VLC_EGENERIC )
  258.             return VLC_EGENERIC;
  259.     }
  260.     skip_space( &psz_command );
  261.     if( isdigit( *psz_command ) )
  262.     {
  263.         if( parse_digit( &psz_command, &g ) == VLC_EGENERIC )
  264.             return VLC_EGENERIC;
  265.     }
  266.     skip_space( &psz_command );
  267.     if( isdigit( *psz_command ) )
  268.     {
  269.         if( parse_digit( &psz_command, &b ) == VLC_EGENERIC )
  270.             return VLC_EGENERIC;
  271.     }
  272.     p_params->fontstyle.i_font_color = (r<<16) | (g<<8) | (b<<0);
  273.     return VLC_SUCCESS;
  274. }
  276. static int parser_SetTextSize( char *psz_command, char *psz_end,
  277.                                commandparams_t *p_params )
  278. {
  279.     VLC_UNUSED(psz_end);
  280.     skip_space( &psz_command );
  281.     if( isdigit( *psz_command ) )
  282.     {
  283.         if( parse_digit( &psz_command, &p_params->i_id ) == VLC_EGENERIC )
  284.             return VLC_EGENERIC;
  285.     }
  286.     skip_space( &psz_command );
  287.     if( isdigit( *psz_command ) )
  288.     {
  289.         if( parse_digit( &psz_command, &p_params->fontstyle.i_font_size ) == VLC_EGENERIC )
  290.             return VLC_EGENERIC;
  291.     }
  292.     return VLC_SUCCESS;
  293. }
  295. static int parser_SetVisibility( char *psz_command, char *psz_end,
  296.                                  commandparams_t *p_params )
  297. {
  298.     VLC_UNUSED(psz_end);
  299.     skip_space( &psz_command );
  300.     if( isdigit( *psz_command ) )
  301.     {
  302.         if( parse_digit( &psz_command, &p_params->i_id ) == VLC_EGENERIC )
  303.             return VLC_EGENERIC;
  304.     }
  305.     skip_space( &psz_command );
  306.     if( isdigit( *psz_command ) )
  307.     {
  308.         int32_t i_vis = 0;
  309.         if( parse_digit( &psz_command, &i_vis ) == VLC_EGENERIC )
  310.             return VLC_EGENERIC;
  311.         p_params->b_visible = (i_vis == 1) ? true : false;
  312.     }
  313.     return VLC_SUCCESS;
  314. }
  316. /*****************************************************************************
  317.  * Command unparser functions
  318.  *****************************************************************************/
  320. static int unparse_default( const commandparams_t *p_results,
  321.                             buffer_t *p_output )
  322. {
  323.     VLC_UNUSED(p_results);
  324.     VLC_UNUSED(p_output);
  325.     return VLC_SUCCESS;
  326. }
  328. static int unparse_GenImage( const commandparams_t *p_results,
  329.                              buffer_t *p_output )
  330. {
  331.     int ret = BufferPrintf( p_output, " %d", p_results->i_id );
  332.     if( ret != VLC_SUCCESS )
  333.         return ret;
  335.     return VLC_SUCCESS;
  336. }
  338. static int unparse_GetAlpha( const commandparams_t *p_results,
  339.                              buffer_t *p_output )
  340. {
  341.     int ret = BufferPrintf( p_output, " %d", p_results->i_alpha );
  342.     if( ret != VLC_SUCCESS )
  343.         return ret;
  345.     return VLC_SUCCESS;
  346. }
  348. static int unparse_GetPosition( const commandparams_t *p_results,
  349.                                 buffer_t *p_output )
  350. {
  351.     int ret = BufferPrintf( p_output, " %d", p_results->i_x );
  352.     if( ret != VLC_SUCCESS )
  353.         return ret;
  355.     ret = BufferPrintf( p_output, " %d", p_results->i_y );
  356.     if( ret != VLC_SUCCESS )
  357.         return ret;
  359.     return VLC_SUCCESS;
  360. }
  362. static int unparse_GetTextAlpha( const commandparams_t *p_results,
  363.                                  buffer_t *p_output )
  364. {
  365.     int ret = BufferPrintf( p_output, " %d", p_results->fontstyle.i_font_alpha );
  366.     if( ret != VLC_SUCCESS )
  367.         return ret;
  369.     return VLC_SUCCESS;
  370. }
  372. static int unparse_GetTextColor( const commandparams_t *p_results,
  373.                                  buffer_t *p_output )
  374. {
  375.     int ret = BufferPrintf( p_output, " %d", (p_results->fontstyle.i_font_color & 0xff0000)>>16 );
  376.     if( ret != VLC_SUCCESS )
  377.         return ret;
  379.     ret = BufferPrintf( p_output, " %d", (p_results->fontstyle.i_font_color & 0x00ff00)>>8 );
  380.     if( ret != VLC_SUCCESS )
  381.         return ret;
  383.     ret = BufferPrintf( p_output, " %d", (p_results->fontstyle.i_font_color & 0x0000ff) );
  384.     if( ret != VLC_SUCCESS )
  385.         return ret;
  387.     return VLC_SUCCESS;
  388. }
  390. static int unparse_GetTextSize( const commandparams_t *p_results,
  391.                                 buffer_t *p_output )
  392. {
  393.     int ret = BufferPrintf( p_output, " %d", p_results->fontstyle.i_font_size );
  394.     if( ret != VLC_SUCCESS )
  395.         return ret;
  397.     return VLC_SUCCESS;
  398. }
  400. static int unparse_GetVisibility( const commandparams_t *p_results,
  401.                              buffer_t *p_output )
  402. {
  403.     int ret = BufferPrintf( p_output, " %d", (p_results->b_visible ? 1 : 0) );
  404.     if( ret != VLC_SUCCESS ) {
  405.         return ret;
  406.     }
  407.     return VLC_SUCCESS;
  408. }
  410. /*****************************************************************************
  411.  * Command functions
  412.  *****************************************************************************/
  413. static int exec_DataSharedMem( filter_t *p_filter,
  414.                                const commandparams_t *p_params,
  415.                                commandparams_t *p_results )
  416. {
  417. #if defined(HAVE_SYS_SHM_H)
  418.     filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
  419.     struct shmid_ds shminfo;
  420.     overlay_t *p_ovl;
  421.     size_t i_size;
  423.     VLC_UNUSED(p_results);
  425.     p_ovl = ListGet( &p_sys->overlays, p_params->i_id );
  426.     if( p_ovl == NULL )
  427.     {
  428.         msg_Err( p_filter, "Invalid overlay: %d", p_params->i_id );
  429.         return VLC_EGENERIC;
  430.     }
  432.     if( shmctl( p_params->i_shmid, IPC_STAT, &shminfo ) == -1 )
  433.     {
  434.         msg_Err( p_filter, "Unable to access shared memory" );
  435.         return VLC_EGENERIC;
  436.     }
  437.     i_size = shminfo.shm_segsz;
  439.     if( p_params->fourcc == VLC_FOURCC('T','E','X','T') )
  440.     {
  441.         char *p_data;
  443.         if( (p_params->i_height != 1) || (p_params->i_width < 1) )
  444.         {
  445.             msg_Err( p_filter,
  446.                      "Invalid width and/or height. when specifing text height "
  447.                      "must be 1 and width the number of bytes in the string, "
  448.                      "including the null terminator" );
  449.             return VLC_EGENERIC;
  450.         }
  452.         if( (size_t)p_params->i_width > i_size )
  453.         {
  454.             msg_Err( p_filter,
  455.                      "Insufficient data in shared memory. need %d, got %zu",
  456.                      p_params->i_width, i_size );
  457.             return VLC_EGENERIC;
  458.         }
  460.         p_ovl->data.p_text = malloc( p_params->i_width );
  461.         if( p_ovl->data.p_text == NULL )
  462.         {
  463.             msg_Err( p_filter, "Unable to allocate string storage" );
  464.             return VLC_ENOMEM;
  465.         }
  467.         vout_InitFormat( &p_ovl->format, VLC_FOURCC('T','E','X','T'),
  468.                          0, 0, 0 );
  470.         p_data = shmat( p_params->i_shmid, NULL, SHM_RDONLY );
  471.         if( p_data == NULL )
  472.         {
  473.             msg_Err( p_filter, "Unable to attach to shared memory" );
  474.             free( p_ovl->data.p_text );
  475.             p_ovl->data.p_text = NULL;
  476.             return VLC_ENOMEM;
  477.         }
  478.         memcpy( p_ovl->data.p_text, p_data, p_params->i_width );
  480.         shmdt( p_data );
  481.     }
  482.     else
  483.     {
  484.         uint8_t *p_data, *p_in;
  485.         size_t i_neededsize = 0;
  487.         p_ovl->data.p_pic = malloc( sizeof( picture_t ) );
  488.         if( p_ovl->data.p_pic == NULL )
  489.             return VLC_ENOMEM;
  491.         vout_InitFormat( &p_ovl->format, p_params->fourcc,
  492.                          p_params->i_width, p_params->i_height,
  493.                          VOUT_ASPECT_FACTOR );
  494.         if( vout_AllocatePicture( p_filter, p_ovl->data.p_pic,
  495.                                   p_ovl->format.i_chroma, p_params->i_width,
  496.                                   p_params->i_height, p_ovl->format.i_aspect ) )
  497.         {
  498.             msg_Err( p_filter, "Unable to allocate picture" );
  499.             free( p_ovl->data.p_pic );
  500.             p_ovl->data.p_pic = NULL;
  501.             return VLC_ENOMEM;
  502.         }
  504.         for( size_t i_plane = 0; i_plane < (size_t)p_ovl->data.p_pic->i_planes;
  505.              ++i_plane )
  506.         {
  507.             i_neededsize += p_ovl->data.p_pic->p[i_plane].i_visible_lines *
  508.                             p_ovl->data.p_pic->p[i_plane].i_visible_pitch;
  509.         }
  511.         if( i_neededsize > i_size )
  512.         {
  513.             msg_Err( p_filter,
  514.                      "Insufficient data in shared memory. need %zu, got %zu",
  515.                      i_neededsize, i_size );
  516.             picture_Release( p_ovl->data.p_pic );
  517.             free( p_ovl->data.p_pic );
  518.             p_ovl->data.p_pic = NULL;
  519.             return VLC_EGENERIC;
  520.         }
  522.         p_data = shmat( p_params->i_shmid, NULL, SHM_RDONLY );
  523.         if( p_data == NULL )
  524.         {
  525.             msg_Err( p_filter, "Unable to attach to shared memory" );
  526.             picture_Release( p_ovl->data.p_pic );
  527.             free( p_ovl->data.p_pic );
  528.             p_ovl->data.p_pic = NULL;
  529.             return VLC_ENOMEM;
  530.         }
  532.         p_in = p_data;
  533.         for( size_t i_plane = 0; i_plane < (size_t)p_ovl->data.p_pic->i_planes;
  534.              ++i_plane )
  535.         {
  536.             uint8_t *p_out = p_ovl->data.p_pic->p[i_plane].p_pixels;
  537.             for( size_t i_line = 0;
  538.                  i_line < (size_t)p_ovl->data.p_pic->p[i_plane].i_visible_lines;
  539.                  ++i_line )
  540.             {
  541.                 vlc_memcpy( p_out, p_in,
  542.                             p_ovl->data.p_pic->p[i_plane].i_visible_pitch );
  543.                 p_out += p_ovl->data.p_pic->p[i_plane].i_pitch;
  544.                 p_in += p_ovl->data.p_pic->p[i_plane].i_visible_pitch;
  545.             }
  546.         }
  547.         shmdt( p_data );
  548.     }
  549.     p_sys->b_updated = p_ovl->b_active;
  551.     return VLC_SUCCESS;
  552. #else
  553.     VLC_UNUSED(p_params);
  554.     VLC_UNUSED(p_results);
  556.     msg_Err( p_filter, "system doesn't support shared memory" );
  557.     return VLC_EGENERIC;
  558. #endif
  559. }
  561. static int exec_DeleteImage( filter_t *p_filter,
  562.                              const commandparams_t *p_params,
  563.                              commandparams_t *p_results )
  564. {
  565.     VLC_UNUSED(p_results);
  566.     filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
  567.     p_sys->b_updated = true;
  569.     return ListRemove( &p_sys->overlays, p_params->i_id );
  570. }
  572. static int exec_EndAtomic( filter_t *p_filter,
  573.                            const commandparams_t *p_params,
  574.                            commandparams_t *p_results )
  575. {
  576.     VLC_UNUSED(p_params);
  577.     VLC_UNUSED(p_results);
  578.     filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
  579.     QueueTransfer( &p_sys->pending, &p_sys->atomic );
  580.     p_sys->b_atomic = false;
  581.     return VLC_SUCCESS;
  582. }
  584. static int exec_GenImage( filter_t *p_filter,
  585.                           const commandparams_t *p_params,
  586.                           commandparams_t *p_results )
  587. {
  588.     VLC_UNUSED(p_params);
  589.     filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
  591.     overlay_t *p_ovl = OverlayCreate();
  592.     if( p_ovl == NULL )
  593.         return VLC_ENOMEM;
  595.     ssize_t i_idx = ListAdd( &p_sys->overlays, p_ovl );
  596.     if( i_idx < 0 )
  597.         return i_idx;
  599.     p_results->i_id = i_idx;
  600.     return VLC_SUCCESS;
  601. }
  603. static int exec_GetAlpha( filter_t *p_filter,
  604.                           const commandparams_t *p_params,
  605.                           commandparams_t *p_results )
  606. {
  607.     filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
  608.     overlay_t *p_ovl = ListGet( &p_sys->overlays, p_params->i_id );
  609.     if( p_ovl == NULL )
  610.         return VLC_EGENERIC;
  612.     p_results->i_alpha = p_ovl->i_alpha;
  613.     return VLC_SUCCESS;
  614. }
  616. static int exec_GetPosition( filter_t *p_filter,
  617.                              const commandparams_t *p_params,
  618.                              commandparams_t *p_results )
  619. {
  620.     filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
  621.     overlay_t *p_ovl = ListGet( &p_sys->overlays, p_params->i_id );
  622.     if( p_ovl == NULL )
  623.         return VLC_EGENERIC;
  625.     p_results->i_x = p_ovl->i_x;
  626.     p_results->i_y = p_ovl->i_y;
  627.     return VLC_SUCCESS;
  628. }
  630. static int exec_GetTextAlpha( filter_t *p_filter,
  631.                               const commandparams_t *p_params,
  632.                               commandparams_t *p_results )
  633. {
  634.     filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
  635.     overlay_t *p_ovl = ListGet( &p_sys->overlays, p_params->i_id );
  636.     if( p_ovl == NULL )
  637.         return VLC_EGENERIC;
  639.     p_results->fontstyle.i_font_alpha = p_ovl->fontstyle.i_font_alpha;
  640.     return VLC_SUCCESS;
  641. }
  643. static int exec_GetTextColor( filter_t *p_filter,
  644.                               const commandparams_t *p_params,
  645.                               commandparams_t *p_results )
  646. {
  647.     filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
  648.     overlay_t *p_ovl = ListGet( &p_sys->overlays, p_params->i_id );
  649.     if( p_ovl == NULL )
  650.         return VLC_EGENERIC;
  652.     p_results->fontstyle.i_font_color = p_ovl->fontstyle.i_font_color;
  653.     return VLC_SUCCESS;
  654. }
  656. static int exec_GetTextSize( filter_t *p_filter,
  657.                              const commandparams_t *p_params,
  658.                              commandparams_t *p_results )
  659. {
  660.     filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
  661.     overlay_t *p_ovl = ListGet( &p_sys->overlays, p_params->i_id );
  662.     if( p_ovl == NULL )
  663.         return VLC_EGENERIC;
  665.     p_results->fontstyle.i_font_size = p_ovl->fontstyle.i_font_size;
  666.     return VLC_SUCCESS;
  667. }
  669. static int exec_GetVisibility( filter_t *p_filter,
  670.                                const commandparams_t *p_params,
  671.                                commandparams_t *p_results )
  672. {
  673.     filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
  675.     overlay_t *p_ovl = ListGet( &p_sys->overlays, p_params->i_id );
  676.     if( p_ovl == NULL )
  677.         return VLC_EGENERIC;
  679.     p_results->b_visible = ( p_ovl->b_active == true ) ? 1 : 0;
  680.     return VLC_SUCCESS;
  681. }
  683. static int exec_SetAlpha( filter_t *p_filter,
  684.                           const commandparams_t *p_params,
  685.                           commandparams_t *p_results )
  686. {
  687.     VLC_UNUSED(p_results);
  688.     filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
  690.     overlay_t *p_ovl = ListGet( &p_sys->overlays, p_params->i_id );
  691.     if( p_ovl == NULL )
  692.         return VLC_EGENERIC;
  694.     p_ovl->i_alpha = p_params->i_alpha;
  695.     p_sys->b_updated = p_ovl->b_active;
  696.     return VLC_SUCCESS;
  697. }
  699. static int exec_SetPosition( filter_t *p_filter,
  700.                              const commandparams_t *p_params,
  701.                              commandparams_t *p_results )
  702. {
  703.     VLC_UNUSED(p_results);
  704.     filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
  706.     overlay_t *p_ovl = ListGet( &p_sys->overlays, p_params->i_id );
  707.     if( p_ovl == NULL )
  708.         return VLC_EGENERIC;
  710.     p_ovl->i_x = p_params->i_x;
  711.     p_ovl->i_y = p_params->i_y;
  713.     p_sys->b_updated = p_ovl->b_active;
  714.     return VLC_SUCCESS;
  715. }
  717. static int exec_SetTextAlpha( filter_t *p_filter,
  718.                               const commandparams_t *p_params,
  719.                               commandparams_t *p_results )
  720. {
  721.     VLC_UNUSED(p_results);
  722.     filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
  724.     overlay_t *p_ovl = ListGet( &p_sys->overlays, p_params->i_id );
  725.     if( p_ovl == NULL )
  726.         return VLC_EGENERIC;
  728.     p_ovl->fontstyle.i_font_alpha = p_params->fontstyle.i_font_alpha;
  729.     p_sys->b_updated = p_ovl->b_active;
  730.     return VLC_SUCCESS;
  731. }
  733. static int exec_SetTextColor( filter_t *p_filter,
  734.                               const commandparams_t *p_params,
  735.                               commandparams_t *p_results )
  736. {
  737.     VLC_UNUSED(p_results);
  738.     filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
  740.     overlay_t *p_ovl = ListGet( &p_sys->overlays, p_params->i_id );
  741.     if( p_ovl == NULL )
  742.         return VLC_EGENERIC;
  744.     p_ovl->fontstyle.i_font_color = p_params->fontstyle.i_font_color;
  745.     p_sys->b_updated = p_ovl->b_active;
  746.     return VLC_SUCCESS;
  747. }
  749. static int exec_SetTextSize( filter_t *p_filter,
  750.                               const commandparams_t *p_params,
  751.                               commandparams_t *p_results )
  752. {
  753.     VLC_UNUSED(p_results);
  754.     filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
  756.     overlay_t *p_ovl = ListGet( &p_sys->overlays, p_params->i_id );
  757.     if( p_ovl == NULL )
  758.         return VLC_EGENERIC;
  760.     p_ovl->fontstyle.i_font_size = p_params->fontstyle.i_font_size;
  761.     p_sys->b_updated = p_ovl->b_active;
  762.     return VLC_SUCCESS;
  763. }
  765. static int exec_SetVisibility( filter_t *p_filter,
  766.                                const commandparams_t *p_params,
  767.                                commandparams_t *p_results )
  768. {
  769.     VLC_UNUSED(p_results);
  770.     filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
  772.     overlay_t *p_ovl = ListGet( &p_sys->overlays, p_params->i_id );
  773.     if( p_ovl == NULL )
  774.         return VLC_EGENERIC;
  776.     p_ovl->b_active = p_params->b_visible;// ? false : true;
  777.     p_sys->b_updated = true;
  778.     return VLC_SUCCESS;
  779. }
  781. static int exec_StartAtomic( filter_t *p_filter,
  782.                              const commandparams_t *p_params,
  783.                              commandparams_t *p_results )
  784. {
  785.     filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
  786.     VLC_UNUSED(p_params);
  787.     VLC_UNUSED(p_results);
  789.     p_sys->b_atomic = true;
  790.     return VLC_SUCCESS;
  791. }
  793. /*****************************************************************************
  794.  * Command functions
  795.  *****************************************************************************/
  796. static const commanddesc_t p_commands[] =
  797. {
  798.     {   .psz_command = "DataSharedMem",
  799.         .b_atomic = true,
  800.         .pf_parser = parser_DataSharedMem,
  801.         .pf_execute = exec_DataSharedMem,
  802.         .pf_unparse = unparse_default,
  803.     },
  804.     {   .psz_command = "DeleteImage",
  805.         .b_atomic = true,
  806.         .pf_parser = parser_Id,
  807.         .pf_execute = exec_DeleteImage,
  808.         .pf_unparse = unparse_default,
  809.     },
  810.     {   .psz_command = "EndAtomic",
  811.         .b_atomic = false,
  812.         .pf_parser = parser_None,
  813.         .pf_execute = exec_EndAtomic,
  814.         .pf_unparse = unparse_default,
  815.     },
  816.     {   .psz_command = "GenImage",
  817.         .b_atomic = false,
  818.         .pf_parser = parser_None,
  819.         .pf_execute = exec_GenImage,
  820.         .pf_unparse = unparse_GenImage,
  821.     },
  822.     {   .psz_command = "GetAlpha",
  823.         .b_atomic = false,
  824.         .pf_parser = parser_Id,
  825.         .pf_execute = exec_GetAlpha,
  826.         .pf_unparse = unparse_GetAlpha,
  827.     },
  828.     {   .psz_command = "GetPosition",
  829.         .b_atomic = false,
  830.         .pf_parser = parser_Id,
  831.         .pf_execute = exec_GetPosition,
  832.         .pf_unparse = unparse_GetPosition,
  833.     },
  834.     {   .psz_command = "GetTextAlpha",
  835.         .b_atomic = false,
  836.         .pf_parser = parser_Id,
  837.         .pf_execute = exec_GetTextAlpha,
  838.         .pf_unparse = unparse_GetTextAlpha,
  839.     },
  840.     {   .psz_command = "GetTextColor",
  841.         .b_atomic = false,
  842.         .pf_parser = parser_Id,
  843.         .pf_execute = exec_GetTextColor,
  844.         .pf_unparse = unparse_GetTextColor,
  845.     },
  846.     {   .psz_command = "GetTextSize",
  847.         .b_atomic = true,
  848.         .pf_parser = parser_Id,
  849.         .pf_execute = exec_GetTextSize,
  850.         .pf_unparse = unparse_GetTextSize,
  851.     },
  852.     {   .psz_command = "GetVisibility",
  853.         .b_atomic = false,
  854.         .pf_parser = parser_Id,
  855.         .pf_execute = exec_GetVisibility,
  856.         .pf_unparse = unparse_GetVisibility,
  857.     },
  858.     {   .psz_command = "SetAlpha",
  859.         .b_atomic = true,
  860.         .pf_parser = parser_SetAlpha,
  861.         .pf_execute = exec_SetAlpha,
  862.         .pf_unparse = unparse_default,
  863.     },
  864.     {   .psz_command = "SetPosition",
  865.         .b_atomic = true,
  866.         .pf_parser = parser_SetPosition,
  867.         .pf_execute = exec_SetPosition,
  868.         .pf_unparse = unparse_default,
  869.     },
  870.     {   .psz_command = "SetTextAlpha",
  871.         .b_atomic = true,
  872.         .pf_parser = parser_SetTextAlpha,
  873.         .pf_execute = exec_SetTextAlpha,
  874.         .pf_unparse = unparse_default,
  875.     },
  876.     {   .psz_command = "SetTextColor",
  877.         .b_atomic = true,
  878.         .pf_parser = parser_SetTextColor,
  879.         .pf_execute = exec_SetTextColor,
  880.         .pf_unparse = unparse_default,
  881.     },
  882.     {   .psz_command = "SetTextSize",
  883.         .b_atomic = true,
  884.         .pf_parser = parser_SetTextSize,
  885.         .pf_execute = exec_SetTextSize,
  886.         .pf_unparse = unparse_default,
  887.     },
  888.     {   .psz_command = "SetVisibility",
  889.         .b_atomic = true,
  890.         .pf_parser = parser_SetVisibility,
  891.         .pf_execute = exec_SetVisibility,
  892.         .pf_unparse = unparse_default,
  893.     },
  894.     {   .psz_command = "StartAtomic",
  895.         .b_atomic = true,
  896.         .pf_parser = parser_None,
  897.         .pf_execute = exec_StartAtomic,
  898.         .pf_unparse = unparse_default,
  899.     }
  900. };
  902. void RegisterCommand( filter_t *p_filter )
  903. {
  904.     filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
  905.     size_t i_index = 0;
  907.     p_sys->i_commands = ARRAY_SIZE(p_commands);
  908.     p_sys->pp_commands = (commanddesc_t **) calloc( p_sys->i_commands, sizeof(commanddesc_t*) );
  909.     if( !p_sys->pp_commands ) return;
  910.     for( i_index = 0; i_index < p_sys->i_commands; i_index ++ )
  911.     {
  912.         p_sys->pp_commands[i_index] = (commanddesc_t *) malloc( sizeof(commanddesc_t) );
  913.         if( !p_sys->pp_commands[i_index] ) return;
  914.         p_sys->pp_commands[i_index]->psz_command = strdup( p_commands[i_index].psz_command );
  915.         p_sys->pp_commands[i_index]->b_atomic = p_commands[i_index].b_atomic;
  916.         p_sys->pp_commands[i_index]->pf_parser = p_commands[i_index].pf_parser;
  917.         p_sys->pp_commands[i_index]->pf_execute = p_commands[i_index].pf_execute;
  918.         p_sys->pp_commands[i_index]->pf_unparse = p_commands[i_index].pf_unparse;
  919.     }
  921.     msg_Dbg( p_filter, "%zu commands are available", p_sys->i_commands );
  922.     for( size_t i_index = 0; i_index < p_sys->i_commands; i_index++ )
  923.         msg_Dbg( p_filter, "    %s", p_sys->pp_commands[i_index]->psz_command );
  924. }
  926. void UnregisterCommand( filter_t *p_filter )
  927. {
  928.     filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
  929.     size_t i_index = 0;
  931.     for( i_index = 0; i_index < p_sys->i_commands; i_index++ )
  932.     {
  933.         free( p_sys->pp_commands[i_index]->psz_command );
  934.         free( p_sys->pp_commands[i_index] );
  935.     }
  936.     free( p_sys->pp_commands );
  937.     p_sys->pp_commands = NULL;
  938.     p_sys->i_commands = 0;
  939. }