GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavfilter/vf_chromashift.c Lines: 0 58 0.0 %
Date: 2020-09-25 23:16:12 Branches: 0 122 0.0 %

Line Branch Exec Source
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
};