X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=modules%2Fvideo_filter%2Ferase.c;h=33f507bf2ef86099b7b04d6bfd7d046dc9bd2d3f;hb=8b524cb8b23f4acfb96c6a07b404c73615e5e6c2;hp=955280ccc70bb1c170e14ed1ee53f8e7bfc7b998;hpb=6ec82b018ceee54f37157333ce6bc74dd23b57cb;p=vlc diff --git a/modules/video_filter/erase.c b/modules/video_filter/erase.c index 955280ccc7..33f507bf2e 100644 --- a/modules/video_filter/erase.c +++ b/modules/video_filter/erase.c @@ -24,17 +24,19 @@ /***************************************************************************** * Preamble *****************************************************************************/ -#include /* malloc(), free() */ -#include -#include /* sin(), cos() */ +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif -#include +#include +#include #include #include #include "vlc_image.h" #include "vlc_filter.h" +#include "filter_picture.h" /***************************************************************************** * Local prototypes @@ -61,22 +63,22 @@ static int EraseCallback( vlc_object_t *, char const *, #define CFG_PREFIX "erase-" vlc_module_begin(); - set_description( _("Erase video filter") ); - set_shortname( _( "Erase" )); + set_description( N_("Erase video filter") ); + set_shortname( N_( "Erase" )); set_capability( "video filter2", 0 ); set_category( CAT_VIDEO ); set_subcategory( SUBCAT_VIDEO_VFILTER ); add_file( CFG_PREFIX "mask", NULL, NULL, - MASK_TEXT, MASK_LONGTEXT, VLC_FALSE ); - add_integer( CFG_PREFIX "x", 0, NULL, POSX_TEXT, POSX_LONGTEXT, VLC_FALSE ); - add_integer( CFG_PREFIX "y", 0, NULL, POSY_TEXT, POSY_LONGTEXT, VLC_FALSE ); + MASK_TEXT, MASK_LONGTEXT, false ); + add_integer( CFG_PREFIX "x", 0, NULL, POSX_TEXT, POSX_LONGTEXT, false ); + add_integer( CFG_PREFIX "y", 0, NULL, POSY_TEXT, POSY_LONGTEXT, false ); add_shortcut( "erase" ); set_callbacks( Create, Destroy ); vlc_module_end(); -static const char *ppsz_filter_options[] = { +static const char *const ppsz_filter_options[] = { "mask", "x", "y", NULL }; @@ -95,14 +97,23 @@ static void LoadMask( filter_t *p_filter, const char *psz_filename ) { image_handler_t *p_image; video_format_t fmt_in, fmt_out; + picture_t *p_old_mask = p_filter->p_sys->p_mask; memset( &fmt_in, 0, sizeof( video_format_t ) ); memset( &fmt_out, 0, sizeof( video_format_t ) ); fmt_out.i_chroma = VLC_FOURCC('Y','U','V','A'); - if( p_filter->p_sys->p_mask ) - p_filter->p_sys->p_mask->pf_release( p_filter->p_sys->p_mask ); p_image = image_HandlerCreate( p_filter ); p_filter->p_sys->p_mask = image_ReadUrl( p_image, psz_filename, &fmt_in, &fmt_out ); + if( p_filter->p_sys->p_mask ) + { + if( p_old_mask ) + picture_Release( p_old_mask ); + } + else if( p_old_mask ) + { + p_filter->p_sys->p_mask = p_old_mask; + msg_Err( p_filter, "Error while loading new mask. Keeping old mask." ); + } image_HandlerDelete( p_image ); } @@ -115,13 +126,27 @@ static int Create( vlc_object_t *p_this ) filter_sys_t *p_sys; char *psz_filename; + switch( p_filter->fmt_in.video.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'): + + case VLC_FOURCC('I','4','2','2'): + case VLC_FOURCC('J','4','2','2'): + break; + + default: + msg_Err( p_filter, "Unsupported input chroma (%4s)", + (char*)&(p_filter->fmt_in.video.i_chroma) ); + return VLC_EGENERIC; + } + /* Allocate structure */ p_filter->p_sys = malloc( sizeof( filter_sys_t ) ); if( p_filter->p_sys == NULL ) - { - msg_Err( p_filter, "out of memory" ); return VLC_ENOMEM; - } p_sys = p_filter->p_sys; p_filter->pf_video_filter = Filter; @@ -148,7 +173,7 @@ static int Create( vlc_object_t *p_this ) var_AddCallback( p_filter, CFG_PREFIX "y", EraseCallback, p_sys ); var_AddCallback( p_filter, CFG_PREFIX "mask", EraseCallback, p_sys ); - vlc_mutex_init( p_filter, &p_sys->lock ); + vlc_mutex_init( &p_sys->lock ); return VLC_SUCCESS; } @@ -161,7 +186,7 @@ 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; if( p_sys->p_mask ) - p_sys->p_mask->pf_release( p_sys->p_mask ); + picture_Release( p_sys->p_mask ); vlc_mutex_destroy( &p_sys->lock ); @@ -176,43 +201,18 @@ static picture_t *Filter( filter_t *p_filter, picture_t *p_pic ) picture_t *p_outpic; if( !p_pic ) return NULL; - switch( p_pic->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'): - break; - default: - msg_Warn( p_filter, "Unsupported input chroma (%4s)", - (char*)&(p_pic->format.i_chroma) ); - if( p_pic->pf_release ) - p_pic->pf_release( p_pic ); - return NULL; - } - 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_pic->pf_release ) - p_pic->pf_release( p_pic ); + picture_Release( p_pic ); return NULL; } /* Here */ FilterErase( p_filter, p_pic, p_outpic ); - p_outpic->date = p_pic->date; - p_outpic->b_force = p_pic->b_force; - p_outpic->i_nb_fields = p_pic->i_nb_fields; - p_outpic->b_progressive = p_pic->b_progressive; - p_outpic->b_top_field_first = p_pic->b_top_field_first; - - if( p_pic->pf_release ) - p_pic->pf_release( p_pic ); - - return p_outpic; + return CopyInfoAndRelease( p_outpic, p_pic ); } /***************************************************************************** @@ -232,6 +232,7 @@ static void FilterErase( filter_t *p_filter, picture_t *p_inpic, for( i_plane = 0; i_plane < p_inpic->i_planes; i_plane++ ) { const int i_pitch = p_inpic->p[i_plane].i_pitch; + const int i_2pitch = i_pitch<<1; const int i_visible_pitch = p_inpic->p[i_plane].i_visible_pitch; const int i_lines = p_inpic->p[i_plane].i_lines; const int i_visible_lines = p_inpic->p[i_plane].i_visible_lines; @@ -240,50 +241,79 @@ static void FilterErase( filter_t *p_filter, picture_t *p_inpic, uint8_t *p_outpix = p_outpic->p[i_plane].p_pixels; uint8_t *p_mask = p_sys->p_mask->A_PIXELS; - int i_x = p_sys->i_x, i_y = p_sys->i_y; + int i_x = p_sys->i_x, + i_y = p_sys->i_y; int x, y; int i_height = i_mask_visible_lines; - int i_width = i_mask_visible_pitch; + int i_width = i_mask_visible_pitch; + + const bool b_line_factor = ( i_plane /* U_PLANE or V_PLANE */ && + !( p_inpic->format.i_chroma == VLC_FOURCC('I','4','2','2') + || p_inpic->format.i_chroma == VLC_FOURCC('J','4','2','2') ) ); + if( i_plane ) /* U_PLANE or V_PLANE */ { - i_width /= 2; - i_height /= 2; - i_x /= 2; - i_y /= 2; + i_width >>= 1; + i_x >>= 1; + } + if( b_line_factor ) + { + i_height >>= 1; + i_y >>= 1; } i_height = __MIN( i_visible_lines - i_y, i_height ); i_width = __MIN( i_visible_pitch - i_x, i_width ); - p_filter->p_libvlc->pf_memcpy( p_outpix, p_inpix, i_pitch * i_lines ); + /* Copy original pixel buffer */ + vlc_memcpy( p_outpix, p_inpix, i_pitch * i_lines ); - for( y = 0; y < i_height; y++, p_mask += i_mask_pitch ) + /* Horizontal linear interpolation of masked areas */ + p_outpix = p_outpic->p[i_plane].p_pixels + i_y*i_pitch + i_x; + for( y = 0; y < i_height; + y++, p_mask += i_mask_pitch, p_outpix += i_pitch ) { uint8_t prev, next = 0; int prev_x = -1, next_x = -2; - p_outpix = p_outpic->p[i_plane].p_pixels + (i_y+y)*i_pitch + i_x; + int quot = 0; + + /* Find a suitable value for the previous color to use when + * interpoling a masked pixel's value */ if( i_x ) { + /* There are pixels before current position on the same line. + * Use those */ prev = *(p_outpix-1); } else if( y || i_y ) { + /* This is the first pixel on a line but there other lines + * above us. Use the pixel right above */ prev = *(p_outpix-i_pitch); } else { + /* We're in the upper left corner. This sucks. We can't use + * any previous value, so we'll use a dummy one. In most + * cases this dummy value will be fixed later on in the + * algorithm */ prev = 0xff; } + for( x = 0; x < i_width; x++ ) { - if( p_mask[i_plane?2*x:x] > 127 ) + if( p_mask[i_plane?x<<1:x] > 127 ) { + /* This is a masked pixel */ if( next_x <= prev_x ) { int x0; + /* Look for the next non masked pixel on the same + * line (inside the mask's bounding box) */ for( x0 = x; x0 < i_width; x0++ ) { - if( p_mask[i_plane?2*x0:x0] <= 127 ) + if( p_mask[i_plane?x0<<1:x0] <= 127 ) { + /* We found an unmasked pixel. Victory! */ next_x = x0; next = p_outpix[x0]; break; @@ -291,26 +321,45 @@ static void FilterErase( filter_t *p_filter, picture_t *p_inpic, } if( next_x <= prev_x ) { + /* We didn't find an unmasked pixel yet. Try + * harder */ if( x0 == x ) x0++; - if( x0 >= i_visible_pitch ) + if( x0 < i_visible_pitch ) { + /* If we didn't find a non masked pixel on the + * same line inside the mask's bounding box, + * use the next pixel on the line (except if + * it doesn't exist) */ next_x = x0; - next = prev; + next = p_outpix[x0]; } else { + /* The last pixel on the line is masked, + * so we'll use the "prev" value. A better + * approach would be to use unmasked pixels + * at the end of adjacent lines */ next_x = x0; - next = p_outpix[x0]; + next = prev; } } if( !( i_x || y || i_y ) ) + /* We were unable to find a suitable value for + * the previous color (which means that we are + * on the first line in the upper left corner) + */ prev = next; + + /* Divide only once instead of next_x-prev_x-1 times */ + quot = ((next-prev)<<16)/(next_x-prev_x); } - /* interpolate new value */ - p_outpix[x] = prev;// + (x-prev_x)*(next-prev)/(next_x-prev_x); + /* Interpolate new value, and round correctly */ + p_outpix[x] = prev + (((x-prev_x)*quot+(1<<16))>>16); } else { + /* This pixel isn't masked. It's thus suitable as a + * previous color for the next interpolation */ prev = p_outpix[x]; prev_x = x; } @@ -319,32 +368,38 @@ static void FilterErase( filter_t *p_filter, picture_t *p_inpic, /* Vertical bluring */ p_mask = p_sys->p_mask->A_PIXELS; - i_height = i_mask_visible_lines / (i_plane?2:1); + i_height = b_line_factor ? i_mask_visible_lines>>1 + : i_mask_visible_lines; + /* Make sure that we stop at least 2 lines before the picture's end + * (since our bluring algorithm uses the 2 next lines) */ i_height = __MIN( i_visible_lines - i_y - 2, i_height ); - for( y = __MAX(i_y-2,0); y < i_height; - y++, p_mask += i_mask_pitch ) + /* Make sure that we start at least 2 lines from the top (since our + * bluring algorithm uses the 2 previous lines) */ + y = __MAX(i_y,2); + p_outpix = p_outpic->p[i_plane].p_pixels + (i_y+y)*i_pitch + i_x; + for( ; y < i_height; y++, p_mask += i_mask_pitch, p_outpix += i_pitch ) { - p_outpix = p_outpic->p[i_plane].p_pixels + (i_y+y)*i_pitch + i_x; for( x = 0; x < i_width; x++ ) { - if( p_mask[i_plane?2*x:x] > 127 ) + if( p_mask[i_plane?x<<1:x] > 127 ) { + /* Ugly bluring function */ p_outpix[x] = - ( (p_outpix[x-2*i_pitch]<<1) /* 2 */ - + (p_outpix[x-i_pitch]<<2) /* 4 */ - + (p_outpix[x]<<2) /* 4 */ - + (p_outpix[x+i_pitch]<<2) /* 4 */ - + (p_outpix[x+2*i_pitch]<<1) )>>4; /* 2 */ + ( (p_outpix[x-i_2pitch]<<1) /* 2 */ + + (p_outpix[x-i_pitch ]<<2) /* 4 */ + + (p_outpix[x ]<<2) /* 4 */ + + (p_outpix[x+i_pitch ]<<2) /* 4 */ + + (p_outpix[x+i_2pitch]<<1) )>>4; /* 2 */ } } } - } } static int EraseCallback( vlc_object_t *p_this, char const *psz_var, vlc_value_t oldval, vlc_value_t newval, void *p_data ) { + VLC_UNUSED(oldval); filter_sys_t *p_sys = (filter_sys_t *)p_data; if( !strcmp( psz_var, CFG_PREFIX "x" ) )