Add fast-path for getextrema on 8-bit multichannel images

Author: akx

src/PIL/Image.py

@@ -1573,8 +1573,6 @@ def getextrema(self) -> tuple[float, float] | tuple[tuple[int, int], ...]:
         """
 
         self.load()
-        if self.im.bands > 1:
-            return tuple(self.im.getband(i).getextrema() for i in range(self.im.bands))
         return self.im.getextrema()
 
     def getxmp(self) -> dict[str, Any]:

src/_imaging.c

@@ -2335,15 +2335,39 @@ _getcolors(ImagingObject *self, PyObject *args) {
 
 static PyObject *
 _getextrema(ImagingObject *self, PyObject *args) {
+    if (self->image->type == IMAGING_TYPE_UINT8 && self->image->bands > 1 &&
+        self->image->bands <= 4) {
+        // Fast per-band extrema for 8-bit multiband images (RGB, RGBA, etc.)
+        UINT8 mb[2 * 4];
+        int bands = self->image->bands;
+        int nb = ImagingGetExtremaMultiband(self->image, mb);
+        if (nb < 0) {
+            return NULL;
+        }
+        PyObject *result = PyTuple_New(bands);
+        if (!result) {
+            return NULL;
+        }
+        for (int b = 0; b < bands; b++) {
+            // nb == 0 for an empty image: report None per band.
+            PyObject *item =
+                nb ? Py_BuildValue("BB", mb[b * 2], mb[b * 2 + 1]) : Py_NewRef(Py_None);
+            if (!item) {
+                Py_DECREF(result);
+                return NULL;
+            }
+            PyTuple_SET_ITEM(result, b, item);
+        }
+        return result;
+    }
+
     union {
         UINT8 u[2];
         INT32 i[2];
         FLOAT32 f[2];
         UINT16 s[2];
     } extrema;
-    int status;
-
-    status = ImagingGetExtrema(self->image, &extrema);
+    int status = ImagingGetExtrema(self->image, &extrema);
     if (status < 0) {
         return NULL;
     }

src/libImaging/GetBBox.c

@@ -248,6 +248,57 @@ ImagingGetExtrema(Imaging im, void *extrema) {
     return 1; /* ok */
 }
 
+int
+ImagingGetExtremaMultiband(Imaging im, UINT8 extrema[const 8]) {
+    // Per-band min/max for interleaved 8-bit images (up to 4 bands).
+    // Writes 2 * im->bands bytes to extrema as [min0, max0, min1, max1, ...].
+    // Returns the band count on success, 0 for an empty image, or -1 on error.
+    int bands = im->bands, xsize = im->xsize, ysize = im->ysize;
+    UINT8 vmin[4], vmax[4];
+
+    if (im->type != IMAGING_TYPE_UINT8 || im->image8 || bands < 2 || bands > 4) {
+        // `_getextrema` should have checked these, but best be sure,
+        // in case someone ends up calling this directly.
+        (void)ImagingError_ModeError();
+        return -1;
+    }
+
+    if (!xsize || !ysize) {
+        return 0; /* zero size */
+    }
+
+    UINT8 *restrict in = (UINT8 *)im->image[0];
+    for (int b = 0; b < 4; b++) {
+        vmin[b] = vmax[b] = in[b];
+    }
+
+    for (int y = 0; y < ysize; y++) {
+        UINT8 *restrict in = (UINT8 *)im->image[y];
+        for (int x = 0; x < xsize; x++, in += 4) {
+            for (int b = 0; b < 4; b++) {
+                if (in[b] < vmin[b]) {
+                    vmin[b] = in[b];
+                }
+                if (in[b] > vmax[b]) {
+                    vmax[b] = in[b];
+                }
+            }
+        }
+    }
+
+    // The second band of a two-band image is stored in the fourth byte
+    // (mirrors the special case in ImagingGetBand).
+    if (bands == 2) {
+        vmin[1] = vmin[3];
+        vmax[1] = vmax[3];
+    }
+    for (int b = 0; b < bands; b++) {
+        extrema[b * 2 + 0] = vmin[b];
+        extrema[b * 2 + 1] = vmax[b];
+    }
+    return bands;
+}
+
 /* static ImagingColorItem* getcolors8(Imaging im, int maxcolors, int* size);*/
 static ImagingColorItem *
 getcolors32(Imaging im, int maxcolors, int *size);

src/libImaging/Imaging.h

@@ -354,6 +354,8 @@ ImagingGetColors(Imaging im, int maxcolors, int *colors);
 extern int
 ImagingGetExtrema(Imaging im, void *extrema);
 extern int
+ImagingGetExtremaMultiband(Imaging im, UINT8 extrema[const 8]);
+extern int
 ImagingGetProjection(Imaging im, UINT8 *xproj, UINT8 *yproj);
 extern ImagingHistogram
 ImagingGetHistogram(Imaging im, Imaging mask, void *extrema);