Go to the documentation of this file.
42 static int comp(
const float *
a,
const float *
b)
71 #define OFFSET(x) offsetof(BLRContext, x)
72 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
77 {
"block_pct",
"block pooling threshold when calculating blurriness",
OFFSET(block_pct),
AV_OPT_TYPE_INT, {.i64=80}, 1, 100,
FLAGS },
78 {
"block_width",
"block size for block-based abbreviation of blurriness",
OFFSET(block_width),
AV_OPT_TYPE_INT, {.i64=-1}, -1, INT_MAX,
FLAGS },
79 {
"block_height",
"block size for block-based abbreviation of blurriness",
OFFSET(block_height),
AV_OPT_TYPE_INT, {.i64=-1}, -1, INT_MAX,
FLAGS },
90 s->low_u8 =
s->low * 255. + .5;
91 s->high_u8 =
s->high * 255. + .5;
108 if (
s->block_width < 1 ||
s->block_height < 1) {
115 s->gradients =
av_calloc(bufsize,
sizeof(*
s->gradients));
120 if (!
s->tmpbuf || !
s->filterbuf || !
s->gradients || !
s->directions || !
s->blks)
128 int edge,
const uint8_t *
src,
int src_linesize)
144 default: dX = 1; dY = 1;
break;
148 sign =
src[j * src_linesize +
i] >
src[(j - dY) * src_linesize +
i - dX] ? 1 : -1;
151 for (k = 0; k < radius; k++) {
154 p1 = y * src_linesize + x;
157 p2 = y * src_linesize + x;
158 if (x < 0 || x >=
w || y < 0 || y >=
h)
169 for (k = 0; k < radius; k++) {
172 p1 = y * src_linesize + x;
175 p2 = y * src_linesize + x;
176 if (x < 0 || x >=
w || y < 0 || y >=
h)
194 int8_t* dir,
int dir_linesize,
195 uint8_t*
dst,
int dst_linesize,
196 uint8_t*
src,
int src_linesize)
198 float total_width = 0.0;
200 double block_total_width;
205 float *blks =
s->blks;
206 float block_pool_threshold =
s->block_pct / 100.0;
210 int brows =
h / block_height;
211 int bcols =
w / block_width;
213 for (
int blkj = 0; blkj < brows; blkj++) {
214 for (
int blki = 0; blki < bcols; blki++) {
215 block_total_width = 0.0;
217 for (
int inj = 0; inj < block_height; inj++) {
218 for (
int ini = 0; ini < block_width; ini++) {
219 i = blki * block_width + ini;
220 j = blkj * block_height + inj;
222 if (
dst[j * dst_linesize +
i] > 0) {
224 w,
h,
dst[j*dst_linesize+
i],
228 block_total_width +=
width;
234 if (block_total_width >= 2 && block_count) {
235 blks[blkcnt] = block_total_width / block_count;
243 blkcnt =
ceil(blkcnt * block_pool_threshold);
244 for (
int i = 0;
i < blkcnt;
i++) {
245 total_width += blks[
i];
248 return total_width / blkcnt;
265 const int inw =
inlink->w;
266 const int inh =
inlink->h;
268 uint8_t *tmpbuf =
s->tmpbuf;
269 uint8_t *filterbuf =
s->filterbuf;
270 uint16_t *gradients =
s->gradients;
271 int8_t *directions =
s->directions;
278 for (
int plane = 0; plane <
s->nb_planes; plane++) {
279 int hsub = plane == 1 || plane == 2 ?
s->hsub : 0;
280 int vsub = plane == 1 || plane == 2 ?
s->vsub : 0;
284 if (!((1 << plane) &
s->planes))
290 ff_gaussian_blur_8(
w,
h,
295 ff_sobel_8(
w,
h, gradients,
w, directions,
w, filterbuf,
w, 1);
299 memset(tmpbuf, 0, inw * inh);
305 tmpbuf,
w, tmpbuf,
w);
308 tmpbuf,
w, filterbuf,
w);
314 s->blur_total +=
blur;
330 if (
s->nb_frames > 0) {
332 s->blur_total /
s->nb_frames);
364 .
name =
"blurdetect",
372 .priv_class = &blurdetect_class,
AVPixelFormat
Pixel format.
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
#define FILTER_PIXFMTS_ARRAY(array)
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
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
#define FILTER_INPUTS(array)
This structure describes decoded (raw) audio or video data.
static float calculate_blur(BLRContext *s, int w, int h, int hsub, int vsub, int8_t *dir, int dir_linesize, uint8_t *dst, int dst_linesize, uint8_t *src, int src_linesize)
static const struct @467 planes[]
static av_cold int blurdetect_init(AVFilterContext *ctx)
#define AV_LOG_VERBOSE
Detailed information.
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
const char * name
Filter name.
A link between two filters.
static enum AVPixelFormat pix_fmts[]
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Link properties exposed to filter code, but not external callers.
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
static void set_meta(AVDictionary **metadata, const char *key, float d)
A filter pad used for either input or output.
#define FFDIFFSIGN(x, y)
Comparator.
@ AV_PIX_FMT_YUVJ411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...
static __device__ float ceil(float a)
const AVFilterPad ff_video_default_filterpad[1]
An AVFilterPad array whose only entry has name "default" and is of type AVMEDIA_TYPE_VIDEO.
@ AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
#define AV_CEIL_RSHIFT(a, b)
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
#define FILTER_OUTPUTS(array)
static int comp(const float *a, const float *b)
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Describe the class of an AVClass context structure.
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
void ff_non_maximum_suppression(int w, int h, uint8_t *dst, int dst_linesize, const int8_t *dir, int dir_linesize, const uint16_t *src, int src_linesize)
Filters rounded gradients to drop all non-maxima pixels in the magnitude image Expects gradients gene...
static av_cold void blurdetect_uninit(AVFilterContext *ctx)
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
static FilterLink * ff_filter_link(AVFilterLink *link)
static void blur(uint8_t *dst, int dst_step, const uint8_t *src, int src_step, int len, int radius, int pixsize)
int(* init)(AVBSFContext *ctx)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
void ff_double_threshold(int low, int high, int w, int h, uint8_t *dst, int dst_linesize, const uint8_t *src, int src_linesize)
Filters all pixels in src to keep all pixels > high, and keep all pixels > low where all surrounding ...
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
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
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
#define AV_LOG_INFO
Standard information.
@ AV_OPT_TYPE_FLOAT
Underlying C type is float.
static void uninit(AVBSFContext *ctx)
#define i(width, name, range_min, range_max)
#define AV_QSORT(p, num, type, cmp)
Quicksort This sort is fast, and fully inplace but not stable and it is possible to construct input t...
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 value
@ AV_PIX_FMT_YUVJ440P
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range
const char * name
Pad name.
static const AVOption blurdetect_options[]
void * av_calloc(size_t nmemb, size_t size)
static float edge_width(BLRContext *blr, int i, int j, int8_t dir, int w, int h, int edge, const uint8_t *src, int src_linesize)
static const AVFilterPad blurdetect_inputs[]
static int blurdetect_filter_frame(AVFilterLink *inlink, AVFrame *in)
AVFILTER_DEFINE_CLASS(blurdetect)
@ AV_OPT_TYPE_INT
Underlying C type is int.
AVDictionary * metadata
metadata.
#define AVFILTER_FLAG_METADATA_ONLY
The filter is a "metadata" filter - it does not modify the frame data in any way.
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
static int blurdetect_config_input(AVFilterLink *inlink)
const AVFilter ff_vf_blurdetect
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
int64_t frame_count_in
Number of past frames sent through the link.