/***************************************************************************** * 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; }