vf_estdif.c File Reference

#include "libavutil/common.h"
#include "libavutil/imgutils.h"
#include "libavutil/opt.h"
#include "libavutil/pixdesc.h"
#include "avfilter.h"
#include "internal.h"
#include "video.h"

Go to the source code of this file.

Data Structures
struct	ESTDIFContext
struct	ThreadData
	Used for passing data between threads. More...

Macros
#define	MAX_R   15
#define	S   (MAX_R * 2 + 1)
#define	OFFSET(x)   offsetof(ESTDIFContext, x)
#define	FLAGS   AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
#define	CONST(name, help, val, unit)   { name, help, 0, AV_OPT_TYPE_CONST, {.i64=val}, 0, 0, FLAGS, unit }
#define	MIDL(type, ss)
#define	MID2(type, ss)
#define	MID4(type, ss)
#define	MID6(type, ss)
#define	DIFF(type, ss)
#define	COST(type, ss)
#define	INTERPOLATE(type, atype, amax, ss)

Functions
	AVFILTER_DEFINE_CLASS (estdif)
static int	config_output (AVFilterLink *outlink)
static int	deinterlace_slice (AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
static int	filter (AVFilterContext *ctx, AVFrame *in, int64_t pts, int64_t duration)
static int	config_input (AVFilterLink *inlink)
static int	filter_frame (AVFilterLink *inlink, AVFrame *in)
static int	request_frame (AVFilterLink *link)
static av_cold void	uninit (AVFilterContext *ctx)

Variables
static const AVOption	estdif_options []
static enum AVPixelFormat	pix_fmts []
static const AVFilterPad	estdif_inputs []
static const AVFilterPad	estdif_outputs []
const AVFilter	ff_vf_estdif

Macro Definition Documentation

MAX_R

#define MAX_R   15

Definition at line 76 of file vf_estdif.c.

S

#define S   (MAX_R * 2 + 1)

Definition at line 77 of file vf_estdif.c.

OFFSET

#define OFFSET

(

x

)

offsetof(ESTDIFContext, x)

Definition at line 79 of file vf_estdif.c.

FLAGS

#define FLAGS   AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM

Definition at line 80 of file vf_estdif.c.

CONST

#define CONST	(		name,
			help,
			val,
			unit
	)		{ name, help, 0, AV_OPT_TYPE_CONST, {.i64=val}, 0, 0, FLAGS, unit }

Definition at line 81 of file vf_estdif.c.

MIDL

#define MIDL	(		type,
			ss
	)

Value:

static unsigned midl_##ss(const type *const prev,              \
                          const type *const next,              \
                          int end, int x, int k)               \
{                                                              \
    return (prev[av_clip(x + k, 0, end)] +                     \
            next[av_clip(x - k, 0, end)] + 1) >> 1;            \
}

Definition at line 151 of file vf_estdif.c.

MID2

#define MID2	(		type,
			ss
	)

Value:

static unsigned mid2_##ss(const type *const prev,              \
                          const type *const next,              \
                          const type *const prev2,             \
                          const type *const next2,             \
                          const type *const prev3,             \
                          const type *const next3,             \
                          int end, int x, int k, int depth)    \
{                                                              \
    return (prev[av_clip(x + k, 0, end)] +                     \
            next[av_clip(x - k, 0, end)] + 1) >> 1;            \
}

Definition at line 163 of file vf_estdif.c.

MID4

#define MID4	(		type,
			ss
	)

Value:

static unsigned mid4_##ss(const type *const prev,              \
                          const type *const next,              \
                          const type *const prev2,             \
                          const type *const next2,             \
                          const type *const prev3,             \
                          const type *const next3,             \
                          int end, int x, int k, int depth)    \
{                                                              \
    return av_clip_uintp2_c((                                  \
            9 * (prev[av_clip(x + k, 0, end)] +                \
                 next[av_clip(x - k, 0, end)]) -               \
            1 * (prev2[av_clip(x + k*3, 0, end)] +             \
                 next2[av_clip(x - k*3, 0, end)]) + 8) >> 4,   \
                 depth);                                       \
}

Definition at line 179 of file vf_estdif.c.

MID6

#define MID6	(		type,
			ss
	)

Value:

static unsigned mid6_##ss(const type *const prev,              \
                          const type *const next,              \
                          const type *const prev2,             \
                          const type *const next2,             \
                          const type *const prev3,             \
                          const type *const next3,             \
                          int end, int x, int k, int depth)    \
{                                                              \
    return av_clip_uintp2_c((                                  \
           20 * (prev[av_clip(x + k, 0, end)] +                \
                 next[av_clip(x - k, 0, end)]) -               \
            5 * (prev2[av_clip(x + k*3, 0, end)] +             \
                 next2[av_clip(x - k*3, 0, end)]) +            \
            1 * (prev3[av_clip(x + k*5, 0, end)] +             \
                 next3[av_clip(x - k*5, 0, end)]) + 16) >> 5,  \
                 depth);                                       \
}

Definition at line 199 of file vf_estdif.c.

DIFF

#define DIFF	(		type,
			ss
	)

Value:

static unsigned diff_##ss(const type *const prev,              \
                          const type *const next,              \
                          int x, int y)                        \
{                                                              \
    return FFABS(prev[x] -  next[y]);                          \
}

Definition at line 221 of file vf_estdif.c.

COST

#define COST	(		type,
			ss
	)

Value:

static unsigned cost_##ss(const type *const prev,              \
                          const type *const next,              \
                          int end, int x, int k)               \
{                                                              \
    const int m = midl_##ss(prev, next, end, x, k);            \
    const int p = prev[x];                                     \
    const int n = next[x];                                     \
                                                               \
    return FFABS(p - m) + FFABS(n - m);                        \
}

Definition at line 232 of file vf_estdif.c.

INTERPOLATE

#define INTERPOLATE	(		type,
			atype,
			amax,
			ss
	)

Definition at line 247 of file vf_estdif.c.

Function Documentation

AVFILTER_DEFINE_CLASS()

AVFILTER_DEFINE_CLASS

(

estdif

)

config_output()

static int config_output ( AVFilterLink *  outlink )

static

Definition at line 134 of file vf_estdif.c.

deinterlace_slice()

static int deinterlace_slice ( AVFilterContext *  ctx, void *  arg, int  jobnr, int  nb_jobs  )

static

Definition at line 333 of file vf_estdif.c.

Referenced by filter().

filter()

static int filter ( AVFilterContext *  ctx, AVFrame *  in, int64_t  pts, int64_t  duration  )

static

Definition at line 430 of file vf_estdif.c.

Referenced by filter_frame().

config_input()

static int config_input ( AVFilterLink *  inlink )

static

Definition at line 460 of file vf_estdif.c.

filter_frame()

static int filter_frame ( AVFilterLink *  inlink, AVFrame *  in  )

static

Definition at line 494 of file vf_estdif.c.

Referenced by request_frame().

request_frame()

static int request_frame ( AVFilterLink *  link )

static

Definition at line 527 of file vf_estdif.c.

uninit()

static av_cold void uninit ( AVFilterContext *  ctx )

static

Definition at line 555 of file vf_estdif.c.

Variable Documentation

estdif_options

const AVOption estdif_options[]

static

Initial value:

= {
    { "mode", "specify the mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=1}, 0, 1, FLAGS, "mode" },
    CONST("frame", "send one frame for each frame", 0, "mode"),
    CONST("field", "send one frame for each field", 1, "mode"),
    { "parity", "specify the assumed picture field parity", OFFSET(parity), AV_OPT_TYPE_INT, {.i64=-1}, -1, 1, FLAGS, "parity" },
    CONST("tff",  "assume top field first",    0, "parity"),
    CONST("bff",  "assume bottom field first", 1, "parity"),
    CONST("auto", "auto detect parity",       -1, "parity"),
    { "deint",  "specify which frames to deinterlace", OFFSET(deint), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS, "deint" },
    CONST("all",        "deinterlace all frames",                       0, "deint"),
    CONST("interlaced", "only deinterlace frames marked as interlaced", 1, "deint"),
    { "rslope", "specify the search radius for edge slope tracing", OFFSET(rslope), AV_OPT_TYPE_INT, {.i64=1}, 1, MAX_R, FLAGS },
    { "redge",  "specify the search radius for best edge matching", OFFSET(redge),  AV_OPT_TYPE_INT, {.i64=2}, 0, MAX_R, FLAGS },
    { "ecost",  "specify the edge cost for edge matching",          OFFSET(ecost),  AV_OPT_TYPE_INT, {.i64=2}, 0, 50, FLAGS },
    { "mcost",  "specify the middle cost for edge matching",        OFFSET(mcost),  AV_OPT_TYPE_INT, {.i64=1}, 0, 50, FLAGS },
    { "dcost",  "specify the distance cost for edge matching",      OFFSET(dcost),  AV_OPT_TYPE_INT, {.i64=1}, 0, 50, FLAGS },
    { "interp", "specify the type of interpolation",                OFFSET(interp), AV_OPT_TYPE_INT, {.i64=1}, 0, 2,     FLAGS, "interp" },
    CONST("2p", "two-point interpolation",  0, "interp"),
    CONST("4p", "four-point interpolation", 1, "interp"),
    CONST("6p", "six-point interpolation",  2, "interp"),
    { NULL }
}

Definition at line 83 of file vf_estdif.c.

pix_fmts

enum AVPixelFormat pix_fmts[]

static

Initial value:

= {
    AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
    AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
    AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
    AV_PIX_FMT_YUVJ411P,
    AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,
    AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
    AV_PIX_FMT_GRAY8,
    AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY14, AV_PIX_FMT_GRAY16,
    AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
    AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
    AV_PIX_FMT_YUV440P10,
    AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
    AV_PIX_FMT_YUV440P12,
    AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
    AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16,
    AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
    AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA444P12, AV_PIX_FMT_YUVA444P16,
    AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA422P12, AV_PIX_FMT_YUVA422P16,
    AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA420P16,
    AV_PIX_FMT_GBRAP10,   AV_PIX_FMT_GBRAP12,    AV_PIX_FMT_GBRAP16,
    AV_PIX_FMT_NONE
}

Definition at line 108 of file vf_estdif.c.

estdif_inputs

const AVFilterPad estdif_inputs[]

static

Initial value:

= {
    {
        .name          = "default",
        .type          = AVMEDIA_TYPE_VIDEO,
        .filter_frame  = filter_frame,
        .config_props  = config_input,
    },
}

Definition at line 562 of file vf_estdif.c.

estdif_outputs

const AVFilterPad estdif_outputs[]

static

Initial value:

= {
    {
        .name          = "default",
        .type          = AVMEDIA_TYPE_VIDEO,
        .config_props  = config_output,
        .request_frame = request_frame,
    },
}

Definition at line 571 of file vf_estdif.c.

ff_vf_estdif

const AVFilter ff_vf_estdif

Initial value:

= {
    .name          = "estdif",
    .description   = NULL_IF_CONFIG_SMALL("Apply Edge Slope Tracing deinterlace."),
    .priv_size     = sizeof(ESTDIFContext),
    .priv_class    = &estdif_class,
    .uninit        = uninit,
    FILTER_INPUTS(estdif_inputs),
    FILTER_OUTPUTS(estdif_outputs),
    FILTER_PIXFMTS_ARRAY(pix_fmts),
    .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,
    .process_command = ff_filter_process_command,
}

Definition at line 580 of file vf_estdif.c.