FFmpeg
vf_dblur.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2020 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/imgutils.h"
22 #include "libavutil/opt.h"
23 #include "libavutil/pixdesc.h"
24 #include "avfilter.h"
25 #include "formats.h"
26 #include "internal.h"
27 #include "video.h"
28 
29 typedef struct DBlurContext {
30  const AVClass *class;
31 
32  float angle;
33  float radius;
34  int planes;
35 
36  float b0, b1, q, c, R3;
37 
38  int depth;
39  int planewidth[4];
40  int planeheight[4];
41  float *buffer;
42  int nb_planes;
43  void (*horiz_slice)(float *buffer, int width, int height, int steps, float nu, float bscale);
44 } DBlurContext;
45 
46 #define OFFSET(x) offsetof(DBlurContext, x)
47 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
48 
49 static const AVOption dblur_options[] = {
50  { "angle", "set angle", OFFSET(angle), AV_OPT_TYPE_FLOAT, {.dbl=45}, 0.0, 360, FLAGS },
51  { "radius", "set radius", OFFSET(radius), AV_OPT_TYPE_FLOAT, {.dbl=5}, 1, 8192, FLAGS },
52  { "planes", "set planes to filter", OFFSET(planes), AV_OPT_TYPE_INT, {.i64=0xF}, 0, 0xF, FLAGS },
53  { NULL }
54 };
55 
57 
58 #define f(n, m) (dst[(n) * width + (m)])
59 
61 {
62  DBlurContext *s = ctx->priv;
63  const float b0 = s->b0;
64  const float b1 = s->b1;
65  const float q = s->q;
66  const float c = s->c;
67  float *dst = s->buffer;
68  float g;
69 
70  if (s->R3 > 0) {
71  for (int y = 1; y < height - 1; y++) {
72  g = q * f(0, 0) + c * f(0, 0);
73  for (int x = 0; x < width; x++) {
74  f(y, x) = b0 * f(y, x) + b1 * f(y - 1, x) + g;
75  g = q * f(y, x) + c * f(y - 1, x);
76  }
77  }
78 
79  for (int y = height - 2; y >= 0; y--) {
80  g = q * f(y, width - 1) + c * f(y, width - 1);
81  for (int x = width - 1; x >= 0; x--) {
82  f(y, x) = b0 * f(y, x) + b1 * f(y + 1, x) + g;
83  g = q * f(y, x) + c * f(y + 1, x);
84  }
85  }
86  } else {
87  for (int y = 1; y < height - 1; y++) {
88  g = q * f(0, width - 1) + c * f(0, width - 1);
89  for (int x = width - 1; x >= 0; x--) {
90  f(y, x) = b0 * f(y, x) + b1 * f(y - 1, x) + g;
91  g = q * f(y, x) + c * f(y - 1, x);
92  }
93  }
94 
95  for (int y = height - 2; y >= 0; y--) {
96  g = q * f(y, 0) + c * f(y, 0);
97  for (int x = 0; x < width; x++) {
98  f(y, x) = b0 * f(y, x) + b1 * f(y + 1, x) + g;
99  g = q * f(y, x) + c * f(y + 1, x);
100  }
101  }
102  }
103 
104  return 0;
105 }
106 
107 static void diriir2d(AVFilterContext *ctx, int plane)
108 {
109  DBlurContext *s = ctx->priv;
110  const int width = s->planewidth[plane];
111  const int height = s->planeheight[plane];
112 
113  filter_horizontally(ctx, width, height);
114 }
115 
117 {
118  static const enum AVPixelFormat pix_fmts[] = {
138  };
139 
140  return ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
141 }
142 
144 {
146  DBlurContext *s = inlink->dst->priv;
147 
148  s->depth = desc->comp[0].depth;
149  s->planewidth[1] = s->planewidth[2] = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
150  s->planewidth[0] = s->planewidth[3] = inlink->w;
151  s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
152  s->planeheight[0] = s->planeheight[3] = inlink->h;
153 
155 
156  s->buffer = av_malloc_array(FFALIGN(inlink->w, 16), FFALIGN(inlink->h, 16) * sizeof(*s->buffer));
157  if (!s->buffer)
158  return AVERROR(ENOMEM);
159 
160  return 0;
161 }
162 
163 static void set_params(DBlurContext *s, float angle, float r)
164 {
165  float mu, nu, R1, R2, w1, w2;
166  float a0, a1, a2, a3;
167 
168  angle = angle * M_PI / 180.f;
169 
170  mu = cosf(angle);
171  nu = sinf(angle);
172  R1 = (mu * r) * (mu * r);
173  R2 = (nu * r) * (nu * r);
174  s->R3 = mu * nu * r * r;
175  w1 = sqrtf(0.25f + R1);
176  w2 = sqrtf(0.25f + R2);
177  a0 = (w1 + 0.5f) * (w2 + 0.5f) - fabsf(s->R3);
178  a1 = 0.5f + w2 - a0;
179  a2 = 0.5f + w1 - a0;
180  a3 = a0 - w1 - w2;
181  s->b0 = 1.f / a0;
182  s->b1 = -a2 / a0;
183  s->q = -a1 / a0;
184  s->c = -a3 / a0;
185 }
186 
188 {
189  AVFilterContext *ctx = inlink->dst;
190  DBlurContext *s = ctx->priv;
191  AVFilterLink *outlink = ctx->outputs[0];
192  AVFrame *out;
193  int plane;
194 
195  set_params(s, s->angle, s->radius);
196 
197  if (av_frame_is_writable(in)) {
198  out = in;
199  } else {
200  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
201  if (!out) {
202  av_frame_free(&in);
203  return AVERROR(ENOMEM);
204  }
205  av_frame_copy_props(out, in);
206  }
207 
208  for (plane = 0; plane < s->nb_planes; plane++) {
209  const int height = s->planeheight[plane];
210  const int width = s->planewidth[plane];
211  float *bptr = s->buffer;
212  const uint8_t *src = in->data[plane];
213  const uint16_t *src16 = (const uint16_t *)in->data[plane];
214  uint8_t *dst = out->data[plane];
215  uint16_t *dst16 = (uint16_t *)out->data[plane];
216  int y, x;
217 
218  if (!(s->planes & (1 << plane))) {
219  if (out != in)
220  av_image_copy_plane(out->data[plane], out->linesize[plane],
221  in->data[plane], in->linesize[plane],
222  width * ((s->depth + 7) / 8), height);
223  continue;
224  }
225 
226  if (s->depth == 8) {
227  for (y = 0; y < height; y++) {
228  for (x = 0; x < width; x++) {
229  bptr[x] = src[x];
230  }
231  bptr += width;
232  src += in->linesize[plane];
233  }
234  } else {
235  for (y = 0; y < height; y++) {
236  for (x = 0; x < width; x++) {
237  bptr[x] = src16[x];
238  }
239  bptr += width;
240  src16 += in->linesize[plane] / 2;
241  }
242  }
243 
244  diriir2d(ctx, plane);
245 
246  bptr = s->buffer;
247  if (s->depth == 8) {
248  for (y = 0; y < height; y++) {
249  for (x = 0; x < width; x++) {
250  dst[x] = bptr[x];
251  }
252  bptr += width;
253  dst += out->linesize[plane];
254  }
255  } else {
256  for (y = 0; y < height; y++) {
257  for (x = 0; x < width; x++) {
258  dst16[x] = bptr[x];
259  }
260  bptr += width;
261  dst16 += out->linesize[plane] / 2;
262  }
263  }
264  }
265 
266  if (out != in)
267  av_frame_free(&in);
268  return ff_filter_frame(outlink, out);
269 }
270 
272 {
273  DBlurContext *s = ctx->priv;
274 
275  av_freep(&s->buffer);
276 }
277 
278 static const AVFilterPad dblur_inputs[] = {
279  {
280  .name = "default",
281  .type = AVMEDIA_TYPE_VIDEO,
282  .config_props = config_input,
283  .filter_frame = filter_frame,
284  },
285  { NULL }
286 };
287 
288 static const AVFilterPad dblur_outputs[] = {
289  {
290  .name = "default",
291  .type = AVMEDIA_TYPE_VIDEO,
292  },
293  { NULL }
294 };
295 
297  .name = "dblur",
298  .description = NULL_IF_CONFIG_SMALL("Apply Directional Blur filter."),
299  .priv_size = sizeof(DBlurContext),
300  .priv_class = &dblur_class,
301  .uninit = uninit,
303  .inputs = dblur_inputs,
304  .outputs = dblur_outputs,
307 };
#define NULL
Definition: coverity.c:32
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:442
#define AV_PIX_FMT_YUVA422P9
Definition: pixfmt.h:434
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
AVOption.
Definition: opt.h:248
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:436
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:409
int planewidth[4]
Definition: vf_dblur.c:39
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:419
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:437
const char * desc
Definition: libsvtav1.c:79
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:2613
Main libavfilter public API header.
const char * g
Definition: vf_curves.c:115
#define a0
Definition: regdef.h:46
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:168
static const AVFilterPad dblur_outputs[]
Definition: vf_dblur.c:288
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:415
float angle
Definition: vf_dblur.c:32
#define R2
Definition: simple_idct.c:173
#define AV_PIX_FMT_GRAY9
Definition: pixfmt.h:379
#define a1
Definition: regdef.h:47
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:403
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
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:92
float c
Definition: vf_dblur.c:36
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:287
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:380
#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 f(n, m)
Definition: vf_dblur.c:58
const char * name
Pad name.
Definition: internal.h:60
static const AVFilterPad dblur_inputs[]
Definition: vf_dblur.c:278
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:381
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1091
#define a3
Definition: regdef.h:49
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
#define FLAGS
Definition: vf_dblur.c:47
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
uint8_t
#define av_cold
Definition: attributes.h:88
int nb_planes
Definition: vf_dblur.c:42
AVOptions.
static int filter_horizontally(AVFilterContext *ctx, int width, int height)
Definition: vf_dblur.c:60
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: vf_dblur.c:187
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:433
#define cosf(x)
Definition: libm.h:78
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:414
#define height
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:412
float radius
Definition: vf_dblur.c:33
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:404
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:441
#define FFALIGN(x, a)
Definition: macros.h:48
A filter pad used for either input or output.
Definition: internal.h:54
AVFILTER_DEFINE_CLASS(dblur)
#define src
Definition: vp8dsp.c:254
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:588
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
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:153
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:885
const char * r
Definition: vf_curves.c:114
void * priv
private data for use by the filter
Definition: avfilter.h:354
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:443
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:420
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:402
int planeheight[4]
Definition: vf_dblur.c:40
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:421
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
static void diriir2d(AVFilterContext *ctx, int plane)
Definition: vf_dblur.c:107
static void set_params(DBlurContext *s, float angle, float r)
Definition: vf_dblur.c:163
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:397
#define OFFSET(x)
Definition: vf_dblur.c:46
static int query_formats(AVFilterContext *ctx)
Definition: vf_dblur.c:116
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:418
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:383
int planes
Definition: vf_dblur.c:34
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:440
#define width
float R3
Definition: vf_dblur.c:36
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
AVFormatContext * ctx
Definition: movenc.c:48
#define a2
Definition: regdef.h:48
#define s(width, name)
Definition: cbs_vp9.c:257
float * buffer
Definition: vf_dblur.c:41
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:438
static const AVOption dblur_options[]
Definition: vf_dblur.c:49
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:398
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:417
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_dblur.c:271
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:410
#define R1
Definition: simple_idct.c:172
#define sinf(x)
Definition: libm.h:419
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:407
float q
Definition: vf_dblur.c:36
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:607
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:339
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:382
float b1
Definition: vf_dblur.c:36
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several inputs
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
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:399
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:145
const char * name
Filter name.
Definition: avfilter.h:149
#define AV_PIX_FMT_YUV440P12
Definition: pixfmt.h:405
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:396
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:351
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:300
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:408
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:416
#define flags(name, subs,...)
Definition: cbs_av1.c:560
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:400
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:406
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:322
static int config_input(AVFilterLink *inlink)
Definition: vf_dblur.c:143
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
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
Y , 8bpp.
Definition: pixfmt.h:74
AVFilter ff_vf_dblur
Definition: vf_dblur.c:296
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:215
void(* horiz_slice)(float *buffer, int width, int height, int steps, float nu, float bscale)
Definition: vf_dblur.c:43
#define AV_PIX_FMT_YUVA444P9
Definition: pixfmt.h:435
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
float b0
Definition: vf_dblur.c:36
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:339
FILE * out
Definition: movenc.c:54
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
Definition: af_afftdn.c:1374
#define av_freep(p)
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:99
#define M_PI
Definition: mathematics.h:52
#define av_malloc_array(a, b)
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
internal API functions
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
int depth
Number of bits in the component.
Definition: pixdesc.h:58
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:411
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:671
#define AV_PIX_FMT_YUVA422P12
Definition: pixfmt.h:439
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58