Fix getbbox for I;16 modes

Author: akx

Tests/test_image_getbbox.py

@@ -25,9 +25,9 @@ def check(im: Image.Image, fill_color: int | tuple[int, ...]) -> None:
         im.paste(fill_color, (-10, -10, 110, 110))
         assert im.getbbox() == (0, 0, 100, 100)
 
-    # 8-bit mode
-    im = Image.new("L", (100, 100), 0)
-    check(im, 255)
+    for mode in ("1", "L", "I", "P", "I;16", "I;16L", "I;16B"):
+        im = Image.new(mode, (100, 100), 0)
+        check(im, 255)
 
     # 32-bit mode
     im = Image.new("RGB", (100, 100), 0)
@@ -44,7 +44,9 @@ def check(im: Image.Image, fill_color: int | tuple[int, ...]) -> None:
             check(im, (255, 255))
 
 
-@pytest.mark.parametrize("mode", ("L", "RGB", "RGBA", "I", "F"))
+@pytest.mark.parametrize(
+    "mode", ("L", "RGB", "RGBA", "I", "F", "I;16", "I;16L", "I;16B")
+)
 @pytest.mark.parametrize(
     "box",
     (

src/libImaging/GetBBox.c

@@ -30,62 +30,68 @@ ImagingGetBBox(Imaging im, int bbox[4], int alpha_only) {
     bbox[1] = -1;
     bbox[2] = bbox[3] = 0;
 
-#define GETBBOX(image, mask, type)                           \
-    /* first stage: looking for any pixels from top */       \
-    for (int y = 0; y < ysize; y++) {                        \
-        has_data = 0;                                        \
-        const type *restrict row = im->image[y];             \
-        for (int x = 0; x < xsize; x++) {                    \
-            if (row[x] & mask) {                             \
-                has_data = 1;                                \
-                bbox[0] = x;                                 \
-                bbox[1] = y;                                 \
-                break;                                       \
-            }                                                \
-        }                                                    \
-        if (has_data) {                                      \
-            break;                                           \
-        }                                                    \
-    }                                                        \
-    /* Check that we have a box */                           \
-    if (bbox[1] < 0) {                                       \
-        return 0; /* no data */                              \
-    }                                                        \
-    /* second stage: looking for any pixels from bottom */   \
-    for (int y = ysize - 1; y >= bbox[1]; y--) {             \
-        has_data = 0;                                        \
-        const type *restrict row = im->image[y];             \
-        for (int x = 0; x < xsize; x++) {                    \
-            if (row[x] & mask) {                             \
-                has_data = 1;                                \
-                bbox[0] = x < bbox[0] ? x : bbox[0];         \
-                bbox[3] = y + 1;                             \
-                break;                                       \
-            }                                                \
-        }                                                    \
-        if (has_data) {                                      \
-            break;                                           \
-        }                                                    \
-    }                                                        \
-    /* third stage: looking for left and right boundaries */ \
-    for (int y = bbox[1]; y < bbox[3]; y++) {                \
-        const type *restrict row = im->image[y];             \
-        for (int x = 0; x < bbox[0]; x++) {                  \
-            if (row[x] & mask) {                             \
-                bbox[0] = x;                                 \
-                break;                                       \
-            }                                                \
-        }                                                    \
-        for (int x = xsize - 1; x >= bbox[2]; x--) {         \
-            if (row[x] & mask) {                             \
-                bbox[2] = x + 1;                             \
-                break;                                       \
-            }                                                \
-        }                                                    \
+#define GETBBOX(image, mask, type)                             \
+    /* first stage: looking for any pixels from top */         \
+    for (int y = 0; y < ysize; y++) {                          \
+        has_data = 0;                                          \
+        const type *restrict row = (const type *)im->image[y]; \
+        for (int x = 0; x < xsize; x++) {                      \
+            if (row[x] & mask) {                               \
+                has_data = 1;                                  \
+                bbox[0] = x;                                   \
+                bbox[1] = y;                                   \
+                break;                                         \
+            }                                                  \
+        }                                                      \
+        if (has_data) {                                        \
+            break;                                             \
+        }                                                      \
+    }                                                          \
+    /* Check that we have a box */                             \
+    if (bbox[1] < 0) {                                         \
+        return 0; /* no data */                                \
+    }                                                          \
+    /* second stage: looking for any pixels from bottom */     \
+    for (int y = ysize - 1; y >= bbox[1]; y--) {               \
+        has_data = 0;                                          \
+        const type *restrict row = (const type *)im->image[y]; \
+        for (int x = 0; x < xsize; x++) {                      \
+            if (row[x] & mask) {                               \
+                has_data = 1;                                  \
+                bbox[0] = x < bbox[0] ? x : bbox[0];           \
+                bbox[3] = y + 1;                               \
+                break;                                         \
+            }                                                  \
+        }                                                      \
+        if (has_data) {                                        \
+            break;                                             \
+        }                                                      \
+    }                                                          \
+    /* third stage: looking for left and right boundaries */   \
+    for (int y = bbox[1]; y < bbox[3]; y++) {                  \
+        const type *restrict row = (const type *)im->image[y]; \
+        for (int x = 0; x < bbox[0]; x++) {                    \
+            if (row[x] & mask) {                               \
+                bbox[0] = x;                                   \
+                break;                                         \
+            }                                                  \
+        }                                                      \
+        for (int x = xsize - 1; x >= bbox[2]; x--) {           \
+            if (row[x] & mask) {                               \
+                bbox[2] = x + 1;                               \
+                break;                                         \
+            }                                                  \
+        }                                                      \
     }
 
     if (im->image8) {
-        GETBBOX(image8, 0xff, UINT8);
+        if (isModeI16(im->mode)) {
+            // In I16 modes, image8 is two-byte pixels, so scan as UINT16.
+            // Since we're looking for zeroes, endianness testing is independent.
+            GETBBOX(image8, 0xffff, UINT16);
+        } else {
+            GETBBOX(image8, 0xff, UINT8);
+        }
     } else {
         INT32 mask = 0xffffffff;
         if (im->bands == 3) {