git.sesse.net Git - ffmpeg/blob - libavfilter/vf_chromashift.c

   1 /*
   2  * Copyright (c) 2018 Paul B Mahol
   3  *
   4  * This file is part of FFmpeg.
   5  *
   6  * FFmpeg is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * FFmpeg is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with FFmpeg; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #include "libavutil/avstring.h"
  22 #include "libavutil/eval.h"
  23 #include "libavutil/imgutils.h"
  24 #include "libavutil/intreadwrite.h"
  25 #include "libavutil/opt.h"
  26 #include "libavutil/pixdesc.h"
  27
  28 #include "avfilter.h"
  29 #include "formats.h"
  30 #include "internal.h"
  31 #include "video.h"
  32
  33 typedef struct ChromaShiftContext {
  34     const AVClass *class;
  35     int cbh, cbv;
  36     int crh, crv;
  37     int rh, rv;
  38     int gh, gv;
  39     int bh, bv;
  40     int ah, av;
  41     int edge;
  42
  43     int nb_planes;
  44     int depth;
  45     int height[4];
  46     int width[4];
  47     int linesize[4];
  48
  49     AVFrame *in;
  50
  51     int is_rgbashift;
  52     int (*filter_slice)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
  53 } ChromaShiftContext;
  54
  55 static int query_formats(AVFilterContext *ctx)
  56 {
  57     static const enum AVPixelFormat yuv_pix_fmts[] = {
  58         AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA420P,
  59         AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ422P,AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ411P,
  60         AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
  61         AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
  62         AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUV440P10,
  63         AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10,
  64         AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
  65         AV_PIX_FMT_YUVA422P12, AV_PIX_FMT_YUVA444P12,
  66         AV_PIX_FMT_YUV444P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV420P14,
  67         AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16,
  68         AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,
  69         AV_PIX_FMT_NONE
  70     };
  71     static const enum AVPixelFormat rgb_pix_fmts[] = {
  72         AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRP9,
  73         AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP12,
  74         AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
  75         AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,
  76         AV_PIX_FMT_NONE
  77     };
  78     const enum AVPixelFormat *pix_fmts;
  79     AVFilterFormats *fmts_list;
  80
  81     if (!strcmp(ctx->filter->name, "rgbashift"))
  82         pix_fmts = rgb_pix_fmts;
  83     else
  84         pix_fmts = yuv_pix_fmts;
  85
  86     fmts_list = ff_make_format_list(pix_fmts);
  87     if (!fmts_list)
  88         return AVERROR(ENOMEM);
  89     return ff_set_common_formats(ctx, fmts_list);
  90 }
  91
  92 #define DEFINE_SMEAR(depth, type, div)                                                    \
  93 static int smear_slice ## depth(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)  \
  94 {                                                                                         \
  95     ChromaShiftContext *s = ctx->priv;                                                    \
  96     AVFrame *in = s->in;                                                                  \
  97     AVFrame *out = arg;                                                                   \
  98     const int sulinesize = in->linesize[1] / div;                                         \
  99     const int svlinesize = in->linesize[2] / div;                                         \
 100     const int ulinesize = out->linesize[1] / div;                                         \
 101     const int vlinesize = out->linesize[2] / div;                                         \
 102     const int cbh = s->cbh;                                                               \
 103     const int cbv = s->cbv;                                                               \
 104     const int crh = s->crh;                                                               \
 105     const int crv = s->crv;                                                               \
 106     const int h = s->height[1];                                                           \
 107     const int w = s->width[1];                                                            \
 108     const int slice_start = (h * jobnr) / nb_jobs;                                        \
 109     const int slice_end = (h * (jobnr+1)) / nb_jobs;                                      \
 110     const type *su = (const type *)in->data[1];                                           \
 111     const type *sv = (const type *)in->data[2];                                           \
 112     type *du = (type *)out->data[1] + slice_start * ulinesize;                            \
 113     type *dv = (type *)out->data[2] + slice_start * vlinesize;                            \
 114                                                                                           \
 115     for (int y = slice_start; y < slice_end; y++) {                                       \
 116         const int duy = av_clip(y - cbv, 0, h-1) * sulinesize;                            \
 117         const int dvy = av_clip(y - crv, 0, h-1) * svlinesize;                            \
 118                                                                                           \
 119         for (int x = 0; x < w; x++) {                                                     \
 120             du[x] = su[av_clip(x - cbh, 0, w - 1) + duy];                                 \
 121             dv[x] = sv[av_clip(x - crh, 0, w - 1) + dvy];                                 \
 122         }                                                                                 \
 123                                                                                           \
 124         du += ulinesize;                                                                  \
 125         dv += vlinesize;                                                                  \
 126     }                                                                                     \
 127                                                                                           \
 128     return 0;                                                                             \
 129 }
 130
 131 DEFINE_SMEAR(8, uint8_t, 1)
 132 DEFINE_SMEAR(16, uint16_t, 2)
 133
 134 #define DEFINE_WRAP(depth, type, div)                                                     \
 135 static int wrap_slice ## depth(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)   \
 136 {                                                                                         \
 137     ChromaShiftContext *s = ctx->priv;                                                    \
 138     AVFrame *in = s->in;                                                                  \
 139     AVFrame *out = arg;                                                                   \
 140     const int sulinesize = in->linesize[1] / div;                                         \
 141     const int svlinesize = in->linesize[2] / div;                                         \
 142     const int ulinesize = out->linesize[1] / div;                                         \
 143     const int vlinesize = out->linesize[2] / div;                                         \
 144     const int cbh = s->cbh;                                                               \
 145     const int cbv = s->cbv;                                                               \
 146     const int crh = s->crh;                                                               \
 147     const int crv = s->crv;                                                               \
 148     const int h = s->height[1];                                                           \
 149     const int w = s->width[1];                                                            \
 150     const int slice_start = (h * jobnr) / nb_jobs;                                        \
 151     const int slice_end = (h * (jobnr+1)) / nb_jobs;                                      \
 152     const type *su = (const type *)in->data[1];                                           \
 153     const type *sv = (const type *)in->data[2];                                           \
 154     type *du = (type *)out->data[1] + slice_start * ulinesize;                            \
 155     type *dv = (type *)out->data[2] + slice_start * vlinesize;                            \
 156                                                                                           \
 157     for (int y = slice_start; y < slice_end; y++) {                                       \
 158         int uy = (y - cbv) % h;                                                           \
 159         int vy = (y - crv) % h;                                                           \
 160                                                                                           \
 161         if (uy < 0)                                                                       \
 162             uy += h;                                                                      \
 163         if (vy < 0)                                                                       \
 164             vy += h;                                                                      \
 165                                                                                           \
 166         for (int x = 0; x < w; x++) {                                                     \
 167             int ux = (x - cbh) % w;                                                       \
 168             int vx = (x - crh) % w;                                                       \
 169                                                                                           \
 170             if (ux < 0)                                                                   \
 171                 ux += w;                                                                  \
 172             if (vx < 0)                                                                   \
 173                 vx += w;                                                                  \
 174                                                                                           \
 175             du[x] = su[ux + uy * sulinesize];                                             \
 176             dv[x] = sv[vx + vy * svlinesize];                                             \
 177         }                                                                                 \
 178                                                                                           \
 179         du += ulinesize;                                                                  \
 180         dv += vlinesize;                                                                  \
 181     }                                                                                     \
 182                                                                                           \
 183     return 0;                                                                             \
 184 }
 185
 186 DEFINE_WRAP(8, uint8_t, 1)
 187 DEFINE_WRAP(16, uint16_t, 2)
 188
 189 #define DEFINE_RGBASMEAR(depth, type, div)                                                    \
 190 static int rgbasmear_slice ## depth(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)  \
 191 {                                                                                         \
 192     ChromaShiftContext *s = ctx->priv;                                                    \
 193     AVFrame *in = s->in;                                                                  \
 194     AVFrame *out = arg;                                                                   \
 195     const int srlinesize = in->linesize[2] / div;                                         \
 196     const int sglinesize = in->linesize[0] / div;                                         \
 197     const int sblinesize = in->linesize[1] / div;                                         \
 198     const int salinesize = in->linesize[3] / div;                                         \
 199     const int rlinesize = out->linesize[2] / div;                                         \
 200     const int glinesize = out->linesize[0] / div;                                         \
 201     const int blinesize = out->linesize[1] / div;                                         \
 202     const int alinesize = out->linesize[3] / div;                                         \
 203     const int rh = s->rh;                                                                 \
 204     const int rv = s->rv;                                                                 \
 205     const int gh = s->gh;                                                                 \
 206     const int gv = s->gv;                                                                 \
 207     const int bh = s->bh;                                                                 \
 208     const int bv = s->bv;                                                                 \
 209     const int ah = s->ah;                                                                 \
 210     const int av = s->av;                                                                 \
 211     const int h = s->height[1];                                                           \
 212     const int w = s->width[1];                                                            \
 213     const int slice_start = (h * jobnr) / nb_jobs;                                        \
 214     const int slice_end = (h * (jobnr+1)) / nb_jobs;                                      \
 215     const type *sr = (const type *)in->data[2];                                           \
 216     const type *sg = (const type *)in->data[0];                                           \
 217     const type *sb = (const type *)in->data[1];                                           \
 218     const type *sa = (const type *)in->data[3];                                           \
 219     type *dr = (type *)out->data[2] + slice_start * rlinesize;                            \
 220     type *dg = (type *)out->data[0] + slice_start * glinesize;                            \
 221     type *db = (type *)out->data[1] + slice_start * blinesize;                            \
 222     type *da = (type *)out->data[3] + slice_start * alinesize;                            \
 223                                                                                           \
 224     for (int y = slice_start; y < slice_end; y++) {                                       \
 225         const int ry = av_clip(y - rv, 0, h-1) * srlinesize;                              \
 226         const int gy = av_clip(y - gv, 0, h-1) * sglinesize;                              \
 227         const int by = av_clip(y - bv, 0, h-1) * sblinesize;                              \
 228         int ay;                                                                           \
 229                                                                                           \
 230         for (int x = 0; x < w; x++) {                                                     \
 231             dr[x] = sr[av_clip(x - rh, 0, w - 1) + ry];                                   \
 232             dg[x] = sg[av_clip(x - gh, 0, w - 1) + gy];                                   \
 233             db[x] = sb[av_clip(x - bh, 0, w - 1) + by];                                   \
 234         }                                                                                 \
 235                                                                                           \
 236         dr += rlinesize;                                                                  \
 237         dg += glinesize;                                                                  \
 238         db += blinesize;                                                                  \
 239                                                                                           \
 240         if (s->nb_planes < 4)                                                             \
 241             continue;                                                                     \
 242         ay = av_clip(y - av, 0, h-1) * salinesize;                                        \
 243         for (int x = 0; x < w; x++) {                                                     \
 244             da[x] = sa[av_clip(x - ah, 0, w - 1) + ay];                                   \
 245         }                                                                                 \
 246                                                                                           \
 247         da += alinesize;                                                                  \
 248     }                                                                                     \
 249                                                                                           \
 250     return 0;                                                                             \
 251 }
 252
 253 DEFINE_RGBASMEAR(8, uint8_t, 1)
 254 DEFINE_RGBASMEAR(16, uint16_t, 2)
 255
 256 #define DEFINE_RGBAWRAP(depth, type, div)                                                     \
 257 static int rgbawrap_slice ## depth(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)   \
 258 {                                                                                         \
 259     ChromaShiftContext *s = ctx->priv;                                                    \
 260     AVFrame *in = s->in;                                                                  \
 261     AVFrame *out = arg;                                                                   \
 262     const int srlinesize = in->linesize[2] / div;                                         \
 263     const int sglinesize = in->linesize[0] / div;                                         \
 264     const int sblinesize = in->linesize[1] / div;                                         \
 265     const int salinesize = in->linesize[3] / div;                                         \
 266     const int rlinesize = out->linesize[2] / div;                                         \
 267     const int glinesize = out->linesize[0] / div;                                         \
 268     const int blinesize = out->linesize[1] / div;                                         \
 269     const int alinesize = out->linesize[3] / div;                                         \
 270     const int rh = s->rh;                                                                 \
 271     const int rv = s->rv;                                                                 \
 272     const int gh = s->gh;                                                                 \
 273     const int gv = s->gv;                                                                 \
 274     const int bh = s->bh;                                                                 \
 275     const int bv = s->bv;                                                                 \
 276     const int ah = s->ah;                                                                 \
 277     const int av = s->av;                                                                 \
 278     const int h = s->height[1];                                                           \
 279     const int w = s->width[1];                                                            \
 280     const int slice_start = (h * jobnr) / nb_jobs;                                        \
 281     const int slice_end = (h * (jobnr+1)) / nb_jobs;                                      \
 282     const type *sr = (const type *)in->data[2];                                           \
 283     const type *sg = (const type *)in->data[0];                                           \
 284     const type *sb = (const type *)in->data[1];                                           \
 285     const type *sa = (const type *)in->data[3];                                           \
 286     type *dr = (type *)out->data[2] + slice_start * rlinesize;                            \
 287     type *dg = (type *)out->data[0] + slice_start * glinesize;                            \
 288     type *db = (type *)out->data[1] + slice_start * blinesize;                            \
 289     type *da = (type *)out->data[3] + slice_start * alinesize;                            \
 290                                                                                           \
 291     for (int y = slice_start; y < slice_end; y++) {                                       \
 292         int ry = (y - rv) % h;                                                            \
 293         int gy = (y - gv) % h;                                                            \
 294         int by = (y - bv) % h;                                                            \
 295                                                                                           \
 296         if (ry < 0)                                                                       \
 297             ry += h;                                                                      \
 298         if (gy < 0)                                                                       \
 299             gy += h;                                                                      \
 300         if (by < 0)                                                                       \
 301             by += h;                                                                      \
 302                                                                                           \
 303         for (int x = 0; x < w; x++) {                                                     \
 304             int rx = (x - rh) % w;                                                        \
 305             int gx = (x - gh) % w;                                                        \
 306             int bx = (x - bh) % w;                                                        \
 307                                                                                           \
 308             if (rx < 0)                                                                   \
 309                 rx += w;                                                                  \
 310             if (gx < 0)                                                                   \
 311                 gx += w;                                                                  \
 312             if (bx < 0)                                                                   \
 313                 bx += w;                                                                  \
 314             dr[x] = sr[rx + ry * srlinesize];                                             \
 315             dg[x] = sg[gx + gy * sglinesize];                                             \
 316             db[x] = sb[bx + by * sblinesize];                                             \
 317         }                                                                                 \
 318                                                                                           \
 319         dr += rlinesize;                                                                  \
 320         dg += glinesize;                                                                  \
 321         db += blinesize;                                                                  \
 322                                                                                           \
 323         if (s->nb_planes < 4)                                                             \
 324             continue;                                                                     \
 325         for (int x = 0; x < w; x++) {                                                     \
 326             int ax = (x - ah) % w;                                                        \
 327             int ay = (x - av) % h;                                                        \
 328                                                                                           \
 329             if (ax < 0)                                                                   \
 330                 ax += w;                                                                  \
 331             if (ay < 0)                                                                   \
 332                 ay += h;                                                                  \
 333             da[x] = sa[ax + ay * salinesize];                                             \
 334         }                                                                                 \
 335                                                                                           \
 336         da += alinesize;                                                                  \
 337     }                                                                                     \
 338                                                                                           \
 339     return 0;                                                                             \
 340 }
 341
 342 DEFINE_RGBAWRAP(8, uint8_t, 1)
 343 DEFINE_RGBAWRAP(16, uint16_t, 2)
 344
 345 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
 346 {
 347     AVFilterContext *ctx = inlink->dst;
 348     AVFilterLink *outlink = ctx->outputs[0];
 349     ChromaShiftContext *s = ctx->priv;
 350     AVFrame *out;
 351
 352     out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
 353     if (!out) {
 354         av_frame_free(&in);
 355         return AVERROR(ENOMEM);
 356     }
 357     av_frame_copy_props(out, in);
 358
 359     s->in = in;
 360     if (!s->is_rgbashift) {
 361         av_image_copy_plane(out->data[0],
 362                             out->linesize[0],
 363                             in->data[0], in->linesize[0],
 364                             s->linesize[0], s->height[0]);
 365     }
 366     ctx->internal->execute(ctx, s->filter_slice, out, NULL,
 367                            FFMIN3(s->height[1],
 368                                   s->height[2],
 369                                   ff_filter_get_nb_threads(ctx)));
 370     s->in = NULL;
 371     av_frame_free(&in);
 372     return ff_filter_frame(outlink, out);
 373 }
 374
 375 static int config_input(AVFilterLink *inlink)
 376 {
 377     AVFilterContext *ctx = inlink->dst;
 378     ChromaShiftContext *s = ctx->priv;
 379     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
 380
 381     s->is_rgbashift = !strcmp(ctx->filter->name, "rgbashift");
 382     s->depth = desc->comp[0].depth;
 383     s->nb_planes = desc->nb_components;
 384     if (s->is_rgbashift) {
 385         if (s->edge)
 386             s->filter_slice = s->depth > 8 ? rgbawrap_slice16 : rgbawrap_slice8;
 387         else
 388             s->filter_slice = s->depth > 8 ? rgbasmear_slice16 : rgbasmear_slice8;
 389     } else {
 390         if (s->edge)
 391             s->filter_slice = s->depth > 8 ? wrap_slice16 : wrap_slice8;
 392         else
 393             s->filter_slice = s->depth > 8 ? smear_slice16 : smear_slice8;
 394     }
 395     s->height[1] = s->height[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
 396     s->height[0] = s->height[3] = inlink->h;
 397     s->width[1] = s->width[2] = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
 398     s->width[0] = s->width[3] = inlink->w;
 399
 400     return av_image_fill_linesizes(s->linesize, inlink->format, inlink->w);
 401 }
 402
 403 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
 404                            char *res, int res_len, int flags)
 405 {
 406     int ret;
 407
 408     ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags);
 409     if (ret < 0)
 410         return ret;
 411
 412     return config_input(ctx->inputs[0]);
 413 }
 414
 415 #define OFFSET(x) offsetof(ChromaShiftContext, x)
 416 #define VFR AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_RUNTIME_PARAM
 417
 418 static const AVOption chromashift_options[] = {
 419     { "cbh", "shift chroma-blue horizontally", OFFSET(cbh),  AV_OPT_TYPE_INT,   {.i64=0}, -255, 255, .flags = VFR },
 420     { "cbv", "shift chroma-blue vertically",   OFFSET(cbv),  AV_OPT_TYPE_INT,   {.i64=0}, -255, 255, .flags = VFR },
 421     { "crh", "shift chroma-red horizontally",  OFFSET(crh),  AV_OPT_TYPE_INT,   {.i64=0}, -255, 255, .flags = VFR },
 422     { "crv", "shift chroma-red vertically",    OFFSET(crv),  AV_OPT_TYPE_INT,   {.i64=0}, -255, 255, .flags = VFR },
 423     { "edge", "set edge operation",            OFFSET(edge), AV_OPT_TYPE_INT,   {.i64=0},    0,   1, .flags = VFR, "edge" },
 424     { "smear",                              0,            0, AV_OPT_TYPE_CONST, {.i64=0},    0,   0, .flags = VFR, "edge" },
 425     { "wrap",                               0,            0, AV_OPT_TYPE_CONST, {.i64=1},    0,   0, .flags = VFR, "edge" },
 426     { NULL },
 427 };
 428
 429 static const AVFilterPad inputs[] = {
 430     {
 431         .name         = "default",
 432         .type         = AVMEDIA_TYPE_VIDEO,
 433         .filter_frame = filter_frame,
 434         .config_props = config_input,
 435     },
 436     { NULL }
 437 };
 438
 439 static const AVFilterPad outputs[] = {
 440     {
 441         .name = "default",
 442         .type = AVMEDIA_TYPE_VIDEO,
 443     },
 444     { NULL }
 445 };
 446
 447 AVFILTER_DEFINE_CLASS(chromashift);
 448
 449 AVFilter ff_vf_chromashift = {
 450     .name          = "chromashift",
 451     .description   = NULL_IF_CONFIG_SMALL("Shift chroma."),
 452     .priv_size     = sizeof(ChromaShiftContext),
 453     .priv_class    = &chromashift_class,
 454     .query_formats = query_formats,
 455     .outputs       = outputs,
 456     .inputs        = inputs,
 457     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
 458     .process_command = process_command,
 459 };
 460
 461 static const AVOption rgbashift_options[] = {
 462     { "rh", "shift red horizontally",   OFFSET(rh),   AV_OPT_TYPE_INT,   {.i64=0}, -255, 255, .flags = VFR },
 463     { "rv", "shift red vertically",     OFFSET(rv),   AV_OPT_TYPE_INT,   {.i64=0}, -255, 255, .flags = VFR },
 464     { "gh", "shift green horizontally", OFFSET(gh),   AV_OPT_TYPE_INT,   {.i64=0}, -255, 255, .flags = VFR },
 465     { "gv", "shift green vertically",   OFFSET(gv),   AV_OPT_TYPE_INT,   {.i64=0}, -255, 255, .flags = VFR },
 466     { "bh", "shift blue horizontally",  OFFSET(bh),   AV_OPT_TYPE_INT,   {.i64=0}, -255, 255, .flags = VFR },
 467     { "bv", "shift blue vertically",    OFFSET(bv),   AV_OPT_TYPE_INT,   {.i64=0}, -255, 255, .flags = VFR },
 468     { "ah", "shift alpha horizontally", OFFSET(ah),   AV_OPT_TYPE_INT,   {.i64=0}, -255, 255, .flags = VFR },
 469     { "av", "shift alpha vertically",   OFFSET(av),   AV_OPT_TYPE_INT,   {.i64=0}, -255, 255, .flags = VFR },
 470     { "edge", "set edge operation",     OFFSET(edge), AV_OPT_TYPE_INT,   {.i64=0},    0,   1, .flags = VFR, "edge" },
 471     { "smear",                          0,         0, AV_OPT_TYPE_CONST, {.i64=0},    0,   0, .flags = VFR, "edge" },
 472     { "wrap",                           0,         0, AV_OPT_TYPE_CONST, {.i64=1},    0,   0, .flags = VFR, "edge" },
 473     { NULL },
 474 };
 475
 476 AVFILTER_DEFINE_CLASS(rgbashift);
 477
 478 AVFilter ff_vf_rgbashift = {
 479     .name          = "rgbashift",
 480     .description   = NULL_IF_CONFIG_SMALL("Shift RGBA."),
 481     .priv_size     = sizeof(ChromaShiftContext),
 482     .priv_class    = &rgbashift_class,
 483     .query_formats = query_formats,
 484     .outputs       = outputs,
 485     .inputs        = inputs,
 486     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
 487     .process_command = process_command,
 488 };