def testFromFile(self): s = CBS(filename='test.m1v') self.assertEqual(s[0:32].hex, '000001b3') self.assertEqual(s.read(8 * 4).hex, '000001b3') width = s.read(12).uint height = s.read(12).uint self.assertEqual((width, height), (352, 288))
def from_bytes(cls, bitstream): packet = cls() # Convert to ConstBitStream (if not already provided) if not isinstance(bitstream, ConstBitStream): if isinstance(bitstream, Bits): bitstream = ConstBitStream(auto=bitstream) else: bitstream = ConstBitStream(bytes=bitstream) # Read the next header type packet.next_header = bitstream.read('uint:8') # Read the header length, given in multiples of 8 octets header_length = bitstream.read('uint:8') + 1 # Read the options options_length = (header_length * 8) - 2 packet.options = bitstream.read('bytes:%d' % options_length) # And the rest is payload remaining = bitstream[bitstream.pos:] packet.payload = remaining.bytes payload_class = protocol_registry.get_type_class(packet.next_header) if payload_class: packet.payload = payload_class.from_bytes(packet.payload) # Verify that the properties make sense packet.sanitize() return packet
def testReading(self): s = CBS(uie=333) a = s.read('uie') self.assertEqual(a, 333) s = CBS('uie=12, sie=-9, sie=9, uie=1000000') u = s.unpack('uie, 2*sie, uie') self.assertEqual(u, [12, -9, 9, 1000000])
def from_bytes(cls, bitstream): ''' +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | /| Priority | Weight | M Priority | M Weight | | L +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | o | Unused Flags |L|p|R| Loc-AFI | | c +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | \| Locator | +-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ''' record = cls() # Convert to ConstBitStream (if not already provided) if not isinstance(bitstream, ConstBitStream): if isinstance(bitstream, Bits): bitstream = ConstBitStream(auto=bitstream) else: bitstream = ConstBitStream(bytes=bitstream) # Read the priorities and weights (record.priority, record.weight, record.m_priority, record.m_weight) = bitstream.readlist('4*uint:8') # Read over unused flags record.reserved = bitstream.read(13) # Read the flags (record.local, record.probed_locator, record.reachable) = bitstream.readlist('3*bool') # Read the locator record.address = read_afi_address_from_bitstream(bitstream) return record
def testReadingLines(self): s = b"This is a test\nof reading lines\nof text\n" b = CBS(bytes=s) n = bitstring.Bits(bytes=b'\n') self.assertEqual(b.readto(n).bytes, b'This is a test\n') self.assertEqual(b.readto(n).bytes, b'of reading lines\n') self.assertEqual(b.readto(n).bytes, b'of text\n')
def testReadingErrors(self): s = CBS(10) with self.assertRaises(bitstring.ReadError): s.read('uie') self.assertEqual(s.pos, 0) with self.assertRaises(bitstring.ReadError): s.read('sie') self.assertEqual(s.pos, 0)
def testByteAligned(self): a = CBS('0xaabb00aa00bb') b = a.readto('0x00', bytealigned=True) self.assertEqual(b, '0xaabb00') self.assertEqual(a.bytepos, 3) b = a.readto('0xaa', bytealigned=True) self.assertEqual(b, '0xaa') self.assertRaises(bitstring.ReadError, a.readto, '0xcc', bytealigned=True)
def testUnpackingBytes(self): s = CBS(80) t = s.unpack('bytes:1') self.assertEqual(t[0], b'\x00') a, b, c = s.unpack('bytes:1, bytes, bytes:2') self.assertEqual(a, b'\x00') self.assertEqual(b, b'\x00' * 7) self.assertEqual(c, b'\x00' * 2)
def testByteAligned(self): a = CBS("0xaabb00aa00bb") b = a.readto("0x00", bytealigned=True) self.assertEqual(b, "0xaabb00") self.assertEqual(a.bytepos, 3) b = a.readto("0xaa", bytealigned=True) self.assertEqual(b, "0xaa") self.assertRaises(bitstring.ReadError, a.readto, "0xcc", bytealigned=True)
def testUnpackingBytes(self): s = CBS(80) t = s.unpack("bytes:1") self.assertEqual(t[0], b"\x00") a, b, c = s.unpack("bytes:1, bytes, bytes:2") self.assertEqual(a, b"\x00") self.assertEqual(b, b"\x00" * 7) self.assertEqual(c, b"\x00" * 2)
def tableBtreeEqualitySearch(currentPageBitstream, fpt, rowid, pageSize): """ -equality search in a table btree for (a,a) and (a, b) based on the Emp_ID (the indexed column) -the other two only need to scan, no performance enhancement -only the leaf pages have the data @param currentPageBitstream: the bitstream reader of a page @param fpt: the file pointer of a page @param rowid: look for a record with this rowid @param pageSize: the page size of the db """ pageType, numCells, toPosition, rightMostPointer = _pageInfo(currentPageBitstream) readCounts(pageType) # read each cell offset within the page from the cell pointer array for i in range(0, numCells): cellOffset = bitstreamReadAtOffset(currentPageBitstream, int, 'bytes:2', i * 2 + toPosition) # read the cell from cellOffset nxtChildPage, record = parse_cell_content(cellOffset, currentPageBitstream, pageType, fpt, pageSize) # interior cell cases if nxtChildPage: # get the rowid currentRowid, _, _ = readVarintAtOffset(cellOffset + POINTER_SIZE, currentPageBitstream) if rowid <= currentRowid: # keep traverse to the left of this cell nxtPagebitstream = ConstBitStream(readPage(nxtChildPage, fpt, pageSize)) tableBtreeEqualitySearch(nxtPagebitstream, fpt, rowid, pageSize) return # when the rowid > currentRowid ==> iterate nxt cell to try continue '''in the leaf page''' # get the rowid of the cell _, _, varintBytes = readVarintAtOffset(cellOffset, currentPageBitstream) currentRowid, _, _ = readVarintAtOffset(cellOffset + varintBytes, currentPageBitstream) if currentRowid == rowid: # found the record print("Full Name: {} {} {}".format(record[FIRST_NAME_INDEX], record[MIDDLE_NAME_INDEX], record[LAST_NAME_INDEX])) return elif currentRowid > rowid: # ==> the rest of cell in this page has greater rowid return # iterate the nxt cell to check equality if rightMostPointer: nxtPagebitstream = ConstBitStream(readPage(rightMostPointer, fpt, pageSize)) tableBtreeEqualitySearch(nxtPagebitstream, fpt, rowid, pageSize) else: # sanity check for debug print("record not found")
def testStringRepresentationFromFile(self): s = CBS(filename='test.m1v', pos=2001) self.assertEqual( s.__repr__(), "ConstBitStream(filename='test.m1v', length=1002400, pos=2001)") s.pos = 0 self.assertEqual( s.__repr__(), "ConstBitStream(filename='test.m1v', length=1002400)")
def __init__(self, fileString): self.stream = ConstBitStream(filename=fileString) name_b, self.width, self.height, self.depth, self.timepoints, self.channels, self.bytesPerPix, packingOrder_idx = self.stream.readlist('bytes:64, uintle:32, uintle:32, uintle:32, uintle:32, uintle:32, uintle:32, uintle:32') self.packingOrder = GetFilePackingOrder(packingOrder_idx) self.name = StringFromBytes(name_b) self.channelNames = [] for i in range(self.channels): self.channelNames.append(StringFromBytes(self.stream.read('bytes:32'))) self.imageMap = [] n = self.channels * self.depth * self.timepoints for i in range(n): nBytes = self.stream.read('uintle:32') self.imageMap.append({'offset': self.stream.bytepos, 'nBytes': nBytes}) if i < (n - 1): self.stream.bytepos += nBytes def BaseLookUpFunc(first, second, third, n1, n2): nf = len(first) ns = len(second) nt = len(third) first = np.repeat(first, ns * nt) second = np.tile(np.repeat(second, nt), nf) third = np.tile(third, nf * ns) return (first * n1) + (second * n2) + third if self.packingOrder == file_packing_order['ZTC']: def LookUpFunc(z, t, c): return BaseLookUpFunc(c, t, z, self.depth * self.timepoints, self.depth) elif self.packingOrder == file_packing_order['ZCT']: def LookUpFunc(z, t, c): return BaseLookUpFunc(t, c, z, self.depth * self.channels, self.depth) elif self.packingOrder == file_packing_order['TZC']: def LookUpFunc(z, t, c): return BaseLookUpFunc(c, z, t, self.depth * self.timepoints, self.timepoints) elif self.packingOrder == file_packing_order['TCZ']: def LookUpFunc(z, t, c): return BaseLookUpFunc(z, c, t, self.timepoints * self.channels, self.timepoints) elif self.packingOrder == file_packing_order['CZT']: def LookUpFunc(z, t, c): return BaseLookUpFunc(t, z, c, self.depth * self.channels, self.channels) elif self.packingOrder == file_packing_order['CTZ']: def LookUpFunc(z, t, c): return BaseLookUpFunc(z, t, c, self.timepoints * self.channels, self.channels) self._LookUpFunc_ = LookUpFunc if self.bytesPerPix == 4: dt = np.dtype(np.uint32) elif self.bytesPerPix == 2: dt = np.dtype(np.uint16) elif self.bytesPerPix == 1: dt = np.dtype(np.uint8) self._dt_ = dt.newbyteorder('<')
def __init__(self, src, *args, **kwargs): super(EC3SpecificBox,self).__init__(src, *args,**kwargs) data = src.read(self.size) bs = ConstBitStream(bytes=data) self.data_rate = bs.read('uint:13') self.num_ind_sub = 1+bs.read('uint:3') self.substreams = [] for i in range(self.num_ind_sub): self.substreams.append(EC3SpecificBox.SubStream(bs))
def __init__(self, f, read=True): if read: self.file = ConstBitStream(f.read()) else: self.file = ConstBitStream(f) self.file.pos = self.identifier_offset identifier = self.file.peek(f'bytes:{self.identifier_size}') if identifier != b'Joker': raise ValueError('Input not a Joker container file')
def pack(self, for_game=False): is_translated = False if not self.solution.translated == "": is_translated = True # SAVE! output = BitStream() # Type flag if self.type == ANAGRAM_TYPE.Demo: output += DEMO_FLAG else: output += FULL_FLAG # Number of letters if is_translated: output += ConstBitStream(uintle=len(self.solution.translated), length=16) else: output += ConstBitStream(uintle=len(self.solution.original), length=16) # Magic output += ANAGRAM_MAGIC # File indexes output += ConstBitStream(uintle=self.solution_index, length=16) output += ConstBitStream(uintle=self.extra_index, length=16) # Unknown output += self.__unknown # Shown/unshown if is_translated: num_letters = len(self.solution.translated) output += self.pack_shown(self.easy, num_letters) output += self.pack_shown(self.normal, num_letters) if self.type == ANAGRAM_TYPE.Full: output += self.pack_shown(self.hard, num_letters) if not for_game: num_letters = len(self.solution.original) output += ConstBitStream(uintle=num_letters, length=16) if not is_translated or not for_game: # This shows up either way. num_letters = len(self.solution.original) output += self.pack_shown(self.easy_orig, num_letters) output += self.pack_shown(self.normal_orig, num_letters) if self.type == ANAGRAM_TYPE.Full: output += self.pack_shown(self.hard_orig, num_letters) return output
def __init__(self, file_name): """ Init method or constructor @:param self The object pointer @:param file_name it's the file that we want to read @:param stream it's the 8 bit stream """ self.file_name = file_name self.stream = ConstBitStream(filename=file_name)
def _parse_binary_feed(feed): logger.debug("Parsing binary feed %s", feed) binaryfeed = bytearray(b64decode(feed)) bitstream = ConstBitStream(binaryfeed) payload_encoding = binaryfeed[0] if payload_encoding != bitstream.read("uint:8"): raise PyiCloudBinaryFeedParseError( "Missmatch betweeen binaryfeed and bistream payload encoding") ASSET_PAYLOAD = 255 ASSET_WITH_ORIENTATION_PAYLOAD = 254 ASPECT_RATIOS = [ 0.75, 4.0 / 3.0 - 3.0 * (4.0 / 3.0 - 1.0) / 4.0, 4.0 / 3.0 - 2.0 * (4.0 / 3.0 - 1.0) / 4.0, 1.25, 4.0 / 3.0, 1.5 - 2.0 * (1.5 - 4.0 / 3.0) / 3.0, 1.5 - 1.0 * (1.5 - 4.0 / 3.0) / 3.0, 1.5, 1.5694444444444444, 1.6388888888888888, 1.7083333333333333, 16.0 / 9.0, 2.0 - 2.0 * (2.0 - 16.0 / 9.0) / 3.0, 2.0 - 1.0 * (2.0 - 16.0 / 9.0) / 3.0, 2, 3 ] valid_payloads = [ASSET_PAYLOAD, ASSET_WITH_ORIENTATION_PAYLOAD] if payload_encoding not in valid_payloads: raise PyiCloudBinaryFeedParseError("Unknown payload encoding '%s'" % payload_encoding) assets = {} while len(bitstream) - bitstream.pos >= 48: range_start = bitstream.read("uint:24") range_length = bitstream.read("uint:24") range_end = range_start + range_length logger.debug("Decoding indexes [%s-%s) (length %s)", range_start, range_end, range_length) previous_asset_id = 0 for index in range(range_start, range_end): aspect_ratio = ASPECT_RATIOS[bitstream.read("uint:4")] id_size = bitstream.read("uint:2") if id_size: # A size has been reserved for the asset id asset_id = bitstream.read("uint:%s" % (2 + 8 * id_size)) else: # The id is just an increment to a previous id asset_id = previous_asset_id + bitstream.read("uint:2") + 1 orientation = None if payload_encoding == ASSET_WITH_ORIENTATION_PAYLOAD: orientation = bitstream.read("uint:3") assets[index] = PhotoAsset(asset_id, aspect_ratio, orientation) previous_asset_id = asset_id return assets
def testByteAligned(self): a = CBS('0xaabb00aa00bb') b = a.readto('0x00', bytealigned=True) self.assertEqual(b, '0xaabb00') self.assertEqual(a.bytepos, 3) b = a.readto('0xaa', bytealigned=True) self.assertEqual(b, '0xaa') with self.assertRaises(bitstring.ReadError): b.readto('0xcc', bytealigned=True)
def main(): file = open(sys.argv[1], "rb") msg = ConstBitStream(file) s_in = BitArray() keys = {Bits(''): 0} s_out = BitArray() count = 1 n_bits = 0 while True: try: s_in.append(msg.read(1)) except ReadError: break #Se a palavra nao tiver no dicionario if Bits(s_in) not in keys: # x = yb y = s_in[:-1] b = s_in[-1:] pos = keys[Bits(y)] #log base 2 |keys| n_bits = ceil(log2(len(keys))) if n_bits != 0: prefix = Bits(uint=int(pos), length=n_bits) else: prefix = Bits('') s_out.append(Bits('0b' + str(prefix.bin) + str(b.bin))) keys[Bits(s_in)] = count count += 1 s_in.clear() #Add padding: 00000 10101 #Numero de zeros é o tamanho dos bits extra para depois no descompressor saber if s_in[:1].bin == Bits(1): z = Bits('0b' + '0' * len(s_in)) else: z = Bits('0b' + '1' * len(s_in)) s_in.reverse() s_out.reverse() s_out.append(s_in) s_out.append(z) s_out.reverse() with open(sys.argv[2], 'wb') as f_out: s_out.tofile(f_out) file.close()
def indexBtreeEqualitySearch(currentPageBitstream, fpt, empID, ops, pageSize): """ equality search in the index btree (c,b) and (d, c) may need to search through this to get the rowid then go back to the table btree to get the actual record return the rowid of empID record @param currentPageBitstream: the bitstream for the index page; start from the root page of a index tree @param fpt: the file pointer of a page @param empID: the condition to be search; assume empID is the indexed column; should be sorted in the index btree @param ops: the operation to be done for each record @param pageSize: the page size of the db """ pageType, numCells, toPosition, rightMostPointer = _pageInfo(currentPageBitstream) readCounts(pageType) # store the child pointer of the previous cell result = -1 # determine the direction of traversing the cells start, end, step = 0, numCells, 1 # read each cell offset within the page from the cell pointer array for i in range(start, end, step): cellOffset = bitstreamReadAtOffset(currentPageBitstream, int, 'bytes:2', i * 2 + toPosition) # read the cell from cellOffset nxtChildPage, record = parse_cell_content(cellOffset, currentPageBitstream, pageType, fpt, pageSize) # for debug if not record: print("This is not a index btree page") break # if found a matching record ==> no need to search result = ops(record) if result: break # need to traversethe pointer of the cell since we want to find the best matching if empID < record[0]: # by the sorted properties and in the leaf page ==> empID << record for all cells if not nxtChildPage: break nxtPagebitstream = ConstBitStream(readPage(nxtChildPage, fpt, pageSize)) return indexBtreeEqualitySearch(nxtPagebitstream, fpt, empID, ops, pageSize) # if empID > record[0], iterate the nxt cell; let the cell key get closer to the empID from the left if rightMostPointer: nxtPagebitstream = ConstBitStream(readPage(rightMostPointer, fpt, pageSize)) return indexBtreeEqualitySearch(nxtPagebitstream, fpt, empID, ops, pageSize) return result
def handleDump(fileObj): tech = [] raw = ConstBitStream(fileObj) try: while True: tech.append(raw.read('floatle:32')) except: pass del(raw) return tech
def testRead(self): s = CBS("0b100011110001") a = s.read("pad:1") self.assertEqual(a, None) self.assertEqual(s.pos, 1) a = s.read(3) self.assertEqual(a, CBS("0b000")) a = s.read("pad:0") self.assertEqual(a, None) self.assertEqual(s.pos, 4)
def make_step(self, motor_id, direction, steps_per_click): data = ConstBitStream('0x1400') data += ConstBitStream('intle:16=%d' % command.MAKE_STEP) data += ConstBitStream('intle:16=%d' % (2 * (motor_id == 0) * (direction - .5) * steps_per_click)) data += ConstBitStream('intle:16=%d' % (2 * (motor_id == 1) * (direction - .5) * steps_per_click)) tmp = self._make_connection(data)
def testRead(self): s = CBS('0b100011110001') a = s.read('pad:1') self.assertEqual(a, None) self.assertEqual(s.pos, 1) a = s.read(3) self.assertEqual(a, CBS('0b000')) a = s.read('pad:0') self.assertEqual(a, None) self.assertEqual(s.pos, 4)
def handle_read(self): #format: 20 bytes in total. Size: intle:16 #Incomming messages comes with 160 bytes.. data0 = self.recv(160); if data0: data = ConstBitStream(bytes=data0, length=160) #print "All: %s" % data.bin msize = data.read('intle:16') mtype = data.read('intle:16') mtime = data.read('intle:64') # RA: ant_pos = data.bitpos ra = data.read('hex:32') data.bitpos = ant_pos ra_uint = data.read('uintle:32') # DEC: ant_pos = data.bitpos dec = data.read('hex:32') data.bitpos = ant_pos dec_int = data.read('intle:32') #______ Testing: # Sends back to Stellarium the received coordinates, in order to update the field of view indicator (sra, sdec, stime) = coords.eCoords2str(float("%f" % ra_uint), float("%f" % dec_int), float("%f" % mtime)) self.act_pos(coords.hourStr_2_rad(sra), coords.degStr_2_rad(sdec)) #______ End Testing # Emits the signal with received equatorial coordinates (for use in external Qt Gui..) self.stell_pos_recv.emit("%f" % ra_uint, "%f" % dec_int, "%f" % mtime)
def handle_read(self): #format: 20 bytes in total. Size: intle:16 #Incomming messages comes with 160 bytes.. data0 = self.recv(160); if data0: data = ConstBitStream(bytes=data0, length=160) print "All: %s" % data.bin msize = data.read('intle:16') mtype = data.read('intle:16') mtime = data.read('intle:64') # RA: ant_pos = data.bitpos ra = data.read('hex:32') data.bitpos = ant_pos ra_uint = data.read('uintle:32') # DEC: ant_pos = data.bitpos dec = data.read('hex:32') data.bitpos = ant_pos dec_int = data.read('intle:32') logging.debug("Size: %d, Type: %d, Time: %d, RA: %d (%s), DEC: %d (%s)" % (msize, mtype, mtime, ra_uint, ra, dec_int, dec)) (sra, sdec, stime) = coords.eCoords2str(float("%f" % ra_uint), float("%f" % dec_int), float("%f" % mtime)) #Sends back the coordinates to Stellarium self.act_pos(coords.hourStr_2_rad(sra), coords.degStr_2_rad(sdec))
def main(): test_file = sys.argv[1] f = open(os.path.join(os.getcwd(), test_file), "rb") s = ConstBitStream(f) try: file_type = s.read("bytes:3") if file_type == "FWS": print "Standard SWF" print "Version:", s.read("uintle:8") print "Size:", s.read("uintle:32"), "bytes" s = datatypes.rect(s) print "Frame rate: %d.%d" % datatypes.fixed_8(s) print "Frame count:", s.read("uintle:16") read_tag_headers(s) elif file_type == "CWS": print "Compressed SWF" print "Version:", s.read("uintle:8") print "Uncompressed size:", s.read("uintle:32"), "bytes" to_decompress = s[64:].tobytes() s = ConstBitStream(bytes=zlib.decompress(to_decompress)) s = datatypes.rect(s) print "Frame rate: %d.%d" % datatypes.fixed_8(s) print "Frame count:", s.read("uintle:16") read_tag_headers(s) # print "[Cannot currently parse]" finally: f.close()
def search(): try: s = ConstBitStream(filename=kipname) global find global find2 find = s.find('0x003C00121F280071' ) # Atmosphere 11 and 12 (set for 1 byte patch) find2 = s.find('0x01c0be121f00016b' ) # Atmosphere 13 > Current (set for 1 byte patch) except OSError as e: print("Unable to search files for this reason! %s" % e)
class JokerContainerFile: file = None # Offset/sizes in bytes identifier_offset = 0 identifier_size = 5 mode_offset = identifier_offset + identifier_size mode_size = 2 data_offset = mode_offset + mode_size + 1 # Skips unknown byte 0x01 between mode and data mode_f100_offset = data_offset + (7 * 8) def __init__(self, f, read=True): if read: self.file = ConstBitStream(f.read()) else: self.file = ConstBitStream(f) self.file.pos = self.identifier_offset identifier = self.file.peek(f'bytes:{self.identifier_size}') if identifier != b'Joker': raise ValueError('Input not a Joker container file') @property def mode(self): self.file.pos = self.mode_offset * 8 return self.file.peek(f'uintle:{self.mode_size * 8}') @property def _data(self): return self.file[self.data_offset * 8:] @property def data(self): data = self._data if self.mode == 0x0300 or self.mode == 0x0200: # Compressed/encrypted decompressed = zlib.decompress(data.tobytes())[:-1] decoded = bytes.fromhex(base64.b64decode(decompressed, validate=True).decode()) data = JokerCipher.decrypt(decoded) if self.mode == 0x300: data = self._process_mode_300(data) elif self.mode == 0xF100: return data[self.mode_f100_offset:] return data @staticmethod def _process_mode_300(data): decoded = base64.decodebytes(data) decrypted = DefaultCipher.decrypt(decoded) decompressed = zlib.decompress(decrypted) return decompressed
def parse_file_data(self, file_offset, length, data): # filter on the file ID for instance if file_offset.id == 64: # parse the data, in this example we are assuming the file data contains a temperature value in decicelsius # stored as int16, as transmitted by the sensor examples of OSS-7 s = ConstBitStream(bytes=bytearray(data)) sensor_value = s.read("uintbe:16") / 10.0 yield 'temperature', sensor_value, DataPointType.telemetry # note this is a generator function, so multiple values can be returned return
def decompress(data, bit_length, output_length): stream = ConstBitStream(bytes=data) result = [] while len(result) < output_length: t = stream.read(1) if t: count = stream.read(8).uint + 1 else: count = 1 result.extend([stream.read(bit_length).uint] * count) return bytes(result)
def _parse_binary_feed(self, feed): binaryfeed = bytearray(b64decode(feed)) bitstream = ConstBitStream(binaryfeed) payload_encoding = binaryfeed[0] if payload_encoding != bitstream.read("uint:8"): raise PyiCloudBinaryFeedParseError("Missmatch betweeen binaryfeed and bistream payload encoding") ASSET_PAYLOAD = 255 ASSET_WITH_ORIENTATION_PAYLOAD = 254 ASPECT_RATIOS = [ 0.75, 4.0 / 3.0 - 3.0 * (4.0 / 3.0 - 1.0) / 4.0, 4.0 / 3.0 - 2.0 * (4.0 / 3.0 - 1.0) / 4.0, 1.25, 4.0 / 3.0, 1.5 - 2.0 * (1.5 - 4.0 / 3.0) / 3.0, 1.5 - 1.0 * (1.5 - 4.0 / 3.0) / 3.0, 1.5, 1.5694444444444444, 1.6388888888888888, 1.7083333333333333, 16.0 / 9.0, 2.0 - 2.0 * (2.0 - 16.0 / 9.0) / 3.0, 2.0 - 1.0 * (2.0 - 16.0 / 9.0) / 3.0, 2, 3, ] valid_payloads = [ASSET_PAYLOAD, ASSET_WITH_ORIENTATION_PAYLOAD] if payload_encoding not in valid_payloads: raise PyiCloudBinaryFeedParseError("Unknown payload encoding '%s'" % payload_encoding) assets = {} while len(bitstream) - bitstream.pos >= 48: range_start = bitstream.read("uint:24") range_length = bitstream.read("uint:24") range_end = range_start + range_length previous_asset_id = 0 for index in range(range_start, range_end): aspect_ratio = ASPECT_RATIOS[bitstream.read("uint:4")] id_size = bitstream.read("uint:2") if id_size: # A size has been reserved for the asset id asset_id = bitstream.read("uint:%s" % (2 + 8 * id_size)) else: # The id is just an increment to a previous id asset_id = previous_asset_id + bitstream.read("uint:2") + 1 orientation = None if payload_encoding == ASSET_WITH_ORIENTATION_PAYLOAD: orientation = bitstream.read("uint:3") assets[index] = PhotoAsset(index, asset_id, aspect_ratio, orientation, self) previous_asset_id = asset_id return assets.values()
def render_calibrator(image, block_height, block_width, pixel_width): '''This creates the checkboard-like pattern along the top and left of the first frame of video streams, and every frame of image streams. This is what the reader uses to initially lock onto the frame. Stream block_width and block_height are encoded into this pattern, using alternating color palettes so no two repeating values produce a continuous block of color, interfering with the frame lock process.''' initializer_palette_dict_a = ValuesToColor(palette_grabber('1'), 'initializer_palette A') initializer_palette_dict_b = ValuesToColor(palette_grabber('11'), 'initializer_palette B') draw = ImageDraw.Draw(image) draw.rectangle((0, 0, pixel_width - 1, pixel_width - 1), fill='rgb(0,0,0)') block_width_encoded = BitArray(uint=block_width, length=block_width - 1) block_width_encoded.reverse() readable_block_width = ConstBitStream(block_width_encoded) for i in range(block_width - 1): next_bit = readable_block_width.read('bits : 1') if i % 2 == 0: color_value = initializer_palette_dict_b.get_color( ConstBitStream(next_bit)) else: color_value = initializer_palette_dict_a.get_color( ConstBitStream(next_bit)) draw.rectangle((pixel_width * i + pixel_width, 0, pixel_width * (i + 1) - 1 + pixel_width, pixel_width - 1), fill=f'rgb{str(color_value)}') block_height_encoded = BitArray(uint=block_height, length=block_height - 1) block_height_encoded.reverse() readable_block_height = ConstBitStream(block_height_encoded) for i in range(block_height - 1): next_bit = readable_block_height.read('bits : 1') if i % 2 == 0: color_value = initializer_palette_dict_b.get_color( ConstBitStream(next_bit)) else: color_value = initializer_palette_dict_a.get_color( ConstBitStream(next_bit)) draw.rectangle( (0, pixel_width * i + pixel_width, pixel_width - 1, pixel_width * (i + 1) - 1 + pixel_width), fill=f'rgb{str(color_value)}') return image
def search(): try: from bitstring import ConstBitStream s = ConstBitStream(filename=kipname) global find find = s.find(pattern) global findnew findnew = s.find(pattern2) except OSError as e: print("Error: %s : %s" % ("Search: ", e.strerror))
def degree_decodeFile(compressed_file_name): encoded_text = readFile(compressed_file_name) encoded_text = encoded_text.read('bin:{0}'.format(len(encoded_text))) encoded_text, file_name_lenght = getBits(encoded_text, 8) file_name_lenght = int(file_name_lenght, base=2) # gaunam failo pavadinimo ilgi encoded_text, file_name = getBits(encoded_text, file_name_lenght) file_name = ''.join( [chr(int(file_name[i:i + 8], base=2)) for i in range(0, len(file_name), 8)]) # gaunam orig. failo pav. encoded_text, degree = getBits(encoded_text, 8) degree = int(degree, base=2) encoded_text, context_huffman_list_lenght = getBits(encoded_text, 16 * int(degree)) context_huffman_list_lenght = int(context_huffman_list_lenght, base=2) # lenteles ilgis context_huffman_list = [] huffman_list = [] for i in range(context_huffman_list_lenght): encoded_text, context = getBits(encoded_text, 8 * degree) encoded_text, list_lenght = getBits(encoded_text, 8) list_lenght = int(list_lenght, base=2) for j in range(list_lenght): encoded_text, bite = getBits(encoded_text, 8) encoded_text, v_lenght = getBits(encoded_text, 8) v_lenght = int(v_lenght, base=2) # uzkodavimo ilgis v_size = bestSize(v_lenght) encoded_text, temp_value = getBits(encoded_text, v_size) temp_value = temp_value.replace('0', '', v_size - v_lenght) huffman_list.append([bite, temp_value]) context_huffman_list.append([context, huffman_list]) huffman_list = [] encoded_text, text_lenght = getBits(encoded_text, 32) text_lenght = int(text_lenght, base=2) # teksto ilgis text_full_size = bestSize(text_lenght) encoded_text, encoded_text = getBits(encoded_text, text_full_size) # uzkoduotas tekstas encoded_text = encoded_text.replace('0', '', text_full_size - text_lenght) if int(degree) == 1: bites = degree_decodeText(context_huffman_list, encoded_text) # atkoduojame else: bites = second_degree_burn_decodeText(context_huffman_list, encoded_text) text = ''.join(bites) # print(context_huffman_list) # print(text) with open(file_name, 'wb') as f: # orig. teksta atgal i faila write_buffer = ConstBitStream(bin=text) write_buffer.tofile(f)
def test_parsing(self): length_bytes = [0x01] length = Length.parse(ConstBitStream(bytes=length_bytes)) self.assertEqual(length.value, 1) length_bytes = [0x40, 0x41] length = Length.parse(ConstBitStream(bytes=length_bytes)) self.assertEqual(length.value, 65) length_bytes = [0xC0, 0x41, 0x10, 0x00] length = Length.parse(ConstBitStream(bytes=length_bytes)) self.assertEqual(length.value, 4263936)
def __init__(self, bin_data=None, rw=False): """Initialising the class with an byte (octet) array or make a new, empty one. :param bin_data: Byte array. :param rw: If bin_data is set, make it read/write-able, otherwise it's read-only. """ if bin_data is None: self._data = BitStream() elif rw: self._data = BitStream(bytes=bin_data) else: self._data = ConstBitStream(bytes=bin_data) self.reset()
def _parse_request(bytes, path): stream = ConstBitStream(bytes=bytes) pos = stream.find(Bits(bytes=b'\r\n\r\n'), bytealigned=True)[0] # For now I don't care about the request body. header_bytes, _ = stream[:pos], stream[pos + 32:] headers = dict() header_lines = header_bytes.bytes.decode("ascii").split('\r\n') for h in header_lines[1:]: splits = h.split(":") headers[splits[0]] = splits[1].strip() return HttpRequest(headers, path, None)
def apply_sys_lang(eboot): if LANG_CFG_ID in common.editor_config.hacks: sys_menu_lang = common.editor_config.hacks[LANG_CFG_ID] else: sys_menu_lang = 1 common.editor_config.hacks[LANG_CFG_ID] = sys_menu_lang patch_loc = 0x1B300 patch = ConstBitStream(uintle = sys_menu_lang, length = 8) + ConstBitStream(hex = "0x000224") eboot.overwrite(patch, patch_loc * 8) return eboot
def from_bytes(cls, bitstream): """ Parse the given record and update properties accordingly """ record = cls() # Convert to ConstBitStream (if not already provided) if not isinstance(bitstream, ConstBitStream): if isinstance(bitstream, Bits): bitstream = ConstBitStream(auto=bitstream) else: bitstream = ConstBitStream(bytes=bitstream) # Read the record TTL record.ttl = bitstream.read("uint:32") # Store the locator record count until we need it referral_count = bitstream.read("uint:8") # Store the EID prefix mask length until we need it eid_prefix_len = bitstream.read("uint:8") # Read the Negative Map_Reply action record.action = bitstream.read("uint:3") # Read the flags (record.authoritative, record.incomplete) = bitstream.readlist("2*bool") # Read reserved bits record._reserved1 = bitstream.read(11) # Read the signature count sig_count = bitstream.read("uint:4") # Read the map version record.map_version = bitstream.read("uint:12") # Read the EID prefix record.eid_prefix = read_afi_address_from_bitstream(bitstream, eid_prefix_len) # Read the locator records for dummy in range(referral_count): locator_record = LocatorRecord.from_bytes(bitstream) record.locator_records.append(locator_record) # TODO: Can't handle signatures yet! [LISP-Security] if sig_count: raise NotImplementedError("Cannot handle signatures yet") # Verify that the properties make sense record.sanitize() return record
def bzip0_decode(in_bytes): in_data = ConstBitStream(in_bytes) out_data = BitArray() try: while True: encoded_block_size = in_data.read(f'uint:{BLOCK_SIZE_BITS}') encoded_block = in_data.read(f'bytes:{encoded_block_size}') decoded_block = decode_block(encoded_block) out_data.append(decoded_block) except ReadError: pass return out_data.tobytes()
def parse_file_data(self, file_offset, data): # filter on the file ID for instance if file_offset.id == 64: # parse the data, in this example we are assuming the file data contains 2 sensor values of type int8 # note this is a generator function, so multiple values can be returned s = ConstBitStream(bytes=bytearray(data)) sensor_value = s.read("int:8") yield 'my-sensorvalue1', sensor_value, DataPointType.telemetry sensor_value = s.read("int:8") yield 'my-sensorvalue2', sensor_value, DataPointType.telemetry return
def bzip0_encode(in_bytes): in_data = ConstBitStream(in_bytes) out_data = BitArray() while in_data.bitpos < in_data.length: block_size = min((in_data.length - in_data.bitpos) // 8, 2**BLOCK_SIZE_BITS - 1) block_data = in_data.read(f'bytes:{block_size}') encoded_block = encode_block(block_data) encoded_block_size = len(encoded_block) out_data.append(Bits(uint=encoded_block_size, length=BLOCK_SIZE_BITS)) out_data.append(encoded_block) return out_data.tobytes()
def lz77_decode(encoded_data, window_bits=DEFAULT_WINDOW_BITS): encoded = ConstBitStream(encoded_data) tokens = [] try: while True: pfx_dist = encoded.read(f'uint:{window_bits}') pfx_len = encoded.read(f'uint:{REFERENCE_SIZE_BITS}') next_ch = encoded.read('uint:8') tokens.append((pfx_dist, pfx_len, next_ch)) except ReadError: pass return lz77_decode_from_tokens(tokens)
def parse_one_frame_from_buffer(self): retry = True # until we have one or don't have enough errors = [] frame = None bits_parsed = 0 while retry and len(self.buffer) > 0: try: self.s = ConstBitStream(bytes=self.buffer) frame = self.parse_frame() bits_parsed = self.s.pos self.shift_buffer(bits_parsed/8) retry = False # got one, carry on except ReadError as e: # not enough to read, carry on and wait for more retry = False except ParseError as e: # actual problem with current buffer, need to skip errors.append({ "error" : e.args[0], "buffer" : list(self.buffer), "pos" : self.s.pos, "skipped" : self.skip_bad_buffer_content() }) info = { "parsed" : bits_parsed, "buffer" : len(self.buffer) * 8, "errors" : errors } return (frame, info)
def test_afi_2_with_prefixlen(self): ''' Test decoding of AFI 2 (IPv6) prefixes ''' afi_address_hex = '000220010db80102abcd0000000000000000' bitstream = ConstBitStream(hex=afi_address_hex) address = afi.read_afi_address_from_bitstream(bitstream, 64) self.assertEqual(address, IPv6Network(u'2001:db8:102:abcd::/64')) self.assertEqual(bitstream.pos, bitstream.len, 'unprocessed bits remaining in bitstream') new_bitstream = afi.get_bitstream_for_afi_address(address) self.assertEqual(new_bitstream.tobytes(), bitstream.tobytes())
def test_afi_0_without_prefixlen(self): ''' Test en/decoding of empty AFI addresses ''' afi_address_hex = '0000' bitstream = ConstBitStream(hex=afi_address_hex) address = afi.read_afi_address_from_bitstream(bitstream) self.assertIsNone(address, 'wrong address') self.assertEqual(bitstream.pos, bitstream.len, 'unprocessed bits remaining in bitstream') new_bitstream = afi.get_bitstream_for_afi_address(address) self.assertEqual(new_bitstream.tobytes(), bitstream.tobytes())
def test_afi_1_with_prefixlen(self): ''' Test decoding of AFI 1 (IPv4) prefixes ''' afi_address_hex = '0001c0000200' bitstream = ConstBitStream(hex=afi_address_hex) address = afi.read_afi_address_from_bitstream(bitstream, 24) self.assertEqual(address, IPv4Network(u'192.0.2.0/24')) self.assertEqual(bitstream.pos, bitstream.len, 'unprocessed bits remaining in bitstream') new_bitstream = afi.get_bitstream_for_afi_address(address) self.assertEqual(new_bitstream.tobytes(), bitstream.tobytes())
def ff(file, mode='unknown'): '''Read header from data file.''' infile = open(file, 'r') oldheader = infile.read(8) # Finds "Dartmouth" s = ConstBitStream(filename=file) found = s.find('0x446172746d6f757468', bytealigned=True) if found: print("Found start code at byte offset %d." % found[0]) # s0f0, length, bitdepth, height, width = s.readlist('hex: 16, uint: 16, # uint: 8, 2 * uint: 16') # print("Width %d, Height %d" % (width, height)) else: print("No way!!") if oldheader[0:6] == "999999" and mode == 'unknown': if oldheader[6:8] == "01": mode = 'head' elif oldheader[6:8] == "04": mode = 'tail' else: print "ff(): Mode not defined in input or old header" return(1) elif oldheader[0:6] != "999999" and mode != 'tail': print "ff(): No valid GGSE header signature." return(1) if mode == 'head': header = infile.read(8184) elif mode == 'tail': infile.seek(-8192, os.SEEK_END) header = infile.read(8192) else: print "ff(): Unknown mode." return(1) infile.close() try: fhead = fs(header) except confp.ParsingError or confp.MissingSectionHeaderError: print "ff(): error parsing file: No header in " + mode + " of file?" fhead = 1 return fhead
def parse(self): f = open(self.filename,"rb") self._bitstream = ConstBitStream(f) try: self.parse_header() self.parse_tags() finally: f.close()
def test_afi_0_with_prefixlen_0(self): ''' Although a prefix length of 0 is allowed (since that is how many implementations transmit it on the wire) ''' afi_address_hex = '0000' bitstream = ConstBitStream(hex=afi_address_hex) address = afi.read_afi_address_from_bitstream(bitstream, 0) self.assertIsNone(address, 'wrong address') self.assertEqual(bitstream.pos, bitstream.len, 'unprocessed bits remaining in bitstream') new_bitstream = afi.get_bitstream_for_afi_address(address) self.assertEqual(new_bitstream.tobytes(), bitstream.tobytes())
def huff_decode(enc_file): enc = ConstBitStream(enc_file) tree = [] tree_sz = enc.read("uint:8") while tree_sz > 0: s = enc.read("bytes:1") c_sz = enc.read("uint:8") c = BitArray(enc.read("bits:"+str(c_sz))) tree.append([s, c]) tree_sz -= 1 tree = sorted(tree, key = lambda v: v[1].len) text = "" while True: try: found = False for s,c in tree: if enc.startswith(c, enc.pos): print enc[enc.pos:].bin code = enc.read("bits:"+str(c.len)) text += s found = True break if found == False: raise ReadError except ReadError: break return text
def handle_read(self): data0 = self.recv(160); if data0: data = ConstBitStream(bytes=data0, length=160) # print "All: %s" % data.bin msize = data.read('intle:16') mtype = data.read('intle:16') mtime = data.read('intle:64') # RA: ant_pos = data.bitpos ra = data.read('hex:32') data.bitpos = ant_pos ra_uint = data.read('uintle:32') # DEC: ant_pos = data.bitpos dec = data.read('hex:32') data.bitpos = ant_pos dec_int = data.read('intle:32') logging.debug("Size: %d, Type: %d, Time: %d, RA: %d (%s), DEC: %d (%s)" % (msize, mtype, mtime, ra_uint, ra, dec_int, dec)) (ra, dec, time) = coords.int_2_rads(ra_uint, dec_int, mtime) x = transformar_coordenadas(dec, ra) az,alt = x.get_azi_alt() #instancia o motor de azimute nos pinos 12, 16, 20 e 21 do RPi motor_az = Motor([31,33,35,37]) motor_az.rpm = 5 motor_az.mode = 2 motor_az.move_to(az-self.az_anterior) self.az_anterior = az #instancia o motor de azimute nos pinos 32, 36, 38 e 40 do RPi motor_alt = Motor([32,36,38,40]) motor_alt.rpm = 5 motor_alt.mode = 2 motor_alt.move_to(alt-self.alt_anterior) self.alt_anterior = alt logging.debug("Azimute: %d, Altitude: %d" % (az,alt)) # envia as cordenadas para o Stellarium self.act_pos(ra, dec)
def from_bytes(cls, bitstream): ''' Parse the given record and update properties accordingly ''' record = cls() # Convert to ConstBitStream (if not already provided) if not isinstance(bitstream, ConstBitStream): if isinstance(bitstream, Bits): bitstream = ConstBitStream(auto=bitstream) else: bitstream = ConstBitStream(bytes=bitstream) # Read the record TTL record.ttl = bitstream.read('uint:32') # Store the locator record count until we need it locator_record_count = bitstream.read('uint:8') # Store the EID prefix mask length until we need it eid_prefix_len = bitstream.read('uint:8') # Read the Negative Map_Reply action record.action = bitstream.read('uint:3') # Read the flag record.authoritative = bitstream.read('bool') # Read reserved bits record._reserved1 = bitstream.read(12 + 4) # Read the map version record.map_version = bitstream.read('uint:12') # Read the EID prefix record.eid_prefix = read_afi_address_from_bitstream(bitstream, eid_prefix_len) # Read the locator records for dummy in range(locator_record_count): locator_record = LocatorRecord.from_bytes(bitstream) record.locator_records.append(locator_record) # Verify that the properties make sense record.sanitize() return record
def __new__(cls, font_filename): """ Create a new PGFFont from tile font file specified by `font_filename` """ log.info('Opening font file %s' % (font_filename,)) bits = ConstBitStream(filename=font_filename) obj = super(PGFFont, cls).__new__(cls) obj.bits = bits log.info('Parsing Font Information') obj._size = bits.len / 8 for (field_name, fmt_str, offset) in PGFFont._fields_: assert bits.bytepos == offset, \ 'Incorrect offset while parsing field %s: %x\n%s' % \ (field_name, bits.bytepos, obj) setattr(obj, field_name, bits.read(fmt_str)) log.info('Parsed %s' % (obj,)) obj._validate_parse() obj.tables = OrderedDict() for name in PGFFont._int64_tables_: entries = getattr(obj, 'len_%s' % (name,)) buf = bits.read('bytes: %d' % (entries * 2 * 4)) obj.tables[name] = array('I', buf) for name in PGFFont._tables_: entries = getattr(obj, 'len_%s' % (name,)) bpe = 64 bpe_name = 'bpe_%s' % (name,) if bpe_name in obj.__dict__: bpe = getattr(obj, bpe_name) obj.tables[name] = Table(name, bits, entries, bpe) log.debug('Parsed table offset:%x - name=%s - %s' % (bits.bytepos, name, obj.tables[name])) obj.fontdatasize = (bits.len - bits.pos)/8 obj.fontdata = FontData(obj, bits, obj.fontdatasize) char = obj.tables['charmap'][ord(u'o')] return obj
def mc_parser(): out, buff = yield while True: header_bytes = yield from buff.read(24) header = ConstBitStream(header_bytes) readlist_fmt = 'uint:8, uint:8, uint:16' magic, opcode, key_length = header.readlist(readlist_fmt) extras_length, data_type, status = header.readlist(readlist_fmt) total_body_length = header.read('uint:32') opaque = header.read('uint:32') cas = header.read('uint:64') extras = None if extras_length: extras = yield from buff.read(extras_length) key = None if key_length: key = yield from buff.read(key_length) value_length = total_body_length - (key_length + extras_length) value = None if value_length: value = yield from buff.read(value_length) out.feed_data(MCResponse(opcode, data_type, status, cas, extras, key, value))
def encode(self, infile, outfile): s='' chars=[] print(BitArray(filename=infile).bin[2:]) f=ConstBitStream(filename=infile) done=False eof=False while not done: found=False cursor=self.encoding while not found: try: bit=f.read('uint:1') except: eof=True bit=0 cursor=cursor[bit+1] if len(cursor)==2: # leaf found=True val=cursor[1] s=s+chr(val) chars.append(val) if eof: done=True f=open(outfile, 'wb') f.write(s) f.close() print(chars) print(BitArray(filename=outfile).bin[2:])
def testReadList(self): s = CBS("0b10001111001") t = s.readlist("pad:1, uint:3, pad:4, uint:3") self.assertEqual(t, [0, 1]) s.pos = 0 t = s.readlist("pad:1, pad:5") self.assertEqual(t, []) self.assertEqual(s.pos, 6) s.pos = 0 t = s.readlist("pad:1, bin, pad:4, uint:3") self.assertEqual(t, ["000", 1]) s.pos = 0 t = s.readlist("pad, bin:3, pad:4, uint:3") self.assertEqual(t, ["000", 1])
def parseAxisBlock(axBlkStr): ret = dict() if len(axBlkStr) != AX_BLK_SIZE: raise ValueError("Invalid passed string length") keys = ["status", "switches", "stopCode", "refPos", "motorPos", "posError", "auxPos", "vel", "torque", "analog"] statusKeys = ["moving", "motionMode1", "motionMode1", "findingEdge", "homing", "homeP1Done", "homeP2Done", "coordMotion", "movingNeg", "contourMode", "slewingMode", "stopping", "finalDecel", "latchArmed", "offOnErrArmed", "motorOff"] # The f*****g galil is little endian, so [:2] splits off the segment of the string we want, and [::-1] reverses it statusBs = ConstBitStream(bytes=axBlkStr[:2][::-1]) # Status is 16 boolean values packed into a uint_16 statusVals = statusBs.readlist(["uint:1"]*16) # zip flags and names into dict zipped = zip(statusKeys, statusVals) vals = [dict(zipped)] vals.extend(struct.unpack(AX_BLK_PARSE_STR, axBlkStr)) ret = dict(zip(keys, vals)) return ret