testyuv.c File Reference

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "SDL.h"
#include "SDL_test_font.h"
#include "testyuv_cvt.h"

Include dependency graph for testyuv.c:

Go to the source code of this file.

Macros
#define	MAX_YUV_SURFACE_SIZE(W, H, P)   (H*4*(W+P+1)/2)

Functions
static SDL_bool	is_packed_yuv_format (Uint32 format)
static SDL_Surface *	generate_test_pattern (int pattern_size)
static SDL_bool	verify_yuv_data (Uint32 format, const Uint8 *yuv, int yuv_pitch, SDL_Surface *surface)
static int	run_automated_tests (int pattern_size, int extra_pitch)
int	main (int argc, char **argv)

Macro Definition Documentation

#define MAX_YUV_SURFACE_SIZE	(		W,
			H,
			P
	)		(H*4*(W+P+1)/2)

Definition at line 22 of file testyuv.c.

Referenced by main(), and run_automated_tests().

Function Documentation

static SDL_Surface* generate_test_pattern ( int  pattern_size )

static

Definition at line 34 of file testyuv.c.

References SDL_Surface::h, i, SDL_Surface::pitch, SDL_Surface::pixels, SDL_CreateRGBSurfaceWithFormat, SDL_memset, SDL_PIXELFORMAT_RGB24, and SDL_Surface::w.

Referenced by run_automated_tests().

{
    SDL_Surface *pattern = SDL_CreateRGBSurfaceWithFormat(0, pattern_size, pattern_size, 0, SDL_PIXELFORMAT_RGB24);

    if (pattern) {
        int i, x, y;
        Uint8 *p, c;
        const int thickness = 2;    /* Important so 2x2 blocks of color are the same, to avoid Cr/Cb interpolation over pixels */

        /* R, G, B in alternating horizontal bands */
        for (y = 0; y < pattern->h; y += thickness) {
            for (i = 0; i < thickness; ++i) {
                p = (Uint8 *)pattern->pixels + (y + i) * pattern->pitch + ((y/thickness) % 3);
                for (x = 0; x < pattern->w; ++x) {
                    *p = 0xFF;
                    p += 3;
                }
            }
        }

        /* Black and white in alternating vertical bands */
        c = 0xFF;
        for (x = 1*thickness; x < pattern->w; x += 2*thickness) {
            for (i = 0; i < thickness; ++i) {
                p = (Uint8 *)pattern->pixels + (x + i)*3;
                for (y = 0; y < pattern->h; ++y) {
                    SDL_memset(p, c, 3);
                    p += pattern->pitch;
                }
            }
            if (c) {
                c = 0x00;
            } else {
                c = 0xFF;
            }
        }
    }
    return pattern;
}

static SDL_bool is_packed_yuv_format ( Uint32  format )

static

Definition at line 26 of file testyuv.c.

References SDL_PIXELFORMAT_UYVY, SDL_PIXELFORMAT_YUY2, and SDL_PIXELFORMAT_YVYU.

Referenced by run_automated_tests().

{
    return (format == SDL_PIXELFORMAT_YUY2 ||
            format == SDL_PIXELFORMAT_UYVY ||
            format == SDL_PIXELFORMAT_YVYU);
}

int main	(	int	argc,
		char **	argv
	)

Definition at line 220 of file testyuv.c.

References SDL_Event::button, CalculateYUVPitch(), ConvertRGBtoYUV(), done, sort_controllers::filename, SDL_Surface::h, i, iterations, SDL_Event::key, SDL_KeyboardEvent::keysym, MAX_YUV_SURFACE_SIZE, NULL, sort_controllers::output, SDL_Surface::pitch, SDL_Surface::pixels, renderer, run_automated_tests(), SDL_arraysize, SDL_calloc, SDL_ConvertPixels, SDL_ConvertSurfaceFormat, SDL_CreateRenderer, SDL_CreateRGBSurfaceWithFormat, SDL_CreateTexture, SDL_CreateTextureFromSurface, SDL_CreateWindow, SDL_Delay, SDL_FALSE, SDL_GetError, SDL_GetPixelFormatName, SDL_GetTicks(), SDL_GetYUVConversionModeForResolution, SDL_KEYDOWN, SDL_LoadBMP, SDL_LOG_CATEGORY_APPLICATION, SDL_LogError, SDL_LogInfo, SDL_MOUSEBUTTONDOWN, SDL_PIXELFORMAT_ABGR8888, SDL_PIXELFORMAT_ARGB8888, SDL_PIXELFORMAT_BGRA8888, SDL_PIXELFORMAT_IYUV, SDL_PIXELFORMAT_NV12, SDL_PIXELFORMAT_NV21, SDL_PIXELFORMAT_RGB24, SDL_PIXELFORMAT_RGB555, SDL_PIXELFORMAT_RGB565, SDL_PIXELFORMAT_RGBA8888, SDL_PIXELFORMAT_RGBX8888, SDL_PIXELFORMAT_UYVY, SDL_PIXELFORMAT_YUY2, SDL_PIXELFORMAT_YV12, SDL_PIXELFORMAT_YVYU, SDL_PollEvent, SDL_Quit, SDL_QUIT, SDL_RenderClear, SDL_RenderCopy, SDL_RenderPresent, SDL_SetRenderDrawColor, SDL_SetYUVConversionMode, SDL_snprintf, SDL_strcmp, SDL_strncmp, SDL_TEXTUREACCESS_STREAMING, SDL_TRUE, SDL_UpdateTexture, SDL_WINDOWPOS_UNDEFINED, SDL_YUV_CONVERSION_AUTOMATIC, SDL_YUV_CONVERSION_BT601, SDL_YUV_CONVERSION_BT709, SDL_YUV_CONVERSION_JPEG, SDLK_ESCAPE, SDLK_LEFT, SDLK_RIGHT, SDLTest_DrawString(), SDL_Keysym::sym, SDL_Event::type, SDL_Surface::w, and SDL_MouseButtonEvent::x.

{
    struct {
        SDL_bool enable_intrinsics;
        int pattern_size;
        int extra_pitch;
    } automated_test_params[] = {
        /* Test: even width and height */
        { SDL_FALSE, 2, 0 },
        { SDL_FALSE, 4, 0 },
        /* Test: odd width and height */
        { SDL_FALSE, 1, 0 },
        { SDL_FALSE, 3, 0 },
        /* Test: even width and height, extra pitch */
        { SDL_FALSE, 2, 3 },
        { SDL_FALSE, 4, 3 },
        /* Test: odd width and height, extra pitch */
        { SDL_FALSE, 1, 3 },
        { SDL_FALSE, 3, 3 },
        /* Test: even width and height with intrinsics */
        { SDL_TRUE, 32, 0 },
        /* Test: odd width and height with intrinsics */
        { SDL_TRUE, 33, 0 },
        { SDL_TRUE, 37, 0 },
        /* Test: even width and height with intrinsics, extra pitch */
        { SDL_TRUE, 32, 3 },
        /* Test: odd width and height with intrinsics, extra pitch */
        { SDL_TRUE, 33, 3 },
        { SDL_TRUE, 37, 3 },
    };
    int arg = 1;
    const char *filename;
    SDL_Surface *original;
    SDL_Surface *converted;
    SDL_Window *window;
    SDL_Renderer *renderer;
    SDL_Texture *output[3];
    const char *titles[3] = { "ORIGINAL", "SOFTWARE", "HARDWARE" };
    char title[128];
    const char *yuv_name;
    const char *yuv_mode;
    Uint32 rgb_format = SDL_PIXELFORMAT_RGBX8888;
    Uint32 yuv_format = SDL_PIXELFORMAT_YV12;
    int current = 0;
    int pitch;
    Uint8 *raw_yuv;
    Uint32 then, now, i, iterations = 100;
    SDL_bool should_run_automated_tests = SDL_FALSE;

    while (argv[arg] && *argv[arg] == '-') {
        if (SDL_strcmp(argv[arg], "--jpeg") == 0) {
            SDL_SetYUVConversionMode(SDL_YUV_CONVERSION_JPEG);
        } else if (SDL_strcmp(argv[arg], "--bt601") == 0) {
            SDL_SetYUVConversionMode(SDL_YUV_CONVERSION_BT601);
        } else if (SDL_strcmp(argv[arg], "--bt709") == 0) {
            SDL_SetYUVConversionMode(SDL_YUV_CONVERSION_BT709);
        } else if (SDL_strcmp(argv[arg], "--auto") == 0) {
            SDL_SetYUVConversionMode(SDL_YUV_CONVERSION_AUTOMATIC);
        } else if (SDL_strcmp(argv[arg], "--yv12") == 0) {
            yuv_format = SDL_PIXELFORMAT_YV12;
        } else if (SDL_strcmp(argv[arg], "--iyuv") == 0) {
            yuv_format = SDL_PIXELFORMAT_IYUV;
        } else if (SDL_strcmp(argv[arg], "--yuy2") == 0) {
            yuv_format = SDL_PIXELFORMAT_YUY2;
        } else if (SDL_strcmp(argv[arg], "--uyvy") == 0) {
            yuv_format = SDL_PIXELFORMAT_UYVY;
        } else if (SDL_strcmp(argv[arg], "--yvyu") == 0) {
            yuv_format = SDL_PIXELFORMAT_YVYU;
        } else if (SDL_strcmp(argv[arg], "--nv12") == 0) {
            yuv_format = SDL_PIXELFORMAT_NV12;
        } else if (SDL_strcmp(argv[arg], "--nv21") == 0) {
            yuv_format = SDL_PIXELFORMAT_NV21;
        } else if (SDL_strcmp(argv[arg], "--rgb555") == 0) {
            rgb_format = SDL_PIXELFORMAT_RGB555;
        } else if (SDL_strcmp(argv[arg], "--rgb565") == 0) {
            rgb_format = SDL_PIXELFORMAT_RGB565;
        } else if (SDL_strcmp(argv[arg], "--rgb24") == 0) {
            rgb_format = SDL_PIXELFORMAT_RGB24;
        } else if (SDL_strcmp(argv[arg], "--argb") == 0) {
            rgb_format = SDL_PIXELFORMAT_ARGB8888;
        } else if (SDL_strcmp(argv[arg], "--abgr") == 0) {
            rgb_format = SDL_PIXELFORMAT_ABGR8888;
        } else if (SDL_strcmp(argv[arg], "--rgba") == 0) {
            rgb_format = SDL_PIXELFORMAT_RGBA8888;
        } else if (SDL_strcmp(argv[arg], "--bgra") == 0) {
            rgb_format = SDL_PIXELFORMAT_BGRA8888;
        } else if (SDL_strcmp(argv[arg], "--automated") == 0) {
            should_run_automated_tests = SDL_TRUE;
        } else {
            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]);
            return 1;
        }
        ++arg;
    }

    /* Run automated tests */
    if (should_run_automated_tests) {
        for (i = 0; i < SDL_arraysize(automated_test_params); ++i) {
            SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "Running automated test, pattern size %d, extra pitch %d, intrinsics %s\n", 
                automated_test_params[i].pattern_size,
                automated_test_params[i].extra_pitch,
                automated_test_params[i].enable_intrinsics ? "enabled" : "disabled");
            if (run_automated_tests(automated_test_params[i].pattern_size, automated_test_params[i].extra_pitch) < 0) {
                return 2;
            }
        }
        return 0;
    }

    if (argv[arg]) {
        filename = argv[arg];
    } else {
        filename = "testyuv.bmp";
    }
    original = SDL_ConvertSurfaceFormat(SDL_LoadBMP(filename), SDL_PIXELFORMAT_RGB24, 0);
    if (!original) {
        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't load %s: %s\n", filename, SDL_GetError());
        return 3;
    }

    raw_yuv = SDL_calloc(1, MAX_YUV_SURFACE_SIZE(original->w, original->h, 0));
    ConvertRGBtoYUV(yuv_format, original->pixels, original->pitch, raw_yuv, original->w, original->h,
        SDL_GetYUVConversionModeForResolution(original->w, original->h),
        0, 100);
    pitch = CalculateYUVPitch(yuv_format, original->w);

    converted = SDL_CreateRGBSurfaceWithFormat(0, original->w, original->h, 0, rgb_format);
    if (!converted) {
        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create converted surface: %s\n", SDL_GetError());
        return 3;
    }

    then = SDL_GetTicks();
    for ( i = 0; i < iterations; ++i ) {
        SDL_ConvertPixels(original->w, original->h, yuv_format, raw_yuv, pitch, rgb_format, converted->pixels, converted->pitch);
    }
    now = SDL_GetTicks();
    SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "%d iterations in %d ms, %.2fms each\n", iterations, (now - then), (float)(now - then)/iterations);

    window = SDL_CreateWindow("YUV test",
                              SDL_WINDOWPOS_UNDEFINED,
                              SDL_WINDOWPOS_UNDEFINED,
                              original->w, original->h,
                              0);
    if (!window) {
        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create window: %s\n", SDL_GetError());
        return 4;
    }

    renderer = SDL_CreateRenderer(window, -1, 0);
    if (!renderer) {
        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create renderer: %s\n", SDL_GetError());
        return 4;
    }

    output[0] = SDL_CreateTextureFromSurface(renderer, original);
    output[1] = SDL_CreateTextureFromSurface(renderer, converted);
    output[2] = SDL_CreateTexture(renderer, yuv_format, SDL_TEXTUREACCESS_STREAMING, original->w, original->h);
    if (!output[0] || !output[1] || !output[2]) {
        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't set create texture: %s\n", SDL_GetError());
        return 5;
    }
    SDL_UpdateTexture(output[2], NULL, raw_yuv, pitch);
    
    yuv_name = SDL_GetPixelFormatName(yuv_format);
    if (SDL_strncmp(yuv_name, "SDL_PIXELFORMAT_", 16) == 0) {
        yuv_name += 16;
    }

    switch (SDL_GetYUVConversionModeForResolution(original->w, original->h)) {
    case SDL_YUV_CONVERSION_JPEG:
        yuv_mode = "JPEG";
        break;
    case SDL_YUV_CONVERSION_BT601:
        yuv_mode = "BT.601";
        break;
    case SDL_YUV_CONVERSION_BT709:
        yuv_mode = "BT.709";
        break;
    default:
        yuv_mode = "UNKNOWN";
        break;
    }

    { int done = 0;
        while ( !done )
        {
            SDL_Event event;
            while (SDL_PollEvent(&event) > 0) {
                if (event.type == SDL_QUIT) {
                    done = 1;
                }
                if (event.type == SDL_KEYDOWN) {
                    if (event.key.keysym.sym == SDLK_ESCAPE) {
                        done = 1;
                    } else if (event.key.keysym.sym == SDLK_LEFT) {
                        --current;
                    } else if (event.key.keysym.sym == SDLK_RIGHT) {
                        ++current;
                    }
                }
                if (event.type == SDL_MOUSEBUTTONDOWN) {
                    if (event.button.x < (original->w/2)) {
                        --current;
                    } else {
                        ++current;
                    }
                }
            }

            /* Handle wrapping */
            if (current < 0) {
                current += SDL_arraysize(output);
            }
            if (current >= SDL_arraysize(output)) {
                current -= SDL_arraysize(output);
            }

            SDL_RenderClear(renderer);
            SDL_RenderCopy(renderer, output[current], NULL, NULL);
            SDL_SetRenderDrawColor(renderer, 0xFF, 0xFF, 0xFF, 0xFF);
            if (current == 0) {
                SDLTest_DrawString(renderer, 4, 4, titles[current]);
            } else {
                SDL_snprintf(title, sizeof(title), "%s %s %s", titles[current], yuv_name, yuv_mode);
                SDLTest_DrawString(renderer, 4, 4, title);
            }
            SDL_RenderPresent(renderer);
            SDL_Delay(10);
        }
    }
    SDL_Quit();
    return 0;
}

static int run_automated_tests ( int  pattern_size, int  extra_pitch  )

static

Definition at line 114 of file testyuv.c.

References CalculateYUVPitch(), ConvertRGBtoYUV(), done, SDL_Surface::format, SDL_PixelFormat::format, generate_test_pattern(), SDL_Surface::h, i, is_packed_yuv_format(), j, MAX_YUV_SURFACE_SIZE, SDL_Surface::pitch, SDL_Surface::pixels, SDL_arraysize, SDL_ConvertPixels, SDL_free, SDL_FreeSurface, SDL_GetError, SDL_GetPixelFormatName, SDL_GetYUVConversionModeForResolution, SDL_LOG_CATEGORY_APPLICATION, SDL_LogError, SDL_malloc, SDL_PIXELFORMAT_IYUV, SDL_PIXELFORMAT_NV12, SDL_PIXELFORMAT_NV21, SDL_PIXELFORMAT_UYVY, SDL_PIXELFORMAT_YUY2, SDL_PIXELFORMAT_YV12, SDL_PIXELFORMAT_YVYU, verify_yuv_data(), and SDL_Surface::w.

Referenced by main().

{
    const Uint32 formats[] = {
        SDL_PIXELFORMAT_YV12,
        SDL_PIXELFORMAT_IYUV,
        SDL_PIXELFORMAT_NV12,
        SDL_PIXELFORMAT_NV21,
        SDL_PIXELFORMAT_YUY2,
        SDL_PIXELFORMAT_UYVY,
        SDL_PIXELFORMAT_YVYU
    };
    int i, j;
    SDL_Surface *pattern = generate_test_pattern(pattern_size);
    const int yuv_len = MAX_YUV_SURFACE_SIZE(pattern->w, pattern->h, extra_pitch);
    Uint8 *yuv1 = (Uint8 *)SDL_malloc(yuv_len);
    Uint8 *yuv2 = (Uint8 *)SDL_malloc(yuv_len);
    int yuv1_pitch, yuv2_pitch;
    int result = -1;
    
    if (!pattern || !yuv1 || !yuv2) {
        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't allocate test surfaces");
        goto done;
    }

    /* Verify conversion from YUV formats */
    for (i = 0; i < SDL_arraysize(formats); ++i) {
        if (!ConvertRGBtoYUV(formats[i], pattern->pixels, pattern->pitch, yuv1, pattern->w, pattern->h, SDL_GetYUVConversionModeForResolution(pattern->w, pattern->h), 0, 100)) {
            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "ConvertRGBtoYUV() doesn't support converting to %s\n", SDL_GetPixelFormatName(formats[i]));
            goto done;
        }
        yuv1_pitch = CalculateYUVPitch(formats[i], pattern->w);
        if (!verify_yuv_data(formats[i], yuv1, yuv1_pitch, pattern)) {
            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed conversion from %s to RGB\n", SDL_GetPixelFormatName(formats[i]));
            goto done;
        }
    }

    /* Verify conversion to YUV formats */
    for (i = 0; i < SDL_arraysize(formats); ++i) {
        yuv1_pitch = CalculateYUVPitch(formats[i], pattern->w) + extra_pitch;
        if (SDL_ConvertPixels(pattern->w, pattern->h, pattern->format->format, pattern->pixels, pattern->pitch, formats[i], yuv1, yuv1_pitch) < 0) {
            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());
            goto done;
        }
        if (!verify_yuv_data(formats[i], yuv1, yuv1_pitch, pattern)) {
            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed conversion from RGB to %s\n", SDL_GetPixelFormatName(formats[i]));
            goto done;
        }
    }

    /* Verify conversion between YUV formats */
    for (i = 0; i < SDL_arraysize(formats); ++i) {
        for (j = 0; j < SDL_arraysize(formats); ++j) {
            yuv1_pitch = CalculateYUVPitch(formats[i], pattern->w) + extra_pitch;
            yuv2_pitch = CalculateYUVPitch(formats[j], pattern->w) + extra_pitch;
            if (SDL_ConvertPixels(pattern->w, pattern->h, pattern->format->format, pattern->pixels, pattern->pitch, formats[i], yuv1, yuv1_pitch) < 0) {
                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());
                goto done;
            }
            if (SDL_ConvertPixels(pattern->w, pattern->h, formats[i], yuv1, yuv1_pitch, formats[j], yuv2, yuv2_pitch) < 0) {
                SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't convert %s to %s: %s\n", SDL_GetPixelFormatName(formats[i]), SDL_GetPixelFormatName(formats[j]), SDL_GetError());
                goto done;
            }
            if (!verify_yuv_data(formats[j], yuv2, yuv2_pitch, pattern)) {
                SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed conversion from %s to %s\n", SDL_GetPixelFormatName(formats[i]), SDL_GetPixelFormatName(formats[j]));
                goto done;
            }
        }
    }

    /* Verify conversion between YUV formats in-place */
    for (i = 0; i < SDL_arraysize(formats); ++i) {
        for (j = 0; j < SDL_arraysize(formats); ++j) {
            if (is_packed_yuv_format(formats[i]) != is_packed_yuv_format(formats[j])) {
                /* Can't change plane vs packed pixel layout in-place */
                continue;
            }

            yuv1_pitch = CalculateYUVPitch(formats[i], pattern->w) + extra_pitch;
            yuv2_pitch = CalculateYUVPitch(formats[j], pattern->w) + extra_pitch;
            if (SDL_ConvertPixels(pattern->w, pattern->h, pattern->format->format, pattern->pixels, pattern->pitch, formats[i], yuv1, yuv1_pitch) < 0) {
                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());
                goto done;
            }
            if (SDL_ConvertPixels(pattern->w, pattern->h, formats[i], yuv1, yuv1_pitch, formats[j], yuv1, yuv2_pitch) < 0) {
                SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't convert %s to %s: %s\n", SDL_GetPixelFormatName(formats[i]), SDL_GetPixelFormatName(formats[j]), SDL_GetError());
                goto done;
            }
            if (!verify_yuv_data(formats[j], yuv1, yuv2_pitch, pattern)) {
                SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed conversion from %s to %s\n", SDL_GetPixelFormatName(formats[i]), SDL_GetPixelFormatName(formats[j]));
                goto done;
            }
        }
    }


    result = 0;

done:
    SDL_free(yuv1);
    SDL_free(yuv2);
    SDL_FreeSurface(pattern);
    return result;
}

static SDL_bool verify_yuv_data ( Uint32  format, const Uint8 *  yuv, int  yuv_pitch, SDL_Surface *  surface  )

static

Definition at line 74 of file testyuv.c.

References SDL_Surface::format, SDL_PixelFormat::format, SDL_Surface::h, SDL_Surface::pitch, SDL_Surface::pixels, SDL_ConvertPixels, SDL_FALSE, SDL_free, SDL_GetError, SDL_GetPixelFormatName, SDL_LOG_CATEGORY_APPLICATION, SDL_LogError, SDL_malloc, SDL_TRUE, and SDL_Surface::w.

Referenced by run_automated_tests().

{
    const int tolerance = 20;
    const int size = (surface->h * surface->pitch);
    Uint8 *rgb;
    SDL_bool result = SDL_FALSE;

    rgb = (Uint8 *)SDL_malloc(size);
    if (!rgb) {
        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Out of memory");
        return SDL_FALSE;
    }

    if (SDL_ConvertPixels(surface->w, surface->h, format, yuv, yuv_pitch, surface->format->format, rgb, surface->pitch) == 0) {
        int x, y;
        result = SDL_TRUE;
        for (y = 0; y < surface->h; ++y) {
            const Uint8 *actual = rgb + y * surface->pitch;
            const Uint8 *expected = (const Uint8 *)surface->pixels + y * surface->pitch;
            for (x = 0; x < surface->w; ++x) {
                int deltaR = (int)actual[0] - expected[0];
                int deltaG = (int)actual[1] - expected[1];
                int deltaB = (int)actual[2] - expected[2];
                int distance = (deltaR * deltaR + deltaG * deltaG + deltaB * deltaB);
                if (distance > tolerance) {
                    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);
                    result = SDL_FALSE;
                }
                actual += 3;
                expected += 3;
            }
        }
    } else {
        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't convert %s to %s: %s\n", SDL_GetPixelFormatName(format), SDL_GetPixelFormatName(surface->format->format), SDL_GetError());
    }
    SDL_free(rgb);

    return result;
}