Add JPEG XL Open/Read support via libjxl

Tests/test_file_jxl.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+import re
+
+import pytest
+
+from PIL import Image, JpegXlImagePlugin, features
+
+from .helper import (
+    assert_image_similar_tofile,
+    skip_unless_feature,
+)
+
+try:
+    from PIL import _jpegxl
+
+    HAVE_JPEGXL = True
+except ImportError:
+    HAVE_JPEGXL = False
+
+# cjxl v0.9.2 41b8cdab
+# hopper.jxl: cjxl hopper.png hopper.jxl -q 75 -e 8
+# 16_bit_binary.jxl: cjxl 16_bit_binary.pgm 16_bit_binary.jxl -q 100 -e 9
+
+
+class TestUnsupportedJpegXl:
+    def test_unsupported(self) -> None:
+        if HAVE_JPEGXL:
+            JpegXlImagePlugin.SUPPORTED = False
+
+        file_path = "Tests/images/hopper.jxl"
+        with pytest.raises(OSError):
+            with Image.open(file_path):
+                pass
+
+        if HAVE_JPEGXL:
+            JpegXlImagePlugin.SUPPORTED = True
+
+
+@skip_unless_feature("jpegxl")
+class TestFileJpegXl:
+    def setup_method(self) -> None:
+        self.rgb_mode = "RGB"
+        self.i16_mode = "I;16"
+
+    def test_version(self) -> None:
+        _jpegxl.JpegXlDecoderVersion()
+        assert re.search(r"\d+\.\d+\.\d+$", features.version_module("jpegxl"))
+
+    def test_read_rgb(self) -> None:
+        """
+        Can we read a RGB mode Jpeg XL file without error?
+        Does it have the bits we expect?
+        """
+
+        with Image.open("Tests/images/hopper.jxl") as image:
+            assert image.mode == self.rgb_mode
+            assert image.size == (128, 128)
+            assert image.format == "JPEG XL"
+            image.load()
+            image.getdata()
+
+            # generated with:
+            # djxl hopper.jxl hopper_jxl_bits.ppm
+            assert_image_similar_tofile(image, "Tests/images/hopper_jxl_bits.ppm", 1.0)
+
+    def test_read_i16(self) -> None:
+        """
+        Can we read 16-bit Grayscale Jpeg XL image?
+        """
+
+        with Image.open("Tests/images/jxl/16bit_subcutaneous.cropped.jxl") as image:
+            assert image.mode == self.i16_mode
+            assert image.size == (128, 64)
+            assert image.format == "JPEG XL"
+            image.load()
+            image.getdata()
+
+            assert_image_similar_tofile(
+                image, "Tests/images/jxl/16bit_subcutaneous.cropped.png", 1.0
+            )
+
+    def test_JpegXlDecode_with_invalid_args(self) -> None:
+        """
+        Calling decoder functions with no arguments should result in an error.
+        """
+
+        with pytest.raises(TypeError):
+            _jpegxl.PILJpegXlDecoder()

Tests/test_file_jxl_alpha.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import pytest
+
+from PIL import Image
+
+from .helper import assert_image_similar_tofile
+
+_jpegxl = pytest.importorskip("PIL._jpegxl", reason="JPEG XL support not installed")
+
+
+def test_read_rgba() -> None:
+    """
+    Can we read an RGBA mode file without error?
+    Does it have the bits we expect?
+    """
+
+    # Generated with `cjxl transparent.png transparent.jxl -q 100 -e 8`
+    file_path = "Tests/images/transparent.jxl"
+    with Image.open(file_path) as image:
+        assert image.mode == "RGBA"
+        assert image.size == (200, 150)
+        assert image.format == "JPEG XL"
+        image.load()
+        image.getdata()
+
+        image.tobytes()
+
+        assert_image_similar_tofile(image, "Tests/images/transparent.png", 1.0)

Tests/test_file_jxl_animated.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import pytest
+
+from PIL import Image
+
+from .helper import (
+    assert_image_equal,
+    skip_unless_feature,
+)
+
+pytestmark = [
+    skip_unless_feature("jpegxl"),
+]
+
+
+def test_n_frames() -> None:
+    """Ensure that jxl format sets n_frames and is_animated attributes correctly."""
+
+    with Image.open("Tests/images/hopper.jxl") as im:
+        assert im.n_frames == 1
+        assert not im.is_animated
+
+    with Image.open("Tests/images/iss634.jxl") as im:
+        assert im.n_frames == 41
+        assert im.is_animated
+
+
+def test_float_duration() -> None:
+
+    with Image.open("Tests/images/iss634.jxl") as im:
+        im.load()
+        assert im.info["duration"] == 70
+
+
+def test_seeking() -> None:
+    """
+    Open an animated jxl file, and then try seeking through frames in reverse-order,
+    verifying the durations are correct.
+    """
+
+    with Image.open("Tests/images/jxl/traffic_light.jxl") as im1:
+        with Image.open("Tests/images/jxl/traffic_light.gif") as im2:
+            assert im1.n_frames == im2.n_frames
+            assert im1.is_animated
+
+            # Traverse frames in reverse, checking timestamps and durations
+            total_dur = 0
+            for frame in reversed(range(im1.n_frames)):
+                im1.seek(frame)
+                im1.load()
+                im2.seek(frame)
+                im2.load()
+
+                assert_image_equal(im1.convert("RGB"), im2.convert("RGB"))
+
+                total_dur += im1.info["duration"]
+                assert im1.info["duration"] == im2.info["duration"]
+                assert im1.info["timestamp"] == im1.info["timestamp"]
+            assert total_dur == 8000
+
+            assert im1.tell() == 0
+            assert im2.tell() == 0
+
+            im1.seek(0)
+            im1.load()
+            im2.seek(0)
+            im2.load()
+
+
+def test_seek_errors() -> None:
+    with Image.open("Tests/images/iss634.jxl") as im:
+        with pytest.raises(EOFError):
+            im.seek(-1)
+
+        with pytest.raises(EOFError):
+            im.seek(47)

Tests/test_file_jxl_metadata.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+from types import ModuleType
+
+import pytest
+
+from PIL import Image
+
+from .helper import skip_unless_feature
+
+pytestmark = [
+    skip_unless_feature("jpegxl"),
+]
+
+ElementTree: ModuleType | None
+try:
+    from defusedxml import ElementTree
+except ImportError:
+    ElementTree = None
+
+
+# cjxl flower.jpg flower.jxl --lossless_jpeg=0 -q 75 -e 8
+
+# >>> from PIL import Image
+# >>> with Image.open('Tests/images/flower2.webp') as im:
+# >>>   with open('/tmp/xmp.xml', 'wb') as f:
+# >>>     f.write(im.info['xmp'])
+# cjxl flower2.jpg flower2.jxl --lossless_jpeg=0 -q 75 -e 8 -x xmp=/tmp/xmp.xml
+
+
+def test_read_exif_metadata() -> None:
+    file_path = "Tests/images/flower.jxl"
+    with Image.open(file_path) as image:
+        assert image.format == "JPEG XL"
+        exif_data = image.info.get("exif", None)
+        assert exif_data
+
+        exif = image._getexif()
+
+        # Camera make
+        assert exif[271] == "Canon"
+
+        with Image.open("Tests/images/flower.jpg") as jpeg_image:
+            expected_exif = jpeg_image.info["exif"]
+
+            # jpeg xl always returns exif without 'Exif\0\0' prefix
+            assert exif_data == expected_exif[6:]
+
+
+def test_read_exif_metadata_without_prefix() -> None:
+    with Image.open("Tests/images/flower2.jxl") as im:
+        # Assert prefix is not present
+        assert im.info["exif"][:6] != b"Exif\x00\x00"
+
+        exif = im.getexif()
+        assert exif[305] == "Adobe Photoshop CS6 (Macintosh)"
+
+
+def test_read_icc_profile() -> None:
+    file_path = "Tests/images/flower2.jxl"
+    with Image.open(file_path) as image:
+        assert image.format == "JPEG XL"
+        assert image.info.get("icc_profile", None)
+
+        icc = image.info["icc_profile"]
+
+        with Image.open("Tests/images/flower2.jxl") as jpeg_image:
+            expected_icc = jpeg_image.info["icc_profile"]
+
+            assert icc == expected_icc
+
+
+def test_getxmp() -> None:
+    with Image.open("Tests/images/flower.jxl") as im:
+        assert "xmp" not in im.info
+        assert im.getxmp() == {}
+
+    with Image.open("Tests/images/flower2.jxl") as im:
+        if ElementTree:
+            assert (
+                im.getxmp()["xmpmeta"]["xmptk"]
+                == "Adobe XMP Core 5.3-c011 66.145661, 2012/02/06-14:56:27        "
+            )
+        else:
+            with pytest.warns(
+                UserWarning,
+                match="XMP data cannot be read without defusedxml dependency",
+            ):
+                assert im.getxmp() == {}
+
+
+def test_fix_exif_fail() -> None:
+    with Image.open("Tests/images/flower2.jxl") as image:
+        assert image._fix_exif(b"\0\0\0\0") is None
+
+
+def test_read_exif_metadata_empty() -> None:
+    with Image.open("Tests/images/hopper.jxl") as image:
+        assert image._getexif() is None

Tests/test_jxl_leaks.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from io import BytesIO
+
+from PIL import Image
+
+from .helper import PillowLeakTestCase, skip_unless_feature
+
+TEST_FILE = "Tests/images/hopper.jxl"
+
+
+@skip_unless_feature("jpegxl")
+class TestJpegXlLeaks(PillowLeakTestCase):
+    mem_limit = 6 * 1024  # kb
+    iterations = 1000
+
+    def test_leak_load(self) -> None:
+        with open(TEST_FILE, "rb") as f:
+            im_data = f.read()
+
+        def core() -> None:
+            with Image.open(BytesIO(im_data)) as im:
+                im.load()
+
+        self._test_leak(core)

setup.py

@@ -300,6 +300,7 @@ class ext_feature:
         features = [
             "zlib",
             "jpeg",
+            "jpegxl",
             "tiff",
             "freetype",
             "raqm",
@@ -746,6 +747,14 @@ def build_extensions(self) -> None:
                 feature.set("jpeg2000", "openjp2")
                 feature.set("openjpeg_version", ".".join(str(x) for x in best_version))
 
+        if feature.want("jpegxl"):
+            _dbg("Looking for jpegxl")
+            if _find_include_file(self, "jxl/encode.h") and _find_include_file(
+                self, "jxl/decode.h"
+            ):
+                if _find_library_file(self, "jxl"):
+                    feature.set("jpegxl", "jxl jxl_threads")
+
         if feature.want("imagequant"):
             _dbg("Looking for imagequant")
             if _find_include_file(self, "libimagequant.h"):
@@ -829,6 +838,15 @@ def build_extensions(self) -> None:
                     # alternate Windows name.
                     feature.set("lcms", "lcms2_static")
 
+        if feature.get("jpegxl"):
+            # jxl and jxl_threads are required
+            libs = feature.get("jpegxl").split()
+            defs = []
+
+            self._update_extension("PIL._jpegxl", libs, defs)
+        else:
+            self._remove_extension("PIL._jpegxl")
+
         if feature.want("webp"):
             _dbg("Looking for webp")
             if all(
@@ -992,6 +1010,7 @@ def summary_report(self, feature: ext_feature) -> None:
             (feature.get("freetype"), "FREETYPE2"),
             (feature.get("raqm"), "RAQM (Text shaping)", raqm_extra_info),
             (feature.get("lcms"), "LITTLECMS2"),
+            (feature.get("jpegxl"), "JPEG XL"),
             (feature.get("webp"), "WEBP"),
             (feature.get("xcb"), "XCB (X protocol)"),
             (feature.get("avif"), "LIBAVIF"),
@@ -1036,6 +1055,7 @@ def debug_build() -> bool:
     Extension("PIL._imaging", files),
     Extension("PIL._imagingft", ["src/_imagingft.c"]),
     Extension("PIL._imagingcms", ["src/_imagingcms.c"]),
+    Extension("PIL._jpegxl", ["src/_jpegxl.c"]),
     Extension("PIL._webp", ["src/_webp.c"]),
     Extension("PIL._avif", ["src/_avif.c"]),
     Extension("PIL._imagingtk", ["src/_imagingtk.c", "src/Tk/tkImaging.c"]),