/*****************************************************************************
* Create: allocates video thread output method
*****************************************************************************/
static int Create( vlc_object_t *p_this )
{
filter_t *p_filter = (filter_t *)p_this;
filter_sys_t *p_sys;
char *psz_temp, *psz_cmd;
int i_ret;
/* Allocate structure */
p_filter->p_sys = (filter_sys_t *)malloc( sizeof( filter_sys_t ) ); // sunqueen modify
if( p_filter->p_sys == NULL )
return VLC_ENOMEM;
p_sys = p_filter->p_sys;
p_sys->b_done = false;
p_filter->pf_video_filter = Filter;
/* needed to get options passed in transcode using the
* adjust{name=value} syntax */
config_ChainParse( p_filter, CFG_PREFIX, ppsz_filter_options,
p_filter->p_cfg );
p_sys->i_loops = var_CreateGetIntegerCommand( p_filter,
CFG_PREFIX "loops" );
p_sys->i_alpha = var_CreateGetIntegerCommand( p_filter,
CFG_PREFIX "alpha" );
psz_temp = var_CreateGetStringCommand( p_filter, CFG_PREFIX "base-chroma" );
p_sys->i_base_chroma = VLC_FOURCC( psz_temp[0], psz_temp[1],
psz_temp[2], psz_temp[3] );
psz_cmd = var_CreateGetStringCommand( p_filter, CFG_PREFIX "base-image" );
i_ret = blendbench_LoadImage( p_this, &p_sys->p_base_image,
p_sys->i_base_chroma, psz_cmd, "Base" );
free( psz_temp );
free( psz_cmd );
if( i_ret != VLC_SUCCESS )
{
free( p_sys );
return i_ret;
}
psz_temp = var_CreateGetStringCommand( p_filter,
CFG_PREFIX "blend-chroma" );
p_sys->i_blend_chroma = VLC_FOURCC( psz_temp[0], psz_temp[1],
psz_temp[2], psz_temp[3] );
psz_cmd = var_CreateGetStringCommand( p_filter, CFG_PREFIX "blend-image" );
blendbench_LoadImage( p_this, &p_sys->p_blend_image, p_sys->i_blend_chroma,
psz_cmd, "Blend" );
free( psz_temp );
free( psz_cmd );
return VLC_SUCCESS;
}
/*****************************************************************************
* CreateFilter: allocates marquee video filter
*****************************************************************************/
static int CreateFilter( vlc_object_t *p_this )
{
filter_t *p_filter = (filter_t *)p_this;
filter_sys_t *p_sys;
/* Allocate structure */
p_sys = p_filter->p_sys = malloc( sizeof( filter_sys_t ) );
if( p_sys == NULL )
return VLC_ENOMEM;
p_sys->p_style = text_style_Create( STYLE_NO_DEFAULTS );
if(unlikely(!p_sys->p_style))
{
free(p_sys);
return VLC_ENOMEM;
}
vlc_mutex_init( &p_sys->lock );
config_ChainParse( p_filter, CFG_PREFIX, ppsz_filter_options,
p_filter->p_cfg );
#define CREATE_VAR( stor, type, var ) \
p_sys->stor = var_CreateGet##type##Command( p_filter, var ); \
var_AddCallback( p_filter, var, MarqueeCallback, p_sys );
CREATE_VAR( i_xoff, Integer, "marq-x" );
CREATE_VAR( i_yoff, Integer, "marq-y" );
CREATE_VAR( i_timeout,Integer, "marq-timeout" );
p_sys->i_refresh = 1000 * var_CreateGetIntegerCommand( p_filter,
"marq-refresh" );
var_AddCallback( p_filter, "marq-refresh", MarqueeCallback, p_sys );
CREATE_VAR( i_pos, Integer, "marq-position" );
CREATE_VAR( format, String, "marq-marquee" );
p_sys->filepath = var_InheritString( p_filter, "marq-file" );
p_sys->message = NULL;
p_sys->p_style->i_font_alpha = var_CreateGetIntegerCommand( p_filter,
"marq-opacity" );
var_AddCallback( p_filter, "marq-opacity", MarqueeCallback, p_sys );
p_sys->p_style->i_features |= STYLE_HAS_FONT_ALPHA;
CREATE_VAR( p_style->i_font_color, Integer, "marq-color" );
p_sys->p_style->i_features |= STYLE_HAS_FONT_COLOR;
CREATE_VAR( p_style->i_font_size, Integer, "marq-size" );
/* Misc init */
p_filter->pf_sub_source = Filter;
p_sys->last_time = 0;
return VLC_SUCCESS;
}
/*****************************************************************************
* Create: allocates adjust video thread output method
*****************************************************************************
* This function allocates and initializes a adjust vout method.
*****************************************************************************/
static int Create( vlc_object_t *p_this )
{
filter_t *p_filter = (filter_t *)p_this;
filter_sys_t *p_sys;
switch( p_filter->fmt_in.video.i_chroma )
{
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_filter->fmt_in.video.i_chroma) );
return VLC_EGENERIC;
}
if( p_filter->fmt_in.video.i_chroma != p_filter->fmt_out.video.i_chroma )
{
msg_Err( p_filter, "Input and output chromas don't match" );
return VLC_EGENERIC;
}
/* Allocate structure */
p_sys = p_filter->p_sys = malloc( sizeof( filter_sys_t ) );
if( p_filter->p_sys == NULL )
return VLC_ENOMEM;
config_ChainParse( p_filter, CFG_PREFIX, ppsz_filter_options,
p_filter->p_cfg );
p_sys->i_color = var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "color" );
p_sys->i_simthres = var_CreateGetIntegerCommand( p_filter,
CFG_PREFIX "similaritythres" );
p_sys->i_satthres = var_CreateGetIntegerCommand( p_filter,
CFG_PREFIX "saturationthres" );
vlc_mutex_init( &p_sys->lock );
var_AddCallback( p_filter, CFG_PREFIX "color", FilterCallback, NULL );
var_AddCallback( p_filter, CFG_PREFIX "similaritythres", FilterCallback, NULL );
var_AddCallback( p_filter, CFG_PREFIX "saturationthres", FilterCallback, NULL );
return VLC_SUCCESS;
}
/*****************************************************************************
* Create
*****************************************************************************/
static int Create( vlc_object_t *p_this )
{
filter_t *p_filter = (filter_t *)p_this;
const vlc_chroma_description_t *p_chroma =
vlc_fourcc_GetChromaDescription( p_filter->fmt_in.video.i_chroma );
if( p_chroma == NULL || p_chroma->plane_count == 0 )
return VLC_EGENERIC;
/* Allocate structure */
p_filter->p_sys = malloc( sizeof( filter_sys_t ) );
if( p_filter->p_sys == NULL )
return VLC_ENOMEM;
p_filter->p_sys->p_tmp = picture_NewFromFormat( &p_filter->fmt_in.video );
if( !p_filter->p_sys->p_tmp )
{
free( p_filter->p_sys );
return VLC_ENOMEM;
}
p_filter->p_sys->b_first = true;
p_filter->pf_video_filter = Filter;
config_ChainParse( p_filter, FILTER_PREFIX, ppsz_filter_options,
p_filter->p_cfg );
atomic_init( &p_filter->p_sys->i_factor,
var_CreateGetIntegerCommand( p_filter, FILTER_PREFIX "factor" ) );
var_AddCallback( p_filter, FILTER_PREFIX "factor",
MotionBlurCallback, p_filter->p_sys );
return VLC_SUCCESS;
}
/*****************************************************************************
* Create
*****************************************************************************/
static int Create( vlc_object_t *p_this )
{
filter_t *p_filter = (filter_t *)p_this;
/* Allocate structure */
p_filter->p_sys = malloc( sizeof( filter_sys_t ) );
if( p_filter->p_sys == NULL )
return VLC_ENOMEM;
p_filter->p_sys->p_tmp = picture_NewFromFormat( &p_filter->fmt_in.video );
if( !p_filter->p_sys->p_tmp )
{
free( p_filter->p_sys );
return VLC_ENOMEM;
}
p_filter->p_sys->b_first = true;
p_filter->pf_video_filter = Filter;
config_ChainParse( p_filter, FILTER_PREFIX, ppsz_filter_options,
p_filter->p_cfg );
p_filter->p_sys->i_factor =
var_CreateGetIntegerCommand( p_filter, FILTER_PREFIX "factor" );
vlc_spin_init( &p_filter->p_sys->lock );
var_AddCallback( p_filter, FILTER_PREFIX "factor",
MotionBlurCallback, p_filter->p_sys );
return VLC_SUCCESS;
}
/*****************************************************************************
* Create: allocates adjust video filter
*****************************************************************************/
static int Create( vlc_object_t *p_this )
{
filter_t *p_filter = (filter_t *)p_this;
filter_sys_t *p_sys;
switch( p_filter->fmt_in.video.i_chroma )
{
CASE_PLANAR_YUV
/* Planar YUV */
p_filter->pf_video_filter = FilterPlanar;
break;
CASE_PACKED_YUV_422
/* Packed YUV 4:2:2 */
p_filter->pf_video_filter = FilterPacked;
break;
default:
msg_Err( p_filter, "Unsupported input chroma (%4.4s)",
(char*)&(p_filter->fmt_in.video.i_chroma) );
return VLC_EGENERIC;
}
if( p_filter->fmt_in.video.i_chroma != p_filter->fmt_out.video.i_chroma )
{
msg_Err( p_filter, "Input and output chromas don't match" );
return VLC_EGENERIC;
}
/* Allocate structure */
p_filter->p_sys = malloc( sizeof( filter_sys_t ) );
if( p_filter->p_sys == NULL )
return VLC_ENOMEM;
p_sys = p_filter->p_sys;
/* needed to get options passed in transcode using the
* adjust{name=value} syntax */
config_ChainParse( p_filter, "", ppsz_filter_options,
p_filter->p_cfg );
p_sys->f_contrast = var_CreateGetFloatCommand( p_filter, "contrast" );
p_sys->f_brightness = var_CreateGetFloatCommand( p_filter, "brightness" );
p_sys->i_hue = var_CreateGetIntegerCommand( p_filter, "hue" );
p_sys->f_saturation = var_CreateGetFloatCommand( p_filter, "saturation" );
p_sys->f_gamma = var_CreateGetFloatCommand( p_filter, "gamma" );
p_sys->b_brightness_threshold =
var_CreateGetBoolCommand( p_filter, "brightness-threshold" );
vlc_mutex_init( &p_sys->lock );
var_AddCallback( p_filter, "contrast", AdjustCallback, p_sys );
var_AddCallback( p_filter, "brightness", AdjustCallback, p_sys );
var_AddCallback( p_filter, "hue", AdjustCallback, p_sys );
var_AddCallback( p_filter, "saturation", AdjustCallback, p_sys );
var_AddCallback( p_filter, "gamma", AdjustCallback, p_sys );
var_AddCallback( p_filter, "brightness-threshold",
AdjustCallback, p_sys );
return VLC_SUCCESS;
}
/*****************************************************************************
* CreateFilter: allocates marquee video filter
*****************************************************************************/
static int CreateFilter( vlc_object_t *p_this )
{
filter_t *p_filter = (filter_t *)p_this;
filter_sys_t *p_sys;
/* Allocate structure */
p_sys = p_filter->p_sys = malloc( sizeof( filter_sys_t ) );
if( p_sys == NULL )
return VLC_ENOMEM;
vlc_mutex_init( &p_sys->lock );
p_sys->p_style = text_style_New();
config_ChainParse( p_filter, CFG_PREFIX, ppsz_filter_options,
p_filter->p_cfg );
#define CREATE_VAR( stor, type, var ) \
p_sys->stor = var_CreateGet##type##Command( p_filter, var ); \
var_AddCallback( p_filter, var, MarqueeCallback, p_sys );
p_sys->b_need_update = true;
CREATE_VAR( i_xoff, Integer, "marq-x" );
CREATE_VAR( i_yoff, Integer, "marq-y" );
CREATE_VAR( i_timeout,Integer, "marq-timeout" );
p_sys->i_refresh = 1000 * var_CreateGetIntegerCommand( p_filter,
"marq-refresh" );
var_AddCallback( p_filter, "marq-refresh", MarqueeCallback, p_sys );
CREATE_VAR( i_pos, Integer, "marq-position" );
CREATE_VAR( psz_marquee, String, "marq-marquee" );
p_sys->p_style->i_font_alpha = 255 - var_CreateGetIntegerCommand( p_filter,
"marq-opacity" );
var_AddCallback( p_filter, "marq-opacity", MarqueeCallback, p_sys );
CREATE_VAR( p_style->i_font_color, Integer, "marq-color" );
CREATE_VAR( p_style->i_font_size, Integer, "marq-size" );
/* Misc init */
p_filter->pf_sub_filter = Filter;
p_sys->last_time = 0;
return VLC_SUCCESS;
}
/**
* Open the filter
*/
static int Open( vlc_object_t *p_this )
{
filter_t *p_filter = (filter_t *)p_this;
filter_sys_t *p_sys;
/* */
if( !es_format_IsSimilar( &p_filter->fmt_in, &p_filter->fmt_out ) )
{
msg_Err( p_filter, "Input and output format does not match" );
return VLC_EGENERIC;
}
/* Allocate structure */
p_filter->p_sys = p_sys = malloc( sizeof( *p_sys ) );
if( !p_sys )
return VLC_ENOMEM;
config_ChainParse( p_filter, CFG_PREFIX, ppsz_filter_options,
p_filter->p_cfg );
p_sys->pi_order = NULL;
vlc_mutex_init( &p_sys->lock );
p_sys->change.i_rows =
var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "rows" );
p_sys->change.i_cols =
var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "cols" );
p_sys->change.b_blackslot =
var_CreateGetBoolCommand( p_filter, CFG_PREFIX "black-slot" );
p_sys->b_change = true;
var_AddCallback( p_filter, CFG_PREFIX "rows", PuzzleCallback, p_sys );
var_AddCallback( p_filter, CFG_PREFIX "cols", PuzzleCallback, p_sys );
var_AddCallback( p_filter, CFG_PREFIX "black-slot", PuzzleCallback, p_sys );
p_filter->pf_video_filter = Filter;
p_filter->pf_video_mouse = Mouse;
return VLC_SUCCESS;
}
static int Open(vlc_object_t *object)
{
filter_t *filter = (filter_t *)object;
const vlc_fourcc_t fourcc = filter->fmt_in.video.i_chroma;
const vlc_chroma_description_t *chroma = vlc_fourcc_GetChromaDescription(fourcc);
if (!chroma || chroma->plane_count < 3 || chroma->pixel_size != 1) {
msg_Err(filter, "Unsupported chroma (%4.4s)", (char*)&fourcc);
return VLC_EGENERIC;
}
filter_sys_t *sys = malloc(sizeof(*sys));
if (!sys)
return VLC_ENOMEM;
vlc_mutex_init(&sys->lock);
sys->chroma = chroma;
sys->strength = var_CreateGetFloatCommand(filter, CFG_PREFIX "strength");
sys->radius = var_CreateGetIntegerCommand(filter, CFG_PREFIX "radius");
var_AddCallback(filter, CFG_PREFIX "strength", Callback, NULL);
var_AddCallback(filter, CFG_PREFIX "radius", Callback, NULL);
sys->cfg.buf = NULL;
struct vf_priv_s *cfg = &sys->cfg;
cfg->thresh = 0.0;
cfg->radius = 0;
cfg->buf = NULL;
#if HAVE_SSE2 && HAVE_6REGS
if (vlc_CPU_SSE2())
cfg->blur_line = blur_line_sse2;
else
#endif
cfg->blur_line = blur_line_c;
#if HAVE_SSSE3
if (vlc_CPU_SSSE3())
cfg->filter_line = filter_line_ssse3;
else
#endif
#if HAVE_MMX2
if (vlc_CPU_MMXEXT())
cfg->filter_line = filter_line_mmx2;
else
#endif
cfg->filter_line = filter_line_c;
filter->p_sys = sys;
filter->pf_video_filter = Filter;
return VLC_SUCCESS;
}
/*****************************************************************************
* Create: allocates Distort video filter
*****************************************************************************/
static int Create( vlc_object_t *p_this )
{
filter_t *p_filter = (filter_t *)p_this;
filter_sys_t *p_sys;
if( p_filter->fmt_in.video.i_chroma != p_filter->fmt_out.video.i_chroma )
{
msg_Err( p_filter, "Input and output chromas don't match" );
return VLC_EGENERIC;
}
switch( p_filter->fmt_in.video.i_chroma )
{
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 (%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 )
return VLC_ENOMEM;
p_sys = p_filter->p_sys;
config_ChainParse( p_filter, FILTER_PREFIX, ppsz_filter_options,
p_filter->p_cfg );
int i_angle = var_CreateGetIntegerCommand( p_filter,
FILTER_PREFIX "angle" ) * 10;
cache_trigo( i_angle, &p_sys->i_sin, &p_sys->i_cos );
var_Create( p_filter, FILTER_PREFIX "deciangle",
VLC_VAR_INTEGER|VLC_VAR_ISCOMMAND );
vlc_spin_init( &p_sys->lock );
var_AddCallback( p_filter, FILTER_PREFIX "angle", RotateCallback, p_sys );
var_AddCallback( p_filter, FILTER_PREFIX "deciangle",
PreciseRotateCallback, p_sys );
return VLC_SUCCESS;
}
static int Open(vlc_object_t *obj)
{
filter_t *filter = (filter_t *)obj;
if (filter->fmt_in.video.i_chroma != VLC_CODEC_VDPAU_VIDEO_420
&& filter->fmt_in.video.i_chroma != VLC_CODEC_VDPAU_VIDEO_422
&& filter->fmt_in.video.i_chroma != VLC_CODEC_VDPAU_VIDEO_444)
return VLC_EGENERIC;
if (!video_format_IsSimilar(&filter->fmt_in.video, &filter->fmt_out.video))
return VLC_EGENERIC;
filter_sys_t *sys = malloc(sizeof (*sys));
if (unlikely(sys == NULL))
return VLC_ENOMEM;
filter->pf_video_filter = Adjust;
filter->p_sys = sys;
config_ChainParse(filter, "", options, filter->p_cfg);
float f;
int i;
f = var_CreateGetFloatCommand(filter, "brightness");
var_AddCallback(filter, "brightness", BrightnessCallback,
&sys->brightness);
vlc_atomic_init_float(&sys->brightness, vlc_to_vdp_brightness(f));
f = var_CreateGetFloatCommand(filter, "contrast");
var_AddCallback(filter, "contrast", ContrastCallback, &sys->contrast);
vlc_atomic_init_float(&sys->contrast, vlc_to_vdp_contrast(f));
f = var_CreateGetFloatCommand(filter, "saturation");
var_AddCallback(filter, "saturation", SaturationCallback,
&sys->saturation);
vlc_atomic_init_float(&sys->saturation, vlc_to_vdp_saturation(f));
i = var_CreateGetIntegerCommand(filter, "hue");
var_AddCallback(filter, "hue", HueCallback, &sys->hue);
vlc_atomic_init_float(&sys->hue, vlc_to_vdp_hue(i));
return VLC_SUCCESS;
}
/*****************************************************************************
* SubsdelayCreate: Create subsdelay filter
*****************************************************************************/
static int SubsdelayCreate( vlc_object_t *p_this )
{
filter_t *p_filter = (filter_t *) p_this;
filter_sys_t *p_sys;
/* allocate structure */
p_sys = (filter_sys_t*) malloc( sizeof(filter_sys_t) );
if( !p_sys )
{
return VLC_ENOMEM;
}
/* init parameters */
p_sys->i_mode = var_CreateGetIntegerCommand( p_filter, CFG_MODE );
var_AddCallback( p_filter, CFG_MODE, SubsdelayCallback, p_sys );
p_sys->i_factor = FLOAT_FACTOR_TO_INT_FACTOR( var_CreateGetFloatCommand( p_filter, CFG_FACTOR ) );
var_AddCallback( p_filter, CFG_FACTOR, SubsdelayCallback, p_sys );
p_sys->i_overlap = var_CreateGetIntegerCommand( p_filter, CFG_OVERLAP );
var_AddCallback( p_filter, CFG_OVERLAP, SubsdelayCallback, p_sys );
p_sys->i_min_alpha = var_CreateGetIntegerCommand( p_filter, CFG_MIN_ALPHA );
var_AddCallback( p_filter, CFG_MIN_ALPHA, SubsdelayCallback, p_sys );
p_sys->i_min_stops_interval
= MILLISEC_TO_MICROSEC( var_CreateGetIntegerCommand( p_filter, CFG_MIN_STOPS_INTERVAL ) );
var_AddCallback( p_filter, CFG_MIN_STOPS_INTERVAL, SubsdelayCallback, p_sys );
p_sys->i_min_stop_start_interval
= MILLISEC_TO_MICROSEC( var_CreateGetIntegerCommand( p_filter, CFG_MIN_STOP_START_INTERVAL ) );
var_AddCallback( p_filter, CFG_MIN_STOP_START_INTERVAL, SubsdelayCallback, p_sys );
p_sys->i_min_start_stop_interval
= MILLISEC_TO_MICROSEC( var_CreateGetIntegerCommand( p_filter, CFG_MIN_START_STOP_INTERVAL ) );
var_AddCallback( p_filter, CFG_MIN_START_STOP_INTERVAL, SubsdelayCallback, p_sys );
p_filter->p_sys = p_sys;
p_filter->pf_sub_filter = SubsdelayFilter;
config_ChainParse( p_filter, CFG_PREFIX, ppsz_filter_options, p_filter->p_cfg );
SubsdelayHeapInit( &p_sys->heap );
return VLC_SUCCESS;
}
/**
* Open the filter
*/
int Open( vlc_object_t *p_this )
{
filter_t *p_filter = (filter_t *)p_this;
filter_sys_t *p_sys;
/* Assert video in match with video out */
if( !es_format_IsSimilar( &p_filter->fmt_in, &p_filter->fmt_out ) ) {
msg_Err( p_filter, "Input and output format does not match" );
return VLC_EGENERIC;
}
const vlc_chroma_description_t *p_chroma =
vlc_fourcc_GetChromaDescription( p_filter->fmt_in.video.i_chroma );
if( p_chroma == NULL || p_chroma->plane_count == 0 )
return VLC_EGENERIC;
/* Allocate structure */
p_filter->p_sys = p_sys = calloc(1, sizeof( *p_sys ) );
if( !p_sys )
return VLC_ENOMEM;
/* init some values */
p_sys->b_shuffle_rqst = true;
p_sys->b_change_param = true;
p_sys->i_mouse_drag_pce = NO_PCE;
p_sys->i_pointed_pce = NO_PCE;
p_sys->i_magnet_accuracy = 3;
/* Generate values of random bezier shapes */
p_sys->ps_bezier_pts_H = calloc( SHAPES_QTY, sizeof( point_t *) );
if( !p_sys->ps_bezier_pts_H )
{
free(p_filter->p_sys);
p_filter->p_sys = NULL;
return VLC_ENOMEM;
}
for (int32_t i_shape = 0; i_shape<SHAPES_QTY; i_shape++)
p_sys->ps_bezier_pts_H[i_shape] = puzzle_rand_bezier(7);
config_ChainParse( p_filter, CFG_PREFIX, ppsz_filter_options,
p_filter->p_cfg );
vlc_mutex_init( &p_sys->lock );
vlc_mutex_init( &p_sys->pce_lock );
p_sys->s_new_param.i_rows =
var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "rows" );
p_sys->s_new_param.i_cols =
var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "cols" );
p_sys->s_new_param.i_border =
var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "border" );
p_sys->s_new_param.b_preview =
var_CreateGetBoolCommand( p_filter, CFG_PREFIX "preview" );
p_sys->s_new_param.i_preview_size =
var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "preview-size" );
p_sys->s_new_param.i_shape_size =
var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "shape-size" );
p_sys->s_new_param.i_auto_shuffle_speed =
var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "auto-shuffle" );
p_sys->s_new_param.i_auto_solve_speed =
var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "auto-solve" );
p_sys->s_new_param.i_rotate =
var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "rotation" );
p_sys->s_new_param.i_mode =
var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "mode" );
var_AddCallback( p_filter, CFG_PREFIX "rows", puzzle_Callback, p_sys );
var_AddCallback( p_filter, CFG_PREFIX "cols", puzzle_Callback, p_sys );
var_AddCallback( p_filter, CFG_PREFIX "border", puzzle_Callback, p_sys );
var_AddCallback( p_filter, CFG_PREFIX "preview", puzzle_Callback, p_sys );
var_AddCallback( p_filter, CFG_PREFIX "preview-size", puzzle_Callback, p_sys );
var_AddCallback( p_filter, CFG_PREFIX "shape-size", puzzle_Callback, p_sys );
var_AddCallback( p_filter, CFG_PREFIX "auto-shuffle", puzzle_Callback, p_sys );
var_AddCallback( p_filter, CFG_PREFIX "auto-solve", puzzle_Callback, p_sys );
var_AddCallback( p_filter, CFG_PREFIX "rotation", puzzle_Callback, p_sys );
var_AddCallback( p_filter, CFG_PREFIX "mode", puzzle_Callback, p_sys );
p_filter->pf_video_filter = Filter;
p_filter->pf_video_mouse = puzzle_mouse;
return VLC_SUCCESS;
}
/*****************************************************************************
* OpenFilter: probe the filter and return score
*****************************************************************************/
static int OpenFilter(vlc_object_t *p_this)
{
filter_t *p_filter = (filter_t*) p_this;
filter_sys_t *p_sys;
/* Allocate the memory needed to store the decoder's structure */
if ((p_filter->p_sys = p_sys =
(filter_sys_t *) malloc(sizeof (filter_sys_t))) == NULL) {
return VLC_ENOMEM;
}
vlc_value_t val1;
var_Get(p_filter->p_parent->p_parent, "video-object", &val1);
analytic_input_params *parameters = (analytic_input_params*) val1.p_address;
p_sys->input_parameters = parameters;
p_sys->event_info.i_region_size = 0;
p_sys->event_info.p_region = NULL;
p_sys->i_id = 0;
p_sys->counter = 0;
p_filter->p_sys->x_old = 0;
p_filter->p_sys->x_new = 0;
p_filter->p_sys->y_old = 0;
p_filter->p_sys->y_new = 0;
p_filter->p_sys->mov = 0;
p_filter->p_sys->click = 0;
p_filter->p_sys->save_preset = 0;
p_filter->p_sys->scroll_value = 0;
p_filter->p_sys->Var_on_click_zoom = 0;
p_filter->p_sys->angle_rotate = 0;
p_filter->p_sys->start = 1;
///////////////////////////////////////////////////////text file assignment/////////////////////
//////////////// creating folder "fisheye_config" ////////////////////////
char idnum[20];
sprintf(idnum, "%d", p_filter->p_sys->input_parameters->cameraid);
char name[] = "fisheye_config/camera_num_";
strcpy(p_filter->p_sys->camera_id, name);
char txt[] = ".txt";
strcat(p_filter->p_sys->camera_id, idnum);
strcat(p_filter->p_sys->camera_id, txt);
//Open the input file
ifstream input;
input.open(p_filter->p_sys->camera_id);
if (!input)
{
cout << "camera1.txt could not be accessed!" << endl;
ofstream outf(p_filter->p_sys->camera_id);
// If we couldn't open the output file stream for writing
if (!outf)
{
// Print an error and exit
cerr << "Uh oh, Sample.dat could not be opened for writing!" << endl;
return 0;
}
// We'll write two lines into this file
outf << "radius = 400.00" << endl;
outf << "theta = 1.57" << endl;
outf << "centre_x = 200.00" << endl;
outf << "centre_y = 200.00" << endl;
outf.close();
p_filter->p_sys->start = 0;
input.open(p_filter->p_sys->camera_id);
}
else
{
//Variables
string temp;
if (!input.eof())
{
getline(input, temp); //Get 1 line from the file and place into temp
p_filter->p_sys->radius_video = HOME_MADE_ATOI(temp);
}
if (!input.eof())
{
getline(input, temp); //Get 1 line from the file and place into temp
p_filter->p_sys->theta = HOME_MADE_ATOI(temp);
}
if (!input.eof())
{
getline(input, temp); //Get 1 line from the file and place into temp
p_filter->p_sys->centre_x = HOME_MADE_ATOI(temp);
}
if (!input.eof())
{
getline(input, temp); //Get 1 line from the file and place into temp
p_filter->p_sys->centre_y = HOME_MADE_ATOI(temp);
}
}
input.close();
////////////////////////////////////////////////////////////////////////////////////////////////////////
p_filter->p_sys->para = p_filter->p_sys->input_parameters->debugParam.thresh4;
p_filter->pf_video_filter = Filter;
p_filter->pf_video_mouse = Mouse;
///////////////////////////////////////////////////////
var_CreateGetIntegerCommand(p_filter, "mouse-wheel");
var_AddCallback(p_filter, "mouse-wheel", MouseWheelCallback, p_sys);
p_filter->p_sys->f_scale = p_filter->p_sys->input_parameters->debugParam.minObjHeight;
p_filter->p_sys->output_max_height = p_filter->p_sys->input_parameters->debugParam.maxObjHeight;
p_filter->p_sys->output_max_width = p_filter->p_sys->input_parameters->debugParam.maxObjWidth;
///////////////////////////////////////////////////////////////
return VLC_SUCCESS;
}
/*****************************************************************************
* OpenDecoder: probe the decoder and return score
*****************************************************************************/
static int OpenDecoder( vlc_object_t *p_this )
{
decoder_t *p_dec = (decoder_t*)p_this;
vlc_value_t val;
image_handler_t *p_handler;
video_format_t fmt_in, fmt_out;
picture_t *p_image;
char *psz_file, *psz_chroma;
bool b_keep_ar;
int i_aspect = 0;
if( p_dec->fmt_in.i_codec != VLC_FOURCC('f','a','k','e') )
{
return VLC_EGENERIC;
}
p_dec->p_sys = calloc( 1, sizeof( *p_dec->p_sys ) );
if( !p_dec->p_sys )
return VLC_ENOMEM;
psz_file = var_CreateGetNonEmptyStringCommand( p_dec, "fake-file" );
if( !psz_file )
{
msg_Err( p_dec, "specify a file with --fake-file=..." );
free( p_dec->p_sys );
return VLC_EGENERIC;
}
var_AddCallback( p_dec, "fake-file", FakeCallback, p_dec );
memset( &fmt_in, 0, sizeof(fmt_in) );
memset( &fmt_out, 0, sizeof(fmt_out) );
val.i_int = var_CreateGetIntegerCommand( p_dec, "fake-file-reload" );
if( val.i_int > 0)
{
p_dec->p_sys->b_reload = true;
p_dec->p_sys->i_reload = (mtime_t)(val.i_int * 1000000);
p_dec->p_sys->i_next = (mtime_t)(p_dec->p_sys->i_reload + mdate());
}
var_AddCallback( p_dec, "fake-file-reload", FakeCallback , p_dec );
psz_chroma = var_CreateGetString( p_dec, "fake-chroma" );
fmt_out.i_chroma = vlc_fourcc_GetCodecFromString( VIDEO_ES, psz_chroma );
if( !fmt_out.i_chroma )
{
msg_Warn( p_dec, "Invalid chroma (%s). Using I420.", psz_chroma );
fmt_out.i_chroma = VLC_CODEC_I420;
}
free( psz_chroma );
var_Create( p_dec, "fake-keep-ar", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
var_Get( p_dec, "fake-keep-ar", &val );
b_keep_ar = val.b_bool;
var_Create( p_dec, "fake-width", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
var_Create( p_dec, "fake-height", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
var_Create( p_dec, "fake-aspect-ratio",
VLC_VAR_STRING | VLC_VAR_DOINHERIT );
var_Get( p_dec, "fake-aspect-ratio", &val );
if ( val.psz_string )
{
char *psz_parser = strchr( val.psz_string, ':' );
if( psz_parser )
{
*psz_parser++ = '\0';
i_aspect = atoi( val.psz_string )
* VOUT_ASPECT_FACTOR / atoi( psz_parser );
}
free( val.psz_string );
}
if ( !b_keep_ar )
{
var_Get( p_dec, "fake-width", &val );
fmt_out.i_width = val.i_int;
var_Get( p_dec, "fake-height", &val );
fmt_out.i_height = val.i_int;
}
p_handler = image_HandlerCreate( p_dec );
p_image = image_ReadUrl( p_handler, psz_file, &fmt_in, &fmt_out );
image_HandlerDelete( p_handler );
if ( p_image == NULL )
{
msg_Err( p_dec, "unable to read image file %s", psz_file );
free( psz_file );
free( p_dec->p_sys );
return VLC_EGENERIC;
}
msg_Dbg( p_dec, "file %s loaded successfully", psz_file );
free( psz_file );
if ( b_keep_ar )
{
picture_t *p_old = p_image;
int i_width, i_height;
var_Get( p_dec, "fake-width", &val );
i_width = val.i_int;
var_Get( p_dec, "fake-height", &val );
i_height = val.i_int;
if ( i_width && i_height )
{
int i_image_ar = fmt_out.i_width * VOUT_ASPECT_FACTOR
/ fmt_out.i_height;
int i_region_ar = i_width * VOUT_ASPECT_FACTOR / i_height;
fmt_in = fmt_out;
if ( i_aspect == i_image_ar )
{
fmt_out.i_width = i_width;
fmt_out.i_height = i_height;
}
else if ( i_image_ar > i_region_ar )
{
fmt_out.i_width = i_width;
fmt_out.i_height = i_width * VOUT_ASPECT_FACTOR
/ i_image_ar;
i_aspect = i_image_ar;
}
else
{
fmt_out.i_height = i_height;
fmt_out.i_width = i_height * i_image_ar
/ VOUT_ASPECT_FACTOR;
i_aspect = i_image_ar;
}
p_handler = image_HandlerCreate( p_dec );
p_image = image_Convert( p_handler, p_old, &fmt_in, &fmt_out );
image_HandlerDelete( p_handler );
if ( p_image == NULL )
{
msg_Warn( p_dec, "couldn't load resizing module" );
p_image = p_old;
fmt_out = fmt_in;
}
else
{
picture_Release( p_old );
}
}
}
if ( i_aspect )
{
fmt_out.i_aspect = i_aspect;
}
else
{
fmt_out.i_aspect = fmt_out.i_width
* VOUT_ASPECT_FACTOR / fmt_out.i_height;
}
var_Create( p_dec, "fake-deinterlace", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
var_Get( p_dec, "fake-deinterlace", &val );
if ( val.b_bool )
{
picture_t *p_old = p_image;
var_Create( p_dec, "fake-deinterlace-module",
VLC_VAR_STRING | VLC_VAR_DOINHERIT );
var_Get( p_dec, "fake-deinterlace-module", &val );
p_handler = image_HandlerCreate( p_dec );
p_image = image_Filter( p_handler, p_old, &fmt_out, val.psz_string );
image_HandlerDelete( p_handler );
free( val.psz_string );
if ( p_image == NULL )
{
msg_Warn( p_dec, "couldn't load deinterlace module" );
p_image = p_old;
}
else
{
picture_Release( p_old );
}
}
/* Set output properties */
p_dec->fmt_out.i_cat = VIDEO_ES;
p_dec->fmt_out.i_codec = fmt_out.i_chroma;
p_dec->fmt_out.video = fmt_out;
/* Set callbacks */
p_dec->pf_decode_video = DecodeBlock;
p_dec->p_sys->p_image = p_image;
vlc_mutex_init( &p_dec->p_sys->lock );
return VLC_SUCCESS;
}
/**
* Common open function
*/
static int OpenCommon( vlc_object_t *p_this, bool b_sub )
{
filter_t *p_filter = (filter_t *)p_this;
filter_sys_t *p_sys;
char *psz_filename;
/* */
if( !b_sub && !es_format_IsSimilar( &p_filter->fmt_in, &p_filter->fmt_out ) )
{
msg_Err( p_filter, "Input and output format does not match" );
return VLC_EGENERIC;
}
/* */
p_filter->p_sys = p_sys = malloc( sizeof( *p_sys ) );
if( !p_sys )
return VLC_ENOMEM;
/* */
p_sys->p_blend = NULL;
if( !b_sub )
{
p_sys->p_blend = filter_NewBlend( VLC_OBJECT(p_filter),
&p_filter->fmt_in.video );
if( !p_sys->p_blend )
{
free( p_sys );
return VLC_EGENERIC;
}
}
/* */
config_ChainParse( p_filter, CFG_PREFIX, ppsz_filter_options,
p_filter->p_cfg );
/* */
logo_list_t *p_list = &p_sys->list;
psz_filename = var_CreateGetStringCommand( p_filter, "logo-file" );
if( !psz_filename )
{
if( p_sys->p_blend )
filter_DeleteBlend( p_sys->p_blend );
free( p_sys );
return VLC_ENOMEM;
}
if( *psz_filename == '\0' )
msg_Warn( p_this, "no logo file specified" );
p_list->i_alpha = var_CreateGetIntegerCommand( p_filter, "logo-opacity");
p_list->i_alpha = __MAX( __MIN( p_list->i_alpha, 255 ), 0 );
p_list->i_delay = var_CreateGetIntegerCommand( p_filter, "logo-delay" );
p_list->i_repeat = var_CreateGetIntegerCommand( p_filter, "logo-repeat" );
p_sys->i_pos = var_CreateGetIntegerCommand( p_filter, "logo-position" );
p_sys->i_pos_x = var_CreateGetIntegerCommand( p_filter, "logo-x" );
p_sys->i_pos_y = var_CreateGetIntegerCommand( p_filter, "logo-y" );
/* Ignore aligment if a position is given for video filter */
if( !b_sub && p_sys->i_pos_x >= 0 && p_sys->i_pos_y >= 0 )
p_sys->i_pos = 0;
vlc_mutex_init( &p_sys->lock );
LogoListLoad( p_this, p_list, psz_filename );
p_sys->b_spu_update = true;
p_sys->b_mouse_grab = false;
for( int i = 0; ppsz_filter_callbacks[i]; i++ )
var_AddCallback( p_filter, ppsz_filter_callbacks[i],
LogoCallback, p_sys );
/* Misc init */
if( b_sub )
{
p_filter->pf_sub_source = FilterSub;
}
else
{
p_filter->pf_video_filter = FilterVideo;
p_filter->pf_video_mouse = Mouse;
}
free( psz_filename );
return VLC_SUCCESS;
}
/*****************************************************************************
* Open
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
sout_stream_t *p_stream = (sout_stream_t *)p_this;
sout_stream_sys_t *p_sys;
vlc_value_t val;
config_ChainParse( p_stream, CFG_PREFIX, ppsz_sout_options,
p_stream->p_cfg );
p_sys = malloc( sizeof( sout_stream_sys_t ) );
if( !p_sys )
return VLC_ENOMEM;
p_stream->p_sys = p_sys;
p_sys->b_inited = false;
p_sys->psz_id = var_CreateGetString( p_stream, CFG_PREFIX "id" );
p_sys->i_height =
var_CreateGetIntegerCommand( p_stream, CFG_PREFIX "height" );
var_AddCallback( p_stream, CFG_PREFIX "height", HeightCallback, p_stream );
p_sys->i_width =
var_CreateGetIntegerCommand( p_stream, CFG_PREFIX "width" );
var_AddCallback( p_stream, CFG_PREFIX "width", WidthCallback, p_stream );
var_Get( p_stream, CFG_PREFIX "sar", &val );
if( val.psz_string )
{
char *psz_parser = strchr( val.psz_string, ':' );
if( psz_parser )
{
*psz_parser++ = '\0';
p_sys->i_sar_num = atoi( val.psz_string );
p_sys->i_sar_den = atoi( psz_parser );
vlc_ureduce( &p_sys->i_sar_num, &p_sys->i_sar_den,
p_sys->i_sar_num, p_sys->i_sar_den, 0 );
}
else
{
msg_Warn( p_stream, "bad aspect ratio %s", val.psz_string );
p_sys->i_sar_num = p_sys->i_sar_den = 1;
}
free( val.psz_string );
}
else
{
p_sys->i_sar_num = p_sys->i_sar_den = 1;
}
p_sys->i_chroma = 0;
val.psz_string = var_GetNonEmptyString( p_stream, CFG_PREFIX "chroma" );
if( val.psz_string && strlen( val.psz_string ) >= 4 )
{
memcpy( &p_sys->i_chroma, val.psz_string, 4 );
msg_Dbg( p_stream, "Forcing image chroma to 0x%.8x (%4.4s)", p_sys->i_chroma, (char*)&p_sys->i_chroma );
}
free( val.psz_string );
#define INT_COMMAND( a ) do { \
var_Create( p_stream, CFG_PREFIX #a, \
VLC_VAR_INTEGER | VLC_VAR_DOINHERIT | VLC_VAR_ISCOMMAND ); \
var_AddCallback( p_stream, CFG_PREFIX #a, a ## Callback, \
p_stream ); } while(0)
INT_COMMAND( alpha );
INT_COMMAND( x );
INT_COMMAND( y );
#undef INT_COMMAND
p_stream->pf_add = Add;
p_stream->pf_del = Del;
p_stream->pf_send = Send;
p_stream->pace_nocontrol = true;
return VLC_SUCCESS;
}
/**
* Common open function
*/
static int OpenCommon( vlc_object_t *p_this, bool b_sub )
{
filter_t *p_filter = (filter_t *)p_this;
filter_sys_t *p_sys;
BarGraph_t *p_BarGraph;
char* i_values = NULL;
/* */
if( !b_sub && !es_format_IsSimilar( &p_filter->fmt_in, &p_filter->fmt_out ) )
{
msg_Err( p_filter, "Input and output format does not match" );
return VLC_EGENERIC;
}
/* */
p_filter->p_sys = p_sys = malloc( sizeof( *p_sys ) );
if( !p_sys )
return VLC_ENOMEM;
p_BarGraph = &(p_sys->p_BarGraph);
/* */
p_sys->p_blend = NULL;
if( !b_sub )
{
p_sys->p_blend = filter_NewBlend( VLC_OBJECT(p_filter),
&p_filter->fmt_in.video );
if( !p_sys->p_blend )
{
//free( p_BarGraph );
free( p_sys );
return VLC_EGENERIC;
}
}
/* */
config_ChainParse( p_filter, CFG_PREFIX, ppsz_filter_options,
p_filter->p_cfg );
/* create and initialize variables */
p_sys->i_pos = var_CreateGetIntegerCommand( p_filter, "audiobargraph_v-position" );
p_sys->i_pos_x = var_CreateGetIntegerCommand( p_filter, "audiobargraph_v-x" );
p_sys->i_pos_y = var_CreateGetIntegerCommand( p_filter, "audiobargraph_v-y" );
p_BarGraph->i_alpha = var_CreateGetIntegerCommand( p_filter,
"audiobargraph_v-transparency" );
p_BarGraph->i_alpha = VLC_CLIP( p_BarGraph->i_alpha, 0, 255 );
i_values = var_CreateGetStringCommand( p_filter, "audiobargraph_v-i_values" );
//p_BarGraph->nbChannels = 0;
//p_BarGraph->i_values = NULL;
parse_i_values(p_BarGraph, i_values);
p_BarGraph->alarm = var_CreateGetIntegerCommand( p_filter, "audiobargraph_v-alarm" );
p_BarGraph->barWidth = var_CreateGetIntegerCommand( p_filter, "audiobargraph_v-barWidth" );
p_BarGraph->scale = 400;
/* Ignore aligment if a position is given for video filter */
if( !b_sub && p_sys->i_pos_x >= 0 && p_sys->i_pos_y >= 0 )
p_sys->i_pos = 0;
vlc_mutex_init( &p_sys->lock );
LoadBarGraph( p_this, p_BarGraph );
p_sys->b_spu_update = true;
for( int i = 0; ppsz_filter_callbacks[i]; i++ )
var_AddCallback( p_filter, ppsz_filter_callbacks[i],
BarGraphCallback, p_sys );
/* Misc init */
if( b_sub )
{
p_filter->pf_sub_source = FilterSub;
}
else
{
p_filter->pf_video_filter = FilterVideo;
}
free( i_values );
return VLC_SUCCESS;
}
/*****************************************************************************
* CreateFilter: Create the filter and open the definition file
*****************************************************************************/
static int CreateFilter ( vlc_object_t *p_this )
{
filter_t *p_filter = (filter_t *)p_this;
filter_sys_t *p_sys = NULL;
msg_Dbg( p_filter, "Creating vnc osd filter..." );
p_filter->p_sys = p_sys = calloc( 1, sizeof(*p_sys) );
if( !p_filter->p_sys )
return VLC_ENOMEM;
/* Populating struct */
vlc_mutex_init( &p_sys->lock );
p_sys->b_continue = true;
p_sys->i_socket = -1;
p_sys->p_pic = NULL;
p_sys->psz_host = var_CreateGetString( p_this, RMTOSD_CFG "host" );
if( EMPTY_STR(p_sys->psz_host) )
{
msg_Err( p_filter, "unable to get vnc host" );
goto error;
}
p_sys->psz_passwd = var_CreateGetString( p_this, RMTOSD_CFG "password" );
if( !p_sys->psz_passwd )
{
msg_Err( p_filter, "unable to get vnc password" );
goto error;
}
p_sys->i_port = var_CreateGetIntegerCommand( p_this, RMTOSD_CFG "port" );
p_sys->i_alpha = var_CreateGetIntegerCommand( p_this, RMTOSD_CFG "alpha" );
/* in milliseconds, 0 disables polling, should not be lower than 100 */
p_sys->i_vnc_poll_interval = var_CreateGetIntegerCommand( p_this,
RMTOSD_CFG "update" );
if ( p_sys->i_vnc_poll_interval < 100)
{
p_sys->i_vnc_poll_interval = 100;
}
for ( int i = 0; i < 256; i++ )
{
p_sys->ar_color_table_yuv[i][0] = 255;
p_sys->ar_color_table_yuv[i][1] = 255;
p_sys->ar_color_table_yuv[i][2] = 255;
p_sys->ar_color_table_yuv[i][3] = 255;
}
p_sys->b_vnc_poll = var_CreateGetBoolCommand( p_this,
RMTOSD_CFG "vnc-polling" );
p_sys->b_vnc_mouse_events = var_CreateGetBoolCommand( p_this,
RMTOSD_CFG "mouse-events" );
p_sys->b_vnc_key_events = var_CreateGetBoolCommand( p_this,
RMTOSD_CFG "key-events" );
/* Keep track of OSD Events */
p_sys->b_need_update = false;
/* Attach subpicture source callback */
p_filter->pf_sub_source = Filter;
p_filter->pf_sub_mouse = MouseEvent;
var_AddCallback( p_filter->p_libvlc, "key-pressed", KeyEvent, p_this );
es_format_Init( &p_filter->fmt_out, SPU_ES, VLC_CODEC_SPU );
p_filter->fmt_out.i_priority = 0;
vlc_gcrypt_init();
/* create the vnc worker thread */
if( vlc_clone( &p_sys->worker_thread,
vnc_worker_thread, p_filter, VLC_THREAD_PRIORITY_LOW ) )
{
msg_Err( p_filter, "cannot spawn vnc message reader thread" );
goto error;
}
msg_Dbg( p_filter, "osdvnc filter started" );
return VLC_SUCCESS;
error:
msg_Err( p_filter, "osdvnc filter discarded" );
stop_osdvnc( p_filter );
vlc_mutex_destroy( &p_sys->lock );
free( p_sys->psz_host );
free( p_sys->psz_passwd );
free( p_sys );
return VLC_EGENERIC;
}
