static byte[] GenerateSoundFile(byte[] buffer, byte[] footer)
{
byte[] sound_file;
using (MemoryStream ms = new MemoryStream())
using (IO.EndianWriter write = new IO.EndianWriter(ms))
{
write.Write("RIFF", "RIFF".Length);
write.Write(uint.MinValue);
write.Write("WAVEdata", "WAVEdata".Length);
write.Write(uint.MinValue);
write.Write(buffer);
if (footer != null)
{
write.Write(footer);
}
int size = (int)ms.Length;
// Write file size to RIFF header
write.Seek(4);
write.Write(size - 8);
// Write data size to WAVE header
write.Seek(16);
write.Write(buffer.Length);
sound_file = ms.ToArray();
}
return(sound_file);
}
public void Write(IO.EndianWriter s)
{
var context = s.UserData as XmbFileContext;
s.Write(kSignature);
if (context.PointerSize == Shell.ProcessorSize.x64)
{
s.Pad32();
}
#region Elements header
s.Write(mElements.Count);
if (context.PointerSize == Shell.ProcessorSize.x64)
{
s.Pad32();
}
var elements_offset_pos = s.MarkVirtualAddress(context.PointerSize);
#endregion
#region Pool header
s.Write(mPool.Size);
if (context.PointerSize == Shell.ProcessorSize.x64)
{
s.Pad32();
}
var pool_offset_pos = s.MarkVirtualAddress(context.PointerSize);
#endregion
if (context.PointerSize == Shell.ProcessorSize.x64)
{
s.Pad64();
}
var elements_offset = s.PositionPtr;
foreach (var e in mElements)
{
e.Write(s);
}
foreach (var e in mElements)
{
e.WriteAttributes(s);
e.WriteChildren(s);
}
var pool_offset = s.PositionPtr;
mPool.Write(s);
s.Seek((long)elements_offset_pos);
s.WriteVirtualAddress(elements_offset);
s.Seek((long)pool_offset_pos);
s.WriteVirtualAddress(pool_offset);
}
/// <summary>
/// Process the block data to a stream
/// </summary>
/// <param name="s">Stream</param>
public override void Write(IO.EndianWriter s)
{
if (this.elements.Count == 0)
{
return; // don't do anything when empty
}
relativeOffset = s.PositionUnsigned; // store offset
s.Seek(headerOffset, System.IO.SeekOrigin.Begin); // go to the reflexive header
s.WritePointer(relativeOffset); // write offset
s.Seek(relativeOffset, System.IO.SeekOrigin.Begin); // go back to where we were
elements.Write(s);
}
public void Write(IO.EndianWriter s)
{
//Flags = EnumFlags.Remove(Flags, FileFlags.EncryptHeader | FileFlags.EncryptContent);
s.Write(Flags, FileFlagsStreamer.Instance);
s.Write((ushort)kVersion);
Write(s, EnumFlags.Test(Flags, FileFlags.EncryptHeader), Header, MediaHeader.kSizeOf);
GenerateHash();
if (EnumFlags.Test(Flags, FileFlags.CompressContent))
{
using (var cs = new CompressedStream(true))
using (var ms = new System.IO.MemoryStream(kMaxContentSize))
using (var sout = new IO.EndianWriter(ms, Shell.EndianFormat.Big))
{
sout.Write(Content);
sout.Seek(0);
cs.InitializeFromStream(ms);
cs.Compress();
Write(s, EnumFlags.Test(Flags, FileFlags.EncryptContent), cs,
userKey: Header.DataCryptKey, writeLeftovers: WriteLeftovers);
}
}
else
{
s.Write(Content);
}
}
void StreamCompressedContent(IO.EndianStream s)
{
if (s.IsReading)
{
using (var cs = new CompressedStream(true))
{
Stream(s, EnumFlags.Test(Flags, FileFlags.EncryptContent), cs,
userKey: Header.DataCryptKey, streamLeftovers: StreamLeftovers);
cs.Decompress();
Content = cs.UncompressedData;
}
}
else if (s.IsWriting)
{
using (var cs = new CompressedStream(true))
using (var ms = new System.IO.MemoryStream(kMaxContentSize))
using (var sout = new IO.EndianWriter(ms, s.ByteOrder))
{
sout.Write(Content);
sout.Seek(0);
cs.InitializeFromStream(ms);
cs.Compress();
Stream(s, EnumFlags.Test(Flags, FileFlags.EncryptContent), cs,
userKey: Header.DataCryptKey, streamLeftovers: StreamLeftovers);
}
}
}
public void WriteChildren(IO.EndianWriter s)
{
if (ChildrenIndices.Count == 0)
{
return;
}
mChildrenOffset = s.PositionPtr;
foreach (int ci in ChildrenIndices)
{
s.Write(ci);
}
// Update element entry
var pos = s.BaseStream.Position;
s.Seek((long)mChildrenOffsetPos);
s.WriteVirtualAddress(mChildrenOffset);
s.Seek(pos);
}
public void WriteAttributes(IO.EndianWriter s)
{
if (Attributes.Count == 0)
{
return;
}
mAttributesOffset = s.PositionPtr;
foreach (var kv in Attributes)
{
XmbVariantSerialization.Write(s, kv.Key);
XmbVariantSerialization.Write(s, kv.Value);
}
// Update element entry
var pos = s.BaseStream.Position;
s.Seek((long)mAttributesOffsetPos);
s.WriteVirtualAddress(mAttributesOffset);
s.Seek(pos);
}
void WriteBitStream(IO.EndianWriter s, long hashPosition)
{
byte[] bs_bytes = new byte[GetBitStreamSize()];
int bs_length;
using (var ms = new System.IO.MemoryStream(bs_bytes))
using (var bs = new IO.BitStream(ms, System.IO.FileAccess.Write, streamName: "GameVariant"))
{
bs.StreamMode = System.IO.FileAccess.Write;
Data.Serialize(bs);
bs.Flush();
bs_length = (int)ms.Position;
}
#region calculate hash
byte[] calculated_hash;
using (var hasher = Program.GetGen3RuntimeDataHasher())
{
byte[] bs_length_bytes = BitConverter.GetBytes(bs_length);
if (!s.ByteOrder.IsSameAsRuntime())
{
Bitwise.ByteSwap.SwapData(Bitwise.ByteSwap.kInt32Definition, bs_length_bytes);
}
hasher.TransformBlock(bs_length_bytes, 0, bs_length_bytes.Length, null, 0);
hasher.TransformFinalBlock(bs_bytes, 0, bs_length);
calculated_hash = hasher.Hash;
}
#endregion
s.Write(bs_length);
s.Write(bs_bytes);
long position = s.BaseStream.Position;
s.Seek(hashPosition);
s.Write(calculated_hash);
s.Seek(position);
}
/// <summary>
/// Process the block data to a tag stream
/// </summary>
/// <param name="ts"></param>
public override void Write(IO.ITagStream ts)
{
if (this.elements.Count == 0)
{
return; // don't do anything when empty
}
IO.EndianWriter s = ts.GetOutputStream();
if (ts.Flags.Test(IO.ITagStreamFlags.UseStreamPositions))
{
relativeOffset = s.PositionUnsigned; // store offset
s.Seek(headerOffset, System.IO.SeekOrigin.Begin); // go to the reflexive header
s.WritePointer(relativeOffset); // write offset
s.Seek(relativeOffset, System.IO.SeekOrigin.Begin); // go back to where we were
}
if (DefinitionState.FieldSetRequiresVersioningHeader(ts))
{
kState.FieldSetWriteVersion(ts, FieldType.Block, Count);
}
elements.Write(ts);
}