public void ExportNamedConstants( GpuNamedConstants pConsts, string filename, Endian endianMode ) { using ( var f = new FileStream( filename, FileMode.CreateNew, FileAccess.Write ) ) { ExportNamedConstants( pConsts, f, endianMode ); } }
/** * Writes any number of bytes into a byte array, at a given position. * This is an aux function used when creating the WAV data. */ public static void writeBytes(byte[] __bytes, ref int __position, byte[] __newBytes, Endian __endian) { // Writes __newBytes to __bytes at position __position, increasing the position depending on the length of __newBytes for (int i = 0; i < __newBytes.Length; i++) { __bytes[__position] = __newBytes[__endian == Endian.BIG_ENDIAN ? i : __newBytes.Length - i - 1]; __position++; } }
public static BinaryReader Create(Stream s, Endian e) { if (BitConverter.IsLittleEndian) { if (Endian.Little == e) { return new BinaryReader(s); } else { return new EndianBinaryReader(s, e); } } else { if (Endian.Big == e) { return new BinaryReader(s); } else { return new EndianBinaryReader(s, e); } } }
public ByteBuffer(byte[] data, Endian endian) { _data = data; _endian = endian; _encoding = Encoding.ASCII; _specificCharacterSet = null; }
static private bool NeedConvert(Endian endian) { if (endian == Endian.LittleEndian) return !isLittleEndian; else return isLittleEndian; }
public static void WriteValueF32(this Stream stream, Single value, Endian endian) { byte[] data = ShouldSwap(endian) == true ? BitConverter.GetBytes(BitConverter.ToInt32(BitConverter.GetBytes(value), 0).Swap()) : BitConverter.GetBytes(value); Debug.Assert(data.Length == 4); stream.WriteBytes(data); }
private void ExportNamedConstants( GpuNamedConstants pConsts, Stream stream, Endian endianMode ) { using ( var w = new BinaryWriter( stream ) ) { } throw new NotImplementedException(); }
internal FileReference(string file, long offset, long length, Endian endian, DicomVr vr) { _filename = file; _offset = offset; _length = length; _endian = endian; _vr = vr; }
public MemoryDomainByteArray(string name, Endian endian, byte[] data, bool writable, int wordSize) { Name = name; EndianType = endian; Data = data; Writable = writable; WordSize = wordSize; }
internal FileReference(DicomStreamOpener streamOpener, long offset, long length, Endian endian, DicomVr vr) { StreamOpener = streamOpener; Offset = offset; _length = length; Endian = endian; Vr = vr; }
public MPEntryValue(byte[] bytes, int startIndex, Endian endian) { ImageAttr = (uint)BitConverterEx.ToInt32(bytes, startIndex + 0, endian); ImageSize = (uint)BitConverterEx.ToInt32(bytes, startIndex + 4, endian); ImageDataOffset = (uint)BitConverterEx.ToInt32(bytes, startIndex + 8, endian); DependentImage1 = (ushort)BitConverterEx.ToInt16(bytes, startIndex + 12, endian); DependentImage2 = (ushort)BitConverterEx.ToInt16(bytes, startIndex + 14, endian); }
/// <summary> /// Constructor. /// </summary> /// <param name="data">Data to encapsulate</param> /// <param name="endian"><see cref="Endian"/> to use when reading the data.</param> public EndianBinaryReader(byte[] data, Endian endian) : base(new MemoryStream(data)) { if (data == null) throw new ArgumentNullException("data"); this.CurrentEndian = endian; }
/// <summary> /// Constructor /// </summary> /// <param name="endianness">Big or little endian</param> /// <param name="sizeofInt">Size of int in bytes</param> /// <param name="sizeofSizeT">Size of size_t in bytes</param> /// <param name="sizeofLuaNumber">Size of lua_Number in bytes</param> /// <param name="stripDebugInfo">Whether to strip debug info or not</param> public LuaCompilerConfig(Endian endianness, int sizeofInt, int sizeofSizeT, int sizeofLuaNumber, bool stripDebugInfo) { Endianness = endianness; SizeOfInt = sizeofInt; SizeOfSizeT = sizeofSizeT; SizeOfLuaNumber = sizeofLuaNumber; StripDebugInfo = stripDebugInfo; }
private ByteBuffer(byte[] data, Endian endian, bool highCapacityMode = false) { _data = data; _endian = endian; Encoding = Encoding.ASCII; SpecificCharacterSet = null; _highCapacityMode = highCapacityMode; }
public static Guid ReadValueGuid(this Stream stream, Endian endian) { var a = stream.ReadValueS32(endian); var b = stream.ReadValueS16(endian); var c = stream.ReadValueS16(endian); var d = stream.ReadBytes(8); return new Guid(a, b, c, d); }
public static void WriteValueF64(this Stream stream, Double value, Endian endian) { byte[] data = ShouldSwap(endian) == true ? BitConverter.GetBytes(BitConverter.DoubleToInt64Bits(value).Swap()) : BitConverter.GetBytes(value); Debug.Assert(data.Length == 8); stream.WriteBytes(data); }
/// <summary> /// Initializes a new instance of the DataStream class. /// This will store all PDU information for either an InputStream or OutputStream. /// </summary> public DataStream() { // Test the machine to determine to see what it supports. this.endianType = (BitConverter.IsLittleEndian ? Endian.Little : Endian.Big); // create a new MemoryStream this.Stream = new MemoryStream(); }
internal static bool ShouldSwap(Endian endian) { switch (endian) { case Endian.Little: return BitConverter.IsLittleEndian == false; case Endian.Big: return BitConverter.IsLittleEndian == true; default: throw new ArgumentException("unsupported endianness", "endian"); } }
public static void WriteValueGuid(this Stream stream, Guid value, Endian endian) { var data = value.ToByteArray(); Debug.Assert(data.Length == 16); stream.WriteValueS32(BitConverter.ToInt32(data, 0), endian); stream.WriteValueS16(BitConverter.ToInt16(data, 4), endian); stream.WriteValueS16(BitConverter.ToInt16(data, 6), endian); stream.Write(data, 8, 8); }
public static bool NeedToSwapBytes(Endian endian) { if (BitConverter.IsLittleEndian) { return Endian.Little != endian; } return Endian.Big != endian; }
/// <summary> /// Initializes a new instance of the <see cref="EndianStream"/> class. /// </summary> /// <param name="stream">The stream to read from and write to.</param> /// <param name="endianness">The initial endianness to use when operating on the stream.</param> /// <exception cref="System.ArgumentException">Thrown if <paramref name="stream"/> is not both readable and writable.</exception> public EndianStream(Stream stream, Endian endianness) { if (!stream.CanRead || !stream.CanWrite) throw new ArgumentException("The input stream must be both readable and writable."); _stream = stream; _reader = new EndianReader(stream, endianness); _writer = new EndianWriter(stream, endianness); }
/// <summary> /// Reads a 4-byte unsigned integer from the current stream using provided endian and advances the /// position of the stream by four bytes. /// </summary> /// <param name="reader"></param> /// <param name="endian">Endian of binary stream.</param> /// <returns></returns> public static uint ReadUInt32(this BinaryReader reader, Endian endian) { if(endian == Endian.SmallEndian) return reader.ReadUInt32(); var buffer = new byte[4]; reader.Read(buffer, 0, 4); return BitConverter.ToUInt32(buffer.Reverse().ToArray(), 0); }
/// <summary> /// Reads a 2-byte signed integer from the current stream using privded endian and advances the current /// position of the stream by two bytes. /// </summary> /// <param name="reader"></param> /// <param name="endian">Endian of binary stream.</param> /// <returns></returns> public static short ReadInt16(this BinaryReader reader, Endian endian) { if(endian == Endian.SmallEndian) return reader.ReadInt16(); var buffer = new byte[2]; reader.Read(buffer, 0, 2); return BitConverter.ToInt16(buffer.Reverse().ToArray(), 0); }
/// <summary> /// Attempts to read the specified T. If this system is /// doesn't match the specified endian, then this will reverse the array of bytes, /// so that it corresponds with the big-endian format. /// </summary> /// <param name="stream">The stream to read the value from</param> /// <param name="endian">Specifies what endian property should be used.</param> /// <returns>The integer value</returns> public static int ReadInt32(this Stream stream, Endian endian) { byte[] val = new byte[4]; stream.Read(val, 0, 4); if ((endian == Endian.LittleEndian) != BitConverter.IsLittleEndian) { Array.Reverse(val); } return BitConverter.ToInt32(val, 0); }
public override bool OnInitialize() { _major = CommonHeader->VersionMajor; _minor = CommonHeader->VersionMinor; _tag = CommonHeader->_tag; _length = CommonHeader->_length; _endian = CommonHeader->Endian; return false; }
public MemoryDomainDelegate(string name, long size, Endian endian, Func<long, byte> peek, Action<long, byte> poke, int wordSize) { Name = name; EndianType = endian; Size = size; _peek = peek; _poke = poke; Writable = poke != null; WordSize = wordSize; }
public static ushort ToUInt16(byte[] buffer, int startIndex = 0, Endian endian = Endian.Big) { if (endian == Endian.Little) { return (ushort)(buffer[startIndex + 1] << 8 | buffer[startIndex + 0]); } else { return (ushort)(buffer[startIndex + 0] << 8 | buffer[startIndex + 1]); } }
public static void FromUInt16(ushort value, byte[] buffer, int startIndex = 0, Endian endian = Endian.Big) { if(endian == Endian.Little) { buffer[startIndex + 1] = (byte)((value >> 8) & 0xff); buffer[startIndex + 0] = (byte)(value & 0xff); } else { buffer[startIndex + 0] = (byte)((value >> 8) & 0xff); buffer[startIndex + 1] = (byte)(value & 0xff); } }
/// <summary> /// Usage: using(var myFile = FileSystem.LoadFile("relativePath")) { // Do stuff with myFile } /// /// Returns a EndianBinaryReader (of specified endian-ness) which contains the specified file. This /// function will eventually be Folder vs. ISO agnostic. /// </summary> /// <param name="relativeFilePath">Relative to the root dir of the WindWaker ISO extract.</param> /// <param name="endian">Endian-ness of the file to load.</param> public static EndianBinaryReader LoadFileRelative(string relativeFilePath, Endian endian) { if (string.IsNullOrEmpty(Settings.Default.rootDiskDir)) throw new SettingsPropertyNotFoundException("Root Disk Dir not configured, cannot retrieve local file."); string combinedFilePath = Path.Combine(Settings.Default.rootDiskDir, relativeFilePath); if (!File.Exists(combinedFilePath)) throw new FileNotFoundException("Requested local file not found.", combinedFilePath); return new EndianBinaryReader(File.Open(combinedFilePath, FileMode.Open, FileAccess.Read), endian); }
/// <summary> /// Constructs a new EndianStream based off of a Stream object. /// </summary> /// <param name="stream">The Stream to use. It must at least be available for reading or writing.</param> /// <param name="endianness">The endianness to use when performing I/O operations.</param> public EndianStream(Stream stream, Endian endianness) { _stream = stream; if (stream.CanRead) _reader = new EndianReader(stream, endianness); if (stream.CanWrite) _writer = new EndianWriter(stream, endianness); if (_reader == null && _writer == null) throw new ArgumentException("The input stream cannot be read from or written to."); }
/// <summary> /// Constructor. /// </summary> /// <param name="stream">The <see cref="Stream"/> to wrap within this EndianBinaryReader.</param> /// <param name="encoding">The <see cref="Encoding"/> to use for characters.</param> /// <param name="leaveOpen">Whether or not to leave the stream open after this EndianBinaryReader is disposed.</param> /// <param name="endian">The <see cref="Endian"/> to use when reading from files.</param> public EndianBinaryReader(Stream stream, Encoding encoding, bool leaveOpen, Endian endian) : base(stream, encoding, leaveOpen) { CurrentEndian = endian; }
/// <summary> /// Constructor. /// </summary> /// <param name="data">Data to encapsulate</param> /// <param name="encoding">The <see cref="Encoding"/> to use for characters.</param> /// <param name="endian"><see cref="Endian"/> to use when reading the data.</param> public EndianBinaryReader(byte[] data, Encoding encoding, Endian endian) : base(new MemoryStream(data), encoding) { CurrentEndian = endian; }
public void Deserialize(IBlock parent, Stream input, Endian endian) { }
/// <summary> /// Initializes an instance of the <see cref="EndianBinaryReader"/> class. /// </summary> /// <param name="input">Stream from which to read.</param> /// <param name="encoding">Encoding of the <paramref name="input"/>.</param> /// <param name="endian">Endianness of the <paramref name="input"/>. Default values is <c>Endian.Little</c></param> public EndianBinaryReader(Stream input, Encoding encoding, Endian endian = Endian.Little) : base(input, encoding) { Endian = endian; }
public void Deserialize(Stream input, Endian endian, StringTable strings) { this.R = input.ReadValueF32(endian); this.G = input.ReadValueF32(endian); this.B = input.ReadValueF32(endian); }
public AnimIdentifier(Stream stream, Endian endianness = Endian.LittleEndian) : base(stream, endianness) { }
public void Deserialize(Stream input) { input.Seek(0, SeekOrigin.Begin); this.FormatType = input.ReadValueEnum <GFF.FormatType>(Endian.Big); var version = input.ReadValueU32(Endian.Big); if (version != 0x56332E32) // 3.2 { throw new FormatException("unsupported version"); } this.FileVersion = (byte)(version - 0x56332E32); var endian = this.Endian = Endian.Little; var structOffset = input.ReadValueU32(endian); var structCount = input.ReadValueU32(endian); var fieldOffset = input.ReadValueU32(endian); var fieldCount = input.ReadValueU32(endian); var labelOffset = input.ReadValueU32(endian); var labelCount = input.ReadValueU32(endian); var fieldDataOffset = input.ReadValueU32(endian); var fieldDataSize = input.ReadValueU32(endian); var fieldIndicesOffset = input.ReadValueU32(endian); var fieldIndicesSize = input.ReadValueU32(endian); var listIndicesOffset = input.ReadValueU32(endian); var listIndicesSize = input.ReadValueU32(endian); if (structCount < 1) { throw new FormatException(); } // field data input.Seek(fieldDataOffset, SeekOrigin.Begin); var data = input.ReadToMemoryStream(fieldDataSize); // labels var labels = new string[labelCount]; input.Seek(labelOffset, SeekOrigin.Begin); for (int i = 0; i < labels.Length; i++) { labels[i] = input.ReadString(16, true, Encoding.ASCII); } // field indices if ((fieldIndicesSize % 4) != 0) { throw new FormatException(); } var fieldIndices = new uint[fieldIndicesSize / 4]; input.Seek(fieldIndicesOffset, SeekOrigin.Begin); for (int i = 0; i < fieldIndices.Length; i++) { fieldIndices[i] = input.ReadValueU32(endian); } // list indices if ((listIndicesSize % 4) != 0) { throw new FormatException(); } var listIndices = new uint[listIndicesSize / 4]; input.Seek(listIndicesOffset, SeekOrigin.Begin); for (int i = 0; i < listIndices.Length; i++) { listIndices[i] = input.ReadValueU32(endian); } // fields var fields = new FieldFormat[fieldCount]; input.Seek(fieldOffset, SeekOrigin.Begin); for (int i = 0; i < fields.Length; i++) { fields[i].Type = input.ReadValueEnum <GFF.FieldType>(endian); fields[i].LabelIndex = input.ReadValueU32(endian); fields[i].DataOrDataOffset = input.ReadValueU32(endian); } // structures var structs = new GFF.StructureData[structCount]; for (int i = 0; i < structs.Length; i++) { structs[i] = new GFF.StructureData(); } input.Seek(structOffset, SeekOrigin.Begin); for (int i = 0; i < structs.Length; i++) { var structData = structs[i]; var structFormat = new StructFormat(); structData.Type = input.ReadValueU32(endian); if (i == 0 && structData.Type != 0xFFFFFFFF) { throw new FormatException(); } structFormat.DataOrDataOffset = input.ReadValueU32(endian); structFormat.FieldCount = input.ReadValueU32(endian); var indices = new uint[structFormat.FieldCount]; if (structFormat.FieldCount == 1) { indices[0] = structFormat.DataOrDataOffset; } else { if ((structFormat.DataOrDataOffset % 4) != 0) { throw new FormatException(); } uint baseIndex = structFormat.DataOrDataOffset / 4; for (uint j = 0; j < structFormat.FieldCount; j++) { indices[j] = fieldIndices[baseIndex + j]; } } var _input = input; input = null; foreach (var index in indices) { var fieldData = new GFF.FieldData(); var fieldFormat = fields[index]; var label = labels[fieldFormat.LabelIndex]; fieldData.Type = fieldFormat.Type; switch (fieldFormat.Type) { case GFF.FieldType.UInt8: { fieldData.Value = (byte)fieldFormat.DataOrDataOffset; break; } case GFF.FieldType.Int8: { fieldData.Value = (sbyte)((byte)fieldFormat.DataOrDataOffset); break; } case GFF.FieldType.UInt16: { fieldData.Value = (ushort)fieldFormat.DataOrDataOffset; break; } case GFF.FieldType.Int16: { fieldData.Value = (short)((ushort)fieldFormat.DataOrDataOffset); break; } case GFF.FieldType.UInt32: { fieldData.Value = (uint)fieldFormat.DataOrDataOffset; break; } case GFF.FieldType.Int32: { fieldData.Value = (int)fieldFormat.DataOrDataOffset; break; } case GFF.FieldType.UInt64: { if (fieldFormat.DataOrDataOffset + 8 > data.Length) { throw new FormatException(); } data.Seek(fieldFormat.DataOrDataOffset, SeekOrigin.Begin); fieldData.Value = data.ReadValueU64(endian); break; } case GFF.FieldType.Int64: { if (fieldFormat.DataOrDataOffset + 8 > data.Length) { throw new FormatException(); } data.Seek(fieldFormat.DataOrDataOffset, SeekOrigin.Begin); fieldData.Value = data.ReadValueS64(endian); break; } case GFF.FieldType.Single: { fieldData.Value = BitConverter.ToSingle(BitConverter.GetBytes(fieldFormat.DataOrDataOffset), 0); break; } case GFF.FieldType.Double: { if (fieldFormat.DataOrDataOffset + 8 > data.Length) { throw new FormatException(); } data.Seek(fieldFormat.DataOrDataOffset, SeekOrigin.Begin); fieldData.Value = data.ReadValueF64(endian); break; } case GFF.FieldType.String: { if (fieldFormat.DataOrDataOffset + 4 > data.Length) { throw new FormatException(); } data.Seek(fieldFormat.DataOrDataOffset, SeekOrigin.Begin); var length = data.ReadValueU32(); if (fieldFormat.DataOrDataOffset + 4 + length > fieldDataOffset) { throw new FormatException(); } fieldData.Value = data.ReadString(length, true, Encoding.ASCII); break; } case GFF.FieldType.Resource: { if (fieldFormat.DataOrDataOffset + 1 > data.Length) { throw new FormatException(); } data.Seek(fieldFormat.DataOrDataOffset, SeekOrigin.Begin); var length = data.ReadValueU8(); if (fieldFormat.DataOrDataOffset + 1 + length > data.Length) { throw new FormatException(); } fieldData.Value = data.ReadString(length, true, Encoding.ASCII); break; } case GFF.FieldType.LocalizedString: { if (fieldFormat.DataOrDataOffset + 4 + 8 > data.Length) { throw new FormatException(); } data.Seek(fieldFormat.DataOrDataOffset, SeekOrigin.Begin); var size = data.ReadValueU32(); if (fieldFormat.DataOrDataOffset + 4 + size > data.Length) { throw new FormatException(); } var loc = new GFF.LocalizedString(); loc.Id = data.ReadValueU32(endian); var count = data.ReadValueU32(endian); for (uint j = 0; j < count; j++) { var id = data.ReadValueS32(endian); var length = data.ReadValueU32(); loc.Strings.Add(id, data.ReadString(length, true, Encoding.ASCII)); } fieldData.Value = loc; break; } case GFF.FieldType.Void: { throw new NotSupportedException(); } case GFF.FieldType.Structure: { throw new NotSupportedException(); } case GFF.FieldType.List: { if ((fieldFormat.DataOrDataOffset % 4) != 0) { throw new FormatException(); } var baseIndex = fieldFormat.DataOrDataOffset / 4; var list = new List <GFF.StructureData>(); var count = listIndices[baseIndex]; for (uint j = 0; j < count; j++) { list.Add(structs[listIndices[baseIndex + 1 + j]]); } fieldData.Value = list; break; } } structData.Fields.Add(label, fieldData); } input = _input; } this.Root = structs[0]; }
public UnknownData1(Stream stream, Endian endianness = Endian.LittleEndian) : base(stream, endianness) { }
void PropertyContainerFile.IRawVariant.Serialize(Stream output, Endian endian) { FileFormats.Vector3.Write(output, this._Value, endian); }
void PropertyContainerFile.IRawVariant.Deserialize(Stream input, Endian endian) { this._Value = FileFormats.Vector3.Read(input, endian); }
public void ReadScene(HeaderCommands.Rooms forcerooms = null) { Program.Status.Message = string.Format("Reading scene '{0}'...", Name); ROM.SegmentMapping.Remove((byte)0x02); ROM.SegmentMapping.Add((byte)0x02, data); sceneHeaders = new List <HeaderLoader>(); HeaderLoader newheader = null; HeaderCommands.Rooms rooms = null; HeaderCommands.Collision coll = null; if (data[0] == (byte)HeaderLoader.CommandTypeIDs.SettingsSoundScene || data[0] == (byte)HeaderLoader.CommandTypeIDs.Rooms || BitConverter.ToUInt32(data, 0) == (byte)HeaderLoader.CommandTypeIDs.SubHeaders) { /* Get rooms & collision command from first header */ newheader = new HeaderLoader(ROM, this, 0x02, 0, 0); /* If external rooms should be forced, overwrite command in header */ if (forcerooms != null) { int roomidx = newheader.Commands.FindIndex(x => x.Command == HeaderLoader.CommandTypeIDs.Rooms); if (roomidx != -1) { newheader.Commands[roomidx] = forcerooms; } } rooms = newheader.Commands.FirstOrDefault(x => x.Command == HeaderLoader.CommandTypeIDs.Rooms) as HeaderCommands.Rooms; coll = newheader.Commands.FirstOrDefault(x => x.Command == HeaderLoader.CommandTypeIDs.Collision) as HeaderCommands.Collision; sceneHeaders.Add(newheader); if (BitConverter.ToUInt32((byte[])ROM.SegmentMapping[(byte)0x02], 0) == 0x18) { int hnum = 1; uint aofs = Endian.SwapUInt32(BitConverter.ToUInt32((byte[])ROM.SegmentMapping[(byte)0x02], 4)); while (true) { uint rofs = Endian.SwapUInt32(BitConverter.ToUInt32((byte[])ROM.SegmentMapping[(byte)0x02], (int)(aofs & 0x00FFFFFF))); if (rofs != 0) { if ((rofs & 0x00FFFFFF) > ((byte[])ROM.SegmentMapping[(byte)0x02]).Length || (rofs >> 24) != 0x02) { break; } newheader = new HeaderLoader(ROM, this, 0x02, (int)(rofs & 0x00FFFFFF), hnum++); /* Get room command index... */ int roomidx = newheader.Commands.FindIndex(x => x.Command == HeaderLoader.CommandTypeIDs.Rooms); /* If external rooms should be forced, overwrite command in header */ if (roomidx != -1 && forcerooms != null) { newheader.Commands[roomidx] = forcerooms; } /* If rooms were found in first header, force using these! */ if (roomidx != -1 && rooms != null) { newheader.Commands[roomidx] = rooms; } /* If collision was found in header, force */ int collidx = newheader.Commands.FindIndex(x => x.Command == HeaderLoader.CommandTypeIDs.Collision); if (collidx != -1 && coll != null) { newheader.Commands[collidx] = coll; } sceneHeaders.Add(newheader); } aofs += 4; } } currentSceneHeader = sceneHeaders[0]; } }
public void Write(Stream output, Endian endian) { Write(output, this, endian); }
public CollectionParameter(Endian endian) { _endian = endian; }
/// <summary> /// Initializes an instance of the <see cref="EndianBinaryReader"/> class. /// </summary> /// <param name="input">Stream from which to read.</param> /// <param name="endian">Endianness of the <paramref name="input"/>. Default values is <c>Endian.Little</c></param> public EndianBinaryReader(Stream input, Endian endian = Endian.Little) : base(input) { Endian = endian; }
/// <summary> /// Constructor /// </summary> /// <param name="stream">The <see cref="Stream"/> to wrap within this EndianBinaryReader.</param> /// <param name="encoding">The <see cref="Encoding"/> to use for characters.</param> /// <param name="endian">The <see cref="Endian"/> to use when reading files.</param> public EndianBinaryReader(Stream stream, Encoding encoding, Endian endian) : base(stream, encoding) { CurrentEndian = endian; }
/// <summary> /// Constructor. Uses UTF-8 by default for character encoding. /// </summary> /// <param name="stream">The <see cref="Stream"/> to wrap within this EndianBinaryReader.</param> /// <param name="endian">The <see cref="Endian"/> to use when reading files..</param> public EndianBinaryReader(Stream stream, Endian endian) : base(stream) { CurrentEndian = endian; }
public void Deserialize(Stream input) { var magic = input.ReadValueU32(); if (magic != 0xBEEFFEED) { throw new FormatException("not an asm file"); } var endian = magic == 0xBEEFFEED ? Endian.Little : Endian.Big; var version = input.ReadValueU16(endian); if (version != 11) { throw new FormatException("unsupported asm version " + this._Version); } var containerCount = input.ReadValueU16(); var allocatorTypeCount = version < 8 ? 0 : input.ReadValueU32(endian); var allocatorTypes = new Asm.TypeId[allocatorTypeCount]; for (uint i = 0; i < allocatorTypeCount; i++) { var name = input.ReadStringU16(0x40, Encoding.ASCII, endian); var id = input.ReadValueU8(); allocatorTypes[i] = new Asm.TypeId(name, id); } var primitiveTypeCount = version < 8 ? 0 : input.ReadValueU32(endian); var primitiveTypes = new Asm.TypeId[allocatorTypeCount]; for (uint i = 0; i < primitiveTypeCount; i++) { var name = input.ReadStringU16(0x40, Encoding.ASCII, endian); var id = input.ReadValueU8(); primitiveTypes[i] = new Asm.TypeId(name, id); } var containerTypeCount = version < 8 ? 0 : input.ReadValueU32(endian); var containerTypes = new Asm.TypeId[allocatorTypeCount]; for (uint i = 0; i < containerTypeCount; i++) { var name = input.ReadStringU16(0x40, Encoding.ASCII, endian); var id = input.ReadValueU8(); containerTypes[i] = new Asm.TypeId(name, id); } var containers = new Asm.ContainerEntry[containerCount]; for (ushort i = 0; i < containerCount; i++) { var container = new Asm.ContainerEntry(); container.Deserialize(input, this._Version, endian); containers[i] = container; } this._Endian = endian; this._Version = version; this._AllocatorTypes.Clear(); this._AllocatorTypes.AddRange(allocatorTypes); this._PrimitiveTypes.Clear(); this._PrimitiveTypes.AddRange(primitiveTypes); this._ContainerTypes.Clear(); this._ContainerTypes.AddRange(containerTypes); this._Containers.Clear(); this._Containers.AddRange(containers); }
public BlamScriptGenerator(ScriptTable scripts, OpcodeLookup opcodes, Endian endian) { _endian = endian; _scripts = scripts; _opcodes = opcodes; }
// llllllll llllllll llllllll llllllll // iiiiiiii iiiiiiii iiiiiiii iiiiiiii // uuuuuuuu uuuuuuuu uuuuuuuu uuuuuuss // ???????? ???????? ???????? ???????? // oocccccc cccccccc cccccccc cccccccc // oooooooo oooooooo oooooooo oooooooo // [l] lower 32 bits of hash = 32 bits // [i] upper 32 bits of hash = 32 bits // [s] compression scheme = 2 bits // [u] uncompressed size = 30 bits // [?] unknown = 32 bits // [o] offset = 34 bits // [c] compressed size = 30 bits public void Serialize(Stream output, Entry entry, Endian endian) { throw new NotImplementedException(); }
public void Deserialize(Stream input) { const Endian endian = Endian.Little; var unknownType1 = new type1 { unknown1 = new type2[input.ReadValueU32(endian)] }; //count for (uint i = 0; i < unknownType1.unknown1.Length; i++) { var unknownType2 = new type2 { unknown1 = input.ReadValueU32(endian), //unknown0 unknown2 = ReadString(input, endian), //unknown1 unknown3 = new type3[input.ReadValueU32(endian)] //unknown2 }; for (uint j = 0; j < unknownType2.unknown3.Length; j++) { unknownType2.unknown3[j] = new type3 { unknown1 = input.ReadValueU32(endian), //unknown3 unknown2 = ReadString(input, endian) //unknown4 }; } unknownType2.unknown4 = new type4[input.ReadValueU32(endian)]; //unknown5 for (uint j = 0; j < unknownType2.unknown4.Length; j++) { unknownType2.unknown4[j] = new type4 { unknown1 = input.ReadValueU32(endian), //unknown6 unknown2 = input.ReadValueU32(endian), //unknown7 unknown3 = ReadString(input, endian) //unknown8 }; } unknownType2.unknown5 = new type5[input.ReadValueU32(endian)]; //unknown9 for (uint j = 0; j < unknownType2.unknown5.Length; j++) { unknownType2.unknown5[j] = new type5 { unknown1 = input.ReadValueU32(endian), //unknown10 unknown2 = ReadString(input, endian) //unknown11 }; } unknownType2.unknown6 = new type6[input.ReadValueU32(endian)]; //unknown12 for (uint j = 0; j < unknownType2.unknown6.Length; j++) { unknownType2.unknown6[j] = new type6 { unknown1 = input.ReadValueU32(endian), //unknown13 unknown2 = ReadString(input, endian) //unknown14 }; } unknownType2.unknown7 = ReadString(input, endian); //unknown15 unknownType2.unknown8 = new type7[input.ReadValueU32(endian)]; //unknown16 for (uint j = 0; j < unknownType2.unknown8.Length; j++) { var unknownType7 = new type7 { unknown1 = ReadString(input, endian), //unknown17 unknown2 = input.ReadValueU32(endian), //unknown18 unknown3 = input.ReadValueU8(), //unknown19 unknown4 = new type8[input.ReadValueU32(endian)] //unknown20 }; for (uint k = 0; k < unknownType7.unknown4.Length; k++) { unknownType7.unknown4[k] = new type8 { unknown1 = input.ReadValueF32(endian), //unknown21 unknown2 = input.ReadValueF32(endian), //unknown22 unknown3 = input.ReadValueF32(endian), //unknown23 unknown4 = input.ReadValueF32(endian), //unknown24 unknown5 = input.ReadValueU32(endian), //unknown25 unknown6 = input.ReadValueU8(), //unknown26 unknown7 = input.ReadValueF32(endian), //unknown27 unknown8 = input.ReadValueF32(endian), //unknown28 unknown9 = input.ReadValueF32(endian), //unknown29 unknown10 = input.ReadValueF32(endian), //unknown30 unknown11 = input.ReadValueU32(endian), //unknown31 unknown12 = input.ReadValueU32(endian), //unknown32 unknown13 = input.ReadValueU32(endian), //unknown33 unknown14 = input.ReadValueU32(endian), //unknown34 unknown15 = input.ReadValueU8() //unknown35 }; } unknownType7.unknown5 = new type9[input.ReadValueU32(endian)]; //unknown36 for (uint k = 0; k < unknownType7.unknown5.Length; k++) { var unknownType9 = new type9 { unknown1 = input.ReadValueU32(endian), //unknown37 unknown2 = input.ReadValueU8(), //unknown38 unknown3 = new type10[input.ReadValueU32(endian)] //unknown39 }; for (uint l = 0; l < unknownType9.unknown3.Length; l++) { unknownType9.unknown3[l] = new type10 { unknown1 = input.ReadValueF32(endian), //unknown40 unknown2 = input.ReadValueF32(endian), //unknown41 unknown3 = input.ReadValueF32(endian), //unknown42 unknown4 = input.ReadValueF32(endian), //unknown43 unknown5 = input.ReadValueF32(endian), //unknown44 unknown6 = input.ReadValueF32(endian), //unknown45 unknown7 = input.ReadValueF32(endian), //unknown46 unknown8 = input.ReadValueF32(endian), //unknown47 unknown9 = input.ReadValueF32(endian), //unknown48 unknown10 = input.ReadValueF32(endian), //unknown49 unknown11 = input.ReadValueU32(endian), //unknown50 unknown12 = input.ReadValueU8(), //unknown51 unknown13 = input.ReadValueF32(endian), //unknown52 unknown14 = input.ReadValueF32(endian), //unknown53 unknown15 = input.ReadValueF32(endian), //unknown54 unknown16 = input.ReadValueF32(endian), //unknown55 unknown17 = input.ReadValueF32(endian), //unknown56 unknown18 = input.ReadValueF32(endian), //unknown57 unknown19 = input.ReadValueF32(endian), //unknown58 unknown20 = input.ReadValueF32(endian), //unknown59 unknown21 = input.ReadValueU8() //unknown60 }; } unknownType7.unknown5 [k] = unknownType9; } unknownType7.unknown6 = new type11[input.ReadValueU32(endian)]; //unknown61 for (uint k = 0; k < unknownType7.unknown6.Length; k++) { var unknownType11 = new type11 { unknown1 = input.ReadValueU32(endian), //unknown62 unknown2 = input.ReadValueU8(), //unknown63 unknown3 = new type8[input.ReadValueU32(endian)] //unknown64 }; for (uint l = 0; l < unknownType11.unknown3.Length; l++) { unknownType11.unknown3[l] = new type8 { unknown1 = input.ReadValueF32(endian), //unknown21 unknown2 = input.ReadValueF32(endian), //unknown22 unknown3 = input.ReadValueF32(endian), //unknown23 unknown4 = input.ReadValueF32(endian), //unknown24 unknown5 = input.ReadValueU32(endian), //unknown25 unknown6 = input.ReadValueU8(), //unknown26 unknown7 = input.ReadValueF32(endian), //unknown27 unknown8 = input.ReadValueF32(endian), //unknown28 unknown9 = input.ReadValueF32(endian), //unknown29 unknown10 = input.ReadValueF32(endian), //unknown30 unknown11 = input.ReadValueU32(endian), //unknown31 unknown12 = input.ReadValueU32(endian), //unknown32 unknown13 = input.ReadValueU32(endian), //unknown33 unknown14 = input.ReadValueU32(endian), //unknown34 unknown15 = input.ReadValueU8() //unknown35 }; } unknownType7.unknown6 [k] = unknownType11; } unknownType7.unknown7 = new type13[input.ReadValueU32(endian)]; //unknown65 for (uint k = 0; k < unknownType7.unknown7.Length; k++) { unknownType7.unknown7[k] = new type13 { unknown1 = input.ReadValueU32(endian), //unknown66 unknown2 = input.ReadValueU32(endian) //unknown67 }; } unknownType2.unknown8 [j] = unknownType7; } unknownType1.unknown1 [i] = unknownType2; } this.result = unknownType1; }
public void Serialize(IBlock parent, Stream output, Endian endian) { }
internal void WriteGlobalConfig(Encoding encoding, Endian endian) { WriteByte((byte)(((int)encoding << 4) | (int)endian)); }
///<summary> /// Creates a BinaryReader backed by a file (RO) ///</summary> /// <param name="file"></param> /// <param name="endian"></param> public EndianBinaryReader(string file, Endian endian = Endian.Little) : base(File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read)) { Endian = endian; }