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;
134  pd.buf = av_realloc(pd.buf, size + AVPROBE_PADDING_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 }
Context structure for the Lagged Fibonacci PRNG.
Definition: lfg.h:33
int(* read_probe)(const AVProbeData *)
Tell if a given file has a chance of being parsed as this format.
Definition: avformat.h:708
#define NULL
Definition: coverity.c:32
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:134
#define MAX_FORMATS
Definition: probetest.c:28
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:208
const char * filename
Definition: avformat.h:442
#define AVPROBE_PADDING_SIZE
extra allocated bytes at the end of the probe buffer
Definition: avformat.h:455
GLint GLenum type
Definition: opengl_enc.c:104
static struct @315 state
static void probe(AVProbeData *pd, int type, int p, int size)
Definition: probetest.c:38
static int read_int(char *arg)
Definition: probetest.c:83
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_NOTIMESTAMPS, AVFMT_GENERIC_INDEX, AVFMT_TS_DISCONT, AVFMT_NOBINSEARCH, AVFMT_NOGENSEARCH, AVFMT_NO_BYTE_SEEK, AVFMT_SEEK_TO_PTS.
Definition: avformat.h:664
static int64_t time_array[MAX_FORMATS]
Definition: probetest.c:30
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
ptrdiff_t size
Definition: opengl_enc.c:100
static const char * single_format
Definition: probetest.c:32
high precision timer, useful to profile code
#define U(x)
Definition: vp56_arith.h:37
static int score_array[MAX_FORMATS]
Definition: probetest.c:29
const char * arg
Definition: jacosubdec.c:66
#define AV_READ_TIME(x)
Definition: probetest.c:35
#define FFMAX(a, b)
Definition: common.h:94
static int failures
Definition: probetest.c:31
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:444
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:443
int main(int argc, char **argv)
Definition: probetest.c:94
const AVInputFormat * av_demuxer_iterate(void **opaque)
Iterate over all registered demuxers.
Definition: allformats.c:535
static unsigned int av_lfg_get(AVLFG *c)
Get the next random unsigned 32-bit number using an ALFG.
Definition: lfg.h:53
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
Definition: lfg.c:32
This structure contains the data a format has to probe a file.
Definition: avformat.h:441
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:453
Main libavformat public API header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:101
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:458
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:48
static void print_times(void)
Definition: probetest.c:66
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:650
int i
Definition: input.c:406
bitstream writer API