@ai-ecoverse/py-pillow 12.3.0-2

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

@@ -0,0 +1,232 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# PCX file handling
+#
+# This format was originally used by ZSoft's popular PaintBrush
+# program for the IBM PC.  It is also supported by many MS-DOS and
+# Windows applications, including the Windows PaintBrush program in
+# Windows 3.
+#
+# history:
+# 1995-09-01 fl   Created
+# 1996-05-20 fl   Fixed RGB support
+# 1997-01-03 fl   Fixed 2-bit and 4-bit support
+# 1999-02-03 fl   Fixed 8-bit support (broken in 1.0b1)
+# 1999-02-07 fl   Added write support
+# 2002-06-09 fl   Made 2-bit and 4-bit support a bit more robust
+# 2002-07-30 fl   Seek from to current position, not beginning of file
+# 2003-06-03 fl   Extract DPI settings (info["dpi"])
+#
+# Copyright (c) 1997-2003 by Secret Labs AB.
+# Copyright (c) 1995-2003 by Fredrik Lundh.
+#
+# See the README file for information on usage and redistribution.
+#
+from __future__ import annotations
+
+import io
+import logging
+from typing import IO
+
+from . import Image, ImageFile, ImagePalette
+from ._binary import i16le as i16
+from ._binary import o8
+from ._binary import o16le as o16
+
+logger = logging.getLogger(__name__)
+
+
+def _accept(prefix: bytes) -> bool:
+    return len(prefix) >= 2 and prefix[0] == 10 and prefix[1] in [0, 2, 3, 5]
+
+
+##
+# Image plugin for Paintbrush images.
+
+
+class PcxImageFile(ImageFile.ImageFile):
+    format = "PCX"
+    format_description = "Paintbrush"
+
+    def _open(self) -> None:
+        # header
+        assert self.fp is not None
+
+        s = self.fp.read(68)
+        if not _accept(s):
+            msg = "not a PCX file"
+            raise SyntaxError(msg)
+
+        # image
+        bbox = i16(s, 4), i16(s, 6), i16(s, 8) + 1, i16(s, 10) + 1
+        if bbox[2] <= bbox[0] or bbox[3] <= bbox[1]:
+            msg = "bad PCX image size"
+            raise SyntaxError(msg)
+        logger.debug("BBox: %s %s %s %s", *bbox)
+
+        offset = self.fp.tell() + 60
+
+        # format
+        version = s[1]
+        bits = s[3]
+        planes = s[65]
+        provided_stride = i16(s, 66)
+        logger.debug(
+            "PCX version %s, bits %s, planes %s, stride %s",
+            version,
+            bits,
+            planes,
+            provided_stride,
+        )
+
+        self.info["dpi"] = i16(s, 12), i16(s, 14)
+
+        if bits == 1 and planes == 1:
+            mode = rawmode = "1"
+
+        elif bits == 1 and planes in (2, 4):
+            mode = "P"
+            rawmode = f"P;{planes}L"
+            self.palette = ImagePalette.raw("RGB", s[16:64])
+
+        elif version == 5 and bits == 8 and planes == 1:
+            mode = rawmode = "L"
+            # FIXME: hey, this doesn't work with the incremental loader !!!
+            self.fp.seek(-769, io.SEEK_END)
+            s = self.fp.read(769)
+            if len(s) == 769 and s[0] == 12:
+                # check if the palette is linear grayscale
+                for i in range(256):
+                    if s[i * 3 + 1 : i * 3 + 4] != o8(i) * 3:
+                        mode = rawmode = "P"
+                        break
+                if mode == "P":
+                    self.palette = ImagePalette.raw("RGB", s[1:])
+
+        elif version == 5 and bits == 8 and planes == 3:
+            mode = "RGB"
+            rawmode = "RGB;L"
+
+        else:
+            msg = "unknown PCX mode"
+            raise OSError(msg)
+
+        self._mode = mode
+        self._size = bbox[2] - bbox[0], bbox[3] - bbox[1]
+
+        # Don't trust the passed in stride.
+        # Calculate the approximate position for ourselves.
+        # CVE-2020-35653
+        stride = (self._size[0] * bits + 7) // 8
+
+        # While the specification states that this must be even,
+        # not all images follow this
+        if provided_stride != stride:
+            stride += stride % 2
+
+        bbox = (0, 0) + self.size
+        logger.debug("size: %sx%s", *self.size)
+
+        self.tile = [ImageFile._Tile("pcx", bbox, offset, (rawmode, planes * stride))]
+
+
+# --------------------------------------------------------------------
+# save PCX files
+
+
+SAVE = {
+    # mode: (version, bits, planes, raw mode)
+    "1": (2, 1, 1, "1"),
+    "L": (5, 8, 1, "L"),
+    "P": (5, 8, 1, "P"),
+    "RGB": (5, 8, 3, "RGB;L"),
+}
+
+
+def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
+    if im.width == 0 or im.height == 0:
+        msg = "Cannot write empty image as PCX"
+        raise ValueError(msg)
+
+    try:
+        version, bits, planes, rawmode = SAVE[im.mode]
+    except KeyError as e:
+        msg = f"Cannot save {im.mode} images as PCX"
+        raise ValueError(msg) from e
+
+    # bytes per plane
+    stride = (im.size[0] * bits + 7) // 8
+    # stride should be even
+    stride += stride % 2
+    # Stride needs to be kept in sync with the PcxEncode.c version.
+    # Ideally it should be passed in in the state, but the bytes value
+    # gets overwritten.
+
+    logger.debug(
+        "PcxImagePlugin._save: xwidth: %d, bits: %d, stride: %d",
+        im.size[0],
+        bits,
+        stride,
+    )
+
+    # under windows, we could determine the current screen size with
+    # "Image.core.display_mode()[1]", but I think that's overkill...
+
+    screen = im.size
+
+    dpi = 100, 100
+
+    # PCX header
+    fp.write(
+        o8(10)
+        + o8(version)
+        + o8(1)
+        + o8(bits)
+        + o16(0)
+        + o16(0)
+        + o16(im.size[0] - 1)
+        + o16(im.size[1] - 1)
+        + o16(dpi[0])
+        + o16(dpi[1])
+        + b"\0" * 24
+        + b"\xff" * 24
+        + b"\0"
+        + o8(planes)
+        + o16(stride)
+        + o16(1)
+        + o16(screen[0])
+        + o16(screen[1])
+        + b"\0" * 54
+    )
+
+    assert fp.tell() == 128
+
+    ImageFile._save(
+        im, fp, [ImageFile._Tile("pcx", (0, 0) + im.size, 0, (rawmode, bits * planes))]
+    )
+
+    if im.mode == "P":
+        # colour palette
+        fp.write(o8(12))
+        palette = im.im.getpalette("RGB", "RGB")
+        palette += b"\x00" * (768 - len(palette))
+        fp.write(palette)  # 768 bytes
+    elif im.mode == "L":
+        # grayscale palette
+        fp.write(o8(12))
+        for i in range(256):
+            fp.write(o8(i) * 3)
+
+
+# --------------------------------------------------------------------
+# registry
+
+
+Image.register_open(PcxImageFile.format, PcxImageFile, _accept)
+Image.register_save(PcxImageFile.format, _save)
+
+Image.register_extension(PcxImageFile.format, ".pcx")
+
+Image.register_mime(PcxImageFile.format, "image/x-pcx")

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

@@ -0,0 +1,315 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# PDF (Acrobat) file handling
+#
+# History:
+# 1996-07-16 fl   Created
+# 1997-01-18 fl   Fixed header
+# 2004-02-21 fl   Fixes for 1/L/CMYK images, etc.
+# 2004-02-24 fl   Fixes for 1 and P images.
+#
+# Copyright (c) 1997-2004 by Secret Labs AB.  All rights reserved.
+# Copyright (c) 1996-1997 by Fredrik Lundh.
+#
+# See the README file for information on usage and redistribution.
+#
+
+##
+# Image plugin for PDF images (output only).
+##
+from __future__ import annotations
+
+import io
+import math
+import os
+import time
+from typing import IO, Any
+
+from . import Image, ImageFile, ImageSequence, PdfParser, features
+
+#
+# --------------------------------------------------------------------
+
+# object ids:
+#  1. catalogue
+#  2. pages
+#  3. image
+#  4. page
+#  5. page contents
+
+
+def _save_all(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
+    _save(im, fp, filename, save_all=True)
+
+
+##
+# (Internal) Image save plugin for the PDF format.
+
+
+def _write_image(
+    im: Image.Image,
+    filename: str | bytes,
+    existing_pdf: PdfParser.PdfParser,
+    image_refs: list[PdfParser.IndirectReference],
+) -> tuple[PdfParser.IndirectReference, str]:
+    # FIXME: Should replace ASCIIHexDecode with RunLengthDecode
+    # (packbits) or LZWDecode (tiff/lzw compression).  Note that
+    # PDF 1.2 also supports Flatedecode (zip compression).
+
+    params = None
+    decode = None
+
+    #
+    # Get image characteristics
+
+    width, height = im.size
+
+    dict_obj: dict[str, Any] = {"BitsPerComponent": 8}
+    if im.mode == "1":
+        if features.check("libtiff"):
+            decode_filter = "CCITTFaxDecode"
+            dict_obj["BitsPerComponent"] = 1
+            params = PdfParser.PdfArray(
+                [
+                    PdfParser.PdfDict(
+                        {
+                            "K": -1,
+                            "BlackIs1": True,
+                            "Columns": width,
+                            "Rows": height,
+                        }
+                    )
+                ]
+            )
+        else:
+            decode_filter = "DCTDecode"
+        dict_obj["ColorSpace"] = PdfParser.PdfName("DeviceGray")
+        procset = "ImageB"  # grayscale
+    elif im.mode == "L":
+        decode_filter = "DCTDecode"
+        # params = f"<< /Predictor 15 /Columns {width-2} >>"
+        dict_obj["ColorSpace"] = PdfParser.PdfName("DeviceGray")
+        procset = "ImageB"  # grayscale
+    elif im.mode == "LA":
+        decode_filter = "JPXDecode"
+        # params = f"<< /Predictor 15 /Columns {width-2} >>"
+        procset = "ImageB"  # grayscale
+        dict_obj["SMaskInData"] = 1
+    elif im.mode == "P":
+        decode_filter = "ASCIIHexDecode"
+        palette = im.getpalette()
+        assert palette is not None
+        dict_obj["ColorSpace"] = [
+            PdfParser.PdfName("Indexed"),
+            PdfParser.PdfName("DeviceRGB"),
+            len(palette) // 3 - 1,
+            PdfParser.PdfBinary(palette),
+        ]
+        procset = "ImageI"  # indexed color
+
+        if "transparency" in im.info:
+            smask = im.convert("LA").getchannel("A")
+            smask.encoderinfo = {}
+
+            image_ref = _write_image(smask, filename, existing_pdf, image_refs)[0]
+            dict_obj["SMask"] = image_ref
+    elif im.mode == "RGB":
+        decode_filter = "DCTDecode"
+        dict_obj["ColorSpace"] = PdfParser.PdfName("DeviceRGB")
+        procset = "ImageC"  # color images
+    elif im.mode == "RGBA":
+        decode_filter = "JPXDecode"
+        procset = "ImageC"  # color images
+        dict_obj["SMaskInData"] = 1
+    elif im.mode == "CMYK":
+        decode_filter = "DCTDecode"
+        dict_obj["ColorSpace"] = PdfParser.PdfName("DeviceCMYK")
+        procset = "ImageC"  # color images
+        decode = [1, 0, 1, 0, 1, 0, 1, 0]
+    else:
+        msg = f"cannot save mode {im.mode}"
+        raise ValueError(msg)
+
+    #
+    # image
+
+    op = io.BytesIO()
+
+    if decode_filter == "ASCIIHexDecode":
+        ImageFile._save(im, op, [ImageFile._Tile("hex", (0, 0) + im.size, 0, im.mode)])
+    elif decode_filter == "CCITTFaxDecode":
+        im.save(
+            op,
+            "TIFF",
+            compression="group4",
+            # use a single strip
+            strip_size=math.ceil(width / 8) * height,
+        )
+    elif decode_filter == "DCTDecode":
+        from . import JpegImagePlugin
+
+        JpegImagePlugin._save(im, op, filename)
+    elif decode_filter == "JPXDecode":
+        from . import Jpeg2KImagePlugin
+
+        del dict_obj["BitsPerComponent"]
+        Jpeg2KImagePlugin._save(im, op, filename)
+    else:
+        msg = f"unsupported PDF filter ({decode_filter})"
+        raise ValueError(msg)
+
+    stream = op.getvalue()
+    filter: PdfParser.PdfArray | PdfParser.PdfName
+    if decode_filter == "CCITTFaxDecode":
+        stream = stream[8:]
+        filter = PdfParser.PdfArray([PdfParser.PdfName(decode_filter)])
+    else:
+        filter = PdfParser.PdfName(decode_filter)
+
+    image_ref = image_refs.pop(0)
+    existing_pdf.write_obj(
+        image_ref,
+        stream=stream,
+        Type=PdfParser.PdfName("XObject"),
+        Subtype=PdfParser.PdfName("Image"),
+        Width=width,  # * 72.0 / x_resolution,
+        Height=height,  # * 72.0 / y_resolution,
+        Filter=filter,
+        Decode=decode,
+        DecodeParms=params,
+        **dict_obj,
+    )
+
+    return image_ref, procset
+
+
+def _save(
+    im: Image.Image, fp: IO[bytes], filename: str | bytes, save_all: bool = False
+) -> None:
+    is_appending = im.encoderinfo.get("append", False)
+    filename_str = filename.decode() if isinstance(filename, bytes) else filename
+    if is_appending:
+        existing_pdf = PdfParser.PdfParser(f=fp, filename=filename_str, mode="r+b")
+    else:
+        existing_pdf = PdfParser.PdfParser(f=fp, filename=filename_str, mode="w+b")
+
+    dpi = im.encoderinfo.get("dpi")
+    if dpi:
+        x_resolution = dpi[0]
+        y_resolution = dpi[1]
+    else:
+        x_resolution = y_resolution = im.encoderinfo.get("resolution", 72.0)
+
+    info = {
+        "title": (
+            None if is_appending else os.path.splitext(os.path.basename(filename))[0]
+        ),
+        "author": None,
+        "subject": None,
+        "keywords": None,
+        "creator": None,
+        "producer": None,
+        "creationDate": None if is_appending else time.gmtime(),
+        "modDate": None if is_appending else time.gmtime(),
+    }
+    for k, default in info.items():
+        v = im.encoderinfo.get(k) if k in im.encoderinfo else default
+        if v:
+            existing_pdf.info[k[0].upper() + k[1:]] = v
+
+    #
+    # make sure image data is available
+    im.load()
+
+    existing_pdf.start_writing()
+    existing_pdf.write_header()
+    existing_pdf.write_comment("created by Pillow PDF driver")
+
+    #
+    # pages
+    ims = [im]
+    if save_all:
+        append_images = im.encoderinfo.get("append_images", [])
+        for append_im in append_images:
+            append_im.encoderinfo = im.encoderinfo.copy()
+            ims.append(append_im)
+    number_of_pages = 0
+    image_refs = []
+    page_refs = []
+    contents_refs = []
+    for im in ims:
+        im_number_of_pages = 1
+        if save_all:
+            im_number_of_pages = getattr(im, "n_frames", 1)
+        number_of_pages += im_number_of_pages
+        for i in range(im_number_of_pages):
+            image_refs.append(existing_pdf.next_object_id(0))
+            if im.mode == "P" and "transparency" in im.info:
+                image_refs.append(existing_pdf.next_object_id(0))
+
+            page_refs.append(existing_pdf.next_object_id(0))
+            contents_refs.append(existing_pdf.next_object_id(0))
+            existing_pdf.pages.append(page_refs[-1])
+
+    #
+    # catalog and list of pages
+    existing_pdf.write_catalog()
+
+    page_number = 0
+    for im_sequence in ims:
+        im_pages: ImageSequence.Iterator | list[Image.Image] = (
+            ImageSequence.Iterator(im_sequence) if save_all else [im_sequence]
+        )
+        for im in im_pages:
+            image_ref, procset = _write_image(im, filename, existing_pdf, image_refs)
+
+            #
+            # page
+
+            existing_pdf.write_page(
+                page_refs[page_number],
+                Resources=PdfParser.PdfDict(
+                    ProcSet=[PdfParser.PdfName("PDF"), PdfParser.PdfName(procset)],
+                    XObject=PdfParser.PdfDict(image=image_ref),
+                ),
+                MediaBox=[
+                    0,
+                    0,
+                    im.width * 72.0 / x_resolution,
+                    im.height * 72.0 / y_resolution,
+                ],
+                Contents=contents_refs[page_number],
+            )
+
+            #
+            # page contents
+
+            page_contents = b"q %f 0 0 %f 0 0 cm /image Do Q\n" % (
+                im.width * 72.0 / x_resolution,
+                im.height * 72.0 / y_resolution,
+            )
+
+            existing_pdf.write_obj(contents_refs[page_number], stream=page_contents)
+
+            page_number += 1
+
+    #
+    # trailer
+    existing_pdf.write_xref_and_trailer()
+    if hasattr(fp, "flush"):
+        fp.flush()
+    existing_pdf.close()
+
+
+#
+# --------------------------------------------------------------------
+
+
+Image.register_save("PDF", _save)
+Image.register_save_all("PDF", _save_all)
+
+Image.register_extension("PDF", ".pdf")
+
+Image.register_mime("PDF", "application/pdf")