git.sesse.net Git - vlc/blob - modules/video_filter/gaussianblur.c

   1 /*****************************************************************************
   2  * gaussianblur.c : gaussian blur video filter
   3  *****************************************************************************
   4  * Copyright (C) 2000-2007 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Antoine Cellerier <dionoea -at- videolan -dot- org>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27 #include <string.h>
  28
  29 #include <vlc/vlc.h>
  30 #include <vlc_vout.h>
  31
  32 #include "vlc_filter.h"
  33
  34 #include <math.h>                                          /* exp(), sqrt() */
  35
  36 /*****************************************************************************
  37  * Local prototypes
  38  *****************************************************************************/
  39 static int  Create    ( vlc_object_t * );
  40 static void Destroy   ( vlc_object_t * );
  41
  42 static picture_t *Filter( filter_t *, picture_t * );
  43
  44 #define SIGMA_TEXT N_("Gaussian's std deviation")
  45 #define SIGMA_LONGTEXT N_( \
  46     "Gaussian's standard deviation. The bluring will take " \
  47     "into account pixels up to 3*sigma away in any direction.")
  48
  49 #define FILTER_PREFIX "gaussianblur-"
  50
  51 /*****************************************************************************
  52  * Module descriptor
  53  *****************************************************************************/
  54 vlc_module_begin();
  55     set_description( _("Gaussian blur video filter") );
  56     set_shortname( _( "Gaussian Blur" ));
  57     set_capability( "video filter2", 0 );
  58     set_category( CAT_VIDEO );
  59     set_subcategory( SUBCAT_VIDEO_VFILTER );
  60
  61     add_float( FILTER_PREFIX "sigma", 2., NULL, SIGMA_TEXT, SIGMA_LONGTEXT,
  62                VLC_FALSE );
  63
  64     set_callbacks( Create, Destroy );
  65 vlc_module_end();
  66
  67 static const char *ppsz_filter_options[] = {
  68     "sigma", NULL
  69 };
  70
  71 /* Comment this to use floats instead of integers (faster for bigger sigma
  72  * values)
  73  * For sigma = 2 ints are faster
  74  * For sigma = 4 floats are faster
  75  */
  76 #define DONT_USE_FLOATS
  77 struct filter_sys_t
  78 {
  79     double f_sigma;
  80     int i_dim;
  81 #ifdef DONT_USE_FLOATS
  82     int *pi_distribution;
  83     int *pi_buffer;
  84     int *pi_scale;
  85 #else
  86     float *pf_distribution;
  87     float *pf_buffer;
  88     float *pf_scale;
  89 #endif
  90 };
  91
  92 static void gaussianblur_InitDistribution( filter_sys_t *p_sys )
  93 {
  94     double f_sigma = p_sys->f_sigma;
  95     int i_dim = (int)(3.*f_sigma);
  96 #ifdef DONT_USE_FLOATS
  97     int *pi_distribution = (int*)malloc( (2*i_dim+1) * sizeof( int ) );
  98 #else
  99     float *pf_distribution = (float*)malloc( (2*i_dim+1) * sizeof( float ) );
 100 #endif
 101     int x;
 102     for( x = -i_dim; x <= i_dim; x++ )
 103     {
 104 #ifdef DONT_USE_FLOATS
 105         pi_distribution[i_dim+x] =
 106             (int)( sqrt( exp(-(x*x)/(f_sigma*f_sigma) )
 107                  / (2.*M_PI*f_sigma*f_sigma) )  * (double)(1<<8) );
 108         printf("%d\n",pi_distribution[i_dim+x]);
 109 #else
 110         pf_distribution[i_dim+x] = (float)
 111             sqrt( exp(-(x*x)/(f_sigma*f_sigma) ) / (2.*M_PI*f_sigma*f_sigma) );
 112         printf("%f\n",pf_distribution[i_dim+x]);
 113 #endif
 114     }
 115     p_sys->i_dim = i_dim;
 116 #ifdef DONT_USE_FLOATS
 117     p_sys->pi_distribution = pi_distribution;
 118 #else
 119     p_sys->pf_distribution = pf_distribution;
 120 #endif
 121 }
 122
 123 static int Create( vlc_object_t *p_this )
 124 {
 125     filter_t *p_filter = (filter_t *)p_this;
 126
 127     p_filter->p_sys = malloc( sizeof( filter_sys_t ) );
 128     if( p_filter->p_sys == NULL )
 129     {
 130         msg_Err( p_filter, "out of memory" );
 131         return VLC_ENOMEM;
 132     }
 133
 134     config_ChainParse( p_filter, FILTER_PREFIX, ppsz_filter_options,
 135                        p_filter->p_cfg );
 136
 137     p_filter->pf_video_filter = Filter;
 138
 139     p_filter->p_sys->f_sigma =
 140         var_CreateGetFloat( p_filter, FILTER_PREFIX "sigma" );
 141     if( p_filter->p_sys->f_sigma <= 0. )
 142     {
 143         msg_Err( p_filter, "sigma must be positive" );
 144         return VLC_EGENERIC;
 145     }
 146     gaussianblur_InitDistribution( p_filter->p_sys );
 147     msg_Dbg( p_filter, "gaussian distribution is %d pixels wide",
 148              p_filter->p_sys->i_dim*2+1 );
 149 #ifdef DONT_USE_FLOATS
 150     p_filter->p_sys->pi_buffer = NULL;
 151     p_filter->p_sys->pi_scale = NULL;
 152 #else
 153     p_filter->p_sys->pf_buffer = NULL;
 154     p_filter->p_sys->pf_scale = NULL;
 155 #endif
 156
 157     return VLC_SUCCESS;
 158 }
 159
 160 static void Destroy( vlc_object_t *p_this )
 161 {
 162     filter_t *p_filter = (filter_t *)p_this;
 163 #ifdef DONT_USE_FLOATS
 164     free( p_filter->p_sys->pi_distribution );
 165     free( p_filter->p_sys->pi_buffer );
 166     free( p_filter->p_sys->pi_scale );
 167 #else
 168     free( p_filter->p_sys->pf_distribution );
 169     free( p_filter->p_sys->pf_buffer );
 170     free( p_filter->p_sys->pf_scale );
 171 #endif
 172     free( p_filter->p_sys );
 173 }
 174
 175 static picture_t *Filter( filter_t *p_filter, picture_t *p_pic )
 176 {
 177     picture_t *p_outpic;
 178     filter_sys_t *p_sys = p_filter->p_sys;
 179     int i_plane;
 180     const int i_dim = p_sys->i_dim;
 181 #ifdef DONT_USE_FLOATS
 182     int *pi_buffer;
 183     int *pi_scale;
 184     const int *pi_distribution = p_sys->pi_distribution;
 185 #else
 186     float *pf_buffer;
 187     float *pf_scale;
 188     const float *pf_distribution = p_sys->pf_distribution;
 189 #endif
 190     if( !p_pic ) return NULL;
 191
 192     p_outpic = p_filter->pf_vout_buffer_new( p_filter );
 193     if( !p_outpic )
 194     {
 195         msg_Warn( p_filter, "can't get output picture" );
 196         if( p_pic->pf_release )
 197             p_pic->pf_release( p_pic );
 198         return NULL;
 199     }
 200 #ifdef DONT_USE_FLOATS
 201     if( !p_sys->pi_buffer )
 202     {
 203         p_sys->pi_buffer = (int*)realloc( p_sys->pi_buffer,
 204                                           p_pic->p[Y_PLANE].i_visible_lines
 205                                           * p_pic->p[Y_PLANE].i_pitch
 206                                           * sizeof( int ) );
 207     }
 208     pi_buffer = p_sys->pi_buffer;
 209 #else
 210     if( !p_sys->pf_buffer )
 211     {
 212         p_sys->pf_buffer = (float*)realloc( p_sys->pf_buffer,
 213                                             p_pic->p[Y_PLANE].i_visible_lines
 214                                             * p_pic->p[Y_PLANE].i_pitch
 215                                             * sizeof( float ) );
 216     }
 217     pf_buffer = p_sys->pf_buffer;
 218 #endif
 219 #ifdef DONT_USE_FLOATS
 220     if( !p_sys->pi_scale )
 221 #else
 222     if( !p_sys->pf_scale )
 223 #endif
 224     {
 225         const int i_visible_lines = p_pic->p[Y_PLANE].i_visible_lines;
 226         const int i_visible_pitch = p_pic->p[Y_PLANE].i_visible_pitch;
 227         const int i_pitch = p_pic->p[Y_PLANE].i_pitch;
 228         int i_col, i_line;
 229 #ifdef DONT_USE_FLOATS
 230         p_sys->pi_scale = (int*)malloc( i_visible_lines * i_pitch
 231                                         * sizeof( int ) );
 232         pi_scale = p_sys->pi_scale;
 233 #else
 234         p_sys->pf_scale = (float*)malloc( i_visible_lines * i_pitch
 235                                           * sizeof( float ) );
 236         pf_scale = p_sys->pf_scale;
 237 #endif
 238         for( i_line = 0 ; i_line < i_visible_lines ; i_line++ )
 239         {
 240             for( i_col = 0; i_col < i_visible_pitch ; i_col++ )
 241             {
 242                 int x, y;
 243 #ifdef DONT_USE_FLOATS
 244                 int value = 0;
 245 #else
 246                 double value = 0.;
 247 #endif
 248                 for( y = __MAX( -i_dim, -i_line );
 249                      y <= __MIN( i_dim, i_visible_lines - i_line - 1 );
 250                      y++ )
 251                 {
 252                     for( x = __MAX( -i_dim, -i_col );
 253                          x <= __MIN( i_dim, i_visible_pitch - i_col + 1 );
 254                          x++ )
 255                     {
 256 #ifdef DONT_USE_FLOATS
 257                         value += pi_distribution[y+i_dim]
 258                                * pi_distribution[x+i_dim];
 259 #else
 260                         value += ((double)pf_distribution[y+i_dim])
 261                                * ((double)pf_distribution[x+i_dim]);
 262 #endif
 263                     }
 264                 }
 265 #ifdef DONT_USE_FLOATS
 266                 pi_scale[i_line*i_pitch+i_col] = value;
 267 #else
 268                 pf_scale[i_line*i_pitch+i_col] = (float)(1./value);
 269 #endif
 270             }
 271         }
 272     }
 273 #ifdef DONT_USE_FLOATS
 274     pi_scale = p_sys->pi_scale;
 275 #else
 276     pf_scale = p_sys->pf_scale;
 277 #endif
 278
 279     for( i_plane = 0 ; i_plane < p_pic->i_planes ; i_plane++ )
 280     {
 281
 282         uint8_t *p_in = p_pic->p[i_plane].p_pixels;
 283         uint8_t *p_out = p_outpic->p[i_plane].p_pixels;
 284
 285         const int i_visible_lines = p_pic->p[i_plane].i_visible_lines;
 286         const int i_visible_pitch = p_pic->p[i_plane].i_visible_pitch;
 287         const int i_pitch = p_pic->p[i_plane].i_pitch;
 288
 289         int i_line, i_col;
 290         const int factor = i_plane ? 1 : 0;
 291
 292         for( i_line = 0 ; i_line < i_visible_lines ; i_line++ )
 293         {
 294             for( i_col = 0; i_col < i_visible_pitch ; i_col++ )
 295             {
 296 #ifdef DONT_USE_FLOATS
 297                 int value = 0;
 298 #else
 299                 float value = 0.;
 300 #endif
 301                 int x;
 302                 const int c = i_line*i_pitch+i_col;
 303                 for( x = __MAX( -i_dim, -i_col*(factor+1) );
 304                      x <= __MIN( i_dim, (i_visible_pitch - i_col)*(factor+1) + 1 );
 305                      x++ )
 306                 {
 307 #ifdef DONT_USE_FLOATS
 308                     value += pi_distribution[x+i_dim]
 309                            * p_in[c+(x>>factor)];
 310 #else
 311                     value += pf_distribution[x+i_dim]
 312                            * (float)p_in[c+(x>>factor)];
 313 #endif
 314                 }
 315 #ifdef DONT_USE_FLOATS
 316                 pi_buffer[c] = value;
 317 #else
 318                 pf_buffer[c] = value;
 319 #endif
 320             }
 321         }
 322         for( i_line = 0 ; i_line < i_visible_lines ; i_line++ )
 323         {
 324             for( i_col = 0; i_col < i_visible_pitch ; i_col++ )
 325             {
 326 #ifdef DONT_USE_FLOATS
 327                 int value = 0;
 328 #else
 329                 float value = 0.;
 330 #endif
 331                 int y;
 332                 const int c = i_line*i_pitch+i_col;
 333                 for( y = __MAX( -i_dim, (-i_line)*(factor+1) );
 334                      y <= __MIN( i_dim, (i_visible_lines - i_line)*(factor+1) - 1 );
 335                      y++ )
 336                 {
 337 #ifdef DONT_USE_FLOATS
 338                     value += pi_distribution[y+i_dim]
 339                            * pi_buffer[c+(y>>factor)*i_pitch];
 340 #else
 341                     value += pf_distribution[y+i_dim]
 342                            * pf_buffer[c+(y>>factor)*i_pitch];
 343 #endif
 344                 }
 345 #ifdef DONT_USE_FLOATS
 346                 p_out[c] = (uint8_t)(value/pi_scale[(i_line<<factor)*(i_pitch<<factor)+(i_col<<factor)]);
 347 #else
 348                 p_out[c] = (uint8_t)(value*pf_scale[(i_line<<factor)*(i_pitch<<factor)+(i_col<<factor)]);
 349 #endif
 350             }
 351         }
 352     }
 353
 354     p_outpic->date = p_pic->date;
 355     p_outpic->b_force = p_pic->b_force;
 356     p_outpic->i_nb_fields = p_pic->i_nb_fields;
 357     p_outpic->b_progressive = p_pic->b_progressive;
 358     p_outpic->b_top_field_first = p_pic->b_top_field_first;
 359
 360     if( p_pic->pf_release )
 361         p_pic->pf_release( p_pic );
 362
 363     return p_outpic;
 364 }