/// <summary>
/// Read and preprocess header information
/// </summary>
private void ReadPreprocess()
{
char[] gtag;
#region Endian Switch
ushort us_temp = InputStream.ReadUInt16();
if (us_temp == HeaderEndian)
{
SetEndianState(IO.EndianState.Little);
}
else if (us_temp == HeaderEndianSwap)
{
SetEndianState(IO.EndianState.Big);
}
else
{
throw new Debug.ExceptionLog("File: Invalid switch! {0:X4}", us_temp);
}
#endregion
#region Version
us_temp = InputStream.ReadUInt16();
Debug.Assert.If(us_temp == HeaderVersion,
"File: mismatching file version! [{0}, !{1}",
HeaderVersion, us_temp);
#endregion
#region Signature
gtag = InputStream.ReadTag();
Debug.Assert.If(TagGroup.Test(gtag, (char[])IO.TagGroups.BlamLib),
"File: invalid signature! [{0} !{1}]",
IO.TagGroups.BlamLib.TagToString(), new string(gtag));
#endregion
flags.Reset((uint)(InputStream.ReadUInt16() << 16) | flags);
#region Data Version
us_temp = InputStream.ReadUInt16();
Debug.Assert.If(us_temp == data.Attribute.Version,
"File: mismatching data version! [{0}, !{1}",
data.Attribute.Version, us_temp);
#endregion
#region Data Signature
gtag = InputStream.ReadTag();
Debug.Assert.If(TagGroup.Test(gtag, (char[])data.GroupTag),
"File: invalid data signature! [{0} !{1}]",
data.GroupTag.TagToString(), new string(gtag));
#endregion
#region Data Directories
InputStream.ReadInt32();
InputStream.ReadInt32();
#endregion
#region Data
InputStream.ReadInt32();
int data_offset = InputStream.ReadInt32();
#endregion
Debug.Assert.If(InputStream.Position == HeaderSize,
"File: Update header size! [{0}, !{1}]", HeaderSize, InputStream.Position);
InputStream.Seek(data_offset);
}
public void Read(IO.EndianReader s)
{
s.Owner = this;
Flags = s.Read(FileFlagsStreamer.Instance);
Version = s.ReadUInt16();
if (Version != kVersion)
{
throw new IO.VersionMismatchException(s.BaseStream,
kVersion, Version);
}
Read(s, EnumFlags.Test(Flags, FileFlags.EncryptHeader), Header, MediaHeader.kSizeOf);
GenerateHash();
if (EnumFlags.Test(Flags, FileFlags.CompressContent))
{
using (var cs = new CompressedStream(true))
{
Read(s, EnumFlags.Test(Flags, FileFlags.EncryptContent), cs,
userKey: Header.DataCryptKey, readLeftovers: ReadLeftovers);
cs.Decompress();
Content = cs.UncompressedData;
}
}
else
{
Content = s.ReadBytes((int)(s.BaseStream.Length - s.BaseStream.Position));
}
}
int ReadChunk(IO.EndianReader s, System.IO.MemoryStream ms)
{
ushort chunk_size = s.ReadUInt16(), negate_chunk_size = s.ReadUInt16();
ushort expected_negate = (ushort)~chunk_size;
if (expected_negate != negate_chunk_size)
{
throw new IO.SignatureMismatchException(s.BaseStream,
expected_negate, negate_chunk_size);
}
byte[] bytes = s.ReadBytes(chunk_size);
ms.Write(bytes, 0, bytes.Length);
return(chunk_size);
}
public static void Assert(IO.EndianReader s, ushort expected)
{
Contract.Requires(s != null);
var version = s.ReadUInt16();
if (version != expected)
{
throw new VersionMismatchException(s.BaseStream, expected, version);
}
}
public static ushort Assert(IO.EndianReader s
, ushort expectedMin
, ushort expectedMax)
{
Contract.Requires(s != null);
var version = s.ReadUInt16();
if (version < expectedMin || version > expectedMax)
{
throw new VersionOutOfRangeException(s.BaseStream, expectedMin, expectedMax, version);
}
return(version);
}
public override void Read(IO.EndianReader s)
{
BlamVersion ver = (BlamVersion)s.ReadUInt16();
// HACK: this is a hack
if (ver == BlamVersion.Halo1)
{
ver = BlamVersion.Halo1_CE;
}
Debug.Assert.If(ver == engine, "Engine version mismatch: expected {0}, but got {1}", engine, ver);
s.Seek(2, System.IO.SeekOrigin.Current);
#region FileNames
int file_count = s.ReadInt32();
for (int x = 0; x < file_count; x++)
{
files.Add(s.ReadCString());
}
#endregion
}
void ReadInt(IO.EndianReader s)
{
switch (TypeDesc.SizeOf)
{
case sizeof(byte):
{
if (ArrayLength == 1)
{
Int = TypeDesc.IsUnsigned
? (uint)s.ReadByte()
: (uint)s.ReadSByte();
}
else
{
if (TypeDesc.IsUnsigned)
{
var array = s.ReadBytes(ArrayLength);
OpaqueArrayRef = array;
}
else
{
var array = new sbyte[ArrayLength];
for (int x = 0; x < array.Length; x++)
{
array[x] = s.ReadSByte();
}
OpaqueArrayRef = array;
}
}
} break;
case sizeof(ushort):
{
if (ArrayLength == 1)
{
Int = TypeDesc.IsUnsigned
? (uint)s.ReadUInt16()
: (uint)s.ReadInt16();
}
else
{
if (TypeDesc.IsUnsigned)
{
var array = new ushort[ArrayLength];
for (int x = 0; x < array.Length; x++)
{
array[x] = s.ReadUInt16();
}
OpaqueArrayRef = array;
}
else
{
var array = new short[ArrayLength];
for (int x = 0; x < array.Length; x++)
{
array[x] = s.ReadInt16();
}
OpaqueArrayRef = array;
}
}
} break;
case sizeof(uint):
{
if (ArrayLength == 1)
{
Int = TypeDesc.IsUnsigned
? (uint)s.ReadUInt32()
: (uint)s.ReadInt32();
}
else
{
if (TypeDesc.IsUnsigned)
{
var array = new uint[ArrayLength];
for (int x = 0; x < array.Length; x++)
{
array[x] = s.ReadUInt32();
}
OpaqueArrayRef = array;
}
else
{
var array = new int[ArrayLength];
for (int x = 0; x < array.Length; x++)
{
array[x] = s.ReadInt32();
}
OpaqueArrayRef = array;
}
}
} break;
case sizeof(ulong):
{
if (ArrayLength == 1)
{
Int64 = TypeDesc.IsUnsigned
? (ulong)s.ReadUInt64()
: (ulong)s.ReadInt64();
}
else
{
if (TypeDesc.IsUnsigned)
{
var array = new ulong[ArrayLength];
for (int x = 0; x < array.Length; x++)
{
array[x] = s.ReadUInt64();
}
OpaqueArrayRef = array;
}
else
{
var array = new long[ArrayLength];
for (int x = 0; x < array.Length; x++)
{
array[x] = s.ReadInt64();
}
OpaqueArrayRef = array;
}
}
} break;
default:
throw new KSoft.Debug.UnreachableException(TypeDesc.SizeOf.ToString());
}
}
