@ai-ecoverse/py-pillow 12.3.0-2

package/lib/python3.14/site-packages/PIL/QoiImagePlugin.py

@@ -0,0 +1,235 @@
+#
+# The Python Imaging Library.
+#
+# QOI support for PIL
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import os
+from typing import IO
+
+from . import Image, ImageFile
+from ._binary import i32be as i32
+from ._binary import o8
+from ._binary import o32be as o32
+
+
+def _accept(prefix: bytes) -> bool:
+    return prefix.startswith(b"qoif")
+
+
+class QoiImageFile(ImageFile.ImageFile):
+    format = "QOI"
+    format_description = "Quite OK Image"
+
+    def _open(self) -> None:
+        assert self.fp is not None
+        if not _accept(self.fp.read(4)):
+            msg = "not a QOI file"
+            raise SyntaxError(msg)
+
+        self._size = i32(self.fp.read(4)), i32(self.fp.read(4))
+
+        channels = self.fp.read(1)[0]
+        self._mode = "RGB" if channels == 3 else "RGBA"
+
+        self.fp.seek(1, os.SEEK_CUR)  # colorspace
+        self.tile = [ImageFile._Tile("qoi", (0, 0) + self._size, self.fp.tell())]
+
+
+class QoiDecoder(ImageFile.PyDecoder):
+    _pulls_fd = True
+    _previous_pixel: bytes | bytearray | None = None
+    _previously_seen_pixels: dict[int, bytes | bytearray] = {}
+
+    def _add_to_previous_pixels(self, value: bytes | bytearray) -> None:
+        self._previous_pixel = value
+
+        r, g, b, a = value
+        hash_value = (r * 3 + g * 5 + b * 7 + a * 11) % 64
+        self._previously_seen_pixels[hash_value] = value
+
+    def decode(self, buffer: Image.DecoderInput) -> tuple[int, int]:
+        assert self.fd is not None
+
+        self._previously_seen_pixels = {}
+        self._previous_pixel = bytearray((0, 0, 0, 255))
+
+        data = bytearray()
+        bands = Image.getmodebands(self.mode)
+        dest_length = self.state.xsize * self.state.ysize * bands
+        while len(data) < dest_length:
+            byte = self.fd.read(1)[0]
+            value: bytes | bytearray
+            if byte == 0b11111110 and self._previous_pixel:  # QOI_OP_RGB
+                value = bytearray(self.fd.read(3)) + self._previous_pixel[3:]
+            elif byte == 0b11111111:  # QOI_OP_RGBA
+                value = self.fd.read(4)
+            else:
+                op = byte >> 6
+                if op == 0:  # QOI_OP_INDEX
+                    op_index = byte & 0b00111111
+                    value = self._previously_seen_pixels.get(
+                        op_index, bytearray((0, 0, 0, 0))
+                    )
+                elif op == 1 and self._previous_pixel:  # QOI_OP_DIFF
+                    value = bytearray(
+                        (
+                            (self._previous_pixel[0] + ((byte & 0b00110000) >> 4) - 2)
+                            % 256,
+                            (self._previous_pixel[1] + ((byte & 0b00001100) >> 2) - 2)
+                            % 256,
+                            (self._previous_pixel[2] + (byte & 0b00000011) - 2) % 256,
+                            self._previous_pixel[3],
+                        )
+                    )
+                elif op == 2 and self._previous_pixel:  # QOI_OP_LUMA
+                    second_byte = self.fd.read(1)[0]
+                    diff_green = (byte & 0b00111111) - 32
+                    diff_red = ((second_byte & 0b11110000) >> 4) - 8
+                    diff_blue = (second_byte & 0b00001111) - 8
+
+                    value = bytearray(
+                        tuple(
+                            (self._previous_pixel[i] + diff_green + diff) % 256
+                            for i, diff in enumerate((diff_red, 0, diff_blue))
+                        )
+                    )
+                    value += self._previous_pixel[3:]
+                elif op == 3 and self._previous_pixel:  # QOI_OP_RUN
+                    run_length = (byte & 0b00111111) + 1
+                    value = self._previous_pixel
+                    if bands == 3:
+                        value = value[:3]
+                    data += value * run_length
+                    continue
+            self._add_to_previous_pixels(value)
+
+            if bands == 3:
+                value = value[:3]
+            data += value
+        self.set_as_raw(data)
+        return -1, 0
+
+
+def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
+    if im.mode == "RGB":
+        channels = 3
+    elif im.mode == "RGBA":
+        channels = 4
+    else:
+        msg = "Unsupported QOI image mode"
+        raise ValueError(msg)
+
+    colorspace = 0 if im.encoderinfo.get("colorspace") == "sRGB" else 1
+
+    fp.write(b"qoif")
+    fp.write(o32(im.size[0]))
+    fp.write(o32(im.size[1]))
+    fp.write(o8(channels))
+    fp.write(o8(colorspace))
+
+    ImageFile._save(im, fp, [ImageFile._Tile("qoi", (0, 0) + im.size)])
+
+
+class QoiEncoder(ImageFile.PyEncoder):
+    _pushes_fd = True
+    _previous_pixel: tuple[int, int, int, int] | None = None
+    _previously_seen_pixels: dict[int, tuple[int, int, int, int]] = {}
+    _run = 0
+
+    def _write_run(self) -> bytes:
+        data = o8(0b11000000 | (self._run - 1))  # QOI_OP_RUN
+        self._run = 0
+        return data
+
+    def _delta(self, left: int, right: int) -> int:
+        result = (left - right) & 255
+        if result >= 128:
+            result -= 256
+        return result
+
+    def encode(self, bufsize: int) -> tuple[int, int, bytes]:
+        assert self.im is not None
+
+        self._previously_seen_pixels = {0: (0, 0, 0, 0)}
+        self._previous_pixel = (0, 0, 0, 255)
+
+        data = bytearray()
+        w, h = self.im.size
+        bands = Image.getmodebands(self.mode)
+
+        for y in range(h):
+            for x in range(w):
+                pixel = self.im.getpixel((x, y))
+                if bands == 3:
+                    pixel = (*pixel, 255)
+
+                if pixel == self._previous_pixel:
+                    self._run += 1
+                    if self._run == 62:
+                        data += self._write_run()
+                else:
+                    if self._run:
+                        data += self._write_run()
+
+                    r, g, b, a = pixel
+                    hash_value = (r * 3 + g * 5 + b * 7 + a * 11) % 64
+                    if self._previously_seen_pixels.get(hash_value) == pixel:
+                        data += o8(hash_value)  # QOI_OP_INDEX
+                    elif self._previous_pixel:
+                        self._previously_seen_pixels[hash_value] = pixel
+
+                        prev_r, prev_g, prev_b, prev_a = self._previous_pixel
+                        if prev_a == a:
+                            delta_r = self._delta(r, prev_r)
+                            delta_g = self._delta(g, prev_g)
+                            delta_b = self._delta(b, prev_b)
+
+                            if (
+                                -2 <= delta_r < 2
+                                and -2 <= delta_g < 2
+                                and -2 <= delta_b < 2
+                            ):
+                                data += o8(
+                                    0b01000000
+                                    | (delta_r + 2) << 4
+                                    | (delta_g + 2) << 2
+                                    | (delta_b + 2)
+                                )  # QOI_OP_DIFF
+                            else:
+                                delta_gr = self._delta(delta_r, delta_g)
+                                delta_gb = self._delta(delta_b, delta_g)
+                                if (
+                                    -8 <= delta_gr < 8
+                                    and -32 <= delta_g < 32
+                                    and -8 <= delta_gb < 8
+                                ):
+                                    data += o8(
+                                        0b10000000 | (delta_g + 32)
+                                    )  # QOI_OP_LUMA
+                                    data += o8((delta_gr + 8) << 4 | (delta_gb + 8))
+                                else:
+                                    data += o8(0b11111110)  # QOI_OP_RGB
+                                    data += bytes(pixel[:3])
+                        else:
+                            data += o8(0b11111111)  # QOI_OP_RGBA
+                            data += bytes(pixel)
+
+                self._previous_pixel = pixel
+
+        if self._run:
+            data += self._write_run()
+        data += bytes((0, 0, 0, 0, 0, 0, 0, 1))  # padding
+
+        return len(data), 0, bytes(data)
+
+
+Image.register_open(QoiImageFile.format, QoiImageFile, _accept)
+Image.register_decoder("qoi", QoiDecoder)
+Image.register_extension(QoiImageFile.format, ".qoi")
+
+Image.register_save(QoiImageFile.format, _save)
+Image.register_encoder("qoi", QoiEncoder)

package/lib/python3.14/site-packages/PIL/SgiImagePlugin.py

@@ -0,0 +1,231 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# SGI image file handling
+#
+# See "The SGI Image File Format (Draft version 0.97)", Paul Haeberli.
+# <ftp://ftp.sgi.com/graphics/SGIIMAGESPEC>
+#
+#
+# History:
+# 2017-22-07 mb   Add RLE decompression
+# 2016-16-10 mb   Add save method without compression
+# 1995-09-10 fl   Created
+#
+# Copyright (c) 2016 by Mickael Bonfill.
+# Copyright (c) 2008 by Karsten Hiddemann.
+# Copyright (c) 1997 by Secret Labs AB.
+# Copyright (c) 1995 by Fredrik Lundh.
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import os
+import struct
+from typing import IO
+
+from . import Image, ImageFile
+from ._binary import i16be as i16
+from ._binary import o8
+
+
+def _accept(prefix: bytes) -> bool:
+    return len(prefix) >= 2 and i16(prefix) == 474
+
+
+MODES = {
+    (1, 1, 1): "L",
+    (1, 2, 1): "L",
+    (2, 1, 1): "L;16B",
+    (2, 2, 1): "L;16B",
+    (1, 3, 3): "RGB",
+    (2, 3, 3): "RGB;16B",
+    (1, 3, 4): "RGBA",
+    (2, 3, 4): "RGBA;16B",
+}
+
+
+##
+# Image plugin for SGI images.
+class SgiImageFile(ImageFile.ImageFile):
+    format = "SGI"
+    format_description = "SGI Image File Format"
+
+    def _open(self) -> None:
+        # HEAD
+        assert self.fp is not None
+
+        headlen = 512
+        s = self.fp.read(headlen)
+
+        if not _accept(s):
+            msg = "Not an SGI image file"
+            raise ValueError(msg)
+
+        # compression : verbatim or RLE
+        compression = s[2]
+
+        # bpc : 1 or 2 bytes (8bits or 16bits)
+        bpc = s[3]
+
+        # dimension : 1, 2 or 3 (depending on xsize, ysize and zsize)
+        dimension = i16(s, 4)
+
+        # xsize : width
+        xsize = i16(s, 6)
+
+        # ysize : height
+        ysize = i16(s, 8)
+
+        # zsize : channels count
+        zsize = i16(s, 10)
+
+        # determine mode from bits/zsize
+        try:
+            rawmode = MODES[(bpc, dimension, zsize)]
+        except KeyError:
+            msg = "Unsupported SGI image mode"
+            raise ValueError(msg)
+
+        self._size = xsize, ysize
+        self._mode = rawmode.split(";")[0]
+        if self.mode == "RGB":
+            self.custom_mimetype = "image/rgb"
+
+        # orientation -1 : scanlines begins at the bottom-left corner
+        orientation = -1
+
+        # decoder info
+        if compression == 0:
+            pagesize = xsize * ysize * bpc
+            if bpc == 2:
+                self.tile = [
+                    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(
+                        ImageFile._Tile(
+                            "raw", (0, 0) + self.size, offset, (layer, 0, orientation)
+                        )
+                    )
+                    offset += pagesize
+        elif compression == 1:
+            self.tile = [
+                ImageFile._Tile(
+                    "sgi_rle", (0, 0) + self.size, headlen, (rawmode, orientation, bpc)
+                )
+            ]
+
+
+def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
+    if im.mode not in {"RGB", "RGBA", "L"}:
+        msg = "Unsupported SGI image mode"
+        raise ValueError(msg)
+
+    # Get the keyword arguments
+    info = im.encoderinfo
+
+    # Byte-per-pixel precision, 1 = 8bits per pixel
+    bpc = info.get("bpc", 1)
+
+    if bpc not in (1, 2):
+        msg = "Unsupported number of bytes per pixel"
+        raise ValueError(msg)
+
+    # Flip the image, since the origin of SGI file is the bottom-left corner
+    orientation = -1
+    # Define the file as SGI File Format
+    magic_number = 474
+    # Run-Length Encoding Compression - Unsupported at this time
+    rle = 0
+
+    # X Dimension = width / Y Dimension = height
+    x, y = im.size
+    # Z Dimension: Number of channels
+    z = len(im.mode)
+    # Number of dimensions (x,y,z)
+    if im.mode == "L":
+        dimension = 1 if y == 1 else 2
+    else:
+        dimension = 3
+
+    # Minimum Byte value
+    pinmin = 0
+    # Maximum Byte value (255 = 8bits per pixel)
+    pinmax = 255
+    # Image name (79 characters max, truncated below in write)
+    img_name = os.path.splitext(os.path.basename(filename))[0]
+    if isinstance(img_name, str):
+        img_name = img_name.encode("ascii", "ignore")
+    # Standard representation of pixel in the file
+    colormap = 0
+    fp.write(struct.pack(">h", magic_number))
+    fp.write(o8(rle))
+    fp.write(o8(bpc))
+    fp.write(struct.pack(">H", dimension))
+    fp.write(struct.pack(">H", x))
+    fp.write(struct.pack(">H", y))
+    fp.write(struct.pack(">H", z))
+    fp.write(struct.pack(">l", pinmin))
+    fp.write(struct.pack(">l", pinmax))
+    fp.write(struct.pack("4s", b""))  # dummy
+    fp.write(struct.pack("79s", img_name))  # truncates to 79 chars
+    fp.write(struct.pack("s", b""))  # force null byte after img_name
+    fp.write(struct.pack(">l", colormap))
+    fp.write(struct.pack("404s", b""))  # dummy
+
+    rawmode = "L"
+    if bpc == 2:
+        rawmode = "L;16B"
+
+    for channel in im.split():
+        fp.write(channel.tobytes("raw", rawmode, 0, orientation))
+
+    if hasattr(fp, "flush"):
+        fp.flush()
+
+
+class SGI16Decoder(ImageFile.PyDecoder):
+    _pulls_fd = True
+
+    def decode(self, buffer: Image.DecoderInput) -> tuple[int, int]:
+        assert self.fd is not None
+        assert self.im is not None
+
+        rawmode, stride, orientation = self.args
+        pagesize = self.state.xsize * self.state.ysize
+        zsize = len(self.mode)
+        self.fd.seek(512)
+
+        for band in range(zsize):
+            channel = Image.new("L", (self.state.xsize, self.state.ysize))
+            channel.frombytes(
+                self.fd.read(2 * pagesize), "raw", "L;16B", stride, orientation
+            )
+            self.im.putband(channel.im, band)
+
+        return -1, 0
+
+
+#
+# registry
+
+
+Image.register_decoder("SGI16", SGI16Decoder)
+Image.register_open(SgiImageFile.format, SgiImageFile, _accept)
+Image.register_save(SgiImageFile.format, _save)
+Image.register_mime(SgiImageFile.format, "image/sgi")
+
+Image.register_extensions(SgiImageFile.format, [".bw", ".rgb", ".rgba", ".sgi"])
+
+# End of file