Merge branch 'main' into improve-error-messages

.ci/install.sh

@@ -21,7 +21,7 @@ set -e
 
 if [[ $(uname) != CYGWIN* ]]; then
     sudo apt-get -qq install libfreetype6-dev liblcms2-dev python3-tk\
-                             ghostscript libffi-dev libjpeg-turbo-progs libopenjp2-7-dev\
+                             ghostscript libjpeg-turbo-progs libopenjp2-7-dev\
                              cmake meson imagemagick libharfbuzz-dev libfribidi-dev\
                              sway wl-clipboard libopenblas-dev
 fi

.ci/requirements-mypy.txt

@@ -6,6 +6,7 @@ numpy
 packaging
 pytest
 sphinx
+types-atheris
 types-defusedxml
 types-olefile
 types-setuptools

.github/workflows/test.yml

@@ -76,7 +76,7 @@ jobs:
           "pyproject.toml"
 
     - name: Set up Python ${{ matrix.python-version }} (free-threaded)
-      uses: deadsnakes/action@v3.1.0
+      uses: deadsnakes/action@v3.2.0
       if: "${{ matrix.disable-gil }}"
       with:
         python-version: ${{ matrix.python-version }}

.github/workflows/wheels-dependencies.sh

@@ -16,7 +16,11 @@ ARCHIVE_SDIR=pillow-depends-main
 
 # Package versions for fresh source builds
 FREETYPE_VERSION=2.13.2
-HARFBUZZ_VERSION=8.5.0
+if [[ "$MB_ML_VER" != 2014 ]]; then
+    HARFBUZZ_VERSION=9.0.0
+else
+    HARFBUZZ_VERSION=8.5.0
+fi
 LIBPNG_VERSION=1.6.43
 JPEGTURBO_VERSION=3.0.3
 OPENJPEG_VERSION=2.5.2
@@ -40,7 +44,7 @@ BROTLI_VERSION=1.1.0
 
 if [[ -n "$IS_MACOS" ]] && [[ "$CIBW_ARCHS" == "x86_64" ]]; then
     function build_openjpeg {
-        local out_dir=$(fetch_unpack https://github.com/uclouvain/openjpeg/archive/v${OPENJPEG_VERSION}.tar.gz openjpeg-${OPENJPEG_VERSION}.tar.gz)
+        local out_dir=$(fetch_unpack https://github.com/uclouvain/openjpeg/archive/v$OPENJPEG_VERSION.tar.gz openjpeg-$OPENJPEG_VERSION.tar.gz)
         (cd $out_dir \
             && cmake -DCMAKE_INSTALL_PREFIX=$BUILD_PREFIX -DCMAKE_INSTALL_NAME_DIR=$BUILD_PREFIX/lib . \
             && make install)
@@ -50,7 +54,7 @@ fi
 
 function build_brotli {
     local cmake=$(get_modern_cmake)
-    local out_dir=$(fetch_unpack https://github.com/google/brotli/archive/v$BROTLI_VERSION.tar.gz brotli-1.1.0.tar.gz)
+    local out_dir=$(fetch_unpack https://github.com/google/brotli/archive/v$BROTLI_VERSION.tar.gz brotli-$BROTLI_VERSION.tar.gz)
     (cd $out_dir \
         && $cmake -DCMAKE_INSTALL_PREFIX=$BUILD_PREFIX -DCMAKE_INSTALL_NAME_DIR=$BUILD_PREFIX/lib . \
         && make install)
@@ -60,6 +64,25 @@ function build_brotli {
     fi
 }
 
+function build_harfbuzz {
+    if [[ "$HARFBUZZ_VERSION" == 8.5.0 ]]; then
+        export FREETYPE_LIBS=-lfreetype
+        export FREETYPE_CFLAGS=-I/usr/local/include/freetype2/
+        build_simple harfbuzz $HARFBUZZ_VERSION https://github.com/harfbuzz/harfbuzz/releases/download/$HARFBUZZ_VERSION tar.xz --with-freetype=yes --with-glib=no
+        export FREETYPE_LIBS=""
+        export FREETYPE_CFLAGS=""
+    else
+        local out_dir=$(fetch_unpack https://github.com/harfbuzz/harfbuzz/releases/download/$HARFBUZZ_VERSION/$HARFBUZZ_VERSION.tar.xz harfbuzz-$HARFBUZZ_VERSION.tar.xz)
+        (cd $out_dir \
+            && meson setup build --buildtype=release -Dfreetype=enabled -Dglib=disabled)
+        (cd $out_dir/build \
+            && meson install)
+        if [[ "$MB_ML_LIBC" == "manylinux" ]]; then
+            cp /usr/local/lib64/libharfbuzz* /usr/local/lib
+        fi
+    fi
+}
+
 function build {
     if [[ -n "$IS_MACOS" ]] && [[ "$CIBW_ARCHS" == "arm64" ]]; then
         sudo chown -R runner /usr/local
@@ -109,15 +132,7 @@ function build {
         build_freetype
     fi
 
-    if [ -z "$IS_MACOS" ]; then
-        export FREETYPE_LIBS=-lfreetype
-        export FREETYPE_CFLAGS=-I/usr/local/include/freetype2/
-    fi
-    build_simple harfbuzz $HARFBUZZ_VERSION https://github.com/harfbuzz/harfbuzz/releases/download/$HARFBUZZ_VERSION tar.xz --with-freetype=yes --with-glib=no
-    if [ -z "$IS_MACOS" ]; then
-        export FREETYPE_LIBS=""
-        export FREETYPE_CFLAGS=""
-    fi
+    build_harfbuzz
 }
 
 # Any stuff that you need to do before you start building the wheels
@@ -140,7 +155,13 @@ if [[ -n "$IS_MACOS" ]]; then
     brew remove --ignore-dependencies webp
   fi
 
-  brew install pkg-config
+  brew install meson pkg-config
+elif [[ "$MB_ML_LIBC" == "manylinux" ]]; then
+  if [[ "$HARFBUZZ_VERSION" != 8.5.0 ]]; then
+    yum install -y meson
+  fi
+else
+  apk add meson
 fi
 
 wrap_wheel_builder build

CHANGES.rst

@@ -5,6 +5,54 @@ Changelog (Pillow)
 11.0.0 (unreleased)
 -------------------
 
+- Deprecate ICNS (width, height, scale) sizes in favour of load(scale) #8352
+  [radarhere]
+
+- Improved handling of RGBA palettes when saving GIF images #8366
+  [radarhere]
+
+- Deprecate isImageType #8364
+  [radarhere]
+
+- Support converting more modes to LAB by converting to RGBA first #8358
+  [radarhere]
+
+- Deprecate support for FreeType 2.9.0 #8356
+  [hugovk, radarhere]
+
+- Removed unused TiffImagePlugin IFD_LEGACY_API #8355
+  [radarhere]
+
+- Handle duplicate EXIF header #8350
+  [zakajd, radarhere]
+
+- Return early from BoxBlur if either width or height is zero #8347
+  [radarhere]
+
+- Check text is either string or bytes #8308
+  [radarhere]
+
+- Added writing XMP bytes to JPEG #8286
+  [radarhere]
+
+- Support JPEG2000 RGBA palettes #8256
+  [radarhere]
+
+- Expand C image to match GIF frame image size #8237
+  [radarhere]
+
+- Allow saving I;16 images as PPM #8231
+  [radarhere]
+
+- When IFD is missing, connect get_ifd() dictionary to Exif #8230
+  [radarhere]
+
+- Skip truncated ICO mask if LOAD_TRUNCATED_IMAGES is enabled #8180
+  [radarhere]
+
+- Treat unknown JPEG2000 colorspace as unspecified #8343
+  [radarhere]
+
 - Updated error message when saving WebP with invalid width or height #8322
   [radarhere, hugovk]
 

Tests/oss-fuzz/fuzz_font.py

@@ -16,8 +16,9 @@
 
 
 import atheris
+from atheris.import_hook import instrument_imports
 
-with atheris.instrument_imports():
+with instrument_imports():
     import sys
 
     import fuzzers

Tests/oss-fuzz/fuzz_pillow.py

@@ -14,8 +14,9 @@
 
 
 import atheris
+from atheris.import_hook import instrument_imports
 
-with atheris.instrument_imports():
+with instrument_imports():
     import sys
 
     import fuzzers

Tests/oss-fuzz/python.supp

@@ -1,5 +1,5 @@
 {
-   <py3_8_encode_current_locale>
+   <py3_10_encode_current_locale>
    Memcheck:Cond
    ...
    fun:encode_current_locale

Tests/test_box_blur.py

@@ -71,6 +71,11 @@ def test_color_modes() -> None:
         box_blur(sample.convert("YCbCr"))
 
 
+@pytest.mark.parametrize("size", ((0, 1), (1, 0)))
+def test_zero_dimension(size: tuple[int, int]) -> None:
+    assert box_blur(Image.new("L", size)).size == size
+
+
 def test_radius_0() -> None:
     assert_blur(
         sample,

Tests/test_file_gif.py

@@ -1378,16 +1378,39 @@ def test_lzw_bits() -> None:
         im.load()
 
 
-def test_extents() -> None:
-    with Image.open("Tests/images/test_extents.gif") as im:
-        assert im.size == (100, 100)
+@pytest.mark.parametrize(
+    "test_file, loading_strategy",
+    (
+        ("test_extents.gif", GifImagePlugin.LoadingStrategy.RGB_AFTER_FIRST),
+        (
+            "test_extents.gif",
+            GifImagePlugin.LoadingStrategy.RGB_AFTER_DIFFERENT_PALETTE_ONLY,
+        ),
+        (
+            "test_extents_transparency.gif",
+            GifImagePlugin.LoadingStrategy.RGB_AFTER_FIRST,
+        ),
+    ),
+)
+def test_extents(
+    test_file: str, loading_strategy: GifImagePlugin.LoadingStrategy
+) -> None:
+    GifImagePlugin.LOADING_STRATEGY = loading_strategy
+    try:
+        with Image.open("Tests/images/" + test_file) as im:
+            assert im.size == (100, 100)
 
-        # Check that n_frames does not change the size
-        assert im.n_frames == 2
-        assert im.size == (100, 100)
+            # Check that n_frames does not change the size
+            assert im.n_frames == 2
+            assert im.size == (100, 100)
 
-        im.seek(1)
-        assert im.size == (150, 150)
+            im.seek(1)
+            assert im.size == (150, 150)
+
+            im.load()
+            assert im.im.size == (150, 150)
+    finally:
+        GifImagePlugin.LOADING_STRATEGY = GifImagePlugin.LoadingStrategy.RGB_AFTER_FIRST
 
 
 def test_missing_background() -> None:
@@ -1406,3 +1429,21 @@ def test_saving_rgba(tmp_path: Path) -> None:
     with Image.open(out) as reloaded:
         reloaded_rgba = reloaded.convert("RGBA")
         assert reloaded_rgba.load()[0, 0][3] == 0
+
+
+def test_optimizing_p_rgba(tmp_path: Path) -> None:
+    out = str(tmp_path / "temp.gif")
+
+    im1 = Image.new("P", (100, 100))
+    d = ImageDraw.Draw(im1)
+    d.ellipse([(40, 40), (60, 60)], fill=1)
+    data = [0, 0, 0, 0, 0, 0, 0, 255] + [0, 0, 0, 0] * 254
+    im1.putpalette(data, "RGBA")
+
+    im2 = Image.new("P", (100, 100))
+    im2.putpalette(data, "RGBA")
+
+    im1.save(out, save_all=True, append_images=[im2])
+
+    with Image.open(out) as reloaded:
+        assert reloaded.n_frames == 2

Tests/test_file_icns.py

@@ -63,8 +63,8 @@ def test_save_append_images(tmp_path: Path) -> None:
         assert_image_similar_tofile(im, temp_file, 1)
 
         with Image.open(temp_file) as reread:
-            reread.size = (16, 16, 2)
-            reread.load()
+            reread.size = (16, 16)
+            reread.load(2)
             assert_image_equal(reread, provided_im)
 
 
@@ -87,14 +87,21 @@ def test_sizes() -> None:
         for w, h, r in im.info["sizes"]:
             wr = w * r
             hr = h * r
-            im.size = (w, h, r)
+            with pytest.warns(DeprecationWarning):
+                im.size = (w, h, r)
             im.load()
             assert im.mode == "RGBA"
             assert im.size == (wr, hr)
 
+            # Test using load() with scale
+            im.size = (w, h)
+            im.load(scale=r)
+            assert im.mode == "RGBA"
+            assert im.size == (wr, hr)
+
         # Check that we cannot load an incorrect size
         with pytest.raises(ValueError):
-            im.size = (1, 1)
+            im.size = (1, 2)
 
 
 def test_older_icon() -> None:
@@ -105,8 +112,8 @@ def test_older_icon() -> None:
             wr = w * r
             hr = h * r
             with Image.open("Tests/images/pillow2.icns") as im2:
-                im2.size = (w, h, r)
-                im2.load()
+                im2.size = (w, h)
+                im2.load(r)
                 assert im2.mode == "RGBA"
                 assert im2.size == (wr, hr)
 
@@ -122,8 +129,8 @@ def test_jp2_icon() -> None:
             wr = w * r
             hr = h * r
             with Image.open("Tests/images/pillow3.icns") as im2:
-                im2.size = (w, h, r)
-                im2.load()
+                im2.size = (w, h)
+                im2.load(r)
                 assert im2.mode == "RGBA"
                 assert im2.size == (wr, hr)
 

Tests/test_file_ico.py

@@ -6,7 +6,7 @@ from pathlib import Path
 
 import pytest
 
-from PIL import IcoImagePlugin, Image, ImageDraw
+from PIL import IcoImagePlugin, Image, ImageDraw, ImageFile
 
 from .helper import assert_image_equal, assert_image_equal_tofile, hopper
 
@@ -241,3 +241,29 @@ def test_draw_reloaded(tmp_path: Path) -> None:
 
     with Image.open(outfile) as im:
         assert_image_equal_tofile(im, "Tests/images/hopper_draw.ico")
+
+
+def test_truncated_mask() -> None:
+    # 1 bpp
+    with open("Tests/images/hopper_mask.ico", "rb") as fp:
+        data = fp.read()
+
+    ImageFile.LOAD_TRUNCATED_IMAGES = True
+    data = data[:-3]
+
+    try:
+        with Image.open(io.BytesIO(data)) as im:
+            with Image.open("Tests/images/hopper_mask.png") as expected:
+                assert im.mode == "1"
+
+        # 32 bpp
+        output = io.BytesIO()
+        expected = hopper("RGBA")
+        expected.save(output, "ico", bitmap_format="bmp")
+
+        data = output.getvalue()[:-1]
+
+        with Image.open(io.BytesIO(data)) as im:
+            assert im.mode == "RGB"
+    finally:
+        ImageFile.LOAD_TRUNCATED_IMAGES = False

Tests/test_file_jpeg.py

@@ -991,12 +991,29 @@ class TestFileJpeg:
             else:
                 assert im.getxmp() == {"xmpmeta": None}
 
+    def test_save_xmp(self, tmp_path: Path) -> None:
+        f = str(tmp_path / "temp.jpg")
+        im = hopper()
+        im.save(f, xmp=b"XMP test")
+        with Image.open(f) as reloaded:
+            assert reloaded.info["xmp"] == b"XMP test"
+
+        im.info["xmp"] = b"1" * 65504
+        im.save(f)
+        with Image.open(f) as reloaded:
+            assert reloaded.info["xmp"] == b"1" * 65504
+
+        with pytest.raises(ValueError):
+            im.save(f, xmp=b"1" * 65505)
+
     @pytest.mark.timeout(timeout=1)
     def test_eof(self) -> None:
         # Even though this decoder never says that it is finished
         # the image should still end when there is no new data
         class InfiniteMockPyDecoder(ImageFile.PyDecoder):
-            def decode(self, buffer: bytes) -> tuple[int, int]:
+            def decode(
+                self, buffer: bytes | Image.SupportsArrayInterface
+            ) -> tuple[int, int]:
                 return 0, 0
 
         Image.register_decoder("INFINITE", InfiniteMockPyDecoder)

Tests/test_file_jpeg2k.py

@@ -182,6 +182,15 @@ def test_restricted_icc_profile() -> None:
         ImageFile.LOAD_TRUNCATED_IMAGES = False
 
 
+@pytest.mark.skipif(
+    not os.path.exists(EXTRA_DIR), reason="Extra image files not installed"
+)
+def test_unknown_colorspace() -> None:
+    with Image.open(f"{EXTRA_DIR}/file8.jp2") as im:
+        im.load()
+        assert im.mode == "L"
+
+
 def test_header_errors() -> None:
     for path in (
         "Tests/images/invalid_header_length.jp2",
@@ -391,6 +400,13 @@ def test_pclr() -> None:
         assert len(im.palette.colors) == 256
         assert im.palette.colors[(255, 255, 255)] == 0
 
+    with Image.open(
+        f"{EXTRA_DIR}/147af3f1083de4393666b7d99b01b58b_signal_sigsegv_130c531_6155_5136.jp2"
+    ) as im:
+        assert im.mode == "P"
+        assert len(im.palette.colors) == 139
+        assert im.palette.colors[(0, 0, 0, 0)] == 0
+
 
 def test_comment() -> None:
     with Image.open("Tests/images/comment.jp2") as im:

Tests/test_file_ppm.py

@@ -95,7 +95,9 @@ def test_16bit_pgm_write(tmp_path: Path) -> None:
     with Image.open("Tests/images/16_bit_binary.pgm") as im:
         filename = str(tmp_path / "temp.pgm")
         im.save(filename, "PPM")
+        assert_image_equal_tofile(im, filename)
 
+        im.convert("I;16").save(filename, "PPM")
         assert_image_equal_tofile(im, filename)
 
 

Tests/test_image.py

@@ -775,6 +775,22 @@ class TestImage:
         exif.load(b"Exif\x00\x00")
         assert not dict(exif)
 
+    def test_duplicate_exif_header(self) -> None:
+        with Image.open("Tests/images/exif.png") as im:
+            im.load()
+            im.info["exif"] = b"Exif\x00\x00" + im.info["exif"]
+
+            exif = im.getexif()
+        assert exif[274] == 1
+
+    def test_empty_get_ifd(self) -> None:
+        exif = Image.Exif()
+        ifd = exif.get_ifd(0x8769)
+        assert ifd == {}
+
+        ifd[36864] = b"0220"
+        assert exif.get_ifd(0x8769) == {36864: b"0220"}
+
     @mark_if_feature_version(
         pytest.mark.valgrind_known_error, "libjpeg_turbo", "2.0", reason="Known Failing"
     )
@@ -1101,6 +1117,10 @@ class TestImage:
             assert len(caplog.records) == 0
             assert im.fp is None
 
+    def test_deprecation(self) -> None:
+        with pytest.warns(DeprecationWarning):
+            assert not Image.isImageType(None)
+
 
 class TestImageBytes:
     @pytest.mark.parametrize("mode", Image.MODES + ["BGR;15", "BGR;16", "BGR;24"])

Tests/test_image_array.py

@@ -24,7 +24,7 @@ def test_toarray() -> None:
 
     def test_with_dtype(dtype: npt.DTypeLike) -> None:
         ai = numpy.array(im, dtype=dtype)
-        assert ai.dtype == dtype
+        assert ai.dtype.type is dtype
 
     # assert test("1") == ((100, 128), '|b1', 1600))
     assert test("L") == ((100, 128), "|u1", 12800)

Tests/test_imagecms.py

@@ -696,6 +696,12 @@ def test_rgb_lab(mode: str) -> None:
     assert value[:3] == (0, 255, 255)
 
 
+def test_cmyk_lab() -> None:
+    im = Image.new("CMYK", (1, 1))
+    converted_im = im.convert("LAB")
+    assert converted_im.getpixel((0, 0)) == (255, 128, 128)
+
+
 def test_deprecation() -> None:
     with pytest.warns(DeprecationWarning):
         assert ImageCms.DESCRIPTION.strip().startswith("pyCMS")

Tests/test_imagefile.py

@@ -210,7 +210,7 @@ class MockPyDecoder(ImageFile.PyDecoder):
 
         super().__init__(mode, *args)
 
-    def decode(self, buffer: bytes) -> tuple[int, int]:
+    def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
         # eof
         return -1, 0
 
@@ -238,7 +238,9 @@ class MockImageFile(ImageFile.ImageFile):
         self.rawmode = "RGBA"
         self._mode = "RGBA"
         self._size = (200, 200)
-        self.tile = [("MOCK", (xoff, yoff, xoff + xsize, yoff + ysize), 32, None)]
+        self.tile = [
+            ImageFile._Tile("MOCK", (xoff, yoff, xoff + xsize, yoff + ysize), 32, None)
+        ]
 
 
 class CodecsTest:
@@ -268,7 +270,7 @@ class TestPyDecoder(CodecsTest):
         buf = BytesIO(b"\x00" * 255)
 
         im = MockImageFile(buf)
-        im.tile = [("MOCK", None, 32, None)]
+        im.tile = [ImageFile._Tile("MOCK", None, 32, None)]
 
         im.load()
 
@@ -281,12 +283,12 @@ class TestPyDecoder(CodecsTest):
         buf = BytesIO(b"\x00" * 255)
 
         im = MockImageFile(buf)
-        im.tile = [("MOCK", (xoff, yoff, -10, yoff + ysize), 32, None)]
+        im.tile = [ImageFile._Tile("MOCK", (xoff, yoff, -10, yoff + ysize), 32, None)]
 
         with pytest.raises(ValueError):
             im.load()
 
-        im.tile = [("MOCK", (xoff, yoff, xoff + xsize, -10), 32, None)]
+        im.tile = [ImageFile._Tile("MOCK", (xoff, yoff, xoff + xsize, -10), 32, None)]
         with pytest.raises(ValueError):
             im.load()
 
@@ -294,12 +296,20 @@ class TestPyDecoder(CodecsTest):
         buf = BytesIO(b"\x00" * 255)
 
         im = MockImageFile(buf)
-        im.tile = [("MOCK", (xoff, yoff, xoff + xsize + 100, yoff + ysize), 32, None)]
+        im.tile = [
+            ImageFile._Tile(
+                "MOCK", (xoff, yoff, xoff + xsize + 100, yoff + ysize), 32, None
+            )
+        ]
 
         with pytest.raises(ValueError):
             im.load()
 
-        im.tile = [("MOCK", (xoff, yoff, xoff + xsize, yoff + ysize + 100), 32, None)]
+        im.tile = [
+            ImageFile._Tile(
+                "MOCK", (xoff, yoff, xoff + xsize, yoff + ysize + 100), 32, None
+            )
+        ]
         with pytest.raises(ValueError):
             im.load()
 
@@ -336,7 +346,7 @@ class TestPyEncoder(CodecsTest):
         buf = BytesIO(b"\x00" * 255)
 
         im = MockImageFile(buf)
-        im.tile = [("MOCK", None, 32, None)]
+        im.tile = [ImageFile._Tile("MOCK", None, 32, None)]
 
         fp = BytesIO()
         ImageFile._save(im, fp, [ImageFile._Tile("MOCK", None, 0, "RGB")])

Tests/test_imagefont.py

@@ -1140,6 +1140,9 @@ def test_bytes(font: ImageFont.FreeTypeFont) -> None:
     )
     assert font.getmask2(b"test")[1] == font.getmask2("test")[1]
 
+    with pytest.raises(TypeError):
+        font.getlength((0, 0))  # type: ignore[arg-type]
+
 
 @pytest.mark.parametrize(
     "test_file",
@@ -1174,3 +1177,15 @@ def test_invalid_truetype_sizes_raise_valueerror(
 ) -> None:
     with pytest.raises(ValueError):
         ImageFont.truetype(FONT_PATH, size, layout_engine=layout_engine)
+
+
+def test_freetype_deprecation(monkeypatch: pytest.MonkeyPatch) -> None:
+    # Arrange: mock features.version_module to return fake FreeType version
+    def fake_version_module(module: str) -> str:
+        return "2.9.0"
+
+    monkeypatch.setattr(features, "version_module", fake_version_module)
+
+    # Act / Assert
+    with pytest.warns(DeprecationWarning):
+        ImageFont.truetype(FONT_PATH, FONT_SIZE)

depends/install_imagequant.sh

@@ -2,7 +2,7 @@
 # install libimagequant
 
 archive_name=libimagequant
-archive_version=4.3.1
+archive_version=4.3.3
 
 archive=$archive_name-$archive_version
 

docs/conf.py

@@ -121,7 +121,7 @@ nitpicky = True
 # generating warnings in “nitpicky mode”. Note that type should include the domain name
 # if present. Example entries would be ('py:func', 'int') or
 # ('envvar', 'LD_LIBRARY_PATH').
-# nitpick_ignore = []
+nitpick_ignore = [("py:class", "_io.BytesIO")]
 
 
 # -- Options for HTML output ----------------------------------------------

docs/deprecations.rst

@@ -109,6 +109,35 @@ ImageDraw.getdraw hints parameter
 
 The ``hints`` parameter in :py:meth:`~PIL.ImageDraw.getdraw()` has been deprecated.
 
+FreeType 2.9.0
+^^^^^^^^^^^^^^
+
+.. deprecated:: 11.0.0
+
+Support for FreeType 2.9.0 is deprecated and will be removed in Pillow 12.0.0
+(2025-10-15), when FreeType 2.9.1 will be the minimum supported.
+
+We recommend upgrading to at least FreeType `2.10.4`_, which fixed a severe
+vulnerability introduced in FreeType 2.6 (:cve:`2020-15999`).
+
+.. _2.10.4: https://sourceforge.net/projects/freetype/files/freetype2/2.10.4/
+
+ICNS (width, height, scale) sizes
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. deprecated:: 11.0.0
+
+Setting an ICNS image size to ``(width, height, scale)`` before loading has been
+deprecated. Instead, ``load(scale)`` can be used.
+
+Image isImageType()
+^^^^^^^^^^^^^^^^^^^
+
+.. deprecated:: 11.0.0
+
+``Image.isImageType(im)`` has been deprecated. Use ``isinstance(im, Image.Image)``
+instead.
+
 ImageMath.lambda_eval and ImageMath.unsafe_eval options parameter
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
@@ -142,6 +171,13 @@ Removed features
 Deprecated features are only removed in major releases after an appropriate
 period of deprecation has passed.
 
+TiffImagePlugin IFD_LEGACY_API
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. versionremoved:: 11.0.0
+
+``TiffImagePlugin.IFD_LEGACY_API`` was removed, as it was an unused setting.
+
 PSFile
 ~~~~~~
 

docs/example/DdsImagePlugin.py

@@ -246,7 +246,9 @@ class DdsImageFile(ImageFile.ImageFile):
             msg = f"Unimplemented pixel format {repr(fourcc)}"
             raise NotImplementedError(msg)
 
-        self.tile = [(self.decoder, (0, 0) + self.size, 0, (self.mode, 0, 1))]
+        self.tile = [
+            ImageFile._Tile(self.decoder, (0, 0) + self.size, 0, (self.mode, 0, 1))
+        ]
 
     def load_seek(self, pos: int) -> None:
         pass
@@ -255,7 +257,7 @@ class DdsImageFile(ImageFile.ImageFile):
 class DXT1Decoder(ImageFile.PyDecoder):
     _pulls_fd = True
 
-    def decode(self, buffer: bytes) -> tuple[int, int]:
+    def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
         assert self.fd is not None
         try:
             self.set_as_raw(_dxt1(self.fd, self.state.xsize, self.state.ysize))
@@ -268,7 +270,7 @@ class DXT1Decoder(ImageFile.PyDecoder):
 class DXT5Decoder(ImageFile.PyDecoder):
     _pulls_fd = True
 
-    def decode(self, buffer: bytes) -> tuple[int, int]:
+    def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
         assert self.fd is not None
         try:
             self.set_as_raw(_dxt5(self.fd, self.state.xsize, self.state.ysize))

docs/handbook/image-file-formats.rst

@@ -324,12 +324,19 @@ sets the following :py:attr:`~PIL.Image.Image.info` property:
 **sizes**
     A list of supported sizes found in this icon file; these are a
     3-tuple, ``(width, height, scale)``, where ``scale`` is 2 for a retina
-    icon and 1 for a standard icon.  You *are* permitted to use this 3-tuple
-    format for the :py:attr:`~PIL.Image.Image.size` property if you set it
-    before calling :py:meth:`~PIL.Image.Image.load`; after loading, the size
-    will be reset to a 2-tuple containing pixel dimensions (so, e.g. if you
-    ask for ``(512, 512, 2)``, the final value of
-    :py:attr:`~PIL.Image.Image.size` will be ``(1024, 1024)``).
+    icon and 1 for a standard icon.
+
+.. _icns-loading:
+
+Loading
+~~~~~~~
+
+You can call the :py:meth:`~PIL.Image.Image.load` method with the following parameter.
+
+**scale**
+    Affects the scale of the resultant image. If the size is set to ``(512, 512)``,
+    after loading at scale 2, the final value of :py:attr:`~PIL.Image.Image.size` will
+    be ``(1024, 1024)``.
 
 .. _icns-saving:
 

docs/installation/building-from-source.rst

@@ -64,7 +64,7 @@ Many of Pillow's features require external libraries:
 
 * **libimagequant** provides improved color quantization
 
-  * Pillow has been tested with libimagequant **2.6-4.3.1**
+  * Pillow has been tested with libimagequant **2.6-4.3.3**
   * Libimagequant is licensed GPLv3, which is more restrictive than
     the Pillow license, therefore we will not be distributing binaries
     with libimagequant support enabled.

docs/reference/internal_modules.rst

@@ -33,6 +33,14 @@ Internal Modules
 Provides a convenient way to import type hints that are not available
 on some Python versions.
 
+.. py:class:: Buffer
+
+    Typing alias.
+
+.. py:class:: IntegralLike
+
+    Typing alias.
+
 .. py:class:: NumpyArray
 
     Typing alias.

docs/releasenotes/11.0.0.rst

@@ -40,12 +40,53 @@ removed. Pillow's C API will now be used on PyPy instead.
 ``Image.USE_CFFI_ACCESS``, for switching from the C API to PyAccess, was
 similarly removed.
 
+TiffImagePlugin IFD_LEGACY_API
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+An unused setting, ``TiffImagePlugin.IFD_LEGACY_API``, has been removed.
+
+WebP 0.4
+^^^^^^^^
+
+Support for WebP 0.4 and earlier has been removed; WebP 0.5 is the minimum supported.
+
 Deprecations
 ============
 
+FreeType 2.9.0
+^^^^^^^^^^^^^^
+
+.. deprecated:: 11.0.0
+
+Support for FreeType 2.9.0 is deprecated and will be removed in Pillow 12.0.0
+(2025-10-15), when FreeType 2.9.1 will be the minimum supported.
+
+We recommend upgrading to at least FreeType `2.10.4`_, which fixed a severe
+vulnerability introduced in FreeType 2.6 (:cve:`2020-15999`).
+
+.. _2.10.4: https://sourceforge.net/projects/freetype/files/freetype2/2.10.4/
+
+ICNS (width, height, scale) sizes
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. deprecated:: 11.0.0
+
+Setting an ICNS image size to ``(width, height, scale)`` before loading has been
+deprecated. Instead, ``load(scale)`` can be used.
+
+Image isImageType()
+^^^^^^^^^^^^^^^^^^^
+
+.. deprecated:: 11.0.0
+
+``Image.isImageType(im)`` has been deprecated. Use ``isinstance(im, Image.Image)``
+instead.
+
 ImageMath.lambda_eval and ImageMath.unsafe_eval options parameter
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+.. deprecated:: 11.0.0
+
 The ``options`` parameter in :py:meth:`~PIL.ImageMath.lambda_eval()` and
 :py:meth:`~PIL.ImageMath.unsafe_eval()` has been deprecated. One or more
 keyword arguments can be used instead.
@@ -61,6 +102,8 @@ have been deprecated, and will be removed in Pillow 12 (2025-10-15).
 Specific WebP Feature Checks
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+.. deprecated:: 11.0.0
+
 ``features.check("transp_webp")``, ``features.check("webp_mux")`` and
 ``features.check("webp_anim")`` are now deprecated. They will always return
 ``True`` if the WebP module is installed, until they are removed in Pillow
@@ -77,10 +120,18 @@ TODO
 API Additions
 =============
 
-TODO
-^^^^
+Writing XMP bytes to JPEG and MPO
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-TODO
+XMP data can now be saved to JPEG files using an ``xmp`` argument::
+
+    im.save("out.jpg", xmp=b"test")
+
+The data can also be set  through :py:attr:`~PIL.Image.Image.info`, for use when saving
+either JPEG or MPO images::
+
+    im.info["xmp"] = b"test"
+    im.save("out.jpg")
 
 Other Changes
 =============
@@ -94,6 +145,8 @@ of 3.13.0 final (2024-10-01, :pep:`719`).
 
 Pillow 11.0.0 now officially supports Python 3.13.
 
+Support has also been added for the experimental free-threaded mode of :pep:`703`.
+
 C-level Flags
 ^^^^^^^^^^^^^
 

pyproject.toml

@@ -163,7 +163,3 @@ follow_imports = "silent"
 warn_redundant_casts = true
 warn_unreachable = true
 warn_unused_ignores = true
-exclude = [
-  '^Tests/oss-fuzz/fuzz_font.py$',
-  '^Tests/oss-fuzz/fuzz_pillow.py$',
-]

setup.py

@@ -15,18 +15,20 @@ import struct
 import subprocess
 import sys
 import warnings
+from collections.abc import Iterator
+from typing import Any
 
 from setuptools import Extension, setup
 from setuptools.command.build_ext import build_ext
 
 
-def get_version():
+def get_version() -> str:
     version_file = "src/PIL/_version.py"
     with open(version_file, encoding="utf-8") as f:
         return f.read().split('"')[1]
 
 
-configuration = {}
+configuration: dict[str, list[str]] = {}
 
 
 PILLOW_VERSION = get_version()
@@ -143,7 +145,7 @@ class RequiredDependencyException(Exception):
 PLATFORM_MINGW = os.name == "nt" and "GCC" in sys.version
 
 
-def _dbg(s, tp=None):
+def _dbg(s: str, tp: Any = None) -> None:
     if DEBUG:
         if tp:
             print(s % tp)
@@ -151,10 +153,13 @@ def _dbg(s, tp=None):
         print(s)
 
 
-def _find_library_dirs_ldconfig():
+def _find_library_dirs_ldconfig() -> list[str]:
     # Based on ctypes.util from Python 2
 
     ldconfig = "ldconfig" if shutil.which("ldconfig") else "/sbin/ldconfig"
+    args: list[str]
+    env: dict[str, str]
+    expr: str
     if sys.platform.startswith("linux") or sys.platform.startswith("gnu"):
         if struct.calcsize("l") == 4:
             machine = os.uname()[4] + "-32"
@@ -184,13 +189,11 @@ def _find_library_dirs_ldconfig():
 
     try:
         p = subprocess.Popen(
-            args, stderr=subprocess.DEVNULL, stdout=subprocess.PIPE, env=env
+            args, stderr=subprocess.DEVNULL, stdout=subprocess.PIPE, env=env, text=True
         )
     except OSError:  # E.g. command not found
         return []
-    [data, _] = p.communicate()
-    if isinstance(data, bytes):
-        data = data.decode("latin1")
+    data = p.communicate()[0]
 
     dirs = []
     for dll in re.findall(expr, data):
@@ -200,7 +203,9 @@ def _find_library_dirs_ldconfig():
     return dirs
 
 
-def _add_directory(path, subdir, where=None):
+def _add_directory(
+    path: list[str], subdir: str | None, where: int | None = None
+) -> None:
     if subdir is None:
         return
     subdir = os.path.realpath(subdir)
@@ -216,7 +221,7 @@ def _add_directory(path, subdir, where=None):
         path.insert(where, subdir)
 
 
-def _find_include_file(self, include):
+def _find_include_file(self: pil_build_ext, include: str) -> int:
     for directory in self.compiler.include_dirs:
         _dbg("Checking for include file %s in %s", (include, directory))
         if os.path.isfile(os.path.join(directory, include)):
@@ -225,7 +230,7 @@ def _find_include_file(self, include):
     return 0
 
 
-def _find_library_file(self, library):
+def _find_library_file(self: pil_build_ext, library: str) -> str | None:
     ret = self.compiler.find_library_file(self.compiler.library_dirs, library)
     if ret:
         _dbg("Found library %s at %s", (library, ret))
@@ -234,7 +239,7 @@ def _find_library_file(self, library):
     return ret
 
 
-def _find_include_dir(self, dirname, include):
+def _find_include_dir(self: pil_build_ext, dirname: str, include: str) -> bool | str:
     for directory in self.compiler.include_dirs:
         _dbg("Checking for include file %s in %s", (include, directory))
         if os.path.isfile(os.path.join(directory, include)):
@@ -245,6 +250,7 @@ def _find_include_dir(self, dirname, include):
         if os.path.isfile(os.path.join(subdir, include)):
             _dbg("Found %s in %s", (include, subdir))
             return subdir
+    return False
 
 
 def _cmd_exists(cmd: str) -> bool:
@@ -256,7 +262,7 @@ def _cmd_exists(cmd: str) -> bool:
     )
 
 
-def _pkg_config(name):
+def _pkg_config(name: str) -> tuple[list[str], list[str]] | None:
     command = os.environ.get("PKG_CONFIG", "pkg-config")
     for keep_system in (True, False):
         try:
@@ -283,10 +289,11 @@ def _pkg_config(name):
             return libs, cflags
         except Exception:
             pass
+    return None
 
 
 class pil_build_ext(build_ext):
-    class feature:
+    class ext_feature:
         features = [
             "zlib",
             "jpeg",
@@ -301,25 +308,32 @@ class pil_build_ext(build_ext):
         ]
 
         required = {"jpeg", "zlib"}
-        vendor = set()
+        vendor: set[str] = set()
 
-        def __init__(self):
+        def __init__(self) -> None:
+            self._settings: dict[str, str | bool | None] = {}
             for f in self.features:
-                setattr(self, f, None)
+                self.set(f, None)
 
-        def require(self, feat):
+        def require(self, feat: str) -> bool:
             return feat in self.required
 
-        def want(self, feat):
-            return getattr(self, feat) is None
+        def get(self, feat: str) -> str | bool | None:
+            return self._settings[feat]
 
-        def want_vendor(self, feat):
+        def set(self, feat: str, value: str | bool | None) -> None:
+            self._settings[feat] = value
+
+        def want(self, feat: str) -> bool:
+            return self._settings[feat] is None
+
+        def want_vendor(self, feat: str) -> bool:
             return feat in self.vendor
 
-        def __iter__(self):
+        def __iter__(self) -> Iterator[str]:
             yield from self.features
 
-    feature = feature()
+    feature = ext_feature()
 
     user_options = (
         build_ext.user_options
@@ -337,10 +351,10 @@ class pil_build_ext(build_ext):
     )
 
     @staticmethod
-    def check_configuration(option, value):
+    def check_configuration(option: str, value: str) -> bool | None:
         return True if value in configuration.get(option, []) else None
 
-    def initialize_options(self):
+    def initialize_options(self) -> None:
         self.disable_platform_guessing = self.check_configuration(
             "platform-guessing", "disable"
         )
@@ -355,7 +369,7 @@ class pil_build_ext(build_ext):
             self.debug = True
         self.parallel = configuration.get("parallel", [None])[-1]
 
-    def finalize_options(self):
+    def finalize_options(self) -> None:
         build_ext.finalize_options(self)
         if self.debug:
             global DEBUG
@@ -363,12 +377,16 @@ class pil_build_ext(build_ext):
         if not self.parallel:
             # If --parallel (or -j) wasn't specified, we want to reproduce the same
             # behavior as before, that is, auto-detect the number of jobs.
-            try:
-                self.parallel = int(
-                    os.environ.get("MAX_CONCURRENCY", min(4, os.cpu_count()))
-                )
-            except TypeError:
-                self.parallel = None
+            self.parallel = None
+
+            cpu_count = os.cpu_count()
+            if cpu_count is not None:
+                try:
+                    self.parallel = int(
+                        os.environ.get("MAX_CONCURRENCY", min(4, cpu_count))
+                    )
+                except TypeError:
+                    pass
         for x in self.feature:
             if getattr(self, f"disable_{x}"):
                 setattr(self.feature, x, False)
@@ -402,7 +420,13 @@ class pil_build_ext(build_ext):
                 _dbg("Using vendored version of %s", x)
                 self.feature.vendor.add(x)
 
-    def _update_extension(self, name, libraries, define_macros=None, sources=None):
+    def _update_extension(
+        self,
+        name: str,
+        libraries: list[str] | list[str | bool | None],
+        define_macros: list[tuple[str, str | None]] | None = None,
+        sources: list[str] | None = None,
+    ) -> None:
         for extension in self.extensions:
             if extension.name == name:
                 extension.libraries += libraries
@@ -415,13 +439,13 @@ class pil_build_ext(build_ext):
                     extension.extra_link_args = ["--stdlib=libc++"]
                 break
 
-    def _remove_extension(self, name):
+    def _remove_extension(self, name: str) -> None:
         for extension in self.extensions:
             if extension.name == name:
                 self.extensions.remove(extension)
                 break
 
-    def get_macos_sdk_path(self):
+    def get_macos_sdk_path(self) -> str | None:
         try:
             sdk_path = (
                 subprocess.check_output(["xcrun", "--show-sdk-path"])
@@ -442,9 +466,9 @@ class pil_build_ext(build_ext):
                 sdk_path = commandlinetools_sdk_path
         return sdk_path
 
-    def build_extensions(self):
-        library_dirs = []
-        include_dirs = []
+    def build_extensions(self) -> None:
+        library_dirs: list[str] = []
+        include_dirs: list[str] = []
 
         pkg_config = None
         if _cmd_exists(os.environ.get("PKG_CONFIG", "pkg-config")):
@@ -468,19 +492,22 @@ class pil_build_ext(build_ext):
             root = globals()[root_name]
 
             if root is None and root_name in os.environ:
-                prefix = os.environ[root_name]
-                root = (os.path.join(prefix, "lib"), os.path.join(prefix, "include"))
+                root_prefix = os.environ[root_name]
+                root = (
+                    os.path.join(root_prefix, "lib"),
+                    os.path.join(root_prefix, "include"),
+                )
 
             if root is None and pkg_config:
-                if isinstance(lib_name, tuple):
+                if isinstance(lib_name, str):
+                    _dbg(f"Looking for `{lib_name}` using pkg-config.")
+                    root = pkg_config(lib_name)
+                else:
                     for lib_name2 in lib_name:
                         _dbg(f"Looking for `{lib_name2}` using pkg-config.")
                         root = pkg_config(lib_name2)
                         if root:
                             break
-                else:
-                    _dbg(f"Looking for `{lib_name}` using pkg-config.")
-                    root = pkg_config(lib_name)
 
             if isinstance(root, tuple):
                 lib_root, include_root = root
@@ -660,22 +687,22 @@ class pil_build_ext(build_ext):
             _dbg("Looking for zlib")
             if _find_include_file(self, "zlib.h"):
                 if _find_library_file(self, "z"):
-                    feature.zlib = "z"
+                    feature.set("zlib", "z")
                 elif sys.platform == "win32" and _find_library_file(self, "zlib"):
-                    feature.zlib = "zlib"  # alternative name
+                    feature.set("zlib", "zlib")  # alternative name
 
         if feature.want("jpeg"):
             _dbg("Looking for jpeg")
             if _find_include_file(self, "jpeglib.h"):
                 if _find_library_file(self, "jpeg"):
-                    feature.jpeg = "jpeg"
+                    feature.set("jpeg", "jpeg")
                 elif sys.platform == "win32" and _find_library_file(self, "libjpeg"):
-                    feature.jpeg = "libjpeg"  # alternative name
+                    feature.set("jpeg", "libjpeg")  # alternative name
 
-        feature.openjpeg_version = None
+        feature.set("openjpeg_version", None)
         if feature.want("jpeg2000"):
             _dbg("Looking for jpeg2000")
-            best_version = None
+            best_version: tuple[int, ...] | None = None
             best_path = None
 
             # Find the best version
@@ -705,26 +732,26 @@ class pil_build_ext(build_ext):
                 # <openjpeg.h> rather than having to cope with the versioned
                 # include path
                 _add_directory(self.compiler.include_dirs, best_path, 0)
-                feature.jpeg2000 = "openjp2"
-                feature.openjpeg_version = ".".join(str(x) for x in best_version)
+                feature.set("jpeg2000", "openjp2")
+                feature.set("openjpeg_version", ".".join(str(x) for x in best_version))
 
         if feature.want("imagequant"):
             _dbg("Looking for imagequant")
             if _find_include_file(self, "libimagequant.h"):
                 if _find_library_file(self, "imagequant"):
-                    feature.imagequant = "imagequant"
+                    feature.set("imagequant", "imagequant")
                 elif _find_library_file(self, "libimagequant"):
-                    feature.imagequant = "libimagequant"
+                    feature.set("imagequant", "libimagequant")
 
         if feature.want("tiff"):
             _dbg("Looking for tiff")
             if _find_include_file(self, "tiff.h"):
                 if _find_library_file(self, "tiff"):
-                    feature.tiff = "tiff"
+                    feature.set("tiff", "tiff")
                 if sys.platform in ["win32", "darwin"] and _find_library_file(
                     self, "libtiff"
                 ):
-                    feature.tiff = "libtiff"
+                    feature.set("tiff", "libtiff")
 
         if feature.want("freetype"):
             _dbg("Looking for freetype")
@@ -745,31 +772,31 @@ class pil_build_ext(build_ext):
                         freetype_version = 21
                         break
                 if freetype_version:
-                    feature.freetype = "freetype"
+                    feature.set("freetype", "freetype")
                     if subdir:
                         _add_directory(self.compiler.include_dirs, subdir, 0)
 
-        if feature.freetype and feature.want("raqm"):
+        if feature.get("freetype") and feature.want("raqm"):
             if not feature.want_vendor("raqm"):  # want system Raqm
                 _dbg("Looking for Raqm")
                 if _find_include_file(self, "raqm.h"):
                     if _find_library_file(self, "raqm"):
-                        feature.raqm = "raqm"
+                        feature.set("raqm", "raqm")
                     elif _find_library_file(self, "libraqm"):
-                        feature.raqm = "libraqm"
+                        feature.set("raqm", "libraqm")
             else:  # want to build Raqm from src/thirdparty
                 _dbg("Looking for HarfBuzz")
-                feature.harfbuzz = None
+                feature.set("harfbuzz", None)
                 hb_dir = _find_include_dir(self, "harfbuzz", "hb.h")
                 if hb_dir:
                     if isinstance(hb_dir, str):
                         _add_directory(self.compiler.include_dirs, hb_dir, 0)
                     if _find_library_file(self, "harfbuzz"):
-                        feature.harfbuzz = "harfbuzz"
-                if feature.harfbuzz:
+                        feature.set("harfbuzz", "harfbuzz")
+                if feature.get("harfbuzz"):
                     if not feature.want_vendor("fribidi"):  # want system FriBiDi
                         _dbg("Looking for FriBiDi")
-                        feature.fribidi = None
+                        feature.set("fribidi", None)
                         fribidi_dir = _find_include_dir(self, "fribidi", "fribidi.h")
                         if fribidi_dir:
                             if isinstance(fribidi_dir, str):
@@ -777,19 +804,19 @@ class pil_build_ext(build_ext):
                                     self.compiler.include_dirs, fribidi_dir, 0
                                 )
                             if _find_library_file(self, "fribidi"):
-                                feature.fribidi = "fribidi"
-                                feature.raqm = True
+                                feature.set("fribidi", "fribidi")
+                                feature.set("raqm", True)
                     else:  # want to build FriBiDi shim from src/thirdparty
-                        feature.raqm = True
+                        feature.set("raqm", True)
 
         if feature.want("lcms"):
             _dbg("Looking for lcms")
             if _find_include_file(self, "lcms2.h"):
                 if _find_library_file(self, "lcms2"):
-                    feature.lcms = "lcms2"
+                    feature.set("lcms", "lcms2")
                 elif _find_library_file(self, "lcms2_static"):
                     # alternate Windows name.
-                    feature.lcms = "lcms2_static"
+                    feature.set("lcms", "lcms2_static")
 
         if feature.want("webp"):
             _dbg("Looking for webp")
@@ -803,17 +830,17 @@ class pil_build_ext(build_ext):
                         _find_library_file(self, prefix + library)
                         for library in ("webp", "webpmux", "webpdemux")
                     ):
-                        feature.webp = prefix + "webp"
+                        feature.set("webp", prefix + "webp")
                         break
 
         if feature.want("xcb"):
             _dbg("Looking for xcb")
             if _find_include_file(self, "xcb/xcb.h"):
                 if _find_library_file(self, "xcb"):
-                    feature.xcb = "xcb"
+                    feature.set("xcb", "xcb")
 
         for f in feature:
-            if not getattr(feature, f) and feature.require(f):
+            if not feature.get(f) and feature.require(f):
                 if f in ("jpeg", "zlib"):
                     raise RequiredDependencyException(f)
                 raise DependencyException(f)
@@ -821,10 +848,11 @@ class pil_build_ext(build_ext):
         #
         # core library
 
-        libs = self.add_imaging_libs.split()
-        defs = []
-        if feature.tiff:
-            libs.append(feature.tiff)
+        libs: list[str | bool | None] = []
+        libs.extend(self.add_imaging_libs.split())
+        defs: list[tuple[str, str | None]] = []
+        if feature.get("tiff"):
+            libs.append(feature.get("tiff"))
             defs.append(("HAVE_LIBTIFF", None))
             if sys.platform == "win32":
                 # This define needs to be defined if-and-only-if it was defined
@@ -832,22 +860,22 @@ class pil_build_ext(build_ext):
                 # so we have to guess; by default it is defined in all Windows builds.
                 # See #4237, #5243, #5359 for more information.
                 defs.append(("USE_WIN32_FILEIO", None))
-        if feature.jpeg:
-            libs.append(feature.jpeg)
+        if feature.get("jpeg"):
+            libs.append(feature.get("jpeg"))
             defs.append(("HAVE_LIBJPEG", None))
-        if feature.jpeg2000:
-            libs.append(feature.jpeg2000)
+        if feature.get("jpeg2000"):
+            libs.append(feature.get("jpeg2000"))
             defs.append(("HAVE_OPENJPEG", None))
             if sys.platform == "win32" and not PLATFORM_MINGW:
                 defs.append(("OPJ_STATIC", None))
-        if feature.zlib:
-            libs.append(feature.zlib)
+        if feature.get("zlib"):
+            libs.append(feature.get("zlib"))
             defs.append(("HAVE_LIBZ", None))
-        if feature.imagequant:
-            libs.append(feature.imagequant)
+        if feature.get("imagequant"):
+            libs.append(feature.get("imagequant"))
             defs.append(("HAVE_LIBIMAGEQUANT", None))
-        if feature.xcb:
-            libs.append(feature.xcb)
+        if feature.get("xcb"):
+            libs.append(feature.get("xcb"))
             defs.append(("HAVE_XCB", None))
         if sys.platform == "win32":
             libs.extend(["kernel32", "user32", "gdi32"])
@@ -861,22 +889,22 @@ class pil_build_ext(build_ext):
         #
         # additional libraries
 
-        if feature.freetype:
+        if feature.get("freetype"):
             srcs = []
             libs = ["freetype"]
             defs = []
-            if feature.raqm:
+            if feature.get("raqm"):
                 if not feature.want_vendor("raqm"):  # using system Raqm
                     defs.append(("HAVE_RAQM", None))
                     defs.append(("HAVE_RAQM_SYSTEM", None))
-                    libs.append(feature.raqm)
+                    libs.append(feature.get("raqm"))
                 else:  # building Raqm from src/thirdparty
                     defs.append(("HAVE_RAQM", None))
                     srcs.append("src/thirdparty/raqm/raqm.c")
-                    libs.append(feature.harfbuzz)
+                    libs.append(feature.get("harfbuzz"))
                     if not feature.want_vendor("fribidi"):  # using system FriBiDi
                         defs.append(("HAVE_FRIBIDI_SYSTEM", None))
-                        libs.append(feature.fribidi)
+                        libs.append(feature.get("fribidi"))
                     else:  # building FriBiDi shim from src/thirdparty
                         srcs.append("src/thirdparty/fribidi-shim/fribidi.c")
             self._update_extension("PIL._imagingft", libs, defs, srcs)
@@ -884,16 +912,17 @@ class pil_build_ext(build_ext):
         else:
             self._remove_extension("PIL._imagingft")
 
-        if feature.lcms:
-            extra = []
+        if feature.get("lcms"):
+            libs = [feature.get("lcms")]
             if sys.platform == "win32":
-                extra.extend(["user32", "gdi32"])
-            self._update_extension("PIL._imagingcms", [feature.lcms] + extra)
+                libs.extend(["user32", "gdi32"])
+            self._update_extension("PIL._imagingcms", libs)
         else:
             self._remove_extension("PIL._imagingcms")
 
-        if feature.webp:
-            libs = [feature.webp, feature.webp + "mux", feature.webp + "demux"]
+        webp = feature.get("webp")
+        if isinstance(webp, str):
+            libs = [webp, webp + "mux", webp + "demux"]
             self._update_extension("PIL._webp", libs)
         else:
             self._remove_extension("PIL._webp")
@@ -908,14 +937,14 @@ class pil_build_ext(build_ext):
 
         self.summary_report(feature)
 
-    def summary_report(self, feature):
+    def summary_report(self, feature: ext_feature) -> None:
         print("-" * 68)
         print("PIL SETUP SUMMARY")
         print("-" * 68)
         print(f"version      Pillow {PILLOW_VERSION}")
-        v = sys.version.split("[")
-        print(f"platform     {sys.platform} {v[0].strip()}")
-        for v in v[1:]:
+        version = sys.version.split("[")
+        print(f"platform     {sys.platform} {version[0].strip()}")
+        for v in version[1:]:
             print(f"             [{v.strip()}")
         print("-" * 68)
 
@@ -926,16 +955,20 @@ class pil_build_ext(build_ext):
                 raqm_extra_info += ", FriBiDi shim"
 
         options = [
-            (feature.jpeg, "JPEG"),
-            (feature.jpeg2000, "OPENJPEG (JPEG2000)", feature.openjpeg_version),
-            (feature.zlib, "ZLIB (PNG/ZIP)"),
-            (feature.imagequant, "LIBIMAGEQUANT"),
-            (feature.tiff, "LIBTIFF"),
-            (feature.freetype, "FREETYPE2"),
-            (feature.raqm, "RAQM (Text shaping)", raqm_extra_info),
-            (feature.lcms, "LITTLECMS2"),
-            (feature.webp, "WEBP"),
-            (feature.xcb, "XCB (X protocol)"),
+            (feature.get("jpeg"), "JPEG"),
+            (
+                feature.get("jpeg2000"),
+                "OPENJPEG (JPEG2000)",
+                feature.get("openjpeg_version"),
+            ),
+            (feature.get("zlib"), "ZLIB (PNG/ZIP)"),
+            (feature.get("imagequant"), "LIBIMAGEQUANT"),
+            (feature.get("tiff"), "LIBTIFF"),
+            (feature.get("freetype"), "FREETYPE2"),
+            (feature.get("raqm"), "RAQM (Text shaping)", raqm_extra_info),
+            (feature.get("lcms"), "LITTLECMS2"),
+            (feature.get("webp"), "WEBP"),
+            (feature.get("xcb"), "XCB (X protocol)"),
         ]
 
         all = 1
@@ -964,7 +997,7 @@ class pil_build_ext(build_ext):
         print("")
 
 
-def debug_build():
+def debug_build() -> bool:
     return hasattr(sys, "gettotalrefcount") or FUZZING_BUILD
 
 

src/PIL/BlpImagePlugin.py

@@ -273,13 +273,13 @@ class BlpImageFile(ImageFile.ImageFile):
             raise BLPFormatError(msg)
 
         self._mode = "RGBA" if self._blp_alpha_depth else "RGB"
-        self.tile = [(decoder, (0, 0) + self.size, 0, (self.mode, 0, 1))]
+        self.tile = [ImageFile._Tile(decoder, (0, 0) + self.size, 0, (self.mode, 0, 1))]
 
 
 class _BLPBaseDecoder(ImageFile.PyDecoder):
     _pulls_fd = True
 
-    def decode(self, buffer: bytes) -> tuple[int, int]:
+    def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
         try:
             self._read_blp_header()
             self._load()
@@ -372,7 +372,10 @@ class BLP1Decoder(_BLPBaseDecoder):
         Image._decompression_bomb_check(image.size)
         if image.mode == "CMYK":
             decoder_name, extents, offset, args = image.tile[0]
-            image.tile = [(decoder_name, extents, offset, (args[0], "CMYK"))]
+            assert isinstance(args, tuple)
+            image.tile = [
+                ImageFile._Tile(decoder_name, extents, offset, (args[0], "CMYK"))
+            ]
         r, g, b = image.convert("RGB").split()
         reversed_image = Image.merge("RGB", (b, g, r))
         self.set_as_raw(reversed_image.tobytes())

src/PIL/BmpImagePlugin.py

@@ -296,7 +296,7 @@ class BmpImageFile(ImageFile.ImageFile):
             args.append(((file_info["width"] * file_info["bits"] + 31) >> 3) & (~3))
         args.append(file_info["direction"])
         self.tile = [
-            (
+            ImageFile._Tile(
                 decoder_name,
                 (0, 0, file_info["width"], file_info["height"]),
                 offset or self.fp.tell(),
@@ -321,7 +321,7 @@ class BmpImageFile(ImageFile.ImageFile):
 class BmpRleDecoder(ImageFile.PyDecoder):
     _pulls_fd = True
 
-    def decode(self, buffer: bytes) -> tuple[int, int]:
+    def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
         assert self.fd is not None
         rle4 = self.args[1]
         data = bytearray()
@@ -387,7 +387,7 @@ class BmpRleDecoder(ImageFile.PyDecoder):
                     if self.fd.tell() % 2 != 0:
                         self.fd.seek(1, os.SEEK_CUR)
         rawmode = "L" if self.mode == "L" else "P"
-        self.set_as_raw(bytes(data), (rawmode, 0, self.args[-1]))
+        self.set_as_raw(bytes(data), rawmode, (0, self.args[-1]))
         return -1, 0
 
 

src/PIL/CurImagePlugin.py

@@ -17,7 +17,7 @@
 #
 from __future__ import annotations
 
-from . import BmpImagePlugin, Image
+from . import BmpImagePlugin, Image, ImageFile
 from ._binary import i16le as i16
 from ._binary import i32le as i32
 
@@ -64,7 +64,7 @@ class CurImageFile(BmpImagePlugin.BmpImageFile):
         # patch up the bitmap height
         self._size = self.size[0], self.size[1] // 2
         d, e, o, a = self.tile[0]
-        self.tile[0] = d, (0, 0) + self.size, o, a
+        self.tile[0] = ImageFile._Tile(d, (0, 0) + self.size, o, a)
 
 
 #

src/PIL/DdsImagePlugin.py

@@ -367,7 +367,7 @@ class DdsImageFile(ImageFile.ImageFile):
                 mask_count = 3
 
             masks = struct.unpack(f"<{mask_count}I", header.read(mask_count * 4))
-            self.tile = [("dds_rgb", extents, 0, (bitcount, masks))]
+            self.tile = [ImageFile._Tile("dds_rgb", extents, 0, (bitcount, masks))]
             return
         elif pfflags & DDPF.LUMINANCE:
             if bitcount == 8:
@@ -481,7 +481,7 @@ class DdsImageFile(ImageFile.ImageFile):
 class DdsRgbDecoder(ImageFile.PyDecoder):
     _pulls_fd = True
 
-    def decode(self, buffer: bytes) -> tuple[int, int]:
+    def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
         assert self.fd is not None
         bitcount, masks = self.args
 

src/PIL/FitsImagePlugin.py

@@ -67,7 +67,7 @@ class FitsImageFile(ImageFile.ImageFile):
             raise ValueError(msg)
 
         offset += self.fp.tell() - 80
-        self.tile = [(decoder_name, (0, 0) + self.size, offset, args)]
+        self.tile = [ImageFile._Tile(decoder_name, (0, 0) + self.size, offset, args)]
 
     def _get_size(
         self, headers: dict[bytes, bytes], prefix: bytes
@@ -126,7 +126,7 @@ class FitsImageFile(ImageFile.ImageFile):
 class FitsGzipDecoder(ImageFile.PyDecoder):
     _pulls_fd = True
 
-    def decode(self, buffer: bytes) -> tuple[int, int]:
+    def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
         assert self.fd is not None
         value = gzip.decompress(self.fd.read())
 

src/PIL/FliImagePlugin.py

@@ -159,7 +159,7 @@ class FliImageFile(ImageFile.ImageFile):
         framesize = i32(s)
 
         self.decodermaxblock = framesize
-        self.tile = [("fli", (0, 0) + self.size, self.__offset, None)]
+        self.tile = [ImageFile._Tile("fli", (0, 0) + self.size, self.__offset, None)]
 
         self.__offset += framesize
 

src/PIL/FpxImagePlugin.py

@@ -166,7 +166,7 @@ class FpxImageFile(ImageFile.ImageFile):
 
             if compression == 0:
                 self.tile.append(
-                    (
+                    ImageFile._Tile(
                         "raw",
                         (x, y, x1, y1),
                         i32(s, i) + 28,
@@ -177,7 +177,7 @@ class FpxImageFile(ImageFile.ImageFile):
             elif compression == 1:
                 # FIXME: the fill decoder is not implemented
                 self.tile.append(
-                    (
+                    ImageFile._Tile(
                         "fill",
                         (x, y, x1, y1),
                         i32(s, i) + 28,
@@ -205,7 +205,7 @@ class FpxImageFile(ImageFile.ImageFile):
                     jpegmode = rawmode
 
                 self.tile.append(
-                    (
+                    ImageFile._Tile(
                         "jpeg",
                         (x, y, x1, y1),
                         i32(s, i) + 28,

src/PIL/FtexImagePlugin.py

@@ -93,9 +93,9 @@ class FtexImageFile(ImageFile.ImageFile):
 
         if format == Format.DXT1:
             self._mode = "RGBA"
-            self.tile = [("bcn", (0, 0) + self.size, 0, 1)]
+            self.tile = [ImageFile._Tile("bcn", (0, 0) + self.size, 0, (1,))]
         elif format == Format.UNCOMPRESSED:
-            self.tile = [("raw", (0, 0) + self.size, 0, ("RGB", 0, 1))]
+            self.tile = [ImageFile._Tile("raw", (0, 0) + self.size, 0, ("RGB", 0, 1))]
         else:
             msg = f"Invalid texture compression format: {repr(format)}"
             raise ValueError(msg)

src/PIL/GdImageFile.py

@@ -72,7 +72,7 @@ class GdImageFile(ImageFile.ImageFile):
         )
 
         self.tile = [
-            (
+            ImageFile._Tile(
                 "raw",
                 (0, 0) + self.size,
                 7 + true_color_offset + 4 + 256 * 4,

src/PIL/GifImagePlugin.py

@@ -29,7 +29,6 @@ import itertools
 import math
 import os
 import subprocess
-import sys
 from enum import IntEnum
 from functools import cached_property
 from typing import IO, TYPE_CHECKING, Any, Literal, NamedTuple, Union
@@ -49,6 +48,7 @@ from ._binary import o16le as o16
 
 if TYPE_CHECKING:
     from . import _imaging
+    from ._typing import Buffer
 
 
 class LoadingStrategy(IntEnum):
@@ -407,7 +407,7 @@ class GifImageFile(ImageFile.ImageFile):
                 elif self.mode not in ("RGB", "RGBA"):
                     transparency = frame_transparency
             self.tile = [
-                (
+                ImageFile._Tile(
                     "gif",
                     (x0, y0, x1, y1),
                     self.__offset,
@@ -438,6 +438,13 @@ class GifImageFile(ImageFile.ImageFile):
                 self.im.putpalette("RGB", *self._frame_palette.getdata())
             else:
                 self._im = None
+        if not self._prev_im and self._im is not None and self.size != self.im.size:
+            expanded_im = Image.core.fill(self.im.mode, self.size)
+            if self._frame_palette:
+                expanded_im.putpalette("RGB", *self._frame_palette.getdata())
+            expanded_im.paste(self.im, (0, 0) + self.im.size)
+
+            self.im = expanded_im
         self._mode = temp_mode
         self._frame_palette = None
 
@@ -455,6 +462,17 @@ class GifImageFile(ImageFile.ImageFile):
             return
         if not self._prev_im:
             return
+        if self.size != self._prev_im.size:
+            if self._frame_transparency is not None:
+                expanded_im = Image.core.fill("RGBA", self.size)
+            else:
+                expanded_im = Image.core.fill("P", self.size)
+                expanded_im.putpalette("RGB", "RGB", self.im.getpalette())
+                expanded_im = expanded_im.convert("RGB")
+            expanded_im.paste(self._prev_im, (0, 0) + self._prev_im.size)
+
+            self._prev_im = expanded_im
+            assert self._prev_im is not None
         if self._frame_transparency is not None:
             self.im.putpalettealpha(self._frame_transparency, 0)
             frame_im = self.im.convert("RGBA")
@@ -535,7 +553,9 @@ def _normalize_palette(
 
     if im.mode == "P":
         if not source_palette:
-            source_palette = im.im.getpalette("RGB")[:768]
+            im_palette = im.getpalette(None)
+            assert im_palette is not None
+            source_palette = bytearray(im_palette)
     else:  # L-mode
         if not source_palette:
             source_palette = bytearray(i // 3 for i in range(768))
@@ -611,7 +631,10 @@ def _write_single_frame(
 def _getbbox(
     base_im: Image.Image, im_frame: Image.Image
 ) -> tuple[Image.Image, tuple[int, int, int, int] | None]:
-    if _get_palette_bytes(im_frame) != _get_palette_bytes(base_im):
+    palette_bytes = [
+        bytes(im.palette.palette) if im.palette else b"" for im in (base_im, im_frame)
+    ]
+    if palette_bytes[0] != palette_bytes[1]:
         im_frame = im_frame.convert("RGBA")
         base_im = base_im.convert("RGBA")
     delta = ImageChops.subtract_modulo(im_frame, base_im)
@@ -966,7 +989,13 @@ def _get_palette_bytes(im: Image.Image) -> bytes:
     :param im: Image object
     :returns: Bytes, len<=768 suitable for inclusion in gif header
     """
-    return bytes(im.palette.palette) if im.palette else b""
+    if not im.palette:
+        return b""
+
+    palette = bytes(im.palette.palette)
+    if im.palette.mode == "RGBA":
+        palette = b"".join(palette[i * 4 : i * 4 + 3] for i in range(len(palette) // 3))
+    return palette
 
 
 def _get_background(
@@ -1139,18 +1168,9 @@ def getdata(
     class Collector(BytesIO):
         data = []
 
-        if sys.version_info >= (3, 12):
-            from collections.abc import Buffer
-
-            def write(self, data: Buffer) -> int:
-                self.data.append(data)
-                return len(data)
-
-        else:
-
-            def write(self, data: Any) -> int:
-                self.data.append(data)
-                return len(data)
+        def write(self, data: Buffer) -> int:
+            self.data.append(data)
+            return len(data)
 
     im.load()  # make sure raster data is available
 

src/PIL/IcnsImagePlugin.py

@@ -25,6 +25,7 @@ import sys
 from typing import IO
 
 from . import Image, ImageFile, PngImagePlugin, features
+from ._deprecate import deprecate
 
 enable_jpeg2k = features.check_codec("jpg_2000")
 if enable_jpeg2k:
@@ -275,37 +276,37 @@ class IcnsImageFile(ImageFile.ImageFile):
             self.best_size[1] * self.best_size[2],
         )
 
-    @property
-    def size(self):
+    @property  # type: ignore[override]
+    def size(self) -> tuple[int, int] | tuple[int, int, int]:
         return self._size
 
     @size.setter
-    def size(self, value) -> None:
-        info_size = value
-        if info_size not in self.info["sizes"] and len(info_size) == 2:
-            info_size = (info_size[0], info_size[1], 1)
-        if (
-            info_size not in self.info["sizes"]
-            and len(info_size) == 3
-            and info_size[2] == 1
-        ):
-            simple_sizes = [
-                (size[0] * size[2], size[1] * size[2]) for size in self.info["sizes"]
-            ]
-            if value in simple_sizes:
-                info_size = self.info["sizes"][simple_sizes.index(value)]
-        if info_size not in self.info["sizes"]:
-            msg = "This is not one of the allowed sizes of this image"
-            raise ValueError(msg)
-        self._size = value
+    def size(self, value: tuple[int, int] | tuple[int, int, int]) -> None:
+        if len(value) == 3:
+            deprecate("Setting size to (width, height, scale)", 12, "load(scale)")
+            if value in self.info["sizes"]:
+                self._size = value  # type: ignore[assignment]
+                return
+        else:
+            # Check that a matching size exists,
+            # or that there is a scale that would create a size that matches
+            for size in self.info["sizes"]:
+                simple_size = size[0] * size[2], size[1] * size[2]
+                scale = simple_size[0] // value[0]
+                if simple_size[1] / value[1] == scale:
+                    self._size = value
+                    return
+        msg = "This is not one of the allowed sizes of this image"
+        raise ValueError(msg)
 
-    def load(self) -> Image.core.PixelAccess | None:
-        if len(self.size) == 3:
-            self.best_size = self.size
-            self.size = (
-                self.best_size[0] * self.best_size[2],
-                self.best_size[1] * self.best_size[2],
-            )
+    def load(self, scale: int | None = None) -> Image.core.PixelAccess | None:
+        if scale is not None or len(self.size) == 3:
+            if scale is None and len(self.size) == 3:
+                scale = self.size[2]
+            assert scale is not None
+            width, height = self.size[:2]
+            self.size = width * scale, height * scale
+            self.best_size = width, height, scale
 
         px = Image.Image.load(self)
         if self._im is not None and self.im.size == self.size:

src/PIL/IcoImagePlugin.py

@@ -228,7 +228,7 @@ class IcoFile:
             # change tile dimension to only encompass XOR image
             im._size = (im.size[0], int(im.size[1] / 2))
             d, e, o, a = im.tile[0]
-            im.tile[0] = d, (0, 0) + im.size, o, a
+            im.tile[0] = ImageFile._Tile(d, (0, 0) + im.size, o, a)
 
             # figure out where AND mask image starts
             if header.bpp == 32:
@@ -243,13 +243,19 @@ class IcoFile:
                 alpha_bytes = self.buf.read(im.size[0] * im.size[1] * 4)[3::4]
 
                 # convert to an 8bpp grayscale image
-                mask = Image.frombuffer(
-                    "L",  # 8bpp
-                    im.size,  # (w, h)
-                    alpha_bytes,  # source chars
-                    "raw",  # raw decoder
-                    ("L", 0, -1),  # 8bpp inverted, unpadded, reversed
-                )
+                try:
+                    mask = Image.frombuffer(
+                        "L",  # 8bpp
+                        im.size,  # (w, h)
+                        alpha_bytes,  # source chars
+                        "raw",  # raw decoder
+                        ("L", 0, -1),  # 8bpp inverted, unpadded, reversed
+                    )
+                except ValueError:
+                    if ImageFile.LOAD_TRUNCATED_IMAGES:
+                        mask = None
+                    else:
+                        raise
             else:
                 # get AND image from end of bitmap
                 w = im.size[0]
@@ -267,19 +273,26 @@ class IcoFile:
                 mask_data = self.buf.read(total_bytes)
 
                 # convert raw data to image
-                mask = Image.frombuffer(
-                    "1",  # 1 bpp
-                    im.size,  # (w, h)
-                    mask_data,  # source chars
-                    "raw",  # raw decoder
-                    ("1;I", int(w / 8), -1),  # 1bpp inverted, padded, reversed
-                )
+                try:
+                    mask = Image.frombuffer(
+                        "1",  # 1 bpp
+                        im.size,  # (w, h)
+                        mask_data,  # source chars
+                        "raw",  # raw decoder
+                        ("1;I", int(w / 8), -1),  # 1bpp inverted, padded, reversed
+                    )
+                except ValueError:
+                    if ImageFile.LOAD_TRUNCATED_IMAGES:
+                        mask = None
+                    else:
+                        raise
 
                 # now we have two images, im is XOR image and mask is AND image
 
             # apply mask image as alpha channel
-            im = im.convert("RGBA")
-            im.putalpha(mask)
+            if mask:
+                im = im.convert("RGBA")
+                im.putalpha(mask)
 
         return im
 

src/PIL/ImImagePlugin.py

@@ -253,7 +253,11 @@ class ImImageFile(ImageFile.ImageFile):
                 # use bit decoder (if necessary)
                 bits = int(self.rawmode[2:])
                 if bits not in [8, 16, 32]:
-                    self.tile = [("bit", (0, 0) + self.size, offs, (bits, 8, 3, 0, -1))]
+                    self.tile = [
+                        ImageFile._Tile(
+                            "bit", (0, 0) + self.size, offs, (bits, 8, 3, 0, -1)
+                        )
+                    ]
                     return
             except ValueError:
                 pass
@@ -263,13 +267,17 @@ class ImImageFile(ImageFile.ImageFile):
             # ever stumbled upon such a file ;-)
             size = self.size[0] * self.size[1]
             self.tile = [
-                ("raw", (0, 0) + self.size, offs, ("G", 0, -1)),
-                ("raw", (0, 0) + self.size, offs + size, ("R", 0, -1)),
-                ("raw", (0, 0) + self.size, offs + 2 * size, ("B", 0, -1)),
+                ImageFile._Tile("raw", (0, 0) + self.size, offs, ("G", 0, -1)),
+                ImageFile._Tile("raw", (0, 0) + self.size, offs + size, ("R", 0, -1)),
+                ImageFile._Tile(
+                    "raw", (0, 0) + self.size, offs + 2 * size, ("B", 0, -1)
+                ),
             ]
         else:
             # LabEye/IFUNC files
-            self.tile = [("raw", (0, 0) + self.size, offs, (self.rawmode, 0, -1))]
+            self.tile = [
+                ImageFile._Tile("raw", (0, 0) + self.size, offs, (self.rawmode, 0, -1))
+            ]
 
     @property
     def n_frames(self) -> int:
@@ -295,7 +303,9 @@ class ImImageFile(ImageFile.ImageFile):
 
         self.fp = self._fp
 
-        self.tile = [("raw", (0, 0) + self.size, offs, (self.rawmode, 0, -1))]
+        self.tile = [
+            ImageFile._Tile("raw", (0, 0) + self.size, offs, (self.rawmode, 0, -1))
+        ]
 
     def tell(self) -> int:
         return self.frame

src/PIL/Image.py

@@ -133,6 +133,7 @@ def isImageType(t: Any) -> TypeGuard[Image]:
     :param t: object to check if it's an image
     :returns: True if the object is an image
     """
+    deprecate("Image.isImageType(im)", 12, "isinstance(im, Image.Image)")
     return hasattr(t, "im")
 
 
@@ -225,6 +226,11 @@ if TYPE_CHECKING:
 
     from . import ImageFile, ImageFilter, ImagePalette, ImageQt, TiffImagePlugin
     from ._typing import NumpyArray, StrOrBytesPath, TypeGuard
+
+    if sys.version_info >= (3, 13):
+        from types import CapsuleType
+    else:
+        CapsuleType = object
 ID: list[str] = []
 OPEN: dict[
     str,
@@ -851,7 +857,10 @@ class Image:
         )
 
     def frombytes(
-        self, data: bytes | bytearray, decoder_name: str = "raw", *args: Any
+        self,
+        data: bytes | bytearray | SupportsArrayInterface,
+        decoder_name: str = "raw",
+        *args: Any,
     ) -> None:
         """
         Loads this image with pixel data from a bytes object.
@@ -1058,7 +1067,7 @@ class Image:
                     trns_im = new(self.mode, (1, 1))
                     if self.mode == "P":
                         assert self.palette is not None
-                        trns_im.putpalette(self.palette)
+                        trns_im.putpalette(self.palette, self.palette.mode)
                         if isinstance(t, tuple):
                             err = "Couldn't allocate a palette color for transparency"
                             assert trns_im.palette is not None
@@ -1122,17 +1131,23 @@ class Image:
             return new_im
 
         if "LAB" in (self.mode, mode):
-            other_mode = mode if self.mode == "LAB" else self.mode
+            im = self
+            if mode == "LAB":
+                if im.mode not in ("RGB", "RGBA", "RGBX"):
+                    im = im.convert("RGBA")
+                other_mode = im.mode
+            else:
+                other_mode = mode
             if other_mode in ("RGB", "RGBA", "RGBX"):
                 from . import ImageCms
 
                 srgb = ImageCms.createProfile("sRGB")
                 lab = ImageCms.createProfile("LAB")
-                profiles = [lab, srgb] if self.mode == "LAB" else [srgb, lab]
+                profiles = [lab, srgb] if im.mode == "LAB" else [srgb, lab]
                 transform = ImageCms.buildTransform(
-                    profiles[0], profiles[1], self.mode, mode
+                    profiles[0], profiles[1], im.mode, mode
                 )
-                return transform.apply(self)
+                return transform.apply(im)
 
         # colorspace conversion
         if dither is None:
@@ -1598,7 +1613,7 @@ class Image:
             self.fp.seek(offset)
         return child_images
 
-    def getim(self):
+    def getim(self) -> CapsuleType:
         """
         Returns a capsule that points to the internal image memory.
 
@@ -1809,23 +1824,22 @@ class Image:
         :param mask: An optional mask image.
         """
 
-        if isImageType(box):
+        if isinstance(box, Image):
             if mask is not None:
                 msg = "If using second argument as mask, third argument must be None"
                 raise ValueError(msg)
             # abbreviated paste(im, mask) syntax
             mask = box
             box = None
-        assert not isinstance(box, Image)
 
         if box is None:
             box = (0, 0)
 
         if len(box) == 2:
             # upper left corner given; get size from image or mask
-            if isImageType(im):
+            if isinstance(im, Image):
                 size = im.size
-            elif isImageType(mask):
+            elif isinstance(mask, Image):
                 size = mask.size
             else:
                 # FIXME: use self.size here?
@@ -1838,17 +1852,15 @@ class Image:
             from . import ImageColor
 
             source = ImageColor.getcolor(im, self.mode)
-        elif isImageType(im):
+        elif isinstance(im, Image):
             im.load()
             if self.mode != im.mode:
                 if self.mode != "RGB" or im.mode not in ("LA", "RGBA", "RGBa"):
                     # should use an adapter for this!
                     im = im.convert(self.mode)
             source = im.im
-        elif isinstance(im, tuple):
-            source = im
         else:
-            source = cast(float, im)
+            source = im
 
         self._ensure_mutable()
 
@@ -2009,7 +2021,7 @@ class Image:
         else:
             band = 3
 
-        if isImageType(alpha):
+        if isinstance(alpha, Image):
             # alpha layer
             if alpha.mode not in ("1", "L"):
                 msg = "illegal image mode"
@@ -2019,7 +2031,6 @@ class Image:
                 alpha = alpha.convert("L")
         else:
             # constant alpha
-            alpha = cast(int, alpha)  # see python/typing#1013
             try:
                 self.im.fillband(band, alpha)
             except (AttributeError, ValueError):
@@ -2168,6 +2179,9 @@ class Image:
                 source_palette = self.im.getpalette(palette_mode, palette_mode)
             else:  # L-mode
                 source_palette = bytearray(i // 3 for i in range(768))
+        elif len(source_palette) > 768:
+            bands = 4
+            palette_mode = "RGBA"
 
         palette_bytes = b""
         new_positions = [0] * 256
@@ -3140,7 +3154,7 @@ def new(
 def frombytes(
     mode: str,
     size: tuple[int, int],
-    data: bytes | bytearray,
+    data: bytes | bytearray | SupportsArrayInterface,
     decoder_name: str = "raw",
     *args: Any,
 ) -> Image:
@@ -3184,7 +3198,11 @@ def frombytes(
 
 
 def frombuffer(
-    mode: str, size: tuple[int, int], data, decoder_name: str = "raw", *args: Any
+    mode: str,
+    size: tuple[int, int],
+    data: bytes | SupportsArrayInterface,
+    decoder_name: str = "raw",
+    *args: Any,
 ) -> Image:
     """
     Creates an image memory referencing pixel data in a byte buffer.
@@ -3641,7 +3659,10 @@ def merge(mode: str, bands: Sequence[Image]) -> Image:
 
 def register_open(
     id: str,
-    factory: Callable[[IO[bytes], str | bytes], ImageFile.ImageFile],
+    factory: (
+        Callable[[IO[bytes], str | bytes], ImageFile.ImageFile]
+        | type[ImageFile.ImageFile]
+    ),
     accept: Callable[[bytes], bool | str] | None = None,
 ) -> None:
     """
@@ -3960,7 +3981,7 @@ class Exif(_ExifBase):
         self._data.clear()
         self._hidden_data.clear()
         self._ifds.clear()
-        if data and data.startswith(b"Exif\x00\x00"):
+        while data and data.startswith(b"Exif\x00\x00"):
             data = data[6:]
         if not data:
             self._info = None
@@ -4136,7 +4157,7 @@ class Exif(_ExifBase):
                     ifd = self._get_ifd_dict(tag_data, tag)
                     if ifd is not None:
                         self._ifds[tag] = ifd
-        ifd = self._ifds.get(tag, {})
+        ifd = self._ifds.setdefault(tag, {})
         if tag == ExifTags.IFD.Exif and self._hidden_data:
             ifd = {
                 k: v

src/PIL/ImageFile.py

@@ -34,12 +34,15 @@ import itertools
 import os
 import struct
 import sys
-from typing import IO, Any, NamedTuple
+from typing import IO, TYPE_CHECKING, Any, NamedTuple, cast
 
 from . import Image
 from ._deprecate import deprecate
 from ._util import is_path
 
+if TYPE_CHECKING:
+    from ._typing import StrOrBytesPath
+
 MAXBLOCK = 65536
 
 SAFEBLOCK = 1024 * 1024
@@ -107,32 +110,34 @@ class _Tile(NamedTuple):
 class ImageFile(Image.Image):
     """Base class for image file format handlers."""
 
-    def __init__(self, fp=None, filename=None):
+    def __init__(
+        self, fp: StrOrBytesPath | IO[bytes], filename: str | bytes | None = None
+    ) -> None:
         super().__init__()
 
         self._min_frame = 0
 
-        self.custom_mimetype = None
+        self.custom_mimetype: str | None = None
 
-        self.tile = None
+        self.tile: list[_Tile] = []
         """ A list of tile descriptors, or ``None`` """
 
         self.readonly = 1  # until we know better
 
-        self.decoderconfig = ()
+        self.decoderconfig: tuple[Any, ...] = ()
         self.decodermaxblock = MAXBLOCK
 
         if is_path(fp):
             # filename
             self.fp = open(fp, "rb")
-            self.filename = fp
+            self.filename = os.path.realpath(os.fspath(fp))
             self._exclusive_fp = True
         else:
             # stream
-            self.fp = fp
-            self.filename = filename
+            self.fp = cast(IO[bytes], fp)
+            self.filename = filename if filename is not None else ""
             # can be overridden
-            self._exclusive_fp = None
+            self._exclusive_fp = False
 
         try:
             try:
@@ -155,6 +160,9 @@ class ImageFile(Image.Image):
                 self.fp.close()
             raise
 
+    def _open(self) -> None:
+        pass
+
     def get_format_mimetype(self) -> str | None:
         if self.custom_mimetype:
             return self.custom_mimetype
@@ -178,7 +186,7 @@ class ImageFile(Image.Image):
     def load(self) -> Image.core.PixelAccess | None:
         """Load image data based on tile list"""
 
-        if self.tile is None:
+        if not self.tile and self._im is None:
             msg = "cannot load this image"
             raise OSError(msg)
 
@@ -214,6 +222,7 @@ class ImageFile(Image.Image):
                 args = (args, 0, 1)
             if (
                 decoder_name == "raw"
+                and isinstance(args, tuple)
                 and len(args) >= 3
                 and args[0] == self.mode
                 and args[0] in Image._MAPMODES
@@ -724,7 +733,7 @@ class PyDecoder(PyCodec):
     def pulls_fd(self) -> bool:
         return self._pulls_fd
 
-    def decode(self, buffer: bytes) -> tuple[int, int]:
+    def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
         """
         Override to perform the decoding process.
 
@@ -736,19 +745,22 @@ class PyDecoder(PyCodec):
         msg = "unavailable in base decoder"
         raise NotImplementedError(msg)
 
-    def set_as_raw(self, data: bytes, rawmode=None) -> None:
+    def set_as_raw(
+        self, data: bytes, rawmode: str | None = None, extra: tuple[Any, ...] = ()
+    ) -> None:
         """
         Convenience method to set the internal image from a stream of raw data
 
         :param data: Bytes to be set
         :param rawmode: The rawmode to be used for the decoder.
             If not specified, it will default to the mode of the image
+        :param extra: Extra arguments for the decoder.
         :returns: None
         """
 
         if not rawmode:
             rawmode = self.mode
-        d = Image._getdecoder(self.mode, "raw", rawmode)
+        d = Image._getdecoder(self.mode, "raw", rawmode, extra)
         assert self.im is not None
         d.setimage(self.im, self.state.extents())
         s = d.decode(data)

src/PIL/ImageFont.py

@@ -34,9 +34,9 @@ import warnings
 from enum import IntEnum
 from io import BytesIO
 from types import ModuleType
-from typing import IO, TYPE_CHECKING, Any, BinaryIO, TypedDict
+from typing import IO, TYPE_CHECKING, Any, BinaryIO, TypedDict, cast
 
-from . import Image
+from . import Image, features
 from ._typing import StrOrBytesPath
 from ._util import DeferredError, is_path
 
@@ -215,7 +215,7 @@ class FreeTypeFont:
 
     def __init__(
         self,
-        font: StrOrBytesPath | BinaryIO | None = None,
+        font: StrOrBytesPath | BinaryIO,
         size: float = 10,
         index: int = 0,
         encoding: str = "",
@@ -235,6 +235,21 @@ class FreeTypeFont:
         self.index = index
         self.encoding = encoding
 
+        try:
+            from packaging.version import parse as parse_version
+        except ImportError:
+            pass
+        else:
+            if freetype_version := features.version_module("freetype2"):
+                if parse_version(freetype_version) < parse_version("2.9.1"):
+                    warnings.warn(
+                        "Support for FreeType 2.9.0 is deprecated and will be removed "
+                        "in Pillow 12 (2025-10-15). Please upgrade to FreeType 2.9.1 "
+                        "or newer, preferably FreeType 2.10.4 which fixes "
+                        "CVE-2020-15999.",
+                        DeprecationWarning,
+                    )
+
         if layout_engine not in (Layout.BASIC, Layout.RAQM):
             layout_engine = Layout.BASIC
             if core.HAVE_RAQM:
@@ -248,7 +263,7 @@ class FreeTypeFont:
 
         self.layout_engine = layout_engine
 
-        def load_from_bytes(f) -> None:
+        def load_from_bytes(f: IO[bytes]) -> None:
             self.font_bytes = f.read()
             self.font = core.getfont(
                 "", size, index, encoding, self.font_bytes, layout_engine
@@ -270,7 +285,7 @@ class FreeTypeFont:
                 font, size, index, encoding, layout_engine=layout_engine
             )
         else:
-            load_from_bytes(font)
+            load_from_bytes(cast(IO[bytes], font))
 
     def __getstate__(self) -> list[Any]:
         return [self.path, self.size, self.index, self.encoding, self.layout_engine]
@@ -785,7 +800,7 @@ def load(filename: str) -> ImageFont:
 
 
 def truetype(
-    font: StrOrBytesPath | BinaryIO | None = None,
+    font: StrOrBytesPath | BinaryIO,
     size: float = 10,
     index: int = 0,
     encoding: str = "",
@@ -857,7 +872,7 @@ def truetype(
     :exception ValueError: If the font size is not greater than zero.
     """
 
-    def freetype(font: StrOrBytesPath | BinaryIO | None) -> FreeTypeFont:
+    def freetype(font: StrOrBytesPath | BinaryIO) -> FreeTypeFont:
         return FreeTypeFont(font, size, index, encoding, layout_engine)
 
     try:

src/PIL/ImageMath.py

@@ -268,7 +268,7 @@ def lambda_eval(
     args.update(options)
     args.update(kw)
     for k, v in args.items():
-        if hasattr(v, "im"):
+        if isinstance(v, Image.Image):
             args[k] = _Operand(v)
 
     out = expression(args)
@@ -319,7 +319,7 @@ def unsafe_eval(
     args.update(options)
     args.update(kw)
     for k, v in args.items():
-        if hasattr(v, "im"):
+        if isinstance(v, Image.Image):
             args[k] = _Operand(v)
 
     compiled_code = compile(expression, "<string>", "eval")

src/PIL/ImtImagePlugin.py

@@ -58,7 +58,7 @@ class ImtImageFile(ImageFile.ImageFile):
             if s == b"\x0C":
                 # image data begins
                 self.tile = [
-                    (
+                    ImageFile._Tile(
                         "raw",
                         (0, 0) + self.size,
                         self.fp.tell() - len(buffer),

src/PIL/IptcImagePlugin.py

@@ -147,7 +147,9 @@ class IptcImageFile(ImageFile.ImageFile):
 
         # tile
         if tag == (8, 10):
-            self.tile = [("iptc", (0, 0) + self.size, offset, compression)]
+            self.tile = [
+                ImageFile._Tile("iptc", (0, 0) + self.size, offset, compression)
+            ]
 
     def load(self) -> Image.core.PixelAccess | None:
         if len(self.tile) != 1 or self.tile[0][0] != "iptc":

src/PIL/Jpeg2KImagePlugin.py

@@ -18,6 +18,7 @@ from __future__ import annotations
 import io
 import os
 import struct
+from collections.abc import Callable
 from typing import IO, cast
 
 from . import Image, ImageFile, ImagePalette, _binary
@@ -205,7 +206,7 @@ def _parse_jp2_header(
                 if bitdepth > max_bitdepth:
                     max_bitdepth = bitdepth
             if max_bitdepth <= 8:
-                palette = ImagePalette.ImagePalette()
+                palette = ImagePalette.ImagePalette("RGBA" if npc == 4 else "RGB")
                 for i in range(ne):
                     color: list[int] = []
                     for value in header.read_fields(">" + ("B" * npc)):
@@ -286,7 +287,7 @@ class Jpeg2KImageFile(ImageFile.ImageFile):
                 length = -1
 
         self.tile = [
-            (
+            ImageFile._Tile(
                 "jpeg2k",
                 (0, 0) + self.size,
                 0,
@@ -316,8 +317,13 @@ class Jpeg2KImageFile(ImageFile.ImageFile):
             else:
                 self.fp.seek(length - 2, os.SEEK_CUR)
 
-    @property
-    def reduce(self):
+    @property  # type: ignore[override]
+    def reduce(
+        self,
+    ) -> (
+        Callable[[int | tuple[int, int], tuple[int, int, int, int] | None], Image.Image]
+        | int
+    ):
         # https://github.com/python-pillow/Pillow/issues/4343 found that the
         # new Image 'reduce' method was shadowed by this plugin's 'reduce'
         # property. This attempts to allow for both scenarios
@@ -338,8 +344,9 @@ class Jpeg2KImageFile(ImageFile.ImageFile):
 
             # Update the reduce and layers settings
             t = self.tile[0]
+            assert isinstance(t[3], tuple)
             t3 = (t[3][0], self._reduce, self.layers, t[3][3], t[3][4])
-            self.tile = [(t[0], (0, 0) + self.size, t[2], t3)]
+            self.tile = [ImageFile._Tile(t[0], (0, 0) + self.size, t[2], t3)]
 
         return ImageFile.ImageFile.load(self)
 

src/PIL/JpegImagePlugin.py

@@ -372,7 +372,9 @@ class JpegImageFile(ImageFile.ImageFile):
                     rawmode = self.mode
                     if self.mode == "CMYK":
                         rawmode = "CMYK;I"  # assume adobe conventions
-                    self.tile = [("jpeg", (0, 0) + self.size, 0, (rawmode, ""))]
+                    self.tile = [
+                        ImageFile._Tile("jpeg", (0, 0) + self.size, 0, (rawmode, ""))
+                    ]
                     # self.__offset = self.fp.tell()
                     break
                 s = self.fp.read(1)
@@ -423,6 +425,7 @@ class JpegImageFile(ImageFile.ImageFile):
         scale = 1
         original_size = self.size
 
+        assert isinstance(a, tuple)
         if a[0] == "RGB" and mode in ["L", "YCbCr"]:
             self._mode = mode
             a = mode, ""
@@ -432,6 +435,7 @@ class JpegImageFile(ImageFile.ImageFile):
             for s in [8, 4, 2, 1]:
                 if scale >= s:
                     break
+            assert e is not None
             e = (
                 e[0],
                 e[1],
@@ -441,7 +445,7 @@ class JpegImageFile(ImageFile.ImageFile):
             self._size = ((self.size[0] + s - 1) // s, (self.size[1] + s - 1) // s)
             scale = s
 
-        self.tile = [(d, e, o, a)]
+        self.tile = [ImageFile._Tile(d, e, o, a)]
         self.decoderconfig = (scale, 0)
 
         box = (0, 0, original_size[0] / scale, original_size[1] / scale)
@@ -747,17 +751,27 @@ def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
     extra = info.get("extra", b"")
 
     MAX_BYTES_IN_MARKER = 65533
+    xmp = info.get("xmp", im.info.get("xmp"))
+    if xmp:
+        overhead_len = 29  # b"http://ns.adobe.com/xap/1.0/\x00"
+        max_data_bytes_in_marker = MAX_BYTES_IN_MARKER - overhead_len
+        if len(xmp) > max_data_bytes_in_marker:
+            msg = "XMP data is too long"
+            raise ValueError(msg)
+        size = o16(2 + overhead_len + len(xmp))
+        extra += b"\xFF\xE1" + size + b"http://ns.adobe.com/xap/1.0/\x00" + xmp
+
     icc_profile = info.get("icc_profile")
     if icc_profile:
-        ICC_OVERHEAD_LEN = 14
-        MAX_DATA_BYTES_IN_MARKER = MAX_BYTES_IN_MARKER - ICC_OVERHEAD_LEN
+        overhead_len = 14  # b"ICC_PROFILE\0" + o8(i) + o8(len(markers))
+        max_data_bytes_in_marker = MAX_BYTES_IN_MARKER - overhead_len
         markers = []
         while icc_profile:
-            markers.append(icc_profile[:MAX_DATA_BYTES_IN_MARKER])
-            icc_profile = icc_profile[MAX_DATA_BYTES_IN_MARKER:]
+            markers.append(icc_profile[:max_data_bytes_in_marker])
+            icc_profile = icc_profile[max_data_bytes_in_marker:]
         i = 1
         for marker in markers:
-            size = o16(2 + ICC_OVERHEAD_LEN + len(marker))
+            size = o16(2 + overhead_len + len(marker))
             extra += (
                 b"\xFF\xE2"
                 + size
@@ -844,7 +858,7 @@ def _save_cjpeg(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
 ##
 # Factory for making JPEG and MPO instances
 def jpeg_factory(
-    fp: IO[bytes] | None = None, filename: str | bytes | None = None
+    fp: IO[bytes], filename: str | bytes | None = None
 ) -> JpegImageFile | MpoImageFile:
     im = JpegImageFile(fp, filename)
     try:

src/PIL/McIdasImagePlugin.py

@@ -67,7 +67,9 @@ class McIdasImageFile(ImageFile.ImageFile):
         offset = w[34] + w[15]
         stride = w[15] + w[10] * w[11] * w[14]
 
-        self.tile = [("raw", (0, 0) + self.size, offset, (rawmode, stride, 1))]
+        self.tile = [
+            ImageFile._Tile("raw", (0, 0) + self.size, offset, (rawmode, stride, 1))
+        ]
 
 
 # --------------------------------------------------------------------

src/PIL/MpoImagePlugin.py

@@ -26,6 +26,7 @@ from typing import IO, Any, cast
 
 from . import (
     Image,
+    ImageFile,
     ImageSequence,
     JpegImagePlugin,
     TiffImagePlugin,
@@ -145,7 +146,9 @@ class MpoImageFile(JpegImagePlugin.JpegImageFile):
         if self.info.get("exif") != original_exif:
             self._reload_exif()
 
-        self.tile = [("jpeg", (0, 0) + self.size, self.offset, self.tile[0][-1])]
+        self.tile = [
+            ImageFile._Tile("jpeg", (0, 0) + self.size, self.offset, self.tile[0][-1])
+        ]
         self.__frame = frame
 
     def tell(self) -> int:

src/PIL/MspImagePlugin.py

@@ -70,9 +70,9 @@ class MspImageFile(ImageFile.ImageFile):
         self._size = i16(s, 4), i16(s, 6)
 
         if s[:4] == b"DanM":
-            self.tile = [("raw", (0, 0) + self.size, 32, ("1", 0, 1))]
+            self.tile = [ImageFile._Tile("raw", (0, 0) + self.size, 32, ("1", 0, 1))]
         else:
-            self.tile = [("MSP", (0, 0) + self.size, 32, None)]
+            self.tile = [ImageFile._Tile("MSP", (0, 0) + self.size, 32, None)]
 
 
 class MspDecoder(ImageFile.PyDecoder):
@@ -112,7 +112,7 @@ class MspDecoder(ImageFile.PyDecoder):
 
     _pulls_fd = True
 
-    def decode(self, buffer: bytes) -> tuple[int, int]:
+    def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
         assert self.fd is not None
 
         img = io.BytesIO()
@@ -152,7 +152,7 @@ class MspDecoder(ImageFile.PyDecoder):
                 msg = f"Corrupted MSP file in row {x}"
                 raise OSError(msg) from e
 
-        self.set_as_raw(img.getvalue(), ("1", 0, 1))
+        self.set_as_raw(img.getvalue(), "1")
 
         return -1, 0
 

src/PIL/PcdImagePlugin.py

@@ -47,7 +47,7 @@ class PcdImageFile(ImageFile.ImageFile):
 
         self._mode = "RGB"
         self._size = 768, 512  # FIXME: not correct for rotated images!
-        self.tile = [("pcd", (0, 0) + self.size, 96 * 2048, None)]
+        self.tile = [ImageFile._Tile("pcd", (0, 0) + self.size, 96 * 2048, None)]
 
     def load_end(self) -> None:
         if self.tile_post_rotate:

src/PIL/PcxImagePlugin.py

@@ -128,7 +128,9 @@ class PcxImageFile(ImageFile.ImageFile):
         bbox = (0, 0) + self.size
         logger.debug("size: %sx%s", *self.size)
 
-        self.tile = [("pcx", bbox, self.fp.tell(), (rawmode, planes * stride))]
+        self.tile = [
+            ImageFile._Tile("pcx", bbox, self.fp.tell(), (rawmode, planes * stride))
+        ]
 
 
 # --------------------------------------------------------------------

src/PIL/PixarImagePlugin.py

@@ -61,7 +61,9 @@ class PixarImageFile(ImageFile.ImageFile):
         # FIXME: to be continued...
 
         # create tile descriptor (assuming "dumped")
-        self.tile = [("raw", (0, 0) + self.size, 1024, (self.mode, 0, 1))]
+        self.tile = [
+            ImageFile._Tile("raw", (0, 0) + self.size, 1024, (self.mode, 0, 1))
+        ]
 
 
 #

src/PIL/PngImagePlugin.py

@@ -258,7 +258,9 @@ class iTXt(str):
     tkey: str | bytes | None
 
     @staticmethod
-    def __new__(cls, text, lang=None, tkey=None):
+    def __new__(
+        cls, text: str, lang: str | None = None, tkey: str | None = None
+    ) -> iTXt:
         """
         :param cls: the class to use when creating the instance
         :param text: value for this key
@@ -368,21 +370,27 @@ class PngInfo:
 # PNG image stream (IHDR/IEND)
 
 
+class _RewindState(NamedTuple):
+    info: dict[str | tuple[int, int], Any]
+    tile: list[ImageFile._Tile]
+    seq_num: int | None
+
+
 class PngStream(ChunkStream):
-    def __init__(self, fp):
+    def __init__(self, fp: IO[bytes]) -> None:
         super().__init__(fp)
 
         # local copies of Image attributes
-        self.im_info = {}
-        self.im_text = {}
+        self.im_info: dict[str | tuple[int, int], Any] = {}
+        self.im_text: dict[str, str | iTXt] = {}
         self.im_size = (0, 0)
-        self.im_mode = None
-        self.im_tile = None
-        self.im_palette = None
-        self.im_custom_mimetype = None
-        self.im_n_frames = None
-        self._seq_num = None
-        self.rewind_state = None
+        self.im_mode = ""
+        self.im_tile: list[ImageFile._Tile] = []
+        self.im_palette: tuple[str, bytes] | None = None
+        self.im_custom_mimetype: str | None = None
+        self.im_n_frames: int | None = None
+        self._seq_num: int | None = None
+        self.rewind_state = _RewindState({}, [], None)
 
         self.text_memory = 0
 
@@ -396,16 +404,16 @@ class PngStream(ChunkStream):
             raise ValueError(msg)
 
     def save_rewind(self) -> None:
-        self.rewind_state = {
-            "info": self.im_info.copy(),
-            "tile": self.im_tile,
-            "seq_num": self._seq_num,
-        }
+        self.rewind_state = _RewindState(
+            self.im_info.copy(),
+            self.im_tile,
+            self._seq_num,
+        )
 
     def rewind(self) -> None:
-        self.im_info = self.rewind_state["info"].copy()
-        self.im_tile = self.rewind_state["tile"]
-        self._seq_num = self.rewind_state["seq_num"]
+        self.im_info = self.rewind_state.info.copy()
+        self.im_tile = self.rewind_state.tile
+        self._seq_num = self.rewind_state.seq_num
 
     def chunk_iCCP(self, pos: int, length: int) -> bytes:
         # ICC profile
@@ -459,11 +467,11 @@ class PngStream(ChunkStream):
     def chunk_IDAT(self, pos: int, length: int) -> NoReturn:
         # image data
         if "bbox" in self.im_info:
-            tile = [("zip", self.im_info["bbox"], pos, self.im_rawmode)]
+            tile = [ImageFile._Tile("zip", self.im_info["bbox"], pos, self.im_rawmode)]
         else:
             if self.im_n_frames is not None:
                 self.im_info["default_image"] = True
-            tile = [("zip", (0, 0) + self.im_size, pos, self.im_rawmode)]
+            tile = [ImageFile._Tile("zip", (0, 0) + self.im_size, pos, self.im_rawmode)]
         self.im_tile = tile
         self.im_idat = length
         msg = "image data found"

src/PIL/PpmImagePlugin.py

@@ -151,7 +151,9 @@ class PpmImageFile(ImageFile.ImageFile):
                     decoder_name = "ppm"
 
             args = rawmode if decoder_name == "raw" else (rawmode, maxval)
-        self.tile = [(decoder_name, (0, 0) + self.size, self.fp.tell(), args)]
+        self.tile = [
+            ImageFile._Tile(decoder_name, (0, 0) + self.size, self.fp.tell(), args)
+        ]
 
 
 #
@@ -282,7 +284,7 @@ class PpmPlainDecoder(ImageFile.PyDecoder):
                     break
         return data
 
-    def decode(self, buffer: bytes) -> tuple[int, int]:
+    def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
         self._comment_spans = False
         if self.mode == "1":
             data = self._decode_bitonal()
@@ -298,7 +300,7 @@ class PpmPlainDecoder(ImageFile.PyDecoder):
 class PpmDecoder(ImageFile.PyDecoder):
     _pulls_fd = True
 
-    def decode(self, buffer: bytes) -> tuple[int, int]:
+    def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
         assert self.fd is not None
 
         data = bytearray()
@@ -333,7 +335,7 @@ def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
         rawmode, head = "1;I", b"P4"
     elif im.mode == "L":
         rawmode, head = "L", b"P5"
-    elif im.mode == "I":
+    elif im.mode in ("I", "I;16"):
         rawmode, head = "I;16B", b"P5"
     elif im.mode in ("RGB", "RGBA"):
         rawmode, head = "RGB", b"P6"

src/PIL/PsdImagePlugin.py

@@ -277,8 +277,8 @@ def _layerinfo(
 
 def _maketile(
     file: IO[bytes], mode: str, bbox: tuple[int, int, int, int], channels: int
-) -> list[ImageFile._Tile] | None:
-    tiles = None
+) -> list[ImageFile._Tile]:
+    tiles = []
     read = file.read
 
     compression = i16(read(2))
@@ -291,7 +291,6 @@ def _maketile(
     if compression == 0:
         #
         # raw compression
-        tiles = []
         for channel in range(channels):
             layer = mode[channel]
             if mode == "CMYK":
@@ -303,7 +302,6 @@ def _maketile(
         #
         # packbits compression
         i = 0
-        tiles = []
         bytecount = read(channels * ysize * 2)
         offset = file.tell()
         for channel in range(channels):

src/PIL/QoiImagePlugin.py

@@ -32,7 +32,7 @@ class QoiImageFile(ImageFile.ImageFile):
         self._mode = "RGB" if channels == 3 else "RGBA"
 
         self.fp.seek(1, os.SEEK_CUR)  # colorspace
-        self.tile = [("qoi", (0, 0) + self._size, self.fp.tell(), None)]
+        self.tile = [ImageFile._Tile("qoi", (0, 0) + self._size, self.fp.tell(), None)]
 
 
 class QoiDecoder(ImageFile.PyDecoder):
@@ -47,7 +47,7 @@ class QoiDecoder(ImageFile.PyDecoder):
         hash_value = (r * 3 + g * 5 + b * 7 + a * 11) % 64
         self._previously_seen_pixels[hash_value] = value
 
-    def decode(self, buffer: bytes) -> tuple[int, int]:
+    def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
         assert self.fd is not None
 
         self._previously_seen_pixels = {}

src/PIL/SgiImagePlugin.py

@@ -109,19 +109,28 @@ class SgiImageFile(ImageFile.ImageFile):
             pagesize = xsize * ysize * bpc
             if bpc == 2:
                 self.tile = [
-                    ("SGI16", (0, 0) + self.size, headlen, (self.mode, 0, orientation))
+                    ImageFile._Tile(
+                        "SGI16",
+                        (0, 0) + self.size,
+                        headlen,
+                        (self.mode, 0, orientation),
+                    )
                 ]
             else:
                 self.tile = []
                 offset = headlen
                 for layer in self.mode:
                     self.tile.append(
-                        ("raw", (0, 0) + self.size, offset, (layer, 0, orientation))
+                        ImageFile._Tile(
+                            "raw", (0, 0) + self.size, offset, (layer, 0, orientation)
+                        )
                     )
                     offset += pagesize
         elif compression == 1:
             self.tile = [
-                ("sgi_rle", (0, 0) + self.size, headlen, (rawmode, orientation, bpc))
+                ImageFile._Tile(
+                    "sgi_rle", (0, 0) + self.size, headlen, (rawmode, orientation, bpc)
+                )
             ]
 
 
@@ -205,7 +214,7 @@ def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
 class SGI16Decoder(ImageFile.PyDecoder):
     _pulls_fd = True
 
-    def decode(self, buffer: bytes) -> tuple[int, int]:
+    def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]:
         assert self.fd is not None
         assert self.im is not None
 

src/PIL/SpiderImagePlugin.py

@@ -154,7 +154,9 @@ class SpiderImageFile(ImageFile.ImageFile):
             self.rawmode = "F;32F"
         self._mode = "F"
 
-        self.tile = [("raw", (0, 0) + self.size, offset, (self.rawmode, 0, 1))]
+        self.tile = [
+            ImageFile._Tile("raw", (0, 0) + self.size, offset, (self.rawmode, 0, 1))
+        ]
         self._fp = self.fp  # FIXME: hack
 
     @property

src/PIL/SunImagePlugin.py

@@ -124,9 +124,13 @@ class SunImageFile(ImageFile.ImageFile):
         # (https://www.fileformat.info/format/sunraster/egff.htm)
 
         if file_type in (0, 1, 3, 4, 5):
-            self.tile = [("raw", (0, 0) + self.size, offset, (rawmode, stride))]
+            self.tile = [
+                ImageFile._Tile("raw", (0, 0) + self.size, offset, (rawmode, stride))
+            ]
         elif file_type == 2:
-            self.tile = [("sun_rle", (0, 0) + self.size, offset, rawmode)]
+            self.tile = [
+                ImageFile._Tile("sun_rle", (0, 0) + self.size, offset, rawmode)
+            ]
         else:
             msg = "Unsupported Sun Raster file type"
             raise SyntaxError(msg)

src/PIL/TgaImagePlugin.py

@@ -137,7 +137,7 @@ class TgaImageFile(ImageFile.ImageFile):
             if imagetype & 8:
                 # compressed
                 self.tile = [
-                    (
+                    ImageFile._Tile(
                         "tga_rle",
                         (0, 0) + self.size,
                         self.fp.tell(),
@@ -146,7 +146,7 @@ class TgaImageFile(ImageFile.ImageFile):
                 ]
             else:
                 self.tile = [
-                    (
+                    ImageFile._Tile(
                         "raw",
                         (0, 0) + self.size,
                         self.fp.tell(),

src/PIL/TiffImagePlugin.py

@@ -61,12 +61,14 @@ from ._typing import StrOrBytesPath
 from ._util import is_path
 from .TiffTags import TYPES
 
+if TYPE_CHECKING:
+    from ._typing import Buffer, IntegralLike
+
 logger = logging.getLogger(__name__)
 
 # Set these to true to force use of libtiff for reading or writing.
 READ_LIBTIFF = False
 WRITE_LIBTIFF = False
-IFD_LEGACY_API = True
 STRIP_SIZE = 65536
 
 II = b"II"  # little-endian (Intel style)
@@ -291,22 +293,24 @@ def _accept(prefix: bytes) -> bool:
 
 def _limit_rational(
     val: float | Fraction | IFDRational, max_val: int
-) -> tuple[float, float]:
+) -> tuple[IntegralLike, IntegralLike]:
     inv = abs(float(val)) > 1
     n_d = IFDRational(1 / val if inv else val).limit_rational(max_val)
     return n_d[::-1] if inv else n_d
 
 
-def _limit_signed_rational(val, max_val, min_val):
+def _limit_signed_rational(
+    val: IFDRational, max_val: int, min_val: int
+) -> tuple[IntegralLike, IntegralLike]:
     frac = Fraction(val)
-    n_d = frac.numerator, frac.denominator
+    n_d: tuple[IntegralLike, IntegralLike] = frac.numerator, frac.denominator
 
-    if min(n_d) < min_val:
+    if min(float(i) for i in n_d) < min_val:
         n_d = _limit_rational(val, abs(min_val))
 
-    if max(n_d) > max_val:
-        val = Fraction(*n_d)
-        n_d = _limit_rational(val, max_val)
+    n_d_float = tuple(float(i) for i in n_d)
+    if max(n_d_float) > max_val:
+        n_d = _limit_rational(n_d_float[0] / n_d_float[1], max_val)
 
     return n_d
 
@@ -318,8 +322,10 @@ _load_dispatch = {}
 _write_dispatch = {}
 
 
-def _delegate(op: str):
-    def delegate(self, *args):
+def _delegate(op: str) -> Any:
+    def delegate(
+        self: IFDRational, *args: tuple[float, ...]
+    ) -> bool | float | Fraction:
         return getattr(self._val, op)(*args)
 
     return delegate
@@ -358,7 +364,10 @@ class IFDRational(Rational):
             self._numerator = value.numerator
             self._denominator = value.denominator
         else:
-            self._numerator = value
+            if TYPE_CHECKING:
+                self._numerator = cast(IntegralLike, value)
+            else:
+                self._numerator = value
             self._denominator = denominator
 
         if denominator == 0:
@@ -371,14 +380,14 @@ class IFDRational(Rational):
             self._val = Fraction(value / denominator)
 
     @property
-    def numerator(self):
+    def numerator(self) -> IntegralLike:
         return self._numerator
 
     @property
     def denominator(self) -> int:
         return self._denominator
 
-    def limit_rational(self, max_denominator: int) -> tuple[float, int]:
+    def limit_rational(self, max_denominator: int) -> tuple[IntegralLike, int]:
         """
 
         :param max_denominator: Integer, the maximum denominator value
@@ -406,14 +415,18 @@ class IFDRational(Rational):
             val = float(val)
         return val == other
 
-    def __getstate__(self) -> list[float | Fraction]:
+    def __getstate__(self) -> list[float | Fraction | IntegralLike]:
         return [self._val, self._numerator, self._denominator]
 
-    def __setstate__(self, state: list[float | Fraction]) -> None:
+    def __setstate__(self, state: list[float | Fraction | IntegralLike]) -> None:
         IFDRational.__init__(self, 0)
         _val, _numerator, _denominator = state
+        assert isinstance(_val, (float, Fraction))
         self._val = _val
-        self._numerator = _numerator
+        if TYPE_CHECKING:
+            self._numerator = cast(IntegralLike, _numerator)
+        else:
+            self._numerator = _numerator
         assert isinstance(_denominator, int)
         self._denominator = _denominator
 
@@ -471,8 +484,8 @@ def _register_loader(idx: int, size: int) -> Callable[[_LoaderFunc], _LoaderFunc
     return decorator
 
 
-def _register_writer(idx: int):
-    def decorator(func):
+def _register_writer(idx: int) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
         _write_dispatch[idx] = func  # noqa: F821
         return func
 
@@ -1111,7 +1124,7 @@ class ImageFileDirectory_v1(ImageFileDirectory_v2):
         return val
 
 
-# undone -- switch this pointer when IFD_LEGACY_API == False
+# undone -- switch this pointer
 ImageFileDirectory = ImageFileDirectory_v1
 
 
@@ -1126,7 +1139,7 @@ class TiffImageFile(ImageFile.ImageFile):
 
     def __init__(
         self,
-        fp: StrOrBytesPath | IO[bytes] | None = None,
+        fp: StrOrBytesPath | IO[bytes],
         filename: str | bytes | None = None,
     ) -> None:
         self.tag_v2: ImageFileDirectory_v2
@@ -1298,7 +1311,7 @@ class TiffImageFile(ImageFile.ImageFile):
         # (self._compression, (extents tuple),
         #   0, (rawmode, self._compression, fp))
         extents = self.tile[0][1]
-        args = list(self.tile[0][3])
+        args = self.tile[0][3]
 
         # To be nice on memory footprint, if there's a
         # file descriptor, use that instead of reading
@@ -1316,11 +1329,12 @@ class TiffImageFile(ImageFile.ImageFile):
             fp = False
 
         if fp:
-            args[2] = fp
+            assert isinstance(args, tuple)
+            args_list = list(args)
+            args_list[2] = fp
+            args = tuple(args_list)
 
-        decoder = Image._getdecoder(
-            self.mode, "libtiff", tuple(args), self.decoderconfig
-        )
+        decoder = Image._getdecoder(self.mode, "libtiff", args, self.decoderconfig)
         try:
             decoder.setimage(self.im, extents)
         except ValueError as e:
@@ -1538,7 +1552,7 @@ class TiffImageFile(ImageFile.ImageFile):
             # Offset in the tile tuple is 0, we go from 0,0 to
             # w,h, and we only do this once -- eds
             a = (rawmode, self._compression, False, self.tag_v2.offset)
-            self.tile.append(("libtiff", (0, 0, xsize, ysize), 0, a))
+            self.tile.append(ImageFile._Tile("libtiff", (0, 0, xsize, ysize), 0, a))
 
         elif STRIPOFFSETS in self.tag_v2 or TILEOFFSETS in self.tag_v2:
             # striped image
@@ -1571,7 +1585,7 @@ class TiffImageFile(ImageFile.ImageFile):
 
                 args = (tile_rawmode, int(stride), 1)
                 self.tile.append(
-                    (
+                    ImageFile._Tile(
                         self._compression,
                         (x, y, min(x + w, xsize), min(y + h, ysize)),
                         offset,
@@ -1632,7 +1646,7 @@ SAVE_INFO = {
 }
 
 
-def _save(im: Image.Image, fp, filename: str | bytes) -> None:
+def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
     try:
         rawmode, prefix, photo, format, bits, extra = SAVE_INFO[im.mode]
     except KeyError as e:
@@ -1943,7 +1957,7 @@ def _save(im: Image.Image, fp, filename: str | bytes) -> None:
         setattr(im, "_debug_multipage", ifd)
 
 
-class AppendingTiffWriter:
+class AppendingTiffWriter(io.BytesIO):
     fieldSizes = [
         0,  # None
         1,  # byte
@@ -2053,6 +2067,12 @@ class AppendingTiffWriter:
         return self.f.tell() - self.offsetOfNewPage
 
     def seek(self, offset: int, whence: int = io.SEEK_SET) -> int:
+        """
+        :param offset: Distance to seek.
+        :param whence: Whether the distance is relative to the start,
+                       end or current position.
+        :returns: The resulting position, relative to the start.
+        """
         if whence == os.SEEK_SET:
             offset += self.offsetOfNewPage
 
@@ -2086,7 +2106,7 @@ class AppendingTiffWriter:
             num_tags = self.readShort()
             self.f.seek(num_tags * 12, os.SEEK_CUR)
 
-    def write(self, data: bytes) -> int | None:
+    def write(self, data: Buffer, /) -> int:
         return self.f.write(data)
 
     def readShort(self) -> int:
@@ -2128,7 +2148,8 @@ class AppendingTiffWriter:
 
     def close(self) -> None:
         self.finalize()
-        self.f.close()
+        if self.close_fp:
+            self.f.close()
 
     def fixIFD(self) -> None:
         num_tags = self.readShort()

src/PIL/WebPImagePlugin.py

@@ -142,7 +142,7 @@ class WebPImageFile(ImageFile.ImageFile):
             if self.fp and self._exclusive_fp:
                 self.fp.close()
             self.fp = BytesIO(data)
-            self.tile = [("raw", (0, 0) + self.size, 0, self.rawmode)]
+            self.tile = [ImageFile._Tile("raw", (0, 0) + self.size, 0, self.rawmode)]
 
         return super().load()
 

src/PIL/XVThumbImagePlugin.py

@@ -73,7 +73,11 @@ class XVThumbImageFile(ImageFile.ImageFile):
 
         self.palette = ImagePalette.raw("RGB", PALETTE)
 
-        self.tile = [("raw", (0, 0) + self.size, self.fp.tell(), (self.mode, 0, 1))]
+        self.tile = [
+            ImageFile._Tile(
+                "raw", (0, 0) + self.size, self.fp.tell(), (self.mode, 0, 1)
+            )
+        ]
 
 
 # --------------------------------------------------------------------

src/PIL/XbmImagePlugin.py

@@ -67,7 +67,7 @@ class XbmImageFile(ImageFile.ImageFile):
         self._mode = "1"
         self._size = xsize, ysize
 
-        self.tile = [("xbm", (0, 0) + self.size, m.end(), None)]
+        self.tile = [ImageFile._Tile("xbm", (0, 0) + self.size, m.end(), None)]
 
 
 def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:

src/PIL/XpmImagePlugin.py

@@ -101,7 +101,9 @@ class XpmImageFile(ImageFile.ImageFile):
         self._mode = "P"
         self.palette = ImagePalette.raw("RGB", b"".join(palette))
 
-        self.tile = [("raw", (0, 0) + self.size, self.fp.tell(), ("P", 0, 1))]
+        self.tile = [
+            ImageFile._Tile("raw", (0, 0) + self.size, self.fp.tell(), ("P", 0, 1))
+        ]
 
     def load_read(self, read_bytes: int) -> bytes:
         #

src/PIL/_typing.py

@@ -6,6 +6,8 @@ from collections.abc import Sequence
 from typing import TYPE_CHECKING, Any, Protocol, TypeVar, Union
 
 if TYPE_CHECKING:
+    from numbers import _IntegralLike as IntegralLike
+
     try:
         import numpy.typing as npt
 
@@ -13,6 +15,11 @@ if TYPE_CHECKING:
     except (ImportError, AttributeError):
         pass
 
+if sys.version_info >= (3, 12):
+    from collections.abc import Buffer
+else:
+    Buffer = Any
+
 if sys.version_info >= (3, 10):
     from typing import TypeGuard
 else:
@@ -38,4 +45,4 @@ class SupportsRead(Protocol[_T_co]):
 StrOrBytesPath = Union[str, bytes, "os.PathLike[str]", "os.PathLike[bytes]"]
 
 
-__all__ = ["TypeGuard", "StrOrBytesPath", "SupportsRead"]
+__all__ = ["Buffer", "IntegralLike", "StrOrBytesPath", "SupportsRead", "TypeGuard"]

src/_imagingft.c

@@ -272,7 +272,7 @@ text_layout_raqm(
         }
         set_text = raqm_set_text(rq, text, size);
         PyMem_Free(text);
-    } else {
+    } else if (PyBytes_Check(string)) {
         char *buffer;
         PyBytes_AsStringAndSize(string, &buffer, &size);
         if (!buffer || !size) {
@@ -281,6 +281,9 @@ text_layout_raqm(
             goto failed;
         }
         set_text = raqm_set_text_utf8(rq, buffer, size);
+    } else {
+        PyErr_SetString(PyExc_TypeError, "expected string or bytes");
+        goto failed;
     }
     if (!set_text) {
         PyErr_SetString(PyExc_ValueError, "raqm_set_text() failed");
@@ -425,8 +428,11 @@ text_layout_fallback(
 
     if (PyUnicode_Check(string)) {
         count = PyUnicode_GET_LENGTH(string);
-    } else {
+    } else if (PyBytes_Check(string)) {
         PyBytes_AsStringAndSize(string, &buffer, &count);
+    } else {
+        PyErr_SetString(PyExc_TypeError, "expected string or bytes");
+        return 0;
     }
     if (count == 0) {
         return 0;

src/libImaging/Access.c

@@ -185,7 +185,7 @@ put_pixel_32(Imaging im, int x, int y, const void *color) {
 }
 
 void
-ImagingAccessInit() {
+ImagingAccessInit(void) {
 #define ADD(mode_, get_pixel_, put_pixel_)      \
     {                                           \
         ImagingAccess access = add_item(mode_); \

src/libImaging/BoxBlur.c

@@ -238,6 +238,9 @@ ImagingBoxBlur(Imaging imOut, Imaging imIn, float xradius, float yradius, int n)
     int i;
     Imaging imTransposed;
 
+    if (imOut->xsize == 0 || imOut->ysize == 0) {
+        return imOut;
+    }
     if (n < 1) {
         return ImagingError_ValueError("number of passes must be greater than zero");
     }

src/libImaging/GetBBox.c

@@ -30,26 +30,57 @@ ImagingGetBBox(Imaging im, int bbox[4], int alpha_only) {
     bbox[1] = -1;
     bbox[2] = bbox[3] = 0;
 
-#define GETBBOX(image, mask)              \
-    for (y = 0; y < im->ysize; y++) {     \
-        has_data = 0;                     \
-        for (x = 0; x < im->xsize; x++) { \
-            if (im->image[y][x] & mask) { \
-                has_data = 1;             \
-                if (x < bbox[0]) {        \
-                    bbox[0] = x;          \
-                }                         \
-                if (x >= bbox[2]) {       \
-                    bbox[2] = x + 1;      \
-                }                         \
-            }                             \
-        }                                 \
-        if (has_data) {                   \
-            if (bbox[1] < 0) {            \
-                bbox[1] = y;              \
-            }                             \
-            bbox[3] = y + 1;              \
-        }                                 \
+#define GETBBOX(image, mask)                                 \
+    /* first stage: looking for any pixels from top */       \
+    for (y = 0; y < im->ysize; y++) {                        \
+        has_data = 0;                                        \
+        for (x = 0; x < im->xsize; x++) {                    \
+            if (im->image[y][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 (y = im->ysize - 1; y >= bbox[1]; y--) {             \
+        has_data = 0;                                        \
+        for (x = 0; x < im->xsize; x++) {                    \
+            if (im->image[y][x] & mask) {                    \
+                has_data = 1;                                \
+                if (x < bbox[0]) {                           \
+                    bbox[0] = x;                             \
+                }                                            \
+                bbox[3] = y + 1;                             \
+                break;                                       \
+            }                                                \
+        }                                                    \
+        if (has_data) {                                      \
+            break;                                           \
+        }                                                    \
+    }                                                        \
+    /* third stage: looking for left and right boundaries */ \
+    for (y = bbox[1]; y < bbox[3]; y++) {                    \
+        for (x = 0; x < bbox[0]; x++) {                      \
+            if (im->image[y][x] & mask) {                    \
+                bbox[0] = x;                                 \
+                break;                                       \
+            }                                                \
+        }                                                    \
+        for (x = im->xsize - 1; x >= bbox[2]; x--) {         \
+            if (im->image[y][x] & mask) {                    \
+                bbox[2] = x + 1;                             \
+                break;                                       \
+            }                                                \
+        }                                                    \
     }
 
     if (im->image8) {
@@ -71,11 +102,6 @@ ImagingGetBBox(Imaging im, int bbox[4], int alpha_only) {
         GETBBOX(image32, mask);
     }
 
-    /* Check that we got a box */
-    if (bbox[1] < 0) {
-        return 0; /* no data */
-    }
-
     return 1; /* ok */
 }
 
@@ -144,6 +170,9 @@ ImagingGetExtrema(Imaging im, void *extrema) {
                         imax = in[x];
                     }
                 }
+                if (imin == 0 && imax == 255) {
+                    break;
+                }
             }
             ((UINT8 *)extrema)[0] = (UINT8)imin;
             ((UINT8 *)extrema)[1] = (UINT8)imax;

src/libImaging/Jpeg2KDecode.c

@@ -698,8 +698,7 @@ j2k_decode_entry(Imaging im, ImagingCodecState state) {
     }
 
     /* Check that this image is something we can handle */
-    if (image->numcomps < 1 || image->numcomps > 4 ||
-        image->color_space == OPJ_CLRSPC_UNKNOWN) {
+    if (image->numcomps < 1 || image->numcomps > 4) {
         state->errcode = IMAGING_CODEC_BROKEN;
         state->state = J2K_STATE_FAILED;
         goto quick_exit;
@@ -744,7 +743,7 @@ j2k_decode_entry(Imaging im, ImagingCodecState state) {
     /* Find the correct unpacker */
     color_space = image->color_space;
 
-    if (color_space == OPJ_CLRSPC_UNSPECIFIED) {
+    if (color_space == OPJ_CLRSPC_UNKNOWN || color_space == OPJ_CLRSPC_UNSPECIFIED) {
         switch (image->numcomps) {
             case 1:
             case 2:

src/libImaging/JpegDecode.c

@@ -48,7 +48,7 @@ char *libjpeg_turbo_version = NULL;
 #endif
 
 int
-ImagingJpegUseJCSExtensions() {
+ImagingJpegUseJCSExtensions(void) {
     int use_jcs_extensions = 0;
 #ifdef JCS_EXTENSIONS
 #if defined(LIBJPEG_TURBO_VERSION_NUMBER)

tox.ini

@@ -36,4 +36,4 @@ deps =
 extras =
     typing
 commands =
-    mypy docs src winbuild Tests {posargs}
+    mypy conftest.py selftest.py setup.py docs src winbuild Tests {posargs}

winbuild/build_prepare.py

@@ -110,9 +110,9 @@ ARCHITECTURES = {
 
 V = {
     "BROTLI": "1.1.0",
-    "FREETYPE": "2.13.2",
+    "FREETYPE": "2.13.3",
     "FRIBIDI": "1.0.15",
-    "HARFBUZZ": "8.5.0",
+    "HARFBUZZ": "9.0.0",
     "JPEGTURBO": "3.0.3",
     "LCMS2": "2.16",
     "LIBPNG": "1.6.43",
@@ -292,12 +292,8 @@ DEPS: dict[str, dict[str, Any]] = {
         },
         "build": [
             cmd_rmdir("objs"),
-            cmd_msbuild(
-                r"builds\windows\vc2010\freetype.sln", "Release Static", "Clean"
-            ),
-            cmd_msbuild(
-                r"builds\windows\vc2010\freetype.sln", "Release Static", "Build"
-            ),
+            cmd_msbuild("MSBuild.sln", "Release Static", "Clean"),
+            cmd_msbuild("MSBuild.sln", "Release Static", "Build"),
             cmd_xcopy("include", "{inc_dir}"),
         ],
         "libs": [r"objs\{msbuild_arch}\Release Static\freetype.lib"],