mirror of
https://github.com/python-pillow/Pillow.git
synced 2025-01-12 18:26:17 +03:00
Add support for BLP file format
This commit is contained in:
Jerome Leclanche
parent
262b6d15cc
commit
adaa703576
|
|
@ -1189,7 +1189,7 @@ Changelog (Pillow)
|
|||
- Change function declaration to match Tcl_CmdProc type #1966
|
||||
[homm]
|
||||
|
||||
- Integer overflow checks on all calls to *alloc #1781
|
||||
- Integer overflow checks on all calls to \*alloc #1781
|
||||
[wiredfool]
|
||||
|
||||
- Change equals method on Image so it short circuits #1967
|
||||
|
|
|
|||
BIN
Tests/images/blp2_dxt1.blp
Normal file
BIN
Tests/images/blp2_dxt1.blp
Normal file
Binary file not shown.
BIN
Tests/images/blp2_dxt1.png
Normal file
BIN
Tests/images/blp2_dxt1.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 761 B |
14
Tests/test_file_blp.py
Normal file
14
Tests/test_file_blp.py
Normal file
|
|
@ -0,0 +1,14 @@
|
|||
from PIL import Image
|
||||
|
||||
from helper import PillowTestCase, unittest
|
||||
|
||||
|
||||
class TestFileBlp(PillowTestCase):
|
||||
def test_load_blp2_dxt1(self):
|
||||
im = Image.open("Tests/images/blp2_dxt1.blp")
|
||||
target = Image.open("Tests/images/blp2_dxt1.png")
|
||||
self.assert_image_similar(im, target.convert("RGBA"), 15)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
432
src/PIL/BlpImagePlugin.py
Normal file
432
src/PIL/BlpImagePlugin.py
Normal file
|
|
@ -0,0 +1,432 @@
|
|||
"""
|
||||
Blizzard Mipmap Format (.blp)
|
||||
Jerome Leclanche <jerome@leclan.ch>
|
||||
|
||||
The contents of this file are hereby released in the public domain (CC0)
|
||||
Full text of the CC0 license:
|
||||
https://creativecommons.org/publicdomain/zero/1.0/
|
||||
|
||||
BLP1 files, used mostly in Warcraft III, are not fully supported.
|
||||
All types of BLP2 files used in World of Warcraft are supported.
|
||||
|
||||
The BLP file structure consists of a header, up to 16 mipmaps of the
|
||||
texture
|
||||
|
||||
Texture sizes must be powers of two, though the two dimensions do
|
||||
not have to be equal; 512x256 is valid, but 512x200 is not.
|
||||
The first mipmap (mipmap #0) is the full size image; each subsequent
|
||||
mipmap halves both dimensions. The final mipmap should be 1x1.
|
||||
|
||||
BLP files come in many different flavours:
|
||||
* JPEG-compressed (type == 0) - only supported for BLP1.
|
||||
* RAW images (type == 1, encoding == 1). Each mipmap is stored as an
|
||||
array of 8-bit values, one per pixel, left to right, top to bottom.
|
||||
Each value is an index to the palette.
|
||||
* DXT-compressed (type == 1, encoding == 2):
|
||||
- DXT1 compression is used if alpha_encoding == 0.
|
||||
- An additional alpha bit is used if alpha_depth == 1.
|
||||
- DXT3 compression is used if alpha_encoding == 1.
|
||||
- DXT5 compression is used if alpha_encoding == 7.
|
||||
"""
|
||||
|
||||
import struct
|
||||
from io import BytesIO
|
||||
|
||||
from . import Image, ImageFile
|
||||
|
||||
|
||||
BLP_FORMAT_JPEG = 0
|
||||
|
||||
BLP_ENCODING_UNCOMPRESSED = 1
|
||||
BLP_ENCODING_DXT = 2
|
||||
BLP_ENCODING_UNCOMPRESSED_RAW_BGRA = 3
|
||||
|
||||
BLP_ALPHA_ENCODING_DXT1 = 0
|
||||
BLP_ALPHA_ENCODING_DXT3 = 1
|
||||
BLP_ALPHA_ENCODING_DXT5 = 7
|
||||
|
||||
|
||||
def decode_dxt1(data, alpha=False):
|
||||
"""
|
||||
input: one "row" of data (i.e. will produce 4*width pixels)
|
||||
"""
|
||||
|
||||
blocks = len(data) // 8 # number of blocks in row
|
||||
final = (bytearray(), bytearray(), bytearray(), bytearray())
|
||||
|
||||
for block in range(blocks):
|
||||
# Decode next 8-byte block.
|
||||
idx = block * 8
|
||||
color0, color1, bits = struct.unpack("<HHI", data[idx:idx + 8])
|
||||
|
||||
# color 0, packed 5-6-5
|
||||
r0 = ((color0 >> 11) & 0x1f) << 3
|
||||
g0 = ((color0 >> 5) & 0x3f) << 2
|
||||
b0 = (color0 & 0x1f) << 3
|
||||
|
||||
# color 1, packed 5-6-5
|
||||
r1 = ((color1 >> 11) & 0x1f) << 3
|
||||
g1 = ((color1 >> 5) & 0x3f) << 2
|
||||
b1 = (color1 & 0x1f) << 3
|
||||
|
||||
# Decode this block into 4x4 pixels
|
||||
# Accumulate the results onto our 4 row accumulators
|
||||
for j in range(4):
|
||||
for i in range(4):
|
||||
# get next control op and generate a pixel
|
||||
|
||||
control = bits & 3
|
||||
bits = bits >> 2
|
||||
if control == 0:
|
||||
final[j].append(r0)
|
||||
final[j].append(g0)
|
||||
final[j].append(b0)
|
||||
elif control == 1:
|
||||
final[j].append(r1)
|
||||
final[j].append(g1)
|
||||
final[j].append(b1)
|
||||
elif control == 2:
|
||||
if color0 > color1:
|
||||
final[j].append((2 * r0 + r1) // 3)
|
||||
final[j].append((2 * g0 + g1) // 3)
|
||||
final[j].append((2 * b0 + b1) // 3)
|
||||
else:
|
||||
final[j].append((r0 + r1) // 2)
|
||||
final[j].append((g0 + g1) // 2)
|
||||
final[j].append((b0 + b1) // 2)
|
||||
elif control == 3:
|
||||
if color0 > color1:
|
||||
final[j].append((2 * r1 + r0) // 3)
|
||||
final[j].append((2 * g1 + g0) // 3)
|
||||
final[j].append((2 * b1 + b0) // 3)
|
||||
else:
|
||||
final[j].append(0)
|
||||
final[j].append(0)
|
||||
final[j].append(0)
|
||||
if alpha:
|
||||
final[j].append(0)
|
||||
|
||||
if alpha:
|
||||
final[j].append(0xFF)
|
||||
|
||||
return final
|
||||
|
||||
|
||||
def decode_dxt3(data):
|
||||
"""
|
||||
input: one "row" of data (i.e. will produce 4*width pixels)
|
||||
"""
|
||||
|
||||
blocks = len(data) // 16 # number of blocks in row
|
||||
final = (bytearray(), bytearray(), bytearray(), bytearray())
|
||||
|
||||
for block in range(blocks):
|
||||
idx = block * 16
|
||||
block = data[idx:idx + 16]
|
||||
# Decode next 16-byte block.
|
||||
bits = struct.unpack("<8B", block[:8])
|
||||
color0, color1 = struct.unpack("<HH", block[8:12])
|
||||
|
||||
code, = struct.unpack("<I", block[12:])
|
||||
|
||||
# color 0, packed 5-6-5
|
||||
r0 = ((color0 >> 11) & 0x1f) << 3
|
||||
g0 = ((color0 >> 5) & 0x3f) << 2
|
||||
b0 = (color0 & 0x1f) << 3
|
||||
|
||||
# color 1, packed 5-6-5
|
||||
r1 = ((color1 >> 11) & 0x1f) << 3
|
||||
g1 = ((color1 >> 5) & 0x3f) << 2
|
||||
b1 = (color1 & 0x1f) << 3
|
||||
|
||||
for j in range(4):
|
||||
high = False # Do we want the higher bits?
|
||||
for i in range(4):
|
||||
alphacode_index = (4 * j + i) // 2
|
||||
a = bits[alphacode_index]
|
||||
if high:
|
||||
high = False
|
||||
a >>= 4
|
||||
else:
|
||||
high = True
|
||||
a &= 0xf
|
||||
a *= 17 # We get a value between 0 and 15
|
||||
|
||||
color_code = (code >> 2 * (4 * j + i)) & 0x03
|
||||
|
||||
if color_code == 0:
|
||||
final[j].append(r0)
|
||||
final[j].append(g0)
|
||||
final[j].append(b0)
|
||||
final[j].append(a)
|
||||
elif color_code == 1:
|
||||
final[j].append(r1)
|
||||
final[j].append(g1)
|
||||
final[j].append(b1)
|
||||
final[j].append(a)
|
||||
elif color_code == 2:
|
||||
final[j].append((2 * r0 + r1) // 3)
|
||||
final[j].append((2 * g0 + g1) // 3)
|
||||
final[j].append((2 * b0 + b1) // 3)
|
||||
final[j].append(a)
|
||||
elif color_code == 3:
|
||||
final[j].append((2 * r1 + r0) // 3)
|
||||
final[j].append((2 * g1 + g0) // 3)
|
||||
final[j].append((2 * b1 + b0) // 3)
|
||||
final[j].append(a)
|
||||
|
||||
return final
|
||||
|
||||
|
||||
def decode_dxt5(data):
|
||||
"""
|
||||
input: one "row" of data (i.e. will produce 4 * width pixels)
|
||||
"""
|
||||
|
||||
blocks = len(data) // 16 # number of blocks in row
|
||||
final = (bytearray(), bytearray(), bytearray(), bytearray())
|
||||
|
||||
for block in range(blocks):
|
||||
idx = block * 16
|
||||
block = data[idx:idx + 16]
|
||||
# Decode next 16-byte block.
|
||||
a0, a1 = struct.unpack("<BB", block[:2])
|
||||
|
||||
bits = struct.unpack("<6B", block[2:8])
|
||||
alphacode1 = (
|
||||
bits[2] | (bits[3] << 8) | (bits[4] << 16) | (bits[5] << 24)
|
||||
)
|
||||
alphacode2 = bits[0] | (bits[1] << 8)
|
||||
|
||||
color0, color1 = struct.unpack("<HH", block[8:12])
|
||||
|
||||
code, = struct.unpack("<I", block[12:])
|
||||
|
||||
# color 0, packed 5-6-5
|
||||
r0 = ((color0 >> 11) & 0x1f) << 3
|
||||
g0 = ((color0 >> 5) & 0x3f) << 2
|
||||
b0 = (color0 & 0x1f) << 3
|
||||
|
||||
# color 1, packed 5-6-5
|
||||
r1 = ((color1 >> 11) & 0x1f) << 3
|
||||
g1 = ((color1 >> 5) & 0x3f) << 2
|
||||
b1 = (color1 & 0x1f) << 3
|
||||
|
||||
for j in range(4):
|
||||
for i in range(4):
|
||||
# get next control op and generate a pixel
|
||||
alphacode_index = 3 * (4 * j + i)
|
||||
|
||||
if alphacode_index <= 12:
|
||||
alphacode = (alphacode2 >> alphacode_index) & 0x07
|
||||
elif alphacode_index == 15:
|
||||
alphacode = (alphacode2 >> 15) | ((alphacode1 << 1) & 0x06)
|
||||
else: # alphacode_index >= 18 and alphacode_index <= 45
|
||||
alphacode = (alphacode1 >> (alphacode_index - 16)) & 0x07
|
||||
|
||||
if alphacode == 0:
|
||||
a = a0
|
||||
elif alphacode == 1:
|
||||
a = a1
|
||||
elif a0 > a1:
|
||||
a = ((8 - alphacode) * a0 + (alphacode - 1) * a1) // 7
|
||||
else:
|
||||
if alphacode == 6:
|
||||
a = 0
|
||||
elif alphacode == 7:
|
||||
a = 255
|
||||
else:
|
||||
a = ((6 - alphacode) * a0 + (alphacode - 1) * a1) // 5
|
||||
|
||||
color_code = (code >> 2 * (4 * j + i)) & 0x03
|
||||
|
||||
if color_code == 0:
|
||||
final[j].append(r0)
|
||||
final[j].append(g0)
|
||||
final[j].append(b0)
|
||||
final[j].append(a)
|
||||
elif color_code == 1:
|
||||
final[j].append(r1)
|
||||
final[j].append(g1)
|
||||
final[j].append(b1)
|
||||
final[j].append(a)
|
||||
elif color_code == 2:
|
||||
final[j].append((2 * r0 + r1) // 3)
|
||||
final[j].append((2 * g0 + g1) // 3)
|
||||
final[j].append((2 * b0 + b1) // 3)
|
||||
final[j].append(a)
|
||||
elif color_code == 3:
|
||||
final[j].append((2 * r1 + r0) // 3)
|
||||
final[j].append((2 * g1 + g0) // 3)
|
||||
final[j].append((2 * b1 + b0) // 3)
|
||||
final[j].append(a)
|
||||
|
||||
return tuple(final)
|
||||
|
||||
|
||||
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):
|
||||
pass
|
||||
|
||||
|
||||
class BlpImageFile(ImageFile.ImageFile):
|
||||
"""
|
||||
Blizzard Mipmap Format
|
||||
"""
|
||||
format = "BLP"
|
||||
format_description = "Blizzard Mipmap Format"
|
||||
|
||||
def _decode_blp1(self):
|
||||
header = BytesIO(self.fp.read(28 + 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))
|
||||
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:
|
||||
from PIL.JpegImagePlugin import JpegImageFile
|
||||
jpeg_header_size, = struct.unpack("<I", self.fp.read(4))
|
||||
jpeg_header = self.fp.read(jpeg_header_size)
|
||||
self.fp.read(offsets[0] - self.fp.tell()) # What IS this?
|
||||
data = self.fp.read(lengths[0])
|
||||
data = jpeg_header + data
|
||||
data = BytesIO(data)
|
||||
image = JpegImageFile(data)
|
||||
image.show()
|
||||
self.tile = image.tile # :/
|
||||
self.fp = image.fp
|
||||
self.mode = image.mode
|
||||
|
||||
elif compression == 1:
|
||||
if encoding == 5:
|
||||
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.im = Image.core.new(self.mode, self.size)
|
||||
self.frombytes(data)
|
||||
else:
|
||||
raise BLPFormatError(
|
||||
"Unknown or unsupported BLP encoding %r" % (encoding)
|
||||
)
|
||||
else:
|
||||
raise BLPFormatError(
|
||||
"Unknown or unsupported BLP compression %r" % (encoding)
|
||||
)
|
||||
|
||||
def _decode_blp2(self):
|
||||
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
|
||||
data = []
|
||||
self.fp.seek(offsets[0])
|
||||
|
||||
if encoding == BLP_ENCODING_UNCOMPRESSED:
|
||||
palette = getpalette(palette_data)
|
||||
_data = BytesIO(self.fp.read(lengths[0]))
|
||||
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))
|
||||
|
||||
elif encoding == BLP_ENCODING_DXT:
|
||||
if alpha_encoding == BLP_ALPHA_ENCODING_DXT1:
|
||||
linesize = (self.size[0] + 3) // 4 * 8
|
||||
for yb in range((self.size[1] + 3) // 4):
|
||||
line_data = self.fp.read(linesize)
|
||||
if alpha_depth:
|
||||
self.mode = "RGBA"
|
||||
decoded = decode_dxt1(line_data, alpha=True)
|
||||
else:
|
||||
decoded = decode_dxt1(line_data)
|
||||
for d in decoded:
|
||||
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:
|
||||
raise BLPFormatError(
|
||||
"Unsupported alpha encoding %r" % (alpha_encoding)
|
||||
)
|
||||
|
||||
self.im = Image.core.new(self.mode, self.size)
|
||||
|
||||
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):
|
||||
return prefix[:4] in (b"BLP1", b"BLP2")
|
||||
|
||||
|
||||
Image.register_open(BlpImageFile.format, BlpImageFile, _validate)
|
||||
Image.register_extension(BlpImageFile.format, ".blp")
|
||||
|
|
@ -14,11 +14,12 @@
|
|||
from . import version
|
||||
|
||||
VERSION = '1.1.7' # PIL Version
|
||||
PILLOW_VERSION = version.__version__
|
||||
PILLOW_VERSION = version.__version__
|
||||
|
||||
__version__ = PILLOW_VERSION
|
||||
|
||||
_plugins = ['BmpImagePlugin',
|
||||
_plugins = ['BlpImagePlugin',
|
||||
'BmpImagePlugin',
|
||||
'BufrStubImagePlugin',
|
||||
'CurImagePlugin',
|
||||
'DcxImagePlugin',
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user