blob: 3cfeb20a382ca5caec40ad221c8dfd8e757bf979
1 | /* |
2 | * Copyright (c) 2016 Paul B Mahol |
3 | * |
4 | * This file is part of FFmpeg. |
5 | * |
6 | * FFmpeg is free software; you can redistribute it and/or |
7 | * modify it under the terms of the GNU Lesser General Public |
8 | * License as published by the Free Software Foundation; either |
9 | * version 2.1 of the License, or (at your option) any later version. |
10 | * |
11 | * FFmpeg is distributed in the hope that it will be useful, |
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
14 | * Lesser General Public License for more details. |
15 | * |
16 | * You should have received a copy of the GNU Lesser General Public |
17 | * License along with FFmpeg; if not, write to the Free Software |
18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
19 | */ |
20 | |
21 | #include "libavutil/avassert.h" |
22 | #include "libavutil/imgutils.h" |
23 | #include "libavutil/internal.h" |
24 | #include "libavutil/opt.h" |
25 | #include "libavutil/pixdesc.h" |
26 | #include "avfilter.h" |
27 | #include "internal.h" |
28 | #include "video.h" |
29 | |
30 | typedef struct FieldHintContext { |
31 | const AVClass *class; |
32 | |
33 | char *hint_file_str; |
34 | FILE *hint; |
35 | int mode; |
36 | |
37 | AVFrame *frame[3]; |
38 | |
39 | int64_t line; |
40 | int nb_planes; |
41 | int eof; |
42 | int planewidth[4]; |
43 | int planeheight[4]; |
44 | } FieldHintContext; |
45 | |
46 | #define OFFSET(x) offsetof(FieldHintContext, x) |
47 | #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM |
48 | |
49 | static const AVOption fieldhint_options[] = { |
50 | { "hint", "set hint file", OFFSET(hint_file_str), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS }, |
51 | { "mode", "set hint mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS, "mode" }, |
52 | { "absolute", 0, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "mode" }, |
53 | { "relative", 0, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "mode" }, |
54 | { NULL } |
55 | }; |
56 | |
57 | AVFILTER_DEFINE_CLASS(fieldhint); |
58 | |
59 | static av_cold int init(AVFilterContext *ctx) |
60 | { |
61 | FieldHintContext *s = ctx->priv; |
62 | int ret; |
63 | |
64 | if (!s->hint_file_str) { |
65 | av_log(ctx, AV_LOG_ERROR, "Hint file must be set.\n"); |
66 | return AVERROR(EINVAL); |
67 | } |
68 | s->hint = fopen(s->hint_file_str, "r"); |
69 | if (!s->hint) { |
70 | ret = AVERROR(errno); |
71 | av_log(ctx, AV_LOG_ERROR, "%s: %s\n", s->hint_file_str, av_err2str(ret)); |
72 | return ret; |
73 | } |
74 | |
75 | return 0; |
76 | } |
77 | |
78 | static int query_formats(AVFilterContext *ctx) |
79 | { |
80 | AVFilterFormats *pix_fmts = NULL; |
81 | int fmt, ret; |
82 | |
83 | for (fmt = 0; av_pix_fmt_desc_get(fmt); fmt++) { |
84 | const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(fmt); |
85 | if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL || |
86 | desc->flags & AV_PIX_FMT_FLAG_PAL || |
87 | desc->flags & AV_PIX_FMT_FLAG_BITSTREAM) && |
88 | (ret = ff_add_format(&pix_fmts, fmt)) < 0) |
89 | return ret; |
90 | } |
91 | |
92 | return ff_set_common_formats(ctx, pix_fmts); |
93 | } |
94 | |
95 | static int config_input(AVFilterLink *inlink) |
96 | { |
97 | FieldHintContext *s = inlink->dst->priv; |
98 | const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format); |
99 | int ret; |
100 | |
101 | if ((ret = av_image_fill_linesizes(s->planewidth, inlink->format, inlink->w)) < 0) |
102 | return ret; |
103 | |
104 | s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h); |
105 | s->planeheight[0] = s->planeheight[3] = inlink->h; |
106 | |
107 | s->nb_planes = av_pix_fmt_count_planes(inlink->format); |
108 | |
109 | return 0; |
110 | } |
111 | |
112 | static int filter_frame(AVFilterLink *inlink, AVFrame *in) |
113 | { |
114 | AVFilterContext *ctx = inlink->dst; |
115 | AVFilterLink *outlink = ctx->outputs[0]; |
116 | FieldHintContext *s = ctx->priv; |
117 | AVFrame *out, *top, *bottom; |
118 | char buf[1024] = { 0 }; |
119 | int64_t tf, bf; |
120 | char hint = '='; |
121 | int p; |
122 | |
123 | av_frame_free(&s->frame[0]); |
124 | s->frame[0] = s->frame[1]; |
125 | s->frame[1] = s->frame[2]; |
126 | s->frame[2] = in; |
127 | if (!s->frame[1]) |
128 | return 0; |
129 | else if (!s->frame[0]) { |
130 | s->frame[0] = av_frame_clone(s->frame[1]); |
131 | if (!s->frame[0]) |
132 | return AVERROR(ENOMEM); |
133 | } |
134 | |
135 | while (1) { |
136 | if (fgets(buf, sizeof(buf)-1, s->hint)) { |
137 | s->line++; |
138 | if (buf[0] == '#' || buf[0] == ';') { |
139 | continue; |
140 | } else if (sscanf(buf, "%"PRId64",%"PRId64" %c", &tf, &bf, &hint) == 3) { |
141 | ; |
142 | } else if (sscanf(buf, "%"PRId64",%"PRId64"", &tf, &bf) == 2) { |
143 | ; |
144 | } else { |
145 | av_log(ctx, AV_LOG_ERROR, "Invalid entry at line %"PRId64".\n", s->line); |
146 | return AVERROR_INVALIDDATA; |
147 | } |
148 | switch (s->mode) { |
149 | case 0: |
150 | if (tf > outlink->frame_count_in + 1 || tf < FFMAX(0, outlink->frame_count_in - 1) || |
151 | bf > outlink->frame_count_in + 1 || bf < FFMAX(0, outlink->frame_count_in - 1)) { |
152 | av_log(ctx, AV_LOG_ERROR, "Out of range frames %"PRId64" and/or %"PRId64" on line %"PRId64" for %"PRId64". input frame.\n", tf, bf, s->line, inlink->frame_count_out); |
153 | return AVERROR_INVALIDDATA; |
154 | } |
155 | break; |
156 | case 1: |
157 | if (tf > 1 || tf < -1 || |
158 | bf > 1 || bf < -1) { |
159 | av_log(ctx, AV_LOG_ERROR, "Out of range %"PRId64" and/or %"PRId64" on line %"PRId64" for %"PRId64". input frame.\n", tf, bf, s->line, inlink->frame_count_out); |
160 | return AVERROR_INVALIDDATA; |
161 | } |
162 | }; |
163 | break; |
164 | } else { |
165 | av_log(ctx, AV_LOG_ERROR, "Missing entry for %"PRId64". input frame.\n", inlink->frame_count_out); |
166 | return AVERROR_INVALIDDATA; |
167 | } |
168 | } |
169 | |
170 | out = ff_get_video_buffer(outlink, outlink->w, outlink->h); |
171 | if (!out) |
172 | return AVERROR(ENOMEM); |
173 | av_frame_copy_props(out, s->frame[1]); |
174 | |
175 | switch (s->mode) { |
176 | case 0: |
177 | top = s->frame[tf - outlink->frame_count_in + 1]; |
178 | bottom = s->frame[bf - outlink->frame_count_in + 1]; |
179 | break; |
180 | case 1: |
181 | top = s->frame[1 + tf]; |
182 | bottom = s->frame[1 + bf]; |
183 | break; |
184 | default: |
185 | av_assert0(0); |
186 | } |
187 | |
188 | switch (hint) { |
189 | case '+': |
190 | out->interlaced_frame = 1; |
191 | break; |
192 | case '-': |
193 | out->interlaced_frame = 0; |
194 | break; |
195 | case '=': |
196 | break; |
197 | default: |
198 | av_log(ctx, AV_LOG_ERROR, "Invalid hint: %c.\n", hint); |
199 | av_frame_free(&out); |
200 | return AVERROR(EINVAL); |
201 | } |
202 | |
203 | for (p = 0; p < s->nb_planes; p++) { |
204 | av_image_copy_plane(out->data[p], |
205 | out->linesize[p] * 2, |
206 | top->data[p], |
207 | top->linesize[p] * 2, |
208 | s->planewidth[p], |
209 | (s->planeheight[p] + 1) / 2); |
210 | av_image_copy_plane(out->data[p] + out->linesize[p], |
211 | out->linesize[p] * 2, |
212 | bottom->data[p] + bottom->linesize[p], |
213 | bottom->linesize[p] * 2, |
214 | s->planewidth[p], |
215 | (s->planeheight[p] + 1) / 2); |
216 | } |
217 | |
218 | return ff_filter_frame(outlink, out); |
219 | } |
220 | |
221 | static int request_frame(AVFilterLink *outlink) |
222 | { |
223 | AVFilterContext *ctx = outlink->src; |
224 | FieldHintContext *s = ctx->priv; |
225 | int ret; |
226 | |
227 | if (s->eof) |
228 | return AVERROR_EOF; |
229 | |
230 | ret = ff_request_frame(ctx->inputs[0]); |
231 | if (ret == AVERROR_EOF && s->frame[2]) { |
232 | AVFrame *next = av_frame_clone(s->frame[2]); |
233 | if (!next) |
234 | return AVERROR(ENOMEM); |
235 | ret = filter_frame(ctx->inputs[0], next); |
236 | s->eof = 1; |
237 | } |
238 | |
239 | return ret; |
240 | } |
241 | |
242 | static av_cold void uninit(AVFilterContext *ctx) |
243 | { |
244 | FieldHintContext *s = ctx->priv; |
245 | |
246 | if (s->hint) |
247 | fclose(s->hint); |
248 | s->hint = NULL; |
249 | |
250 | av_frame_free(&s->frame[0]); |
251 | av_frame_free(&s->frame[1]); |
252 | av_frame_free(&s->frame[2]); |
253 | } |
254 | |
255 | static const AVFilterPad inputs[] = { |
256 | { |
257 | .name = "default", |
258 | .type = AVMEDIA_TYPE_VIDEO, |
259 | .config_props = config_input, |
260 | .filter_frame = filter_frame, |
261 | }, |
262 | { NULL } |
263 | }; |
264 | |
265 | static const AVFilterPad outputs[] = { |
266 | { |
267 | .name = "default", |
268 | .type = AVMEDIA_TYPE_VIDEO, |
269 | .request_frame = request_frame, |
270 | }, |
271 | { NULL } |
272 | }; |
273 | |
274 | AVFilter ff_vf_fieldhint = { |
275 | .name = "fieldhint", |
276 | .description = NULL_IF_CONFIG_SMALL("Field matching using hints."), |
277 | .priv_size = sizeof(FieldHintContext), |
278 | .priv_class = &fieldhint_class, |
279 | .init = init, |
280 | .uninit = uninit, |
281 | .query_formats = query_formats, |
282 | .inputs = inputs, |
283 | .outputs = outputs, |
284 | }; |
285 |