Python field.Bits类代码示例

 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):
     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 __init__(self, parent, name):
     Bits.__init__(self, parent, name, 4)

 def createValue(self):
     return Bits.createValue(self) - self.bias

 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 __init__(self, parent, name, size, description=None):
     Bits.__init__(self, parent, name, size, description)

 def __nonzero__(self):
     return Bits.createValue(self) != 0

 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]
#.........这里部分代码省略.........

 def createDisplay(self):
     if self._display_pattern:
         return u"<padding pattern=%s>" % self.pattern
     else:
         return Bits.createDisplay(self)

 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 createRawDisplay(self):
     return unicode(Bits.createValue(self))