vf_fieldmatch.c File Reference

Fieldmatching filter, ported from VFM filter (VapourSynth) by Clément. More...

#include <inttypes.h>
#include "libavutil/avassert.h"
#include "libavutil/imgutils.h"
#include "libavutil/opt.h"
#include "libavutil/timestamp.h"
#include "avfilter.h"
#include "internal.h"

Classes
struct	FieldMatchContext

Macros
#define	INPUT_MAIN   0
#define	INPUT_CLEANSRC   1
#define	OFFSET(x)   offsetof(FieldMatchContext, x)
#define	FLAGS   AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
#define	FILTER(xm2, xm1, xp1, xp2)
#define	HAS_FF_AROUND(p, lz)
#define	C_ARRAY_ADD(v)
#define	VERTICAL_HALF(y_start, y_end)
#define	LOAD_COMB(mid)
#define	SLIDING_FRAME_WINDOW(prv, src, nxt)

Typedefs
typedef struct FieldMatchContext	FieldMatchContext

Enumerations
enum	fieldmatch_parity { FM_PARITY_AUTO = -1, FM_PARITY_BOTTOM = 0, FM_PARITY_TOP = 1 }
enum	matching_mode {   MODE_PC, MODE_PC_N, MODE_PC_U, MODE_PC_N_UB,   MODE_PCN, MODE_PCN_UB, NB_MODE }
enum	comb_matching_mode { COMBMATCH_NONE, COMBMATCH_SC, COMBMATCH_FULL, NB_COMBMATCH }
enum	comb_dbg { COMBDBG_NONE, COMBDBG_PCN, COMBDBG_PCNUB, NB_COMBDBG }
enum	{   mP, mC, mN, mB,   mU }

Functions
	AVFILTER_DEFINE_CLASS (fieldmatch)

Variables
AVFilter	ff_vf_fieldmatch

Detailed Description

Fieldmatching filter, ported from VFM filter (VapourSynth) by Clément.

Fredrik Mellbin is the author of the VIVTC/VFM filter, which is itself a light clone of the TIVTC/TFM (AviSynth) filter written by Kevin Stone (tritical), the original author.

See also

http://bengal.missouri.edu/~kes25c/

http://www.vapoursynth.com/about/

Macro Definition Documentation

C_ARRAY_ADD

#define C_ARRAY_ADD

(

v

)

Value:

do {                         \
    const int box1 = (x / blockx) * 4;              \
    const int box2 = ((x + xhalf) / blockx) * 4;    \
    c_array[temp1 + box1    ] += v;                 \
    c_array[temp1 + box2 + 1] += v;                 \
    c_array[temp2 + box1 + 2] += v;                 \
    c_array[temp2 + box2 + 3] += v;                 \
} while (0)

FILTER

#define FILTER	(		xm2,
			xm1,
			xp1,
			xp2
	)

Value:

abs(  4 * srcp[x] \
             -3 * (srcp[x + (xm1)*src_linesize] + srcp[x + (xp1)*src_linesize]) \
             +    (srcp[x + (xm2)*src_linesize] + srcp[x + (xp2)*src_linesize])) > cthresh6

HAS_FF_AROUND

#define HAS_FF_AROUND	(		p,
			lz
	)

Value:

(p[(x)-1 - (lz)] == 0xff || p[(x) - (lz)] == 0xff || p[(x)+1 - (lz)] == 0xff || \
                              p[(x)-1       ] == 0xff ||                          p[(x)+1       ] == 0xff || \
                              p[(x)-1 + (lz)] == 0xff || p[(x) + (lz)] == 0xff || p[(x)+1 + (lz)] == 0xff)

LOAD_COMB

#define LOAD_COMB

(

mid

)

Value:

do {                                                     \
    if (combs[mid] < 0) {                                                       \
        if (!gen_frames[mid])                                                   \
            gen_frames[mid] = create_weave_frame(ctx, mid, field,               \
                                                 fm->prv, fm->src, fm->nxt);    \
        combs[mid] = calc_combed_score(fm, gen_frames[mid]);                    \
    }                                                                           \
} while (0)

SLIDING_FRAME_WINDOW

#define SLIDING_FRAME_WINDOW	(		prv,
			src,
			nxt
	)

Value:

do {                \
        if (prv != src) /* 2nd loop exception (1st has prv==src and we don't want to loose src) */ \
            av_frame_free(&prv);                                \
        prv = src;                                              \
        src = nxt;                                              \
        if (in)                                                 \
            nxt = in;                                           \
        if (!prv)                                               \
            prv = src;                                          \
        if (!prv) /* received only one frame at that point */   \
            return 0;                                           \
        av_assert0(prv && src && nxt);                          \
} while (0)

VERTICAL_HALF

#define VERTICAL_HALF	(		y_start,
			y_end
	)

Value:

do {                                  \
    for (y = y_start; y < y_end; y++) {                                     \
        const int temp1 = (y / blocky) * xblocks4;                          \
        const int temp2 = ((y + yhalf) / blocky) * xblocks4;                \
        for (x = 0; x < width; x++)                                         \
            if (cmkp[x - cmk_linesize] == 0xff &&                           \
                cmkp[x               ] == 0xff &&                           \
                cmkp[x + cmk_linesize] == 0xff)                             \
                C_ARRAY_ADD(1);                                             \
        cmkp += cmk_linesize;                                               \
    }                                                                       \
} while (0)

Variable Documentation

ff_vf_fieldmatch

AVFilter ff_vf_fieldmatch

Initial value:

= {
    .name           = "fieldmatch",
    .description    = NULL_IF_CONFIG_SMALL("Field matching for inverse telecine."),
    .query_formats  = query_formats,
    .priv_size      = sizeof(FieldMatchContext),
    .init           = fieldmatch_init,
    .uninit         = fieldmatch_uninit,
    .inputs         = NULL,
    .outputs        = fieldmatch_outputs,
    .priv_class     = &fieldmatch_class,
    .flags          = AVFILTER_FLAG_DYNAMIC_INPUTS,
}