1/* 2 * Copyright (c) 2012 Jeremy Tran 3 * Copyright (c) 2004 Tobias Diedrich 4 * Copyright (c) 2003 Donald A. Graft 5 * 6 * This file is part of FFmpeg. 7 * 8 * FFmpeg is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * FFmpeg is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License along 19 * with FFmpeg; if not, write to the Free Software Foundation, Inc., 20 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 21 */ 22 23/** 24 * @file 25 * Kernel Deinterlacer 26 * Ported from MPlayer libmpcodecs/vf_kerndeint.c. 27 */ 28 29#include "libavutil/imgutils.h" 30#include "libavutil/intreadwrite.h" 31#include "libavutil/opt.h" 32#include "libavutil/pixdesc.h" 33 34#include "avfilter.h" 35#include "formats.h" 36#include "internal.h" 37 38typedef struct { 39 const AVClass *class; 40 int frame; ///< frame count, starting from 0 41 int thresh, map, order, sharp, twoway; 42 int vsub; 43 int is_packed_rgb; 44 uint8_t *tmp_data [4]; ///< temporary plane data buffer 45 int tmp_linesize[4]; ///< temporary plane byte linesize 46 int tmp_bwidth [4]; ///< temporary plane byte width 47} KerndeintContext; 48 49#define OFFSET(x) offsetof(KerndeintContext, x) 50#define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM 51static const AVOption kerndeint_options[] = { 52 { "thresh", "set the threshold", OFFSET(thresh), AV_OPT_TYPE_INT, {.i64=10}, 0, 255, FLAGS }, 53 { "map", "set the map", OFFSET(map), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS }, 54 { "order", "set the order", OFFSET(order), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS }, 55 { "sharp", "enable sharpening", OFFSET(sharp), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS }, 56 { "twoway", "enable twoway", OFFSET(twoway), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS }, 57 { NULL } 58}; 59 60AVFILTER_DEFINE_CLASS(kerndeint); 61 62static av_cold void uninit(AVFilterContext *ctx) 63{ 64 KerndeintContext *kerndeint = ctx->priv; 65 66 av_free(kerndeint->tmp_data[0]); 67} 68 69static int query_formats(AVFilterContext *ctx) 70{ 71 static const enum PixelFormat pix_fmts[] = { 72 AV_PIX_FMT_YUV420P, 73 AV_PIX_FMT_YUYV422, 74 AV_PIX_FMT_ARGB, AV_PIX_FMT_0RGB, 75 AV_PIX_FMT_ABGR, AV_PIX_FMT_0BGR, 76 AV_PIX_FMT_RGBA, AV_PIX_FMT_RGB0, 77 AV_PIX_FMT_BGRA, AV_PIX_FMT_BGR0, 78 AV_PIX_FMT_NONE 79 }; 80 81 ff_set_common_formats(ctx, ff_make_format_list(pix_fmts)); 82 83 return 0; 84} 85 86static int config_props(AVFilterLink *inlink) 87{ 88 KerndeintContext *kerndeint = inlink->dst->priv; 89 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format); 90 int ret; 91 92 kerndeint->is_packed_rgb = av_pix_fmt_desc_get(inlink->format)->flags & AV_PIX_FMT_FLAG_RGB; 93 kerndeint->vsub = desc->log2_chroma_h; 94 95 ret = av_image_alloc(kerndeint->tmp_data, kerndeint->tmp_linesize, 96 inlink->w, inlink->h, inlink->format, 16); 97 if (ret < 0) 98 return ret; 99 memset(kerndeint->tmp_data[0], 0, ret); 100 101 if ((ret = av_image_fill_linesizes(kerndeint->tmp_bwidth, inlink->format, inlink->w)) < 0) 102 return ret; 103 104 return 0; 105} 106 107static int filter_frame(AVFilterLink *inlink, AVFrame *inpic) 108{ 109 KerndeintContext *kerndeint = inlink->dst->priv; 110 AVFilterLink *outlink = inlink->dst->outputs[0]; 111 AVFrame *outpic; 112 const uint8_t *prvp; ///< Previous field's pixel line number n 113 const uint8_t *prvpp; ///< Previous field's pixel line number (n - 1) 114 const uint8_t *prvpn; ///< Previous field's pixel line number (n + 1) 115 const uint8_t *prvppp; ///< Previous field's pixel line number (n - 2) 116 const uint8_t *prvpnn; ///< Previous field's pixel line number (n + 2) 117 const uint8_t *prvp4p; ///< Previous field's pixel line number (n - 4) 118 const uint8_t *prvp4n; ///< Previous field's pixel line number (n + 4) 119 120 const uint8_t *srcp; ///< Current field's pixel line number n 121 const uint8_t *srcpp; ///< Current field's pixel line number (n - 1) 122 const uint8_t *srcpn; ///< Current field's pixel line number (n + 1) 123 const uint8_t *srcppp; ///< Current field's pixel line number (n - 2) 124 const uint8_t *srcpnn; ///< Current field's pixel line number (n + 2) 125 const uint8_t *srcp3p; ///< Current field's pixel line number (n - 3) 126 const uint8_t *srcp3n; ///< Current field's pixel line number (n + 3) 127 const uint8_t *srcp4p; ///< Current field's pixel line number (n - 4) 128 const uint8_t *srcp4n; ///< Current field's pixel line number (n + 4) 129 130 uint8_t *dstp, *dstp_saved; 131 const uint8_t *srcp_saved; 132 133 int src_linesize, psrc_linesize, dst_linesize, bwidth; 134 int x, y, plane, val, hi, lo, g, h, n = kerndeint->frame++; 135 double valf; 136 137 const int thresh = kerndeint->thresh; 138 const int order = kerndeint->order; 139 const int map = kerndeint->map; 140 const int sharp = kerndeint->sharp; 141 const int twoway = kerndeint->twoway; 142 143 const int is_packed_rgb = kerndeint->is_packed_rgb; 144 145 outpic = ff_get_video_buffer(outlink, outlink->w, outlink->h); 146 if (!outpic) { 147 av_frame_free(&inpic); 148 return AVERROR(ENOMEM); 149 } 150 av_frame_copy_props(outpic, inpic); 151 outpic->interlaced_frame = 0; 152 153 for (plane = 0; plane < 4 && inpic->data[plane] && inpic->linesize[plane]; plane++) { 154 h = plane == 0 ? inlink->h : FF_CEIL_RSHIFT(inlink->h, kerndeint->vsub); 155 bwidth = kerndeint->tmp_bwidth[plane]; 156 157 srcp = srcp_saved = inpic->data[plane]; 158 src_linesize = inpic->linesize[plane]; 159 psrc_linesize = kerndeint->tmp_linesize[plane]; 160 dstp = dstp_saved = outpic->data[plane]; 161 dst_linesize = outpic->linesize[plane]; 162 srcp = srcp_saved + (1 - order) * src_linesize; 163 dstp = dstp_saved + (1 - order) * dst_linesize; 164 165 for (y = 0; y < h; y += 2) { 166 memcpy(dstp, srcp, bwidth); 167 srcp += 2 * src_linesize; 168 dstp += 2 * dst_linesize; 169 } 170 171 // Copy through the lines that will be missed below. 172 memcpy(dstp_saved + order * dst_linesize, srcp_saved + (1 - order) * src_linesize, bwidth); 173 memcpy(dstp_saved + (2 + order ) * dst_linesize, srcp_saved + (3 - order) * src_linesize, bwidth); 174 memcpy(dstp_saved + (h - 2 + order) * dst_linesize, srcp_saved + (h - 1 - order) * src_linesize, bwidth); 175 memcpy(dstp_saved + (h - 4 + order) * dst_linesize, srcp_saved + (h - 3 - order) * src_linesize, bwidth); 176 177 /* For the other field choose adaptively between using the previous field 178 or the interpolant from the current field. */ 179 prvp = kerndeint->tmp_data[plane] + 5 * psrc_linesize - (1 - order) * psrc_linesize; 180 prvpp = prvp - psrc_linesize; 181 prvppp = prvp - 2 * psrc_linesize; 182 prvp4p = prvp - 4 * psrc_linesize; 183 prvpn = prvp + psrc_linesize; 184 prvpnn = prvp + 2 * psrc_linesize; 185 prvp4n = prvp + 4 * psrc_linesize; 186 187 srcp = srcp_saved + 5 * src_linesize - (1 - order) * src_linesize; 188 srcpp = srcp - src_linesize; 189 srcppp = srcp - 2 * src_linesize; 190 srcp3p = srcp - 3 * src_linesize; 191 srcp4p = srcp - 4 * src_linesize; 192 193 srcpn = srcp + src_linesize; 194 srcpnn = srcp + 2 * src_linesize; 195 srcp3n = srcp + 3 * src_linesize; 196 srcp4n = srcp + 4 * src_linesize; 197 198 dstp = dstp_saved + 5 * dst_linesize - (1 - order) * dst_linesize; 199 200 for (y = 5 - (1 - order); y <= h - 5 - (1 - order); y += 2) { 201 for (x = 0; x < bwidth; x++) { 202 if (thresh == 0 || n == 0 || 203 (abs((int)prvp[x] - (int)srcp[x]) > thresh) || 204 (abs((int)prvpp[x] - (int)srcpp[x]) > thresh) || 205 (abs((int)prvpn[x] - (int)srcpn[x]) > thresh)) { 206 if (map) { 207 g = x & ~3; 208 209 if (is_packed_rgb) { 210 AV_WB32(dstp + g, 0xffffffff); 211 x = g + 3; 212 } else if (inlink->format == AV_PIX_FMT_YUYV422) { 213 // y <- 235, u <- 128, y <- 235, v <- 128 214 AV_WB32(dstp + g, 0xeb80eb80); 215 x = g + 3; 216 } else { 217 dstp[x] = plane == 0 ? 235 : 128; 218 } 219 } else { 220 if (is_packed_rgb) { 221 hi = 255; 222 lo = 0; 223 } else if (inlink->format == AV_PIX_FMT_YUYV422) { 224 hi = x & 1 ? 240 : 235; 225 lo = 16; 226 } else { 227 hi = plane == 0 ? 235 : 240; 228 lo = 16; 229 } 230 231 if (sharp) { 232 if (twoway) { 233 valf = + 0.526 * ((int)srcpp[x] + (int)srcpn[x]) 234 + 0.170 * ((int)srcp[x] + (int)prvp[x]) 235 - 0.116 * ((int)srcppp[x] + (int)srcpnn[x] + (int)prvppp[x] + (int)prvpnn[x]) 236 - 0.026 * ((int)srcp3p[x] + (int)srcp3n[x]) 237 + 0.031 * ((int)srcp4p[x] + (int)srcp4n[x] + (int)prvp4p[x] + (int)prvp4n[x]); 238 } else { 239 valf = + 0.526 * ((int)srcpp[x] + (int)srcpn[x]) 240 + 0.170 * ((int)prvp[x]) 241 - 0.116 * ((int)prvppp[x] + (int)prvpnn[x]) 242 - 0.026 * ((int)srcp3p[x] + (int)srcp3n[x]) 243 + 0.031 * ((int)prvp4p[x] + (int)prvp4p[x]); 244 } 245 dstp[x] = av_clip(valf, lo, hi); 246 } else { 247 if (twoway) { 248 val = (8 * ((int)srcpp[x] + (int)srcpn[x]) + 2 * ((int)srcp[x] + (int)prvp[x]) 249 - (int)(srcppp[x]) - (int)(srcpnn[x]) 250 - (int)(prvppp[x]) - (int)(prvpnn[x])) >> 4; 251 } else { 252 val = (8 * ((int)srcpp[x] + (int)srcpn[x]) + 2 * ((int)prvp[x]) 253 - (int)(prvppp[x]) - (int)(prvpnn[x])) >> 4; 254 } 255 dstp[x] = av_clip(val, lo, hi); 256 } 257 } 258 } else { 259 dstp[x] = srcp[x]; 260 } 261 } 262 prvp += 2 * psrc_linesize; 263 prvpp += 2 * psrc_linesize; 264 prvppp += 2 * psrc_linesize; 265 prvpn += 2 * psrc_linesize; 266 prvpnn += 2 * psrc_linesize; 267 prvp4p += 2 * psrc_linesize; 268 prvp4n += 2 * psrc_linesize; 269 srcp += 2 * src_linesize; 270 srcpp += 2 * src_linesize; 271 srcppp += 2 * src_linesize; 272 srcp3p += 2 * src_linesize; 273 srcp4p += 2 * src_linesize; 274 srcpn += 2 * src_linesize; 275 srcpnn += 2 * src_linesize; 276 srcp3n += 2 * src_linesize; 277 srcp4n += 2 * src_linesize; 278 dstp += 2 * dst_linesize; 279 } 280 281 srcp = inpic->data[plane]; 282 dstp = kerndeint->tmp_data[plane]; 283 av_image_copy_plane(dstp, psrc_linesize, srcp, src_linesize, bwidth, h); 284 } 285 286 av_frame_free(&inpic); 287 return ff_filter_frame(outlink, outpic); 288} 289 290static const AVFilterPad kerndeint_inputs[] = { 291 { 292 .name = "default", 293 .type = AVMEDIA_TYPE_VIDEO, 294 .filter_frame = filter_frame, 295 .config_props = config_props, 296 }, 297 { NULL } 298}; 299 300static const AVFilterPad kerndeint_outputs[] = { 301 { 302 .name = "default", 303 .type = AVMEDIA_TYPE_VIDEO, 304 }, 305 { NULL } 306}; 307 308 309AVFilter ff_vf_kerndeint = { 310 .name = "kerndeint", 311 .description = NULL_IF_CONFIG_SMALL("Apply kernel deinterlacing to the input."), 312 .priv_size = sizeof(KerndeintContext), 313 .priv_class = &kerndeint_class, 314 .uninit = uninit, 315 .query_formats = query_formats, 316 .inputs = kerndeint_inputs, 317 .outputs = kerndeint_outputs, 318}; 319