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 "libavformat/demux.h"
25 #include "libavcodec/put_bits.h"
26 #include "libavutil/lfg.h"
27 #include "libavutil/timer.h"
28 
29 #define MAX_FORMATS 1000 //this must be larger than the number of formats
31 static int64_t time_array[MAX_FORMATS];
32 static int failures = 0;
33 static const char *single_format;
34 
35 #ifndef AV_READ_TIME
36 #define AV_READ_TIME(x) 0
37 #endif
38 
39 static void probe(AVProbeData *pd, int type, int p, int size)
40 {
41  int i = 0;
42  const AVInputFormat *fmt = NULL;
43  void *fmt_opaque = NULL;
44 
45  while ((fmt = av_demuxer_iterate(&fmt_opaque))) {
46  if (fmt->flags & AVFMT_NOFILE)
47  continue;
48  if (ffifmt(fmt)->read_probe &&
49  (!single_format || !strcmp(single_format, fmt->name))
50  ) {
51  int score;
52  int64_t start = AV_READ_TIME();
53  score = ffifmt(fmt)->read_probe(pd);
54  time_array[i] += AV_READ_TIME() - start;
55  if (score > score_array[i] && score > AVPROBE_SCORE_MAX / 4) {
56  score_array[i] = score;
57  fprintf(stderr,
58  "Failure of %s probing code with score=%d type=%d p=%X size=%d\n",
59  fmt->name, score, type, p, size);
60  failures++;
61  }
62  }
63  i++;
64  }
65 }
66 
67 static void print_times(void)
68 {
69  int i = 0;
70  const AVInputFormat *fmt = NULL;
71  void *fmt_opaque = NULL;
72 
73  while ((fmt = av_demuxer_iterate(&fmt_opaque))) {
74  if (fmt->flags & AVFMT_NOFILE)
75  continue;
76  if (time_array[i] > 1000000) {
77  fprintf(stderr, "%12"PRIu64" cycles, %12s\n",
78  time_array[i], fmt->name);
79  }
80  i++;
81  }
82 }
83 
84 static int read_int(char *arg) {
85  int ret;
86 
87  if (!arg || !*arg)
88  return -1;
89  ret = strtol(arg, &arg, 0);
90  if (*arg)
91  return -1;
92  return ret;
93 }
94 
95 int main(int argc, char **argv)
96 {
97  unsigned int p, i, type, size, retry;
98  AVProbeData pd = { 0 };
99  AVLFG state;
100  PutBitContext pb;
101  int retry_count= 4097;
102  int max_size = 65537;
103  int j;
104 
105  for (j = i = 1; i<argc; i++) {
106  if (!strcmp(argv[i], "-f") && i+1<argc && !single_format) {
107  single_format = argv[++i];
108  } else if (read_int(argv[i])>0 && j == 1) {
109  retry_count = read_int(argv[i]);
110  j++;
111  } else if (read_int(argv[i])>0 && j == 2) {
112  max_size = read_int(argv[i]);
113  j++;
114  } else {
115  fprintf(stderr, "probetest [-f <input format>] [<retry_count> [<max_size>]]\n");
116  return 1;
117  }
118  }
119 
120  if (max_size > 1000000000U/8) {
121  fprintf(stderr, "max_size out of bounds\n");
122  return 1;
123  }
124 
125  if (retry_count > 1000000000U) {
126  fprintf(stderr, "retry_count out of bounds\n");
127  return 1;
128  }
129 
130  av_lfg_init(&state, 0xdeadbeef);
131 
132  pd.buf = NULL;
133  for (size = 1; size < max_size; size *= 2) {
134  pd.buf_size = size;
136  pd.filename = "";
137 
138  if (!pd.buf) {
139  fprintf(stderr, "out of memory\n");
140  return 1;
141  }
142 
143  memset(pd.buf, 0, size + AVPROBE_PADDING_SIZE);
144 
145  fprintf(stderr, "testing size=%d\n", size);
146 
147  for (retry = 0; retry < retry_count; retry += FFMAX(size, 32)) {
148  for (type = 0; type < 4; type++) {
149  for (p = 0; p < 4096; p++) {
150  unsigned hist = 0;
151  init_put_bits(&pb, pd.buf, size);
152  switch (type) {
153  case 0:
154  for (i = 0; i < size * 8; i++)
155  put_bits(&pb, 1, (av_lfg_get(&state) & 0xFFFFFFFF) > p << 20);
156  break;
157  case 1:
158  for (i = 0; i < size * 8; i++) {
159  unsigned int p2 = hist ? p & 0x3F : (p >> 6);
160  unsigned int v = (av_lfg_get(&state) & 0xFFFFFFFF) > p2 << 26;
161  put_bits(&pb, 1, v);
162  hist = v;
163  }
164  break;
165  case 2:
166  for (i = 0; i < size * 8; i++) {
167  unsigned int p2 = (p >> (hist * 3)) & 7;
168  unsigned int v = (av_lfg_get(&state) & 0xFFFFFFFF) > p2 << 29;
169  put_bits(&pb, 1, v);
170  hist = (2 * hist + v) & 3;
171  }
172  break;
173  case 3:
174  for (i = 0; i < size; i++) {
175  int c = 0;
176  while (p & 63) {
177  c = (av_lfg_get(&state) & 0xFFFFFFFF) >> 24;
178  if (c >= 'a' && c <= 'z' && (p & 1))
179  break;
180  else if (c >= 'A' && c <= 'Z' && (p & 2))
181  break;
182  else if (c >= '0' && c <= '9' && (p & 4))
183  break;
184  else if (c == ' ' && (p & 8))
185  break;
186  else if (c == 0 && (p & 16))
187  break;
188  else if (c == 1 && (p & 32))
189  break;
190  }
191  pd.buf[i] = c;
192  }
193  }
194  flush_put_bits(&pb);
195  probe(&pd, type, p, size);
196  }
197  }
198  }
199  }
200  if(AV_READ_TIME())
201  print_times();
202  return failures;
203 }
MAX_FORMATS
#define MAX_FORMATS
Definition: probetest.c:29
FFInputFormat::read_probe
int(* read_probe)(const AVProbeData *)
Tell if a given file has a chance of being parsed as this format.
Definition: demux.h:63
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:62
main
int main(int argc, char **argv)
Definition: probetest.c:95
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:222
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:454
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:463
score_array
static int score_array[MAX_FORMATS]
Definition: probetest.c:30
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:465
AVInputFormat
Definition: avformat.h:548
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:553
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:453
AVProbeData::filename
const char * filename
Definition: avformat.h:452
lfg.h
read_int
static int read_int(char *arg)
Definition: probetest.c:84
time_array
static int64_t time_array[MAX_FORMATS]
Definition: probetest.c:31
PutBitContext
Definition: put_bits.h:50
arg
const char * arg
Definition: jacosubdec.c:67
NULL
#define NULL
Definition: coverity.c:32
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:451
timer.h
state
static struct @385 state
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
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:468
av_demuxer_iterate
const AVInputFormat * av_demuxer_iterate(void **opaque)
Iterate over all registered demuxers.
Definition: allformats.c:603
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
single_format
static const char * single_format
Definition: probetest.c:33
demux.h
ret
ret
Definition: filter_design.txt:187
avformat.h
U
#define U(x)
Definition: vpx_arith.h:37
AVInputFormat::flags
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_NOTIMESTAMPS,...
Definition: avformat.h:567
ffifmt
static const FFInputFormat * ffifmt(const AVInputFormat *fmt)
Definition: demux.h:133
AV_READ_TIME
#define AV_READ_TIME(x)
Definition: probetest.c:36
failures
static int failures
Definition: probetest.c:32
read_probe
static int read_probe(const AVProbeData *p)
Definition: cdg.c:30
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:143
print_times
static void print_times(void)
Definition: probetest.c:67
put_bits.h
probe
static void probe(AVProbeData *pd, int type, int p, int size)
Definition: probetest.c:39
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:153