FFmpeg
vf_corr.c
Go to the documentation of this file.
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18 
19 /**
20  * @file
21  * Calculate the correlation between two input videos.
22  */
23 
24 #include "libavutil/avstring.h"
25 #include "libavutil/mem.h"
26 #include "libavutil/opt.h"
27 #include "libavutil/pixdesc.h"
28 #include "avfilter.h"
29 #include "drawutils.h"
30 #include "framesync.h"
31 #include "internal.h"
32 
33 typedef struct Sums {
34  uint64_t s[2];
35 } Sums;
36 
37 typedef struct QSums {
38  float s[3];
39 } QSums;
40 
41 typedef struct CorrContext {
42  const AVClass *class;
45  uint64_t nb_frames;
47  int is_rgb;
48  uint8_t rgba_map[4];
49  int max[4];
50  char comps[4];
51  float mean[4][2];
55  int planewidth[4];
56  int planeheight[4];
58  int jobnr, int nb_jobs);
60  int jobnr, int nb_jobs);
61 } CorrContext;
62 
63 typedef struct ThreadData {
65 } ThreadData;
66 
67 #define OFFSET(x) offsetof(CorrContext, x)
68 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
69 
71  AVDictionary **metadata, const char *key, char comp, float d)
72 {
73  char value[128];
74  snprintf(value, sizeof(value), "%f", d);
75  if (comp) {
76  char key2[128];
77  snprintf(key2, sizeof(key2), "lavfi.%s.%s%s%c",
78  ctx->filter->name, ctx->filter->name, key, comp);
79  av_dict_set(metadata, key2, value, 0);
80  } else {
81  char key2[128];
82  snprintf(key2, sizeof(key2), "lavfi.%s.%s%s",
83  ctx->filter->name, ctx->filter->name, key);
84  av_dict_set(metadata, key2, value, 0);
85  }
86 }
87 
88 #define SUM(type, name) \
89 static int sum_##name(AVFilterContext *ctx, void *arg, \
90  int jobnr, int nb_jobs) \
91 { \
92  CorrContext *s = ctx->priv; \
93  ThreadData *td = arg; \
94  AVFrame *master = td->master; \
95  AVFrame *ref = td->ref; \
96  \
97  for (int c = 0; c < s->nb_components; c++) { \
98  const ptrdiff_t linesize1 = master->linesize[c] / \
99  sizeof(type); \
100  const ptrdiff_t linesize2 = ref->linesize[c] / \
101  sizeof(type); \
102  const int h = s->planeheight[c]; \
103  const int w = s->planewidth[c]; \
104  const int slice_start = (h * jobnr) / nb_jobs; \
105  const int slice_end = (h * (jobnr+1)) / nb_jobs; \
106  const type *src1 = (const type *)master->data[c] + \
107  linesize1 * slice_start; \
108  const type *src2 = (const type *)ref->data[c] + \
109  linesize2 * slice_start; \
110  uint64_t sum1 = 0, sum2 = 0; \
111  \
112  for (int y = slice_start; y < slice_end; y++) { \
113  for (int x = 0; x < w; x++) { \
114  sum1 += src1[x]; \
115  sum2 += src2[x]; \
116  } \
117  \
118  src1 += linesize1; \
119  src2 += linesize2; \
120  } \
121  \
122  s->sums[jobnr * s->nb_components + c].s[0] = sum1; \
123  s->sums[jobnr * s->nb_components + c].s[1] = sum2; \
124  } \
125  \
126  return 0; \
127 }
128 
129 SUM(uint8_t, slice8)
130 SUM(uint16_t, slice16)
131 
132 #define CORR(type, name) \
133 static int corr_##name(AVFilterContext *ctx, void *arg, \
134  int jobnr, int nb_jobs) \
135 { \
136  CorrContext *s = ctx->priv; \
137  ThreadData *td = arg; \
138  AVFrame *master = td->master; \
139  AVFrame *ref = td->ref; \
140  \
141  for (int c = 0; c < s->nb_components; c++) { \
142  const ptrdiff_t linesize1 = master->linesize[c] / \
143  sizeof(type); \
144  const ptrdiff_t linesize2 = ref->linesize[c] / \
145  sizeof(type); \
146  const type *src1 = (const type *)master->data[c]; \
147  const type *src2 = (const type *)ref->data[c]; \
148  const int h = s->planeheight[c]; \
149  const int w = s->planewidth[c]; \
150  const int slice_start = (h * jobnr) / nb_jobs; \
151  const int slice_end = (h * (jobnr+1)) / nb_jobs; \
152  const float scale = 1.f / s->max[c]; \
153  const float mean1 = s->mean[c][0]; \
154  const float mean2 = s->mean[c][1]; \
155  float sum12 = 0.f, sum1q = 0.f, sum2q = 0.f; \
156  \
157  src1 = (const type *)master->data[c] + \
158  slice_start * linesize1; \
159  src2 = (const type *)ref->data[c] + \
160  slice_start * linesize2; \
161  \
162  for (int y = slice_start; y < slice_end; y++) { \
163  for (int x = 0; x < w; x++) { \
164  const float f1 = scale * src1[x] - mean1; \
165  const float f2 = scale * src2[x] - mean2; \
166  \
167  sum12 += f1 * f2; \
168  sum1q += f1 * f1; \
169  sum2q += f2 * f2; \
170  } \
171  \
172  src1 += linesize1; \
173  src2 += linesize2; \
174  } \
175  \
176  s->qsums[jobnr * s->nb_components + c].s[0] = sum12; \
177  s->qsums[jobnr * s->nb_components + c].s[1] = sum1q; \
178  s->qsums[jobnr * s->nb_components + c].s[2] = sum2q; \
179  } \
180  \
181  return 0; \
182 }
183 
184 CORR(uint8_t, slice8)
185 CORR(uint16_t, slice16)
186 
187 static int do_corr(FFFrameSync *fs)
188 {
189  AVFilterContext *ctx = fs->parent;
190  CorrContext *s = ctx->priv;
191  AVFrame *master, *ref;
192  double comp_score[4], score = 0.;
193  AVDictionary **metadata;
194  ThreadData td;
195  int ret;
196 
198  if (ret < 0)
199  return ret;
200  if (ctx->is_disabled || !ref)
201  return ff_filter_frame(ctx->outputs[0], master);
202  metadata = &master->metadata;
203 
204  td.master = master;
205  td.ref = ref;
206  ff_filter_execute(ctx, s->sum_slice, &td, NULL,
207  FFMIN(s->planeheight[1], s->nb_threads));
208 
209  for (int c = 0; c < s->nb_components; c++) {
210  const double scale = 1.f / s->max[c];
211  uint64_t sum1 = 0, sum2 = 0;
212 
213  for (int n = 0; n < s->nb_threads; n++) {
214  sum1 += s->sums[n * s->nb_components + c].s[0];
215  sum2 += s->sums[n * s->nb_components + c].s[1];
216  }
217 
218  s->mean[c][0] = scale * (sum1 /(double)(s->planewidth[c] * s->planeheight[c]));
219  s->mean[c][1] = scale * (sum2 /(double)(s->planewidth[c] * s->planeheight[c]));
220  }
221 
222  ff_filter_execute(ctx, s->corr_slice, &td, NULL,
223  FFMIN(s->planeheight[1], s->nb_threads));
224 
225  for (int c = 0; c < s->nb_components; c++) {
226  double sumq, sum12 = 0.0, sum1q = 0.0, sum2q = 0.0;
227 
228  for (int n = 0; n < s->nb_threads; n++) {
229  sum12 += s->qsums[n * s->nb_components + c].s[0];
230  sum1q += s->qsums[n * s->nb_components + c].s[1];
231  sum2q += s->qsums[n * s->nb_components + c].s[2];
232  }
233 
234  sumq = sqrt(sum1q * sum2q);
235  if (sumq > 0.0) {
236  comp_score[c] = av_clipd(sum12 / sumq,-1.0,1.0);
237  } else {
238  comp_score[c] = 0.f;
239  }
240  }
241 
242  for (int c = 0; c < s->nb_components; c++)
243  score += comp_score[c];
244  score /= s->nb_components;
245  s->score += score;
246 
247  s->min_score = fmin(s->min_score, score);
248  s->max_score = fmax(s->max_score, score);
249 
250  for (int c = 0; c < s->nb_components; c++)
251  s->score_comp[c] += comp_score[c];
252  s->nb_frames++;
253 
254  for (int j = 0; j < s->nb_components; j++) {
255  int c = s->is_rgb ? s->rgba_map[j] : j;
256  set_meta(ctx, metadata, ".", s->comps[j], comp_score[c]);
257  }
258  set_meta(ctx, metadata, "_avg", 0, score);
259 
260  return ff_filter_frame(ctx->outputs[0], master);
261 }
262 
264 {
265  CorrContext *s = ctx->priv;
266 
267  s->fs.on_event = do_corr;
268 
269  return 0;
270 }
271 
272 static const enum AVPixelFormat pix_fmts[] = {
274 #define PF_NOALPHA(suf) AV_PIX_FMT_YUV420##suf, AV_PIX_FMT_YUV422##suf, AV_PIX_FMT_YUV444##suf
275 #define PF_ALPHA(suf) AV_PIX_FMT_YUVA420##suf, AV_PIX_FMT_YUVA422##suf, AV_PIX_FMT_YUVA444##suf
276 #define PF(suf) PF_NOALPHA(suf), PF_ALPHA(suf)
277  PF(P), PF(P9), PF(P10), PF_NOALPHA(P12), PF_NOALPHA(P14), PF(P16),
285 };
286 
288 {
290  AVFilterContext *ctx = inlink->dst;
291  CorrContext *s = ctx->priv;
292 
293  s->nb_threads = ff_filter_get_nb_threads(ctx);
294  s->nb_components = desc->nb_components;
295  if (ctx->inputs[0]->w != ctx->inputs[1]->w ||
296  ctx->inputs[0]->h != ctx->inputs[1]->h) {
297  av_log(ctx, AV_LOG_ERROR, "Width and height of input videos must be same.\n");
298  return AVERROR(EINVAL);
299  }
300 
301  s->is_rgb = ff_fill_rgba_map(s->rgba_map, inlink->format) >= 0;
302  s->comps[0] = s->is_rgb ? 'R' : 'Y' ;
303  s->comps[1] = s->is_rgb ? 'G' : 'U' ;
304  s->comps[2] = s->is_rgb ? 'B' : 'V' ;
305  s->comps[3] = 'A';
306 
307  s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
308  s->planeheight[0] = s->planeheight[3] = inlink->h;
309  s->planewidth[1] = s->planewidth[2] = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
310  s->planewidth[0] = s->planewidth[3] = inlink->w;
311 
312  s->sums = av_calloc(s->nb_threads * s->nb_components, sizeof(*s->sums));
313  s->qsums = av_calloc(s->nb_threads * s->nb_components, sizeof(*s->qsums));
314  if (!s->qsums || !s->sums)
315  return AVERROR(ENOMEM);
316 
317  s->min_score = +INFINITY;
318  s->max_score = -INFINITY;
319 
320  s->max[0] = (1 << desc->comp[0].depth) - 1;
321  s->max[1] = (1 << desc->comp[1].depth) - 1;
322  s->max[2] = (1 << desc->comp[2].depth) - 1;
323  s->max[3] = (1 << desc->comp[3].depth) - 1;
324 
325  s->sum_slice = desc->comp[0].depth > 8 ? sum_slice16 : sum_slice8;
326  s->corr_slice = desc->comp[0].depth > 8 ? corr_slice16 : corr_slice8;
327 
328  return 0;
329 }
330 
331 static int config_output(AVFilterLink *outlink)
332 {
333  AVFilterContext *ctx = outlink->src;
334  CorrContext *s = ctx->priv;
335  AVFilterLink *mainlink = ctx->inputs[0];
336  int ret;
337 
339  if (ret < 0)
340  return ret;
341  outlink->w = mainlink->w;
342  outlink->h = mainlink->h;
343  outlink->time_base = mainlink->time_base;
344  outlink->sample_aspect_ratio = mainlink->sample_aspect_ratio;
345  outlink->frame_rate = mainlink->frame_rate;
346  if ((ret = ff_framesync_configure(&s->fs)) < 0)
347  return ret;
348 
349  outlink->time_base = s->fs.time_base;
350 
351  if (av_cmp_q(mainlink->time_base, outlink->time_base) ||
352  av_cmp_q(ctx->inputs[1]->time_base, outlink->time_base))
353  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",
354  mainlink->time_base.num, mainlink->time_base.den,
355  ctx->inputs[1]->time_base.num, ctx->inputs[1]->time_base.den);
356 
357  return 0;
358 }
359 
361 {
362  CorrContext *s = ctx->priv;
363  return ff_framesync_activate(&s->fs);
364 }
365 
367 {
368  CorrContext *s = ctx->priv;
369 
370  if (s->nb_frames > 0) {
371  char buf[256];
372 
373  buf[0] = 0;
374  for (int j = 0; j < s->nb_components; j++) {
375  int c = s->is_rgb ? s->rgba_map[j] : j;
376  av_strlcatf(buf, sizeof(buf), " %c:%f", s->comps[j], s->score_comp[c] / s->nb_frames);
377  }
378 
379  av_log(ctx, AV_LOG_INFO, "%s%s average:%f min:%f max:%f\n",
380  ctx->filter->name,
381  buf,
382  s->score / s->nb_frames,
383  s->min_score,
384  s->max_score);
385  }
386 
387  ff_framesync_uninit(&s->fs);
388  av_freep(&s->qsums);
389  av_freep(&s->sums);
390 }
391 
392 static const AVFilterPad corr_inputs[] = {
393  {
394  .name = "main",
395  .type = AVMEDIA_TYPE_VIDEO,
396  },{
397  .name = "reference",
398  .type = AVMEDIA_TYPE_VIDEO,
399  .config_props = config_input_ref,
400  },
401 };
402 
403 static const AVFilterPad corr_outputs[] = {
404  {
405  .name = "default",
406  .type = AVMEDIA_TYPE_VIDEO,
407  .config_props = config_output,
408  },
409 };
410 
411 static const AVOption options[] = {
412  { NULL }
413 };
414 
415 #define corr_options options
417 
419  .name = "corr",
420  .description = NULL_IF_CONFIG_SMALL("Calculate the correlation between two video streams."),
421  .preinit = corr_framesync_preinit,
422  .init = init,
423  .uninit = uninit,
424  .activate = activate,
425  .priv_size = sizeof(CorrContext),
426  .priv_class = &corr_class,
433 };
AV_PIX_FMT_GBRAP16
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:501
ff_framesync_configure
int ff_framesync_configure(FFFrameSync *fs)
Configure a frame sync structure.
Definition: framesync.c:134
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
td
#define td
Definition: regdef.h:70
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
INFINITY
#define INFINITY
Definition: mathematics.h:118
CorrContext::max
int max[4]
Definition: vf_corr.c:49
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
ff_framesync_uninit
void ff_framesync_uninit(FFFrameSync *fs)
Free all memory currently allocated.
Definition: framesync.c:304
CorrContext::planeheight
int planeheight[4]
Definition: vf_corr.c:56
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:81
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1015
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2965
FILTER_PIXFMTS_ARRAY
#define FILTER_PIXFMTS_ARRAY(array)
Definition: internal.h:162
inlink
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
Definition: filter_design.txt:212
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:375
pixdesc.h
QSums::s
float s[3]
Definition: vf_corr.c:38
AVOption
AVOption.
Definition: opt.h:346
CorrContext::min_score
double min_score
Definition: vf_corr.c:44
CorrContext::is_rgb
int is_rgb
Definition: vf_corr.c:47
AV_PIX_FMT_YUV440P
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:106
AVDictionary
Definition: dict.c:34
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:170
FFFrameSync
Frame sync structure.
Definition: framesync.h:168
av_strlcatf
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
Definition: avstring.c:103
config_output
static int config_output(AVFilterLink *outlink)
Definition: vf_corr.c:331
AV_PIX_FMT_GRAY9
#define AV_PIX_FMT_GRAY9
Definition: pixfmt.h:458
FRAMESYNC_DEFINE_CLASS
FRAMESYNC_DEFINE_CLASS(corr, CorrContext, fs)
Sums
Definition: vf_corr.c:33
corr_inputs
static const AVFilterPad corr_inputs[]
Definition: vf_corr.c:392
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:496
AV_PIX_FMT_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:212
corr_outputs
static const AVFilterPad corr_outputs[]
Definition: vf_corr.c:403
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:494
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:462
ff_vf_corr
const AVFilter ff_vf_corr
Definition: vf_corr.c:418
AVRational::num
int num
Numerator.
Definition: rational.h:59
CorrContext::rgba_map
uint8_t rgba_map[4]
Definition: vf_corr.c:48
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:33
ThreadData::master
AVFrame * master
Definition: vf_corr.c:64
AV_PIX_FMT_YUVJ411P
@ 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:283
CorrContext::corr_slice
int(* corr_slice)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_corr.c:59
CorrContext::score
double score
Definition: vf_corr.c:44
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
init
static av_cold int init(AVFilterContext *ctx)
Definition: vf_corr.c:263
AV_PIX_FMT_YUVJ422P
@ 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:86
AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:498
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV_PIX_FMT_GBRAP12
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:499
CorrContext::sum_slice
int(* sum_slice)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_corr.c:57
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:59
activate
static int activate(AVFilterContext *ctx)
Definition: vf_corr.c:360
CorrContext::fs
FFFrameSync fs
Definition: vf_corr.c:43
ctx
AVFormatContext * ctx
Definition: movenc.c:49
AV_PIX_FMT_GRAY14
#define AV_PIX_FMT_GRAY14
Definition: pixfmt.h:461
options
static const AVOption options[]
Definition: vf_corr.c:411
CorrContext
Definition: vf_corr.c:41
key
const char * key
Definition: hwcontext_opencl.c:189
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:182
AV_PIX_FMT_YUVJ444P
@ 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:87
arg
const char * arg
Definition: jacosubdec.c:67
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:459
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:497
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
fs
#define fs(width, name, subs,...)
Definition: cbs_vp9.c:200
CorrContext::score_comp
double score_comp[4]
Definition: vf_corr.c:44
AV_PIX_FMT_YUVJ420P
@ 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:85
CorrContext::planewidth
int planewidth[4]
Definition: vf_corr.c:55
double
double
Definition: af_crystalizer.c:131
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
PF
#define PF(suf)
AV_PIX_FMT_GBRP9
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:493
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
CORR
#define CORR(type, name)
Definition: vf_corr.c:132
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:94
ff_framesync_init_dualinput
int ff_framesync_init_dualinput(FFFrameSync *fs, AVFilterContext *parent)
Initialize a frame sync structure for dualinput.
Definition: framesync.c:375
master
const char * master
Definition: vf_curves.c:130
P
#define P
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
fmin
double fmin(double, double)
CorrContext::nb_threads
int nb_threads
Definition: vf_corr.c:46
CorrContext::nb_components
int nb_components
Definition: vf_corr.c:54
CorrContext::qsums
QSums * qsums
Definition: vf_corr.c:53
SUM
#define SUM(type, name)
Definition: vf_corr.c:88
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
internal.h
PF_NOALPHA
#define PF_NOALPHA(suf)
CorrContext::sums
Sums * sums
Definition: vf_corr.c:52
config_input_ref
static int config_input_ref(AVFilterLink *inlink)
Definition: vf_corr.c:287
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:495
ff_filter_get_nb_threads
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:827
ThreadData
Used for passing data between threads.
Definition: dsddec.c:71
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: vf_corr.c:272
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_corr.c:366
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AV_PIX_FMT_YUVJ440P
@ 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:107
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:39
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
av_cmp_q
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
AVFilter
Filter definition.
Definition: avfilter.h:166
set_meta
static void set_meta(AVFilterContext *ctx, AVDictionary **metadata, const char *key, char comp, float d)
Definition: vf_corr.c:70
ret
ret
Definition: filter_design.txt:187
ThreadData::ref
AVFrame * ref
Definition: vf_corr.c:64
fmax
double fmax(double, double)
framesync.h
CorrContext::nb_frames
uint64_t nb_frames
Definition: vf_corr.c:45
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
avfilter.h
AVFILTER_FLAG_METADATA_ONLY
#define AVFILTER_FLAG_METADATA_ONLY
The filter is a "metadata" filter - it does not modify the frame data in any way.
Definition: avfilter.h:133
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
AVFilterContext
An instance of a filter.
Definition: avfilter.h:407
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:165
AVFILTER_FLAG_SLICE_THREADS
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition: avfilter.h:117
desc
const char * desc
Definition: libsvtav1.c:75
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mem.h
CorrContext::max_score
double max_score
Definition: vf_corr.c:44
QSums
Definition: vf_corr.c:37
CorrContext::comps
char comps[4]
Definition: vf_corr.c:50
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:291
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:183
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
av_dict_set
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:88
AV_PIX_FMT_YUV411P
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:80
ff_fill_rgba_map
int ff_fill_rgba_map(uint8_t *rgba_map, enum AVPixelFormat pix_fmt)
Definition: drawutils.c:35
d
d
Definition: ffmpeg_filter.c:424
AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
#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:155
AV_PIX_FMT_YUV410P
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:79
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
ff_framesync_activate
int ff_framesync_activate(FFFrameSync *fs)
Examine the frames in the filter's input and try to produce output.
Definition: framesync.c:355
avstring.h
ff_framesync_dualinput_get
int ff_framesync_dualinput_get(FFFrameSync *fs, AVFrame **f0, AVFrame **f1)
Definition: framesync.c:393
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:460
drawutils.h
ff_filter_execute
static av_always_inline int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
Definition: internal.h:134
int
int
Definition: ffmpeg_filter.c:424
CorrContext::mean
float mean[4][2]
Definition: vf_corr.c:51
snprintf
#define snprintf
Definition: snprintf.h:34
Sums::s
uint64_t s[2]
Definition: vf_corr.c:34
av_clipd
av_clipd
Definition: af_crystalizer.c:131
do_corr
static int do_corr(FFFrameSync *fs)
Definition: vf_corr.c:187