vf_dejudder.c

Go to the documentation of this file.

/*
 * Copyright (c) 2014 Nicholas Robbins
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
 
/**
 * @file
 * remove judder in video stream
 *
 * Algorithm:
 *    - If the old packets had PTS of old_pts[i]. Replace these with new
 *      value based on the running average of the last n=cycle frames. So
 *
 *      new_pts[i] = Sum(k=i-n+1, i, old_pts[k])/n
 *                        + (old_pts[i]-old_pts[i-n])*(n-1)/2n
 *
 *      For any repeating pattern of length n of judder this will produce
 *      an even progression of PTS's.
 *
 *    - In order to avoid calculating this sum ever frame, a running tally
 *      is maintained in ctx->new_pts. Each frame the new term at the start
 *      of the sum is added, the one and the end is removed, and the offset
 *      terms (second line in formula above) are recalculated.
 *
 *    - To aid in this a ringbuffer of the last n-2 PTS's is maintained in
 *      ctx->ringbuff. With the indices of the first two and last two entries
 *      stored in i1, i2, i3, & i4.
 *
 *    - To ensure that the new PTS's are integers, time_base is divided
 *      by 2n. This removes the division in the new_pts calculation.
 *
 *    - frame_rate is also multiplied by 2n to allow the frames to fall
 *      where they may in what may now be a VFR output. This produces more
 *      even output then setting frame_rate=1/0 in practice.
 */
 
#include "libavutil/mem.h"
#include "libavutil/opt.h"
#include "avfilter.h"
#include "filters.h"
 
typedef struct DejudderContext {
    const AVClass *class;
    int64_t *ringbuff;
    int i1, i2, i3, i4;
    int64_t new_pts;
    int start_count;
 
    /* options */
    int cycle;
} DejudderContext;
 
#define OFFSET(x) offsetof(DejudderContext, x)
#define FLAGS AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_VIDEO_PARAM
 
static const AVOption dejudder_options[] = {
    {"cycle", "set the length of the cycle to use for dejuddering",
        OFFSET(cycle), AV_OPT_TYPE_INT, {.i64 = 4}, 2, 240, .flags = FLAGS},
    {NULL}
};
 
AVFILTER_DEFINE_CLASS(dejudder);
 
static int config_out_props(AVFilterLink *outlink)
{
    FilterLink     *outl = ff_filter_link(outlink);
    AVFilterContext *ctx = outlink->src;
    DejudderContext *s = ctx->priv;
    AVFilterLink *inlink = outlink->src->inputs[0];
    FilterLink      *inl = ff_filter_link(inlink);
 
    outlink->time_base = av_mul_q(inlink->time_base, av_make_q(1, 2 * s->cycle));
    outl->frame_rate = av_mul_q(inl->frame_rate, av_make_q(2 * s->cycle, 1));
 
    av_log(ctx, AV_LOG_VERBOSE, "cycle:%d\n", s->cycle);
 
    return 0;
}
 
static av_cold int dejudder_init(AVFilterContext *ctx)
{
    DejudderContext *s = ctx->priv;
 
    s->ringbuff = av_calloc(s->cycle + 2, sizeof(*s->ringbuff));
    if (!s->ringbuff)
        return AVERROR(ENOMEM);
 
    s->new_pts = 0;
    s->i1 = 0;
    s->i2 = 1;
    s->i3 = 2;
    s->i4 = 3;
    s->start_count = s->cycle + 2;
 
    return 0;
}
 
static av_cold void dejudder_uninit(AVFilterContext *ctx)
{
    DejudderContext *s = ctx->priv;
 
    av_freep(&(s->ringbuff));
}
 
static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
{
    int k;
    AVFilterContext *ctx  = inlink->dst;
    AVFilterLink *outlink = ctx->outputs[0];
    DejudderContext *s   = ctx->priv;
    int64_t *judbuff      = s->ringbuff;
    int64_t next_pts      = frame->pts;
    int64_t offset;
 
    if (next_pts == AV_NOPTS_VALUE)
        return ff_filter_frame(outlink, frame);
 
    if (s->start_count) {
        s->start_count--;
        s->new_pts = next_pts * 2 * s->cycle;
    } else {
        if (next_pts < judbuff[s->i2]) {
            offset = next_pts + judbuff[s->i3] - judbuff[s->i4] - judbuff[s->i1];
            for (k = 0; k < s->cycle + 2; k++)
                judbuff[k] += offset;
        }
        s->new_pts += (s->cycle - 1) * (judbuff[s->i3] - judbuff[s->i1])
                    + (s->cycle + 1) * (next_pts - judbuff[s->i4]);
    }
 
    judbuff[s->i2] = next_pts;
    s->i1 = s->i2;
    s->i2 = s->i3;
    s->i3 = s->i4;
    s->i4 = (s->i4 + 1) % (s->cycle + 2);
 
    frame->pts = s->new_pts;
 
    for (k = 0; k < s->cycle + 2; k++)
        av_log(ctx, AV_LOG_DEBUG, "%"PRId64"\t", judbuff[k]);
    av_log(ctx, AV_LOG_DEBUG, "next=%"PRId64", new=%"PRId64"\n", next_pts, frame->pts);
 
    return ff_filter_frame(outlink, frame);
}
 
static const AVFilterPad dejudder_inputs[] = {
    {
        .name         = "default",
        .type         = AVMEDIA_TYPE_VIDEO,
        .filter_frame = filter_frame,
    },
};
 
static const AVFilterPad dejudder_outputs[] = {
    {
        .name = "default",
        .type = AVMEDIA_TYPE_VIDEO,
        .config_props = config_out_props,
    },
};
 
const FFFilter ff_vf_dejudder = {
    .p.name      = "dejudder",
    .p.description= NULL_IF_CONFIG_SMALL("Remove judder produced by pullup."),
    .p.priv_class= &dejudder_class,
    .priv_size   = sizeof(DejudderContext),
    FILTER_INPUTS(dejudder_inputs),
    FILTER_OUTPUTS(dejudder_outputs),
    .init        = dejudder_init,
    .uninit      = dejudder_uninit,
};