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/opt.h"
24 #include "libavutil/pixdesc.h"
37 int chromah; // height of chroma plane
38 int chromaw; // width of chroma plane
39 int hsub; // horizontal subsampling
40 int vsub; // vertical subsampling
41 int fs; // pixel count per frame
42 int cfs; // pixel count per frame of chroma planes
43 int outfilter; // FilterMode
46 uint8_t rgba_color[4];
55 typedef struct ThreadData {
60 typedef struct ThreadDataHueSatMetrics {
62 AVFrame *dst_sat, *dst_hue;
63 } ThreadDataHueSatMetrics;
65 #define OFFSET(x) offsetof(SignalstatsContext, x)
66 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
68 static const AVOption signalstats_options[] = {
69 {"stat", "set statistics filters", OFFSET(filters), AV_OPT_TYPE_FLAGS, {.i64=0}, 0, INT_MAX, FLAGS, "filters"},
70 {"tout", "analyze pixels for temporal outliers", 0, AV_OPT_TYPE_CONST, {.i64=1<<FILTER_TOUT}, 0, 0, FLAGS, "filters"},
71 {"vrep", "analyze video lines for vertical line repetition", 0, AV_OPT_TYPE_CONST, {.i64=1<<FILTER_VREP}, 0, 0, FLAGS, "filters"},
72 {"brng", "analyze for pixels outside of broadcast range", 0, AV_OPT_TYPE_CONST, {.i64=1<<FILTER_BRNG}, 0, 0, FLAGS, "filters"},
73 {"out", "set video filter", OFFSET(outfilter), AV_OPT_TYPE_INT, {.i64=FILTER_NONE}, -1, FILT_NUMB-1, FLAGS, "out"},
74 {"tout", "highlight pixels that depict temporal outliers", 0, AV_OPT_TYPE_CONST, {.i64=FILTER_TOUT}, 0, 0, FLAGS, "out"},
75 {"vrep", "highlight video lines that depict vertical line repetition", 0, AV_OPT_TYPE_CONST, {.i64=FILTER_VREP}, 0, 0, FLAGS, "out"},
76 {"brng", "highlight pixels that are outside of broadcast range", 0, AV_OPT_TYPE_CONST, {.i64=FILTER_BRNG}, 0, 0, FLAGS, "out"},
77 {"c", "set highlight color", OFFSET(rgba_color), AV_OPT_TYPE_COLOR, {.str="yellow"}, .flags=FLAGS},
78 {"color", "set highlight color", OFFSET(rgba_color), AV_OPT_TYPE_COLOR, {.str="yellow"}, .flags=FLAGS},
82 AVFILTER_DEFINE_CLASS(signalstats);
84 static av_cold int init(AVFilterContext *ctx)
87 SignalstatsContext *s = ctx->priv;
89 if (s->outfilter != FILTER_NONE)
90 s->filters |= 1 << s->outfilter;
95 s->yuv_color[0] = (( 66*r + 129*g + 25*b + (1<<7)) >> 8) + 16;
96 s->yuv_color[1] = ((-38*r + -74*g + 112*b + (1<<7)) >> 8) + 128;
97 s->yuv_color[2] = ((112*r + -94*g + -18*b + (1<<7)) >> 8) + 128;
101 static av_cold void uninit(AVFilterContext *ctx)
103 SignalstatsContext *s = ctx->priv;
104 av_frame_free(&s->frame_prev);
105 av_frame_free(&s->frame_sat);
106 av_frame_free(&s->frame_hue);
107 av_freep(&s->jobs_rets);
110 static int query_formats(AVFilterContext *ctx)
113 static const enum AVPixelFormat pix_fmts[] = {
114 AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV411P,
116 AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ411P,
121 AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
123 return AVERROR(ENOMEM);
124 return ff_set_common_formats(ctx, fmts_list);
127 static AVFrame *alloc_frame(enum AVPixelFormat pixfmt, int w, int h)
129 AVFrame *frame = av_frame_alloc();
133 frame->format = pixfmt;
137 if (av_frame_get_buffer(frame, 32) < 0) {
138 av_frame_free(&frame);
145 static int config_props(AVFilterLink *outlink)
147 AVFilterContext *ctx = outlink->src;
148 SignalstatsContext *s = ctx->priv;
149 AVFilterLink *inlink = outlink->src->inputs[0];
150 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(outlink->format);
151 s->hsub = desc->log2_chroma_w;
152 s->vsub = desc->log2_chroma_h;
154 outlink->w = inlink->w;
155 outlink->h = inlink->h;
157 s->chromaw = AV_CEIL_RSHIFT(inlink->w, s->hsub);
158 s->chromah = AV_CEIL_RSHIFT(inlink->h, s->vsub);
160 s->fs = inlink->w * inlink->h;
161 s->cfs = s->chromaw * s->chromah;
163 s->nb_jobs = FFMAX(1, FFMIN(inlink->h, ctx->graph->nb_threads));
164 s->jobs_rets = av_malloc_array(s->nb_jobs, sizeof(*s->jobs_rets));
166 return AVERROR(ENOMEM);
168 s->frame_sat = alloc_frame(AV_PIX_FMT_GRAY8, inlink->w, inlink->h);
169 s->frame_hue = alloc_frame(AV_PIX_FMT_GRAY16, inlink->w, inlink->h);
170 if (!s->frame_sat || !s->frame_hue)
171 return AVERROR(ENOMEM);
176 static void burn_frame(const SignalstatsContext *s, AVFrame *f, int x, int y)
178 const int chromax = x >> s->hsub;
179 const int chromay = y >> s->vsub;
180 f->data[0][y * f->linesize[0] + x] = s->yuv_color[0];
181 f->data[1][chromay * f->linesize[1] + chromax] = s->yuv_color[1];
182 f->data[2][chromay * f->linesize[2] + chromax] = s->yuv_color[2];
185 static int filter_brng(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
187 ThreadData *td = arg;
188 const SignalstatsContext *s = ctx->priv;
189 const AVFrame *in = td->in;
190 AVFrame *out = td->out;
191 const int w = in->width;
192 const int h = in->height;
193 const int slice_start = (h * jobnr ) / nb_jobs;
194 const int slice_end = (h * (jobnr+1)) / nb_jobs;
197 for (y = slice_start; y < slice_end; y++) {
198 const int yc = y >> s->vsub;
199 const uint8_t *pluma = &in->data[0][y * in->linesize[0]];
200 const uint8_t *pchromau = &in->data[1][yc * in->linesize[1]];
201 const uint8_t *pchromav = &in->data[2][yc * in->linesize[2]];
203 for (x = 0; x < w; x++) {
204 const int xc = x >> s->hsub;
205 const int luma = pluma[x];
206 const int chromau = pchromau[xc];
207 const int chromav = pchromav[xc];
208 const int filt = luma < 16 || luma > 235 ||
209 chromau < 16 || chromau > 240 ||
210 chromav < 16 || chromav > 240;
213 burn_frame(s, out, x, y);
219 static int filter_tout_outlier(uint8_t x, uint8_t y, uint8_t z)
221 return ((abs(x - y) + abs (z - y)) / 2) - abs(z - x) > 4; // make 4 configurable?
224 static int filter_tout(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
226 ThreadData *td = arg;
227 const SignalstatsContext *s = ctx->priv;
228 const AVFrame *in = td->in;
229 AVFrame *out = td->out;
230 const int w = in->width;
231 const int h = in->height;
232 const int slice_start = (h * jobnr ) / nb_jobs;
233 const int slice_end = (h * (jobnr+1)) / nb_jobs;
234 const uint8_t *p = in->data[0];
235 int lw = in->linesize[0];
236 int x, y, score = 0, filt;
238 for (y = slice_start; y < slice_end; y++) {
240 if (y - 1 < 0 || y + 1 >= h)
243 // detect two pixels above and below (to eliminate interlace artefacts)
244 // should check that video format is infact interlaced.
246 #define FILTER(i, j) \
247 filter_tout_outlier(p[(y-j) * lw + x + i], \
248 p[ y * lw + x + i], \
249 p[(y+j) * lw + x + i])
251 #define FILTER3(j) (FILTER(-1, j) && FILTER(0, j) && FILTER(1, j))
253 if (y - 2 >= 0 && y + 2 < h) {
254 for (x = 1; x < w - 1; x++) {
255 filt = FILTER3(2) && FILTER3(1);
258 burn_frame(s, out, x, y);
261 for (x = 1; x < w - 1; x++) {
265 burn_frame(s, out, x, y);
274 static int filter_vrep(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
276 ThreadData *td = arg;
277 const SignalstatsContext *s = ctx->priv;
278 const AVFrame *in = td->in;
279 AVFrame *out = td->out;
280 const int w = in->width;
281 const int h = in->height;
282 const int slice_start = (h * jobnr ) / nb_jobs;
283 const int slice_end = (h * (jobnr+1)) / nb_jobs;
284 const uint8_t *p = in->data[0];
285 const int lw = in->linesize[0];
288 for (y = slice_start; y < slice_end; y++) {
289 const int y2lw = (y - VREP_START) * lw;
290 const int ylw = y * lw;
291 int filt, totdiff = 0;
296 for (x = 0; x < w; x++)
297 totdiff += abs(p[y2lw + x] - p[ylw + x]);
302 for (x = 0; x < w; x++)
303 burn_frame(s, out, x, y);
308 static const struct {
310 int (*process)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
312 {"TOUT", filter_tout},
313 {"VREP", filter_vrep},
314 {"BRNG", filter_brng},
320 static int compute_sat_hue_metrics(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
323 ThreadDataHueSatMetrics *td = arg;
324 const SignalstatsContext *s = ctx->priv;
325 const AVFrame *src = td->src;
326 AVFrame *dst_sat = td->dst_sat;
327 AVFrame *dst_hue = td->dst_hue;
329 const int slice_start = (s->chromah * jobnr ) / nb_jobs;
330 const int slice_end = (s->chromah * (jobnr+1)) / nb_jobs;
332 const int lsz_u = src->linesize[1];
333 const int lsz_v = src->linesize[2];
334 const uint8_t *p_u = src->data[1] + slice_start * lsz_u;
335 const uint8_t *p_v = src->data[2] + slice_start * lsz_v;
337 const int lsz_sat = dst_sat->linesize[0];
338 const int lsz_hue = dst_hue->linesize[0];
339 uint8_t *p_sat = dst_sat->data[0] + slice_start * lsz_sat;
340 uint8_t *p_hue = dst_hue->data[0] + slice_start * lsz_hue;
342 for (j = slice_start; j < slice_end; j++) {
343 for (i = 0; i < s->chromaw; i++) {
344 const int yuvu = p_u[i];
345 const int yuvv = p_v[i];
346 p_sat[i] = hypot(yuvu - 128, yuvv - 128); // int or round?
347 ((int16_t*)p_hue)[i] = floor((180 / M_PI) * atan2f(yuvu-128, yuvv-128) + 180);
358 static int filter_frame(AVFilterLink *link, AVFrame *in)
360 AVFilterContext *ctx = link->dst;
361 SignalstatsContext *s = ctx->priv;
362 AVFilterLink *outlink = ctx->outputs[0];
365 int w = 0, cw = 0, // in
366 pw = 0, cpw = 0; // prev
369 unsigned int histy[DEPTH] = {0},
373 histsat[DEPTH] = {0}; // limited to 8 bit data.
374 int miny = -1, minu = -1, minv = -1;
375 int maxy = -1, maxu = -1, maxv = -1;
376 int lowy = -1, lowu = -1, lowv = -1;
377 int highy = -1, highu = -1, highv = -1;
378 int minsat = -1, maxsat = -1, lowsat = -1, highsat = -1;
379 int lowp, highp, clowp, chighp;
380 int accy, accu, accv;
381 int accsat, acchue = 0;
383 int toty = 0, totu = 0, totv = 0, totsat=0;
385 int dify = 0, difu = 0, difv = 0;
387 int filtot[FILT_NUMB] = {0};
390 AVFrame *sat = s->frame_sat;
391 AVFrame *hue = s->frame_hue;
392 const uint8_t *p_sat = sat->data[0];
393 const uint8_t *p_hue = hue->data[0];
394 const int lsz_sat = sat->linesize[0];
395 const int lsz_hue = hue->linesize[0];
396 ThreadDataHueSatMetrics td_huesat = {
403 s->frame_prev = av_frame_clone(in);
405 prev = s->frame_prev;
407 if (s->outfilter != FILTER_NONE) {
408 out = av_frame_clone(in);
409 av_frame_make_writable(out);
412 ctx->internal->execute(ctx, compute_sat_hue_metrics, &td_huesat,
413 NULL, FFMIN(s->chromah, ctx->graph->nb_threads));
415 // Calculate luma histogram and difference with previous frame or field.
416 for (j = 0; j < link->h; j++) {
417 for (i = 0; i < link->w; i++) {
418 const int yuv = in->data[0][w + i];
420 dify += abs(yuv - prev->data[0][pw + i]);
422 w += in->linesize[0];
423 pw += prev->linesize[0];
426 // Calculate chroma histogram and difference with previous frame or field.
427 for (j = 0; j < s->chromah; j++) {
428 for (i = 0; i < s->chromaw; i++) {
429 const int yuvu = in->data[1][cw+i];
430 const int yuvv = in->data[2][cw+i];
432 difu += abs(yuvu - prev->data[1][cpw+i]);
434 difv += abs(yuvv - prev->data[2][cpw+i]);
437 histhue[((int16_t*)p_hue)[i]]++;
439 cw += in->linesize[1];
440 cpw += prev->linesize[1];
445 for (fil = 0; fil < FILT_NUMB; fil ++) {
446 if (s->filters & 1<<fil) {
449 .out = out != in && s->outfilter == fil ? out : NULL,
451 memset(s->jobs_rets, 0, s->nb_jobs * sizeof(*s->jobs_rets));
452 ctx->internal->execute(ctx, filters_def[fil].process,
453 &td, s->jobs_rets, s->nb_jobs);
454 for (i = 0; i < s->nb_jobs; i++)
455 filtot[fil] += s->jobs_rets[i];
459 // find low / high based on histogram percentile
460 // these only need to be calculated once.
462 lowp = lrint(s->fs * 10 / 100.);
463 highp = lrint(s->fs * 90 / 100.);
464 clowp = lrint(s->cfs * 10 / 100.);
465 chighp = lrint(s->cfs * 90 / 100.);
467 accy = accu = accv = accsat = 0;
468 for (fil = 0; fil < DEPTH; fil++) {
469 if (miny < 0 && histy[fil]) miny = fil;
470 if (minu < 0 && histu[fil]) minu = fil;
471 if (minv < 0 && histv[fil]) minv = fil;
472 if (minsat < 0 && histsat[fil]) minsat = fil;
474 if (histy[fil]) maxy = fil;
475 if (histu[fil]) maxu = fil;
476 if (histv[fil]) maxv = fil;
477 if (histsat[fil]) maxsat = fil;
479 toty += histy[fil] * fil;
480 totu += histu[fil] * fil;
481 totv += histv[fil] * fil;
482 totsat += histsat[fil] * fil;
487 accsat += histsat[fil];
489 if (lowy == -1 && accy >= lowp) lowy = fil;
490 if (lowu == -1 && accu >= clowp) lowu = fil;
491 if (lowv == -1 && accv >= clowp) lowv = fil;
492 if (lowsat == -1 && accsat >= clowp) lowsat = fil;
494 if (highy == -1 && accy >= highp) highy = fil;
495 if (highu == -1 && accu >= chighp) highu = fil;
496 if (highv == -1 && accv >= chighp) highv = fil;
497 if (highsat == -1 && accsat >= chighp) highsat = fil;
502 for (fil = 0; fil < 360; fil++) {
503 tothue += histhue[fil] * fil;
504 acchue += histhue[fil];
506 if (medhue == -1 && acchue > s->cfs / 2)
508 if (histhue[fil] > maxhue) {
509 maxhue = histhue[fil];
513 av_frame_free(&s->frame_prev);
514 s->frame_prev = av_frame_clone(in);
516 #define SET_META(key, fmt, val) do { \
517 snprintf(metabuf, sizeof(metabuf), fmt, val); \
518 av_dict_set(&out->metadata, "lavfi.signalstats." key, metabuf, 0); \
521 SET_META("YMIN", "%d", miny);
522 SET_META("YLOW", "%d", lowy);
523 SET_META("YAVG", "%g", 1.0 * toty / s->fs);
524 SET_META("YHIGH", "%d", highy);
525 SET_META("YMAX", "%d", maxy);
527 SET_META("UMIN", "%d", minu);
528 SET_META("ULOW", "%d", lowu);
529 SET_META("UAVG", "%g", 1.0 * totu / s->cfs);
530 SET_META("UHIGH", "%d", highu);
531 SET_META("UMAX", "%d", maxu);
533 SET_META("VMIN", "%d", minv);
534 SET_META("VLOW", "%d", lowv);
535 SET_META("VAVG", "%g", 1.0 * totv / s->cfs);
536 SET_META("VHIGH", "%d", highv);
537 SET_META("VMAX", "%d", maxv);
539 SET_META("SATMIN", "%d", minsat);
540 SET_META("SATLOW", "%d", lowsat);
541 SET_META("SATAVG", "%g", 1.0 * totsat / s->cfs);
542 SET_META("SATHIGH", "%d", highsat);
543 SET_META("SATMAX", "%d", maxsat);
545 SET_META("HUEMED", "%d", medhue);
546 SET_META("HUEAVG", "%g", 1.0 * tothue / s->cfs);
548 SET_META("YDIF", "%g", 1.0 * dify / s->fs);
549 SET_META("UDIF", "%g", 1.0 * difu / s->cfs);
550 SET_META("VDIF", "%g", 1.0 * difv / s->cfs);
552 for (fil = 0; fil < FILT_NUMB; fil ++) {
553 if (s->filters & 1<<fil) {
555 snprintf(metabuf, sizeof(metabuf), "%g", 1.0 * filtot[fil] / s->fs);
556 snprintf(metaname, sizeof(metaname), "lavfi.signalstats.%s", filters_def[fil].name);
557 av_dict_set(&out->metadata, metaname, metabuf, 0);
563 return ff_filter_frame(outlink, out);
566 static const AVFilterPad signalstats_inputs[] = {
569 .type = AVMEDIA_TYPE_VIDEO,
570 .filter_frame = filter_frame,
575 static const AVFilterPad signalstats_outputs[] = {
578 .config_props = config_props,
579 .type = AVMEDIA_TYPE_VIDEO,
584 AVFilter ff_vf_signalstats = {
585 .name = "signalstats",
586 .description = "Generate statistics from video analysis.",
589 .query_formats = query_formats,
590 .priv_size = sizeof(SignalstatsContext),
591 .inputs = signalstats_inputs,
592 .outputs = signalstats_outputs,
593 .priv_class = &signalstats_class,
594 .flags = AVFILTER_FLAG_SLICE_THREADS,