FFmpeg  4.3.6
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 
50 
52  int (*filter_slice)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
54 
56 {
57  static const enum AVPixelFormat yuv_pix_fmts[] = {
70  };
71  static const enum AVPixelFormat rgb_pix_fmts[] = {
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 
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 
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],
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;
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 
450  .name = "chromashift",
451  .description = NULL_IF_CONFIG_SMALL("Shift chroma."),
452  .priv_size = sizeof(ChromaShiftContext),
453  .priv_class = &chromashift_class,
455  .outputs = outputs,
456  .inputs = inputs,
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 
479  .name = "rgbashift",
480  .description = NULL_IF_CONFIG_SMALL("Shift RGBA."),
481  .priv_size = sizeof(ChromaShiftContext),
482  .priv_class = &rgbashift_class,
484  .outputs = outputs,
485  .inputs = inputs,
488 };
#define NULL
Definition: coverity.c:32
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:440
#define AV_PIX_FMT_YUV440P10
Definition: pixfmt.h:399
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2549
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
AVOption.
Definition: opt.h:246
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:434
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:407
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:417
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:435
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
misc image utilities
Main libavfilter public API header.
const char * desc
Definition: nvenc.c:79
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:168
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:413
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:401
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:104
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:92
static enum AVPixelFormat rgb_pix_fmts[]
Definition: jpeg2000dec.c:252
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:300
AVFilter ff_vf_rgbashift
#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:125
static const AVFilterPad inputs[]
const char * name
Pad name.
Definition: internal.h:60
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:346
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1075
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
uint8_t
AVOptions.
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:412
int(* filter_slice)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range...
Definition: pixfmt.h:100
#define FFMIN3(a, b, c)
Definition: common.h:97
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
Definition: pixfmt.h:79
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:410
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:402
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:439
A filter pad used for either input or output.
Definition: internal.h:54
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:176
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:605
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
static const AVOption rgbashift_options[]
#define AVERROR(e)
Definition: error.h:43
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:188
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:869
static const AVOption chromashift_options[]
void * priv
private data for use by the filter
Definition: avfilter.h:353
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition: avfilter.h:116
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:441
const char * arg
Definition: jacosubdec.c:66
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:418
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:400
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:419
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:395
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:83
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:416
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:784
#define DEFINE_RGBASMEAR(depth, type, div)
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:78
#define AV_PIX_FMT_YUVA444P12
Definition: pixfmt.h:438
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
#define VFR
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:436
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:396
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:415
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:408
static const AVFilterPad outputs[]
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:405
static enum AVPixelFormat yuv_pix_fmts[]
Definition: jpeg2000dec.c:254
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:331
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:177
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
#define DEFINE_WRAP(depth, type, div)
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:397
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:72
Describe the class of an AVClass context structure.
Definition: log.h:67
Filter definition.
Definition: avfilter.h:144
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
static int query_formats(AVFilterContext *ctx)
const char * name
Filter name.
Definition: avfilter.h:148
#define AV_PIX_FMT_YUV440P12
Definition: pixfmt.h:403
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:394
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:350
#define OFFSET(x)
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:406
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:414
#define flags(name, subs,...)
Definition: cbs_av1.c:565
AVFilterInternal * internal
An opaque struct for libavfilter internal use.
Definition: avfilter.h:378
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:398
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:404
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:314
#define DEFINE_RGBAWRAP(depth, type, div)
int
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:215
AVFilter ff_vf_chromashift
AVFILTER_DEFINE_CLASS(chromashift)
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:80
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:73
avfilter_execute_func * execute
Definition: internal.h:144
static int config_input(AVFilterLink *inlink)
A list of supported formats for one end of a filter link.
Definition: formats.h:64
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...
Definition: pixfmt.h:258
An instance of a filter.
Definition: avfilter.h:338
FILE * out
Definition: movenc.c:54
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:99
#define DEFINE_SMEAR(depth, type, div)
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:338
internal API functions
int depth
Number of bits in the component.
Definition: pixdesc.h:58
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
const AVFilter * filter
the AVFilter of which this is an instance
Definition: avfilter.h:341
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:409
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:659
#define AV_PIX_FMT_YUVA422P12
Definition: pixfmt.h:437
simple arithmetic expression evaluator
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58