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 "internal.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 #include "unsharp.h"
48 
49 typedef struct TheadData {
51  uint8_t *dst;
52  const uint8_t *src;
55  int width;
56  int height;
57 } ThreadData;
58 
59 #define DEF_UNSHARP_SLICE_FUNC(name, nbits) \
60 static int name##_##nbits(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs) \
61 { \
62  ThreadData *td = arg; \
63  UnsharpFilterParam *fp = td->fp; \
64  UnsharpContext *s = ctx->priv; \
65  uint32_t **sc = fp->sc; \
66  uint32_t *sr = fp->sr; \
67  const uint##nbits##_t *src2 = NULL; \
68  const int amount = fp->amount; \
69  const int steps_x = fp->steps_x; \
70  const int steps_y = fp->steps_y; \
71  const int scalebits = fp->scalebits; \
72  const int32_t halfscale = fp->halfscale; \
73  \
74  uint##nbits##_t *dst = (uint##nbits##_t*)td->dst; \
75  const uint##nbits##_t *src = (const uint##nbits##_t *)td->src; \
76  int dst_stride = td->dst_stride; \
77  int src_stride = td->src_stride; \
78  const int width = td->width; \
79  const int height = td->height; \
80  const int sc_offset = jobnr * 2 * steps_y; \
81  const int sr_offset = jobnr * (MAX_MATRIX_SIZE - 1); \
82  const int slice_start = (height * jobnr) / nb_jobs; \
83  const int slice_end = (height * (jobnr+1)) / nb_jobs; \
84  \
85  int32_t res; \
86  int x, y, z; \
87  uint32_t tmp1, tmp2; \
88  \
89  if (!amount) { \
90  av_image_copy_plane(td->dst + slice_start * dst_stride, dst_stride, \
91  td->src + slice_start * src_stride, src_stride, \
92  width * s->bps, slice_end - slice_start); \
93  return 0; \
94  } \
95  \
96  for (y = 0; y < 2 * steps_y; y++) \
97  memset(sc[sc_offset + y], 0, sizeof(sc[y][0]) * (width + 2 * steps_x)); \
98  \
99  dst_stride = dst_stride / s->bps; \
100  src_stride = src_stride / s->bps; \
101  /* if this is not the first tile, we start from (slice_start - steps_y) */ \
102  /* so we can get smooth result at slice boundary */ \
103  if (slice_start > steps_y) { \
104  src += (slice_start - steps_y) * src_stride; \
105  dst += (slice_start - steps_y) * dst_stride; \
106  } \
107  \
108  for (y = -steps_y + slice_start; y < steps_y + slice_end; y++) { \
109  if (y < height) \
110  src2 = src; \
111  \
112  memset(sr + sr_offset, 0, sizeof(sr[0]) * (2 * steps_x - 1)); \
113  for (x = -steps_x; x < width + steps_x; x++) { \
114  tmp1 = x <= 0 ? src2[0] : x >= width ? src2[width-1] : src2[x]; \
115  for (z = 0; z < steps_x * 2; z += 2) { \
116  tmp2 = sr[sr_offset + z + 0] + tmp1; sr[sr_offset + z + 0] = tmp1; \
117  tmp1 = sr[sr_offset + z + 1] + tmp2; sr[sr_offset + z + 1] = tmp2; \
118  } \
119  for (z = 0; z < steps_y * 2; z += 2) { \
120  tmp2 = sc[sc_offset + z + 0][x + steps_x] + tmp1; \
121  sc[sc_offset + z + 0][x + steps_x] = tmp1; \
122  tmp1 = sc[sc_offset + z + 1][x + steps_x] + tmp2; \
123  sc[sc_offset + z + 1][x + steps_x] = tmp2; \
124  } \
125  if (x >= steps_x && y >= (steps_y + slice_start)) { \
126  const uint##nbits##_t *srx = src - steps_y * src_stride + x - steps_x; \
127  uint##nbits##_t *dsx = dst - steps_y * dst_stride + x - steps_x; \
128  \
129  res = (int32_t)*srx + ((((int32_t) * srx - \
130  (int32_t)((tmp1 + halfscale) >> scalebits)) * amount) >> (8+nbits)); \
131  *dsx = av_clip_uint##nbits(res); \
132  } \
133  } \
134  if (y >= 0) { \
135  dst += dst_stride; \
136  src += src_stride; \
137  } \
138  } \
139  return 0; \
140 }
141 DEF_UNSHARP_SLICE_FUNC(unsharp_slice, 16)
142 DEF_UNSHARP_SLICE_FUNC(unsharp_slice, 8)
143 
145 {
146  AVFilterLink *inlink = ctx->inputs[0];
147  UnsharpContext *s = ctx->priv;
148  int i, plane_w[4], plane_h[4];
150  ThreadData td;
151 
152  plane_w[0] = plane_w[3] = inlink->w;
153  plane_w[1] = plane_w[2] = AV_CEIL_RSHIFT(inlink->w, s->hsub);
154  plane_h[0] = plane_h[3] = inlink->h;
155  plane_h[1] = plane_h[2] = AV_CEIL_RSHIFT(inlink->h, s->vsub);
156  fp[0] = &s->luma;
157  fp[1] = fp[2] = &s->chroma;
158  fp[3] = &s->alpha;
159  for (i = 0; i < s->nb_planes; i++) {
160  td.fp = fp[i];
161  td.dst = out->data[i];
162  td.src = in->data[i];
163  td.width = plane_w[i];
164  td.height = plane_h[i];
165  td.dst_stride = out->linesize[i];
166  td.src_stride = in->linesize[i];
167  ff_filter_execute(ctx, s->unsharp_slice, &td, NULL,
168  FFMIN(plane_h[i], s->nb_threads));
169  }
170  return 0;
171 }
172 
173 #define MAX_SCALEBITS 25
174 
175 static int set_filter_param(AVFilterContext *ctx, const char *name, const char *short_name,
176  UnsharpFilterParam *fp, int msize_x, int msize_y, float amount)
177 {
178  fp->msize_x = msize_x;
179  fp->msize_y = msize_y;
180  fp->amount = amount * 65536.0;
181 
182  fp->steps_x = msize_x / 2;
183  fp->steps_y = msize_y / 2;
184  fp->scalebits = (fp->steps_x + fp->steps_y) * 2;
185  fp->halfscale = 1 << (fp->scalebits - 1);
186 
187  if (fp->scalebits > MAX_SCALEBITS) {
188  av_log(ctx, AV_LOG_ERROR, "%s matrix size (%sx/2+%sy/2)*2=%d greater than maximum value %d\n",
189  name, short_name, short_name, fp->scalebits, MAX_SCALEBITS);
190  return AVERROR(EINVAL);
191  }
192 
193  return 0;
194 }
195 
197 {
198  UnsharpContext *s = ctx->priv;
199  int ret;
200 
201 #define SET_FILTER_PARAM(name_, short_) \
202  ret = set_filter_param(ctx, #name_, #short_, &s->name_, \
203  s->short_##msize_x, s->short_##msize_y, s->short_##amount); \
204  if (ret < 0) \
205  return ret; \
206 
207  SET_FILTER_PARAM(luma, l);
210 
211  s->apply_unsharp = apply_unsharp_c;
212  return 0;
213 }
214 
215 static const enum AVPixelFormat pix_fmts[] = {
227 };
228 
229 static int init_filter_param(AVFilterContext *ctx, UnsharpFilterParam *fp, const char *effect_type, int width)
230 {
231  int z;
232  UnsharpContext *s = ctx->priv;
233  const char *effect = fp->amount == 0 ? "none" : fp->amount < 0 ? "blur" : "sharpen";
234 
235  if (!(fp->msize_x & fp->msize_y & 1)) {
237  "Invalid even size for %s matrix size %dx%d\n",
238  effect_type, fp->msize_x, fp->msize_y);
239  return AVERROR(EINVAL);
240  }
241 
242  av_log(ctx, AV_LOG_VERBOSE, "effect:%s type:%s msize_x:%d msize_y:%d amount:%0.2f\n",
243  effect, effect_type, fp->msize_x, fp->msize_y, fp->amount / 65535.0);
244 
245  fp->sr = av_malloc_array((MAX_MATRIX_SIZE - 1) * s->nb_threads, sizeof(uint32_t));
246  fp->sc = av_calloc(fp->steps_y * s->nb_threads, 2 * sizeof(*fp->sc));
247  if (!fp->sr || !fp->sc)
248  return AVERROR(ENOMEM);
249 
250  for (z = 0; z < 2 * fp->steps_y * s->nb_threads; z++)
251  if (!(fp->sc[z] = av_malloc_array(width + 2 * fp->steps_x,
252  sizeof(*(fp->sc[z])))))
253  return AVERROR(ENOMEM);
254 
255  return 0;
256 }
257 
259 {
260  UnsharpContext *s = inlink->dst->priv;
262  int ret;
263 
264  s->nb_planes = desc->nb_components;
265  s->hsub = desc->log2_chroma_w;
266  s->vsub = desc->log2_chroma_h;
267  s->bitdepth = desc->comp[0].depth;
268  s->bps = s->bitdepth > 8 ? 2 : 1;
269  s->unsharp_slice = s->bitdepth > 8 ? unsharp_slice_16 : unsharp_slice_8;
270 
271  // ensure (height / nb_threads) > 4 * steps_y,
272  // so that we don't have too much overlap between two threads
273  s->nb_threads = FFMIN(ff_filter_get_nb_threads(inlink->dst),
274  inlink->h / (4 * s->luma.steps_y));
275 
276  ret = init_filter_param(inlink->dst, &s->luma, "luma", inlink->w);
277  if (ret < 0)
278  return ret;
279  ret = init_filter_param(inlink->dst, &s->chroma, "chroma", AV_CEIL_RSHIFT(inlink->w, s->hsub));
280  if (ret < 0)
281  return ret;
282 
283  return 0;
284 }
285 
286 static void free_filter_param(UnsharpFilterParam *fp, int nb_threads)
287 {
288  int z;
289 
290  if (fp->sc) {
291  for (z = 0; z < 2 * fp->steps_y * nb_threads; z++)
292  av_freep(&fp->sc[z]);
293  av_freep(&fp->sc);
294  }
295  av_freep(&fp->sr);
296 }
297 
299 {
300  UnsharpContext *s = ctx->priv;
301 
302  free_filter_param(&s->luma, s->nb_threads);
303  free_filter_param(&s->chroma, s->nb_threads);
304 }
305 
307 {
308  UnsharpContext *s = link->dst->priv;
309  AVFilterLink *outlink = link->dst->outputs[0];
310  AVFrame *out;
311  int ret = 0;
312 
313  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
314  if (!out) {
315  av_frame_free(&in);
316  return AVERROR(ENOMEM);
317  }
319 
320  ret = s->apply_unsharp(link->dst, in, out);
321 
322  av_frame_free(&in);
323 
324  if (ret < 0) {
325  av_frame_free(&out);
326  return ret;
327  }
328  return ff_filter_frame(outlink, out);
329 }
330 
331 #define OFFSET(x) offsetof(UnsharpContext, x)
332 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
333 #define MIN_SIZE 3
334 #define MAX_SIZE 23
335 static const AVOption unsharp_options[] = {
336  { "luma_msize_x", "set luma matrix horizontal size", OFFSET(lmsize_x), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
337  { "lx", "set luma matrix horizontal size", OFFSET(lmsize_x), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
338  { "luma_msize_y", "set luma matrix vertical size", OFFSET(lmsize_y), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
339  { "ly", "set luma matrix vertical size", OFFSET(lmsize_y), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
340  { "luma_amount", "set luma effect strength", OFFSET(lamount), AV_OPT_TYPE_FLOAT, { .dbl = 1 }, -2, 5, FLAGS },
341  { "la", "set luma effect strength", OFFSET(lamount), AV_OPT_TYPE_FLOAT, { .dbl = 1 }, -2, 5, FLAGS },
342  { "chroma_msize_x", "set chroma matrix horizontal size", OFFSET(cmsize_x), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
343  { "cx", "set chroma matrix horizontal size", OFFSET(cmsize_x), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
344  { "chroma_msize_y", "set chroma matrix vertical size", OFFSET(cmsize_y), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
345  { "cy", "set chroma matrix vertical size", OFFSET(cmsize_y), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
346  { "chroma_amount", "set chroma effect strength", OFFSET(camount), AV_OPT_TYPE_FLOAT, { .dbl = 0 }, -2, 5, FLAGS },
347  { "ca", "set chroma effect strength", OFFSET(camount), AV_OPT_TYPE_FLOAT, { .dbl = 0 }, -2, 5, FLAGS },
348  { "alpha_msize_x", "set alpha matrix horizontal size", OFFSET(amsize_x), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
349  { "ax", "set alpha matrix horizontal size", OFFSET(amsize_x), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
350  { "alpha_msize_y", "set alpha matrix vertical size", OFFSET(amsize_y), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
351  { "ay", "set alpha matrix vertical size", OFFSET(amsize_y), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
352  { "alpha_amount", "set alpha effect strength", OFFSET(aamount), AV_OPT_TYPE_FLOAT, { .dbl = 0 }, -2, 5, FLAGS },
353  { "aa", "set alpha effect strength", OFFSET(aamount), AV_OPT_TYPE_FLOAT, { .dbl = 0 }, -2, 5, FLAGS },
354  { NULL }
355 };
356 
357 AVFILTER_DEFINE_CLASS(unsharp);
358 
360  {
361  .name = "default",
362  .type = AVMEDIA_TYPE_VIDEO,
363  .filter_frame = filter_frame,
364  .config_props = config_input,
365  },
366 };
367 
369  .name = "unsharp",
370  .description = NULL_IF_CONFIG_SMALL("Sharpen or blur the input video."),
371  .priv_size = sizeof(UnsharpContext),
372  .priv_class = &unsharp_class,
373  .init = init,
374  .uninit = uninit,
379 };
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:112
AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:526
td
#define td
Definition: regdef.h:70
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
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
out
FILE * out
Definition: movenc.c:54
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1007
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2968
FILTER_PIXFMTS_ARRAY
#define FILTER_PIXFMTS_ARRAY(array)
Definition: internal.h:162
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:173
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:100
AV_PIX_FMT_YUVA422P9
#define AV_PIX_FMT_YUVA422P9
Definition: pixfmt.h:518
ff_vf_unsharp
const AVFilter ff_vf_unsharp
Definition: vf_unsharp.c:368
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
pixdesc.h
AV_PIX_FMT_YUVA420P16
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:525
AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:520
AVOption
AVOption.
Definition: opt.h:294
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:482
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
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:170
apply_unsharp_c
static int apply_unsharp_c(AVFilterContext *ctx, AVFrame *in, AVFrame *out)
Definition: vf_unsharp.c:144
video.h
AV_PIX_FMT_YUVA422P10
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:521
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_unsharp.c:298
MIN_SIZE
#define MIN_SIZE
Definition: vf_unsharp.c:333
filter_frame
static int filter_frame(AVFilterLink *link, AVFrame *in)
Definition: vf_unsharp.c:306
AV_PIX_FMT_YUVA420P9
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:517
config_input
static int config_input(AVFilterLink *inlink)
Definition: vf_unsharp.c:258
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:527
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:480
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:175
init
static av_cold int init(AVFilterContext *ctx)
Definition: vf_unsharp.c:196
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:33
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:485
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:494
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
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
width
#define width
TheadData::width
int width
Definition: vf_unsharp.c:55
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
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:495
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
UnsharpFilterParam
Definition: unsharp.h:32
AV_PIX_FMT_YUVA444P12
#define AV_PIX_FMT_YUVA444P12
Definition: pixfmt.h:524
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:479
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:493
ctx
AVFormatContext * ctx
Definition: movenc.c:48
MAX_SIZE
#define MAX_SIZE
Definition: vf_unsharp.c:334
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_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:182
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
UnsharpContext
Definition: unsharp.h:44
free_filter_param
static void free_filter_param(UnsharpFilterParam *fp, int nb_threads)
Definition: vf_unsharp.c:286
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:736
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
AV_PIX_FMT_YUV440P10
#define AV_PIX_FMT_YUV440P10
Definition: pixfmt.h:484
OFFSET
#define OFFSET(x)
Definition: vf_unsharp.c:331
SET_FILTER_PARAM
#define SET_FILTER_PARAM(name_, short_)
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:483
init_filter_param
static int init_filter_param(AVFilterContext *ctx, UnsharpFilterParam *fp, const char *effect_type, int width)
Definition: vf_unsharp.c:229
fp
#define fp
Definition: regdef.h:44
TheadData::dst_stride
int dst_stride
Definition: vf_unsharp.c:53
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:56
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:106
DEF_UNSHARP_SLICE_FUNC
#define DEF_UNSHARP_SLICE_FUNC(name, nbits)
Definition: vf_unsharp.c:59
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:487
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:489
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:335
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:522
TheadData
Definition: vf_unsharp.c:49
internal.h
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:147
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Definition: opt.h:228
TheadData::fp
UnsharpFilterParam * fp
Definition: vf_unsharp.c:50
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
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:814
ThreadData
Used for passing data between threads.
Definition: dsddec.c:69
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: vf_unsharp.c:215
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:332
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:39
TheadData::dst
uint8_t * dst
Definition: vf_unsharp.c:51
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:262
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:481
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(unsharp)
AVFilter
Filter definition.
Definition: avfilter.h:166
ret
ret
Definition: filter_design.txt:187
AV_PIX_FMT_YUVA444P9
#define AV_PIX_FMT_YUVA444P9
Definition: pixfmt.h:519
unsharp.h
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:486
avfilter_vf_unsharp_inputs
static const AVFilterPad avfilter_vf_unsharp_inputs[]
Definition: vf_unsharp.c:359
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_PIX_FMT_YUVA422P12
#define AV_PIX_FMT_YUVA422P12
Definition: pixfmt.h:523
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
avfilter.h
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:409
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:117
desc
const char * desc
Definition: libsvtav1.c:83
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
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
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:183
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
TheadData::src_stride
int src_stride
Definition: vf_unsharp.c:54
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
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:488
MAX_MATRIX_SIZE
#define MAX_MATRIX_SIZE
Definition: unsharp.h:29
ff_filter_execute
static av_always_inline int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
Definition: internal.h:134
TheadData::src
const uint8_t * src
Definition: vf_unsharp.c:52
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