def __init__(self, parent, name, description=None): Bits.__init__(self, parent, name, 8, description) stream = parent.stream addr = self.absolute_address value = 0 while True: bits = stream.readBits(addr, 8, parent.endian) value = (value << 7) + (bits & 127) if not (bits & 128): break addr += 8 self._size += 8 if 32 < self._size: raise ParserError("Integer size is bigger than 32-bit") self.createValue = lambda: value
def createFields(self): values = [] yield UInt8(self, "alpha_val[0]", "First alpha value") values.append(self["alpha_val[0]"].value) yield UInt8(self, "alpha_val[1]", "Second alpha value") values.append(self["alpha_val[1]"].value) if values[0] > values[1]: values += interp_avg(values[0], values[1], 7) else: values += interp_avg(values[0], values[1], 5) values += [0, 255] for i in xrange(16): pixel = Bits(self, "alpha[%i][%i]" % divmod(i, 4), 3) alpha = values[pixel.value] pixel._description = "Alpha value: %i" % alpha yield pixel
def __init__(self, parent, name, description=None): Bits.__init__(self, parent, name, 8, description) stream = self._parent.stream addr = self.absolute_address size = 8 value = 0 byte = stream.readBits(addr, 8, BIG_ENDIAN) value = byte & 127 while 128 <= byte: addr += 8 size += 8 if 64 < size: # Arbitrary limit to catch errors raise ParserError("ASN.1: Object identifier is limited 64 bits") byte = stream.readBits(addr, 8, BIG_ENDIAN) value = (value << 7) + (byte & 127) self._size = size self.createValue = lambda: value
def __init__(self, parent, name, signed=False, nbits=30, description=None): Bits.__init__(self, parent, name, 8, description) stream = self._parent.stream addr = self.absolute_address size = 0 value = 0 mult = 1 while True: byte = stream.readBits(addr+size, 8, LITTLE_ENDIAN) value += mult * (byte & 0x7f) size += 8 mult <<= 7 if byte < 128: break self._size = size if signed and (1 << (nbits-1)) <= value: value -= (1 << nbits) self.createValue = lambda: value
def createFields(self): values = [[], []] for i in (0, 1): yield Bits(self, "blue[]", 5) yield Bits(self, "green[]", 6) yield Bits(self, "red[]", 5) values[i] = [self["red[%i]" % i].value, self["green[%i]" % i].value, self["blue[%i]" % i].value] if values[0] > values[1] or self.dxt2_mode: values += interp_avg(values[0], values[1], 3) else: values += interp_avg(values[0], values[1], 2) values.append(None) # transparent for i in xrange(16): pixel = Bits(self, "pixel[%i][%i]" % divmod(i, 4), 2) color = values[pixel.value] if color is None: pixel._description = "Transparent" else: pixel._description = "RGB color: %s" % color_name(color, [5, 6, 5]) yield pixel
def createFields(self): field = HuffmanCode(self, "dc_data", self.dc_tree) field._description = "DC Code %i (Huffman Code %i)" % (field.realvalue, field.value) + field._description yield field if field.realvalue != 0: extra = Bits(self, "dc_data_extra", field.realvalue) if extra.value < 2**(field.realvalue - 1): corrected_value = extra.value + (-1 << field.realvalue) + 1 else: corrected_value = extra.value extra._description = "Extra Bits: Corrected DC Value %i" % corrected_value yield extra data = [] while len(data) < 63: field = HuffmanCode(self, "ac_data[]", self.ac_tree) value_r = field.realvalue >> 4 if value_r: data += [0] * value_r value_s = field.realvalue & 0x0F if value_r == value_s == 0: field._description = "AC Code Block Terminator (0, 0) (Huffman Code %i)" % field.value + field._description yield field return field._description = "AC Code %i, %i (Huffman Code %i)" % (value_r, value_s, field.value) + field._description yield field if value_s != 0: extra = Bits(self, "ac_data_extra[%s" % field.name.split('[')[1], value_s) if extra.value < 2**(value_s - 1): corrected_value = extra.value + (-1 << value_s) + 1 else: corrected_value = extra.value extra._description = "Extra Bits: Corrected AC Value %i" % corrected_value data.append(corrected_value) yield extra else: data.append(0)
def createFields(self): for i in xrange(20): yield Bits(self, "pretree_lengths[]", 4) pre_tree = build_tree([self['pretree_lengths[%d]'%x].value for x in xrange(20)]) if not hasattr(self.root, "lzx_tree_lengths_"+self.name): self.lengths = [0] * self.num_elements setattr(self.root, "lzx_tree_lengths_"+self.name, self.lengths) else: self.lengths = getattr(self.root, "lzx_tree_lengths_"+self.name) i = 0 while i < self.num_elements: field = HuffmanCode(self, "tree_code[]", pre_tree) if field.realvalue <= 16: self.lengths[i] = (self.lengths[i] - field.realvalue) % 17 field._description = "Literal tree delta length %i (new length value %i for element %i)" % ( field.realvalue, self.lengths[i], i) i += 1 yield field elif field.realvalue == 17: field._description = "Tree Code 17: Zeros for 4-19 elements" yield field extra = Bits(self, "extra[]", 4) zeros = 4 + extra.value extra._description = "Extra bits: zeros for %i elements (elements %i through %i)" % (zeros, i, i+zeros-1) yield extra self.lengths[i:i+zeros] = [0] * zeros i += zeros elif field.realvalue == 18: field._description = "Tree Code 18: Zeros for 20-51 elements" yield field extra = Bits(self, "extra[]", 5) zeros = 20 + extra.value extra._description = "Extra bits: zeros for %i elements (elements %i through %i)" % (zeros, i, i+zeros-1) yield extra self.lengths[i:i+zeros] = [0] * zeros i += zeros elif field.realvalue == 19: field._description = "Tree Code 19: Same code for 4-5 elements" yield field extra = Bits(self, "extra[]", 1) run = 4 + extra.value extra._description = "Extra bits: run for %i elements (elements %i through %i)" % (run, i, i+run-1) yield extra newfield = HuffmanCode(self, "tree_code[]", pre_tree) assert newfield.realvalue <= 16 newfield._description = "Literal tree delta length %i (new length value %i for elements %i through %i)" % ( newfield.realvalue, self.lengths[i], i, i+run-1) self.lengths[i:i+run] = [(self.lengths[i] - newfield.realvalue) % 17] * run i += run yield newfield
def createDisplay(self): if self._display_pattern: return u"<padding pattern=%s>" % self.pattern else: return Bits.createDisplay(self)
def __init__(self, parent, name): Bits.__init__(self, parent, name, 4)
def __init__(self, parent, name, size): Bits.__init__(self, parent, name, size) self.bias = 2 ** (size-1) - 1
def createFields(self): yield Enum(UInt32(self, "type"), self.TYPE_DESC) yield Bits(self, "offset", 31) yield Bit(self, "is_subdir")
def __init__(self, parent, name, signed, size, description=None): if not (8 <= size <= 256): raise FieldError( "Invalid integer size (%s): have to be in 8..256" % size) Bits.__init__(self, parent, name, size, description) self.signed = signed
def __init__(self, parent, name, nbits, description="Padding", pattern=None): Bits.__init__(self, parent, name, nbits, description) self.pattern = pattern self._display_pattern = self.checkPattern()
def createDisplay(self): if self._display_pattern: return "<null>" else: return Bits.createDisplay(self)
def createFields(self): for i in xrange(16): yield Bits(self, "alpha[%i][%i]" % divmod(i, 4), 4)
def createFields(self): yield UInt8(self, "component_id") yield Bits(self, "horiz_sample", 4, "Horizontal sampling factor") yield Bits(self, "vert_sample", 4, "Vertical sampling factor") yield UInt8(self, "quant_table", "Quantization table destination selector")
def createFields(self): if self.stream.readBits(self.absolute_address, 2, self.endian) == 1: # MPEG version 2 yield Bits(self, "sync[]", 2) yield SCR(self, "scr") yield Bit(self, "sync[]") yield Bits(self, "scr_ext", 9) yield Bit(self, "sync[]") yield Bits(self, "mux_rate", 22) yield Bits(self, "sync[]", 2) yield PaddingBits(self, "reserved", 5, pattern=1) yield Bits(self, "stuffing_length", 3) count = self["stuffing_length"].value if count: yield PaddingBytes(self, "stuffing", count, pattern="\xff") else: # MPEG version 1 yield Bits(self, "sync[]", 4) yield Bits(self, "scr_a", 3) yield Bit(self, "sync[]") yield Bits(self, "scr_b", 15) yield Bit(self, "sync[]") yield Bits(self, "scr_c", 15) yield Bits(self, "sync[]", 2) yield Bits(self, "mux_rate", 22) yield Bit(self, "sync[]")
def createFields(self): yield Bits(self, "scr_a", 3) yield Bit(self, "sync[]") # =True yield Bits(self, "scr_b", 15) yield Bit(self, "sync[]") # =True yield Bits(self, "scr_c", 15)
def __nonzero__(self): return Bits.createValue(self) != 0
def createFields(self): yield UInt16(self, "wIdent", "Magic Number") yield UInt16(self, "nFib", "File Information Block (FIB) Version") yield UInt16(self, "nProduct", "Product Version") yield Enum(UInt16(self, "lid", "Language ID"), LANGUAGE_ID) yield Int16(self, "pnNext") yield Bit(self, "fDot", "Is the document a document template?") yield Bit(self, "fGlsy", "Is the document a glossary?") yield Bit(self, "fComplex", "Is the document in Complex format?") yield Bit(self, "fHasPic", "Does the document have embedded images?") yield Bits(self, "cQuickSaves", 4, "Number of times the document was quick-saved") yield Bit(self, "fEncrypted", "Is the document encrypted?") yield Bits(self, "reserved[]", 7) yield UInt16(self, "nFibBack") yield UInt32(self, "reserved[]") yield NullBytes(self, "rgwSpare", 6) yield UInt32(self, "fcMin", "File offset of first text character") yield UInt32(self, "fcMax", "File offset of last text character + 1") yield Int32(self, "cbMax", "File offset of last byte + 1") yield NullBytes(self, "fcSpare", 16) yield UInt32(self, "ccpText", "Length of main document text stream") yield Int32(self, "ccpFtn", "Length of footnote subdocument text stream") yield Int32(self, "ccpHdr", "Length of header subdocument text stream") yield Int32(self, "ccpMcr", "Length of macro subdocument text stream") yield Int32(self, "ccpAtn", "Length of annotation subdocument text stream") yield NullBytes(self, "ccpSpare", 16) yield FC_CB(self, "StshfOrig", "Original STSH allocation") yield FC_CB(self, "Stshf", "Current STSH allocation") yield FC_CB(self, "PlcffndRef", "Footnote reference PLC") yield FC_CB(self, "PlcffndTxt", "Footnote text PLC") yield FC_CB(self, "PlcfandRef", "Annotation reference PLC") yield FC_CB(self, "PlcfandTxt", "Annotation text PLC") yield FC_CB(self, "Plcfsed", "Section descriptor PLC") yield FC_CB(self, "Plcfpgd", "Page descriptor PLC") yield FC_CB(self, "Plcfphe", "Paragraph heights PLC") yield FC_CB(self, "Sttbfglsy", "Glossary string table") yield FC_CB(self, "Plcfglsy", "Glossary PLC") yield FC_CB(self, "Plcfhdd", "Header PLC") yield FC_CB(self, "PlcfbteChpx", "Character property bin table PLC") yield FC_CB(self, "PlcfbtePapx", "Paragraph property bin table PLC") yield FC_CB(self, "Plcfsea", "Private Use PLC") yield FC_CB(self, "Sttbfffn") yield FC_CB(self, "PlcffldMom") yield FC_CB(self, "PlcffldHdr") yield FC_CB(self, "PlcffldFtn") yield FC_CB(self, "PlcffldAtn") yield FC_CB(self, "PlcffldMcr") yield FC_CB(self, "Sttbfbkmk") yield FC_CB(self, "Plcfbkf") yield FC_CB(self, "Plcfbkl") yield FC_CB(self, "Cmds") yield FC_CB(self, "Plcmcr") yield FC_CB(self, "Sttbfmcr") yield FC_CB(self, "PrDrvr", "Printer Driver information") yield FC_CB(self, "PrEnvPort", "Printer environment for Portrait mode") yield FC_CB(self, "PrEnvLand", "Printer environment for Landscape mode") yield FC_CB(self, "Wss", "Window Save State") yield FC_CB(self, "Dop", "Document Property data") yield FC_CB(self, "SttbfAssoc") yield FC_CB(self, "Clx", "'Complex' file format data") yield FC_CB(self, "PlcfpgdFtn", "Footnote page descriptor PLC") yield FC_CB(self, "AutosaveSource", "Original filename for Autosave purposes") yield FC_CB(self, "Spare5") yield FC_CB(self, "Spare6") yield Int16(self, "wSpare4") yield UInt16(self, "pnChpFirst") yield UInt16(self, "pnPapFirst") yield UInt16(self, "cpnBteChp", "Count of CHPX FKPs recorded in file") yield UInt16(self, "cpnBtePap", "Count of PAPX FKPs recorded in file")
def __init__(self, parent, name, size, description=None): Bits.__init__(self, parent, name, size, description)
def createFields(self): yield Bits(self, "mantisa_high", 20) yield FloatExponent(self, "exponent", 11) yield Bit(self, "negative") yield Bits(self, "mantisa_low", 32)
def createValue(self): return Bits.createValue(self) - self.bias
def __init__(self, parent, name, signed, size, description=None): if not (8 <= size <= 256): raise FieldError("Invalid integer size (%s): have to be in 8..256" % size) Bits.__init__(self, parent, name, size, description) self.signed = signed
def createFields(self): yield UInt32(self, "name") yield Bits(self, "offset", 31) yield Bit(self, "is_name")
def createFields(self): yield Bit(self, "final", "Is this the final block?") # BFINAL yield Enum( Bits(self, "compression_type", 2), # BTYPE { 0: "None", 1: "Fixed Huffman", 2: "Dynamic Huffman", 3: "Reserved" }) if self["compression_type"].value == 0: # no compression padding = paddingSize(self.current_size + self.absolute_address, 8) # align on byte boundary if padding: yield PaddingBits(self, "padding[]", padding) yield Int16(self, "len") yield Int16(self, "nlen", "One's complement of len") if self["len"].value != ~self["nlen"].value: raise ParserError( "len must be equal to the one's complement of nlen!") if self["len"].value: # null stored blocks produced by some encoders (e.g. PIL) yield RawBytes(self, "data", self["len"].value, "Uncompressed data") return elif self["compression_type"].value == 1: # Fixed Huffman length_tree = {} # (size, huffman code): value distance_tree = {} for i in xrange(144): length_tree[(8, i + 48)] = i for i in xrange(144, 256): length_tree[(9, i + 256)] = i for i in xrange(256, 280): length_tree[(7, i - 256)] = i for i in xrange(280, 288): length_tree[(8, i - 88)] = i for i in xrange(32): distance_tree[(5, i)] = i elif self["compression_type"].value == 2: # Dynamic Huffman yield Bits(self, "huff_num_length_codes", 5, "Number of Literal/Length Codes, minus 257") yield Bits(self, "huff_num_distance_codes", 5, "Number of Distance Codes, minus 1") yield Bits(self, "huff_num_code_length_codes", 4, "Number of Code Length Codes, minus 4") code_length_code_lengths = [0] * 19 # confusing variable name... for i in self.CODE_LENGTH_ORDER[:self["huff_num_code_length_codes"] .value + 4]: field = Bits(self, "huff_code_length_code[%i]" % i, 3, "Code lengths for the code length alphabet") yield field code_length_code_lengths[i] = field.value code_length_tree = build_tree(code_length_code_lengths) length_code_lengths = [] distance_code_lengths = [] for numcodes, name, lengths in ( (self["huff_num_length_codes"].value + 257, "length", length_code_lengths), (self["huff_num_distance_codes"].value + 1, "distance", distance_code_lengths)): while len(lengths) < numcodes: field = HuffmanCode(self, "huff_%s_code[]" % name, code_length_tree) value = field.realvalue if value < 16: prev_value = value field._description = "Literal Code Length %i (Huffman Code %i)" % ( value, field.value) yield field lengths.append(value) else: info = { 16: (3, 6, 2), 17: (3, 10, 3), 18: (11, 138, 7) }[value] if value == 16: repvalue = prev_value else: repvalue = 0 field._description = "Repeat Code %i, Repeating value (%i) %i to %i times (Huffman Code %i)" % ( value, repvalue, info[0], info[1], field.value) yield field extrafield = Bits( self, "huff_%s_code_extra[%s" % (name, field.name.split('[')[1]), info[2]) num_repeats = extrafield.value + info[0] extrafield._description = "Repeat Extra Bits (%i), total repeats %i" % ( extrafield.value, num_repeats) yield extrafield lengths += [repvalue] * num_repeats length_tree = build_tree(length_code_lengths) distance_tree = build_tree(distance_code_lengths) else: raise ParserError("Unsupported compression type 3!") while True: field = HuffmanCode(self, "length_code[]", length_tree) value = field.realvalue if value < 256: field._description = "Literal Code %r (Huffman Code %i)" % ( chr(value), field.value) yield field self.uncomp_data += chr(value) if value == 256: field._description = "Block Terminator Code (256) (Huffman Code %i)" % field.value yield field break elif value > 256: info = self.LENGTH_SYMBOLS[value] if info[2] == 0: field._description = "Length Code %i, Value %i (Huffman Code %i)" % ( value, info[0], field.value) length = info[0] yield field else: field._description = "Length Code %i, Values %i to %i (Huffman Code %i)" % ( value, info[0], info[1], field.value) yield field extrafield = Bits( self, "length_extra[%s" % field.name.split('[')[1], info[2]) length = extrafield.value + info[0] extrafield._description = "Length Extra Bits (%i), total length %i" % ( extrafield.value, length) yield extrafield field = HuffmanCode(self, "distance_code[]", distance_tree) value = field.realvalue info = self.DISTANCE_SYMBOLS[value] if info[2] == 0: field._description = "Distance Code %i, Value %i (Huffman Code %i)" % ( value, info[0], field.value) distance = info[0] yield field else: field._description = "Distance Code %i, Values %i to %i (Huffman Code %i)" % ( value, info[0], info[1], field.value) yield field extrafield = Bits( self, "distance_extra[%s" % field.name.split('[')[1], info[2]) distance = extrafield.value + info[0] extrafield._description = "Distance Extra Bits (%i), total length %i" % ( extrafield.value, distance) yield extrafield self.uncomp_data = extend_data(self.uncomp_data, length, distance)
def __init__(self, parent, name, description=None): Bits.__init__(self, parent, name, 10, description)
def __init__(self, parent, name, signed, endian, size, description=None): if not (8 <= size <= 16384): raise FieldError("Invalid integer size (%s): have to be in 8..16384" % size) Bits.__init__(self, parent, name, size, description) self.signed = signed self.endian = endian or self._parent.endian
def __init__(self, parent, name, size, description=None): Bits.__init__(self, parent, name, size, None) self.desc = description
def createValue(self): value = Bits.createValue(self) return 1 + float(value) / (2 ** self.size)
def createFields(self): yield Bit(self, "is_water_tile") yield Bits(self, "offset", 39)
def createFields(self): yield Bit(self, "final", "Is this the final block?") # BFINAL yield Enum(Bits(self, "compression_type", 2), # BTYPE {0:"None", 1:"Fixed Huffman", 2:"Dynamic Huffman", 3:"Reserved"}) if self["compression_type"].value == 0: # no compression padding = paddingSize(self.current_size + self.absolute_address, 8) # align on byte boundary if padding: yield PaddingBits(self, "padding[]", padding) yield Int16(self, "len") yield Int16(self, "nlen", "One's complement of len") if self["len"].value != ~self["nlen"].value: raise ParserError("len must be equal to the one's complement of nlen!") if self["len"].value: # null stored blocks produced by some encoders (e.g. PIL) yield RawBytes(self, "data", self["len"].value, "Uncompressed data") return elif self["compression_type"].value == 1: # Fixed Huffman length_tree = {} # (size, huffman code): value distance_tree = {} for i in xrange(144): length_tree[(8, i+48)] = i for i in xrange(144, 256): length_tree[(9, i+256)] = i for i in xrange(256, 280): length_tree[(7, i-256)] = i for i in xrange(280, 288): length_tree[(8, i-88)] = i for i in xrange(32): distance_tree[(5, i)] = i elif self["compression_type"].value == 2: # Dynamic Huffman yield Bits(self, "huff_num_length_codes", 5, "Number of Literal/Length Codes, minus 257") yield Bits(self, "huff_num_distance_codes", 5, "Number of Distance Codes, minus 1") yield Bits(self, "huff_num_code_length_codes", 4, "Number of Code Length Codes, minus 4") code_length_code_lengths = [0]*19 # confusing variable name... for i in self.CODE_LENGTH_ORDER[:self["huff_num_code_length_codes"].value+4]: field = Bits(self, "huff_code_length_code[%i]" % i, 3, "Code lengths for the code length alphabet") yield field code_length_code_lengths[i] = field.value code_length_tree = build_tree(code_length_code_lengths) length_code_lengths = [] distance_code_lengths = [] for numcodes, name, lengths in ( (self["huff_num_length_codes"].value + 257, "length", length_code_lengths), (self["huff_num_distance_codes"].value + 1, "distance", distance_code_lengths)): while len(lengths) < numcodes: field = HuffmanCode(self, "huff_%s_code[]" % name, code_length_tree) value = field.realvalue if value < 16: prev_value = value field._description = "Literal Code Length %i (Huffman Code %i)" % (value, field.value) yield field lengths.append(value) else: info = {16: (3,6,2), 17: (3,10,3), 18: (11,138,7)}[value] if value == 16: repvalue = prev_value else: repvalue = 0 field._description = "Repeat Code %i, Repeating value (%i) %i to %i times (Huffman Code %i)" % (value, repvalue, info[0], info[1], field.value) yield field extrafield = Bits(self, "huff_%s_code_extra[%s" % (name, field.name.split('[')[1]), info[2]) num_repeats = extrafield.value+info[0] extrafield._description = "Repeat Extra Bits (%i), total repeats %i"%(extrafield.value, num_repeats) yield extrafield lengths += [repvalue]*num_repeats length_tree = build_tree(length_code_lengths) distance_tree = build_tree(distance_code_lengths) else: raise ParserError("Unsupported compression type 3!") while True: field = HuffmanCode(self, "length_code[]", length_tree) value = field.realvalue if value < 256: field._description = "Literal Code %r (Huffman Code %i)" % (chr(value), field.value) yield field self.uncomp_data += chr(value) if value == 256: field._description = "Block Terminator Code (256) (Huffman Code %i)" % field.value yield field break elif value > 256: info = self.LENGTH_SYMBOLS[value] if info[2] == 0: field._description = "Length Code %i, Value %i (Huffman Code %i)" % (value, info[0], field.value) length = info[0] yield field else: field._description = "Length Code %i, Values %i to %i (Huffman Code %i)" % (value, info[0], info[1], field.value) yield field extrafield = Bits(self, "length_extra[%s" % field.name.split('[')[1], info[2]) length = extrafield.value + info[0] extrafield._description = "Length Extra Bits (%i), total length %i"%(extrafield.value, length) yield extrafield field = HuffmanCode(self, "distance_code[]", distance_tree) value = field.realvalue info = self.DISTANCE_SYMBOLS[value] if info[2] == 0: field._description = "Distance Code %i, Value %i (Huffman Code %i)" % (value, info[0], field.value) distance = info[0] yield field else: field._description = "Distance Code %i, Values %i to %i (Huffman Code %i)" % (value, info[0], info[1], field.value) yield field extrafield = Bits(self, "distance_extra[%s" % field.name.split('[')[1], info[2]) distance = extrafield.value + info[0] extrafield._description = "Distance Extra Bits (%i), total length %i"%(extrafield.value, distance) yield extrafield self.uncomp_data = extend_data(self.uncomp_data, length, distance)
def createFields(self): yield Bits(self, "block_type", 3) yield Bits(self, "block_size", 24) self.uncompressed_size = self["block_size"].value self.compression_level = self.root.compr_level self.window_size = self.WINDOW_SIZE[self.compression_level] self.block_type = self["block_type"].value curlen = len(self.parent.uncompressed_data) if self.block_type in (1, 2): # Verbatim or aligned offset block if self.block_type == 2: for i in xrange(8): yield Bits(self, "aligned_len[]", 3) aligned_tree = build_tree([self['aligned_len[%d]'%i].value for i in xrange(8)]) yield LZXPreTreeEncodedTree(self, "main_tree_start", 256) yield LZXPreTreeEncodedTree(self, "main_tree_rest", self.window_size * 8) main_tree = build_tree(self["main_tree_start"].lengths + self["main_tree_rest"].lengths) yield LZXPreTreeEncodedTree(self, "length_tree", 249) length_tree = build_tree(self["length_tree"].lengths) current_decoded_size = 0 while current_decoded_size < self.uncompressed_size: if (curlen+current_decoded_size) % 32768 == 0 and (curlen+current_decoded_size) != 0: padding = paddingSize(self.address + self.current_size, 16) if padding: yield PaddingBits(self, "padding[]", padding) field = HuffmanCode(self, "main_code[]", main_tree) if field.realvalue < 256: field._description = "Literal value %r" % chr(field.realvalue) current_decoded_size += 1 self.parent.uncompressed_data += chr(field.realvalue) yield field continue position_header, length_header = divmod(field.realvalue - 256, 8) info = self.POSITION_SLOTS[position_header] if info[2] == 0: if info[0] == 0: position = self.parent.r0 field._description = "Position Slot %i, Position [R0] (%i)" % (position_header, position) elif info[0] == 1: position = self.parent.r1 self.parent.r1 = self.parent.r0 self.parent.r0 = position field._description = "Position Slot %i, Position [R1] (%i)" % (position_header, position) elif info[0] == 2: position = self.parent.r2 self.parent.r2 = self.parent.r0 self.parent.r0 = position field._description = "Position Slot %i, Position [R2] (%i)" % (position_header, position) else: position = info[0] - 2 self.parent.r2 = self.parent.r1 self.parent.r1 = self.parent.r0 self.parent.r0 = position field._description = "Position Slot %i, Position %i" % (position_header, position) else: field._description = "Position Slot %i, Positions %i to %i" % (position_header, info[0] - 2, info[1] - 2) if length_header == 7: field._description += ", Length Values 9 and up" yield field length_field = HuffmanCode(self, "length_code[]", length_tree) length = length_field.realvalue + 9 length_field._description = "Length Code %i, total length %i" % (length_field.realvalue, length) yield length_field else: field._description += ", Length Value %i (Huffman Code %i)"%(length_header + 2, field.value) yield field length = length_header + 2 if info[2]: if self.block_type == 1 or info[2] < 3: # verbatim extrafield = Bits(self, "position_extra[%s" % field.name.split('[')[1], info[2]) position = extrafield.value + info[0] - 2 extrafield._description = "Position Extra Bits (%i), total position %i"%(extrafield.value, position) yield extrafield else: # aligned offset position = info[0] - 2 if info[2] > 3: extrafield = Bits(self, "position_verbatim[%s" % field.name.split('[')[1], info[2]-3) position += extrafield.value*8 extrafield._description = "Position Verbatim Bits (%i), added position %i"%(extrafield.value, extrafield.value*8) yield extrafield if info[2] >= 3: extrafield = HuffmanCode(self, "position_aligned[%s" % field.name.split('[')[1], aligned_tree) position += extrafield.realvalue extrafield._description = "Position Aligned Bits (%i), total position %i"%(extrafield.realvalue, position) yield extrafield self.parent.r2 = self.parent.r1 self.parent.r1 = self.parent.r0 self.parent.r0 = position self.parent.uncompressed_data = extend_data(self.parent.uncompressed_data, length, position) current_decoded_size += length elif self.block_type == 3: # Uncompressed block padding = paddingSize(self.address + self.current_size, 16) if padding: yield PaddingBits(self, "padding[]", padding) else: yield PaddingBits(self, "padding[]", 16) self.endian = LITTLE_ENDIAN yield UInt32(self, "r[]", "New value of R0") yield UInt32(self, "r[]", "New value of R1") yield UInt32(self, "r[]", "New value of R2") self.parent.r0 = self["r[0]"].value self.parent.r1 = self["r[1]"].value self.parent.r2 = self["r[2]"].value yield RawBytes(self, "data", self.uncompressed_size) self.parent.uncompressed_data+=self["data"].value if self["block_size"].value % 2: yield PaddingBits(self, "padding", 8) else: raise ParserError("Unknown block type %d!"%self.block_type)
def createFields(self): yield Bits(self, "int_part", int_bits) yield Bits(self, "float_part", float_bits)
def createRawDisplay(self): return unicode(Bits.createValue(self))
def createValue(self): value = Bits.createValue(self) return 1 + float(value) / (2**self.size)
def createRawDisplay(self): value = Bits.createValue(self) return unicode(value)
def createValue(self): value = Bits.createValue(self) return handler(value)
def __init__(self, parent, name, size): Bits.__init__(self, parent, name, size) self.bias = 2**(size - 1) - 1
def createValue(self): value = Bits.createValue(self) return durationWin64(value)