archive/blender-asset-manager
Archived
0
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

refactor for newstyle py api, add __slots__

Browse Source
This commit is contained in:
Campbell Barton
2014-10-14 11:14:20 +02:00
parent c48bcff794
commit f1f6033618
1 changed files with 286 additions and 234 deletions
Download Patch File Download Diff File Expand all files Collapse all files

518
blendfile.py
View File

@@ -66,8 +66,8 @@ def openBlendFile(filename, access="rb"):
log.debug("normal blendfile detected") log.debug("normal blendfile detected")
handle.seek(0, os.SEEK_SET) handle.seek(0, os.SEEK_SET)
res = BlendFile(handle) res = BlendFile(handle)
res.compressed = False res.is_compressed = False
res.originalfilename = filename res.filepath_orig = filename
return res return res
else: else:
log.debug("gzip blendfile detected?") log.debug("gzip blendfile detected?")
@@ -84,8 +84,8 @@ def openBlendFile(filename, access="rb"):
log.debug("resetting decompressed file") log.debug("resetting decompressed file")
handle.seek(os.SEEK_SET, 0) handle.seek(os.SEEK_SET, 0)
res = BlendFile(handle) res = BlendFile(handle)
res.compressed = True res.is_compressed = True
res.originalfilename = filename res.filepath_orig = filename
return res return res
@@ -93,11 +93,11 @@ def closeBlendFile(afile):
"""close the blend file """close the blend file
writes the blend file to disk if changes has happened""" writes the blend file to disk if changes has happened"""
handle = afile.handle handle = afile.handle
if afile.compressed: if afile.is_compressed:
log.debug("close compressed blend file") log.debug("close compressed blend file")
handle.seek(os.SEEK_SET, 0) handle.seek(os.SEEK_SET, 0)
log.debug("compressing started") log.debug("compressing started")
fs = gzip.open(afile.originalfilename, "wb") fs = gzip.open(afile.filepath_orig, "wb")
data = handle.read(FILE_BUFFER_SIZE) data = handle.read(FILE_BUFFER_SIZE)
while data: while data:
fs.write(data) fs.write(data)
@@ -156,7 +156,7 @@ def ReadString0(data, offset):
###################################################### ######################################################
USHORT = [struct.Struct("<H"), struct.Struct(">H")] USHORT = [struct.Struct("<H"), struct.Struct(">H")]
def ReadUShort(handle, fileheader): def ReadUShort(handle, fileheader):
us = USHORT[fileheader.LittleEndiannessIndex] us = USHORT[fileheader.endian_index]
return us.unpack(handle.read(us.size))[0] return us.unpack(handle.read(us.size))[0]
@@ -165,27 +165,27 @@ def ReadUShort(handle, fileheader):
###################################################### ######################################################
UINT = [struct.Struct("<I"), struct.Struct(">I")] UINT = [struct.Struct("<I"), struct.Struct(">I")]
def ReadUInt(handle, fileheader): def ReadUInt(handle, fileheader):
us = UINT[fileheader.LittleEndiannessIndex] us = UINT[fileheader.endian_index]
return us.unpack(handle.read(us.size))[0] return us.unpack(handle.read(us.size))[0]
def ReadInt(handle, fileheader): def ReadInt(handle, fileheader):
return struct.unpack(fileheader.StructPre+"i", handle.read(4))[0] return struct.unpack(fileheader.endian_str + "i", handle.read(4))[0]
def ReadFloat(handle, fileheader): def ReadFloat(handle, fileheader):
return struct.unpack(fileheader.StructPre+"f", handle.read(4))[0] return struct.unpack(fileheader.endian_str + "f", handle.read(4))[0]
SSHORT = [struct.Struct("<h"), struct.Struct(">h")] SSHORT = [struct.Struct("<h"), struct.Struct(">h")]
def ReadShort(handle, fileheader): def ReadShort(handle, fileheader):
us = SSHORT[fileheader.LittleEndiannessIndex] us = SSHORT[fileheader.endian_index]
return us.unpack(handle.read(us.size))[0] return us.unpack(handle.read(us.size))[0]
ULONG = [struct.Struct("<Q"), struct.Struct(">Q")] ULONG = [struct.Struct("<Q"), struct.Struct(">Q")]
def ReadULong(handle, fileheader): def ReadULong(handle, fileheader):
us = ULONG[fileheader.LittleEndiannessIndex] us = ULONG[fileheader.endian_index]
return us.unpack(handle.read(us.size))[0] return us.unpack(handle.read(us.size))[0]
@@ -194,143 +194,161 @@ def ReadULong(handle, fileheader):
# the pointersize is given by the header (BlendFileHeader) # the pointersize is given by the header (BlendFileHeader)
###################################################### ######################################################
def ReadPointer(handle, header): def ReadPointer(handle, header):
if header.PointerSize == 4: if header.pointer_size == 4:
us = UINT[header.LittleEndiannessIndex] us = UINT[header.endian_index]
return us.unpack(handle.read(us.size))[0] return us.unpack(handle.read(us.size))[0]
if header.PointerSize == 8: if header.pointer_size == 8:
us = ULONG[header.LittleEndiannessIndex] us = ULONG[header.endian_index]
return us.unpack(handle.read(us.size))[0] return us.unpack(handle.read(us.size))[0]
###################################################### ######################################################
# Allign alligns the filehandle on 4 bytes # Align alligns the filehandle on 4 bytes
###################################################### ######################################################
def Allign(offset): def align(offset, by):
trim = offset % 4 n = by - 1
if trim != 0: return (offset + n) & ~n
offset = offset + (4 - trim)
return offset
###################################################### ######################################################
# module classes # module classes
###################################################### ######################################################
######################################################
# BlendFile
# - Header (BlendFileHeader)
# - Blocks (FileBlockHeader)
# - Catalog (DNACatalog)
######################################################
class BlendFile: class BlendFile:
"""
Blend file.
"""
__slots__ = (
# file (result of open())
"handle",
# str (original name of the file path)
"filepath_orig",
# BlendFileHeader
"header",
# struct.Struct
"block_header_struct",
# FileBlockHeader
"blocks",
# DNACatalog
"catalog",
# int
"code_index",
# bool (did we make a change)
"is_modified",
# bool (is file gzipped)
"is_compressed",
)
def __init__(self, handle): def __init__(self, handle):
log.debug("initializing reading blend-file") log.debug("initializing reading blend-file")
self.handle = handle self.handle = handle
self.Header = BlendFileHeader(handle) self.header = BlendFileHeader(handle)
self.BlockHeaderStruct = self.Header.CreateBlockHeaderStruct() self.block_header_struct = self.header.create_block_header_struct()
self.Blocks = [] self.blocks = []
self.CodeIndex = {} self.code_index = {}
aBlock = BlendFileBlock(handle, self) block = BlendFileBlock(handle, self)
while aBlock.Code != "ENDB": while block.code != "ENDB":
if aBlock.Code == "DNA1": if block.code == "DNA1":
self.Catalog = DNACatalog(self.Header, aBlock, handle) self.catalog = DNACatalog(self.header, block, handle)
else: else:
handle.read(aBlock.Size) handle.seek(block.size, os.SEEK_CUR)
# handle.seek(aBlock.Size, os.SEEK_CUR) does not work with py3.0!
self.Blocks.append(aBlock) self.blocks.append(block)
self.code_index.setdefault(block.code, []).append(block)
if aBlock.Code not in self.CodeIndex: block = BlendFileBlock(handle, self)
self.CodeIndex[aBlock.Code] = [] self.is_modified = False
self.CodeIndex[aBlock.Code].append(aBlock) self.blocks.append(block)
aBlock = BlendFileBlock(handle, self) def find_blocks_from_code(self, code):
self.Modified = False
self.Blocks.append(aBlock)
def FindBlendFileBlocksWithCode(self, code):
if len(code) == 2: if len(code) == 2:
code = code code = code
if code not in self.CodeIndex: if code not in self.code_index:
return [] return []
return self.CodeIndex[code] return self.code_index[code]
def FindBlendFileBlockWithOffset(self, offset): def find_block_from_offset(self, offset):
for block in self.Blocks: for block in self.blocks:
if block.OldAddress == offset: if block.addr_old == offset:
return block return block
return None return None
def close(self): def close(self):
if not self.Modified: if not self.is_modified:
self.handle.close() self.handle.close()
else: else:
closeBlendFile(self) closeBlendFile(self)
######################################################
# BlendFileBlock
# File=BlendFile
# Header=FileBlockHeader
######################################################
class BlendFileBlock: class BlendFileBlock:
"""
Instance of a struct.
"""
__slots__ = (
# file handle
"file",
"code",
"size",
"addr_old",
"sdna_index",
"count",
"file_offset",
)
def __init__(self, handle, afile): def __init__(self, handle, afile):
self.File = afile self.file = afile
header = afile.Header header = afile.header
bytes = handle.read(afile.BlockHeaderStruct.size) data = handle.read(afile.block_header_struct.size)
# header size can be 8, 20, or 24 bytes long # header size can be 8, 20, or 24 bytes long
# 8: old blend files ENDB block (exception) # 8: old blend files ENDB block (exception)
# 20: normal headers 32 bit platform # 20: normal headers 32 bit platform
# 24: normal headers 64 bit platform # 24: normal headers 64 bit platform
if len(bytes) > 15: if len(data) > 15:
blockheader = afile.BlockHeaderStruct.unpack(bytes) blockheader = afile.block_header_struct.unpack(data)
self.Code = blockheader[0].decode().split("\0")[0] self.code = blockheader[0].decode().split("\0")[0]
if self.Code != "ENDB": if self.code != "ENDB":
self.Size = blockheader[1] self.size = blockheader[1]
self.OldAddress = blockheader[2] self.addr_old = blockheader[2]
self.SDNAIndex = blockheader[3] self.sdna_index = blockheader[3]
self.Count = blockheader[4] self.count = blockheader[4]
self.FileOffset = handle.tell() self.file_offset = handle.tell()
else: else:
self.Size = 0 self.size = 0
self.OldAddress = 0 self.addr_old = 0
self.SDNAIndex = 0 self.sdna_index = 0
self.Count = 0 self.count = 0
self.FileOffset = 0 self.file_offset = 0
else: else:
blockheader = OLDBLOCK.unpack(bytes) blockheader = OLDBLOCK.unpack(data)
self.Code = blockheader[0].decode().split("\0")[0] self.code = blockheader[0].decode().split("\0")[0]
self.Size = 0 self.size = 0
self.OldAddress = 0 self.addr_old = 0
self.SDNAIndex = 0 self.sdna_index = 0
self.Count = 0 self.count = 0
self.FileOffset = 0 self.file_offset = 0
def Get(self, path): def get(self, path):
dnaIndex = self.SDNAIndex dna_index = self.sdna_index
dnaStruct = self.File.Catalog.Structs[dnaIndex] dna_struct = self.file.catalog.structs[dna_index]
self.File.handle.seek(self.FileOffset, os.SEEK_SET) self.file.handle.seek(self.file_offset, os.SEEK_SET)
return dnaStruct.GetField(self.File.Header, self.File.handle, path) return dna_struct.field_get(self.file.header, self.file.handle, path)
def Set(self, path, value): def set(self, path, value):
dnaIndex = self.SDNAIndex dna_index = self.sdna_index
dnaStruct = self.File.Catalog.Structs[dnaIndex] dna_struct = self.file.catalog.structs[dna_index]
self.File.handle.seek(self.FileOffset, os.SEEK_SET) self.file.handle.seek(self.file_offset, os.SEEK_SET)
self.File.Modified = True self.file.is_modified = True
return dnaStruct.SetField(self.File.Header, self.File.handle, path, value) return dna_struct.field_set(self.file.header, self.file.handle, path, value)
###################################################### ######################################################
# BlendFileHeader allocates the first 12 bytes of a blend file # magic = str
# it contains information about the hardware architecture # pointer_size = int
# Magic = str # is_little_endian = bool
# PointerSize = int # version = int
# LittleEndianness = bool
# Version = int
###################################################### ######################################################
BLOCKHEADERSTRUCT = {} BLOCKHEADERSTRUCT = {}
BLOCKHEADERSTRUCT["<4"] = struct.Struct("<4sIIII") BLOCKHEADERSTRUCT["<4"] = struct.Struct("<4sIIII")
@@ -342,189 +360,222 @@ OLDBLOCK = struct.Struct("4sI")
class BlendFileHeader: class BlendFileHeader:
"""
BlendFileHeader allocates the first 12 bytes of a blend file
it contains information about the hardware architecture
"""
__slots__ = (
# str
"magic",
# int 4/8
"pointer_size",
# bool
"is_little_endian",
# int
"version",
# str, used to pass to 'struct'
"endian_str",
# int, used to index common types
"endian_index",
)
def __init__(self, handle): def __init__(self, handle):
log.debug("reading blend-file-header") log.debug("reading blend-file-header")
values = FILEHEADER.unpack(handle.read(FILEHEADER.size)) values = FILEHEADER.unpack(handle.read(FILEHEADER.size))
self.Magic = values[0] self.magic = values[0]
tPointerSize = values[1].decode() pointer_size_id = values[1].decode()
if tPointerSize == "-": if pointer_size_id == "-":
self.PointerSize = 8 self.pointer_size = 8
elif tPointerSize == "_": elif pointer_size_id == "_":
self.PointerSize = 4 self.pointer_size = 4
tEndianness = values[2].decode() else:
if tEndianness == "v": assert(0)
self.LittleEndianness = True endian_id = values[2].decode()
self.StructPre = "<" if endian_id == "v":
self.LittleEndiannessIndex = 0 self.is_little_endian = True
elif tEndianness == "V": self.endian_str = "<"
self.LittleEndianness = False self.endian_index = 0
self.LittleEndiannessIndex = 1 elif endian_id == "V":
self.StructPre = ">" self.is_little_endian = False
self.endian_index = 1
self.endian_str = ">"
else:
assert(0)
tVersion = values[3].decode() tVersion = values[3].decode()
self.Version = int(tVersion) self.version = int(tVersion)
def CreateBlockHeaderStruct(self): def create_block_header_struct(self):
return BLOCKHEADERSTRUCT[self.StructPre+str(self.PointerSize)] return BLOCKHEADERSTRUCT[self.endian_str + str(self.pointer_size)]
######################################################
# DNACatalog is a catalog of all information in the DNA1 file-block
#
# Header=None
# Names=None
# Types=None
# Structs=None
######################################################
class DNACatalog: class DNACatalog:
"""
DNACatalog is a catalog of all information in the DNA1 file-block
"""
__slots__ = (
"header",
"names",
"types",
"structs",
)
def __init__(self, header, block, handle): def __init__(self, header, block, handle):
log.debug("building DNA catalog") log.debug("building DNA catalog")
shortstruct = USHORT[header.LittleEndiannessIndex] shortstruct = USHORT[header.endian_index]
shortstruct2 = struct.Struct(str(USHORT[header.LittleEndiannessIndex].format.decode() + 'H')) shortstruct2 = struct.Struct(str(USHORT[header.endian_index].format.decode() + 'H'))
intstruct = UINT[header.LittleEndiannessIndex] intstruct = UINT[header.endian_index]
data = handle.read(block.Size) data = handle.read(block.size)
self.Names = [] self.names = []
self.Types = [] self.types = []
self.Structs = [] self.structs = []
offset = 8 offset = 8
numberOfNames = intstruct.unpack_from(data, offset)[0] names_len = intstruct.unpack_from(data, offset)[0]
offset += 4 offset += 4
log.debug("building #"+str(numberOfNames)+" names") log.debug("building #%d names" % names_len)
for i in range(numberOfNames): for i in range(names_len):
tName = ReadString0(data, offset) tName = ReadString0(data, offset)
offset = offset + len(tName) + 1 offset = offset + len(tName) + 1
self.Names.append(DNAName(tName)) self.names.append(DNAName(tName))
del names_len
offset = Allign(offset) offset = align(offset, 4)
offset += 4 offset += 4
numberOfTypes = intstruct.unpack_from(data, offset)[0] types_len = intstruct.unpack_from(data, offset)[0]
offset += 4 offset += 4
log.debug("building #"+str(numberOfTypes)+" types") log.debug("building #"+str(types_len)+" types")
for i in range(numberOfTypes): for i in range(types_len):
tType = ReadString0(data, offset) tType = ReadString0(data, offset)
self.Types.append([tType, 0, None]) self.types.append([tType, 0, None])
offset += len(tType) + 1 offset += len(tType) + 1
offset = Allign(offset) offset = align(offset, 4)
offset += 4 offset += 4
log.debug("building #"+str(numberOfTypes)+" type-lengths") log.debug("building #%d type-lengths" % types_len)
for i in range(numberOfTypes): for i in range(types_len):
tLen = shortstruct.unpack_from(data, offset)[0] tLen = shortstruct.unpack_from(data, offset)[0]
offset = offset + 2 offset = offset + 2
self.Types[i][1] = tLen self.types[i][1] = tLen
del types_len
offset = Allign(offset) offset = align(offset, 4)
offset += 4 offset += 4
numberOfStructures = intstruct.unpack_from(data, offset)[0] structs_len = intstruct.unpack_from(data, offset)[0]
offset += 4 offset += 4
log.debug("building #"+str(numberOfStructures)+" structures") log.debug("building #%d structures" % structs_len)
for structureIndex in range(numberOfStructures): for struct_index in range(structs_len):
d = shortstruct2.unpack_from(data, offset) d = shortstruct2.unpack_from(data, offset)
tType = d[0] struct_type_index = d[0]
offset += 4 offset += 4
Type = self.Types[tType] dna_type = self.types[struct_type_index]
structure = DNAStructure(Type) structure = DNAStructure(dna_type)
self.Structs.append(structure) self.structs.append(structure)
numberOfFields = d[1] fields_len = d[1]
for fieldIndex in range(numberOfFields): for field_index in range(fields_len):
d2 = shortstruct2.unpack_from(data, offset) d2 = shortstruct2.unpack_from(data, offset)
fTypeIndex = d2[0] field_type_index = d2[0]
fNameIndex = d2[1] field_name_index = d2[1]
offset += 4 offset += 4
fType = self.Types[fTypeIndex] fType = self.types[field_type_index]
fName = self.Names[fNameIndex] fName = self.names[field_name_index]
if fName.IsPointer or fName.IsMethodPointer: if fName.is_pointer or fName.is_method_pointer:
fsize = header.PointerSize*fName.ArraySize fsize = header.pointer_size * fName.array_size
else: else:
fsize = fType[1]*fName.ArraySize fsize = fType[1] * fName.array_size
structure.Fields.append([fType, fName, fsize]) structure.fields.append([fType, fName, fsize])
######################################################
# DNAName is a C-type name stored in the DNA
# Name=str
######################################################
class DNAName: class DNAName:
"""
DNAName is a C-type name stored in the DNA
"""
__slots__ = (
"name",
"name_short",
"is_pointer",
"is_method_pointer",
"array_size",
"_SN", # TODO, investigate why this is needed!
)
def __init__(self, aName): def __init__(self, aName):
self.Name = aName self.name = aName
self.ShortName = self.DetermineShortName() self.name_short = self.calc_name_short()
self.IsPointer = self.DetermineIsPointer() self.is_pointer = self.calc_is_pointer()
self.IsMethodPointer = self.DetermineIsMethodPointer() self.is_method_pointer = self.calc_is_method_pointer()
self.ArraySize = self.DetermineArraySize() self.array_size = self.calc_array_size()
def AsReference(self, parent): def as_reference(self, parent):
if parent is None: if parent is None:
Result = "" result = ""
else: else:
Result = parent+"." result = parent + "."
Result = Result + self.ShortName result = result + self.name_short
return Result return result
def DetermineShortName(self): def calc_name_short(self):
Result = self.Name result = self.name
Result = Result.replace("*", "") result = result.replace("*", "")
Result = Result.replace("(", "") result = result.replace("(", "")
Result = Result.replace(")", "") result = result.replace(")", "")
Index = Result.find("[") index = result.find("[")
if Index != -1: if index != -1:
Result = Result[0:Index] result = result[:index]
self._SN = Result self._SN = result
return Result return result
def DetermineIsPointer(self): def calc_is_pointer(self):
return self.Name.find("*") > -1 return self.name.find("*") > -1
def DetermineIsMethodPointer(self): def calc_is_method_pointer(self):
return self.Name.find("(*") > -1 return self.name.find("(*") > -1
def DetermineArraySize(self): def calc_array_size(self):
Result = 1 result = 1
Temp = self.Name temp = self.name
Index = Temp.find("[") index = temp.find("[")
while Index != -1: while index != -1:
Index2 = Temp.find("]") index_2 = temp.find("]")
Result *= int(Temp[Index + 1:Index2]) result *= int(temp[index + 1:index_2])
Temp = Temp[Index2 + 1:] temp = temp[index_2 + 1:]
Index = Temp.find("[") index = temp.find("[")
return Result return result
######################################################
# DNAType is a C-type structure stored in the DNA
#
# Type=DNAType
# Fields=[DNAField]
######################################################
class DNAStructure: class DNAStructure:
"""
DNAType is a C-type structure stored in the DNA
"""
__slots__ = (
"dna_type",
"fields",
)
def __init__(self, aType): def __init__(self, aType):
self.Type = aType self.dna_type = aType
aType[2] = self aType[2] = self
self.Fields = [] self.fields = []
def GetField(self, header, handle, path): def field_get(self, header, handle, path):
splitted = path.partition(".") splitted = path.partition(".")
name = splitted[0] name = splitted[0]
rest = splitted[2] rest = splitted[2]
offset = 0 offset = 0
for field in self.Fields: for field in self.fields:
fname = field[1] fname = field[1]
if fname.ShortName == name: if fname.name_short == name:
handle.seek(offset, os.SEEK_CUR) handle.seek(offset, os.SEEK_CUR)
ftype = field[0] ftype = field[0]
if len(rest) == 0: if len(rest) == 0:
if fname.IsPointer: if fname.is_pointer:
return ReadPointer(handle, header) return ReadPointer(handle, header)
elif ftype[0] == "int": elif ftype[0] == "int":
return ReadInt(handle, header) return ReadInt(handle, header)
@@ -533,52 +584,53 @@ class DNAStructure:
elif ftype[0] == "float": elif ftype[0] == "float":
return ReadFloat(handle, header) return ReadFloat(handle, header)
elif ftype[0] == "char": elif ftype[0] == "char":
return ReadString(handle, fname.ArraySize) return ReadString(handle, fname.array_size)
else: else:
return ftype[2].GetField(header, handle, rest) return ftype[2].field_get(header, handle, rest)
else: else:
offset += field[2] offset += field[2]
return None return None
def SetField(self, header, handle, path, value): def field_set(self, header, handle, path, value):
splitted = path.partition(".") splitted = path.partition(".")
name = splitted[0] name = splitted[0]
rest = splitted[2] rest = splitted[2]
offset = 0 offset = 0
for field in self.Fields: for field in self.fields:
fname = field[1] fname = field[1]
if fname.ShortName == name: if fname.name_short == name:
handle.seek(offset, os.SEEK_CUR) handle.seek(offset, os.SEEK_CUR)
ftype = field[0] ftype = field[0]
if len(rest) == 0: if len(rest) == 0:
if ftype[0] == "char": if ftype[0] == "char":
return WriteString(handle, value, fname.ArraySize) return WriteString(handle, value, fname.array_size)
else: else:
return ftype[2].SetField(header, handle, rest, value) return ftype[2].field_set(header, handle, rest, value)
else: else:
offset += field[2] offset += field[2]
return None return None
######################################################
# DNAField is a coupled DNAType and DNAName
# Type=DNAType
# Name=DNAName
######################################################
class DNAField: class DNAField:
"""
DNAField is a coupled DNAType and DNAName
"""
__slots__ = (
"name",
"dna_type",
)
def __init__(self, dna_type, name):
self.dna_type = dna_type
self.name = name
def __init__(self, aType, aName): def size(self, header):
self.Type = aType if self.name.is_pointer or self.name.is_method_pointer:
self.Name = aName return header.pointer_size * self.name.array_size
def Size(self, header):
if self.Name.IsPointer or self.Name.IsMethodPointer:
return header.PointerSize*self.Name.ArraySize
else: else:
return self.Type.Size*self.Name.ArraySize return self.dna_type.size * self.name.array_size
# determine the relative production location of a blender path.basename # determine the relative production location of a blender path.basename