aboutsummaryrefslogtreecommitdiff
path: root/.venv/lib/python3.12/site-packages/PIL/IcnsImagePlugin.py
diff options
context:
space:
mode:
Diffstat (limited to '.venv/lib/python3.12/site-packages/PIL/IcnsImagePlugin.py')
-rw-r--r--.venv/lib/python3.12/site-packages/PIL/IcnsImagePlugin.py412
1 files changed, 412 insertions, 0 deletions
diff --git a/.venv/lib/python3.12/site-packages/PIL/IcnsImagePlugin.py b/.venv/lib/python3.12/site-packages/PIL/IcnsImagePlugin.py
new file mode 100644
index 00000000..9757b2b1
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/PIL/IcnsImagePlugin.py
@@ -0,0 +1,412 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# macOS icns file decoder, based on icns.py by Bob Ippolito.
+#
+# history:
+# 2004-10-09 fl Turned into a PIL plugin; removed 2.3 dependencies.
+# 2020-04-04 Allow saving on all operating systems.
+#
+# Copyright (c) 2004 by Bob Ippolito.
+# Copyright (c) 2004 by Secret Labs.
+# Copyright (c) 2004 by Fredrik Lundh.
+# Copyright (c) 2014 by Alastair Houghton.
+# Copyright (c) 2020 by Pan Jing.
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import io
+import os
+import struct
+import sys
+from typing import IO
+
+from . import Image, ImageFile, PngImagePlugin, features
+from ._deprecate import deprecate
+
+enable_jpeg2k = features.check_codec("jpg_2000")
+if enable_jpeg2k:
+ from . import Jpeg2KImagePlugin
+
+MAGIC = b"icns"
+HEADERSIZE = 8
+
+
+def nextheader(fobj: IO[bytes]) -> tuple[bytes, int]:
+ return struct.unpack(">4sI", fobj.read(HEADERSIZE))
+
+
+def read_32t(
+ fobj: IO[bytes], start_length: tuple[int, int], size: tuple[int, int, int]
+) -> dict[str, Image.Image]:
+ # The 128x128 icon seems to have an extra header for some reason.
+ (start, length) = start_length
+ fobj.seek(start)
+ sig = fobj.read(4)
+ if sig != b"\x00\x00\x00\x00":
+ msg = "Unknown signature, expecting 0x00000000"
+ raise SyntaxError(msg)
+ return read_32(fobj, (start + 4, length - 4), size)
+
+
+def read_32(
+ fobj: IO[bytes], start_length: tuple[int, int], size: tuple[int, int, int]
+) -> dict[str, Image.Image]:
+ """
+ Read a 32bit RGB icon resource. Seems to be either uncompressed or
+ an RLE packbits-like scheme.
+ """
+ (start, length) = start_length
+ fobj.seek(start)
+ pixel_size = (size[0] * size[2], size[1] * size[2])
+ sizesq = pixel_size[0] * pixel_size[1]
+ if length == sizesq * 3:
+ # uncompressed ("RGBRGBGB")
+ indata = fobj.read(length)
+ im = Image.frombuffer("RGB", pixel_size, indata, "raw", "RGB", 0, 1)
+ else:
+ # decode image
+ im = Image.new("RGB", pixel_size, None)
+ for band_ix in range(3):
+ data = []
+ bytesleft = sizesq
+ while bytesleft > 0:
+ byte = fobj.read(1)
+ if not byte:
+ break
+ byte_int = byte[0]
+ if byte_int & 0x80:
+ blocksize = byte_int - 125
+ byte = fobj.read(1)
+ for i in range(blocksize):
+ data.append(byte)
+ else:
+ blocksize = byte_int + 1
+ data.append(fobj.read(blocksize))
+ bytesleft -= blocksize
+ if bytesleft <= 0:
+ break
+ if bytesleft != 0:
+ msg = f"Error reading channel [{repr(bytesleft)} left]"
+ raise SyntaxError(msg)
+ band = Image.frombuffer("L", pixel_size, b"".join(data), "raw", "L", 0, 1)
+ im.im.putband(band.im, band_ix)
+ return {"RGB": im}
+
+
+def read_mk(
+ fobj: IO[bytes], start_length: tuple[int, int], size: tuple[int, int, int]
+) -> dict[str, Image.Image]:
+ # Alpha masks seem to be uncompressed
+ start = start_length[0]
+ fobj.seek(start)
+ pixel_size = (size[0] * size[2], size[1] * size[2])
+ sizesq = pixel_size[0] * pixel_size[1]
+ band = Image.frombuffer("L", pixel_size, fobj.read(sizesq), "raw", "L", 0, 1)
+ return {"A": band}
+
+
+def read_png_or_jpeg2000(
+ fobj: IO[bytes], start_length: tuple[int, int], size: tuple[int, int, int]
+) -> dict[str, Image.Image]:
+ (start, length) = start_length
+ fobj.seek(start)
+ sig = fobj.read(12)
+
+ im: Image.Image
+ if sig[:8] == b"\x89PNG\x0d\x0a\x1a\x0a":
+ fobj.seek(start)
+ im = PngImagePlugin.PngImageFile(fobj)
+ Image._decompression_bomb_check(im.size)
+ return {"RGBA": im}
+ elif (
+ sig[:4] == b"\xff\x4f\xff\x51"
+ or sig[:4] == b"\x0d\x0a\x87\x0a"
+ or sig == b"\x00\x00\x00\x0cjP \x0d\x0a\x87\x0a"
+ ):
+ if not enable_jpeg2k:
+ msg = (
+ "Unsupported icon subimage format (rebuild PIL "
+ "with JPEG 2000 support to fix this)"
+ )
+ raise ValueError(msg)
+ # j2k, jpc or j2c
+ fobj.seek(start)
+ jp2kstream = fobj.read(length)
+ f = io.BytesIO(jp2kstream)
+ im = Jpeg2KImagePlugin.Jpeg2KImageFile(f)
+ Image._decompression_bomb_check(im.size)
+ if im.mode != "RGBA":
+ im = im.convert("RGBA")
+ return {"RGBA": im}
+ else:
+ msg = "Unsupported icon subimage format"
+ raise ValueError(msg)
+
+
+class IcnsFile:
+ SIZES = {
+ (512, 512, 2): [(b"ic10", read_png_or_jpeg2000)],
+ (512, 512, 1): [(b"ic09", read_png_or_jpeg2000)],
+ (256, 256, 2): [(b"ic14", read_png_or_jpeg2000)],
+ (256, 256, 1): [(b"ic08", read_png_or_jpeg2000)],
+ (128, 128, 2): [(b"ic13", read_png_or_jpeg2000)],
+ (128, 128, 1): [
+ (b"ic07", read_png_or_jpeg2000),
+ (b"it32", read_32t),
+ (b"t8mk", read_mk),
+ ],
+ (64, 64, 1): [(b"icp6", read_png_or_jpeg2000)],
+ (32, 32, 2): [(b"ic12", read_png_or_jpeg2000)],
+ (48, 48, 1): [(b"ih32", read_32), (b"h8mk", read_mk)],
+ (32, 32, 1): [
+ (b"icp5", read_png_or_jpeg2000),
+ (b"il32", read_32),
+ (b"l8mk", read_mk),
+ ],
+ (16, 16, 2): [(b"ic11", read_png_or_jpeg2000)],
+ (16, 16, 1): [
+ (b"icp4", read_png_or_jpeg2000),
+ (b"is32", read_32),
+ (b"s8mk", read_mk),
+ ],
+ }
+
+ def __init__(self, fobj: IO[bytes]) -> None:
+ """
+ fobj is a file-like object as an icns resource
+ """
+ # signature : (start, length)
+ self.dct = {}
+ self.fobj = fobj
+ sig, filesize = nextheader(fobj)
+ if not _accept(sig):
+ msg = "not an icns file"
+ raise SyntaxError(msg)
+ i = HEADERSIZE
+ while i < filesize:
+ sig, blocksize = nextheader(fobj)
+ if blocksize <= 0:
+ msg = "invalid block header"
+ raise SyntaxError(msg)
+ i += HEADERSIZE
+ blocksize -= HEADERSIZE
+ self.dct[sig] = (i, blocksize)
+ fobj.seek(blocksize, io.SEEK_CUR)
+ i += blocksize
+
+ def itersizes(self) -> list[tuple[int, int, int]]:
+ sizes = []
+ for size, fmts in self.SIZES.items():
+ for fmt, reader in fmts:
+ if fmt in self.dct:
+ sizes.append(size)
+ break
+ return sizes
+
+ def bestsize(self) -> tuple[int, int, int]:
+ sizes = self.itersizes()
+ if not sizes:
+ msg = "No 32bit icon resources found"
+ raise SyntaxError(msg)
+ return max(sizes)
+
+ def dataforsize(self, size: tuple[int, int, int]) -> dict[str, Image.Image]:
+ """
+ Get an icon resource as {channel: array}. Note that
+ the arrays are bottom-up like windows bitmaps and will likely
+ need to be flipped or transposed in some way.
+ """
+ dct = {}
+ for code, reader in self.SIZES[size]:
+ desc = self.dct.get(code)
+ if desc is not None:
+ dct.update(reader(self.fobj, desc, size))
+ return dct
+
+ def getimage(
+ self, size: tuple[int, int] | tuple[int, int, int] | None = None
+ ) -> Image.Image:
+ if size is None:
+ size = self.bestsize()
+ elif len(size) == 2:
+ size = (size[0], size[1], 1)
+ channels = self.dataforsize(size)
+
+ im = channels.get("RGBA")
+ if im:
+ return im
+
+ im = channels["RGB"].copy()
+ try:
+ im.putalpha(channels["A"])
+ except KeyError:
+ pass
+ return im
+
+
+##
+# Image plugin for Mac OS icons.
+
+
+class IcnsImageFile(ImageFile.ImageFile):
+ """
+ PIL image support for Mac OS .icns files.
+ Chooses the best resolution, but will possibly load
+ a different size image if you mutate the size attribute
+ before calling 'load'.
+
+ The info dictionary has a key 'sizes' that is a list
+ of sizes that the icns file has.
+ """
+
+ format = "ICNS"
+ format_description = "Mac OS icns resource"
+
+ def _open(self) -> None:
+ self.icns = IcnsFile(self.fp)
+ self._mode = "RGBA"
+ self.info["sizes"] = self.icns.itersizes()
+ self.best_size = self.icns.bestsize()
+ self.size = (
+ self.best_size[0] * self.best_size[2],
+ self.best_size[1] * self.best_size[2],
+ )
+
+ @property # type: ignore[override]
+ def size(self) -> tuple[int, int] | tuple[int, int, int]:
+ return self._size
+
+ @size.setter
+ def size(self, value: tuple[int, int] | tuple[int, int, int]) -> None:
+ if len(value) == 3:
+ deprecate("Setting size to (width, height, scale)", 12, "load(scale)")
+ if value in self.info["sizes"]:
+ self._size = value # type: ignore[assignment]
+ return
+ else:
+ # Check that a matching size exists,
+ # or that there is a scale that would create a size that matches
+ for size in self.info["sizes"]:
+ simple_size = size[0] * size[2], size[1] * size[2]
+ scale = simple_size[0] // value[0]
+ if simple_size[1] / value[1] == scale:
+ self._size = value
+ return
+ msg = "This is not one of the allowed sizes of this image"
+ raise ValueError(msg)
+
+ def load(self, scale: int | None = None) -> Image.core.PixelAccess | None:
+ if scale is not None or len(self.size) == 3:
+ if scale is None and len(self.size) == 3:
+ scale = self.size[2]
+ assert scale is not None
+ width, height = self.size[:2]
+ self.size = width * scale, height * scale
+ self.best_size = width, height, scale
+
+ px = Image.Image.load(self)
+ if self._im is not None and self.im.size == self.size:
+ # Already loaded
+ return px
+ self.load_prepare()
+ # This is likely NOT the best way to do it, but whatever.
+ im = self.icns.getimage(self.best_size)
+
+ # If this is a PNG or JPEG 2000, it won't be loaded yet
+ px = im.load()
+
+ self.im = im.im
+ self._mode = im.mode
+ self.size = im.size
+
+ return px
+
+
+def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
+ """
+ Saves the image as a series of PNG files,
+ that are then combined into a .icns file.
+ """
+ if hasattr(fp, "flush"):
+ fp.flush()
+
+ sizes = {
+ b"ic07": 128,
+ b"ic08": 256,
+ b"ic09": 512,
+ b"ic10": 1024,
+ b"ic11": 32,
+ b"ic12": 64,
+ b"ic13": 256,
+ b"ic14": 512,
+ }
+ provided_images = {im.width: im for im in im.encoderinfo.get("append_images", [])}
+ size_streams = {}
+ for size in set(sizes.values()):
+ image = (
+ provided_images[size]
+ if size in provided_images
+ else im.resize((size, size))
+ )
+
+ temp = io.BytesIO()
+ image.save(temp, "png")
+ size_streams[size] = temp.getvalue()
+
+ entries = []
+ for type, size in sizes.items():
+ stream = size_streams[size]
+ entries.append((type, HEADERSIZE + len(stream), stream))
+
+ # Header
+ fp.write(MAGIC)
+ file_length = HEADERSIZE # Header
+ file_length += HEADERSIZE + 8 * len(entries) # TOC
+ file_length += sum(entry[1] for entry in entries)
+ fp.write(struct.pack(">i", file_length))
+
+ # TOC
+ fp.write(b"TOC ")
+ fp.write(struct.pack(">i", HEADERSIZE + len(entries) * HEADERSIZE))
+ for entry in entries:
+ fp.write(entry[0])
+ fp.write(struct.pack(">i", entry[1]))
+
+ # Data
+ for entry in entries:
+ fp.write(entry[0])
+ fp.write(struct.pack(">i", entry[1]))
+ fp.write(entry[2])
+
+ if hasattr(fp, "flush"):
+ fp.flush()
+
+
+def _accept(prefix: bytes) -> bool:
+ return prefix[:4] == MAGIC
+
+
+Image.register_open(IcnsImageFile.format, IcnsImageFile, _accept)
+Image.register_extension(IcnsImageFile.format, ".icns")
+
+Image.register_save(IcnsImageFile.format, _save)
+Image.register_mime(IcnsImageFile.format, "image/icns")
+
+if __name__ == "__main__":
+ if len(sys.argv) < 2:
+ print("Syntax: python3 IcnsImagePlugin.py [file]")
+ sys.exit()
+
+ with open(sys.argv[1], "rb") as fp:
+ imf = IcnsImageFile(fp)
+ for size in imf.info["sizes"]:
+ width, height, scale = imf.size = size
+ imf.save(f"out-{width}-{height}-{scale}.png")
+ with Image.open(sys.argv[1]) as im:
+ im.save("out.png")
+ if sys.platform == "windows":
+ os.startfile("out.png")
generated by cgit v1.2.3 (git 2.47.1) at 2025-07-27 10:13:29 +0000