python-pillow/Pillow
1
1
Fork 0
mirror of https://github.com/python-pillow/Pillow.git synced 2025-02-05 14:10:52 +03:00
Code Issues Packages Projects Releases Wiki Activity

blp: Separate BLP1 and BLP2 decoding more cleanly

Browse Source
This commit is contained in:
Jerome Leclanche 2018-02-18 04:56:13 +02:00
parent fcba3583c3
commit 73d7fff16e
3 changed files with 104 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

0
Tests/images/blp2_dxt1.blp → Tests/images/blp/blp2_dxt1.blp
View File

0
Tests/images/blp2_dxt1.png → Tests/images/blp/blp2_dxt1.png
View File

Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 761 B

After

Width:  |  Height:  |  Size: 761 B

231
src/PIL/BlpImagePlugin.py
View File

@ -234,20 +234,6 @@ def decode_dxt5(data):
return ret return ret
def getpalette(data):
"""
Helper to transform a BytesIO object into a palette
"""
palette = []
string = BytesIO(data)
while True:
try:
palette.append(struct.unpack("<4B", string.read(4)))
except struct.error:
break
return palette
class BLPFormatError(NotImplementedError): class BLPFormatError(NotImplementedError):
pass pass
@ -259,24 +245,83 @@ class BlpImageFile(ImageFile.ImageFile):
format = "BLP" format = "BLP"
format_description = "Blizzard Mipmap Format" format_description = "Blizzard Mipmap Format"
def _decode_blp1(self): def _open(self):
header = BytesIO(self.fp.read(28 + 16 * 4 + 16 * 4)) self.tile = []
self.magic = self.fp.read(4)
self._read_blp_header()
magic, compression = struct.unpack("<4si", header.read(8)) if self.magic == b"BLP1":
encoding, alpha_depth, alpha_encoding, has_mips = struct.unpack( self._open_blp1()
"<4b", header.read(4) elif self.magic == b"BLP2":
self._open_blp2()
else:
raise BLPFormatError("Bad BLP magic %r" % (self.magic))
def _read_palette(self):
ret = []
for i in range(256):
try:
b, g, r, a = struct.unpack("<4B", self.fp.read(4))
except struct.error:
break
ret.append((b, g, r, a))
return ret
def _read_blp_header(self):
self._blp_compression, = struct.unpack("<i", self.fp.read(4))
self._blp_encoding, = struct.unpack("<b", self.fp.read(1))
self._blp_alpha_depth, = struct.unpack("<b", self.fp.read(1))
self._blp_alpha_encoding, = struct.unpack("<b", self.fp.read(1))
self._blp_mips, = struct.unpack("<b", self.fp.read(1))
self.size = struct.unpack("<II", self.fp.read(8))
if self.magic == b"BLP1":
# Only present for BLP1
self._blp_encoding, = struct.unpack("<i", self.fp.read(4))
self._blp_subtype, = struct.unpack("<i", self.fp.read(4))
self._blp_offsets = struct.unpack("<16I", self.fp.read(16 * 4))
self._blp_lengths = struct.unpack("<16I", self.fp.read(16 * 4))
def _open_blp1(self):
self.mode = "RGB"
if self._blp_compression == BLP_FORMAT_JPEG:
self._decode_jpeg_stream()
elif self._blp_compression == 1:
if self._blp_encoding in (4, 5):
data = bytearray()
palette = self._read_palette()
_data = BytesIO(self.fp.read(self._blp_lengths[0]))
while True:
try:
offset, = struct.unpack("<B", _data.read(1))
except struct.error:
break
b, g, r, a = palette[offset]
data.extend([r, g, b])
self.im = Image.core.new(self.mode, self.size)
self.frombytes(bytes(data))
else:
raise BLPFormatError(
"Unsupported BLP encoding %r" % (self._blp_encoding)
)
else:
raise BLPFormatError(
"Unsupported BLP compression %r" % (self._blp_encoding)
) )
self.size = struct.unpack("<II", header.read(8))
encoding, subtype = struct.unpack("<ii", header.read(8))
offsets = struct.unpack("<16I", header.read(16 * 4))
lengths = struct.unpack("<16I", header.read(16 * 4))
if compression == BLP_FORMAT_JPEG: def _decode_jpeg_stream(self):
from PIL.JpegImagePlugin import JpegImageFile from PIL.JpegImagePlugin import JpegImageFile
jpeg_header_size, = struct.unpack("<I", self.fp.read(4)) jpeg_header_size, = struct.unpack("<I", self.fp.read(4))
jpeg_header = self.fp.read(jpeg_header_size) jpeg_header = self.fp.read(jpeg_header_size)
self.fp.read(offsets[0] - self.fp.tell()) # What IS this? self.fp.read(self._blp_offsets[0] - self.fp.tell()) # What IS this?
data = self.fp.read(lengths[0]) data = self.fp.read(self._blp_lengths[0])
data = jpeg_header + data data = jpeg_header + data
data = BytesIO(data) data = BytesIO(data)
image = JpegImageFile(data) image = JpegImageFile(data)
@ -285,118 +330,66 @@ class BlpImageFile(ImageFile.ImageFile):
self.fp = image.fp self.fp = image.fp
self.mode = image.mode self.mode = image.mode
elif compression == 1: def _open_blp2(self):
if encoding == 5: palette = self._read_palette()
data = []
palette_data = self.fp.read(256 * 4)
palette = getpalette(palette_data)
_data = BytesIO(self.fp.read(lengths[0]))
self.mode = "RGB"
self.tile = []
while True:
try:
offset, = struct.unpack("<B", _data.read(1))
except struct.error:
break
b, g, r, a = palette[offset]
data.append(struct.pack("<BBB", r, g, b))
data = b"".join(data) self.mode = "RGBA" if self._blp_alpha_depth else "RGB"
self.im = Image.core.new(self.mode, self.size) data = bytearray()
self.frombytes(data) self.fp.seek(self._blp_offsets[0])
else:
raise BLPFormatError(
"Unknown or unsupported BLP encoding %r" % (encoding)
)
else:
raise BLPFormatError(
"Unknown or unsupported BLP compression %r" % (encoding)
)
def _decode_blp2(self): if self._blp_compression == 1:
header = BytesIO(self.fp.read(20 + 16 * 4 + 16 * 4))
magic, compression = struct.unpack("<4si", header.read(8))
encoding, alpha_depth, alpha_encoding, has_mips = struct.unpack(
"<4b", header.read(4)
)
self.size = struct.unpack("<II", header.read(8))
offsets = struct.unpack("<16I", header.read(16 * 4))
lengths = struct.unpack("<16I", header.read(16 * 4))
palette_data = self.fp.read(256 * 4)
self.mode = "RGB"
self.tile = []
if compression == 1:
# Uncompressed or DirectX compression # Uncompressed or DirectX compression
data = []
self.fp.seek(offsets[0])
if encoding == BLP_ENCODING_UNCOMPRESSED: if self._blp_encoding == BLP_ENCODING_UNCOMPRESSED:
palette = getpalette(palette_data) _data = BytesIO(self.fp.read(self._blp_lengths[0]))
_data = BytesIO(self.fp.read(lengths[0]))
while True: while True:
try: try:
offset, = struct.unpack("<B", _data.read(1)) offset, = struct.unpack("<B", _data.read(1))
except struct.error: except struct.error:
break break
b, g, r, a = palette[offset] b, g, r, a = palette[offset]
data.append(struct.pack("<BBB", r, g, b)) data.extend((r, g, b))
elif encoding == BLP_ENCODING_DXT: elif self._blp_encoding == BLP_ENCODING_DXT:
if alpha_encoding == BLP_ALPHA_ENCODING_DXT1: if self._blp_alpha_encoding == BLP_ALPHA_ENCODING_DXT1:
linesize = (self.size[0] + 3) // 4 * 8 linesize = (self.size[0] + 3) // 4 * 8
for yb in range((self.size[1] + 3) // 4): for yb in range((self.size[1] + 3) // 4):
line_data = self.fp.read(linesize) for d in decode_dxt1(
if alpha_depth: self.fp.read(linesize),
self.mode = "RGBA" alpha=bool(self._blp_alpha_depth)
decoded = decode_dxt1(line_data, alpha=True) ):
data += d
elif self._blp_alpha_encoding == BLP_ALPHA_ENCODING_DXT3:
linesize = (self.size[0] + 3) // 4 * 16
for yb in range((self.size[1] + 3) // 4):
for d in decode_dxt3(self.fp.read(linesize)):
data += d
elif self._blp_alpha_encoding == BLP_ALPHA_ENCODING_DXT5:
linesize = (self.size[0] + 3) // 4 * 16
for yb in range((self.size[1] + 3) // 4):
for d in decode_dxt5(self.fp.read(linesize)):
data += d
else: else:
decoded = decode_dxt1(line_data) raise BLPFormatError("Unsupported alpha encoding %r" % (
for d in decoded: self._blp_alpha_encoding
data.append(d) ))
elif alpha_encoding == BLP_ALPHA_ENCODING_DXT3:
linesize = (self.size[0] + 3) // 4 * 16
self.mode = "RGBA"
for yb in range((self.size[1] + 3) // 4):
decoded = decode_dxt3(self.fp.read(linesize))
for d in decoded:
data.append(d)
elif alpha_encoding == BLP_ALPHA_ENCODING_DXT5:
linesize = (self.size[0] + 3) // 4 * 16
self.mode = "RGBA"
for yb in range((self.size[1] + 3) // 4):
decoded = decode_dxt5(self.fp.read(linesize))
for d in decoded:
data.append(d)
else: else:
raise BLPFormatError( raise BLPFormatError(
"Unsupported alpha encoding %r" % (alpha_encoding) "Unknown BLP encoding %r" % (self._blp_encoding)
)
else:
raise BLPFormatError(
"Unknown BLP compression %r" % (self._blp_compression)
) )
self.im = Image.core.new(self.mode, self.size) self.im = Image.core.new(self.mode, self.size)
self.frombytes(bytes(data))
data = b"".join(data)
self.frombytes(data)
def _open(self):
magic = self.fp.read(4)
self.fp.seek(0)
if magic == b"BLP1":
return self._decode_blp1()
if magic == b"BLP2":
return self._decode_blp2()
raise ValueError("not a BLP file (magic: %r)" % (magic))
def _validate(prefix): Image.register_open(
return prefix[:4] in (b"BLP1", b"BLP2") BlpImageFile.format, BlpImageFile, lambda p: p[:4] in (b"BLP1", b"BLP2")
)
Image.register_open(BlpImageFile.format, BlpImageFile, _validate)
Image.register_extension(BlpImageFile.format, ".blp") Image.register_extension(BlpImageFile.format, ".blp")