test/testoverlay2.c

   1 /*
   2   Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
   3
   4   This software is provided 'as-is', without any express or implied
   5   warranty.  In no event will the authors be held liable for any damages
   6   arising from the use of this software.
   7
   8   Permission is granted to anyone to use this software for any purpose,
   9   including commercial applications, and to alter it and redistribute it
  10   freely.
  11 */
  12 /********************************************************************************
  13  *                                                                              *
  14  * Test of the overlay used for moved pictures, test more closed to real life.  *
  15  * Running trojan moose :) Coded by Mike Gorchak.                               *
  16  *                                                                              *
  17  ********************************************************************************/
  18
  19 #include <stdlib.h>
  20
  21 #ifdef __EMSCRIPTEN__
  22 #include <emscripten/emscripten.h>
  23 #endif
  24
  25 #include "SDL.h"
  26
  27 #include "testyuv_cvt.h"
  28
  29 #define MOOSEPIC_W 64
  30 #define MOOSEPIC_H 88
  31
  32 #define MOOSEFRAME_SIZE (MOOSEPIC_W * MOOSEPIC_H)
  33 #define MOOSEFRAMES_COUNT 10
  34
  35 SDL_Color MooseColors[84] = {
  36     {49, 49, 49, SDL_ALPHA_OPAQUE}
  37     , {66, 24, 0, SDL_ALPHA_OPAQUE}
  38     , {66, 33, 0, SDL_ALPHA_OPAQUE}
  39     , {66, 66, 66, SDL_ALPHA_OPAQUE}
  40     ,
  41     {66, 115, 49, SDL_ALPHA_OPAQUE}
  42     , {74, 33, 0, SDL_ALPHA_OPAQUE}
  43     , {74, 41, 16, SDL_ALPHA_OPAQUE}
  44     , {82, 33, 8, SDL_ALPHA_OPAQUE}
  45     ,
  46     {82, 41, 8, SDL_ALPHA_OPAQUE}
  47     , {82, 49, 16, SDL_ALPHA_OPAQUE}
  48     , {82, 82, 82, SDL_ALPHA_OPAQUE}
  49     , {90, 41, 8, SDL_ALPHA_OPAQUE}
  50     ,
  51     {90, 41, 16, SDL_ALPHA_OPAQUE}
  52     , {90, 57, 24, SDL_ALPHA_OPAQUE}
  53     , {99, 49, 16, SDL_ALPHA_OPAQUE}
  54     , {99, 66, 24, SDL_ALPHA_OPAQUE}
  55     ,
  56     {99, 66, 33, SDL_ALPHA_OPAQUE}
  57     , {99, 74, 33, SDL_ALPHA_OPAQUE}
  58     , {107, 57, 24, SDL_ALPHA_OPAQUE}
  59     , {107, 82, 41, SDL_ALPHA_OPAQUE}
  60     ,
  61     {115, 57, 33, SDL_ALPHA_OPAQUE}
  62     , {115, 66, 33, SDL_ALPHA_OPAQUE}
  63     , {115, 66, 41, SDL_ALPHA_OPAQUE}
  64     , {115, 74, 0, SDL_ALPHA_OPAQUE}
  65     ,
  66     {115, 90, 49, SDL_ALPHA_OPAQUE}
  67     , {115, 115, 115, SDL_ALPHA_OPAQUE}
  68     , {123, 82, 0, SDL_ALPHA_OPAQUE}
  69     , {123, 99, 57, SDL_ALPHA_OPAQUE}
  70     ,
  71     {132, 66, 41, SDL_ALPHA_OPAQUE}
  72     , {132, 74, 41, SDL_ALPHA_OPAQUE}
  73     , {132, 90, 8, SDL_ALPHA_OPAQUE}
  74     , {132, 99, 33, SDL_ALPHA_OPAQUE}
  75     ,
  76     {132, 99, 66, SDL_ALPHA_OPAQUE}
  77     , {132, 107, 66, SDL_ALPHA_OPAQUE}
  78     , {140, 74, 49, SDL_ALPHA_OPAQUE}
  79     , {140, 99, 16, SDL_ALPHA_OPAQUE}
  80     ,
  81     {140, 107, 74, SDL_ALPHA_OPAQUE}
  82     , {140, 115, 74, SDL_ALPHA_OPAQUE}
  83     , {148, 107, 24, SDL_ALPHA_OPAQUE}
  84     , {148, 115, 82, SDL_ALPHA_OPAQUE}
  85     ,
  86     {148, 123, 74, SDL_ALPHA_OPAQUE}
  87     , {148, 123, 90, SDL_ALPHA_OPAQUE}
  88     , {156, 115, 33, SDL_ALPHA_OPAQUE}
  89     , {156, 115, 90, SDL_ALPHA_OPAQUE}
  90     ,
  91     {156, 123, 82, SDL_ALPHA_OPAQUE}
  92     , {156, 132, 82, SDL_ALPHA_OPAQUE}
  93     , {156, 132, 99, SDL_ALPHA_OPAQUE}
  94     , {156, 156, 156, SDL_ALPHA_OPAQUE}
  95     ,
  96     {165, 123, 49, SDL_ALPHA_OPAQUE}
  97     , {165, 123, 90, SDL_ALPHA_OPAQUE}
  98     , {165, 132, 82, SDL_ALPHA_OPAQUE}
  99     , {165, 132, 90, SDL_ALPHA_OPAQUE}
 100     ,
 101     {165, 132, 99, SDL_ALPHA_OPAQUE}
 102     , {165, 140, 90, SDL_ALPHA_OPAQUE}
 103     , {173, 132, 57, SDL_ALPHA_OPAQUE}
 104     , {173, 132, 99, SDL_ALPHA_OPAQUE}
 105     ,
 106     {173, 140, 107, SDL_ALPHA_OPAQUE}
 107     , {173, 140, 115, SDL_ALPHA_OPAQUE}
 108     , {173, 148, 99, SDL_ALPHA_OPAQUE}
 109     , {173, 173, 173, SDL_ALPHA_OPAQUE}
 110     ,
 111     {181, 140, 74, SDL_ALPHA_OPAQUE}
 112     , {181, 148, 115, SDL_ALPHA_OPAQUE}
 113     , {181, 148, 123, SDL_ALPHA_OPAQUE}
 114     , {181, 156, 107, SDL_ALPHA_OPAQUE}
 115     ,
 116     {189, 148, 123, SDL_ALPHA_OPAQUE}
 117     , {189, 156, 82, SDL_ALPHA_OPAQUE}
 118     , {189, 156, 123, SDL_ALPHA_OPAQUE}
 119     , {189, 156, 132, SDL_ALPHA_OPAQUE}
 120     ,
 121     {189, 189, 189, SDL_ALPHA_OPAQUE}
 122     , {198, 156, 123, SDL_ALPHA_OPAQUE}
 123     , {198, 165, 132, SDL_ALPHA_OPAQUE}
 124     , {206, 165, 99, SDL_ALPHA_OPAQUE}
 125     ,
 126     {206, 165, 132, SDL_ALPHA_OPAQUE}
 127     , {206, 173, 140, SDL_ALPHA_OPAQUE}
 128     , {206, 206, 206, SDL_ALPHA_OPAQUE}
 129     , {214, 173, 115, SDL_ALPHA_OPAQUE}
 130     ,
 131     {214, 173, 140, SDL_ALPHA_OPAQUE}
 132     , {222, 181, 148, SDL_ALPHA_OPAQUE}
 133     , {222, 189, 132, SDL_ALPHA_OPAQUE}
 134     , {222, 189, 156, SDL_ALPHA_OPAQUE}
 135     ,
 136     {222, 222, 222, SDL_ALPHA_OPAQUE}
 137     , {231, 198, 165, SDL_ALPHA_OPAQUE}
 138     , {231, 231, 231, SDL_ALPHA_OPAQUE}
 139     , {239, 206, 173, SDL_ALPHA_OPAQUE}
 140 };
 141
 142 Uint8 MooseFrame[MOOSEFRAMES_COUNT][MOOSEFRAME_SIZE*2];
 143 SDL_Texture *MooseTexture;
 144 SDL_Rect displayrect;
 145 int window_w;
 146 int window_h;
 147 SDL_Window *window;
 148 SDL_Renderer *renderer;
 149 int paused = 0;
 150 int i;
 151 SDL_bool done = SDL_FALSE;
 152 static int fpsdelay;
 153
 154 /* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */
 155 static void
 156 quit(int rc)
 157 {
 158     SDL_Quit();
 159     exit(rc);
 160 }
 161
 162 static void
 163 PrintUsage(char *argv0)
 164 {
 165     SDL_Log("Usage: %s [arg] [arg] [arg] ...\n", argv0);
 166     SDL_Log("\n");
 167     SDL_Log("Where 'arg' is any of the following options:\n");
 168     SDL_Log("\n");
 169     SDL_Log("    -fps <frames per second>\n");
 170     SDL_Log("    -nodelay\n");
 171     SDL_Log("    -format <fmt> (one of the: YV12, IYUV, YUY2, UYVY, YVYU)\n");
 172     SDL_Log("    -scale <scale factor> (initial scale of the overlay)\n");
 173     SDL_Log("    -help (shows this help)\n");
 174     SDL_Log("\n");
 175     SDL_Log("Press ESC to exit, or SPACE to freeze the movie while application running.\n");
 176     SDL_Log("\n");
 177 }
 178
 179 void
 180 loop()
 181 {
 182     SDL_Event event;
 183
 184     while (SDL_PollEvent(&event)) {
 185         switch (event.type) {
 186         case SDL_WINDOWEVENT:
 187             if (event.window.event == SDL_WINDOWEVENT_RESIZED) {
 188                 SDL_RenderSetViewport(renderer, NULL);
 189                 displayrect.w = window_w = event.window.data1;
 190                 displayrect.h = window_h = event.window.data2;
 191             }
 192             break;
 193         case SDL_MOUSEBUTTONDOWN:
 194             displayrect.x = event.button.x - window_w / 2;
 195             displayrect.y = event.button.y - window_h / 2;
 196             break;
 197         case SDL_MOUSEMOTION:
 198             if (event.motion.state) {
 199                 displayrect.x = event.motion.x - window_w / 2;
 200                 displayrect.y = event.motion.y - window_h / 2;
 201             }
 202             break;
 203         case SDL_KEYDOWN:
 204             if (event.key.keysym.sym == SDLK_SPACE) {
 205                 paused = !paused;
 206                 break;
 207             }
 208             if (event.key.keysym.sym != SDLK_ESCAPE) {
 209                 break;
 210             }
 211            if(event.key.keysym.sym == 0)
 212            {
 213                 done = SDL_TRUE;
 214                 break;
 215            }
 216         case SDL_QUIT:
 217             done = SDL_TRUE;
 218             break;
 219         }
 220     }
 221
 222 #ifndef __EMSCRIPTEN__
 223     SDL_Delay(fpsdelay);
 224 #endif
 225
 226     if (!paused) {
 227         i = (i + 1) % MOOSEFRAMES_COUNT;
 228
 229         SDL_UpdateTexture(MooseTexture, NULL, MooseFrame[i], MOOSEPIC_W);
 230     }
 231     SDL_RenderClear(renderer);
 232     SDL_RenderCopy(renderer, MooseTexture, NULL, &displayrect);
 233     SDL_RenderPresent(renderer);
 234
 235 #ifdef __EMSCRIPTEN__
 236     if (done) {
 237         emscripten_cancel_main_loop();
 238     }
 239 #endif
 240 }
 241 int
 242 main(int argc, char **argv)
 243 {
 244     Uint8 *RawMooseData;
 245     SDL_RWops *handle;
 246     SDL_Window *window;
 247     int j;
 248     int fps = 12;
 249     int nodelay = 0;
 250     int scale = 5;
 251
 252     /* Enable standard application logging */
 253     SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
 254
 255     if (SDL_Init(SDL_INIT_VIDEO) < 0) {
 256         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't initialize SDL: %s\n", SDL_GetError());
 257         return 3;
 258     }
 259
 260     while (argc > 1) {
 261         if (SDL_strcmp(argv[1], "-fps") == 0) {
 262             if (argv[2]) {
 263                 fps = SDL_atoi(argv[2]);
 264                 if (fps == 0) {
 265                     SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
 266                             "The -fps option requires an argument [from 1 to 1000], default is 12.\n");
 267                     quit(10);
 268                 }
 269                 if ((fps < 0) || (fps > 1000)) {
 270                     SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
 271                             "The -fps option must be in range from 1 to 1000, default is 12.\n");
 272                     quit(10);
 273                 }
 274                 argv += 2;
 275                 argc -= 2;
 276             } else {
 277                 SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
 278                         "The -fps option requires an argument [from 1 to 1000], default is 12.\n");
 279                 quit(10);
 280             }
 281         } else if (SDL_strcmp(argv[1], "-nodelay") == 0) {
 282             nodelay = 1;
 283             argv += 1;
 284             argc -= 1;
 285         } else if (SDL_strcmp(argv[1], "-scale") == 0) {
 286             if (argv[2]) {
 287                 scale = SDL_atoi(argv[2]);
 288                 if (scale == 0) {
 289                     SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
 290                             "The -scale option requires an argument [from 1 to 50], default is 5.\n");
 291                     quit(10);
 292                 }
 293                 if ((scale < 0) || (scale > 50)) {
 294                     SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
 295                             "The -scale option must be in range from 1 to 50, default is 5.\n");
 296                     quit(10);
 297                 }
 298                 argv += 2;
 299                 argc -= 2;
 300             } else {
 301                 SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
 302                         "The -fps option requires an argument [from 1 to 1000], default is 12.\n");
 303                 quit(10);
 304             }
 305         } else if ((SDL_strcmp(argv[1], "-help") == 0)
 306                    || (SDL_strcmp(argv[1], "-h") == 0)) {
 307             PrintUsage(argv[0]);
 308             quit(0);
 309         } else {
 310             SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Unrecognized option: %s.\n", argv[1]);
 311             quit(10);
 312         }
 313         break;
 314     }
 315
 316     RawMooseData = (Uint8 *) SDL_malloc(MOOSEFRAME_SIZE * MOOSEFRAMES_COUNT);
 317     if (RawMooseData == NULL) {
 318         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Can't allocate memory for movie !\n");
 319         quit(1);
 320     }
 321
 322     /* load the trojan moose images */
 323     handle = SDL_RWFromFile("res/moose.dat", "rb");
 324     if (handle == NULL) {
 325         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Can't find the file moose.dat !\n");
 326         SDL_free(RawMooseData);
 327         quit(2);
 328     }
 329
 330     SDL_RWread(handle, RawMooseData, MOOSEFRAME_SIZE, MOOSEFRAMES_COUNT);
 331
 332     SDL_RWclose(handle);
 333
 334     /* Create the window and renderer */
 335     window_w = MOOSEPIC_W * scale;
 336     window_h = MOOSEPIC_H * scale;
 337     window = SDL_CreateWindow("Happy Moose",
 338                               SDL_WINDOWPOS_UNDEFINED,
 339                               SDL_WINDOWPOS_UNDEFINED,
 340                               window_w, window_h,
 341                               SDL_WINDOW_RESIZABLE);
 342     if (!window) {
 343         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't set create window: %s\n", SDL_GetError());
 344         SDL_free(RawMooseData);
 345         quit(4);
 346     }
 347
 348     renderer = SDL_CreateRenderer(window, -1, 0);
 349     if (!renderer) {
 350         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't set create renderer: %s\n", SDL_GetError());
 351         SDL_free(RawMooseData);
 352         quit(4);
 353     }
 354
 355     MooseTexture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_YV12, SDL_TEXTUREACCESS_STREAMING, MOOSEPIC_W, MOOSEPIC_H);
 356     if (!MooseTexture) {
 357         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't set create texture: %s\n", SDL_GetError());
 358         SDL_free(RawMooseData);
 359         quit(5);
 360     }
 361     /* Uncomment this to check vertex color with a YUV texture */
 362     /* SDL_SetTextureColorMod(MooseTexture, 0xff, 0x80, 0x80); */
 363
 364     for (i = 0; i < MOOSEFRAMES_COUNT; i++) {
 365         Uint8 MooseFrameRGB[MOOSEFRAME_SIZE*3];
 366         Uint8 *rgb;
 367         Uint8 *frame;
 368
 369         rgb = MooseFrameRGB;
 370         frame = RawMooseData + i * MOOSEFRAME_SIZE;
 371         for (j = 0; j < MOOSEFRAME_SIZE; ++j) {
 372             rgb[0] = MooseColors[frame[j]].r;
 373             rgb[1] = MooseColors[frame[j]].g;
 374             rgb[2] = MooseColors[frame[j]].b;
 375             rgb += 3;
 376         }
 377         ConvertRGBtoYUV(SDL_PIXELFORMAT_YV12, MooseFrameRGB, MOOSEPIC_W*3, MooseFrame[i], MOOSEPIC_W, MOOSEPIC_H,
 378             SDL_GetYUVConversionModeForResolution(MOOSEPIC_W, MOOSEPIC_H),
 379             0, 100);
 380     }
 381
 382     SDL_free(RawMooseData);
 383
 384     /* set the start frame */
 385     i = 0;
 386     if (nodelay) {
 387         fpsdelay = 0;
 388     } else {
 389         fpsdelay = 1000 / fps;
 390     }
 391
 392     displayrect.x = 0;
 393     displayrect.y = 0;
 394     displayrect.w = window_w;
 395     displayrect.h = window_h;
 396
 397     /* Ignore key up events, they don't even get filtered */
 398     SDL_EventState(SDL_KEYUP, SDL_IGNORE);
 399
 400     /* Loop, waiting for QUIT or RESIZE */
 401 #ifdef __EMSCRIPTEN__
 402     emscripten_set_main_loop(loop, nodelay ? 0 : fps, 1);
 403 #else
 404     while (!done) {
 405         loop();
 406             }
 407 #endif
 408
 409     SDL_DestroyRenderer(renderer);
 410     quit(0);
 411     return 0;
 412 }
 413
 414 /* vi: set ts=4 sw=4 expandtab: */