FFmpeg coverage

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavfilter/vf_bwdif.c	Lines:	0	134	0.0 %
Date:	2020-10-23 17:01:47	Branches:	0	106	0.0 %


/*
 * BobWeaver Deinterlacing Filter
 * Copyright (C) 2016 Thomas Mundt <loudmax@yahoo.de>
 *
 * Based on YADIF (Yet Another Deinterlacing Filter)
 * Copyright (C) 2006-2011 Michael Niedermayer <michaelni@gmx.at>
 *               2010      James Darnley <james.darnley@gmail.com>
 *
 * With use of Weston 3 Field Deinterlacing Filter algorithm
 * Copyright (C) 2012 British Broadcasting Corporation, All Rights Reserved
 * Author of de-interlace algorithm: Jim Easterbrook for BBC R&D
 * Based on the process described by Martin Weston for BBC R&D
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser 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
 */

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

/*
 * Filter coefficients coef_lf and coef_hf taken from BBC PH-2071 (Weston 3 Field Deinterlacer).
 * Used when there is spatial and temporal interpolation.
 * Filter coefficients coef_sp are used when there is spatial interpolation only.
 * Adjusted for matching visual sharpness impression of spatial and temporal interpolation.
 */
static const uint16_t coef_lf[2] = { 4309, 213 };
static const uint16_t coef_hf[3] = { 5570, 3801, 1016 };
static const uint16_t coef_sp[2] = { 5077, 981 };

typedef struct ThreadData {
    AVFrame *frame;
    int plane;
    int w, h;
    int parity;
    int tff;
} ThreadData;

#define FILTER_INTRA() \
    for (x = 0; x < w; x++) { \
        interpol = (coef_sp[0] * (cur[mrefs] + cur[prefs]) - coef_sp[1] * (cur[mrefs3] + cur[prefs3])) >> 13; \
        dst[0] = av_clip(interpol, 0, clip_max); \
 \
        dst++; \
        cur++; \
    }

#define FILTER1() \
    for (x = 0; x < w; x++) { \
        int c = cur[mrefs]; \
        int d = (prev2[0] + next2[0]) >> 1; \
        int e = cur[prefs]; \
        int temporal_diff0 = FFABS(prev2[0] - next2[0]); \
        int temporal_diff1 =(FFABS(prev[mrefs] - c) + FFABS(prev[prefs] - e)) >> 1; \
        int temporal_diff2 =(FFABS(next[mrefs] - c) + FFABS(next[prefs] - e)) >> 1; \
        int diff = FFMAX3(temporal_diff0 >> 1, temporal_diff1, temporal_diff2); \
 \
        if (!diff) { \
            dst[0] = d; \
        } else {

#define SPAT_CHECK() \
            int b = ((prev2[mrefs2] + next2[mrefs2]) >> 1) - c; \
            int f = ((prev2[prefs2] + next2[prefs2]) >> 1) - e; \
            int dc = d - c; \
            int de = d - e; \
            int max = FFMAX3(de, dc, FFMIN(b, f)); \
            int min = FFMIN3(de, dc, FFMAX(b, f)); \
            diff = FFMAX3(diff, min, -max);

#define FILTER_LINE() \
            SPAT_CHECK() \
            if (FFABS(c - e) > temporal_diff0) { \
                interpol = (((coef_hf[0] * (prev2[0] + next2[0]) \
                    - coef_hf[1] * (prev2[mrefs2] + next2[mrefs2] + prev2[prefs2] + next2[prefs2]) \
                    + coef_hf[2] * (prev2[mrefs4] + next2[mrefs4] + prev2[prefs4] + next2[prefs4])) >> 2) \
                    + coef_lf[0] * (c + e) - coef_lf[1] * (cur[mrefs3] + cur[prefs3])) >> 13; \
            } else { \
                interpol = (coef_sp[0] * (c + e) - coef_sp[1] * (cur[mrefs3] + cur[prefs3])) >> 13; \
            }

#define FILTER_EDGE() \
            if (spat) { \
                SPAT_CHECK() \
            } \
            interpol = (c + e) >> 1;

#define FILTER2() \
            if (interpol > d + diff) \
                interpol = d + diff; \
            else if (interpol < d - diff) \
                interpol = d - diff; \
 \
            dst[0] = av_clip(interpol, 0, clip_max); \
        } \
 \
        dst++; \
        cur++; \
        prev++; \
        next++; \
        prev2++; \
        next2++; \
    }

static void filter_intra(void *dst1, void *cur1, int w, int prefs, int mrefs,
                         int prefs3, int mrefs3, int parity, int clip_max)
{
    uint8_t *dst = dst1;
    uint8_t *cur = cur1;
    int interpol, x;

    FILTER_INTRA()
}

static void filter_line_c(void *dst1, void *prev1, void *cur1, void *next1,
                          int w, int prefs, int mrefs, int prefs2, int mrefs2,
                          int prefs3, int mrefs3, int prefs4, int mrefs4,
                          int parity, int clip_max)
{
    uint8_t *dst   = dst1;
    uint8_t *prev  = prev1;
    uint8_t *cur   = cur1;
    uint8_t *next  = next1;
    uint8_t *prev2 = parity ? prev : cur ;
    uint8_t *next2 = parity ? cur  : next;
    int interpol, x;

    FILTER1()
    FILTER_LINE()
    FILTER2()
}

static void filter_edge(void *dst1, void *prev1, void *cur1, void *next1,
                        int w, int prefs, int mrefs, int prefs2, int mrefs2,
                        int parity, int clip_max, int spat)
{
    uint8_t *dst   = dst1;
    uint8_t *prev  = prev1;
    uint8_t *cur   = cur1;
    uint8_t *next  = next1;
    uint8_t *prev2 = parity ? prev : cur ;
    uint8_t *next2 = parity ? cur  : next;
    int interpol, x;

    FILTER1()
    FILTER_EDGE()
    FILTER2()
}

static void filter_intra_16bit(void *dst1, void *cur1, int w, int prefs, int mrefs,
                               int prefs3, int mrefs3, int parity, int clip_max)
{
    uint16_t *dst = dst1;
    uint16_t *cur = cur1;
    int interpol, x;

    FILTER_INTRA()
}

static void filter_line_c_16bit(void *dst1, void *prev1, void *cur1, void *next1,
                                int w, int prefs, int mrefs, int prefs2, int mrefs2,
                                int prefs3, int mrefs3, int prefs4, int mrefs4,
                                int parity, int clip_max)
{
    uint16_t *dst   = dst1;
    uint16_t *prev  = prev1;
    uint16_t *cur   = cur1;
    uint16_t *next  = next1;
    uint16_t *prev2 = parity ? prev : cur ;
    uint16_t *next2 = parity ? cur  : next;
    int interpol, x;

    FILTER1()
    FILTER_LINE()
    FILTER2()
}

static void filter_edge_16bit(void *dst1, void *prev1, void *cur1, void *next1,
                              int w, int prefs, int mrefs, int prefs2, int mrefs2,
                              int parity, int clip_max, int spat)
{
    uint16_t *dst   = dst1;
    uint16_t *prev  = prev1;
    uint16_t *cur   = cur1;
    uint16_t *next  = next1;
    uint16_t *prev2 = parity ? prev : cur ;
    uint16_t *next2 = parity ? cur  : next;
    int interpol, x;

    FILTER1()
    FILTER_EDGE()
    FILTER2()
}

static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
{
    BWDIFContext *s = ctx->priv;
    YADIFContext *yadif = &s->yadif;
    ThreadData *td  = arg;
    int linesize = yadif->cur->linesize[td->plane];
    int clip_max = (1 << (yadif->csp->comp[td->plane].depth)) - 1;
    int df = (yadif->csp->comp[td->plane].depth + 7) / 8;
    int refs = linesize / df;
    int slice_start = (td->h *  jobnr   ) / nb_jobs;
    int slice_end   = (td->h * (jobnr+1)) / nb_jobs;
    int y;

    for (y = slice_start; y < slice_end; y++) {
        if ((y ^ td->parity) & 1) {
            uint8_t *prev = &yadif->prev->data[td->plane][y * linesize];
            uint8_t *cur  = &yadif->cur ->data[td->plane][y * linesize];
            uint8_t *next = &yadif->next->data[td->plane][y * linesize];
            uint8_t *dst  = &td->frame->data[td->plane][y * td->frame->linesize[td->plane]];
            if (yadif->current_field == YADIF_FIELD_END) {
                s->filter_intra(dst, cur, td->w, (y + df) < td->h ? refs : -refs,
                                y > (df - 1) ? -refs : refs,
                                (y + 3*df) < td->h ? 3 * refs : -refs,
                                y > (3*df - 1) ? -3 * refs : refs,
                                td->parity ^ td->tff, clip_max);
            } else if ((y < 4) || ((y + 5) > td->h)) {
                s->filter_edge(dst, prev, cur, next, td->w,
                               (y + df) < td->h ? refs : -refs,
                               y > (df - 1) ? -refs : refs,
                               refs << 1, -(refs << 1),
                               td->parity ^ td->tff, clip_max,
                               (y < 2) || ((y + 3) > td->h) ? 0 : 1);
            } else {
                s->filter_line(dst, prev, cur, next, td->w,
                               refs, -refs, refs << 1, -(refs << 1),
                               3 * refs, -3 * refs, refs << 2, -(refs << 2),
                               td->parity ^ td->tff, clip_max);
            }
        } else {
            memcpy(&td->frame->data[td->plane][y * td->frame->linesize[td->plane]],
                   &yadif->cur->data[td->plane][y * linesize], td->w * df);
        }
    }
    return 0;
}

static void filter(AVFilterContext *ctx, AVFrame *dstpic,
                   int parity, int tff)
{
    BWDIFContext *bwdif = ctx->priv;
    YADIFContext *yadif = &bwdif->yadif;
    ThreadData td = { .frame = dstpic, .parity = parity, .tff = tff };
    int i;

    for (i = 0; i < yadif->csp->nb_components; i++) {
        int w = dstpic->width;
        int h = dstpic->height;

        if (i == 1 || i == 2) {
            w = AV_CEIL_RSHIFT(w, yadif->csp->log2_chroma_w);
            h = AV_CEIL_RSHIFT(h, yadif->csp->log2_chroma_h);
        }

        td.w     = w;
        td.h     = h;
        td.plane = i;

        ctx->internal->execute(ctx, filter_slice, &td, NULL, FFMIN(h, ff_filter_get_nb_threads(ctx)));
    }
    if (yadif->current_field == YADIF_FIELD_END) {
        yadif->current_field = YADIF_FIELD_NORMAL;
    }

    emms_c();
}

static av_cold void uninit(AVFilterContext *ctx)
{
    BWDIFContext *bwdif = ctx->priv;
    YADIFContext *yadif = &bwdif->yadif;

    av_frame_free(&yadif->prev);
    av_frame_free(&yadif->cur );
    av_frame_free(&yadif->next);
}

static int query_formats(AVFilterContext *ctx)
{
    static const enum AVPixelFormat pix_fmts[] = {
        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_YUVJ411P, AV_PIX_FMT_YUVJ420P,
        AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
        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_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
        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_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,
        AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9,
        AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10,
        AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,
        AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
        AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
        AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP16,
        AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16,
        AV_PIX_FMT_NONE
    };

    AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
    if (!fmts_list)
        return AVERROR(ENOMEM);

    return ff_set_common_formats(ctx, fmts_list);
}

static int config_props(AVFilterLink *link)
{
    AVFilterContext *ctx = link->src;
    BWDIFContext *s = link->src->priv;
    YADIFContext *yadif = &s->yadif;

    link->time_base.num = link->src->inputs[0]->time_base.num;
    link->time_base.den = link->src->inputs[0]->time_base.den * 2;
    link->w             = link->src->inputs[0]->w;
    link->h             = link->src->inputs[0]->h;

    if(yadif->mode&1)
        link->frame_rate = av_mul_q(link->src->inputs[0]->frame_rate, (AVRational){2,1});

    if (link->w < 3 || link->h < 4) {
        av_log(ctx, AV_LOG_ERROR, "Video of less than 3 columns or 4 lines is not supported\n");
        return AVERROR(EINVAL);
    }

    yadif->csp = av_pix_fmt_desc_get(link->format);
    yadif->filter = filter;
    if (yadif->csp->comp[0].depth > 8) {
        s->filter_intra = filter_intra_16bit;
        s->filter_line  = filter_line_c_16bit;
        s->filter_edge  = filter_edge_16bit;
    } else {
        s->filter_intra = filter_intra;
        s->filter_line  = filter_line_c;
        s->filter_edge  = filter_edge;
    }

    if (ARCH_X86)
        ff_bwdif_init_x86(s);

    return 0;
}


#define OFFSET(x) offsetof(YADIFContext, 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 bwdif_options[] = {
    { "mode",   "specify the interlacing mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=YADIF_MODE_SEND_FIELD}, 0, 1, FLAGS, "mode"},
    CONST("send_frame", "send one frame for each frame", YADIF_MODE_SEND_FRAME, "mode"),
    CONST("send_field", "send one frame for each field", YADIF_MODE_SEND_FIELD, "mode"),

    { "parity", "specify the assumed picture field parity", OFFSET(parity), AV_OPT_TYPE_INT, {.i64=YADIF_PARITY_AUTO}, -1, 1, FLAGS, "parity" },
    CONST("tff",  "assume top field first",    YADIF_PARITY_TFF,  "parity"),
    CONST("bff",  "assume bottom field first", YADIF_PARITY_BFF,  "parity"),
    CONST("auto", "auto detect parity",        YADIF_PARITY_AUTO, "parity"),

    { "deint", "specify which frames to deinterlace", OFFSET(deint), AV_OPT_TYPE_INT, {.i64=YADIF_DEINT_ALL}, 0, 1, FLAGS, "deint" },
    CONST("all",        "deinterlace all frames",                       YADIF_DEINT_ALL,        "deint"),
    CONST("interlaced", "only deinterlace frames marked as interlaced", YADIF_DEINT_INTERLACED, "deint"),

    { NULL }
};

AVFILTER_DEFINE_CLASS(bwdif);

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

static const AVFilterPad avfilter_vf_bwdif_outputs[] = {
    {
        .name          = "default",
        .type          = AVMEDIA_TYPE_VIDEO,
        .request_frame = ff_yadif_request_frame,
        .config_props  = config_props,
    },
    { NULL }
};

AVFilter ff_vf_bwdif = {
    .name          = "bwdif",
    .description   = NULL_IF_CONFIG_SMALL("Deinterlace the input image."),
    .priv_size     = sizeof(BWDIFContext),
    .priv_class    = &bwdif_class,
    .uninit        = uninit,
    .query_formats = query_formats,
    .inputs        = avfilter_vf_bwdif_inputs,
    .outputs       = avfilter_vf_bwdif_outputs,
    .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,
};


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			/*
2			* BobWeaver Deinterlacing Filter
3			* Copyright (C) 2016 Thomas Mundt <loudmax@yahoo.de>
4			*
5			* Based on YADIF (Yet Another Deinterlacing Filter)
6			* Copyright (C) 2006-2011 Michael Niedermayer <michaelni@gmx.at>
7			* 2010 James Darnley <james.darnley@gmail.com>
8			*
9			* With use of Weston 3 Field Deinterlacing Filter algorithm
10			* Copyright (C) 2012 British Broadcasting Corporation, All Rights Reserved
11			* Author of de-interlace algorithm: Jim Easterbrook for BBC R&D
12			* Based on the process described by Martin Weston for BBC R&D
13			*
14			* This file is part of FFmpeg.
15			*
16			* FFmpeg is free software; you can redistribute it and/or
17			* modify it under the terms of the GNU Lesser General Public
18			* License as published by the Free Software Foundation; either
19			* version 2.1 of the License, or (at your option) any later version.
20			*
21			* FFmpeg is distributed in the hope that it will be useful,
22			* but WITHOUT ANY WARRANTY; without even the implied warranty of
23			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
24			* Lesser General Public License for more details.
25			*
26			* You should have received a copy of the GNU Lesser General Public
27			* License along with FFmpeg; if not, write to the Free Software
28			* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
29			*/
30
31			#include "libavutil/avassert.h"
32			#include "libavutil/common.h"
33			#include "libavutil/opt.h"
34			#include "libavutil/pixdesc.h"
35			#include "libavutil/imgutils.h"
36			#include "avfilter.h"
37			#include "formats.h"
38			#include "internal.h"
39			#include "video.h"
40			#include "bwdif.h"
41
42			/*
43			* Filter coefficients coef_lf and coef_hf taken from BBC PH-2071 (Weston 3 Field Deinterlacer).
44			* Used when there is spatial and temporal interpolation.
45			* Filter coefficients coef_sp are used when there is spatial interpolation only.
46			* Adjusted for matching visual sharpness impression of spatial and temporal interpolation.
47			*/
48			static const uint16_t coef_lf[2] = { 4309, 213 };
49			static const uint16_t coef_hf[3] = { 5570, 3801, 1016 };
50			static const uint16_t coef_sp[2] = { 5077, 981 };
51
52			typedef struct ThreadData {
53			AVFrame *frame;
54			int plane;
55			int w, h;
56			int parity;
57			int tff;
58			} ThreadData;
59
60			#define FILTER_INTRA() \
61			for (x = 0; x < w; x++) { \
62			interpol = (coef_sp[0] * (cur[mrefs] + cur[prefs]) - coef_sp[1] * (cur[mrefs3] + cur[prefs3])) >> 13; \
63			dst[0] = av_clip(interpol, 0, clip_max); \
64			\
65			dst++; \
66			cur++; \
67			}
68
69			#define FILTER1() \
70			for (x = 0; x < w; x++) { \
71			int c = cur[mrefs]; \
72			int d = (prev2[0] + next2[0]) >> 1; \
73			int e = cur[prefs]; \
74			int temporal_diff0 = FFABS(prev2[0] - next2[0]); \
75			int temporal_diff1 =(FFABS(prev[mrefs] - c) + FFABS(prev[prefs] - e)) >> 1; \
76			int temporal_diff2 =(FFABS(next[mrefs] - c) + FFABS(next[prefs] - e)) >> 1; \
77			int diff = FFMAX3(temporal_diff0 >> 1, temporal_diff1, temporal_diff2); \
78			\
79			if (!diff) { \
80			dst[0] = d; \
81			} else {
82
83			#define SPAT_CHECK() \
84			int b = ((prev2[mrefs2] + next2[mrefs2]) >> 1) - c; \
85			int f = ((prev2[prefs2] + next2[prefs2]) >> 1) - e; \
86			int dc = d - c; \
87			int de = d - e; \
88			int max = FFMAX3(de, dc, FFMIN(b, f)); \
89			int min = FFMIN3(de, dc, FFMAX(b, f)); \
90			diff = FFMAX3(diff, min, -max);
91
92			#define FILTER_LINE() \
93			SPAT_CHECK() \
94			if (FFABS(c - e) > temporal_diff0) { \
95			interpol = (((coef_hf[0] * (prev2[0] + next2[0]) \
96			- coef_hf[1] * (prev2[mrefs2] + next2[mrefs2] + prev2[prefs2] + next2[prefs2]) \
97			+ coef_hf[2] * (prev2[mrefs4] + next2[mrefs4] + prev2[prefs4] + next2[prefs4])) >> 2) \
98			+ coef_lf[0] * (c + e) - coef_lf[1] * (cur[mrefs3] + cur[prefs3])) >> 13; \
99			} else { \
100			interpol = (coef_sp[0] * (c + e) - coef_sp[1] * (cur[mrefs3] + cur[prefs3])) >> 13; \
101			}
102
103			#define FILTER_EDGE() \
104			if (spat) { \
105			SPAT_CHECK() \
106			} \
107			interpol = (c + e) >> 1;
108
109			#define FILTER2() \
110			if (interpol > d + diff) \
111			interpol = d + diff; \
112			else if (interpol < d - diff) \
113			interpol = d - diff; \
114			\
115			dst[0] = av_clip(interpol, 0, clip_max); \
116			} \
117			\
118			dst++; \
119			cur++; \
120			prev++; \
121			next++; \
122			prev2++; \
123			next2++; \
124			}
125
126			static void filter_intra(void dst1, void cur1, int w, int prefs, int mrefs,
127			int prefs3, int mrefs3, int parity, int clip_max)
128			{
129			uint8_t *dst = dst1;
130			uint8_t *cur = cur1;
131			int interpol, x;
132
133			FILTER_INTRA()
134			}
135
136			static void filter_line_c(void dst1, void prev1, void cur1, void next1,
137			int w, int prefs, int mrefs, int prefs2, int mrefs2,
138			int prefs3, int mrefs3, int prefs4, int mrefs4,
139			int parity, int clip_max)
140			{
141			uint8_t *dst = dst1;
142			uint8_t *prev = prev1;
143			uint8_t *cur = cur1;
144			uint8_t *next = next1;
145			uint8_t *prev2 = parity ? prev : cur ;
146			uint8_t *next2 = parity ? cur : next;
147			int interpol, x;
148
149			FILTER1()
150			FILTER_LINE()
151			FILTER2()
152			}
153
154			static void filter_edge(void dst1, void prev1, void cur1, void next1,
155			int w, int prefs, int mrefs, int prefs2, int mrefs2,
156			int parity, int clip_max, int spat)
157			{
158			uint8_t *dst = dst1;
159			uint8_t *prev = prev1;
160			uint8_t *cur = cur1;
161			uint8_t *next = next1;
162			uint8_t *prev2 = parity ? prev : cur ;
163			uint8_t *next2 = parity ? cur : next;
164			int interpol, x;
165
166			FILTER1()
167			FILTER_EDGE()
168			FILTER2()
169			}
170
171			static void filter_intra_16bit(void dst1, void cur1, int w, int prefs, int mrefs,
172			int prefs3, int mrefs3, int parity, int clip_max)
173			{
174			uint16_t *dst = dst1;
175			uint16_t *cur = cur1;
176			int interpol, x;
177
178			FILTER_INTRA()
179			}
180
181			static void filter_line_c_16bit(void dst1, void prev1, void cur1, void next1,
182			int w, int prefs, int mrefs, int prefs2, int mrefs2,
183			int prefs3, int mrefs3, int prefs4, int mrefs4,
184			int parity, int clip_max)
185			{
186			uint16_t *dst = dst1;
187			uint16_t *prev = prev1;
188			uint16_t *cur = cur1;
189			uint16_t *next = next1;
190			uint16_t *prev2 = parity ? prev : cur ;
191			uint16_t *next2 = parity ? cur : next;
192			int interpol, x;
193
194			FILTER1()
195			FILTER_LINE()
196			FILTER2()
197			}
198
199			static void filter_edge_16bit(void dst1, void prev1, void cur1, void next1,
200			int w, int prefs, int mrefs, int prefs2, int mrefs2,
201			int parity, int clip_max, int spat)
202			{
203			uint16_t *dst = dst1;
204			uint16_t *prev = prev1;
205			uint16_t *cur = cur1;
206			uint16_t *next = next1;
207			uint16_t *prev2 = parity ? prev : cur ;
208			uint16_t *next2 = parity ? cur : next;
209			int interpol, x;
210
211			FILTER1()
212			FILTER_EDGE()
213			FILTER2()
214			}
215
216			static int filter_slice(AVFilterContext ctx, void arg, int jobnr, int nb_jobs)
217			{
218			BWDIFContext *s = ctx->priv;
219			YADIFContext *yadif = &s->yadif;
220			ThreadData *td = arg;
221			int linesize = yadif->cur->linesize[td->plane];
222			int clip_max = (1 << (yadif->csp->comp[td->plane].depth)) - 1;
223			int df = (yadif->csp->comp[td->plane].depth + 7) / 8;
224			int refs = linesize / df;
225			int slice_start = (td->h * jobnr ) / nb_jobs;
226			int slice_end = (td->h * (jobnr+1)) / nb_jobs;
227			int y;
228
229			for (y = slice_start; y < slice_end; y++) {
230			if ((y ^ td->parity) & 1) {
231			uint8_t prev = &yadif->prev->data[td->plane][y linesize];
232			uint8_t cur = &yadif->cur ->data[td->plane][y linesize];
233			uint8_t next = &yadif->next->data[td->plane][y linesize];
234			uint8_t dst = &td->frame->data[td->plane][y td->frame->linesize[td->plane]];
235			if (yadif->current_field == YADIF_FIELD_END) {
236			s->filter_intra(dst, cur, td->w, (y + df) < td->h ? refs : -refs,
237			y > (df - 1) ? -refs : refs,
238			(y + 3df) < td->h ? 3 refs : -refs,
239			y > (3df - 1) ? -3 refs : refs,
240			td->parity ^ td->tff, clip_max);
241			} else if ((y < 4) \|\| ((y + 5) > td->h)) {
242			s->filter_edge(dst, prev, cur, next, td->w,
243			(y + df) < td->h ? refs : -refs,
244			y > (df - 1) ? -refs : refs,
245			refs << 1, -(refs << 1),
246			td->parity ^ td->tff, clip_max,
247			(y < 2) \|\| ((y + 3) > td->h) ? 0 : 1);
248			} else {
249			s->filter_line(dst, prev, cur, next, td->w,
250			refs, -refs, refs << 1, -(refs << 1),
251			3 * refs, -3 * refs, refs << 2, -(refs << 2),
252			td->parity ^ td->tff, clip_max);
253			}
254			} else {
255			memcpy(&td->frame->data[td->plane][y * td->frame->linesize[td->plane]],
256			&yadif->cur->data[td->plane][y * linesize], td->w * df);
257			}
258			}
259			return 0;
260			}
261
262			static void filter(AVFilterContext ctx, AVFrame dstpic,
263			int parity, int tff)
264			{
265			BWDIFContext *bwdif = ctx->priv;
266			YADIFContext *yadif = &bwdif->yadif;
267			ThreadData td = { .frame = dstpic, .parity = parity, .tff = tff };
268			int i;
269
270			for (i = 0; i < yadif->csp->nb_components; i++) {
271			int w = dstpic->width;
272			int h = dstpic->height;
273
274			if (i == 1 \|\| i == 2) {
275			w = AV_CEIL_RSHIFT(w, yadif->csp->log2_chroma_w);
276			h = AV_CEIL_RSHIFT(h, yadif->csp->log2_chroma_h);
277			}
278
279			td.w = w;
280			td.h = h;
281			td.plane = i;
282
283			ctx->internal->execute(ctx, filter_slice, &td, NULL, FFMIN(h, ff_filter_get_nb_threads(ctx)));
284			}
285			if (yadif->current_field == YADIF_FIELD_END) {
286			yadif->current_field = YADIF_FIELD_NORMAL;
287			}
288
289			emms_c();
290			}
291
292			static av_cold void uninit(AVFilterContext *ctx)
293			{
294			BWDIFContext *bwdif = ctx->priv;
295			YADIFContext *yadif = &bwdif->yadif;
296
297			av_frame_free(&yadif->prev);
298			av_frame_free(&yadif->cur );
299			av_frame_free(&yadif->next);
300			}
301
302			static int query_formats(AVFilterContext *ctx)
303			{
304			static const enum AVPixelFormat pix_fmts[] = {
305			AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV420P,
306			AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
307			AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUVJ420P,
308			AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
309			AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
310			AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
311			AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
312			AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
313			AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16,
314			AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,
315			AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9,
316			AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10,
317			AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,
318			AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
319			AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
320			AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP16,
321			AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16,
322			AV_PIX_FMT_NONE
323			};
324
325			AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
326			if (!fmts_list)
327			return AVERROR(ENOMEM);
328
329			return ff_set_common_formats(ctx, fmts_list);
330			}
331
332			static int config_props(AVFilterLink *link)
333			{
334			AVFilterContext *ctx = link->src;
335			BWDIFContext *s = link->src->priv;
336			YADIFContext *yadif = &s->yadif;
337
338			link->time_base.num = link->src->inputs[0]->time_base.num;
339			link->time_base.den = link->src->inputs[0]->time_base.den * 2;
340			link->w = link->src->inputs[0]->w;
341			link->h = link->src->inputs[0]->h;
342
343			if(yadif->mode&1)
344			link->frame_rate = av_mul_q(link->src->inputs[0]->frame_rate, (AVRational){2,1});
345
346			if (link->w < 3 \|\| link->h < 4) {
347			av_log(ctx, AV_LOG_ERROR, "Video of less than 3 columns or 4 lines is not supported\n");
348			return AVERROR(EINVAL);
349			}
350
351			yadif->csp = av_pix_fmt_desc_get(link->format);
352			yadif->filter = filter;
353			if (yadif->csp->comp[0].depth > 8) {
354			s->filter_intra = filter_intra_16bit;
355			s->filter_line = filter_line_c_16bit;
356			s->filter_edge = filter_edge_16bit;
357			} else {
358			s->filter_intra = filter_intra;
359			s->filter_line = filter_line_c;
360			s->filter_edge = filter_edge;
361			}
362
363			if (ARCH_X86)
364			ff_bwdif_init_x86(s);
365
366			return 0;
367			}
368
369
370			#define OFFSET(x) offsetof(YADIFContext, x)
371			#define FLAGS AV_OPT_FLAG_VIDEO_PARAM\|AV_OPT_FLAG_FILTERING_PARAM
372
373			#define CONST(name, help, val, unit) { name, help, 0, AV_OPT_TYPE_CONST, {.i64=val}, INT_MIN, INT_MAX, FLAGS, unit }
374
375			static const AVOption bwdif_options[] = {
376			{ "mode", "specify the interlacing mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=YADIF_MODE_SEND_FIELD}, 0, 1, FLAGS, "mode"},
377			CONST("send_frame", "send one frame for each frame", YADIF_MODE_SEND_FRAME, "mode"),
378			CONST("send_field", "send one frame for each field", YADIF_MODE_SEND_FIELD, "mode"),
379
380			{ "parity", "specify the assumed picture field parity", OFFSET(parity), AV_OPT_TYPE_INT, {.i64=YADIF_PARITY_AUTO}, -1, 1, FLAGS, "parity" },
381			CONST("tff", "assume top field first", YADIF_PARITY_TFF, "parity"),
382			CONST("bff", "assume bottom field first", YADIF_PARITY_BFF, "parity"),
383			CONST("auto", "auto detect parity", YADIF_PARITY_AUTO, "parity"),
384
385			{ "deint", "specify which frames to deinterlace", OFFSET(deint), AV_OPT_TYPE_INT, {.i64=YADIF_DEINT_ALL}, 0, 1, FLAGS, "deint" },
386			CONST("all", "deinterlace all frames", YADIF_DEINT_ALL, "deint"),
387			CONST("interlaced", "only deinterlace frames marked as interlaced", YADIF_DEINT_INTERLACED, "deint"),
388
389			{ NULL }
390			};
391
392			AVFILTER_DEFINE_CLASS(bwdif);
393
394			static const AVFilterPad avfilter_vf_bwdif_inputs[] = {
395			{
396			.name = "default",
397			.type = AVMEDIA_TYPE_VIDEO,
398			.filter_frame = ff_yadif_filter_frame,
399			},
400			{ NULL }
401			};
402
403			static const AVFilterPad avfilter_vf_bwdif_outputs[] = {
404			{
405			.name = "default",
406			.type = AVMEDIA_TYPE_VIDEO,
407			.request_frame = ff_yadif_request_frame,
408			.config_props = config_props,
409			},
410			{ NULL }
411			};
412
413			AVFilter ff_vf_bwdif = {
414			.name = "bwdif",
415			.description = NULL_IF_CONFIG_SMALL("Deinterlace the input image."),
416			.priv_size = sizeof(BWDIFContext),
417			.priv_class = &bwdif_class,
418			.uninit = uninit,
419			.query_formats = query_formats,
420			.inputs = avfilter_vf_bwdif_inputs,
421			.outputs = avfilter_vf_bwdif_outputs,
422			.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL \| AVFILTER_FLAG_SLICE_THREADS,
423			};