Skip to content

GitLab

VLC
VLC
Commit 7588d6a1 authored by Antoine Cellerier's avatar Antoine Cellerier
Browse files
Options

Split the distort video filter module into several video filter2 modules.

parent f5141f9f
Hide whitespace changes
Inline Side-by-side
Showing with 779 additions and 508 deletions
configure.ac
View file @ 7588d6a1
......@@ -564,7 +564,7 @@ AM_CONDITIONAL(BUILD_GETOPT, ${need_getopt})
if test "${SYS}" != "mingw32" -a "${SYS}" != "mingwce"; then
AC_TYPE_SIGNAL
AC_CHECK_LIB(m,cos,[
VLC_ADD_LDFLAGS([adjust distort a52tofloat32 dtstofloat32 x264 goom visual],[-lm])
VLC_ADD_LDFLAGS([adjust wave ripple psychedelic gradient a52tofloat32 dtstofloat32 x264 goom visual],[-lm])
])
AC_CHECK_LIB(m,pow,[
VLC_ADD_LDFLAGS([ffmpeg ffmpegaltivec stream_out_transrate i420_rgb faad twolame equalizer param_eq vlc freetype mpc dmo quicktime realaudio galaktos],[-lm])
......@@ -1122,7 +1122,7 @@ dnl
VLC_ADD_PLUGINS([dummy logger memcpy])
VLC_ADD_PLUGINS([mpgv mpga m4v m4a h264 ps pva avi asf mp4 rawdv nsv real aiff mjpeg demuxdump flac])
VLC_ADD_PLUGINS([cvdsub svcdsub spudec subsdec dvbsub mpeg_audio lpcm a52 dts cinepak flacdec])
VLC_ADD_PLUGINS([deinterlace invert adjust transform distort motionblur rv32])
VLC_ADD_PLUGINS([deinterlace invert adjust transform wave ripple psychedelic gradient motionblur rv32])
VLC_ADD_PLUGINS([fixed32tos16 s16tofixed32 u8tofixed32])
VLC_ADD_PLUGINS([trivial_resampler ugly_resampler])
VLC_ADD_PLUGINS([trivial_channel_mixer trivial_mixer])
......
modules/video_filter/Modules.am
View file @ 7588d6a1
......@@ -2,7 +2,6 @@ SOURCES_mosaic = mosaic.c mosaic.h
SOURCES_transform = transform.c
SOURCES_invert = invert.c
SOURCES_adjust = adjust.c
SOURCES_distort = distort.c
SOURCES_wall = wall.c
SOURCES_clone = clone.c
SOURCES_crop = crop.c
......@@ -18,4 +17,8 @@ SOURCES_motiondetect = motiondetect.c
SOURCES_rv32 = rv32.c
SOURCES_osdmenu = osdmenu.c
SOURCES_magnify = magnify.c
SOURCES_wave = wave.c
SOURCES_ripple = ripple.c
SOURCES_psychedelic = psychedelic.c
SOURCES_gradient = gradient.c
noinst_HEADERS = filter_common.h
modules/video_filter/distort.c → modules/video_filter/gradient.c
View file @ 7588d6a1
/*****************************************************************************
* distort.c : Misc video effects plugin for vlc
* gradient.c : Gradient and edge detection video effects plugin for vlc
*****************************************************************************
* Copyright (C) 2000-2006 the VideoLAN team
* $Id$
......@@ -31,12 +31,12 @@
#include <math.h> /* sin(), cos() */
#include <vlc/vlc.h>
#include <vlc/vout.h>
#include <vlc/sout.h>
#include <vlc/decoder.h>
#include "filter_common.h"
#include "vlc_image.h"
#include "vlc_filter.h"
enum { WAVE, RIPPLE, GRADIENT, EDGE, HOUGH, PSYCHEDELIC };
enum { GRADIENT, EDGE, HOUGH };
/*****************************************************************************
* Local prototypes
......@@ -44,25 +44,17 @@ enum { WAVE, RIPPLE, GRADIENT, EDGE, HOUGH, PSYCHEDELIC };
static int Create ( vlc_object_t * );
static void Destroy ( vlc_object_t * );
static int Init ( vout_thread_t * );
static void End ( vout_thread_t * );
static void Render ( vout_thread_t *, picture_t * );
static picture_t *Filter( filter_t *, picture_t * );
static void DistortWave ( vout_thread_t *, picture_t *, picture_t * );
static void DistortRipple ( vout_thread_t *, picture_t *, picture_t * );
static void DistortGradient( vout_thread_t *, picture_t *, picture_t * );
static void DistortEdge ( vout_thread_t *, picture_t *, picture_t * );
static void DistortHough ( vout_thread_t *, picture_t *, picture_t * );
static void DistortPsychedelic( vout_thread_t *, picture_t *, picture_t * );
static int SendEvents ( vlc_object_t *, char const *,
vlc_value_t, vlc_value_t, void * );
static void FilterGradient( filter_t *, picture_t *, picture_t * );
static void FilterEdge ( filter_t *, picture_t *, picture_t * );
static void FilterHough ( filter_t *, picture_t *, picture_t * );
/*****************************************************************************
* Module descriptor
*****************************************************************************/
#define MODE_TEXT N_("Distort mode")
#define MODE_LONGTEXT N_("Distort mode, one of \"wave\", \"ripple\", \"gradient\", \"edge\", \"hough\" and \"psychedelic\".")
#define MODE_LONGTEXT N_("Distort mode, one of \"gradient\", \"edge\" and \"hough\".")
#define GRADIENT_TEXT N_("Gradient image type")
#define GRADIENT_LONGTEXT N_("Gradient image type (0 or 1). 0 will " \
......@@ -72,68 +64,53 @@ static int SendEvents ( vlc_object_t *, char const *,
#define CARTOON_LONGTEXT N_("Apply cartoon effect. It is only used by " \
"\"gradient\" and \"edge\".")
static char *mode_list[] = { "wave", "ripple", "gradient", "edge", "hough",
"psychedelic" };
static char *mode_list_text[] = { N_("Wave"), N_("Ripple"), N_("Gradient"),
N_("Edge"), N_("Hough"), N_("Psychedelic") };
static char *mode_list[] = { "gradient", "edge", "hough" };
static char *mode_list_text[] = { N_("Gradient"), N_("Edge"), N_("Hough") };
#define FILTER_PREFIX "gradient-"
vlc_module_begin();
set_description( _("Distort video filter") );
set_shortname( N_( "Distortion" ));
set_capability( "video filter", 0 );
set_description( _("Gradient video filter") );
set_shortname( N_( "Gradient" ));
set_capability( "video filter2", 0 );
set_category( CAT_VIDEO );
set_subcategory( SUBCAT_VIDEO_VFILTER );
set_subcategory( SUBCAT_VIDEO_VFILTER2 );
add_string( "distort-mode", "wave", NULL, MODE_TEXT, MODE_LONGTEXT,
VLC_FALSE );
add_string( FILTER_PREFIX "mode", "gradient", NULL,
MODE_TEXT, MODE_LONGTEXT, VLC_FALSE );
change_string_list( mode_list, mode_list_text, 0 );
add_integer_with_range( "distort-gradient-type", 0, 0, 1, NULL,
add_integer_with_range( FILTER_PREFIX "type", 0, 0, 1, NULL,
GRADIENT_TEXT, GRADIENT_LONGTEXT, VLC_FALSE );
add_bool( "distort-cartoon", 1, NULL,
add_bool( FILTER_PREFIX "cartoon", 1, NULL,
CARTOON_TEXT, CARTOON_LONGTEXT, VLC_FALSE );
add_shortcut( "distort" );
add_shortcut( "gradient" );
set_callbacks( Create, Destroy );
vlc_module_end();
static const char *ppsz_filter_options[] = {
"mode", "type", "cartoon", NULL
};
/*****************************************************************************
* vout_sys_t: Distort video output method descriptor
*****************************************************************************
* This structure is part of the video output thread descriptor.
* It describes the Distort specific properties of an output thread.
*****************************************************************************/
struct vout_sys_t
struct filter_sys_t
{
int i_mode;
vout_thread_t *p_vout;
/* For the wave mode */
double f_angle;
mtime_t last_date;
/* For the gradient mode */
int i_gradient_type;
vlc_bool_t b_cartoon;
/* For pyschedelic mode */
image_handler_t *p_image;
unsigned int x, y, scale;
int xinc, yinc, scaleinc;
uint8_t u,v;
/* For hough mode */
int *p_pre_hough;
};
/*****************************************************************************
* Control: control facility for the vout (forwards to child vout)
*****************************************************************************/
static int Control( vout_thread_t *p_vout, int i_query, va_list args )
{
return vout_vaControl( p_vout->p_sys->p_vout, i_query, args );
}
/*****************************************************************************
* Create: allocates Distort video thread output method
*****************************************************************************
......@@ -141,144 +118,67 @@ static int Control( vout_thread_t *p_vout, int i_query, va_list args )
*****************************************************************************/
static int Create( vlc_object_t *p_this )
{
vout_thread_t *p_vout = (vout_thread_t *)p_this;
char *psz_method, *psz_method_tmp;
filter_t *p_filter = (filter_t *)p_this;
char *psz_method;
/* Allocate structure */
p_vout->p_sys = malloc( sizeof( vout_sys_t ) );
if( p_vout->p_sys == NULL )
p_filter->p_sys = malloc( sizeof( filter_sys_t ) );
if( p_filter->p_sys == NULL )
{
msg_Err( p_vout, "out of memory" );
msg_Err( p_filter, "out of memory" );
return VLC_ENOMEM;
}
p_vout->pf_init = Init;
p_vout->pf_end = End;
p_vout->pf_manage = NULL;
p_vout->pf_render = Render;
p_vout->pf_display = NULL;
p_vout->pf_control = Control;
p_filter->pf_video_filter = Filter;
p_filter->p_sys->p_pre_hough = NULL;
sout_CfgParse( p_filter, FILTER_PREFIX, ppsz_filter_options,
p_filter->p_cfg );
p_vout->p_sys->i_mode = 0;
p_vout->p_sys->p_pre_hough = NULL;
var_Create( p_filter, FILTER_PREFIX "mode",
VLC_VAR_STRING | VLC_VAR_DOINHERIT );
var_Create( p_filter, FILTER_PREFIX "type",
VLC_VAR_STRING | VLC_VAR_DOINHERIT );
var_Create( p_filter, FILTER_PREFIX "cartoon",
VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
if( !(psz_method = psz_method_tmp
= config_GetPsz( p_vout, "distort-mode" )) )
if( !(psz_method = var_GetString( p_filter, FILTER_PREFIX "mode" )) )
{
msg_Err( p_vout, "configuration variable %s empty, using 'wave'",
"distort-mode" );
p_vout->p_sys->i_mode = WAVE;
msg_Err( p_filter, "configuration variable "
FILTER_PREFIX "mode empty" );
p_filter->p_sys->i_mode = GRADIENT;
}
else
{
if( !strcmp( psz_method, "wave" ) )
{
p_vout->p_sys->i_mode = WAVE;
}
else if( !strcmp( psz_method, "ripple" ) )
if( !strcmp( psz_method, "gradient" ) )
{
p_vout->p_sys->i_mode = RIPPLE;
}
else if( !strcmp( psz_method, "gradient" ) )
{
p_vout->p_sys->i_mode = GRADIENT;
p_filter->p_sys->i_mode = GRADIENT;
}
else if( !strcmp( psz_method, "edge" ) )
{
p_vout->p_sys->i_mode = EDGE;
p_filter->p_sys->i_mode = EDGE;
}
else if( !strcmp( psz_method, "hough" ) )
{
p_vout->p_sys->i_mode = HOUGH;
}
else if( !strcmp( psz_method, "psychedelic" ) )
{
p_vout->p_sys->i_mode = PSYCHEDELIC;
p_vout->p_sys->x = 10;
p_vout->p_sys->y = 10;
p_vout->p_sys->scale = 1;
p_vout->p_sys->xinc = 1;
p_vout->p_sys->yinc = 1;
p_vout->p_sys->scaleinc = 1;
p_vout->p_sys->u = 0;
p_vout->p_sys->v = 0;
p_filter->p_sys->i_mode = HOUGH;
}
else
{
msg_Err( p_vout, "no valid distort mode provided, using wave" );
p_vout->p_sys->i_mode = WAVE;
msg_Err( p_filter, "no valid gradient mode provided" );
p_filter->p_sys->i_mode = GRADIENT;
}
}
free( psz_method_tmp );
free( psz_method );
p_vout->p_sys->i_gradient_type =
config_GetInt( p_vout, "distort-gradient-type" );
p_vout->p_sys->b_cartoon =
config_GetInt( p_vout, "distort-cartoon" );
p_filter->p_sys->i_gradient_type =
var_GetInteger( p_filter, FILTER_PREFIX "type" );
p_filter->p_sys->b_cartoon =
var_GetInteger( p_filter, FILTER_PREFIX "cartoon" );
return VLC_SUCCESS;
}
/*****************************************************************************
* Init: initialize Distort video thread output method
*****************************************************************************/
static int Init( vout_thread_t *p_vout )
{
int i_index;
picture_t *p_pic;
video_format_t fmt = {0};
I_OUTPUTPICTURES = 0;
/* Initialize the output structure */
p_vout->output.i_chroma = p_vout->render.i_chroma;
p_vout->output.i_width = p_vout->render.i_width;
p_vout->output.i_height = p_vout->render.i_height;
p_vout->output.i_aspect = p_vout->render.i_aspect;
p_vout->fmt_out = p_vout->fmt_in;
fmt = p_vout->fmt_out;
/* Try to open the real video output */
msg_Dbg( p_vout, "spawning the real video output" );
p_vout->p_sys->p_vout = vout_Create( p_vout, &fmt );
/* Everything failed */
if( p_vout->p_sys->p_vout == NULL )
{
msg_Err( p_vout, "cannot open vout, aborting" );
return VLC_EGENERIC;
}
ALLOCATE_DIRECTBUFFERS( VOUT_MAX_PICTURES );
ADD_CALLBACKS( p_vout->p_sys->p_vout, SendEvents );
ADD_PARENT_CALLBACKS( SendEventsToChild );
p_vout->p_sys->f_angle = 0.0;
p_vout->p_sys->last_date = 0;
p_vout->p_sys->p_image = NULL;
return VLC_SUCCESS;
}
/*****************************************************************************
* End: terminate Distort video thread output method
*****************************************************************************/
static void End( vout_thread_t *p_vout )
{
int i_index;
/* Free the fake output buffers we allocated */
for( i_index = I_OUTPUTPICTURES ; i_index ; )
{
i_index--;
free( PP_OUTPUTPICTURE[ i_index ]->p_data_orig );
}
}
/*****************************************************************************
* Destroy: destroy Distort video thread output method
*****************************************************************************
......@@ -286,24 +186,12 @@ static void End( vout_thread_t *p_vout )
*****************************************************************************/
static void Destroy( vlc_object_t *p_this )
{
vout_thread_t *p_vout = (vout_thread_t *)p_this;
filter_t *p_filter = (filter_t *)p_this;
if( p_vout->p_sys->p_vout )
{
DEL_CALLBACKS( p_vout->p_sys->p_vout, SendEvents );
vlc_object_detach( p_vout->p_sys->p_vout );
vout_Destroy( p_vout->p_sys->p_vout );
}
DEL_PARENT_CALLBACKS( SendEventsToChild );
if(p_vout->p_sys->p_pre_hough)
free(p_vout->p_sys->p_pre_hough);
if( p_vout->p_sys->p_image )
image_HandlerDelete( p_vout->p_sys->p_image );
if(p_filter->p_sys->p_pre_hough)
free(p_filter->p_sys->p_pre_hough);
free( p_vout->p_sys );
free( p_filter->p_sys );
}
/*****************************************************************************
......@@ -313,202 +201,50 @@ static void Destroy( vlc_object_t *p_this )
* until it is displayed and switch the two rendering buffers, preparing next
* frame.
*****************************************************************************/
static void Render( vout_thread_t *p_vout, picture_t *p_pic )
static picture_t *Filter( filter_t *p_filter, picture_t *p_pic )
{
picture_t *p_outpic;
/* This is a new frame. Get a structure from the video_output. */
while( ( p_outpic = vout_CreatePicture( p_vout->p_sys->p_vout, 0, 0, 0 ) )
== NULL )
if( !p_pic ) return NULL;
p_outpic = p_filter->pf_vout_buffer_new( p_filter );
if( !p_outpic )
{
if( p_vout->b_die || p_vout->b_error )
{
return;
}
msleep( VOUT_OUTMEM_SLEEP );
msg_Warn( p_filter, "can't get output picture" );
if( p_pic->pf_release )
p_pic->pf_release( p_pic );
return NULL;
}
vout_DatePicture( p_vout->p_sys->p_vout, p_outpic, p_pic->date );
switch( p_vout->p_sys->i_mode )
switch( p_filter->p_sys->i_mode )
{
case WAVE:
DistortWave( p_vout, p_pic, p_outpic );
break;
case RIPPLE:
DistortRipple( p_vout, p_pic, p_outpic );
break;
case EDGE:
DistortEdge( p_vout, p_pic, p_outpic );
FilterEdge( p_filter, p_pic, p_outpic );
break;
case GRADIENT:
DistortGradient( p_vout, p_pic, p_outpic );
FilterGradient( p_filter, p_pic, p_outpic );
break;
case HOUGH:
DistortHough( p_vout, p_pic, p_outpic );
break;
case PSYCHEDELIC:
DistortPsychedelic( p_vout, p_pic, p_outpic );
FilterHough( p_filter, p_pic, p_outpic );
break;
default:
break;
}
vout_DisplayPicture( p_vout->p_sys->p_vout, p_outpic );
}
/*****************************************************************************
* DistortWave: draw a wave effect on the picture
*****************************************************************************/
static void DistortWave( vout_thread_t *p_vout, picture_t *p_inpic,
picture_t *p_outpic )
{
int i_index;
double f_angle;
mtime_t new_date = mdate();
p_vout->p_sys->f_angle += (new_date - p_vout->p_sys->last_date) / 200000.0;
p_vout->p_sys->last_date = new_date;
f_angle = p_vout->p_sys->f_angle;
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;
for( i_index = 0 ; i_index < p_inpic->i_planes ; i_index++ )
{
int i_line, i_num_lines, i_offset;
uint8_t black_pixel;
uint8_t *p_in, *p_out;
p_pic->pf_release( p_pic );
p_in = p_inpic->p[i_index].p_pixels;
p_out = p_outpic->p[i_index].p_pixels;
i_num_lines = p_inpic->p[i_index].i_visible_lines;
black_pixel = ( i_index == Y_PLANE ) ? 0x00 : 0x80;
/* Ok, we do 3 times the sin() calculation for each line. So what ? */
for( i_line = 0 ; i_line < i_num_lines ; i_line++ )
{
/* Calculate today's offset, don't go above 1/20th of the screen */
i_offset = (int)( (double)(p_inpic->p[i_index].i_visible_pitch)
* sin( f_angle + 10.0 * (double)i_line
/ (double)i_num_lines )
/ 20.0 );
if( i_offset )
{
if( i_offset < 0 )
{
p_vout->p_vlc->pf_memcpy( p_out, p_in - i_offset,
p_inpic->p[i_index].i_visible_pitch + i_offset );
p_in += p_inpic->p[i_index].i_pitch;
p_out += p_outpic->p[i_index].i_pitch;
memset( p_out + i_offset, black_pixel, -i_offset );
}
else
{
p_vout->p_vlc->pf_memcpy( p_out + i_offset, p_in,
p_inpic->p[i_index].i_visible_pitch - i_offset );
memset( p_out, black_pixel, i_offset );
p_in += p_inpic->p[i_index].i_pitch;
p_out += p_outpic->p[i_index].i_pitch;
}
}
else
{
p_vout->p_vlc->pf_memcpy( p_out, p_in,
p_inpic->p[i_index].i_visible_pitch );
p_in += p_inpic->p[i_index].i_pitch;
p_out += p_outpic->p[i_index].i_pitch;
}
}
}
return p_outpic;
}
/*****************************************************************************
* DistortRipple: draw a ripple effect at the bottom of the picture
*****************************************************************************/
static void DistortRipple( vout_thread_t *p_vout, picture_t *p_inpic,
picture_t *p_outpic )
{
int i_index;
double f_angle;
mtime_t new_date = mdate();
p_vout->p_sys->f_angle -= (p_vout->p_sys->last_date - new_date) / 100000.0;
p_vout->p_sys->last_date = new_date;
f_angle = p_vout->p_sys->f_angle;
for( i_index = 0 ; i_index < p_inpic->i_planes ; i_index++ )
{
int i_line, i_first_line, i_num_lines, i_offset;
uint8_t black_pixel;
uint8_t *p_in, *p_out;
black_pixel = ( i_index == Y_PLANE ) ? 0x00 : 0x80;
i_num_lines = p_inpic->p[i_index].i_visible_lines;
i_first_line = i_num_lines * 4 / 5;
p_in = p_inpic->p[i_index].p_pixels;
p_out = p_outpic->p[i_index].p_pixels;
for( i_line = 0 ; i_line < i_first_line ; i_line++ )
{
p_vout->p_vlc->pf_memcpy( p_out, p_in,
p_inpic->p[i_index].i_visible_pitch );
p_in += p_inpic->p[i_index].i_pitch;
p_out += p_outpic->p[i_index].i_pitch;
}
/* Ok, we do 3 times the sin() calculation for each line. So what ? */
for( i_line = i_first_line ; i_line < i_num_lines ; i_line++ )
{
/* Calculate today's offset, don't go above 1/20th of the screen */
i_offset = (int)( (double)(p_inpic->p[i_index].i_pitch)
* sin( f_angle + 2.0 * (double)i_line
/ (double)( 1 + i_line
- i_first_line) )
* (double)(i_line - i_first_line)
/ (double)i_num_lines
/ 8.0 );
if( i_offset )
{
if( i_offset < 0 )
{
p_vout->p_vlc->pf_memcpy( p_out, p_in - i_offset,
p_inpic->p[i_index].i_visible_pitch + i_offset );
p_in -= p_inpic->p[i_index].i_pitch;
p_out += p_outpic->p[i_index].i_pitch;
memset( p_out + i_offset, black_pixel, -i_offset );
}
else
{
p_vout->p_vlc->pf_memcpy( p_out + i_offset, p_in,
p_inpic->p[i_index].i_visible_pitch - i_offset );
memset( p_out, black_pixel, i_offset );
p_in -= p_inpic->p[i_index].i_pitch;
p_out += p_outpic->p[i_index].i_pitch;
}
}
else
{
p_vout->p_vlc->pf_memcpy( p_out, p_in,
p_inpic->p[i_index].i_visible_pitch );
p_in -= p_inpic->p[i_index].i_pitch;
p_out += p_outpic->p[i_index].i_pitch;
}
}
}
}
/*****************************************************************************
* Gaussian Convolution
......@@ -570,10 +306,10 @@ static void GaussianConvolution( picture_t *p_inpic, uint32_t *p_smooth )
}
/*****************************************************************************
* DistortGradient: Sobel
* FilterGradient: Sobel
*****************************************************************************/
static void DistortGradient( vout_thread_t *p_vout, picture_t *p_inpic,
picture_t *p_outpic )
static void FilterGradient( filter_t *p_filter, picture_t *p_inpic,
picture_t *p_outpic )
{
int x, y;
int i_src_pitch = p_inpic->p[Y_PLANE].i_pitch;
......@@ -588,20 +324,20 @@ static void DistortGradient( vout_thread_t *p_vout, picture_t *p_inpic,
if( !p_smooth ) return;
if( p_vout->p_sys->b_cartoon )
if( p_filter->p_sys->b_cartoon )
{
p_vout->p_vlc->pf_memcpy( p_outpic->p[U_PLANE].p_pixels,
p_filter->p_vlc->pf_memcpy( p_outpic->p[U_PLANE].p_pixels,
p_inpic->p[U_PLANE].p_pixels,
p_outpic->p[U_PLANE].i_lines * p_outpic->p[U_PLANE].i_pitch );
p_vout->p_vlc->pf_memcpy( p_outpic->p[V_PLANE].p_pixels,
p_filter->p_vlc->pf_memcpy( p_outpic->p[V_PLANE].p_pixels,
p_inpic->p[V_PLANE].p_pixels,