[PATCH 2/2] Add rotate filter.

Stefano Sabatini stefano.sabatini-lala
Sun Oct 3 12:20:14 CEST 2010


---
 configure                         |    1 +
 libavfilter/Makefile              |    1 +
 libavfilter/allfilters.c          |    1 +
 libavfilter/vf_rotate.c           |  473 +++++++++++++++++++++++++++++++++++++
 tests/lavfi-regression.sh         |    1 +
 tests/ref/lavfi/pixfmts_rotate_le |   18 ++
 6 files changed, 495 insertions(+), 0 deletions(-)
 create mode 100644 libavfilter/vf_rotate.c
 create mode 100644 tests/ref/lavfi/pixfmts_rotate_le

diff --git a/configure b/configure
index cfd26f9..2e1bcf3 100755
--- a/configure
+++ b/configure
@@ -1518,6 +1518,7 @@ set_ne_test_deps pixfmts_crop
 set_ne_test_deps pixfmts_hflip
 set_ne_test_deps pixfmts_null
 set_ne_test_deps pixfmts_pad
+set_ne_test_deps pixfmts_rotate
 set_ne_test_deps pixfmts_scale
 set_ne_test_deps pixfmts_vflip
 
diff --git a/libavfilter/Makefile b/libavfilter/Makefile
index a0407a5..177a3f1 100644
--- a/libavfilter/Makefile
+++ b/libavfilter/Makefile
@@ -35,6 +35,7 @@ OBJS-$(CONFIG_OCV_SMOOTH_FILTER)             += vf_libopencv.o
 OBJS-$(CONFIG_PAD_FILTER)                    += vf_pad.o
 OBJS-$(CONFIG_PIXDESCTEST_FILTER)            += vf_pixdesctest.o
 OBJS-$(CONFIG_PIXELASPECT_FILTER)            += vf_aspect.o
+OBJS-$(CONFIG_ROTATE_FILTER)                 += vf_rotate.o
 OBJS-$(CONFIG_SCALE_FILTER)                  += vf_scale.o
 OBJS-$(CONFIG_SLICIFY_FILTER)                += vf_slicify.o
 OBJS-$(CONFIG_UNSHARP_FILTER)                += vf_unsharp.o
diff --git a/libavfilter/allfilters.c b/libavfilter/allfilters.c
index c5da648..944c7ec 100644
--- a/libavfilter/allfilters.c
+++ b/libavfilter/allfilters.c
@@ -54,6 +54,7 @@ void avfilter_register_all(void)
     REGISTER_FILTER (PAD,         pad,         vf);
     REGISTER_FILTER (PIXDESCTEST, pixdesctest, vf);
     REGISTER_FILTER (PIXELASPECT, pixelaspect, vf);
+    REGISTER_FILTER (ROTATE,      rotate,      vf);
     REGISTER_FILTER (SCALE,       scale,       vf);
     REGISTER_FILTER (SLICIFY,     slicify,     vf);
     REGISTER_FILTER (UNSHARP,     unsharp,     vf);
diff --git a/libavfilter/vf_rotate.c b/libavfilter/vf_rotate.c
new file mode 100644
index 0000000..3ec43f7
--- /dev/null
+++ b/libavfilter/vf_rotate.c
@@ -0,0 +1,473 @@
+/*
+ * Copyright (C) 2010 Stefano Sabatini
+ * Copyright (C) 2008 Vitor Sessak
+ *
+ * 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
+ * rotation filter
+ *
+ * @todo handle planar pixel and more packed formats in the non-float path
+*/
+
+#include "libavutil/eval.h"
+#include "libavutil/intreadwrite.h"
+#include "libavutil/pixdesc.h"
+#include "avfilter.h"
+#include "drawutils.h"
+#include "parseutils.h"
+
+static const char *var_names[] = {
+    "E",
+    "PHI",
+    "PI",
+    "w",            ///< width  of the input video
+    "h",            ///< height of the input video
+    "n",            ///< number of frame
+    "t",            ///< timestamp expressed in seconds
+    NULL
+};
+
+enum var_name {
+    VAR_E,
+    VAR_PHI,
+    VAR_PI,
+    VAR_W,
+    VAR_H,
+    VAR_N,
+    VAR_T,
+    VAR_VARS_NB
+};
+
+#define FIXP (1<<16)
+#define INT_PI 205887 //(M_PI * FIXP)
+
+/**
+ * Compute the sin of a using integer values.
+ * Input and output values are scaled by FIXP.
+ */
+static int64_t int_sin(int64_t a)
+{
+    int64_t a2, res = 0;
+    int i;
+    if (a < 0) a = INT_PI-a; // 0..inf
+    a %= 2 * INT_PI;         // 0..2PI
+
+    if (a >= INT_PI*3/2) a -= 2*INT_PI;  // -PI/2 .. 3PI/2
+    if (a >= INT_PI/2  ) a = INT_PI - a; // -PI/2 ..  PI/2
+
+    /* compute sin using sin Taylor series approximated to the third term */
+    a2 = (a*a)/FIXP;
+    for (i=2; i<7; i+=2) {
+        res += a;
+        a = -a*a2/(FIXP*i*(i+1));
+    }
+    return res;
+}
+
+/**
+ * Interpolate the color in src at position x and y using bilinear
+ * interpolation.
+ *
+ * @param dst_color put here the destination color
+ */
+static uint8_t *ipol(uint8_t *dst_color,
+                     const uint8_t *src, int src_linesize, int src_linestep,
+                     int x, int y, int max_x, int max_y)
+{
+    int int_x = x>>16;
+    int int_y = y>>16;
+    int frac_x = x&0xFFFF;
+    int frac_y = y&0xFFFF;
+    int i;
+    int int_x1 = FFMIN(int_x+1,max_x);
+    int int_y1 = FFMIN(int_y+1,max_y);
+
+    for (i = 0; i < src_linestep; i++) {
+        int s00 = src[src_linestep * int_x  + i + src_linesize * int_y ];
+        int s01 = src[src_linestep * int_x1 + i + src_linesize * int_y ];
+        int s10 = src[src_linestep * int_x  + i + src_linesize * int_y1];
+        int s11 = src[src_linestep * int_x1 + i + src_linesize * int_y1];
+        int s0 = (((1<<16) - frac_x)*s00 + frac_x*s01)>>8;
+        int s1 = (((1<<16) - frac_x)*s10 + frac_x*s11)>>8;
+
+        dst_color[i] = (((1<<16) - frac_y)*s0 + frac_y*s1)>>24;
+    }
+
+    return dst_color;
+}
+
+typedef struct {
+    const AVClass *class;
+    int angle;
+    char *angle_expr;       ///< expression for the angle
+    AVExpr *angle_pexpr;    ///< parsed expression for the angle
+    uint8_t bgcolor[4];     ///< color expressed either in YUVA or RGBA colorspace for the padding area
+    char *bgcolor_str;
+    int hsub, vsub;
+    int nb_planes;
+    int use_float;
+    int use_bilinear;
+    int keep_same_size;
+    uint8_t *line[4];
+    int      linestep[4];
+    float transx, transy; ///< how much to translate (in pixels)
+    float sinx, cosx;
+    int output_h, output_w;
+    double var_values[VAR_VARS_NB];
+} RotContext;
+
+#define OFFSET(x) offsetof(RotContext, x)
+
+static const AVOption rot_options[]= {
+    {"angle",    "set angle expression", OFFSET(angle_expr),     FF_OPT_TYPE_STRING, 0,  CHAR_MIN, CHAR_MAX },
+    {"bgcolor",  "set background color", OFFSET(bgcolor_str),    FF_OPT_TYPE_STRING, 0,  CHAR_MIN, CHAR_MAX },
+    {"float",    "use float path",       OFFSET(use_float),      FF_OPT_TYPE_INT,    0,         0,        1 },
+    {"ss",       "keep same size",       OFFSET(keep_same_size), FF_OPT_TYPE_INT,    0,         0,        1 },
+    {"bilinear", "use bilinear interpolation", OFFSET(use_bilinear), FF_OPT_TYPE_INT, 1,        0,        1 },
+    {NULL},
+};
+
+static const char *rot_get_name(void *ctx)
+{
+    return "rot";
+}
+
+static const AVClass rot_class = {
+    "RotContext",
+    rot_get_name,
+    rot_options
+};
+
+static av_cold int init(AVFilterContext *ctx, const char *args, void *opaque)
+{
+    RotContext *rot = ctx->priv;
+    int ret;
+
+    rot->class = &rot_class;
+    av_opt_set_defaults2(rot, 0, 0);
+    rot->bgcolor_str = av_strdup("black");
+    rot->angle_expr  = av_strdup("45");
+
+    if (args && (ret = (av_set_options_string(rot, args, "=", ":"))) < 0) {
+        av_log(ctx, AV_LOG_ERROR, "Error parsing options string: '%s'\n", args);
+        return ret;
+    }
+
+    if ((ret = av_parse_color(rot->bgcolor, rot->bgcolor_str, ctx)) < 0)
+        return ret;
+
+    return 0;
+}
+
+static av_cold void uninit(AVFilterContext *ctx)
+{
+    RotContext *rot = ctx->priv;
+    int i;
+
+    for (i = 0; i < 4; i++) {
+        av_freep(&rot->line[i]);
+        rot->linestep[i] = 0;
+    }
+
+    av_freep(&rot->bgcolor_str);
+    av_freep(&rot->angle_expr);
+}
+
+static int query_formats(AVFilterContext *ctx)
+{
+    RotContext *rot = ctx->priv;
+
+    static enum PixelFormat pix_fmts_float[] = {
+        PIX_FMT_YUV444P,  PIX_FMT_YUV422P,  PIX_FMT_YUV420P,
+        PIX_FMT_YUV411P,  PIX_FMT_YUV410P,
+        PIX_FMT_YUVJ444P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ420P,
+        PIX_FMT_YUV440P,  PIX_FMT_YUVJ440P,
+        PIX_FMT_NONE
+    };
+    static enum PixelFormat pix_fmts_non_float[] = {
+        PIX_FMT_ARGB,         PIX_FMT_RGBA,
+        PIX_FMT_ABGR,         PIX_FMT_BGRA,
+        PIX_FMT_RGB24,        PIX_FMT_BGR24,
+        PIX_FMT_GRAY8,
+        PIX_FMT_YUV444P,      PIX_FMT_YUVJ444P,
+/*         PIX_FMT_YUV422P,  PIX_FMT_YUV420P, */
+/*         PIX_FMT_YUV411P,  PIX_FMT_YUV410P, */
+/*         PIX_FMT_YUVJ444P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ420P, */
+/*         PIX_FMT_YUV440P,  PIX_FMT_YUVJ440P, */
+        PIX_FMT_NONE
+    };
+
+    avfilter_set_common_formats(
+        ctx, avfilter_make_format_list(rot->use_float ? pix_fmts_float : pix_fmts_non_float));
+    return 0;
+}
+
+static int config_props_output(AVFilterLink *outlink)
+{
+    AVFilterContext *ctx = outlink->src;
+    RotContext *rot = ctx->priv;
+    AVFilterLink *inlink = ctx->inputs[0];
+    const AVPixFmtDescriptor *pixdesc = &av_pix_fmt_descriptors[inlink->format];
+    uint8_t rgba_color[4];
+    int i, is_packed_rgba, ret;
+    double res;
+
+    rot->var_values[VAR_E]   = M_E;
+    rot->var_values[VAR_PHI] = M_PHI;
+    rot->var_values[VAR_PI]  = M_PI;
+    rot->var_values[VAR_W]   = ctx->inputs[0]->w;
+    rot->var_values[VAR_H]   = ctx->inputs[0]->h;
+    rot->var_values[VAR_N]   = 0;
+    rot->var_values[VAR_T]   = NAN;
+
+    if ((ret = av_parse_expr(&rot->angle_pexpr, rot->angle_expr, var_names,
+                             NULL, NULL, NULL, NULL, 0, ctx)) < 0)
+        return ret;
+    if (!rot->keep_same_size) {
+        res = av_eval_expr(rot->angle_pexpr, rot->var_values, NULL);
+        if (isnan(res)) {
+            av_log(ctx, AV_LOG_ERROR, "Invalid angle expression '%s', evaluates to nan.\n", rot->angle_expr);
+            return AVERROR(EINVAL);
+        }
+        rot->angle = res;
+    }
+
+    rot->hsub = pixdesc->log2_chroma_w;
+    rot->vsub = pixdesc->log2_chroma_h;
+
+    /* compute number of planes */
+    rot->nb_planes = 0;
+    for (i = 0; i < 4; i++) {
+        const AVComponentDescriptor *comp = &(pixdesc->comp[i]);
+        rot->nb_planes = FFMAX(rot->nb_planes, comp->plane);
+    }
+    rot->nb_planes++;
+
+    if (rot->keep_same_size) {
+        outlink->w = inlink->w;
+        outlink->h = inlink->h;
+    } else {
+        rot->sinx = sin(rot->angle*M_PI/180.0);
+        rot->cosx = cos(rot->angle*M_PI/180.0);
+
+        rot->transx = FFMAX(0,  outlink->src->inputs[0]->h * rot->sinx) +
+                      FFMAX(0, -outlink->src->inputs[0]->w * rot->cosx);
+        rot->transy = FFMAX(0, -outlink->src->inputs[0]->h * rot->cosx) +
+                      FFMAX(0, -outlink->src->inputs[0]->w * rot->sinx);
+        rot->output_w = rot->transx + FFMAX(0,  rot->cosx * outlink->src->inputs[0]->w) +
+                                      FFMAX(0, -rot->sinx * outlink->src->inputs[0]->h);
+        rot->output_h = rot->transy + FFMAX(0,  rot->cosx * outlink->src->inputs[0]->h) +
+                                      FFMAX(0,  rot->sinx * outlink->src->inputs[0]->w);
+        outlink->w = rot->output_w;
+        outlink->h = rot->output_h;
+    }
+
+    memcpy(rgba_color, rot->bgcolor, sizeof(rgba_color));
+    ff_fill_line_with_color(rot->line, rot->linestep, outlink->w, rot->bgcolor,
+                            outlink->format, rgba_color, &is_packed_rgba);
+
+    av_log(ctx, AV_LOG_INFO, "angle:%d in_h:%d out_h:%d -> out_w:%d out_h:%d bgcolor:0x%02X%02X%02X%02X[%s]\n",
+           rot->angle, inlink->w, inlink->h, outlink->w, outlink->h,
+           rot->bgcolor[0], rot->bgcolor[1], rot->bgcolor[2], rot->bgcolor[3],
+           is_packed_rgba ? "rgba" : "yuva");
+
+    return 0;
+}
+
+static void start_frame(AVFilterLink *inlink, AVFilterBufferRef *picref)
+{
+    AVFilterLink *outlink = inlink->dst->outputs[0];
+    AVFilterBufferRef *outpicref;
+
+    outlink->out_buf = avfilter_get_video_buffer(outlink, AV_PERM_WRITE, outlink->w, outlink->h);
+    outpicref = outlink->out_buf;
+    avfilter_copy_buffer_ref_props(outpicref, picref);
+    outpicref->video->w = outlink->w;
+    outpicref->video->h = outlink->h;
+
+    avfilter_start_frame(outlink, avfilter_ref_buffer(outpicref, ~0));
+}
+
+static void null_draw_slice(AVFilterLink *link, int y, int h, int slice_dir) { }
+
+static void filter_frame_float(AVFilterContext *ctx,
+                               AVFilterBufferRef *in, AVFilterBufferRef *out)
+{
+    RotContext *rot = ctx->priv;
+    int i, j, plane;
+
+    /* luma plane */
+    for (i = 0; i < rot->output_h; i++)
+        for (j = 0; j < rot->output_w; j++) {
+            int line   = (i - rot->transy)*rot->sinx +
+                         (j - rot->transx)*rot->cosx + 0.5;
+            int column = (i - rot->transy)*rot->cosx -
+                         (j - rot->transx)*rot->sinx + 0.5;
+            if (line < 0   || line >= in->video->w ||
+                column < 0 || column >= in->video->h)
+                *(out->data[0] +      i*out->linesize[0] + j) = rot->bgcolor[0];
+            else
+                *(out->data[0] +      i*out->linesize[0] + j) =
+                *( in->data[0] + column*in ->linesize[0] + line);
+        }
+
+    /* chroma planes */
+    for (plane = 1; plane < 3; plane ++)
+        for (i = 0 >> rot->vsub; i < rot->output_h >> rot->vsub; i++)
+            for (j = 0; j < rot->output_w >> rot->hsub; j++) {
+                int i2 = (i + rot->vsub/2) << rot->vsub;
+                int j2 = (j + rot->hsub/2) << rot->hsub;
+                int line =   (i2 - rot->transy)*rot->sinx +
+                             (j2 - rot->transx)*rot->cosx + 0.5;
+                int column = (i2 - rot->transy)*rot->cosx -
+                             (j2 - rot->transx)*rot->sinx + 0.5;
+                if (line   < 0 || line   >= in->video->w ||
+                    column < 0 || column >= in->video->h) {
+                    *(out->data[plane] +   i*out->linesize[plane] + j) = rot->bgcolor[plane];
+                } else {
+                    line   = (line   + rot->hsub/2) >> rot->hsub;
+                    column = (column + rot->vsub/2) >> rot->vsub;
+
+                    *(out->data[plane] +      i*out->linesize[plane] + j   ) =
+                    *(in ->data[plane] + column*in ->linesize[plane] + line);
+                }
+            }
+}
+
+static void filter_frame_int(AVFilterContext *ctx,
+                             AVFilterBufferRef *in, AVFilterBufferRef *out)
+{
+    RotContext *rot = ctx->priv;
+    int radian = 2 * rot->angle * INT_PI/360;
+    const int s = int_sin(radian           );
+    const int c = int_sin(radian + INT_PI/2);
+    int plane;
+
+    /* fill with the backcolor */
+    ff_draw_rectangle(out->data, out->linesize,
+                      rot->line, rot->linestep, rot->hsub, rot->vsub,
+                      0, 0, out->video->w, out->video->h);
+
+    for (plane = 0; plane < rot->nb_planes; plane++) {
+        int hsub = plane == 1 || plane == 2 ? rot->hsub : 0;
+        int vsub = plane == 1 || plane == 2 ? rot->vsub : 0;
+        int inw  = in ->video->w >> hsub;
+        int inh  = in ->video->h >> vsub;
+        int outw = out->video->w >> hsub;
+        int outh = out->video->h >> vsub;
+        const int xi = -outw/2 * c;
+        const int yi =  outw/2 * s;
+        int xprime = -outh/2 * s;
+        int yprime = -outh/2 * c;
+        int i, j, x, y;
+
+        for (j = 0; j < outh; j++) {
+            x = xprime + xi + FIXP*inw/2;
+            y = yprime + yi + FIXP*inh/2;
+
+            for (i = 0; i < outw; i++) {
+                int32_t v;
+                int x1, y1;
+                uint8_t *pin, *pout;
+                x += c;
+                y -= s;
+                x1 = x>>16;
+                y1 = y>>16;
+                if (x1 >= 0 && x1 < inw && y1 >= 0 && y1 < inh) {
+                    av_unused uint8_t inp_inv[4]; /* interpolated input value */
+                    pout = out->data[plane] + j * out->linesize[plane] + i * rot->linestep[plane];
+                    if (rot->use_bilinear)
+                        pin = ipol(inp_inv, in->data[plane], in->linesize[plane], rot->linestep[plane],
+                                   x, y, inw-1, inh-1);
+                    else
+                        pin = in->data[plane] + y1 * in ->linesize[plane] + x1 * rot->linestep[plane];
+
+                    switch (rot->linestep[plane]) {
+                    case 1:
+                        *pout = *pin;
+                        break;
+                    case 2:
+                        *((uint16_t *)pout) = *((uint16_t *)pin);
+                        break;
+                    case 3:
+                        v = AV_RB24(pin);
+                        AV_WB24(pout, v);
+                        break;
+                    case 4:
+                        *((uint32_t *)pout) = *((uint32_t *)pin);
+                        break;
+                    }
+                }
+            }
+            xprime += s;
+            yprime += c;
+        }
+    }
+}
+
+static void end_frame(AVFilterLink *inlink)
+{
+    AVFilterContext *ctx = inlink->dst;
+    RotContext *rot = ctx->priv;
+    AVFilterBufferRef *in  = inlink->cur_buf;
+    AVFilterBufferRef *out = ctx->outputs[0]->out_buf;
+
+    if (rot->keep_same_size) {
+        double res;
+        rot->var_values[VAR_T] = in->pts == AV_NOPTS_VALUE ? NAN : (double)in->pts / AV_TIME_BASE;
+        res = av_eval_expr(rot->angle_pexpr, rot->var_values, NULL);
+        if (!isnan(res))
+            rot->angle = res;
+        rot->var_values[VAR_N] += 1.0;
+    }
+
+    if (rot->use_float)
+        filter_frame_float(ctx, in, out);
+    else
+        filter_frame_int(ctx, in, out);
+
+    avfilter_unref_buffer(in);
+    avfilter_draw_slice(ctx->outputs[0], 0, out->video->h, 1);
+    avfilter_end_frame(ctx->outputs[0]);
+    avfilter_unref_buffer(out);
+}
+
+AVFilter avfilter_vf_rotate = {
+    .name      = "rotate",
+    .description = NULL_IF_CONFIG_SMALL("Rotate the input image."),
+    .init      = init,
+    .uninit    = uninit,
+
+    .priv_size = sizeof(RotContext),
+
+    .query_formats = query_formats,
+
+    .inputs    = (AVFilterPad[]) {{ .name            = "default",
+                                    .type            = AVMEDIA_TYPE_VIDEO,
+                                    .start_frame     = start_frame,
+                                    .draw_slice      = null_draw_slice,
+                                    .end_frame       = end_frame,
+                                    .min_perms       = AV_PERM_READ, },
+                                  { .name = NULL}},
+    .outputs   = (AVFilterPad[]) {{ .name            = "default",
+                                    .config_props    = config_props_output,
+                                    .type            = AVMEDIA_TYPE_VIDEO, },
+                                  { .name = NULL}},
+};
diff --git a/tests/lavfi-regression.sh b/tests/lavfi-regression.sh
index a3e75dd..348263a 100755
--- a/tests/lavfi-regression.sh
+++ b/tests/lavfi-regression.sh
@@ -62,6 +62,7 @@ do_lavfi_pixfmts "crop"    "100:100:100:100"
 do_lavfi_pixfmts "hflip"   ""
 do_lavfi_pixfmts "null"    ""
 do_lavfi_pixfmts "pad"     "500:400:20:20"
+do_lavfi_pixfmts "rotate"  ""
 do_lavfi_pixfmts "scale"   "200:100"
 do_lavfi_pixfmts "vflip"   ""
 
diff --git a/tests/ref/lavfi/pixfmts_rotate_le b/tests/ref/lavfi/pixfmts_rotate_le
new file mode 100644
index 0000000..f0a3d23
--- /dev/null
+++ b/tests/ref/lavfi/pixfmts_rotate_le
@@ -0,0 +1,18 @@
+eab6316d1462171052c6fb861f750755 *./tests/data/lavfi/pixfmts_rotate_le-abgr.nut
+40862303 ./tests/data/lavfi/pixfmts_rotate_le-abgr.nut
+6d763fae9a14e5c54511da8fc36f2de6 *./tests/data/lavfi/pixfmts_rotate_le-argb.nut
+40862303 ./tests/data/lavfi/pixfmts_rotate_le-argb.nut
+fd209cd7505f1274b98287bf6371ed00 *./tests/data/lavfi/pixfmts_rotate_le-bgr24.nut
+30647103 ./tests/data/lavfi/pixfmts_rotate_le-bgr24.nut
+5e4d177bee05b6861a3ad3b25f0d4d6a *./tests/data/lavfi/pixfmts_rotate_le-bgra.nut
+40862303 ./tests/data/lavfi/pixfmts_rotate_le-bgra.nut
+9015c715e63cc47f43bb3c0646269e3a *./tests/data/lavfi/pixfmts_rotate_le-gray.nut
+10216654 ./tests/data/lavfi/pixfmts_rotate_le-gray.nut
+4b6d1a72eb4f83aac217e567ce1bf984 *./tests/data/lavfi/pixfmts_rotate_le-rgb24.nut
+30647103 ./tests/data/lavfi/pixfmts_rotate_le-rgb24.nut
+352a46578fc3f7cc59acffc843d837cb *./tests/data/lavfi/pixfmts_rotate_le-rgba.nut
+40862303 ./tests/data/lavfi/pixfmts_rotate_le-rgba.nut
+bca7578a4b5c3981318b04d1f56e61cc *./tests/data/lavfi/pixfmts_rotate_le-yuv444p.nut
+30647103 ./tests/data/lavfi/pixfmts_rotate_le-yuv444p.nut
+7c53e427e7dc8e6bdcb7b3a04722c0ee *./tests/data/lavfi/pixfmts_rotate_le-yuvj444p.nut
+30647103 ./tests/data/lavfi/pixfmts_rotate_le-yuvj444p.nut
-- 
1.7.1


--jI8keyz6grp/JLjh--



More information about the ffmpeg-devel mailing list