vf_paletteuse: Add error checking to apply_palette
[ffmpeg.git] / libavfilter / vf_fps.c
1 /*
2  * Copyright 2007 Bobby Bingham
3  * Copyright 2012 Robert Nagy <ronag89 gmail com>
4  * Copyright 2012 Anton Khirnov <anton khirnov net>
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (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 GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22
23 /**
24  * @file
25  * a filter enforcing given constant framerate
26  */
27
28 #include <float.h>
29 #include <stdint.h>
30
31 #include "libavutil/common.h"
32 #include "libavutil/fifo.h"
33 #include "libavutil/mathematics.h"
34 #include "libavutil/opt.h"
35 #include "libavutil/parseutils.h"
36
37 #define FF_INTERNAL_FIELDS 1
38 #include "framequeue.h"
39 #include "avfilter.h"
40 #include "internal.h"
41 #include "video.h"
42
43 enum EOFAction {
44     EOF_ACTION_ROUND,
45     EOF_ACTION_PASS,
46     EOF_ACTION_NB
47 };
48
49 typedef struct FPSContext {
50     const AVClass *class;
51
52     AVFifoBuffer *fifo;     ///< store frames until we get two successive timestamps
53
54     /* timestamps in input timebase */
55     int64_t first_pts;      ///< pts of the first frame that arrived on this filter
56
57     double start_time;      ///< pts, in seconds, of the expected first frame
58
59     AVRational framerate;   ///< target framerate
60     int rounding;           ///< AVRounding method for timestamps
61     int eof_action;         ///< action performed for last frame in FIFO
62
63     /* statistics */
64     int frames_in;             ///< number of frames on input
65     int frames_out;            ///< number of frames on output
66     int dup;                   ///< number of frames duplicated
67     int drop;                  ///< number of framed dropped
68 } FPSContext;
69
70 #define OFFSET(x) offsetof(FPSContext, x)
71 #define V AV_OPT_FLAG_VIDEO_PARAM
72 #define F AV_OPT_FLAG_FILTERING_PARAM
73 static const AVOption fps_options[] = {
74     { "fps", "A string describing desired output framerate", OFFSET(framerate), AV_OPT_TYPE_VIDEO_RATE, { .str = "25" }, 0, INT_MAX, V|F },
75     { "start_time", "Assume the first PTS should be this value.", OFFSET(start_time), AV_OPT_TYPE_DOUBLE, { .dbl = DBL_MAX}, -DBL_MAX, DBL_MAX, V|F },
76     { "round", "set rounding method for timestamps", OFFSET(rounding), AV_OPT_TYPE_INT, { .i64 = AV_ROUND_NEAR_INF }, 0, 5, V|F, "round" },
77         { "zero", "round towards 0",                 0, AV_OPT_TYPE_CONST, { .i64 = AV_ROUND_ZERO     }, 0, 0, V|F, "round" },
78         { "inf",  "round away from 0",               0, AV_OPT_TYPE_CONST, { .i64 = AV_ROUND_INF      }, 0, 0, V|F, "round" },
79         { "down", "round towards -infty",            0, AV_OPT_TYPE_CONST, { .i64 = AV_ROUND_DOWN     }, 0, 0, V|F, "round" },
80         { "up",   "round towards +infty",            0, AV_OPT_TYPE_CONST, { .i64 = AV_ROUND_UP       }, 0, 0, V|F, "round" },
81         { "near", "round to nearest",                0, AV_OPT_TYPE_CONST, { .i64 = AV_ROUND_NEAR_INF }, 0, 0, V|F, "round" },
82     { "eof_action", "action performed for last frame", OFFSET(eof_action), AV_OPT_TYPE_INT, { .i64 = EOF_ACTION_ROUND }, 0, EOF_ACTION_NB-1, V|F, "eof_action" },
83         { "round", "round similar to other frames",  0, AV_OPT_TYPE_CONST, { .i64 = EOF_ACTION_ROUND }, 0, 0, V|F, "eof_action" },
84         { "pass",  "pass through last frame",        0, AV_OPT_TYPE_CONST, { .i64 = EOF_ACTION_PASS  }, 0, 0, V|F, "eof_action" },
85     { NULL }
86 };
87
88 AVFILTER_DEFINE_CLASS(fps);
89
90 static av_cold int init(AVFilterContext *ctx)
91 {
92     FPSContext *s = ctx->priv;
93
94     if (!(s->fifo = av_fifo_alloc_array(2, sizeof(AVFrame*))))
95         return AVERROR(ENOMEM);
96
97     s->first_pts    = AV_NOPTS_VALUE;
98
99     av_log(ctx, AV_LOG_VERBOSE, "fps=%d/%d\n", s->framerate.num, s->framerate.den);
100     return 0;
101 }
102
103 static void flush_fifo(AVFifoBuffer *fifo)
104 {
105     while (av_fifo_size(fifo)) {
106         AVFrame *tmp;
107         av_fifo_generic_read(fifo, &tmp, sizeof(tmp), NULL);
108         av_frame_free(&tmp);
109     }
110 }
111
112 static av_cold void uninit(AVFilterContext *ctx)
113 {
114     FPSContext *s = ctx->priv;
115     if (s->fifo) {
116         s->drop += av_fifo_size(s->fifo) / sizeof(AVFrame*);
117         flush_fifo(s->fifo);
118         av_fifo_freep(&s->fifo);
119     }
120
121     av_log(ctx, AV_LOG_VERBOSE, "%d frames in, %d frames out; %d frames dropped, "
122            "%d frames duplicated.\n", s->frames_in, s->frames_out, s->drop, s->dup);
123 }
124
125 static int config_props(AVFilterLink* link)
126 {
127     FPSContext   *s = link->src->priv;
128
129     link->time_base = av_inv_q(s->framerate);
130     link->frame_rate= s->framerate;
131     link->w         = link->src->inputs[0]->w;
132     link->h         = link->src->inputs[0]->h;
133
134     return 0;
135 }
136
137 static int request_frame(AVFilterLink *outlink)
138 {
139     AVFilterContext *ctx = outlink->src;
140     FPSContext        *s = ctx->priv;
141     int ret;
142
143     ret = ff_request_frame(ctx->inputs[0]);
144
145     /* flush the fifo */
146     if (ret == AVERROR_EOF && av_fifo_size(s->fifo)) {
147         int i;
148         for (i = 0; av_fifo_size(s->fifo); i++) {
149             AVFrame *buf;
150
151             av_fifo_generic_read(s->fifo, &buf, sizeof(buf), NULL);
152             if (av_fifo_size(s->fifo)) {
153                 buf->pts = av_rescale_q(s->first_pts, ctx->inputs[0]->time_base,
154                                         outlink->time_base) + s->frames_out;
155
156                 if ((ret = ff_filter_frame(outlink, buf)) < 0)
157                     return ret;
158
159                 s->frames_out++;
160             } else {
161                 /* This is the last frame, we may have to duplicate it to match
162                  * the last frame duration */
163                 int j;
164                 int eof_rounding = (s->eof_action == EOF_ACTION_PASS) ? AV_ROUND_UP : s->rounding;
165                 int delta = av_rescale_q_rnd(ctx->inputs[0]->current_pts - s->first_pts,
166                                              ctx->inputs[0]->time_base,
167                                              outlink->time_base, eof_rounding) - s->frames_out;
168                 av_log(ctx, AV_LOG_DEBUG, "EOF frames_out:%d delta:%d\n", s->frames_out, delta);
169                 /* if the delta is equal to 1, it means we just need to output
170                  * the last frame. Greater than 1 means we will need duplicate
171                  * delta-1 frames */
172                 if (delta > 0 ) {
173                     for (j = 0; j < delta; j++) {
174                         AVFrame *dup = av_frame_clone(buf);
175
176                         av_log(ctx, AV_LOG_DEBUG, "Duplicating frame.\n");
177                         dup->pts = av_rescale_q(s->first_pts, ctx->inputs[0]->time_base,
178                                                 outlink->time_base) + s->frames_out;
179
180                         if ((ret = ff_filter_frame(outlink, dup)) < 0)
181                             return ret;
182
183                         s->frames_out++;
184                         if (j > 0) s->dup++;
185                     }
186                     av_frame_free(&buf);
187                 } else {
188                     /* for delta less or equal to 0, we should drop the frame,
189                      * otherwise, we will have one or more extra frames */
190                     av_frame_free(&buf);
191                     s->drop++;
192                 }
193             }
194         }
195         return 0;
196     }
197
198     return ret;
199 }
200
201 static int write_to_fifo(AVFifoBuffer *fifo, AVFrame *buf)
202 {
203     int ret;
204
205     if (!av_fifo_space(fifo) &&
206         (ret = av_fifo_realloc2(fifo, 2*av_fifo_size(fifo)))) {
207         av_frame_free(&buf);
208         return ret;
209     }
210
211     av_fifo_generic_write(fifo, &buf, sizeof(buf), NULL);
212     return 0;
213 }
214
215 static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
216 {
217     AVFilterContext    *ctx = inlink->dst;
218     FPSContext           *s = ctx->priv;
219     AVFilterLink   *outlink = ctx->outputs[0];
220     int64_t delta;
221     int i, ret;
222
223     s->frames_in++;
224     /* discard frames until we get the first timestamp */
225     if (s->first_pts == AV_NOPTS_VALUE) {
226         if (buf->pts != AV_NOPTS_VALUE) {
227             ret = write_to_fifo(s->fifo, buf);
228             if (ret < 0)
229                 return ret;
230
231             if (s->start_time != DBL_MAX && s->start_time != AV_NOPTS_VALUE) {
232                 double first_pts = s->start_time * AV_TIME_BASE;
233                 first_pts = FFMIN(FFMAX(first_pts, INT64_MIN), INT64_MAX);
234                 s->first_pts = av_rescale_q(first_pts, AV_TIME_BASE_Q,
235                                                      inlink->time_base);
236                 av_log(ctx, AV_LOG_VERBOSE, "Set first pts to (in:%"PRId64" out:%"PRId64")\n",
237                        s->first_pts, av_rescale_q(first_pts, AV_TIME_BASE_Q,
238                                                   outlink->time_base));
239             } else {
240                 s->first_pts = buf->pts;
241             }
242         } else {
243             av_log(ctx, AV_LOG_WARNING, "Discarding initial frame(s) with no "
244                    "timestamp.\n");
245             av_frame_free(&buf);
246             s->drop++;
247         }
248         return 0;
249     }
250
251     /* now wait for the next timestamp */
252     if (buf->pts == AV_NOPTS_VALUE || av_fifo_size(s->fifo) <= 0) {
253         return write_to_fifo(s->fifo, buf);
254     }
255
256     /* number of output frames */
257     delta = av_rescale_q_rnd(buf->pts - s->first_pts, inlink->time_base,
258                              outlink->time_base, s->rounding) - s->frames_out ;
259
260     if (delta < 1) {
261         /* drop everything buffered except the last */
262         int drop = av_fifo_size(s->fifo)/sizeof(AVFrame*);
263
264         av_log(ctx, AV_LOG_DEBUG, "Dropping %d frame(s).\n", drop);
265         s->drop += drop;
266
267         flush_fifo(s->fifo);
268         ret = write_to_fifo(s->fifo, buf);
269
270         return ret;
271     }
272
273     /* can output >= 1 frames */
274     for (i = 0; i < delta; i++) {
275         AVFrame *buf_out;
276         av_fifo_generic_read(s->fifo, &buf_out, sizeof(buf_out), NULL);
277
278         /* duplicate the frame if needed */
279         if (!av_fifo_size(s->fifo) && i < delta - 1) {
280             AVFrame *dup = av_frame_clone(buf_out);
281
282             av_log(ctx, AV_LOG_DEBUG, "Duplicating frame.\n");
283             if (dup)
284                 ret = write_to_fifo(s->fifo, dup);
285             else
286                 ret = AVERROR(ENOMEM);
287
288             if (ret < 0) {
289                 av_frame_free(&buf_out);
290                 av_frame_free(&buf);
291                 return ret;
292             }
293
294             s->dup++;
295         }
296
297         buf_out->pts = av_rescale_q(s->first_pts, inlink->time_base,
298                                     outlink->time_base) + s->frames_out;
299
300         if ((ret = ff_filter_frame(outlink, buf_out)) < 0) {
301             av_frame_free(&buf);
302             return ret;
303         }
304
305         s->frames_out++;
306     }
307     flush_fifo(s->fifo);
308
309     ret = write_to_fifo(s->fifo, buf);
310
311     return ret;
312 }
313
314 static const AVFilterPad avfilter_vf_fps_inputs[] = {
315     {
316         .name         = "default",
317         .type         = AVMEDIA_TYPE_VIDEO,
318         .filter_frame = filter_frame,
319     },
320     { NULL }
321 };
322
323 static const AVFilterPad avfilter_vf_fps_outputs[] = {
324     {
325         .name          = "default",
326         .type          = AVMEDIA_TYPE_VIDEO,
327         .request_frame = request_frame,
328         .config_props  = config_props
329     },
330     { NULL }
331 };
332
333 AVFilter ff_vf_fps = {
334     .name        = "fps",
335     .description = NULL_IF_CONFIG_SMALL("Force constant framerate."),
336     .init        = init,
337     .uninit      = uninit,
338     .priv_size   = sizeof(FPSContext),
339     .priv_class  = &fps_class,
340     .inputs      = avfilter_vf_fps_inputs,
341     .outputs     = avfilter_vf_fps_outputs,
342 };