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 {
51  UnsharpFilterParam *fp;
52  uint8_t *dst;
53  const uint8_t *src;
54  int dst_stride;
55  int src_stride;
56  int width;
57  int height;
58 } ThreadData;
59 
60 static int unsharp_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
61 {
62  ThreadData *td = arg;
63  UnsharpFilterParam *fp = td->fp;
64  uint32_t **sc = fp->sc;
65  uint32_t *sr = fp->sr;
66  const uint8_t *src2 = NULL; //silence a warning
67  const int amount = fp->amount;
68  const int steps_x = fp->steps_x;
69  const int steps_y = fp->steps_y;
70  const int scalebits = fp->scalebits;
71  const int32_t halfscale = fp->halfscale;
72 
73  uint8_t *dst = td->dst;
74  const uint8_t *src = td->src;
75  const int dst_stride = td->dst_stride;
76  const int src_stride = td->src_stride;
77  const int width = td->width;
78  const int height = td->height;
79  const int sc_offset = jobnr * 2 * steps_y;
80  const int sr_offset = jobnr * (MAX_MATRIX_SIZE - 1);
81  const int slice_start = (height * jobnr) / nb_jobs;
82  const int slice_end = (height * (jobnr+1)) / nb_jobs;
83 
84  int32_t res;
85  int x, y, z;
86  uint32_t tmp1, tmp2;
87 
88  if (!amount) {
89  av_image_copy_plane(dst + slice_start * dst_stride, dst_stride,
90  src + slice_start * src_stride, src_stride,
91  width, slice_end - slice_start);
92  return 0;
93  }
94 
95  for (y = 0; y < 2 * steps_y; y++)
96  memset(sc[sc_offset + y], 0, sizeof(sc[y][0]) * (width + 2 * steps_x));
97 
98  // if this is not the first tile, we start from (slice_start - steps_y),
99  // so we can get smooth result at slice boundary
100  if (slice_start > steps_y) {
101  src += (slice_start - steps_y) * src_stride;
102  dst += (slice_start - steps_y) * dst_stride;
103  }
104 
105  for (y = -steps_y + slice_start; y < steps_y + slice_end; y++) {
106  if (y < height)
107  src2 = src;
108 
109  memset(sr + sr_offset, 0, sizeof(sr[0]) * (2 * steps_x - 1));
110  for (x = -steps_x; x < width + steps_x; x++) {
111  tmp1 = x <= 0 ? src2[0] : x >= width ? src2[width-1] : src2[x];
112  for (z = 0; z < steps_x * 2; z += 2) {
113  tmp2 = sr[sr_offset + z + 0] + tmp1; sr[sr_offset + z + 0] = tmp1;
114  tmp1 = sr[sr_offset + z + 1] + tmp2; sr[sr_offset + z + 1] = tmp2;
115  }
116  for (z = 0; z < steps_y * 2; z += 2) {
117  tmp2 = sc[sc_offset + z + 0][x + steps_x] + tmp1; sc[sc_offset + z + 0][x + steps_x] = tmp1;
118  tmp1 = sc[sc_offset + z + 1][x + steps_x] + tmp2; sc[sc_offset + z + 1][x + steps_x] = tmp2;
119  }
120  if (x >= steps_x && y >= (steps_y + slice_start)) {
121  const uint8_t *srx = src - steps_y * src_stride + x - steps_x;
122  uint8_t *dsx = dst - steps_y * dst_stride + x - steps_x;
123 
124  res = (int32_t)*srx + ((((int32_t) * srx - (int32_t)((tmp1 + halfscale) >> scalebits)) * amount) >> 16);
125  *dsx = av_clip_uint8(res);
126  }
127  }
128  if (y >= 0) {
129  dst += dst_stride;
130  src += src_stride;
131  }
132  }
133  return 0;
134 }
135 
136 static int apply_unsharp_c(AVFilterContext *ctx, AVFrame *in, AVFrame *out)
137 {
138  AVFilterLink *inlink = ctx->inputs[0];
139  UnsharpContext *s = ctx->priv;
140  int i, plane_w[3], plane_h[3];
141  UnsharpFilterParam *fp[3];
142  ThreadData td;
143 
144  plane_w[0] = inlink->w;
145  plane_w[1] = plane_w[2] = AV_CEIL_RSHIFT(inlink->w, s->hsub);
146  plane_h[0] = inlink->h;
147  plane_h[1] = plane_h[2] = AV_CEIL_RSHIFT(inlink->h, s->vsub);
148  fp[0] = &s->luma;
149  fp[1] = fp[2] = &s->chroma;
150  for (i = 0; i < 3; i++) {
151  td.fp = fp[i];
152  td.dst = out->data[i];
153  td.src = in->data[i];
154  td.width = plane_w[i];
155  td.height = plane_h[i];
156  td.dst_stride = out->linesize[i];
157  td.src_stride = in->linesize[i];
158  ctx->internal->execute(ctx, unsharp_slice, &td, NULL, FFMIN(plane_h[i], s->nb_threads));
159  }
160  return 0;
161 }
162 
163 static void set_filter_param(UnsharpFilterParam *fp, int msize_x, int msize_y, float amount)
164 {
165  fp->msize_x = msize_x;
166  fp->msize_y = msize_y;
167  fp->amount = amount * 65536.0;
168 
169  fp->steps_x = msize_x / 2;
170  fp->steps_y = msize_y / 2;
171  fp->scalebits = (fp->steps_x + fp->steps_y) * 2;
172  fp->halfscale = 1 << (fp->scalebits - 1);
173 }
174 
175 static av_cold int init(AVFilterContext *ctx)
176 {
177  UnsharpContext *s = ctx->priv;
178 
179  set_filter_param(&s->luma, s->lmsize_x, s->lmsize_y, s->lamount);
180  set_filter_param(&s->chroma, s->cmsize_x, s->cmsize_y, s->camount);
181 
182  if (s->luma.scalebits >= 26 || s->chroma.scalebits >= 26) {
183  av_log(ctx, AV_LOG_ERROR, "luma or chroma matrix size too big\n");
184  return AVERROR(EINVAL);
185  }
186  s->apply_unsharp = apply_unsharp_c;
187  return 0;
188 }
189 
190 static int query_formats(AVFilterContext *ctx)
191 {
192  static const enum AVPixelFormat pix_fmts[] = {
193  AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV410P,
194  AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
195  AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_NONE
196  };
197 
198  AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
199  if (!fmts_list)
200  return AVERROR(ENOMEM);
201  return ff_set_common_formats(ctx, fmts_list);
202 }
203 
204 static int init_filter_param(AVFilterContext *ctx, UnsharpFilterParam *fp, const char *effect_type, int width)
205 {
206  int z;
207  UnsharpContext *s = ctx->priv;
208  const char *effect = fp->amount == 0 ? "none" : fp->amount < 0 ? "blur" : "sharpen";
209 
210  if (!(fp->msize_x & fp->msize_y & 1)) {
211  av_log(ctx, AV_LOG_ERROR,
212  "Invalid even size for %s matrix size %dx%d\n",
213  effect_type, fp->msize_x, fp->msize_y);
214  return AVERROR(EINVAL);
215  }
216 
217  av_log(ctx, AV_LOG_VERBOSE, "effect:%s type:%s msize_x:%d msize_y:%d amount:%0.2f\n",
218  effect, effect_type, fp->msize_x, fp->msize_y, fp->amount / 65535.0);
219 
220  fp->sr = av_malloc_array((MAX_MATRIX_SIZE - 1) * s->nb_threads, sizeof(uint32_t));
221  fp->sc = av_mallocz_array(2 * fp->steps_y * s->nb_threads, sizeof(uint32_t *));
222  if (!fp->sr || !fp->sc)
223  return AVERROR(ENOMEM);
224 
225  for (z = 0; z < 2 * fp->steps_y * s->nb_threads; z++)
226  if (!(fp->sc[z] = av_malloc_array(width + 2 * fp->steps_x,
227  sizeof(*(fp->sc[z])))))
228  return AVERROR(ENOMEM);
229 
230  return 0;
231 }
232 
233 static int config_props(AVFilterLink *link)
234 {
235  UnsharpContext *s = link->dst->priv;
236  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(link->format);
237  int ret;
238 
239  s->hsub = desc->log2_chroma_w;
240  s->vsub = desc->log2_chroma_h;
241 
242  // ensure (height / nb_threads) > 4 * steps_y,
243  // so that we don't have too much overlap between two threads
244  s->nb_threads = FFMIN(ff_filter_get_nb_threads(link->dst),
245  link->h / (4 * s->luma.steps_y));
246 
247  ret = init_filter_param(link->dst, &s->luma, "luma", link->w);
248  if (ret < 0)
249  return ret;
250  ret = init_filter_param(link->dst, &s->chroma, "chroma", AV_CEIL_RSHIFT(link->w, s->hsub));
251  if (ret < 0)
252  return ret;
253 
254  return 0;
255 }
256 
257 static void free_filter_param(UnsharpFilterParam *fp, int nb_threads)
258 {
259  int z;
260 
261  if (fp->sc) {
262  for (z = 0; z < 2 * fp->steps_y * nb_threads; z++)
263  av_freep(&fp->sc[z]);
264  av_freep(&fp->sc);
265  }
266  av_freep(&fp->sr);
267 }
268 
269 static av_cold void uninit(AVFilterContext *ctx)
270 {
271  UnsharpContext *s = ctx->priv;
272 
273  free_filter_param(&s->luma, s->nb_threads);
274  free_filter_param(&s->chroma, s->nb_threads);
275 }
276 
277 static int filter_frame(AVFilterLink *link, AVFrame *in)
278 {
279  UnsharpContext *s = link->dst->priv;
280  AVFilterLink *outlink = link->dst->outputs[0];
281  AVFrame *out;
282  int ret = 0;
283 
284  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
285  if (!out) {
286  av_frame_free(&in);
287  return AVERROR(ENOMEM);
288  }
289  av_frame_copy_props(out, in);
290 
291  ret = s->apply_unsharp(link->dst, in, out);
292 
293  av_frame_free(&in);
294 
295  if (ret < 0) {
296  av_frame_free(&out);
297  return ret;
298  }
299  return ff_filter_frame(outlink, out);
300 }
301 
302 #define OFFSET(x) offsetof(UnsharpContext, x)
303 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
304 #define MIN_SIZE 3
305 #define MAX_SIZE 23
306 static const AVOption unsharp_options[] = {
307  { "luma_msize_x", "set luma matrix horizontal size", OFFSET(lmsize_x), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
308  { "lx", "set luma matrix horizontal size", OFFSET(lmsize_x), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
309  { "luma_msize_y", "set luma matrix vertical size", OFFSET(lmsize_y), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
310  { "ly", "set luma matrix vertical size", OFFSET(lmsize_y), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
311  { "luma_amount", "set luma effect strength", OFFSET(lamount), AV_OPT_TYPE_FLOAT, { .dbl = 1 }, -2, 5, FLAGS },
312  { "la", "set luma effect strength", OFFSET(lamount), AV_OPT_TYPE_FLOAT, { .dbl = 1 }, -2, 5, FLAGS },
313  { "chroma_msize_x", "set chroma matrix horizontal size", OFFSET(cmsize_x), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
314  { "cx", "set chroma matrix horizontal size", OFFSET(cmsize_x), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
315  { "chroma_msize_y", "set chroma matrix vertical size", OFFSET(cmsize_y), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
316  { "cy", "set chroma matrix vertical size", OFFSET(cmsize_y), AV_OPT_TYPE_INT, { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
317  { "chroma_amount", "set chroma effect strength", OFFSET(camount), AV_OPT_TYPE_FLOAT, { .dbl = 0 }, -2, 5, FLAGS },
318  { "ca", "set chroma effect strength", OFFSET(camount), AV_OPT_TYPE_FLOAT, { .dbl = 0 }, -2, 5, FLAGS },
319  { "opencl", "ignored", OFFSET(opencl), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
320  { NULL }
321 };
322 
323 AVFILTER_DEFINE_CLASS(unsharp);
324 
325 static const AVFilterPad avfilter_vf_unsharp_inputs[] = {
326  {
327  .name = "default",
328  .type = AVMEDIA_TYPE_VIDEO,
329  .filter_frame = filter_frame,
330  .config_props = config_props,
331  },
332  { NULL }
333 };
334 
335 static const AVFilterPad avfilter_vf_unsharp_outputs[] = {
336  {
337  .name = "default",
338  .type = AVMEDIA_TYPE_VIDEO,
339  },
340  { NULL }
341 };
342 
343 AVFilter ff_vf_unsharp = {
344  .name = "unsharp",
345  .description = NULL_IF_CONFIG_SMALL("Sharpen or blur the input video."),
346  .priv_size = sizeof(UnsharpContext),
347  .priv_class = &unsharp_class,
348  .init = init,
349  .uninit = uninit,
350  .query_formats = query_formats,
351  .inputs = avfilter_vf_unsharp_inputs,
352  .outputs = avfilter_vf_unsharp_outputs,
353  .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
354 };
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:99
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
ff_make_format_list
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:283
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:1080
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2522
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:202
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
pixdesc.h
AVOption
AVOption.
Definition: opt.h:246
av_mallocz_array
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:191
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
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:148
apply_unsharp_c
static int apply_unsharp_c(AVFilterContext *ctx, AVFrame *in, AVFrame *out)
Definition: vf_unsharp.c:136
video.h
AVFormatContext::internal
AVFormatInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1795
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_unsharp.c:269
MIN_SIZE
#define MIN_SIZE
Definition: vf_unsharp.c:304
filter_frame
static int filter_frame(AVFilterLink *link, AVFrame *in)
Definition: vf_unsharp.c:277
av_image_copy_plane
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
AVFilterFormats
A list of supported formats for one end of a filter link.
Definition: formats.h:64
formats.h
src
#define src
Definition: vp8dsp.c:254
init
static av_cold int init(AVFilterContext *ctx)
Definition: vf_unsharp.c:175
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:54
set_filter_param
static void set_filter_param(UnsharpFilterParam *fp, int msize_x, int msize_y, float amount)
Definition: vf_unsharp.c:163
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
av_cold
#define av_cold
Definition: attributes.h:84
ff_set_common_formats
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
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_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
UnsharpFilterParam
Definition: unsharp.h:32
slice_end
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2026
outputs
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
unsharp_slice
static int unsharp_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_unsharp.c:60
ctx
AVFormatContext * ctx
Definition: movenc.c:48
MAX_SIZE
#define MAX_SIZE
Definition: vf_unsharp.c:305
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
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
int32_t
int32_t
Definition: audio_convert.c:194
arg
const char * arg
Definition: jacosubdec.c:66
UnsharpContext
Definition: unsharp.h:44
free_filter_param
static void free_filter_param(UnsharpFilterParam *fp, int nb_threads)
Definition: vf_unsharp.c:257
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:654
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
OFFSET
#define OFFSET(x)
Definition: vf_unsharp.c:302
inputs
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several inputs
Definition: filter_design.txt:243
init_filter_param
static int init_filter_param(AVFilterContext *ctx, UnsharpFilterParam *fp, const char *effect_type, int width)
Definition: vf_unsharp.c:204
fp
#define fp
Definition: regdef.h:44
ff_vf_unsharp
AVFilter ff_vf_unsharp
Definition: vf_unsharp.c:343
TheadData::dst_stride
int dst_stride
Definition: vf_unsharp.c:54
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: vf_unsharp.c:190
TheadData::height
int height
Definition: vf_unsharp.c:57
desc
const char * desc
Definition: nvenc.c:68
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:188
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:368
height
#define height
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
unsharp_options
static const AVOption unsharp_options[]
Definition: vf_unsharp.c:306
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:125
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Definition: opt.h:226
TheadData::fp
UnsharpFilterParam * fp
Definition: vf_unsharp.c:51
in
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method !=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2) { ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc) { av_free(ac);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
Definition: audio_convert.c:326
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
avfilter_vf_unsharp_outputs
static const AVFilterPad avfilter_vf_unsharp_outputs[]
Definition: vf_unsharp.c:335
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:802
ThreadData
Used for passing data between threads.
Definition: af_adeclick.c:487
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
uint8_t
uint8_t
Definition: audio_convert.c:194
FLAGS
#define FLAGS
Definition: vf_unsharp.c:303
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:60
TheadData::dst
uint8_t * dst
Definition: vf_unsharp.c:52
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(unsharp)
config_props
static int config_props(AVFilterLink *link)
Definition: vf_unsharp.c:233
AVFilter
Filter definition.
Definition: avfilter.h:144
ret
ret
Definition: filter_design.txt:187
unsharp.h
avfilter_vf_unsharp_inputs
static const AVFilterPad avfilter_vf_unsharp_inputs[]
Definition: vf_unsharp.c:325
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:223
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:338
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:116
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:81
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:240
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
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:565
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
MAX_MATRIX_SIZE
#define MAX_MATRIX_SIZE
Definition: unsharp.h:29
TheadData::src
const uint8_t * src
Definition: vf_unsharp.c:53
Generated on Wed Aug 24 2022 21:27:17 for FFmpeg by   doxygen 1.8.17