public override void LoadData(BinaryReaderEx reader)
{
base.LoadData(reader);
this.String = reader.ReadNullTerminatedString(Encoding.ASCII);
this.DisplayName = "STR";
}
public override void LoadSection(BinaryReaderEx reader)
{
base.LoadSection(reader);
this.MotionInfoBlocks = new List<MotionInfoBlock>();
int numMIBs = (this.SectionLength - 4) / bytesPerBlock;
for (var i = 0; i < numMIBs; i++)
{
var mib = new MotionInfoBlock();
mib.MotionName = reader.ReadFixedLengthString(16).Trim();
mib.FrameCount = reader.ReadSByte();
mib.CurveCoefficient = reader.ReadSByte();
mib.InitialVelocity = reader.ReadSByte();
mib.RollingFrameEnd = reader.ReadSByte();
mib.CaseOfRightFootEnd = reader.ReadSByte();
mib.CaseOfLeftFootEnd = reader.ReadSByte();
mib.Unk1 = reader.ReadSByte();
mib.Unk2 = reader.ReadSByte();
mib.SubstituteMotionName = reader.ReadFixedLengthString(16).Trim();
mib.SubstituteMotionStartFrame = reader.ReadSByte();
mib.IdleFramesToBlend = reader.ReadSByte();
mib.FrameStartingRotationStop = reader.ReadSByte();
mib.EndsOnWhichFoot = reader.ReadSByte();
mib.Unknown = reader.ReadInt16();
this.MotionInfoBlocks.Add(mib);
}
}
private void ReadHeader(BinaryReaderEx reader)
{
this.Header = new DatDigger.Sound.AdpcmWaveFormat();
this.Header.FormatTag = (SlimDX.Multimedia.WaveFormatTag)reader.ReadInt16();
this.Header.Channels = reader.ReadInt16();
this.Header.SamplesPerSecond = reader.ReadInt32();
this.Header.AverageBytesPerSecond = reader.ReadInt32();
this.Header.BlockAlignment = reader.ReadInt16();
this.Header.BitsPerSample = reader.ReadInt16();
short cbSize = reader.ReadInt16();
if (cbSize != 0x20)
{
throw new InvalidOperationException(String.Format("Unexpected value for ADPCMWAVEFORMAT cbSize 0x{0}. Expected 0x20", cbSize));
}
this.Header.SamplesPerBlock = reader.ReadInt16();
this.Header.NumCoef = reader.ReadInt16();
this.Header.Coefficients = new List<DatDigger.Sound.AdpcmCoefficient>(this.Header.NumCoef);
for (var i = 0; i < this.Header.NumCoef; i++)
{
DatDigger.Sound.AdpcmCoefficient coef = new DatDigger.Sound.AdpcmCoefficient();
coef.A = reader.ReadInt16();
coef.B = reader.ReadInt16();
this.Header.Coefficients.Add(coef);
}
}
public override void LoadSection(BinaryReaderEx reader)
{
base.LoadSection(reader);
this.NumElements = reader.ReadInt32();
reader.BaseStream.Seek(12, System.IO.SeekOrigin.Current); // Skip 12 bytes
this.ElementOffsets = new List<ElementOffsetData>();
for (var i = 0; i < this.NumElements; i++)
{
var thing = new ElementOffsetData();
thing.BoneNameOffset = reader.ReadInt32();
thing.NameOffset = reader.ReadInt32();
thing.OffsetX = reader.ReadSingle();
thing.OffsetY = reader.ReadSingle();
thing.OffsetZ = reader.ReadSingle();
thing.Unused1 = reader.ReadInt32();
thing.Unused2 = reader.ReadInt32();
thing.Unused3 = reader.ReadInt32();
this.ElementOffsets.Add(thing);
}
foreach (var el in this.ElementOffsets)
{
reader.BaseStream.Position = this.SectionStart + el.BoneNameOffset;
el.BoneName = reader.ReadNullTerminatedString();
reader.BaseStream.Position = this.SectionStart + el.NameOffset;
el.Name = reader.ReadNullTerminatedString();
}
}
public override void LoadSection(BinaryReaderEx reader)
{
base.LoadSection(reader);
this.LoadHeader(reader);
this.LoadStringTable(reader);
this.LoadBones(reader);
}
public override void LoadSection(BinaryReaderEx reader)
{
base.LoadSection(reader);
this.baseChunk = ChunkLoader.LoadChunk(SectionType.wrb, reader, this);
this.Children = new List<INavigable>();
this.Children.Add(baseChunk);
}
public void LoadFile(BinaryReaderEx reader)
{
reader.BaseStream.Seek(8, System.IO.SeekOrigin.Begin);
this.ReadEncodedData(reader);
this.DecodeData();
this.Contents = Encoding.UTF8.GetString(this.decodedData);
}
public void LoadData(BinaryReaderEx reader)
{
reader.ReadInt32(); // Remove PWIB bytes
this.FileSize = reader.ReadUInt32(Endianness.BigEndian);
this.Unknown = reader.ReadInt32(Endianness.BigEndian);
this.DataOffset = reader.ReadUInt32(Endianness.BigEndian);
this.LoadSection(reader);
}
public void LoadData(BinaryReaderEx reader)
{
long pos = reader.BaseStream.Position;
BuildFormat();
reader.BaseStream.Position = pos + this.WaveHeader.FormatHeaderLength;
this.WaveData = reader.ReadBytes(this.WaveHeader.DataLength);
}
public override void LoadSection(BinaryReaderEx reader)
{
base.LoadSection(reader);
this.LoadHeader(reader);
this.LoadResourceTypes(reader);
this.LoadResourceIds(reader);
this.LoadStringTable(reader);
this.LoadResources(reader);
}
public virtual void LoadData(BinaryReaderEx reader)
{
this.ChunkStart = reader.BaseStream.Position;
this.ChunkHeader = new ChunkHeader();
this.ChunkHeader.ChunkType = reader.ReadInt32();
this.ChunkHeader.Unknown1 = reader.ReadInt32(Endianness.BigEndian);
this.ChunkHeader.DataSize = reader.ReadInt32(Endianness.BigEndian);
this.ChunkHeader.NextChunkOffset = reader.ReadInt32(Endianness.BigEndian);
}
public override void LoadSection(BinaryReaderEx reader)
{
base.LoadSection(reader);
this.Strings = new List<string>();
int numStrings = (this.SectionLength - 4) / bytesPerBlock;
for (var i = 0; i < numStrings; i++)
{
this.Strings.Add(reader.ReadFixedLengthString(16).Trim());
}
}
public virtual void LoadSection(BinaryReaderEx reader)
{
this.SectionStart = reader.BaseStream.Position;
this.SectionHeader = new SectionHeader();
this.SectionHeader.Magic = reader.ReadInt64();
this.SectionHeader.Version = reader.ReadInt32();
this.SectionHeader.Unknown2 = reader.ReadInt32();
this.SectionHeader.SectionLength = reader.ReadInt32();
this.SectionHeader.Junk = reader.ReadBytes(28);
}
private void LoadHeader(BinaryReaderEx reader)
{
// Load Header
this.ResourceHeader = new ResourceHeader();
this.ResourceHeader.NumResources = reader.ReadInt32();
this.ResourceHeader.StringTableOffset = reader.ReadInt32();
this.ResourceHeader.NumStrings = reader.ReadInt32();
this.ResourceHeader.ResourceType = (SectionType)reader.ReadInt32();
this.LoadResourceInfo(reader);
}
public override void LoadData(BinaryReaderEx reader)
{
base.LoadData(reader);
this.boundingBox.Minimum.X = reader.ReadSingle(Endianness.BigEndian);
this.boundingBox.Minimum.Y = reader.ReadSingle(Endianness.BigEndian);
this.boundingBox.Minimum.Z = reader.ReadSingle(Endianness.BigEndian);
this.boundingBox.Maximum.X = reader.ReadSingle(Endianness.BigEndian);
this.boundingBox.Maximum.Y = reader.ReadSingle(Endianness.BigEndian);
this.boundingBox.Maximum.Z = reader.ReadSingle(Endianness.BigEndian);
this.DisplayName = "AABB";
}
private void LoadHeader(BinaryReaderEx reader)
{
this.startHeaderOffset = reader.BaseStream.Position;
this.SscfHeader = new SscfHeader();
this.SscfHeader.Unknown0 = reader.ReadInt16();
this.SscfHeader.NumTracks = reader.ReadInt16();
this.SscfHeader.NumWaves = reader.ReadInt16();
this.SscfHeader.Unknown1 = reader.ReadInt16();
this.SscfHeader.OffsetA = reader.ReadInt32();
this.SscfHeader.OffsetB = reader.ReadInt32();
this.SscfHeader.OffsetC = reader.ReadInt64();
this.SscfHeader.OffsetD = reader.ReadInt64();
this.SscfHeader.OffsetE = reader.ReadInt64();
this.SscfHeader.Unused = reader.ReadInt64();
}
public override void LoadSection(BinaryReaderEx reader)
{
base.LoadSection(reader);
for (var i = 0; i < this.NumChildren; i++)
{
StringEntry entry = new StringEntry()
{
StringIndex = reader.ReadInt16(),
Value = reader.ReadInt16(),
Parent = this
};
entry.DisplayName = entry.StringIndex.ToString();
this.Children.Add(entry);
}
}
public override void LoadSection(BinaryReaderEx reader)
{
base.LoadSection(reader);
this.CibtData = new List<CibtData>();
int numCibtBlocks = (this.SectionLength - 4) / bytesPerBlock;
for (var i = 0; i < numCibtBlocks; i++)
{
var cibt = new CibtData();
cibt.Name = reader.ReadFixedLengthString(16).Trim();
cibt.Unk1 = reader.ReadByte();
cibt.Unk2 = reader.ReadByte();
cibt.Unk3 = reader.ReadByte();
cibt.Unk4 = reader.ReadByte();
this.CibtData.Add(cibt);
}
}
private void LoadVoices(BinaryReaderEx reader)
{
if (this.SscfHeader.NumWaves <= 0)
{
return;
}
reader.BaseStream.Position = this.SscfHeader.OffsetB;
this.VoiceOffsets = new List<int>(this.SscfHeader.NumWaves);
this.Children = new List<INavigable>(this.SscfHeader.NumWaves);
for (var i = 0; i < this.SscfHeader.NumWaves; i++)
{
this.VoiceOffsets.Add(reader.ReadInt32());
}
foreach (int offset in this.VoiceOffsets)
{
reader.BaseStream.Position = offset;
WaveHeader waveHeader = ReadWaveHeader(reader);
IWave voice = null;
switch (waveHeader.Format)
{
case WaveCompressionFormat.PCM:
voice = new PcmWave() { Parent = this, WaveHeader = waveHeader };
break;
case WaveCompressionFormat.Vorbis:
voice = new VorbisWave() { Parent = this, WaveHeader = waveHeader };
break;
case WaveCompressionFormat.ADPCM:
voice = new AdpcmWave() { Parent = this, WaveHeader = waveHeader };
break;
case WaveCompressionFormat.ATRAC3:
case WaveCompressionFormat.ATRAC3_Too:
case WaveCompressionFormat.XMA:
throw new InvalidOperationException("Unsupported Wave Format: " + waveHeader.Format);
default:
throw new InvalidOperationException("Unknown Wave Format: 0x" + ((int)waveHeader.Format).ToString("X"));
}
this.Children.Add(voice);
voice.LoadData(reader);
}
}
public override void LoadSection(BinaryReaderEx reader)
{
base.LoadSection(reader);
this.TextureHeader = new TextureHeader();
this.TextureHeader.Unknown1 = reader.ReadInt32();
this.TextureHeader.Unknown2 = reader.ReadInt32();
this.TextureHeader.Unknown3 = reader.ReadInt32();
this.TextureHeader.Unknown4 = reader.ReadInt32();
// Load GTEX
Gtex = new GtexData();
Gtex.Parent = this;
Gtex.LoadSection(reader);
this.Children = new List<INavigable>();
this.Children.Add(this.Gtex);
}
public override void Load(BinaryReaderEx reader)
{
base.Load(reader);
Float1 = reader.ReadSingle();
AnimationLength = reader.ReadSingle();
Bones = reader.ReadInt16();
NumIndices = reader.ReadInt16();
Flags = reader.ReadByte();
reader.BaseStream.Seek(3, System.IO.SeekOrigin.Current);
for (var i = 0; i < NumIndices; i++)
{
int val = reader.ReadInt32();
ChunkIndex idx = new ChunkIndex();
idx.Index = val & 0x7FFFFFFF;
idx.Flag = (val & 0x80000000) == 0x80000000;
this.Offsets.Add(idx);
}
}
public override Endogine.ColorEx.Palette Load(string filename)
{
Serialization.BinaryReaderEx reader = new BinaryReaderEx(new System.IO.FileStream(filename, System.IO.FileMode.Open));
int numColors = (int)(reader.BaseStream.Length / 3);
Endogine.ColorEx.Palette palette = new Endogine.ColorEx.Palette();
for (int i = 0; i < numColors; i++)
{
Vector4 v = new Vector4(0, 0, 0, 1);
for (int channelNum = 0; channelNum < 3; channelNum++)
v[channelNum] = (float)reader.ReadByte() / 255;
string name = i.ToString();
ColorEx.ColorRgb rgb = new Endogine.ColorEx.ColorRgb();
rgb.Vector = v;
palette.Add(name, rgb);
}
return palette;
}
public override void LoadData(BinaryReaderEx reader)
{
base.LoadData(reader);
this.DisplayName = "Header";
this.Unknown0 = reader.ReadByte();
this.PgrpCount = reader.ReadByte();
this.StmsCount = reader.ReadByte();
this.EnvdCount = reader.ReadByte();
this.Unknown1 = reader.ReadInt32(Endianness.BigEndian);
this.Unknown2 = reader.ReadByte();
this.Unknown3 = reader.ReadByte();
this.Unknown4 = reader.ReadByte();
this.Unknown5 = reader.ReadByte();
this.ShapCount = reader.ReadByte();
this.MimsCount = reader.ReadByte();
this.Unknown6 = reader.ReadByte();
this.Unknown7 = reader.ReadByte();
}
public void LoadFile(BinaryReaderEx reader)
{
reader.BaseStream.Position = 4;
this.Unknown = reader.ReadInt32();
this.ContentLength = reader.ReadInt32();
this.IsEncoded = (reader.ReadByte() == 0xFF);
byte[] data = new byte[this.ContentLength];
reader.Read(data, 0, this.ContentLength);
if (this.IsEncoded)
{
for (var i = 0; i < data.Length; i++)
{
data[i] ^= 0x73;
}
}
this.Data = data;
this.DataAsString = Encoding.UTF8.GetString(data);
}
public override void LoadData(BinaryReaderEx reader)
{
base.LoadData(reader);
shapOffset = reader.BaseStream.Position;
this.ShapHeader = new ShapHeader();
this.ShapHeader.NumThings = reader.ReadInt32(Endianness.BigEndian);
this.ShapHeader.ThingOffset = reader.ReadInt32(Endianness.BigEndian);
this.ShapHeader.NumThings2 = reader.ReadInt32(Endianness.BigEndian);
this.ShapHeader.Thing2Offset = reader.ReadInt32(Endianness.BigEndian);
this.ShapHeader.NameOffset = reader.ReadInt32(Endianness.BigEndian);
this.ShapHeader.Unknown = reader.ReadInt32(Endianness.BigEndian);
reader.BaseStream.Position = shapOffset + this.ShapHeader.ThingOffset;
this.Things = new List<ShapThing1>();
for (var i = 0; i < this.ShapHeader.NumThings; i++)
{
ShapThing1 t = new ShapThing1();
t.Unk1 = reader.ReadInt16(Endianness.BigEndian);
t.Unk2 = reader.ReadInt16(Endianness.BigEndian);
this.Things.Add(t);
}
reader.BaseStream.Position = shapOffset + this.ShapHeader.Thing2Offset;
this.Things2 = new List<ShapThing2>();
for (var j = 0; j < this.ShapHeader.NumThings2; j++)
{
ShapThing2 t = new ShapThing2();
t.Unk1 = reader.ReadSingle(Endianness.BigEndian);
t.Unk2 = reader.ReadSingle(Endianness.BigEndian);
t.Unk3 = reader.ReadSingle(Endianness.BigEndian);
this.Things2.Add(t);
}
reader.BaseStream.Position = shapOffset + this.ShapHeader.NameOffset;
this.Name = reader.ReadNullTerminatedString();
this.DisplayName = String.Format("SHAP [{0}]", this.Name);
}
private void LoadBones(BinaryReaderEx reader)
{
reader.BaseStream.Position = this.BasePosition;
this.Bones = new List<Skeleton.SkeletonBone>(this.BoneCount);
this.Children = new List<INavigable>(this.BoneCount);
for (var i = 0; i < this.BoneCount; i++)
{
Skeleton.SkeletonBone bone = new Skeleton.SkeletonBone();
bone.Parent = this;
bone.StringIndex = reader.ReadInt32();
bone.Unknown1 = reader.ReadInt32();
bone.Unknown2 = reader.ReadInt32();
bone.Unknown3 = reader.ReadInt32();
bone.Translation.X = reader.ReadSingle();
bone.Translation.Y = reader.ReadSingle();
bone.Translation.Z = reader.ReadSingle();
bone.Rotation.X = reader.ReadSingle();
bone.Rotation.Y = reader.ReadSingle();
bone.Rotation.Z = reader.ReadSingle();
bone.Rotation.W = reader.ReadSingle();
bone.Scale.X = reader.ReadSingle();
bone.Scale.Y = reader.ReadSingle();
bone.Scale.Z = reader.ReadSingle();
bone.ParentBoneIndex = reader.ReadInt32();
bone.ChildBoneIndex = reader.ReadInt32();
bone.SiblingBoneIndex = reader.ReadInt32();
bone.BoneIndex = reader.ReadInt32();
bone.Unknown4 = reader.ReadInt32();
bone.Unknown5 = reader.ReadInt32();
bone.Stuff = reader.ReadBytes(96);
this.Bones.Add(bone);
this.Children.Add(bone);
bone.Name = this.StringTable[bone.StringIndex];
}
}
public override void LoadData(BinaryReaderEx reader)
{
base.LoadData(reader);
long pos = reader.BaseStream.Position;
this.BlockSize = reader.ReadInt32(Endianness.BigEndian);
this.StringOffset = reader.ReadInt32(Endianness.BigEndian);
this.ShaderOffset = reader.ReadInt32(Endianness.BigEndian);
this.Name = reader.ReadNullTerminatedString();
reader.BaseStream.Position = pos + this.ShaderOffset;
this.UnknownData = reader.ReadBytes(16);
this.CompiledShaderLength = reader.ReadInt32(Endianness.BigEndian);
this.Unknown4 = reader.ReadInt32(Endianness.BigEndian);
reader.BaseStream.Position = pos + this.ShaderOffset + 0x20;
this.CompiledShader = reader.ReadBytes(this.CompiledShaderLength);
this.DisplayName = String.Format("File [0x{0:X}]", this.ChunkStart);
}
private void ReadHeader(BinaryReaderEx br)
{
MemoryStream msHeader = new MemoryStream();
Debug.Assert(br.CopyDataTo == null);
br.CopyDataTo = msHeader;
byte[] pbSig1 = br.ReadBytes(4);
uint uSig1 = MemUtil.BytesToUInt32(pbSig1);
byte[] pbSig2 = br.ReadBytes(4);
uint uSig2 = MemUtil.BytesToUInt32(pbSig2);
if((uSig1 == FileSignatureOld1) && (uSig2 == FileSignatureOld2))
throw new OldFormatException(PwDefs.ShortProductName + @" 1.x",
OldFormatException.OldFormatType.KeePass1x);
if((uSig1 == FileSignature1) && (uSig2 == FileSignature2)) { }
else if((uSig1 == FileSignaturePreRelease1) && (uSig2 ==
FileSignaturePreRelease2)) { }
else throw new FormatException(KLRes.FileSigInvalid);
byte[] pb = br.ReadBytes(4);
uint uVersion = MemUtil.BytesToUInt32(pb);
if((uVersion & FileVersionCriticalMask) > (FileVersion32 & FileVersionCriticalMask))
throw new FormatException(KLRes.FileVersionUnsupported +
MessageService.NewParagraph + KLRes.FileNewVerReq);
while(true)
{
if(ReadHeaderField(br) == false)
break;
}
br.CopyDataTo = null;
byte[] pbHeader = msHeader.ToArray();
msHeader.Close();
SHA256Managed sha256 = new SHA256Managed();
m_pbHashOfHeader = sha256.ComputeHash(pbHeader);
}
public PosAng(BinaryReaderEx br)
{
Read(br);
}
private bool ReadHeaderField(BinaryReaderEx brSource)
{
Debug.Assert(brSource != null);
if(brSource == null) throw new ArgumentNullException("brSource");
byte btFieldID = brSource.ReadByte();
ushort uSize = MemUtil.BytesToUInt16(brSource.ReadBytes(2));
byte[] pbData = null;
if(uSize > 0)
{
string strPrevExcpText = brSource.ReadExceptionText;
brSource.ReadExceptionText = KLRes.FileHeaderEndEarly;
pbData = brSource.ReadBytes(uSize);
brSource.ReadExceptionText = strPrevExcpText;
}
bool bResult = true;
KdbxHeaderFieldID kdbID = (KdbxHeaderFieldID)btFieldID;
switch(kdbID)
{
case KdbxHeaderFieldID.EndOfHeader:
bResult = false; // Returning false indicates end of header
break;
case KdbxHeaderFieldID.CipherID:
SetCipher(pbData);
break;
case KdbxHeaderFieldID.CompressionFlags:
SetCompressionFlags(pbData);
break;
case KdbxHeaderFieldID.MasterSeed:
m_pbMasterSeed = pbData;
CryptoRandom.Instance.AddEntropy(pbData);
break;
case KdbxHeaderFieldID.TransformSeed:
m_pbTransformSeed = pbData;
CryptoRandom.Instance.AddEntropy(pbData);
break;
case KdbxHeaderFieldID.TransformRounds:
m_pwDatabase.KeyEncryptionRounds = MemUtil.BytesToUInt64(pbData);
break;
case KdbxHeaderFieldID.EncryptionIV:
m_pbEncryptionIV = pbData;
break;
case KdbxHeaderFieldID.ProtectedStreamKey:
m_pbProtectedStreamKey = pbData;
CryptoRandom.Instance.AddEntropy(pbData);
break;
case KdbxHeaderFieldID.StreamStartBytes:
m_pbStreamStartBytes = pbData;
break;
case KdbxHeaderFieldID.InnerRandomStreamID:
SetInnerRandomStreamID(pbData);
break;
default:
Debug.Assert(false);
if(m_slLogger != null)
m_slLogger.SetText(KLRes.UnknownHeaderId + @": " +
kdbID.ToString() + "!", LogStatusType.Warning);
break;
}
return bResult;
}
public void Read(BinaryReaderEx br)
{
Position = new Vector3s(br);
Angle = new Vector3s(br);
}
public override void LoadData(BinaryReaderEx reader)
{
base.LoadData(reader);
this.DisplayName = String.Format("VCAP [0x{0:X}]", this.ChunkStart);
}
public override void Read(PackFileDeserializer des, BinaryReaderEx br)
{
base.Read(des, br);
}
