diff --git a/libavfilter/vf_fps.c b/libavfilter/vf_fps.c
index dbafd2c35a..16e432db0b 100644
--- a/libavfilter/vf_fps.c
+++ b/libavfilter/vf_fps.c
@@ -2,6 +2,7 @@
  * Copyright 2007 Bobby Bingham
  * Copyright 2012 Robert Nagy <ronag89 gmail com>
  * Copyright 2012 Anton Khirnov <anton khirnov net>
+ * Copyright 2018 Calvin Walton <calvin.walton@kepstin.ca>
  *
  * This file is part of FFmpeg.
  *
@@ -28,17 +29,12 @@
 #include <float.h>
 #include <stdint.h>
 
-#include "libavutil/common.h"
-#include "libavutil/fifo.h"
+#include "libavutil/avassert.h"
 #include "libavutil/mathematics.h"
 #include "libavutil/opt.h"
-#include "libavutil/parseutils.h"
-
-#define FF_INTERNAL_FIELDS 1
-#include "framequeue.h"
 #include "avfilter.h"
+#include "filters.h"
 #include "internal.h"
-#include "video.h"
 
 enum EOFAction {
     EOF_ACTION_ROUND,
@@ -49,17 +45,24 @@ enum EOFAction {
 typedef struct FPSContext {
     const AVClass *class;
 
-    AVFifoBuffer *fifo;     ///< store frames until we get two successive timestamps
-
-    /* timestamps in input timebase */
-    int64_t first_pts;      ///< pts of the first frame that arrived on this filter
-
+    /* Options */
     double start_time;      ///< pts, in seconds, of the expected first frame
-
     AVRational framerate;   ///< target framerate
     int rounding;           ///< AVRounding method for timestamps
     int eof_action;         ///< action performed for last frame in FIFO
 
+    /* Set during outlink configuration */
+    int64_t  start_pts;     ///< pts of the expected first frame
+
+    /* Runtime state */
+    int      status;        ///< buffered input status
+    int64_t  status_pts;    ///< buffered input status timestamp
+
+    AVFrame *frames[2];     ///< buffered frames
+    int      frames_count;  ///< number of buffered frames
+
+    int64_t  next_pts;      ///< pts of the next frame to output
+
     /* statistics */
     int frames_in;             ///< number of frames on input
     int frames_out;            ///< number of frames on output
@@ -91,31 +94,46 @@ static av_cold int init(AVFilterContext *ctx)
 {
     FPSContext *s = ctx->priv;
 
-    if (!(s->fifo = av_fifo_alloc_array(2, sizeof(AVFrame*))))
-        return AVERROR(ENOMEM);
+    /* Pass INT64_MIN/MAX through unchanged to avoid special cases for AV_NOPTS_VALUE */
+    s->rounding = s->rounding | AV_ROUND_PASS_MINMAX;
 
-    s->first_pts    = AV_NOPTS_VALUE;
+    s->start_pts    = AV_NOPTS_VALUE;
+    s->status_pts   = AV_NOPTS_VALUE;
+    s->next_pts     = AV_NOPTS_VALUE;
 
     av_log(ctx, AV_LOG_VERBOSE, "fps=%d/%d\n", s->framerate.num, s->framerate.den);
     return 0;
 }
 
-static void flush_fifo(AVFifoBuffer *fifo)
+/* Remove the first frame from the buffer, returning it */
+static AVFrame *shift_frame(FPSContext *s)
 {
-    while (av_fifo_size(fifo)) {
-        AVFrame *tmp;
-        av_fifo_generic_read(fifo, &tmp, sizeof(tmp), NULL);
-        av_frame_free(&tmp);
-    }
+    AVFrame *frame;
+
+    /* Must only be called when there are frames in the buffer */
+    av_assert1(s->frames_count > 0);
+
+    frame = s->frames[0];
+    s->frames[0] = s->frames[1];
+    s->frames[1] = NULL;
+    s->frames_count--;
+
+    return frame;
 }
 
 static av_cold void uninit(AVFilterContext *ctx)
 {
     FPSContext *s = ctx->priv;
-    if (s->fifo) {
-        s->drop += av_fifo_size(s->fifo) / sizeof(AVFrame*);
-        flush_fifo(s->fifo);
-        av_fifo_freep(&s->fifo);
+
+    AVFrame *frame;
+
+    /* Free any remaining buffered frames. This only happens if a downstream
+     * filter has asked us to stop, so don't count them as dropped. */
+    av_log(ctx, AV_LOG_DEBUG, "Discarding %d buffered frame(s) at exit.\n",
+            s->frames_count);
+    while (s->frames_count > 0) {
+        frame = shift_frame(s);
+        av_frame_free(&frame);
     }
 
     av_log(ctx, AV_LOG_VERBOSE, "%d frames in, %d frames out; %d frames dropped, "
@@ -128,194 +146,238 @@ static int config_props(AVFilterLink* link)
 
     link->time_base = av_inv_q(s->framerate);
     link->frame_rate= s->framerate;
-    link->w         = link->src->inputs[0]->w;
-    link->h         = link->src->inputs[0]->h;
+
+    /* Convert the start time option to output timebase and save it */
+    if (s->start_time != DBL_MAX && s->start_time != AV_NOPTS_VALUE) {
+        double first_pts = s->start_time * AV_TIME_BASE;
+        first_pts = FFMIN(FFMAX(first_pts, INT64_MIN), INT64_MAX);
+        s->start_pts = av_rescale_q_rnd(first_pts, AV_TIME_BASE_Q,
+                link->time_base, s->rounding);
+    }
 
     return 0;
 }
 
-static int request_frame(AVFilterLink *outlink)
+/* Read a frame from the input and save it in the buffer */
+static void read_frame(AVFilterContext *ctx, FPSContext *s, AVFilterLink *inlink, AVFilterLink *outlink)
 {
-    AVFilterContext *ctx = outlink->src;
-    FPSContext        *s = ctx->priv;
+    AVFrame *frame;
     int ret;
+    int64_t in_pts;
 
-    ret = ff_request_frame(ctx->inputs[0]);
-
-    /* flush the fifo */
-    if (ret == AVERROR_EOF && av_fifo_size(s->fifo)) {
-        int i;
-        for (i = 0; av_fifo_size(s->fifo); i++) {
-            AVFrame *buf;
-
-            av_fifo_generic_read(s->fifo, &buf, sizeof(buf), NULL);
-            if (av_fifo_size(s->fifo)) {
-                buf->pts = av_rescale_q(s->first_pts, ctx->inputs[0]->time_base,
-                                        outlink->time_base) + s->frames_out;
-
-                if ((ret = ff_filter_frame(outlink, buf)) < 0)
-                    return ret;
-
-                s->frames_out++;
-            } else {
-                /* This is the last frame, we may have to duplicate it to match
-                 * the last frame duration */
-                int j;
-                int eof_rounding = (s->eof_action == EOF_ACTION_PASS) ? AV_ROUND_UP : s->rounding;
-                int delta = av_rescale_q_rnd(ctx->inputs[0]->current_pts - s->first_pts,
-                                             ctx->inputs[0]->time_base,
-                                             outlink->time_base, eof_rounding) - s->frames_out;
-                av_log(ctx, AV_LOG_DEBUG, "EOF frames_out:%d delta:%d\n", s->frames_out, delta);
-                /* if the delta is equal to 1, it means we just need to output
-                 * the last frame. Greater than 1 means we will need duplicate
-                 * delta-1 frames */
-                if (delta > 0 ) {
-                    for (j = 0; j < delta; j++) {
-                        AVFrame *dup = av_frame_clone(buf);
-
-                        av_log(ctx, AV_LOG_DEBUG, "Duplicating frame.\n");
-                        dup->pts = av_rescale_q(s->first_pts, ctx->inputs[0]->time_base,
-                                                outlink->time_base) + s->frames_out;
-
-                        if ((ret = ff_filter_frame(outlink, dup)) < 0)
-                            return ret;
-
-                        s->frames_out++;
-                        if (j > 0) s->dup++;
-                    }
-                    av_frame_free(&buf);
-                } else {
-                    /* for delta less or equal to 0, we should drop the frame,
-                     * otherwise, we will have one or more extra frames */
-                    av_frame_free(&buf);
-                    s->drop++;
-                }
-            }
-        }
-        return 0;
-    }
+    /* Must only be called when we have buffer room available */
+    av_assert1(s->frames_count < 2);
 
-    return ret;
-}
+    ret = ff_inlink_consume_frame(inlink, &frame);
+    /* Caller must have run ff_inlink_check_available_frame first */
+    av_assert1(ret);
 
-static int write_to_fifo(AVFifoBuffer *fifo, AVFrame *buf)
-{
-    int ret;
+    /* Convert frame pts to output timebase */
+    in_pts = frame->pts;
+    frame->pts = av_rescale_q_rnd(in_pts, inlink->time_base,
+            outlink->time_base, s->rounding);
 
-    if (!av_fifo_space(fifo) &&
-        (ret = av_fifo_realloc2(fifo, 2*av_fifo_size(fifo)))) {
-        av_frame_free(&buf);
-        return ret;
-    }
+    av_log(ctx, AV_LOG_DEBUG, "Read frame with in pts %"PRId64", out pts %"PRId64"\n",
+            in_pts, frame->pts);
 
-    av_fifo_generic_write(fifo, &buf, sizeof(buf), NULL);
-    return 0;
+    s->frames[s->frames_count++] = frame;
+    s->frames_in++;
 }
 
-static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
+/* Write a frame to the output */
+static int write_frame(AVFilterContext *ctx, FPSContext *s, AVFilterLink *outlink)
 {
-    AVFilterContext    *ctx = inlink->dst;
-    FPSContext           *s = ctx->priv;
-    AVFilterLink   *outlink = ctx->outputs[0];
-    int64_t delta;
-    int i, ret;
+    AVFrame *frame;
+    int ret;
+    int dup = 0;
 
-    s->frames_in++;
-    /* discard frames until we get the first timestamp */
-    if (s->first_pts == AV_NOPTS_VALUE) {
-        if (buf->pts != AV_NOPTS_VALUE) {
-            ret = write_to_fifo(s->fifo, buf);
-            if (ret < 0)
-                return ret;
-
-            if (s->start_time != DBL_MAX && s->start_time != AV_NOPTS_VALUE) {
-                double first_pts = s->start_time * AV_TIME_BASE;
-                first_pts = FFMIN(FFMAX(first_pts, INT64_MIN), INT64_MAX);
-                s->first_pts = av_rescale_q(first_pts, AV_TIME_BASE_Q,
-                                                     inlink->time_base);
-                av_log(ctx, AV_LOG_VERBOSE, "Set first pts to (in:%"PRId64" out:%"PRId64")\n",
-                       s->first_pts, av_rescale_q(first_pts, AV_TIME_BASE_Q,
-                                                  outlink->time_base));
-            } else {
-                s->first_pts = buf->pts;
-            }
+    av_assert1(s->frames_count == 2);
+
+    /* We haven't yet determined the pts of the first frame */
+    if (s->next_pts == AV_NOPTS_VALUE) {
+        if (s->frames[0]->pts != AV_NOPTS_VALUE) {
+            s->next_pts = s->frames[0]->pts;
+            av_log(ctx, AV_LOG_VERBOSE, "Set first pts to %"PRId64"\n",
+                    s->next_pts);
         } else {
             av_log(ctx, AV_LOG_WARNING, "Discarding initial frame(s) with no "
-                   "timestamp.\n");
-            av_frame_free(&buf);
+                    "timestamp.\n");
+            frame = shift_frame(s);
+            av_frame_free(&frame);
             s->drop++;
+            return AVERROR(EAGAIN);
         }
-        return 0;
     }
 
-    /* now wait for the next timestamp */
-    if (buf->pts == AV_NOPTS_VALUE || av_fifo_size(s->fifo) <= 0) {
-        return write_to_fifo(s->fifo, buf);
+    /* If the second buffered frame is acceptable for the next frame, drop the first. */
+    if (s->frames[1]->pts <= s->next_pts) {
+        frame = shift_frame(s);
+        if (frame->pts == s->next_pts) {
+            av_log(ctx, AV_LOG_DEBUG, "Dropping frame with pts %"PRId64"\n", frame->pts);
+            s->drop++;
+        }
+        av_frame_free(&frame);
+        return AVERROR(EAGAIN);
+
+    /* The second buffered frame is in the future, output the first */
+    } else {
+        frame = av_frame_clone(s->frames[0]);
+        frame->pts = s->next_pts++;
+
+        /* If we're using a different pts than the frame's original, it's a dup */
+        if (s->frames[0]->pts != frame->pts) {
+            av_log(ctx, AV_LOG_DEBUG, "Duplicating frame with pts %"PRId64" to pts %"PRId64"\n",
+                    s->frames[0]->pts, frame->pts);
+            dup = 1;
+        } else {
+            av_log(ctx, AV_LOG_DEBUG, "Writing frame with pts %"PRId64"\n", frame->pts);
+        }
+
+        ret = ff_filter_frame(outlink, frame);
+        if (ret >= 0) {
+            s->frames_out++;
+            s->dup += dup;
+        }
+
+        return ret;
     }
+}
 
-    /* number of output frames */
-    delta = av_rescale_q_rnd(buf->pts - s->first_pts, inlink->time_base,
-                             outlink->time_base, s->rounding) - s->frames_out ;
+/* Write the last frame to the output */
+static int write_frame_eof(AVFilterContext *ctx, FPSContext *s, AVFilterLink *outlink)
+{
+    AVFrame *frame;
+    int ret;
+    int dup = 0;
 
-    if (delta < 1) {
-        /* drop everything buffered except the last */
-        int drop = av_fifo_size(s->fifo)/sizeof(AVFrame*);
+    av_assert1(s->frames_count == 1);
 
-        av_log(ctx, AV_LOG_DEBUG, "Dropping %d frame(s).\n", drop);
-        s->drop += drop;
+    /* Either we've already hit the status timestamp or it's in the past,
+     * e.g. AV_NOPTS_VALUE, so drop the last frame. */
+    if (s->status_pts <= s->next_pts) {
+        frame = shift_frame(s);
+        if (frame->pts == s->next_pts) {
+            av_log(ctx, AV_LOG_DEBUG, "Dropping frame with pts %"PRId64"\n", frame->pts);
+            s->drop++;
+        }
+        av_frame_free(&frame);
+        return AVERROR(EAGAIN);
+
+    /* We haven't yet reached the timestamp of the status (EOF) */
+    } else {
+        frame = av_frame_clone(s->frames[0]);
+        frame->pts = s->next_pts++;
+
+        /* If we're using a different pts than the frame's original, it's a dup */
+        if (s->frames[0]->pts != frame->pts) {
+            av_log(ctx, AV_LOG_DEBUG, "Duplicating frame with pts %"PRId64" to pts %"PRId64"\n",
+                    s->frames[0]->pts, frame->pts);
+            dup = 1;
+        } else {
+            av_log(ctx, AV_LOG_DEBUG, "Writing frame with pts %"PRId64"\n", frame->pts);
+        }
 
-        flush_fifo(s->fifo);
-        ret = write_to_fifo(s->fifo, buf);
+        ret = ff_filter_frame(outlink, frame);
+        if (ret >= 0) {
+            s->frames_out++;
+            s->dup += dup;
+        }
 
         return ret;
     }
+}
 
-    /* can output >= 1 frames */
-    for (i = 0; i < delta; i++) {
-        AVFrame *buf_out;
-        av_fifo_generic_read(s->fifo, &buf_out, sizeof(buf_out), NULL);
+static void update_eof_pts(AVFilterContext *ctx, FPSContext *s, AVFilterLink *inlink, AVFilterLink *outlink)
+{
+    /* Convert status_pts to outlink timebase */
+    int eof_rounding = (s->eof_action == EOF_ACTION_PASS) ? AV_ROUND_UP : s->rounding;
+    s->status_pts = av_rescale_q_rnd(s->status_pts, inlink->time_base,
+            outlink->time_base, eof_rounding);
 
-        /* duplicate the frame if needed */
-        if (!av_fifo_size(s->fifo) && i < delta - 1) {
-            AVFrame *dup = av_frame_clone(buf_out);
+    av_log(ctx, AV_LOG_DEBUG, "EOF is at pts %"PRId64"\n", s->status_pts);
+}
 
-            av_log(ctx, AV_LOG_DEBUG, "Duplicating frame.\n");
-            if (dup)
-                ret = write_to_fifo(s->fifo, dup);
-            else
-                ret = AVERROR(ENOMEM);
+static int activate(AVFilterContext *ctx)
+{
+    FPSContext   *s       = ctx->priv;
+    AVFilterLink *inlink  = ctx->inputs[0];
+    AVFilterLink *outlink = ctx->outputs[0];
 
-            if (ret < 0) {
-                av_frame_free(&buf_out);
-                av_frame_free(&buf);
-                return ret;
-            }
+    int ret;
 
-            s->dup++;
+    FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink);
+
+    /* No buffered status: normal operation */
+    if (!s->status) {
+
+        /* Read available input frames if we have room */
+        while (s->frames_count < 2 &&
+                ff_inlink_check_available_frame(inlink)) {
+            read_frame(ctx, s, inlink, outlink);
         }
 
-        buf_out->pts = av_rescale_q(s->first_pts, inlink->time_base,
-                                    outlink->time_base) + s->frames_out;
+        /* We do not yet have enough frames to produce output */
+        if (s->frames_count < 2) {
 
-        if ((ret = ff_filter_frame(outlink, buf_out)) < 0) {
-            av_frame_free(&buf);
-            return ret;
+            ret = ff_inlink_acknowledge_status(inlink, &s->status, &s->status_pts);
+            if (!ret) {
+                /* If someone wants us to output, we'd better ask for more input */
+                if (ff_outlink_frame_wanted(outlink) > 0)
+                    ff_inlink_request_frame(inlink);
+
+                return 0;
+            }
+            if (ret > 0) {
+                /* Need to calculate the end timestamp in the output timebase */
+                update_eof_pts(ctx, s, inlink, outlink);
+            }
         }
 
-        s->frames_out++;
+        /* Buffered frames are available, so generate an output frame */
+        if (s->frames_count == 2 && ff_outlink_frame_wanted(outlink) >= 0) {
+            ret = write_frame(ctx, s, outlink);
+            /* Couldn't generate a frame: e.g. a frame was dropped */
+            if (ret == AVERROR(EAGAIN)) {
+                /* Schedule us to perform another step */
+                ff_filter_set_ready(ctx, 100);
+                return 0;
+            }
+            return ret;
+        }
     }
-    flush_fifo(s->fifo);
 
-    ret = write_to_fifo(s->fifo, buf);
+    /* There is a buffered status, flush frames and forward it */
+    if (s->status) {
+
+        /* There are still buffered frames, so flush a frame */
+        if (s->frames_count > 0) {
+            if (s->frames_count == 2)
+                ret = write_frame(ctx, s, outlink);
+            else
+                ret = write_frame_eof(ctx, s, outlink);
+
+            /* Couldn't generate a frame: e.g. a frame was dropped */
+            if (ret == AVERROR(EAGAIN)) {
+                /* Schedule us to perform another step */
+                ff_filter_set_ready(ctx, 100);
+                return 0;
+            }
+        }
+
+        /* No frames left, so forward the status */
+        if (s->frames_count == 0) {
+            ff_outlink_set_status(outlink, s->status, s->next_pts);
+            return 0;
+        }
+    }
 
-    return ret;
+    return FFERROR_NOT_READY;
 }
 
 static const AVFilterPad avfilter_vf_fps_inputs[] = {
     {
         .name         = "default",
         .type         = AVMEDIA_TYPE_VIDEO,
-        .filter_frame = filter_frame,
     },
     { NULL }
 };
@@ -324,8 +386,7 @@ static const AVFilterPad avfilter_vf_fps_outputs[] = {
     {
         .name          = "default",
         .type          = AVMEDIA_TYPE_VIDEO,
-        .request_frame = request_frame,
-        .config_props  = config_props
+        .config_props  = config_props,
     },
     { NULL }
 };
@@ -337,6 +398,7 @@ AVFilter ff_vf_fps = {
     .uninit      = uninit,
     .priv_size   = sizeof(FPSContext),
     .priv_class  = &fps_class,
+    .activate    = activate,
     .inputs      = avfilter_vf_fps_inputs,
     .outputs     = avfilter_vf_fps_outputs,
 };
