lavfi/dynaudnorm: rename pow2 to pow_2
[ffmpeg.git] / libavfilter / vf_fieldhint.c
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 };