test/testyuv.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 #include <stdlib.h>
  13 #include <stdio.h>
  14 #include <string.h>
  15
  16 #include "SDL.h"
  17 #include "SDL_test_font.h"
  18 #include "testyuv_cvt.h"
  19
  20
  21 /* 422 (YUY2, etc) formats are the largest */
  22 #define MAX_YUV_SURFACE_SIZE(W, H, P)  (H*4*(W+P+1)/2)
  23
  24
  25 /* Return true if the YUV format is packed pixels */
  26 static SDL_bool is_packed_yuv_format(Uint32 format)
  27 {
  28     return (format == SDL_PIXELFORMAT_YUY2 ||
  29             format == SDL_PIXELFORMAT_UYVY ||
  30             format == SDL_PIXELFORMAT_YVYU);
  31 }
  32
  33 /* Create a surface with a good pattern for verifying YUV conversion */
  34 static SDL_Surface *generate_test_pattern(int pattern_size)
  35 {
  36     SDL_Surface *pattern = SDL_CreateRGBSurfaceWithFormat(0, pattern_size, pattern_size, 0, SDL_PIXELFORMAT_RGB24);
  37
  38     if (pattern) {
  39         int i, x, y;
  40         Uint8 *p, c;
  41         const int thickness = 2;    /* Important so 2x2 blocks of color are the same, to avoid Cr/Cb interpolation over pixels */
  42
  43         /* R, G, B in alternating horizontal bands */
  44         for (y = 0; y < pattern->h; y += thickness) {
  45             for (i = 0; i < thickness; ++i) {
  46                 p = (Uint8 *)pattern->pixels + (y + i) * pattern->pitch + ((y/thickness) % 3);
  47                 for (x = 0; x < pattern->w; ++x) {
  48                     *p = 0xFF;
  49                     p += 3;
  50                 }
  51             }
  52         }
  53
  54         /* Black and white in alternating vertical bands */
  55         c = 0xFF;
  56         for (x = 1*thickness; x < pattern->w; x += 2*thickness) {
  57             for (i = 0; i < thickness; ++i) {
  58                 p = (Uint8 *)pattern->pixels + (x + i)*3;
  59                 for (y = 0; y < pattern->h; ++y) {
  60                     SDL_memset(p, c, 3);
  61                     p += pattern->pitch;
  62                 }
  63             }
  64             if (c) {
  65                 c = 0x00;
  66             } else {
  67                 c = 0xFF;
  68             }
  69         }
  70     }
  71     return pattern;
  72 }
  73
  74 static SDL_bool verify_yuv_data(Uint32 format, const Uint8 *yuv, int yuv_pitch, SDL_Surface *surface)
  75 {
  76     const int tolerance = 20;
  77     const int size = (surface->h * surface->pitch);
  78     Uint8 *rgb;
  79     SDL_bool result = SDL_FALSE;
  80
  81     rgb = (Uint8 *)SDL_malloc(size);
  82     if (!rgb) {
  83         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Out of memory");
  84         return SDL_FALSE;
  85     }
  86
  87     if (SDL_ConvertPixels(surface->w, surface->h, format, yuv, yuv_pitch, surface->format->format, rgb, surface->pitch) == 0) {
  88         int x, y;
  89         result = SDL_TRUE;
  90         for (y = 0; y < surface->h; ++y) {
  91             const Uint8 *actual = rgb + y * surface->pitch;
  92             const Uint8 *expected = (const Uint8 *)surface->pixels + y * surface->pitch;
  93             for (x = 0; x < surface->w; ++x) {
  94                 int deltaR = (int)actual[0] - expected[0];
  95                 int deltaG = (int)actual[1] - expected[1];
  96                 int deltaB = (int)actual[2] - expected[2];
  97                 int distance = (deltaR * deltaR + deltaG * deltaG + deltaB * deltaB);
  98                 if (distance > tolerance) {
  99                     SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Pixel at %d,%d was 0x%.2x,0x%.2x,0x%.2x, expected 0x%.2x,0x%.2x,0x%.2x, distance = %d\n", x, y, actual[0], actual[1], actual[2], expected[0], expected[1], expected[2], distance);
 100                     result = SDL_FALSE;
 101                 }
 102                 actual += 3;
 103                 expected += 3;
 104             }
 105         }
 106     } else {
 107         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't convert %s to %s: %s\n", SDL_GetPixelFormatName(format), SDL_GetPixelFormatName(surface->format->format), SDL_GetError());
 108     }
 109     SDL_free(rgb);
 110
 111     return result;
 112 }
 113
 114 static int run_automated_tests(int pattern_size, int extra_pitch)
 115 {
 116     const Uint32 formats[] = {
 117         SDL_PIXELFORMAT_YV12,
 118         SDL_PIXELFORMAT_IYUV,
 119         SDL_PIXELFORMAT_NV12,
 120         SDL_PIXELFORMAT_NV21,
 121         SDL_PIXELFORMAT_YUY2,
 122         SDL_PIXELFORMAT_UYVY,
 123         SDL_PIXELFORMAT_YVYU
 124     };
 125     int i, j;
 126     SDL_Surface *pattern = generate_test_pattern(pattern_size);
 127     const int yuv_len = MAX_YUV_SURFACE_SIZE(pattern->w, pattern->h, extra_pitch);
 128     Uint8 *yuv1 = (Uint8 *)SDL_malloc(yuv_len);
 129     Uint8 *yuv2 = (Uint8 *)SDL_malloc(yuv_len);
 130     int yuv1_pitch, yuv2_pitch;
 131     int result = -1;
 132
 133     if (!pattern || !yuv1 || !yuv2) {
 134         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't allocate test surfaces");
 135         goto done;
 136     }
 137
 138     /* Verify conversion from YUV formats */
 139     for (i = 0; i < SDL_arraysize(formats); ++i) {
 140         if (!ConvertRGBtoYUV(formats[i], pattern->pixels, pattern->pitch, yuv1, pattern->w, pattern->h, SDL_GetYUVConversionModeForResolution(pattern->w, pattern->h), 0, 100)) {
 141             SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "ConvertRGBtoYUV() doesn't support converting to %s\n", SDL_GetPixelFormatName(formats[i]));
 142             goto done;
 143         }
 144         yuv1_pitch = CalculateYUVPitch(formats[i], pattern->w);
 145         if (!verify_yuv_data(formats[i], yuv1, yuv1_pitch, pattern)) {
 146             SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed conversion from %s to RGB\n", SDL_GetPixelFormatName(formats[i]));
 147             goto done;
 148         }
 149     }
 150
 151     /* Verify conversion to YUV formats */
 152     for (i = 0; i < SDL_arraysize(formats); ++i) {
 153         yuv1_pitch = CalculateYUVPitch(formats[i], pattern->w) + extra_pitch;
 154         if (SDL_ConvertPixels(pattern->w, pattern->h, pattern->format->format, pattern->pixels, pattern->pitch, formats[i], yuv1, yuv1_pitch) < 0) {
 155             SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't convert %s to %s: %s\n", SDL_GetPixelFormatName(pattern->format->format), SDL_GetPixelFormatName(formats[i]), SDL_GetError());
 156             goto done;
 157         }
 158         if (!verify_yuv_data(formats[i], yuv1, yuv1_pitch, pattern)) {
 159             SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed conversion from RGB to %s\n", SDL_GetPixelFormatName(formats[i]));
 160             goto done;
 161         }
 162     }
 163
 164     /* Verify conversion between YUV formats */
 165     for (i = 0; i < SDL_arraysize(formats); ++i) {
 166         for (j = 0; j < SDL_arraysize(formats); ++j) {
 167             yuv1_pitch = CalculateYUVPitch(formats[i], pattern->w) + extra_pitch;
 168             yuv2_pitch = CalculateYUVPitch(formats[j], pattern->w) + extra_pitch;
 169             if (SDL_ConvertPixels(pattern->w, pattern->h, pattern->format->format, pattern->pixels, pattern->pitch, formats[i], yuv1, yuv1_pitch) < 0) {
 170                 SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't convert %s to %s: %s\n", SDL_GetPixelFormatName(pattern->format->format), SDL_GetPixelFormatName(formats[i]), SDL_GetError());
 171                 goto done;
 172             }
 173             if (SDL_ConvertPixels(pattern->w, pattern->h, formats[i], yuv1, yuv1_pitch, formats[j], yuv2, yuv2_pitch) < 0) {
 174                 SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't convert %s to %s: %s\n", SDL_GetPixelFormatName(formats[i]), SDL_GetPixelFormatName(formats[j]), SDL_GetError());
 175                 goto done;
 176             }
 177             if (!verify_yuv_data(formats[j], yuv2, yuv2_pitch, pattern)) {
 178                 SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed conversion from %s to %s\n", SDL_GetPixelFormatName(formats[i]), SDL_GetPixelFormatName(formats[j]));
 179                 goto done;
 180             }
 181         }
 182     }
 183
 184     /* Verify conversion between YUV formats in-place */
 185     for (i = 0; i < SDL_arraysize(formats); ++i) {
 186         for (j = 0; j < SDL_arraysize(formats); ++j) {
 187             if (is_packed_yuv_format(formats[i]) != is_packed_yuv_format(formats[j])) {
 188                 /* Can't change plane vs packed pixel layout in-place */
 189                 continue;
 190             }
 191
 192             yuv1_pitch = CalculateYUVPitch(formats[i], pattern->w) + extra_pitch;
 193             yuv2_pitch = CalculateYUVPitch(formats[j], pattern->w) + extra_pitch;
 194             if (SDL_ConvertPixels(pattern->w, pattern->h, pattern->format->format, pattern->pixels, pattern->pitch, formats[i], yuv1, yuv1_pitch) < 0) {
 195                 SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't convert %s to %s: %s\n", SDL_GetPixelFormatName(pattern->format->format), SDL_GetPixelFormatName(formats[i]), SDL_GetError());
 196                 goto done;
 197             }
 198             if (SDL_ConvertPixels(pattern->w, pattern->h, formats[i], yuv1, yuv1_pitch, formats[j], yuv1, yuv2_pitch) < 0) {
 199                 SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't convert %s to %s: %s\n", SDL_GetPixelFormatName(formats[i]), SDL_GetPixelFormatName(formats[j]), SDL_GetError());
 200                 goto done;
 201             }
 202             if (!verify_yuv_data(formats[j], yuv1, yuv2_pitch, pattern)) {
 203                 SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed conversion from %s to %s\n", SDL_GetPixelFormatName(formats[i]), SDL_GetPixelFormatName(formats[j]));
 204                 goto done;
 205             }
 206         }
 207     }
 208
 209
 210     result = 0;
 211
 212 done:
 213     SDL_free(yuv1);
 214     SDL_free(yuv2);
 215     SDL_FreeSurface(pattern);
 216     return result;
 217 }
 218
 219 int
 220 main(int argc, char **argv)
 221 {
 222     struct {
 223         SDL_bool enable_intrinsics;
 224         int pattern_size;
 225         int extra_pitch;
 226     } automated_test_params[] = {
 227         /* Test: even width and height */
 228         { SDL_FALSE, 2, 0 },
 229         { SDL_FALSE, 4, 0 },
 230         /* Test: odd width and height */
 231         { SDL_FALSE, 1, 0 },
 232         { SDL_FALSE, 3, 0 },
 233         /* Test: even width and height, extra pitch */
 234         { SDL_FALSE, 2, 3 },
 235         { SDL_FALSE, 4, 3 },
 236         /* Test: odd width and height, extra pitch */
 237         { SDL_FALSE, 1, 3 },
 238         { SDL_FALSE, 3, 3 },
 239         /* Test: even width and height with intrinsics */
 240         { SDL_TRUE, 32, 0 },
 241         /* Test: odd width and height with intrinsics */
 242         { SDL_TRUE, 33, 0 },
 243         { SDL_TRUE, 37, 0 },
 244         /* Test: even width and height with intrinsics, extra pitch */
 245         { SDL_TRUE, 32, 3 },
 246         /* Test: odd width and height with intrinsics, extra pitch */
 247         { SDL_TRUE, 33, 3 },
 248         { SDL_TRUE, 37, 3 },
 249     };
 250     int arg = 1;
 251     const char *filename;
 252     SDL_Surface *original;
 253     SDL_Surface *converted;
 254     SDL_Window *window;
 255     SDL_Renderer *renderer;
 256     SDL_Texture *output[3];
 257     const char *titles[3] = { "ORIGINAL", "SOFTWARE", "HARDWARE" };
 258     char title[128];
 259     const char *yuv_name;
 260     const char *yuv_mode;
 261     Uint32 rgb_format = SDL_PIXELFORMAT_RGBX8888;
 262     Uint32 yuv_format = SDL_PIXELFORMAT_YV12;
 263     int current = 0;
 264     int pitch;
 265     Uint8 *raw_yuv;
 266     Uint32 then, now, i, iterations = 100;
 267     SDL_bool should_run_automated_tests = SDL_FALSE;
 268
 269     while (argv[arg] && *argv[arg] == '-') {
 270         if (SDL_strcmp(argv[arg], "--jpeg") == 0) {
 271             SDL_SetYUVConversionMode(SDL_YUV_CONVERSION_JPEG);
 272         } else if (SDL_strcmp(argv[arg], "--bt601") == 0) {
 273             SDL_SetYUVConversionMode(SDL_YUV_CONVERSION_BT601);
 274         } else if (SDL_strcmp(argv[arg], "--bt709") == 0) {
 275             SDL_SetYUVConversionMode(SDL_YUV_CONVERSION_BT709);
 276         } else if (SDL_strcmp(argv[arg], "--auto") == 0) {
 277             SDL_SetYUVConversionMode(SDL_YUV_CONVERSION_AUTOMATIC);
 278         } else if (SDL_strcmp(argv[arg], "--yv12") == 0) {
 279             yuv_format = SDL_PIXELFORMAT_YV12;
 280         } else if (SDL_strcmp(argv[arg], "--iyuv") == 0) {
 281             yuv_format = SDL_PIXELFORMAT_IYUV;
 282         } else if (SDL_strcmp(argv[arg], "--yuy2") == 0) {
 283             yuv_format = SDL_PIXELFORMAT_YUY2;
 284         } else if (SDL_strcmp(argv[arg], "--uyvy") == 0) {
 285             yuv_format = SDL_PIXELFORMAT_UYVY;
 286         } else if (SDL_strcmp(argv[arg], "--yvyu") == 0) {
 287             yuv_format = SDL_PIXELFORMAT_YVYU;
 288         } else if (SDL_strcmp(argv[arg], "--nv12") == 0) {
 289             yuv_format = SDL_PIXELFORMAT_NV12;
 290         } else if (SDL_strcmp(argv[arg], "--nv21") == 0) {
 291             yuv_format = SDL_PIXELFORMAT_NV21;
 292         } else if (SDL_strcmp(argv[arg], "--rgb555") == 0) {
 293             rgb_format = SDL_PIXELFORMAT_RGB555;
 294         } else if (SDL_strcmp(argv[arg], "--rgb565") == 0) {
 295             rgb_format = SDL_PIXELFORMAT_RGB565;
 296         } else if (SDL_strcmp(argv[arg], "--rgb24") == 0) {
 297             rgb_format = SDL_PIXELFORMAT_RGB24;
 298         } else if (SDL_strcmp(argv[arg], "--argb") == 0) {
 299             rgb_format = SDL_PIXELFORMAT_ARGB8888;
 300         } else if (SDL_strcmp(argv[arg], "--abgr") == 0) {
 301             rgb_format = SDL_PIXELFORMAT_ABGR8888;
 302         } else if (SDL_strcmp(argv[arg], "--rgba") == 0) {
 303             rgb_format = SDL_PIXELFORMAT_RGBA8888;
 304         } else if (SDL_strcmp(argv[arg], "--bgra") == 0) {
 305             rgb_format = SDL_PIXELFORMAT_BGRA8888;
 306         } else if (SDL_strcmp(argv[arg], "--automated") == 0) {
 307             should_run_automated_tests = SDL_TRUE;
 308         } else {
 309             SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Usage: %s [--jpeg|--bt601|-bt709|--auto] [--yv12|--iyuv|--yuy2|--uyvy|--yvyu|--nv12|--nv21] [--rgb555|--rgb565|--rgb24|--argb|--abgr|--rgba|--bgra] [image_filename]\n", argv[0]);
 310             return 1;
 311         }
 312         ++arg;
 313     }
 314
 315     /* Run automated tests */
 316     if (should_run_automated_tests) {
 317         for (i = 0; i < SDL_arraysize(automated_test_params); ++i) {
 318             SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "Running automated test, pattern size %d, extra pitch %d, intrinsics %s\n",
 319                 automated_test_params[i].pattern_size,
 320                 automated_test_params[i].extra_pitch,
 321                 automated_test_params[i].enable_intrinsics ? "enabled" : "disabled");
 322             if (run_automated_tests(automated_test_params[i].pattern_size, automated_test_params[i].extra_pitch) < 0) {
 323                 return 2;
 324             }
 325         }
 326         return 0;
 327     }
 328
 329     if (argv[arg]) {
 330         filename = argv[arg];
 331     } else {
 332         filename = "testyuv.bmp";
 333     }
 334     original = SDL_ConvertSurfaceFormat(SDL_LoadBMP(filename), SDL_PIXELFORMAT_RGB24, 0);
 335     if (!original) {
 336         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't load %s: %s\n", filename, SDL_GetError());
 337         return 3;
 338     }
 339
 340     raw_yuv = SDL_calloc(1, MAX_YUV_SURFACE_SIZE(original->w, original->h, 0));
 341     ConvertRGBtoYUV(yuv_format, original->pixels, original->pitch, raw_yuv, original->w, original->h,
 342         SDL_GetYUVConversionModeForResolution(original->w, original->h),
 343         0, 100);
 344     pitch = CalculateYUVPitch(yuv_format, original->w);
 345
 346     converted = SDL_CreateRGBSurfaceWithFormat(0, original->w, original->h, 0, rgb_format);
 347     if (!converted) {
 348         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create converted surface: %s\n", SDL_GetError());
 349         return 3;
 350     }
 351
 352     then = SDL_GetTicks();
 353     for ( i = 0; i < iterations; ++i ) {
 354         SDL_ConvertPixels(original->w, original->h, yuv_format, raw_yuv, pitch, rgb_format, converted->pixels, converted->pitch);
 355     }
 356     now = SDL_GetTicks();
 357     SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "%d iterations in %d ms, %.2fms each\n", iterations, (now - then), (float)(now - then)/iterations);
 358
 359     window = SDL_CreateWindow("YUV test",
 360                               SDL_WINDOWPOS_UNDEFINED,
 361                               SDL_WINDOWPOS_UNDEFINED,
 362                               original->w, original->h,
 363                               0);
 364     if (!window) {
 365         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create window: %s\n", SDL_GetError());
 366         return 4;
 367     }
 368
 369     renderer = SDL_CreateRenderer(window, -1, 0);
 370     if (!renderer) {
 371         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create renderer: %s\n", SDL_GetError());
 372         return 4;
 373     }
 374
 375     output[0] = SDL_CreateTextureFromSurface(renderer, original);
 376     output[1] = SDL_CreateTextureFromSurface(renderer, converted);
 377     output[2] = SDL_CreateTexture(renderer, yuv_format, SDL_TEXTUREACCESS_STREAMING, original->w, original->h);
 378     if (!output[0] || !output[1] || !output[2]) {
 379         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't set create texture: %s\n", SDL_GetError());
 380         return 5;
 381     }
 382     SDL_UpdateTexture(output[2], NULL, raw_yuv, pitch);
 383
 384     yuv_name = SDL_GetPixelFormatName(yuv_format);
 385     if (SDL_strncmp(yuv_name, "SDL_PIXELFORMAT_", 16) == 0) {
 386         yuv_name += 16;
 387     }
 388
 389     switch (SDL_GetYUVConversionModeForResolution(original->w, original->h)) {
 390     case SDL_YUV_CONVERSION_JPEG:
 391         yuv_mode = "JPEG";
 392         break;
 393     case SDL_YUV_CONVERSION_BT601:
 394         yuv_mode = "BT.601";
 395         break;
 396     case SDL_YUV_CONVERSION_BT709:
 397         yuv_mode = "BT.709";
 398         break;
 399     default:
 400         yuv_mode = "UNKNOWN";
 401         break;
 402     }
 403
 404     { int done = 0;
 405         while ( !done )
 406         {
 407             SDL_Event event;
 408             while (SDL_PollEvent(&event) > 0) {
 409                 if (event.type == SDL_QUIT) {
 410                     done = 1;
 411                 }
 412                 if (event.type == SDL_KEYDOWN) {
 413                     if (event.key.keysym.sym == SDLK_ESCAPE) {
 414                         done = 1;
 415                     } else if (event.key.keysym.sym == SDLK_LEFT) {
 416                         --current;
 417                     } else if (event.key.keysym.sym == SDLK_RIGHT) {
 418                         ++current;
 419                     }
 420                 }
 421                 if (event.type == SDL_MOUSEBUTTONDOWN) {
 422                     if (event.button.x < (original->w/2)) {
 423                         --current;
 424                     } else {
 425                         ++current;
 426                     }
 427                 }
 428             }
 429
 430             /* Handle wrapping */
 431             if (current < 0) {
 432                 current += SDL_arraysize(output);
 433             }
 434             if (current >= SDL_arraysize(output)) {
 435                 current -= SDL_arraysize(output);
 436             }
 437
 438             SDL_RenderClear(renderer);
 439             SDL_RenderCopy(renderer, output[current], NULL, NULL);
 440             SDL_SetRenderDrawColor(renderer, 0xFF, 0xFF, 0xFF, 0xFF);
 441             if (current == 0) {
 442                 SDLTest_DrawString(renderer, 4, 4, titles[current]);
 443             } else {
 444                 SDL_snprintf(title, sizeof(title), "%s %s %s", titles[current], yuv_name, yuv_mode);
 445                 SDLTest_DrawString(renderer, 4, 4, title);
 446             }
 447             SDL_RenderPresent(renderer);
 448             SDL_Delay(10);
 449         }
 450     }
 451     SDL_Quit();
 452     return 0;
 453 }
 454
 455 /* vi: set ts=4 sw=4 expandtab: */