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.  
  27. static int score_array[1000]; //this must be larger than the number of formats
  28. static int failures = 0;
  29.  
  30. static void probe(AVProbeData *pd, int type, int p, int size)
  31. {
  32.     int i = 0;
  33.     AVInputFormat *fmt = NULL;
  34.  
  35.     while ((fmt = av_iformat_next(fmt))) {
  36.         if (fmt->flags & AVFMT_NOFILE)
  37.             continue;
  38.         if (fmt->read_probe) {
  39.             int score = fmt->read_probe(pd);
  40.             if (score > score_array[i] && score > AVPROBE_SCORE_MAX / 4) {
  41.                 score_array[i] = score;
  42.                 fprintf(stderr,
  43.                         "Failure of %s probing code with score=%d type=%d p=%X size=%d\n",
  44.                         fmt->name, score, type, p, size);
  45.                 failures++;
  46.             }
  47.         }
  48.         i++;
  49.     }
  50. }
  51.  
  52. int main(int argc, char **argv)
  53. {
  54.     unsigned int p, i, type, size, retry;
  55.     AVProbeData pd;
  56.     AVLFG state;
  57.     PutBitContext pb;
  58.     int retry_count= 4097;
  59.     int max_size = 65537;
  60.  
  61.     if(argc >= 2)
  62.         retry_count = atoi(argv[1]);
  63.     if(argc >= 3)
  64.         max_size = atoi(argv[2]);
  65.  
  66.     if (max_size > 1000000000U/8) {
  67.         fprintf(stderr, "max_size out of bounds\n");
  68.         return 1;
  69.     }
  70.  
  71.     if (retry_count > 1000000000U) {
  72.         fprintf(stderr, "retry_count out of bounds\n");
  73.         return 1;
  74.     }
  75.  
  76.     avcodec_register_all();
  77.     av_register_all();
  78.  
  79.     av_lfg_init(&state, 0xdeadbeef);
  80.  
  81.     pd.buf = NULL;
  82.     for (size = 1; size < max_size; size *= 2) {
  83.         pd.buf_size = size;
  84.         pd.buf      = av_realloc(pd.buf, size + AVPROBE_PADDING_SIZE);
  85.         pd.filename = "";
  86.  
  87.         memset(pd.buf, 0, size + AVPROBE_PADDING_SIZE);
  88.  
  89.         fprintf(stderr, "testing size=%d\n", size);
  90.  
  91.         for (retry = 0; retry < retry_count; retry += FFMAX(size, 32)) {
  92.             for (type = 0; type < 4; type++) {
  93.                 for (p = 0; p < 4096; p++) {
  94.                     unsigned hist = 0;
  95.                     init_put_bits(&pb, pd.buf, size);
  96.                     switch (type) {
  97.                     case 0:
  98.                         for (i = 0; i < size * 8; i++)
  99.                             put_bits(&pb, 1, (av_lfg_get(&state) & 0xFFFFFFFF) > p << 20);
  100.                         break;
  101.                     case 1:
  102.                         for (i = 0; i < size * 8; i++) {
  103.                             unsigned int p2 = hist ? p & 0x3F : (p >> 6);
  104.                             unsigned int v  = (av_lfg_get(&state) & 0xFFFFFFFF) > p2 << 26;
  105.                             put_bits(&pb, 1, v);
  106.                             hist = v;
  107.                         }
  108.                         break;
  109.                     case 2:
  110.                         for (i = 0; i < size * 8; i++) {
  111.                             unsigned int p2 = (p >> (hist * 3)) & 7;
  112.                             unsigned int v  = (av_lfg_get(&state) & 0xFFFFFFFF) > p2 << 29;
  113.                             put_bits(&pb, 1, v);
  114.                             hist = (2 * hist + v) & 3;
  115.                         }
  116.                         break;
  117.                     case 3:
  118.                         for (i = 0; i < size; i++) {
  119.                             int c = 0;
  120.                             while (p & 63) {
  121.                                 c = (av_lfg_get(&state) & 0xFFFFFFFF) >> 24;
  122.                                 if (c >= 'a' && c <= 'z' && (p & 1))
  123.                                     break;
  124.                                 else if (c >= 'A' && c <= 'Z' && (p & 2))
  125.                                     break;
  126.                                 else if (c >= '0' && c <= '9' && (p & 4))
  127.                                     break;
  128.                                 else if (c == ' ' && (p & 8))
  129.                                     break;
  130.                                 else if (c == 0 && (p & 16))
  131.                                     break;
  132.                                 else if (c == 1 && (p & 32))
  133.                                     break;
  134.                             }
  135.                             pd.buf[i] = c;
  136.                         }
  137.                     }
  138.                     flush_put_bits(&pb);
  139.                     probe(&pd, type, p, size);
  140.                 }
  141.             }
  142.         }
  143.     }
  144.     return failures;
  145. }
  146.