FFmpeg  4.3.7
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 
143 static int config_input(AVFilterLink *inlink)
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 
187 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
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:440
#define AV_PIX_FMT_YUVA422P9
Definition: pixfmt.h:432
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
int planewidth[4]
Definition: vf_dblur.c:39
#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
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2589
Main libavfilter public API header.
const char * g
Definition: vf_curves.c:115
const char * desc
Definition: nvenc.c:79
#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:413
float angle
Definition: vf_dblur.c:32
#define R2
Definition: simple_idct.c:173
#define AV_PIX_FMT_GRAY9
Definition: pixfmt.h:377
#define a1
Definition: regdef.h:47
#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
float c
Definition: vf_dblur.c:36
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:300
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:378
#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
#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:379
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1075
#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:431
#define cosf(x)
Definition: libm.h:78
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:412
#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:410
float radius
Definition: vf_dblur.c:33
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:402
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:439
#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:605
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
#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
const char * r
Definition: vf_curves.c:114
void * priv
private data for use by the filter
Definition: avfilter.h:353
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:441
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:418
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:400
int planeheight[4]
Definition: vf_dblur.c:40
#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
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:395
#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:416
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:381
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:438
#define width
float R3
Definition: vf_dblur.c:36
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:436
static const AVOption dblur_options[]
Definition: vf_dblur.c:49
static const AVFilterPad inputs[]
Definition: af_acontrast.c:193
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:396
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:415
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:408
#define R1
Definition: simple_idct.c:172
#define sinf(x)
Definition: libm.h:419
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:405
float q
Definition: vf_dblur.c:36
typedef void(RENAME(mix_any_func_type))
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:595
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 AV_PIX_FMT_GRAY14
Definition: pixfmt.h:380
float b1
Definition: vf_dblur.c:36
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)\", 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: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
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
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
#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
static int config_input(AVFilterLink *inlink)
Definition: vf_dblur.c:143
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:433
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:338
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:338
internal API functions
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: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
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58