FFmpeg
probetest.c
Go to the documentation of this file.
1 /*
2  * copyright (c) 2009 Michael Niedermayer <michaelni@gmx.at>
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (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 GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include <stdlib.h>
22 
23 #include "libavformat/avformat.h"
24 #include "libavcodec/put_bits.h"
25 #include "libavutil/lfg.h"
26 #include "libavutil/timer.h"
27 
28 #define MAX_FORMATS 1000 //this must be larger than the number of formats
30 static int64_t time_array[MAX_FORMATS];
31 static int failures = 0;
32 static const char *single_format;
33 
34 #ifndef AV_READ_TIME
35 #define AV_READ_TIME(x) 0
36 #endif
37 
38 static void probe(AVProbeData *pd, int type, int p, int size)
39 {
40  int i = 0;
41  const AVInputFormat *fmt = NULL;
42  void *fmt_opaque = NULL;
43 
44  while ((fmt = av_demuxer_iterate(&fmt_opaque))) {
45  if (fmt->flags & AVFMT_NOFILE)
46  continue;
47  if (fmt->read_probe &&
48  (!single_format || !strcmp(single_format, fmt->name))
49  ) {
50  int score;
51  int64_t start = AV_READ_TIME();
52  score = fmt->read_probe(pd);
53  time_array[i] += AV_READ_TIME() - start;
54  if (score > score_array[i] && score > AVPROBE_SCORE_MAX / 4) {
55  score_array[i] = score;
56  fprintf(stderr,
57  "Failure of %s probing code with score=%d type=%d p=%X size=%d\n",
58  fmt->name, score, type, p, size);
59  failures++;
60  }
61  }
62  i++;
63  }
64 }
65 
66 static void print_times(void)
67 {
68  int i = 0;
69  const AVInputFormat *fmt = NULL;
70  void *fmt_opaque = NULL;
71 
72  while ((fmt = av_demuxer_iterate(&fmt_opaque))) {
73  if (fmt->flags & AVFMT_NOFILE)
74  continue;
75  if (time_array[i] > 1000000) {
76  fprintf(stderr, "%12"PRIu64" cycles, %12s\n",
77  time_array[i], fmt->name);
78  }
79  i++;
80  }
81 }
82 
83 static int read_int(char *arg) {
84  int ret;
85 
86  if (!arg || !*arg)
87  return -1;
88  ret = strtol(arg, &arg, 0);
89  if (*arg)
90  return -1;
91  return ret;
92 }
93 
94 int main(int argc, char **argv)
95 {
96  unsigned int p, i, type, size, retry;
97  AVProbeData pd = { 0 };
98  AVLFG state;
99  PutBitContext pb;
100  int retry_count= 4097;
101  int max_size = 65537;
102  int j;
103 
104  for (j = i = 1; i<argc; i++) {
105  if (!strcmp(argv[i], "-f") && i+1<argc && !single_format) {
106  single_format = argv[++i];
107  } else if (read_int(argv[i])>0 && j == 1) {
108  retry_count = read_int(argv[i]);
109  j++;
110  } else if (read_int(argv[i])>0 && j == 2) {
111  max_size = read_int(argv[i]);
112  j++;
113  } else {
114  fprintf(stderr, "probetest [-f <input format>] [<retry_count> [<max_size>]]\n");
115  return 1;
116  }
117  }
118 
119  if (max_size > 1000000000U/8) {
120  fprintf(stderr, "max_size out of bounds\n");
121  return 1;
122  }
123 
124  if (retry_count > 1000000000U) {
125  fprintf(stderr, "retry_count out of bounds\n");
126  return 1;
127  }
128 
129  av_lfg_init(&state, 0xdeadbeef);
130 
131  pd.buf = NULL;
132  for (size = 1; size < max_size; size *= 2) {
133  pd.buf_size = size;
135  pd.filename = "";
136 
137  if (!pd.buf) {
138  fprintf(stderr, "out of memory\n");
139  return 1;
140  }
141 
142  memset(pd.buf, 0, size + AVPROBE_PADDING_SIZE);
143 
144  fprintf(stderr, "testing size=%d\n", size);
145 
146  for (retry = 0; retry < retry_count; retry += FFMAX(size, 32)) {
147  for (type = 0; type < 4; type++) {
148  for (p = 0; p < 4096; p++) {
149  unsigned hist = 0;
150  init_put_bits(&pb, pd.buf, size);
151  switch (type) {
152  case 0:
153  for (i = 0; i < size * 8; i++)
154  put_bits(&pb, 1, (av_lfg_get(&state) & 0xFFFFFFFF) > p << 20);
155  break;
156  case 1:
157  for (i = 0; i < size * 8; i++) {
158  unsigned int p2 = hist ? p & 0x3F : (p >> 6);
159  unsigned int v = (av_lfg_get(&state) & 0xFFFFFFFF) > p2 << 26;
160  put_bits(&pb, 1, v);
161  hist = v;
162  }
163  break;
164  case 2:
165  for (i = 0; i < size * 8; i++) {
166  unsigned int p2 = (p >> (hist * 3)) & 7;
167  unsigned int v = (av_lfg_get(&state) & 0xFFFFFFFF) > p2 << 29;
168  put_bits(&pb, 1, v);
169  hist = (2 * hist + v) & 3;
170  }
171  break;
172  case 3:
173  for (i = 0; i < size; i++) {
174  int c = 0;
175  while (p & 63) {
176  c = (av_lfg_get(&state) & 0xFFFFFFFF) >> 24;
177  if (c >= 'a' && c <= 'z' && (p & 1))
178  break;
179  else if (c >= 'A' && c <= 'Z' && (p & 2))
180  break;
181  else if (c >= '0' && c <= '9' && (p & 4))
182  break;
183  else if (c == ' ' && (p & 8))
184  break;
185  else if (c == 0 && (p & 16))
186  break;
187  else if (c == 1 && (p & 32))
188  break;
189  }
190  pd.buf[i] = c;
191  }
192  }
193  flush_put_bits(&pb);
194  probe(&pd, type, p, size);
195  }
196  }
197  }
198  }
199  if(AV_READ_TIME())
200  print_times();
201  return failures;
202 }
MAX_FORMATS
#define MAX_FORMATS
Definition: probetest.c:28
av_lfg_init
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
Definition: lfg.c:32
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:61
state
static struct @321 state
main
int main(int argc, char **argv)
Definition: probetest.c:94
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:218
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:444
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:453
U
#define U(x)
Definition: vp56_arith.h:37
score_array
static int score_array[MAX_FORMATS]
Definition: probetest.c:29
type
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 type
Definition: writing_filters.txt:86
AVPROBE_PADDING_SIZE
#define AVPROBE_PADDING_SIZE
extra allocated bytes at the end of the probe buffer
Definition: avformat.h:455
AVInputFormat
Definition: avformat.h:616
av_lfg_get
static unsigned int av_lfg_get(AVLFG *c)
Get the next random unsigned 32-bit number using an ALFG.
Definition: lfg.h:53
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:621
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:443
AVProbeData::filename
const char * filename
Definition: avformat.h:442
lfg.h
read_int
static int read_int(char *arg)
Definition: probetest.c:83
time_array
static int64_t time_array[MAX_FORMATS]
Definition: probetest.c:30
PutBitContext
Definition: put_bits.h:49
arg
const char * arg
Definition: jacosubdec.c:67
NULL
#define NULL
Definition: coverity.c:32
AVInputFormat::read_probe
int(* read_probe)(const AVProbeData *)
Tell if a given file has a chance of being parsed as this format.
Definition: avformat.h:677
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:441
timer.h
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
AVLFG
Context structure for the Lagged Fibonacci PRNG.
Definition: lfg.h:33
FFMAX
#define FFMAX(a, b)
Definition: common.h:103
size
int size
Definition: twinvq_data.h:10344
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:458
av_demuxer_iterate
const AVInputFormat * av_demuxer_iterate(void **opaque)
Iterate over all registered demuxers.
Definition: allformats.c:554
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:134
i
int i
Definition: input.c:407
single_format
static const char * single_format
Definition: probetest.c:32
ret
ret
Definition: filter_design.txt:187
avformat.h
AVInputFormat::flags
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_NOTIMESTAMPS,...
Definition: avformat.h:635
AV_READ_TIME
#define AV_READ_TIME(x)
Definition: probetest.c:35
failures
static int failures
Definition: probetest.c:31
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:142
print_times
static void print_times(void)
Definition: probetest.c:66
put_bits.h
probe
static void probe(AVProbeData *pd, int type, int p, int size)
Definition: probetest.c:38