FFmpeg
vf_chromashift.c
Go to the documentation of this file.
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 };
ff_get_video_buffer
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:99
AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:442
AV_PIX_FMT_GBRAP16
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:421
ChromaShiftContext
Definition: vf_chromashift.c:33
process_command
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
Definition: vf_chromashift.c:403
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
ff_make_format_list
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:286
out
FILE * out
Definition: movenc.c:54
ChromaShiftContext::in
AVFrame * in
Definition: vf_chromashift.c:49
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1096
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: vf_chromashift.c:55
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
inlink
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
Definition: filter_design.txt:212
DEFINE_SMEAR
#define DEFINE_SMEAR(depth, type, div)
Definition: vf_chromashift.c:92
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
pixdesc.h
AV_PIX_FMT_YUVA420P16
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:441
config_input
static int config_input(AVFilterLink *inlink)
Definition: vf_chromashift.c:375
AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:436
AVOption
AVOption.
Definition: opt.h:248
ChromaShiftContext::height
int height[4]
Definition: vf_chromashift.c:45
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:399
ChromaShiftContext::nb_planes
int nb_planes
Definition: vf_chromashift.c:43
AV_PIX_FMT_YUV440P
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:99
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:149
video.h
AVFormatContext::internal
AVFormatInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1699
AV_PIX_FMT_YUVA422P10
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:437
av_image_copy_plane
void av_image_copy_plane(uint8_t *dst, int dst_linesize, const uint8_t *src, int src_linesize, int bytewidth, int height)
Copy image plane from src to dst.
Definition: imgutils.c:373
AVFilterFormats
A list of supported formats for one end of a filter link.
Definition: formats.h:65
formats.h
ChromaShiftContext::rh
int rh
Definition: vf_chromashift.c:37
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:417
AV_PIX_FMT_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:215
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:415
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:443
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:397
ChromaShiftContext::crv
int crv
Definition: vf_chromashift.c:36
FFMIN3
#define FFMIN3(a, b, c)
Definition: common.h:106
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:54
ff_vf_chromashift
AVFilter ff_vf_chromashift
Definition: vf_chromashift.c:449
ChromaShiftContext::bv
int bv
Definition: vf_chromashift.c:39
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:402
DEFINE_WRAP
#define DEFINE_WRAP(depth, type, div)
Definition: vf_chromashift.c:134
AV_PIX_FMT_YUVJ411P
@ AV_PIX_FMT_YUVJ411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...
Definition: pixfmt.h:258
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(chromashift)
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:411
ff_set_common_formats
int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
A helper for query_formats() which sets all links to the same list of formats.
Definition: formats.c:587
AV_PIX_FMT_YUVJ422P
@ AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
Definition: pixfmt.h:79
AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:419
av_image_fill_linesizes
int av_image_fill_linesizes(int linesizes[4], enum AVPixelFormat pix_fmt, int width)
Fill plane linesizes for an image with pixel format pix_fmt and width width.
Definition: imgutils.c:89
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:257
AV_PIX_FMT_GBRAP12
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:420
AV_PIX_FMT_YUVA420P
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:412
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
ChromaShiftContext::width
int width[4]
Definition: vf_chromashift.c:46
ChromaShiftContext::linesize
int linesize[4]
Definition: vf_chromashift.c:47
ChromaShiftContext::ah
int ah
Definition: vf_chromashift.c:40
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:309
AV_PIX_FMT_YUVA444P12
#define AV_PIX_FMT_YUVA444P12
Definition: pixfmt.h:440
ChromaShiftContext::av
int av
Definition: vf_chromashift.c:40
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:396
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:410
ctx
AVFormatContext * ctx
Definition: movenc.c:48
DEFINE_RGBAWRAP
#define DEFINE_RGBAWRAP(depth, type, div)
Definition: vf_chromashift.c:256
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
ChromaShiftContext::cbv
int cbv
Definition: vf_chromashift.c:35
AV_PIX_FMT_YUVJ444P
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:80
arg
const char * arg
Definition: jacosubdec.c:66
ChromaShiftContext::bh
int bh
Definition: vf_chromashift.c:39
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:418
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
NULL
#define NULL
Definition: coverity.c:32
rv
int32_t rv
Definition: input.c:405
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:658
rgbashift_options
static const AVOption rgbashift_options[]
Definition: vf_chromashift.c:461
ChromaShiftContext::gh
int gh
Definition: vf_chromashift.c:38
AV_PIX_FMT_YUVJ420P
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:78
ChromaShiftContext::filter_slice
int(* filter_slice)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_chromashift.c:52
AV_PIX_FMT_YUV440P10
#define AV_PIX_FMT_YUV440P10
Definition: pixfmt.h:401
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:400
DEFINE_RGBASMEAR
#define DEFINE_RGBASMEAR(depth, type, div)
Definition: vf_chromashift.c:189
AV_PIX_FMT_GBRP9
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:414
OFFSET
#define OFFSET(x)
Definition: vf_chromashift.c:415
eval.h
inputs
static const AVFilterPad inputs[]
Definition: vf_chromashift.c:429
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:404
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:406
ff_filter_process_command
int ff_filter_process_command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Generic processing of user supplied commands that are set in the same way as the filter options.
Definition: avfilter.c:882
AV_PIX_FMT_YUVA444P
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:177
AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:438
internal.h
AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
#define AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
Some filters support a generic "enable" expression option that can be used to enable or disable a fil...
Definition: avfilter.h:126
in
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method !=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2) { ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc) { av_free(ac);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
Definition: audio_convert.c:326
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:416
ff_filter_get_nb_threads
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:802
AV_PIX_FMT_YUVJ440P
@ AV_PIX_FMT_YUVJ440P
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range
Definition: pixfmt.h:100
uint8_t
uint8_t
Definition: audio_convert.c:194
bv
int32_t bv
Definition: input.c:405
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:60
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:398
ChromaShiftContext::cbh
int cbh
Definition: vf_chromashift.c:35
ChromaShiftContext::is_rgbashift
int is_rgbashift
Definition: vf_chromashift.c:51
chromashift_options
static const AVOption chromashift_options[]
Definition: vf_chromashift.c:418
ChromaShiftContext::gv
int gv
Definition: vf_chromashift.c:38
AVFilter
Filter definition.
Definition: avfilter.h:145
ret
ret
Definition: filter_design.txt:187
ff_vf_rgbashift
AVFilter ff_vf_rgbashift
Definition: vf_chromashift.c:478
gv
int32_t gv
Definition: input.c:405
VFR
#define VFR
Definition: vf_chromashift.c:416
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:403
AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:408
ChromaShiftContext::crh
int crh
Definition: vf_chromashift.c:36
ChromaShiftContext::depth
int depth
Definition: vf_chromashift.c:44
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_PIX_FMT_YUVA422P12
#define AV_PIX_FMT_YUVA422P12
Definition: pixfmt.h:439
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
avfilter.h
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: vf_chromashift.c:345
ChromaShiftContext::edge
int edge
Definition: vf_chromashift.c:41
ChromaShiftContext::rv
int rv
Definition: vf_chromashift.c:37
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
AVFilterContext
An instance of a filter.
Definition: avfilter.h:341
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:168
AVFILTER_FLAG_SLICE_THREADS
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition: avfilter.h:117
desc
const char * desc
Definition: libsvtav1.c:79
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
yuv_pix_fmts
static enum AVPixelFormat yuv_pix_fmts[]
Definition: jpeg2000dec.c:262
AV_PIX_FMT_YUV411P
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:73
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
AV_PIX_FMT_YUV410P
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:72
AV_PIX_FMT_YUV440P12
#define AV_PIX_FMT_YUV440P12
Definition: pixfmt.h:405
AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:409
rgb_pix_fmts
static enum AVPixelFormat rgb_pix_fmts[]
Definition: jpeg2000dec.c:260
avstring.h
int
int
Definition: ffmpeg_filter.c:170
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
AV_PIX_FMT_YUVA422P
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:176
AV_PIX_FMT_YUV420P14
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:407
outputs
static const AVFilterPad outputs[]
Definition: vf_chromashift.c:439
Generated on Wed Aug 24 2022 21:34:30 for FFmpeg by   doxygen 1.8.17