Go to the documentation of this file.
72 #define OFFSET(x) offsetof(SignalstatsContext, x)
73 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
97 s->filters |= 1 <<
s->outfilter;
100 g =
s->rgba_color[1];
101 b =
s->rgba_color[2];
102 s->yuv_color[0] = (( 66*
r + 129*
g + 25*
b + (1<<7)) >> 8) + 16;
103 s->yuv_color[1] = ((-38*
r + -74*
g + 112*
b + (1<<7)) >> 8) + 128;
104 s->yuv_color[2] = ((112*
r + -94*
g + -18*
b + (1<<7)) >> 8) + 128;
161 s->hsub =
desc->log2_chroma_w;
162 s->vsub =
desc->log2_chroma_h;
163 s->depth =
desc->comp[0].depth;
164 s->maxsize = 1 <<
s->depth;
170 if (!
s->histy || !
s->histu || !
s->histv || !
s->histsat)
180 s->cfs =
s->chromaw *
s->chromah;
189 if (!
s->frame_sat || !
s->frame_hue)
197 const int chromax = x >>
s->hsub;
198 const int chromay = y >>
s->vsub;
199 f->data[0][y *
f->linesize[0] + x] =
s->yuv_color[0];
200 f->data[1][chromay *
f->linesize[1] + chromax] =
s->yuv_color[1];
201 f->data[2][chromay *
f->linesize[2] + chromax] =
s->yuv_color[2];
206 const int chromax = x >>
s->hsub;
207 const int chromay = y >>
s->vsub;
208 const int mult = 1 << (
s->depth - 8);
209 AV_WN16(
f->data[0] + y *
f->linesize[0] + x * 2,
s->yuv_color[0] *
mult);
210 AV_WN16(
f->data[1] + chromay *
f->linesize[1] + chromax * 2,
s->yuv_color[1] *
mult);
211 AV_WN16(
f->data[2] + chromay *
f->linesize[2] + chromax * 2,
s->yuv_color[2] *
mult);
223 const int slice_end = (
h * (jobnr+1)) / nb_jobs;
227 const int yc = y >>
s->vsub;
228 const uint8_t *pluma = &in->
data[0][y * in->
linesize[0]];
229 const uint8_t *pchromau = &in->
data[1][yc * in->
linesize[1]];
230 const uint8_t *pchromav = &in->
data[2][yc * in->
linesize[2]];
232 for (x = 0; x <
w; x++) {
233 const int xc = x >>
s->hsub;
234 const int luma = pluma[x];
235 const int chromau = pchromau[xc];
236 const int chromav = pchromav[xc];
237 const int filt = luma < 16 || luma > 235 ||
238 chromau < 16 || chromau > 240 ||
239 chromav < 16 || chromav > 240;
254 const int mult = 1 << (
s->depth - 8);
258 const int slice_end = (
h * (jobnr+1)) / nb_jobs;
262 const int yc = y >>
s->vsub;
263 const uint16_t *pluma = (uint16_t *)&in->
data[0][y * in->
linesize[0]];
264 const uint16_t *pchromau = (uint16_t *)&in->
data[1][yc * in->
linesize[1]];
265 const uint16_t *pchromav = (uint16_t *)&in->
data[2][yc * in->
linesize[2]];
267 for (x = 0; x <
w; x++) {
268 const int xc = x >>
s->hsub;
269 const int luma = pluma[x];
270 const int chromau = pchromau[xc];
271 const int chromav = pchromav[xc];
272 const int filt = luma < 16 * mult || luma > 235 *
mult ||
273 chromau < 16 * mult || chromau > 240 *
mult ||
274 chromav < 16 * mult || chromav > 240 *
mult;
285 return ((
abs(x - y) +
abs (z - y)) / 2) -
abs(z - x) > 4;
297 const int slice_end = (
h * (jobnr+1)) / nb_jobs;
298 const uint8_t *p = in->
data[0];
300 int x, y, score = 0,
filt;
304 if (y - 1 < 0 || y + 1 >=
h)
310 #define FILTER(i, j) \
311 filter_tout_outlier(p[(y-j) * lw + x + i], \
312 p[ y * lw + x + i], \
313 p[(y+j) * lw + x + i])
315 #define FILTER3(j) (FILTER(-1, j) && FILTER(0, j) && FILTER(1, j))
317 if (y - 2 >= 0 && y + 2 <
h) {
318 for (x = 1; x <
w - 1; x++) {
325 for (x = 1; x <
w - 1; x++) {
345 const int slice_end = (
h * (jobnr+1)) / nb_jobs;
346 const uint16_t *p = (uint16_t *)in->
data[0];
348 int x, y, score = 0,
filt;
352 if (y - 1 < 0 || y + 1 >=
h)
358 if (y - 2 >= 0 && y + 2 <
h) {
359 for (x = 1; x <
w - 1; x++) {
366 for (x = 1; x <
w - 1; x++) {
388 const int slice_end = (
h * (jobnr+1)) / nb_jobs;
389 const uint8_t *p = in->
data[0];
395 const int ylw = y * lw;
396 int filt, totdiff = 0;
401 for (x = 0; x <
w; x++)
402 totdiff +=
abs(p[y2lw + x] - p[ylw + x]);
407 for (x = 0; x <
w; x++)
422 const int slice_end = (
h * (jobnr+1)) / nb_jobs;
423 const uint16_t *p = (uint16_t *)in->
data[0];
429 const int ylw = y * lw;
436 for (x = 0; x <
w; x++)
437 totdiff +=
abs(p[y2lw + x] - p[ylw + x]);
442 for (x = 0; x <
w; x++)
448 static const struct {
468 const int slice_start = (
s->chromah * jobnr ) / nb_jobs;
469 const int slice_end = (
s->chromah * (jobnr+1)) / nb_jobs;
471 const int lsz_u =
src->linesize[1];
472 const int lsz_v =
src->linesize[2];
476 const int lsz_sat = dst_sat->
linesize[0];
477 const int lsz_hue = dst_hue->
linesize[0];
482 for (
i = 0;
i <
s->chromaw;
i++) {
483 const int yuvu = p_u[
i];
484 const int yuvv = p_v[
i];
485 p_sat[
i] = hypotf(yuvu - 128, yuvv - 128);
486 ((int16_t*)p_hue)[
i] = fmodf(
floorf((180.
f /
M_PI) *
atan2f(yuvu-128, yuvv-128) + 180.
f), 360.
f);
505 const int mid = 1 << (
s->depth - 1);
507 const int slice_start = (
s->chromah * jobnr ) / nb_jobs;
508 const int slice_end = (
s->chromah * (jobnr+1)) / nb_jobs;
510 const int lsz_u =
src->linesize[1] / 2;
511 const int lsz_v =
src->linesize[2] / 2;
512 const uint16_t *p_u = (uint16_t*)
src->data[1] +
slice_start * lsz_u;
513 const uint16_t *p_v = (uint16_t*)
src->data[2] +
slice_start * lsz_v;
515 const int lsz_sat = dst_sat->
linesize[0] / 2;
516 const int lsz_hue = dst_hue->
linesize[0] / 2;
521 for (
i = 0;
i <
s->chromaw;
i++) {
522 const int yuvu = p_u[
i];
523 const int yuvv = p_v[
i];
524 p_sat[
i] = hypotf(yuvu - mid, yuvv - mid);
525 ((int16_t*)p_hue)[
i] = fmodf(
floorf((180.
f /
M_PI) *
atan2f(yuvu-mid, yuvv-mid) + 180.
f), 360.
f);
551 unsigned int *histy =
s->histy,
555 *histsat =
s->histsat;
556 int miny = -1, minu = -1, minv = -1;
557 int maxy = -1, maxu = -1, maxv = -1;
558 int lowy = -1, lowu = -1, lowv = -1;
559 int highy = -1, highu = -1, highv = -1;
560 int minsat = -1, maxsat = -1, lowsat = -1, highsat = -1;
561 int lowp, highp, clowp, chighp;
562 int accy, accu, accv;
563 int accsat, acchue = 0;
565 int64_t toty = 0, totu = 0, totv = 0, totsat=0;
567 int64_t dify = 0, difu = 0, difv = 0;
568 uint16_t masky = 0, masku = 0, maskv = 0;
575 const int hbd =
s->depth > 8;
585 prev =
s->frame_prev;
605 memset(
s->histy, 0,
s->maxsize *
sizeof(*
s->histy));
606 memset(
s->histu, 0,
s->maxsize *
sizeof(*
s->histu));
607 memset(
s->histv, 0,
s->maxsize *
sizeof(*
s->histv));
608 memset(
s->histsat, 0,
s->maxsize *
sizeof(*
s->histsat));
611 const uint16_t *p_sat = (uint16_t *)sat->
data[0];
612 const uint16_t *p_hue = (uint16_t *)hue->
data[0];
613 const int lsz_sat = sat->
linesize[0] / 2;
614 const int lsz_hue = hue->
linesize[0] / 2;
616 for (
int j = 0; j <
link->h; j++) {
617 for (
int i = 0;
i <
link->w;
i++) {
629 for (
int j = 0; j <
s->chromah; j++) {
630 for (
int i = 0;
i <
s->chromaw;
i++) {
642 histhue[((int16_t*)p_hue)[
i]]++;
650 const uint8_t *p_sat = sat->
data[0];
651 const uint8_t *p_hue = hue->
data[0];
652 const int lsz_sat = sat->
linesize[0];
653 const int lsz_hue = hue->
linesize[0];
655 for (
int j = 0; j <
link->h; j++) {
656 for (
int i = 0;
i <
link->w;
i++) {
657 const int yuv = in->
data[0][
w +
i];
661 dify +=
abs(yuv - prev->
data[0][pw +
i]);
668 for (
int j = 0; j <
s->chromah; j++) {
669 for (
int i = 0;
i <
s->chromaw;
i++) {
670 const int yuvu = in->
data[1][cw+
i];
671 const int yuvv = in->
data[2][cw+
i];
676 difu +=
abs(yuvu - prev->
data[1][cpw+
i]);
678 difv +=
abs(yuvv - prev->
data[2][cpw+
i]);
681 histhue[((int16_t*)p_hue)[
i]]++;
691 if (
s->filters & 1<<fil) {
694 .out =
out != in &&
s->outfilter == fil ?
out :
NULL,
696 memset(
s->jobs_rets, 0,
s->nb_jobs *
sizeof(*
s->jobs_rets));
698 &td,
s->jobs_rets,
s->nb_jobs);
699 for (
int i = 0;
i <
s->nb_jobs;
i++)
700 filtot[fil] +=
s->jobs_rets[
i];
707 lowp =
lrint(
s->fs * 10 / 100.);
708 highp =
lrint(
s->fs * 90 / 100.);
709 clowp =
lrint(
s->cfs * 10 / 100.);
710 chighp =
lrint(
s->cfs * 90 / 100.);
712 accy = accu = accv = accsat = 0;
713 for (fil = 0; fil <
s->maxsize; fil++) {
714 if (miny < 0 && histy[fil]) miny = fil;
715 if (minu < 0 && histu[fil]) minu = fil;
716 if (minv < 0 && histv[fil]) minv = fil;
717 if (minsat < 0 && histsat[fil]) minsat = fil;
719 if (histy[fil]) maxy = fil;
720 if (histu[fil]) maxu = fil;
721 if (histv[fil]) maxv = fil;
722 if (histsat[fil]) maxsat = fil;
724 toty += (uint64_t)histy[fil] * fil;
725 totu += (uint64_t)histu[fil] * fil;
726 totv += (uint64_t)histv[fil] * fil;
727 totsat += (uint64_t)histsat[fil] * fil;
732 accsat += histsat[fil];
734 if (lowy == -1 && accy >= lowp) lowy = fil;
735 if (lowu == -1 && accu >= clowp) lowu = fil;
736 if (lowv == -1 && accv >= clowp) lowv = fil;
737 if (lowsat == -1 && accsat >= clowp) lowsat = fil;
739 if (highy == -1 && accy >= highp) highy = fil;
740 if (highu == -1 && accu >= chighp) highu = fil;
741 if (highv == -1 && accv >= chighp) highv = fil;
742 if (highsat == -1 && accsat >= chighp) highsat = fil;
747 for (fil = 0; fil < 360; fil++) {
748 tothue += (uint64_t)histhue[fil] * fil;
749 acchue += histhue[fil];
751 if (medhue == -1 && acchue >
s->cfs / 2)
753 if (histhue[fil] > maxhue) {
754 maxhue = histhue[fil];
761 #define SET_META(key, fmt, val) do { \
762 snprintf(metabuf, sizeof(metabuf), fmt, val); \
763 av_dict_set(&out->metadata, "lavfi.signalstats." key, metabuf, 0); \
768 SET_META(
"YAVG",
"%g", 1.0 * toty /
s->fs);
774 SET_META(
"UAVG",
"%g", 1.0 * totu /
s->cfs);
780 SET_META(
"VAVG",
"%g", 1.0 * totv /
s->cfs);
786 SET_META(
"SATAVG",
"%g", 1.0 * totsat /
s->cfs);
791 SET_META(
"HUEAVG",
"%g", 1.0 * tothue /
s->cfs);
793 SET_META(
"YDIF",
"%g", 1.0 * dify /
s->fs);
794 SET_META(
"UDIF",
"%g", 1.0 * difu /
s->cfs);
795 SET_META(
"VDIF",
"%g", 1.0 * difv /
s->cfs);
802 if (
s->filters & 1<<fil) {
804 snprintf(metabuf,
sizeof(metabuf),
"%g", 1.0 * filtot[fil] /
s->fs);
832 .
name =
"signalstats",
833 .description =
"Generate statistics from video analysis.",
840 .priv_class = &signalstats_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
static int compute_sat_hue_metrics16(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
static av_cold int init(AVFilterContext *ctx)
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
#define SET_META(key, fmt, val)
#define FILTER_PIXFMTS_ARRAY(array)
static __device__ float floorf(float a)
static int filter8_brng(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
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
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
This structure describes decoded (raw) audio or video data.
#define AV_PIX_FMT_YUV420P10
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
AVFILTER_DEFINE_CLASS(signalstats)
const char * name
Filter name.
A link between two filters.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static int slice_end(AVCodecContext *avctx, AVFrame *pict, int *got_output)
Handle slice ends.
#define AV_PIX_FMT_YUV422P9
static int filter16_tout(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
#define AV_PIX_FMT_GRAY16
static int filter_tout_outlier(uint8_t x, uint8_t y, uint8_t z)
static enum AVPixelFormat pix_fmts[]
A filter pad used for either input or output.
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
#define AV_PIX_FMT_YUV444P10
@ 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 av_cold void uninit(AVFilterContext *ctx)
static int16_t mult(Float11 *f1, Float11 *f2)
#define AV_PIX_FMT_YUV422P16
static const uint16_t mask[17]
@ AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
static AVFrame * alloc_frame(enum AVPixelFormat pixfmt, int w, int h)
#define AV_PIX_FMT_YUV444P16
#define AV_CEIL_RSHIFT(a, b)
#define filters(fmt, type, inverse, clp, inverset, clip, one, clip_fn, packed)
#define AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P16
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
#define FILTER_INPUTS(array)
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
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
int ff_inlink_make_frame_writable(AVFilterLink *link, AVFrame **rframe)
Make sure a frame is writable.
Describe the class of an AVClass context structure.
static void burn_frame16(const SignalstatsContext *s, AVFrame *f, int x, int y)
static const struct @334 filters_def[]
static int filter8_tout(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
AVFilterLink ** inputs
array of pointers to input links
#define AV_PIX_FMT_YUV440P10
#define AV_PIX_FMT_YUV422P10
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
const AVFilter ff_vf_signalstats
static const AVFilterPad signalstats_inputs[]
static void burn_frame8(const SignalstatsContext *s, AVFrame *f, int x, int y)
static int filter_frame(AVFilterLink *link, AVFrame *in)
int format
agreed upon media format
#define AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV444P12
static const AVFilterPad signalstats_outputs[]
AVFilterContext * src
source filter
static int compute_sat_hue_metrics8(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
#define i(width, name, range_min, range_max)
int(* process8)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
int w
agreed upon image width
#define av_malloc_array(a, b)
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
static int config_output(AVFilterLink *outlink)
Used for passing data between threads.
int(* process16)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
@ AV_PIX_FMT_YUVJ440P
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range
static const int8_t filt[NUMTAPS *2]
const char * name
Pad name.
#define AV_PIX_FMT_YUV444P9
enum AVPixelFormat pixfmt
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 the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
#define AV_PIX_FMT_YUV420P12
static int filter16_brng(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
#define AV_PIX_FMT_YUV422P14
int h
agreed upon image height
static const AVOption signalstats_options[]
static int filter8_vrep(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
static int slice_start(SliceContext *sc, VVCContext *s, VVCFrameContext *fc, const CodedBitstreamUnit *unit, const int is_first_slice)
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags)
Convenience wrapper for av_dict_set() that converts the value to a string and stores it.
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
@ 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...
static int filter16_vrep(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
#define FILTER_OUTPUTS(array)
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)
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
#define AV_PIX_FMT_YUV440P12
#define AV_PIX_FMT_YUV444P14
static av_always_inline int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
static unsigned compute_bit_depth(uint16_t mask)
#define AV_PIX_FMT_YUV420P14