Populate duration before load

Author: radarhere

Tests/test_file_jxl.py

@@ -37,7 +37,7 @@ def test_version(self) -> None:
 
     def test_read_rgb(self) -> None:
         """
-        Can we read a RGB mode Jpeg XL file without error?
+        Can we read an RGB mode JPEG XL file without error?
         Does it have the bits we expect?
         """
 
@@ -52,9 +52,22 @@ def test_read_rgb(self) -> None:
             # djxl hopper.jxl hopper_jxl_bits.ppm
             assert_image_similar_tofile(im, "Tests/images/hopper_jxl_bits.ppm", 1)
 
+    def test_read_rgba(self) -> None:
+        # 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)
+
     def test_read_i16(self) -> None:
         """
-        Can we read 16-bit Grayscale Jpeg XL image?
+        Can we read 16-bit Grayscale JPEG XL image?
         """
 
         with Image.open("Tests/images/jxl/16bit_subcutaneous.cropped.jxl") as im:

Tests/test_file_jxl_alpha.py

@@ -21,10 +21,14 @@ def test_n_frames() -> None:
         assert im.is_animated
 
 
-def test_float_duration() -> None:
+def test_duration() -> None:
     with Image.open("Tests/images/iss634.jxl") as im:
-        im.load()
         assert im.info["duration"] == 70
+        assert im.info["timestamp"] == 0
+
+        im.seek(2)
+        assert im.info["duration"] == 60
+        assert im.info["timestamp"] == 140
 
 
 def test_seek() -> None:
@@ -62,8 +66,11 @@ def test_seek() -> None:
 
 def test_seek_errors() -> None:
     with Image.open("Tests/images/iss634.jxl") as im:
-        with pytest.raises(EOFError):
+        with pytest.raises(EOFError, match="attempt to seek outside sequence"):
             im.seek(-1)
 
-        with pytest.raises(EOFError):
+        im.seek(1)
+        with pytest.raises(EOFError, match="no more images in JPEG XL file"):
             im.seek(47)
+
+        assert im.tell() == 1

Tests/test_file_jxl_animated.py

@@ -39,7 +39,7 @@ def test_read_exif_metadata() -> None:
     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
+    # JPEG XL always returns exif without 'Exif\0\0' prefix
     assert exif_data == expected_exif[6:]
 
 
@@ -97,8 +97,8 @@ class JpegXlDecoder:
             def __init__(self, b: bytes) -> None:
                 pass
 
-            def get_info(self) -> tuple[tuple[int, int], str, int, int, int, int]:
-                return ((1, 1), "L", 0, 0, 0, 0)
+            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

Tests/test_file_jxl_metadata.py

@@ -25,9 +25,7 @@ def _accept(prefix: bytes) -> bool | str:
 class JpegXlImageFile(ImageFile.ImageFile):
     format = "JPEG XL"
     format_description = "JPEG XL image"
-    __loaded = -1
-    __logical_frame = 0
-    __physical_frame = 0
+    __frame = 0
 
     def _open(self) -> None:
         self._decoder = _jpegxl.JpegXlDecoder(self.fp.read())
@@ -39,24 +37,27 @@ def _open(self) -> None:
             tps_num,
             tps_denom,
             self.info["loop"],
+            tps_duration,
         ) = self._decoder.get_info()
 
         self._n_frames = None if self.is_animated else 1
         self._tps_dur_secs = tps_num / tps_denom if tps_denom != 0 else 1
+        self.info["duration"] = 1000 * tps_duration * (1 / self._tps_dur_secs)
 
         # TODO: handle libjxl time codes
-        self.__timestamp = 0
+        self.info["timestamp"] = 0
 
         if icc := self._decoder.get_icc():
             self.info["icc_profile"] = icc
         if exif := self._decoder.get_exif():
-            # jpeg xl does some weird shenanigans when storing exif
+            # JPEG XL does some weird shenanigans when storing exif
             # it omits first 6 bytes of tiff header but adds 4 byte offset instead
             if len(exif) > 4:
                 exif_start_offset = struct.unpack(">I", exif[:4])[0]
                 self.info["exif"] = exif[exif_start_offset + 4 :]
         if xmp := self._decoder.get_xmp():
             self.info["xmp"] = xmp
+        self.tile = [ImageFile._Tile("raw", (0, 0) + self.size, 0, self.mode)]
 
     @property
     def n_frames(self) -> int:
@@ -67,72 +68,53 @@ def n_frames(self) -> int:
 
         return self._n_frames
 
-    def _get_next(self) -> tuple[bytes, float, float]:
-        # Get next frame
-        next_frame = self._decoder.get_next()
-        self.__physical_frame += 1
+    def _get_next(self) -> bytes:
+        data, tps_duration, is_last = self._decoder.get_next()
 
-        # this actually means EOF, errors are raised in _jxl
-        if next_frame is None:
-            msg = "failed to decode next frame in JXL file"
-            raise EOFError(msg)
-
-        data, tps_duration, is_last = next_frame
         if is_last and self._n_frames is None:
-            # libjxl said this frame is the last one
-            self._n_frames = self.__physical_frame
+            self._n_frames = self.__frame
 
         # duration in milliseconds
-        duration = 1000 * tps_duration * (1 / self._tps_dur_secs)
-        timestamp = self.__timestamp
-        self.__timestamp += duration
-
-        return data, timestamp, duration
+        self.info["timestamp"] += self.info["duration"]
+        self.info["duration"] = 1000 * tps_duration * (1 / self._tps_dur_secs)
 
-    def _seek(self, frame: int) -> None:
-        if frame == self.__physical_frame:
-            return  # Nothing to do
-        if frame < self.__physical_frame:
-            # also rewind libjxl decoder instance
-            self._decoder.rewind()
-            self.__physical_frame = 0
-            self.__loaded = -1
-            self.__timestamp = 0
-
-        while self.__physical_frame < frame:
-            self._get_next()  # Advance to the requested frame
+        return data
 
     def seek(self, frame: int) -> None:
-        if self._n_frames is None:
-            self.n_frames
         if not self._seek_check(frame):
             return
 
-        # Set logical frame to requested position
-        self.__logical_frame = frame
+        if frame < self.__frame:
+            self.__frame = 0
+            self._decoder.rewind()
+            self.info["timestamp"] = 0
 
-    def load(self) -> Image.core.PixelAccess | None:
-        if self.__loaded != self.__logical_frame:
-            self._seek(self.__logical_frame)
+        last_frame = self.__frame
+        while self.__frame < frame:
+            self._get_next()
+            self.__frame += 1
+            if self._n_frames is not None and self._n_frames < frame:
+                self.seek(last_frame)
+                msg = "no more images in JPEG XL file"
+                raise EOFError(msg)
 
-            data, self.info["timestamp"], self.info["duration"] = self._get_next()
-            self.__loaded = self.__logical_frame
+        self.tile = [ImageFile._Tile("raw", (0, 0) + self.size, 0, self.mode)]
+
+    def load(self) -> Image.core.PixelAccess | None:
+        if self.tile:
+            data = self._get_next()
 
-            # Set tile
             if self.fp and self._exclusive_fp:
                 self.fp.close()
-            # this is horribly memory inefficient
-            # you need probably 2*(raw image plane) bytes of memory
             self.fp = BytesIO(data)
-            self.tile = [ImageFile._Tile("raw", (0, 0) + self.size, 0, self.mode)]
 
         return super().load()
 
     def load_seek(self, pos: int) -> None:
         pass
 
     def tell(self) -> int:
-        return self.__logical_frame
+        return self.__frame
 
 
 Image.register_open(JpegXlImageFile.format, JpegXlImageFile, _accept)