avfilter/vsrc_testsrc: fix a preprocessor check
[ffmpeg.git] / libavfilter / vf_fftfilt.c
index bc493e3..af44b1e 100644 (file)
@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2015 Arwa Arif <arwaarif1994@gmail.com>
+ * Copyright (c) 2017 Paul B Mahol
  *
  * This file is part of FFmpeg.
  *
 
 #define MAX_PLANES 4
 
-typedef struct {
+enum EvalMode {
+    EVAL_MODE_INIT,
+    EVAL_MODE_FRAME,
+    EVAL_MODE_NB
+};
+
+typedef struct FFTFILTContext {
     const AVClass *class;
 
-    RDFTContext *rdft;
+    int eval_mode;
+    int depth;
+    int nb_planes;
+    int planewidth[MAX_PLANES];
+    int planeheight[MAX_PLANES];
+
+    RDFTContext *hrdft[MAX_PLANES];
+    RDFTContext *vrdft[MAX_PLANES];
+    RDFTContext *ihrdft[MAX_PLANES];
+    RDFTContext *ivrdft[MAX_PLANES];
     int rdft_hbits[MAX_PLANES];
     int rdft_vbits[MAX_PLANES];
     size_t rdft_hlen[MAX_PLANES];
@@ -49,10 +65,12 @@ typedef struct {
     AVExpr *weight_expr[MAX_PLANES];
     double *weight[MAX_PLANES];
 
+    void (*rdft_horizontal)(struct FFTFILTContext *s, AVFrame *in, int w, int h, int plane);
+    void (*irdft_horizontal)(struct FFTFILTContext *s, AVFrame *out, int w, int h, int plane);
 } FFTFILTContext;
 
-static const char *const var_names[] = {   "X",   "Y",   "W",   "H",     NULL    };
-enum                                   { VAR_X, VAR_Y, VAR_W, VAR_H, VAR_VARS_NB };
+static const char *const var_names[] = {   "X",   "Y",   "W",   "H",   "N", NULL        };
+enum                                   { VAR_X, VAR_Y, VAR_W, VAR_H, VAR_N, VAR_VARS_NB };
 
 enum { Y = 0, U, V };
 
@@ -66,6 +84,9 @@ static const AVOption fftfilt_options[] = {
     { "weight_Y", "set luminance expression in Y plane",   OFFSET(weight_str[Y]), AV_OPT_TYPE_STRING, {.str = "1"}, CHAR_MIN, CHAR_MAX, FLAGS },
     { "weight_U", "set chrominance expression in U plane", OFFSET(weight_str[U]), AV_OPT_TYPE_STRING, {.str = NULL}, CHAR_MIN, CHAR_MAX, FLAGS },
     { "weight_V", "set chrominance expression in V plane", OFFSET(weight_str[V]), AV_OPT_TYPE_STRING, {.str = NULL}, CHAR_MIN, CHAR_MAX, FLAGS },
+    { "eval", "specify when to evaluate expressions", OFFSET(eval_mode), AV_OPT_TYPE_INT, {.i64 = EVAL_MODE_INIT}, 0, EVAL_MODE_NB-1, FLAGS, "eval" },
+         { "init",  "eval expressions once during initialization", 0, AV_OPT_TYPE_CONST, {.i64=EVAL_MODE_INIT},  .flags = FLAGS, .unit = "eval" },
+         { "frame", "eval expressions per-frame",                  0, AV_OPT_TYPE_CONST, {.i64=EVAL_MODE_FRAME}, .flags = FLAGS, .unit = "eval" },
     {NULL},
 };
 
@@ -93,10 +114,9 @@ static void copy_rev (FFTSample *dest, int w, int w2)
 }
 
 /*Horizontal pass - RDFT*/
-static void rdft_horizontal(FFTFILTContext *s, AVFrame *in, int w, int h, int plane)
+static void rdft_horizontal8(FFTFILTContext *s, AVFrame *in, int w, int h, int plane)
 {
     int i, j;
-    s->rdft = av_rdft_init(s->rdft_hbits[plane], DFT_R2C);
 
     for (i = 0; i < h; i++) {
         for (j = 0; j < w; j++)
@@ -106,16 +126,30 @@ static void rdft_horizontal(FFTFILTContext *s, AVFrame *in, int w, int h, int pl
     }
 
     for (i = 0; i < h; i++)
-        av_rdft_calc(s->rdft, s->rdft_hdata[plane] + i * s->rdft_hlen[plane]);
+        av_rdft_calc(s->hrdft[plane], s->rdft_hdata[plane] + i * s->rdft_hlen[plane]);
+}
 
-    av_rdft_end(s->rdft);
+static void rdft_horizontal16(FFTFILTContext *s, AVFrame *in, int w, int h, int plane)
+{
+    const uint16_t *src = (const uint16_t *)in->data[plane];
+    int linesize = in->linesize[plane] / 2;
+    int i, j;
+
+    for (i = 0; i < h; i++) {
+        for (j = 0; j < w; j++)
+            s->rdft_hdata[plane][i * s->rdft_hlen[plane] + j] = *(src + linesize * i + j);
+
+        copy_rev(s->rdft_hdata[plane] + i * s->rdft_hlen[plane], w, s->rdft_hlen[plane]);
+    }
+
+    for (i = 0; i < h; i++)
+        av_rdft_calc(s->hrdft[plane], s->rdft_hdata[plane] + i * s->rdft_hlen[plane]);
 }
 
 /*Vertical pass - RDFT*/
 static void rdft_vertical(FFTFILTContext *s, int h, int plane)
 {
     int i, j;
-    s->rdft = av_rdft_init(s->rdft_vbits[plane], DFT_R2C);
 
     for (i = 0; i < s->rdft_hlen[plane]; i++) {
         for (j = 0; j < h; j++)
@@ -125,33 +159,29 @@ static void rdft_vertical(FFTFILTContext *s, int h, int plane)
     }
 
     for (i = 0; i < s->rdft_hlen[plane]; i++)
-        av_rdft_calc(s->rdft, s->rdft_vdata[plane] + i * s->rdft_vlen[plane]);
-
-    av_rdft_end(s->rdft);
+        av_rdft_calc(s->vrdft[plane], s->rdft_vdata[plane] + i * s->rdft_vlen[plane]);
 }
 /*Vertical pass - IRDFT*/
 static void irdft_vertical(FFTFILTContext *s, int h, int plane)
 {
     int i, j;
-    s->rdft = av_rdft_init(s->rdft_vbits[plane], IDFT_C2R);
+
     for (i = 0; i < s->rdft_hlen[plane]; i++)
-        av_rdft_calc(s->rdft, s->rdft_vdata[plane] + i * s->rdft_vlen[plane]);
+        av_rdft_calc(s->ivrdft[plane], s->rdft_vdata[plane] + i * s->rdft_vlen[plane]);
 
     for (i = 0; i < s->rdft_hlen[plane]; i++)
         for (j = 0; j < h; j++)
             s->rdft_hdata[plane][j * s->rdft_hlen[plane] + i] =
             s->rdft_vdata[plane][i * s->rdft_vlen[plane] + j];
-
-    av_rdft_end(s->rdft);
 }
 
 /*Horizontal pass - IRDFT*/
-static void irdft_horizontal(FFTFILTContext *s, AVFrame *out, int w, int h, int plane)
+static void irdft_horizontal8(FFTFILTContext *s, AVFrame *out, int w, int h, int plane)
 {
     int i, j;
-    s->rdft = av_rdft_init(s->rdft_hbits[plane], IDFT_C2R);
+
     for (i = 0; i < h; i++)
-        av_rdft_calc(s->rdft, s->rdft_hdata[plane] + i * s->rdft_hlen[plane]);
+        av_rdft_calc(s->ihrdft[plane], s->rdft_hdata[plane] + i * s->rdft_hlen[plane]);
 
     for (i = 0; i < h; i++)
         for (j = 0; j < w; j++)
@@ -159,8 +189,24 @@ static void irdft_horizontal(FFTFILTContext *s, AVFrame *out, int w, int h, int
                                                                          *s->rdft_hlen[plane] + j] * 4 /
                                                                          (s->rdft_hlen[plane] *
                                                                           s->rdft_vlen[plane]), 0, 255);
+}
+
+static void irdft_horizontal16(FFTFILTContext *s, AVFrame *out, int w, int h, int plane)
+{
+    uint16_t *dst = (uint16_t *)out->data[plane];
+    int linesize = out->linesize[plane] / 2;
+    int max = (1 << s->depth) - 1;
+    int i, j;
 
-    av_rdft_end(s->rdft);
+    for (i = 0; i < h; i++)
+        av_rdft_calc(s->ihrdft[plane], s->rdft_hdata[plane] + i * s->rdft_hlen[plane]);
+
+    for (i = 0; i < h; i++)
+        for (j = 0; j < w; j++)
+            *(dst + linesize * i + j) = av_clip(s->rdft_hdata[plane][i
+                                                *s->rdft_hlen[plane] + j] * 4 /
+                                                (s->rdft_hlen[plane] *
+                                                s->rdft_vlen[plane]), 0, max);
 }
 
 static av_cold int initialize(AVFilterContext *ctx)
@@ -197,17 +243,43 @@ static av_cold int initialize(AVFilterContext *ctx)
     return ret;
 }
 
+static void do_eval(FFTFILTContext *s, AVFilterLink *inlink, int plane)
+{
+    double values[VAR_VARS_NB];
+    int i, j;
+
+    values[VAR_N] = inlink->frame_count_out;
+    values[VAR_W] = s->planewidth[plane];
+    values[VAR_H] = s->planeheight[plane];
+
+    for (i = 0; i < s->rdft_hlen[plane]; i++) {
+        values[VAR_X] = i;
+        for (j = 0; j < s->rdft_vlen[plane]; j++) {
+            values[VAR_Y] = j;
+            s->weight[plane][i * s->rdft_vlen[plane] + j] =
+            av_expr_eval(s->weight_expr[plane], values, s);
+        }
+    }
+}
+
 static int config_props(AVFilterLink *inlink)
 {
     FFTFILTContext *s = inlink->dst->priv;
     const AVPixFmtDescriptor *desc;
-    int rdft_hbits, rdft_vbits, i, j, plane;
-    double values[VAR_VARS_NB];
+    int rdft_hbits, rdft_vbits, i, plane;
 
     desc = av_pix_fmt_desc_get(inlink->format);
+    s->depth = desc->comp[0].depth;
+    s->planewidth[1] = s->planewidth[2] = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
+    s->planewidth[0] = s->planewidth[3] = inlink->w;
+    s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
+    s->planeheight[0] = s->planeheight[3] = inlink->h;
+
+    s->nb_planes = av_pix_fmt_count_planes(inlink->format);
+
     for (i = 0; i < desc->nb_components; i++) {
-        int w = inlink->w;
-        int h = inlink->h;
+        int w = s->planewidth[i];
+        int h = s->planeheight[i];
 
         /* RDFT - Array initialization for Horizontal pass*/
         for (rdft_hbits = 1; 1 << rdft_hbits < w*10/9; rdft_hbits++);
@@ -216,31 +288,41 @@ static int config_props(AVFilterLink *inlink)
         if (!(s->rdft_hdata[i] = av_malloc_array(h, s->rdft_hlen[i] * sizeof(FFTSample))))
             return AVERROR(ENOMEM);
 
+        if (!(s->hrdft[i] = av_rdft_init(s->rdft_hbits[i], DFT_R2C)))
+            return AVERROR(ENOMEM);
+        if (!(s->ihrdft[i] = av_rdft_init(s->rdft_hbits[i], IDFT_C2R)))
+            return AVERROR(ENOMEM);
+
         /* RDFT - Array initialization for Vertical pass*/
         for (rdft_vbits = 1; 1 << rdft_vbits < h*10/9; rdft_vbits++);
         s->rdft_vbits[i] = rdft_vbits;
         s->rdft_vlen[i] = 1 << rdft_vbits;
         if (!(s->rdft_vdata[i] = av_malloc_array(s->rdft_hlen[i], s->rdft_vlen[i] * sizeof(FFTSample))))
             return AVERROR(ENOMEM);
+
+        if (!(s->vrdft[i] = av_rdft_init(s->rdft_vbits[i], DFT_R2C)))
+            return AVERROR(ENOMEM);
+        if (!(s->ivrdft[i] = av_rdft_init(s->rdft_vbits[i], IDFT_C2R)))
+            return AVERROR(ENOMEM);
     }
 
     /*Luminance value - Array initialization*/
-    values[VAR_W] = inlink->w;
-    values[VAR_H] = inlink->h;
-    for (plane = 0; plane < 3; plane++)
-    {
+    for (plane = 0; plane < 3; plane++) {
         if(!(s->weight[plane] = av_malloc_array(s->rdft_hlen[plane], s->rdft_vlen[plane] * sizeof(double))))
             return AVERROR(ENOMEM);
-        for (i = 0; i < s->rdft_hlen[plane]; i++)
-        {
-            values[VAR_X] = i;
-            for (j = 0; j < s->rdft_vlen[plane]; j++)
-            {
-                values[VAR_Y] = j;
-                s->weight[plane][i * s->rdft_vlen[plane] + j] =
-                av_expr_eval(s->weight_expr[plane], values, s);
-            }
-        }
+
+        if (s->eval_mode == EVAL_MODE_INIT)
+            do_eval(s, inlink, plane);
+    }
+
+    if (s->depth <= 8) {
+        s->rdft_horizontal = rdft_horizontal8;
+        s->irdft_horizontal = irdft_horizontal8;
+    } else if (s->depth > 8) {
+        s->rdft_horizontal = rdft_horizontal16;
+        s->irdft_horizontal = irdft_horizontal16;
+    } else {
+        return AVERROR_BUG;
     }
     return 0;
 }
@@ -249,28 +331,26 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
 {
     AVFilterContext *ctx = inlink->dst;
     AVFilterLink *outlink = inlink->dst->outputs[0];
-    const AVPixFmtDescriptor *desc;
     FFTFILTContext *s = ctx->priv;
     AVFrame *out;
     int i, j, plane;
 
     out = ff_get_video_buffer(outlink, inlink->w, inlink->h);
-    if (!out)
+    if (!out) {
+        av_frame_free(&in);
         return AVERROR(ENOMEM);
+    }
 
     av_frame_copy_props(out, in);
 
-    desc = av_pix_fmt_desc_get(inlink->format);
-    for (plane = 0; plane < desc->nb_components; plane++) {
-        int w = inlink->w;
-        int h = inlink->h;
+    for (plane = 0; plane < s->nb_planes; plane++) {
+        int w = s->planewidth[plane];
+        int h = s->planeheight[plane];
 
-        if (plane == 1 || plane == 2) {
-            w = FF_CEIL_RSHIFT(w, desc->log2_chroma_w);
-            h = FF_CEIL_RSHIFT(h, desc->log2_chroma_h);
-        }
+        if (s->eval_mode == EVAL_MODE_FRAME)
+            do_eval(s, inlink, plane);
 
-        rdft_horizontal(s, in, w, h, plane);
+        s->rdft_horizontal(s, in, w, h, plane);
         rdft_vertical(s, h, plane);
 
         /*Change user defined parameters*/
@@ -282,7 +362,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
         s->rdft_vdata[plane][0] += s->rdft_hlen[plane] * s->rdft_vlen[plane] * s->dc[plane];
 
         irdft_vertical(s, h, plane);
-        irdft_horizontal(s, out, w, h, plane);
+        s->irdft_horizontal(s, out, w, h, plane);
     }
 
     av_frame_free(&in);
@@ -298,6 +378,10 @@ static av_cold void uninit(AVFilterContext *ctx)
         av_free(s->rdft_vdata[i]);
         av_expr_free(s->weight_expr[i]);
         av_free(s->weight[i]);
+        av_rdft_end(s->hrdft[i]);
+        av_rdft_end(s->ihrdft[i]);
+        av_rdft_end(s->vrdft[i]);
+        av_rdft_end(s->ivrdft[i]);
     }
 }
 
@@ -305,7 +389,18 @@ static int query_formats(AVFilterContext *ctx)
 {
     static const enum AVPixelFormat pixel_fmts_fftfilt[] = {
         AV_PIX_FMT_GRAY8,
-        AV_PIX_FMT_YUV444P,
+        AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P,
+        AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVJ420P,
+        AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVJ422P,
+        AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10,
+        AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV420P14,
+        AV_PIX_FMT_YUV420P16,
+        AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV422P10,
+        AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV422P14,
+        AV_PIX_FMT_YUV422P16,
+        AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV444P10,
+        AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV444P14,
+        AV_PIX_FMT_YUV444P16,
         AV_PIX_FMT_NONE
     };
 
@@ -335,7 +430,7 @@ static const AVFilterPad fftfilt_outputs[] = {
 
 AVFilter ff_vf_fftfilt = {
     .name            = "fftfilt",
-    .description     = NULL_IF_CONFIG_SMALL("Apply arbitrary expressions to samples in frequency domain."),
+    .description     = NULL_IF_CONFIG_SMALL("Apply arbitrary expressions to pixels in frequency domain."),
     .priv_size       = sizeof(FFTFILTContext),
     .priv_class      = &fftfilt_class,
     .inputs          = fftfilt_inputs,
@@ -343,4 +438,5 @@ AVFilter ff_vf_fftfilt = {
     .query_formats   = query_formats,
     .init            = initialize,
     .uninit          = uninit,
+    .flags           = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };