avfilter/vf_signalstats: add >8 bit depth support
[ffmpeg.git] / libavfilter / vf_signalstats.c
1 /*
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
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 #include "libavutil/intreadwrite.h"
24 #include "libavutil/opt.h"
25 #include "libavutil/pixdesc.h"
26 #include "internal.h"
27
28 enum FilterMode {
29     FILTER_NONE = -1,
30     FILTER_TOUT,
31     FILTER_VREP,
32     FILTER_BRNG,
33     FILT_NUMB
34 };
35
36 typedef struct {
37     const AVClass *class;
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
46     int filters;
47     AVFrame *frame_prev;
48     uint8_t rgba_color[4];
49     int yuv_color[3];
50     int nb_jobs;
51     int *jobs_rets;
52
53     int *histy, *histu, *histv, *histsat;
54
55     AVFrame *frame_sat;
56     AVFrame *frame_hue;
57 } SignalstatsContext;
58
59 typedef struct ThreadData {
60     const AVFrame *in;
61     AVFrame *out;
62 } ThreadData;
63
64 typedef struct ThreadDataHueSatMetrics {
65     const AVFrame *src;
66     AVFrame *dst_sat, *dst_hue;
67 } ThreadDataHueSatMetrics;
68
69 #define OFFSET(x) offsetof(SignalstatsContext, x)
70 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
71
72 static const AVOption signalstats_options[] = {
73     {"stat", "set statistics filters", OFFSET(filters), AV_OPT_TYPE_FLAGS, {.i64=0}, 0, INT_MAX, FLAGS, "filters"},
74         {"tout", "analyze pixels for temporal outliers",                0, AV_OPT_TYPE_CONST, {.i64=1<<FILTER_TOUT}, 0, 0, FLAGS, "filters"},
75         {"vrep", "analyze video lines for vertical line repetition",    0, AV_OPT_TYPE_CONST, {.i64=1<<FILTER_VREP}, 0, 0, FLAGS, "filters"},
76         {"brng", "analyze for pixels outside of broadcast range",       0, AV_OPT_TYPE_CONST, {.i64=1<<FILTER_BRNG}, 0, 0, FLAGS, "filters"},
77     {"out", "set video filter", OFFSET(outfilter), AV_OPT_TYPE_INT, {.i64=FILTER_NONE}, -1, FILT_NUMB-1, FLAGS, "out"},
78         {"tout", "highlight pixels that depict temporal outliers",              0, AV_OPT_TYPE_CONST, {.i64=FILTER_TOUT}, 0, 0, FLAGS, "out"},
79         {"vrep", "highlight video lines that depict vertical line repetition",  0, AV_OPT_TYPE_CONST, {.i64=FILTER_VREP}, 0, 0, FLAGS, "out"},
80         {"brng", "highlight pixels that are outside of broadcast range",        0, AV_OPT_TYPE_CONST, {.i64=FILTER_BRNG}, 0, 0, FLAGS, "out"},
81     {"c",     "set highlight color", OFFSET(rgba_color), AV_OPT_TYPE_COLOR, {.str="yellow"}, .flags=FLAGS},
82     {"color", "set highlight color", OFFSET(rgba_color), AV_OPT_TYPE_COLOR, {.str="yellow"}, .flags=FLAGS},
83     {NULL}
84 };
85
86 AVFILTER_DEFINE_CLASS(signalstats);
87
88 static av_cold int init(AVFilterContext *ctx)
89 {
90     uint8_t r, g, b;
91     SignalstatsContext *s = ctx->priv;
92
93     if (s->outfilter != FILTER_NONE)
94         s->filters |= 1 << s->outfilter;
95
96     r = s->rgba_color[0];
97     g = s->rgba_color[1];
98     b = s->rgba_color[2];
99     s->yuv_color[0] = (( 66*r + 129*g +  25*b + (1<<7)) >> 8) +  16;
100     s->yuv_color[1] = ((-38*r + -74*g + 112*b + (1<<7)) >> 8) + 128;
101     s->yuv_color[2] = ((112*r + -94*g + -18*b + (1<<7)) >> 8) + 128;
102     return 0;
103 }
104
105 static av_cold void uninit(AVFilterContext *ctx)
106 {
107     SignalstatsContext *s = ctx->priv;
108     av_frame_free(&s->frame_prev);
109     av_frame_free(&s->frame_sat);
110     av_frame_free(&s->frame_hue);
111     av_freep(&s->jobs_rets);
112     av_freep(&s->histy);
113     av_freep(&s->histu);
114     av_freep(&s->histv);
115     av_freep(&s->histsat);
116 }
117
118 static int query_formats(AVFilterContext *ctx)
119 {
120     // TODO: add more
121     static const enum AVPixelFormat pix_fmts[] = {
122         AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV411P,
123         AV_PIX_FMT_YUV440P,
124         AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ411P,
125         AV_PIX_FMT_YUVJ440P,
126         AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV420P9,
127         AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV420P10,
128         AV_PIX_FMT_YUV440P10,
129         AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV420P12,
130         AV_PIX_FMT_YUV440P12,
131         AV_PIX_FMT_YUV444P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV420P14,
132         AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV420P16,
133         AV_PIX_FMT_NONE
134     };
135
136     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
137     if (!fmts_list)
138         return AVERROR(ENOMEM);
139     return ff_set_common_formats(ctx, fmts_list);
140 }
141
142 static AVFrame *alloc_frame(enum AVPixelFormat pixfmt, int w, int h)
143 {
144     AVFrame *frame = av_frame_alloc();
145     if (!frame)
146         return NULL;
147
148     frame->format = pixfmt;
149     frame->width  = w;
150     frame->height = h;
151
152     if (av_frame_get_buffer(frame, 32) < 0) {
153         av_frame_free(&frame);
154         return NULL;
155     }
156
157     return frame;
158 }
159
160 static int config_props(AVFilterLink *outlink)
161 {
162     AVFilterContext *ctx = outlink->src;
163     SignalstatsContext *s = ctx->priv;
164     AVFilterLink *inlink = outlink->src->inputs[0];
165     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(outlink->format);
166     s->hsub = desc->log2_chroma_w;
167     s->vsub = desc->log2_chroma_h;
168     s->depth = desc->comp[0].depth;
169     if (s->depth > 8) {
170         s->histy = av_malloc_array(1 << s->depth, sizeof(*s->histy));
171         s->histu = av_malloc_array(1 << s->depth, sizeof(*s->histu));
172         s->histv = av_malloc_array(1 << s->depth, sizeof(*s->histv));
173         s->histsat = av_malloc_array(1 << s->depth, sizeof(*s->histsat));
174
175         if (!s->histy || !s->histu || !s->histv || !s->histsat)
176             return AVERROR(ENOMEM);
177     }
178
179     outlink->w = inlink->w;
180     outlink->h = inlink->h;
181
182     s->chromaw = AV_CEIL_RSHIFT(inlink->w, s->hsub);
183     s->chromah = AV_CEIL_RSHIFT(inlink->h, s->vsub);
184
185     s->fs = inlink->w * inlink->h;
186     s->cfs = s->chromaw * s->chromah;
187
188     s->nb_jobs   = FFMAX(1, FFMIN(inlink->h, ctx->graph->nb_threads));
189     s->jobs_rets = av_malloc_array(s->nb_jobs, sizeof(*s->jobs_rets));
190     if (!s->jobs_rets)
191         return AVERROR(ENOMEM);
192
193     s->frame_sat = alloc_frame(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);
197
198     return 0;
199 }
200
201 static void burn_frame8(const SignalstatsContext *s, AVFrame *f, int x, int y)
202 {
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];
208 }
209
210 static void burn_frame16(const SignalstatsContext *s, AVFrame *f, int x, int y)
211 {
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);
218 }
219
220 static int filter8_brng(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
221 {
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;
230     int x, y, score = 0;
231
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]];
237
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;
246             score += filt;
247             if (out && filt)
248                 burn_frame8(s, out, x, y);
249         }
250     }
251     return score;
252 }
253
254 static int filter16_brng(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
255 {
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;
265     int x, y, score = 0;
266
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]];
272
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;
281             score += filt;
282             if (out && filt)
283                 burn_frame16(s, out, x, y);
284         }
285     }
286     return score;
287 }
288
289 static int filter_tout_outlier(uint8_t x, uint8_t y, uint8_t z)
290 {
291     return ((abs(x - y) + abs (z - y)) / 2) - abs(z - x) > 4; // make 4 configurable?
292 }
293
294 static int filter8_tout(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
295 {
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;
307
308     for (y = slice_start; y < slice_end; y++) {
309
310         if (y - 1 < 0 || y + 1 >= h)
311             continue;
312
313         // detect two pixels above and below (to eliminate interlace artefacts)
314         // should check that video format is infact interlaced.
315
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])
320
321 #define FILTER3(j) (FILTER(-1, j) && FILTER(0, j) && FILTER(1, j))
322
323         if (y - 2 >= 0 && y + 2 < h) {
324             for (x = 1; x < w - 1; x++) {
325                 filt = FILTER3(2) && FILTER3(1);
326                 score += filt;
327                 if (filt && out)
328                     burn_frame8(s, out, x, y);
329             }
330         } else {
331             for (x = 1; x < w - 1; x++) {
332                 filt = FILTER3(1);
333                 score += filt;
334                 if (filt && out)
335                     burn_frame8(s, out, x, y);
336             }
337         }
338     }
339     return score;
340 }
341
342 static int filter16_tout(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
343 {
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;
355
356     for (y = slice_start; y < slice_end; y++) {
357
358         if (y - 1 < 0 || y + 1 >= h)
359             continue;
360
361         // detect two pixels above and below (to eliminate interlace artefacts)
362         // should check that video format is infact interlaced.
363
364         if (y - 2 >= 0 && y + 2 < h) {
365             for (x = 1; x < w - 1; x++) {
366                 filt = FILTER3(2) && FILTER3(1);
367                 score += filt;
368                 if (filt && out)
369                     burn_frame16(s, out, x, y);
370             }
371         } else {
372             for (x = 1; x < w - 1; x++) {
373                 filt = FILTER3(1);
374                 score += filt;
375                 if (filt && out)
376                     burn_frame16(s, out, x, y);
377             }
378         }
379     }
380     return score;
381 }
382
383 #define VREP_START 4
384
385 static int filter8_vrep(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
386 {
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];
397     int x, y, score = 0;
398
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;
403
404         if (y < VREP_START)
405             continue;
406
407         for (x = 0; x < w; x++)
408             totdiff += abs(p[y2lw + x] - p[ylw + x]);
409         filt = totdiff < w;
410
411         score += filt;
412         if (filt && out)
413             for (x = 0; x < w; x++)
414                 burn_frame8(s, out, x, y);
415     }
416     return score * w;
417 }
418
419 static int filter16_vrep(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
420 {
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;
431     int x, y, score = 0;
432
433     for (y = slice_start; y < slice_end; y++) {
434         const int y2lw = (y - VREP_START) * lw;
435         const int ylw  =  y               * lw;
436         int64_t totdiff = 0;
437         int filt;
438
439         if (y < VREP_START)
440             continue;
441
442         for (x = 0; x < w; x++)
443             totdiff += abs(p[y2lw + x] - p[ylw + x]);
444         filt = totdiff < w;
445
446         score += filt;
447         if (filt && out)
448             for (x = 0; x < w; x++)
449                 burn_frame16(s, out, x, y);
450     }
451     return score * w;
452 }
453
454 static const struct {
455     const char *name;
456     int (*process8)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
457     int (*process16)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
458 } filters_def[] = {
459     {"TOUT", filter8_tout, filter16_tout},
460     {"VREP", filter8_vrep, filter16_vrep},
461     {"BRNG", filter8_brng, filter16_brng},
462     {NULL}
463 };
464
465 #define DEPTH 256
466
467 static int compute_sat_hue_metrics8(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
468 {
469     int i, j;
470     ThreadDataHueSatMetrics *td = arg;
471     const SignalstatsContext *s = ctx->priv;
472     const AVFrame *src = td->src;
473     AVFrame *dst_sat = td->dst_sat;
474     AVFrame *dst_hue = td->dst_hue;
475
476     const int slice_start = (s->chromah *  jobnr   ) / nb_jobs;
477     const int slice_end   = (s->chromah * (jobnr+1)) / nb_jobs;
478
479     const int lsz_u = src->linesize[1];
480     const int lsz_v = src->linesize[2];
481     const uint8_t *p_u = src->data[1] + slice_start * lsz_u;
482     const uint8_t *p_v = src->data[2] + slice_start * lsz_v;
483
484     const int lsz_sat = dst_sat->linesize[0];
485     const int lsz_hue = dst_hue->linesize[0];
486     uint8_t *p_sat = dst_sat->data[0] + slice_start * lsz_sat;
487     uint8_t *p_hue = dst_hue->data[0] + slice_start * lsz_hue;
488
489     for (j = slice_start; j < slice_end; j++) {
490         for (i = 0; i < s->chromaw; i++) {
491             const int yuvu = p_u[i];
492             const int yuvv = p_v[i];
493             p_sat[i] = hypot(yuvu - 128, yuvv - 128); // int or round?
494             ((int16_t*)p_hue)[i] = floor((180 / M_PI) * atan2f(yuvu-128, yuvv-128) + 180);
495         }
496         p_u   += lsz_u;
497         p_v   += lsz_v;
498         p_sat += lsz_sat;
499         p_hue += lsz_hue;
500     }
501
502     return 0;
503 }
504
505 static int compute_sat_hue_metrics16(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
506 {
507     int i, j;
508     ThreadDataHueSatMetrics *td = arg;
509     const SignalstatsContext *s = ctx->priv;
510     const AVFrame *src = td->src;
511     AVFrame *dst_sat = td->dst_sat;
512     AVFrame *dst_hue = td->dst_hue;
513     const int mid = 1 << (s->depth - 1);
514
515     const int slice_start = (s->chromah *  jobnr   ) / nb_jobs;
516     const int slice_end   = (s->chromah * (jobnr+1)) / nb_jobs;
517
518     const int lsz_u = src->linesize[1] / 2;
519     const int lsz_v = src->linesize[2] / 2;
520     const uint16_t *p_u = (uint16_t*)src->data[1] + slice_start * lsz_u;
521     const uint16_t *p_v = (uint16_t*)src->data[2] + slice_start * lsz_v;
522
523     const int lsz_sat = dst_sat->linesize[0] / 2;
524     const int lsz_hue = dst_hue->linesize[0] / 2;
525     uint16_t *p_sat = (uint16_t*)dst_sat->data[0] + slice_start * lsz_sat;
526     uint16_t *p_hue = (uint16_t*)dst_hue->data[0] + slice_start * lsz_hue;
527
528     for (j = slice_start; j < slice_end; j++) {
529         for (i = 0; i < s->chromaw; i++) {
530             const int yuvu = p_u[i];
531             const int yuvv = p_v[i];
532             p_sat[i] = hypot(yuvu - mid, yuvv - mid); // int or round?
533             ((int16_t*)p_hue)[i] = floor((180 / M_PI) * atan2f(yuvu-mid, yuvv-mid) + 180);
534         }
535         p_u   += lsz_u;
536         p_v   += lsz_v;
537         p_sat += lsz_sat;
538         p_hue += lsz_hue;
539     }
540
541     return 0;
542 }
543
544 static int filter_frame8(AVFilterLink *link, AVFrame *in)
545 {
546     AVFilterContext *ctx = link->dst;
547     SignalstatsContext *s = ctx->priv;
548     AVFilterLink *outlink = ctx->outputs[0];
549     AVFrame *out = in;
550     int i, j;
551     int  w = 0,  cw = 0, // in
552         pw = 0, cpw = 0; // prev
553     int fil;
554     char metabuf[128];
555     unsigned int histy[DEPTH] = {0},
556                  histu[DEPTH] = {0},
557                  histv[DEPTH] = {0},
558                  histhue[360] = {0},
559                  histsat[DEPTH] = {0}; // limited to 8 bit data.
560     int miny  = -1, minu  = -1, minv  = -1;
561     int maxy  = -1, maxu  = -1, maxv  = -1;
562     int lowy  = -1, lowu  = -1, lowv  = -1;
563     int highy = -1, highu = -1, highv = -1;
564     int minsat = -1, maxsat = -1, lowsat = -1, highsat = -1;
565     int lowp, highp, clowp, chighp;
566     int accy, accu, accv;
567     int accsat, acchue = 0;
568     int medhue, maxhue;
569     int toty = 0, totu = 0, totv = 0, totsat=0;
570     int tothue = 0;
571     int dify = 0, difu = 0, difv = 0;
572
573     int filtot[FILT_NUMB] = {0};
574     AVFrame *prev;
575
576     AVFrame *sat = s->frame_sat;
577     AVFrame *hue = s->frame_hue;
578     const uint8_t *p_sat = sat->data[0];
579     const uint8_t *p_hue = hue->data[0];
580     const int lsz_sat = sat->linesize[0];
581     const int lsz_hue = hue->linesize[0];
582     ThreadDataHueSatMetrics td_huesat = {
583         .src     = in,
584         .dst_sat = sat,
585         .dst_hue = hue,
586     };
587
588     if (!s->frame_prev)
589         s->frame_prev = av_frame_clone(in);
590
591     prev = s->frame_prev;
592
593     if (s->outfilter != FILTER_NONE) {
594         out = av_frame_clone(in);
595         av_frame_make_writable(out);
596     }
597
598     ctx->internal->execute(ctx, compute_sat_hue_metrics8, &td_huesat,
599                            NULL, FFMIN(s->chromah, ctx->graph->nb_threads));
600
601     // Calculate luma histogram and difference with previous frame or field.
602     for (j = 0; j < link->h; j++) {
603         for (i = 0; i < link->w; i++) {
604             const int yuv = in->data[0][w + i];
605             histy[yuv]++;
606             dify += abs(yuv - prev->data[0][pw + i]);
607         }
608         w  += in->linesize[0];
609         pw += prev->linesize[0];
610     }
611
612     // Calculate chroma histogram and difference with previous frame or field.
613     for (j = 0; j < s->chromah; j++) {
614         for (i = 0; i < s->chromaw; i++) {
615             const int yuvu = in->data[1][cw+i];
616             const int yuvv = in->data[2][cw+i];
617             histu[yuvu]++;
618             difu += abs(yuvu - prev->data[1][cpw+i]);
619             histv[yuvv]++;
620             difv += abs(yuvv - prev->data[2][cpw+i]);
621
622             histsat[p_sat[i]]++;
623             histhue[((int16_t*)p_hue)[i]]++;
624         }
625         cw  += in->linesize[1];
626         cpw += prev->linesize[1];
627         p_sat += lsz_sat;
628         p_hue += lsz_hue;
629     }
630
631     for (fil = 0; fil < FILT_NUMB; fil ++) {
632         if (s->filters & 1<<fil) {
633             ThreadData td = {
634                 .in = in,
635                 .out = out != in && s->outfilter == fil ? out : NULL,
636             };
637             memset(s->jobs_rets, 0, s->nb_jobs * sizeof(*s->jobs_rets));
638             ctx->internal->execute(ctx, filters_def[fil].process8,
639                                    &td, s->jobs_rets, s->nb_jobs);
640             for (i = 0; i < s->nb_jobs; i++)
641                 filtot[fil] += s->jobs_rets[i];
642         }
643     }
644
645     // find low / high based on histogram percentile
646     // these only need to be calculated once.
647
648     lowp   = lrint(s->fs  * 10 / 100.);
649     highp  = lrint(s->fs  * 90 / 100.);
650     clowp  = lrint(s->cfs * 10 / 100.);
651     chighp = lrint(s->cfs * 90 / 100.);
652
653     accy = accu = accv = accsat = 0;
654     for (fil = 0; fil < DEPTH; fil++) {
655         if (miny   < 0 && histy[fil])   miny = fil;
656         if (minu   < 0 && histu[fil])   minu = fil;
657         if (minv   < 0 && histv[fil])   minv = fil;
658         if (minsat < 0 && histsat[fil]) minsat = fil;
659
660         if (histy[fil])   maxy   = fil;
661         if (histu[fil])   maxu   = fil;
662         if (histv[fil])   maxv   = fil;
663         if (histsat[fil]) maxsat = fil;
664
665         toty   += histy[fil]   * fil;
666         totu   += histu[fil]   * fil;
667         totv   += histv[fil]   * fil;
668         totsat += histsat[fil] * fil;
669
670         accy   += histy[fil];
671         accu   += histu[fil];
672         accv   += histv[fil];
673         accsat += histsat[fil];
674
675         if (lowy   == -1 && accy   >=  lowp) lowy   = fil;
676         if (lowu   == -1 && accu   >= clowp) lowu   = fil;
677         if (lowv   == -1 && accv   >= clowp) lowv   = fil;
678         if (lowsat == -1 && accsat >= clowp) lowsat = fil;
679
680         if (highy   == -1 && accy   >=  highp) highy   = fil;
681         if (highu   == -1 && accu   >= chighp) highu   = fil;
682         if (highv   == -1 && accv   >= chighp) highv   = fil;
683         if (highsat == -1 && accsat >= chighp) highsat = fil;
684     }
685
686     maxhue = histhue[0];
687     medhue = -1;
688     for (fil = 0; fil < 360; fil++) {
689         tothue += histhue[fil] * fil;
690         acchue += histhue[fil];
691
692         if (medhue == -1 && acchue > s->cfs / 2)
693             medhue = fil;
694         if (histhue[fil] > maxhue) {
695             maxhue = histhue[fil];
696         }
697     }
698
699     av_frame_free(&s->frame_prev);
700     s->frame_prev = av_frame_clone(in);
701
702 #define SET_META(key, fmt, val) do {                                \
703     snprintf(metabuf, sizeof(metabuf), fmt, val);                   \
704     av_dict_set(&out->metadata, "lavfi.signalstats." key, metabuf, 0);   \
705 } while (0)
706
707     SET_META("YMIN",    "%d", miny);
708     SET_META("YLOW",    "%d", lowy);
709     SET_META("YAVG",    "%g", 1.0 * toty / s->fs);
710     SET_META("YHIGH",   "%d", highy);
711     SET_META("YMAX",    "%d", maxy);
712
713     SET_META("UMIN",    "%d", minu);
714     SET_META("ULOW",    "%d", lowu);
715     SET_META("UAVG",    "%g", 1.0 * totu / s->cfs);
716     SET_META("UHIGH",   "%d", highu);
717     SET_META("UMAX",    "%d", maxu);
718
719     SET_META("VMIN",    "%d", minv);
720     SET_META("VLOW",    "%d", lowv);
721     SET_META("VAVG",    "%g", 1.0 * totv / s->cfs);
722     SET_META("VHIGH",   "%d", highv);
723     SET_META("VMAX",    "%d", maxv);
724
725     SET_META("SATMIN",  "%d", minsat);
726     SET_META("SATLOW",  "%d", lowsat);
727     SET_META("SATAVG",  "%g", 1.0 * totsat / s->cfs);
728     SET_META("SATHIGH", "%d", highsat);
729     SET_META("SATMAX",  "%d", maxsat);
730
731     SET_META("HUEMED",  "%d", medhue);
732     SET_META("HUEAVG",  "%g", 1.0 * tothue / s->cfs);
733
734     SET_META("YDIF",    "%g", 1.0 * dify / s->fs);
735     SET_META("UDIF",    "%g", 1.0 * difu / s->cfs);
736     SET_META("VDIF",    "%g", 1.0 * difv / s->cfs);
737
738     for (fil = 0; fil < FILT_NUMB; fil ++) {
739         if (s->filters & 1<<fil) {
740             char metaname[128];
741             snprintf(metabuf,  sizeof(metabuf),  "%g", 1.0 * filtot[fil] / s->fs);
742             snprintf(metaname, sizeof(metaname), "lavfi.signalstats.%s", filters_def[fil].name);
743             av_dict_set(&out->metadata, metaname, metabuf, 0);
744         }
745     }
746
747     if (in != out)
748         av_frame_free(&in);
749     return ff_filter_frame(outlink, out);
750 }
751
752 static int filter_frame16(AVFilterLink *link, AVFrame *in)
753 {
754     AVFilterContext *ctx = link->dst;
755     SignalstatsContext *s = ctx->priv;
756     AVFilterLink *outlink = ctx->outputs[0];
757     AVFrame *out = in;
758     int i, j;
759     int  w = 0,  cw = 0, // in
760         pw = 0, cpw = 0; // prev
761     int fil;
762     char metabuf[128];
763     unsigned int *histy = s->histy,
764                  *histu = s->histu,
765                  *histv = s->histv,
766                  histhue[360] = {0},
767                  *histsat = s->histsat;
768     int miny  = -1, minu  = -1, minv  = -1;
769     int maxy  = -1, maxu  = -1, maxv  = -1;
770     int lowy  = -1, lowu  = -1, lowv  = -1;
771     int highy = -1, highu = -1, highv = -1;
772     int minsat = -1, maxsat = -1, lowsat = -1, highsat = -1;
773     int lowp, highp, clowp, chighp;
774     int accy, accu, accv;
775     int accsat, acchue = 0;
776     int medhue, maxhue;
777     int64_t toty = 0, totu = 0, totv = 0, totsat=0;
778     int64_t tothue = 0;
779     int64_t dify = 0, difu = 0, difv = 0;
780
781     int filtot[FILT_NUMB] = {0};
782     AVFrame *prev;
783
784     AVFrame *sat = s->frame_sat;
785     AVFrame *hue = s->frame_hue;
786     const uint8_t *p_sat = sat->data[0];
787     const uint8_t *p_hue = hue->data[0];
788     const int lsz_sat = sat->linesize[0];
789     const int lsz_hue = hue->linesize[0];
790     ThreadDataHueSatMetrics td_huesat = {
791         .src     = in,
792         .dst_sat = sat,
793         .dst_hue = hue,
794     };
795
796     if (!s->frame_prev)
797         s->frame_prev = av_frame_clone(in);
798
799     prev = s->frame_prev;
800
801     if (s->outfilter != FILTER_NONE) {
802         out = av_frame_clone(in);
803         av_frame_make_writable(out);
804     }
805
806     ctx->internal->execute(ctx, compute_sat_hue_metrics16, &td_huesat,
807                            NULL, FFMIN(s->chromah, ctx->graph->nb_threads));
808
809     // Calculate luma histogram and difference with previous frame or field.
810     memset(s->histy, 0, (1 << s->depth) * sizeof(*s->histy));
811     for (j = 0; j < link->h; j++) {
812         for (i = 0; i < link->w; i++) {
813             const int yuv = AV_RN16(in->data[0] + w + i * 2);
814             histy[yuv]++;
815             dify += abs(yuv - AV_RN16(prev->data[0] + pw + i * 2));
816         }
817         w  += in->linesize[0];
818         pw += prev->linesize[0];
819     }
820
821     // Calculate chroma histogram and difference with previous frame or field.
822     memset(s->histu, 0, (1 << s->depth) * sizeof(*s->histu));
823     memset(s->histv, 0, (1 << s->depth) * sizeof(*s->histv));
824     memset(s->histsat, 0, (1 << s->depth) * sizeof(*s->histsat));
825     for (j = 0; j < s->chromah; j++) {
826         for (i = 0; i < s->chromaw; i++) {
827             const int yuvu = AV_RN16(in->data[1] + cw + i * 2);
828             const int yuvv = AV_RN16(in->data[2] + cw + i * 2);
829             histu[yuvu]++;
830             difu += abs(yuvu - AV_RN16(prev->data[1] + cpw + i * 2));
831             histv[yuvv]++;
832             difv += abs(yuvv - AV_RN16(prev->data[2] + cpw + i * 2));
833
834             histsat[p_sat[i]]++;
835             histhue[((int16_t*)p_hue)[i]]++;
836         }
837         cw  += in->linesize[1];
838         cpw += prev->linesize[1];
839         p_sat += lsz_sat;
840         p_hue += lsz_hue;
841     }
842
843     for (fil = 0; fil < FILT_NUMB; fil ++) {
844         if (s->filters & 1<<fil) {
845             ThreadData td = {
846                 .in = in,
847                 .out = out != in && s->outfilter == fil ? out : NULL,
848             };
849             memset(s->jobs_rets, 0, s->nb_jobs * sizeof(*s->jobs_rets));
850             ctx->internal->execute(ctx, filters_def[fil].process16,
851                                    &td, s->jobs_rets, s->nb_jobs);
852             for (i = 0; i < s->nb_jobs; i++)
853                 filtot[fil] += s->jobs_rets[i];
854         }
855     }
856
857     // find low / high based on histogram percentile
858     // these only need to be calculated once.
859
860     lowp   = lrint(s->fs  * 10 / 100.);
861     highp  = lrint(s->fs  * 90 / 100.);
862     clowp  = lrint(s->cfs * 10 / 100.);
863     chighp = lrint(s->cfs * 90 / 100.);
864
865     accy = accu = accv = accsat = 0;
866     for (fil = 0; fil < 1 << s->depth; fil++) {
867         if (miny   < 0 && histy[fil])   miny = fil;
868         if (minu   < 0 && histu[fil])   minu = fil;
869         if (minv   < 0 && histv[fil])   minv = fil;
870         if (minsat < 0 && histsat[fil]) minsat = fil;
871
872         if (histy[fil])   maxy   = fil;
873         if (histu[fil])   maxu   = fil;
874         if (histv[fil])   maxv   = fil;
875         if (histsat[fil]) maxsat = fil;
876
877         toty   += histy[fil]   * fil;
878         totu   += histu[fil]   * fil;
879         totv   += histv[fil]   * fil;
880         totsat += histsat[fil] * fil;
881
882         accy   += histy[fil];
883         accu   += histu[fil];
884         accv   += histv[fil];
885         accsat += histsat[fil];
886
887         if (lowy   == -1 && accy   >=  lowp) lowy   = fil;
888         if (lowu   == -1 && accu   >= clowp) lowu   = fil;
889         if (lowv   == -1 && accv   >= clowp) lowv   = fil;
890         if (lowsat == -1 && accsat >= clowp) lowsat = fil;
891
892         if (highy   == -1 && accy   >=  highp) highy   = fil;
893         if (highu   == -1 && accu   >= chighp) highu   = fil;
894         if (highv   == -1 && accv   >= chighp) highv   = fil;
895         if (highsat == -1 && accsat >= chighp) highsat = fil;
896     }
897
898     maxhue = histhue[0];
899     medhue = -1;
900     for (fil = 0; fil < 360; fil++) {
901         tothue += histhue[fil] * fil;
902         acchue += histhue[fil];
903
904         if (medhue == -1 && acchue > s->cfs / 2)
905             medhue = fil;
906         if (histhue[fil] > maxhue) {
907             maxhue = histhue[fil];
908         }
909     }
910
911     av_frame_free(&s->frame_prev);
912     s->frame_prev = av_frame_clone(in);
913
914     SET_META("YMIN",    "%d", miny);
915     SET_META("YLOW",    "%d", lowy);
916     SET_META("YAVG",    "%g", 1.0 * toty / s->fs);
917     SET_META("YHIGH",   "%d", highy);
918     SET_META("YMAX",    "%d", maxy);
919
920     SET_META("UMIN",    "%d", minu);
921     SET_META("ULOW",    "%d", lowu);
922     SET_META("UAVG",    "%g", 1.0 * totu / s->cfs);
923     SET_META("UHIGH",   "%d", highu);
924     SET_META("UMAX",    "%d", maxu);
925
926     SET_META("VMIN",    "%d", minv);
927     SET_META("VLOW",    "%d", lowv);
928     SET_META("VAVG",    "%g", 1.0 * totv / s->cfs);
929     SET_META("VHIGH",   "%d", highv);
930     SET_META("VMAX",    "%d", maxv);
931
932     SET_META("SATMIN",  "%d", minsat);
933     SET_META("SATLOW",  "%d", lowsat);
934     SET_META("SATAVG",  "%g", 1.0 * totsat / s->cfs);
935     SET_META("SATHIGH", "%d", highsat);
936     SET_META("SATMAX",  "%d", maxsat);
937
938     SET_META("HUEMED",  "%d", medhue);
939     SET_META("HUEAVG",  "%g", 1.0 * tothue / s->cfs);
940
941     SET_META("YDIF",    "%g", 1.0 * dify / s->fs);
942     SET_META("UDIF",    "%g", 1.0 * difu / s->cfs);
943     SET_META("VDIF",    "%g", 1.0 * difv / s->cfs);
944
945     for (fil = 0; fil < FILT_NUMB; fil ++) {
946         if (s->filters & 1<<fil) {
947             char metaname[128];
948             snprintf(metabuf,  sizeof(metabuf),  "%g", 1.0 * filtot[fil] / s->fs);
949             snprintf(metaname, sizeof(metaname), "lavfi.signalstats.%s", filters_def[fil].name);
950             av_dict_set(&out->metadata, metaname, metabuf, 0);
951         }
952     }
953
954     if (in != out)
955         av_frame_free(&in);
956     return ff_filter_frame(outlink, out);
957 }
958
959 static int filter_frame(AVFilterLink *link, AVFrame *in)
960 {
961     AVFilterContext *ctx = link->dst;
962     SignalstatsContext *s = ctx->priv;
963
964     if (s->depth > 8)
965         return filter_frame16(link, in);
966     else
967         return filter_frame8(link, in);
968 }
969
970 static const AVFilterPad signalstats_inputs[] = {
971     {
972         .name           = "default",
973         .type           = AVMEDIA_TYPE_VIDEO,
974         .filter_frame   = filter_frame,
975     },
976     { NULL }
977 };
978
979 static const AVFilterPad signalstats_outputs[] = {
980     {
981         .name           = "default",
982         .config_props   = config_props,
983         .type           = AVMEDIA_TYPE_VIDEO,
984     },
985     { NULL }
986 };
987
988 AVFilter ff_vf_signalstats = {
989     .name          = "signalstats",
990     .description   = "Generate statistics from video analysis.",
991     .init          = init,
992     .uninit        = uninit,
993     .query_formats = query_formats,
994     .priv_size     = sizeof(SignalstatsContext),
995     .inputs        = signalstats_inputs,
996     .outputs       = signalstats_outputs,
997     .priv_class    = &signalstats_class,
998     .flags         = AVFILTER_FLAG_SLICE_THREADS,
999 };