FFmpeg: libavfilter/vf_unsharp.c Source File

FFmpeg
vf_unsharp.c
Go to the documentation of this file.
1 /*
2  * Original copyright (c) 2002 Remi Guyomarch <rguyom@pobox.com>
3  * Port copyright (c) 2010 Daniel G. Taylor <dan@programmer-art.org>
4  * Relicensed to the LGPL with permission from Remi Guyomarch.
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * blur / sharpen filter, ported to FFmpeg from MPlayer
26  * libmpcodecs/unsharp.c.
27  *
28  * This code is based on:
29  *
30  * An Efficient algorithm for Gaussian blur using finite-state machines
31  * Frederick M. Waltz and John W. V. Miller
32  *
33  * SPIE Conf. on Machine Vision Systems for Inspection and Metrology VII
34  * Originally published Boston, Nov 98
35  *
36  * http://www.engin.umd.umich.edu/~jwvm/ece581/21_GBlur.pdf
37  */
38 
39 #include "avfilter.h"
40 #include "filters.h"
41 #include "video.h"
42 #include "libavutil/common.h"
43 #include "libavutil/imgutils.h"
44 #include "libavutil/mem.h"
45 #include "libavutil/opt.h"
46 #include "libavutil/pixdesc.h"
47 
48  #define MIN_MATRIX_SIZE 3
49  #define MAX_MATRIX_SIZE 63
50 
51  typedef struct UnsharpFilterParam {
52   int msize_x; ///< matrix width
53   int msize_y; ///< matrix height
54   int amount; ///< effect amount
55   int steps_x; ///< horizontal step count
56   int steps_y; ///< vertical step count
57   int scalebits; ///< bits to shift pixel
58   int32_t halfscale; ///< amount to add to pixel
59   uint32_t *sr; ///< finite state machine storage within a row
60   uint32_t **sc; ///< finite state machine storage across rows
61 } UnsharpFilterParam;
62 
63  typedef struct UnsharpContext {
64   const AVClass *class;
65   int lmsize_x, lmsize_y, cmsize_x, cmsize_y;
66   int amsize_x, amsize_y;
67   float lamount, camount;
68   float aamount;
69   UnsharpFilterParam luma; ///< luma parameters (width, height, amount)
70   UnsharpFilterParam chroma; ///< chroma parameters (width, height, amount)
71   UnsharpFilterParam alpha; ///< alpha parameters (width, height, amount)
72   int hsub, vsub;
73   int nb_planes;
74   int bitdepth;
75   int bps;
76   int nb_threads;
77   int (* unsharp_slice)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
78 } UnsharpContext;
79 
80  typedef struct TheadData {
81   UnsharpFilterParam *fp;
82   uint8_t *dst;
83   const uint8_t *src;
84   int dst_stride;
85   int src_stride;
86   int width;
87   int height;
88 } ThreadData;
89 
90  #define DEF_UNSHARP_SLICE_FUNC(name, nbits) \
91 static int name##_##nbits(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs) \
92 { \
93  ThreadData *td = arg; \
94  UnsharpFilterParam *fp = td->fp; \
95  UnsharpContext *s = ctx->priv; \
96  uint32_t **sc = fp->sc; \
97  uint32_t *sr = fp->sr; \
98  const uint##nbits##_t *src2 = NULL; \
99  const int amount = fp->amount; \
100  const int steps_x = fp->steps_x; \
101  const int steps_y = fp->steps_y; \
102  const int scalebits = fp->scalebits; \
103  const int32_t halfscale = fp->halfscale; \
104  \
105  uint##nbits##_t *dst = (uint##nbits##_t*)td->dst; \
106  const uint##nbits##_t *src = (const uint##nbits##_t *)td->src; \
107  int dst_stride = td->dst_stride; \
108  int src_stride = td->src_stride; \
109  const int width = td->width; \
110  const int height = td->height; \
111  const int sc_offset = jobnr * 2 * steps_y; \
112  const int sr_offset = jobnr * (MAX_MATRIX_SIZE - 1); \
113  const int slice_start = (height * jobnr) / nb_jobs; \
114  const int slice_end = (height * (jobnr+1)) / nb_jobs; \
115  \
116  int32_t res; \
117  int x, y, z; \
118  uint32_t tmp1, tmp2; \
119  \
120  if (!amount) { \
121  av_image_copy_plane(td->dst + slice_start * dst_stride, dst_stride, \
122  td->src + slice_start * src_stride, src_stride, \
123  width * s->bps, slice_end - slice_start); \
124  return 0; \
125  } \
126  \
127  for (y = 0; y < 2 * steps_y; y++) \
128  memset(sc[sc_offset + y], 0, sizeof(sc[y][0]) * (width + 2 * steps_x)); \
129  \
130  dst_stride = dst_stride / s->bps; \
131  src_stride = src_stride / s->bps; \
132 /* if this is not the first tile, we start from (slice_start - steps_y) */ \
133 /* so we can get smooth result at slice boundary */ \
134  if (slice_start > steps_y) { \
135  src += (slice_start - steps_y) * src_stride; \
136  dst += (slice_start - steps_y) * dst_stride; \
137  } \
138  \
139  for (y = -steps_y + slice_start; y < steps_y + slice_end; y++) { \
140  if (y < height) \
141  src2 = src; \
142  \
143  memset(sr + sr_offset, 0, sizeof(sr[0]) * (2 * steps_x - 1)); \
144  for (x = -steps_x; x < width + steps_x; x++) { \
145  tmp1 = x <= 0 ? src2[0] : x >= width ? src2[width-1] : src2[x]; \
146  for (z = 0; z < steps_x * 2; z += 2) { \
147  tmp2 = sr[sr_offset + z + 0] + tmp1; sr[sr_offset + z + 0] = tmp1; \
148  tmp1 = sr[sr_offset + z + 1] + tmp2; sr[sr_offset + z + 1] = tmp2; \
149  } \
150  for (z = 0; z < steps_y * 2; z += 2) { \
151  tmp2 = sc[sc_offset + z + 0][x + steps_x] + tmp1; \
152  sc[sc_offset + z + 0][x + steps_x] = tmp1; \
153  tmp1 = sc[sc_offset + z + 1][x + steps_x] + tmp2; \
154  sc[sc_offset + z + 1][x + steps_x] = tmp2; \
155  } \
156  if (x >= steps_x && y >= (steps_y + slice_start)) { \
157  const uint##nbits##_t *srx = src - steps_y * src_stride + x - steps_x; \
158  uint##nbits##_t *dsx = dst - steps_y * dst_stride + x - steps_x; \
159  \
160  res = (int32_t)*srx + ((((int32_t) * srx - \
161  (int32_t)((tmp1 + halfscale) >> scalebits)) * amount) >> (8+nbits)); \
162  *dsx = av_clip_uint##nbits(res); \
163  } \
164  } \
165  if (y >= 0) { \
166  dst += dst_stride; \
167  src += src_stride; \
168  } \
169  } \
170  return 0; \
171 }
172 DEF_UNSHARP_SLICE_FUNC(unsharp_slice, 16)
173 DEF_UNSHARP_SLICE_FUNC(unsharp_slice, 8)
174 
175  static int apply_unsharp(AVFilterContext *ctx, AVFrame *in, AVFrame *out)
176 {
177  AVFilterLink *inlink = ctx->inputs[0];
178  UnsharpContext *s = ctx->priv;
179  int i, plane_w[4], plane_h[4];
180  UnsharpFilterParam *fp[4];
181  ThreadData td;
182 
183  plane_w[0] = plane_w[3] = inlink->w;
184  plane_w[1] = plane_w[2] = AV_CEIL_RSHIFT(inlink->w, s->hsub);
185  plane_h[0] = plane_h[3] = inlink->h;
186  plane_h[1] = plane_h[2] = AV_CEIL_RSHIFT(inlink->h, s->vsub);
187  fp[0] = &s->luma;
188  fp[1] = fp[2] = &s->chroma;
189  fp[3] = &s->alpha;
190  for (i = 0; i < s->nb_planes; i++) {
191  td.fp = fp[i];
192  td.dst = out->data[i];
193  td.src = in->data[i];
194  td.width = plane_w[i];
195  td.height = plane_h[i];
196  td.dst_stride = out->linesize[i];
197  td.src_stride = in->linesize[i];
198  ff_filter_execute(ctx, s->unsharp_slice, &td, NULL,
199  FFMIN(plane_h[i], s->nb_threads));
200  }
201  return 0;
202 }
203 
204  #define MAX_SCALEBITS 25
205 
206  static int set_filter_param(AVFilterContext *ctx, const char *name, const char *short_name,
207  UnsharpFilterParam *fp, int msize_x, int msize_y, float amount)
208 {
209  fp->msize_x = msize_x;
210  fp->msize_y = msize_y;
211  fp->amount = amount * 65536.0;
212 
213  fp->steps_x = msize_x / 2;
214  fp->steps_y = msize_y / 2;
215  fp->scalebits = (fp->steps_x + fp->steps_y) * 2;
216  fp->halfscale = 1 << (fp->scalebits - 1);
217 
218  if (fp->scalebits > MAX_SCALEBITS) {
219  av_log(ctx, AV_LOG_ERROR, "%s matrix size (%sx/2+%sy/2)*2=%d greater than maximum value %d\n",
220  name, short_name, short_name, fp->scalebits, MAX_SCALEBITS);
221  return AVERROR(EINVAL);
222  }
223 
224  return 0;
225 }
226 
227  static av_cold int init(AVFilterContext *ctx)
228 {
229  UnsharpContext *s = ctx->priv;
230  int ret;
231 
232 #define SET_FILTER_PARAM(name_, short_) \
233  ret = set_filter_param(ctx, #name_, #short_, &s->name_, \
234  s->short_##msize_x, s->short_##msize_y, s->short_##amount); \
235  if (ret < 0) \
236  return ret; \
237 
238  SET_FILTER_PARAM(luma, l);
239  SET_FILTER_PARAM(chroma, c);
240  SET_FILTER_PARAM(alpha, a);
241 
242  return 0;
243 }
244 
245  static const enum AVPixelFormat pix_fmts[] = {
246  AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,
247  AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA444P12, AV_PIX_FMT_YUVA444P16,
248  AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA422P12, AV_PIX_FMT_YUVA422P16,
249  AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA420P16,
250  AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV410P,
251  AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
252  AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
253  AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUV440P10,
254  AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
255  AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16,
256  AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_NONE
257 };
258 
259  static int init_filter_param(AVFilterContext *ctx, UnsharpFilterParam *fp, const char *effect_type, int width)
260 {
261  int z;
262  UnsharpContext *s = ctx->priv;
263  const char *effect = fp->amount == 0 ? "none" : fp->amount < 0 ? "blur" : "sharpen";
264 
265  if (!(fp->msize_x & fp->msize_y & 1)) {
266  av_log(ctx, AV_LOG_ERROR,
267  "Invalid even size for %s matrix size %dx%d\n",
268  effect_type, fp->msize_x, fp->msize_y);
269  return AVERROR(EINVAL);
270  }
271 
272  av_log(ctx, AV_LOG_VERBOSE, "effect:%s type:%s msize_x:%d msize_y:%d amount:%0.2f\n",
273  effect, effect_type, fp->msize_x, fp->msize_y, fp->amount / 65535.0);
274 
275  fp->sr = av_malloc_array((MAX_MATRIX_SIZE - 1) * s->nb_threads, sizeof(uint32_t));
276  fp->sc = av_calloc(fp->steps_y * s->nb_threads, 2 * sizeof(*fp->sc));
277  if (!fp->sr || !fp->sc)
278  return AVERROR(ENOMEM);
279 
280  for (z = 0; z < 2 * fp->steps_y * s->nb_threads; z++)
281  if (!(fp->sc[z] = av_malloc_array(width + 2 * fp->steps_x,
282  sizeof(*(fp->sc[z])))))
283  return AVERROR(ENOMEM);
284 
285  return 0;
286 }
287 
288  static int config_input(AVFilterLink *inlink)
289 {
290  UnsharpContext *s = inlink->dst->priv;
291  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
292  int ret;
293 
294  s->nb_planes = desc->nb_components;
295  s->hsub = desc->log2_chroma_w;
296  s->vsub = desc->log2_chroma_h;
297  s->bitdepth = desc->comp[0].depth;
298  s->bps = s->bitdepth > 8 ? 2 : 1;
299  s->unsharp_slice = s->bitdepth > 8 ? unsharp_slice_16 : unsharp_slice_8;
300 
301  // ensure (height / nb_threads) > 4 * steps_y,
302  // so that we don't have too much overlap between two threads
303  s->nb_threads = FFMIN(ff_filter_get_nb_threads(inlink->dst),
304  inlink->h / (4 * s->luma.steps_y));
305 
306  ret = init_filter_param(inlink->dst, &s->luma, "luma", inlink->w);
307  if (ret < 0)
308  return ret;
309  ret = init_filter_param(inlink->dst, &s->chroma, "chroma", AV_CEIL_RSHIFT(inlink->w, s->hsub));
310  if (ret < 0)
311  return ret;
312 
313  return 0;
314 }
315 
316  static void free_filter_param(UnsharpFilterParam *fp, int nb_threads)
317 {
318  int z;
319 
320  if (fp->sc) {
321  for (z = 0; z < 2 * fp->steps_y * nb_threads; z++)
322  av_freep(&fp->sc[z]);
323  av_freep(&fp->sc);
324  }
325  av_freep(&fp->sr);
326 }
327 
328  static av_cold void uninit(AVFilterContext *ctx)
329 {
330  UnsharpContext *s = ctx->priv;
331 
332  free_filter_param(&s->luma, s->nb_threads);
333  free_filter_param(&s->chroma, s->nb_threads);
334 }
335 
336  static int filter_frame(AVFilterLink *link, AVFrame *in)
337 {
338  AVFilterLink *outlink = link->dst->outputs[0];
339  AVFrame *out;
340  int ret = 0;
341 
342  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
343  if (!out) {
344  av_frame_free(&in);
345  return AVERROR(ENOMEM);
346  }
347  av_frame_copy_props(out, in);
348 
349  ret = apply_unsharp(link->dst, in, out);
350 
351  av_frame_free(&in);
352 
353  if (ret < 0) {
354  av_frame_free(&out);
355  return ret;
356  }
357  return ff_filter_frame(outlink, out);
358 }
359 
360  #define OFFSET(x) offsetof(UnsharpContext, x)
361  #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
362  #define MIN_SIZE 3
363  #define MAX_SIZE 23
364  static const AVOption unsharp_options[] = {
365  { "luma_msize_x", "set luma matrix horizontal size", OFFSET(lmsize_x), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
366  { "lx", "set luma matrix horizontal size", OFFSET(lmsize_x), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
367  { "luma_msize_y", "set luma matrix vertical size", OFFSET(lmsize_y), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
368  { "ly", "set luma matrix vertical size", OFFSET(lmsize_y), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
369  { "luma_amount", "set luma effect strength", OFFSET(lamount), AV_OPT_TYPE_FLOAT, { .dbl = 1 }, -2, 5, FLAGS },
370  { "la", "set luma effect strength", OFFSET(lamount), AV_OPT_TYPE_FLOAT, { .dbl = 1 }, -2, 5, FLAGS },
371  { "chroma_msize_x", "set chroma matrix horizontal size", OFFSET(cmsize_x), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
372  { "cx", "set chroma matrix horizontal size", OFFSET(cmsize_x), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
373  { "chroma_msize_y", "set chroma matrix vertical size", OFFSET(cmsize_y), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
374  { "cy", "set chroma matrix vertical size", OFFSET(cmsize_y), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
375  { "chroma_amount", "set chroma effect strength", OFFSET(camount), AV_OPT_TYPE_FLOAT, { .dbl = 0 }, -2, 5, FLAGS },
376  { "ca", "set chroma effect strength", OFFSET(camount), AV_OPT_TYPE_FLOAT, { .dbl = 0 }, -2, 5, FLAGS },
377  { "alpha_msize_x", "set alpha matrix horizontal size", OFFSET(amsize_x), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
378  { "ax", "set alpha matrix horizontal size", OFFSET(amsize_x), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
379  { "alpha_msize_y", "set alpha matrix vertical size", OFFSET(amsize_y), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
380  { "ay", "set alpha matrix vertical size", OFFSET(amsize_y), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
381  { "alpha_amount", "set alpha effect strength", OFFSET(aamount), AV_OPT_TYPE_FLOAT, { .dbl = 0 }, -2, 5, FLAGS },
382  { "aa", "set alpha effect strength", OFFSET(aamount), AV_OPT_TYPE_FLOAT, { .dbl = 0 }, -2, 5, FLAGS },
383  { NULL }
384 };
385 
386 AVFILTER_DEFINE_CLASS(unsharp);
387 
388  static const AVFilterPad avfilter_vf_unsharp_inputs[] = {
389  {
390  .name = "default",
391  .type = AVMEDIA_TYPE_VIDEO,
392  .filter_frame = filter_frame,
393  .config_props = config_input,
394  },
395 };
396 
397  const FFFilter ff_vf_unsharp = {
398  .p.name = "unsharp",
399  .p.description = NULL_IF_CONFIG_SMALL("Sharpen or blur the input video."),
400  .p.priv_class = &unsharp_class,
401  .p.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
402  .priv_size = sizeof(UnsharpContext),
403  .init = init,
404  .uninit = uninit,
405  FILTER_INPUTS(avfilter_vf_unsharp_inputs),
406  FILTER_OUTPUTS(ff_video_default_filterpad),
407  FILTER_PIXFMTS_ARRAY(pix_fmts),
408 };
ff_get_video_buffer
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:117
AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:596
ThreadData::src_stride
int src_stride
Definition: vf_vif.c:92
UnsharpContext::cmsize_x
int cmsize_x
Definition: vf_unsharp.c:65
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
UnsharpContext::chroma
UnsharpFilterParam chroma
chroma parameters (width, height, amount)
Definition: vf_unsharp.c:70
AVERROR
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
opt.h
FILTER_PIXFMTS_ARRAY
#define FILTER_PIXFMTS_ARRAY(array)
Definition: filters.h:243
out
FILE * out
Definition: movenc.c:55
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1067
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3447
ThreadData::dst_stride
int dst_stride
Definition: vf_vif.c:93
UnsharpFilterParam::msize_x
int msize_x
matrix width
Definition: vf_unsharp.c:52
inlink
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
Definition: filter_design.txt:212
MAX_SCALEBITS
#define MAX_SCALEBITS
Definition: vf_unsharp.c:204
ff_vf_unsharp
const FFFilter ff_vf_unsharp
Definition: vf_unsharp.c:397
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:64
AV_PIX_FMT_YUVA422P9
#define AV_PIX_FMT_YUVA422P9
Definition: pixfmt.h:588
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: filters.h:263
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:427
pixdesc.h
AV_PIX_FMT_YUVA420P16
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:595
AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:590
AVOption
AVOption.
Definition: opt.h:429
chroma
static av_always_inline void chroma(WaveformContext *s, AVFrame *in, AVFrame *out, int component, int intensity, int offset_y, int offset_x, int column, int mirror, int jobnr, int nb_jobs)
Definition: vf_waveform.c:1639
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:539
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:226
AV_PIX_FMT_YUV440P
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:106
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:220
video.h
AV_PIX_FMT_YUVA422P10
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:591
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_unsharp.c:328
MIN_SIZE
#define MIN_SIZE
Definition: vf_unsharp.c:362
filter_frame
static int filter_frame(AVFilterLink *link, AVFrame *in)
Definition: vf_unsharp.c:336
ThreadData::width
int width
Definition: vf_avgblur.c:65
AV_PIX_FMT_YUVA420P9
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:587
UnsharpContext::aamount
float aamount
Definition: vf_unsharp.c:68
config_input
static int config_input(AVFilterLink *inlink)
Definition: vf_unsharp.c:288
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:597
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:537
set_filter_param
static int set_filter_param(AVFilterContext *ctx, const char *name, const char *short_name, UnsharpFilterParam *fp, int msize_x, int msize_y, float amount)
Definition: vf_unsharp.c:206
init
static av_cold int init(AVFilterContext *ctx)
Definition: vf_unsharp.c:227
AVFilterPad
A filter pad used for either input or output.
Definition: filters.h:39
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:542
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
UnsharpContext::lmsize_y
int lmsize_y
Definition: vf_unsharp.c:65
av_cold
#define av_cold
Definition: attributes.h:106
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:551
ff_video_default_filterpad
const AVFilterPad ff_video_default_filterpad[1]
An AVFilterPad array whose only entry has name "default" and is of type AVMEDIA_TYPE_VIDEO.
Definition: video.c:37
FFFilter
Definition: filters.h:266
AV_PIX_FMT_YUVJ422P
@ 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:86
TheadData::width
int width
Definition: vf_unsharp.c:86
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV_PIX_FMT_YUVA420P
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:108
UnsharpContext::amsize_y
int amsize_y
Definition: vf_unsharp.c:66
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:552
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:60
ThreadData::height
int height
Definition: vf_avgblur.c:64
UnsharpFilterParam
Definition: vf_unsharp.c:51
UnsharpContext::alpha
UnsharpFilterParam alpha
alpha parameters (width, height, amount)
Definition: vf_unsharp.c:71
UnsharpFilterParam::msize_y
int msize_y
matrix height
Definition: vf_unsharp.c:53
filters.h
AV_PIX_FMT_YUVA444P12
#define AV_PIX_FMT_YUVA444P12
Definition: pixfmt.h:594
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:536
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:550
ctx
AVFormatContext * ctx
Definition: movenc.c:49
apply_unsharp
static int apply_unsharp(AVFilterContext *ctx, AVFrame *in, AVFrame *out)
Definition: vf_unsharp.c:175
MAX_SIZE
#define MAX_SIZE
Definition: vf_unsharp.c:363
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: filters.h:264
link
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 link
Definition: filter_design.txt:23
AV_PIX_FMT_YUVJ444P
@ 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:87
arg
const char * arg
Definition: jacosubdec.c:67
ThreadData::dst
AVFrame * dst
Definition: vf_blend.c:58
UnsharpContext
Definition: vf_unsharp.c:63
free_filter_param
static void free_filter_param(UnsharpFilterParam *fp, int nb_threads)
Definition: vf_unsharp.c:316
UnsharpContext::bitdepth
int bitdepth
Definition: vf_unsharp.c:74
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
UnsharpContext::cmsize_y
int cmsize_y
Definition: vf_unsharp.c:65
NULL
#define NULL
Definition: coverity.c:32
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:599
ThreadData::src
const uint8_t * src
Definition: vf_bm3d.c:54
UnsharpFilterParam::steps_y
int steps_y
vertical step count
Definition: vf_unsharp.c:56
UnsharpContext::camount
float camount
Definition: vf_unsharp.c:67
AV_PIX_FMT_YUVJ420P
@ 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:85
UnsharpContext::vsub
int vsub
Definition: vf_unsharp.c:72
AV_PIX_FMT_YUV440P10
#define AV_PIX_FMT_YUV440P10
Definition: pixfmt.h:541
OFFSET
#define OFFSET(x)
Definition: vf_unsharp.c:360
SET_FILTER_PARAM
#define SET_FILTER_PARAM(name_, short_)
MAX_MATRIX_SIZE
#define MAX_MATRIX_SIZE
Definition: vf_unsharp.c:49
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:540
init_filter_param
static int init_filter_param(AVFilterContext *ctx, UnsharpFilterParam *fp, const char *effect_type, int width)
Definition: vf_unsharp.c:259
TheadData::dst_stride
int dst_stride
Definition: vf_unsharp.c:84
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
TheadData::height
int height
Definition: vf_unsharp.c:87
UnsharpFilterParam::scalebits
int scalebits
bits to shift pixel
Definition: vf_unsharp.c:57
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:94
DEF_UNSHARP_SLICE_FUNC
#define DEF_UNSHARP_SLICE_FUNC(name, nbits)
Definition: vf_unsharp.c:90
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:544
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:546
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
unsharp_options
static const AVOption unsharp_options[]
Definition: vf_unsharp.c:364
UnsharpContext::lamount
float lamount
Definition: vf_unsharp.c:67
AV_PIX_FMT_YUVA444P
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:174
AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:592
TheadData
Definition: vf_unsharp.c:80
AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
#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:197
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Underlying C type is float.
Definition: opt.h:271
UnsharpFilterParam::steps_x
int steps_x
horizontal step count
Definition: vf_unsharp.c:55
TheadData::fp
UnsharpFilterParam * fp
Definition: vf_unsharp.c:81
UnsharpContext::nb_threads
int nb_threads
Definition: vf_unsharp.c:76
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
common.h
ff_filter_get_nb_threads
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:845
ThreadData
Used for passing data between threads.
Definition: dsddec.c:71
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: vf_unsharp.c:245
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AV_PIX_FMT_YUVJ440P
@ 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:107
FLAGS
#define FLAGS
Definition: vf_unsharp.c:361
AVFilterPad::name
const char * name
Pad name.
Definition: filters.h:45
TheadData::dst
uint8_t * dst
Definition: vf_unsharp.c:82
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:538
UnsharpContext::unsharp_slice
int(* unsharp_slice)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_unsharp.c:77
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(unsharp)
UnsharpContext::hsub
int hsub
Definition: vf_unsharp.c:72
ret
ret
Definition: filter_design.txt:187
UnsharpContext::nb_planes
int nb_planes
Definition: vf_unsharp.c:73
AV_PIX_FMT_YUVA444P9
#define AV_PIX_FMT_YUVA444P9
Definition: pixfmt.h:589
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:543
ff_filter_execute
int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
Definition: avfilter.c:1693
avfilter_vf_unsharp_inputs
static const AVFilterPad avfilter_vf_unsharp_inputs[]
Definition: vf_unsharp.c:388
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
UnsharpContext::amsize_x
int amsize_x
Definition: vf_unsharp.c:66
AV_PIX_FMT_YUVA422P12
#define AV_PIX_FMT_YUVA422P12
Definition: pixfmt.h:593
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
avfilter.h
UnsharpFilterParam::halfscale
int32_t halfscale
amount to add to pixel
Definition: vf_unsharp.c:58
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:78
AVFilterContext
An instance of a filter.
Definition: avfilter.h:274
AVFILTER_FLAG_SLICE_THREADS
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition: avfilter.h:167
desc
const char * desc
Definition: libsvtav1.c:79
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
FFFilter::p
AVFilter p
The public AVFilter.
Definition: filters.h:270
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:77
mem.h
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
UnsharpContext::bps
int bps
Definition: vf_unsharp.c:75
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
TheadData::src_stride
int src_stride
Definition: vf_unsharp.c:85
AV_PIX_FMT_YUV411P
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:80
int32_t
int32_t
Definition: audioconvert.c:56
imgutils.h
AV_PIX_FMT_YUV410P
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:79
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AV_PIX_FMT_YUV440P12
#define AV_PIX_FMT_YUV440P12
Definition: pixfmt.h:545
width
#define width
Definition: dsp.h:89
UnsharpFilterParam::sc
uint32_t ** sc
finite state machine storage across rows
Definition: vf_unsharp.c:60
UnsharpFilterParam::sr
uint32_t * sr
finite state machine storage within a row
Definition: vf_unsharp.c:59
TheadData::src
const uint8_t * src
Definition: vf_unsharp.c:83
UnsharpFilterParam::amount
int amount
effect amount
Definition: vf_unsharp.c:54
AV_PIX_FMT_YUVA422P
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:173
UnsharpContext::lmsize_x
int lmsize_x
Definition: vf_unsharp.c:65
UnsharpContext::luma
UnsharpFilterParam luma
luma parameters (width, height, amount)
Definition: vf_unsharp.c:69
Generated on Sat Oct 18 2025 19:23:13 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /