Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Generate a synthetic YUV video sequence suitable for codec testing.
  3.  * NOTE: No floats are used to guarantee bitexact output.
  4.  *
  5.  * Copyright (c) 2002 Fabrice Bellard
  6.  *
  7.  * This file is part of FFmpeg.
  8.  *
  9.  * FFmpeg is free software; you can redistribute it and/or
  10.  * modify it under the terms of the GNU Lesser General Public
  11.  * License as published by the Free Software Foundation; either
  12.  * version 2.1 of the License, or (at your option) any later version.
  13.  *
  14.  * FFmpeg is distributed in the hope that it will be useful,
  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17.  * Lesser General Public License for more details.
  18.  *
  19.  * You should have received a copy of the GNU Lesser General Public
  20.  * License along with FFmpeg; if not, write to the Free Software
  21.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  22.  */
  23.  
  24. #include <stdlib.h>
  25. #include <stdint.h>
  26. #include <stdio.h>
  27.  
  28. #include "utils.c"
  29.  
  30. static unsigned int myrnd(unsigned int *seed_ptr, int n)
  31. {
  32.     unsigned int seed, val;
  33.  
  34.     seed = *seed_ptr;
  35.     seed = (seed * 314159) + 1;
  36.     if (n == 256) {
  37.         val = seed >> 24;
  38.     } else {
  39.         val = seed % n;
  40.     }
  41.     *seed_ptr = seed;
  42.     return val;
  43. }
  44.  
  45. #define NOISE_X  10
  46. #define NOISE_Y  30
  47. #define NOISE_W  26
  48.  
  49. #define FRAC_BITS 8
  50. #define FRAC_ONE (1 << FRAC_BITS)
  51.  
  52. /* cosine approximate with 1-x^2 */
  53. static int int_cos(int a)
  54. {
  55.     int v, neg;
  56.     a = a & (FRAC_ONE - 1);
  57.     if (a >= (FRAC_ONE / 2))
  58.         a = FRAC_ONE - a;
  59.     neg = 0;
  60.     if (a > (FRAC_ONE / 4)) {
  61.         neg = -1;
  62.         a   = (FRAC_ONE / 2) - a;
  63.     }
  64.     v = FRAC_ONE - ((a * a) >> 4);
  65.     v = (v ^ neg) - neg;
  66.     return v;
  67. }
  68.  
  69. #define NB_OBJS  10
  70.  
  71. typedef struct VObj {
  72.     int x, y, w, h;
  73.     int r, g, b;
  74. } VObj;
  75.  
  76. static VObj objs[NB_OBJS];
  77.  
  78. static unsigned int seed = 1;
  79.  
  80. static void gen_image(int num, int w, int h)
  81. {
  82.     int r, g, b, x, y, i, dx, dy, x1, y1;
  83.     unsigned int seed1;
  84.  
  85.     if (num == 0) {
  86.         for (i = 0; i < NB_OBJS; i++) {
  87.             objs[i].x = myrnd(&seed, w);
  88.             objs[i].y = myrnd(&seed, h);
  89.             objs[i].w = myrnd(&seed, w / 4) + 10;
  90.             objs[i].h = myrnd(&seed, h / 4) + 10;
  91.             objs[i].r = myrnd(&seed, 256);
  92.             objs[i].g = myrnd(&seed, 256);
  93.             objs[i].b = myrnd(&seed, 256);
  94.         }
  95.     }
  96.  
  97.     /* first a moving background with gradients */
  98.     /* test motion estimation */
  99.     dx = int_cos(num * FRAC_ONE / 50) * 35;
  100.     dy = int_cos(num * FRAC_ONE / 50 + FRAC_ONE / 10) * 30;
  101.     for (y = 0; y < h; y++) {
  102.         for (x = 0; x < w; x++) {
  103.             x1 = (x << FRAC_BITS) + dx;
  104.             y1 = (y << FRAC_BITS) + dy;
  105.             r  =       ((y1  * 7) >> FRAC_BITS) & 0xff;
  106.             g  = (((x1 + y1) * 9) >> FRAC_BITS) & 0xff;
  107.             b  =  ((x1       * 5) >> FRAC_BITS) & 0xff;
  108.             put_pixel(x, y, r, g, b);
  109.         }
  110.     }
  111.  
  112.     /* then some noise with very high intensity to test saturation */
  113.     seed1 = num;
  114.     for (y = 0; y < NOISE_W; y++) {
  115.         for (x = 0; x < NOISE_W; x++) {
  116.             r = myrnd(&seed1, 256);
  117.             g = myrnd(&seed1, 256);
  118.             b = myrnd(&seed1, 256);
  119.             put_pixel(x + NOISE_X, y + NOISE_Y, r, g, b);
  120.         }
  121.     }
  122.  
  123.     /* then moving objects */
  124.     for (i = 0; i < NB_OBJS; i++) {
  125.         VObj *p = &objs[i];
  126.         seed1 = i;
  127.         for (y = 0; y < p->h; y++) {
  128.             for (x = 0; x < p->w; x++) {
  129.                 r = p->r;
  130.                 g = p->g;
  131.                 b = p->b;
  132.                 /* add a per object noise */
  133.                 r += myrnd(&seed1, 50);
  134.                 g += myrnd(&seed1, 50);
  135.                 b += myrnd(&seed1, 50);
  136.                 put_pixel(x + p->x, y + p->y, r, g, b);
  137.             }
  138.         }
  139.         p->x += myrnd(&seed, 21) - 10;
  140.         p->y += myrnd(&seed, 21) - 10;
  141.     }
  142. }
  143.  
  144. void print_help(const char* name)
  145. {
  146.     printf("usage: %s file|dir [w=%i] [h=%i]\n"
  147.             "generate a test video stream\n",
  148.             name, DEFAULT_WIDTH, DEFAULT_HEIGHT);
  149.     exit(1);
  150. }
  151.  
  152. int main(int argc, char **argv)
  153. {
  154.     int w, h, i;
  155.     char buf[1024];
  156.     int isdir = 0;
  157.  
  158.     if (argc < 2 || argc > 4) {
  159.         print_help(argv[0]);
  160.     }
  161.  
  162.     if (!freopen(argv[1], "wb", stdout))
  163.         isdir = 1;
  164.  
  165.     w = DEFAULT_WIDTH;
  166.     if(argc > 2) {
  167.         w = atoi(argv[2]);
  168.         if (w < 1) print_help(argv[0]);
  169.     }
  170.     h = DEFAULT_HEIGHT;
  171.     if(argc > 3) {
  172.         h = atoi(argv[3]);
  173.         if (h < 1) print_help(argv[0]);
  174.     }
  175.  
  176.     rgb_tab = malloc(w * h * 3);
  177.     wrap    = w * 3;
  178.     width   = w;
  179.     height  = h;
  180.  
  181.     for (i = 0; i < DEFAULT_NB_PICT; i++) {
  182.         gen_image(i, w, h);
  183.         if (isdir) {
  184.             snprintf(buf, sizeof(buf), "%s%02d.pgm", argv[1], i);
  185.             pgmyuv_save(buf, w, h, rgb_tab);
  186.         } else {
  187.             pgmyuv_save(NULL, w, h, rgb_tab);
  188.         }
  189.     }
  190.  
  191.     free(rgb_tab);
  192.     return 0;
  193. }
  194.