263 lines
6.8 KiB
Python
263 lines
6.8 KiB
Python
#
|
|
# The Python Imaging Library.
|
|
# $Id$
|
|
#
|
|
# TGA file handling
|
|
#
|
|
# History:
|
|
# 95-09-01 fl created (reads 24-bit files only)
|
|
# 97-01-04 fl support more TGA versions, including compressed images
|
|
# 98-07-04 fl fixed orientation and alpha layer bugs
|
|
# 98-09-11 fl fixed orientation for runlength decoder
|
|
#
|
|
# Copyright (c) Secret Labs AB 1997-98.
|
|
# Copyright (c) Fredrik Lundh 1995-97.
|
|
#
|
|
# See the README file for information on usage and redistribution.
|
|
#
|
|
from __future__ import annotations
|
|
|
|
import warnings
|
|
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
|
|
|
|
#
|
|
# --------------------------------------------------------------------
|
|
# Read RGA file
|
|
|
|
|
|
MODES = {
|
|
# map imagetype/depth to rawmode
|
|
(1, 8): "P",
|
|
(3, 1): "1",
|
|
(3, 8): "L",
|
|
(3, 16): "LA",
|
|
(2, 16): "BGRA;15Z",
|
|
(2, 24): "BGR",
|
|
(2, 32): "BGRA",
|
|
}
|
|
|
|
|
|
##
|
|
# Image plugin for Targa files.
|
|
|
|
|
|
class TgaImageFile(ImageFile.ImageFile):
|
|
format = "TGA"
|
|
format_description = "Targa"
|
|
|
|
def _open(self) -> None:
|
|
# process header
|
|
assert self.fp is not None
|
|
|
|
s = self.fp.read(18)
|
|
|
|
id_len = s[0]
|
|
|
|
colormaptype = s[1]
|
|
imagetype = s[2]
|
|
|
|
depth = s[16]
|
|
|
|
flags = s[17]
|
|
|
|
self._size = i16(s, 12), i16(s, 14)
|
|
|
|
# validate header fields
|
|
if (
|
|
colormaptype not in (0, 1)
|
|
or self.size[0] <= 0
|
|
or self.size[1] <= 0
|
|
or depth not in (1, 8, 16, 24, 32)
|
|
):
|
|
msg = "not a TGA file"
|
|
raise SyntaxError(msg)
|
|
|
|
# image mode
|
|
if imagetype in (3, 11):
|
|
self._mode = "L"
|
|
if depth == 1:
|
|
self._mode = "1" # ???
|
|
elif depth == 16:
|
|
self._mode = "LA"
|
|
elif imagetype in (1, 9):
|
|
self._mode = "P" if colormaptype else "L"
|
|
elif imagetype in (2, 10):
|
|
self._mode = "RGB" if depth == 24 else "RGBA"
|
|
else:
|
|
msg = "unknown TGA mode"
|
|
raise SyntaxError(msg)
|
|
|
|
# orientation
|
|
orientation = flags & 0x30
|
|
self._flip_horizontally = orientation in [0x10, 0x30]
|
|
if orientation in [0x20, 0x30]:
|
|
orientation = 1
|
|
elif orientation in [0, 0x10]:
|
|
orientation = -1
|
|
else:
|
|
msg = "unknown TGA orientation"
|
|
raise SyntaxError(msg)
|
|
|
|
self.info["orientation"] = orientation
|
|
|
|
if imagetype & 8:
|
|
self.info["compression"] = "tga_rle"
|
|
|
|
if id_len:
|
|
self.info["id_section"] = self.fp.read(id_len)
|
|
|
|
if colormaptype:
|
|
# read palette
|
|
start, size, mapdepth = i16(s, 3), i16(s, 5), s[7]
|
|
if mapdepth == 16:
|
|
self.palette = ImagePalette.raw(
|
|
"BGRA;15Z", bytes(2 * start) + self.fp.read(2 * size)
|
|
)
|
|
self.palette.mode = "RGBA"
|
|
elif mapdepth == 24:
|
|
self.palette = ImagePalette.raw(
|
|
"BGR", bytes(3 * start) + self.fp.read(3 * size)
|
|
)
|
|
elif mapdepth == 32:
|
|
self.palette = ImagePalette.raw(
|
|
"BGRA", bytes(4 * start) + self.fp.read(4 * size)
|
|
)
|
|
else:
|
|
msg = "unknown TGA map depth"
|
|
raise SyntaxError(msg)
|
|
|
|
# setup tile descriptor
|
|
try:
|
|
rawmode = MODES[(imagetype & 7, depth)]
|
|
if imagetype & 8:
|
|
# compressed
|
|
self.tile = [
|
|
(
|
|
"tga_rle",
|
|
(0, 0) + self.size,
|
|
self.fp.tell(),
|
|
(rawmode, orientation, depth),
|
|
)
|
|
]
|
|
else:
|
|
self.tile = [
|
|
(
|
|
"raw",
|
|
(0, 0) + self.size,
|
|
self.fp.tell(),
|
|
(rawmode, 0, orientation),
|
|
)
|
|
]
|
|
except KeyError:
|
|
pass # cannot decode
|
|
|
|
def load_end(self) -> None:
|
|
if self._flip_horizontally:
|
|
assert self.im is not None
|
|
self.im = self.im.transpose(Image.Transpose.FLIP_LEFT_RIGHT)
|
|
|
|
|
|
#
|
|
# --------------------------------------------------------------------
|
|
# Write TGA file
|
|
|
|
|
|
SAVE = {
|
|
"1": ("1", 1, 0, 3),
|
|
"L": ("L", 8, 0, 3),
|
|
"LA": ("LA", 16, 0, 3),
|
|
"P": ("P", 8, 1, 1),
|
|
"RGB": ("BGR", 24, 0, 2),
|
|
"RGBA": ("BGRA", 32, 0, 2),
|
|
}
|
|
|
|
|
|
def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None:
|
|
try:
|
|
rawmode, bits, colormaptype, imagetype = SAVE[im.mode]
|
|
except KeyError as e:
|
|
msg = f"cannot write mode {im.mode} as TGA"
|
|
raise OSError(msg) from e
|
|
|
|
if "rle" in im.encoderinfo:
|
|
rle = im.encoderinfo["rle"]
|
|
else:
|
|
compression = im.encoderinfo.get("compression", im.info.get("compression"))
|
|
rle = compression == "tga_rle"
|
|
if rle:
|
|
imagetype += 8
|
|
|
|
id_section = im.encoderinfo.get("id_section", im.info.get("id_section", ""))
|
|
id_len = len(id_section)
|
|
if id_len > 255:
|
|
id_len = 255
|
|
id_section = id_section[:255]
|
|
warnings.warn("id_section has been trimmed to 255 characters")
|
|
|
|
if colormaptype:
|
|
assert im.im is not None
|
|
palette = im.im.getpalette("RGB", "BGR")
|
|
colormaplength, colormapentry = len(palette) // 3, 24
|
|
else:
|
|
colormaplength, colormapentry = 0, 0
|
|
|
|
if im.mode in ("LA", "RGBA"):
|
|
flags = 8
|
|
else:
|
|
flags = 0
|
|
|
|
orientation = im.encoderinfo.get("orientation", im.info.get("orientation", -1))
|
|
if orientation > 0:
|
|
flags = flags | 0x20
|
|
|
|
fp.write(
|
|
o8(id_len)
|
|
+ o8(colormaptype)
|
|
+ o8(imagetype)
|
|
+ o16(0) # colormapfirst
|
|
+ o16(colormaplength)
|
|
+ o8(colormapentry)
|
|
+ o16(0)
|
|
+ o16(0)
|
|
+ o16(im.size[0])
|
|
+ o16(im.size[1])
|
|
+ o8(bits)
|
|
+ o8(flags)
|
|
)
|
|
|
|
if id_section:
|
|
fp.write(id_section)
|
|
|
|
if colormaptype:
|
|
fp.write(palette)
|
|
|
|
if rle:
|
|
ImageFile._save(
|
|
im, fp, [("tga_rle", (0, 0) + im.size, 0, (rawmode, orientation))]
|
|
)
|
|
else:
|
|
ImageFile._save(
|
|
im, fp, [("raw", (0, 0) + im.size, 0, (rawmode, 0, orientation))]
|
|
)
|
|
|
|
# write targa version 2 footer
|
|
fp.write(b"\000" * 8 + b"TRUEVISION-XFILE." + b"\000")
|
|
|
|
|
|
#
|
|
# --------------------------------------------------------------------
|
|
# Registry
|
|
|
|
|
|
Image.register_open(TgaImageFile.format, TgaImageFile)
|
|
Image.register_save(TgaImageFile.format, _save)
|
|
|
|
Image.register_extensions(TgaImageFile.format, [".tga", ".icb", ".vda", ".vst"])
|
|
|
|
Image.register_mime(TgaImageFile.format, "image/x-tga")
|