pillow-avif-plugin 1.4.4__tar.gz → 1.4.6__tar.gz

{pillow-avif-plugin-1.4.4 → pillow-avif-plugin-1.4.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pillow-avif-plugin
-Version: 1.4.4
+Version: 1.4.6
 Summary: A pillow plugin that adds avif support via libavif
 Home-page: https://github.com/fdintino/pillow-avif-plugin/
 Download-URL: https://github.com/fdintino/pillow-avif-plugin/releases

{pillow-avif-plugin-1.4.4 → pillow-avif-plugin-1.4.6}/src/pillow_avif/__init__.py

@@ -2,4 +2,4 @@ from . import AvifImagePlugin
 
 
 __all__ = ["AvifImagePlugin"]
-__version__ = "1.4.4"
+__version__ = "1.4.6"

{pillow-avif-plugin-1.4.4 → pillow-avif-plugin-1.4.6}/src/pillow_avif_plugin.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pillow-avif-plugin
-Version: 1.4.4
+Version: 1.4.6
 Summary: A pillow plugin that adds avif support via libavif
 Home-page: https://github.com/fdintino/pillow-avif-plugin/
 Download-URL: https://github.com/fdintino/pillow-avif-plugin/releases

{pillow-avif-plugin-1.4.4 → pillow-avif-plugin-1.4.6}/src/pillow_avif_plugin.egg-info/SOURCES.txt

@@ -6,7 +6,6 @@ setup.cfg
 setup.py
 tox.ini
 src/pillow_avif/AvifImagePlugin.py
-src/pillow_avif/AvifImagePlugin.py.orig
 src/pillow_avif/__init__.py
 src/pillow_avif/_avif.c
 src/pillow_avif_plugin.egg-info/PKG-INFO

{pillow-avif-plugin-1.4.4 → pillow-avif-plugin-1.4.6}/tests/test_file_avif.py

@@ -584,6 +584,18 @@ class TestFileAvif:
         with Image.open("%s/tests/images/chimera-missing-pixi.avif" % CURR_DIR) as im:
             assert im.size == (480, 270)
 
+    @skip_unless_avif_encoder("aom")
+    def test_aom_optimizations(self):
+        im = hopper("RGB")
+        buf = BytesIO()
+        im.save(buf, format="AVIF", codec="aom", speed=1)
+
+    @skip_unless_avif_encoder("svt")
+    def test_svt_optimizations(self):
+        im = hopper("RGB")
+        buf = BytesIO()
+        im.save(buf, format="AVIF", codec="svt", speed=1)
+
 
 class TestAvifAnimation:
     @contextmanager

pillow-avif-plugin-1.4.4/src/pillow_avif/AvifImagePlugin.py.orig

@@ -1,282 +0,0 @@
-from __future__ import division
-
-from io import BytesIO
-import sys
-
-from PIL import ExifTags, Image, ImageFile
-
-try:
-    from pillow_avif import _avif
-
-    SUPPORTED = True
-except ImportError:
-    SUPPORTED = False
-
-# Decoder options as module globals, until there is a way to pass parameters
-# to Image.open (see https://github.com/python-pillow/Pillow/issues/569)
-DECODE_CODEC_CHOICE = "auto"
-CHROMA_UPSAMPLING = "auto"
-<<<<<<< HEAD
-DEFAULT_MAX_THREADS = 0
-=======
-DECODE_MAX_THREADS = 0
->>>>>>> 1e2fa65 (Let users pass max_threads manually as an argument)
-
-_VALID_AVIF_MODES = {"RGB", "RGBA"}
-
-
-if sys.version_info[0] == 2:
-    text_type = unicode  # noqa
-else:
-    text_type = str
-
-
-def _accept(prefix):
-    if prefix[4:8] != b"ftyp":
-        return
-    coding_brands = (b"avif", b"avis")
-    container_brands = (b"mif1", b"msf1")
-    major_brand = prefix[8:12]
-    if major_brand in coding_brands:
-        if not SUPPORTED:
-            return (
-                "image file could not be identified because AVIF "
-                "support not installed"
-            )
-        return True
-    if major_brand in container_brands:
-        # We accept files with AVIF container brands; we can't yet know if
-        # the ftyp box has the correct compatible brands, but if it doesn't
-        # then the plugin will raise a SyntaxError which Pillow will catch
-        # before moving on to the next plugin that accepts the file.
-        #
-        # Also, because this file might not actually be an AVIF file, we
-        # don't raise an error if AVIF support isn't properly compiled.
-        return True
-
-
-class AvifImageFile(ImageFile.ImageFile):
-    format = "AVIF"
-    format_description = "AVIF image"
-    __loaded = -1
-    __frame = 0
-
-    def load_seek(self, pos):
-        pass
-
-    def _open(self):
-        self._decoder = _avif.AvifDecoder(
-            self.fp.read(), DECODE_CODEC_CHOICE, CHROMA_UPSAMPLING, DECODE_MAX_THREADS
-        )
-
-        # Get info from decoder
-        width, height, n_frames, mode, icc, exif, xmp = self._decoder.get_info()
-        self._size = width, height
-        self.n_frames = n_frames
-        self.is_animated = self.n_frames > 1
-        try:
-            self.mode = self.rawmode = mode
-        except AttributeError:
-            self._mode = self.rawmode = mode
-        self.tile = []
-
-        if icc:
-            self.info["icc_profile"] = icc
-        if exif:
-            self.info["exif"] = exif
-        if xmp:
-            self.info["xmp"] = xmp
-
-    def seek(self, frame):
-        if not self._seek_check(frame):
-            return
-
-        self.__frame = frame
-
-    def load(self):
-        if self.__loaded != self.__frame:
-            # We need to load the image data for this frame
-            data, timescale, tsp_in_ts, dur_in_ts = self._decoder.get_frame(
-                self.__frame
-            )
-            timestamp = round(1000 * (tsp_in_ts / timescale))
-            duration = round(1000 * (dur_in_ts / timescale))
-            self.info["timestamp"] = timestamp
-            self.info["duration"] = duration
-            self.__loaded = self.__frame
-
-            # Set tile
-            if self.fp and self._exclusive_fp:
-                self.fp.close()
-            self.fp = BytesIO(data)
-            self.tile = [("raw", (0, 0) + self.size, 0, self.rawmode)]
-
-        return super(AvifImageFile, self).load()
-
-    def tell(self):
-        return self.__frame
-
-
-def _save_all(im, fp, filename):
-    _save(im, fp, filename, save_all=True)
-
-
-def _save(im, fp, filename, save_all=False):
-    info = im.encoderinfo.copy()
-    if save_all:
-        append_images = list(info.get("append_images", []))
-    else:
-        append_images = []
-
-    total = 0
-    for ims in [im] + append_images:
-        total += getattr(ims, "n_frames", 1)
-
-    is_single_frame = total == 1
-
-    qmin = info.get("qmin", -1)
-    qmax = info.get("qmax", -1)
-    quality = info.get("quality", 75)
-    if not isinstance(quality, int) or quality < 0 or quality > 100:
-        raise ValueError("Invalid quality setting")
-
-    duration = info.get("duration", 0)
-    subsampling = info.get("subsampling", "4:2:0")
-    speed = info.get("speed", 6)
-    max_threads = info.get("max_threads", DEFAULT_MAX_THREADS)
-    codec = info.get("codec", "auto")
-    range_ = info.get("range", "full")
-    tile_rows_log2 = info.get("tile_rows", 0)
-    tile_cols_log2 = info.get("tile_cols", 0)
-    alpha_premultiplied = bool(info.get("alpha_premultiplied", False))
-    autotiling = bool(info.get("autotiling", tile_rows_log2 == tile_cols_log2 == 0))
-
-    icc_profile = info.get("icc_profile", im.info.get("icc_profile"))
-    exif = info.get("exif", im.info.get("exif"))
-    if isinstance(exif, Image.Exif):
-        exif = exif.tobytes()
-
-    exif_orientation = 0
-    if exif:
-        exif_data = Image.Exif()
-        try:
-            exif_data.load(exif)
-        except SyntaxError:
-            pass
-        else:
-            orientation_tag = next(
-                k for k, v in ExifTags.TAGS.items() if v == "Orientation"
-            )
-            exif_orientation = exif_data.get(orientation_tag) or 0
-
-    xmp = info.get("xmp", im.info.get("xmp") or im.info.get("XML:com.adobe.xmp"))
-
-    if isinstance(xmp, text_type):
-        xmp = xmp.encode("utf-8")
-
-    advanced = info.get("advanced")
-    if isinstance(advanced, dict):
-        advanced = tuple([k, v] for (k, v) in advanced.items())
-    if advanced is not None:
-        try:
-            advanced = tuple(advanced)
-        except TypeError:
-            invalid = True
-        else:
-            invalid = all(isinstance(v, tuple) and len(v) == 2 for v in advanced)
-        if invalid:
-            raise ValueError(
-                "advanced codec options must be a dict of key-value string "
-                "pairs or a series of key-value two-tuples"
-            )
-        advanced = tuple(
-            [(str(k).encode("utf-8"), str(v).encode("utf-8")) for k, v in advanced]
-        )
-
-    # Setup the AVIF encoder
-    enc = _avif.AvifEncoder(
-        im.size[0],
-        im.size[1],
-        subsampling,
-        qmin,
-        qmax,
-        quality,
-        speed,
-        max_threads,
-        codec,
-        range_,
-        tile_rows_log2,
-        tile_cols_log2,
-        alpha_premultiplied,
-        autotiling,
-        icc_profile or b"",
-        exif or b"",
-        exif_orientation,
-        xmp or b"",
-        advanced,
-    )
-
-    # Add each frame
-    frame_idx = 0
-    frame_dur = 0
-    cur_idx = im.tell()
-    try:
-        for ims in [im] + append_images:
-            # Get # of frames in this image
-            nfr = getattr(ims, "n_frames", 1)
-
-            for idx in range(nfr):
-                ims.seek(idx)
-                ims.load()
-
-                # Make sure image mode is supported
-                frame = ims
-                rawmode = ims.mode
-                if ims.mode not in _VALID_AVIF_MODES:
-                    alpha = (
-                        "A" in ims.mode
-                        or "a" in ims.mode
-                        or (ims.mode == "P" and "A" in ims.im.getpalettemode())
-                    )
-                    rawmode = "RGBA" if alpha else "RGB"
-                    frame = ims.convert(rawmode)
-
-                # Update frame duration
-                if isinstance(duration, (list, tuple)):
-                    frame_dur = duration[frame_idx]
-                else:
-                    frame_dur = duration
-
-                # Append the frame to the animation encoder
-                enc.add(
-                    frame.tobytes("raw", rawmode),
-                    frame_dur,
-                    frame.size[0],
-                    frame.size[1],
-                    rawmode,
-                    is_single_frame,
-                )
-
-                # Update frame index
-                frame_idx += 1
-
-                if not save_all:
-                    break
-
-    finally:
-        im.seek(cur_idx)
-
-    # Get the final output from the encoder
-    data = enc.finish()
-    if data is None:
-        raise OSError("cannot write file as AVIF (encoder returned None)")
-
-    fp.write(data)
-
-
-Image.register_open(AvifImageFile.format, AvifImageFile, _accept)
-if SUPPORTED:
-    Image.register_save(AvifImageFile.format, _save)
-    Image.register_save_all(AvifImageFile.format, _save_all)
-    Image.register_extensions(AvifImageFile.format, [".avif", ".avifs"])
-    Image.register_mime(AvifImageFile.format, "image/avif")