FFmpeg
vf_signature.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2017 Gerion Entrup
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (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
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License along
17  * with FFmpeg; if not, write to the Free Software Foundation, Inc.,
18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19  */
20 
21 /**
22  * @file
23  * MPEG-7 video signature calculation and lookup filter
24  * @see http://epubs.surrey.ac.uk/531590/1/MPEG-7%20Video%20Signature%20Author%27s%20Copy.pdf
25  */
26 
27 #include "libavcodec/put_bits.h"
28 #include "libavformat/avformat.h"
29 #include "libavutil/opt.h"
30 #include "libavutil/avstring.h"
31 #include "libavutil/file_open.h"
32 #include "avfilter.h"
33 #include "internal.h"
34 #include "signature.h"
35 #include "signature_lookup.c"
36 
37 #define OFFSET(x) offsetof(SignatureContext, x)
38 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_VIDEO_PARAM
39 #define BLOCK_LCM (int64_t) 476985600
40 
41 static const AVOption signature_options[] = {
42  { "detectmode", "set the detectmode",
43  OFFSET(mode), AV_OPT_TYPE_INT, {.i64 = MODE_OFF}, 0, NB_LOOKUP_MODE-1, FLAGS, .unit = "mode" },
44  { "off", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = MODE_OFF}, 0, 0, .flags = FLAGS, .unit = "mode" },
45  { "full", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = MODE_FULL}, 0, 0, .flags = FLAGS, .unit = "mode" },
46  { "fast", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = MODE_FAST}, 0, 0, .flags = FLAGS, .unit = "mode" },
47  { "nb_inputs", "number of inputs",
48  OFFSET(nb_inputs), AV_OPT_TYPE_INT, {.i64 = 1}, 1, INT_MAX, FLAGS },
49  { "filename", "filename for output files",
50  OFFSET(filename), AV_OPT_TYPE_STRING, {.str = ""}, 0, NB_FORMATS-1, FLAGS },
51  { "format", "set output format",
52  OFFSET(format), AV_OPT_TYPE_INT, {.i64 = FORMAT_BINARY}, 0, 1, FLAGS , .unit = "format" },
53  { "binary", 0, 0, AV_OPT_TYPE_CONST, {.i64=FORMAT_BINARY}, 0, 0, FLAGS, .unit = "format" },
54  { "xml", 0, 0, AV_OPT_TYPE_CONST, {.i64=FORMAT_XML}, 0, 0, FLAGS, .unit = "format" },
55  { "th_d", "threshold to detect one word as similar",
56  OFFSET(thworddist), AV_OPT_TYPE_INT, {.i64 = 9000}, 1, INT_MAX, FLAGS },
57  { "th_dc", "threshold to detect all words as similar",
58  OFFSET(thcomposdist), AV_OPT_TYPE_INT, {.i64 = 60000}, 1, INT_MAX, FLAGS },
59  { "th_xh", "threshold to detect frames as similar",
60  OFFSET(thl1), AV_OPT_TYPE_INT, {.i64 = 116}, 1, INT_MAX, FLAGS },
61  { "th_di", "minimum length of matching sequence in frames",
62  OFFSET(thdi), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, FLAGS },
63  { "th_it", "threshold for relation of good to all frames",
64  OFFSET(thit), AV_OPT_TYPE_DOUBLE, {.dbl = 0.5}, 0.0, 1.0, FLAGS },
65  { NULL }
66 };
67 
69 
70 /* all formats with a separate gray value */
71 static const enum AVPixelFormat pix_fmts[] = {
81 };
82 
84 {
85  AVFilterContext *ctx = inlink->dst;
86  SignatureContext *sic = ctx->priv;
88 
89  sc->time_base = inlink->time_base;
90  /* test for overflow */
91  sc->divide = (((uint64_t) inlink->w/32) * (inlink->w/32 + 1) * (inlink->h/32 * inlink->h/32 + 1) > INT64_MAX / (BLOCK_LCM * 255));
92  if (sc->divide) {
93  av_log(ctx, AV_LOG_WARNING, "Input dimension too high for precise calculation, numbers will be rounded.\n");
94  }
95  sc->w = inlink->w;
96  sc->h = inlink->h;
97  return 0;
98 }
99 
100 static int get_block_size(const Block *b)
101 {
102  return (b->to.y - b->up.y + 1) * (b->to.x - b->up.x + 1);
103 }
104 
105 static uint64_t get_block_sum(StreamContext *sc, uint64_t intpic[32][32], const Block *b)
106 {
107  uint64_t sum = 0;
108 
109  int x0, y0, x1, y1;
110 
111  x0 = b->up.x;
112  y0 = b->up.y;
113  x1 = b->to.x;
114  y1 = b->to.y;
115 
116  if (x0-1 >= 0 && y0-1 >= 0) {
117  sum = intpic[y1][x1] + intpic[y0-1][x0-1] - intpic[y1][x0-1] - intpic[y0-1][x1];
118  } else if (x0-1 >= 0) {
119  sum = intpic[y1][x1] - intpic[y1][x0-1];
120  } else if (y0-1 >= 0) {
121  sum = intpic[y1][x1] - intpic[y0-1][x1];
122  } else {
123  sum = intpic[y1][x1];
124  }
125  return sum;
126 }
127 
128 static int cmp(const void *x, const void *y)
129 {
130  const uint64_t *a = x, *b = y;
131  return *a < *b ? -1 : ( *a > *b ? 1 : 0 );
132 }
133 
134 /**
135  * sets the bit at position pos to 1 in data
136  */
137 static void set_bit(uint8_t* data, size_t pos)
138 {
139  uint8_t mask = 1 << 7-(pos%8);
140  data[pos/8] |= mask;
141 }
142 
144 {
145  AVFilterContext *ctx = inlink->dst;
146  SignatureContext *sic = ctx->priv;
148  FineSignature* fs;
149 
150  static const uint8_t pot3[5] = { 3*3*3*3, 3*3*3, 3*3, 3, 1 };
151  /* indexes of words : 210,217,219,274,334 44,175,233,270,273 57,70,103,237,269 100,285,295,337,354 101,102,111,275,296
152  s2usw = sorted to unsorted wordvec: 44 is at index 5, 57 at index 10...
153  */
154  static const unsigned int wordvec[25] = {44,57,70,100,101,102,103,111,175,210,217,219,233,237,269,270,273,274,275,285,295,296,334,337,354};
155  static const uint8_t s2usw[25] = { 5,10,11, 15, 20, 21, 12, 22, 6, 0, 1, 2, 7, 13, 14, 8, 9, 3, 23, 16, 17, 24, 4, 18, 19};
156 
157  uint8_t wordt2b[5] = { 0, 0, 0, 0, 0 }; /* word ternary to binary */
158  uint64_t intpic[32][32];
159  uint64_t rowcount;
160  uint8_t *p = picref->data[0];
161  int inti, intj;
162  int *intjlut;
163 
164  uint64_t conflist[DIFFELEM_SIZE];
165  int f = 0, g = 0, w = 0;
166  int32_t dh1 = 1, dh2 = 1, dw1 = 1, dw2 = 1, a, b;
167  int64_t denom;
168  int i, j, k, ternary;
169  uint64_t blocksum;
170  int blocksize;
171  int64_t th; /* threshold */
172  int64_t sum;
173 
174  int64_t precfactor = (sc->divide) ? 65536 : BLOCK_LCM;
175 
176  /* initialize fs */
177  if (sc->curfinesig) {
178  fs = av_mallocz(sizeof(FineSignature));
179  if (!fs)
180  return AVERROR(ENOMEM);
181  sc->curfinesig->next = fs;
182  fs->prev = sc->curfinesig;
183  sc->curfinesig = fs;
184  } else {
185  fs = sc->curfinesig = sc->finesiglist;
186  sc->curcoarsesig1->first = fs;
187  }
188 
189  fs->pts = picref->pts;
190  fs->index = sc->lastindex++;
191 
192  memset(intpic, 0, sizeof(uint64_t)*32*32);
193  intjlut = av_malloc_array(inlink->w, sizeof(int));
194  if (!intjlut)
195  return AVERROR(ENOMEM);
196  for (i = 0; i < inlink->w; i++) {
197  intjlut[i] = (i*32)/inlink->w;
198  }
199 
200  for (i = 0; i < inlink->h; i++) {
201  inti = (i*32)/inlink->h;
202  for (j = 0; j < inlink->w; j++) {
203  intj = intjlut[j];
204  intpic[inti][intj] += p[j];
205  }
206  p += picref->linesize[0];
207  }
208  av_freep(&intjlut);
209 
210  /* The following calculates a summed area table (intpic) and brings the numbers
211  * in intpic to the same denominator.
212  * So you only have to handle the numinator in the following sections.
213  */
214  dh1 = inlink->h / 32;
215  if (inlink->h % 32)
216  dh2 = dh1 + 1;
217  dw1 = inlink->w / 32;
218  if (inlink->w % 32)
219  dw2 = dw1 + 1;
220  denom = (sc->divide) ? dh1 * (int64_t)dh2 * dw1 * dw2 : 1;
221 
222  for (i = 0; i < 32; i++) {
223  rowcount = 0;
224  a = 1;
225  if (dh2 > 1) {
226  a = ((inlink->h*(i+1))%32 == 0) ? (inlink->h*(i+1))/32 - 1 : (inlink->h*(i+1))/32;
227  a -= ((inlink->h*i)%32 == 0) ? (inlink->h*i)/32 - 1 : (inlink->h*i)/32;
228  a = (a == dh1)? dh2 : dh1;
229  }
230  for (j = 0; j < 32; j++) {
231  b = 1;
232  if (dw2 > 1) {
233  b = ((inlink->w*(j+1))%32 == 0) ? (inlink->w*(j+1))/32 - 1 : (inlink->w*(j+1))/32;
234  b -= ((inlink->w*j)%32 == 0) ? (inlink->w*j)/32 - 1 : (inlink->w*j)/32;
235  b = (b == dw1)? dw2 : dw1;
236  }
237  rowcount += intpic[i][j] * a * b * precfactor / denom;
238  if (i > 0) {
239  intpic[i][j] = intpic[i-1][j] + rowcount;
240  } else {
241  intpic[i][j] = rowcount;
242  }
243  }
244  }
245 
246  denom = (sc->divide) ? 1 : dh1 * (int64_t)dh2 * dw1 * dw2;
247 
248  for (i = 0; i < ELEMENT_COUNT; i++) {
249  const ElemCat* elemcat = elements[i];
250  int64_t* elemsignature;
251  uint64_t* sortsignature;
252 
253  elemsignature = av_malloc_array(elemcat->elem_count, 2 * sizeof(int64_t));
254  if (!elemsignature)
255  return AVERROR(ENOMEM);
256  sortsignature = elemsignature + elemcat->elem_count;
257 
258  for (j = 0; j < elemcat->elem_count; j++) {
259  blocksum = 0;
260  blocksize = 0;
261  for (k = 0; k < elemcat->left_count; k++) {
262  blocksum += get_block_sum(sc, intpic, &elemcat->blocks[j*elemcat->block_count+k]);
263  blocksize += get_block_size(&elemcat->blocks[j*elemcat->block_count+k]);
264  }
265  sum = blocksum / blocksize;
266  if (elemcat->av_elem) {
267  sum -= 128 * precfactor * denom;
268  } else {
269  blocksum = 0;
270  blocksize = 0;
271  for (; k < elemcat->block_count; k++) {
272  blocksum += get_block_sum(sc, intpic, &elemcat->blocks[j*elemcat->block_count+k]);
273  blocksize += get_block_size(&elemcat->blocks[j*elemcat->block_count+k]);
274  }
275  sum -= blocksum / blocksize;
276  conflist[g++] = FFABS(sum * 8 / (precfactor * denom));
277  }
278 
279  elemsignature[j] = sum;
280  sortsignature[j] = FFABS(sum);
281  }
282 
283  /* get threshold */
284  qsort(sortsignature, elemcat->elem_count, sizeof(uint64_t), cmp);
285  th = sortsignature[(int) (elemcat->elem_count*0.333)];
286 
287  /* ternarize */
288  for (j = 0; j < elemcat->elem_count; j++) {
289  if (elemsignature[j] < -th) {
290  ternary = 0;
291  } else if (elemsignature[j] <= th) {
292  ternary = 1;
293  } else {
294  ternary = 2;
295  }
296  fs->framesig[f/5] += ternary * pot3[f%5];
297 
298  if (f == wordvec[w]) {
299  fs->words[s2usw[w]/5] += ternary * pot3[wordt2b[s2usw[w]/5]++];
300  if (w < 24)
301  w++;
302  }
303  f++;
304  }
305  av_freep(&elemsignature);
306  }
307 
308  /* confidence */
309  qsort(conflist, DIFFELEM_SIZE, sizeof(uint64_t), cmp);
310  fs->confidence = FFMIN(conflist[DIFFELEM_SIZE/2], 255);
311 
312  /* coarsesignature */
313  if (sc->coarsecount == 0) {
314  if (sc->curcoarsesig2) {
316  if (!sc->curcoarsesig1)
317  return AVERROR(ENOMEM);
318  sc->curcoarsesig1->first = fs;
319  sc->curcoarsesig2->next = sc->curcoarsesig1;
320  sc->coarseend = sc->curcoarsesig1;
321  }
322  }
323  if (sc->coarsecount == 45) {
324  sc->midcoarse = 1;
326  if (!sc->curcoarsesig2)
327  return AVERROR(ENOMEM);
328  sc->curcoarsesig2->first = fs;
329  sc->curcoarsesig1->next = sc->curcoarsesig2;
330  sc->coarseend = sc->curcoarsesig2;
331  }
332  for (i = 0; i < 5; i++) {
333  set_bit(sc->curcoarsesig1->data[i], fs->words[i]);
334  }
335  /* assuming the actual frame is the last */
336  sc->curcoarsesig1->last = fs;
337  if (sc->midcoarse) {
338  for (i = 0; i < 5; i++) {
339  set_bit(sc->curcoarsesig2->data[i], fs->words[i]);
340  }
341  sc->curcoarsesig2->last = fs;
342  }
343 
344  sc->coarsecount = (sc->coarsecount+1)%90;
345 
346  /* debug printing finesignature */
347  if (av_log_get_level() == AV_LOG_DEBUG) {
348  av_log(ctx, AV_LOG_DEBUG, "input %d, confidence: %d\n", FF_INLINK_IDX(inlink), fs->confidence);
349 
350  av_log(ctx, AV_LOG_DEBUG, "words:");
351  for (i = 0; i < 5; i++) {
352  av_log(ctx, AV_LOG_DEBUG, " %d:", fs->words[i] );
353  av_log(ctx, AV_LOG_DEBUG, " %d", fs->words[i] / pot3[0] );
354  for (j = 1; j < 5; j++)
355  av_log(ctx, AV_LOG_DEBUG, ",%d", fs->words[i] % pot3[j-1] / pot3[j] );
356  av_log(ctx, AV_LOG_DEBUG, ";");
357  }
358  av_log(ctx, AV_LOG_DEBUG, "\n");
359 
360  av_log(ctx, AV_LOG_DEBUG, "framesignature:");
361  for (i = 0; i < SIGELEM_SIZE/5; i++) {
362  av_log(ctx, AV_LOG_DEBUG, " %d", fs->framesig[i] / pot3[0] );
363  for (j = 1; j < 5; j++)
364  av_log(ctx, AV_LOG_DEBUG, ",%d", fs->framesig[i] % pot3[j-1] / pot3[j] );
365  }
366  av_log(ctx, AV_LOG_DEBUG, "\n");
367  }
368 
369  if (FF_INLINK_IDX(inlink) == 0)
370  return ff_filter_frame(inlink->dst->outputs[0], picref);
371  return 1;
372 }
373 
374 static int xml_export(AVFilterContext *ctx, StreamContext *sc, const char* filename)
375 {
376  FineSignature* fs;
377  CoarseSignature* cs;
378  int i, j;
379  FILE* f;
380  unsigned int pot3[5] = { 3*3*3*3, 3*3*3, 3*3, 3, 1 };
381 
382  f = avpriv_fopen_utf8(filename, "w");
383  if (!f) {
384  int err = AVERROR(EINVAL);
385  char buf[128];
386  av_strerror(err, buf, sizeof(buf));
387  av_log(ctx, AV_LOG_ERROR, "cannot open xml file %s: %s\n", filename, buf);
388  return err;
389  }
390 
391  /* header */
392  fprintf(f, "<?xml version='1.0' encoding='ASCII' ?>\n");
393  fprintf(f, "<Mpeg7 xmlns=\"urn:mpeg:mpeg7:schema:2001\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"urn:mpeg:mpeg7:schema:2001 schema/Mpeg7-2001.xsd\">\n");
394  fprintf(f, " <DescriptionUnit xsi:type=\"DescriptorCollectionType\">\n");
395  fprintf(f, " <Descriptor xsi:type=\"VideoSignatureType\">\n");
396  fprintf(f, " <VideoSignatureRegion>\n");
397  fprintf(f, " <VideoSignatureSpatialRegion>\n");
398  fprintf(f, " <Pixel>0 0 </Pixel>\n");
399  fprintf(f, " <Pixel>%d %d </Pixel>\n", sc->w - 1, sc->h - 1);
400  fprintf(f, " </VideoSignatureSpatialRegion>\n");
401  fprintf(f, " <StartFrameOfSpatialRegion>0</StartFrameOfSpatialRegion>\n");
402  /* hoping num is 1, other values are vague */
403  fprintf(f, " <MediaTimeUnit>%d</MediaTimeUnit>\n", sc->time_base.den / sc->time_base.num);
404  fprintf(f, " <MediaTimeOfSpatialRegion>\n");
405  fprintf(f, " <StartMediaTimeOfSpatialRegion>0</StartMediaTimeOfSpatialRegion>\n");
406  fprintf(f, " <EndMediaTimeOfSpatialRegion>%" PRIu64 "</EndMediaTimeOfSpatialRegion>\n", sc->coarseend->last->pts);
407  fprintf(f, " </MediaTimeOfSpatialRegion>\n");
408 
409  /* coarsesignatures */
410  for (cs = sc->coarsesiglist; cs; cs = cs->next) {
411  fprintf(f, " <VSVideoSegment>\n");
412  fprintf(f, " <StartFrameOfSegment>%" PRIu32 "</StartFrameOfSegment>\n", cs->first->index);
413  fprintf(f, " <EndFrameOfSegment>%" PRIu32 "</EndFrameOfSegment>\n", cs->last->index);
414  fprintf(f, " <MediaTimeOfSegment>\n");
415  fprintf(f, " <StartMediaTimeOfSegment>%" PRIu64 "</StartMediaTimeOfSegment>\n", cs->first->pts);
416  fprintf(f, " <EndMediaTimeOfSegment>%" PRIu64 "</EndMediaTimeOfSegment>\n", cs->last->pts);
417  fprintf(f, " </MediaTimeOfSegment>\n");
418  for (i = 0; i < 5; i++) {
419  fprintf(f, " <BagOfWords>");
420  for (j = 0; j < 31; j++) {
421  uint8_t n = cs->data[i][j];
422  if (j < 30) {
423  fprintf(f, "%d %d %d %d %d %d %d %d ", (n & 0x80) >> 7,
424  (n & 0x40) >> 6,
425  (n & 0x20) >> 5,
426  (n & 0x10) >> 4,
427  (n & 0x08) >> 3,
428  (n & 0x04) >> 2,
429  (n & 0x02) >> 1,
430  (n & 0x01));
431  } else {
432  /* print only 3 bit in last byte */
433  fprintf(f, "%d %d %d ", (n & 0x80) >> 7,
434  (n & 0x40) >> 6,
435  (n & 0x20) >> 5);
436  }
437  }
438  fprintf(f, "</BagOfWords>\n");
439  }
440  fprintf(f, " </VSVideoSegment>\n");
441  }
442 
443  /* finesignatures */
444  for (fs = sc->finesiglist; fs; fs = fs->next) {
445  fprintf(f, " <VideoFrame>\n");
446  fprintf(f, " <MediaTimeOfFrame>%" PRIu64 "</MediaTimeOfFrame>\n", fs->pts);
447  /* confidence */
448  fprintf(f, " <FrameConfidence>%d</FrameConfidence>\n", fs->confidence);
449  /* words */
450  fprintf(f, " <Word>");
451  for (i = 0; i < 5; i++) {
452  fprintf(f, "%d ", fs->words[i]);
453  if (i < 4) {
454  fprintf(f, " ");
455  }
456  }
457  fprintf(f, "</Word>\n");
458  /* framesignature */
459  fprintf(f, " <FrameSignature>");
460  for (i = 0; i< SIGELEM_SIZE/5; i++) {
461  if (i > 0) {
462  fprintf(f, " ");
463  }
464  fprintf(f, "%d ", fs->framesig[i] / pot3[0]);
465  for (j = 1; j < 5; j++)
466  fprintf(f, " %d ", fs->framesig[i] % pot3[j-1] / pot3[j] );
467  }
468  fprintf(f, "</FrameSignature>\n");
469  fprintf(f, " </VideoFrame>\n");
470  }
471  fprintf(f, " </VideoSignatureRegion>\n");
472  fprintf(f, " </Descriptor>\n");
473  fprintf(f, " </DescriptionUnit>\n");
474  fprintf(f, "</Mpeg7>\n");
475 
476  fclose(f);
477  return 0;
478 }
479 
480 static int binary_export(AVFilterContext *ctx, StreamContext *sc, const char* filename)
481 {
482  FILE* f;
483  FineSignature* fs;
484  CoarseSignature* cs;
485  uint32_t numofsegments = (sc->lastindex + 44)/45;
486  int i, j;
487  PutBitContext buf;
488  /* buffer + header + coarsesignatures + finesignature */
489  int len = (512 + 6 * 32 + 3*16 + 2 +
490  numofsegments * (4*32 + 1 + 5*243) +
491  sc->lastindex * (2 + 32 + 6*8 + 608)) / 8;
492  uint8_t* buffer = av_malloc_array(len, sizeof(uint8_t));
493  if (!buffer)
494  return AVERROR(ENOMEM);
495 
496  f = avpriv_fopen_utf8(filename, "wb");
497  if (!f) {
498  int err = AVERROR(EINVAL);
499  char buf[128];
500  av_strerror(err, buf, sizeof(buf));
501  av_log(ctx, AV_LOG_ERROR, "cannot open file %s: %s\n", filename, buf);
502  av_freep(&buffer);
503  return err;
504  }
505  init_put_bits(&buf, buffer, len);
506 
507  put_bits32(&buf, 1); /* NumOfSpatial Regions, only 1 supported */
508  put_bits(&buf, 1, 1); /* SpatialLocationFlag, always the whole image */
509  put_bits32(&buf, 0); /* PixelX,1 PixelY,1, 0,0 */
510  put_bits(&buf, 16, sc->w-1 & 0xFFFF); /* PixelX,2 */
511  put_bits(&buf, 16, sc->h-1 & 0xFFFF); /* PixelY,2 */
512  put_bits32(&buf, 0); /* StartFrameOfSpatialRegion */
513  put_bits32(&buf, sc->lastindex); /* NumOfFrames */
514  /* hoping num is 1, other values are vague */
515  /* den/num might be greater than 16 bit, so cutting it */
516  put_bits(&buf, 16, 0xFFFF & (sc->time_base.den / sc->time_base.num)); /* MediaTimeUnit */
517  put_bits(&buf, 1, 1); /* MediaTimeFlagOfSpatialRegion */
518  put_bits32(&buf, 0); /* StartMediaTimeOfSpatialRegion */
519  put_bits32(&buf, 0xFFFFFFFF & sc->coarseend->last->pts); /* EndMediaTimeOfSpatialRegion */
520  put_bits32(&buf, numofsegments); /* NumOfSegments */
521  /* coarsesignatures */
522  for (cs = sc->coarsesiglist; cs; cs = cs->next) {
523  put_bits32(&buf, cs->first->index); /* StartFrameOfSegment */
524  put_bits32(&buf, cs->last->index); /* EndFrameOfSegment */
525  put_bits(&buf, 1, 1); /* MediaTimeFlagOfSegment */
526  put_bits32(&buf, 0xFFFFFFFF & cs->first->pts); /* StartMediaTimeOfSegment */
527  put_bits32(&buf, 0xFFFFFFFF & cs->last->pts); /* EndMediaTimeOfSegment */
528  for (i = 0; i < 5; i++) {
529  /* put 243 bits ( = 7 * 32 + 19 = 8 * 28 + 19) into buffer */
530  for (j = 0; j < 30; j++) {
531  put_bits(&buf, 8, cs->data[i][j]);
532  }
533  put_bits(&buf, 3, cs->data[i][30] >> 5);
534  }
535  }
536  /* finesignatures */
537  put_bits(&buf, 1, 0); /* CompressionFlag, only 0 supported */
538  for (fs = sc->finesiglist; fs; fs = fs->next) {
539  put_bits(&buf, 1, 1); /* MediaTimeFlagOfFrame */
540  put_bits32(&buf, 0xFFFFFFFF & fs->pts); /* MediaTimeOfFrame */
541  put_bits(&buf, 8, fs->confidence); /* FrameConfidence */
542  for (i = 0; i < 5; i++) {
543  put_bits(&buf, 8, fs->words[i]); /* Words */
544  }
545  /* framesignature */
546  for (i = 0; i < SIGELEM_SIZE/5; i++) {
547  put_bits(&buf, 8, fs->framesig[i]);
548  }
549  }
550 
551  flush_put_bits(&buf);
552  fwrite(buffer, 1, put_bytes_output(&buf), f);
553  fclose(f);
554  av_freep(&buffer);
555  return 0;
556 }
557 
559 {
560  SignatureContext* sic = ctx->priv;
561  char filename[1024];
562 
563  if (sic->nb_inputs > 1) {
564  /* error already handled */
565  av_assert0(av_get_frame_filename(filename, sizeof(filename), sic->filename, input) == 0);
566  } else {
567  if (av_strlcpy(filename, sic->filename, sizeof(filename)) >= sizeof(filename))
568  return AVERROR(EINVAL);
569  }
570  if (sic->format == FORMAT_XML) {
571  return xml_export(ctx, sc, filename);
572  } else {
573  return binary_export(ctx, sc, filename);
574  }
575 }
576 
577 static int request_frame(AVFilterLink *outlink)
578 {
579  AVFilterContext *ctx = outlink->src;
580  SignatureContext *sic = ctx->priv;
581  StreamContext *sc, *sc2;
582  MatchingInfo match;
583  int i, j, ret;
584  int lookup = 1; /* indicates wheather EOF of all files is reached */
585 
586  /* process all inputs */
587  for (i = 0; i < sic->nb_inputs; i++){
588  sc = &(sic->streamcontexts[i]);
589 
590  ret = ff_request_frame(ctx->inputs[i]);
591 
592  /* return if unexpected error occurs in input stream */
593  if (ret < 0 && ret != AVERROR_EOF)
594  return ret;
595 
596  /* export signature at EOF */
597  if (ret == AVERROR_EOF && !sc->exported) {
598  /* export if wanted */
599  if (strlen(sic->filename) > 0) {
600  if (export(ctx, sc, i) < 0)
601  return ret;
602  }
603  sc->exported = 1;
604  }
605  lookup &= sc->exported;
606  }
607 
608  /* signature lookup */
609  if (lookup && sic->mode != MODE_OFF) {
610  /* iterate over every pair */
611  for (i = 0; i < sic->nb_inputs; i++) {
612  sc = &(sic->streamcontexts[i]);
613  for (j = i+1; j < sic->nb_inputs; j++) {
614  sc2 = &(sic->streamcontexts[j]);
615  match = lookup_signatures(ctx, sic, sc, sc2, sic->mode);
616  if (match.score != 0) {
617  av_log(ctx, AV_LOG_INFO, "matching of video %d at %f and %d at %f, %d frames matching\n",
618  i, ((double) match.first->pts * sc->time_base.num) / sc->time_base.den,
619  j, ((double) match.second->pts * sc2->time_base.num) / sc2->time_base.den,
620  match.matchframes);
621  if (match.whole)
622  av_log(ctx, AV_LOG_INFO, "whole video matching\n");
623  } else {
624  av_log(ctx, AV_LOG_INFO, "no matching of video %d and %d\n", i, j);
625  }
626  }
627  }
628  }
629 
630  return ret;
631 }
632 
634 {
635 
636  SignatureContext *sic = ctx->priv;
637  StreamContext *sc;
638  int i, ret;
639  char tmp[1024];
640 
641  sic->streamcontexts = av_mallocz(sic->nb_inputs * sizeof(StreamContext));
642  if (!sic->streamcontexts)
643  return AVERROR(ENOMEM);
644 
645  for (i = 0; i < sic->nb_inputs; i++) {
646  AVFilterPad pad = {
648  .name = av_asprintf("in%d", i),
649  .config_props = config_input,
650  .filter_frame = filter_frame,
651  };
652 
653  if (!pad.name)
654  return AVERROR(ENOMEM);
655  if ((ret = ff_append_inpad_free_name(ctx, &pad)) < 0)
656  return ret;
657 
658  sc = &(sic->streamcontexts[i]);
659 
660  sc->lastindex = 0;
661  sc->finesiglist = av_mallocz(sizeof(FineSignature));
662  if (!sc->finesiglist)
663  return AVERROR(ENOMEM);
664  sc->curfinesig = NULL;
665 
667  if (!sc->coarsesiglist)
668  return AVERROR(ENOMEM);
669  sc->curcoarsesig1 = sc->coarsesiglist;
670  sc->coarseend = sc->coarsesiglist;
671  sc->coarsecount = 0;
672  sc->midcoarse = 0;
673  }
674 
675  /* check filename */
676  if (sic->nb_inputs > 1 && strlen(sic->filename) > 0 && av_get_frame_filename(tmp, sizeof(tmp), sic->filename, 0) == -1) {
677  av_log(ctx, AV_LOG_ERROR, "The filename must contain %%d or %%0nd, if you have more than one input.\n");
678  return AVERROR(EINVAL);
679  }
680 
681  return 0;
682 }
683 
684 
685 
687 {
688  SignatureContext *sic = ctx->priv;
689  StreamContext *sc;
690  void* tmp;
691  FineSignature* finsig;
692  CoarseSignature* cousig;
693  int i;
694 
695 
696  /* free the lists */
697  if (sic->streamcontexts != NULL) {
698  for (i = 0; i < sic->nb_inputs; i++) {
699  sc = &(sic->streamcontexts[i]);
700  finsig = sc->finesiglist;
701  cousig = sc->coarsesiglist;
702 
703  while (finsig) {
704  tmp = finsig;
705  finsig = finsig->next;
706  av_freep(&tmp);
707  }
708  sc->finesiglist = NULL;
709 
710  while (cousig) {
711  tmp = cousig;
712  cousig = cousig->next;
713  av_freep(&tmp);
714  }
715  sc->coarsesiglist = NULL;
716  }
717  av_freep(&sic->streamcontexts);
718  }
719 }
720 
721 static int config_output(AVFilterLink *outlink)
722 {
723  AVFilterContext *ctx = outlink->src;
724  AVFilterLink *inlink = ctx->inputs[0];
725 
726  outlink->time_base = inlink->time_base;
727  outlink->frame_rate = inlink->frame_rate;
728  outlink->sample_aspect_ratio = inlink->sample_aspect_ratio;
729  outlink->w = inlink->w;
730  outlink->h = inlink->h;
731 
732  return 0;
733 }
734 
735 static const AVFilterPad signature_outputs[] = {
736  {
737  .name = "default",
738  .type = AVMEDIA_TYPE_VIDEO,
739  .request_frame = request_frame,
740  .config_props = config_output,
741  },
742 };
743 
745  .name = "signature",
746  .description = NULL_IF_CONFIG_SMALL("Calculate the MPEG-7 video signature"),
747  .priv_size = sizeof(SignatureContext),
748  .priv_class = &signature_class,
749  .init = init,
750  .uninit = uninit,
752  .inputs = NULL,
755 };
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
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
put_bits32
static void av_unused put_bits32(PutBitContext *s, uint32_t value)
Write exactly 32 bits into a bitstream.
Definition: put_bits.h:291
StreamContext::coarsesiglist
CoarseSignature * coarsesiglist
Definition: signature.h:114
elements
static const ElemCat * elements[ELEMENT_COUNT]
Definition: signature.h:566
put_bytes_output
static int put_bytes_output(const PutBitContext *s)
Definition: put_bits.h:89
OFFSET
#define OFFSET(x)
Definition: vf_signature.c:37
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1018
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
signature_outputs
static const AVFilterPad signature_outputs[]
Definition: vf_signature.c:735
FineSignature::next
struct FineSignature * next
Definition: signature.h:73
FILTER_PIXFMTS_ARRAY
#define FILTER_PIXFMTS_ARRAY(array)
Definition: internal.h:162
set_bit
static void set_bit(uint8_t *data, size_t pos)
sets the bit at position pos to 1 in data
Definition: vf_signature.c:137
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
av_asprintf
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:115
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:62
FORMAT_BINARY
@ FORMAT_BINARY
Definition: signature.h:49
ElemCat::left_count
short left_count
Definition: signature.h:66
MatchingInfo
Definition: signature.h:90
StreamContext::curcoarsesig2
CoarseSignature * curcoarsesig2
Definition: signature.h:118
ElemCat::av_elem
int av_elem
Definition: signature.h:65
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:222
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:452
w
uint8_t w
Definition: llviddspenc.c:38
MatchingInfo::whole
int whole
Definition: signature.h:96
AVOption
AVOption.
Definition: opt.h:346
b
#define b
Definition: input.c:41
StreamContext::divide
int divide
Definition: signature.h:109
data
const char data[16]
Definition: mxf.c:148
MatchingInfo::score
int score
Definition: signature.h:93
ff_request_frame
int ff_request_frame(AVFilterLink *link)
Request an input frame from the filter at the other end of the link.
Definition: avfilter.c:462
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
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:170
av_get_frame_filename
int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
Definition: utils.c:353
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:361
FineSignature::pts
uint64_t pts
Definition: signature.h:75
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *picref)
Definition: vf_signature.c:143
FineSignature::index
uint32_t index
Definition: signature.h:76
signature_options
static const AVOption signature_options[]
Definition: vf_signature.c:41
StreamContext::exported
int exported
Definition: signature.h:124
av_strerror
int av_strerror(int errnum, char *errbuf, size_t errbuf_size)
Put a description of the AVERROR code errnum in errbuf.
Definition: error.c:108
lookup_signatures
static MatchingInfo lookup_signatures(AVFilterContext *ctx, SignatureContext *sc, StreamContext *first, StreamContext *second, int mode)
Definition: signature_lookup.c:533
SignatureContext::mode
int mode
Definition: signature.h:130
AVFILTER_FLAG_DYNAMIC_INPUTS
#define AVFILTER_FLAG_DYNAMIC_INPUTS
The number of the filter inputs is not determined just by AVFilter.inputs.
Definition: avfilter.h:106
AVRational::num
int num
Numerator.
Definition: rational.h:59
CoarseSignature::last
struct FineSignature * last
Definition: signature.h:85
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:33
signature
static const char signature[]
Definition: ipmovie.c:591
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
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
get_block_sum
static uint64_t get_block_sum(StreamContext *sc, uint64_t intpic[32][32], const Block *b)
Definition: vf_signature.c:105
av_cold
#define av_cold
Definition: attributes.h:90
ElemCat::blocks
const Block * blocks
Definition: signature.h:69
ElemCat
Definition: signature.h:64
mask
static const uint16_t mask[17]
Definition: lzw.c:38
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
MODE_FAST
@ MODE_FAST
Definition: signature.h:44
CoarseSignature::first
struct FineSignature * first
Definition: signature.h:84
SIGELEM_SIZE
#define SIGELEM_SIZE
Definition: signature.h:37
format
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 format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
g
const char * g
Definition: vf_curves.c:127
AV_OPT_TYPE_DOUBLE
@ AV_OPT_TYPE_DOUBLE
Definition: opt.h:237
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
SignatureContext::nb_inputs
int nb_inputs
Definition: signature.h:131
ctx
AVFormatContext * ctx
Definition: movenc.c:48
export
static int export(AVFilterContext *ctx, StreamContext *sc, int input)
Definition: vf_signature.c:558
ElemCat::block_count
short block_count
Definition: signature.h:67
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
NB_LOOKUP_MODE
@ NB_LOOKUP_MODE
Definition: signature.h:45
PutBitContext
Definition: put_bits.h:50
file_open.h
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
BLOCK_LCM
#define BLOCK_LCM
Definition: vf_signature.c:39
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
ff_vf_signature
const AVFilter ff_vf_signature
Definition: vf_signature.c:744
config_output
static int config_output(AVFilterLink *outlink)
Definition: vf_signature.c:721
av_log_get_level
int av_log_get_level(void)
Get the current log level.
Definition: log.c:442
NULL
#define NULL
Definition: coverity.c:32
fs
#define fs(width, name, subs,...)
Definition: cbs_vp9.c:200
signature.h
request_frame
static int request_frame(AVFilterLink *outlink)
Definition: vf_signature.c:577
ff_append_inpad_free_name
int ff_append_inpad_free_name(AVFilterContext *f, AVFilterPad *p)
Definition: avfilter.c:131
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
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_signature.c:686
cmp
static int cmp(const void *x, const void *y)
Definition: vf_signature.c:128
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
get_block_size
static int get_block_size(const Block *b)
Definition: vf_signature.c:100
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(signature)
StreamContext
Definition: transcode.c:53
Block
Definition: flashsv2enc.c:70
f
f
Definition: af_crystalizer.c:121
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:106
config_input
static int config_input(AVFilterLink *inlink)
Definition: vf_signature.c:83
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
signature_lookup.c
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: vf_signature.c:71
StreamContext::midcoarse
int midcoarse
Definition: signature.h:121
StreamContext::curfinesig
FineSignature * curfinesig
Definition: signature.h:112
StreamContext::h
int h
Definition: signature.h:106
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
input
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some input
Definition: filter_design.txt:172
th
#define th
Definition: regdef.h:75
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
FineSignature
Definition: signature.h:72
internal.h
SignatureContext
Definition: signature.h:127
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
lookup
int lookup
Definition: vorbis_enc_data.h:428
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
StreamContext::coarsecount
int coarsecount
Definition: signature.h:120
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
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:254
init
static av_cold int init(AVFilterContext *ctx)
Definition: vf_signature.c:633
AV_PIX_FMT_NV21
@ AV_PIX_FMT_NV21
as above, but U and V bytes are swapped
Definition: pixfmt.h:97
len
int len
Definition: vorbis_enc_data.h:426
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:39
xml_export
static int xml_export(AVFilterContext *ctx, StreamContext *sc, const char *filename)
Definition: vf_signature.c:374
avpriv_fopen_utf8
FILE * avpriv_fopen_utf8(const char *path, const char *mode)
Open a file using a UTF-8 filename.
Definition: file_open.c:159
MODE_OFF
@ MODE_OFF
Definition: signature.h:42
AVFilter
Filter definition.
Definition: avfilter.h:166
MODE_FULL
@ MODE_FULL
Definition: f_graphmonitor.c:69
ret
ret
Definition: filter_design.txt:187
AVFilterPad::type
enum AVMediaType type
AVFilterPad type.
Definition: internal.h:44
AV_PIX_FMT_NV12
@ AV_PIX_FMT_NV12
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition: pixfmt.h:96
pos
unsigned int pos
Definition: spdifenc.c:413
avformat.h
NB_FORMATS
@ NB_FORMATS
Definition: signature.h:51
CoarseSignature::data
uint8_t data[5][31]
Definition: signature.h:83
StreamContext::w
int w
Definition: signature.h:105
StreamContext::coarseend
CoarseSignature * coarseend
Definition: signature.h:115
CoarseSignature::next
struct CoarseSignature * next
Definition: signature.h:86
ElemCat::elem_count
short elem_count
Definition: signature.h:68
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
DIFFELEM_SIZE
#define DIFFELEM_SIZE
Definition: signature.h:38
AVRational::den
int den
Denominator.
Definition: rational.h:60
mode
mode
Definition: ebur128.h:83
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
FF_INLINK_IDX
#define FF_INLINK_IDX(link)
Find the index of a link.
Definition: internal.h:331
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:235
avfilter.h
ELEMENT_COUNT
#define ELEMENT_COUNT
Definition: signature.h:36
binary_export
static int binary_export(AVFilterContext *ctx, StreamContext *sc, const char *filename)
Definition: vf_signature.c:480
MatchingInfo::second
struct FineSignature * second
Definition: signature.h:98
SignatureContext::filename
char * filename
Definition: signature.h:132
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:78
FLAGS
#define FLAGS
Definition: vf_signature.c:38
AVFilterContext
An instance of a filter.
Definition: avfilter.h:407
StreamContext::curcoarsesig1
CoarseSignature * curcoarsesig1
Definition: signature.h:117
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:77
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:143
FORMAT_XML
@ FORMAT_XML
Definition: signature.h:50
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:183
SignatureContext::format
int format
Definition: signature.h:133
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
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
MatchingInfo::first
struct FineSignature * first
Definition: signature.h:97
StreamContext::finesiglist
FineSignature * finesiglist
Definition: signature.h:111
int32_t
int32_t
Definition: audioconvert.c:56
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:385
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_strlcpy
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:85
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
SignatureContext::streamcontexts
StreamContext * streamcontexts
Definition: signature.h:142
avstring.h
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:239
StreamContext::time_base
AVRational time_base
Definition: signature.h:103
int
int
Definition: ffmpeg_filter.c:425
put_bits.h
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:244
CoarseSignature
Definition: signature.h:82
MatchingInfo::matchframes
int matchframes
Definition: signature.h:95
StreamContext::lastindex
uint32_t lastindex
Definition: signature.h:122