2 * Copyright (c) 2010 Mark Heath mjpeg0 @ silicontrip dot org
3 * Copyright (c) 2014 Clément Bœsch
4 * Copyright (c) 2014 Dave Rice @dericed
6 * This file is part of FFmpeg.
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.
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.
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
23 #include "libavutil/intreadwrite.h"
24 #include "libavutil/opt.h"
25 #include "libavutil/pixdesc.h"
36 typedef struct SignalstatsContext {
38 int chromah; // height of chroma plane
39 int chromaw; // width of chroma plane
40 int hsub; // horizontal subsampling
41 int vsub; // vertical subsampling
42 int depth; // pixel depth
43 int fs; // pixel count per frame
44 int cfs; // pixel count per frame of chroma planes
45 int outfilter; // FilterMode
48 uint8_t rgba_color[4];
53 int maxsize; // history stats array size
54 int *histy, *histu, *histv, *histsat;
60 typedef struct ThreadData {
65 typedef struct ThreadDataHueSatMetrics {
67 AVFrame *dst_sat, *dst_hue;
68 } ThreadDataHueSatMetrics;
70 #define OFFSET(x) offsetof(SignalstatsContext, x)
71 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
73 static const AVOption signalstats_options[] = {
74 {"stat", "set statistics filters", OFFSET(filters), AV_OPT_TYPE_FLAGS, {.i64=0}, 0, INT_MAX, FLAGS, "filters"},
75 {"tout", "analyze pixels for temporal outliers", 0, AV_OPT_TYPE_CONST, {.i64=1<<FILTER_TOUT}, 0, 0, FLAGS, "filters"},
76 {"vrep", "analyze video lines for vertical line repetition", 0, AV_OPT_TYPE_CONST, {.i64=1<<FILTER_VREP}, 0, 0, FLAGS, "filters"},
77 {"brng", "analyze for pixels outside of broadcast range", 0, AV_OPT_TYPE_CONST, {.i64=1<<FILTER_BRNG}, 0, 0, FLAGS, "filters"},
78 {"out", "set video filter", OFFSET(outfilter), AV_OPT_TYPE_INT, {.i64=FILTER_NONE}, -1, FILT_NUMB-1, FLAGS, "out"},
79 {"tout", "highlight pixels that depict temporal outliers", 0, AV_OPT_TYPE_CONST, {.i64=FILTER_TOUT}, 0, 0, FLAGS, "out"},
80 {"vrep", "highlight video lines that depict vertical line repetition", 0, AV_OPT_TYPE_CONST, {.i64=FILTER_VREP}, 0, 0, FLAGS, "out"},
81 {"brng", "highlight pixels that are outside of broadcast range", 0, AV_OPT_TYPE_CONST, {.i64=FILTER_BRNG}, 0, 0, FLAGS, "out"},
82 {"c", "set highlight color", OFFSET(rgba_color), AV_OPT_TYPE_COLOR, {.str="yellow"}, .flags=FLAGS},
83 {"color", "set highlight color", OFFSET(rgba_color), AV_OPT_TYPE_COLOR, {.str="yellow"}, .flags=FLAGS},
87 AVFILTER_DEFINE_CLASS(signalstats);
89 static av_cold int init(AVFilterContext *ctx)
92 SignalstatsContext *s = ctx->priv;
94 if (s->outfilter != FILTER_NONE)
95 s->filters |= 1 << s->outfilter;
100 s->yuv_color[0] = (( 66*r + 129*g + 25*b + (1<<7)) >> 8) + 16;
101 s->yuv_color[1] = ((-38*r + -74*g + 112*b + (1<<7)) >> 8) + 128;
102 s->yuv_color[2] = ((112*r + -94*g + -18*b + (1<<7)) >> 8) + 128;
106 static av_cold void uninit(AVFilterContext *ctx)
108 SignalstatsContext *s = ctx->priv;
109 av_frame_free(&s->frame_prev);
110 av_frame_free(&s->frame_sat);
111 av_frame_free(&s->frame_hue);
112 av_freep(&s->jobs_rets);
116 av_freep(&s->histsat);
119 static int query_formats(AVFilterContext *ctx)
122 static const enum AVPixelFormat pix_fmts[] = {
123 AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV411P,
125 AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ411P,
127 AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV420P9,
128 AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV420P10,
129 AV_PIX_FMT_YUV440P10,
130 AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV420P12,
131 AV_PIX_FMT_YUV440P12,
132 AV_PIX_FMT_YUV444P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV420P14,
133 AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV420P16,
137 AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
139 return AVERROR(ENOMEM);
140 return ff_set_common_formats(ctx, fmts_list);
143 static AVFrame *alloc_frame(enum AVPixelFormat pixfmt, int w, int h)
145 AVFrame *frame = av_frame_alloc();
149 frame->format = pixfmt;
153 if (av_frame_get_buffer(frame, 0) < 0) {
154 av_frame_free(&frame);
161 static int config_output(AVFilterLink *outlink)
163 AVFilterContext *ctx = outlink->src;
164 SignalstatsContext *s = ctx->priv;
165 AVFilterLink *inlink = outlink->src->inputs[0];
166 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(outlink->format);
167 s->hsub = desc->log2_chroma_w;
168 s->vsub = desc->log2_chroma_h;
169 s->depth = desc->comp[0].depth;
170 s->maxsize = 1 << s->depth;
171 s->histy = av_malloc_array(s->maxsize, sizeof(*s->histy));
172 s->histu = av_malloc_array(s->maxsize, sizeof(*s->histu));
173 s->histv = av_malloc_array(s->maxsize, sizeof(*s->histv));
174 s->histsat = av_malloc_array(s->maxsize, sizeof(*s->histsat));
176 if (!s->histy || !s->histu || !s->histv || !s->histsat)
177 return AVERROR(ENOMEM);
179 outlink->w = inlink->w;
180 outlink->h = inlink->h;
182 s->chromaw = AV_CEIL_RSHIFT(inlink->w, s->hsub);
183 s->chromah = AV_CEIL_RSHIFT(inlink->h, s->vsub);
185 s->fs = inlink->w * inlink->h;
186 s->cfs = s->chromaw * s->chromah;
188 s->nb_jobs = FFMAX(1, FFMIN(inlink->h, ff_filter_get_nb_threads(ctx)));
189 s->jobs_rets = av_malloc_array(s->nb_jobs, sizeof(*s->jobs_rets));
191 return AVERROR(ENOMEM);
193 s->frame_sat = alloc_frame(s->depth > 8 ? AV_PIX_FMT_GRAY16 : AV_PIX_FMT_GRAY8, inlink->w, inlink->h);
194 s->frame_hue = alloc_frame(AV_PIX_FMT_GRAY16, inlink->w, inlink->h);
195 if (!s->frame_sat || !s->frame_hue)
196 return AVERROR(ENOMEM);
201 static void burn_frame8(const SignalstatsContext *s, AVFrame *f, int x, int y)
203 const int chromax = x >> s->hsub;
204 const int chromay = y >> s->vsub;
205 f->data[0][y * f->linesize[0] + x] = s->yuv_color[0];
206 f->data[1][chromay * f->linesize[1] + chromax] = s->yuv_color[1];
207 f->data[2][chromay * f->linesize[2] + chromax] = s->yuv_color[2];
210 static void burn_frame16(const SignalstatsContext *s, AVFrame *f, int x, int y)
212 const int chromax = x >> s->hsub;
213 const int chromay = y >> s->vsub;
214 const int mult = 1 << (s->depth - 8);
215 AV_WN16(f->data[0] + y * f->linesize[0] + x * 2, s->yuv_color[0] * mult);
216 AV_WN16(f->data[1] + chromay * f->linesize[1] + chromax * 2, s->yuv_color[1] * mult);
217 AV_WN16(f->data[2] + chromay * f->linesize[2] + chromax * 2, s->yuv_color[2] * mult);
220 static int filter8_brng(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
222 ThreadData *td = arg;
223 const SignalstatsContext *s = ctx->priv;
224 const AVFrame *in = td->in;
225 AVFrame *out = td->out;
226 const int w = in->width;
227 const int h = in->height;
228 const int slice_start = (h * jobnr ) / nb_jobs;
229 const int slice_end = (h * (jobnr+1)) / nb_jobs;
232 for (y = slice_start; y < slice_end; y++) {
233 const int yc = y >> s->vsub;
234 const uint8_t *pluma = &in->data[0][y * in->linesize[0]];
235 const uint8_t *pchromau = &in->data[1][yc * in->linesize[1]];
236 const uint8_t *pchromav = &in->data[2][yc * in->linesize[2]];
238 for (x = 0; x < w; x++) {
239 const int xc = x >> s->hsub;
240 const int luma = pluma[x];
241 const int chromau = pchromau[xc];
242 const int chromav = pchromav[xc];
243 const int filt = luma < 16 || luma > 235 ||
244 chromau < 16 || chromau > 240 ||
245 chromav < 16 || chromav > 240;
248 burn_frame8(s, out, x, y);
254 static int filter16_brng(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
256 ThreadData *td = arg;
257 const SignalstatsContext *s = ctx->priv;
258 const AVFrame *in = td->in;
259 AVFrame *out = td->out;
260 const int mult = 1 << (s->depth - 8);
261 const int w = in->width;
262 const int h = in->height;
263 const int slice_start = (h * jobnr ) / nb_jobs;
264 const int slice_end = (h * (jobnr+1)) / nb_jobs;
267 for (y = slice_start; y < slice_end; y++) {
268 const int yc = y >> s->vsub;
269 const uint16_t *pluma = (uint16_t *)&in->data[0][y * in->linesize[0]];
270 const uint16_t *pchromau = (uint16_t *)&in->data[1][yc * in->linesize[1]];
271 const uint16_t *pchromav = (uint16_t *)&in->data[2][yc * in->linesize[2]];
273 for (x = 0; x < w; x++) {
274 const int xc = x >> s->hsub;
275 const int luma = pluma[x];
276 const int chromau = pchromau[xc];
277 const int chromav = pchromav[xc];
278 const int filt = luma < 16 * mult || luma > 235 * mult ||
279 chromau < 16 * mult || chromau > 240 * mult ||
280 chromav < 16 * mult || chromav > 240 * mult;
283 burn_frame16(s, out, x, y);
289 static int filter_tout_outlier(uint8_t x, uint8_t y, uint8_t z)
291 return ((abs(x - y) + abs (z - y)) / 2) - abs(z - x) > 4; // make 4 configurable?
294 static int filter8_tout(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
296 ThreadData *td = arg;
297 const SignalstatsContext *s = ctx->priv;
298 const AVFrame *in = td->in;
299 AVFrame *out = td->out;
300 const int w = in->width;
301 const int h = in->height;
302 const int slice_start = (h * jobnr ) / nb_jobs;
303 const int slice_end = (h * (jobnr+1)) / nb_jobs;
304 const uint8_t *p = in->data[0];
305 int lw = in->linesize[0];
306 int x, y, score = 0, filt;
308 for (y = slice_start; y < slice_end; y++) {
310 if (y - 1 < 0 || y + 1 >= h)
313 // detect two pixels above and below (to eliminate interlace artefacts)
314 // should check that video format is infact interlaced.
316 #define FILTER(i, j) \
317 filter_tout_outlier(p[(y-j) * lw + x + i], \
318 p[ y * lw + x + i], \
319 p[(y+j) * lw + x + i])
321 #define FILTER3(j) (FILTER(-1, j) && FILTER(0, j) && FILTER(1, j))
323 if (y - 2 >= 0 && y + 2 < h) {
324 for (x = 1; x < w - 1; x++) {
325 filt = FILTER3(2) && FILTER3(1);
328 burn_frame8(s, out, x, y);
331 for (x = 1; x < w - 1; x++) {
335 burn_frame8(s, out, x, y);
342 static int filter16_tout(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
344 ThreadData *td = arg;
345 const SignalstatsContext *s = ctx->priv;
346 const AVFrame *in = td->in;
347 AVFrame *out = td->out;
348 const int w = in->width;
349 const int h = in->height;
350 const int slice_start = (h * jobnr ) / nb_jobs;
351 const int slice_end = (h * (jobnr+1)) / nb_jobs;
352 const uint16_t *p = (uint16_t *)in->data[0];
353 int lw = in->linesize[0] / 2;
354 int x, y, score = 0, filt;
356 for (y = slice_start; y < slice_end; y++) {
358 if (y - 1 < 0 || y + 1 >= h)
361 // detect two pixels above and below (to eliminate interlace artefacts)
362 // should check that video format is infact interlaced.
364 if (y - 2 >= 0 && y + 2 < h) {
365 for (x = 1; x < w - 1; x++) {
366 filt = FILTER3(2) && FILTER3(1);
369 burn_frame16(s, out, x, y);
372 for (x = 1; x < w - 1; x++) {
376 burn_frame16(s, out, x, y);
385 static int filter8_vrep(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
387 ThreadData *td = arg;
388 const SignalstatsContext *s = ctx->priv;
389 const AVFrame *in = td->in;
390 AVFrame *out = td->out;
391 const int w = in->width;
392 const int h = in->height;
393 const int slice_start = (h * jobnr ) / nb_jobs;
394 const int slice_end = (h * (jobnr+1)) / nb_jobs;
395 const uint8_t *p = in->data[0];
396 const int lw = in->linesize[0];
399 for (y = slice_start; y < slice_end; y++) {
400 const int y2lw = (y - VREP_START) * lw;
401 const int ylw = y * lw;
402 int filt, totdiff = 0;
407 for (x = 0; x < w; x++)
408 totdiff += abs(p[y2lw + x] - p[ylw + x]);
413 for (x = 0; x < w; x++)
414 burn_frame8(s, out, x, y);
419 static int filter16_vrep(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
421 ThreadData *td = arg;
422 const SignalstatsContext *s = ctx->priv;
423 const AVFrame *in = td->in;
424 AVFrame *out = td->out;
425 const int w = in->width;
426 const int h = in->height;
427 const int slice_start = (h * jobnr ) / nb_jobs;
428 const int slice_end = (h * (jobnr+1)) / nb_jobs;
429 const uint16_t *p = (uint16_t *)in->data[0];
430 const int lw = in->linesize[0] / 2;
433 for (y = slice_start; y < slice_end; y++) {
434 const int y2lw = (y - VREP_START) * lw;
435 const int ylw = y * lw;
442 for (x = 0; x < w; x++)
443 totdiff += abs(p[y2lw + x] - p[ylw + x]);
448 for (x = 0; x < w; x++)
449 burn_frame16(s, out, x, y);
454 static const struct {
456 int (*process8)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
457 int (*process16)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
459 {"TOUT", filter8_tout, filter16_tout},
460 {"VREP", filter8_vrep, filter16_vrep},
461 {"BRNG", filter8_brng, filter16_brng},
465 static int compute_sat_hue_metrics8(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
468 ThreadDataHueSatMetrics *td = arg;
469 const SignalstatsContext *s = ctx->priv;
470 const AVFrame *src = td->src;
471 AVFrame *dst_sat = td->dst_sat;
472 AVFrame *dst_hue = td->dst_hue;
474 const int slice_start = (s->chromah * jobnr ) / nb_jobs;
475 const int slice_end = (s->chromah * (jobnr+1)) / nb_jobs;
477 const int lsz_u = src->linesize[1];
478 const int lsz_v = src->linesize[2];
479 const uint8_t *p_u = src->data[1] + slice_start * lsz_u;
480 const uint8_t *p_v = src->data[2] + slice_start * lsz_v;
482 const int lsz_sat = dst_sat->linesize[0];
483 const int lsz_hue = dst_hue->linesize[0];
484 uint8_t *p_sat = dst_sat->data[0] + slice_start * lsz_sat;
485 uint8_t *p_hue = dst_hue->data[0] + slice_start * lsz_hue;
487 for (j = slice_start; j < slice_end; j++) {
488 for (i = 0; i < s->chromaw; i++) {
489 const int yuvu = p_u[i];
490 const int yuvv = p_v[i];
491 p_sat[i] = hypot(yuvu - 128, yuvv - 128); // int or round?
492 ((int16_t*)p_hue)[i] = fmod(floor((180 / M_PI) * atan2f(yuvu-128, yuvv-128) + 180), 360.);
503 static int compute_sat_hue_metrics16(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
506 ThreadDataHueSatMetrics *td = arg;
507 const SignalstatsContext *s = ctx->priv;
508 const AVFrame *src = td->src;
509 AVFrame *dst_sat = td->dst_sat;
510 AVFrame *dst_hue = td->dst_hue;
511 const int mid = 1 << (s->depth - 1);
513 const int slice_start = (s->chromah * jobnr ) / nb_jobs;
514 const int slice_end = (s->chromah * (jobnr+1)) / nb_jobs;
516 const int lsz_u = src->linesize[1] / 2;
517 const int lsz_v = src->linesize[2] / 2;
518 const uint16_t *p_u = (uint16_t*)src->data[1] + slice_start * lsz_u;
519 const uint16_t *p_v = (uint16_t*)src->data[2] + slice_start * lsz_v;
521 const int lsz_sat = dst_sat->linesize[0] / 2;
522 const int lsz_hue = dst_hue->linesize[0] / 2;
523 uint16_t *p_sat = (uint16_t*)dst_sat->data[0] + slice_start * lsz_sat;
524 uint16_t *p_hue = (uint16_t*)dst_hue->data[0] + slice_start * lsz_hue;
526 for (j = slice_start; j < slice_end; j++) {
527 for (i = 0; i < s->chromaw; i++) {
528 const int yuvu = p_u[i];
529 const int yuvv = p_v[i];
530 p_sat[i] = hypot(yuvu - mid, yuvv - mid); // int or round?
531 ((int16_t*)p_hue)[i] = fmod(floor((180 / M_PI) * atan2f(yuvu-mid, yuvv-mid) + 180), 360.);
542 static unsigned compute_bit_depth(uint16_t mask)
544 return av_popcount(mask);
547 static int filter_frame8(AVFilterLink *link, AVFrame *in)
549 AVFilterContext *ctx = link->dst;
550 SignalstatsContext *s = ctx->priv;
551 AVFilterLink *outlink = ctx->outputs[0];
554 int w = 0, cw = 0, // in
555 pw = 0, cpw = 0; // prev
558 unsigned int *histy = s->histy,
562 *histsat = s->histsat;
563 int miny = -1, minu = -1, minv = -1;
564 int maxy = -1, maxu = -1, maxv = -1;
565 int lowy = -1, lowu = -1, lowv = -1;
566 int highy = -1, highu = -1, highv = -1;
567 int minsat = -1, maxsat = -1, lowsat = -1, highsat = -1;
568 int lowp, highp, clowp, chighp;
569 int accy, accu, accv;
570 int accsat, acchue = 0;
572 int toty = 0, totu = 0, totv = 0, totsat=0;
574 int dify = 0, difu = 0, difv = 0;
575 uint16_t masky = 0, masku = 0, maskv = 0;
577 int filtot[FILT_NUMB] = {0};
580 AVFrame *sat = s->frame_sat;
581 AVFrame *hue = s->frame_hue;
582 const uint8_t *p_sat = sat->data[0];
583 const uint8_t *p_hue = hue->data[0];
584 const int lsz_sat = sat->linesize[0];
585 const int lsz_hue = hue->linesize[0];
586 ThreadDataHueSatMetrics td_huesat = {
593 s->frame_prev = av_frame_clone(in);
595 prev = s->frame_prev;
597 if (s->outfilter != FILTER_NONE) {
598 out = av_frame_clone(in);
599 av_frame_make_writable(out);
602 ctx->internal->execute(ctx, compute_sat_hue_metrics8, &td_huesat,
603 NULL, FFMIN(s->chromah, ff_filter_get_nb_threads(ctx)));
605 // Calculate luma histogram and difference with previous frame or field.
606 memset(s->histy, 0, s->maxsize * sizeof(*s->histy));
607 for (j = 0; j < link->h; j++) {
608 for (i = 0; i < link->w; i++) {
609 const int yuv = in->data[0][w + i];
613 dify += abs(yuv - prev->data[0][pw + i]);
615 w += in->linesize[0];
616 pw += prev->linesize[0];
619 // Calculate chroma histogram and difference with previous frame or field.
620 memset(s->histu, 0, s->maxsize * sizeof(*s->histu));
621 memset(s->histv, 0, s->maxsize * sizeof(*s->histv));
622 memset(s->histsat, 0, s->maxsize * sizeof(*s->histsat));
623 for (j = 0; j < s->chromah; j++) {
624 for (i = 0; i < s->chromaw; i++) {
625 const int yuvu = in->data[1][cw+i];
626 const int yuvv = in->data[2][cw+i];
631 difu += abs(yuvu - prev->data[1][cpw+i]);
633 difv += abs(yuvv - prev->data[2][cpw+i]);
636 histhue[((int16_t*)p_hue)[i]]++;
638 cw += in->linesize[1];
639 cpw += prev->linesize[1];
644 for (fil = 0; fil < FILT_NUMB; fil ++) {
645 if (s->filters & 1<<fil) {
648 .out = out != in && s->outfilter == fil ? out : NULL,
650 memset(s->jobs_rets, 0, s->nb_jobs * sizeof(*s->jobs_rets));
651 ctx->internal->execute(ctx, filters_def[fil].process8,
652 &td, s->jobs_rets, s->nb_jobs);
653 for (i = 0; i < s->nb_jobs; i++)
654 filtot[fil] += s->jobs_rets[i];
658 // find low / high based on histogram percentile
659 // these only need to be calculated once.
661 lowp = lrint(s->fs * 10 / 100.);
662 highp = lrint(s->fs * 90 / 100.);
663 clowp = lrint(s->cfs * 10 / 100.);
664 chighp = lrint(s->cfs * 90 / 100.);
666 accy = accu = accv = accsat = 0;
667 for (fil = 0; fil < s->maxsize; fil++) {
668 if (miny < 0 && histy[fil]) miny = fil;
669 if (minu < 0 && histu[fil]) minu = fil;
670 if (minv < 0 && histv[fil]) minv = fil;
671 if (minsat < 0 && histsat[fil]) minsat = fil;
673 if (histy[fil]) maxy = fil;
674 if (histu[fil]) maxu = fil;
675 if (histv[fil]) maxv = fil;
676 if (histsat[fil]) maxsat = fil;
678 toty += histy[fil] * fil;
679 totu += histu[fil] * fil;
680 totv += histv[fil] * fil;
681 totsat += histsat[fil] * fil;
686 accsat += histsat[fil];
688 if (lowy == -1 && accy >= lowp) lowy = fil;
689 if (lowu == -1 && accu >= clowp) lowu = fil;
690 if (lowv == -1 && accv >= clowp) lowv = fil;
691 if (lowsat == -1 && accsat >= clowp) lowsat = fil;
693 if (highy == -1 && accy >= highp) highy = fil;
694 if (highu == -1 && accu >= chighp) highu = fil;
695 if (highv == -1 && accv >= chighp) highv = fil;
696 if (highsat == -1 && accsat >= chighp) highsat = fil;
701 for (fil = 0; fil < 360; fil++) {
702 tothue += histhue[fil] * fil;
703 acchue += histhue[fil];
705 if (medhue == -1 && acchue > s->cfs / 2)
707 if (histhue[fil] > maxhue) {
708 maxhue = histhue[fil];
712 av_frame_free(&s->frame_prev);
713 s->frame_prev = av_frame_clone(in);
715 #define SET_META(key, fmt, val) do { \
716 snprintf(metabuf, sizeof(metabuf), fmt, val); \
717 av_dict_set(&out->metadata, "lavfi.signalstats." key, metabuf, 0); \
720 SET_META("YMIN", "%d", miny);
721 SET_META("YLOW", "%d", lowy);
722 SET_META("YAVG", "%g", 1.0 * toty / s->fs);
723 SET_META("YHIGH", "%d", highy);
724 SET_META("YMAX", "%d", maxy);
726 SET_META("UMIN", "%d", minu);
727 SET_META("ULOW", "%d", lowu);
728 SET_META("UAVG", "%g", 1.0 * totu / s->cfs);
729 SET_META("UHIGH", "%d", highu);
730 SET_META("UMAX", "%d", maxu);
732 SET_META("VMIN", "%d", minv);
733 SET_META("VLOW", "%d", lowv);
734 SET_META("VAVG", "%g", 1.0 * totv / s->cfs);
735 SET_META("VHIGH", "%d", highv);
736 SET_META("VMAX", "%d", maxv);
738 SET_META("SATMIN", "%d", minsat);
739 SET_META("SATLOW", "%d", lowsat);
740 SET_META("SATAVG", "%g", 1.0 * totsat / s->cfs);
741 SET_META("SATHIGH", "%d", highsat);
742 SET_META("SATMAX", "%d", maxsat);
744 SET_META("HUEMED", "%d", medhue);
745 SET_META("HUEAVG", "%g", 1.0 * tothue / s->cfs);
747 SET_META("YDIF", "%g", 1.0 * dify / s->fs);
748 SET_META("UDIF", "%g", 1.0 * difu / s->cfs);
749 SET_META("VDIF", "%g", 1.0 * difv / s->cfs);
751 SET_META("YBITDEPTH", "%d", compute_bit_depth(masky));
752 SET_META("UBITDEPTH", "%d", compute_bit_depth(masku));
753 SET_META("VBITDEPTH", "%d", compute_bit_depth(maskv));
755 for (fil = 0; fil < FILT_NUMB; fil ++) {
756 if (s->filters & 1<<fil) {
758 snprintf(metabuf, sizeof(metabuf), "%g", 1.0 * filtot[fil] / s->fs);
759 snprintf(metaname, sizeof(metaname), "lavfi.signalstats.%s", filters_def[fil].name);
760 av_dict_set(&out->metadata, metaname, metabuf, 0);
766 return ff_filter_frame(outlink, out);
769 static int filter_frame16(AVFilterLink *link, AVFrame *in)
771 AVFilterContext *ctx = link->dst;
772 SignalstatsContext *s = ctx->priv;
773 AVFilterLink *outlink = ctx->outputs[0];
776 int w = 0, cw = 0, // in
777 pw = 0, cpw = 0; // prev
780 unsigned int *histy = s->histy,
784 *histsat = s->histsat;
785 int miny = -1, minu = -1, minv = -1;
786 int maxy = -1, maxu = -1, maxv = -1;
787 int lowy = -1, lowu = -1, lowv = -1;
788 int highy = -1, highu = -1, highv = -1;
789 int minsat = -1, maxsat = -1, lowsat = -1, highsat = -1;
790 int lowp, highp, clowp, chighp;
791 int accy, accu, accv;
792 int accsat, acchue = 0;
794 int64_t toty = 0, totu = 0, totv = 0, totsat=0;
796 int64_t dify = 0, difu = 0, difv = 0;
797 uint16_t masky = 0, masku = 0, maskv = 0;
799 int filtot[FILT_NUMB] = {0};
802 AVFrame *sat = s->frame_sat;
803 AVFrame *hue = s->frame_hue;
804 const uint16_t *p_sat = (uint16_t *)sat->data[0];
805 const uint16_t *p_hue = (uint16_t *)hue->data[0];
806 const int lsz_sat = sat->linesize[0] / 2;
807 const int lsz_hue = hue->linesize[0] / 2;
808 ThreadDataHueSatMetrics td_huesat = {
815 s->frame_prev = av_frame_clone(in);
817 prev = s->frame_prev;
819 if (s->outfilter != FILTER_NONE) {
820 out = av_frame_clone(in);
821 av_frame_make_writable(out);
824 ctx->internal->execute(ctx, compute_sat_hue_metrics16, &td_huesat,
825 NULL, FFMIN(s->chromah, ff_filter_get_nb_threads(ctx)));
827 // Calculate luma histogram and difference with previous frame or field.
828 memset(s->histy, 0, s->maxsize * sizeof(*s->histy));
829 for (j = 0; j < link->h; j++) {
830 for (i = 0; i < link->w; i++) {
831 const int yuv = AV_RN16(in->data[0] + w + i * 2);
835 dify += abs(yuv - (int)AV_RN16(prev->data[0] + pw + i * 2));
837 w += in->linesize[0];
838 pw += prev->linesize[0];
841 // Calculate chroma histogram and difference with previous frame or field.
842 memset(s->histu, 0, s->maxsize * sizeof(*s->histu));
843 memset(s->histv, 0, s->maxsize * sizeof(*s->histv));
844 memset(s->histsat, 0, s->maxsize * sizeof(*s->histsat));
845 for (j = 0; j < s->chromah; j++) {
846 for (i = 0; i < s->chromaw; i++) {
847 const int yuvu = AV_RN16(in->data[1] + cw + i * 2);
848 const int yuvv = AV_RN16(in->data[2] + cw + i * 2);
853 difu += abs(yuvu - (int)AV_RN16(prev->data[1] + cpw + i * 2));
855 difv += abs(yuvv - (int)AV_RN16(prev->data[2] + cpw + i * 2));
858 histhue[((int16_t*)p_hue)[i]]++;
860 cw += in->linesize[1];
861 cpw += prev->linesize[1];
866 for (fil = 0; fil < FILT_NUMB; fil ++) {
867 if (s->filters & 1<<fil) {
870 .out = out != in && s->outfilter == fil ? out : NULL,
872 memset(s->jobs_rets, 0, s->nb_jobs * sizeof(*s->jobs_rets));
873 ctx->internal->execute(ctx, filters_def[fil].process16,
874 &td, s->jobs_rets, s->nb_jobs);
875 for (i = 0; i < s->nb_jobs; i++)
876 filtot[fil] += s->jobs_rets[i];
880 // find low / high based on histogram percentile
881 // these only need to be calculated once.
883 lowp = lrint(s->fs * 10 / 100.);
884 highp = lrint(s->fs * 90 / 100.);
885 clowp = lrint(s->cfs * 10 / 100.);
886 chighp = lrint(s->cfs * 90 / 100.);
888 accy = accu = accv = accsat = 0;
889 for (fil = 0; fil < s->maxsize; fil++) {
890 if (miny < 0 && histy[fil]) miny = fil;
891 if (minu < 0 && histu[fil]) minu = fil;
892 if (minv < 0 && histv[fil]) minv = fil;
893 if (minsat < 0 && histsat[fil]) minsat = fil;
895 if (histy[fil]) maxy = fil;
896 if (histu[fil]) maxu = fil;
897 if (histv[fil]) maxv = fil;
898 if (histsat[fil]) maxsat = fil;
900 toty += histy[fil] * fil;
901 totu += histu[fil] * fil;
902 totv += histv[fil] * fil;
903 totsat += histsat[fil] * fil;
908 accsat += histsat[fil];
910 if (lowy == -1 && accy >= lowp) lowy = fil;
911 if (lowu == -1 && accu >= clowp) lowu = fil;
912 if (lowv == -1 && accv >= clowp) lowv = fil;
913 if (lowsat == -1 && accsat >= clowp) lowsat = fil;
915 if (highy == -1 && accy >= highp) highy = fil;
916 if (highu == -1 && accu >= chighp) highu = fil;
917 if (highv == -1 && accv >= chighp) highv = fil;
918 if (highsat == -1 && accsat >= chighp) highsat = fil;
923 for (fil = 0; fil < 360; fil++) {
924 tothue += histhue[fil] * fil;
925 acchue += histhue[fil];
927 if (medhue == -1 && acchue > s->cfs / 2)
929 if (histhue[fil] > maxhue) {
930 maxhue = histhue[fil];
934 av_frame_free(&s->frame_prev);
935 s->frame_prev = av_frame_clone(in);
937 SET_META("YMIN", "%d", miny);
938 SET_META("YLOW", "%d", lowy);
939 SET_META("YAVG", "%g", 1.0 * toty / s->fs);
940 SET_META("YHIGH", "%d", highy);
941 SET_META("YMAX", "%d", maxy);
943 SET_META("UMIN", "%d", minu);
944 SET_META("ULOW", "%d", lowu);
945 SET_META("UAVG", "%g", 1.0 * totu / s->cfs);
946 SET_META("UHIGH", "%d", highu);
947 SET_META("UMAX", "%d", maxu);
949 SET_META("VMIN", "%d", minv);
950 SET_META("VLOW", "%d", lowv);
951 SET_META("VAVG", "%g", 1.0 * totv / s->cfs);
952 SET_META("VHIGH", "%d", highv);
953 SET_META("VMAX", "%d", maxv);
955 SET_META("SATMIN", "%d", minsat);
956 SET_META("SATLOW", "%d", lowsat);
957 SET_META("SATAVG", "%g", 1.0 * totsat / s->cfs);
958 SET_META("SATHIGH", "%d", highsat);
959 SET_META("SATMAX", "%d", maxsat);
961 SET_META("HUEMED", "%d", medhue);
962 SET_META("HUEAVG", "%g", 1.0 * tothue / s->cfs);
964 SET_META("YDIF", "%g", 1.0 * dify / s->fs);
965 SET_META("UDIF", "%g", 1.0 * difu / s->cfs);
966 SET_META("VDIF", "%g", 1.0 * difv / s->cfs);
968 SET_META("YBITDEPTH", "%d", compute_bit_depth(masky));
969 SET_META("UBITDEPTH", "%d", compute_bit_depth(masku));
970 SET_META("VBITDEPTH", "%d", compute_bit_depth(maskv));
972 for (fil = 0; fil < FILT_NUMB; fil ++) {
973 if (s->filters & 1<<fil) {
975 snprintf(metabuf, sizeof(metabuf), "%g", 1.0 * filtot[fil] / s->fs);
976 snprintf(metaname, sizeof(metaname), "lavfi.signalstats.%s", filters_def[fil].name);
977 av_dict_set(&out->metadata, metaname, metabuf, 0);
983 return ff_filter_frame(outlink, out);
986 static int filter_frame(AVFilterLink *link, AVFrame *in)
988 AVFilterContext *ctx = link->dst;
989 SignalstatsContext *s = ctx->priv;
992 return filter_frame16(link, in);
994 return filter_frame8(link, in);
997 static const AVFilterPad signalstats_inputs[] = {
1000 .type = AVMEDIA_TYPE_VIDEO,
1001 .filter_frame = filter_frame,
1006 static const AVFilterPad signalstats_outputs[] = {
1009 .config_props = config_output,
1010 .type = AVMEDIA_TYPE_VIDEO,
1015 const AVFilter ff_vf_signalstats = {
1016 .name = "signalstats",
1017 .description = "Generate statistics from video analysis.",
1020 .query_formats = query_formats,
1021 .priv_size = sizeof(SignalstatsContext),
1022 .inputs = signalstats_inputs,
1023 .outputs = signalstats_outputs,
1024 .priv_class = &signalstats_class,
1025 .flags = AVFILTER_FLAG_SLICE_THREADS,