153 lines
3.1 KiB
Python
153 lines
3.1 KiB
Python
import struct
|
|
|
|
file_track = []
|
|
print_debug = False
|
|
|
|
|
|
def debug_print(s):
|
|
if print_debug:
|
|
print(s)
|
|
|
|
|
|
def init_filetrack(size):
|
|
global file_track
|
|
file_track = [0] * size
|
|
|
|
|
|
def show_filetrack():
|
|
i = 0
|
|
curr = 1
|
|
curr_len = 0
|
|
while i < len(file_track):
|
|
if file_track[i] != curr:
|
|
if curr == 0:
|
|
print("%s starts at %s, ends at %s for %s (%s) bytes (%s ints)" % (curr, i-curr_len, i, curr_len, hex(curr_len), curr_len/4))
|
|
curr = file_track[i]
|
|
curr_len = 1
|
|
else:
|
|
curr_len += 1
|
|
i += 1
|
|
print(file_track)
|
|
|
|
|
|
def advance_track(offset, size):
|
|
if not file_track:
|
|
return
|
|
for i in range(size):
|
|
file_track[offset+i] = 1
|
|
|
|
|
|
def stat_track():
|
|
r = 0
|
|
total = len(file_track)
|
|
for i in file_track:
|
|
if i == 1:
|
|
r += 1
|
|
return r/total*100
|
|
|
|
|
|
def read_int(fp):
|
|
advance_track(fp.tell(), 4)
|
|
return struct.unpack("<L", fp.read(4))[0]
|
|
|
|
|
|
def read_byte(fp):
|
|
advance_track(fp.tell(), 1)
|
|
return struct.unpack("<B", fp.read(1))[0]
|
|
|
|
|
|
def read_float(fp):
|
|
advance_track(fp.tell(), 4)
|
|
return struct.unpack("<f", fp.read(4))[0]
|
|
|
|
|
|
def read_short(fp):
|
|
advance_track(fp.tell(), 2)
|
|
return struct.unpack("<H", fp.read(2))[0]
|
|
|
|
|
|
def read_string(fp, size):
|
|
return read_bytes(fp, size).decode("utf8").replace("\x00", "")
|
|
|
|
|
|
def read_bytes(fp, size):
|
|
advance_track(fp.tell(), size)
|
|
return bytes(struct.unpack('<' + str(size) + 'B', fp.read(size)))
|
|
|
|
|
|
def read_string_until_none(fp) -> str:
|
|
s = ""
|
|
c = read_byte(fp)
|
|
while c != 0x00:
|
|
s += chr(c)
|
|
c = read_byte(fp)
|
|
return s
|
|
|
|
|
|
def decompress(compressed_bytes, original_size: int):
|
|
i = 0
|
|
j = 0
|
|
dec_byte = 0
|
|
dec_bits = 8
|
|
buff_start = 0xFEE
|
|
|
|
res = bytearray(original_size)
|
|
|
|
if original_size == 0:
|
|
return res
|
|
|
|
while j < original_size:
|
|
if dec_bits == 8:
|
|
dec_byte = compressed_bytes[i]
|
|
i += 1
|
|
dec_bits = 0
|
|
if (dec_byte >> dec_bits & 1) == 0:
|
|
dec_pos = ((compressed_bytes[i] + (
|
|
(compressed_bytes[i + 1] & 0xF0) << 4) - buff_start - j) & 0xFFF) - 0x1000 + j
|
|
dec_len = (compressed_bytes[i + 1] & 0xF) + 3
|
|
i += 2
|
|
while dec_len > 0:
|
|
if dec_pos >= 0:
|
|
res[j] = res[dec_pos]
|
|
else:
|
|
res[j] = 32
|
|
j += 1
|
|
dec_pos += 1
|
|
dec_len -= 1
|
|
else:
|
|
res[j] = compressed_bytes[i]
|
|
i += 1
|
|
j += 1
|
|
dec_bits += 1
|
|
return res
|
|
|
|
|
|
def read_int_and_print(n, b):
|
|
a = read_int(b)
|
|
debug_print("%s=%s" % (n, a))
|
|
return a
|
|
|
|
|
|
def read_float_and_print(n, b):
|
|
a = read_float(b)
|
|
debug_print("%s=%s" % (n, a))
|
|
return a
|
|
|
|
|
|
def read_byte_and_print(n, b):
|
|
a = read_byte(b)
|
|
debug_print("%s=%s" % (n, a))
|
|
return a
|
|
|
|
|
|
def read_short_and_print(n, b):
|
|
a = read_short(b)
|
|
debug_print("%s=%s" % (n, a))
|
|
return a
|
|
|
|
|
|
def read_string_until_none_and_print(n, b):
|
|
s = read_string_until_none(b)
|
|
debug_print("%s=%s" % (n, s))
|
|
return s
|