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 "formats.h"
41 #include "internal.h"
42 #include "video.h"
43 #include "libavutil/common.h"
44 #include "libavutil/imgutils.h"
45 #include "libavutil/mem.h"
46 #include "libavutil/opt.h"
47 #include "libavutil/pixdesc.h"
48 #include "unsharp.h"
49 
50 typedef struct TheadData {
52  uint8_t *dst;
53  const uint8_t *src;
56  int width;
57  int height;
58 } ThreadData;
59 
60 #define DEF_UNSHARP_SLICE_FUNC(name, nbits) \
61 static int name##_##nbits(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs) \
62 { \
63  ThreadData *td = arg; \
64  UnsharpFilterParam *fp = td->fp; \
65  UnsharpContext *s = ctx->priv; \
66  uint32_t **sc = fp->sc; \
67  uint32_t *sr = fp->sr; \
68  const uint##nbits##_t *src2 = NULL; \
69  const int amount = fp->amount; \
70  const int steps_x = fp->steps_x; \
71  const int steps_y = fp->steps_y; \
72  const int scalebits = fp->scalebits; \
73  const int32_t halfscale = fp->halfscale; \
74  \
75  uint##nbits##_t *dst = (uint##nbits##_t*)td->dst; \
76  const uint##nbits##_t *src = (const uint##nbits##_t *)td->src; \
77  int dst_stride = td->dst_stride; \
78  int src_stride = td->src_stride; \
79  const int width = td->width; \
80  const int height = td->height; \
81  const int sc_offset = jobnr * 2 * steps_y; \
82  const int sr_offset = jobnr * (MAX_MATRIX_SIZE - 1); \
83  const int slice_start = (height * jobnr) / nb_jobs; \
84  const int slice_end = (height * (jobnr+1)) / nb_jobs; \
85  \
86  int32_t res; \
87  int x, y, z; \
88  uint32_t tmp1, tmp2; \
89  \
90  if (!amount) { \
91  av_image_copy_plane(td->dst + slice_start * dst_stride, dst_stride, \
92  td->src + slice_start * src_stride, src_stride, \
93  width * s->bps, slice_end - slice_start); \
94  return 0; \
95  } \
96  \
97  for (y = 0; y < 2 * steps_y; y++) \
98  memset(sc[sc_offset + y], 0, sizeof(sc[y][0]) * (width + 2 * steps_x)); \
99  \
100  dst_stride = dst_stride / s->bps; \
101  src_stride = src_stride / s->bps; \
102  /* if this is not the first tile, we start from (slice_start - steps_y) */ \
103  /* so we can get smooth result at slice boundary */ \
104  if (slice_start > steps_y) { \
105  src += (slice_start - steps_y) * src_stride; \
106  dst += (slice_start - steps_y) * dst_stride; \
107  } \
108  \
109  for (y = -steps_y + slice_start; y < steps_y + slice_end; y++) { \
110  if (y < height) \
111  src2 = src; \
112  \
113  memset(sr + sr_offset, 0, sizeof(sr[0]) * (2 * steps_x - 1)); \
114  for (x = -steps_x; x < width + steps_x; x++) { \
115  tmp1 = x <= 0 ? src2[0] : x >= width ? src2[width-1] : src2[x]; \
116  for (z = 0; z < steps_x * 2; z += 2) { \
117  tmp2 = sr[sr_offset + z + 0] + tmp1; sr[sr_offset + z + 0] = tmp1; \
118  tmp1 = sr[sr_offset + z + 1] + tmp2; sr[sr_offset + z + 1] = tmp2; \
119  } \
120  for (z = 0; z < steps_y * 2; z += 2) { \
121  tmp2 = sc[sc_offset + z + 0][x + steps_x] + tmp1; \
122  sc[sc_offset + z + 0][x + steps_x] = tmp1; \
123  tmp1 = sc[sc_offset + z + 1][x + steps_x] + tmp2; \
124  sc[sc_offset + z + 1][x + steps_x] = tmp2; \
125  } \
126  if (x >= steps_x && y >= (steps_y + slice_start)) { \
127  const uint##nbits##_t *srx = src - steps_y * src_stride + x - steps_x; \
128  uint##nbits##_t *dsx = dst - steps_y * dst_stride + x - steps_x; \
129  \
130  res = (int32_t)*srx + ((((int32_t) * srx - \
131  (int32_t)((tmp1 + halfscale) >> scalebits)) * amount) >> (8+nbits)); \
132  *dsx = av_clip_uint##nbits(res); \
133  } \
134  } \
135  if (y >= 0) { \
136  dst += dst_stride; \
137  src += src_stride; \
138  } \
139  } \
140  return 0; \
141 }
142 DEF_UNSHARP_SLICE_FUNC(unsharp_slice, 16)
143 DEF_UNSHARP_SLICE_FUNC(unsharp_slice, 8)
144 
146 {
147  AVFilterLink *inlink = ctx->inputs[0];
148  UnsharpContext *s = ctx->priv;
149  int i, plane_w[3], plane_h[3];
151  ThreadData td;
152 
153  plane_w[0] = inlink->w;
154  plane_w[1] = plane_w[2] = AV_CEIL_RSHIFT(inlink->w, s->hsub);
155  plane_h[0] = inlink->h;
156  plane_h[1] = plane_h[2] = AV_CEIL_RSHIFT(inlink->h, s->vsub);
157  fp[0] = &s->luma;
158  fp[1] = fp[2] = &s->chroma;
159  for (i = 0; i < 3; 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 static void set_filter_param(UnsharpFilterParam *fp, int msize_x, int msize_y, float amount)
174 {
175  fp->msize_x = msize_x;
176  fp->msize_y = msize_y;
177  fp->amount = amount * 65536.0;
178 
179  fp->steps_x = msize_x / 2;
180  fp->steps_y = msize_y / 2;
181  fp->scalebits = (fp->steps_x + fp->steps_y) * 2;
182  fp->halfscale = 1 << (fp->scalebits - 1);
183 }
184 
186 {
187  UnsharpContext *s = ctx->priv;
188 
189  set_filter_param(&s->luma, s->lmsize_x, s->lmsize_y, s->lamount);
190  set_filter_param(&s->chroma, s->cmsize_x, s->cmsize_y, s->camount);
191 
192  if (s->luma.scalebits >= 26 || s->chroma.scalebits >= 26) {
193  av_log(ctx, AV_LOG_ERROR, "luma or chroma matrix size too big\n");
194  return AVERROR(EINVAL);
195  }
196  s->apply_unsharp = apply_unsharp_c;
197  return 0;
198 }
199 
201 {
202  static const enum AVPixelFormat pix_fmts[] = {
210  };
211 
213 }
214 
215 static int init_filter_param(AVFilterContext *ctx, UnsharpFilterParam *fp, const char *effect_type, int width)
216 {
217  int z;
218  UnsharpContext *s = ctx->priv;
219  const char *effect = fp->amount == 0 ? "none" : fp->amount < 0 ? "blur" : "sharpen";
220 
221  if (!(fp->msize_x & fp->msize_y & 1)) {
223  "Invalid even size for %s matrix size %dx%d\n",
224  effect_type, fp->msize_x, fp->msize_y);
225  return AVERROR(EINVAL);
226  }
227 
228  av_log(ctx, AV_LOG_VERBOSE, "effect:%s type:%s msize_x:%d msize_y:%d amount:%0.2f\n",
229  effect, effect_type, fp->msize_x, fp->msize_y, fp->amount / 65535.0);
230 
231  fp->sr = av_malloc_array((MAX_MATRIX_SIZE - 1) * s->nb_threads, sizeof(uint32_t));
232  fp->sc = av_mallocz_array(2 * fp->steps_y * s->nb_threads, sizeof(uint32_t *));
233  if (!fp->sr || !fp->sc)
234  return AVERROR(ENOMEM);
235 
236  for (z = 0; z < 2 * fp->steps_y * s->nb_threads; z++)
237  if (!(fp->sc[z] = av_malloc_array(width + 2 * fp->steps_x,
238  sizeof(*(fp->sc[z])))))
239  return AVERROR(ENOMEM);
240 
241  return 0;
242 }
243 
245 {
246  UnsharpContext *s = inlink->dst->priv;
248  int ret;
249 
250  s->hsub = desc->log2_chroma_w;
251  s->vsub = desc->log2_chroma_h;
252  s->bitdepth = desc->comp[0].depth;
253  s->bps = s->bitdepth > 8 ? 2 : 1;
254  s->unsharp_slice = s->bitdepth > 8 ? unsharp_slice_16 : unsharp_slice_8;
255 
256  // ensure (height / nb_threads) > 4 * steps_y,
257  // so that we don't have too much overlap between two threads
258  s->nb_threads = FFMIN(ff_filter_get_nb_threads(inlink->dst),
259  inlink->h / (4 * s->luma.steps_y));
260 
261  ret = init_filter_param(inlink->dst, &s->luma, "luma", inlink->w);
262  if (ret < 0)
263  return ret;
264  ret = init_filter_param(inlink->dst, &s->chroma, "chroma", AV_CEIL_RSHIFT(inlink->w, s->hsub));
265  if (ret < 0)
266  return ret;
267 
268  return 0;
269 }
270 
271 static void free_filter_param(UnsharpFilterParam *fp, int nb_threads)
272 {
273  int z;
274 
275  if (fp->sc) {
276  for (z = 0; z < 2 * fp->steps_y * nb_threads; z++)
277  av_freep(&fp->sc[z]);
278  av_freep(&fp->sc);
279  }
280  av_freep(&fp->sr);
281 }
282 
284 {
285  UnsharpContext *s = ctx->priv;
286 
287  free_filter_param(&s->luma, s->nb_threads);
288  free_filter_param(&s->chroma, s->nb_threads);
289 }
290 
292 {
293  UnsharpContext *s = link->dst->priv;
294  AVFilterLink *outlink = link->dst->outputs[0];
295  AVFrame *out;
296  int ret = 0;
297 
298  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
299  if (!out) {
300  av_frame_free(&in);
301  return AVERROR(ENOMEM);
302  }
304 
305  ret = s->apply_unsharp(link->dst, in, out);
306 
307  av_frame_free(&in);
308 
309  if (ret < 0) {
310  av_frame_free(&out);
311  return ret;
312  }
313  return ff_filter_frame(outlink, out);
314 }
315 
316 #define OFFSET(x) offsetof(UnsharpContext, x)
317 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
318 #define MIN_SIZE 3
319 #define MAX_SIZE 23
320 static const AVOption unsharp_options[] = {
321  { "luma_msize_x", "set luma matrix horizontal size", OFFSET(lmsize_x), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
322  { "lx", "set luma matrix horizontal size", OFFSET(lmsize_x), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
323  { "luma_msize_y", "set luma matrix vertical size", OFFSET(lmsize_y), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
324  { "ly", "set luma matrix vertical size", OFFSET(lmsize_y), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
325  { "luma_amount", "set luma effect strength", OFFSET(lamount), AV_OPT_TYPE_FLOAT, { .dbl = 1 }, -2, 5, FLAGS },
326  { "la", "set luma effect strength", OFFSET(lamount), AV_OPT_TYPE_FLOAT, { .dbl = 1 }, -2, 5, FLAGS },
327  { "chroma_msize_x", "set chroma matrix horizontal size", OFFSET(cmsize_x), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
328  { "cx", "set chroma matrix horizontal size", OFFSET(cmsize_x), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
329  { "chroma_msize_y", "set chroma matrix vertical size", OFFSET(cmsize_y), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
330  { "cy", "set chroma matrix vertical size", OFFSET(cmsize_y), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
331  { "chroma_amount", "set chroma effect strength", OFFSET(camount), AV_OPT_TYPE_FLOAT, { .dbl = 0 }, -2, 5, FLAGS },
332  { "ca", "set chroma effect strength", OFFSET(camount), AV_OPT_TYPE_FLOAT, { .dbl = 0 }, -2, 5, FLAGS },
333  { "opencl", "ignored", OFFSET(opencl), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
334  { NULL }
335 };
336 
337 AVFILTER_DEFINE_CLASS(unsharp);
338 
340  {
341  .name = "default",
342  .type = AVMEDIA_TYPE_VIDEO,
343  .filter_frame = filter_frame,
344  .config_props = config_input,
345  },
346 };
347 
349  {
350  .name = "default",
351  .type = AVMEDIA_TYPE_VIDEO,
352  },
353 };
354 
356  .name = "unsharp",
357  .description = NULL_IF_CONFIG_SMALL("Sharpen or blur the input video."),
358  .priv_size = sizeof(UnsharpContext),
359  .priv_class = &unsharp_class,
360  .init = init,
361  .uninit = uninit,
366 };
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:98
td
#define td
Definition: regdef.h:70
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
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:1017
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2540
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
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:112
ff_vf_unsharp
const AVFilter ff_vf_unsharp
Definition: vf_unsharp.c:355
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
pixdesc.h
AVOption
AVOption.
Definition: opt.h:247
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:389
av_mallocz_array
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:214
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:99
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:153
apply_unsharp_c
static int apply_unsharp_c(AVFilterContext *ctx, AVFrame *in, AVFrame *out)
Definition: vf_unsharp.c:145
video.h
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_unsharp.c:283
MIN_SIZE
#define MIN_SIZE
Definition: vf_unsharp.c:318
filter_frame
static int filter_frame(AVFilterLink *link, AVFrame *in)
Definition: vf_unsharp.c:291
formats.h
config_input
static int config_input(AVFilterLink *inlink)
Definition: vf_unsharp.c:244
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:387
init
static av_cold int init(AVFilterContext *ctx)
Definition: vf_unsharp.c:185
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:50
set_filter_param
static void set_filter_param(UnsharpFilterParam *fp, int msize_x, int msize_y, float amount)
Definition: vf_unsharp.c:173
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:392
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:401
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:79
width
#define width
TheadData::width
int width
Definition: vf_unsharp.c:56
s
#define s(width, name)
Definition: cbs_vp9.c:257
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:402
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:51
UnsharpFilterParam
Definition: unsharp.h:32
ff_set_common_formats_from_list
int ff_set_common_formats_from_list(AVFilterContext *ctx, const int *fmts)
Equivalent to ff_set_common_formats(ctx, ff_make_format_list(fmts))
Definition: formats.c:703
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:290
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:386
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:400
ctx
AVFormatContext * ctx
Definition: movenc.c:48
MAX_SIZE
#define MAX_SIZE
Definition: vf_unsharp.c:319
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:66
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:152
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:80
UnsharpContext
Definition: unsharp.h:44
free_filter_param
static void free_filter_param(UnsharpFilterParam *fp, int nb_threads)
Definition: vf_unsharp.c:271
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:537
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:78
AV_PIX_FMT_YUV440P10
#define AV_PIX_FMT_YUV440P10
Definition: pixfmt.h:391
OFFSET
#define OFFSET(x)
Definition: vf_unsharp.c:316
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:390
init_filter_param
static int init_filter_param(AVFilterContext *ctx, UnsharpFilterParam *fp, const char *effect_type, int width)
Definition: vf_unsharp.c:215
fp
#define fp
Definition: regdef.h:44
TheadData::dst_stride
int dst_stride
Definition: vf_unsharp.c:54
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: vf_unsharp.c:200
TheadData::height
int height
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:117
DEF_UNSHARP_SLICE_FUNC
#define DEF_UNSHARP_SLICE_FUNC(name, nbits)
Definition: vf_unsharp.c:60
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:394
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:396
unsharp_options
static const AVOption unsharp_options[]
Definition: vf_unsharp.c:320
TheadData
Definition: vf_unsharp.c:50
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:130
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Definition: opt.h:227
TheadData::fp
UnsharpFilterParam * fp
Definition: vf_unsharp.c:51
i
int i
Definition: input.c:406
avfilter_vf_unsharp_outputs
static const AVFilterPad avfilter_vf_unsharp_outputs[]
Definition: vf_unsharp.c:348
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:804
ThreadData
Used for passing data between threads.
Definition: dsddec.c:67
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:100
FLAGS
#define FLAGS
Definition: vf_unsharp.c:317
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:56
TheadData::dst
uint8_t * dst
Definition: vf_unsharp.c:52
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:388
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(unsharp)
AVFilter
Filter definition.
Definition: avfilter.h:149
ret
ret
Definition: filter_design.txt:187
unsharp.h
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:393
avfilter_vf_unsharp_inputs
static const AVFilterPad avfilter_vf_unsharp_inputs[]
Definition: vf_unsharp.c:339
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
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:71
AVFilterContext
An instance of a filter.
Definition: avfilter.h:346
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:121
desc
const char * desc
Definition: libsvtav1.c:79
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:70
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
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:241
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:153
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
TheadData::src_stride
int src_stride
Definition: vf_unsharp.c:55
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:73
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:72
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AV_PIX_FMT_YUV440P12
#define AV_PIX_FMT_YUV440P12
Definition: pixfmt.h:395
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:143
TheadData::src
const uint8_t * src
Definition: vf_unsharp.c:53