@tushar-br/desktop 1.0.283 → 1.0.284

package/staging_area/micro projects/SD -Advanced Media Processing Toolkit Automated Downloader, Segmenter & Neural Dubber/.venv/Lib/site-packages/PIL/QoiImagePlugin.py

@@ -1,235 +0,0 @@
-#
-# 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: bytes | Image.SupportsArrayInterface) -> 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, 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/staging_area/micro projects/SD -Advanced Media Processing Toolkit Automated Downloader, Segmenter & Neural Dubber/.venv/Lib/site-packages/PIL/SgiImagePlugin.py

@@ -1,231 +0,0 @@
-#
-# 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: bytes | Image.SupportsArrayInterface) -> 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