X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=modules%2Fvideo_filter%2Fmotiondetect.c;h=a7062cfac662f7be0f0317b192c847acbc9cfd89;hb=eb07c341123fd85843c56ded82bd1e323fc660cb;hp=ce5244ac77831f72148100a0c46accc10432cf6a;hpb=a90c35233438b461d095a693368c517636526857;p=vlc diff --git a/modules/video_filter/motiondetect.c b/modules/video_filter/motiondetect.c index ce5244ac77..a7062cfac6 100644 --- a/modules/video_filter/motiondetect.c +++ b/modules/video_filter/motiondetect.c @@ -1,7 +1,7 @@ /***************************************************************************** * motiondetec.c : Second version of a motion detection plugin. ***************************************************************************** - * Copyright (C) 2000-2006 the VideoLAN team + * Copyright (C) 2000-2008 the VideoLAN team * $Id$ * * Authors: Antoine Cellerier @@ -24,55 +24,63 @@ /***************************************************************************** * Preamble *****************************************************************************/ -#include /* malloc(), free() */ -#include -#include +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include +#include #include -#include -#include "vlc_filter.h" +#include +#include "filter_picture.h" /***************************************************************************** - * Local prototypes + * Module descriptor *****************************************************************************/ static int Create ( vlc_object_t * ); static void Destroy ( vlc_object_t * ); -static picture_t *Filter( filter_t *, picture_t * ); -static void GaussianConvolution( uint32_t *, uint32_t *, int, int, int ); - -/***************************************************************************** - * Module descriptor - *****************************************************************************/ - #define FILTER_PREFIX "motiondetect-" -vlc_module_begin(); - set_description( _("Motion detect video filter") ); - set_shortname( _( "Motion Detect" )); - set_capability( "video filter2", 0 ); - set_category( CAT_VIDEO ); - set_subcategory( SUBCAT_VIDEO_VFILTER ); +vlc_module_begin () + set_description( N_("Motion detect video filter") ) + set_shortname( N_( "Motion Detect" )) + set_category( CAT_VIDEO ) + set_subcategory( SUBCAT_VIDEO_VFILTER ) + set_capability( "video filter2", 0 ) - add_shortcut( "motion" ); - set_callbacks( Create, Destroy ); -vlc_module_end(); + add_shortcut( "motion" ) + set_callbacks( Create, Destroy ) +vlc_module_end () -#if 0 -static const char *ppsz_filter_options[] = { - NULL -}; -#endif + +/***************************************************************************** + * Local prototypes + *****************************************************************************/ +static picture_t *Filter( filter_t *, picture_t * ); +static picture_t *FilterPacked( filter_t *, picture_t * ); +static void GaussianConvolution( uint32_t *, uint32_t *, int, int, int ); +static int FindShapes( uint32_t *, uint32_t *, int, int, int, + int *, int *, int *, int *, int *); +static void Draw( filter_t *p_filter, uint8_t *p_pix, int i_pix_pitch, int i_pix_size ); +#define NUM_COLORS (5000) struct filter_sys_t { - uint8_t *p_oldpix; - uint8_t *p_oldpix_u; - uint8_t *p_oldpix_v; + bool b_old; + picture_t *p_old; uint32_t *p_buf; uint32_t *p_buf2; - vlc_mutex_t lock; + + /* */ + int i_colors; + int colors[NUM_COLORS]; + int color_x_min[NUM_COLORS]; + int color_x_max[NUM_COLORS]; + int color_y_min[NUM_COLORS]; + int color_y_max[NUM_COLORS]; }; /***************************************************************************** @@ -81,25 +89,43 @@ struct filter_sys_t static int Create( vlc_object_t *p_this ) { filter_t *p_filter = (filter_t *)p_this; + const video_format_t *p_fmt = &p_filter->fmt_in.video; + filter_sys_t *p_sys; - /* Allocate structure */ - p_filter->p_sys = malloc( sizeof( filter_sys_t ) ); - if( p_filter->p_sys == NULL ) + switch( p_fmt->i_chroma ) { - msg_Err( p_filter, "out of memory" ); - return VLC_ENOMEM; + CASE_PLANAR_YUV + p_filter->pf_video_filter = Filter; + break; + + CASE_PACKED_YUV_422 + p_filter->pf_video_filter = FilterPacked; + break; + + default: + msg_Err( p_filter, "Unsupported input chroma (%4.4s)", + (char*)&(p_fmt->i_chroma) ); + return VLC_EGENERIC; } - p_filter->pf_video_filter = Filter; + /* Allocate structure */ + p_filter->p_sys = p_sys = malloc( sizeof( filter_sys_t ) ); + if( p_filter->p_sys == NULL ) + return VLC_ENOMEM; - p_filter->p_sys->p_oldpix = NULL; - p_filter->p_sys->p_buf = NULL; + p_sys->b_old = false; + p_sys->p_old = picture_NewFromFormat( p_fmt ); + p_sys->p_buf = calloc( p_fmt->i_width * p_fmt->i_height, sizeof(*p_sys->p_buf) ); + p_sys->p_buf2 = calloc( p_fmt->i_width * p_fmt->i_height, sizeof(*p_sys->p_buf) ); -#if 0 - config_ChainParse( p_filter, FILTER_PREFIX, ppsz_filter_options, - p_filter->p_cfg ); -#endif - vlc_mutex_init( p_filter, &p_filter->p_sys->lock ); + if( !p_sys->p_old || !p_sys->p_buf || !p_sys->p_buf2 ) + { + free( p_sys->p_buf2 ); + free( p_sys->p_buf ); + if( p_sys->p_old ) + picture_Release( p_sys->p_old ); + return VLC_ENOMEM; + } return VLC_SUCCESS; } @@ -110,359 +136,224 @@ static int Create( vlc_object_t *p_this ) static void Destroy( vlc_object_t *p_this ) { filter_t *p_filter = (filter_t *)p_this; + filter_sys_t *p_sys = p_filter->p_sys; - free( p_filter->p_sys->p_oldpix ); - free( p_filter->p_sys->p_buf ); - - vlc_mutex_destroy( &p_filter->p_sys->lock ); - - free( p_filter->p_sys ); + free( p_sys->p_buf2 ); + free( p_sys->p_buf ); + picture_Release( p_sys->p_old ); + free( p_sys ); } + /***************************************************************************** - * Render + * Filter YUV Planar *****************************************************************************/ static picture_t *Filter( filter_t *p_filter, picture_t *p_inpic ) { - picture_t *p_outpic; filter_sys_t *p_sys = p_filter->p_sys; + const video_format_t *p_fmt = &p_filter->fmt_in.video; - const uint8_t *p_inpix = p_inpic->p[Y_PLANE].p_pixels; - const int i_src_pitch = p_inpic->p[Y_PLANE].i_pitch; - const int i_src_visible = p_inpic->p[Y_PLANE].i_visible_pitch; - const int i_num_lines = p_inpic->p[Y_PLANE].i_visible_lines; - - const uint8_t *p_inpix_u = p_inpic->p[U_PLANE].p_pixels; - const uint8_t *p_inpix_v = p_inpic->p[V_PLANE].p_pixels; - const int i_src_pitch_u = p_inpic->p[U_PLANE].i_pitch; - const int i_num_lines_u = p_inpic->p[U_PLANE].i_visible_lines; - - uint8_t *p_oldpix; - uint8_t *p_oldpix_u; - uint8_t *p_oldpix_v; - uint8_t *p_outpix; - uint32_t *p_buf; - uint32_t *p_buf2; + picture_t *p_outpic; + + uint8_t *p_oldpix = p_sys->p_old->p[Y_PLANE].p_pixels; + const int i_old_pitch = p_sys->p_old->p[Y_PLANE].i_pitch; + uint32_t *p_buf = p_sys->p_buf; + uint32_t *p_buf2= p_sys->p_buf2; - int i,j; - int last; + unsigned x, y; - if( !p_inpic ) return NULL; + if( !p_inpic ) + return NULL; + + const uint8_t *p_inpix = p_inpic->p[Y_PLANE].p_pixels; + const int i_src_pitch = p_inpic->p[Y_PLANE].i_pitch; - p_outpic = p_filter->pf_vout_buffer_new( p_filter ); + p_outpic = filter_NewPicture( p_filter ); if( !p_outpic ) { - msg_Warn( p_filter, "can't get output picture" ); - if( p_inpic->pf_release ) - p_inpic->pf_release( p_inpic ); + picture_Release( p_inpic ); return NULL; } + picture_Copy( p_outpic, p_inpic ); - p_outpix = p_outpic->p[Y_PLANE].p_pixels; - p_filter->p_libvlc->pf_memcpy( p_outpic->p[U_PLANE].p_pixels, - p_inpic->p[U_PLANE].p_pixels, - p_inpic->p[U_PLANE].i_pitch * p_inpic->p[U_PLANE].i_visible_lines ); - p_filter->p_libvlc->pf_memcpy( p_outpic->p[V_PLANE].p_pixels, - p_inpic->p[V_PLANE].p_pixels, - p_inpic->p[V_PLANE].i_pitch * p_inpic->p[V_PLANE].i_visible_lines ); - - if( !p_sys->p_oldpix || !p_sys->p_buf ) + if( !p_sys->b_old ) { - free( p_sys->p_oldpix ); - free( p_sys->p_buf ); - p_sys->p_oldpix = malloc( i_src_pitch * i_num_lines ); - p_sys->p_oldpix_u = malloc( i_src_pitch_u * i_num_lines_u ); - p_sys->p_oldpix_v = malloc( i_src_pitch_u * i_num_lines_u ); - p_sys->p_buf = malloc( sizeof( uint32_t ) * i_src_pitch * i_num_lines ); - p_sys->p_buf2 = malloc( sizeof( uint32_t ) * i_src_pitch * i_num_lines); - return p_inpic; + picture_Copy( p_sys->p_old, p_inpic ); + picture_Release( p_inpic ); + p_sys->b_old = true; + return p_outpic; } - p_oldpix = p_sys->p_oldpix; - p_oldpix_u = p_sys->p_oldpix_u; - p_oldpix_v = p_sys->p_oldpix_v; - p_buf = p_sys->p_buf; - p_buf2 = p_sys->p_buf2; - - vlc_mutex_lock( &p_filter->p_sys->lock ); /** * Substract Y planes */ - for( i = 0; i < i_src_pitch * i_num_lines; i++ ) + for( y = 0; y < p_fmt->i_height; y++ ) { - if( p_inpix[i] > p_oldpix[i] ) - { - p_buf2[i] = p_inpix[i] - p_oldpix[i]; - } - else - { - p_buf2[i] = p_oldpix[i] - p_inpix[i]; - } + for( x = 0; x < p_fmt->i_width; x++ ) + p_buf2[y*p_fmt->i_width+x] = abs( p_inpix[y*i_src_pitch+x] - p_oldpix[y*i_old_pitch+x] ); } - int line; - int col; - int format; + + int i_chroma_dx; + int i_chroma_dy; switch( p_inpic->format.i_chroma ) { - case VLC_FOURCC('I','4','2','0'): - case VLC_FOURCC('I','Y','U','V'): - case VLC_FOURCC('J','4','2','0'): - case VLC_FOURCC('Y','V','1','2'): - format = 1; + case VLC_CODEC_I420: + case VLC_CODEC_J420: + case VLC_CODEC_YV12: + i_chroma_dx = 2; + i_chroma_dy = 2; break; - case VLC_FOURCC('I','4','2','2'): - case VLC_FOURCC('J','4','2','2'): - format = 2; + case VLC_CODEC_I422: + case VLC_CODEC_J422: + i_chroma_dx = 2; + i_chroma_dy = 1; break; default: - format = 0; msg_Warn( p_filter, "Not taking chroma into account" ); + i_chroma_dx = 0; + i_chroma_dy = 0; break; } - format = 0; - if( format ) + + if( i_chroma_dx != 0 && i_chroma_dy != 0 ) { - for( line = 0; line < i_num_lines_u; line++ ) + const uint8_t *p_inpix_u = p_inpic->p[U_PLANE].p_pixels; + const uint8_t *p_inpix_v = p_inpic->p[V_PLANE].p_pixels; + const int i_src_pitch_u = p_inpic->p[U_PLANE].i_pitch; + const int i_src_pitch_v = p_inpic->p[V_PLANE].i_pitch; + + const uint8_t *p_oldpix_u = p_sys->p_old->p[U_PLANE].p_pixels; + const uint8_t *p_oldpix_v = p_sys->p_old->p[V_PLANE].p_pixels; + const int i_old_pitch_u = p_sys->p_old->p[U_PLANE].i_pitch; + const int i_old_pitch_v = p_sys->p_old->p[V_PLANE].i_pitch; + + for( y = 0; y < p_fmt->i_height/i_chroma_dy; y++ ) { - for( col = 0; col < i_src_pitch_u; col ++ ) + for( x = 0; x < p_fmt->i_width/i_chroma_dx; x ++ ) { - int diff; - i = line * i_src_pitch_u + col; - if( p_inpix_u[i] > p_oldpix_u[i] ) - { - diff = p_inpix_u[i] - p_oldpix_u[i]; - } - else - { - diff = p_oldpix_u[i] - p_inpix_u[i]; - } - if( p_inpix_v[i] > p_oldpix_v[i] ) - { - diff += p_inpix_v[i] - p_oldpix_v[i]; - } - else - { - diff += p_oldpix_v[i] - p_inpix_v[i]; - } - switch( format ) + const int d = abs( p_inpix_u[y*i_src_pitch_u+x] - p_oldpix_u[y*i_old_pitch_u+x] ) + + abs( p_inpix_v[y*i_src_pitch_v+x] - p_oldpix_v[y*i_old_pitch_v+x] ); + int i, j; + + for( j = 0; j < i_chroma_dy; j++ ) { - case 1: - p_buf2[2*line*i_src_pitch+2*col] += diff; - p_buf2[2*line*i_src_pitch+2*col+1] += diff; - p_buf2[(2*line+1)*i_src_pitch+2*col] += diff; - p_buf2[(2*line+1)*i_src_pitch+2*col+1] += diff; - break; - - case 2: - p_buf2[line*i_src_pitch+2*col] += diff; - p_buf2[line*i_src_pitch+2*col+1] += diff; - break; + for( i = 0; i < i_chroma_dx; i++ ) + p_buf2[i_chroma_dy*p_fmt->i_width*j + i_chroma_dx*i] = d; } } } } /** - * Apply some smoothing to remove noise + * Get the areas where movement was detected */ - GaussianConvolution( p_buf2, p_buf, i_src_pitch, i_num_lines, i_src_visible ); + p_sys->i_colors = FindShapes( p_buf2, p_buf, p_fmt->i_width, p_fmt->i_width, p_fmt->i_height, + p_sys->colors, p_sys->color_x_min, p_sys->color_x_max, p_sys->color_y_min, p_sys->color_y_max ); /** - * Copy luminance plane + * Count final number of shapes + * Draw rectangles (there can be more than 1 moving shape in 1 rectangle) */ - for( i = 0; i < i_src_pitch * i_num_lines; i++ ) - { - p_outpix[i] = p_inpix[i]; - } + Draw( p_filter, p_outpic->p[Y_PLANE].p_pixels, p_outpic->p[Y_PLANE].i_pitch, 1 ); /** - * Label the shapes ans build the labels dependencies list - */ - last = 1; - int colors[5000]; - int color_x_min[5000]; - int color_x_max[5000]; - int color_y_min[5000]; - int color_y_max[5000]; - - for( j = 0; j < i_src_pitch; j++ ) + * We're done. Lets keep a copy of the picture + * TODO we may just picture_Release with a latency of 1 if the filters/vout + * handle it correctly */ + picture_Copy( p_sys->p_old, p_inpic ); + + picture_Release( p_inpic ); + return p_outpic; +} + +/***************************************************************************** + * Filter YUV Packed + *****************************************************************************/ +static picture_t *FilterPacked( filter_t *p_filter, picture_t *p_inpic ) +{ + filter_sys_t *p_sys = p_filter->p_sys; + const video_format_t *p_fmt = &p_filter->fmt_in.video; + picture_t *p_outpic; + + const uint8_t *p_inpix = p_inpic->p[Y_PLANE].p_pixels; + const int i_src_pitch = p_inpic->p[Y_PLANE].i_pitch; + + uint8_t *p_oldpix = p_sys->p_old->p[Y_PLANE].p_pixels; + const int i_old_pitch = p_sys->p_old->p[Y_PLANE].i_pitch; + uint32_t *p_buf = p_sys->p_buf; + uint32_t *p_buf2= p_sys->p_buf2; + + int i_y_offset, i_u_offset, i_v_offset; + + unsigned x, y; + + if( GetPackedYuvOffsets( p_fmt->i_chroma, + &i_y_offset, &i_u_offset, &i_v_offset ) ) { - p_buf[j] = 0; - p_buf[(i_num_lines-1)*i_src_pitch+j] = 0; + msg_Warn( p_filter, "Unsupported input chroma (%4.4s)", + (char*)&p_fmt->i_chroma ); + return p_inpic; } - for( i = 1; i < i_num_lines-1; i++ ) + + if( !p_sys->b_old ) { - p_buf[i*i_src_pitch] = 0; - for( j = 1; j < i_src_pitch-1; j++ ) - { - if( p_buf[i*i_src_pitch+j] > 15 ) - { - if( p_buf[(i-1)*i_src_pitch+j-1] ) - { - p_buf[i*i_src_pitch+j] = p_buf[(i-1)*i_src_pitch+j-1]; - } - else if( p_buf[(i-1)*i_src_pitch+j] ) - p_buf[i*i_src_pitch+j] = p_buf[(i-1)*i_src_pitch+j]; - else if( p_buf[i*i_src_pitch+j-1] ) - p_buf[i*i_src_pitch+j] = p_buf[i*i_src_pitch+j-1]; - else - { - p_buf[i*i_src_pitch+j] = last; - colors[last] = last; - last++; - } - #define CHECK( A ) \ - if( p_buf[A] && p_buf[A] != p_buf[i*i_src_pitch+j] ) \ - { \ - if( p_buf[A] < p_buf[i*i_src_pitch+j] ) \ - colors[p_buf[i*i_src_pitch+j]] = p_buf[A]; \ - else \ - colors[p_buf[A]] = p_buf[i*i_src_pitch+j]; \ - } - CHECK( i*i_src_pitch+j-1 ); - CHECK( (i-1)*i_src_pitch+j-1 ); - CHECK( (i-1)*i_src_pitch+j ); - CHECK( (i-1)*i_src_pitch+j+1 ); - } - else - { - p_buf[i*i_src_pitch+j] = 0; - } - } - p_buf[i*i_src_pitch+j] = 0; + picture_Copy( p_sys->p_old, p_inpic ); + p_sys->b_old = true; + return p_inpic; } - /** - * Initialise empty rectangle list - */ - for( i = 1; i < last; i++ ) + p_outpic = filter_NewPicture( p_filter ); + if( !p_outpic ) { - color_x_min[i] = -1; - color_x_max[i] = -1; - color_y_min[i] = -1; - color_y_max[i] = -1; + picture_Release( p_inpic ); + return NULL; } + picture_Copy( p_outpic, p_inpic ); - /** - * Compute rectangle coordinates - */ - for( i = 0; i < i_src_pitch * i_num_lines; i++ ) + /* Substract all planes at once */ + + for( y = 0; y < p_fmt->i_height; y++ ) { - if( p_buf[i] ) + for( x = 0; x < p_fmt->i_width; x+=2 ) { - while( colors[p_buf[i]] != p_buf[i] ) - p_buf[i] = colors[p_buf[i]]; - if( color_x_min[p_buf[i]] == -1 ) - { - color_x_min[p_buf[i]] = - color_x_max[p_buf[i]] = i % i_src_pitch; - color_y_min[p_buf[i]] = - color_y_max[p_buf[i]] = i / i_src_pitch; - } - else - { - int x = i % i_src_pitch, y = i / i_src_pitch; - if( x < color_x_min[p_buf[i]] ) - color_x_min[p_buf[i]] = x; - if( x > color_x_max[p_buf[i]] ) - color_x_max[p_buf[i]] = x; - if( y < color_y_min[p_buf[i]] ) - color_y_min[p_buf[i]] = y; - if( y > color_y_max[p_buf[i]] ) - color_y_max[p_buf[i]] = y; - } + int i; + int d; + + d = abs( p_inpix[y*i_src_pitch+2*x+i_u_offset] - p_oldpix[y*i_old_pitch+2*x+i_u_offset] ) + + abs( p_inpix[y*i_src_pitch+2*x+i_v_offset] - p_oldpix[y*i_old_pitch+2*x+i_v_offset] ); + + for( i = 0; i < 2; i++ ) + p_buf2[y*p_fmt->i_width+x+i] = + abs( p_inpix[y*i_src_pitch+2*(x+i)+i_y_offset] - p_oldpix[y*i_old_pitch+2*(x+i)+i_y_offset] ) + d; } } /** - * Merge overlaping rectangles + * Get the areas where movement was detected */ - for( i = 1; i < last; i++ ) - { - if( colors[i] != i ) continue; - if( color_x_min[i] == -1 ) continue; - for( j = i+1; j < last; j++ ) - { - if( colors[j] != j ) continue; - if( color_x_min[j] == -1 ) continue; -#define max( a, b ) ( a > b ? a : b ) -#define min( a, b ) ( a < b ? a : b ) - if( max( color_x_min[i], color_x_min[j] ) < min( color_x_max[i], color_x_max[j] ) && max( color_y_min[i], color_y_min[j] ) < min( color_y_max[i], color_y_max[j] ) ) - { - color_x_min[i] = min( color_x_min[i], color_x_min[j] ); - color_x_max[i] = max( color_x_max[i], color_x_max[j] ); - color_y_min[i] = min( color_y_min[i], color_y_min[j] ); - color_y_max[i] = max( color_y_max[i], color_y_max[j] ); - color_x_min[j] = -1; - j = 0; - } - } - } + p_sys->i_colors = FindShapes( p_buf2, p_buf, p_fmt->i_width, p_fmt->i_width, p_fmt->i_height, + p_sys->colors, p_sys->color_x_min, p_sys->color_x_max, p_sys->color_y_min, p_sys->color_y_max ); /** * Count final number of shapes * Draw rectangles (there can be more than 1 moving shape in 1 rectangle) */ - j = 0; - for( i = 1; i < last; i++ ) - { - if( colors[i] == i && color_x_min[i] != -1 ) - { - if( ( color_y_max[i] - color_y_min[i] ) * ( color_x_max[i] - color_x_min[i] ) < 16 ) continue; - j++; - int x, y; - y = color_y_min[i]; - for( x = color_x_min[i]; x <= color_x_max[i]; x++ ) - { - p_outpix[y*i_src_pitch+x] = 0xff; - } - y = color_y_max[i]; - for( x = color_x_min[i]; x <= color_x_max[i]; x++ ) - { - p_outpix[y*i_src_pitch+x] = 0xff; - } - x = color_x_min[i]; - for( y = color_y_min[i]; y <= color_y_max[i]; y++ ) - { - p_outpix[y*i_src_pitch+x] = 0xff; - } - x = color_x_max[i]; - for( y = color_y_min[i]; y <= color_y_max[i]; y++ ) - { - p_outpix[y*i_src_pitch+x] = 0xff; - } - } - } - msg_Dbg( p_filter, "Counted %d moving shapes.", j); + Draw( p_filter, &p_outpic->p[Y_PLANE].p_pixels[i_y_offset], p_outpic->p[Y_PLANE].i_pitch, 2 ); /** * We're done. Lets keep a copy of the picture - */ - p_filter->p_libvlc->pf_memcpy( p_oldpix, p_inpix, - i_src_pitch * i_num_lines ); - p_filter->p_libvlc->pf_memcpy( p_oldpix_u, p_inpix_u, - i_src_pitch_u * i_num_lines_u ); - p_filter->p_libvlc->pf_memcpy( p_oldpix_v, p_inpix_v, - i_src_pitch_u * i_num_lines_u ); - - vlc_mutex_unlock( &p_filter->p_sys->lock ); - - /* misc stuff */ - p_outpic->date = p_inpic->date; - p_outpic->b_force = p_inpic->b_force; - p_outpic->i_nb_fields = p_inpic->i_nb_fields; - p_outpic->b_progressive = p_inpic->b_progressive; - p_outpic->b_top_field_first = p_inpic->b_top_field_first; - - if( p_inpic->pf_release ) - p_inpic->pf_release( p_inpic ); + * TODO we may just picture_Release with a latency of 1 if the filters/vout + * handle it correctly */ + picture_Copy( p_sys->p_old, p_inpic ); + picture_Release( p_inpic ); return p_outpic; } + /***************************************************************************** * Gaussian Convolution ***************************************************************************** @@ -478,12 +369,11 @@ static void GaussianConvolution( uint32_t *p_inpix, uint32_t *p_smooth, int i_src_pitch, int i_num_lines, int i_src_visible ) { -/* const uint8_t *p_inpix = p_inpic->p[Y_PLANE].p_pixels; - const int i_src_pitch = p_inpic->p[Y_PLANE].i_pitch; - const int i_src_visible = p_inpic->p[Y_PLANE].i_visible_pitch; - const int i_num_lines = p_inpic->p[Y_PLANE].i_visible_lines;*/ - int x,y; + + /* A bit overkill but ... simpler */ + memset( p_smooth, 0, sizeof(*p_smooth) * i_src_pitch * i_num_lines ); + for( y = 2; y < i_num_lines - 2; y++ ) { for( x = 2; x < i_src_visible - 2; x++ ) @@ -523,3 +413,186 @@ static void GaussianConvolution( uint32_t *p_inpix, uint32_t *p_smooth, } } } + +/***************************************************************************** + * + *****************************************************************************/ +static int FindShapes( uint32_t *p_diff, uint32_t *p_smooth, + int i_pitch, int i_visible, int i_lines, + int *colors, + int *color_x_min, int *color_x_max, + int *color_y_min, int *color_y_max ) +{ + int last = 1; + int i, j; + + /** + * Apply some smoothing to remove noise + */ + GaussianConvolution( p_diff, p_smooth, i_pitch, i_lines, i_visible ); + + /** + * Label the shapes and build the labels dependencies list + */ + for( j = 0; j < i_pitch; j++ ) + { + p_smooth[j] = 0; + p_smooth[(i_lines-1)*i_pitch+j] = 0; + } + for( i = 1; i < i_lines-1; i++ ) + { + p_smooth[i*i_pitch] = 0; + for( j = 1; j < i_pitch-1; j++ ) + { + if( p_smooth[i*i_pitch+j] > 15 ) + { + if( p_smooth[(i-1)*i_pitch+j-1] ) + { + p_smooth[i*i_pitch+j] = p_smooth[(i-1)*i_pitch+j-1]; + } + else if( p_smooth[(i-1)*i_pitch+j] ) + p_smooth[i*i_pitch+j] = p_smooth[(i-1)*i_pitch+j]; + else if( p_smooth[i*i_pitch+j-1] ) + p_smooth[i*i_pitch+j] = p_smooth[i*i_pitch+j-1]; + else + { + if( last < NUM_COLORS ) + { + p_smooth[i*i_pitch+j] = last; + colors[last] = last; + last++; + } + } + #define CHECK( A ) \ + if( p_smooth[A] && p_smooth[A] != p_smooth[i*i_pitch+j] ) \ + { \ + if( p_smooth[A] < p_smooth[i*i_pitch+j] ) \ + colors[p_smooth[i*i_pitch+j]] = p_smooth[A]; \ + else \ + colors[p_smooth[A]] = p_smooth[i*i_pitch+j]; \ + } + CHECK( i*i_pitch+j-1 ); + CHECK( (i-1)*i_pitch+j-1 ); + CHECK( (i-1)*i_pitch+j ); + CHECK( (i-1)*i_pitch+j+1 ); + #undef CHECK + } + else + { + p_smooth[i*i_pitch+j] = 0; + } + } + p_smooth[i*i_pitch+j] = 0; + } + + /** + * Initialise empty rectangle list + */ + for( i = 1; i < last; i++ ) + { + color_x_min[i] = -1; + color_x_max[i] = -1; + color_y_min[i] = -1; + color_y_max[i] = -1; + } + + /** + * Compute rectangle coordinates + */ + for( i = 0; i < i_pitch * i_lines; i++ ) + { + if( p_smooth[i] ) + { + while( colors[p_smooth[i]] != (int)p_smooth[i] ) + p_smooth[i] = colors[p_smooth[i]]; + if( color_x_min[p_smooth[i]] == -1 ) + { + color_x_min[p_smooth[i]] = + color_x_max[p_smooth[i]] = i % i_pitch; + color_y_min[p_smooth[i]] = + color_y_max[p_smooth[i]] = i / i_pitch; + } + else + { + int x = i % i_pitch, y = i / i_pitch; + if( x < color_x_min[p_smooth[i]] ) + color_x_min[p_smooth[i]] = x; + if( x > color_x_max[p_smooth[i]] ) + color_x_max[p_smooth[i]] = x; + if( y < color_y_min[p_smooth[i]] ) + color_y_min[p_smooth[i]] = y; + if( y > color_y_max[p_smooth[i]] ) + color_y_max[p_smooth[i]] = y; + } + } + } + + /** + * Merge overlaping rectangles + */ + for( i = 1; i < last; i++ ) + { + if( colors[i] != i ) continue; + if( color_x_min[i] == -1 ) continue; + for( j = i+1; j < last; j++ ) + { + if( colors[j] != j ) continue; + if( color_x_min[j] == -1 ) continue; + if( __MAX( color_x_min[i], color_x_min[j] ) < __MIN( color_x_max[i], color_x_max[j] ) && + __MAX( color_y_min[i], color_y_min[j] ) < __MIN( color_y_max[i], color_y_max[j] ) ) + { + color_x_min[i] = __MIN( color_x_min[i], color_x_min[j] ); + color_x_max[i] = __MAX( color_x_max[i], color_x_max[j] ); + color_y_min[i] = __MIN( color_y_min[i], color_y_min[j] ); + color_y_max[i] = __MAX( color_y_max[i], color_y_max[j] ); + color_x_min[j] = -1; + j = 0; + } + } + } + + return last; +} + +static void Draw( filter_t *p_filter, uint8_t *p_pix, int i_pix_pitch, int i_pix_size ) +{ + filter_sys_t *p_sys = p_filter->p_sys; + int i, j; + + for( i = 1, j = 0; i < p_sys->i_colors; i++ ) + { + int x, y; + + if( p_sys->colors[i] != i ) + continue; + + const int color_x_min = p_sys->color_x_min[i]; + const int color_x_max = p_sys->color_x_max[i]; + const int color_y_min = p_sys->color_y_min[i]; + const int color_y_max = p_sys->color_y_max[i]; + + if( color_x_min == -1 ) + continue; + if( ( color_y_max - color_y_min ) * ( color_x_max - color_x_min ) < 16 ) + continue; + + j++; + + y = color_y_min; + for( x = color_x_min; x <= color_x_max; x++ ) + p_pix[y*i_pix_pitch+x*i_pix_size] = 0xff; + + y = color_y_max; + for( x = color_x_min; x <= color_x_max; x++ ) + p_pix[y*i_pix_pitch+x*i_pix_size] = 0xff; + + x = color_x_min; + for( y = color_y_min; y <= color_y_max; y++ ) + p_pix[y*i_pix_pitch+x*i_pix_size] = 0xff; + + x = color_x_max; + for( y = color_y_min; y <= color_y_max; y++ ) + p_pix[y*i_pix_pitch+x*i_pix_size] = 0xff; + } + msg_Dbg( p_filter, "Counted %d moving shapes.", j ); +}