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  if (!sc->coarseend->last)
383  return AVERROR(EINVAL); // No frames ?
384 
385  f = avpriv_fopen_utf8(filename, "w");
386  if (!f) {
387  int err = AVERROR(EINVAL);
388  char buf[128];
389  av_strerror(err, buf, sizeof(buf));
390  av_log(ctx, AV_LOG_ERROR, "cannot open xml file %s: %s\n", filename, buf);
391  return err;
392  }
393 
394  /* header */
395  fprintf(f, "<?xml version='1.0' encoding='ASCII' ?>\n");
396  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");
397  fprintf(f, " <DescriptionUnit xsi:type=\"DescriptorCollectionType\">\n");
398  fprintf(f, " <Descriptor xsi:type=\"VideoSignatureType\">\n");
399  fprintf(f, " <VideoSignatureRegion>\n");
400  fprintf(f, " <VideoSignatureSpatialRegion>\n");
401  fprintf(f, " <Pixel>0 0 </Pixel>\n");
402  fprintf(f, " <Pixel>%d %d </Pixel>\n", sc->w - 1, sc->h - 1);
403  fprintf(f, " </VideoSignatureSpatialRegion>\n");
404  fprintf(f, " <StartFrameOfSpatialRegion>0</StartFrameOfSpatialRegion>\n");
405  /* hoping num is 1, other values are vague */
406  fprintf(f, " <MediaTimeUnit>%d</MediaTimeUnit>\n", sc->time_base.den / sc->time_base.num);
407  fprintf(f, " <MediaTimeOfSpatialRegion>\n");
408  fprintf(f, " <StartMediaTimeOfSpatialRegion>0</StartMediaTimeOfSpatialRegion>\n");
409  fprintf(f, " <EndMediaTimeOfSpatialRegion>%" PRIu64 "</EndMediaTimeOfSpatialRegion>\n", sc->coarseend->last->pts);
410  fprintf(f, " </MediaTimeOfSpatialRegion>\n");
411 
412  /* coarsesignatures */
413  for (cs = sc->coarsesiglist; cs; cs = cs->next) {
414  fprintf(f, " <VSVideoSegment>\n");
415  fprintf(f, " <StartFrameOfSegment>%" PRIu32 "</StartFrameOfSegment>\n", cs->first->index);
416  fprintf(f, " <EndFrameOfSegment>%" PRIu32 "</EndFrameOfSegment>\n", cs->last->index);
417  fprintf(f, " <MediaTimeOfSegment>\n");
418  fprintf(f, " <StartMediaTimeOfSegment>%" PRIu64 "</StartMediaTimeOfSegment>\n", cs->first->pts);
419  fprintf(f, " <EndMediaTimeOfSegment>%" PRIu64 "</EndMediaTimeOfSegment>\n", cs->last->pts);
420  fprintf(f, " </MediaTimeOfSegment>\n");
421  for (i = 0; i < 5; i++) {
422  fprintf(f, " <BagOfWords>");
423  for (j = 0; j < 31; j++) {
424  uint8_t n = cs->data[i][j];
425  if (j < 30) {
426  fprintf(f, "%d %d %d %d %d %d %d %d ", (n & 0x80) >> 7,
427  (n & 0x40) >> 6,
428  (n & 0x20) >> 5,
429  (n & 0x10) >> 4,
430  (n & 0x08) >> 3,
431  (n & 0x04) >> 2,
432  (n & 0x02) >> 1,
433  (n & 0x01));
434  } else {
435  /* print only 3 bit in last byte */
436  fprintf(f, "%d %d %d ", (n & 0x80) >> 7,
437  (n & 0x40) >> 6,
438  (n & 0x20) >> 5);
439  }
440  }
441  fprintf(f, "</BagOfWords>\n");
442  }
443  fprintf(f, " </VSVideoSegment>\n");
444  }
445 
446  /* finesignatures */
447  for (fs = sc->finesiglist; fs; fs = fs->next) {
448  fprintf(f, " <VideoFrame>\n");
449  fprintf(f, " <MediaTimeOfFrame>%" PRIu64 "</MediaTimeOfFrame>\n", fs->pts);
450  /* confidence */
451  fprintf(f, " <FrameConfidence>%d</FrameConfidence>\n", fs->confidence);
452  /* words */
453  fprintf(f, " <Word>");
454  for (i = 0; i < 5; i++) {
455  fprintf(f, "%d ", fs->words[i]);
456  if (i < 4) {
457  fprintf(f, " ");
458  }
459  }
460  fprintf(f, "</Word>\n");
461  /* framesignature */
462  fprintf(f, " <FrameSignature>");
463  for (i = 0; i< SIGELEM_SIZE/5; i++) {
464  if (i > 0) {
465  fprintf(f, " ");
466  }
467  fprintf(f, "%d ", fs->framesig[i] / pot3[0]);
468  for (j = 1; j < 5; j++)
469  fprintf(f, " %d ", fs->framesig[i] % pot3[j-1] / pot3[j] );
470  }
471  fprintf(f, "</FrameSignature>\n");
472  fprintf(f, " </VideoFrame>\n");
473  }
474  fprintf(f, " </VideoSignatureRegion>\n");
475  fprintf(f, " </Descriptor>\n");
476  fprintf(f, " </DescriptionUnit>\n");
477  fprintf(f, "</Mpeg7>\n");
478 
479  fclose(f);
480  return 0;
481 }
482 
483 static int binary_export(AVFilterContext *ctx, StreamContext *sc, const char* filename)
484 {
485  FILE* f;
486  FineSignature* fs;
487  CoarseSignature* cs;
488  uint32_t numofsegments = (sc->lastindex + 44)/45;
489  int i, j;
490  PutBitContext buf;
491  /* buffer + header + coarsesignatures + finesignature */
492  int len = (512 + 6 * 32 + 3*16 + 2 +
493  numofsegments * (4*32 + 1 + 5*243) +
494  sc->lastindex * (2 + 32 + 6*8 + 608)) / 8;
495  uint8_t* buffer = av_malloc_array(len, sizeof(uint8_t));
496  if (!buffer)
497  return AVERROR(ENOMEM);
498 
499  f = avpriv_fopen_utf8(filename, "wb");
500  if (!f) {
501  int err = AVERROR(EINVAL);
502  char buf[128];
503  av_strerror(err, buf, sizeof(buf));
504  av_log(ctx, AV_LOG_ERROR, "cannot open file %s: %s\n", filename, buf);
505  av_freep(&buffer);
506  return err;
507  }
508  init_put_bits(&buf, buffer, len);
509 
510  put_bits32(&buf, 1); /* NumOfSpatial Regions, only 1 supported */
511  put_bits(&buf, 1, 1); /* SpatialLocationFlag, always the whole image */
512  put_bits32(&buf, 0); /* PixelX,1 PixelY,1, 0,0 */
513  put_bits(&buf, 16, sc->w-1 & 0xFFFF); /* PixelX,2 */
514  put_bits(&buf, 16, sc->h-1 & 0xFFFF); /* PixelY,2 */
515  put_bits32(&buf, 0); /* StartFrameOfSpatialRegion */
516  put_bits32(&buf, sc->lastindex); /* NumOfFrames */
517  /* hoping num is 1, other values are vague */
518  /* den/num might be greater than 16 bit, so cutting it */
519  put_bits(&buf, 16, 0xFFFF & (sc->time_base.den / sc->time_base.num)); /* MediaTimeUnit */
520  put_bits(&buf, 1, 1); /* MediaTimeFlagOfSpatialRegion */
521  put_bits32(&buf, 0); /* StartMediaTimeOfSpatialRegion */
522  put_bits32(&buf, 0xFFFFFFFF & sc->coarseend->last->pts); /* EndMediaTimeOfSpatialRegion */
523  put_bits32(&buf, numofsegments); /* NumOfSegments */
524  /* coarsesignatures */
525  for (cs = sc->coarsesiglist; cs; cs = cs->next) {
526  put_bits32(&buf, cs->first->index); /* StartFrameOfSegment */
527  put_bits32(&buf, cs->last->index); /* EndFrameOfSegment */
528  put_bits(&buf, 1, 1); /* MediaTimeFlagOfSegment */
529  put_bits32(&buf, 0xFFFFFFFF & cs->first->pts); /* StartMediaTimeOfSegment */
530  put_bits32(&buf, 0xFFFFFFFF & cs->last->pts); /* EndMediaTimeOfSegment */
531  for (i = 0; i < 5; i++) {
532  /* put 243 bits ( = 7 * 32 + 19 = 8 * 28 + 19) into buffer */
533  for (j = 0; j < 30; j++) {
534  put_bits(&buf, 8, cs->data[i][j]);
535  }
536  put_bits(&buf, 3, cs->data[i][30] >> 5);
537  }
538  }
539  /* finesignatures */
540  put_bits(&buf, 1, 0); /* CompressionFlag, only 0 supported */
541  for (fs = sc->finesiglist; fs; fs = fs->next) {
542  put_bits(&buf, 1, 1); /* MediaTimeFlagOfFrame */
543  put_bits32(&buf, 0xFFFFFFFF & fs->pts); /* MediaTimeOfFrame */
544  put_bits(&buf, 8, fs->confidence); /* FrameConfidence */
545  for (i = 0; i < 5; i++) {
546  put_bits(&buf, 8, fs->words[i]); /* Words */
547  }
548  /* framesignature */
549  for (i = 0; i < SIGELEM_SIZE/5; i++) {
550  put_bits(&buf, 8, fs->framesig[i]);
551  }
552  }
553 
554  flush_put_bits(&buf);
555  fwrite(buffer, 1, put_bytes_output(&buf), f);
556  fclose(f);
557  av_freep(&buffer);
558  return 0;
559 }
560 
562 {
563  SignatureContext* sic = ctx->priv;
564  char filename[1024];
565 
566  if (sic->nb_inputs > 1) {
567  /* error already handled */
568  av_assert0(av_get_frame_filename(filename, sizeof(filename), sic->filename, input) == 0);
569  } else {
570  if (av_strlcpy(filename, sic->filename, sizeof(filename)) >= sizeof(filename))
571  return AVERROR(EINVAL);
572  }
573  if (sic->format == FORMAT_XML) {
574  return xml_export(ctx, sc, filename);
575  } else {
576  return binary_export(ctx, sc, filename);
577  }
578 }
579 
580 static int request_frame(AVFilterLink *outlink)
581 {
582  AVFilterContext *ctx = outlink->src;
583  SignatureContext *sic = ctx->priv;
584  StreamContext *sc, *sc2;
585  MatchingInfo match;
586  int i, j, ret;
587  int lookup = 1; /* indicates wheather EOF of all files is reached */
588 
589  /* process all inputs */
590  for (i = 0; i < sic->nb_inputs; i++){
591  sc = &(sic->streamcontexts[i]);
592 
593  ret = ff_request_frame(ctx->inputs[i]);
594 
595  /* return if unexpected error occurs in input stream */
596  if (ret < 0 && ret != AVERROR_EOF)
597  return ret;
598 
599  /* export signature at EOF */
600  if (ret == AVERROR_EOF && !sc->exported) {
601  /* export if wanted */
602  if (strlen(sic->filename) > 0) {
603  if (export(ctx, sc, i) < 0)
604  return ret;
605  }
606  sc->exported = 1;
607  }
608  lookup &= sc->exported;
609  }
610 
611  /* signature lookup */
612  if (lookup && sic->mode != MODE_OFF) {
613  /* iterate over every pair */
614  for (i = 0; i < sic->nb_inputs; i++) {
615  sc = &(sic->streamcontexts[i]);
616  for (j = i+1; j < sic->nb_inputs; j++) {
617  sc2 = &(sic->streamcontexts[j]);
618  match = lookup_signatures(ctx, sic, sc, sc2, sic->mode);
619  if (match.score != 0) {
620  av_log(ctx, AV_LOG_INFO, "matching of video %d at %f and %d at %f, %d frames matching\n",
621  i, ((double) match.first->pts * sc->time_base.num) / sc->time_base.den,
622  j, ((double) match.second->pts * sc2->time_base.num) / sc2->time_base.den,
623  match.matchframes);
624  if (match.whole)
625  av_log(ctx, AV_LOG_INFO, "whole video matching\n");
626  } else {
627  av_log(ctx, AV_LOG_INFO, "no matching of video %d and %d\n", i, j);
628  }
629  }
630  }
631  }
632 
633  return ret;
634 }
635 
637 {
638 
639  SignatureContext *sic = ctx->priv;
640  StreamContext *sc;
641  int i, ret;
642  char tmp[1024];
643 
644  sic->streamcontexts = av_mallocz(sic->nb_inputs * sizeof(StreamContext));
645  if (!sic->streamcontexts)
646  return AVERROR(ENOMEM);
647 
648  for (i = 0; i < sic->nb_inputs; i++) {
649  AVFilterPad pad = {
651  .name = av_asprintf("in%d", i),
652  .config_props = config_input,
653  .filter_frame = filter_frame,
654  };
655 
656  if (!pad.name)
657  return AVERROR(ENOMEM);
658  if ((ret = ff_append_inpad_free_name(ctx, &pad)) < 0)
659  return ret;
660 
661  sc = &(sic->streamcontexts[i]);
662 
663  sc->lastindex = 0;
664  sc->finesiglist = av_mallocz(sizeof(FineSignature));
665  if (!sc->finesiglist)
666  return AVERROR(ENOMEM);
667  sc->curfinesig = NULL;
668 
670  if (!sc->coarsesiglist)
671  return AVERROR(ENOMEM);
672  sc->curcoarsesig1 = sc->coarsesiglist;
673  sc->coarseend = sc->coarsesiglist;
674  sc->coarsecount = 0;
675  sc->midcoarse = 0;
676  }
677 
678  /* check filename */
679  if (sic->nb_inputs > 1 && strlen(sic->filename) > 0 && av_get_frame_filename(tmp, sizeof(tmp), sic->filename, 0) == -1) {
680  av_log(ctx, AV_LOG_ERROR, "The filename must contain %%d or %%0nd, if you have more than one input.\n");
681  return AVERROR(EINVAL);
682  }
683 
684  return 0;
685 }
686 
687 
688 
690 {
691  SignatureContext *sic = ctx->priv;
692  StreamContext *sc;
693  void* tmp;
694  FineSignature* finsig;
695  CoarseSignature* cousig;
696  int i;
697 
698 
699  /* free the lists */
700  if (sic->streamcontexts != NULL) {
701  for (i = 0; i < sic->nb_inputs; i++) {
702  sc = &(sic->streamcontexts[i]);
703  finsig = sc->finesiglist;
704  cousig = sc->coarsesiglist;
705 
706  while (finsig) {
707  tmp = finsig;
708  finsig = finsig->next;
709  av_freep(&tmp);
710  }
711  sc->finesiglist = NULL;
712 
713  while (cousig) {
714  tmp = cousig;
715  cousig = cousig->next;
716  av_freep(&tmp);
717  }
718  sc->coarsesiglist = NULL;
719  }
720  av_freep(&sic->streamcontexts);
721  }
722 }
723 
724 static int config_output(AVFilterLink *outlink)
725 {
726  AVFilterContext *ctx = outlink->src;
727  AVFilterLink *inlink = ctx->inputs[0];
728 
729  outlink->time_base = inlink->time_base;
730  outlink->frame_rate = inlink->frame_rate;
731  outlink->sample_aspect_ratio = inlink->sample_aspect_ratio;
732  outlink->w = inlink->w;
733  outlink->h = inlink->h;
734 
735  return 0;
736 }
737 
738 static const AVFilterPad signature_outputs[] = {
739  {
740  .name = "default",
741  .type = AVMEDIA_TYPE_VIDEO,
742  .request_frame = request_frame,
743  .config_props = config_output,
744  },
745 };
746 
748  .name = "signature",
749  .description = NULL_IF_CONFIG_SMALL("Calculate the MPEG-7 video signature"),
750  .priv_size = sizeof(SignatureContext),
751  .priv_class = &signature_class,
752  .init = init,
753  .uninit = uninit,
755  .inputs = NULL,
758 };
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:738
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:375
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:487
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:396
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:561
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:747
config_output
static int config_output(AVFilterLink *outlink)
Definition: vf_signature.c:724
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:580
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:689
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:636
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
ret
ret
Definition: filter_design.txt:187
AVFilterPad::type
enum AVMediaType type
AVFilterPad type.
Definition: internal.h:44
MODE_FULL
@ MODE_FULL
Definition: f_graphmonitor.c:69
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:483
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:420
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:410
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