static uint32_t get_generic_seed(void) { clock_t last_t=0; int bits=0; uint64_t random=0; unsigned i; float s=0.000000000001; for(i=0;bits<64;i++){ #ifdef AV_READ_TIME clock_t t = AV_READ_TIME(); #else clock_t t = clock(); #endif if(last_t && fabs(t-last_t)>s || t==(clock_t)-1){ if(i<10000 && s<(1<<24)){ s+=s; i=t=0; }else{ random= 2*random + (i&1); bits++; } } last_t= t; } #ifdef AV_READ_TIME random ^= AV_READ_TIME(); #else random ^= clock(); #endif random += random>>32; return random; }
static void probe(AVProbeData *pd, int type, int p, int size) { int i = 0; AVInputFormat *fmt = NULL; while ((fmt = av_iformat_next(fmt))) { if (fmt->flags & AVFMT_NOFILE) continue; if (fmt->read_probe && (!single_format || !strcmp(single_format, fmt->name)) ) { int score; int64_t start = AV_READ_TIME(); score = fmt->read_probe(pd); time_array[i] += AV_READ_TIME() - start; if (score > score_array[i] && score > AVPROBE_SCORE_MAX / 4) { score_array[i] = score; fprintf(stderr, "Failure of %s probing code with score=%d type=%d p=%X size=%d\n", fmt->name, score, type, p, size); failures++; } } i++; } }
static void run_implementation(const uint8_t *input, uint8_t *output, struct hash_impl *impl, unsigned size) { uint64_t t0, t1; unsigned nruns = specified_runs ? specified_runs : (1 << 30) / size; unsigned outlen = 0, outcrc = 0; unsigned i, j, val; double mtime, ttime = 0, ttime2 = 0, stime; uint8_t outref[MAX_OUTPUT_SIZE]; if (enabled_libs && !av_stristr(enabled_libs, impl->lib) || enabled_algos && !av_stristr(enabled_algos, impl->name)) return; if (!sscanf(impl->output, "crc:%x", &outcrc)) { outlen = strlen(impl->output) / 2; for (i = 0; i < outlen; i++) { sscanf(impl->output + i * 2, "%02x", &val); outref[i] = val; } } for (i = 0; i < 8; i++) /* heat caches */ impl->run(output, input, size); for (i = 0; i < nruns; i++) { memset(output, 0, size); /* avoid leftovers from previous runs */ t0 = AV_READ_TIME(); impl->run(output, input, size); t1 = AV_READ_TIME(); if (outlen ? memcmp(output, outref, outlen) : crc32(output, size) != outcrc) { fprintf(stderr, "Expected: "); if (outlen) for (j = 0; j < outlen; j++) fprintf(stderr, "%02x", output[j]); else fprintf(stderr, "%08x", crc32(output, size)); fprintf(stderr, "\n"); fatal_error("output mismatch"); } mtime = (double)(t1 - t0) / size; ttime += mtime; ttime2 += mtime * mtime; } ttime /= nruns; ttime2 /= nruns; stime = sqrt(ttime2 - ttime * ttime); printf("%-10s %-12s size: %7d runs: %6d time: %8.3f +- %.3f\n", impl->lib, impl->name, size, nruns, ttime, stime); fflush(stdout); }
static uint32_t get_generic_seed(void) { uint8_t tmp[120]; struct AVSHA *sha = (void*)tmp; clock_t last_t = 0; static uint64_t i = 0; static uint32_t buffer[512] = { 0 }; unsigned char digest[20]; uint64_t last_i = i; av_assert0(sizeof(tmp) >= av_sha_size); if(TEST){ memset(buffer, 0, sizeof(buffer)); last_i = i = 0; }else{ #ifdef AV_READ_TIME buffer[13] ^= AV_READ_TIME(); buffer[41] ^= AV_READ_TIME()>>32; #endif } for (;;) { clock_t t = clock(); if (last_t == t) { buffer[i & 511]++; } else { buffer[++i & 511] += (t - last_t) % 3294638521U; if (last_i && i - last_i > 4 || i - last_i > 64 || TEST && i - last_i > 8) break; } last_t = t; } if(TEST) { buffer[0] = buffer[1] = 0; } else { #ifdef AV_READ_TIME buffer[111] += AV_READ_TIME(); #endif } av_sha_init(sha, 160); av_sha_update(sha, (const uint8_t *)buffer, sizeof(buffer)); av_sha_final(sha, digest); return AV_RB32(digest) + AV_RB32(digest + 16); }
int main(int argc, char **argv) { unsigned int p, i, type, size, retry; AVProbeData pd = { 0 }; AVLFG state; PutBitContext pb; int retry_count= 4097; int max_size = 65537; int j; for (j = i = 1; i<argc; i++) { if (!strcmp(argv[i], "-f") && i+1<argc && !single_format) { single_format = argv[++i]; } else if (read_int(argv[i])>0 && j == 1) { retry_count = read_int(argv[i]); j++; } else if (read_int(argv[i])>0 && j == 2) { max_size = read_int(argv[i]); j++; } else { fprintf(stderr, "probetest [-f <input format>] [<retry_count> [<max_size>]]\n"); return 1; } } if (max_size > 1000000000U/8) { fprintf(stderr, "max_size out of bounds\n"); return 1; } if (retry_count > 1000000000U) { fprintf(stderr, "retry_count out of bounds\n"); return 1; } av_lfg_init(&state, 0xdeadbeef); pd.buf = NULL; for (size = 1; size < max_size; size *= 2) { pd.buf_size = size; pd.buf = av_realloc(pd.buf, size + AVPROBE_PADDING_SIZE); pd.filename = ""; if (!pd.buf) { fprintf(stderr, "out of memory\n"); return 1; } memset(pd.buf, 0, size + AVPROBE_PADDING_SIZE); fprintf(stderr, "testing size=%d\n", size); for (retry = 0; retry < retry_count; retry += FFMAX(size, 32)) { for (type = 0; type < 4; type++) { for (p = 0; p < 4096; p++) { unsigned hist = 0; init_put_bits(&pb, pd.buf, size); switch (type) { case 0: for (i = 0; i < size * 8; i++) put_bits(&pb, 1, (av_lfg_get(&state) & 0xFFFFFFFF) > p << 20); break; case 1: for (i = 0; i < size * 8; i++) { unsigned int p2 = hist ? p & 0x3F : (p >> 6); unsigned int v = (av_lfg_get(&state) & 0xFFFFFFFF) > p2 << 26; put_bits(&pb, 1, v); hist = v; } break; case 2: for (i = 0; i < size * 8; i++) { unsigned int p2 = (p >> (hist * 3)) & 7; unsigned int v = (av_lfg_get(&state) & 0xFFFFFFFF) > p2 << 29; put_bits(&pb, 1, v); hist = (2 * hist + v) & 3; } break; case 3: for (i = 0; i < size; i++) { int c = 0; while (p & 63) { c = (av_lfg_get(&state) & 0xFFFFFFFF) >> 24; if (c >= 'a' && c <= 'z' && (p & 1)) break; else if (c >= 'A' && c <= 'Z' && (p & 2)) break; else if (c >= '0' && c <= '9' && (p & 4)) break; else if (c == ' ' && (p & 8)) break; else if (c == 0 && (p & 16)) break; else if (c == 1 && (p & 32)) break; } pd.buf[i] = c; } } flush_put_bits(&pb); probe(&pd, type, p, size); } } } } if(AV_READ_TIME()) print_times(); return failures; }