grp/Wii.py
1
Fork 0
mirror of https://github.com/grp/Wii.py.git synced 2025-06-19 07:15:49 -04:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge git@github.com:icefire/Wii.py

Browse Source
This commit is contained in:
Xuzz 2009-06-29 18:06:43 -07:00
commit e2f8d42189
5 changed files with 804 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
TPL.py
View File

@ -568,10 +568,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

564
breff.py Executable file
View File

@ -0,0 +1,564 @@
#!/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_Section2(Struct):
__endian__ = Struct.BE
def __format__(self):
self.unknown01 = Struct.uint32
self.unknown02 = 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
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.unk16p1 = Struct.uint16
self.unk16p2 = Struct.uint16
self.unknown17 = Struct.float
self.unknown18 = Struct.float
self.unknown19 = Struct.uint32
self.unknown20 = Struct.float
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
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
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
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: %04x\t%04x\n" % (self.unk16p1, self.unk16p2)
return_string += "Unknown17: %.9f\n" % self.unknown17
return_string += "Unknown18: %.9f\n" % self.unknown18
return_string += "Unknown19: %08x\n" % self.unknown19
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: %.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
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_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):
__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_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
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
string_groups = []
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
string_groups.append(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
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
print "\n%08x\n" % pos
''' LARGE TEST DATA
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
LARGE TEST DATA '''
#''' 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 <filename>'
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()

53
disc.py
View File

@ -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:
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 :|
@ -262,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)
@ -308,26 +311,52 @@ 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):
self.buffer = open(f, 'r+b').read()
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])
titleFile = updateEntry[0x1:0x1 + 0x50]
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')]
titleName = updateEntry[0x1 + 0x50:0x1 + 0x50 + 0x40]
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')]
out += '[%04i] [0x%02x] [%40s] [%20s]\n' % (x, titleType, titleFile, titleName)
titleInfo = updateEntry[0xA0:0xE0]
titleInfo = titleInfo[:titleInfo.find('\x00')]
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

10
tests/sysmenuUnpack.py Normal file
View File

@ -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/')

182
thp.py Normal file
View File

@ -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:])