text: #
  # 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.
  #
  
  import io
  import logging
  
  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):
      return 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):
  
          # header
          s = self.fp.read(128)
          if not _accept(s):
              raise SyntaxError("not a PCX file")
  
          # 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]:
              raise SyntaxError("bad PCX image size")
          logger.debug("BBox: %s %s %s %s", *bbox)
  
          # 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 = "P;%dL" % planes
              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 greyscale
                  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:])
              self.fp.seek(128)
  
          elif version == 5 and bits == 8 and planes == 3:
              mode = "RGB"
              rawmode = "RGB;L"
  
          else:
              raise OSError("unknown PCX mode")
  
          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 = [("pcx", bbox, self.fp.tell(), (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, fp, filename):
  
      try:
          version, bits, planes, rawmode = SAVE[im.mode]
      except KeyError as e:
          raise ValueError(f"Cannot save {im.mode} images as PCX") 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, [("pcx", (0, 0) + im.size, 0, (rawmode, bits * planes))])
  
      if im.mode == "P":
          # colour palette
          fp.write(o8(12))
          fp.write(im.im.getpalette("RGB", "RGB"))  # 768 bytes
      elif im.mode == "L":
          # greyscale 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")
  