FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 "internal.h"
34 #include "video.h"
35 
36 typedef struct GBlurContext {
37  const AVClass *class;
38 
39  float sigma;
40  float sigmaV;
41  int steps;
42  int planes;
43 
44  int depth;
45  int planewidth[4];
46  int planeheight[4];
47  float *buffer;
50  float postscale;
51  float postscaleV;
52  float nu;
53  float nuV;
54  int nb_planes;
55 } GBlurContext;
56 
57 #define OFFSET(x) offsetof(GBlurContext, x)
58 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
59 
60 static const AVOption gblur_options[] = {
61  { "sigma", "set sigma", OFFSET(sigma), AV_OPT_TYPE_FLOAT, {.dbl=0.5}, 0.0, 1024, FLAGS },
62  { "steps", "set number of steps", OFFSET(steps), AV_OPT_TYPE_INT, {.i64=1}, 1, 6, FLAGS },
63  { "planes", "set planes to filter", OFFSET(planes), AV_OPT_TYPE_INT, {.i64=0xF}, 0, 0xF, FLAGS },
64  { "sigmaV", "set vertical sigma", OFFSET(sigmaV), AV_OPT_TYPE_FLOAT, {.dbl=-1}, -1, 1024, FLAGS },
65  { NULL }
66 };
67 
69 
70 typedef struct ThreadData {
71  int height;
72  int width;
73 } ThreadData;
74 
75 static int filter_horizontally(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
76 {
77  GBlurContext *s = ctx->priv;
78  ThreadData *td = arg;
79  const int height = td->height;
80  const int width = td->width;
81  const int slice_start = (height * jobnr ) / nb_jobs;
82  const int slice_end = (height * (jobnr+1)) / nb_jobs;
83  const float boundaryscale = s->boundaryscale;
84  const int steps = s->steps;
85  const float nu = s->nu;
86  float *buffer = s->buffer;
87  int y, x, step;
88  float *ptr;
89 
90  /* Filter horizontally along each row */
91  for (y = slice_start; y < slice_end; y++) {
92  for (step = 0; step < steps; step++) {
93  ptr = buffer + width * y;
94  ptr[0] *= boundaryscale;
95 
96  /* Filter rightwards */
97  for (x = 1; x < width; x++)
98  ptr[x] += nu * ptr[x - 1];
99 
100  ptr[x = width - 1] *= boundaryscale;
101 
102  /* Filter leftwards */
103  for (; x > 0; x--)
104  ptr[x - 1] += nu * ptr[x];
105  }
106  }
107 
108  return 0;
109 }
110 
111 static int filter_vertically(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
112 {
113  GBlurContext *s = ctx->priv;
114  ThreadData *td = arg;
115  const int height = td->height;
116  const int width = td->width;
117  const int slice_start = (width * jobnr ) / nb_jobs;
118  const int slice_end = (width * (jobnr+1)) / nb_jobs;
119  const float boundaryscale = s->boundaryscaleV;
120  const int numpixels = width * height;
121  const int steps = s->steps;
122  const float nu = s->nuV;
123  float *buffer = s->buffer;
124  int i, x, step;
125  float *ptr;
126 
127  /* Filter vertically along each column */
128  for (x = slice_start; x < slice_end; x++) {
129  for (step = 0; step < steps; step++) {
130  ptr = buffer + x;
131  ptr[0] *= boundaryscale;
132 
133  /* Filter downwards */
134  for (i = width; i < numpixels; i += width)
135  ptr[i] += nu * ptr[i - width];
136 
137  ptr[i = numpixels - width] *= boundaryscale;
138 
139  /* Filter upwards */
140  for (; i > 0; i -= width)
141  ptr[i - width] += nu * ptr[i];
142  }
143  }
144 
145  return 0;
146 }
147 
148 
149 static int filter_postscale(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
150 {
151  GBlurContext *s = ctx->priv;
152  ThreadData *td = arg;
153  const int height = td->height;
154  const int width = td->width;
155  const int64_t numpixels = width * (int64_t)height;
156  const unsigned slice_start = (numpixels * jobnr ) / nb_jobs;
157  const unsigned slice_end = (numpixels * (jobnr+1)) / nb_jobs;
158  const float postscale = s->postscale * s->postscaleV;
159  float *buffer = s->buffer;
160  unsigned i;
161 
162  for (i = slice_start; i < slice_end; i++)
163  buffer[i] *= postscale;
164 
165  return 0;
166 }
167 
169 {
170  GBlurContext *s = ctx->priv;
171  const int width = s->planewidth[plane];
172  const int height = s->planeheight[plane];
173  const int nb_threads = ff_filter_get_nb_threads(ctx);
174  ThreadData td;
175 
176  if (s->sigma <= 0 || s->steps < 0)
177  return;
178 
179  td.width = width;
180  td.height = height;
181  ctx->internal->execute(ctx, filter_horizontally, &td, NULL, FFMIN(height, nb_threads));
182  ctx->internal->execute(ctx, filter_vertically, &td, NULL, FFMIN(width, nb_threads));
183  ctx->internal->execute(ctx, filter_postscale, &td, NULL, FFMIN(width * height, nb_threads));
184 }
185 
187 {
188  static const enum AVPixelFormat pix_fmts[] = {
207  };
208 
209  return ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
210 }
211 
212 static int config_input(AVFilterLink *inlink)
213 {
215  GBlurContext *s = inlink->dst->priv;
216 
217  s->depth = desc->comp[0].depth;
218  s->planewidth[1] = s->planewidth[2] = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
219  s->planewidth[0] = s->planewidth[3] = inlink->w;
220  s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
221  s->planeheight[0] = s->planeheight[3] = inlink->h;
222 
224 
225  s->buffer = av_malloc_array(inlink->w, inlink->h * sizeof(*s->buffer));
226  if (!s->buffer)
227  return AVERROR(ENOMEM);
228 
229  if (s->sigmaV < 0) {
230  s->sigmaV = s->sigma;
231  }
232 
233  return 0;
234 }
235 
236 static void set_params(float sigma, int steps, float *postscale, float *boundaryscale, float *nu)
237 {
238  double dnu, lambda;
239 
240  lambda = (sigma * sigma) / (2.0 * steps);
241  dnu = (1.0 + 2.0 * lambda - sqrt(1.0 + 4.0 * lambda)) / (2.0 * lambda);
242  *postscale = pow(dnu / lambda, steps);
243  *boundaryscale = 1.0 / (1.0 - dnu);
244  *nu = (float)dnu;
245 }
246 
247 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
248 {
249  AVFilterContext *ctx = inlink->dst;
250  GBlurContext *s = ctx->priv;
251  AVFilterLink *outlink = ctx->outputs[0];
252  AVFrame *out;
253  int plane;
254 
255  set_params(s->sigma, s->steps, &s->postscale, &s->boundaryscale, &s->nu);
256  set_params(s->sigmaV, s->steps, &s->postscaleV, &s->boundaryscaleV, &s->nuV);
257 
258  if (av_frame_is_writable(in)) {
259  out = in;
260  } else {
261  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
262  if (!out) {
263  av_frame_free(&in);
264  return AVERROR(ENOMEM);
265  }
266  av_frame_copy_props(out, in);
267  }
268 
269  for (plane = 0; plane < s->nb_planes; plane++) {
270  const int height = s->planeheight[plane];
271  const int width = s->planewidth[plane];
272  float *bptr = s->buffer;
273  const uint8_t *src = in->data[plane];
274  const uint16_t *src16 = (const uint16_t *)in->data[plane];
275  uint8_t *dst = out->data[plane];
276  uint16_t *dst16 = (uint16_t *)out->data[plane];
277  int y, x;
278 
279  if (!s->sigma || !(s->planes & (1 << plane))) {
280  if (out != in)
281  av_image_copy_plane(out->data[plane], out->linesize[plane],
282  in->data[plane], in->linesize[plane],
283  width * ((s->depth + 7) / 8), height);
284  continue;
285  }
286 
287  if (s->depth == 8) {
288  for (y = 0; y < height; y++) {
289  for (x = 0; x < width; x++) {
290  bptr[x] = src[x];
291  }
292  bptr += width;
293  src += in->linesize[plane];
294  }
295  } else {
296  for (y = 0; y < height; y++) {
297  for (x = 0; x < width; x++) {
298  bptr[x] = src16[x];
299  }
300  bptr += width;
301  src16 += in->linesize[plane] / 2;
302  }
303  }
304 
305  gaussianiir2d(ctx, plane);
306 
307  bptr = s->buffer;
308  if (s->depth == 8) {
309  for (y = 0; y < height; y++) {
310  for (x = 0; x < width; x++) {
311  dst[x] = bptr[x];
312  }
313  bptr += width;
314  dst += out->linesize[plane];
315  }
316  } else {
317  for (y = 0; y < height; y++) {
318  for (x = 0; x < width; x++) {
319  dst16[x] = bptr[x];
320  }
321  bptr += width;
322  dst16 += out->linesize[plane] / 2;
323  }
324  }
325  }
326 
327  if (out != in)
328  av_frame_free(&in);
329  return ff_filter_frame(outlink, out);
330 }
331 
333 {
334  GBlurContext *s = ctx->priv;
335 
336  av_freep(&s->buffer);
337 }
338 
339 static const AVFilterPad gblur_inputs[] = {
340  {
341  .name = "default",
342  .type = AVMEDIA_TYPE_VIDEO,
343  .config_props = config_input,
344  .filter_frame = filter_frame,
345  },
346  { NULL }
347 };
348 
349 static const AVFilterPad gblur_outputs[] = {
350  {
351  .name = "default",
352  .type = AVMEDIA_TYPE_VIDEO,
353  },
354  { NULL }
355 };
356 
358  .name = "gblur",
359  .description = NULL_IF_CONFIG_SMALL("Apply Gaussian Blur filter."),
360  .priv_size = sizeof(GBlurContext),
361  .priv_class = &gblur_class,
362  .uninit = uninit,
364  .inputs = gblur_inputs,
365  .outputs = gblur_outputs,
367 };
float nu
Definition: vf_gblur.c:52
int plane
Definition: avisynth_c.h:422
float boundaryscale
Definition: vf_gblur.c:48
#define NULL
Definition: coverity.c:32
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:420
#define AV_PIX_FMT_YUVA422P9
Definition: pixfmt.h:414
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2446
This structure describes decoded (raw) audio or video data.
Definition: frame.h:226
static void gaussianiir2d(AVFilterContext *ctx, int plane)
Definition: vf_gblur.c:168
static const AVFilterPad gblur_inputs[]
Definition: vf_gblur.c:339
AVOption.
Definition: opt.h:246
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:416
float nuV
Definition: vf_gblur.c:53
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:389
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:399
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:417
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:2486
Main libavfilter public API header.
#define FLAGS
Definition: vf_gblur.c:58
const char * desc
Definition: nvenc.c:65
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:168
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:395
#define AV_PIX_FMT_GRAY9
Definition: pixfmt.h:359
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:383
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
#define src
Definition: vp8dsp.c:254
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: vf_gblur.c:46
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:360
int planewidth[4]
Definition: vf_gblur.c:45
#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:361
float sigma
Definition: vf_gblur.c:39
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1080
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.
float boundaryscaleV
Definition: vf_gblur.c:49
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:413
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:394
int height
Definition: vf_avgblur.c:61
#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:392
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:384
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:419
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_gblur.c:332
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:568
#define td
Definition: regdef.h:70
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
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: vf_gblur.c:40
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:421
const char * arg
Definition: jacosubdec.c:66
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:400
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:382
AVFILTER_DEFINE_CLASS(gblur)
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:401
static const AVOption gblur_options[]
Definition: vf_gblur.c:60
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:377
static const struct @304 planes[]
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:398
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:363
#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
#define width
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:418
float * buffer
Definition: vf_gblur.c:47
static const AVFilterPad inputs[]
Definition: af_acontrast.c:193
float postscaleV
Definition: vf_gblur.c:51
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:378
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:397
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
static void set_params(float sigma, int steps, float *postscale, float *boundaryscale, float *nu)
Definition: vf_gblur.c:236
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:390
static int config_input(AVFilterLink *inlink)
Definition: vf_gblur.c:212
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:387
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:484
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:257
static int query_formats(AVFilterContext *ctx)
Definition: vf_gblur.c:186
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:362
int planes
Definition: vf_gblur.c:42
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;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);returnNULL;}returnac;}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;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->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);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> in
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:379
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
AVFilter ff_vf_gblur
Definition: vf_gblur.c:357
int nb_planes
Definition: vf_gblur.c:54
float postscale
Definition: vf_gblur.c:50
const char * name
Filter name.
Definition: avfilter.h:148
#define AV_PIX_FMT_YUV440P12
Definition: pixfmt.h:385
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: vf_gblur.c:247
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:376
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:350
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:266
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:388
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:396
static int filter_vertically(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_gblur.c:111
#define flags(name, subs,...)
Definition: cbs_av1.c:596
AVFilterInternal * internal
An opaque struct for libavfilter internal use.
Definition: avfilter.h:378
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:380
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:386
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:240
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
Y , 8bpp.
Definition: pixfmt.h:74
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:215
#define AV_PIX_FMT_YUVA444P9
Definition: pixfmt.h:415
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:80
#define OFFSET(x)
Definition: vf_gblur.c:57
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
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
#define av_freep(p)
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:99
static const AVFilterPad gblur_outputs[]
Definition: vf_gblur.c:349
#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
static int filter_postscale(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_gblur.c:149
static int filter_horizontally(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_gblur.c:75
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:391
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:654
GLuint buffer
Definition: opengl_enc.c:102
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58