[deb_ffmpeg.git] / ffmpeg / libavfilter / vf_mcdeint.c

/*
 * Copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
 *
 * FFmpeg is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with FFmpeg; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

/**
 * @file
 * Motion Compensation Deinterlacer
 * Ported from MPlayer libmpcodecs/vf_mcdeint.c.
 *
 * Known Issues:
 *
 * The motion estimation is somewhat at the mercy of the input, if the
 * input frames are created purely based on spatial interpolation then
 * for example a thin black line or another random and not
 * interpolateable pattern will cause problems.
 * Note: completely ignoring the "unavailable" lines during motion
 * estimation did not look any better, so the most obvious solution
 * would be to improve tfields or penalize problematic motion vectors.
 *
 * If non iterative ME is used then snow currently ignores the OBMC
 * window and as a result sometimes creates artifacts.
 *
 * Only past frames are used, we should ideally use future frames too,
 * something like filtering the whole movie in forward and then
 * backward direction seems like a interesting idea but the current
 * filter framework is FAR from supporting such things.
 *
 * Combining the motion compensated image with the input image also is
 * not as trivial as it seems, simple blindly taking even lines from
 * one and odd ones from the other does not work at all as ME/MC
 * sometimes has nothing in the previous frames which matches the
 * current. The current algorithm has been found by trial and error
 * and almost certainly can be improved...
 */

#include "libavutil/opt.h"
#include "libavutil/pixdesc.h"
#include "libavcodec/avcodec.h"
#include "avfilter.h"
#include "formats.h"
#include "internal.h"

enum MCDeintMode {
    MODE_FAST = 0,
    MODE_MEDIUM,
    MODE_SLOW,
    MODE_EXTRA_SLOW,
    MODE_NB,
};

enum MCDeintParity {
    PARITY_TFF  =  0, ///< top field first
    PARITY_BFF  =  1, ///< bottom field first
};

typedef struct {
    const AVClass *class;
    enum MCDeintMode mode;
    enum MCDeintParity parity;
    int qp;
    AVCodecContext *enc_ctx;
} MCDeintContext;

#define OFFSET(x) offsetof(MCDeintContext, x)
#define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
#define CONST(name, help, val, unit) { name, help, 0, AV_OPT_TYPE_CONST, {.i64=val}, INT_MIN, INT_MAX, FLAGS, unit }

static const AVOption mcdeint_options[] = {
    { "mode", "set mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=MODE_FAST}, 0, MODE_NB-1, FLAGS, .unit="mode" },
    CONST("fast",       NULL, MODE_FAST,       "mode"),
    CONST("medium",     NULL, MODE_MEDIUM,     "mode"),
    CONST("slow",       NULL, MODE_SLOW,       "mode"),
    CONST("extra_slow", NULL, MODE_EXTRA_SLOW, "mode"),

    { "parity", "set the assumed picture field parity", OFFSET(parity), AV_OPT_TYPE_INT, {.i64=PARITY_BFF}, -1, 1, FLAGS, "parity" },
    CONST("tff", "assume top field first",    PARITY_TFF, "parity"),
    CONST("bff", "assume bottom field first", PARITY_BFF, "parity"),

    { "qp", "set qp", OFFSET(qp), AV_OPT_TYPE_INT, {.i64=1}, INT_MIN, INT_MAX, FLAGS },
    { NULL }
};

AVFILTER_DEFINE_CLASS(mcdeint);

static int config_props(AVFilterLink *inlink)
{
    AVFilterContext *ctx = inlink->dst;
    MCDeintContext *mcdeint = ctx->priv;
    AVCodec *enc;
    AVCodecContext *enc_ctx;
    AVDictionary *opts = NULL;
    int ret;

    if (!(enc = avcodec_find_encoder(AV_CODEC_ID_SNOW))) {
        av_log(ctx, AV_LOG_ERROR, "Snow encoder is not enabled in libavcodec\n");
        return AVERROR(EINVAL);
    }

    mcdeint->enc_ctx = avcodec_alloc_context3(enc);
    if (!mcdeint->enc_ctx)
        return AVERROR(ENOMEM);
    enc_ctx = mcdeint->enc_ctx;
    enc_ctx->width  = inlink->w;
    enc_ctx->height = inlink->h;
    enc_ctx->time_base = (AVRational){1,25};  // meaningless
    enc_ctx->gop_size = 300;
    enc_ctx->max_b_frames = 0;
    enc_ctx->pix_fmt = AV_PIX_FMT_YUV420P;
    enc_ctx->flags = CODEC_FLAG_QSCALE | CODEC_FLAG_LOW_DELAY;
    enc_ctx->strict_std_compliance = FF_COMPLIANCE_EXPERIMENTAL;
    enc_ctx->global_quality = 1;
    enc_ctx->me_cmp = enc_ctx->me_sub_cmp = FF_CMP_SAD;
    enc_ctx->mb_cmp = FF_CMP_SSE;
    av_dict_set(&opts, "memc_only", "1", 0);

    switch (mcdeint->mode) {
    case MODE_EXTRA_SLOW:
        enc_ctx->refs = 3;
    case MODE_SLOW:
        enc_ctx->me_method = ME_ITER;
    case MODE_MEDIUM:
        enc_ctx->flags |= CODEC_FLAG_4MV;
        enc_ctx->dia_size = 2;
    case MODE_FAST:
        enc_ctx->flags |= CODEC_FLAG_QPEL;
    }

    ret = avcodec_open2(enc_ctx, enc, &opts);
    av_dict_free(&opts);
    if (ret < 0)
        return ret;

    return 0;
}

static av_cold void uninit(AVFilterContext *ctx)
{
    MCDeintContext *mcdeint = ctx->priv;

    if (mcdeint->enc_ctx) {
        avcodec_close(mcdeint->enc_ctx);
        av_freep(&mcdeint->enc_ctx);
    }
}

static int query_formats(AVFilterContext *ctx)
{
    static const enum PixelFormat pix_fmts[] = {
        AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE
    };

    ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));

    return 0;
}

static int filter_frame(AVFilterLink *inlink, AVFrame *inpic)
{
    MCDeintContext *mcdeint = inlink->dst->priv;
    AVFilterLink *outlink = inlink->dst->outputs[0];
    AVFrame *outpic, *frame_dec;
    AVPacket pkt;
    int x, y, i, ret, got_frame = 0;

    outpic = ff_get_video_buffer(outlink, outlink->w, outlink->h);
    if (!outpic) {
        av_frame_free(&inpic);
        return AVERROR(ENOMEM);
    }
    av_frame_copy_props(outpic, inpic);
    inpic->quality = mcdeint->qp * FF_QP2LAMBDA;

    av_init_packet(&pkt);
    pkt.data = NULL;    // packet data will be allocated by the encoder
    pkt.size = 0;

    ret = avcodec_encode_video2(mcdeint->enc_ctx, &pkt, inpic, &got_frame);
    if (ret < 0)
        goto end;

    frame_dec = mcdeint->enc_ctx->coded_frame;

    for (i = 0; i < 3; i++) {
        int is_chroma = !!i;
        int w = FF_CEIL_RSHIFT(inlink->w, is_chroma);
        int h = FF_CEIL_RSHIFT(inlink->h, is_chroma);
        int fils = frame_dec->linesize[i];
        int srcs = inpic    ->linesize[i];
        int dsts = outpic   ->linesize[i];

        for (y = 0; y < h; y++) {
            if ((y ^ mcdeint->parity) & 1) {
                for (x = 0; x < w; x++) {
                    uint8_t *filp = &frame_dec->data[i][x + y*fils];
                    uint8_t *srcp = &inpic    ->data[i][x + y*srcs];
                    uint8_t *dstp = &outpic   ->data[i][x + y*dsts];

                    if (y > 0 && y < h-1){
                        int is_edge = x < 3 || x > w-4;
                        int diff0 = filp[-fils] - srcp[-srcs];
                        int diff1 = filp[+fils] - srcp[+srcs];
                        int temp = filp[0];

#define DELTA(j) av_clip(j, -x, w-1-x)

#define GET_SCORE_EDGE(j)\
   FFABS(srcp[-srcs+DELTA(-1+(j))] - srcp[+srcs+DELTA(-1-(j))])+\
   FFABS(srcp[-srcs+DELTA(j)     ] - srcp[+srcs+DELTA(  -(j))])+\
   FFABS(srcp[-srcs+DELTA(1+(j)) ] - srcp[+srcs+DELTA( 1-(j))])

#define GET_SCORE(j)\
   FFABS(srcp[-srcs-1+(j)] - srcp[+srcs-1-(j)])+\
   FFABS(srcp[-srcs  +(j)] - srcp[+srcs  -(j)])+\
   FFABS(srcp[-srcs+1+(j)] - srcp[+srcs+1-(j)])

#define CHECK_EDGE(j)\
    {   int score = GET_SCORE_EDGE(j);\
        if (score < spatial_score){\
            spatial_score = score;\
            diff0 = filp[-fils+DELTA(j)]    - srcp[-srcs+DELTA(j)];\
            diff1 = filp[+fils+DELTA(-(j))] - srcp[+srcs+DELTA(-(j))];\

#define CHECK(j)\
    {   int score = GET_SCORE(j);\
        if (score < spatial_score){\
            spatial_score= score;\
            diff0 = filp[-fils+(j)] - srcp[-srcs+(j)];\
            diff1 = filp[+fils-(j)] - srcp[+srcs-(j)];\

                        if (is_edge) {
                            int spatial_score = GET_SCORE_EDGE(0) - 1;
                            CHECK_EDGE(-1) CHECK_EDGE(-2) }} }}
                            CHECK_EDGE( 1) CHECK_EDGE( 2) }} }}
                        } else {
                            int spatial_score = GET_SCORE(0) - 1;
                            CHECK(-1) CHECK(-2) }} }}
                            CHECK( 1) CHECK( 2) }} }}
                        }


                        if (diff0 + diff1 > 0)
                            temp -= (diff0 + diff1 - FFABS(FFABS(diff0) - FFABS(diff1)) / 2) / 2;
                        else
                            temp -= (diff0 + diff1 + FFABS(FFABS(diff0) - FFABS(diff1)) / 2) / 2;
                        *filp = *dstp = temp > 255U ? ~(temp>>31) : temp;
                    } else {
                        *dstp = *filp;
                    }
                }
            }
        }

        for (y = 0; y < h; y++) {
            if (!((y ^ mcdeint->parity) & 1)) {
                for (x = 0; x < w; x++) {
                    frame_dec->data[i][x + y*fils] =
                    outpic   ->data[i][x + y*dsts] = inpic->data[i][x + y*srcs];
                }
            }
        }
    }
    mcdeint->parity ^= 1;

end:
    av_free_packet(&pkt);
    av_frame_free(&inpic);
    if (ret < 0) {
        av_frame_free(&outpic);
        return ret;
    }
    return ff_filter_frame(outlink, outpic);
}

static const AVFilterPad mcdeint_inputs[] = {
    {
        .name         = "default",
        .type         = AVMEDIA_TYPE_VIDEO,
        .filter_frame = filter_frame,
        .config_props = config_props,
    },
    { NULL }
};

static const AVFilterPad mcdeint_outputs[] = {
    {
        .name = "default",
        .type = AVMEDIA_TYPE_VIDEO,
    },
    { NULL }
};

AVFilter ff_vf_mcdeint = {
    .name          = "mcdeint",
    .description   = NULL_IF_CONFIG_SMALL("Apply motion compensating deinterlacing."),
    .priv_size     = sizeof(MCDeintContext),
    .uninit        = uninit,
    .query_formats = query_formats,
    .inputs        = mcdeint_inputs,
    .outputs       = mcdeint_outputs,
    .priv_class    = &mcdeint_class,
};
Commit	Line	Data
2ba45a60 DM	1	/*
	2	* Copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
	3	*
	4	* FFmpeg is free software; you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License as published by
	6	* the Free Software Foundation; either version 2 of the License, or
	7	* (at your option) any later version.
	8	*
	9	* FFmpeg is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU General Public License along
	15	* with FFmpeg; if not, write to the Free Software Foundation, Inc.,
	16	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
	17	*/
	18
	19	/**
	20	* @file
	21	* Motion Compensation Deinterlacer
	22	* Ported from MPlayer libmpcodecs/vf_mcdeint.c.
	23	*
	24	* Known Issues:
	25	*
	26	* The motion estimation is somewhat at the mercy of the input, if the
	27	* input frames are created purely based on spatial interpolation then
	28	* for example a thin black line or another random and not
	29	* interpolateable pattern will cause problems.
	30	* Note: completely ignoring the "unavailable" lines during motion
	31	* estimation did not look any better, so the most obvious solution
	32	* would be to improve tfields or penalize problematic motion vectors.
	33	*
	34	* If non iterative ME is used then snow currently ignores the OBMC
	35	* window and as a result sometimes creates artifacts.
	36	*
	37	* Only past frames are used, we should ideally use future frames too,
	38	* something like filtering the whole movie in forward and then
	39	* backward direction seems like a interesting idea but the current
	40	* filter framework is FAR from supporting such things.
	41	*
	42	* Combining the motion compensated image with the input image also is
	43	* not as trivial as it seems, simple blindly taking even lines from
	44	* one and odd ones from the other does not work at all as ME/MC
	45	* sometimes has nothing in the previous frames which matches the
	46	* current. The current algorithm has been found by trial and error
	47	* and almost certainly can be improved...
	48	*/
	49
	50	#include "libavutil/opt.h"
	51	#include "libavutil/pixdesc.h"
	52	#include "libavcodec/avcodec.h"
	53	#include "avfilter.h"
	54	#include "formats.h"
	55	#include "internal.h"
	56
	57	enum MCDeintMode {
	58	MODE_FAST = 0,
	59	MODE_MEDIUM,
	60	MODE_SLOW,
	61	MODE_EXTRA_SLOW,
	62	MODE_NB,
	63	};
	64
65	enum MCDeintParity {
66	PARITY_TFF = 0, ///< top field first
67	PARITY_BFF = 1, ///< bottom field first
68	};
69
70	typedef struct {
71	const AVClass *class;
72	enum MCDeintMode mode;
73	enum MCDeintParity parity;
74	int qp;
75	AVCodecContext *enc_ctx;
76	} MCDeintContext;
77
78	#define OFFSET(x) offsetof(MCDeintContext, x)
79	#define FLAGS AV_OPT_FLAG_VIDEO_PARAM\|AV_OPT_FLAG_FILTERING_PARAM
80	#define CONST(name, help, val, unit) { name, help, 0, AV_OPT_TYPE_CONST, {.i64=val}, INT_MIN, INT_MAX, FLAGS, unit }
81
82	static const AVOption mcdeint_options[] = {
83	{ "mode", "set mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=MODE_FAST}, 0, MODE_NB-1, FLAGS, .unit="mode" },
84	CONST("fast", NULL, MODE_FAST, "mode"),
85	CONST("medium", NULL, MODE_MEDIUM, "mode"),
86	CONST("slow", NULL, MODE_SLOW, "mode"),
87	CONST("extra_slow", NULL, MODE_EXTRA_SLOW, "mode"),
88
89	{ "parity", "set the assumed picture field parity", OFFSET(parity), AV_OPT_TYPE_INT, {.i64=PARITY_BFF}, -1, 1, FLAGS, "parity" },
90	CONST("tff", "assume top field first", PARITY_TFF, "parity"),
91	CONST("bff", "assume bottom field first", PARITY_BFF, "parity"),
92
93	{ "qp", "set qp", OFFSET(qp), AV_OPT_TYPE_INT, {.i64=1}, INT_MIN, INT_MAX, FLAGS },
94	{ NULL }
95	};
96
97	AVFILTER_DEFINE_CLASS(mcdeint);
98
99	static int config_props(AVFilterLink *inlink)
100	{
101	AVFilterContext *ctx = inlink->dst;
102	MCDeintContext *mcdeint = ctx->priv;
103	AVCodec *enc;
104	AVCodecContext *enc_ctx;
105	AVDictionary *opts = NULL;
106	int ret;
107
108	if (!(enc = avcodec_find_encoder(AV_CODEC_ID_SNOW))) {
109	av_log(ctx, AV_LOG_ERROR, "Snow encoder is not enabled in libavcodec\n");
110	return AVERROR(EINVAL);
111	}
112
113	mcdeint->enc_ctx = avcodec_alloc_context3(enc);
114	if (!mcdeint->enc_ctx)
115	return AVERROR(ENOMEM);
116	enc_ctx = mcdeint->enc_ctx;
117	enc_ctx->width = inlink->w;
118	enc_ctx->height = inlink->h;
119	enc_ctx->time_base = (AVRational){1,25}; // meaningless
120	enc_ctx->gop_size = 300;
121	enc_ctx->max_b_frames = 0;
122	enc_ctx->pix_fmt = AV_PIX_FMT_YUV420P;
123	enc_ctx->flags = CODEC_FLAG_QSCALE \| CODEC_FLAG_LOW_DELAY;
124	enc_ctx->strict_std_compliance = FF_COMPLIANCE_EXPERIMENTAL;
125	enc_ctx->global_quality = 1;
126	enc_ctx->me_cmp = enc_ctx->me_sub_cmp = FF_CMP_SAD;
127	enc_ctx->mb_cmp = FF_CMP_SSE;
128	av_dict_set(&opts, "memc_only", "1", 0);
129
130	switch (mcdeint->mode) {
131	case MODE_EXTRA_SLOW:
132	enc_ctx->refs = 3;
133	case MODE_SLOW:
134	enc_ctx->me_method = ME_ITER;
135	case MODE_MEDIUM:
136	enc_ctx->flags \|= CODEC_FLAG_4MV;
137	enc_ctx->dia_size = 2;
138	case MODE_FAST:
139	enc_ctx->flags \|= CODEC_FLAG_QPEL;
140	}
141
142	ret = avcodec_open2(enc_ctx, enc, &opts);
143	av_dict_free(&opts);
144	if (ret < 0)
145	return ret;
146
147	return 0;
148	}
149
150	static av_cold void uninit(AVFilterContext *ctx)
151	{
152	MCDeintContext *mcdeint = ctx->priv;
153
154	if (mcdeint->enc_ctx) {
155	avcodec_close(mcdeint->enc_ctx);
156	av_freep(&mcdeint->enc_ctx);
157	}
158	}
159
160	static int query_formats(AVFilterContext *ctx)
161	{
162	static const enum PixelFormat pix_fmts[] = {
163	AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE
164	};
165
166	ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
167
168	return 0;
169	}
170
171	static int filter_frame(AVFilterLink inlink, AVFrame inpic)
172	{
173	MCDeintContext *mcdeint = inlink->dst->priv;
174	AVFilterLink *outlink = inlink->dst->outputs[0];
175	AVFrame outpic, frame_dec;
176	AVPacket pkt;
177	int x, y, i, ret, got_frame = 0;
178
179	outpic = ff_get_video_buffer(outlink, outlink->w, outlink->h);
180	if (!outpic) {
181	av_frame_free(&inpic);
182	return AVERROR(ENOMEM);
183	}
184	av_frame_copy_props(outpic, inpic);
185	inpic->quality = mcdeint->qp * FF_QP2LAMBDA;
186
187	av_init_packet(&pkt);
188	pkt.data = NULL; // packet data will be allocated by the encoder
189	pkt.size = 0;
190
191	ret = avcodec_encode_video2(mcdeint->enc_ctx, &pkt, inpic, &got_frame);
192	if (ret < 0)
193	goto end;
194
195	frame_dec = mcdeint->enc_ctx->coded_frame;
196
197	for (i = 0; i < 3; i++) {
198	int is_chroma = !!i;
199	int w = FF_CEIL_RSHIFT(inlink->w, is_chroma);
200	int h = FF_CEIL_RSHIFT(inlink->h, is_chroma);
201	int fils = frame_dec->linesize[i];
202	int srcs = inpic ->linesize[i];
203	int dsts = outpic ->linesize[i];
204
205	for (y = 0; y < h; y++) {
206	if ((y ^ mcdeint->parity) & 1) {
207	for (x = 0; x < w; x++) {
208	uint8_t filp = &frame_dec->data[i][x + yfils];
209	uint8_t srcp = &inpic ->data[i][x + ysrcs];
210	uint8_t dstp = &outpic ->data[i][x + ydsts];
211
212	if (y > 0 && y < h-1){
213	int is_edge = x < 3 \|\| x > w-4;
214	int diff0 = filp[-fils] - srcp[-srcs];
215	int diff1 = filp[+fils] - srcp[+srcs];
216	int temp = filp[0];
217
218	#define DELTA(j) av_clip(j, -x, w-1-x)
219
220	#define GET_SCORE_EDGE(j)\
221	FFABS(srcp[-srcs+DELTA(-1+(j))] - srcp[+srcs+DELTA(-1-(j))])+\
222	FFABS(srcp[-srcs+DELTA(j) ] - srcp[+srcs+DELTA( -(j))])+\
223	FFABS(srcp[-srcs+DELTA(1+(j)) ] - srcp[+srcs+DELTA( 1-(j))])
224
225	#define GET_SCORE(j)\
226	FFABS(srcp[-srcs-1+(j)] - srcp[+srcs-1-(j)])+\
227	FFABS(srcp[-srcs +(j)] - srcp[+srcs -(j)])+\
228	FFABS(srcp[-srcs+1+(j)] - srcp[+srcs+1-(j)])
229
230	#define CHECK_EDGE(j)\
231	{ int score = GET_SCORE_EDGE(j);\
232	if (score < spatial_score){\
233	spatial_score = score;\
234	diff0 = filp[-fils+DELTA(j)] - srcp[-srcs+DELTA(j)];\
235	diff1 = filp[+fils+DELTA(-(j))] - srcp[+srcs+DELTA(-(j))];\
236
237	#define CHECK(j)\
238	{ int score = GET_SCORE(j);\
239	if (score < spatial_score){\
240	spatial_score= score;\
241	diff0 = filp[-fils+(j)] - srcp[-srcs+(j)];\
242	diff1 = filp[+fils-(j)] - srcp[+srcs-(j)];\
243
244	if (is_edge) {
245	int spatial_score = GET_SCORE_EDGE(0) - 1;
246	CHECK_EDGE(-1) CHECK_EDGE(-2) }} }}
247	CHECK_EDGE( 1) CHECK_EDGE( 2) }} }}
248	} else {
249	int spatial_score = GET_SCORE(0) - 1;
250	CHECK(-1) CHECK(-2) }} }}
251	CHECK( 1) CHECK( 2) }} }}
252	}
253
254
255	if (diff0 + diff1 > 0)
256	temp -= (diff0 + diff1 - FFABS(FFABS(diff0) - FFABS(diff1)) / 2) / 2;
257	else
258	temp -= (diff0 + diff1 + FFABS(FFABS(diff0) - FFABS(diff1)) / 2) / 2;
259	filp = dstp = temp > 255U ? ~(temp>>31) : temp;
260	} else {
261	dstp = filp;
262	}
263	}
264	}
265	}
266
267	for (y = 0; y < h; y++) {
268	if (!((y ^ mcdeint->parity) & 1)) {
269	for (x = 0; x < w; x++) {
270	frame_dec->data[i][x + y*fils] =
271	outpic ->data[i][x + ydsts] = inpic->data[i][x + ysrcs];
272	}
273	}
274	}
275	}
276	mcdeint->parity ^= 1;
277
278	end:
279	av_free_packet(&pkt);
280	av_frame_free(&inpic);
281	if (ret < 0) {
282	av_frame_free(&outpic);
283	return ret;
284	}
285	return ff_filter_frame(outlink, outpic);
286	}
287
288	static const AVFilterPad mcdeint_inputs[] = {
289	{
290	.name = "default",
291	.type = AVMEDIA_TYPE_VIDEO,
292	.filter_frame = filter_frame,
293	.config_props = config_props,
294	},
295	{ NULL }
296	};
297
298	static const AVFilterPad mcdeint_outputs[] = {
299	{
300	.name = "default",
301	.type = AVMEDIA_TYPE_VIDEO,
302	},
303	{ NULL }
304	};
305
306	AVFilter ff_vf_mcdeint = {
307	.name = "mcdeint",
308	.description = NULL_IF_CONFIG_SMALL("Apply motion compensating deinterlacing."),
309	.priv_size = sizeof(MCDeintContext),
310	.uninit = uninit,
311	.query_formats = query_formats,
312	.inputs = mcdeint_inputs,
313	.outputs = mcdeint_outputs,
314	.priv_class = &mcdeint_class,
315	};