#include "avfilter.h"
#include "internal.h"
#include "video.h"
-
-#define N_SRCE 3
-
-typedef struct FrameRateContext {
- const AVClass *class;
- // parameters
- AVRational dest_frame_rate; ///< output frames per second
- int flags; ///< flags affecting frame rate conversion algorithm
- double scene_score; ///< score that denotes a scene change has happened
- int interp_start; ///< start of range to apply linear interpolation
- int interp_end; ///< end of range to apply linear interpolation
-
- int line_size[4]; ///< bytes of pixel data per line for each plane
- int vsub;
-
- int frst, next, prev, crnt, last;
- int pending_srce_frames; ///< how many input frames are still waiting to be processed
- int flush; ///< are we flushing final frames
- int pending_end_frame; ///< flag indicating we are waiting to call filter_frame()
-
- AVRational srce_time_base; ///< timebase of source
-
- AVRational dest_time_base; ///< timebase of destination
- int32_t dest_frame_num;
- int64_t last_dest_frame_pts; ///< pts of the last frame output
- int64_t average_srce_pts_dest_delta;///< average input pts delta converted from input rate to output rate
- int64_t average_dest_pts_delta; ///< calculated average output pts delta
-
- av_pixelutils_sad_fn sad; ///< Sum of the absolute difference function (scene detect only)
- double prev_mafd; ///< previous MAFD (scene detect only)
-
- AVFrame *srce[N_SRCE]; ///< buffered source frames
- int64_t srce_pts_dest[N_SRCE]; ///< pts for source frames scaled to output timebase
- int64_t pts; ///< pts of frame we are working on
-
- int (*blend_frames)(AVFilterContext *ctx, float interpolate,
- AVFrame *copy_src1, AVFrame *copy_src2);
- int max;
- int bitdepth;
- AVFrame *work;
-} FrameRateContext;
+#include "framerate.h"
#define OFFSET(x) offsetof(FrameRateContext, x)
#define V AV_OPT_FLAG_VIDEO_PARAM
{"interp_start", "point to start linear interpolation", OFFSET(interp_start), AV_OPT_TYPE_INT, {.i64=15}, 0, 255, V|F },
{"interp_end", "point to end linear interpolation", OFFSET(interp_end), AV_OPT_TYPE_INT, {.i64=240}, 0, 255, V|F },
- {"scene", "scene change level", OFFSET(scene_score), AV_OPT_TYPE_DOUBLE, {.dbl=7.0}, 0, INT_MAX, V|F },
+ {"scene", "scene change level", OFFSET(scene_score), AV_OPT_TYPE_DOUBLE, {.dbl=8.2}, 0, INT_MAX, V|F },
{"flags", "set flags", OFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64=1}, 0, INT_MAX, V|F, "flags" },
{"scene_change_detect", "enable scene change detection", 0, AV_OPT_TYPE_CONST, {.i64=FRAMERATE_FLAG_SCD}, INT_MIN, INT_MAX, V|F, "flags" },
AVFILTER_DEFINE_CLASS(framerate);
-static void next_source(AVFilterContext *ctx)
-{
- FrameRateContext *s = ctx->priv;
- int i;
-
- ff_dlog(ctx, "next_source()\n");
-
- if (s->srce[s->last] && s->srce[s->last] != s->srce[s->last-1]) {
- ff_dlog(ctx, "next_source() unlink %d\n", s->last);
- av_frame_free(&s->srce[s->last]);
- }
- for (i = s->last; i > s->frst; i--) {
- ff_dlog(ctx, "next_source() copy %d to %d\n", i - 1, i);
- s->srce[i] = s->srce[i - 1];
- }
- ff_dlog(ctx, "next_source() make %d null\n", s->frst);
- s->srce[s->frst] = NULL;
-}
-
static av_always_inline int64_t sad_8x8_16(const uint16_t *src1, ptrdiff_t stride1,
const uint16_t *src2, ptrdiff_t stride2)
{
return sum;
}
-static double get_scene_score16(AVFilterContext *ctx, AVFrame *crnt, AVFrame *next)
+static int64_t scene_sad16(FrameRateContext *s, const uint16_t *p1, int p1_linesize, const uint16_t* p2, int p2_linesize, const int width, const int height)
{
- FrameRateContext *s = ctx->priv;
- double ret = 0;
-
- ff_dlog(ctx, "get_scene_score16()\n");
+ int64_t sad;
+ int x, y;
+ for (sad = y = 0; y < height - 7; y += 8) {
+ for (x = 0; x < width - 7; x += 8) {
+ sad += sad_8x8_16(p1 + y * p1_linesize + x,
+ p1_linesize,
+ p2 + y * p2_linesize + x,
+ p2_linesize);
+ }
+ }
+ return sad;
+}
- if (crnt &&
- crnt->height == next->height &&
- crnt->width == next->width) {
- int x, y;
- int64_t sad;
- double mafd, diff;
- const uint16_t *p1 = (const uint16_t *)crnt->data[0];
- const uint16_t *p2 = (const uint16_t *)next->data[0];
- const int p1_linesize = crnt->linesize[0] / 2;
- const int p2_linesize = next->linesize[0] / 2;
-
- ff_dlog(ctx, "get_scene_score16() process\n");
-
- for (sad = y = 0; y < crnt->height; y += 8) {
- for (x = 0; x < p1_linesize; x += 8) {
- sad += sad_8x8_16(p1 + y * p1_linesize + x,
- p1_linesize,
- p2 + y * p2_linesize + x,
- p2_linesize);
- }
+static int64_t scene_sad8(FrameRateContext *s, uint8_t *p1, int p1_linesize, uint8_t* p2, int p2_linesize, const int width, const int height)
+{
+ int64_t sad;
+ int x, y;
+ for (sad = y = 0; y < height - 7; y += 8) {
+ for (x = 0; x < width - 7; x += 8) {
+ sad += s->sad(p1 + y * p1_linesize + x,
+ p1_linesize,
+ p2 + y * p2_linesize + x,
+ p2_linesize);
}
- mafd = sad / (crnt->height * crnt->width * 3);
- diff = fabs(mafd - s->prev_mafd);
- ret = av_clipf(FFMIN(mafd, diff), 0, 100.0);
- s->prev_mafd = mafd;
}
- ff_dlog(ctx, "get_scene_score16() result is:%f\n", ret);
- return ret;
+ emms_c();
+ return sad;
}
static double get_scene_score(AVFilterContext *ctx, AVFrame *crnt, AVFrame *next)
ff_dlog(ctx, "get_scene_score()\n");
- if (crnt &&
- crnt->height == next->height &&
+ if (crnt->height == next->height &&
crnt->width == next->width) {
- int x, y;
int64_t sad;
double mafd, diff;
- uint8_t *p1 = crnt->data[0];
- uint8_t *p2 = next->data[0];
- const int p1_linesize = crnt->linesize[0];
- const int p2_linesize = next->linesize[0];
ff_dlog(ctx, "get_scene_score() process\n");
+ if (s->bitdepth == 8)
+ sad = scene_sad8(s, crnt->data[0], crnt->linesize[0], next->data[0], next->linesize[0], crnt->width, crnt->height);
+ else
+ sad = scene_sad16(s, (const uint16_t*)crnt->data[0], crnt->linesize[0] / 2, (const uint16_t*)next->data[0], next->linesize[0] / 2, crnt->width, crnt->height);
- for (sad = y = 0; y < crnt->height; y += 8) {
- for (x = 0; x < p1_linesize; x += 8) {
- sad += s->sad(p1 + y * p1_linesize + x,
- p1_linesize,
- p2 + y * p2_linesize + x,
- p2_linesize);
- }
- }
- emms_c();
- mafd = sad / (crnt->height * crnt->width * 3);
+ mafd = (double)sad * 100.0 / FFMAX(1, (crnt->height & ~7) * (crnt->width & ~7)) / (1 << s->bitdepth);
diff = fabs(mafd - s->prev_mafd);
ret = av_clipf(FFMIN(mafd, diff), 0, 100.0);
s->prev_mafd = mafd;
}
- ff_dlog(ctx, "get_scene_score() result is:%f\n", ret);
+ ff_dlog(ctx, "get_scene_score() result is:%f\n", ret);
return ret;
}
-static int blend_frames16(AVFilterContext *ctx, float interpolate,
- AVFrame *copy_src1, AVFrame *copy_src2)
+typedef struct ThreadData {
+ AVFrame *copy_src1, *copy_src2;
+ uint16_t src1_factor, src2_factor;
+} ThreadData;
+
+static int filter_slice(AVFilterContext *ctx, void *arg, int job, int nb_jobs)
{
FrameRateContext *s = ctx->priv;
- AVFilterLink *outlink = ctx->outputs[0];
- double interpolate_scene_score = 0;
+ ThreadData *td = arg;
+ uint16_t src1_factor = td->src1_factor;
+ uint16_t src2_factor = td->src2_factor;
+ int plane;
- if ((s->flags & FRAMERATE_FLAG_SCD) && copy_src2) {
- interpolate_scene_score = get_scene_score16(ctx, copy_src1, copy_src2);
- ff_dlog(ctx, "blend_frames16() interpolate scene score:%f\n", interpolate_scene_score);
+ for (plane = 0; plane < 4 && td->copy_src1->data[plane] && td->copy_src2->data[plane]; plane++) {
+ int cpy_line_width = s->line_size[plane];
+ uint8_t *cpy_src1_data = td->copy_src1->data[plane];
+ int cpy_src1_line_size = td->copy_src1->linesize[plane];
+ uint8_t *cpy_src2_data = td->copy_src2->data[plane];
+ int cpy_src2_line_size = td->copy_src2->linesize[plane];
+ int cpy_src_h = (plane > 0 && plane < 3) ? (td->copy_src1->height >> s->vsub) : (td->copy_src1->height);
+ uint8_t *cpy_dst_data = s->work->data[plane];
+ int cpy_dst_line_size = s->work->linesize[plane];
+ const int start = (cpy_src_h * job ) / nb_jobs;
+ const int end = (cpy_src_h * (job+1)) / nb_jobs;
+ cpy_src1_data += start * cpy_src1_line_size;
+ cpy_src2_data += start * cpy_src2_line_size;
+ cpy_dst_data += start * cpy_dst_line_size;
+
+ s->blend(cpy_src1_data, cpy_src1_line_size,
+ cpy_src2_data, cpy_src2_line_size,
+ cpy_dst_data, cpy_dst_line_size,
+ cpy_line_width, end - start,
+ src1_factor, src2_factor, s->blend_factor_max >> 1);
}
- // decide if the shot-change detection allows us to blend two frames
- if (interpolate_scene_score < s->scene_score && copy_src2) {
- uint16_t src2_factor = fabsf(interpolate) * (1 << (s->bitdepth - 8));
- uint16_t src1_factor = s->max - src2_factor;
- const int half = s->max / 2;
- const int uv = (s->max + 1) * half;
- const int shift = s->bitdepth;
- int plane, line, pixel;
-
- // get work-space for output frame
- s->work = ff_get_video_buffer(outlink, outlink->w, outlink->h);
- if (!s->work)
- return AVERROR(ENOMEM);
- av_frame_copy_props(s->work, s->srce[s->crnt]);
-
- ff_dlog(ctx, "blend_frames16() INTERPOLATE to create work frame\n");
- for (plane = 0; plane < 4 && copy_src1->data[plane] && copy_src2->data[plane]; plane++) {
- int cpy_line_width = s->line_size[plane];
- const uint16_t *cpy_src1_data = (const uint16_t *)copy_src1->data[plane];
- int cpy_src1_line_size = copy_src1->linesize[plane] / 2;
- const uint16_t *cpy_src2_data = (const uint16_t *)copy_src2->data[plane];
- int cpy_src2_line_size = copy_src2->linesize[plane] / 2;
- int cpy_src_h = (plane > 0 && plane < 3) ? (copy_src1->height >> s->vsub) : (copy_src1->height);
- uint16_t *cpy_dst_data = (uint16_t *)s->work->data[plane];
- int cpy_dst_line_size = s->work->linesize[plane] / 2;
-
- if (plane <1 || plane >2) {
- // luma or alpha
- for (line = 0; line < cpy_src_h; line++) {
- for (pixel = 0; pixel < cpy_line_width; pixel++)
- cpy_dst_data[pixel] = ((cpy_src1_data[pixel] * src1_factor) + (cpy_src2_data[pixel] * src2_factor) + half) >> shift;
- cpy_src1_data += cpy_src1_line_size;
- cpy_src2_data += cpy_src2_line_size;
- cpy_dst_data += cpy_dst_line_size;
- }
- } else {
- // chroma
- for (line = 0; line < cpy_src_h; line++) {
- for (pixel = 0; pixel < cpy_line_width; pixel++) {
- cpy_dst_data[pixel] = (((cpy_src1_data[pixel] - half) * src1_factor) + ((cpy_src2_data[pixel] - half) * src2_factor) + uv) >> shift;
- }
- cpy_src1_data += cpy_src1_line_size;
- cpy_src2_data += cpy_src2_line_size;
- cpy_dst_data += cpy_dst_line_size;
- }
- }
- }
- return 1;
- }
return 0;
}
-static int blend_frames8(AVFilterContext *ctx, float interpolate,
- AVFrame *copy_src1, AVFrame *copy_src2)
+static int blend_frames(AVFilterContext *ctx, int interpolate)
{
FrameRateContext *s = ctx->priv;
AVFilterLink *outlink = ctx->outputs[0];
double interpolate_scene_score = 0;
- if ((s->flags & FRAMERATE_FLAG_SCD) && copy_src2) {
- interpolate_scene_score = get_scene_score(ctx, copy_src1, copy_src2);
- ff_dlog(ctx, "blend_frames8() interpolate scene score:%f\n", interpolate_scene_score);
+ if ((s->flags & FRAMERATE_FLAG_SCD)) {
+ if (s->score >= 0.0)
+ interpolate_scene_score = s->score;
+ else
+ interpolate_scene_score = s->score = get_scene_score(ctx, s->f0, s->f1);
+ ff_dlog(ctx, "blend_frames() interpolate scene score:%f\n", interpolate_scene_score);
}
// decide if the shot-change detection allows us to blend two frames
- if (interpolate_scene_score < s->scene_score && copy_src2) {
- uint16_t src2_factor = fabsf(interpolate);
- uint16_t src1_factor = 256 - src2_factor;
- int plane, line, pixel;
+ if (interpolate_scene_score < s->scene_score) {
+ ThreadData td;
+ td.copy_src1 = s->f0;
+ td.copy_src2 = s->f1;
+ td.src2_factor = interpolate;
+ td.src1_factor = s->blend_factor_max - td.src2_factor;
// get work-space for output frame
s->work = ff_get_video_buffer(outlink, outlink->w, outlink->h);
if (!s->work)
return AVERROR(ENOMEM);
- av_frame_copy_props(s->work, s->srce[s->crnt]);
-
- ff_dlog(ctx, "blend_frames8() INTERPOLATE to create work frame\n");
- for (plane = 0; plane < 4 && copy_src1->data[plane] && copy_src2->data[plane]; plane++) {
- int cpy_line_width = s->line_size[plane];
- uint8_t *cpy_src1_data = copy_src1->data[plane];
- int cpy_src1_line_size = copy_src1->linesize[plane];
- uint8_t *cpy_src2_data = copy_src2->data[plane];
- int cpy_src2_line_size = copy_src2->linesize[plane];
- int cpy_src_h = (plane > 0 && plane < 3) ? (copy_src1->height >> s->vsub) : (copy_src1->height);
- uint8_t *cpy_dst_data = s->work->data[plane];
- int cpy_dst_line_size = s->work->linesize[plane];
- if (plane <1 || plane >2) {
- // luma or alpha
- for (line = 0; line < cpy_src_h; line++) {
- for (pixel = 0; pixel < cpy_line_width; pixel++) {
- // integer version of (src1 * src1_factor) + (src2 + src2_factor) + 0.5
- // 0.5 is for rounding
- // 128 is the integer representation of 0.5 << 8
- cpy_dst_data[pixel] = ((cpy_src1_data[pixel] * src1_factor) + (cpy_src2_data[pixel] * src2_factor) + 128) >> 8;
- }
- cpy_src1_data += cpy_src1_line_size;
- cpy_src2_data += cpy_src2_line_size;
- cpy_dst_data += cpy_dst_line_size;
- }
- } else {
- // chroma
- for (line = 0; line < cpy_src_h; line++) {
- for (pixel = 0; pixel < cpy_line_width; pixel++) {
- // as above
- // because U and V are based around 128 we have to subtract 128 from the components.
- // 32896 is the integer representation of 128.5 << 8
- cpy_dst_data[pixel] = (((cpy_src1_data[pixel] - 128) * src1_factor) + ((cpy_src2_data[pixel] - 128) * src2_factor) + 32896) >> 8;
- }
- cpy_src1_data += cpy_src1_line_size;
- cpy_src2_data += cpy_src2_line_size;
- cpy_dst_data += cpy_dst_line_size;
- }
- }
- }
+ av_frame_copy_props(s->work, s->f0);
+
+ ff_dlog(ctx, "blend_frames() INTERPOLATE to create work frame\n");
+ ctx->internal->execute(ctx, filter_slice, &td, NULL, FFMIN(FFMAX(1, outlink->h >> 2), ff_filter_get_nb_threads(ctx)));
return 1;
}
return 0;
}
-static int process_work_frame(AVFilterContext *ctx, int stop)
+static int process_work_frame(AVFilterContext *ctx)
{
FrameRateContext *s = ctx->priv;
- int64_t work_next_pts;
- AVFrame *copy_src1;
- float interpolate;
-
- ff_dlog(ctx, "process_work_frame()\n");
-
- ff_dlog(ctx, "process_work_frame() pending_input_frames %d\n", s->pending_srce_frames);
-
- if (s->srce[s->prev]) ff_dlog(ctx, "process_work_frame() srce prev pts:%"PRId64"\n", s->srce[s->prev]->pts);
- if (s->srce[s->crnt]) ff_dlog(ctx, "process_work_frame() srce crnt pts:%"PRId64"\n", s->srce[s->crnt]->pts);
- if (s->srce[s->next]) ff_dlog(ctx, "process_work_frame() srce next pts:%"PRId64"\n", s->srce[s->next]->pts);
+ int64_t work_pts;
+ int64_t interpolate, interpolate8;
+ int ret;
- if (!s->srce[s->crnt]) {
- // the filter cannot do anything
- ff_dlog(ctx, "process_work_frame() no current frame cached: move on to next frame, do not output a frame\n");
- next_source(ctx);
+ if (!s->f1)
return 0;
- }
-
- work_next_pts = s->pts + s->average_dest_pts_delta;
-
- ff_dlog(ctx, "process_work_frame() work crnt pts:%"PRId64"\n", s->pts);
- ff_dlog(ctx, "process_work_frame() work next pts:%"PRId64"\n", work_next_pts);
- if (s->srce[s->prev])
- ff_dlog(ctx, "process_work_frame() srce prev pts:%"PRId64" at dest time base:%u/%u\n",
- s->srce_pts_dest[s->prev], s->dest_time_base.num, s->dest_time_base.den);
- if (s->srce[s->crnt])
- ff_dlog(ctx, "process_work_frame() srce crnt pts:%"PRId64" at dest time base:%u/%u\n",
- s->srce_pts_dest[s->crnt], s->dest_time_base.num, s->dest_time_base.den);
- if (s->srce[s->next])
- ff_dlog(ctx, "process_work_frame() srce next pts:%"PRId64" at dest time base:%u/%u\n",
- s->srce_pts_dest[s->next], s->dest_time_base.num, s->dest_time_base.den);
-
- av_assert0(s->srce[s->next]);
-
- // should filter be skipping input frame (output frame rate is lower than input frame rate)
- if (!s->flush && s->pts >= s->srce_pts_dest[s->next]) {
- ff_dlog(ctx, "process_work_frame() work crnt pts >= srce next pts: SKIP FRAME, move on to next frame, do not output a frame\n");
- next_source(ctx);
- s->pending_srce_frames--;
+ if (!s->f0 && !s->flush)
return 0;
- }
- // calculate interpolation
- interpolate = ((s->pts - s->srce_pts_dest[s->crnt]) * 256.0 / s->average_srce_pts_dest_delta);
- ff_dlog(ctx, "process_work_frame() interpolate:%f/256\n", interpolate);
- copy_src1 = s->srce[s->crnt];
- if (interpolate > s->interp_end) {
- ff_dlog(ctx, "process_work_frame() source is:NEXT\n");
- copy_src1 = s->srce[s->next];
- }
- if (s->srce[s->prev] && interpolate < -s->interp_end) {
- ff_dlog(ctx, "process_work_frame() source is:PREV\n");
- copy_src1 = s->srce[s->prev];
- }
+ work_pts = s->start_pts + av_rescale_q(s->n, av_inv_q(s->dest_frame_rate), s->dest_time_base);
- // decide whether to blend two frames
- if ((interpolate >= s->interp_start && interpolate <= s->interp_end) || (interpolate <= -s->interp_start && interpolate >= -s->interp_end)) {
- AVFrame *copy_src2;
+ if (work_pts >= s->pts1 && !s->flush)
+ return 0;
- if (interpolate > 0) {
- ff_dlog(ctx, "process_work_frame() interpolate source is:NEXT\n");
- copy_src2 = s->srce[s->next];
+ if (!s->f0) {
+ s->work = av_frame_clone(s->f1);
+ } else {
+ if (work_pts >= s->pts1 + s->delta && s->flush)
+ return 0;
+
+ interpolate = av_rescale(work_pts - s->pts0, s->blend_factor_max, s->delta);
+ interpolate8 = av_rescale(work_pts - s->pts0, 256, s->delta);
+ ff_dlog(ctx, "process_work_frame() interpolate: %"PRId64"/256\n", interpolate8);
+ if (interpolate >= s->blend_factor_max || interpolate8 > s->interp_end) {
+ s->work = av_frame_clone(s->f1);
+ } else if (interpolate <= 0 || interpolate8 < s->interp_start) {
+ s->work = av_frame_clone(s->f0);
} else {
- ff_dlog(ctx, "process_work_frame() interpolate source is:PREV\n");
- copy_src2 = s->srce[s->prev];
+ ret = blend_frames(ctx, interpolate);
+ if (ret < 0)
+ return ret;
+ if (ret == 0)
+ s->work = av_frame_clone(interpolate > (s->blend_factor_max >> 1) ? s->f1 : s->f0);
}
- if (s->blend_frames(ctx, interpolate, copy_src1, copy_src2))
- goto copy_done;
- else
- ff_dlog(ctx, "process_work_frame() CUT - DON'T INTERPOLATE\n");
}
- ff_dlog(ctx, "process_work_frame() COPY to the work frame\n");
- // copy the frame we decided is our base source
- s->work = av_frame_clone(copy_src1);
if (!s->work)
return AVERROR(ENOMEM);
-copy_done:
- s->work->pts = s->pts;
-
- // should filter be re-using input frame (output frame rate is higher than input frame rate)
- if (!s->flush && (work_next_pts + s->average_dest_pts_delta) < (s->srce_pts_dest[s->crnt] + s->average_srce_pts_dest_delta)) {
- ff_dlog(ctx, "process_work_frame() REPEAT FRAME\n");
- } else {
- ff_dlog(ctx, "process_work_frame() CONSUME FRAME, move to next frame\n");
- s->pending_srce_frames--;
- next_source(ctx);
- }
- ff_dlog(ctx, "process_work_frame() output a frame\n");
- s->dest_frame_num++;
- if (stop)
- s->pending_end_frame = 0;
- s->last_dest_frame_pts = s->work->pts;
+ s->work->pts = work_pts;
+ s->n++;
return 1;
}
-static void set_srce_frame_dest_pts(AVFilterContext *ctx)
-{
- FrameRateContext *s = ctx->priv;
-
- ff_dlog(ctx, "set_srce_frame_output_pts()\n");
-
- // scale the input pts from the timebase difference between input and output
- if (s->srce[s->prev])
- s->srce_pts_dest[s->prev] = av_rescale_q(s->srce[s->prev]->pts, s->srce_time_base, s->dest_time_base);
- if (s->srce[s->crnt])
- s->srce_pts_dest[s->crnt] = av_rescale_q(s->srce[s->crnt]->pts, s->srce_time_base, s->dest_time_base);
- if (s->srce[s->next])
- s->srce_pts_dest[s->next] = av_rescale_q(s->srce[s->next]->pts, s->srce_time_base, s->dest_time_base);
-}
-
-static void set_work_frame_pts(AVFilterContext *ctx)
-{
- FrameRateContext *s = ctx->priv;
- int64_t pts, average_srce_pts_delta = 0;
-
- ff_dlog(ctx, "set_work_frame_pts()\n");
-
- av_assert0(s->srce[s->next]);
- av_assert0(s->srce[s->crnt]);
-
- ff_dlog(ctx, "set_work_frame_pts() srce crnt pts:%"PRId64"\n", s->srce[s->crnt]->pts);
- ff_dlog(ctx, "set_work_frame_pts() srce next pts:%"PRId64"\n", s->srce[s->next]->pts);
- if (s->srce[s->prev])
- ff_dlog(ctx, "set_work_frame_pts() srce prev pts:%"PRId64"\n", s->srce[s->prev]->pts);
-
- average_srce_pts_delta = s->average_srce_pts_dest_delta;
- ff_dlog(ctx, "set_work_frame_pts() initial average srce pts:%"PRId64"\n", average_srce_pts_delta);
-
- set_srce_frame_dest_pts(ctx);
-
- // calculate the PTS delta
- if ((pts = (s->srce_pts_dest[s->next] - s->srce_pts_dest[s->crnt]))) {
- average_srce_pts_delta = average_srce_pts_delta?((average_srce_pts_delta+pts)>>1):pts;
- } else if (s->srce[s->prev] && (pts = (s->srce_pts_dest[s->crnt] - s->srce_pts_dest[s->prev]))) {
- average_srce_pts_delta = average_srce_pts_delta?((average_srce_pts_delta+pts)>>1):pts;
- }
-
- s->average_srce_pts_dest_delta = average_srce_pts_delta;
- ff_dlog(ctx, "set_work_frame_pts() average srce pts:%"PRId64"\n", average_srce_pts_delta);
- ff_dlog(ctx, "set_work_frame_pts() average srce pts:%"PRId64" at dest time base:%u/%u\n",
- s->average_srce_pts_dest_delta, s->dest_time_base.num, s->dest_time_base.den);
-
- if (ctx->inputs[0] && !s->average_dest_pts_delta) {
- int64_t d = av_q2d(av_inv_q(av_mul_q(s->dest_time_base, s->dest_frame_rate)));
- s->average_dest_pts_delta = d;
- ff_dlog(ctx, "set_work_frame_pts() average dest pts delta:%"PRId64"\n", s->average_dest_pts_delta);
- }
-
- if (!s->dest_frame_num) {
- s->pts = s->last_dest_frame_pts = s->srce_pts_dest[s->crnt];
- } else {
- s->pts = s->last_dest_frame_pts + s->average_dest_pts_delta;
- }
-
- ff_dlog(ctx, "set_work_frame_pts() calculated pts:%"PRId64" at dest time base:%u/%u\n",
- s->pts, s->dest_time_base.num, s->dest_time_base.den);
-}
-
static av_cold int init(AVFilterContext *ctx)
{
FrameRateContext *s = ctx->priv;
-
- s->dest_frame_num = 0;
-
- s->crnt = (N_SRCE)>>1;
- s->last = N_SRCE - 1;
-
- s->next = s->crnt - 1;
- s->prev = s->crnt + 1;
-
+ s->start_pts = AV_NOPTS_VALUE;
return 0;
}
static av_cold void uninit(AVFilterContext *ctx)
{
FrameRateContext *s = ctx->priv;
- int i;
-
- for (i = s->frst; i < s->last; i++) {
- if (s->srce[i] && (s->srce[i] != s->srce[i + 1]))
- av_frame_free(&s->srce[i]);
- }
- av_frame_free(&s->srce[s->last]);
+ av_frame_free(&s->f0);
+ av_frame_free(&s->f1);
}
static int query_formats(AVFilterContext *ctx)
return ff_set_common_formats(ctx, fmts_list);
}
+static void blend_frames_c(BLEND_FUNC_PARAMS)
+{
+ int line, pixel;
+ for (line = 0; line < height; line++) {
+ for (pixel = 0; pixel < width; pixel++)
+ dst[pixel] = ((src1[pixel] * factor1) + (src2[pixel] * factor2) + half) >> BLEND_FACTOR_DEPTH8;
+ src1 += src1_linesize;
+ src2 += src2_linesize;
+ dst += dst_linesize;
+ }
+}
+
+static void blend_frames16_c(BLEND_FUNC_PARAMS)
+{
+ int line, pixel;
+ uint16_t *dstw = (uint16_t *)dst;
+ uint16_t *src1w = (uint16_t *)src1;
+ uint16_t *src2w = (uint16_t *)src2;
+ width /= 2;
+ src1_linesize /= 2;
+ src2_linesize /= 2;
+ dst_linesize /= 2;
+ for (line = 0; line < height; line++) {
+ for (pixel = 0; pixel < width; pixel++)
+ dstw[pixel] = ((src1w[pixel] * factor1) + (src2w[pixel] * factor2) + half) >> BLEND_FACTOR_DEPTH16;
+ src1w += src1_linesize;
+ src2w += src2_linesize;
+ dstw += dst_linesize;
+ }
+}
+
+void ff_framerate_init(FrameRateContext *s)
+{
+ if (s->bitdepth == 8) {
+ s->blend_factor_max = 1 << BLEND_FACTOR_DEPTH8;
+ s->blend = blend_frames_c;
+ } else {
+ s->blend_factor_max = 1 << BLEND_FACTOR_DEPTH16;
+ s->blend = blend_frames16_c;
+ }
+ if (ARCH_X86)
+ ff_framerate_init_x86(s);
+}
+
static int config_input(AVFilterLink *inlink)
{
AVFilterContext *ctx = inlink->dst;
s->srce_time_base = inlink->time_base;
- if (s->bitdepth == 8)
- s->blend_frames = blend_frames8;
- else
- s->blend_frames = blend_frames16;
- s->max = 1 << (s->bitdepth);
+ ff_framerate_init(s);
return 0;
}
int ret;
AVFilterContext *ctx = inlink->dst;
FrameRateContext *s = ctx->priv;
-
- // we have one new frame
- s->pending_srce_frames++;
+ int64_t pts;
if (inpicref->interlaced_frame)
av_log(ctx, AV_LOG_WARNING, "Interlaced frame found - the output will not be correct.\n");
- // store the pointer to the new frame
- av_frame_free(&s->srce[s->frst]);
- s->srce[s->frst] = inpicref;
+ if (inpicref->pts == AV_NOPTS_VALUE) {
+ av_log(ctx, AV_LOG_WARNING, "Ignoring frame without PTS.\n");
+ return 0;
+ }
- if (!s->pending_end_frame && s->srce[s->crnt]) {
- set_work_frame_pts(ctx);
- s->pending_end_frame = 1;
- } else {
- set_srce_frame_dest_pts(ctx);
+ pts = av_rescale_q(inpicref->pts, s->srce_time_base, s->dest_time_base);
+ if (s->f1 && pts == s->pts1) {
+ av_log(ctx, AV_LOG_WARNING, "Ignoring frame with same PTS.\n");
+ return 0;
+ }
+
+ av_frame_free(&s->f0);
+ s->f0 = s->f1;
+ s->pts0 = s->pts1;
+ s->f1 = inpicref;
+ s->pts1 = pts;
+ s->delta = s->pts1 - s->pts0;
+ s->score = -1.0;
+
+ if (s->delta < 0) {
+ av_log(ctx, AV_LOG_WARNING, "PTS discontinuity.\n");
+ s->start_pts = s->pts1;
+ s->n = 0;
+ av_frame_free(&s->f0);
}
- ret = process_work_frame(ctx, 1);
- if (ret < 0)
- return ret;
- return ret ? ff_filter_frame(ctx->outputs[0], s->work) : 0;
+ if (s->start_pts == AV_NOPTS_VALUE)
+ s->start_pts = s->pts1;
+
+ do {
+ ret = process_work_frame(ctx);
+ if (ret <= 0)
+ return ret;
+ ret = ff_filter_frame(ctx->outputs[0], s->work);
+ } while (ret >= 0);
+
+ return ret;
}
static int config_output(AVFilterLink *outlink)
{
AVFilterContext *ctx = outlink->src;
FrameRateContext *s = ctx->priv;
- int ret, i;
+ int ret;
ff_dlog(ctx, "request_frame()\n");
- // if there is no "next" frame AND we are not in flush then get one from our input filter
- if (!s->srce[s->frst] && !s->flush)
- goto request;
-
- ff_dlog(ctx, "request_frame() REPEAT or FLUSH\n");
-
- if (s->pending_srce_frames <= 0) {
- ff_dlog(ctx, "request_frame() nothing else to do, return:EOF\n");
- return AVERROR_EOF;
- }
-
- // otherwise, make brand-new frame and pass to our output filter
- ff_dlog(ctx, "request_frame() FLUSH\n");
-
- // back fill at end of file when source has no more frames
- for (i = s->last; i > s->frst; i--) {
- if (!s->srce[i - 1] && s->srce[i]) {
- ff_dlog(ctx, "request_frame() copy:%d to:%d\n", i, i - 1);
- s->srce[i - 1] = s->srce[i];
- }
- }
-
- set_work_frame_pts(ctx);
- ret = process_work_frame(ctx, 0);
- if (ret < 0)
- return ret;
- if (ret)
- return ff_filter_frame(ctx->outputs[0], s->work);
-
-request:
- ff_dlog(ctx, "request_frame() call source's request_frame()\n");
ret = ff_request_frame(ctx->inputs[0]);
- if (ret < 0 && (ret != AVERROR_EOF)) {
- ff_dlog(ctx, "request_frame() source's request_frame() returned error:%d\n", ret);
- return ret;
- } else if (ret == AVERROR_EOF) {
+ if (ret == AVERROR_EOF && s->f1 && !s->flush) {
s->flush = 1;
+ ret = process_work_frame(ctx);
+ if (ret < 0)
+ return ret;
+ ret = ret ? ff_filter_frame(ctx->outputs[0], s->work) : AVERROR_EOF;
}
+
ff_dlog(ctx, "request_frame() source's request_frame() returned:%d\n", ret);
- return 0;
+ return ret;
}
static const AVFilterPad framerate_inputs[] = {
.query_formats = query_formats,
.inputs = framerate_inputs,
.outputs = framerate_outputs,
+ .flags = AVFILTER_FLAG_SLICE_THREADS,
};
projects / ffmpeg / blobdiff