From 84fac6ca443dcd246b33f2951d45c91a00e6808f Mon Sep 17 00:00:00 2001
From: Sam Lantinga <[EMAIL REDACTED]>
Date: Wed, 29 Oct 2025 09:07:56 -0700
Subject: [PATCH] testautomation: verify that RLE operation output is correct
---
include/SDL3/SDL_test_compare.h | 1 +
src/test/SDL_test_compare.c | 108 ++++++++++++++++++++++++++++++++
test/testautomation_surface.c | 7 +++
3 files changed, 116 insertions(+)
diff --git a/include/SDL3/SDL_test_compare.h b/include/SDL3/SDL_test_compare.h
index 7ff247793a628..1903549c592c5 100644
--- a/include/SDL3/SDL_test_compare.h
+++ b/include/SDL3/SDL_test_compare.h
@@ -52,6 +52,7 @@ extern "C" {
* \returns 0 if comparison succeeded, >0 (=number of pixels for which the comparison failed) if comparison failed, -1 if any of the surfaces were NULL, -2 if the surface sizes differ.
*/
int SDLCALL SDLTest_CompareSurfaces(SDL_Surface *surface, SDL_Surface *referenceSurface, int allowable_error);
+int SDLCALL SDLTest_CompareSurfacesIgnoreTransparentPixels(SDL_Surface *surface, SDL_Surface *referenceSurface, int allowable_error);
/**
* Compares 2 memory blocks for equality
diff --git a/src/test/SDL_test_compare.c b/src/test/SDL_test_compare.c
index c3ee0392592c0..4bddc2a149ff9 100644
--- a/src/test/SDL_test_compare.c
+++ b/src/test/SDL_test_compare.c
@@ -139,6 +139,114 @@ int SDLTest_CompareSurfaces(SDL_Surface *surface, SDL_Surface *referenceSurface,
return ret;
}
+int SDLTest_CompareSurfacesIgnoreTransparentPixels(SDL_Surface *surface, SDL_Surface *referenceSurface, int allowable_error)
+{
+ int ret;
+ int i, j;
+ int dist;
+ int sampleErrorX = 0, sampleErrorY = 0, sampleDist = 0;
+ SDL_Color sampleReference = { 0, 0, 0, 0 };
+ SDL_Color sampleActual = { 0, 0, 0, 0 };
+ Uint8 R, G, B, A;
+ Uint8 Rd, Gd, Bd, Ad;
+ char imageFilename[FILENAME_SIZE];
+ char referenceFilename[FILENAME_SIZE];
+
+ /* Validate input surfaces */
+ if (!surface) {
+ SDLTest_LogError("Cannot compare NULL surface");
+ return -1;
+ }
+
+ if (!referenceSurface) {
+ SDLTest_LogError("Cannot compare NULL reference surface");
+ return -1;
+ }
+
+ /* Make sure surface size is the same. */
+ if ((surface->w != referenceSurface->w) || (surface->h != referenceSurface->h)) {
+ SDLTest_LogError("Expected %dx%d surface, got %dx%d", referenceSurface->w, referenceSurface->h, surface->w, surface->h);
+ return -2;
+ }
+
+ /* Sanitize input value */
+ if (allowable_error < 0) {
+ allowable_error = 0;
+ }
+
+ SDL_LockSurface(surface);
+ SDL_LockSurface(referenceSurface);
+
+ ret = 0;
+ /* Compare image - should be same format. */
+ for (j = 0; j < surface->h; j++) {
+ for (i = 0; i < surface->w; i++) {
+ int temp;
+
+ temp = SDL_ReadSurfacePixel(surface, i, j, &R, &G, &B, &A);
+ if (!temp) {
+ SDLTest_LogError("Failed to retrieve pixel (%d,%d): %s", i, j, SDL_GetError());
+ ret++;
+ continue;
+ }
+
+ temp = SDL_ReadSurfacePixel(referenceSurface, i, j, &Rd, &Gd, &Bd, &Ad);
+ if (!temp) {
+ SDLTest_LogError("Failed to retrieve reference pixel (%d,%d): %s", i, j, SDL_GetError());
+ ret++;
+ continue;
+ }
+ if (Ad == SDL_ALPHA_TRANSPARENT) {
+ continue;
+ }
+
+ dist = 0;
+ dist += (R - Rd) * (R - Rd);
+ dist += (G - Gd) * (G - Gd);
+ dist += (B - Bd) * (B - Bd);
+
+ /* Allow some difference in blending accuracy */
+ if (dist > allowable_error) {
+ ret++;
+ if (ret == 1) {
+ sampleErrorX = i;
+ sampleErrorY = j;
+ sampleDist = dist;
+ sampleReference.r = Rd;
+ sampleReference.g = Gd;
+ sampleReference.b = Bd;
+ sampleReference.a = Ad;
+ sampleActual.r = R;
+ sampleActual.g = G;
+ sampleActual.b = B;
+ sampleActual.a = A;
+ }
+ }
+ }
+ }
+
+ SDL_UnlockSurface(surface);
+ SDL_UnlockSurface(referenceSurface);
+
+ /* Save test image and reference for analysis on failures */
+ _CompareSurfaceCount++;
+ if (ret != 0) {
+ SDLTest_LogError("Comparison of pixels with allowable error of %i failed %i times.", allowable_error, ret);
+ SDLTest_LogError("Reference surface format: %s", SDL_GetPixelFormatName(referenceSurface->format));
+ SDLTest_LogError("Actual surface format: %s", SDL_GetPixelFormatName(surface->format));
+ SDLTest_LogError("First detected occurrence at position %i,%i with a squared RGB-difference of %i.", sampleErrorX, sampleErrorY, sampleDist);
+ SDLTest_LogError("Reference pixel: R=%u G=%u B=%u A=%u", sampleReference.r, sampleReference.g, sampleReference.b, sampleReference.a);
+ SDLTest_LogError("Actual pixel : R=%u G=%u B=%u A=%u", sampleActual.r, sampleActual.g, sampleActual.b, sampleActual.a);
+ (void)SDL_snprintf(imageFilename, FILENAME_SIZE - 1, "CompareSurfaces%04d_TestOutput.bmp", _CompareSurfaceCount);
+ SDL_SaveBMP(surface, imageFilename);
+ (void)SDL_snprintf(referenceFilename, FILENAME_SIZE - 1, "CompareSurfaces%04d_Reference.bmp", _CompareSurfaceCount);
+ SDL_SaveBMP(referenceSurface, referenceFilename);
+ SDLTest_LogError("Surfaces from failed comparison saved as '%s' and '%s'", imageFilename, referenceFilename);
+ }
+
+ return ret;
+}
+
int SDLTest_CompareMemory(const void *actual, size_t size_actual, const void *reference, size_t size_reference) {
#define WIDTH 16
diff --git a/test/testautomation_surface.c b/test/testautomation_surface.c
index ffa170cb908c1..8c69faa9a15de 100644
--- a/test/testautomation_surface.c
+++ b/test/testautomation_surface.c
@@ -864,6 +864,7 @@ static int SDLCALL surface_testSurfaceNULLPixels(void *arg)
static int SDLCALL surface_testSurfaceRLEPixels(void *arg)
{
SDL_Surface *face, *a, *b, *tmp;
+ int ret;
bool result;
face = SDLTest_ImageFace();
@@ -883,6 +884,8 @@ static int SDLCALL surface_testSurfaceRLEPixels(void *arg)
a = SDL_DuplicateSurface(face);
SDLTest_AssertCheck(a != NULL, "Verify result from SDL_DuplicateSurface() with RLE pixels is not NULL");
SDLTest_AssertCheck(SDL_SurfaceHasRLE(a), "Verify result from SDL_DuplicateSurface() with RLE pixels has RLE set");
+ ret = SDLTest_CompareSurfaces(a, face, 0);
+ SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
/* Verify that blitting from an RLE surface does RLE encode it */
SDLTest_AssertCheck(!SDL_MUSTLOCK(a), "Verify initial RLE surface does not need to be locked");
@@ -891,6 +894,8 @@ static int SDLCALL surface_testSurfaceRLEPixels(void *arg)
SDLTest_AssertCheck(result, "Verify result from SDL_BlitSurface() with RLE surface is true");
SDLTest_AssertCheck(SDL_MUSTLOCK(a), "Verify RLE surface after blit needs to be locked");
SDLTest_AssertCheck(a->pixels == NULL, "Verify RLE surface after blit does not have pixels available");
+ ret = SDLTest_CompareSurfaces(tmp, face, 0);
+ SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
/* Test scaling with RLE pixels */
b = SDL_ScaleSurface(a, a->w * 2, a->h * 2, SDL_SCALEMODE_NEAREST);
@@ -908,6 +913,8 @@ static int SDLCALL surface_testSurfaceRLEPixels(void *arg)
b = SDL_ConvertSurfaceAndColorspace(a, SDL_PIXELFORMAT_ABGR8888, NULL, SDL_COLORSPACE_UNKNOWN, 0);
SDLTest_AssertCheck(b != NULL, "Verify result from SDL_ConvertSurfaceAndColorspace() with RLE pixels is not NULL");
SDLTest_AssertCheck(SDL_SurfaceHasRLE(b), "Verify result from SDL_ConvertSurfaceAndColorspace() with RLE pixels has RLE set");
+ ret = SDLTest_CompareSurfacesIgnoreTransparentPixels(b, face, 0);
+ SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
SDL_BlitSurface(a, NULL, tmp, NULL);
SDL_DestroySurface(b);
b = NULL;