/// <summary> /// Process the reference data to a stream /// </summary> /// <param name="s">Stream</param> public override void WriteHeader(IO.EndianWriter s) { s.Write(elements.Count); headerOffset = s.PositionUnsigned; // we'll come back here and write the element's offset s.Write(-1); s.Write(0); }
/// <summary> /// Stream the field to a buffer /// </summary> /// <param name="output"></param> public override void Write(IO.EndianWriter output) { if (StringType == StringType.Normal) { output.Write(Value, false); } else if (StringType == StringType.Unicode) { output.WriteUnicodeString(Value, Length); } else if (StringType == StringType.Ascii) { output.Write(Value, Length); } else if (StringType == StringType.Halo1Profile) { output.WriteUnicodeString(Value, 12); } else if (StringType == StringType.Halo2Profile) { output.WriteUnicodeString(Value, 16); } else if (StringType == StringType.CString) { output.Write(Value, true); } }
public override void Write(IO.EndianWriter stream) { Compiler comp = stream.Owner as Compiler; uint elementsAddress = 0; int flags = ( (tagRef.IsNonResolving ? 1 << 1 : 0) ); if (tagRef.Elements.Count > 1) { elementsAddress = stream.PositionUnsigned; foreach (string i in tagRef.Elements) { stream.WriteTag(i); } comp.MarkLocationFixup(tagRef.Name, stream, true); stream.Write(flags); stream.Write((int)-1); stream.WritePointer(elementsAddress); } else { comp.MarkLocationFixup(tagRef.Name, stream, true); stream.Write(flags); stream.WriteTag(tagRef.Elements[0]); stream.Write((int)0); } }
void WriteHeader(IO.EndianWriter s, IO.ITagStream ts) { headerGroupTag.Write(s); s.Write((int)state.Attribute.Version - 1); s.Write(expectedCount); s.Write(state.RuntimeSizes.SizeOf); // sizeof a single block would go here but its not actually required }
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); } }
public void Write(IO.EndianWriter s) { var xmbContext = s.UserData as XmbFileContext; s.Write(RootElementIndex); XmbVariantSerialization.Write(s, NameVariant); XmbVariantSerialization.Write(s, InnerTextVariant); if (xmbContext.PointerSize == Shell.ProcessorSize.x64) { s.Pad32(); } #region Attributes header s.Write(Attributes.Count); if (xmbContext.PointerSize == Shell.ProcessorSize.x64) { s.Pad32(); } mAttributesOffsetPos = s.PositionPtr; s.WriteVirtualAddress(Values.PtrHandle.InvalidHandle32); #endregion #region Children header s.Write(ChildrenIndices.Count); if (xmbContext.PointerSize == Shell.ProcessorSize.x64) { s.Pad32(); } mChildrenOffsetPos = s.PositionPtr; s.WriteVirtualAddress(Values.PtrHandle.InvalidHandle32); #endregion }
/// <summary> /// Write the header for this pool to a stream for future re-initializing /// and usage, storing things such as the configuration, count, etc /// </summary> /// <param name="s"></param> public void WriteHeader(IO.EndianWriter s) { Contract.Requires(s != null); // Configuration.Write(s); s.Write(Count); s.Write(Size); }
public uint WriteFields(IO.EndianWriter stream, Compiler comp) { uint fieldsAddress = stream.PositionUnsigned; WriteFieldsRecursive(stream, comp, mFields); stream.Write(comp.TypeIndexTerminator); stream.Write((int)0); stream.Write((int)0); return(fieldsAddress); }
protected void AlignMemoryStream(int k_alignment) { int align = k_alignment - (MemoryStream.Length % k_alignment); if (align != k_alignment) { MemoryStream.Write(new byte[align]); } }
void Write(IO.EndianWriter s, float value) { bool not_zero = value != 0f; s.Write(not_zero); if (not_zero) { s.Write(value); } }
private void TransformGfxToSwfFileInternal(byte[] eraFileEntryBuffer, string fullPath, uint bufferSignature) { uint swf_signature = ResourceUtils.GfxHeaderToSwf(bufferSignature); using (var fs = System.IO.File.Create(fullPath + ".swf")) using (var out_s = new IO.EndianWriter(fs, Shell.EndianFormat.Little)) { out_s.Write(swf_signature); out_s.Write(eraFileEntryBuffer, sizeof(uint), eraFileEntryBuffer.Length - sizeof(uint)); } }
/// <summary>Stream the pointer data to a buffer</summary> /// <param name="s"></param> /// <remarks>Number of bytes written depends on <see cref="Is64bit"/></remarks> public void Write(IO.EndianWriter s) { if (!Is64bit) { s.Write(this.u32); } else { s.Write(this.u64); } }
public override void Write(IO.EndianWriter stream) { Compiler comp = stream.Owner as Compiler; comp.MarkLocationFixup(glob.Name, stream, false); stream.Write(glob.Name); stream.Write(glob.type.Opcode); stream.Write((short)(glob.IsInternal ? 1 : 0)); //stream.Write(ushort.MinValue); stream.Write(uint.MaxValue); stream.Write(uint.MinValue); }
public override void Write(IO.EndianWriter s) { s.Write((ushort)engine); s.Write(ushort.MinValue); #region FileNames s.Write(files.Count); foreach (string str in files) { s.Write(str, true); } #endregion }
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); }
public void Create() { Debug.Assert.If(OutputStream != null, "Can't create a definition file when we're not initialized for that mode"); OutputStream.WriteTag(Ext); groupTag.Write(OutputStream); OutputStream.Write((uint)engine); OutputStream.Write(version); OutputStream.Write(header); Create(def); }
internal uint RamAddMemory(string data, out int length) { uint offset = RamMemory.PositionUnsigned; byte[] bytes = Util.ByteStringToArray(data); RamMemory.Write(bytes); length = bytes.Length; //int align = 4 - (RamMemory.Length % 4); //if (align != 4) RamMemory.Write(new byte[align]); return(offset); }
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); }
/// <summary> /// Stream the field to a buffer /// </summary> /// <param name="output"></param> public override void Write(IO.EndianWriter output) { if (Internal != null) { output.Write(Internal); } else { byte[] temp = new byte[Value]; temp.Initialize(); output.Write(temp); temp = null; } }
/// <summary>Build debug streams which foreign native code can easily interop with</summary> /// <param name="offsets">Buffer containing the offsets of the string values in <paramref name="buffer"/></param> /// <param name="buffer">Buffer containing the string values</param> /// <param name="pack">If true, the strings are stored as null terminated strings, else in 128 character strings</param> public void ToDebugStream(IO.EndianWriter offsets, IO.EndianWriter buffer, bool pack) { foreach (var kv in m_set.Set) { offsets.Write(buffer.Position); if (pack) { buffer.Write(kv.Value, true); } else { buffer.Write(kv.Value, mOwner.Definition.Description.ValueBufferSize); } } }
public override void Write(IO.EndianWriter stream) { Compiler comp = stream.Owner as Compiler; TagBlock tb = new TagBlock((Import.TagBlock)tagStruct.Block); tb.Write(stream); comp.MarkLocationFixup(tagStruct.Name, stream, false); stream.Write(tagStruct.Name); stream.WriteTag(tagStruct.GroupTag); stream.Write(tagStruct.Block.DisplayName); stream.WritePointer(tb.RuntimeAddress); }
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); } } }
/// <summary> /// Stream the field to a buffer /// </summary> /// <param name="output"></param> public override void Write(IO.EndianWriter output) { byte[] temp = new byte[Value]; temp.Initialize(); output.Write(temp); temp = null; }
void WriteLeftovers(IO.EndianWriter ew) { // WriteRandomBlocks(ew); if (ew.BaseStream.Length < kMaxContentSize) { int padding_bytes_count = System.Math.Min(PaddingBytes.Length, kMaxContentSize - (int)(ew.BaseStream.Length)); ew.Write(PaddingBytes, 0, padding_bytes_count); } if (ew.BaseStream.Length < kMaxContentSize) { byte[] zero = new byte[kMaxContentSize - (int)(ew.BaseStream.Length)]; Array.Clear(zero, 0, zero.Length); ew.Write(zero, 0, zero.Length); } }
internal void RamToStream(IO.EndianWriter stream, uint reference, int length) { var ms = RamMemory.BaseStream as System.IO.MemoryStream; byte[] buffer = new byte[length]; ms.Seek(reference, System.IO.SeekOrigin.Begin); ms.Read(buffer, 0, length); stream.Write(buffer); int align = 4 - (stream.Length % 4); if (align != 4) { stream.Write(new byte[align]); } }
public override void Write(IO.EndianWriter stream) { Compiler comp = stream.Owner as Compiler; comp.MarkLocationFixup(tagData.Name, stream, false); int flags = ( (tagData.IsNeverStreamed ? 1 << 0 : 0) | (tagData.IsTextData ? 1 << 1 : 0) | (tagData.IsDebugData ? 1 << 2 : 0) ); stream.Write(tagData.Name); stream.Write(flags); stream.Write(tagData.MaxSize); stream.Write((int)0); // should come back later and write the address of the proc via a lookup table from a xml or text file }
public override void Write(IO.EndianWriter stream) { Compiler comp = stream.Owner as Compiler; uint elementsAddress = stream.PositionUnsigned; // write string list's element's addresses foreach (uint i in stringList.Elements) { stream.Write(i); } comp.MarkLocationFixup(stringList.Name, stream, true); stream.Write(stringList.Elements.Count); stream.WritePointer(elementsAddress); }
/// <summary>Only used for Interop situations where explicit lengths are needed for cases (like enumeration) in unmanaged code</summary> /// <param name="s"></param> public void WriteStringByteLengths(IO.EndianWriter s) { Contract.Requires(s != null); foreach (string str in mPool) { s.Write(CalculateStringByteLength(str)); } }
/// <summary>Write the string values to a stream</summary> /// <param name="s"></param> public void WriteStrings(IO.EndianWriter s) { Contract.Requires(s != null); foreach (string str in mPool) { s.Write(str, mEncoding); } }
/// <summary>Build debug streams which foreign native code can easily interop with</summary> /// <param name="offsets">Buffer containing the offsets of the string values in <paramref name="buffer"/></param> /// <param name="buffer">Buffer containing the string values</param> /// <param name="pack">If true, the strings are stored as null terminated strings, else in 128 character strings</param> public void ToDebugStream(IO.EndianWriter offsets, IO.EndianWriter buffer, bool pack) { foreach (var set in m_sets) { foreach (var kv in set.Set) { offsets.Write(buffer.Position); if (pack) { buffer.Write(kv.Value, true); } else { buffer.Write(kv.Value, 128); } } } }