def extend_data(data, length, offset):
"""Extend data using a length and an offset."""
if length >= offset:
new_data = data[-offset:] * (alignValue(length, offset) // offset)
return data + new_data[:length]
else:
return data + data[-offset:-offset + length]
def __init__(self, *args):
FieldSet.__init__(self, *args)
self._size = (8 + alignValue(self["size"].value, 2)) * 8
tag = self["type"].value
if tag in self.TAG_INFO:
self._name, self._description, self._parser = self.TAG_INFO[tag]
else:
self._parser = None
def __init__(self, *args, **kw):
FieldSet.__init__(self, *args, **kw)
try:
self._name, self.handler, self._description = self.TAG_INFO[
self["tag"].value]
except KeyError:
self.handler = None
size = self["size"]
self._size = size.address + size.size + alignValue(size.value, 2) * 8
def createFields(self):
if self.has_all_byte:
yield Enum(UInt8(self, "all_defined"), {0: 'False', 1: 'True'})
if self['all_defined'].value:
return
nbytes = alignValue(self.num, 8) // 8
ctr = 0
for i in range(nbytes):
for j in reversed(range(8)):
yield Bit(self, "bit[%d]" % (ctr + j))
ctr += 8
def setCheckedSizes(self, size):
# First set size so that end is aligned, if needed
self.real_size = size
size *= 8
if self.ALIGN:
size = alignValue(self.absolute_address + size, 8 * self.ALIGN) \
- self.absolute_address
if self._parent._size:
if self._parent.current_size + size > self._parent._size:
size = self._parent._size - self._parent.current_size
self._size = size
def hexadecimal(field):
"""
Convert an integer to hexadecimal in lower case. Returns unicode string.
>>> hexadecimal(type("", (), dict(value=412, size=16)))
'0x019c'
>>> hexadecimal(type("", (), dict(value=0, size=32)))
'0x00000000'
"""
assert hasattr(field, "value") and hasattr(field, "size")
size = field.size
padding = alignValue(size, 4) // 4
pattern = "0x%%0%ux" % padding
return pattern % field.value
def __init__(self, *args, **kw):
FieldSet.__init__(self, *args, **kw)
self._size = (8 + alignValue(self["size"].value, 2)) * 8
tag = self["tag"].value
if tag in self.TAG_INFO:
self.tag_info = self.TAG_INFO[tag]
if tag == "LIST":
subtag = self["subtag"].value
if subtag in self.subtag_info:
info = self.subtag_info[subtag]
self.tag_info = (info[0], None, info[1])
self._name = self.tag_info[0]
self._description = self.tag_info[2]
else:
self.tag_info = ("field[]", None, None)
def readBits(self, address, nbits, endian):
assert endian in (BIG_ENDIAN, LITTLE_ENDIAN, MIDDLE_ENDIAN)
if endian is MIDDLE_ENDIAN:
# read an aligned chunk of words
wordaddr, remainder = divmod(address, 16)
wordnbits = alignValue(remainder + nbits, 16)
_, data, missing = self.read(wordaddr * 16, wordnbits)
shift = remainder
else:
shift, data, missing = self.read(address, nbits)
if missing:
raise ReadStreamError(nbits, address)
value = str2long(data, endian)
if endian in (BIG_ENDIAN, MIDDLE_ENDIAN):
value >>= len(data) * 8 - shift - nbits
else:
value >>= shift
return value & (1 << nbits) - 1
def createFields(self):
yield String(self, "signature", 4, "8BIM signature", charset="ASCII")
if self["signature"].value != "8BIM":
raise ParserError(
"Stream doesn't look like 8BIM item (wrong signature)!")
yield textHandler(UInt16(self, "tag"), hexadecimal)
if self.stream.readBytes(self.absolute_address + self.current_size,
4) != b"\0\0\0\0":
yield PascalString8(self, "name")
size = 2 + (self["name"].size // 8) % 2
yield NullBytes(self, "name_padding", size)
else:
yield String(self, "name", 4, strip="\0")
yield UInt16(self, "size")
size = alignValue(self["size"].value, 2)
if not size:
return
if self.handler:
if issubclass(self.handler, FieldSet):
yield self.handler(self, "content", size=size * 8)
else:
yield self.handler(self, "content")
else:
yield RawBytes(self, "content", size)
def createFields(self):
if self.frame["../type"].value in [0xC0, 0xC1]:
# yay, huffman coding!
if not hasattr(self, "huffman_tables"):
self.huffman_tables = {}
for huffman in self.parent.array("huffman"):
for table in huffman["content"].array("huffman_table"):
for _dummy_ in table:
# exhaust table, so the huffman tree is built
pass
self.huffman_tables[table["table_class"].value,
table["index"].value] = table.tree
components = [] # sos_comp, samples
max_vert = 0
max_horiz = 0
for component in self.scan.array("component"):
for sof_comp in self.frame.array("component"):
if sof_comp["component_id"].value == component[
"component_id"].value:
vert = sof_comp["vert_sample"].value
horiz = sof_comp["horiz_sample"].value
components.append((component, vert * horiz))
max_vert = max(max_vert, vert)
max_horiz = max(max_horiz, horiz)
mcu_height = alignValue(self.frame["height"].value,
8 * max_vert) // (8 * max_vert)
mcu_width = alignValue(self.frame["width"].value,
8 * max_horiz) // (8 * max_horiz)
if self.restart_interval and self.restart_offset > 0:
mcu_number = self.restart_interval * self.restart_offset
else:
mcu_number = 0
initial_mcu = mcu_number
while True:
if (self.restart_interval and mcu_number != initial_mcu and mcu_number % self.restart_interval == 0) or\
mcu_number == mcu_height * mcu_width:
padding = paddingSize(self.current_size, 8)
if padding:
yield PaddingBits(self, "padding[]", padding) # all 1s
last_byte = self.stream.readBytes(
self.absolute_address + self.current_size - 8, 1)
if last_byte == b'\xFF':
next_byte = self.stream.readBytes(
self.absolute_address + self.current_size, 1)
if next_byte != b'\x00':
raise FieldError("Unexpected byte sequence %r!" %
(last_byte + next_byte))
yield NullBytes(self, "stuffed_byte[]", 1)
break
for sos_comp, num_units in components:
for interleave_count in range(num_units):
yield JpegHuffmanImageUnit(
self, "block[%i]component[%i][]" %
(mcu_number, sos_comp["component_id"].value),
self.huffman_tables[
0, sos_comp["dc_coding_table"].value],
self.huffman_tables[
1, sos_comp["ac_coding_table"].value])
mcu_number += 1
else:
self.warning(
"Sorry, only supporting Baseline & Extended Sequential JPEG images so far!"
)
return
def __init__(self, parent, name):
FieldSet.__init__(self, parent, name)
self._size = alignValue(self["size"].value, 4) * 8
def __init__(self, parent, name, is_32bit=True):
FieldSet.__init__(self, parent, name)
self._size = alignValue(self["size"].value, 4) * 8
self.is_32bit = is_32bit
def createFields(self):
yield String(self, "magic", 4, "Signature (BLP2)")
yield Enum(UInt32(self, "compression", "Compression type"), {
0: "JPEG Compressed",
1: "Uncompressed or DXT/S3TC compressed"
})
yield Enum(UInt8(self, "encoding", "Encoding type"), {
1: "Raw",
2: "DXT/S3TC Texture Compression (a.k.a. DirectX)"
})
yield UInt8(self, "alpha_depth",
"Alpha channel depth, in bits (0 = no alpha)")
yield Enum(
UInt8(self, "alpha_encoding", "Encoding used for alpha channel"), {
0: "DXT1 alpha (0 or 1 bit alpha)",
1: "DXT3 alpha (4 bit alpha)",
7: "DXT5 alpha (8 bit interpolated alpha)"
})
yield Enum(
UInt8(self, "has_mips", "Are mip levels present?"), {
0: "No mip levels",
1:
"Mip levels present; number of levels determined by image size"
})
yield UInt32(self, "width", "Base image width")
yield UInt32(self, "height", "Base image height")
for i in range(16):
yield UInt32(self, "mipmap_offset[]")
for i in range(16):
yield UInt32(self, "mipmap_size[]")
yield PaletteRGBA(self, "palette", 256)
compression = self["compression"].value
encoding = self["encoding"].value
alpha_depth = self["alpha_depth"].value
alpha_encoding = self["alpha_encoding"].value
width = self["width"].value
height = self["height"].value
if compression == 0: # JPEG Compression
yield UInt32(self, "jpeg_header_len")
yield RawBytes(self, "jpeg_header", self["jpeg_header_len"].value,
"Shared JPEG Header")
offsets = self.array("mipmap_offset")
sizes = self.array("mipmap_size")
for i in range(16):
if not offsets[i].value or not sizes[i].value:
continue
padding = self.seekByte(offsets[i].value)
if padding:
yield padding
if compression == 0:
yield RawBytes(
self, "mipmap[%i]" % i, sizes[i].value,
"JPEG data, append to header to recover complete image")
elif compression == 1 and encoding == 1:
yield Generic2DArray(self, "mipmap_indexes[%i]" % i, height,
width, PaletteIndex, "row", "index",
"Indexes into the palette")
if alpha_depth == 1:
yield GenericVector(self, "mipmap_alphas[%i]" % i, height,
width, Bit, "row", "is_opaque",
"Alpha values")
elif alpha_depth == 8:
yield GenericVector(self, "mipmap_alphas[%i]" % i, height,
width, UInt8, "row", "alpha",
"Alpha values")
elif compression == 1 and encoding == 2:
block_height = alignValue(height, 4) // 4
block_width = alignValue(width, 4) // 4
if alpha_depth in [0, 1] and alpha_encoding == 0:
yield Generic2DArray(self, "mipmap[%i]" % i, block_height,
block_width, DXT1, "row", "block",
"DXT1-compressed image blocks")
elif alpha_depth == 8 and alpha_encoding == 1:
yield Generic2DArray(self, "mipmap[%i]" % i, block_height,
block_width, DXT3, "row", "block",
"DXT3-compressed image blocks")
elif alpha_depth == 8 and alpha_encoding == 7:
yield Generic2DArray(self, "mipmap[%i]" % i, block_height,
block_width, DXT5, "row", "block",
"DXT5-compressed image blocks")
width /= 2
height /= 2
def __init__(self, parent, name, width, pixel_class):
FieldSet.__init__(self, parent, name)
self._pixel = pixel_class
self._width = width
self._size = alignValue(self._width * self._pixel.static_size, 32)