Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  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
  29. static int score_array[MAX_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.     AVInputFormat *fmt = NULL;
  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);
  52.             time_array[i] += AV_READ_TIME() - start;
  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;
  68.     AVInputFormat *fmt = NULL;
  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.     avcodec_register_all();
  128.     av_register_all();
  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;
  135.         pd.buf      = av_realloc(pd.buf, size + AVPROBE_PADDING_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. }
  204.