Commit | Line | Data |
---|---|---|
2ba45a60 DM |
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 | ||
38 | typedef 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 | |
51 | static 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 | ||
60 | AVFILTER_DEFINE_CLASS(kerndeint); | |
61 | ||
62 | static av_cold void uninit(AVFilterContext *ctx) | |
63 | { | |
64 | KerndeintContext *kerndeint = ctx->priv; | |
65 | ||
66 | av_free(kerndeint->tmp_data[0]); | |
67 | } | |
68 | ||
69 | static 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 | ||
86 | static 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 | ||
107 | static 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_saved = inpic->data[plane]; | |
158 | src_linesize = inpic->linesize[plane]; | |
159 | psrc_linesize = kerndeint->tmp_linesize[plane]; | |
160 | 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 | ||
290 | static 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 | ||
300 | static const AVFilterPad kerndeint_outputs[] = { | |
301 | { | |
302 | .name = "default", | |
303 | .type = AVMEDIA_TYPE_VIDEO, | |
304 | }, | |
305 | { NULL } | |
306 | }; | |
307 | ||
308 | ||
309 | AVFilter 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 | }; |