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;
42 
43  while ((fmt = av_iformat_next(fmt))) {
44  if (fmt->flags & AVFMT_NOFILE)
45  continue;
46  if (fmt->read_probe &&
47  (!single_format || !strcmp(single_format, fmt->name))
48  ) {
49  int score;
50  int64_t start = AV_READ_TIME();
51  score = fmt->read_probe(pd);
53  if (score > score_array[i] && score > AVPROBE_SCORE_MAX / 4) {
54  score_array[i] = score;
55  fprintf(stderr,
56  "Failure of %s probing code with score=%d type=%d p=%X size=%d\n",
57  fmt->name, score, type, p, size);
58  failures++;
59  }
60  }
61  i++;
62  }
63 }
64 
65 static void print_times(void)
66 {
67  int i = 0;
69 
70  while ((fmt = av_iformat_next(fmt))) {
71  if (fmt->flags & AVFMT_NOFILE)
72  continue;
73  if (time_array[i] > 1000000) {
74  fprintf(stderr, "%12"PRIu64" cycles, %12s\n",
75  time_array[i], fmt->name);
76  }
77  i++;
78  }
79 }
80 
81 static int read_int(char *arg) {
82  int ret;
83 
84  if (!arg || !*arg)
85  return -1;
86  ret = strtol(arg, &arg, 0);
87  if (*arg)
88  return -1;
89  return ret;
90 }
91 
92 int main(int argc, char **argv)
93 {
94  unsigned int p, i, type, size, retry;
95  AVProbeData pd = { 0 };
96  AVLFG state;
97  PutBitContext pb;
98  int retry_count= 4097;
99  int max_size = 65537;
100  int j;
101 
102  for (j = i = 1; i<argc; i++) {
103  if (!strcmp(argv[i], "-f") && i+1<argc && !single_format) {
104  single_format = argv[++i];
105  } else if (read_int(argv[i])>0 && j == 1) {
106  retry_count = read_int(argv[i]);
107  j++;
108  } else if (read_int(argv[i])>0 && j == 2) {
109  max_size = read_int(argv[i]);
110  j++;
111  } else {
112  fprintf(stderr, "probetest [-f <input format>] [<retry_count> [<max_size>]]\n");
113  return 1;
114  }
115  }
116 
117  if (max_size > 1000000000U/8) {
118  fprintf(stderr, "max_size out of bounds\n");
119  return 1;
120  }
121 
122  if (retry_count > 1000000000U) {
123  fprintf(stderr, "retry_count out of bounds\n");
124  return 1;
125  }
126 
127  av_lfg_init(&state, 0xdeadbeef);
128 
129  pd.buf = NULL;
130  for (size = 1; size < max_size; size *= 2) {
131  pd.buf_size = size;
132  pd.buf = av_realloc(pd.buf, size + AVPROBE_PADDING_SIZE);
133  pd.filename = "";
134 
135  if (!pd.buf) {
136  fprintf(stderr, "out of memory\n");
137  return 1;
138  }
139 
140  memset(pd.buf, 0, size + AVPROBE_PADDING_SIZE);
141 
142  fprintf(stderr, "testing size=%d\n", size);
143 
144  for (retry = 0; retry < retry_count; retry += FFMAX(size, 32)) {
145  for (type = 0; type < 4; type++) {
146  for (p = 0; p < 4096; p++) {
147  unsigned hist = 0;
148  init_put_bits(&pb, pd.buf, size);
149  switch (type) {
150  case 0:
151  for (i = 0; i < size * 8; i++)
152  put_bits(&pb, 1, (av_lfg_get(&state) & 0xFFFFFFFF) > p << 20);
153  break;
154  case 1:
155  for (i = 0; i < size * 8; i++) {
156  unsigned int p2 = hist ? p & 0x3F : (p >> 6);
157  unsigned int v = (av_lfg_get(&state) & 0xFFFFFFFF) > p2 << 26;
158  put_bits(&pb, 1, v);
159  hist = v;
160  }
161  break;
162  case 2:
163  for (i = 0; i < size * 8; i++) {
164  unsigned int p2 = (p >> (hist * 3)) & 7;
165  unsigned int v = (av_lfg_get(&state) & 0xFFFFFFFF) > p2 << 29;
166  put_bits(&pb, 1, v);
167  hist = (2 * hist + v) & 3;
168  }
169  break;
170  case 3:
171  for (i = 0; i < size; i++) {
172  int c = 0;
173  while (p & 63) {
174  c = (av_lfg_get(&state) & 0xFFFFFFFF) >> 24;
175  if (c >= 'a' && c <= 'z' && (p & 1))
176  break;
177  else if (c >= 'A' && c <= 'Z' && (p & 2))
178  break;
179  else if (c >= '0' && c <= '9' && (p & 4))
180  break;
181  else if (c == ' ' && (p & 8))
182  break;
183  else if (c == 0 && (p & 16))
184  break;
185  else if (c == 1 && (p & 32))
186  break;
187  }
188  pd.buf[i] = c;
189  }
190  }
191  flush_put_bits(&pb);
192  probe(&pd, type, p, size);
193  }
194  }
195  }
196  }
197  if(AV_READ_TIME())
198  print_times();
199  return failures;
200 }
Definition: lfg.h:27
int(* read_probe)(const AVProbeData *)
Tell if a given file has a chance of being parsed as this format.
Definition: avformat.h:712
#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:135
#define MAX_FORMATS
Definition: probetest.c:28
const char * fmt
Definition: avisynth_c.h:861
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:447
#define AVPROBE_PADDING_SIZE
extra allocated bytes at the end of the probe buffer
Definition: avformat.h:460
GLint GLenum type
Definition: opengl_enc.c:104
static void probe(AVProbeData *pd, int type, int p, int size)
Definition: probetest.c:38
static int read_int(char *arg)
Definition: probetest.c:81
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:668
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
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
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:449
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:448
int main(int argc, char **argv)
Definition: probetest.c:92
static unsigned int av_lfg_get(AVLFG *c)
Get the next random unsigned 32-bit number using an ALFG.
Definition: lfg.h:47
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:446
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:458
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:463
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:65
static struct @316 state
void INT64 start
Definition: avisynth_c.h:766
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:654
bitstream writer API