tests/videogen.c

   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 Libav.
   8  *
   9  * Libav 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  * Libav 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 Libav; 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 int main(int argc, char **argv)
 145 {
 146     int w, h, i;
 147     char buf[1024];
 148     int isdir = 0;
 149
 150     if (argc != 2) {
 151         printf("usage: %s file|dir\n"
 152                "generate a test video stream\n", argv[0]);
 153         exit(1);
 154     }
 155
 156     if (!freopen(argv[1], "wb", stdout))
 157         isdir = 1;
 158
 159     w = DEFAULT_WIDTH;
 160     h = DEFAULT_HEIGHT;
 161
 162     rgb_tab = malloc(w * h * 3);
 163     wrap    = w * 3;
 164     width   = w;
 165     height  = h;
 166
 167     for (i = 0; i < DEFAULT_NB_PICT; i++) {
 168         gen_image(i, w, h);
 169         if (isdir) {
 170             snprintf(buf, sizeof(buf), "%s%02d.pgm", argv[1], i);
 171             pgmyuv_save(buf, w, h, rgb_tab);
 172         } else {
 173             pgmyuv_save(NULL, w, h, rgb_tab);
 174         }
 175     }
 176
 177     free(rgb_tab);
 178     return 0;
 179 }