2 * Copyright 2007 Bobby Bingham
3 * Copyright 2012 Robert Nagy <ronag89 gmail com>
4 * Copyright 2012 Anton Khirnov <anton khirnov net>
6 * This file is part of FFmpeg.
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.
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.
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
25 * a filter enforcing given constant framerate
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"
37 #define FF_INTERNAL_FIELDS 1
38 #include "framequeue.h"
49 typedef struct FPSContext {
52 AVFifoBuffer *fifo; ///< store frames until we get two successive timestamps
54 /* timestamps in input timebase */
55 int64_t first_pts; ///< pts of the first frame that arrived on this filter
57 double start_time; ///< pts, in seconds, of the expected first frame
59 AVRational framerate; ///< target framerate
60 int rounding; ///< AVRounding method for timestamps
61 int eof_action; ///< action performed for last frame in FIFO
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
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" },
88 AVFILTER_DEFINE_CLASS(fps);
90 static av_cold int init(AVFilterContext *ctx)
92 FPSContext *s = ctx->priv;
94 if (!(s->fifo = av_fifo_alloc_array(2, sizeof(AVFrame*))))
95 return AVERROR(ENOMEM);
97 s->first_pts = AV_NOPTS_VALUE;
99 av_log(ctx, AV_LOG_VERBOSE, "fps=%d/%d\n", s->framerate.num, s->framerate.den);
103 static void flush_fifo(AVFifoBuffer *fifo)
105 while (av_fifo_size(fifo)) {
107 av_fifo_generic_read(fifo, &tmp, sizeof(tmp), NULL);
112 static av_cold void uninit(AVFilterContext *ctx)
114 FPSContext *s = ctx->priv;
116 s->drop += av_fifo_size(s->fifo) / sizeof(AVFrame*);
118 av_fifo_freep(&s->fifo);
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);
125 static int config_props(AVFilterLink* link)
127 FPSContext *s = link->src->priv;
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;
137 static int request_frame(AVFilterLink *outlink)
139 AVFilterContext *ctx = outlink->src;
140 FPSContext *s = ctx->priv;
143 ret = ff_request_frame(ctx->inputs[0]);
146 if (ret == AVERROR_EOF && av_fifo_size(s->fifo)) {
148 for (i = 0; av_fifo_size(s->fifo); i++) {
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;
156 if ((ret = ff_filter_frame(outlink, buf)) < 0)
161 /* This is the last frame, we may have to duplicate it to match
162 * the last frame duration */
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
173 for (j = 0; j < delta; j++) {
174 AVFrame *dup = av_frame_clone(buf);
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;
180 if ((ret = ff_filter_frame(outlink, dup)) < 0)
188 /* for delta less or equal to 0, we should drop the frame,
189 * otherwise, we will have one or more extra frames */
201 static int write_to_fifo(AVFifoBuffer *fifo, AVFrame *buf)
205 if (!av_fifo_space(fifo) &&
206 (ret = av_fifo_realloc2(fifo, 2*av_fifo_size(fifo)))) {
211 av_fifo_generic_write(fifo, &buf, sizeof(buf), NULL);
215 static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
217 AVFilterContext *ctx = inlink->dst;
218 FPSContext *s = ctx->priv;
219 AVFilterLink *outlink = ctx->outputs[0];
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);
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,
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));
240 s->first_pts = buf->pts;
243 av_log(ctx, AV_LOG_WARNING, "Discarding initial frame(s) with no "
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);
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 ;
261 /* drop everything buffered except the last */
262 int drop = av_fifo_size(s->fifo)/sizeof(AVFrame*);
264 av_log(ctx, AV_LOG_DEBUG, "Dropping %d frame(s).\n", drop);
268 ret = write_to_fifo(s->fifo, buf);
273 /* can output >= 1 frames */
274 for (i = 0; i < delta; i++) {
276 av_fifo_generic_read(s->fifo, &buf_out, sizeof(buf_out), NULL);
278 /* duplicate the frame if needed */
279 if (!av_fifo_size(s->fifo) && i < delta - 1) {
280 AVFrame *dup = av_frame_clone(buf_out);
282 av_log(ctx, AV_LOG_DEBUG, "Duplicating frame.\n");
284 ret = write_to_fifo(s->fifo, dup);
286 ret = AVERROR(ENOMEM);
289 av_frame_free(&buf_out);
297 buf_out->pts = av_rescale_q(s->first_pts, inlink->time_base,
298 outlink->time_base) + s->frames_out;
300 if ((ret = ff_filter_frame(outlink, buf_out)) < 0) {
309 ret = write_to_fifo(s->fifo, buf);
314 static const AVFilterPad avfilter_vf_fps_inputs[] = {
317 .type = AVMEDIA_TYPE_VIDEO,
318 .filter_frame = filter_frame,
323 static const AVFilterPad avfilter_vf_fps_outputs[] = {
326 .type = AVMEDIA_TYPE_VIDEO,
327 .request_frame = request_frame,
328 .config_props = config_props
333 AVFilter ff_vf_fps = {
335 .description = NULL_IF_CONFIG_SMALL("Force constant framerate."),
338 .priv_size = sizeof(FPSContext),
339 .priv_class = &fps_class,
340 .inputs = avfilter_vf_fps_inputs,
341 .outputs = avfilter_vf_fps_outputs,