FFmpeg  4.4.5
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[] = {
77  };
78  const enum AVPixelFormat *pix_fmts;
79  AVFilterFormats *fmts_list;
80 
81  if (!strcmp(ctx->filter->name, "rgbashift"))
83  else
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  }
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 
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 
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 };
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
uint8_t
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1096
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
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:802
Main libavfilter public API header.
#define flags(name, subs,...)
Definition: cbs_av1.c:572
#define s(width, name)
Definition: cbs_vp9.c:257
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
#define FFMIN3(a, b, c)
Definition: common.h:106
#define NULL
Definition: coverity.c:32
simple arithmetic expression evaluator
int
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
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:286
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
@ AV_OPT_TYPE_INT
Definition: opt.h:225
#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
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition: avfilter.h:117
#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
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:658
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
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
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
misc image utilities
int32_t bv
Definition: input.c:405
int32_t rv
Definition: input.c:405
int32_t gv
Definition: input.c:405
static enum AVPixelFormat rgb_pix_fmts[]
Definition: jpeg2000dec.c:260
static enum AVPixelFormat yuv_pix_fmts[]
Definition: jpeg2000dec.c:262
const char * arg
Definition: jacosubdec.c:66
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:309
const char * desc
Definition: libsvtav1.c:79
AVOptions.
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:420
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:410
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:406
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:398
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:399
#define AV_PIX_FMT_YUV440P12
Definition: pixfmt.h:405
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:421
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:414
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:397
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:438
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:441
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:403
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:436
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:404
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:415
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:400
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:416
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:396
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:437
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:407
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:99
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
@ 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_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
@ 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_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:73
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
@ 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_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
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:215
@ 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_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:176
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:168
@ 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
@ 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
#define AV_PIX_FMT_YUVA422P12
Definition: pixfmt.h:439
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:408
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:411
#define AV_PIX_FMT_YUV440P10
Definition: pixfmt.h:401
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:419
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:443
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:442
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:418
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:409
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:417
#define AV_PIX_FMT_YUVA444P12
Definition: pixfmt.h:440
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:412
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:402
Describe the class of an AVClass context structure.
Definition: log.h:67
An instance of a filter.
Definition: avfilter.h:341
A list of supported formats for one end of a filter link.
Definition: formats.h:65
A filter pad used for either input or output.
Definition: internal.h:54
const char * name
Pad name.
Definition: internal.h:60
Filter definition.
Definition: avfilter.h:145
const char * name
Filter name.
Definition: avfilter.h:149
AVFormatInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1699
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
AVOption.
Definition: opt.h:248
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
int(* filter_slice)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
FILE * out
Definition: movenc.c:54
AVFormatContext * ctx
Definition: movenc.c:48
#define DEFINE_RGBASMEAR(depth, type, div)
static const AVOption rgbashift_options[]
AVFILTER_DEFINE_CLASS(chromashift)
AVFilter ff_vf_chromashift
static int query_formats(AVFilterContext *ctx)
#define DEFINE_RGBAWRAP(depth, type, div)
AVFilter ff_vf_rgbashift
static int config_input(AVFilterLink *inlink)
static const AVFilterPad inputs[]
static const AVFilterPad outputs[]
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
#define VFR
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
#define DEFINE_WRAP(depth, type, div)
static const AVOption chromashift_options[]
#define OFFSET(x)
#define DEFINE_SMEAR(depth, type, div)
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