Merge pull request #1884 from Starbuck5/3610-fast-scale

Starbuck5 · web-flow · commit 624955f364e0 · 2023-03-26T16:08:21.000-07:00
Faster simple scaling algorithm using SDL functions
diff --git a/docs/reST/ref/transform.rst b/docs/reST/ref/transform.rst
@@ -47,6 +47,10 @@ Instead, always begin with the original image and scale to the desired size.)
    the destination must be the same size as the size (width, height) passed in. Also
    the destination surface must be the same format.
 
+   .. versionchanged:: 2.3.0 internal scaling algorithm was replaced with a nearly
+      equivalent one that is 40% faster. Scale results will be very slightly
+      different.
+
    .. ## pygame.transform.scale ##
 
 .. function:: scale_by
diff --git a/src_c/scale2x.c b/src_c/scale2x.c
@@ -195,115 +195,3 @@ scale2x(SDL_Surface *src, SDL_Surface *dst)
         }
     }
 }
-
-void
-scale2xraw(SDL_Surface *src, SDL_Surface *dst)
-{
-    int looph, loopw;
-
-    Uint8 *srcpix = (Uint8 *)src->pixels;
-    Uint8 *dstpix = (Uint8 *)dst->pixels;
-
-    const int srcpitch = src->pitch;
-    const int dstpitch = dst->pitch;
-    const int width = src->w;
-    const int height = src->h;
-
-    switch (src->format->BytesPerPixel) {
-        case 1: {
-            Uint8 E0, E1, E2, E3, E;
-            for (looph = 0; looph < height; ++looph) {
-                for (loopw = 0; loopw < width; ++loopw) {
-                    E = *(Uint8 *)(srcpix + (looph * srcpitch) + (1 * loopw));
-
-                    E0 = E;
-                    E1 = E;
-                    E2 = E;
-                    E3 = E;
-
-                    *(Uint8 *)(dstpix + looph * 2 * dstpitch + loopw * 2 * 1) =
-                        E0;
-                    *(Uint8 *)(dstpix + looph * 2 * dstpitch +
-                               (loopw * 2 + 1) * 1) = E1;
-                    *(Uint8 *)(dstpix + (looph * 2 + 1) * dstpitch +
-                               loopw * 2 * 1) = E2;
-                    *(Uint8 *)(dstpix + (looph * 2 + 1) * dstpitch +
-                               (loopw * 2 + 1) * 1) = E3;
-                }
-            }
-            break;
-        }
-        case 2: {
-            Uint16 E0, E1, E2, E3, E;
-            for (looph = 0; looph < height; ++looph) {
-                for (loopw = 0; loopw < width; ++loopw) {
-                    E = *(Uint16 *)(srcpix + (looph * srcpitch) + (2 * loopw));
-
-                    E0 = E;
-                    E1 = E;
-                    E2 = E;
-                    E3 = E;
-
-                    *(Uint16 *)(dstpix + looph * 2 * dstpitch +
-                                loopw * 2 * 2) = E0;
-                    *(Uint16 *)(dstpix + looph * 2 * dstpitch +
-                                (loopw * 2 + 1) * 2) = E1;
-                    *(Uint16 *)(dstpix + (looph * 2 + 1) * dstpitch +
-                                loopw * 2 * 2) = E2;
-                    *(Uint16 *)(dstpix + (looph * 2 + 1) * dstpitch +
-                                (loopw * 2 + 1) * 2) = E3;
-                }
-            }
-            break;
-        }
-        case 3: {
-            int E0, E1, E2, E3, E;
-            for (looph = 0; looph < height; ++looph) {
-                for (loopw = 0; loopw < width; ++loopw) {
-                    E = READINT24(srcpix + (looph * srcpitch) + (3 * loopw));
-
-                    E0 = E;
-                    E1 = E;
-                    E2 = E;
-                    E3 = E;
-
-                    WRITEINT24((dstpix + looph * 2 * dstpitch + loopw * 2 * 3),
-                               E0);
-                    WRITEINT24(
-                        (dstpix + looph * 2 * dstpitch + (loopw * 2 + 1) * 3),
-                        E1);
-                    WRITEINT24(
-                        (dstpix + (looph * 2 + 1) * dstpitch + loopw * 2 * 3),
-                        E2);
-                    WRITEINT24((dstpix + (looph * 2 + 1) * dstpitch +
-                                (loopw * 2 + 1) * 3),
-                               E3);
-                }
-            }
-            break;
-        }
-        default: { /*case 4:*/
-            Uint32 E0, E1, E2, E3, E;
-            for (looph = 0; looph < height; ++looph) {
-                for (loopw = 0; loopw < width; ++loopw) {
-                    E = *(Uint32 *)(srcpix + (looph * srcpitch) + (4 * loopw));
-
-                    E0 = E;
-                    E1 = E;
-                    E2 = E;
-                    E3 = E;
-
-                    *(Uint32 *)(dstpix + looph * 2 * dstpitch +
-                                loopw * 2 * 4) = E0;
-                    *(Uint32 *)(dstpix + looph * 2 * dstpitch +
-                                (loopw * 2 + 1) * 4) = E1;
-                    *(Uint32 *)(dstpix + (looph * 2 + 1) * dstpitch +
-                                loopw * 2 * 4) = E2;
-                    *(Uint32 *)(dstpix + (looph * 2 + 1) * dstpitch +
-                                (loopw * 2 + 1) * 4) = E3;
-                }
-            }
-            break;
-        }
-    }
-}
diff --git a/src_c/transform.c b/src_c/transform.c
@@ -53,8 +53,6 @@ struct _module_state {
 
 void
 scale2x(SDL_Surface *src, SDL_Surface *dst);
-void
-scale2xraw(SDL_Surface *src, SDL_Surface *dst);
 extern SDL_Surface *
 rotozoomSurface(SDL_Surface *src, double angle, double zoom, int smooth);
 
@@ -411,118 +409,13 @@ rotate(SDL_Surface *src, SDL_Surface *dst, Uint32 bgcolor, double sangle,
     }
 }
 
-static void
-stretch(SDL_Surface *src, SDL_Surface *dst)
-{
-    int looph, loopw;
-
-    Uint8 *srcrow = (Uint8 *)src->pixels;
-    Uint8 *dstrow = (Uint8 *)dst->pixels;
-
-    int srcpitch = src->pitch;
-    int dstpitch = dst->pitch;
-
-    int dstwidth = dst->w;
-    int dstheight = dst->h;
-    int dstwidth2 = dst->w << 1;
-    int dstheight2 = dst->h << 1;
-
-    int srcwidth2 = src->w << 1;
-    int srcheight2 = src->h << 1;
-
-    int w_err, h_err = srcheight2 - dstheight2;
-
-    switch (src->format->BytesPerPixel) {
-        case 1:
-            for (looph = 0; looph < dstheight; ++looph) {
-                Uint8 *srcpix = (Uint8 *)srcrow, *dstpix = (Uint8 *)dstrow;
-                w_err = srcwidth2 - dstwidth2;
-                for (loopw = 0; loopw < dstwidth; ++loopw) {
-                    *dstpix++ = *srcpix;
-                    while (w_err >= 0) {
-                        ++srcpix;
-                        w_err -= dstwidth2;
-                    }
-                    w_err += srcwidth2;
-                }
-                while (h_err >= 0) {
-                    srcrow += srcpitch;
-                    h_err -= dstheight2;
-                }
-                dstrow += dstpitch;
-                h_err += srcheight2;
-            }
-            break;
-        case 2:
-            for (looph = 0; looph < dstheight; ++looph) {
-                Uint16 *srcpix = (Uint16 *)srcrow, *dstpix = (Uint16 *)dstrow;
-                w_err = srcwidth2 - dstwidth2;
-                for (loopw = 0; loopw < dstwidth; ++loopw) {
-                    *dstpix++ = *srcpix;
-                    while (w_err >= 0) {
-                        ++srcpix;
-                        w_err -= dstwidth2;
-                    }
-                    w_err += srcwidth2;
-                }
-                while (h_err >= 0) {
-                    srcrow += srcpitch;
-                    h_err -= dstheight2;
-                }
-                dstrow += dstpitch;
-                h_err += srcheight2;
-            }
-            break;
-        case 3:
-            for (looph = 0; looph < dstheight; ++looph) {
-                Uint8 *srcpix = (Uint8 *)srcrow, *dstpix = (Uint8 *)dstrow;
-                w_err = srcwidth2 - dstwidth2;
-                for (loopw = 0; loopw < dstwidth; ++loopw) {
-                    memcpy(dstpix, srcpix, 3);
-                    dstpix += 3;
-                    while (w_err >= 0) {
-                        srcpix += 3;
-                        w_err -= dstwidth2;
-                    }
-                    w_err += srcwidth2;
-                }
-                while (h_err >= 0) {
-                    srcrow += srcpitch;
-                    h_err -= dstheight2;
-                }
-                dstrow += dstpitch;
-                h_err += srcheight2;
-            }
-            break;
-        default: /*case 4:*/
-            for (looph = 0; looph < dstheight; ++looph) {
-                Uint32 *srcpix = (Uint32 *)srcrow, *dstpix = (Uint32 *)dstrow;
-                w_err = srcwidth2 - dstwidth2;
-                for (loopw = 0; loopw < dstwidth; ++loopw) {
-                    *dstpix++ = *srcpix;
-                    while (w_err >= 0) {
-                        ++srcpix;
-                        w_err -= dstwidth2;
-                    }
-                    w_err += srcwidth2;
-                }
-                while (h_err >= 0) {
-                    srcrow += srcpitch;
-                    h_err -= dstheight2;
-                }
-                dstrow += dstpitch;
-                h_err += srcheight2;
-            }
-            break;
-    }
-}
-
 static SDL_Surface *
 scale_to(pgSurfaceObject *srcobj, pgSurfaceObject *dstobj, int width,
          int height)
 {
     SDL_Surface *src = NULL;
     SDL_Surface *retsurf = NULL;
+    int stretch_result_num = 0;
 
     if (width < 0 || height < 0)
         return RAISE(PyExc_ValueError, "Cannot scale to negative size");
@@ -544,27 +437,21 @@ scale_to(pgSurfaceObject *srcobj, pgSurfaceObject *dstobj, int width,
             "Destination surface not the given width or height."));
     }
 
-    if (src->format->BytesPerPixel != retsurf->format->BytesPerPixel) {
-        return (SDL_Surface *)(RAISE(
-            PyExc_ValueError,
-            "Source and destination surfaces need the same format."));
-    }
-
+    /* Testing width and height of src and dest, because pygame supports
+     * surfaces with "0" as the width or height, and for those nothing should
+     * happen here. */
     if ((width && height) && (src->w && src->h)) {
-        SDL_LockSurface(retsurf);
         pgSurface_Lock(srcobj);
-
         Py_BEGIN_ALLOW_THREADS;
-        if (width == 2 * src->w && height == 2 * src->h) {
-            scale2xraw(src, retsurf);
-        }
-        else {
-            stretch(src, retsurf);
-        }
-        Py_END_ALLOW_THREADS;
 
+        stretch_result_num = SDL_SoftStretch(src, NULL, retsurf, NULL);
+
+        Py_END_ALLOW_THREADS;
         pgSurface_Unlock(srcobj);
-        SDL_UnlockSurface(retsurf);
+
+        if (stretch_result_num < 0) {
+            return (SDL_Surface *)(RAISE(pgExc_SDLError, SDL_GetError()));
+        }
     }
 
     return retsurf;
diff --git a/test/transform_test.py b/test/transform_test.py
@@ -1128,6 +1128,10 @@ def test_scale2x(self):
         self.assertEqual(s2.get_rect().size, (64, 64))
 
     def test_scale2xraw(self):
+        # Even though transform.scale no longer has a special
+        # case for 2x upscaling, this test validates that the behavior
+        # is preserved.
+
         w, h = 32, 32
         s = pygame.Surface((w, h), pygame.SRCALPHA, 32)
         s.fill((0, 0, 0))
