avfilter/vf_chromashift: Fix mixed declaration and code
[ffmpeg.git] / 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 "framesync.h"
32 #include "video.h"
33
34 typedef struct ChromaShiftContext {
35     const AVClass *class;
36     int cbh, cbv;
37     int crh, crv;
38     int rh, rv;
39     int gh, gv;
40     int bh, bv;
41     int ah, av;
42     int edge;
43
44     int nb_planes;
45     int depth;
46     int height[4];
47     int width[4];
48     int linesize[4];
49
50     AVFrame *in;
51
52     int is_rgbashift;
53     int (*filter_slice)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
54 } ChromaShiftContext;
55
56 static int query_formats(AVFilterContext *ctx)
57 {
58     static const enum AVPixelFormat yuv_pix_fmts[] = {
59         AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA420P,
60         AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ422P,AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ411P,
61         AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
62         AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
63         AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUV440P10,
64         AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10,
65         AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
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] + out->linesize[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 #define OFFSET(x) offsetof(ChromaShiftContext, x)
404 #define VF AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM
405
406 static const AVOption chromashift_options[] = {
407     { "cbh", "shift chroma-blue horizontally", OFFSET(cbh),  AV_OPT_TYPE_INT,   {.i64=0}, -255, 255, .flags = VF },
408     { "cbv", "shift chroma-blue vertically",   OFFSET(cbv),  AV_OPT_TYPE_INT,   {.i64=0}, -255, 255, .flags = VF },
409     { "crh", "shift chroma-red horizontally",  OFFSET(crh),  AV_OPT_TYPE_INT,   {.i64=0}, -255, 255, .flags = VF },
410     { "crv", "shift chroma-red vertically",    OFFSET(crv),  AV_OPT_TYPE_INT,   {.i64=0}, -255, 255, .flags = VF },
411     { "edge", "set edge operation",            OFFSET(edge), AV_OPT_TYPE_INT,   {.i64=0},    0,   1, .flags = VF, "edge" },
412     { "smear",                              0,            0, AV_OPT_TYPE_CONST, {.i64=0},    0,   0, .flags = VF, "edge" },
413     { "wrap",                               0,            0, AV_OPT_TYPE_CONST, {.i64=1},    0,   0, .flags = VF, "edge" },
414     { NULL },
415 };
416
417 static const AVFilterPad inputs[] = {
418     {
419         .name         = "default",
420         .type         = AVMEDIA_TYPE_VIDEO,
421         .filter_frame = filter_frame,
422         .config_props = config_input,
423     },
424     { NULL }
425 };
426
427 static const AVFilterPad outputs[] = {
428     {
429         .name = "default",
430         .type = AVMEDIA_TYPE_VIDEO,
431     },
432     { NULL }
433 };
434
435 AVFILTER_DEFINE_CLASS(chromashift);
436
437 AVFilter ff_vf_chromashift = {
438     .name          = "chromashift",
439     .description   = NULL_IF_CONFIG_SMALL("Shift chroma."),
440     .priv_size     = sizeof(ChromaShiftContext),
441     .priv_class    = &chromashift_class,
442     .query_formats = query_formats,
443     .outputs       = outputs,
444     .inputs        = inputs,
445     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
446 };
447
448 static const AVOption rgbashift_options[] = {
449     { "rh", "shift red horizontally",   OFFSET(rh),   AV_OPT_TYPE_INT,   {.i64=0}, -255, 255, .flags = VF },
450     { "rv", "shift red vertically",     OFFSET(rv),   AV_OPT_TYPE_INT,   {.i64=0}, -255, 255, .flags = VF },
451     { "gh", "shift green horizontally", OFFSET(gh),   AV_OPT_TYPE_INT,   {.i64=0}, -255, 255, .flags = VF },
452     { "gv", "shift green vertically",   OFFSET(gv),   AV_OPT_TYPE_INT,   {.i64=0}, -255, 255, .flags = VF },
453     { "bh", "shift blue horizontally",  OFFSET(bh),   AV_OPT_TYPE_INT,   {.i64=0}, -255, 255, .flags = VF },
454     { "bv", "shift blue vertically",    OFFSET(bv),   AV_OPT_TYPE_INT,   {.i64=0}, -255, 255, .flags = VF },
455     { "ah", "shift alpha horizontally", OFFSET(ah),   AV_OPT_TYPE_INT,   {.i64=0}, -255, 255, .flags = VF },
456     { "av", "shift alpha vertically",   OFFSET(av),   AV_OPT_TYPE_INT,   {.i64=0}, -255, 255, .flags = VF },
457     { "edge", "set edge operation",     OFFSET(edge), AV_OPT_TYPE_INT,   {.i64=0},    0,   1, .flags = VF, "edge" },
458     { "smear",                          0,         0, AV_OPT_TYPE_CONST, {.i64=0},    0,   0, .flags = VF, "edge" },
459     { "wrap",                           0,         0, AV_OPT_TYPE_CONST, {.i64=1},    0,   0, .flags = VF, "edge" },
460     { NULL },
461 };
462
463 AVFILTER_DEFINE_CLASS(rgbashift);
464
465 AVFilter ff_vf_rgbashift = {
466     .name          = "rgbashift",
467     .description   = NULL_IF_CONFIG_SMALL("Shift RGBA."),
468     .priv_size     = sizeof(ChromaShiftContext),
469     .priv_class    = &rgbashift_class,
470     .query_formats = query_formats,
471     .outputs       = outputs,
472     .inputs        = inputs,
473     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
474 };