Use vlc_memset/vlc_memcpy

[vlc] / modules / video_filter / gradient.c

diff --git a/modules/video_filter/gradient.c b/modules/video_filter/gradient.c
index e2e59b7a1a9db11fe66b872b96e366ad5bb2beb1..0835c7f09b02928eabec8d4da775a62541edb026 100644 (file)
--- a/modules/video_filter/gradient.c
+++ b/modules/video_filter/gradient.c
@@ -25,14 +25,16 @@
 /*****************************************************************************
  * Preamble
  *****************************************************************************/
-#include <stdlib.h>                                      /* malloc(), free() */
-#include <string.h>
 
 #include <math.h>                                            /* sin(), cos() */
 
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
 #include <vlc/vlc.h>
-#include <vlc/sout.h>
-#include <vlc/decoder.h>
+#include <vlc_sout.h>
+#include <vlc_vout.h>
 
 #include "vlc_filter.h"
 
@@ -45,6 +47,9 @@ static int  Create    ( vlc_object_t * );
 static void Destroy   ( vlc_object_t * );
 
 static picture_t *Filter( filter_t *, picture_t * );
+static int GradientCallback( vlc_object_t *, char const *,
+                             vlc_value_t, vlc_value_t,
+                             void * );
 
 static void FilterGradient( filter_t *, picture_t *, picture_t * );
 static void FilterEdge    ( filter_t *, picture_t *, picture_t * );
@@ -64,26 +69,26 @@ static void FilterHough   ( filter_t *, picture_t *, picture_t * );
 #define CARTOON_LONGTEXT N_("Apply cartoon effect. It is only used by " \
     "\"gradient\" and \"edge\".")
 
-static char *mode_list[] = { "gradient", "edge", "hough" };
-static char *mode_list_text[] = { N_("Gradient"), N_("Edge"), N_("Hough") };
+static const char *mode_list[] = { "gradient", "edge", "hough" };
+static const char *mode_list_text[] = { N_("Gradient"), N_("Edge"), N_("Hough") };
 
 #define FILTER_PREFIX "gradient-"
 
 vlc_module_begin();
     set_description( _("Gradient video filter") );
-    set_shortname( N_( "Gradient" ));
+    set_shortname( _( "Gradient" ));
     set_capability( "video filter2", 0 );
     set_category( CAT_VIDEO );
-    set_subcategory( SUBCAT_VIDEO_VFILTER2 );
+    set_subcategory( SUBCAT_VIDEO_VFILTER );
 
     add_string( FILTER_PREFIX "mode", "gradient", NULL,
-                MODE_TEXT, MODE_LONGTEXT, VLC_FALSE );
+                MODE_TEXT, MODE_LONGTEXT, false );
         change_string_list( mode_list, mode_list_text, 0 );
 
     add_integer_with_range( FILTER_PREFIX "type", 0, 0, 1, NULL,
-                GRADIENT_TEXT, GRADIENT_LONGTEXT, VLC_FALSE );
+                GRADIENT_TEXT, GRADIENT_LONGTEXT, false );
     add_bool( FILTER_PREFIX "cartoon", 1, NULL,
-                CARTOON_TEXT, CARTOON_LONGTEXT, VLC_FALSE );
+                CARTOON_TEXT, CARTOON_LONGTEXT, false );
 
     add_shortcut( "gradient" );
     set_callbacks( Create, Destroy );
@@ -105,7 +110,7 @@ struct filter_sys_t
 
     /* For the gradient mode */
     int i_gradient_type;
-    vlc_bool_t b_cartoon;
+    bool b_cartoon;
 
     uint32_t *p_buf32;
     uint32_t *p_buf32_bis;
@@ -137,17 +142,11 @@ static int Create( vlc_object_t *p_this )
 
     p_filter->p_sys->p_pre_hough = NULL;
 
-    sout_CfgParse( p_filter, FILTER_PREFIX, ppsz_filter_options,
+    config_ChainParse( p_filter, FILTER_PREFIX, ppsz_filter_options,
                    p_filter->p_cfg );
 
-    var_Create( p_filter, FILTER_PREFIX "mode",
-                VLC_VAR_STRING | VLC_VAR_DOINHERIT );
-    var_Create( p_filter, FILTER_PREFIX "type",
-                VLC_VAR_STRING | VLC_VAR_DOINHERIT );
-    var_Create( p_filter, FILTER_PREFIX "cartoon",
-                VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
-
-    if( !(psz_method = var_GetString( p_filter, FILTER_PREFIX "mode" )) )
+    if( !(psz_method =
+        var_CreateGetNonEmptyStringCommand( p_filter, FILTER_PREFIX "mode" )) )
     {
         msg_Err( p_filter, "configuration variable "
                  FILTER_PREFIX "mode empty" );
@@ -169,16 +168,23 @@ static int Create( vlc_object_t *p_this )
         }
         else
         {
-            msg_Err( p_filter, "no valid gradient mode provided" );
+            msg_Err( p_filter, "no valid gradient mode provided (%s)", psz_method );
             p_filter->p_sys->i_mode = GRADIENT;
         }
     }
     free( psz_method );
 
     p_filter->p_sys->i_gradient_type =
-        var_GetInteger( p_filter, FILTER_PREFIX "type" );
+        var_CreateGetIntegerCommand( p_filter, FILTER_PREFIX "type" );
     p_filter->p_sys->b_cartoon =
-        var_GetInteger( p_filter, FILTER_PREFIX "cartoon" );
+        var_CreateGetBoolCommand( p_filter, FILTER_PREFIX "cartoon" );
+
+    var_AddCallback( p_filter, FILTER_PREFIX "mode",
+                     GradientCallback, p_filter->p_sys );
+    var_AddCallback( p_filter, FILTER_PREFIX "type",
+                     GradientCallback, p_filter->p_sys );
+    var_AddCallback( p_filter, FILTER_PREFIX "cartoon",
+                     GradientCallback, p_filter->p_sys );
 
     p_filter->p_sys->p_buf32 = NULL;
     p_filter->p_sys->p_buf32_bis = NULL;
@@ -256,7 +262,6 @@ static picture_t *Filter( filter_t *p_filter, picture_t *p_pic )
     return p_outpic;
 }
 
-
 /*****************************************************************************
  * Gaussian Convolution
  *****************************************************************************
@@ -341,18 +346,18 @@ static void FilterGradient( filter_t *p_filter, picture_t *p_inpic,
 
     if( p_filter->p_sys->b_cartoon )
     {
-        p_filter->p_vlc->pf_memcpy( p_outpic->p[U_PLANE].p_pixels,
+        vlc_memcpy( p_outpic->p[U_PLANE].p_pixels,
             p_inpic->p[U_PLANE].p_pixels,
             p_outpic->p[U_PLANE].i_lines * p_outpic->p[U_PLANE].i_pitch );
-        p_filter->p_vlc->pf_memcpy( p_outpic->p[V_PLANE].p_pixels,
+        vlc_memcpy( p_outpic->p[V_PLANE].p_pixels,
             p_inpic->p[V_PLANE].p_pixels,
             p_outpic->p[V_PLANE].i_lines * p_outpic->p[V_PLANE].i_pitch );
     }
     else
     {
-        p_filter->p_vlc->pf_memset( p_outpic->p[U_PLANE].p_pixels, 0x80,
+        vlc_memset( p_outpic->p[U_PLANE].p_pixels, 0x80,
             p_outpic->p[U_PLANE].i_lines * p_outpic->p[U_PLANE].i_pitch );
-        p_filter->p_vlc->pf_memset( p_outpic->p[V_PLANE].p_pixels, 0x80,
+        vlc_memset( p_outpic->p[V_PLANE].p_pixels, 0x80,
             p_outpic->p[V_PLANE].i_lines * p_outpic->p[V_PLANE].i_pitch );
     }
 
@@ -418,10 +423,7 @@ static void FilterGradient( filter_t *p_filter, picture_t *p_inpic,
         else
         {
             FOR
-            if( a>>8 )
-                p_outpix[y*i_dst_pitch+x] = 255;
-            else
-                p_outpix[y*i_dst_pitch+x] = (uint8_t)a;
+            p_outpix[y*i_dst_pitch+x] = clip_uint8_vlc( a );
             }}
         }
     }
@@ -488,20 +490,20 @@ static void FilterEdge( filter_t *p_filter, picture_t *p_inpic,
 
     if( p_filter->p_sys->b_cartoon )
     {
-        p_filter->p_vlc->pf_memcpy( p_outpic->p[U_PLANE].p_pixels,
+        vlc_memcpy( p_outpic->p[U_PLANE].p_pixels,
             p_inpic->p[U_PLANE].p_pixels,
             p_outpic->p[U_PLANE].i_lines * p_outpic->p[U_PLANE].i_pitch );
-        p_filter->p_vlc->pf_memcpy( p_outpic->p[V_PLANE].p_pixels,
+        vlc_memcpy( p_outpic->p[V_PLANE].p_pixels,
             p_inpic->p[V_PLANE].p_pixels,
             p_outpic->p[V_PLANE].i_lines * p_outpic->p[V_PLANE].i_pitch );
     }
     else
     {
-        p_filter->p_vlc->pf_memset( p_outpic->p[Y_PLANE].p_pixels, 0xff,
+        vlc_memset( p_outpic->p[Y_PLANE].p_pixels, 0xff,
               p_outpic->p[Y_PLANE].i_lines * p_outpic->p[Y_PLANE].i_pitch );
-        p_filter->p_vlc->pf_memset( p_outpic->p[U_PLANE].p_pixels, 0x80,
+        vlc_memset( p_outpic->p[U_PLANE].p_pixels, 0x80,
             p_outpic->p[U_PLANE].i_lines * p_outpic->p[U_PLANE].i_pitch );
-        memset( p_outpic->p[V_PLANE].p_pixels, 0x80,
+        vlc_memset( p_outpic->p[V_PLANE].p_pixels, 0x80,
             p_outpic->p[V_PLANE].i_lines * p_outpic->p[V_PLANE].i_pitch );
     }
 
@@ -658,15 +660,15 @@ static void FilterHough( filter_t *p_filter, picture_t *p_inpic,
         msg_Dbg(p_filter, "Precalculation done");
     }
 
-    memset( p_hough, 0, i_diag * i_nb_steps * sizeof(int) );
+    vlc_memset( p_hough, 0, i_diag * i_nb_steps * sizeof(int) );
 
-    p_filter->p_vlc->pf_memcpy(
+    vlc_memcpy(
         p_outpic->p[Y_PLANE].p_pixels, p_inpic->p[Y_PLANE].p_pixels,
         p_outpic->p[Y_PLANE].i_lines * p_outpic->p[Y_PLANE].i_pitch );
-    p_filter->p_vlc->pf_memcpy(
+    vlc_memcpy(
         p_outpic->p[U_PLANE].p_pixels, p_inpic->p[U_PLANE].p_pixels,
         p_outpic->p[U_PLANE].i_lines * p_outpic->p[U_PLANE].i_pitch );
-    p_filter->p_vlc->pf_memcpy(
+    vlc_memcpy(
         p_outpic->p[V_PLANE].p_pixels, p_inpic->p[V_PLANE].p_pixels,
         p_outpic->p[V_PLANE].i_lines * p_outpic->p[V_PLANE].i_pitch );
 
@@ -733,7 +735,45 @@ static void FilterHough( filter_t *p_filter, picture_t *p_inpic,
         }
     }
 
-    if( p_hough ) free( p_hough );
-    if( p_smooth ) free( p_smooth );
+    free( p_hough );
+    free( p_smooth );
 }
 #undef p_pre_hough
+
+
+static int GradientCallback( vlc_object_t *p_this, char const *psz_var,
+                             vlc_value_t oldval, vlc_value_t newval,
+                             void *p_data )
+{
+    VLC_UNUSED(oldval);
+    filter_sys_t *p_sys = (filter_sys_t *)p_data;
+    if( !strcmp( psz_var, FILTER_PREFIX "mode" ) )
+    {
+        if( !strcmp( newval.psz_string, "gradient" ) )
+        {
+            p_sys->i_mode = GRADIENT;
+        }
+        else if( !strcmp( newval.psz_string, "edge" ) )
+        {
+            p_sys->i_mode = EDGE;
+        }
+        else if( !strcmp( newval.psz_string, "hough" ) )
+        {
+            p_sys->i_mode = HOUGH;
+        }
+        else
+        {
+            msg_Err( p_this, "no valid gradient mode provided (%s)", newval.psz_string );
+            p_sys->i_mode = GRADIENT;
+        }
+    }
+    else if( !strcmp( psz_var, FILTER_PREFIX "type" ) )
+    {
+        p_sys->i_gradient_type = newval.i_int;
+    }
+    else if( !strcmp( psz_var, FILTER_PREFIX "cartoon" ) )
+    {
+        p_sys->b_cartoon = newval.b_bool;
+    }
+    return VLC_SUCCESS;
+}