Add JPEG XL Open/Read support via libjxl

.ci/install.sh

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

Tests/test_file_jxl.py

@@ -0,0 +1,76 @@
+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
+except ImportError:
+    pass
+
+# 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, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setattr(JpegXlImagePlugin, "SUPPORTED", False)
+
+        with pytest.raises(OSError):
+            with Image.open("Tests/images/hopper.jxl"):
+                pass
+
+
+@skip_unless_feature("jpegxl")
+class TestFileJpegXl:
+    def test_version(self) -> None:
+        version = features.version_module("jpegxl")
+        assert version is not None
+        assert re.search(r"\d+\.\d+\.\d+$", version)
+
+    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 im:
+            assert im.mode == "RGB"
+            assert im.size == (128, 128)
+            assert im.format == "JPEG XL"
+            im.load()
+            im.getdata()
+
+            # generated with:
+            # djxl hopper.jxl hopper_jxl_bits.ppm
+            assert_image_similar_tofile(im, "Tests/images/hopper_jxl_bits.ppm", 1)
+
+    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 im:
+            assert im.mode == "I;16"
+            assert im.size == (128, 64)
+            assert im.format == "JPEG XL"
+            im.load()
+            im.getdata()
+
+            assert_image_similar_tofile(
+                im, "Tests/images/jxl/16bit_subcutaneous.cropped.png", 1
+            )
+
+    def test_JpegXlDecode_with_invalid_args(self) -> None:
+        """
+        Calling decoder functions with no arguments should result in an error.
+        """
+
+        with pytest.raises(TypeError):
+            _jpegxl.JpegXlDecoder()

Tests/test_file_jxl_alpha.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from PIL import Image
+
+from .helper import assert_image_similar_tofile, skip_unless_feature
+
+pytestmark = [skip_unless_feature("jpegxl")]
+
+
+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`
+    with Image.open("Tests/images/transparent.jxl") as im:
+        assert im.mode == "RGBA"
+        assert im.size == (200, 150)
+        assert im.format == "JPEG XL"
+        im.load()
+        im.getdata()
+
+        im.tobytes()
+
+        assert_image_similar_tofile(im, "Tests/images/transparent.png", 1)

Tests/test_file_jxl_animated.py

@@ -0,0 +1,71 @@
+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,120 @@
+from __future__ import annotations
+
+from types import ModuleType
+
+import pytest
+
+from PIL import Image, JpegXlImagePlugin
+
+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:
+    with Image.open("Tests/images/flower.jxl") as im:
+        assert im.format == "JPEG XL"
+        exif_data = im.info["exif"]
+
+        exif = im.getexif()
+
+        # Camera make
+        assert exif[271] == "Canon"
+
+    with Image.open("Tests/images/flower.jpg") as im_jpeg:
+        expected_exif = im_jpeg.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:
+    with Image.open("Tests/images/flower2.jxl") as im:
+        assert im.format == "JPEG XL"
+        icc = im.info["icc_profile"]
+
+    with Image.open("Tests/images/flower2.jxl") as im_jpeg:
+        expected_icc = im_jpeg.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
+        if ElementTree is None:
+            with pytest.warns(
+                UserWarning,
+                match="XMP data cannot be read without defusedxml dependency",
+            ):
+                xmp = im.getxmp()
+        else:
+            xmp = im.getxmp()
+        assert xmp == {}
+
+    with Image.open("Tests/images/flower2.jxl") as im:
+        if ElementTree is None:
+            with pytest.warns(
+                UserWarning,
+                match="XMP data cannot be read without defusedxml dependency",
+            ):
+                assert im.getxmp() == {}
+        else:
+            assert "xmp" in im.info
+            assert (
+                im.getxmp()["xmpmeta"]["xmptk"]
+                == "Adobe XMP Core 5.3-c011 66.145661, 2012/02/06-14:56:27        "
+            )
+
+
+def test_4_byte_exif(monkeypatch: pytest.MonkeyPatch) -> None:
+    class _mock_jpegxl:
+        class JpegXlDecoder:
+            def __init__(self, b: bytes) -> None:
+                pass
+
+            def get_info(self) -> tuple[tuple[int, int], str, int, int, int, int, int]:
+                return ((1, 1), "L", 0, 0, 0, 0, 0)
+
+            def get_icc(self) -> None:
+                pass
+
+            def get_exif(self) -> bytes:
+                return b"\0\0\0\0"
+
+            def get_xmp(self) -> None:
+                pass
+
+    monkeypatch.setattr(JpegXlImagePlugin, "_jpegxl", _mock_jpegxl)
+
+    with Image.open("Tests/images/hopper.jxl") as im:
+        assert "exif" not in im.info
+
+
+def test_read_exif_metadata_empty() -> None:
+    with Image.open("Tests/images/hopper.jxl") as im:
+        assert im.getexif() == {}

setup.py

@@ -300,6 +300,7 @@ class ext_feature:
         features = [
             "zlib",
             "jpeg",
+            "jpegxl",
             "tiff",
             "freetype",
             "raqm",
@@ -742,6 +743,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")
+
         if feature.want("imagequant"):
             _dbg("Looking for imagequant")
             if _find_include_file(self, "libimagequant.h"):
@@ -952,6 +961,14 @@ def build_extensions(self) -> None:
         else:
             self._remove_extension("PIL._avif")
 
+        jpegxl = feature.get("jpegxl")
+        if isinstance(jpegxl, str):
+            # jxl and jxl_threads are required
+            libs = [jpegxl, jpegxl + "_threads"]
+            self._update_extension("PIL._jpegxl", libs)
+        else:
+            self._remove_extension("PIL._jpegxl")
+
         tk_libs = ["psapi"] if sys.platform in ("win32", "cygwin") else []
         self._update_extension("PIL._imagingtk", tk_libs)
 
@@ -992,6 +1009,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 +1054,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"]),