avfilter/vf_ssim: fix temp size calculation
[ffmpeg.git] / libavfilter / vf_fieldorder.c
index d2c01d3..ca55ff1 100644 (file)
@@ -23,7 +23,6 @@
  * video field order filter, heavily influenced by vf_pad.c
  */
 
-#include "libavutil/opt.h"
 #include "libavutil/imgutils.h"
 #include "libavutil/internal.h"
 #include "libavutil/opt.h"
@@ -33,7 +32,7 @@
 #include "internal.h"
 #include "video.h"
 
-typedef struct {
+typedef struct FieldOrderContext {
     const AVClass *class;
     int dst_tff;               ///< output bff/tff
     int          line_size[4]; ///< bytes of pixel data per line for each plane
@@ -48,20 +47,20 @@ static int query_formats(AVFilterContext *ctx)
     /** accept any input pixel format that is not hardware accelerated, not
      *  a bitstream format, and does not have vertically sub-sampled chroma */
     if (ctx->inputs[0]) {
+        const AVPixFmtDescriptor *desc = NULL;
         formats = NULL;
-        for (pix_fmt = 0; pix_fmt < AV_PIX_FMT_NB; pix_fmt++) {
-            const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
+        while ((desc = av_pix_fmt_desc_next(desc))) {
+            pix_fmt = av_pix_fmt_desc_get_id(desc);
             if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL ||
                   desc->flags & AV_PIX_FMT_FLAG_PAL     ||
                   desc->flags & AV_PIX_FMT_FLAG_BITSTREAM) &&
                 desc->nb_components && !desc->log2_chroma_h &&
-                (ret = ff_add_format(&formats, pix_fmt)) < 0) {
-                ff_formats_unref(&formats);
+                (ret = ff_add_format(&formats, pix_fmt)) < 0)
                 return ret;
-            }
         }
-        ff_formats_ref(formats, &ctx->inputs[0]->out_formats);
-        ff_formats_ref(formats, &ctx->outputs[0]->in_formats);
+        if ((ret = ff_formats_ref(formats, &ctx->inputs[0]->out_formats)) < 0 ||
+            (ret = ff_formats_ref(formats, &ctx->outputs[0]->in_formats)) < 0)
+            return ret;
     }
 
     return 0;
@@ -80,21 +79,40 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
     AVFilterContext   *ctx     = inlink->dst;
     FieldOrderContext *s       = ctx->priv;
     AVFilterLink      *outlink = ctx->outputs[0];
-    int h, plane, line_step, line_size, line;
-    uint8_t *data;
+    int h, plane, src_line_step, dst_line_step, line_size, line;
+    uint8_t *dst, *src;
+    AVFrame *out;
 
     if (!frame->interlaced_frame ||
-        frame->top_field_first == s->dst_tff)
+        frame->top_field_first == s->dst_tff) {
+        av_log(ctx, AV_LOG_VERBOSE,
+               "Skipping %s.\n",
+               frame->interlaced_frame ?
+               "frame with same field order" : "progressive frame");
         return ff_filter_frame(outlink, frame);
+    }
 
-    av_dlog(ctx,
+    if (av_frame_is_writable(frame)) {
+        out = frame;
+    } else {
+        out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
+        if (!out) {
+            av_frame_free(&frame);
+            return AVERROR(ENOMEM);
+        }
+        av_frame_copy_props(out, frame);
+    }
+
+    av_log(ctx, AV_LOG_TRACE,
             "picture will move %s one line\n",
             s->dst_tff ? "up" : "down");
     h = frame->height;
     for (plane = 0; plane < 4 && frame->data[plane] && frame->linesize[plane]; plane++) {
-        line_step = frame->linesize[plane];
+        dst_line_step = out->linesize[plane];
+        src_line_step = frame->linesize[plane];
         line_size = s->line_size[plane];
-        data = frame->data[plane];
+        dst = out->data[plane];
+        src = frame->data[plane];
         if (s->dst_tff) {
             /** Move every line up one line, working from
              *  the top to the bottom of the frame.
@@ -103,11 +121,12 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
              *  penultimate line from that field. */
             for (line = 0; line < h; line++) {
                 if (1 + line < frame->height) {
-                    memcpy(data, data + line_step, line_size);
+                    memcpy(dst, src + src_line_step, line_size);
                 } else {
-                    memcpy(data, data - line_step - line_step, line_size);
+                    memcpy(dst, src - 2 * src_line_step, line_size);
                 }
-                data += line_step;
+                dst += dst_line_step;
+                src += src_line_step;
             }
         } else {
             /** Move every line down one line, working from
@@ -115,20 +134,24 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
              *  The original bottom line is lost.
              *  The new first line is created as a copy of the
              *  second line from that field. */
-            data += (h - 1) * line_step;
+            dst += (h - 1) * dst_line_step;
+            src += (h - 1) * src_line_step;
             for (line = h - 1; line >= 0 ; line--) {
                 if (line > 0) {
-                    memcpy(data, data - line_step, line_size);
+                    memcpy(dst, src - src_line_step, line_size);
                 } else {
-                    memcpy(data, data + line_step + line_step, line_size);
+                    memcpy(dst, src + 2 * src_line_step, line_size);
                 }
-                data -= line_step;
+                dst -= dst_line_step;
+                src -= src_line_step;
             }
         }
     }
-    frame->top_field_first = s->dst_tff;
+    out->top_field_first = s->dst_tff;
 
-    return ff_filter_frame(outlink, frame);
+    if (frame != out)
+        av_frame_free(&frame);
+    return ff_filter_frame(outlink, out);
 }
 
 #define OFFSET(x) offsetof(FieldOrderContext, x)
@@ -138,18 +161,17 @@ static const AVOption fieldorder_options[] = {
     { "order", "output field order", OFFSET(dst_tff), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, FLAGS, "order" },
         { "bff", "bottom field first", 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, .flags=FLAGS, .unit = "order" },
         { "tff", "top field first",    0, AV_OPT_TYPE_CONST, { .i64 = 1 }, .flags=FLAGS, .unit = "order" },
-    { NULL },
+    { NULL }
 };
 
 AVFILTER_DEFINE_CLASS(fieldorder);
 
 static const AVFilterPad avfilter_vf_fieldorder_inputs[] = {
     {
-        .name             = "default",
-        .type             = AVMEDIA_TYPE_VIDEO,
-        .config_props     = config_input,
-        .filter_frame     = filter_frame,
-        .needs_writable   = 1,
+        .name         = "default",
+        .type         = AVMEDIA_TYPE_VIDEO,
+        .config_props = config_input,
+        .filter_frame = filter_frame,
     },
     { NULL }
 };
@@ -162,7 +184,7 @@ static const AVFilterPad avfilter_vf_fieldorder_outputs[] = {
     { NULL }
 };
 
-AVFilter avfilter_vf_fieldorder = {
+AVFilter ff_vf_fieldorder = {
     .name          = "fieldorder",
     .description   = NULL_IF_CONFIG_SMALL("Set the field order."),
     .priv_size     = sizeof(FieldOrderContext),