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 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 compression_1(f):
# TODO: reuse frame arrays instead of allocating new ones all
# the time.
prevFrame = np.zeros((y_res, x_res), dtype="uint16")
deltaFrame = np.zeros((y_res, x_res), dtype="int32")
n = 0
while f.read(1) == "F":
print "=== FRAME %d ===" % n
n += 1
offset, bit_width, frame_size = get_frame_headers(f)
print "bit width: %d" % bit_width
stream = ConstBitStream(bytes=f.read(frame_size))
val = stream.read('intle:32')
deltaFrame[0][0] = val
num_deltas = (x_res * y_res) - 1
# offset by 1 b/c we already have initial value
for i in range(1, num_deltas + 1):
y = i // x_res
x = i % x_res
# Deltas are "snaked" so work backwards through every
# second row.
if y % 2 == 1:
x = x_res - x - 1
val += stream.read('int:' + str(bit_width))
deltaFrame[y][x] = val
# Calculate the frame by applying the delta frame to the
# previously decompressed frame.
frame = (prevFrame + deltaFrame).astype('uint16')
print frame
prevFrame = frame
class SaveReader():
"""Class designed to retrieve basic data from files."""
def __init__(self, file_name):
self.file = open(file_name, 'r')
self.stream = ConstBitStream(self.file)
def __enter__(self):
return self
def __exit__(self, type_, value, traceback):
self.file.close()
def read_bytes(self, count):
"""Read a number of bytes and return a bitstring."""
return self.stream.read(count * 8)
def find_blocks(self):
"""Find all data blocks and return a tuple of their offsets."""
return tuple(self.stream.findall('0x40000000', bytealigned=True))
def read_int(self):
"""Read a 4 byte little endian int."""
return self.stream.read(32).intle
def read_ints(self, count):
"""Return a tuple of ints."""
return tuple(
map(lambda x: x.read(32).intle,
self.read_bytes(count * 4).cut(32)))
def read_string(self):
"""Read a string with the length given in the first 4 bytes."""
return self.stream.read('bytes:{}'.format(self.read_int())).decode(
"utf-8", 'replace')
def _get_translation_tables():
raw = ConstBitStream(filename='text_eng.dat', offset=0x8 * 8)
tables = []
try:
while True:
table_len = raw.read('intle:32')
table = {}
for _ in range(table_len):
parsed_id, str_len = raw.readlist('intle:32, intle:32')
parsed_str = raw.read('hex:{}'.format(str_len *
8))[:-4].decode('hex')
# Replace random unicode shit with closest ASCII equivalent
parsed_str = parsed_str.replace(
'\xe2\x80\x93', '-') # U-2013 EN-DASH to ASCII dash
table[parsed_id] = parsed_str.decode('ascii', 'ignore')
tables.append(table)
except ReadError:
# EOF
pass
return tables
def png_to_gim(self,
png_file,
gim_file=None,
quant_type=QuantizeType.auto):
# So there's no confusion.
png_file = os.path.abspath(png_file)
if gim_file == None:
gim_file = os.path.splitext(png_file)[0] + ".gim"
png_file = self.quantize_png(png_file, quant_type)
data = ConstBitStream(filename=png_file)
data.bytepos = 0x18
options = ["-jar", "tools/gimexport.jar", png_file, gim_file, "3"]
depth = data.read("int:8")
color_type = data.read("int:8")
if color_type == 3: # Indexed
options.append("true")
else:
options.append("false")
self.process.start("java", options)
self.process.waitForFinished(-1)
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 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 consume(self, data: ConstBitStream) -> None:
value = BitStream()
keep_reading = True
while keep_reading:
keep_reading = data.read("bool")
value += data.read(4)
self.value = value.uint
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 __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 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 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 from_bytes(cls, bitstream):
'''
Parse the given packet and update properties accordingly
'''
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 type
type_nr = bitstream.read('uint:4')
if type_nr != packet.message_type:
msg = 'Invalid bitstream for a {0} packet'
class_name = packet.__class__.__name__
raise ValueError(msg.format(class_name))
# Read if this is a reply
packet.is_reply = bitstream.read('bool')
# Skip reserved bits
packet._reserved1 = bitstream.read(27)
# Read the nonce
packet.nonce = bitstream.read('bytes:8')
# Read the key id
packet.key_id = bitstream.read('uint:16')
# Read the authentication data
data_length = bitstream.read('uint:16')
packet.authentication_data = bitstream.read('bytes:%d' % data_length)
# Read the TTL
packet.ttl = bitstream.read('uint:32')
# Skip reserved bits
packet._reserved2 = bitstream.read(8)
# Store the EID prefix mask length until we need it
eid_prefix_len = bitstream.read('uint:8')
# Read the EID prefix
packet.eid_prefix = read_afi_address_from_bitstream(bitstream, eid_prefix_len)
# Read the reply
packet.reply = read_afi_address_from_bitstream(bitstream)
# Verify that the properties make sense
packet.sanitize()
return packet
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 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 from_bytes(cls, bitstream):
'''
Parse the given packet and update properties accordingly
'''
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 type
type_nr = bitstream.read('uint:4')
if type_nr != packet.message_type:
msg = 'Invalid bitstream for a {0} packet'
class_name = packet.__class__.__name__
raise ValueError(msg.format(class_name))
# Read the flags
has_xtr_site_id = bitstream.read('bool')
# Skip reserved bits
packet._reserved1 = bitstream.read(19)
# Store the record count until we need it
record_count = bitstream.read('uint:8')
# Read the nonce
packet.nonce = bitstream.read('bytes:8')
# Read the key id
packet.key_id = bitstream.read('uint:16')
# Read the authentication data
data_length = bitstream.read('uint:16')
packet.authentication_data = bitstream.read('bytes:%d' % data_length)
# Read the records
for dummy in range(record_count):
record = MapRegisterRecord.from_bytes(bitstream)
packet.records.append(record)
# Read the xtr-id and site-id
if has_xtr_site_id:
packet.xtr_id = bitstream.read('uint:128')
packet.site_id = bitstream.read('uint:64')
# Verify that the properties make sense
packet.sanitize()
return packet
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_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 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 lz77huff_decode(encoded_data, num_symbols, serialized_tree, window_bits=DEFAULT_WINDOW_BITS):
bytestream = huffman_decode(encoded_data, num_symbols, serialized_tree, symbol_bits=window_bits)
bits = ConstBitStream(bytestream)
tokens = []
try:
while True:
t = (bits.read(f'uint:{window_bits}'),
bits.read(f'uint:{window_bits}'),
bits.read(f'uint:{window_bits}'))
tokens.append(t)
except ReadError:
pass
return lz77_decode_from_tokens(tokens)
def verifyBlocksX(image,
pixelWidth,
blockWidthEstimate,
combinedColors,
initializerPaletteADict,
initializerPaletteBDict,
override=False):
'''This is a function used within frameLockOn(). It verifies the correct values for the X axis.'''
calibratorBitsX = BitArray()
for xBlock in range(17):
snappedValue = colorSnap(scanBlock(image, pixelWidth, xBlock, 0),
combinedColors)
if xBlock % 2 == 0:
calibratorBitsX.append(
initializerPaletteADict.getValue(snappedValue))
else:
calibratorBitsX.append(
initializerPaletteBDict.getValue(snappedValue))
calibratorBitsX.reverse()
readCalibratorX = ConstBitStream(calibratorBitsX)
if readCalibratorX.read('uint:16') != blockWidthEstimate:
if override == True:
logging.warning(
'blockWidthOverride is not equal to what was read on calibrator. Aborting...'
)
else:
logging.warning(
'blockWidth verification does not match initial read. This could be the result of \n'
'sufficiently distorted frames. Aborting...')
return False
if readCalibratorX.read('bool') != False:
logging.warning('0,0 block unexpected value. Aborting...')
return False
if override == True:
logging.info('blockWidthOverride successfully verified.')
else:
logging.debug('blockWidth successfully verified.')
return True
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 from_bytes(cls, bitstream):
'''
Parse the given packet and update properties accordingly
'''
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 type
type_nr = bitstream.read('uint:4')
if type_nr != packet.message_type:
msg = 'Invalid bitstream for a {0} packet'
class_name = packet.__class__.__name__
raise ValueError(msg.format(class_name))
# Read the flags
(packet.probe,
packet.enlra_enabled,
packet.security) = bitstream.readlist('3*bool')
# Skip reserved bits
packet._reserved1 = bitstream.read(17)
# Store the record count until we need it
record_count = bitstream.read('uint:8')
# Read the nonce
packet.nonce = bitstream.read('bytes:8')
# Read the records
for dummy in range(record_count):
record = MapReplyRecord.from_bytes(bitstream)
packet.records.append(record)
# If the security flag is set then there should be security data left
# TODO: deal with security flag [LISP-Security]
if packet.security:
raise NotImplementedError('Handling security data is not ' +
'implemented yet')
# Verify that the properties make sense
packet.sanitize()
return packet
def from_bytes(cls, bitstream, decode_payload=True):
"""
Parse the given packet and update properties accordingly
"""
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 version
version = bitstream.read("uint:4")
if version != packet.version:
raise ValueError("Provided bytes do not contain an IPv6 packet")
# Read the traffic class
packet.traffic_class = bitstream.read("uint:8")
# Read the flow label
packet.flow_label = bitstream.read("uint:20")
# Read the payload length
payload_length = bitstream.read("uint:16")
# Read the next header type
packet.next_header = bitstream.read("uint:8")
# Read the hop limit
packet.hop_limit = bitstream.read("uint:8")
# Read the source and destination addresses
packet.source = IPv6Address(bitstream.read("uint:128"))
packet.destination = IPv6Address(bitstream.read("uint:128"))
# And the rest is payload
packet.payload = bitstream.read("bytes:%d" % payload_length)
if decode_payload:
payload_class = protocol_registry.get_type_class(packet.next_header)
if payload_class:
packet.payload = payload_class.from_bytes(packet.payload)
# There should be no remaining bits
if bitstream.pos != bitstream.len:
raise ValueError("Bits remaining after processing packet")
# Verify that the properties make sense
packet.sanitize()
return packet
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 lzwv_decode(in_array):
max_entries = 2**MAX_CODE_LEN
in_stream = ConstBitStream(in_array)
dictionary = {i: bytes([i]) for i in range(256)}
code_len = 9
out_array = bytearray()
while True:
try:
# Read a code
k = in_stream.read(f'uint:{code_len}')
# Look up code and emit value
v = dictionary[k]
out_array += v
# Add v + v_next[0] to dictionary
c = len(dictionary)
if c < max_entries:
if c == 2**code_len - 1:
code_len = min(MAX_CODE_LEN, code_len + 1)
k_next = in_stream.peek(f'uint:{code_len}')
if k_next < c:
v_next = dictionary[k_next]
dictionary[c] = v + v_next[:1]
else:
dictionary[c] = v + v[:1]
except ReadError:
break
return bytes(out_array)
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 _consume_length(self, data: ConstBitStream) -> None:
packet_length = data.read("uint:15")
end_pos = data.pos + packet_length
while data.pos < end_pos:
self.contents.append(_parse_packet(data))
if data.pos > end_pos:
raise RuntimeError("Consumed too much data!")
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 integer(self, N, M, offset=0):
'''
Provide an array of random integers following uniform distribution.
Parameters:
N: int
Amount of provided integers.
M: int
Upper range (exclusive) of the integers,
Which can only take a value among 0, 1, ..., M-1.
offset: int
Amount of bits at the beginning of the file to be skipped over.
Returns:
result: 1d numpy array
'''
width = int(np.ceil(np.log2(M)))
blob = ConstBitStream(filename=self.source)
result = np.empty(N, dtype="u4") # 32-bit unsigned integer in native endian
blob.pos = offset
for i in range(N):
while True:
number = blob.read(width).uint
if number < M:
result[i] = number
break
return result
def Hide():
# file_in = 'xeyes' #Payload script
# image_in = 'burger2.png' #Carrier image
def bitPadder(data, image):
'''
Function to pad the bitstream so that it's
the same size as the number of pixels in the
carrier image
'''
padded_list = []
for index in range(image.size[0] * image.size[1]):
if index < len(data):
padded_list.append(data[index])
#If index refers to a bit in the bitstream, add it
else:
padded_list.append(random.randint(0, 1))
#If the index has exceeded the size of the bitstream,
#insert a random bit
return padded_list
size = os.path.getsize(file_in)
bitsize = size * 8
fh = open(file_in, 'rb')
binary = fh.read()
s = ConstBitStream(binary)
bits = s.read(f'bin:{bitsize}')
im = Image.open(image_in)
imagecopy = im.copy()
bitlist = list(bits)
#list of 0's and 1's as strings
#Append delimiter of 256 1's to bitlist
for i in range(256):
bitlist.append(1)
# print(len(bitlist))
padded_list = bitPadder(bitlist, imagecopy)
#print(len(padded_list))
#Encode the bitstream into the LSB of the blue channel
pixels = imagecopy.load()
rgb_im = imagecopy.convert('RGB')
for y in range(imagecopy.size[1]):
for x in range(imagecopy.size[0]):
# if (y * image.size[0] + x) > len(file_bits):
# return image
r, g, b = rgb_im.getpixel((x, y))
b_zero = (b & 0xFE) # Sets LSB to zero
new_bit = int(padded_list[(y * imagecopy.size[0]) + x])
pixels[x, y] = (r, g, b_zero ^ new_bit)
#Show the steganographic image, then save it
imagecopy.show()
imagecopy.save(output_name)
def lzwf_decode(in_array, code_len=DEFAULT_CODE_LEN):
max_entries = 2**code_len
in_stream = ConstBitStream(in_array)
dictionary = {i: bytes([i]) for i in range(256)}
out_array = bytes()
while True:
try:
# Read a code
k = in_stream.read(f'uint:{code_len}')
# Look up code and emit value
v = dictionary[k]
out_array = out_array + v
# Add v + v_next[0] to dictionary
c = len(dictionary)
if c < max_entries:
k_next = in_stream.peek(f'uint:{code_len}')
if k_next < c:
v_next = dictionary[k_next]
dictionary[c] = v + v_next[:1]
else:
dictionary[c] = v + v[:1]
except ReadError:
break
return bytes(out_array)
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 parse_one_command_from_buffer(self):
retry = True # until we have one or don't have enough
errors = []
cmd = None
message_type = None
bits_parsed = 0
while retry and len(self.buffer) > 0:
try:
s = ConstBitStream(bytes=self.buffer)
cmd_length, message_type = self.parse_serial_interface_header(
s)
if message_type == MessageType.REBOOTED.value:
cmd = s.read("uint:8")
elif message_type == MessageType.LOGGING.value:
cmd = (s.readlist('bytes:b', b=cmd_length)[0])
else:
if self.skip_alp_parsing:
if s.length < cmd_length:
raise ReadError
cmd = s.read("bytes:" + str(cmd_length))
else:
cmd = AlpParser().parse(s, cmd_length)
bits_parsed = s.pos
self.shift_buffer(bits_parsed / 8)
retry = False # got one, carry on
except ReadError: # not enough to read, carry on and wait for more
retry = False
except Exception as e: # actual problem with current buffer, need to skip
errors.append({
"error":
e.args[0],
"buffer":
" ".join(map(lambda b: format(b, "02x"), self.buffer)),
"pos":
s.pos,
"skipped":
self.skip_bad_buffer_content()
})
info = {
"parsed": bits_parsed,
"buffer": len(self.buffer) * 8,
"errors": errors
}
return (message_type, cmd, info)
def from_bytes(cls, bitstream):
'''
Parse the given packet and update properties accordingly
'''
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 source and destination ports
(packet.source_port,
packet.destination_port) = bitstream.readlist('2*uint:16')
# Store the length
length = bitstream.read('uint:16')
if length < 8:
raise ValueError('Invalid UDP length')
# Read the checksum
packet.checksum = bitstream.read('uint:16')
# And the rest is payload
payload_bytes = length - 8
packet.payload = bitstream.read('bytes:%d' % payload_bytes)
# LISP-specific handling
if packet.source_port == 4341 or packet.destination_port == 4341:
# Payload is a LISP data packet
from pylisp.packet.lisp.data import DataPacket
packet.payload = DataPacket.from_bytes(packet.payload)
elif packet.source_port == 4342 or packet.destination_port == 4342:
# Payload is a LISP control message
from pylisp.packet.lisp.control.base import ControlMessage
packet.payload = ControlMessage.from_bytes(packet.payload)
# There should be no remaining bits
if bitstream.pos != bitstream.len:
raise ValueError('Bits remaining after processing packet')
# Verify that the properties make sense
packet.sanitize()
return packet
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 __init__(self, rawbytes=None):
data = ConstBitStream(rawbytes)
self.unparsed = bytes()
if data is not None:
start = data.bytepos
i = 0
for p in self.parsemap:
if isinstance(p, str):
pad = data.read(p)
self.values[f"UNPARSED_{i}"] = pad
else:
self.values[p.name] = p(data)
i += 1
rest = data.read("bin")
if rest:
self.values[f"UNPARSED_REST"] = rest
self.rawdata = data.bytes[start:data.bytepos]
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 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 handleDump(fileObj):
tech = []
raw = ConstBitStream(fileObj)
try:
while True:
tech.append(raw.read('floatle:32'))
except:
pass
del(raw)
return tech
def convert_msk(filename, out_file):
data = ConstBitStream(filename=filename)
magic = data.read("bytes:4")
size = data.read("uintle:32")
w = data.read("uintle:16")
h = data.read("uintle:16")
cmp_size = data.read("uintle:32")
print(w, h, cmp_size)
w = adjust_w(w)
chunk = data.read(cmp_size * 8)
chunk = decompress(chunk)
dump_to_file(chunk)
chunk = get_grayscale(chunk, w, h, crop=False)
chunk.save(out_file)
################################################################################
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 _get_translation_tables():
raw = ConstBitStream(filename='bestiary/com2us_data/text_eng.dat', offset=0x8 * 8)
tables = []
try:
while True:
table_len = raw.read('intle:32')
table = {}
for _ in range(table_len):
parsed_id, str_len = raw.readlist('intle:32, intle:32')
parsed_str = binascii.a2b_hex(raw.read('hex:{}'.format(str_len * 8))[:-4])
table[parsed_id] = parsed_str.decode("utf-8")
tables.append(table)
except ReadError:
# EOF
pass
return tables
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 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 from_bytes(cls, bitstream, prefix_len=None):
'''
Look at the type of the message, instantiate the correct class and
let it parse the message.
'''
# 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)
# Skip the reserved bits
rsvd1 = bitstream.read(8)
# Read the flags (and ignore them, no flags are defined yet)
flags = bitstream.readlist('8*bool')
# Read the type
type_nr = bitstream.read('uint:8')
# Skip the reserved bits
rsvd2 = bitstream.read(8)
# Read the length
length = bitstream.read('uint:16')
# Read the data
data = bitstream.read(length * 8)
# Look for the right class
from pylisp.utils.lcaf import type_registry
type_class = type_registry.get_type_class(type_nr)
if not type_class:
raise ValueError("Can't handle LCAF type {0}".format(type_nr))
# Let the specific class handle it from now on
return type_class._from_data_bytes(data, prefix_len,
rsvd1, flags, rsvd2)
def from_bytes(cls, bitstream):
'''
Parse the given packet and update properties accordingly
'''
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 type
type_nr = bitstream.read('uint:4')
if type_nr != packet.message_type:
msg = 'Invalid bitstream for a {0} packet'
class_name = packet.__class__.__name__
raise ValueError(msg.format(class_name))
# Skip reserved bits
packet._reserved1 = bitstream.read(20)
# Store the record count
record_count = bitstream.read('uint:8')
# Store the nonce
packet.nonce = bitstream.read('bytes:8')
# Read the records
for dummy in range(record_count):
record = MapReferralRecord.from_bytes(bitstream)
packet.records.append(record)
# Verify that the properties make sense
packet.sanitize()
return packet
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 png_to_gim(self, png_file, gim_file=None, quant_type=QuantizeType.auto):
# So there's no confusion.
png_file = os.path.abspath(png_file)
if gim_file == None:
gim_file = os.path.splitext(png_file)[0] + ".gim"
png_file = self.quantize_png(png_file, quant_type)
data = ConstBitStream(filename=png_file)
data.bytepos = 0x18
options = ["-jar", "tools/gimexport.jar", png_file, gim_file, "3"]
depth = data.read("int:8")
color_type = data.read("int:8")
if color_type == 3: # Indexed
options.append("true")
else:
options.append("false")
self.process.start("java", options)
self.process.waitForFinished(-1)
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 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):
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')
# Skip over reserved bits
bitstream.read(8)
# Read the fragment offset
packet.fragment_offset = bitstream.read('uint:13')
# Skip over reserved bits
bitstream.read(2)
# Read the more fragments
packet.more_fragments = bitstream.read('bool')
# Read the identification
packet.identification = bitstream.read('uint:32')
# And the rest is payload
remaining = bitstream[bitstream.pos:]
packet.payload = remaining.bytes
# Verify that the properties make sense
packet.sanitize()
return packet
def load(self, filename):
self.filename = filename
dive = ConstBitStream(filename = os.path.join(common.editor_config.data01_dir, DIVE_DIR, self.filename))
# Header
# XX XX XX XX -- ??? (Always 0x02)
# XX XX XX XX -- Header length? (Always 0x10)
# XX XX XX XX -- File size - header length
# XX XX XX XX -- Padding?
dive.read(32)
header_len = dive.read("uintle:32")
file_len = dive.read("uintle:32")
dive.read(32)
num_rows = dive.read("uintle:32")
for i in range(num_rows):
offset = dive.read("uintle:32") + header_len
row = dive[offset * 8 : (offset + ROW_LEN) * 8].readlist("uint:8," * ROW_LEN)
self.rows.append(row)
def load(self, filename):
filename = filename.lower()
if not filename in DIR_MAP:
_LOGGER.error("Invalid nonstop file: %s" % filename)
return
self.filename = filename
script_dir = DIR_MAP[filename]
self.script_pack = ScriptPack(script_dir, common.editor_config.data01_dir)
file_order = []
# --- NONSTOP FORMAT ---
# XX XX -- ???
# XX XX -- Number of lines (not necessarily files)
#
# [68 bytes per line]
# XX XX -- File number
# XX XX XX XX
# * 0x00000000 = normal line
# * 0x01000100 = chatter
# * 0x01000000 = ??? (Only appears in SDR2)
# * 0x02000000 = ??? (Only appears in SDR2)
# * 0x03000000 = ??? (Only appears in SDR2)
# * 0x04000000 = ??? (Only appears in SDR2)
# XX XX -- Ammo ID that reacts to this line.
# XX XX -- Converted line ID that reacts to this line.
# XX XX -- ???
# XX XX -- 1 = has a weak point, 0 = has no weak point
# XX XX -- The amount of time before the next line is shown (in sixtieths of seconds (frames?)).
# XX XX -- Unknown (Possibly line orientation? Only 0 in the first game, but sometimes 2 in the second.)
# XX XX -- Effect used when transitioning text in.
# XX XX -- Effect used when transitioning text out.
# * 0: fade
# * 1: spin in/out
# * 2: zoom out
# * 3: slide in/out
# XX XX -- The amount of the the line stays on-screen (in sixtieths of seconds (frames?)).
# XX XX -- Initial X position (text centered around this pos).
# XX XX -- Initial Y position (text centered around this pos).
# XX XX -- Text velocity.
# XX XX -- Angle of motion.
# XX XX -- Initial text zoom (in percent).
# XX XX -- Change in zoom over time (in percent).
# * 90% means it gradually shrinks.
# * 100% means it stays the same size the whole time.
# * 110% means it gradually grows.
# XX XX -- 0 = no shake, 1 = shake
# XX XX -- Rotate the text clockwise to this angle.
# XX XX -- Text spins clockwise at this rate.
# XX XX -- Speaker (00 00 if chatter)
# XX XX -- Sprite ID (00 00 if chatter)
# XX XX XX XX -- ???
# XX XX -- Voice index (FF FF if chatter)
# XX XX -- ???
# XX XX -- Chapter
# XX XX XX XX -- ??? (padding?)
nonstop = ConstBitStream(filename = os.path.join(common.editor_config.data01_dir, NONSTOP_DIR, self.filename))
self.magic = nonstop.read(16)
num_lines = nonstop.read('uintle:16')
# Four byte header plus 68 bytes per line.
if nonstop.len < (4 + (num_lines * 68)) * 8:
raise Exception("Invalid nonstop file.")
prev_non_chatter = -1
self.lines = []
for i in range(num_lines):
line = NonstopLine()
line.file_num = nonstop.read('uintle:16')
line.line_type = nonstop.read(32)
if line.line_type in LINE_TYPE_MAP:
line.line_type = LINE_TYPE_MAP[line.line_type]
line.ammo_id = nonstop.read('intle:16')
line.converted_id = nonstop.read('intle:16')
line.unknown1 = nonstop.read(16)
line.weak_point = nonstop.read('uintle:16')
line.delay = nonstop.read('intle:16')
line.orientation = nonstop.read('intle:16')
line.in_effect = nonstop.read('intle:16')
line.out_effect = nonstop.read('intle:16')
line.time_visible = nonstop.read('intle:16')
line.x_start = nonstop.read('intle:16')
line.y_start = nonstop.read('intle:16')
line.velocity = nonstop.read('intle:16')
line.angle = nonstop.read('intle:16')
line.zoom_start = nonstop.read('intle:16')
line.zoom_change = nonstop.read('intle:16')
line.shake = nonstop.read('intle:16')
line.rot_angle = nonstop.read('intle:16')
line.spin_vel = nonstop.read('intle:16')
line.speaker = nonstop.read('intle:16')
# Since we mess with speaker a little bit later, we want to keep the ID for the sprite.
line.char_id = line.speaker
line.sprite_id = nonstop.read('intle:16')
line.unknown3 = nonstop.read(32)
line.voice_id = nonstop.read('intle:16')
line.unknown4 = nonstop.read(16)
line.chapter = nonstop.read('intle:16')
line.unknown5 = nonstop.read(32)
line.unknown6 = nonstop.read(64)
format = copy.deepcopy(TEXT_FORMATS[common.SCENE_MODES.debate])
format.orient = TEXT_ORIENT.hor if line.orientation == 0 else TEXT_ORIENT.ver
format.align = TEXT_ALIGN.center
if format.orient == TEXT_ORIENT.ver:
format.y = format.h
format.x = format.w / 3.5
self.script_pack[line.file_num].scene_info.format = format
if line.line_type == NONSTOP_LINE_TYPE.normal:
prev_non_chatter = line.file_num
# Fixing some weirdness.
# if filename in ["nonstop_06_003.dat", "nonstop_06_005.dat", "nonstop_06_006.dat", "nonstop_06_007.dat"] and line.speaker == 16:
# line.speaker = 15
# if filename[:10] == "nonstop_06" and int(filename[11:14]) >= 10 and line.speaker == 10:
# line.speaker = 18
# if filename in ["nonstop_02_003.dat", "nonstop_02_005.dat", "nonstop_04_005.dat", "nonstop_04_006.dat"] and line.speaker == 10:
# line.speaker = 18
self.script_pack[line.file_num].scene_info.speaker = line.speaker
sprite = SpriteId(SPRITE_TYPE.stand, line.char_id, line.sprite_id)
self.script_pack[line.file_num].scene_info.sprite = sprite
voice = VoiceId(line.speaker, line.chapter, line.voice_id)
self.script_pack[line.file_num].scene_info.voice = voice
self.script_pack[line.file_num].scene_info.special = common.SCENE_SPECIAL.debate
elif "hanron" in str(line.line_type):
self.script_pack[line.file_num].scene_info.speaker = line.speaker
sprite = SpriteId(SPRITE_TYPE.stand, line.char_id, line.sprite_id)
self.script_pack[line.file_num].scene_info.sprite = sprite
voice = VoiceId(line.speaker, line.chapter, line.voice_id)
self.script_pack[line.file_num].scene_info.voice = voice
self.script_pack[line.file_num].scene_info.special = common.SCENE_SPECIAL.hanron
elif line.line_type == NONSTOP_LINE_TYPE.chatter:
self.script_pack[line.file_num].scene_info.speaker = -1
self.script_pack[line.file_num].scene_info.special = common.SCENE_SPECIAL.chatter
self.script_pack[line.file_num].scene_info.extra_val = prev_non_chatter
else:
_LOGGER.error("Invalid line type: %s" % line.line_type)
file_order.append(line.file_num)
self.lines.append(line)
for index in xrange(len(self.script_pack)):
if not index in file_order:
file_order.append(index)
self.script_pack.script_files = [self.script_pack[i] for i in file_order]
def unpack(raw):
"""Unpack ``raw`` and return an object."""
packet = ConstBitStream(raw)
version = packet.read('uint:2')
reserved = packet.read('uint:3')
encryption = packet.read('uint:2')
has_crc = packet.read('uint:1')
total_segment_size = packet.read('uint:24')
payload_id = packet.read('uintbe:8')
segment_id = packet.read('uintbe:16')
segment_version = packet.read('uintbe:8')
section_number = packet.read('uint:12')
last_section_number = packet.read('uint:12')
compression = packet.read('uint:3')
has_provider_id = packet.read('uint:1')
private_header_length = packet.read('uint:4')
if has_provider_id:
provider_id = packet.read('uintbe:32')
else:
provider_id = None
private_header_data = packet.read('bytes:' + str(private_header_length))
if has_crc:
payload = raw[packet.bytepos:-4]
crc = struct.unpack('!I', raw[-4:])[0]
else:
crc = None
payload = raw[packet.bytepos:]
del raw
del packet
return Section(**locals())
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))
calibrate = raw_input("Do you want to calibrate? - Y/N \n")
if calibrate == "Y":
#Calibration GUI
app = Tk()
#app.title("Calibration")
#app.configure(background = "grey")
tframe = Frame(app)
tframe.pack()
lrframe = Frame(app)
lrframe.pack()
dframe = Frame(app)
dframe.pack()
bframe = Frame(app)
bframe.pack(side = BOTTOM)
def upCallBack():
ser.write('w\n');
#tkMessageBox.showinfo( "UP")
def downCallBack():
ser.write("s\n");
#tkMessageBox.showinfo( "DOWN")
def leftCallBack():
ser.write("a\n");
#tkMessageBox.showinfo( "LEFT")
def rightCallBack():
ser.write("d\n");
#tkMessageBox.showinfo( "RIGHT")
def close_window():
app.destroy();
UpButton = Button(tframe, text = "Up", command = upCallBack);
UpButton.pack()
DownButton = Button(dframe, text = "Down", command = downCallBack);
DownButton.pack()
LeftButton = Button(lrframe, text = "Left", command = leftCallBack);
LeftButton.pack( side = LEFT)
RightButton = Button(lrframe, text = "Right", command = rightCallBack);
RightButton.pack( side = LEFT)
DoneButton = Button(bframe, text = "Done", command = close_window);
DoneButton.pack( side = BOTTOM)
app.mainloop()
