[FFmpeg-devel] [PATCH] avfilter: split negate filter from lut filter
Paul B Mahol
onemda at gmail.com
Tue Oct 26 23:09:09 EEST 2021
Using luts for negating is suboptimal.
FATE test changes because filter no longer clips values into limited color range.
Signed-off-by: Paul B Mahol <onemda at gmail.com>
---
doc/filters.texi | 13 ++
libavfilter/Makefile | 2 +-
libavfilter/vf_lut.c | 28 ---
libavfilter/vf_negate.c | 375 +++++++++++++++++++++++++++++++++++
tests/ref/fate/filter-negate | 100 +++++-----
5 files changed, 439 insertions(+), 79 deletions(-)
create mode 100644 libavfilter/vf_negate.c
diff --git a/doc/filters.texi b/doc/filters.texi
index 4f717527e5..770efa6ee1 100644
--- a/doc/filters.texi
+++ b/doc/filters.texi
@@ -15607,6 +15607,19 @@ Negate (invert) the input video.
It accepts the following option:
@table @option
+ at item components
+Set components to negate.
+
+Available values for components are:
+ at table @samp
+ at item y
+ at item u
+ at item v
+ at item a
+ at item r
+ at item g
+ at item b
+ at end table
@item negate_alpha
With value 1, it negates the alpha component, if present. Default value is 0.
diff --git a/libavfilter/Makefile b/libavfilter/Makefile
index eb5365a739..4e6d8bdeea 100644
--- a/libavfilter/Makefile
+++ b/libavfilter/Makefile
@@ -351,7 +351,7 @@ OBJS-$(CONFIG_MIX_FILTER) += vf_mix.o framesync.o
OBJS-$(CONFIG_MONOCHROME_FILTER) += vf_monochrome.o
OBJS-$(CONFIG_MORPHO_FILTER) += vf_morpho.o
OBJS-$(CONFIG_MPDECIMATE_FILTER) += vf_mpdecimate.o
-OBJS-$(CONFIG_NEGATE_FILTER) += vf_lut.o
+OBJS-$(CONFIG_NEGATE_FILTER) += vf_negate.o
OBJS-$(CONFIG_NLMEANS_FILTER) += vf_nlmeans.o
OBJS-$(CONFIG_NLMEANS_OPENCL_FILTER) += vf_nlmeans_opencl.o opencl.o opencl/nlmeans.o
OBJS-$(CONFIG_NNEDI_FILTER) += vf_nnedi.o
diff --git a/libavfilter/vf_lut.c b/libavfilter/vf_lut.c
index 64668039d1..fd5b364797 100644
--- a/libavfilter/vf_lut.c
+++ b/libavfilter/vf_lut.c
@@ -69,7 +69,6 @@ typedef struct LutContext {
int is_planar;
int is_16bit;
int step;
- int negate_alpha; /* only used by negate */
} LutContext;
#define Y 0
@@ -642,30 +641,3 @@ static av_cold int lutrgb_init(AVFilterContext *ctx)
DEFINE_LUT_FILTER(lutrgb, "Compute and apply a lookup table to the RGB input video.",
lut);
#endif
-
-#if CONFIG_NEGATE_FILTER
-
-static const AVOption negate_options[] = {
- { "negate_alpha", NULL, OFFSET(negate_alpha), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
- { NULL }
-};
-
-AVFILTER_DEFINE_CLASS(negate);
-
-static av_cold int negate_init(AVFilterContext *ctx)
-{
- LutContext *s = ctx->priv;
-
- for (int i = 0; i < 4; i++) {
- s->comp_expr_str[i] = av_strdup((i == 3 && !s->negate_alpha) ?
- "val" : "negval");
- if (!s->comp_expr_str[i])
- return AVERROR(ENOMEM);
- }
-
- return 0;
-}
-
-DEFINE_LUT_FILTER(negate, "Negate input video.", negate);
-
-#endif
diff --git a/libavfilter/vf_negate.c b/libavfilter/vf_negate.c
new file mode 100644
index 0000000000..d782e63d3a
--- /dev/null
+++ b/libavfilter/vf_negate.c
@@ -0,0 +1,375 @@
+/*
+ * 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
+ */
+
+#include "libavutil/attributes.h"
+#include "libavutil/common.h"
+#include "libavutil/imgutils.h"
+#include "libavutil/opt.h"
+#include "libavutil/pixdesc.h"
+#include "avfilter.h"
+#include "drawutils.h"
+#include "formats.h"
+#include "internal.h"
+#include "video.h"
+
+#define COMP_R 0x01
+#define COMP_G 0x02
+#define COMP_B 0x04
+#define COMP_A 0x08
+#define COMP_Y 0x10
+#define COMP_U 0x20
+#define COMP_V 0x40
+
+typedef struct ThreadData {
+ AVFrame *in;
+ AVFrame *out;
+} ThreadData;
+
+typedef struct NegateContext {
+ const AVClass *class;
+ int negate_alpha;
+ int max;
+ int requested_components;
+ int components;
+ int planes;
+ int step;
+ int nb_planes;
+ int linesize[4];
+ int width[4];
+ int height[4];
+ uint8_t rgba_map[4];
+
+ void (*negate)(const uint8_t *src, uint8_t *dst,
+ ptrdiff_t slinesize, ptrdiff_t dlinesize,
+ int w, int h, int max, int step,
+ int components);
+} NegateContext;
+
+#define OFFSET(x) offsetof(NegateContext, x)
+#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
+
+static const AVOption negate_options[] = {
+ { "components", "set components to negate", OFFSET(requested_components), AV_OPT_TYPE_FLAGS, {.i64=0x77}, 1, 0xff, FLAGS, "flags"},
+ { "y", "set luma component", 0, AV_OPT_TYPE_CONST, {.i64=COMP_Y}, 0, 0, FLAGS, "flags"},
+ { "u", "set u component", 0, AV_OPT_TYPE_CONST, {.i64=COMP_U}, 0, 0, FLAGS, "flags"},
+ { "v", "set v component", 0, AV_OPT_TYPE_CONST, {.i64=COMP_V}, 0, 0, FLAGS, "flags"},
+ { "r", "set red component", 0, AV_OPT_TYPE_CONST, {.i64=COMP_R}, 0, 0, FLAGS, "flags"},
+ { "g", "set green component", 0, AV_OPT_TYPE_CONST, {.i64=COMP_G}, 0, 0, FLAGS, "flags"},
+ { "b", "set blue component", 0, AV_OPT_TYPE_CONST, {.i64=COMP_B}, 0, 0, FLAGS, "flags"},
+ { "a", "set alpha component", 0, AV_OPT_TYPE_CONST, {.i64=COMP_A}, 0, 0, FLAGS, "flags"},
+ { "negate_alpha", NULL, OFFSET(negate_alpha), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
+ { NULL }
+};
+
+AVFILTER_DEFINE_CLASS(negate);
+
+static const enum AVPixelFormat pix_fmts[] = {
+ AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P,
+ AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV440P,
+ AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,
+ AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
+ AV_PIX_FMT_YUVJ440P,
+ AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV420P9,
+ AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV440P10,
+ AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV440P12,
+ AV_PIX_FMT_YUV444P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV420P14,
+ AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV420P16,
+ AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
+ AV_PIX_FMT_ARGB, AV_PIX_FMT_RGBA,
+ AV_PIX_FMT_ABGR, AV_PIX_FMT_BGRA,
+ AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24,
+ AV_PIX_FMT_RGB48, AV_PIX_FMT_RGBA64,
+ AV_PIX_FMT_BGR48, AV_PIX_FMT_BGRA64,
+ AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
+ AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
+ AV_PIX_FMT_GBRAP10,
+ AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
+ AV_PIX_FMT_GBRP16, AV_PIX_FMT_GBRAP12,
+ AV_PIX_FMT_GBRAP16,
+ AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10,
+ AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY14, AV_PIX_FMT_GRAY16,
+ AV_PIX_FMT_NONE
+};
+
+static void negate8(const uint8_t *src, uint8_t *dst,
+ ptrdiff_t slinesize, ptrdiff_t dlinesize,
+ int w, int h, int max, int step,
+ int components)
+{
+ for (int y = 0; y < h; y++) {
+ for (int x = 0; x < w; x++)
+ dst[x] = 255 - src[x];
+
+ dst += dlinesize;
+ src += slinesize;
+ }
+}
+
+static void negate_packed8(const uint8_t *ssrc, uint8_t *ddst,
+ ptrdiff_t slinesize, ptrdiff_t dlinesize,
+ int w, int h, int max, int step,
+ int components)
+{
+ for (int y = 0; y < h; y++) {
+ const uint8_t *src = ssrc + y * slinesize;
+ uint8_t *dst = ddst + y * dlinesize;
+
+ for (int x = 0; x < w; x++) {
+ switch (step) {
+ case 4: dst[3] = components & 8 ? 255 - src[3] : src[3];
+ case 3: dst[2] = components & 4 ? 255 - src[2] : src[2];
+ case 2: dst[1] = components & 2 ? 255 - src[1] : src[1];
+ default: dst[0] = components & 1 ? 255 - src[0] : src[0];
+ }
+
+ src += step;
+ dst += step;
+ }
+ }
+}
+
+static void negate16(const uint8_t *ssrc, uint8_t *ddst,
+ ptrdiff_t slinesize, ptrdiff_t dlinesize,
+ int w, int h, int max, int step,
+ int components)
+{
+ const uint16_t *src = (const uint16_t *)ssrc;
+ uint16_t *dst = (uint16_t *)ddst;
+
+ dlinesize /= 2;
+ slinesize /= 2;
+
+ for (int y = 0; y < h; y++) {
+ for (int x = 0; x < w; x++)
+ dst[x] = max - src[x];
+
+ dst += dlinesize;
+ src += slinesize;
+ }
+}
+
+static void negate_packed16(const uint8_t *ssrc, uint8_t *ddst,
+ ptrdiff_t slinesize, ptrdiff_t dlinesize,
+ int w, int h, int max, int step,
+ int components)
+{
+ for (int y = 0; y < h; y++) {
+ const uint16_t *src = (const uint16_t *)(ssrc + y * slinesize);
+ uint16_t *dst = (uint16_t *)(ddst + y * dlinesize);
+
+ for (int x = 0; x < w; x++) {
+ switch (step) {
+ case 4: dst[3] = components & 8 ? max - src[3] : src[3];
+ case 3: dst[2] = components & 4 ? max - src[2] : src[2];
+ case 2: dst[1] = components & 2 ? max - src[1] : src[1];
+ default: dst[0] = components & 1 ? max - src[0] : src[0];
+ }
+
+ src += step;
+ dst += step;
+ }
+ }
+}
+
+static int config_input(AVFilterLink *inlink)
+{
+ AVFilterContext *ctx = inlink->dst;
+ NegateContext *s = ctx->priv;
+ const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
+ int depth, vsub, hsub, ret, is_packed;
+ int comp_avail;
+
+ s->planes = s->negate_alpha ? 0xF : 0x7;
+ is_packed = !(desc->flags & AV_PIX_FMT_FLAG_PLANAR) &&
+ (desc->nb_components > 1);
+ if (s->requested_components != 0x77) {
+ comp_avail = ((desc->flags & AV_PIX_FMT_FLAG_RGB) ? COMP_R|COMP_G|COMP_B :
+ COMP_Y |
+ ((desc->nb_components > 2) ? COMP_U|COMP_V : 0)) |
+ ((desc->flags & AV_PIX_FMT_FLAG_ALPHA) ? COMP_A : 0);
+ if (s->requested_components & ~comp_avail) {
+ av_log(ctx, AV_LOG_ERROR, "Requested components not available.\n");
+ return AVERROR(EINVAL);
+ }
+
+ s->planes = 0;
+ if (!(desc->flags & AV_PIX_FMT_FLAG_RGB)) {
+ if (s->requested_components & COMP_Y)
+ s->planes |= 1;
+ if (s->requested_components & COMP_U)
+ s->planes |= 2;
+ if (s->requested_components & COMP_V)
+ s->planes |= 4;
+ if (s->requested_components & COMP_A)
+ s->planes |= 8;
+ } else {
+ if (s->requested_components & COMP_R)
+ s->planes |= 4;
+ if (s->requested_components & COMP_G)
+ s->planes |= 1;
+ if (s->requested_components & COMP_B)
+ s->planes |= 2;
+ if (s->requested_components & COMP_A)
+ s->planes |= 8;
+ }
+ }
+ s->nb_planes = av_pix_fmt_count_planes(inlink->format);
+
+ s->components = 0;
+ if (desc->flags & AV_PIX_FMT_FLAG_RGB) {
+ ff_fill_rgba_map(s->rgba_map, inlink->format);
+
+ if (s->requested_components & COMP_R)
+ s->components |= 1 << s->rgba_map[0];
+ if (s->requested_components & COMP_G)
+ s->components |= 1 << s->rgba_map[1];
+ if (s->requested_components & COMP_B)
+ s->components |= 1 << s->rgba_map[2];
+ if (s->requested_components & COMP_A)
+ s->components |= 1 << s->rgba_map[3];
+ }
+
+ if ((ret = av_image_fill_linesizes(s->linesize, inlink->format, inlink->w)) < 0)
+ return ret;
+
+ depth = desc->comp[0].depth;
+ hsub = desc->log2_chroma_w;
+ vsub = desc->log2_chroma_h;
+ s->height[1] = s->height[2] = AV_CEIL_RSHIFT(inlink->h, vsub);
+ s->height[0] = s->height[3] = inlink->h;
+ s->width[1] = s->width[2] = AV_CEIL_RSHIFT(inlink->w, hsub);
+ s->width[0] = s->width[3] = inlink->w;
+
+ s->negate = depth <= 8 ? negate8 : negate16;
+ if (is_packed) {
+ s->negate = depth <= 8 ? negate_packed8 : negate_packed16;
+ s->planes = 1;
+ }
+ s->max = (1 << depth) - 1;
+ s->step = av_get_bits_per_pixel(desc) >> 3;
+ if (depth > 8)
+ s->step = s->step >> 1;
+
+ return 0;
+}
+
+static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
+{
+ NegateContext *s = ctx->priv;
+ ThreadData *td = arg;
+ AVFrame *in = td->in;
+ AVFrame *out = td->out;
+
+ for (int p = 0; p < s->nb_planes; p++) {
+ const int h = s->height[p];
+ const int slice_start = (h * jobnr) / nb_jobs;
+ const int slice_end = (h * (jobnr+1)) / nb_jobs;
+
+ if (!((1 << p) & s->planes)) {
+ if (out != in)
+ av_image_copy_plane(out->data[p] + slice_start * out->linesize[p],
+ out->linesize[p],
+ in->data[p] + slice_start * in->linesize[p],
+ in->linesize[p],
+ s->linesize[p], slice_end - slice_start);
+ continue;
+ }
+
+ s->negate(in->data[p] + slice_start * in->linesize[p],
+ out->data[p] + slice_start * out->linesize[p],
+ in->linesize[p], out->linesize[p],
+ s->width[p], slice_end - slice_start,
+ s->max, s->step, s->components);
+ }
+
+ return 0;
+}
+
+static int filter_frame(AVFilterLink *inlink, AVFrame *in)
+{
+ AVFilterContext *ctx = inlink->dst;
+ NegateContext *s = ctx->priv;
+ AVFilterLink *outlink = ctx->outputs[0];
+ ThreadData td;
+ AVFrame *out;
+
+ if (av_frame_is_writable(in)) {
+ out = in;
+ } else {
+ out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
+ if (!out) {
+ av_frame_free(&in);
+ return AVERROR(ENOMEM);
+ }
+ av_frame_copy_props(out, in);
+ }
+
+ td.out = out;
+ td.in = in;
+ ff_filter_execute(ctx, filter_slice, &td, NULL,
+ FFMIN(s->height[2], ff_filter_get_nb_threads(ctx)));
+ if (out != in)
+ av_frame_free(&in);
+
+ return ff_filter_frame(outlink, out);
+}
+
+static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
+ char *res, int res_len, int flags)
+{
+ NegateContext *s = ctx->priv;
+ int old_planes = s->planes;
+ int ret;
+
+ ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags);
+ if (ret < 0)
+ return ret;
+
+ ret = config_input(ctx->inputs[0]);
+ if (ret < 0)
+ s->planes = old_planes;
+ return ret;
+}
+
+static const AVFilterPad inputs[] = {
+ {
+ .name = "default",
+ .type = AVMEDIA_TYPE_VIDEO,
+ .filter_frame = filter_frame,
+ .config_props = config_input,
+ },
+};
+
+static const AVFilterPad outputs[] = {
+ {
+ .name = "default",
+ .type = AVMEDIA_TYPE_VIDEO,
+ },
+};
+
+const AVFilter ff_vf_negate = {
+ .name = "negate",
+ .description = NULL_IF_CONFIG_SMALL("Negate input video."),
+ .priv_size = sizeof(NegateContext),
+ .priv_class = &negate_class,
+ FILTER_INPUTS(inputs),
+ FILTER_OUTPUTS(outputs),
+ FILTER_PIXFMTS_ARRAY(pix_fmts),
+ .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
+ .process_command = process_command,
+};
diff --git a/tests/ref/fate/filter-negate b/tests/ref/fate/filter-negate
index 88d04718ae..aa9a820c0d 100644
--- a/tests/ref/fate/filter-negate
+++ b/tests/ref/fate/filter-negate
@@ -3,53 +3,53 @@
#codec_id 0: rawvideo
#dimensions 0: 352x288
#sar 0: 0/1
-0, 0, 0, 1, 152064, 0xef20e1ec
-0, 1, 1, 1, 152064, 0x899606ec
-0, 2, 2, 1, 152064, 0xaea175d2
-0, 3, 3, 1, 152064, 0x5201eb55
-0, 4, 4, 1, 152064, 0xf02bb525
-0, 5, 5, 1, 152064, 0x99fdc305
-0, 6, 6, 1, 152064, 0x3a8fefe7
-0, 7, 7, 1, 152064, 0x005edfbf
-0, 8, 8, 1, 152064, 0xe37aea50
-0, 9, 9, 1, 152064, 0xa5ad32f9
-0, 10, 10, 1, 152064, 0xb1e52485
-0, 11, 11, 1, 152064, 0x55b06e56
-0, 12, 12, 1, 152064, 0xdfb7be97
-0, 13, 13, 1, 152064, 0x191bca13
-0, 14, 14, 1, 152064, 0xa554dd3c
-0, 15, 15, 1, 152064, 0x36075b77
-0, 16, 16, 1, 152064, 0xbf6b1cbd
-0, 17, 17, 1, 152064, 0xf33432b6
-0, 18, 18, 1, 152064, 0x5d7100c3
-0, 19, 19, 1, 152064, 0x376f8f0c
-0, 20, 20, 1, 152064, 0x07ca75fa
-0, 21, 21, 1, 152064, 0xe3984704
-0, 22, 22, 1, 152064, 0xa8fb4e4c
-0, 23, 23, 1, 152064, 0xe8e102d8
-0, 24, 24, 1, 152064, 0xcc6771c9
-0, 25, 25, 1, 152064, 0xf646d238
-0, 26, 26, 1, 152064, 0xa52cd41e
-0, 27, 27, 1, 152064, 0x536d92c2
-0, 28, 28, 1, 152064, 0x7058c6a1
-0, 29, 29, 1, 152064, 0xcc6c05d0
-0, 30, 30, 1, 152064, 0x1fc2ffb8
-0, 31, 31, 1, 152064, 0x041ea59c
-0, 32, 32, 1, 152064, 0xfc006e07
-0, 33, 33, 1, 152064, 0x0246efe1
-0, 34, 34, 1, 152064, 0x079428e5
-0, 35, 35, 1, 152064, 0x64d9d773
-0, 36, 36, 1, 152064, 0x914d3454
-0, 37, 37, 1, 152064, 0xef69686e
-0, 38, 38, 1, 152064, 0x3c91129f
-0, 39, 39, 1, 152064, 0x2a611ca7
-0, 40, 40, 1, 152064, 0xaf56124f
-0, 41, 41, 1, 152064, 0xce48cd45
-0, 42, 42, 1, 152064, 0x75feac29
-0, 43, 43, 1, 152064, 0xfd2b4b5b
-0, 44, 44, 1, 152064, 0x8d2f675c
-0, 45, 45, 1, 152064, 0x1573ed3b
-0, 46, 46, 1, 152064, 0xb0fc17ca
-0, 47, 47, 1, 152064, 0x53e5a654
-0, 48, 48, 1, 152064, 0xe0cbb786
-0, 49, 49, 1, 152064, 0xcaa092fe
+0, 0, 0, 1, 152064, 0xdb0946b2
+0, 1, 1, 1, 152064, 0x950c6b50
+0, 2, 2, 1, 152064, 0x42e3da48
+0, 3, 3, 1, 152064, 0xb63d4ff1
+0, 4, 4, 1, 152064, 0x92dd1a4f
+0, 5, 5, 1, 152064, 0xf2fc27bb
+0, 6, 6, 1, 152064, 0xfea2547e
+0, 7, 7, 1, 152064, 0x860b44f5
+0, 8, 8, 1, 152064, 0xc1a5507b
+0, 9, 9, 1, 152064, 0x4f89978c
+0, 10, 10, 1, 152064, 0xde8c8941
+0, 11, 11, 1, 152064, 0xafcbd3bd
+0, 12, 12, 1, 152064, 0x19af2340
+0, 13, 13, 1, 152064, 0xbbd42e7e
+0, 14, 14, 1, 152064, 0x8e1c42c4
+0, 15, 15, 1, 152064, 0x37a4c19c
+0, 16, 16, 1, 152064, 0x528a8289
+0, 17, 17, 1, 152064, 0x2f6397d9
+0, 18, 18, 1, 152064, 0xee5265d5
+0, 19, 19, 1, 152064, 0xed64f493
+0, 20, 20, 1, 152064, 0xe436db22
+0, 21, 21, 1, 152064, 0x42f9ac8f
+0, 22, 22, 1, 152064, 0x9c63b348
+0, 23, 23, 1, 152064, 0xb19967b2
+0, 24, 24, 1, 152064, 0x12b7d6bc
+0, 25, 25, 1, 152064, 0x4b69376b
+0, 26, 26, 1, 152064, 0x9ce939ec
+0, 27, 27, 1, 152064, 0x0940f80b
+0, 28, 28, 1, 152064, 0x69ee2c4c
+0, 29, 29, 1, 152064, 0x72fd6b93
+0, 30, 30, 1, 152064, 0xd12365d7
+0, 31, 31, 1, 152064, 0xfe1c0b83
+0, 32, 32, 1, 152064, 0x095ad405
+0, 33, 33, 1, 152064, 0xfe825671
+0, 34, 34, 1, 152064, 0x60d68d29
+0, 35, 35, 1, 152064, 0xe6243ba6
+0, 36, 36, 1, 152064, 0x942998f6
+0, 37, 37, 1, 152064, 0x3bb3cea9
+0, 38, 38, 1, 152064, 0xd5b97755
+0, 39, 39, 1, 152064, 0x584d81c4
+0, 40, 40, 1, 152064, 0x0e4d777c
+0, 41, 41, 1, 152064, 0x0bdc3299
+0, 42, 42, 1, 152064, 0xbff210f8
+0, 43, 43, 1, 152064, 0x8964afb5
+0, 44, 44, 1, 152064, 0xe361cc30
+0, 45, 45, 1, 152064, 0x7f0c522e
+0, 46, 46, 1, 152064, 0xd6d17ca2
+0, 47, 47, 1, 152064, 0x72380adf
+0, 48, 48, 1, 152064, 0x25391c1e
+0, 49, 49, 1, 152064, 0x9506f7a8
--
2.33.0
More information about the ffmpeg-devel
mailing list