/// <summary>Read a multi-byte CString from an endian stream</summary>
/// <param name="s">Endian stream to read from</param>
/// <param name="ms">Stream to write the character's bytes to</param>
void ReadCStringMultiByte(IO.EndianReader s, System.IO.MemoryStream ms)
{
byte[] characters;
if (!mStorage.IsFixedLength)
{
characters = new byte[mNullCharacterSize];
while (!ReadStringMultiByteIsNull(s.ByteOrder, s.Read(characters), 0))
{
ms.Write(characters, 0, characters.Length);
}
}
else
{
characters = s.ReadBytes(mFixedLengthByteLength);
int x;
for (x = 0; x < characters.Length - mNullCharacterSize; x += mNullCharacterSize)
{
if (ReadStringMultiByteIsNull(s.ByteOrder, characters, x))
{
break;
}
}
ms.Write(characters, 0, x);
}
}
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));
}
}
void ReadBitStream(IO.EndianReader s, byte[] hashBuffer)
{
int max_bit_stream_size = GetBitStreamSize();
bool is_probably_from_mcc = hashBuffer.EqualsZero();
byte[] bs_bytes;
using (var hasher = Program.GetGen3RuntimeDataHasher())
{
int bs_length = ReadBitStreamSize(s, hasher, max_bit_stream_size, is_probably_from_mcc);
bs_bytes = new byte[IntegerMath.Align(IntegerMath.kInt32AlignmentBit, bs_length)];
s.Read(bs_bytes, bs_length);
hasher.TransformFinalBlock(bs_bytes, 0, bs_length);
InvalidData = hasher.Hash.EqualsArray(hashBuffer) == false;
}
if (RequireValidHashes && InvalidData)
{
Data = null;
}
else
{
using (var ms = new System.IO.MemoryStream(bs_bytes))
using (var bs = new IO.BitStream(ms, System.IO.FileAccess.Read, streamName: "GameVariant"))
{
bs.StreamMode = System.IO.FileAccess.Read;
Data.Serialize(bs);
}
}
}
public void Read(XmbFile xmb, XmbFileContext xmbContext, IO.EndianReader s)
{
s.Read(out RootElementIndex);
XmbVariantSerialization.Read(s, out NameVariant);
XmbVariantSerialization.Read(s, out InnerTextVariant);
if (xmbContext.PointerSize == Shell.ProcessorSize.x64)
{
s.Pad32();
}
#region Attributes header
int count;
s.Read(out count);
if (xmbContext.PointerSize == Shell.ProcessorSize.x64)
{
s.Pad32();
}
s.ReadVirtualAddress(out mAttributesOffset);
Attributes = new List <KeyValuePair <XmbVariant, XmbVariant> >(count);
#endregion
#region Children header
s.Read(out count);
if (xmbContext.PointerSize == Shell.ProcessorSize.x64)
{
s.Pad32();
}
s.ReadVirtualAddress(out mChildrenOffset);
ChildrenIndices = new List <int>(count);
#endregion
if (NameVariant.HasUnicodeData || InnerTextVariant.HasUnicodeData)
{
xmb.mHasUnicodeStrings = true;
}
}
static int ReadBitStreamSize(IO.EndianReader s, System.Security.Cryptography.ICryptoTransform hasher,
int maxBitStreamSize, bool isProbablyFromMcc)
{
byte[] bitstream_size_bytes = new byte[sizeof(int)];
s.Read(bitstream_size_bytes);
hasher.TransformBlock(bitstream_size_bytes, 0, bitstream_size_bytes.Length, null, 0);
if (!s.ByteOrder.IsSameAsRuntime())
{
Bitwise.ByteSwap.SwapData(Bitwise.ByteSwap.kInt32Definition, bitstream_size_bytes);
}
int assumed_size = BitConverter.ToInt32(bitstream_size_bytes, 0);
int size = assumed_size;
bool size_was_in_range_after_forced_byte_swap = false;
if (isProbablyFromMcc)
{
size = Bitwise.ByteSwap.SwapInt32(size);
}
else if (assumed_size < 0 || assumed_size > maxBitStreamSize)
{
size = Bitwise.ByteSwap.SwapInt32(size);
if (size <= maxBitStreamSize)
{
size_was_in_range_after_forced_byte_swap = true;
}
else
{
throw new System.IO.InvalidDataException(string.Format(
"Invalid bitstream size {0}, data is probably corrupt. Max size is {1}",
assumed_size.ToString("X8"),
maxBitStreamSize.ToString("X8")));
}
}
Util.MarkUnusedVariable(ref size_was_in_range_after_forced_byte_swap);
return(size);
}
public void Read(IO.EndianReader s)
{
switch (Type)
{
case XmbVariantType.Int: s.Read(out Int); break;
case XmbVariantType.Single: s.Read(out Single); break;
case XmbVariantType.Double: s.Read(out Double); break;
case XmbVariantType.String:
String = s.ReadString(IsUnicode ? kUnicodeEncoding : kAnsiEncoding);
break;
case XmbVariantType.Vector:
if (VectorLength >= 1)
{
s.Read(out Vector4d.X);
}
if (VectorLength >= 2)
{
s.Read(out Vector4d.Y);
}
if (VectorLength >= 3)
{
s.Read(out Vector4d.Z);
}
if (VectorLength >= 4)
{
s.Read(out Vector4d.W);
}
break;
default: throw new KSoft.Debug.UnreachableException(Type.ToString());
}
}
void ReadLeftovers(IO.EndianReader er)
{
PaddingBytes = new byte[(int)(er.BaseStream.Length - er.BaseStream.Position)];
er.Read(PaddingBytes, 0, PaddingBytes.Length);
}
