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

   1 /*****************************************************************************
   2  * ball.c : Augmented reality ball video filter module
   3  *****************************************************************************
   4  * Copyright (C) 2000-2009 the VideoLAN team
   5  *
   6  * Author: Adrien Maglo <magsoft@videolan.org>
   7  *
   8  * The Canny edge detection algorithm comes from gradient.c which was
   9  * writen by:
  10  *         Samuel Hocevar <sam@zoy.org>
  11  *         Antoine Cellerier <dionoea -at- videolan -dot- org>
  12  *
  13  * This program is free software; you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License as published by
  15  * the Free Software Foundation; either version 2 of the License, or
  16  * (at your option) any later version.
  17  *
  18  * This program is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program; if not, write to the Free Software
  25  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  26  *****************************************************************************/
  27
  28
  29 /*****************************************************************************
  30  * Preamble
  31  *****************************************************************************/
  32
  33 #ifdef HAVE_CONFIG_H
  34 # include "config.h"
  35 #endif
  36
  37 #include <math.h> /* sin(), cos(), asin() */
  38
  39 #include <vlc_common.h>
  40 #include <vlc_plugin.h>
  41 #include <vlc_sout.h>
  42 #include <vlc_vout.h>
  43
  44 #include "vlc_filter.h"
  45 #include "filter_picture.h"
  46 #include "vlc_image.h"
  47
  48 enum { RED, GREEN, BLUE, WHITE };
  49
  50 typedef struct
  51 {
  52     uint8_t comp1;
  53     uint8_t comp2;
  54     uint8_t comp3;
  55 }COLOR;
  56
  57 static COLOR colorList[4];
  58
  59 #define COLORS_RGB \
  60     colorList[RED].comp1 = 255; colorList[RED].comp2 = 0;        \
  61                                 colorList[RED].comp3 = 0;        \
  62     colorList[GREEN].comp1 = 0; colorList[GREEN].comp2 = 255;    \
  63                                colorList[GREEN].comp3 = 0;       \
  64     colorList[BLUE].comp1 = 0; colorList[BLUE].comp2 = 0;        \
  65                                colorList[BLUE].comp3 = 255;      \
  66     colorList[WHITE].comp1 = 255; colorList[WHITE].comp2 = 255;  \
  67                                   colorList[WHITE].comp3 = 255;
  68
  69 #define COLORS_YUV \
  70     colorList[RED].comp1 = 82; colorList[RED].comp2 = 240;        \
  71                                 colorList[RED].comp3 = 90;        \
  72     colorList[GREEN].comp1 = 145; colorList[GREEN].comp2 = 34;    \
  73                                colorList[GREEN].comp3 = 54 ;      \
  74     colorList[BLUE].comp1 = 41; colorList[BLUE].comp2 = 146;      \
  75                                colorList[BLUE].comp3 = 240;       \
  76     colorList[WHITE].comp1 = 255; colorList[WHITE].comp2 = 128;   \
  77                                   colorList[WHITE].comp3 = 128;
  78
  79
  80 /*****************************************************************************
  81  * Local prototypes
  82  *****************************************************************************/
  83 static int  Create    ( vlc_object_t * );
  84 static void Destroy   ( vlc_object_t * );
  85
  86 static picture_t *Filter( filter_t *, picture_t * );
  87
  88 static void drawBall( filter_sys_t *p_sys, picture_t *p_outpic );
  89 static void drawPixelRGB24( filter_sys_t *p_sys, picture_t *p_outpic,
  90                             uint8_t R, uint8_t G, uint8_t B,
  91                             int x, int y, bool b_skip );
  92 static void drawPixelI420( filter_sys_t *p_sys, picture_t *p_outpic,
  93                            uint8_t Y, uint8_t U, uint8_t V,
  94                            int x, int y, bool b_skip );
  95 static void drawPixelPacked( filter_sys_t *p_sys, picture_t *p_outpic,
  96                              uint8_t Y, uint8_t U, uint8_t V,
  97                              int x, int y, bool b_skip );
  98
  99 static void FilterBall( filter_t *, picture_t *, picture_t * );
 100 static int ballCallback( vlc_object_t *, char const *,
 101                          vlc_value_t, vlc_value_t,
 102                          void * );
 103 static int getBallColor( vlc_object_t *p_this, char const *psz_newval );
 104
 105
 106 /*****************************************************************************
 107  * Module descriptor
 108  *****************************************************************************/
 109 #define BALL_COLOR_TEXT N_("Ball color")
 110 #define BALL_COLOR_LONGTEXT N_("Ball color, one of \"red\", \"blue\" and \"green\".")
 111
 112 #define EDGE_VISIBLE_TEXT N_("Edge visible")
 113 #define EDGE_VISIBLE_LONGTEXT N_("Set edge visibility.")
 114
 115 #define BALL_SPEED_TEXT N_("Ball speed")
 116 #define BALL_SPEED_LONGTEXT N_("Set ball speed, the displacement value \
 117                                 in number of pixels by frame.")
 118
 119 #define BALL_SIZE_TEXT N_("Ball size")
 120 #define BALL_SIZE_LONGTEXT N_("Set ball size giving its radius in number \
 121                                 of pixels")
 122
 123 #define GRAD_THRESH_TEXT N_("Gradient threshold")
 124 #define GRAD_THRESH_LONGTEXT N_("Set gradient threshold for edge computation.")
 125
 126 #define BALL_HELP N_("Augmented reality ball game")
 127
 128 #define FILTER_PREFIX "ball-"
 129
 130 static const char *const mode_list[] = { "red", "green", "blue", "white" };
 131 static const char *const mode_list_text[] = { N_("Red"), N_("Green"),
 132                                               N_("Blue"), N_("White") };
 133
 134 vlc_module_begin ()
 135     set_description( N_("Ball video filter") )
 136     set_shortname( N_( "Ball" ))
 137     set_help(BALL_HELP)
 138     set_capability( "video filter2", 0 )
 139     set_category( CAT_VIDEO )
 140     set_subcategory( SUBCAT_VIDEO_VFILTER )
 141
 142     add_string( FILTER_PREFIX "ball-color", "ball-color", NULL,
 143                 BALL_COLOR_TEXT, BALL_COLOR_LONGTEXT, false )
 144     change_string_list( mode_list, mode_list_text, 0 )
 145
 146     add_integer_with_range( FILTER_PREFIX "ball-speed", 4, 1, 15, NULL,
 147                             BALL_SPEED_TEXT, BALL_SPEED_LONGTEXT, false )
 148
 149     add_integer_with_range( FILTER_PREFIX "ball-size", 10, 5, 30, NULL,
 150                             BALL_SIZE_TEXT, BALL_SIZE_LONGTEXT, false )
 151
 152     add_integer_with_range( FILTER_PREFIX "gradient-threshold", 40, 1, 200, NULL,
 153                             GRAD_THRESH_TEXT, GRAD_THRESH_LONGTEXT, false )
 154
 155     add_bool( FILTER_PREFIX "edge-visible", 1, NULL,
 156               EDGE_VISIBLE_TEXT, EDGE_VISIBLE_LONGTEXT, true )
 157
 158     add_shortcut( "ball" )
 159     set_callbacks( Create, Destroy )
 160 vlc_module_end ()
 161
 162 static const char *const ppsz_filter_options[] = {
 163     "ball-color", "ball-speed", "ball-size",
 164     "gradient-threshold", "edge-visible", NULL
 165 };
 166
 167
 168 /*****************************************************************************
 169 * filter_sys_t: Distort video output method descriptor
 170 *****************************************************************************
 171 * This structure is part of the video output thread descriptor.
 172 * It describes the Distort specific properties of an output thread.
 173  *****************************************************************************/
 174 struct filter_sys_t
 175 {
 176     vlc_mutex_t lock;
 177
 178     int ballColor;
 179
 180     image_handler_t *p_image;
 181
 182     /* Ball position */
 183     int i_ball_x;
 184     int i_ball_y;
 185
 186     int i_ballSpeed;
 187
 188     int i_ballSize;
 189
 190     bool b_edgeVisible;
 191
 192     /* Offsets for YUV packed chroma */
 193     int i_y_offset;
 194     int i_u_offset;
 195     int i_v_offset;
 196
 197     /* Gradient values */
 198     uint32_t *p_smooth;
 199     int32_t *p_grad_x;
 200     int32_t *p_grad_y;
 201
 202     /* Gradient threshold */
 203     int i_gradThresh;
 204
 205     /* Motion vectors */
 206     float f_lastVect_x;
 207     float f_lastVect_y;
 208
 209     float f_newVect_x;
 210     float f_newVect_y;
 211
 212     float f_contVect_x;
 213     float f_contVect_y;
 214
 215     /* Pointer on drawing function */
 216     void ( *drawingPixelFunction )( filter_sys_t *, picture_t *,
 217                                     uint8_t, uint8_t, uint8_t,
 218                                     int, int, bool );
 219 };
 220
 221
 222 /*****************************************************************************
 223 * Create: allocates Distort video thread output method
 224 *****************************************************************************
 225 * This function allocates and initializes a Distort vout method.
 226 *****************************************************************************/
 227 static int Create( vlc_object_t *p_this )
 228 {
 229     filter_t *p_filter = (filter_t *)p_this;
 230     char *psz_method;
 231
 232     /* Allocate structure */
 233     p_filter->p_sys = malloc( sizeof( filter_sys_t ) );
 234     if( p_filter->p_sys == NULL )
 235         return VLC_ENOMEM;
 236
 237     switch( p_filter->fmt_in.video.i_chroma )
 238     {
 239         case VLC_CODEC_I420:
 240         case VLC_CODEC_J420:
 241             p_filter->p_sys->drawingPixelFunction = drawPixelI420;
 242             COLORS_YUV
 243             break;
 244         CASE_PACKED_YUV_422
 245             p_filter->p_sys->drawingPixelFunction = drawPixelPacked;
 246             COLORS_YUV
 247             GetPackedYuvOffsets( p_filter->fmt_in.video.i_chroma,
 248                                  &p_filter->p_sys->i_y_offset,
 249                                  &p_filter->p_sys->i_u_offset,
 250                                  &p_filter->p_sys->i_v_offset );
 251             break;
 252         case VLC_CODEC_RGB24:
 253             p_filter->p_sys->drawingPixelFunction = drawPixelRGB24;
 254             COLORS_RGB
 255             break;
 256         default:
 257             msg_Err( p_filter, "Unsupported input chroma (%4.4s)",
 258                      (char*)&(p_filter->fmt_in.video.i_chroma) );
 259             return VLC_EGENERIC;
 260     }
 261
 262     p_filter->p_sys->p_image = image_HandlerCreate( p_filter );
 263     if( p_filter->p_sys->p_image == NULL )
 264         return VLC_EGENERIC;
 265
 266     p_filter->pf_video_filter = Filter;
 267
 268     config_ChainParse( p_filter, FILTER_PREFIX, ppsz_filter_options,
 269                        p_filter->p_cfg );
 270
 271     if( !(psz_method =
 272         var_CreateGetNonEmptyStringCommand( p_filter,
 273                                             FILTER_PREFIX "ball-color" ) ) )
 274     {
 275         msg_Err( p_filter, "configuration variable "
 276                  FILTER_PREFIX "ball-color empty" );
 277         p_filter->p_sys->ballColor = RED;
 278     }
 279     else
 280         p_filter->p_sys->ballColor = getBallColor( p_this, psz_method );
 281
 282     free( psz_method );
 283
 284     p_filter->p_sys->i_ballSize =
 285             var_CreateGetIntegerCommand( p_filter, FILTER_PREFIX "ball-size" );
 286     p_filter->p_sys->i_ballSpeed =
 287             var_CreateGetIntegerCommand( p_filter, FILTER_PREFIX "ball-speed" );
 288     p_filter->p_sys->b_edgeVisible =
 289             var_CreateGetBoolCommand( p_filter, FILTER_PREFIX "edge-visible" );
 290     p_filter->p_sys->i_gradThresh =
 291             var_CreateGetIntegerCommand( p_filter, FILTER_PREFIX "gradient-threshold" );
 292
 293     vlc_mutex_init( &p_filter->p_sys->lock );
 294
 295     var_AddCallback( p_filter, FILTER_PREFIX "ball-color",
 296                      ballCallback, p_filter->p_sys );
 297     var_AddCallback( p_filter, FILTER_PREFIX "ball-size",
 298                      ballCallback, p_filter->p_sys );
 299     var_AddCallback( p_filter, FILTER_PREFIX "ball-speed",
 300                      ballCallback, p_filter->p_sys );
 301     var_AddCallback( p_filter, FILTER_PREFIX "edge-visible",
 302                      ballCallback, p_filter->p_sys );
 303
 304     p_filter->p_sys->p_smooth = NULL;
 305     p_filter->p_sys->p_grad_x = NULL;
 306     p_filter->p_sys->p_grad_y = NULL;
 307
 308     p_filter->p_sys->i_ball_x = 100;
 309     p_filter->p_sys->i_ball_y = 100;
 310
 311     p_filter->p_sys->f_lastVect_x = 0;
 312     p_filter->p_sys->f_lastVect_y = -1;
 313
 314     return VLC_SUCCESS;
 315 }
 316
 317
 318 /*****************************************************************************
 319 * Destroy: destroy Distort video thread output method
 320 *****************************************************************************
 321 * Terminate an output method created by DistortCreateOutputMethod
 322  *****************************************************************************/
 323 static void Destroy( vlc_object_t *p_this )
 324 {
 325     filter_t *p_filter = (filter_t *)p_this;
 326     filter_sys_t *p_sys = p_filter->p_sys;
 327
 328     vlc_mutex_destroy( &p_sys->lock );
 329
 330     image_HandlerDelete( p_sys->p_image );
 331
 332     free( p_sys->p_smooth );
 333     free( p_sys->p_grad_x );
 334     free( p_sys->p_grad_y );
 335
 336     free( p_sys );
 337 }
 338
 339
 340 /*****************************************************************************
 341 * Render: displays previously rendered output
 342 *****************************************************************************
 343 * This function send the currently rendered image to Distort image, waits
 344 * until it is displayed and switch the two rendering buffers, preparing next
 345 * frame.
 346  *****************************************************************************/
 347 static picture_t *Filter( filter_t *p_filter, picture_t *p_pic )
 348 {
 349     picture_t *p_outpic;
 350
 351     if( !p_pic ) return NULL;
 352
 353     p_outpic = filter_NewPicture( p_filter );
 354     if( !p_outpic )
 355     {
 356         picture_Release( p_pic );
 357         return NULL;
 358     }
 359
 360     vlc_mutex_lock( &p_filter->p_sys->lock );
 361     FilterBall( p_filter, p_pic, p_outpic );
 362     vlc_mutex_unlock( &p_filter->p_sys->lock );
 363
 364     return CopyInfoAndRelease( p_outpic, p_pic );
 365 }
 366
 367
 368 /*****************************************************************************
 369 * Drawing functions
 370 *****************************************************************************/
 371
 372 static void drawBall( filter_sys_t *p_sys, picture_t *p_outpic )
 373 {
 374     int x = p_sys->i_ball_x;
 375     int y = p_sys->i_ball_y;
 376     int size = p_sys->i_ballSize;
 377
 378     const int i_width = p_outpic->p[0].i_visible_pitch;
 379     const int i_height = p_outpic->p[0].i_visible_lines;
 380
 381     for( int j = y - size; j <= y + size; j++ )
 382     {
 383         bool b_skip = ( x - size ) % 2;
 384         for( int i = x - size; i <= x + size; i++ )
 385         {
 386             /* Draw the pixel if it is inside the disk
 387                and check we don't write out the frame. */
 388             if( ( i - x ) * ( i - x ) + ( j - y ) * ( j - y ) <= size * size
 389                 && i >= 0 && i < i_width
 390                 && j >= 0 && j < i_height )
 391             {
 392                 ( *p_sys->drawingPixelFunction )( p_sys, p_outpic,
 393                                     colorList[ p_sys->ballColor ].comp1,
 394                                     colorList[ p_sys->ballColor ].comp2,
 395                                     colorList[ p_sys->ballColor ].comp3,
 396                                     i, j, b_skip );
 397             }
 398             b_skip = !b_skip;
 399         }
 400     }
 401 }
 402
 403
 404 static void drawPixelRGB24( filter_sys_t *p_sys, picture_t *p_outpic,
 405                             uint8_t R, uint8_t G, uint8_t B,
 406                             int x, int y, bool b_skip )
 407 {
 408     VLC_UNUSED( p_sys );
 409     VLC_UNUSED( b_skip );
 410     uint8_t *p_pixel = p_outpic->p[0].p_pixels
 411                        + p_outpic->p[0].i_pitch
 412                        * x + 3 * y;
 413     *p_pixel = B;
 414     *++p_pixel = G;
 415     *++p_pixel = R;
 416 }
 417
 418
 419 static void drawPixelI420( filter_sys_t *p_sys, picture_t *p_outpic,
 420                            uint8_t Y, uint8_t U, uint8_t V,
 421                            int x, int y, bool b_skip )
 422 {
 423     VLC_UNUSED( p_sys );
 424     *( p_outpic->p[0].p_pixels + p_outpic->p[0].i_pitch * y + x ) = Y;
 425     if( !b_skip )
 426     {
 427         *( p_outpic->p[2].p_pixels + p_outpic->p[2].i_pitch
 428                                      * ( y / 2 ) + x / 2 ) = U;
 429         *( p_outpic->p[1].p_pixels + p_outpic->p[1].i_pitch
 430                                      * ( y / 2 ) + x / 2 ) = V;
 431     }
 432 }
 433
 434
 435 static void drawPixelPacked( filter_sys_t *p_sys, picture_t *p_outpic,
 436                            uint8_t Y, uint8_t U, uint8_t V,
 437                            int x, int y, bool b_skip )
 438 {
 439     uint8_t *p_pixel = p_outpic->p[0].p_pixels
 440                        + p_outpic->p[0].i_pitch * y + x * 2;
 441     *( p_pixel + p_sys->i_y_offset ) = Y;
 442     if( !b_skip )
 443     {
 444         *( p_pixel + p_sys->i_u_offset ) = U;
 445         *( p_pixel + p_sys->i_v_offset ) = V;
 446     }
 447 }
 448
 449
 450 /*****************************************************************************
 451 * Nomalize vector
 452 *****************************************************************************
 453 * Modify its value to set its norm to 1 and keep its direction.
 454  *****************************************************************************/
 455 static void NormalizeVector( float *vect_x, float *vect_y )
 456 {
 457     float norm = sqrt( *vect_x * *vect_x + *vect_y * *vect_y );
 458     if( *vect_x != 0 || *vect_y != 0 )
 459     {
 460         *vect_x /= norm;
 461         *vect_y /= norm;
 462     }
 463 }
 464
 465
 466 /*****************************************************************************
 467 * Gaussian Convolution
 468 *****************************************************************************
 469 *    Gaussian convolution ( sigma == 1.4 )
 470 *
 471 *    |  2  4  5  4  2  |   |  2  4  4  4  2 |
 472 *    |  4  9 12  9  4  |   |  4  8 12  8  4 |
 473 *    |  5 12 15 12  5  | ~ |  4 12 16 12  4 |
 474 *    |  4  9 12  9  4  |   |  4  8 12  8  4 |
 475 *    |  2  4  5  4  2  |   |  2  4  4  4  2 |
 476  *****************************************************************************/
 477 static void GaussianConvolution( picture_t *p_inpic, uint32_t *p_smooth )
 478 {
 479     const uint8_t *p_inpix = p_inpic->p[Y_PLANE].p_pixels;
 480     const int i_src_pitch = p_inpic->p[Y_PLANE].i_pitch;
 481     const int i_src_visible = p_inpic->p[Y_PLANE].i_visible_pitch;
 482     const int i_numLines = p_inpic->p[Y_PLANE].i_visible_lines;
 483
 484     int x,y;
 485     for( y = 2; y < i_numLines - 2; y++ )
 486     {
 487         for( x = 2; x < i_src_visible - 2; x++ )
 488         {
 489             p_smooth[y*i_src_visible+x] = (uint32_t)(
 490                     /* 2 rows up */
 491                     ( p_inpix[(y-2)*i_src_pitch+x-2] )
 492                     + ((p_inpix[(y-2)*i_src_pitch+x-1]
 493                     +   p_inpix[(y-2)*i_src_pitch+x]
 494                     +   p_inpix[(y-2)*i_src_pitch+x+1])<<1 )
 495                     + ( p_inpix[(y-2)*i_src_pitch+x+2] )
 496                     /* 1 row up */
 497                     + ((p_inpix[(y-1)*i_src_pitch+x-2]
 498                     + ( p_inpix[(y-1)*i_src_pitch+x-1]<<1 )
 499                     + ( p_inpix[(y-1)*i_src_pitch+x]*3 )
 500                     + ( p_inpix[(y-1)*i_src_pitch+x+1]<<1 )
 501                     +   p_inpix[(y-1)*i_src_pitch+x+2]
 502                     /* */
 503                     +   p_inpix[y*i_src_pitch+x-2]
 504                     + ( p_inpix[y*i_src_pitch+x-1]*3 )
 505                     + ( p_inpix[y*i_src_pitch+x]<<2 )
 506                     + ( p_inpix[y*i_src_pitch+x+1]*3 )
 507                     +   p_inpix[y*i_src_pitch+x+2]
 508                     /* 1 row down */
 509                     +   p_inpix[(y+1)*i_src_pitch+x-2]
 510                     + ( p_inpix[(y+1)*i_src_pitch+x-1]<<1 )
 511                     + ( p_inpix[(y+1)*i_src_pitch+x]*3 )
 512                     + ( p_inpix[(y+1)*i_src_pitch+x+1]<<1 )
 513                     +   p_inpix[(y+1)*i_src_pitch+x+2] )<<1 )
 514                     /* 2 rows down */
 515                     + ( p_inpix[(y+2)*i_src_pitch+x-2] )
 516                     + ((p_inpix[(y+2)*i_src_pitch+x-1]
 517                     +   p_inpix[(y+2)*i_src_pitch+x]
 518                     +   p_inpix[(y+2)*i_src_pitch+x+1])<<1 )
 519                     + ( p_inpix[(y+2)*i_src_pitch+x+2] )
 520                                                     ) >> 6 /* 115 */;
 521         }
 522     }
 523 }
 524
 525
 526 /*****************************************************************************
 527  * FilterBall: Augmented reality ball video filter
 528  *****************************************************************************
 529  * The edge detection part comes from gradient.c video filter module.
 530  * The Canny edge detection algorithm is used :
 531  * http://fourier.eng.hmc.edu/e161/lectures/canny/node1.html
 532  * (well ... the implementation isn't really the canny algorithm ... but some
 533  * ideas are the same)
 534  *****************************************************************************/
 535 static void FilterBall( filter_t *p_filter, picture_t *p_inpic,
 536                            picture_t *p_outpic )
 537 {
 538     int x, y;
 539     filter_sys_t *p_sys = p_filter->p_sys;
 540
 541     uint32_t *p_smooth;
 542     int32_t *p_grad_x;
 543     int32_t *p_grad_y;
 544
 545     picture_t *p_converted;
 546     video_format_t fmt_comp;
 547
 548     switch( p_filter->fmt_in.video.i_chroma )
 549     {
 550         case VLC_CODEC_RGB24:
 551         CASE_PACKED_YUV_422
 552             fmt_comp.i_width = p_filter->fmt_in.video.i_width;
 553             fmt_comp.i_height = p_filter->fmt_in.video.i_height;
 554             fmt_comp.i_chroma = VLC_FOURCC('G','R','E','Y');
 555             fmt_comp.i_visible_width = fmt_comp.i_width;
 556             fmt_comp.i_visible_height = fmt_comp.i_height;
 557
 558             p_converted = image_Convert( p_filter->p_sys->p_image, p_inpic,
 559                                          &(p_filter->fmt_in.video),
 560                                          &fmt_comp );
 561             if( !p_converted )
 562                 return;
 563
 564             break;
 565
 566         default:
 567             p_converted = p_inpic;
 568             break;
 569     }
 570
 571     const int i_numCols = p_converted->p[0].i_visible_pitch;
 572     const int i_numLines = p_converted->p[0].i_visible_lines;
 573
 574     if( !p_filter->p_sys->p_smooth )
 575         p_filter->p_sys->p_smooth =
 576                 (uint32_t *)malloc( i_numLines * i_numCols
 577                                     * sizeof(uint32_t));
 578     p_smooth = p_filter->p_sys->p_smooth;
 579
 580     if( !p_filter->p_sys->p_grad_x )
 581         p_filter->p_sys->p_grad_x =
 582                 (int32_t *)malloc( i_numLines * i_numCols
 583                                    * sizeof(int32_t));
 584     p_grad_x = p_filter->p_sys->p_grad_x;
 585
 586     if( !p_filter->p_sys->p_grad_y )
 587         p_filter->p_sys->p_grad_y =
 588                 (int32_t *)malloc( i_numLines * i_numCols
 589                                    * sizeof(int32_t));
 590     p_grad_y = p_filter->p_sys->p_grad_y;
 591
 592     if( !p_smooth || !p_grad_x || !p_grad_y ) return;
 593
 594     vlc_memcpy( p_outpic->p[0].p_pixels, p_inpic->p[0].p_pixels,
 595                 p_outpic->p[0].i_lines * p_outpic->p[0].i_pitch );
 596     vlc_memcpy( p_outpic->p[1].p_pixels, p_inpic->p[1].p_pixels,
 597                 p_outpic->p[1].i_lines * p_outpic->p[1].i_pitch );
 598     vlc_memcpy( p_outpic->p[2].p_pixels, p_inpic->p[2].p_pixels,
 599                 p_outpic->p[2].i_lines * p_outpic->p[2].i_pitch );
 600
 601     GaussianConvolution( p_converted, p_smooth );
 602
 603     /* Compute the picture Sobel gradient
 604        | -1 0 1 |     |  1  2  1 |
 605        | -2 0 2 | and |  0  0  0 |
 606        | -1 0 1 |     | -1 -2 -1 | */
 607
 608     for( y = 1; y < i_numLines - 1; y++ )
 609     {
 610         for( x = 1; x < i_numCols - 1; x++ )
 611         {
 612
 613             p_grad_x[ y * i_numCols + x ] =
 614                     ( p_smooth[(y-1)*i_numCols+x-1]
 615                     - p_smooth[(y+1)*i_numCols+x-1] )
 616                     + ( ( p_smooth[(y-1)*i_numCols+x]
 617                     - p_smooth[(y+1)*i_numCols+x] ) <<1 )
 618                     + ( p_smooth[(y-1)*i_numCols+x+1]
 619                     - p_smooth[(y+1)*i_numCols+x+1] );
 620             p_grad_y[ y * i_numCols + x ] =
 621                     ( p_smooth[(y-1)*i_numCols+x-1]
 622                     - p_smooth[(y-1)*i_numCols+x+1] )
 623                     + ( ( p_smooth[y*i_numCols+x-1]
 624                     - p_smooth[y*i_numCols+x+1] ) <<1 )
 625                     + ( p_smooth[(y+1)*i_numCols+x-1]
 626                     - p_smooth[(y+1)*i_numCols+x+1] );
 627         }
 628     }
 629
 630     if( p_sys->b_edgeVisible )
 631     {
 632         /* Display the edges. */
 633         for( y = 1; y < i_numLines - 1; y++ )
 634         {
 635             for( x = 1; x < i_numCols - 1; x++ )
 636             {
 637                 if( abs( p_grad_x[ y * i_numCols + x ] )
 638                     + abs( p_grad_y[ y * i_numCols + x ] )
 639                     > p_sys->i_gradThresh )
 640                 {
 641                     ( *p_sys->drawingPixelFunction )( p_sys, p_outpic,
 642                                                       colorList[ WHITE ].comp1,
 643                                                       colorList[ WHITE ].comp2,
 644                                                       colorList[ WHITE ].comp3,
 645                                                       x, y, 0 );
 646                 }
 647             }
 648         }
 649     }
 650
 651     int i_motion;
 652
 653     float *pf_lastVect_x = &p_sys->f_lastVect_x;
 654     float *pf_lastVect_y = &p_sys->f_lastVect_y;
 655
 656     float f_newVect_x = 0;
 657     float f_newVect_y = 0;
 658     float f_contVect_x = 0;
 659     float f_contVect_y = 0;
 660
 661     int nb_collisions = 0;
 662
 663     bool bounce = false;
 664
 665     /* Test collisions for each pixel the ball will cover in its
 666        motion. */
 667     for ( i_motion = 0; i_motion <= p_sys->i_ballSpeed && !bounce; i_motion++ )
 668     {
 669         /* Compute next ball position */
 670         x = roundf( (float)p_sys->i_ball_x
 671                     + *pf_lastVect_x * (float)i_motion );
 672         y = roundf( (float)p_sys->i_ball_y
 673                     + *pf_lastVect_y * (float)i_motion );
 674
 675         for( int i = x - p_sys->i_ballSize; i <= x + p_sys->i_ballSize; i++ )
 676         {
 677             for( int j = y - p_sys->i_ballSize;
 678                  j <= y + p_sys->i_ballSize; j++ )
 679             {
 680                 /* Test the pixel if it is inside the disk and check we don't
 681                 write out the frame. */
 682                 if( ( i - x ) * ( i - x ) + ( j - y ) * ( j - y )
 683                     == p_sys->i_ballSize * p_sys->i_ballSize
 684                     && j <= i_numLines - 1 && x <= i_numCols - 1
 685                     && j >= 0 && i >= 0 )
 686                 {
 687                     /* Test firstly the picture limit collisions. */
 688                     if( i <= 2 )
 689                     {
 690                         f_contVect_x = x - i;
 691                         f_contVect_y = 0;
 692                         x++;
 693                         bounce = true;
 694                         nb_collisions = 1;
 695                         goto endLoop;
 696                     }
 697                     if( j <= 2 )
 698                     {
 699                         f_contVect_x = 0;
 700                         f_contVect_y = y - j;
 701                         y++;
 702                         bounce = true;
 703                         nb_collisions = 1;
 704                         goto endLoop;
 705                     }
 706                     if( j >= i_numLines - 3 )
 707                     {
 708                         f_contVect_x = 0;
 709                         f_contVect_y = y - j;
 710                         y--;
 711                         bounce = true;
 712                         nb_collisions = 1;
 713                         goto endLoop;
 714                     }
 715                     if( i >= i_numCols - 3 )
 716                     {
 717                         f_contVect_x = x - i;
 718                         f_contVect_y = 0;
 719                         x--;
 720                         bounce = true;
 721                         nb_collisions = 1;
 722                         goto endLoop;
 723                     }
 724                     /* Test the collisions with edges. */
 725                     if( abs( p_grad_x[ j * i_numCols + i ] )
 726                         + abs( p_grad_y[ j * i_numCols + i ] )
 727                         > p_sys->i_gradThresh )
 728                     {
 729                         f_contVect_x += x - i;
 730                         f_contVect_y += y - j;
 731                         nb_collisions++;
 732                         bounce = true;
 733                     }
 734                 }
 735             }
 736         }
 737     }
 738
 739     endLoop:
 740
 741     if( bounce )
 742     {
 743         /* Compute normal vector. */
 744         f_contVect_x /= nb_collisions;
 745         f_contVect_y /= nb_collisions;
 746         NormalizeVector( &f_contVect_x, &f_contVect_y );
 747
 748         /* Compute the new vector after the bounce. */
 749         float cosinus = *pf_lastVect_x * f_contVect_x
 750                         + *pf_lastVect_y * f_contVect_y;
 751         f_newVect_x = *pf_lastVect_x - 2 * cosinus * f_contVect_x;
 752         f_newVect_y = *pf_lastVect_y - 2 * cosinus * f_contVect_y;
 753         NormalizeVector( &f_newVect_x, &f_newVect_y );
 754
 755         *pf_lastVect_x = f_newVect_x;
 756         *pf_lastVect_y = f_newVect_y;
 757
 758         p_sys->i_ball_x = x;
 759         p_sys->i_ball_y = y;
 760
 761         /* Test if next pixel is outside the frame limits.
 762            If it is the case, then the ball is blocked until it can move. */
 763         x = roundf( (float)x + *pf_lastVect_x );
 764         y = roundf( (float)y + *pf_lastVect_y );
 765         if( x - p_sys->i_ballSize < 2
 766             || x + p_sys->i_ballSize > i_numCols - 3
 767             || y - p_sys->i_ballSize < 2
 768             || y + p_sys->i_ballSize > i_numLines - 3 )
 769         {
 770             *pf_lastVect_x = 0;
 771             *pf_lastVect_y = 0;
 772         }
 773         else
 774             /* After a bouce, the first ball motion is always one pixel. */
 775             i_motion = p_sys->i_ballSpeed - 1;
 776     }
 777     else
 778         i_motion = 0;
 779
 780     /* Compute next ball position. */
 781     p_sys->i_ball_x = roundf( (float)p_sys->i_ball_x + *pf_lastVect_x
 782                               * (float)( p_sys->i_ballSpeed - i_motion ) );
 783     p_sys->i_ball_y = roundf( p_sys->i_ball_y + *pf_lastVect_y
 784                               * (float)( p_sys->i_ballSpeed - i_motion ) );
 785
 786     /* Draw the ball */
 787     drawBall( p_sys, p_outpic );
 788
 789     switch( p_filter->fmt_in.video.i_chroma )
 790     {
 791         case VLC_CODEC_RGB24:
 792         CASE_PACKED_YUV_422
 793             picture_Release( p_converted );
 794         default:
 795             break;
 796     }
 797 }
 798
 799
 800 /*****************************************************************************
 801  * ballCallback
 802  *****************************************************************************
 803  * filter parameter modification callback
 804  *****************************************************************************/
 805 static int ballCallback( vlc_object_t *p_this, char const *psz_var,
 806                              vlc_value_t oldval, vlc_value_t newval,
 807                              void *p_data )
 808 {
 809     VLC_UNUSED(oldval);
 810     filter_sys_t *p_sys = (filter_sys_t *)p_data;
 811     msg_Err( p_this, "Test" );
 812
 813     vlc_mutex_lock( &p_sys->lock );
 814     if( !strcmp( psz_var, FILTER_PREFIX "ball-color" ) )
 815     {
 816         p_sys->ballColor = getBallColor( p_this, newval.psz_string );
 817     }
 818     else if( !strcmp( psz_var, FILTER_PREFIX "ball-size" ) )
 819     {
 820         p_sys->i_ballSize = newval.i_int;
 821     }
 822     else if( !strcmp( psz_var, FILTER_PREFIX "ball-speed" ) )
 823     {
 824         p_sys->i_ballSpeed = newval.i_int;
 825     }
 826     else if( !strcmp( psz_var, FILTER_PREFIX "edge-visible" ) )
 827     {
 828         p_sys->b_edgeVisible = newval.b_bool;
 829     }
 830     else if( !strcmp( psz_var, FILTER_PREFIX "gradient-threshold" ) )
 831     {
 832         p_sys->i_gradThresh = newval.i_int;
 833     }
 834     vlc_mutex_unlock( &p_sys->lock );
 835
 836     return VLC_SUCCESS;
 837 }
 838
 839
 840 /*****************************************************************************
 841  * ballCallback
 842  *****************************************************************************
 843  * Get and assign the ball color value
 844  *****************************************************************************/
 845 static int getBallColor( vlc_object_t *p_this, char const *psz_newval )
 846 {
 847     int ret;
 848     if( !strcmp( psz_newval, "red" ) )
 849         ret = RED;
 850     else if( !strcmp( psz_newval, "blue" ) )
 851         ret = BLUE;
 852     else if( !strcmp( psz_newval, "green" ) )
 853         ret = GREEN;
 854     else if( !strcmp( psz_newval, "white" ) )
 855         ret = WHITE;
 856     else
 857     {
 858         msg_Err( p_this, "no valid ball color provided (%s)", psz_newval );
 859         ret = RED;
 860     }
 861     return ret;
 862 }