testautomation: verify that RLE operation output is correct

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

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
 

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;