Add a bunch of help strings. Feel free to correct them, and add more
[vlc.git] / 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 (%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 }