initial blendfile
This commit is contained in:
574
blendfile.py
Normal file
574
blendfile.py
Normal file
@@ -0,0 +1,574 @@
|
||||
# ***** BEGIN GPL LICENSE BLOCK *****
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU General Public License
|
||||
# as published by the Free Software Foundation; either version 2
|
||||
# of the License, or (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software Foundation,
|
||||
# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
#
|
||||
# ***** END GPL LICENCE BLOCK *****
|
||||
#
|
||||
# (c) 2009, At Mind B.V. - Jeroen Bakker
|
||||
|
||||
# 06-10-2009:
|
||||
# jbakker - adding support for python 3.0
|
||||
# 26-10-2009:
|
||||
# jbakker - adding caching of the SDNA records.
|
||||
# jbakker - adding caching for file block lookup
|
||||
# jbakker - increased performance for readstring
|
||||
# 27-10-2009:
|
||||
# jbakker - remove FileBlockHeader class (reducing memory print,
|
||||
# increasing performance)
|
||||
# 28-10-2009:
|
||||
# jbakker - reduce far-calls by joining setfield with encode and
|
||||
# getfield with decode
|
||||
# 02-11-2009:
|
||||
# jbakker - python 3 compatibility added
|
||||
|
||||
|
||||
######################################################
|
||||
# Importing modules
|
||||
######################################################
|
||||
import os
|
||||
import struct
|
||||
import logging
|
||||
import gzip
|
||||
import tempfile
|
||||
import sys
|
||||
|
||||
log = logging.getLogger("blendfile")
|
||||
FILE_BUFFER_SIZE=1024*1024
|
||||
######################################################
|
||||
# module global routines
|
||||
######################################################
|
||||
# read routines
|
||||
# open a filename
|
||||
# determine if the file is compressed
|
||||
# and returns a handle
|
||||
def openBlendFile(filename, access="rb"):
|
||||
"""Opens a blend file for reading or writing pending on the access
|
||||
supports 2 kind of blend files. Uncompressed and compressed.
|
||||
Known issue: does not support packaged blend files
|
||||
"""
|
||||
handle = open(filename, access)
|
||||
magic = ReadString(handle, 7)
|
||||
if magic == "BLENDER":
|
||||
log.debug("normal blendfile detected")
|
||||
handle.seek(0, os.SEEK_SET)
|
||||
res = BlendFile(handle)
|
||||
res.compressed=False
|
||||
res.originalfilename=filename
|
||||
return res
|
||||
else:
|
||||
log.debug("gzip blendfile detected?")
|
||||
handle.close()
|
||||
log.debug("decompressing started")
|
||||
fs = gzip.open(filename, "rb")
|
||||
handle = tempfile.TemporaryFile()
|
||||
data = fs.read(FILE_BUFFER_SIZE)
|
||||
while data:
|
||||
handle.write(data)
|
||||
data = fs.read(FILE_BUFFER_SIZE)
|
||||
log.debug("decompressing finished")
|
||||
fs.close()
|
||||
log.debug("resetting decompressed file")
|
||||
handle.seek(os.SEEK_SET, 0)
|
||||
res = BlendFile(handle)
|
||||
res.compressed=True
|
||||
res.originalfilename=filename
|
||||
return res
|
||||
|
||||
def closeBlendFile(afile):
|
||||
"""close the blend file
|
||||
writes the blend file to disk if changes has happened"""
|
||||
handle = afile.handle
|
||||
if afile.compressed:
|
||||
log.debug("close compressed blend file")
|
||||
handle.seek(os.SEEK_SET, 0)
|
||||
log.debug("compressing started")
|
||||
fs = gzip.open(afile.originalfilename, "wb")
|
||||
data = handle.read(FILE_BUFFER_SIZE)
|
||||
while data:
|
||||
fs.write(data)
|
||||
data = handle.read(FILE_BUFFER_SIZE)
|
||||
fs.close()
|
||||
log.debug("compressing finished")
|
||||
|
||||
handle.close()
|
||||
|
||||
######################################################
|
||||
# Write a string to the file.
|
||||
######################################################
|
||||
def WriteString(handle, astring, fieldlen):
|
||||
stringw=""
|
||||
if len(astring) >= fieldlen:
|
||||
stringw=astring[0:fieldlen]
|
||||
else:
|
||||
stringw=astring+'\0'
|
||||
handle.write(stringw.encode())
|
||||
|
||||
######################################################
|
||||
# ReadString reads a String of given length from a file handle
|
||||
######################################################
|
||||
STRING=[]
|
||||
for i in range(0, 2048):
|
||||
STRING.append(struct.Struct(str(i)+"s"))
|
||||
|
||||
def ReadString(handle, length):
|
||||
st = STRING[length]
|
||||
return st.unpack(handle.read(st.size))[0].decode("iso-8859-1")
|
||||
|
||||
######################################################
|
||||
# ReadString0 reads a zero terminating String from a file handle
|
||||
######################################################
|
||||
ZEROTESTER = 0
|
||||
if sys.version_info < (3, 0):
|
||||
ZEROTESTER="\0"
|
||||
|
||||
def ReadString0(data, offset):
|
||||
add = 0
|
||||
|
||||
while data[offset+add]!=ZEROTESTER:
|
||||
add+=1
|
||||
if add < len(STRING):
|
||||
st = STRING[add]
|
||||
S=st.unpack_from(data, offset)[0].decode("iso-8859-1")
|
||||
else:
|
||||
S=struct.Struct(str(add)+"s").unpack_from(data, offset)[0].decode("iso-8859-1")
|
||||
return S
|
||||
|
||||
######################################################
|
||||
# ReadUShort reads an unsigned short from a file handle
|
||||
######################################################
|
||||
USHORT=[struct.Struct("<H"), struct.Struct(">H")]
|
||||
def ReadUShort(handle, fileheader):
|
||||
us = USHORT[fileheader.LittleEndiannessIndex]
|
||||
return us.unpack(handle.read(us.size))[0]
|
||||
|
||||
######################################################
|
||||
# ReadUInt reads an unsigned integer from a file handle
|
||||
######################################################
|
||||
UINT=[struct.Struct("<I"), struct.Struct(">I")]
|
||||
def ReadUInt(handle, fileheader):
|
||||
us = UINT[fileheader.LittleEndiannessIndex]
|
||||
return us.unpack(handle.read(us.size))[0]
|
||||
|
||||
def ReadInt(handle, fileheader):
|
||||
return struct.unpack(fileheader.StructPre+"i", handle.read(4))[0]
|
||||
def ReadFloat(handle, fileheader):
|
||||
return struct.unpack(fileheader.StructPre+"f", handle.read(4))[0]
|
||||
|
||||
SSHORT=[struct.Struct("<h"), struct.Struct(">h")]
|
||||
def ReadShort(handle, fileheader):
|
||||
us = SSHORT[fileheader.LittleEndiannessIndex]
|
||||
return us.unpack(handle.read(us.size))[0]
|
||||
|
||||
ULONG=[struct.Struct("<Q"), struct.Struct(">Q")]
|
||||
def ReadULong(handle, fileheader):
|
||||
us = ULONG[fileheader.LittleEndiannessIndex]
|
||||
return us.unpack(handle.read(us.size))[0]
|
||||
|
||||
|
||||
######################################################
|
||||
# ReadPointer reads an pointerfrom a file handle
|
||||
# the pointersize is given by the header (BlendFileHeader)
|
||||
######################################################
|
||||
def ReadPointer(handle, header):
|
||||
if header.PointerSize == 4:
|
||||
us = UINT[header.LittleEndiannessIndex]
|
||||
return us.unpack(handle.read(us.size))[0]
|
||||
if header.PointerSize == 8:
|
||||
us = ULONG[header.LittleEndiannessIndex]
|
||||
return us.unpack(handle.read(us.size))[0]
|
||||
|
||||
######################################################
|
||||
# Allign alligns the filehandle on 4 bytes
|
||||
######################################################
|
||||
def Allign(offset):
|
||||
trim = offset % 4
|
||||
if trim != 0:
|
||||
offset = offset + (4-trim)
|
||||
return offset
|
||||
|
||||
######################################################
|
||||
# module classes
|
||||
######################################################
|
||||
|
||||
######################################################
|
||||
# BlendFile
|
||||
# - Header (BlendFileHeader)
|
||||
# - Blocks (FileBlockHeader)
|
||||
# - Catalog (DNACatalog)
|
||||
######################################################
|
||||
class BlendFile:
|
||||
|
||||
def __init__(self, handle):
|
||||
log.debug("initializing reading blend-file")
|
||||
self.handle=handle
|
||||
self.Header = BlendFileHeader(handle)
|
||||
self.BlockHeaderStruct = self.Header.CreateBlockHeaderStruct()
|
||||
self.Blocks = []
|
||||
self.CodeIndex = {}
|
||||
|
||||
aBlock = BlendFileBlock(handle, self)
|
||||
while aBlock.Code != "ENDB":
|
||||
if aBlock.Code == "DNA1":
|
||||
self.Catalog = DNACatalog(self.Header, aBlock, handle)
|
||||
else:
|
||||
handle.read(aBlock.Size)
|
||||
# handle.seek(aBlock.Size, os.SEEK_CUR) does not work with py3.0!
|
||||
|
||||
self.Blocks.append(aBlock)
|
||||
|
||||
if aBlock.Code not in self.CodeIndex:
|
||||
self.CodeIndex[aBlock.Code] = []
|
||||
self.CodeIndex[aBlock.Code].append(aBlock)
|
||||
|
||||
aBlock = BlendFileBlock(handle, self)
|
||||
self.Modified=False
|
||||
self.Blocks.append(aBlock)
|
||||
|
||||
def FindBlendFileBlocksWithCode(self, code):
|
||||
if len(code) == 2:
|
||||
code = code
|
||||
if code not in self.CodeIndex:
|
||||
return []
|
||||
return self.CodeIndex[code]
|
||||
|
||||
def FindBlendFileBlockWithOffset(self, offset):
|
||||
for block in self.Blocks:
|
||||
if block.OldAddress == offset:
|
||||
return block;
|
||||
return None;
|
||||
|
||||
def close(self):
|
||||
if not self.Modified:
|
||||
self.handle.close()
|
||||
else:
|
||||
closeBlendFile(self)
|
||||
|
||||
######################################################
|
||||
# BlendFileBlock
|
||||
# File=BlendFile
|
||||
# Header=FileBlockHeader
|
||||
######################################################
|
||||
class BlendFileBlock:
|
||||
def __init__(self, handle, afile):
|
||||
self.File = afile
|
||||
header = afile.Header
|
||||
|
||||
bytes = handle.read(afile.BlockHeaderStruct.size)
|
||||
#header size can be 8, 20, or 24 bytes long
|
||||
#8: old blend files ENDB block (exception)
|
||||
#20: normal headers 32 bit platform
|
||||
#24: normal headers 64 bit platform
|
||||
if len(bytes)>15:
|
||||
|
||||
blockheader = afile.BlockHeaderStruct.unpack(bytes)
|
||||
self.Code = blockheader[0].decode().split("\0")[0]
|
||||
if self.Code!="ENDB":
|
||||
self.Size = blockheader[1]
|
||||
self.OldAddress = blockheader[2]
|
||||
self.SDNAIndex = blockheader[3]
|
||||
self.Count = blockheader[4]
|
||||
self.FileOffset = handle.tell()
|
||||
else:
|
||||
self.Size = 0
|
||||
self.OldAddress = 0
|
||||
self.SDNAIndex = 0
|
||||
self.Count = 0
|
||||
self.FileOffset = 0
|
||||
else:
|
||||
blockheader = OLDBLOCK.unpack(bytes)
|
||||
self.Code = blockheader[0].decode().split("\0")[0]
|
||||
self.Size = 0
|
||||
self.OldAddress = 0
|
||||
self.SDNAIndex = 0
|
||||
self.Count = 0
|
||||
self.FileOffset = 0
|
||||
|
||||
def Get(self, path):
|
||||
dnaIndex = self.SDNAIndex
|
||||
dnaStruct = self.File.Catalog.Structs[dnaIndex]
|
||||
self.File.handle.seek(self.FileOffset, os.SEEK_SET)
|
||||
return dnaStruct.GetField(self.File.Header, self.File.handle, path)
|
||||
|
||||
def Set(self, path, value):
|
||||
dnaIndex = self.SDNAIndex
|
||||
dnaStruct = self.File.Catalog.Structs[dnaIndex]
|
||||
self.File.handle.seek(self.FileOffset, os.SEEK_SET)
|
||||
self.File.Modified=True
|
||||
return dnaStruct.SetField(self.File.Header, self.File.handle, path, value)
|
||||
|
||||
######################################################
|
||||
# BlendFileHeader allocates the first 12 bytes of a blend file
|
||||
# it contains information about the hardware architecture
|
||||
# Magic = str
|
||||
# PointerSize = int
|
||||
# LittleEndianness = bool
|
||||
# Version = int
|
||||
######################################################
|
||||
BLOCKHEADERSTRUCT={}
|
||||
BLOCKHEADERSTRUCT["<4"] = struct.Struct("<4sIIII")
|
||||
BLOCKHEADERSTRUCT[">4"] = struct.Struct(">4sIIII")
|
||||
BLOCKHEADERSTRUCT["<8"] = struct.Struct("<4sIQII")
|
||||
BLOCKHEADERSTRUCT[">8"] = struct.Struct(">4sIQII")
|
||||
FILEHEADER = struct.Struct("7s1s1s3s")
|
||||
OLDBLOCK=struct.Struct("4sI")
|
||||
class BlendFileHeader:
|
||||
def __init__(self, handle):
|
||||
log.debug("reading blend-file-header")
|
||||
values = FILEHEADER.unpack(handle.read(FILEHEADER.size))
|
||||
self.Magic = values[0]
|
||||
tPointerSize = values[1].decode()
|
||||
if tPointerSize=="-":
|
||||
self.PointerSize=8
|
||||
elif tPointerSize=="_":
|
||||
self.PointerSize=4
|
||||
tEndianness = values[2].decode()
|
||||
if tEndianness=="v":
|
||||
self.LittleEndianness=True
|
||||
self.StructPre="<"
|
||||
self.LittleEndiannessIndex=0
|
||||
elif tEndianness=="V":
|
||||
self.LittleEndianness=False
|
||||
self.LittleEndiannessIndex=1
|
||||
self.StructPre=">"
|
||||
|
||||
tVersion = values[3].decode()
|
||||
self.Version = int(tVersion)
|
||||
|
||||
def CreateBlockHeaderStruct(self):
|
||||
return BLOCKHEADERSTRUCT[self.StructPre+str(self.PointerSize)]
|
||||
|
||||
######################################################
|
||||
# DNACatalog is a catalog of all information in the DNA1 file-block
|
||||
#
|
||||
# Header=None
|
||||
# Names=None
|
||||
# Types=None
|
||||
# Structs=None
|
||||
######################################################
|
||||
class DNACatalog:
|
||||
|
||||
def __init__(self, header, block, handle):
|
||||
log.debug("building DNA catalog")
|
||||
shortstruct = USHORT[header.LittleEndiannessIndex]
|
||||
shortstruct2 = struct.Struct(str(USHORT[header.LittleEndiannessIndex].format.decode()+'H'))
|
||||
intstruct = UINT[header.LittleEndiannessIndex]
|
||||
data = handle.read(block.Size)
|
||||
self.Names=[]
|
||||
self.Types=[]
|
||||
self.Structs=[]
|
||||
|
||||
offset = 8;
|
||||
numberOfNames = intstruct.unpack_from(data, offset)[0]
|
||||
offset += 4
|
||||
|
||||
log.debug("building #"+str(numberOfNames)+" names")
|
||||
for i in range(numberOfNames):
|
||||
tName = ReadString0(data, offset)
|
||||
offset = offset + len(tName) + 1
|
||||
self.Names.append(DNAName(tName))
|
||||
|
||||
offset = Allign(offset)
|
||||
offset += 4
|
||||
numberOfTypes = intstruct.unpack_from(data, offset)[0]
|
||||
offset += 4
|
||||
log.debug("building #"+str(numberOfTypes)+" types")
|
||||
for i in range(numberOfTypes):
|
||||
tType = ReadString0(data, offset)
|
||||
self.Types.append([tType, 0, None])
|
||||
offset += len(tType)+1
|
||||
|
||||
offset = Allign(offset)
|
||||
offset += 4
|
||||
log.debug("building #"+str(numberOfTypes)+" type-lengths")
|
||||
for i in range(numberOfTypes):
|
||||
tLen = shortstruct.unpack_from(data, offset)[0]
|
||||
offset = offset + 2
|
||||
self.Types[i][1] = tLen
|
||||
|
||||
offset = Allign(offset)
|
||||
offset += 4
|
||||
|
||||
numberOfStructures = intstruct.unpack_from(data, offset)[0]
|
||||
offset += 4
|
||||
log.debug("building #"+str(numberOfStructures)+" structures")
|
||||
for structureIndex in range(numberOfStructures):
|
||||
d = shortstruct2.unpack_from(data, offset)
|
||||
tType = d[0]
|
||||
offset += 4
|
||||
Type = self.Types[tType]
|
||||
structure = DNAStructure(Type)
|
||||
self.Structs.append(structure)
|
||||
|
||||
numberOfFields = d[1]
|
||||
|
||||
for fieldIndex in range(numberOfFields):
|
||||
d2 = shortstruct2.unpack_from(data, offset)
|
||||
fTypeIndex = d2[0]
|
||||
fNameIndex = d2[1]
|
||||
offset += 4
|
||||
fType = self.Types[fTypeIndex]
|
||||
fName = self.Names[fNameIndex]
|
||||
if fName.IsPointer or fName.IsMethodPointer:
|
||||
fsize = header.PointerSize*fName.ArraySize
|
||||
else:
|
||||
fsize = fType[1]*fName.ArraySize
|
||||
structure.Fields.append([fType, fName, fsize])
|
||||
|
||||
######################################################
|
||||
# DNAName is a C-type name stored in the DNA
|
||||
# Name=str
|
||||
######################################################
|
||||
class DNAName:
|
||||
|
||||
def __init__(self, aName):
|
||||
self.Name = aName
|
||||
self.ShortName = self.DetermineShortName()
|
||||
self.IsPointer = self.DetermineIsPointer()
|
||||
self.IsMethodPointer = self.DetermineIsMethodPointer()
|
||||
self.ArraySize = self.DetermineArraySize()
|
||||
|
||||
def AsReference(self, parent):
|
||||
if parent == None:
|
||||
Result = ""
|
||||
else:
|
||||
Result = parent+"."
|
||||
|
||||
Result = Result + self.ShortName
|
||||
return Result
|
||||
|
||||
def DetermineShortName(self):
|
||||
Result = self.Name;
|
||||
Result = Result.replace("*", "")
|
||||
Result = Result.replace("(", "")
|
||||
Result = Result.replace(")", "")
|
||||
Index = Result.find("[")
|
||||
if Index != -1:
|
||||
Result = Result[0:Index]
|
||||
self._SN = Result
|
||||
return Result
|
||||
|
||||
def DetermineIsPointer(self):
|
||||
return self.Name.find("*")>-1
|
||||
|
||||
def DetermineIsMethodPointer(self):
|
||||
return self.Name.find("(*")>-1
|
||||
|
||||
def DetermineArraySize(self):
|
||||
Result = 1
|
||||
Temp = self.Name
|
||||
Index = Temp.find("[")
|
||||
|
||||
while Index != -1:
|
||||
Index2 = Temp.find("]")
|
||||
Result*=int(Temp[Index+1:Index2])
|
||||
Temp = Temp[Index2+1:]
|
||||
Index = Temp.find("[")
|
||||
|
||||
return Result
|
||||
|
||||
######################################################
|
||||
# DNAType is a C-type structure stored in the DNA
|
||||
#
|
||||
# Type=DNAType
|
||||
# Fields=[DNAField]
|
||||
######################################################
|
||||
class DNAStructure:
|
||||
|
||||
def __init__(self, aType):
|
||||
self.Type = aType
|
||||
aType[2] = self
|
||||
self.Fields=[]
|
||||
|
||||
def GetField(self, header, handle, path):
|
||||
splitted = path.partition(".")
|
||||
name = splitted[0]
|
||||
rest = splitted[2]
|
||||
offset = 0;
|
||||
for field in self.Fields:
|
||||
fname = field[1]
|
||||
if fname.ShortName == name:
|
||||
handle.seek(offset, os.SEEK_CUR)
|
||||
ftype = field[0]
|
||||
if len(rest) == 0:
|
||||
|
||||
if fname.IsPointer:
|
||||
return ReadPointer(handle, header)
|
||||
elif ftype[0]=="int":
|
||||
return ReadInt(handle, header)
|
||||
elif ftype[0]=="short":
|
||||
return ReadShort(handle, header)
|
||||
elif ftype[0]=="float":
|
||||
return ReadFloat(handle, header)
|
||||
elif ftype[0]=="char":
|
||||
return ReadString(handle, fname.ArraySize)
|
||||
else:
|
||||
return ftype[2].GetField(header, handle, rest)
|
||||
|
||||
else:
|
||||
offset += field[2]
|
||||
|
||||
return None
|
||||
|
||||
def SetField(self, header, handle, path, value):
|
||||
splitted = path.partition(".")
|
||||
name = splitted[0]
|
||||
rest = splitted[2]
|
||||
offset = 0;
|
||||
for field in self.Fields:
|
||||
fname = field[1]
|
||||
if fname.ShortName == name:
|
||||
handle.seek(offset, os.SEEK_CUR)
|
||||
ftype = field[0]
|
||||
if len(rest)==0:
|
||||
if ftype[0]=="char":
|
||||
return WriteString(handle, value, fname.ArraySize)
|
||||
else:
|
||||
return ftype[2].SetField(header, handle, rest, value)
|
||||
else:
|
||||
offset += field[2]
|
||||
|
||||
return None
|
||||
|
||||
|
||||
|
||||
######################################################
|
||||
# DNAField is a coupled DNAType and DNAName
|
||||
# Type=DNAType
|
||||
# Name=DNAName
|
||||
######################################################
|
||||
class DNAField:
|
||||
|
||||
def __init__(self, aType, aName):
|
||||
self.Type = aType
|
||||
self.Name = aName
|
||||
|
||||
def Size(self, header):
|
||||
if self.Name.IsPointer or self.Name.IsMethodPointer:
|
||||
return header.PointerSize*self.Name.ArraySize
|
||||
else:
|
||||
return self.Type.Size*self.Name.ArraySize
|
||||
|
||||
#determine the relative production location of a blender path.basename
|
||||
def blendPath2AbsolutePath(productionFile, blenderPath):
|
||||
productionFileDir=os.path.dirname(productionFile)
|
||||
if blenderPath.startswith("//"):
|
||||
relpath=blenderPath[2:]
|
||||
abspath = os.path.join(productionFileDir, relpath)
|
||||
return abspath
|
||||
|
||||
|
||||
return blenderPath
|
||||
|
||||
|
||||
Reference in New Issue
Block a user