Go to the documentation of this file.
29 #define HOUGH_MAX_OFFSET 90
30 #define MAX_FRAMERATE 60
34 #define DIR_PREV_END 2
35 #define DIR_NEXT_END 3
38 #define STATUS_END_REACHED 1
39 #define STATUS_BEGIN_REACHED 2
53 int i, j, tmp_i, tmp_j,count;
56 for (
i = 0, count = 0;
i < 242;
i++) {
57 for (j =
i + 1; j < 243; j++, count++) {
62 dist +=
FFABS((tmp_j % 3) - (tmp_i % 3));
65 }
while (tmp_i > 0 || tmp_j > 0);
74 for (
i = 0;
i < 28;
i += 4) {
76 (
first[
i+1] & second[
i+1]) << 16 |
77 (
first[
i+2] & second[
i+2]) << 8 |
81 (
first[29] & second[29]) << 8 |
82 (
first[30] & second[30]) );
89 for (
i = 0;
i < 28;
i += 4) {
91 (
first[
i+1] | second[
i+1]) << 16 |
92 (
first[
i+2] | second[
i+2]) << 8 |
96 (
first[29] | second[29]) << 8 |
97 (
first[30] | second[30]) );
104 unsigned int dist = 0;
113 dist += sc->
l1distlut[243*242/2 - (243-
s)*(242-
s)/2 +
f -
s - 1];
115 dist += sc->
l1distlut[243*242/2 - (243-
f)*(242-
f)/2 +
s -
f - 1];
128 int jaccarddist,
i, composdist = 0, cwthcount = 0;
129 for (
i = 0;
i < 5;
i++) {
134 if (++cwthcount > 2) {
139 composdist += jaccarddist;
155 if ((*second)->next) {
156 *second = (*second)->
next;
157 }
else if ((*first)->next) {
158 *second = secondstart;
159 *
first = (*first)->next;
170 if ((*second)->next) {
171 *second = (*second)->
next;
172 }
else if ((*first)->next) {
173 *second = secondstart;
174 *
first = (*first)->next;
188 size_t i, j, k, l, hmax = 0, score;
201 typedef struct hspace_elem {
210 hspace_elem *hspaces;
221 hspace[
i][j].score = 0;
222 hspace[
i][j].dist = 99999;
229 pairs[
i].dist = 99999;
231 for (j = 0,
s = second; j <
COARSE_SIZE &&
s->next; j++,
s =
s->next) {
234 if (l1dist < sc->thl1) {
235 if (l1dist < pairs[
i].dist) {
237 pairs[
i].dist = l1dist;
238 pairs[
i].b_pos[0] = j;
240 }
else if (l1dist == pairs[
i].dist) {
241 pairs[
i].b[pairs[
i].size] =
s;
242 pairs[
i].b_pos[pairs[
i].size] = j;
249 if (
f->next ==
NULL) {
252 pairs[
i].dist = 99999;
258 for (j = 0; j < pairs[
i].size; j++) {
260 for (l = 0; l < pairs[k].size; l++) {
261 if (pairs[
i].
b[j] != pairs[k].
b[l]) {
263 m = (pairs[k].b_pos[l]-pairs[
i].b_pos[j]) / (k-
i);
268 if (pairs[
i].dist < pairs[k].dist) {
295 hmax = (
int) (0.7*hmax);
298 if (hmax < hspace[
i][j].score) {
305 c->framerateratio = (
i+1.0) / 30;
306 c->score = hspace[
i][j].score;
308 c->first = hspace[
i][j].a;
309 c->second = hspace[
i][j].b;
331 step = ((
int) 0.5 + fcount * frr)
332 -((
int) 0.5 + (fcount-1) * frr);
350 if ((*b)->next && (*b)->next->next) {
351 *
b = (*b)->next->next;
372 if ((*a)->next && (*a)->next->next) {
373 *
a = (*a)->next->next;
396 if ((*b)->prev && (*b)->prev->prev) {
397 *
b = (*b)->prev->prev;
418 if ((*a)->prev && (*a)->prev->prev) {
419 *
a = (*a)->prev->prev;
431 int dist, distsum = 0, bcount = 1, dir =
DIR_NEXT;
432 int fcount = 0, goodfcount = 0, gooda = 0, goodb = 0;
433 double meandist, minmeandist = bestmatch.
meandist;
434 int tolerancecount = 0;
438 for (; infos !=
NULL; infos = infos->
next) {
444 if (dist > sc->
thl1) {
445 if (
a->confidence >= 1 ||
b->confidence >= 1) {
450 if (tolerancecount > 2) {
471 if (
a->confidence < 1) gooda++;
472 if (
b->confidence < 1) goodb++;
490 if (sc->
thdi != 0 && bcount >= sc->
thdi) {
495 if (bcount < sc->thdi)
497 if ((
double) goodfcount / (
double) fcount < sc->thit)
499 if ((
double) goodfcount*0.5 <
FFMAX(gooda, goodb))
502 meandist = (
double) goodfcount / (
double) distsum;
504 if (meandist < minmeandist ||
507 minmeandist = meandist;
541 cs =
first->coarsesiglist;
556 "indices of first frame: %"PRIu32
" and %"PRIu32
"\n",
562 for (
i = infos;
i !=
NULL;
i =
i->next) {
564 "ratio %f, offset %d\n",
i->first->index,
i->second->index,
565 i->framerateratio,
i->offset);
573 "ratio %f, offset %d, score %d, %d frames matching\n",
static void error(const char *err)
CoarseSignature * coarsesiglist
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
uint8_t l1distlut[243 *242/2]
static void fill_l1distlut(uint8_t lut[])
static MatchingInfo lookup_signatures(AVFilterContext *ctx, SignatureContext *sc, StreamContext *first, StreamContext *second, int mode)
static double val(void *priv, double ch)
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But first
static MatchingInfo evaluate_parameters(AVFilterContext *ctx, SignatureContext *sc, MatchingInfo *infos, MatchingInfo bestmatch, int mode)
#define STATUS_END_REACHED
struct FineSignature * first
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
int av_log_get_level(void)
Get the current log level.
static MatchingInfo * get_matching_parameters(AVFilterContext *ctx, SignatureContext *sc, FineSignature *first, FineSignature *second)
compares framesignatures and sorts out signatures with a l1 distance above a given threshold.
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
static void sll_free(MatchingInfo **sll)
static int get_jaccarddist(SignatureContext *sc, CoarseSignature *first, CoarseSignature *second)
calculates the jaccard distance and evaluates a pair of coarse signatures as good
static int iterate_frame(double frr, FineSignature **a, FineSignature **b, int fcount, int *bcount, int dir)
static unsigned int union_word(const uint8_t *first, const uint8_t *second)
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
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 offset
static unsigned int get_l1dist(AVFilterContext *ctx, SignatureContext *sc, const uint8_t *first, const uint8_t *second)
#define i(width, name, range_min, range_max)
static int find_next_coarsecandidate(SignatureContext *sc, CoarseSignature *secondstart, CoarseSignature **first, CoarseSignature **second, int start)
step through the coarsesignatures as long as a good candidate is found
struct CoarseSignature * next
struct FineSignature * second
struct MatchingInfo * next
struct FineSignature * first
static unsigned int intersection_word(const uint8_t *first, const uint8_t *second)
#define STATUS_BEGIN_REACHED