?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Qt: fix build
[vlc.git] / modules / video_filter / gradient.c
blob7f9f000337bdcac385f56b51b0e7411308acad9a
1 /*****************************************************************************
2 * gradient.c : Gradient and edge detection video effects plugin for vlc
3 *****************************************************************************
4 * Copyright (C) 2000-2008 VLC authors and VideoLAN
5 * $Id$
6 *
7 * Authors: Samuel Hocevar <sam@zoy.org>
8 * Antoine Cellerier <dionoea -at- videolan -dot- org>
9 *
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU Lesser General Public License as published by
12 * the Free Software Foundation; either version 2.1 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public License
21 * along with this program; if not, write to the Free Software Foundation,
22 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23 *****************************************************************************/
24
25 /*****************************************************************************
26 * Preamble
27 *****************************************************************************/
28
29 #ifdef HAVE_CONFIG_H
30 # include "config.h"
31 #endif
32
33 #include <math.h> /* sin(), cos() */
34
35 #include <vlc_common.h>
36 #include <vlc_plugin.h>
37 #include <vlc_sout.h>
38 #include <vlc_filter.h>
39 #include <vlc_picture.h>
40 #include "filter_picture.h"
41
42 enum { GRADIENT, EDGE, HOUGH };
43
44 /*****************************************************************************
45 * Local prototypes
46 *****************************************************************************/
47 static int Create ( vlc_object_t * );
48 static void Destroy ( vlc_object_t * );
49
50 static picture_t *Filter( filter_t *, picture_t * );
51 static int GradientCallback( vlc_object_t *, char const *,
52 vlc_value_t, vlc_value_t,
53 void * );
54
55 static void FilterGradient( filter_t *, picture_t *, picture_t * );
56 static void FilterEdge ( filter_t *, picture_t *, picture_t * );
57 static void FilterHough ( filter_t *, picture_t *, picture_t * );
58
59 /*****************************************************************************
60 * Module descriptor
61 *****************************************************************************/
62 #define MODE_TEXT N_("Distort mode")
63 #define MODE_LONGTEXT N_("Distort mode, one of \"gradient\", \"edge\" and \"hough\".")
64
65 #define GRADIENT_TEXT N_("Gradient image type")
66 #define GRADIENT_LONGTEXT N_("Gradient image type (0 or 1). 0 will " \
67 "turn the image to white while 1 will keep colors." )
68
69 #define CARTOON_TEXT N_("Apply cartoon effect")
70 #define CARTOON_LONGTEXT N_("Apply cartoon effect. It is only used by " \
71 "\"gradient\" and \"edge\".")
72
73 #define GRADIENT_HELP N_("Apply color gradient or edge detection effects")
74
75 static const char *const mode_list[] = { "gradient", "edge", "hough" };
76 static const char *const mode_list_text[] = { N_("Gradient"), N_("Edge"), N_("Hough") };
77
78 #define FILTER_PREFIX "gradient-"
79
80 vlc_module_begin ()
81 set_description( N_("Gradient video filter") )
82 set_shortname( N_( "Gradient" ))
83 set_help(GRADIENT_HELP)
84 set_capability( "video filter", 0 )
85 set_category( CAT_VIDEO )
86 set_subcategory( SUBCAT_VIDEO_VFILTER )
87
88 add_string( FILTER_PREFIX "mode", "gradient",
89 MODE_TEXT, MODE_LONGTEXT, false )
90 change_string_list( mode_list, mode_list_text )
91
92 add_integer_with_range( FILTER_PREFIX "type", 0, 0, 1,
93 GRADIENT_TEXT, GRADIENT_LONGTEXT, false )
94 add_bool( FILTER_PREFIX "cartoon", true,
95 CARTOON_TEXT, CARTOON_LONGTEXT, false )
96
97 add_shortcut( "gradient" )
98 set_callbacks( Create, Destroy )
99 vlc_module_end ()
100
101 static const char *const ppsz_filter_options[] = {
102 "mode", "type", "cartoon", NULL
103 };
104
105 /*****************************************************************************
106 * filter_sys_t: Distort video output method descriptor
107 *****************************************************************************
108 * This structure is part of the video output thread descriptor.
109 * It describes the Distort specific properties of an output thread.
110 *****************************************************************************/
111 struct filter_sys_t
112 {
113 vlc_mutex_t lock;
114 int i_mode;
115
116 /* For the gradient mode */
117 int i_gradient_type;
118 bool b_cartoon;
119
120 uint32_t *p_buf32;
121 uint32_t *p_buf32_bis;
122 uint8_t *p_buf8;
123
124 /* For hough mode */
125 int *p_pre_hough;
126 };
127
128 /*****************************************************************************
129 * Create: allocates Distort video thread output method
130 *****************************************************************************
131 * This function allocates and initializes a Distort vout method.
132 *****************************************************************************/
133 static int Create( vlc_object_t *p_this )
134 {
135 filter_t *p_filter = (filter_t *)p_this;
136 char *psz_method;
137
138 switch( p_filter->fmt_in.video.i_chroma )
139 {
140 CASE_PLANAR_YUV
141 break;
142
143 default:
144 msg_Err( p_filter, "Unsupported input chroma (%4.4s)",
145 (char*)&(p_filter->fmt_in.video.i_chroma) );
146 return VLC_EGENERIC;
147 }
148
149 /* Allocate structure */
150 p_filter->p_sys = malloc( sizeof( filter_sys_t ) );
151 if( p_filter->p_sys == NULL )
152 return VLC_ENOMEM;
153
154 p_filter->pf_video_filter = Filter;
155
156 p_filter->p_sys->p_pre_hough = NULL;
157
158 config_ChainParse( p_filter, FILTER_PREFIX, ppsz_filter_options,
159 p_filter->p_cfg );
160
161 if( !(psz_method =
162 var_CreateGetNonEmptyStringCommand( p_filter, FILTER_PREFIX "mode" )) )
163 {
164 msg_Err( p_filter, "configuration variable "
165 FILTER_PREFIX "mode empty" );
166 p_filter->p_sys->i_mode = GRADIENT;
167 }
168 else
169 {
170 if( !strcmp( psz_method, "gradient" ) )
171 {
172 p_filter->p_sys->i_mode = GRADIENT;
173 }
174 else if( !strcmp( psz_method, "edge" ) )
175 {
176 p_filter->p_sys->i_mode = EDGE;
177 }
178 else if( !strcmp( psz_method, "hough" ) )
179 {
180 p_filter->p_sys->i_mode = HOUGH;
181 }
182 else
183 {
184 msg_Err( p_filter, "no valid gradient mode provided (%s)", psz_method );
185 p_filter->p_sys->i_mode = GRADIENT;
186 }
187 }
188 free( psz_method );
189
190 p_filter->p_sys->i_gradient_type =
191 var_CreateGetIntegerCommand( p_filter, FILTER_PREFIX "type" );
192 p_filter->p_sys->b_cartoon =
193 var_CreateGetBoolCommand( p_filter, FILTER_PREFIX "cartoon" );
194
195 vlc_mutex_init( &p_filter->p_sys->lock );
196 var_AddCallback( p_filter, FILTER_PREFIX "mode",
197 GradientCallback, p_filter->p_sys );
198 var_AddCallback( p_filter, FILTER_PREFIX "type",
199 GradientCallback, p_filter->p_sys );
200 var_AddCallback( p_filter, FILTER_PREFIX "cartoon",
201 GradientCallback, p_filter->p_sys );
202
203 p_filter->p_sys->p_buf32 = NULL;
204 p_filter->p_sys->p_buf32_bis = NULL;
205 p_filter->p_sys->p_buf8 = NULL;
206
207 return VLC_SUCCESS;
208 }
209
210 /*****************************************************************************
211 * Destroy: destroy Distort video thread output method
212 *****************************************************************************
213 * Terminate an output method created by DistortCreateOutputMethod
214 *****************************************************************************/
215 static void Destroy( vlc_object_t *p_this )
216 {
217 filter_t *p_filter = (filter_t *)p_this;
218 filter_sys_t *p_sys = p_filter->p_sys;
219
220 var_DelCallback( p_filter, FILTER_PREFIX "mode",
221 GradientCallback, p_sys );
222 var_DelCallback( p_filter, FILTER_PREFIX "type",
223 GradientCallback, p_sys );
224 var_DelCallback( p_filter, FILTER_PREFIX "cartoon",
225 GradientCallback, p_sys );
226 vlc_mutex_destroy( &p_sys->lock );
227
228 free( p_sys->p_buf32 );
229 free( p_sys->p_buf32_bis );
230 free( p_sys->p_buf8 );
231 free( p_sys->p_pre_hough );
232
233 free( p_sys );
234 }
235
236 /*****************************************************************************
237 * Render: displays previously rendered output
238 *****************************************************************************
239 * This function send the currently rendered image to Distort image, waits
240 * until it is displayed and switch the two rendering buffers, preparing next
241 * frame.
242 *****************************************************************************/
243 static picture_t *Filter( filter_t *p_filter, picture_t *p_pic )
244 {
245 picture_t *p_outpic;
246
247 if( !p_pic ) return NULL;
248
249 p_outpic = filter_NewPicture( p_filter );
250 if( !p_outpic )
251 {
252 picture_Release( p_pic );
253 return NULL;
254 }
255
256 vlc_mutex_lock( &p_filter->p_sys->lock );
257 switch( p_filter->p_sys->i_mode )
258 {
259 case EDGE:
260 FilterEdge( p_filter, p_pic, p_outpic );
261 break;
262
263 case GRADIENT:
264 FilterGradient( p_filter, p_pic, p_outpic );
265 break;
266
267 case HOUGH:
268 FilterHough( p_filter, p_pic, p_outpic );
269 break;
270
271 default:
272 break;
273 }
274 vlc_mutex_unlock( &p_filter->p_sys->lock );
275
276 return CopyInfoAndRelease( p_outpic, p_pic );
277 }
278
279 /*****************************************************************************
280 * Gaussian Convolution
281 *****************************************************************************
282 * Gaussian convolution ( sigma == 1.4 )
283 *
284 * | 2 4 5 4 2 | | 2 4 4 4 2 |
285 * | 4 9 12 9 4 | | 4 8 12 8 4 |
286 * | 5 12 15 12 5 | ~ | 4 12 16 12 4 |
287 * | 4 9 12 9 4 | | 4 8 12 8 4 |
288 * | 2 4 5 4 2 | | 2 4 4 4 2 |
289 *****************************************************************************/
290 static void GaussianConvolution( picture_t *p_inpic, uint32_t *p_smooth )
291 {
292 const uint8_t *p_inpix = p_inpic->p[Y_PLANE].p_pixels;
293 const int i_src_pitch = p_inpic->p[Y_PLANE].i_pitch;
294 const int i_src_visible = p_inpic->p[Y_PLANE].i_visible_pitch;
295 const int i_num_lines = p_inpic->p[Y_PLANE].i_visible_lines;
296
297 for( int y = 2; y < i_num_lines - 2; y++ )
298 {
299 for( int x = 2; x < i_src_visible - 2; x++ )
300 {
301 p_smooth[y*i_src_visible+x] = (uint32_t)(
302 /* 2 rows up */
303 ( p_inpix[(y-2)*i_src_pitch+x-2] )
304 + ((p_inpix[(y-2)*i_src_pitch+x-1]
305 + p_inpix[(y-2)*i_src_pitch+x]
306 + p_inpix[(y-2)*i_src_pitch+x+1])<<1 )
307 + ( p_inpix[(y-2)*i_src_pitch+x+2] )
308 /* 1 row up */
309 + ((p_inpix[(y-1)*i_src_pitch+x-2]
310 + ( p_inpix[(y-1)*i_src_pitch+x-1]<<1 )
311 + ( p_inpix[(y-1)*i_src_pitch+x]*3 )
312 + ( p_inpix[(y-1)*i_src_pitch+x+1]<<1 )
313 + p_inpix[(y-1)*i_src_pitch+x+2]
314 /* */
315 + p_inpix[y*i_src_pitch+x-2]
316 + ( p_inpix[y*i_src_pitch+x-1]*3 )
317 + ( p_inpix[y*i_src_pitch+x]<<2 )
318 + ( p_inpix[y*i_src_pitch+x+1]*3 )
319 + p_inpix[y*i_src_pitch+x+2]
320 /* 1 row down */
321 + p_inpix[(y+1)*i_src_pitch+x-2]
322 + ( p_inpix[(y+1)*i_src_pitch+x-1]<<1 )
323 + ( p_inpix[(y+1)*i_src_pitch+x]*3 )
324 + ( p_inpix[(y+1)*i_src_pitch+x+1]<<1 )
325 + p_inpix[(y+1)*i_src_pitch+x+2] )<<1 )
326 /* 2 rows down */
327 + ( p_inpix[(y+2)*i_src_pitch+x-2] )
328 + ((p_inpix[(y+2)*i_src_pitch+x-1]
329 + p_inpix[(y+2)*i_src_pitch+x]
330 + p_inpix[(y+2)*i_src_pitch+x+1])<<1 )
331 + ( p_inpix[(y+2)*i_src_pitch+x+2] )
332 ) >> 6 /* 115 */;
333 }
334 }
335 }
336
337 /*****************************************************************************
338 * FilterGradient: Sobel
339 *****************************************************************************/
340 static void FilterGradient( filter_t *p_filter, picture_t *p_inpic,
341 picture_t *p_outpic )
342 {
343 const int i_src_pitch = p_inpic->p[Y_PLANE].i_pitch;
344 const int i_src_visible = p_inpic->p[Y_PLANE].i_visible_pitch;
345 const int i_dst_pitch = p_outpic->p[Y_PLANE].i_pitch;
346 const int i_num_lines = p_inpic->p[Y_PLANE].i_visible_lines;
347
348 const uint8_t *p_inpix = p_inpic->p[Y_PLANE].p_pixels;
349 uint8_t *p_outpix = p_outpic->p[Y_PLANE].p_pixels;
350
351 uint32_t *p_smooth;
352 if( !p_filter->p_sys->p_buf32 )
353 p_filter->p_sys->p_buf32 =
354 vlc_alloc( i_num_lines * i_src_visible, sizeof(uint32_t));
355 p_smooth = p_filter->p_sys->p_buf32;
356
357 if( !p_smooth ) return;
358
359 if( p_filter->p_sys->b_cartoon )
360 {
361 plane_CopyPixels( &p_outpic->p[U_PLANE], &p_inpic->p[U_PLANE] );
362 plane_CopyPixels( &p_outpic->p[V_PLANE], &p_inpic->p[V_PLANE] );
363 }
364 else
365 {
366 memset( p_outpic->p[U_PLANE].p_pixels, 0x80,
367 p_outpic->p[U_PLANE].i_lines * p_outpic->p[U_PLANE].i_pitch );
368 memset( p_outpic->p[V_PLANE].p_pixels, 0x80,
369 p_outpic->p[V_PLANE].i_lines * p_outpic->p[V_PLANE].i_pitch );
370 }
371
372 GaussianConvolution( p_inpic, p_smooth );
373
374 /* Sobel gradient
375
376 | -1 0 1 | | 1 2 1 |
377 | -2 0 2 | and | 0 0 0 |
378 | -1 0 1 | | -1 -2 -1 | */
379
380 #define FOR \
381 for( int y = 1; y < i_num_lines - 1; y++ ) \
382 { \
383 for( int x = 1; x < i_src_visible - 1; x++ ) \
384 { \
385 const uint32_t a = \
386 abs(((int)p_smooth[(y - 1) * i_src_visible + x - 1] \
387 - (int)p_smooth[(y + 1) * i_src_visible + x - 1]) \
388 + (((int)p_smooth[(y - 1) * i_src_visible + x] \
389 - (int)p_smooth[(y + 1) * i_src_visible + x]) * 2) \
390 + ((int)p_smooth[(y - 1) * i_src_visible + x + 1] \
391 - (int)p_smooth[(y + 1) * i_src_visible + x + 1])) \
392 + abs(((int)p_smooth[(y - 1) * i_src_visible + x - 1] \
393 - (int)p_smooth[(y - 1) * i_src_visible + x + 1]) \
394 + (((int)p_smooth[y * i_src_visible + x - 1] \
395 - (int)p_smooth[y * i_src_visible + x + 1]) * 2) \
396 + ((int)p_smooth[(y + 1) * i_src_visible + x - 1] \
397 - (int)p_smooth[(y + 1) * i_src_visible + x + 1]));
398
399 if( p_filter->p_sys->i_gradient_type )
400 {
401 if( p_filter->p_sys->b_cartoon )
402 {
403 FOR
404 if( a > 60 )
405 {
406 p_outpix[y*i_dst_pitch+x] = 0x00;
407 }
408 else
409 {
410 if( p_smooth[y*i_src_visible+x] > 0xa0 )
411 p_outpix[y*i_dst_pitch+x] =
412 0xff - ((0xff - p_inpix[y*i_src_pitch+x] )>>2);
413 else if( p_smooth[y*i_src_visible+x] > 0x70 )
414 p_outpix[y*i_dst_pitch+x] =
415 0xa0 - ((0xa0 - p_inpix[y*i_src_pitch+x] )>>2);
416 else if( p_smooth[y*i_src_visible+x] > 0x28 )
417 p_outpix[y*i_dst_pitch+x] =
418 0x70 - ((0x70 - p_inpix[y*i_src_pitch+x] )>>2);
419 else
420 p_outpix[y*i_dst_pitch+x] =
421 0x28 - ((0x28 - p_inpix[y*i_src_pitch+x] )>>2);
422 }
423 }}
424 }
425 else
426 {
427 FOR
428 p_outpix[y*i_dst_pitch+x] = clip_uint8_vlc( a );
429 }}
430 }
431 }
432 else
433 {
434 FOR
435 if( a>>8 )
436 p_outpix[y*i_dst_pitch+x] = 0;
437 else
438 p_outpix[y*i_dst_pitch+x] = 0xff-(uint8_t)a;
439 }}
440 }
441 #undef FOR
442 }
443
444 /*****************************************************************************
445 * FilterEdge: Canny edge detection algorithm
446 *****************************************************************************
447 * http://fourier.eng.hmc.edu/e161/lectures/canny/node1.html
448 * (well ... my implementation isn't really the canny algorithm ... but some
449 * ideas are the same)
450 *****************************************************************************/
451 /* angle : | */
452 #define THETA_Y 0
453 /* angle : - */
454 #define THETA_X 1
455 /* angle : / */
456 #define THETA_P 2
457 /* angle : \ */
458 #define THETA_M 3
459 static void FilterEdge( filter_t *p_filter, picture_t *p_inpic,
460 picture_t *p_outpic )
461 {
462 const int i_src_pitch = p_inpic->p[Y_PLANE].i_pitch;
463 const int i_src_visible = p_inpic->p[Y_PLANE].i_visible_pitch;
464 const int i_dst_pitch = p_outpic->p[Y_PLANE].i_pitch;
465 const int i_num_lines = p_inpic->p[Y_PLANE].i_visible_lines;
466
467 const uint8_t *p_inpix = p_inpic->p[Y_PLANE].p_pixels;
468 uint8_t *p_outpix = p_outpic->p[Y_PLANE].p_pixels;
469
470 uint32_t *p_smooth;
471 uint32_t *p_grad;
472 uint8_t *p_theta;
473
474 if( !p_filter->p_sys->p_buf32 )
475 p_filter->p_sys->p_buf32 =
476 vlc_alloc( i_num_lines * i_src_visible, sizeof(uint32_t));
477 p_smooth = p_filter->p_sys->p_buf32;
478
479 if( !p_filter->p_sys->p_buf32_bis )
480 p_filter->p_sys->p_buf32_bis =
481 vlc_alloc( i_num_lines * i_src_visible, sizeof(uint32_t));
482 p_grad = p_filter->p_sys->p_buf32_bis;
483
484 if( !p_filter->p_sys->p_buf8 )
485 p_filter->p_sys->p_buf8 =
486 vlc_alloc( i_num_lines * i_src_visible, sizeof(uint8_t));
487 p_theta = p_filter->p_sys->p_buf8;
488
489 if( !p_smooth || !p_grad || !p_theta ) return;
490
491 if( p_filter->p_sys->b_cartoon )
492 {
493 plane_CopyPixels( &p_outpic->p[U_PLANE], &p_inpic->p[U_PLANE] );
494 plane_CopyPixels( &p_outpic->p[V_PLANE], &p_inpic->p[V_PLANE] );
495 }
496 else
497 {
498 memset( p_outpic->p[Y_PLANE].p_pixels, 0xff,
499 p_outpic->p[Y_PLANE].i_lines * p_outpic->p[Y_PLANE].i_pitch );
500 memset( p_outpic->p[U_PLANE].p_pixels, 0x80,
501 p_outpic->p[U_PLANE].i_lines * p_outpic->p[U_PLANE].i_pitch );
502 memset( p_outpic->p[V_PLANE].p_pixels, 0x80,
503 p_outpic->p[V_PLANE].i_lines * p_outpic->p[V_PLANE].i_pitch );
504 }
505
506 GaussianConvolution( p_inpic, p_smooth );
507
508 /* Sobel gradient
509
510 | -1 0 1 | | 1 2 1 |
511 | -2 0 2 | and | 0 0 0 |
512 | -1 0 1 | | -1 -2 -1 | */
513
514 for( int y = 1; y < i_num_lines - 1; y++ )
515 {
516 for( int x = 1; x < i_src_visible - 1; x++ )
517 {
518
519 const int gradx =
520 ( p_smooth[(y-1)*i_src_visible+x-1]
521 - p_smooth[(y+1)*i_src_visible+x-1] )
522 + ( ( p_smooth[(y-1)*i_src_visible+x]
523 - p_smooth[(y+1)*i_src_visible+x] ) <<1 )
524 + ( p_smooth[(y-1)*i_src_visible+x+1]
525 - p_smooth[(y+1)*i_src_visible+x+1] );
526 const int grady =
527 ( p_smooth[(y-1)*i_src_visible+x-1]
528 - p_smooth[(y-1)*i_src_visible+x+1] )
529 + ( ( p_smooth[y*i_src_visible+x-1]
530 - p_smooth[y*i_src_visible+x+1] ) <<1 )
531 + ( p_smooth[(y+1)*i_src_visible+x-1]
532 - p_smooth[(y+1)*i_src_visible+x+1] );
533
534 p_grad[y*i_src_visible+x] = (uint32_t)(abs( gradx ) + abs( grady ));
535
536 /* tan( 22.5 ) = 0,414213562 .. * 128 = 53
537 * tan( 26,565051177 ) = 0.5
538 * tan( 45 + 22.5 ) = 2,414213562 .. * 128 = 309
539 * tan( 63,434948823 ) 2 */
540 if( (grady<<1) > gradx )
541 p_theta[y*i_src_visible+x] = THETA_P;
542 else if( (grady<<1) < -gradx )
543 p_theta[y*i_src_visible+x] = THETA_M;
544 else if( !gradx || abs(grady) > abs(gradx)<<1 )
545 p_theta[y*i_src_visible+x] = THETA_Y;
546 else
547 p_theta[y*i_src_visible+x] = THETA_X;
548 }
549 }
550
551 /* edge computing */
552 for( int y = 1; y < i_num_lines - 1; y++ )
553 {
554 for( int x = 1; x < i_src_visible - 1; x++ )
555 {
556 if( p_grad[y*i_src_visible+x] > 40 )
557 {
558 switch( p_theta[y*i_src_visible+x] )
559 {
560 case THETA_Y:
561 if( p_grad[y*i_src_visible+x] > p_grad[(y-1)*i_src_visible+x]
562 && p_grad[y*i_src_visible+x] > p_grad[(y+1)*i_src_visible+x] )
563 {
564 p_outpix[y*i_dst_pitch+x] = 0;
565 break;
566 } else goto colorize;
567 case THETA_P:
568 if( p_grad[y*i_src_visible+x] > p_grad[(y-1)*i_src_visible+x-1]
569 && p_grad[y*i_src_visible+x] > p_grad[(y+1)*i_src_visible+x+1] )
570 {
571 p_outpix[y*i_dst_pitch+x] = 0;
572 break;
573 } else goto colorize;
574 case THETA_M:
575 if( p_grad[y*i_src_visible+x] > p_grad[(y-1)*i_src_visible+x+1]
576 && p_grad[y*i_src_visible+x] > p_grad[(y+1)*i_src_visible+x-1] )
577 {
578 p_outpix[y*i_dst_pitch+x] = 0;
579 break;
580 } else goto colorize;
581 case THETA_X:
582 if( p_grad[y*i_src_visible+x] > p_grad[y*i_src_visible+x-1]
583 && p_grad[y*i_src_visible+x] > p_grad[y*i_src_visible+x+1] )
584 {
585 p_outpix[y*i_dst_pitch+x] = 0;
586 break;
587 } else goto colorize;
588 }
589 }
590 else
591 {
592 colorize:
593 if( p_filter->p_sys->b_cartoon )
594 {
595 if( p_smooth[y*i_src_visible+x] > 0xa0 )
596 p_outpix[y*i_dst_pitch+x] = (uint8_t)
597 0xff - ((0xff - p_inpix[y*i_src_pitch+x] )>>2);
598 else if( p_smooth[y*i_src_visible+x] > 0x70 )
599 p_outpix[y*i_dst_pitch+x] =(uint8_t)
600 0xa0 - ((0xa0 - p_inpix[y*i_src_pitch+x] )>>2);
601 else if( p_smooth[y*i_src_visible+x] > 0x28 )
602 p_outpix[y*i_dst_pitch+x] =(uint8_t)
603 0x70 - ((0x70 - p_inpix[y*i_src_pitch+x] )>>2);
604 else
605 p_outpix[y*i_dst_pitch+x] =(uint8_t)
606 0x28 - ((0x28 - p_inpix[y*i_src_pitch+x] )>>2);
607 }
608 }
609 }
610 }
611 }
612
613 /*****************************************************************************
614 * FilterHough
615 *****************************************************************************/
616 #define p_pre_hough p_filter->p_sys->p_pre_hough
617 static void FilterHough( filter_t *p_filter, picture_t *p_inpic,
618 picture_t *p_outpic )
619 {
620 int i_src_visible = p_inpic->p[Y_PLANE].i_visible_pitch;
621 int i_dst_pitch = p_outpic->p[Y_PLANE].i_pitch;
622 int i_num_lines = p_inpic->p[Y_PLANE].i_visible_lines;
623
624 uint8_t *p_outpix = p_outpic->p[Y_PLANE].p_pixels;
625
626 int i_diag = sqrt( i_num_lines * i_num_lines +
627 i_src_visible * i_src_visible);
628 int i_max, i_phi_max, i_rho, i_rho_max;
629 int i_nb_steps = 90;
630 double d_step = M_PI / i_nb_steps;
631 double d_sin;
632 double d_cos;
633 uint32_t *p_smooth;
634
635 int *p_hough = vlc_alloc( i_diag * i_nb_steps, sizeof(int) );
636 if( ! p_hough ) return;
637
638 p_smooth = vlc_alloc( i_num_lines * i_src_visible, sizeof(uint32_t));
639 if( !p_smooth )
640 {
641 free( p_hough );
642 return;
643 }
644
645 if( ! p_pre_hough )
646 {
647 msg_Dbg(p_filter, "Starting precalculation");
648 p_pre_hough = vlc_alloc( i_num_lines*i_src_visible*i_nb_steps,sizeof(int));
649 if( ! p_pre_hough )
650 {
651 free( p_smooth );
652 free( p_hough );
653 return;
654 }
655 for( int i = 0; i < i_nb_steps; i++)
656 {
657 d_sin = sin(d_step * i);
658 d_cos = cos(d_step * i);
659 for( int y = 0; y < i_num_lines; y++ )
660 for( int x = 0; x < i_src_visible; x++ )
661 {
662 p_pre_hough[(i*i_num_lines+y)*i_src_visible + x] =
663 ceil(x*d_sin + y*d_cos);
664 }
665 }
666 msg_Dbg(p_filter, "Precalculation done");
667 }
668
669 memset( p_hough, 0, i_diag * i_nb_steps * sizeof(int) );
670
671 plane_CopyPixels( &p_outpic->p[Y_PLANE], &p_inpic->p[Y_PLANE] );
672 plane_CopyPixels( &p_outpic->p[U_PLANE], &p_inpic->p[U_PLANE] );
673 plane_CopyPixels( &p_outpic->p[V_PLANE], &p_inpic->p[V_PLANE] );
674
675 GaussianConvolution( p_inpic, p_smooth );
676
677 /* Sobel gradient
678
679 | -1 0 1 | | 1 2 1 |
680 | -2 0 2 | and | 0 0 0 |
681 | -1 0 1 | | -1 -2 -1 | */
682
683 i_max = 0;
684 i_rho_max = 0;
685 i_phi_max = 0;
686 for( int y = 4; y < i_num_lines - 4; y++ )
687 {
688 for( int x = 4; x < i_src_visible - 4; x++ )
689 {
690 uint32_t a =
691 abs((((int)p_smooth[(y - 1) * i_src_visible + x]
692 - (int)p_smooth[(y + 1) * i_src_visible + x]) * 2)
693 + ((int)p_smooth[(y - 1) * i_src_visible + x - 1]
694 - (int)p_smooth[(y + 1) * i_src_visible + x - 1])
695 + ((int)p_smooth[(y - 1) * i_src_visible + x + 1]
696 - (int)p_smooth[(y + 1) * i_src_visible + x + 1]))
697 + abs((((int)p_smooth[y * i_src_visible + x - 1]
698 - (int)p_smooth[y * i_src_visible + x + 1]) * 2)
699 + ((int)p_smooth[(y - 1) * i_src_visible + x - 1]
700 - (int)p_smooth[(y - 1) * i_src_visible + x + 1])
701 + ((int)p_smooth[(y + 1) * i_src_visible + x - 1]
702 - (int)p_smooth[(y + 1) * i_src_visible + x + 1]));
703 if( a>>8 )
704 {
705 for( int i = 0; i < i_nb_steps; i++ )
706 {
707 i_rho = p_pre_hough[(i*i_num_lines+y)*i_src_visible + x];
708 if( p_hough[i_rho + i_diag/2 + i * i_diag]++ > i_max )
709 {
710 i_max = p_hough[i_rho + i_diag/2 + i * i_diag];
711 i_rho_max = i_rho;
712 i_phi_max = i;
713 }
714 }
715 }
716 }
717 }
718
719 d_sin = sin(i_phi_max*d_step);
720 d_cos = cos(i_phi_max*d_step);
721 if( d_cos != 0 )
722 {
723 for( int x = 0; x < i_src_visible; x++ )
724 {
725 int y = (i_rho_max - x * d_sin) / d_cos;
726 if( y >= 0 && y < i_num_lines )
727 p_outpix[y*i_dst_pitch+x] = 255;
728 }
729 }
730
731 free( p_hough );
732 free( p_smooth );
733 }
734 #undef p_pre_hough
735
736
737 static int GradientCallback( vlc_object_t *p_this, char const *psz_var,
738 vlc_value_t oldval, vlc_value_t newval,
739 void *p_data )
740 {
741 VLC_UNUSED(oldval);
742 filter_sys_t *p_sys = (filter_sys_t *)p_data;
743
744 vlc_mutex_lock( &p_sys->lock );
745 if( !strcmp( psz_var, FILTER_PREFIX "mode" ) )
746 {
747 if( !strcmp( newval.psz_string, "gradient" ) )
748 {
749 p_sys->i_mode = GRADIENT;
750 }
751 else if( !strcmp( newval.psz_string, "edge" ) )
752 {
753 p_sys->i_mode = EDGE;
754 }
755 else if( !strcmp( newval.psz_string, "hough" ) )
756 {
757 p_sys->i_mode = HOUGH;
758 }
759 else
760 {
761 msg_Err( p_this, "no valid gradient mode provided (%s)", newval.psz_string );
762 p_sys->i_mode = GRADIENT;
763 }
764 }
765 else if( !strcmp( psz_var, FILTER_PREFIX "type" ) )
766 {
767 p_sys->i_gradient_type = newval.i_int;
768 }
769 else if( !strcmp( psz_var, FILTER_PREFIX "cartoon" ) )
770 {
771 p_sys->b_cartoon = newval.b_bool;
772 }
773 vlc_mutex_unlock( &p_sys->lock );
774
775 return VLC_SUCCESS;
776 }
VLC Development tree mirror