FFmpeg  4.4.4
vf_identity.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2021 Paul B Mahol
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 /**
22  * @file
23  * Caculate the Identity between two input videos.
24  */
25 
26 #include "libavutil/avstring.h"
27 #include "libavutil/opt.h"
28 #include "libavutil/pixdesc.h"
29 #include "avfilter.h"
30 #include "drawutils.h"
31 #include "formats.h"
32 #include "framesync.h"
33 #include "internal.h"
34 #include "video.h"
35 #include "scene_sad.h"
36 
37 typedef struct IdentityContext {
38  const AVClass *class;
41  uint64_t nb_frames;
42  int is_rgb;
43  int is_msad;
45  int max[4];
46  char comps[4];
49  int planewidth[4];
50  int planeheight[4];
51  uint64_t **scores;
52  unsigned (*filter_line)(const uint8_t *buf, const uint8_t *ref, int w);
54  int jobnr, int nb_jobs);
57 
58 #define OFFSET(x) offsetof(IdentityContext, x)
59 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
60 
61 static unsigned identity_line_8bit(const uint8_t *main_line, const uint8_t *ref_line, int outw)
62 {
63  unsigned score = 0;
64 
65  for (int j = 0; j < outw; j++)
66  score += main_line[j] == ref_line[j];
67 
68  return score;
69 }
70 
71 static unsigned identity_line_16bit(const uint8_t *mmain_line, const uint8_t *rref_line, int outw)
72 {
73  const uint16_t *main_line = (const uint16_t *)mmain_line;
74  const uint16_t *ref_line = (const uint16_t *)rref_line;
75  unsigned score = 0;
76 
77  for (int j = 0; j < outw; j++)
78  score += main_line[j] == ref_line[j];
79 
80  return score;
81 }
82 
83 typedef struct ThreadData {
84  const uint8_t *main_data[4];
85  const uint8_t *ref_data[4];
86  int main_linesize[4];
87  int ref_linesize[4];
88  int planewidth[4];
89  int planeheight[4];
90  uint64_t **score;
92 } ThreadData;
93 
94 static
96  int jobnr, int nb_jobs)
97 {
98  IdentityContext *s = ctx->priv;
99  ThreadData *td = arg;
100  uint64_t *score = td->score[jobnr];
101 
102  for (int c = 0; c < td->nb_components; c++) {
103  const int outw = td->planewidth[c];
104  const int outh = td->planeheight[c];
105  const int slice_start = (outh * jobnr) / nb_jobs;
106  const int slice_end = (outh * (jobnr+1)) / nb_jobs;
107  const int ref_linesize = td->ref_linesize[c];
108  const int main_linesize = td->main_linesize[c];
109  const uint8_t *main_line = td->main_data[c] + main_linesize * slice_start;
110  const uint8_t *ref_line = td->ref_data[c] + ref_linesize * slice_start;
111  uint64_t m = 0;
112 
113  s->sad(main_line, main_linesize, ref_line, ref_linesize,
114  outw, slice_end - slice_start, &m);
115 
116  score[c] = m;
117  }
118 
119  return 0;
120 }
121 
122 static
124  int jobnr, int nb_jobs)
125 {
126  IdentityContext *s = ctx->priv;
127  ThreadData *td = arg;
128  uint64_t *score = td->score[jobnr];
129 
130  for (int c = 0; c < td->nb_components; c++) {
131  const int outw = td->planewidth[c];
132  const int outh = td->planeheight[c];
133  const int slice_start = (outh * jobnr) / nb_jobs;
134  const int slice_end = (outh * (jobnr+1)) / nb_jobs;
135  const int ref_linesize = td->ref_linesize[c];
136  const int main_linesize = td->main_linesize[c];
137  const uint8_t *main_line = td->main_data[c] + main_linesize * slice_start;
138  const uint8_t *ref_line = td->ref_data[c] + ref_linesize * slice_start;
139  uint64_t m = 0;
140 
141  for (int i = slice_start; i < slice_end; i++) {
142  m += s->filter_line(main_line, ref_line, outw);
143  ref_line += ref_linesize;
144  main_line += main_linesize;
145  }
146  score[c] = m;
147  }
148 
149  return 0;
150 }
151 
153  AVDictionary **metadata, const char *key, char comp, float d)
154 {
155  char value[128];
156  snprintf(value, sizeof(value), "%f", d);
157  if (comp) {
158  char key2[128];
159  snprintf(key2, sizeof(key2), "lavfi.%s.%s%s%c",
160  ctx->filter->name, ctx->filter->name, key, comp);
161  av_dict_set(metadata, key2, value, 0);
162  } else {
163  char key2[128];
164  snprintf(key2, sizeof(key2), "lavfi.%s.%s%s",
165  ctx->filter->name, ctx->filter->name, key);
166  av_dict_set(metadata, key2, value, 0);
167  }
168 }
169 
171 {
172  AVFilterContext *ctx = fs->parent;
173  IdentityContext *s = ctx->priv;
174  AVFrame *master, *ref;
175  double comp_score[4], score = 0.;
176  uint64_t comp_sum[4] = { 0 };
177  AVDictionary **metadata;
178  ThreadData td;
179  int ret;
180 
182  if (ret < 0)
183  return ret;
184  if (ctx->is_disabled || !ref)
185  return ff_filter_frame(ctx->outputs[0], master);
186  metadata = &master->metadata;
187 
188  td.nb_components = s->nb_components;
189  td.score = s->scores;
190  for (int c = 0; c < s->nb_components; c++) {
191  td.main_data[c] = master->data[c];
192  td.ref_data[c] = ref->data[c];
193  td.main_linesize[c] = master->linesize[c];
194  td.ref_linesize[c] = ref->linesize[c];
195  td.planewidth[c] = s->planewidth[c];
196  td.planeheight[c] = s->planeheight[c];
197  }
198 
199  ctx->internal->execute(ctx, s->filter_slice, &td, NULL, FFMIN(s->planeheight[1], s->nb_threads));
200 
201  for (int j = 0; j < s->nb_threads; j++) {
202  for (int c = 0; c < s->nb_components; c++)
203  comp_sum[c] += s->scores[j][c];
204  }
205 
206  for (int c = 0; c < s->nb_components; c++)
207  comp_score[c] = comp_sum[c] / ((double)s->planewidth[c] * s->planeheight[c]);
208 
209  for (int c = 0; c < s->nb_components && s->is_msad; c++)
210  comp_score[c] /= (double)s->max[c];
211 
212  for (int c = 0; c < s->nb_components; c++)
213  score += comp_score[c];
214  score /= s->nb_components;
215 
216  s->min_score = FFMIN(s->min_score, score);
217  s->max_score = FFMAX(s->max_score, score);
218 
219  s->score += score;
220 
221  for (int j = 0; j < s->nb_components; j++)
222  s->score_comp[j] += comp_score[j];
223  s->nb_frames++;
224 
225  for (int j = 0; j < s->nb_components; j++) {
226  int c = s->is_rgb ? s->rgba_map[j] : j;
227  set_meta(ctx, metadata, ".", s->comps[j], comp_score[c]);
228  }
229  set_meta(ctx, metadata, "_avg", 0, score);
230 
231  return ff_filter_frame(ctx->outputs[0], master);
232 }
233 
235 {
236  IdentityContext *s = ctx->priv;
237 
238  s->fs.on_event = do_identity;
239 
240  return 0;
241 }
242 
244 {
245  static const enum AVPixelFormat pix_fmts[] = {
247 #define PF_NOALPHA(suf) AV_PIX_FMT_YUV420##suf, AV_PIX_FMT_YUV422##suf, AV_PIX_FMT_YUV444##suf
248 #define PF_ALPHA(suf) AV_PIX_FMT_YUVA420##suf, AV_PIX_FMT_YUVA422##suf, AV_PIX_FMT_YUVA444##suf
249 #define PF(suf) PF_NOALPHA(suf), PF_ALPHA(suf)
250  PF(P), PF(P9), PF(P10), PF_NOALPHA(P12), PF_NOALPHA(P14), PF(P16),
258  };
259 
261  if (!fmts_list)
262  return AVERROR(ENOMEM);
263  return ff_set_common_formats(ctx, fmts_list);
264 }
265 
266 static int config_input_ref(AVFilterLink *inlink)
267 {
269  AVFilterContext *ctx = inlink->dst;
270  IdentityContext *s = ctx->priv;
271 
272  s->nb_threads = ff_filter_get_nb_threads(ctx);
273  s->nb_components = desc->nb_components;
274  if (ctx->inputs[0]->w != ctx->inputs[1]->w ||
275  ctx->inputs[0]->h != ctx->inputs[1]->h) {
276  av_log(ctx, AV_LOG_ERROR, "Width and height of input videos must be same.\n");
277  return AVERROR(EINVAL);
278  }
279  if (ctx->inputs[0]->format != ctx->inputs[1]->format) {
280  av_log(ctx, AV_LOG_ERROR, "Inputs must be of same pixel format.\n");
281  return AVERROR(EINVAL);
282  }
283 
284  s->is_rgb = ff_fill_rgba_map(s->rgba_map, inlink->format) >= 0;
285  s->comps[0] = s->is_rgb ? 'R' : 'Y' ;
286  s->comps[1] = s->is_rgb ? 'G' : 'U' ;
287  s->comps[2] = s->is_rgb ? 'B' : 'V' ;
288  s->comps[3] = 'A';
289 
290  s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
291  s->planeheight[0] = s->planeheight[3] = inlink->h;
292  s->planewidth[1] = s->planewidth[2] = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
293  s->planewidth[0] = s->planewidth[3] = inlink->w;
294 
295  s->scores = av_calloc(s->nb_threads, sizeof(*s->scores));
296  if (!s->scores)
297  return AVERROR(ENOMEM);
298 
299  for (int t = 0; t < s->nb_threads && s->scores; t++) {
300  s->scores[t] = av_calloc(s->nb_components, sizeof(*s->scores[0]));
301  if (!s->scores[t])
302  return AVERROR(ENOMEM);
303  }
304 
305  s->min_score = +INFINITY;
306  s->max_score = -INFINITY;
307 
308  s->max[0] = (1 << desc->comp[0].depth) - 1;
309  s->max[1] = (1 << desc->comp[1].depth) - 1;
310  s->max[2] = (1 << desc->comp[2].depth) - 1;
311  s->max[3] = (1 << desc->comp[3].depth) - 1;
312 
313  s->is_msad = !strcmp(ctx->filter->name, "msad");
314  s->filter_slice = !s->is_msad ? compute_images_identity : compute_images_msad;
315  s->filter_line = desc->comp[0].depth > 8 ? identity_line_16bit : identity_line_8bit;
316 
317  s->sad = ff_scene_sad_get_fn(desc->comp[0].depth <= 8 ? 8 : 16);
318  if (!s->sad)
319  return AVERROR(EINVAL);
320 
321  return 0;
322 }
323 
324 static int config_output(AVFilterLink *outlink)
325 {
326  AVFilterContext *ctx = outlink->src;
327  IdentityContext *s = ctx->priv;
328  AVFilterLink *mainlink = ctx->inputs[0];
329  int ret;
330 
331  ret = ff_framesync_init_dualinput(&s->fs, ctx);
332  if (ret < 0)
333  return ret;
334  outlink->w = mainlink->w;
335  outlink->h = mainlink->h;
336  outlink->time_base = mainlink->time_base;
337  outlink->sample_aspect_ratio = mainlink->sample_aspect_ratio;
338  outlink->frame_rate = mainlink->frame_rate;
339  if ((ret = ff_framesync_configure(&s->fs)) < 0)
340  return ret;
341 
342  outlink->time_base = s->fs.time_base;
343 
344  if (av_cmp_q(mainlink->time_base, outlink->time_base) ||
345  av_cmp_q(ctx->inputs[1]->time_base, outlink->time_base))
346  av_log(ctx, AV_LOG_WARNING, "not matching timebases found between first input: %d/%d and second input %d/%d, results may be incorrect!\n",
347  mainlink->time_base.num, mainlink->time_base.den,
348  ctx->inputs[1]->time_base.num, ctx->inputs[1]->time_base.den);
349 
350  return 0;
351 }
352 
354 {
355  IdentityContext *s = ctx->priv;
356  return ff_framesync_activate(&s->fs);
357 }
358 
360 {
361  IdentityContext *s = ctx->priv;
362 
363  if (s->nb_frames > 0) {
364  char buf[256];
365 
366  buf[0] = 0;
367  for (int j = 0; j < s->nb_components; j++) {
368  int c = s->is_rgb ? s->rgba_map[j] : j;
369  av_strlcatf(buf, sizeof(buf), " %c:%f", s->comps[j], s->score_comp[c] / s->nb_frames);
370  }
371 
372  av_log(ctx, AV_LOG_INFO, "%s%s average:%f min:%f max:%f\n",
373  ctx->filter->name,
374  buf,
375  s->score / s->nb_frames,
376  s->min_score,
377  s->max_score);
378  }
379 
380  ff_framesync_uninit(&s->fs);
381  for (int t = 0; t < s->nb_threads && s->scores; t++)
382  av_freep(&s->scores[t]);
383  av_freep(&s->scores);
384 }
385 
386 static const AVFilterPad identity_inputs[] = {
387  {
388  .name = "main",
389  .type = AVMEDIA_TYPE_VIDEO,
390  },{
391  .name = "reference",
392  .type = AVMEDIA_TYPE_VIDEO,
393  .config_props = config_input_ref,
394  },
395  { NULL }
396 };
397 
398 static const AVFilterPad identity_outputs[] = {
399  {
400  .name = "default",
401  .type = AVMEDIA_TYPE_VIDEO,
402  .config_props = config_output,
403  },
404  { NULL }
405 };
406 
407 static const AVOption options[] = {
408  { NULL }
409 };
410 
411 #if CONFIG_IDENTITY_FILTER
412 
413 #define identity_options options
415 
417  .name = "identity",
418  .description = NULL_IF_CONFIG_SMALL("Calculate the Identity between two video streams."),
419  .preinit = identity_framesync_preinit,
420  .init = init,
421  .uninit = uninit,
422  .query_formats = query_formats,
423  .activate = activate,
424  .priv_size = sizeof(IdentityContext),
425  .priv_class = &identity_class,
429 };
430 
431 #endif /* CONFIG_IDENTITY_FILTER */
432 
433 #if CONFIG_MSAD_FILTER
434 
435 #define msad_options options
437 
439  .name = "msad",
440  .description = NULL_IF_CONFIG_SMALL("Calculate the MSAD between two video streams."),
441  .preinit = msad_framesync_preinit,
442  .init = init,
443  .uninit = uninit,
444  .query_formats = query_formats,
445  .activate = activate,
446  .priv_size = sizeof(IdentityContext),
447  .priv_class = &msad_class,
451 };
452 
453 #endif /* CONFIG_MSAD_FILTER */
static const AVFilterPad inputs[]
Definition: af_acontrast.c:193
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
AVFilter ff_vf_identity
AVFilter ff_vf_msad
#define av_cold
Definition: attributes.h:88
uint8_t
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1096
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:802
Main libavfilter public API header.
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
Definition: avstring.c:101
#define flags(name, subs,...)
Definition: cbs_av1.c:561
#define s(width, name)
Definition: cbs_vp9.c:257
#define fs(width, name, subs,...)
Definition: cbs_vp9.c:259
#define FFMIN(a, b)
Definition: common.h:105
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
#define FFMAX(a, b)
Definition: common.h:103
#define NULL
Definition: coverity.c:32
int ff_fill_rgba_map(uint8_t *rgba_map, enum AVPixelFormat pix_fmt)
Definition: drawutils.c:35
misc drawing utilities
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:85
double value
Definition: eval.c:98
int
int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
A helper for query_formats() which sets all links to the same list of formats.
Definition: formats.c:587
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:286
int ff_framesync_configure(FFFrameSync *fs)
Configure a frame sync structure.
Definition: framesync.c:124
int ff_framesync_dualinput_get(FFFrameSync *fs, AVFrame **f0, AVFrame **f1)
Definition: framesync.c:376
int ff_framesync_activate(FFFrameSync *fs)
Examine the frames in the filter's input and try to produce output.
Definition: framesync.c:341
int ff_framesync_init_dualinput(FFFrameSync *fs, AVFilterContext *parent)
Initialize a frame sync structure for dualinput.
Definition: framesync.c:358
void ff_framesync_uninit(FFFrameSync *fs)
Free all memory currently allocated.
Definition: framesync.c:290
#define FRAMESYNC_DEFINE_CLASS(name, context, field)
Definition: framesync.h:302
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition: avfilter.h:117
#define AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
Same as AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, except that the filter will have its filter_frame() c...
Definition: avfilter.h:134
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
#define AVERROR(e)
Definition: error.h:43
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:245
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
for(j=16;j >0;--j)
const char * key
int i
Definition: input.c:407
const char * arg
Definition: jacosubdec.c:66
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:309
const char * desc
Definition: libsvtav1.c:79
uint8_t w
Definition: llviddspenc.c:39
#define INFINITY
Definition: mathematics.h:67
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2033
#define P
AVOptions.
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:420
#define AV_PIX_FMT_GRAY9
Definition: pixfmt.h:379
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:421
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:414
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:415
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:381
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:416
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:99
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
@ AV_PIX_FMT_YUVJ440P
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range
Definition: pixfmt.h:100
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:72
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:73
@ AV_PIX_FMT_YUVJ411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...
Definition: pixfmt.h:258
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:215
@ AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
Definition: pixfmt.h:79
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:168
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:80
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:78
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:380
#define AV_PIX_FMT_GRAY14
Definition: pixfmt.h:382
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:383
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:419
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:418
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:417
#define td
Definition: regdef.h:70
ff_scene_sad_fn ff_scene_sad_get_fn(int depth)
Definition: scene_sad.c:59
Scene SAD functions.
void(* ff_scene_sad_fn)(SCENE_SAD_PARAMS)
Definition: scene_sad.h:34
#define snprintf
Definition: snprintf.h:34
Describe the class of an AVClass context structure.
Definition: log.h:67
An instance of a filter.
Definition: avfilter.h:341
A list of supported formats for one end of a filter link.
Definition: formats.h:65
A filter pad used for either input or output.
Definition: internal.h:54
const char * name
Pad name.
Definition: internal.h:60
Filter definition.
Definition: avfilter.h:145
const char * name
Filter name.
Definition: avfilter.h:149
AVFormatInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1699
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
AVOption.
Definition: opt.h:248
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
int num
Numerator.
Definition: rational.h:59
int den
Denominator.
Definition: rational.h:60
Frame sync structure.
Definition: framesync.h:146
unsigned(* filter_line)(const uint8_t *buf, const uint8_t *ref, int w)
Definition: vf_identity.c:52
double min_score
Definition: vf_identity.c:40
ff_scene_sad_fn sad
Definition: vf_identity.c:55
uint64_t ** scores
Definition: vf_identity.c:51
int(* filter_slice)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_identity.c:53
double score_comp[4]
Definition: vf_identity.c:40
FFFrameSync fs
Definition: vf_identity.c:39
int planeheight[4]
Definition: vf_identity.c:50
double max_score
Definition: vf_identity.c:40
uint8_t rgba_map[4]
Definition: vf_identity.c:44
uint64_t nb_frames
Definition: vf_identity.c:41
int planewidth[4]
Definition: vf_identity.c:49
Used for passing data between threads.
Definition: dsddec.c:67
int nb_components
Definition: vf_identity.c:91
int planeheight[4]
Definition: vf_identity.c:89
uint64_t ** score
Definition: vf_identity.c:90
const uint8_t * ref_data[4]
Definition: vf_identity.c:85
int main_linesize[4]
Definition: vf_identity.c:86
int planewidth[4]
Definition: vf_identity.c:88
const uint8_t * main_data[4]
Definition: vf_identity.c:84
int ref_linesize
Definition: vf_bm3d.c:59
#define av_freep(p)
#define av_log(a,...)
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
AVFormatContext * ctx
Definition: movenc.c:48
const char * master
Definition: vf_curves.c:119
static int do_identity(FFFrameSync *fs)
Definition: vf_identity.c:170
#define PF_NOALPHA(suf)
static const AVOption options[]
Definition: vf_identity.c:407
static int compute_images_identity(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_identity.c:123
static int query_formats(AVFilterContext *ctx)
Definition: vf_identity.c:243
static const AVFilterPad identity_inputs[]
Definition: vf_identity.c:386
static unsigned identity_line_16bit(const uint8_t *mmain_line, const uint8_t *rref_line, int outw)
Definition: vf_identity.c:71
static int compute_images_msad(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_identity.c:95
static void set_meta(AVFilterContext *ctx, AVDictionary **metadata, const char *key, char comp, float d)
Definition: vf_identity.c:152
static int config_input_ref(AVFilterLink *inlink)
Definition: vf_identity.c:266
#define PF(suf)
static const AVFilterPad identity_outputs[]
Definition: vf_identity.c:398
static int activate(AVFilterContext *ctx)
Definition: vf_identity.c:353
static av_cold int init(AVFilterContext *ctx)
Definition: vf_identity.c:234
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_identity.c:359
static int config_output(AVFilterLink *outlink)
Definition: vf_identity.c:324
static unsigned identity_line_8bit(const uint8_t *main_line, const uint8_t *ref_line, int outw)
Definition: vf_identity.c:61
static double c[64]