def readheader(self, data):
self.byteorder = ENDIANS[rawutil.unpack_from('>H', data, 8)[0]]
hdata, ptr = self.unpack_from(GARC_HEADER_STRUCT, data, 0, getptr=True)
if hdata[0] != b'CRAG':
error.InvalidMagicError('Invalid magic %s, expected CRAG' %
byterepr(hdata[0]))
#headerlen = hdata[1]
#bom = hdata[2]
self.version = hdata[3]
self.chunkcount = hdata[4]
self.dataoffset = hdata[5]
#filelen = hdata[6]
padinfo, ptr = self.unpack_from(GARC_HEADER_END[self.version],
data,
ptr,
getptr=True)
if self.version == 0x0400:
print('Version: 4')
self.larger_unpadded = padinfo[0]
self.pad_to_nearest = 4
elif self.version == 0x0600:
print('Version: 6')
self.larger_padded = padinfo[0]
self.larger_unpadded = padinfo[1]
self.pad_to_nearest = padinfo[2]
else:
error.UnsupportedVersionError('Unsupported version 0x%04x' %
self.version)
return ptr
def readheader(self):
self.byteorder = ENDIANS[rawutil.unpack_from('<H', self.file, 4)[0]]
header = self.unpack_from(NARC_HEADER_STRUCT, self.file, 0,
NARC_HEADER_NAMES)
if header.magic != b'NARC':
error.InvalidMagicError('Invalid NARC magic: %s' %
byterepr(header.magic))
def readFLIMheader(self, hdr):
self.byteorder = ENDIANS[rawutil.unpack_from('>H', hdr, 4)[0]]
hdata = self.unpack(BFLIM_FLIM_HDR_STRUCT, hdr)
if hdata[0] != b'FLIM':
error('Invalid magic %s, expected FLIM' % byterepr(hdata[0]), 301)
#bom = hdata[1]
#headerlen = hdata[2]
self.version = hdata[3]
def read_header(self, data):
magic = data.read(8)
if magic != b'MsgStdBn':
error.InvalidMagicError('Invalid magic %s, expected MsgStdBn' %
byterepr(magic))
self.byteorder = ENDIANS[rawutil.unpack_from('>H', data)[0]]
magic, bom, unk1, self.encoding, unk2, self.sectionnum, unk3, self.filesize, unk4 = self.unpack_from(
'8s2H2B2HI10s', data, 0)
def read_header(self, data):
self.byteorder = ENDIANS[rawutil.unpack_from(">H", data, 4)[0]]
header = self.unpack_from("4s2H 2I2H SSS", data, 0, "magic, bom, headerlen, version, filesize, seccount, reserved, inforef, seekref, dataref")
if header.magic != b"CSTM":
error.InvalidMagicError("Invalid magic %s, expected CSTM" % byterepr(header.magic))
self.filesize = header.filesize
self.inforef = SizedRef(header.inforef)
self.seekref = SizedRef(header.seekref)
self.dataref = SizedRef(header.dataref)
def readDataHeader(self, data):
data.seek(DATA_HEADER_OFFSET)
self.dataheader = rawutil.unpack_from(DATA_HEADER_STRUCT,
data,
names=DATA_HEADER_NAMES)
if self.dataheader.format not in DATA_FORMATS:
error.UnknownDataFormatError(
"Unknown texture data format identifier 0x%04X" %
self.dataheader.format)
print("Color format : %s" % DATA_FORMATS[self.dataheader.format])
print("Texture swizzling : %d" % self.dataheader.swizzle)
def read_header(self, data):
self.byteorder = ENDIANS[rawutil.unpack_from('>H', data, 4)[0]]
header = self.unpack_from(
'4s2H 2I2H SS', data, 0,
'magic, bom, headerlen, version, filesize, seccount, reserved, inforef, dataref'
)
if header.magic != b'CWAV':
error.InvalidMagicError('Invalid magic %s, expected CWAV' %
byterepr(header.magic))
self.filesize = header.filesize
self.inforef = SizedRef(header.inforef)
self.dataref = SizedRef(header.dataref)
def readFLIMheader(self, data):
data.seek(-0x24, 2)
self.byteorder = ENDIANS[rawutil.unpack_from('>H', data)[0]]
data.seek(-0x28, 2)
hdata = self.unpack_from(BFLIM_FLIM_HDR_STRUCT, data)
if hdata[0] != b'FLIM':
error.InvalidMagicError('Invalid magic %s, expected FLIM' %
byterepr(hdata[0]))
#bom = hdata[1]
#headerlen = hdata[2]
self.version = hdata[3]
if self.verbose:
print('Version: %08x' % self.version)
def readheader(self, data):
magic, hdrlen, bom = rawutil.unpack_from('>4s2H', data, 0)
if magic != b'SARC':
error('Invalid magic %s, expected SARC' % byterepr(magic), 301)
self.byteorder = ENDIANS[bom]
hdr, ptr = self.unpack_from(SARC_HEADER_STRUCT, data, 0, getptr=True)
#magic = hdr[0]
#headerlen = hdr[1]
#bom = hdr[2]
#filelen = hdr[3]
self.dataoffset = hdr[4]
#unknown = hdr[5]
return ptr
def readheader(self):
self.byteorder = ENDIANS[rawutil.unpack_from('>H', self.file, 4)[0]]
header = self.unpack_from(FLAN_HEADER, self.file, 0)
if header[0] != b'FLAN':
error.InvalidMagicError('Invalid magic %s, expected FLAN' %
byterepr(header[0]))
#bom = header[1]
headerlen = header[2]
self.version = header[3]
#unknown = header[4]
self.filelen = header[5]
self.seccount = header[6]
#padding = header[7]
return headerlen
def readHeader(self, data):
self.fileheader = rawutil.unpack_from(FILE_HEADER_STRUCT,
data,
names=FILE_HEADER_NAMES)
if self.fileheader.magic_texture != b"texture\x00":
error.InvalidMagicError("Invalid magic %s, expected texture\x00" %
byterepr(self.fileheader.magic_texture))
self.outname = os.path.join(
os.path.dirname(self.filename),
self.fileheader.filename.decode("utf-8").rpartition(".")[0] +
".png")
if self.verbose:
print("Version : %08X" % self.fileheader.version)
print("Origin file name : %s" %
self.fileheader.filename.decode("utf-8"))
def read_header(self, data):
magic, bom = rawutil.unpack_from('>4sH', data, 0)
self.byteorder = ENDIANS[bom]
if magic != b'CGRP':
error.InvalidMagicError('Invalid magic %s, expected CGRP' % byterepr(magic))
magic, bom, headerlen, self.version, filesize, self.seccount = self.unpack_from('4s2H3I', data, 0)
self.secinfo = {}
for i in range(self.seccount):
id, pad, offset, size = self.unpack_from('2H2I', data)
if id == 0x7800:
self.secinfo['INFO'] = (offset, size)
elif id == 0x7801:
self.secinfo['FILE'] = (offset, size)
elif id == 0x7802:
self.secinfo['INFX'] = (offset, size)
def readhdr(self, data):
magic, endian = rawutil.unpack_from('>4sH', data, 0)
if magic != b'darc':
error('Invalid magic %s, expected darc' % byterepr(magic), 301)
self.byteorder = ENDIANS[endian]
hdr, ptr = self.unpack_from(DARC_HEADER_STRUCT, data, 0, getptr=True)
#magic=hdr[0]
#bom=hdr[1]
#headerlen=hdr[2]
#unknown = hdr[3]
self.version = hdr[4]
#filelen=hdr[5]
self.tableoffset = hdr[6]
self.tablelen = hdr[7]
self.dataoffset = hdr[8]
return ptr
def read_header(self, data):
bom = rawutil.unpack_from('>H', data, 4)[0]
self.byteorder = '<' if bom == 0xfffe else '>'
hdata = self.unpack_from(BCSTM_HEADER_STRUCT, data)
magic = hdata[0]
if magic != b'CSTM':
error('Invalid magic %s, expected CSTM' % byterepr(magic))
bom = hdata[1]
headerlen = hdata[2]
self.version = hdata[3]
filesize = hdata[4]
blockcount = hdata[5] #Should be 3
padding = hdata[6]
inforef = SizedRef(hdata[7])
seekref = SizedRef(hdata[8])
dataref = SizedRef(hdata[9])
self.info = inforef.getdata(data)
self.seek = seekref.getdata(data)
self.data = dataref.getdata(data)
def read_header(self, data):
magic, bom = rawutil.unpack_from('>4sH', data, 0)
if magic != b'FFNT':
error.InvalidMagicError('Invalid magic %s, expected %s' %
(byterepr(magic), 'FFNT'))
self.byteorder = ENDIANS[bom]
headerlen, version, filesize, blockcount = self.unpack_from(
'H3I', data)
if version not in (0x04010000, 0x04000000, 0x03000000):
error.UnsupportedVersionError(
'Only versions 4.0.0, 4.1.0 and 3.0.0 are supported, found %d.%d.%d'
% (version >> 24, (version >> 16) & 0xFF, version & 0xFFFF))
if self.version is None:
self.version = VERSIONS[version]
self.vernum = version
if self.verbose:
print('Version %d.%d.%d (%s)' %
(version >> 24,
(version >> 16) & 0xFF, version & 0xFFFF, self.version))
def decompress(self):
ptr = 0
final = []
while len(final) < self.decsize:
flags = self.tobits(self.data[ptr])
ptr += 1
for flag in flags:
if flag == 0:
byte, ptr = self.uint8(self.data, ptr)
final.append(byte)
else:
infobs = rawutil.unpack_from('>H', self.data, ptr)[0]
ptr += 2
count = (infobs >> 12) + 3
disp = (infobs & 0xfff) + 1
for i in range(0, count):
final.append(final[-disp])
if len(final) >= self.decsize:
break
ret = bytes(final)
return ret
def read_header(self, data):
startpos = data.tell()
node = {}
magic, bom = rawutil.unpack_from('>8s4xH', data)
self.byteorder = ENDIANS[bom]
data.seek(startpos)
magic, self.version, bom, alignment_exponent, target_adress_size = self.unpack_from('8sIH2B', data)
filename_offset, reloc_flag, self.firstsection_offset, self.reloc_offset, filesize = self.unpack_from('I2H2I', data)
endpos = data.tell()
if magic != b'BNTX\x00\x00\x00\x00':
error.InvalidMagicError('Invalid BNTX magic, found %s' % byterepr(magic))
self.alignment = 1 << alignment_exponent
node['version'] = self.version
node['alignment_exponent'] = alignment_exponent
node['target_adress_size'] = target_adress_size
node['relocation_flag'] = reloc_flag
filename = self.unpack_from('n', data, filename_offset)[0].decode('utf-8')
node['filename'] = filename
self.meta['BNTX'] = node
data.seek(endpos)
if self.verbose:
print('File version : %s.%s.%s.%s' % (self.version >> 24, (self.version >> 16) & 0xFF, (self.version >> 8) & 0xFF, (self.version & 0xFF)))
def __init__(self, filename, data, opts={}):
self.make_outdirs(filename)
self.byteorder = ENDIANS[rawutil.unpack_from('>H', data, 4)[0]]
self.readheader(data)
self.readSTRG()
self.readINFO()
