FFmpeg  4.2.3
vf_gblur.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2011 Pascal Getreuer
3  * Copyright (c) 2016 Paul B Mahol
4  *
5  * Redistribution and use in source and binary forms, with or without modification,
6  * are permitted provided that the following conditions are met:
7  *
8  * * Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  * * Redistributions in binary form must reproduce the above
11  * copyright notice, this list of conditions and the following
12  * disclaimer in the documentation and/or other materials provided
13  * with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
18  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
19  * HOLDER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
22  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
23  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
24  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26  */
27 
28 #include "libavutil/imgutils.h"
29 #include "libavutil/opt.h"
30 #include "libavutil/pixdesc.h"
31 #include "avfilter.h"
32 #include "formats.h"
33 #include "gblur.h"
34 #include "internal.h"
35 #include "video.h"
36 
37 #define OFFSET(x) offsetof(GBlurContext, x)
38 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
39 
40 static const AVOption gblur_options[] = {
41  { "sigma", "set sigma", OFFSET(sigma), AV_OPT_TYPE_FLOAT, {.dbl=0.5}, 0.0, 1024, FLAGS },
42  { "steps", "set number of steps", OFFSET(steps), AV_OPT_TYPE_INT, {.i64=1}, 1, 6, FLAGS },
43  { "planes", "set planes to filter", OFFSET(planes), AV_OPT_TYPE_INT, {.i64=0xF}, 0, 0xF, FLAGS },
44  { "sigmaV", "set vertical sigma", OFFSET(sigmaV), AV_OPT_TYPE_FLOAT, {.dbl=-1}, -1, 1024, FLAGS },
45  { NULL }
46 };
47 
49 
50 typedef struct ThreadData {
51  int height;
52  int width;
53 } ThreadData;
54 
55 static void horiz_slice_c(float *buffer, int width, int height, int steps,
56  float nu, float bscale)
57 {
58  int step, x, y;
59  float *ptr;
60  for (y = 0; y < height; y++) {
61  for (step = 0; step < steps; step++) {
62  ptr = buffer + width * y;
63  ptr[0] *= bscale;
64 
65  /* Filter rightwards */
66  for (x = 1; x < width; x++)
67  ptr[x] += nu * ptr[x - 1];
68  ptr[x = width - 1] *= bscale;
69 
70  /* Filter leftwards */
71  for (; x > 0; x--)
72  ptr[x - 1] += nu * ptr[x];
73  }
74  }
75 }
76 
77 static int filter_horizontally(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
78 {
79  GBlurContext *s = ctx->priv;
80  ThreadData *td = arg;
81  const int height = td->height;
82  const int width = td->width;
83  const int slice_start = (height * jobnr ) / nb_jobs;
84  const int slice_end = (height * (jobnr+1)) / nb_jobs;
85  const float boundaryscale = s->boundaryscale;
86  const int steps = s->steps;
87  const float nu = s->nu;
88  float *buffer = s->buffer;
89 
90  s->horiz_slice(buffer + width * slice_start, width, slice_end - slice_start,
91  steps, nu, boundaryscale);
92  emms_c();
93  return 0;
94 }
95 
96 static void do_vertical_columns(float *buffer, int width, int height,
97  int column_begin, int column_end, int steps,
98  float nu, float boundaryscale, int column_step)
99 {
100  const int numpixels = width * height;
101  int i, x, k, step;
102  float *ptr;
103  for (x = column_begin; x < column_end;) {
104  for (step = 0; step < steps; step++) {
105  ptr = buffer + x;
106  for (k = 0; k < column_step; k++) {
107  ptr[k] *= boundaryscale;
108  }
109  /* Filter downwards */
110  for (i = width; i < numpixels; i += width) {
111  for (k = 0; k < column_step; k++) {
112  ptr[i + k] += nu * ptr[i - width + k];
113  }
114  }
115  i = numpixels - width;
116 
117  for (k = 0; k < column_step; k++)
118  ptr[i + k] *= boundaryscale;
119 
120  /* Filter upwards */
121  for (; i > 0; i -= width) {
122  for (k = 0; k < column_step; k++)
123  ptr[i - width + k] += nu * ptr[i + k];
124  }
125  }
126  x += column_step;
127  }
128 }
129 
130 static int filter_vertically(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
131 {
132  GBlurContext *s = ctx->priv;
133  ThreadData *td = arg;
134  const int height = td->height;
135  const int width = td->width;
136  const int slice_start = (width * jobnr ) / nb_jobs;
137  const int slice_end = (width * (jobnr+1)) / nb_jobs;
138  const float boundaryscale = s->boundaryscaleV;
139  const int steps = s->steps;
140  const float nu = s->nuV;
141  float *buffer = s->buffer;
142  int aligned_end;
143 
144  aligned_end = slice_start + (((slice_end - slice_start) >> 3) << 3);
145  /* Filter vertically along columns (process 8 columns in each step) */
146  do_vertical_columns(buffer, width, height, slice_start, aligned_end,
147  steps, nu, boundaryscale, 8);
148 
149  /* Filter un-aligned columns one by one */
150  do_vertical_columns(buffer, width, height, aligned_end, slice_end,
151  steps, nu, boundaryscale, 1);
152  return 0;
153 }
154 
155 
156 static int filter_postscale(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
157 {
158  GBlurContext *s = ctx->priv;
159  ThreadData *td = arg;
160  const int height = td->height;
161  const int width = td->width;
162  const int64_t numpixels = width * (int64_t)height;
163  const unsigned slice_start = (numpixels * jobnr ) / nb_jobs;
164  const unsigned slice_end = (numpixels * (jobnr+1)) / nb_jobs;
165  const float postscale = s->postscale * s->postscaleV;
166  float *buffer = s->buffer;
167  unsigned i;
168 
169  for (i = slice_start; i < slice_end; i++)
170  buffer[i] *= postscale;
171 
172  return 0;
173 }
174 
176 {
177  GBlurContext *s = ctx->priv;
178  const int width = s->planewidth[plane];
179  const int height = s->planeheight[plane];
180  const int nb_threads = ff_filter_get_nb_threads(ctx);
181  ThreadData td;
182 
183  if (s->sigma <= 0 || s->steps < 0)
184  return;
185 
186  td.width = width;
187  td.height = height;
188  ctx->internal->execute(ctx, filter_horizontally, &td, NULL, FFMIN(height, nb_threads));
189  ctx->internal->execute(ctx, filter_vertically, &td, NULL, FFMIN(width, nb_threads));
190  ctx->internal->execute(ctx, filter_postscale, &td, NULL, FFMIN(width * height, nb_threads));
191 }
192 
194 {
195  static const enum AVPixelFormat pix_fmts[] = {
214  };
215 
216  return ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
217 }
218 
220 {
222  if (ARCH_X86_64)
224 }
225 
227 {
229  GBlurContext *s = inlink->dst->priv;
230 
231  s->depth = desc->comp[0].depth;
232  s->planewidth[1] = s->planewidth[2] = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
233  s->planewidth[0] = s->planewidth[3] = inlink->w;
234  s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
235  s->planeheight[0] = s->planeheight[3] = inlink->h;
236 
238 
239  s->buffer = av_malloc_array(inlink->w, inlink->h * sizeof(*s->buffer));
240  if (!s->buffer)
241  return AVERROR(ENOMEM);
242 
243  if (s->sigmaV < 0) {
244  s->sigmaV = s->sigma;
245  }
246  ff_gblur_init(s);
247 
248  return 0;
249 }
250 
251 static void set_params(float sigma, int steps, float *postscale, float *boundaryscale, float *nu)
252 {
253  double dnu, lambda;
254 
255  lambda = (sigma * sigma) / (2.0 * steps);
256  dnu = (1.0 + 2.0 * lambda - sqrt(1.0 + 4.0 * lambda)) / (2.0 * lambda);
257  *postscale = pow(dnu / lambda, steps);
258  *boundaryscale = 1.0 / (1.0 - dnu);
259  *nu = (float)dnu;
260 }
261 
263 {
264  AVFilterContext *ctx = inlink->dst;
265  GBlurContext *s = ctx->priv;
266  AVFilterLink *outlink = ctx->outputs[0];
267  AVFrame *out;
268  int plane;
269 
270  set_params(s->sigma, s->steps, &s->postscale, &s->boundaryscale, &s->nu);
271  set_params(s->sigmaV, s->steps, &s->postscaleV, &s->boundaryscaleV, &s->nuV);
272 
273  if (av_frame_is_writable(in)) {
274  out = in;
275  } else {
276  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
277  if (!out) {
278  av_frame_free(&in);
279  return AVERROR(ENOMEM);
280  }
281  av_frame_copy_props(out, in);
282  }
283 
284  for (plane = 0; plane < s->nb_planes; plane++) {
285  const int height = s->planeheight[plane];
286  const int width = s->planewidth[plane];
287  float *bptr = s->buffer;
288  const uint8_t *src = in->data[plane];
289  const uint16_t *src16 = (const uint16_t *)in->data[plane];
290  uint8_t *dst = out->data[plane];
291  uint16_t *dst16 = (uint16_t *)out->data[plane];
292  int y, x;
293 
294  if (!s->sigma || !(s->planes & (1 << plane))) {
295  if (out != in)
296  av_image_copy_plane(out->data[plane], out->linesize[plane],
297  in->data[plane], in->linesize[plane],
298  width * ((s->depth + 7) / 8), height);
299  continue;
300  }
301 
302  if (s->depth == 8) {
303  for (y = 0; y < height; y++) {
304  for (x = 0; x < width; x++) {
305  bptr[x] = src[x];
306  }
307  bptr += width;
308  src += in->linesize[plane];
309  }
310  } else {
311  for (y = 0; y < height; y++) {
312  for (x = 0; x < width; x++) {
313  bptr[x] = src16[x];
314  }
315  bptr += width;
316  src16 += in->linesize[plane] / 2;
317  }
318  }
319 
320  gaussianiir2d(ctx, plane);
321 
322  bptr = s->buffer;
323  if (s->depth == 8) {
324  for (y = 0; y < height; y++) {
325  for (x = 0; x < width; x++) {
326  dst[x] = bptr[x];
327  }
328  bptr += width;
329  dst += out->linesize[plane];
330  }
331  } else {
332  for (y = 0; y < height; y++) {
333  for (x = 0; x < width; x++) {
334  dst16[x] = bptr[x];
335  }
336  bptr += width;
337  dst16 += out->linesize[plane] / 2;
338  }
339  }
340  }
341 
342  if (out != in)
343  av_frame_free(&in);
344  return ff_filter_frame(outlink, out);
345 }
346 
348 {
349  GBlurContext *s = ctx->priv;
350 
351  av_freep(&s->buffer);
352 }
353 
354 static const AVFilterPad gblur_inputs[] = {
355  {
356  .name = "default",
357  .type = AVMEDIA_TYPE_VIDEO,
358  .config_props = config_input,
359  .filter_frame = filter_frame,
360  },
361  { NULL }
362 };
363 
364 static const AVFilterPad gblur_outputs[] = {
365  {
366  .name = "default",
367  .type = AVMEDIA_TYPE_VIDEO,
368  },
369  { NULL }
370 };
371 
373  .name = "gblur",
374  .description = NULL_IF_CONFIG_SMALL("Apply Gaussian Blur filter."),
375  .priv_size = sizeof(GBlurContext),
376  .priv_class = &gblur_class,
377  .uninit = uninit,
379  .inputs = gblur_inputs,
380  .outputs = gblur_outputs,
382 };
float nu
Definition: gblur.h:48
float boundaryscale
Definition: gblur.h:44
#define NULL
Definition: coverity.c:32
static const AVFilterPad gblur_inputs[]
Definition: vf_gblur.c:354
static const struct @314 planes[]
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:430
AVFrame * out
Definition: af_adeclick.c:488
static int filter_horizontally(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_gblur.c:77
#define AV_PIX_FMT_YUVA422P9
Definition: pixfmt.h:422
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2522
static int filter_vertically(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_gblur.c:130
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
AVOption.
Definition: opt.h:246
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:424
float nuV
Definition: gblur.h:49
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:397
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:407
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:425
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
misc image utilities
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2562
Main libavfilter public API header.
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: vf_gblur.c:262
#define ARCH_X86_64
Definition: config.h:40
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:168
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:403
#define AV_PIX_FMT_GRAY9
Definition: pixfmt.h:367
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:391
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
static int config_input(AVFilterLink *inlink)
Definition: vf_gblur.c:226
static void do_vertical_columns(float *buffer, int width, int height, int column_begin, int column_end, int steps, float nu, float boundaryscale, int column_step)
Definition: vf_gblur.c:96
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:92
int planeheight[4]
Definition: gblur.h:42
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:283
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:368
int planewidth[4]
Definition: gblur.h:41
#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
const char * name
Pad name.
Definition: internal.h:60
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:369
float sigma
Definition: gblur.h:35
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1080
#define FLAGS
Definition: vf_gblur.c:38
static char buffer[20]
Definition: seek.c:32
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
#define av_cold
Definition: attributes.h:82
AVOptions.
void ff_gblur_init_x86(GBlurContext *s)
Definition: vf_gblur_init.c:30
float boundaryscaleV
Definition: gblur.h:45
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_gblur.c:347
#define emms_c()
Definition: internal.h:55
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:421
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:402
int height
Definition: vf_avgblur.c:61
static int query_formats(AVFilterContext *ctx)
Definition: vf_gblur.c:193
AVFrame * dst
Definition: vf_blend.c:55
int plane
Definition: vf_blend.c:57
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range...
Definition: pixfmt.h:100
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:400
AVFilter ff_vf_gblur
Definition: vf_gblur.c:372
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:392
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:429
void(* horiz_slice)(float *buffer, int width, int height, int steps, float nu, float bscale)
Definition: gblur.h:51
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
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
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:568
#define td
Definition: regdef.h:70
int step
Definition: vf_remap.c:77
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
static const FLOAT postscale[64]
Definition: faandct.c:54
#define AVERROR(e)
Definition: error.h:43
uint8_t * ptr
Definition: vf_avgblur.c:63
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
float sigmaV
Definition: gblur.h:36
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:431
const char * arg
Definition: jacosubdec.c:66
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:408
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:390
AVFILTER_DEFINE_CLASS(gblur)
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:409
const uint8_t * src
Definition: vf_bm3d.c:56
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:385
static void gaussianiir2d(AVFilterContext *ctx, int plane)
Definition: vf_gblur.c:175
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:406
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:802
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:371
#define FFMIN(a, b)
Definition: common.h:96
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:78
AVFormatContext * ctx
Definition: movenc.c:48
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:426
float * buffer
Definition: gblur.h:43
static const AVFilterPad inputs[]
Definition: af_acontrast.c:193
float postscaleV
Definition: gblur.h:47
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:386
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:405
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:398
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:395
static int filter_postscale(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_gblur.c:156
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:594
Used for passing data between threads.
Definition: af_adeclick.c:487
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
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 AV_PIX_FMT_GRAY14
Definition: pixfmt.h:370
int planes
Definition: gblur.h:38
void ff_gblur_init(GBlurContext *s)
Definition: vf_gblur.c:219
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:387
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:72
static const AVFilterPad gblur_outputs[]
Definition: vf_gblur.c:364
Filter definition.
Definition: avfilter.h:144
#define OFFSET(x)
Definition: vf_gblur.c:37
static void set_params(float sigma, int steps, float *postscale, float *boundaryscale, float *nu)
Definition: vf_gblur.c:251
int nb_planes
Definition: gblur.h:50
float postscale
Definition: gblur.h:46
const char * name
Filter name.
Definition: avfilter.h:148
#define AV_PIX_FMT_YUV440P12
Definition: pixfmt.h:393
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:384
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:350
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:396
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:404
#define flags(name, subs,...)
Definition: cbs_av1.c:564
AVFilterInternal * internal
An opaque struct for libavfilter internal use.
Definition: avfilter.h:378
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:388
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:394
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
Y , 8bpp.
Definition: pixfmt.h:74
static const AVOption gblur_options[]
Definition: vf_gblur.c:40
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:215
#define AV_PIX_FMT_YUVA444P9
Definition: pixfmt.h:423
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:155
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2029
const AVPixFmtDescriptor * desc
Definition: vf_tonemap.c:196
int depth
Definition: gblur.h:40
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
#define av_freep(p)
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:99
#define av_malloc_array(a, b)
AVFrame * in
Definition: af_afftdn.c:1082
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
AVFilterLink * inlink
Definition: vf_blend.c:56
internal API functions
int depth
Number of bits in the component.
Definition: pixdesc.h:58
static void horiz_slice_c(float *buffer, int width, int height, int steps, float nu, float bscale)
Definition: vf_gblur.c:55
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:399
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:654
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
int steps
Definition: gblur.h:37