From ba1c30c5b852da203095e739a5453b40a7d4ca9a Mon Sep 17 00:00:00 2001 From: megazig Date: Wed, 24 Jun 2009 14:12:26 -0500 Subject: [PATCH 01/11] RGB5A3 a little better --- TPL.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/TPL.py b/TPL.py index 0270f1b..1f76f6d 100644 --- a/TPL.py +++ b/TPL.py @@ -569,10 +569,10 @@ class TPL(): r = (((pixel >> 0) & 0x1F) * 255) / 31 a = 255 else: #RGB4A3 - b = (((pixel >> 12) & 0x0F) * 255) / 15 - g = (((pixel >> 8) & 0x0F) * 255) / 15 - r = (((pixel >> 4) & 0x0F) * 255) / 15 - a = (((pixel >> 0) & 0x07) * 64) / 7 + a = (((pixel >> 12) & 0x07) * 255) / 7 + b = (((pixel >> 8) & 0x0F) * 255) / 15 + g = (((pixel >> 4) & 0x0F) * 255) / 15 + r = (((pixel >> 0) & 0x0F) * 255)/ 15 rgba = (r << 0) | (g << 8) | (b << 16) | (a << 24) out[(y1 * w) + x1] = rgba From 3de32d664edfc9d61eaa2bdeb9f104c51dda3b5d Mon Sep 17 00:00:00 2001 From: "Giuseppe (LemonBoy)" Date: Wed, 24 Jun 2009 21:15:41 +0200 Subject: [PATCH 02/11] Added a function to dump the partition, need testing --- disc.py | 24 ++++++++++++++++++++---- 1 file changed, 20 insertions(+), 4 deletions(-) diff --git a/disc.py b/disc.py index 4d8f714..7ba642f 100644 --- a/disc.py +++ b/disc.py @@ -98,13 +98,12 @@ class WOD: #WiiOpticalDisc blockStart = offset / 0x7C00 blockLen = (align(size, 0x7C00)) / 0x7C00 - for x in range(blockStart, blockLen): + for x in range(blockStart, blockStart + blockLen): try: self.markedBlocks.index(blockStart + x) - except: + except: self.markedBlocks.append(blockStart + x) - #print '%s (%i blocks marked)' % (self.markedBlocks, len(self.markedBlocks)) def decryptBlock(self, block): if len(block) != 0x8000: raise Exception('Block size too big/small') @@ -115,6 +114,10 @@ class WOD: #WiiOpticalDisc return Crypto().decryptData(self.partitionKey, blockIV, blockData, True) + def readBlock(self, blockNumber): + self.fp.seek(self.partitionOffset + 0x20000 + (0x8000 * blockNumber)) + return self.decryptBlock(self.fp.read(0x8000)) + def readPartition(self, offset, size): readStart = offset / 0x7C00 @@ -135,7 +138,7 @@ class WOD: #WiiOpticalDisc return blob[offset:offset + size] def readUnencrypted(self, offset, size): - if offset > 0x20000: + if offset + size > 0x20000: raise Exception('This read is on encrypted data') # FIXMII : Needs testing, extracting the tmd cause to have 10 null bytes in the end instead of 10 useful bytes at start :| @@ -307,6 +310,18 @@ class WOD: #WiiOpticalDisc def getPartitionMainDol(self): return self.readPartition (self.dolOffset, self.dolSize) + + def dumpPartition(self, fn): + rawPartition = open(fn, 'w+b') + + print 'Partition useful data %i Mb' % (align(len(self.markedBlocks) * 0x7C00, 1024) / 1024 / 1024) + + self.fp.seek(self.partitionOffset) + rawPartition.write(self.fp.read(0x2A4)) # Write teh TIK + rawPartition.write(self.readUnencrypted(0, 0x20000 - 0x2A4)) # Write the TMD and other stuff + + for x in range(len(self.markedBlocks)): + rawPartition.write(self.readBlock(self.markedBlocks[x])) # Write each decrypted block class updateInf(): def __init__(self, f): @@ -323,6 +338,7 @@ class updateInf(): for x in range(self.fileCount): updateEntry = self.buffer[0x2f + x * 0x200:0x2f + (x + 1) * 0x200] titleType = ord(updateEntry[0]) + titlePriority = ord(updateEntry[1]) titleFile = updateEntry[0x1:0x1 + 0x50] titleFile = titleFile[:titleFile.find('\x00')] titleName = updateEntry[0x1 + 0x50:0x1 + 0x50 + 0x40] From 05b25a64af2c50aeb17d18480704c9f966b0bd76 Mon Sep 17 00:00:00 2001 From: Alex Marshall Date: Wed, 24 Jun 2009 12:20:10 -0700 Subject: [PATCH 03/11] Fixed up the __update.inf crap. Doesn't display new fields yet. Fix that plz, lemonny. --- disc.py | 25 ++++++++++++++++--------- 1 file changed, 16 insertions(+), 9 deletions(-) diff --git a/disc.py b/disc.py index 7ba642f..948b1c6 100644 --- a/disc.py +++ b/disc.py @@ -329,20 +329,27 @@ class updateInf(): def __str__(self): out = '' - self.buildDate = self.buffer[:0xa] - self.fileCount = struct.unpack('I', self.buffer[0x13:0x13 + 4])[0] + self.buildDate = self.buffer[:0x10] + self.fileCount = struct.unpack('>L', self.buffer[0x10:0x14])[0] out += 'This update partition was built on %s and has %i files\n\n' % (self.buildDate, self.fileCount) out += '[File] [Type] [File name %30s] [Title description ]\n\n' % '' for x in range(self.fileCount): - updateEntry = self.buffer[0x2f + x * 0x200:0x2f + (x + 1) * 0x200] - titleType = ord(updateEntry[0]) - titlePriority = ord(updateEntry[1]) - titleFile = updateEntry[0x1:0x1 + 0x50] - titleFile = titleFile[:titleFile.find('\x00')] - titleName = updateEntry[0x1 + 0x50:0x1 + 0x50 + 0x40] - titleName = titleName[:titleName.find('\x00')] + updateEntry = self.buffer[0x20 + x * 0x200:0x20 + (x + 1) * 0x200] + titleType = struct.unpack('>L', updateEntry[:0x4])[0] + titleAttr = struct.unpack('>L', updateEntry[0x4:0x8])[0] + titleUnk1 = struct.unpack('>L', updateEntry[0x8:0xC])[0] + titleType2 = struct.unpack('>L', updateEntry[0xC:0x10])[0] + titleFile = updateEntry[0x10:0x50] + titleFile = titleFile[:titleFile.find('\x00')] + titleID = struct.unpack('>Q', updateEntry[0x50:0x58])[0] + titleMajor = struct.unpack('>B', updateEntry[0x58:0x59])[0] + titleMinor = struct.unpack('>B', updateEntry[0x59:0x5A])[0] + titleName = updateEntry[0x60:0xA0] + titleName = titleName[:titleName.find('\x00')] + titleInfo = updateEntry[0xA0:0xE0] + titleInfo = titleInfo[:titleInfo.find('\x00')] out += '[%04i] [0x%02x] [%40s] [%20s]\n' % (x, titleType, titleFile, titleName) return out From 2dcfcef7c724f4f15738c226db0fe034bc74a8b6 Mon Sep 17 00:00:00 2001 From: "Giuseppe (LemonBoy)" Date: Thu, 25 Jun 2009 16:28:03 +0200 Subject: [PATCH 04/11] Added new fields for __update.inf, added a test wich decompress the sysmenu --- disc.py | 12 +++++++++--- tests/sysmenuUnpack.py | 10 ++++++++++ 2 files changed, 19 insertions(+), 3 deletions(-) create mode 100644 tests/sysmenuUnpack.py diff --git a/disc.py b/disc.py index 948b1c6..5205e47 100644 --- a/disc.py +++ b/disc.py @@ -265,7 +265,7 @@ class WOD: #WiiOpticalDisc self.appLdr = self.Apploader().unpack(self.readPartition (0x2440, 32)) self.partitionHdr = self.discHeader().unpack(self.readPartition (0x0, 0x400)) - self.partitionIos = TMD(self.getPartitionTmd()).getIOSVersion() & 0x00ffffff + self.partitionIos = TMD(self.getPartitionTmd()).getIOSVersion() & 0x0fffffff def getFst(self): fstBuf = self.readPartition(self.fstOffset, self.fstSize) @@ -333,7 +333,6 @@ class updateInf(): self.fileCount = struct.unpack('>L', self.buffer[0x10:0x14])[0] out += 'This update partition was built on %s and has %i files\n\n' % (self.buildDate, self.fileCount) - out += '[File] [Type] [File name %30s] [Title description ]\n\n' % '' for x in range(self.fileCount): updateEntry = self.buffer[0x20 + x * 0x200:0x20 + (x + 1) * 0x200] @@ -350,7 +349,14 @@ class updateInf(): titleName = titleName[:titleName.find('\x00')] titleInfo = updateEntry[0xA0:0xE0] titleInfo = titleInfo[:titleInfo.find('\x00')] - out += '[%04i] [0x%02x] [%40s] [%20s]\n' % (x, titleType, titleFile, titleName) + out += 'Update type : 0x%x\n' % titleType + out += 'Update flag : %i (0 means critical, 1 means need reboot)\n' % titleAttr + out += 'Update file : %s\n' % titleFile + out += 'Update ID : %lu\n' % titleID + out += 'Update version : %i.%i\n' % (titleMajor, titleMinor) + out += 'Update name : %s\n' % titleName + out += 'Update info : %s\n' % titleInfo + out += '\n' return out diff --git a/tests/sysmenuUnpack.py b/tests/sysmenuUnpack.py new file mode 100644 index 0000000..01f5948 --- /dev/null +++ b/tests/sysmenuUnpack.py @@ -0,0 +1,10 @@ +import os +from U8 import * +from title import WAD + +sysmenuWad = WAD('/home/giuseppe/Scrivania/RVL-WiiSystemmenu-v258.wad') +sysmenuWad.unpack('/home/giuseppe/Scrivania/sysdump') + +for file in os.listdir('/home/giuseppe/Scrivania/sysdump'): + if open('/home/giuseppe/Scrivania/sysdump/' + file).read(4) == '\x55\xaa\x38\x2d': + U8('/home/giuseppe/Scrivania/sysdump/' + file).unpack('/home/giuseppe/Scrivania/sysdump/' + file + '_decompressed/') From 5f31332cd383c72f598190f90efd9ab7c96bfdb2 Mon Sep 17 00:00:00 2001 From: matt Date: Mon, 29 Jun 2009 09:44:49 +1200 Subject: [PATCH 05/11] Added semi working THP player, has experimental frame skipping code, but is still in need of math checks as it is currently out of time after a while, no AUDIO, but there is video. Sadly python is a bit slow. --- thp.py | 182 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 182 insertions(+) create mode 100644 thp.py diff --git a/thp.py b/thp.py new file mode 100644 index 0000000..f05abc0 --- /dev/null +++ b/thp.py @@ -0,0 +1,182 @@ +from Struct import * +from pyglet import clock, window, image +from pyglet.gl import * +import cStringIO +import math + +from time import time + + +class THP(): + class THPHeader(Struct): + __endian__ = Struct.BE + def __format__(self): + self.magic = Struct.string(4) + self.version = Struct.uint32 + self.bufSize = Struct.uint32 + self.audioMaxSamples = Struct.uint32 + self.frameRate = Struct.float + self.numFrames = Struct.uint32 + self.firstFrameSize = Struct.uint32 + self.movieDataSize = Struct.uint32 + self.compInfoDataOffsets = Struct.uint32 + self.offsetDataOffsets = Struct.uint32 #Offset to a offset table, containing offsets to each frame, this allows for starting playback from any frame. If this is 0 then it does not exist. + self.movieDataOffsets = Struct.uint32 + self.finalFrameDataOffsets = Struct.uint32 + def __str__(self): + ret = "\n" + ret += "Magic: %s\n" % self.magic + ret += "Version: %d.%d.%d\n" % (((self.version & 0xFFFF0000) >> 16), ((self.version & 0xFF00) >> 8), ((self.version & 0xFF))) + ret += "bufSize: %s\n" % self.bufSize + ret += "audioMaxSamples: %d\n" % self.audioMaxSamples + ret += "frameRate: %f\n" % self.frameRate + ret += "numFrames: %d\n" % self.numFrames + ret += "firstFrameSize: %d\n" % self.firstFrameSize + ret += "movieDataSize: %d\n" % self.movieDataSize + ret += "compInfoDataOffsets: 0x%08X\n" % self.compInfoDataOffsets + ret += "offsetDataOffsets: 0x%08X\n" % self.offsetDataOffsets + ret += "movieDataOffsets: 0x%08X\n" % self.movieDataOffsets + ret += "finalFrameDataOffsets: 0x%08X\n" % self.finalFrameDataOffsets + return ret + class THPFrameCompInfo(Struct): + __endian__ = Struct.BE + def __format__(self): + self.numComponents = Struct.uint32 + self.frameComp = Struct.uint8[16] + def __str__(self): + ret = "" + ret += "Number of Components: %d\n" % self.numComponents + return ret + class THPCompVideoInfo(Struct): + __endian__ = Struct.BE + def __format__(self): + self.width = Struct.uint32 + self.height = Struct.uint32 + self.videoType = Struct.uint32 + def __str__(self): + tempType = ("Non-Interlaced", "Interlaced", "Odd Interlace", "3", "Even Interlace") + ret = "" + ret += "Width: %d\n" % self.width + ret += "Height: %d\n" % self.height + ret += "VideoType: %s\n" % tempType[self.videoType] + return ret + class THPCompAudioInfo(Struct): + __endian__ = Struct.BE + def __format__(self): + self.sndChannels = Struct.uint32 + self.sndFrequency = Struct.uint32 + self.sndNumberSamples = Struct.uint32 + self.sndNumberTracks = Struct.uint32 + def __str__(self): + ret = "" + ret += "Channels: %d\n" % self.sndChannels + ret += "Frequency: %d\n" % self.sndFrequency + ret += "Samples: %d\n" % self.sndNumberSamples + ret += "Tracks: %d\n" % self.sndNumberTracks + return ret + class THPFrameHeader(Struct): + __endian__ = Struct.BE + def __format__(self): + self.frameSizeNext = Struct.uint32 + self.frameSizePrev = Struct.uint32 + self.vidFileSize = Struct.uint32 + self.sndFileSize = Struct.uint32 + def __str__(self): + ret = "" + ret += "next Frame Size: %d\n" % self.frameSizeNext + ret += "previous Frame Size: %d\n" % self.frameSizePrev + ret += "Video frame data size: %d\n" % self.vidFileSize + ret += "Track file size: %d\n" % self.sndFileSize + return ret + def readData(self, fp, i=0): + self.frameImage = fp.read(self.vidFileSize) + #fileName = "frame%06d.jpg" % i + #open("out/" + fileName, 'w+b').write(self.frameImage) + #print "Frame: %d" % i + startTime = time() + start = self.frameImage.find('\xff\xda') + end = self.frameImage.rfind('\xff\xd9') + #print "find(%d): This took "%i, time()-startTime,start,end + startTime = time() + startStr = self.frameImage[:start+2] + endStr = self.frameImage[end:] + #print "extr(%d): This took "%i, time()-startTime + self.frameImage = self.frameImage[start+2:end] + self.frameImage = startStr + self.frameImage.replace('\xff','\xff\x00') + endStr + #print self.frameImage + + + return cStringIO.StringIO(self.frameImage) + def __init__(self, movieFile=None): + if(movieFile==None): + print "Usage: python thp.py filename.thp" + exit(-1) + fp = file(movieFile, 'rb') + HEADER = self.THPHeader() + HEADER.unpack(fp.read(len(HEADER))) + print HEADER + fp.seek(HEADER.compInfoDataOffsets) + CompInfo = self.THPFrameCompInfo() + CompInfo.unpack(fp.read(len(CompInfo))) + print CompInfo + for i in range(0, CompInfo.numComponents): + if(CompInfo.frameComp[i] == 0): + VideoInfo = self.THPCompVideoInfo() + VideoInfo.unpack(fp.read(len(VideoInfo))) + print VideoInfo + if(CompInfo.frameComp[i] == 1): + AudioInfo = self.THPCompAudioInfo() + AudioInfo.unpack(fp.read(len(AudioInfo))) + print AudioInfo + + clock.set_fps_limit(HEADER.frameRate) + currOff = HEADER.movieDataOffsets + currSize = HEADER.firstFrameSize + fp.seek(currOff) + + win = window.Window(VideoInfo.width, VideoInfo.height) + fps_display = clock.ClockDisplay() + i = 1 + j = 1 + image_index = 0 + image_period = 1.0 / HEADER.frameRate # Reciprocal of the frame rate + remained = 0 + + while not win.has_exit: + + win.dispatch_events() + win.clear() + + dt = clock.tick() + + skip = math.floor((dt+remained)/image_period) + j += skip + print skip, ":break:", i, j, skip + remained = dt - skip * image_period + + tempFrame = self.THPFrameHeader() + tempFrame.unpack(fp.read(len(tempFrame))) + + for xx in range(1,skip): + currOff = currOff+currSize + currSize = tempFrame.frameSizeNext + fp.seek(currOff) + tempFrame = self.THPFrameHeader() + tempFrame.unpack(fp.read(len(tempFrame))) + + imagedat = tempFrame.readData(fp, i) + + pic = image.load("image.jpg",imagedat) + pic.blit(0,0) + + currOff = currOff+currSize + currSize = tempFrame.frameSizeNext + fp.seek(currOff) + + + fps_display.draw() + win.flip() + i += 1 + +if __name__=='__main__': + THP(*sys.argv[1:]) \ No newline at end of file From 891b8557f7a95e4d62dd06e11c9432f18bca260f Mon Sep 17 00:00:00 2001 From: megazig Date: Mon, 29 Jun 2009 15:15:44 -0500 Subject: [PATCH 06/11] started framework for people to do breff --- breff.py | 173 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 173 insertions(+) create mode 100755 breff.py diff --git a/breff.py b/breff.py new file mode 100755 index 0000000..93cff1f --- /dev/null +++ b/breff.py @@ -0,0 +1,173 @@ +#!/usr/bin/python + +import sys, struct + +from Struct import Struct + +def nullterm(str_plus): + z = str_plus.find('\0') + if z != -1: + return str_plus[:z] + else: + return str_plus + +class BREFF(object): + class BREFF_REFF_StringSection1(Struct): + __endian__ = Struct.BE + def __format__(self): + self.offset = Struct.uint32 + self.length = Struct.uint32 + def __str__(self): + return_string = "Offset: %08x\n" % self.offset + return_string += "Length: %08x\n" % self.length + return return_string + + class BREFF_REFF(Struct): + __endian__ = Struct.BE + def __format__(self): + self.magic = Struct.string(4) + self.length = Struct.uint32 + self.chunk_cnt = Struct.uint32 + def __str__(self): + return "Magic: %s\nLength: %08x\nChunk Count: %08x\n" % (self.magic , self.length , self.chunk_cnt) + + class BREFF_Header(Struct): + __endian__ = Struct.BE + def __format__(self): + self.magic = Struct.string(4) + self.version = Struct.uint32 + self.length = Struct.uint32 + self.header_size = Struct.uint16 + self.chunk_cnt = Struct.uint16 + def __str__(self): + return_string = "Magic: %s\n" % self.magic + return_string += "Version: %08x\n" % self.version + return_string += "Length: %08x\n" % self.length + return_string += "Header Size: %04x\n" % self.header_size + return_string += "Chunk Count: %04x\n" % self.chunk_cnt + return return_string + + def __init__(self, data): + self.data = [] + if data != None: + self.Unpack(data) + + def Unpack(self, data): + pos = 0 + header = self.BREFF_Header() + header.unpack(data[pos:pos+len(header)]) + pos += len(header) + print header + assert header.magic == "REFF" + assert header.version == 0xfeff0004 + reff = self.BREFF_REFF() + reff.unpack(data[pos:pos+len(reff)]) + pos += len(reff) + print reff + assert reff.magic == "REFF" + + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown: %08x" % unknown + str_length = Struct.uint16(data[pos:pos+2], endian='>') + pos += 2 + print "String Length with null added: %04x" % str_length + unknown = Struct.uint16(data[pos:pos+2], endian='>') + pos += 2 + print "Unknown: %04x" % unknown + string = data[pos:pos+str_length-1] + pos += str_length + (2 - (str_length % 2)) + print "String: %s\n" % string + + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Offset or Length: %08x" % unknown + + print "\n%08x\n" % pos + + string_cnt = Struct.uint16(data[pos:pos+2], endian='>') + pos += 2 + print "String Count: %04x" % string_cnt + unknown = Struct.uint16(data[pos:pos+2], endian='>') + pos += 2 + print "Unknown: %04x" % unknown + + print "\n%08x\n" % pos + + for x in xrange(string_cnt): + str_length = Struct.uint16(data[pos:pos+2], endian='>') + pos += 2 + print "String Length with null added: %04x" % str_length + string = nullterm(data[pos:pos+str_length]) + pos += str_length + print "String: %s" % string + string_section1 = self.BREFF_REFF_StringSection1() + string_section1.unpack(data[pos:pos+len(string_section1)]) + pos += len(string_section1) + print string_section1 + + print "\n%08x\n" % pos + + while pos % 0x10: + padding = Struct.uint8(data[pos:pos+1]) + pos += 1 + print "Padding: %02x" % padding + + print "\n%08x\n" % pos + + for x in xrange(string_cnt): + pass + + #''' BEGIN TEST DATA + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown: %08x" % unknown + #END TEST DATA ''' + +def main(): + if len(sys.argv) != 2: + print 'Usage: python breff.py ' + sys.exit(1) + + f = open(sys.argv[1], 'rb') + if f: + reff = f.read() + f.close() + assert reff[0:8] == 'REFF\xfe\xff\x00\x04' + breff = BREFF(reff) + else: + print 'Could not open %s' % sys.argv[1] + sys.exit(1) + +if __name__ == "__main__": + main() From 80d274aeab6f88296b29ece6ee16695721e4f8e0 Mon Sep 17 00:00:00 2001 From: megazig Date: Mon, 29 Jun 2009 15:53:08 -0500 Subject: [PATCH 07/11] I found PI --- breff.py | 148 ++++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 146 insertions(+), 2 deletions(-) diff --git a/breff.py b/breff.py index 93cff1f..aad50aa 100755 --- a/breff.py +++ b/breff.py @@ -118,8 +118,152 @@ class BREFF(object): print "\n%08x\n" % pos - for x in xrange(string_cnt): - pass +# for x in xrange(string_cnt): + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown01: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown02: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown03: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown04: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown05: %08x" % unknown + unknown = Struct.float(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown06: %f" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown07: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown08: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown09: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown10: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown11: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown12: %08x" % unknown + unknown = Struct.float(data[pos:pos+4], endian='>') + pos += 4 + print "PI TIMES 2 BITCHES: %.20f" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown14: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown15: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown16: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown17: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown18: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown19: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown20: %08x" % unknown + unknown = Struct.float(data[pos:pos+4], endian='>') + pos += 4 + print "PI DIVIDED BY 4 BITCHES: %.20f" % unknown + unknown = Struct.float(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown22: %f" % unknown + unknown = Struct.float(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown23: %f" % unknown + unknown = Struct.float(data[pos:pos+4], endian='>') + pos += 4 + print "PI BITCHES: %.20f" % unknown + unknown = Struct.float(data[pos:pos+4], endian='>') + pos += 4 + print "PI DIVIDED BY 2 BITCHES: %.20f" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown26: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown27: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown28: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown29: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown30: %08x" % unknown + unknown = Struct.float(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown31: %f" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown32: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown33: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown34: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown35: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown36: %08x" % unknown + unknown = Struct.float(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown37: %f" % unknown + unknown = Struct.float(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown38: %f" % unknown + unknown = Struct.float(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown39: %f" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown40: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown41: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown42: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown43: %08x" % unknown + unknown = Struct.float(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown44: %.20f" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown45: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown46: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown47: %08x" % unknown + unknown = Struct.uint32(data[pos:pos+4], endian='>') + pos += 4 + print "Unknown48: %08x" % unknown + #pass #''' BEGIN TEST DATA unknown = Struct.uint32(data[pos:pos+4], endian='>') From db4c792d031b31fa3c730acc7737c0f7643a3ee0 Mon Sep 17 00:00:00 2001 From: megazig Date: Mon, 29 Jun 2009 16:06:24 -0500 Subject: [PATCH 08/11] I found PI --- breff.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/breff.py b/breff.py index aad50aa..5df4bbe 100755 --- a/breff.py +++ b/breff.py @@ -29,7 +29,10 @@ class BREFF(object): self.length = Struct.uint32 self.chunk_cnt = Struct.uint32 def __str__(self): - return "Magic: %s\nLength: %08x\nChunk Count: %08x\n" % (self.magic , self.length , self.chunk_cnt) + return_string = "Magic: %s\n" % self.magic + return_string += "Length: %08x\n" % self.length + return_string += "Chunk Count: %08x\n" % self.chunk_cnt + return return_string class BREFF_Header(Struct): __endian__ = Struct.BE From 517db2c4097b519d26a487a917ffbda92e88ba2b Mon Sep 17 00:00:00 2001 From: megazig Date: Mon, 29 Jun 2009 16:35:31 -0500 Subject: [PATCH 09/11] started framework for people to do breff --- breff.py | 116 ++++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 114 insertions(+), 2 deletions(-) diff --git a/breff.py b/breff.py index 5df4bbe..d6d6cc1 100755 --- a/breff.py +++ b/breff.py @@ -12,6 +12,108 @@ def nullterm(str_plus): return str_plus class BREFF(object): + class BREFF_REFF_Section2(Struct): + __endian__ = Struct.BE + def __format__(self): + self.unknown01 = Struct.uint32 + self.unknown02 = Struct.uint32 + self.unknown03 = Struct.uint32 + self.unknown04 = Struct.uint32 + self.unknown05 = Struct.uint32 + self.unknown06 = Struct.float + self.unknown07 = Struct.uint32 + self.unknown08 = Struct.uint32 + self.unknown09 = Struct.uint32 + self.unknown10 = Struct.float + self.unknown11 = Struct.float + self.unknown12 = Struct.uint32 + self.unknown13 = Struct.float + self.unknown14 = Struct.uint32 + self.unknown15 = Struct.uint32 + self.unknown16 = Struct.uint32 + self.unknown17 = Struct.float + self.unknown18 = Struct.uint32 + self.unknown19 = Struct.uint32 + self.unknown20 = Struct.uint32 + self.unknown21 = Struct.float + self.unknown22 = Struct.float + self.unknown23 = Struct.float + self.unknown24 = Struct.float + self.unknown25 = Struct.float + self.unknown26 = Struct.uint32 + self.unknown27 = Struct.uint32 + self.unknown28 = Struct.uint32 + self.unknown29 = Struct.uint32 + self.unknown30 = Struct.uint32 + self.unknown31 = Struct.float + self.unknown32 = Struct.uint32 + self.unknown33 = Struct.uint32 + self.unknown34 = Struct.uint32 + self.unknown35 = Struct.uint32 + self.unknown36 = Struct.uint32 + self.unknown37 = Struct.float + self.unknown38 = Struct.float + self.unknown39 = Struct.float + self.unknown40 = Struct.float + self.unknown41 = Struct.float + self.unknown42 = Struct.uint32 + self.unknown43 = Struct.uint32 + self.unknown44 = Struct.float + self.unknown45 = Struct.uint32 + self.unknown46 = Struct.uint32 + self.unknown47 = Struct.uint32 + self.unknown48 = Struct.uint32 + def __str__(self): + return_string = "Unknown01: %08x\n" % self.unknown01 + return_string += "Unknown02: %08x\n" % self.unknown02 + return_string += "Unknown03: %08x\n" % self.unknown03 + return_string += "Unknown04: %08x\n" % self.unknown04 + return_string += "Unknown05: %08x\n" % self.unknown05 + return_string += "Unknown06: %.9f\n" % self.unknown06 + return_string += "Unknown07: %08x\n" % self.unknown07 + return_string += "Unknown08: %08x\n" % self.unknown08 + return_string += "Unknown09: %08x\n" % self.unknown09 + return_string += "Unknown10: %.9f\n" % self.unknown10 + return_string += "Unknown11: %.9f\n" % self.unknown11 + return_string += "Unknown12: %08x\n" % self.unknown12 + return_string += "Unknown13: %.9f\n" % self.unknown13 + return_string += "Unknown14: %08x\n" % self.unknown14 + return_string += "Unknown15: %08x\n" % self.unknown15 + return_string += "Unknown16: %08x\n" % self.unknown16 + return_string += "Unknown17: %.9f\n" % self.unknown17 + return_string += "Unknown18: %08x\n" % self.unknown18 + return_string += "Unknown19: %08x\n" % self.unknown19 + return_string += "Unknown20: %08x\n" % self.unknown20 + return_string += "Unknown21: %.9f\n" % self.unknown21 + return_string += "Unknown22: %08x\n" % self.unknown22 + return_string += "Unknown23: %08x\n" % self.unknown23 + return_string += "Unknown24: %.9f\n" % self.unknown24 + return_string += "Unknown25: %.9f\n" % self.unknown25 + return_string += "Unknown26: %08x\n" % self.unknown26 + return_string += "Unknown27: %08x\n" % self.unknown27 + return_string += "Unknown28: %08x\n" % self.unknown28 + return_string += "Unknown29: %08x\n" % self.unknown29 + return_string += "Unknown30: %08x\n" % self.unknown30 + return_string += "Unknown31: %.9f\n" % self.unknown31 + return_string += "Unknown32: %08x\n" % self.unknown32 + return_string += "Unknown33: %08x\n" % self.unknown33 + return_string += "Unknown34: %08x\n" % self.unknown34 + return_string += "Unknown35: %08x\n" % self.unknown35 + return_string += "Unknown36: %08x\n" % self.unknown36 + return_string += "Unknown37: %.9f\n" % self.unknown37 + return_string += "Unknown38: %.9f\n" % self.unknown38 + return_string += "Unknown39: %.9f\n" % self.unknown39 + return_string += "Unknown40: %.9f\n" % self.unknown40 + return_string += "Unknown41: %.9f\n" % self.unknown41 + return_string += "Unknown42: %08x\n" % self.unknown42 + return_string += "Unknown43: %08x\n" % self.unknown43 + return_string += "Unknown44: %.9f\n" % self.unknown44 + return_string += "Unknown45: %08x\n" % self.unknown45 + return_string += "Unknown46: %08x\n" % self.unknown46 + return_string += "Unknown47: %08x\n" % self.unknown47 + return_string += "Unknown48: %08x\n" % self.unknown48 + return return_string + class BREFF_REFF_StringSection1(Struct): __endian__ = Struct.BE def __format__(self): @@ -100,6 +202,7 @@ class BREFF(object): print "\n%08x\n" % pos + string_groups = [] for x in xrange(string_cnt): str_length = Struct.uint16(data[pos:pos+2], endian='>') pos += 2 @@ -111,6 +214,7 @@ class BREFF(object): string_section1.unpack(data[pos:pos+len(string_section1)]) pos += len(string_section1) print string_section1 + string_groups.append(string_section1) print "\n%08x\n" % pos @@ -121,7 +225,15 @@ class BREFF(object): print "\n%08x\n" % pos -# for x in xrange(string_cnt): + assert pos == string_groups[0].offset + 0x34 + for x in xrange(string_cnt): + pos = 0x34 + string_groups[x].offset + reff_section2 = self.BREFF_REFF_Section2() + reff_section2.unpack(data[pos:pos+len(reff_section2)]) + pos += len(reff_section2) + print reff_section2 + + ''' LARGE TEST DATA unknown = Struct.uint32(data[pos:pos+4], endian='>') pos += 4 print "Unknown01: %08x" % unknown @@ -266,7 +378,7 @@ class BREFF(object): unknown = Struct.uint32(data[pos:pos+4], endian='>') pos += 4 print "Unknown48: %08x" % unknown - #pass + LARGE TEST DATA ''' #''' BEGIN TEST DATA unknown = Struct.uint32(data[pos:pos+4], endian='>') From 55e77da5ace73220d970ea58048339b39c92c3a4 Mon Sep 17 00:00:00 2001 From: megazig Date: Mon, 29 Jun 2009 16:49:48 -0500 Subject: [PATCH 10/11] added more speculation --- breff.py | 29 ++++++++++++++++------------- 1 file changed, 16 insertions(+), 13 deletions(-) diff --git a/breff.py b/breff.py index d6d6cc1..7004197 100755 --- a/breff.py +++ b/breff.py @@ -17,8 +17,10 @@ class BREFF(object): def __format__(self): self.unknown01 = Struct.uint32 self.unknown02 = Struct.uint32 - self.unknown03 = Struct.uint32 - self.unknown04 = Struct.uint32 + self.unk03p1 = Struct.uint16 + self.unk03p2 = Struct.uint16 + self.unk04p1 = Struct.int16 + self.unk04p2 = Struct.uint16 self.unknown05 = Struct.uint32 self.unknown06 = Struct.float self.unknown07 = Struct.uint32 @@ -30,11 +32,12 @@ class BREFF(object): self.unknown13 = Struct.float self.unknown14 = Struct.uint32 self.unknown15 = Struct.uint32 - self.unknown16 = Struct.uint32 + self.unk16p1 = Struct.uint16 + self.unk16p2 = Struct.uint16 self.unknown17 = Struct.float - self.unknown18 = Struct.uint32 + self.unknown18 = Struct.float self.unknown19 = Struct.uint32 - self.unknown20 = Struct.uint32 + self.unknown20 = Struct.float self.unknown21 = Struct.float self.unknown22 = Struct.float self.unknown23 = Struct.float @@ -64,10 +67,10 @@ class BREFF(object): self.unknown47 = Struct.uint32 self.unknown48 = Struct.uint32 def __str__(self): - return_string = "Unknown01: %08x\n" % self.unknown01 - return_string += "Unknown02: %08x\n" % self.unknown02 - return_string += "Unknown03: %08x\n" % self.unknown03 - return_string += "Unknown04: %08x\n" % self.unknown04 + return_string = "Unknown01: %08x\talways 00000128 ?\n" % self.unknown01 + return_string += "Unknown02: %08x\talways 80000xxx ?\n" % self.unknown02 + return_string += "Unknown03: %04x\t%04x\n" % (self.unk03p1 , self.unk03p2) + return_string += "Unknown04: %.2d\t%04x\n" % (self.unk04p1 , self.unk04p2) return_string += "Unknown05: %08x\n" % self.unknown05 return_string += "Unknown06: %.9f\n" % self.unknown06 return_string += "Unknown07: %08x\n" % self.unknown07 @@ -79,15 +82,15 @@ class BREFF(object): return_string += "Unknown13: %.9f\n" % self.unknown13 return_string += "Unknown14: %08x\n" % self.unknown14 return_string += "Unknown15: %08x\n" % self.unknown15 - return_string += "Unknown16: %08x\n" % self.unknown16 + return_string += "Unknown16: %04x\t%04x\n" % (self.unk16p1, self.unk16p2) return_string += "Unknown17: %.9f\n" % self.unknown17 - return_string += "Unknown18: %08x\n" % self.unknown18 + return_string += "Unknown18: %.9f\n" % self.unknown18 return_string += "Unknown19: %08x\n" % self.unknown19 - return_string += "Unknown20: %08x\n" % self.unknown20 + return_string += "Unknown20: %.9f\n" % self.unknown20 return_string += "Unknown21: %.9f\n" % self.unknown21 return_string += "Unknown22: %08x\n" % self.unknown22 return_string += "Unknown23: %08x\n" % self.unknown23 - return_string += "Unknown24: %.9f\n" % self.unknown24 + return_string += "Unknown24: %.20f\n" % self.unknown24 return_string += "Unknown25: %.9f\n" % self.unknown25 return_string += "Unknown26: %08x\n" % self.unknown26 return_string += "Unknown27: %08x\n" % self.unknown27 From e49fa1dbd9ef16813cf657a3ace32a1a011da843 Mon Sep 17 00:00:00 2001 From: megazig Date: Mon, 29 Jun 2009 17:12:22 -0500 Subject: [PATCH 11/11] added bytes up to smallest section --- breff.py | 129 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 129 insertions(+) diff --git a/breff.py b/breff.py index 7004197..ef17c7d 100755 --- a/breff.py +++ b/breff.py @@ -66,6 +66,70 @@ class BREFF(object): self.unknown46 = Struct.uint32 self.unknown47 = Struct.uint32 self.unknown48 = Struct.uint32 + self.unknown49 = Struct.uint32 + self.unknown50 = Struct.uint32 + self.unknown51 = Struct.uint32 + self.unknown52 = Struct.uint32 + self.unknown53 = Struct.uint32 + self.unknown54 = Struct.uint32 + self.unknown55 = Struct.uint32 + self.unknown56 = Struct.uint32 + self.unknown57 = Struct.uint32 + self.unknown58 = Struct.uint32 + self.unknown59 = Struct.uint32 + self.unknown60 = Struct.uint32 + self.unknown61 = Struct.uint32 + self.unknown62 = Struct.uint32 + self.unknown63 = Struct.uint32 + self.unknown64 = Struct.uint32 + self.unknown65 = Struct.uint32 + self.unknown66 = Struct.uint32 + self.unknown67 = Struct.uint32 + self.unknown68 = Struct.uint32 + self.unknown69 = Struct.uint32 + self.unknown70 = Struct.uint32 + self.unknown71 = Struct.uint32 + self.unknown72 = Struct.uint32 + self.unknown73 = Struct.uint32 + self.unknown74 = Struct.uint32 + self.unknown75 = Struct.uint32 + self.unknown76 = Struct.uint32 + self.unknown77 = Struct.uint32 + self.unknown78 = Struct.uint32 + self.unknown79 = Struct.uint32 + self.unknown80 = Struct.uint32 + self.unknown81 = Struct.uint32 + self.unknown82 = Struct.uint32 + self.unknown83 = Struct.uint32 + self.unknown84 = Struct.uint32 + self.unknown85 = Struct.uint32 + self.unknown86 = Struct.uint32 + self.unknown87 = Struct.uint32 + self.unknown88 = Struct.uint32 + self.unknown89 = Struct.uint32 + self.unknown90 = Struct.uint32 + self.unknown91 = Struct.uint32 + self.unknown92 = Struct.uint32 + self.unknown93 = Struct.uint32 + self.unknown94 = Struct.uint32 + self.unknown95 = Struct.uint32 + self.unknown96 = Struct.uint32 + self.unknown97 = Struct.uint32 + self.unknown98 = Struct.uint32 + self.unknown99 = Struct.uint32 + self.unknownA0 = Struct.uint32 + self.unknownA1 = Struct.uint32 + self.unknownA2 = Struct.uint32 + self.unknownA3 = Struct.uint32 + self.unknownA4 = Struct.uint32 + self.unknownA5 = Struct.uint32 + self.unknownA6 = Struct.uint32 + self.unknownA7 = Struct.uint32 + self.unknownA8 = Struct.uint32 + self.unknownA9 = Struct.uint32 + self.unknownB0 = Struct.uint32 + self.unknownB1 = Struct.uint32 + self.unknownB2 = Struct.uint32 def __str__(self): return_string = "Unknown01: %08x\talways 00000128 ?\n" % self.unknown01 return_string += "Unknown02: %08x\talways 80000xxx ?\n" % self.unknown02 @@ -115,6 +179,70 @@ class BREFF(object): return_string += "Unknown46: %08x\n" % self.unknown46 return_string += "Unknown47: %08x\n" % self.unknown47 return_string += "Unknown48: %08x\n" % self.unknown48 + return_string += "Unknown49: %08x\n" % self.unknown49 + return_string += "Unknown50: %08x\n" % self.unknown50 + return_string += "Unknown51: %08x\n" % self.unknown51 + return_string += "Unknown52: %08x\n" % self.unknown52 + return_string += "Unknown53: %08x\n" % self.unknown53 + return_string += "Unknown54: %08x\n" % self.unknown54 + return_string += "Unknown55: %08x\n" % self.unknown55 + return_string += "Unknown56: %08x\n" % self.unknown56 + return_string += "Unknown57: %08x\n" % self.unknown57 + return_string += "Unknown58: %08x\n" % self.unknown58 + return_string += "Unknown59: %08x\n" % self.unknown59 + return_string += "Unknown60: %08x\n" % self.unknown60 + return_string += "Unknown61: %08x\n" % self.unknown61 + return_string += "Unknown62: %08x\n" % self.unknown62 + return_string += "Unknown63: %08x\n" % self.unknown63 + return_string += "Unknown64: %08x\n" % self.unknown64 + return_string += "Unknown65: %08x\n" % self.unknown65 + return_string += "Unknown66: %08x\n" % self.unknown66 + return_string += "Unknown67: %08x\n" % self.unknown67 + return_string += "Unknown68: %08x\n" % self.unknown68 + return_string += "Unknown69: %08x\n" % self.unknown69 + return_string += "Unknown70: %08x\n" % self.unknown70 + return_string += "Unknown71: %08x\n" % self.unknown71 + return_string += "Unknown72: %08x\n" % self.unknown72 + return_string += "Unknown73: %08x\n" % self.unknown73 + return_string += "Unknown74: %08x\n" % self.unknown74 + return_string += "Unknown75: %08x\n" % self.unknown75 + return_string += "Unknown76: %08x\n" % self.unknown76 + return_string += "Unknown77: %08x\n" % self.unknown77 + return_string += "Unknown78: %08x\n" % self.unknown78 + return_string += "Unknown79: %08x\n" % self.unknown79 + return_string += "Unknown80: %08x\n" % self.unknown80 + return_string += "Unknown81: %08x\n" % self.unknown81 + return_string += "Unknown82: %08x\n" % self.unknown82 + return_string += "Unknown83: %08x\n" % self.unknown83 + return_string += "Unknown84: %08x\n" % self.unknown84 + return_string += "Unknown85: %08x\n" % self.unknown85 + return_string += "Unknown86: %08x\n" % self.unknown86 + return_string += "Unknown87: %08x\n" % self.unknown87 + return_string += "Unknown88: %08x\n" % self.unknown88 + return_string += "Unknown89: %08x\n" % self.unknown89 + return_string += "Unknown90: %08x\n" % self.unknown90 + return_string += "Unknown91: %08x\n" % self.unknown91 + return_string += "Unknown92: %08x\n" % self.unknown92 + return_string += "Unknown93: %08x\n" % self.unknown93 + return_string += "Unknown94: %08x\n" % self.unknown94 + return_string += "Unknown95: %08x\n" % self.unknown95 + return_string += "Unknown96: %08x\n" % self.unknown96 + return_string += "Unknown97: %08x\n" % self.unknown97 + return_string += "Unknown98: %08x\n" % self.unknown98 + return_string += "Unknown99: %08x\n" % self.unknown99 + return_string += "UnknownA0: %08x\n" % self.unknownA0 + return_string += "UnknownA1: %08x\n" % self.unknownA1 + return_string += "UnknownA2: %08x\n" % self.unknownA2 + return_string += "UnknownA3: %08x\n" % self.unknownA3 + return_string += "UnknownA4: %08x\n" % self.unknownA4 + return_string += "UnknownA5: %08x\n" % self.unknownA5 + return_string += "UnknownA6: %08x\n" % self.unknownA6 + return_string += "UnknownA7: %08x\n" % self.unknownA7 + return_string += "UnknownA8: %08x\n" % self.unknownA8 + return_string += "UnknownA9: %08x\n" % self.unknownA9 + return_string += "UnknownB0: %08x\n" % self.unknownB0 + return_string += "UnknownB1: %08x\n" % self.unknownB1 + return_string += "UnknownB2: %08x\n" % self.unknownB2 return return_string class BREFF_REFF_StringSection1(Struct): @@ -235,6 +363,7 @@ class BREFF(object): reff_section2.unpack(data[pos:pos+len(reff_section2)]) pos += len(reff_section2) print reff_section2 + print "\n%08x\n" % pos ''' LARGE TEST DATA unknown = Struct.uint32(data[pos:pos+4], endian='>')