public void Question_5_1_BasicCases() { int n = BinaryHelpers.IntFromBinary("11111111"); int m = BinaryHelpers.IntFromBinary("101"); int i = 2; int j = 4; int expected = BinaryHelpers.IntFromBinary("11110111"); Validate(expected, n, m, i, j); i = 0; j = 2; expected = BinaryHelpers.IntFromBinary("11111101"); Validate(expected, n, m, i, j); n = BinaryHelpers.IntFromBinary("10101010"); m = BinaryHelpers.IntFromBinary("1000"); j = 3; expected = BinaryHelpers.IntFromBinary("10101000"); Validate(expected, n, m, i, j); i = 4; j = 7; expected = BinaryHelpers.IntFromBinary("10001010"); Validate(expected, n, m, i, j); }
private void SaveFriction(float[][] ret) { try { var fileName = GetFrictionFileName(this.SaveResultFileName); var dirName = Path.GetDirectoryName(fileName); if (!Directory.Exists(dirName)) { Directory.CreateDirectory(dirName); } BinaryHelpers.ExecuteWriter((writer) => { for (int i = 0; i < ret.Length; i++) { for (int j = 0; j < ret[i].Length; j++) { writer.Write(ret[i][j]); } } }, fileName); } catch (IOException e) { throw new XTMFRuntimeException("Unable to save distribution cache file!\r\n" + e.Message); } }
protected override DxfObject PostParse() { foreach (var a in _objectIdsA) { ObjectIds.Add(a); } foreach (var b in _objectIdsB) { ObjectIds.Add(b); } foreach (var c in _objectIdsC) { ObjectIds.Add(c); } foreach (var d in _objectIdsD) { ObjectIds.Add(d); } _objectIdsA.Clear(); _objectIdsB.Clear(); _objectIdsC.Clear(); _objectIdsD.Clear(); ObjectData = BinaryHelpers.CombineBytes(_binaryObjectBytes); _binaryObjectBytes.Clear(); return(this); }
public void Init() { while (true) { UnityExecutables = GetUnityExecutablePath().Select(p => new UnityBinary(p)); bool quitRequested = false; var choices = UnityExecutables.Select(e => new ConsoleChoice { ChoiceDescription = e.ExecutableVersionString, ChoiceAction = () => UnityExecutable = e }).ToList(); ConsoleHelpers.MultipleChoice(choices, () => quitRequested = true); if (quitRequested) { break; } //replace with FindRegion here UnityVersionContainer currentVersion = FindRegionBytesByVersion(UnityExecutable.ExecutableVersion); //RegionBytes = UnityExecutable.ExecutableVersion >= UnityBinaryVersion.UNITY_2018_3_0 ? RegionBytes_2018_3 : RegionBytes_Pre2018_3; //JumpInstructionOffset = UnityExecutable.ExecutableVersion >= UnityBinaryVersion.UNITY_2018_3_0 ? JumpInstructionOffsetVersionB : JumpInstructionOffsetVersionA; PatchableByteAddress = BinaryHelpers.FindJumpInstructionAddress(UnityExecutable.ExecutablePath, currentVersion.RegionByteArray, currentVersion.InstructionOffset); PatchableByteValue = GetPatchableByteValue(currentVersion); if (PatchableByteValue == currentVersion.DarkSkinIndicator) { ConsoleHelpers.YesNoChoice("Revert to light skin?", () => PatchExecutable(currentVersion.LightSkinIndicator)); } else { ConsoleHelpers.YesNoChoice("Apply dark skin patch?", () => PatchExecutable(currentVersion.DarkSkinIndicator)); } } }
private void ProcessCarList(Chunk chunk) { var newSize = chunk.Size - Reader.AlignToBoundary(0x10); if (newSize % 0xD0 != 0) { throw new InvalidDataException("Malformed car list chunk"); } Progress?.Report("Processing car list"); while (Stream.Position < chunk.EndOffset) { var cti = BinaryHelpers.ReadStruct <CarTypeInfo>(Reader); //Debug.WriteLine("{0} {1} ({2})", cti.ManufacturerName, cti.BaseModelName, cti.UsageType); var acr = new AaronCarRecord(); acr.BaseModelName = cti.BaseModelName; acr.CarTypeName = cti.CarTypeName; acr.ManufacturerName = cti.ManufacturerName; acr.DefaultBasePaint = cti.DefaultBasePaint; acr.DefaultSkinNumber = cti.DefaultSkinNumber; acr.Skinnable = cti.Skinnable; acr.UsageType = cti.UsageType; _carService.AddCar(acr); HashResolver.Add(cti.CarTypeNameHash, cti.CarTypeName); } this.GenerateHashes(); }
private static void BlockDecompress(Stream stream, byte[] outData) { while (stream.Position < stream.Length) { var header = BinaryHelpers.ReadStruct <CIPHeader>(stream); if (header.Magic != 0x55441122) { throw new InvalidDataException($"Invalid magic! Expected 0x55441122, got 0x{header.Magic:X8}"); } var data = new byte[header.CSize - 24]; var decompressed = new byte[header.USize]; if (stream.Read(data, 0, data.Length) != data.Length) { throw new InvalidDataException($"Failed to read {data.Length} bytes from stream"); } Compressor.Decompress(data, decompressed); Array.ConstrainedCopy( decompressed, 0, outData, header.UPos, decompressed.Length); } }
private void ProcessCarInfoArrayChunk(Chunk chunk, BinaryReader reader) { int alignedSize = chunk.GetAlignedSize(0x10); if (alignedSize % 0xD0 != 0) { throw new ChunkCorruptedException("CarTypeInfoArray is malformed!"); } reader.AlignToBoundary(0x10); for (int i = 0; i < alignedSize / 0xD0; i++) { CarTypeInfo carTypeInfo = BinaryHelpers.ReadStruct <CarTypeInfo>(reader); CarRecord carRecord = new CarRecord { BaseModelName = carTypeInfo.BaseModelName, CarTypeName = carTypeInfo.CarTypeName, DefaultBasePaint = carTypeInfo.DefaultBasePaint, DefaultSkinNumber = carTypeInfo.DefaultSkinNumber, GeometryFilename = carTypeInfo.GeometryFilename, ManufacturerName = carTypeInfo.ManufacturerName, MemoryType = (CarMemoryType)carTypeInfo.CarMemTypeHash, Skinnable = carTypeInfo.Skinnable, UsageType = carTypeInfo.UsageType }; Database.CarRecordManager.AddCarRecord(carRecord); } }
private void SaveFriction(float[][] ret) { try { var fileName = GetFrictionFileName(SaveFrictionFileName, -1); var dirName = Path.GetDirectoryName(fileName); if (dirName == null) { throw new XTMFRuntimeException(this, $"In {Name} we were unable to get the directory name from the file {fileName}!"); } if (!Directory.Exists(dirName)) { Directory.CreateDirectory(dirName); } BinaryHelpers.ExecuteWriter(writer => { for (int i = 0; i < ret.Length; i++) { for (int j = 0; j < ret[i].Length; j++) { writer.Write(ret[i][j]); } } }, fileName); } catch (IOException e) { throw new XTMFRuntimeException(this, "Unable to save distribution cache file!\r\n" + e.Message); } }
public Input(string prevTxHash, UInt32 outpointIndex, UInt32 index, UInt32 sequence = 0xFFFFFFFF) { PrevTransactionHashBytes = BinaryHelpers.HexToByteArray(prevTxHash).Reverse().ToArray(); OutpointIndex = outpointIndex; Index = index; Sequence = sequence; ScriptSig = new Script(new byte[] { }); }
public static Addr FromWire(Wire.Network.Addr wire) { return(new Addr { EndPoint = new IPEndPoint( new IPAddress(BinaryHelpers.PackUInt64(wire.Ip)), (ushort)wire.Port) }); }
/// <summary> /// Generates an alignment (null-filled) chunk to align the stream to the given byte boundary. /// </summary> /// <param name="boundary">The desired alignment.</param> public void AlignmentChunk(uint boundary) { if (_stream.Position % boundary != 0) { BeginChunk(0); BinaryHelpers.AlignStream(_stream, boundary); EndChunk(); } }
private void ProcessAttributes(Chunk chunk) { trackedUnknownAttributes.Clear(); Progress?.Report("Processing attributes table"); while (Stream.Position < chunk.EndOffset) { var carPartAttribute = BinaryHelpers.ReadStruct <CarPartAttribute>(Reader); _attributes.Add(carPartAttribute); } }
private void ProcessPresetCars(Chunk chunk) { Progress?.Report("Processing preset cars"); while (Stream.Position < chunk.EndOffset) { var fePresetCar = BinaryHelpers.ReadStruct <FEPresetCar>(Reader); _presetCarService.AddPresetCar(PresetConverter.ConvertFeToAaronPresetCar(fePresetCar)); } }
protected override DxfEntity PostParse() { GraphicsData = BinaryHelpers.CombineBytes(_graphicsDataBytes); _graphicsDataBytes.Clear(); EntityData = BinaryHelpers.CombineBytes(_entityDataBytes); _entityDataBytes.Clear(); return(this); }
public static void Load() { if (!File.Exists(GameConts.ScoreLocation)) { return; } Scores = BinaryHelpers.ReadFromBinaryFile <Scores>(GameConts.ScoreLocation); Scores.Score = Scores.Score.OrderByDescending(x => x.TimeTookMs) /*.ThenByDescending(x => x.AcScore)*/.ToList(); }
public void ByteArrayToHex() { foreach (var tuple in testCases) { var bytes = tuple.Item2; var expectedHex = tuple.Item1.ToLower(); var actualHex = BinaryHelpers.ByteArrayToHex(bytes); Assert.AreEqual(expectedHex, actualHex); } }
public void HexToByteArray() { foreach (var tuple in testCases) { var hex = tuple.Item1; var expectedBytes = tuple.Item2; var actualBytes = BinaryHelpers.HexToByteArray(hex); Assert.AreEqual(expectedBytes, actualBytes); } }
public void TestBufferRoundTrip() { var marshalled = BinaryHelpers.MarshalStruct(BenchmarkStructure); var unmarshalledStructure = BinaryHelpers.BufferToStructure <SimpleStructure>(marshalled); Assert.AreEqual(BenchmarkStructure.StringValue, unmarshalledStructure.StringValue); Assert.AreEqual(BenchmarkStructure.IntValue, unmarshalledStructure.IntValue); Assert.AreEqual(BenchmarkStructure.FloatValue, unmarshalledStructure.FloatValue); CollectionAssert.AreEqual(BenchmarkStructure.ByteArray, unmarshalledStructure.ByteArray); }
protected internal override IEnumerable <DxfCodePair> GetSpecificPairs(DxfAcadVersion version, bool outputHandles, HashSet <IDxfItem> writtenItems) { yield return(new DxfCodePair(90, RawData.Length)); // write lines in 128-byte chunks (expands to 256 hex bytes) foreach (var chunk in BinaryHelpers.ChunkBytes(RawData)) { yield return(new DxfCodePair(310, chunk)); } }
public async override Task <Transaction> GetTransactionAsync(Transaction.Info info) { var json = JToken.Parse(await SendRPCAsync("blockchain.transaction.get", info.Hash, info.Height)); var rawTx = BinaryHelpers.HexToByteArray(json["result"].Value <string>()); var tx = new Transaction(info.Height); tx.ReadPayload(new BinaryReader(new MemoryStream(rawTx))); return(tx); }
/// <summary> /// Reads a compressed-in-place file. This involves reading a header and then /// proceeding to a shared routine for decompression. /// </summary> /// <param name="stream"></param> /// <returns></returns> public static byte[] ReadBlockFile(Stream stream) { var br = new BinaryReader(stream); var fileHeader = BinaryHelpers.ReadStruct <CIPFileHeader>(br); if (fileHeader.Magic != 0x66113388) { throw new InvalidDataException("Invalid header"); } return(ReadCompressedBlocks(stream, fileHeader.USize)); }
public Wire.Network.Addr ToWire() { byte[] ipPadded = new byte[8]; byte[] ipBytes = EndPoint.Address.GetAddressBytes(); Array.Copy(ipBytes, ipPadded, ipBytes.Length); return(new Wire.Network.Addr { Ip = BinaryHelpers.UnpackUInt64(ipPadded), Port = (ushort)EndPoint.Port }); }
public static byte[] WithHeader(byte[] message) { int i = BinaryHelpers.VarIntSize(message.Length); byte[] nmsg = new byte[message.Length + i]; //Support.WriteToArray(nmsg, message.Length, 0); BinaryHelpers.WriteVarInt(nmsg, 0, message.Length); Array.Copy(message, 0, nmsg, i, message.Length); Debug.WriteLine($"Compression: {nmsg.Length}/{Compress(nmsg, Compression.int16).Length}/{Compress(nmsg, Compression.int32).Length}/{Compress(nmsg, Compression.int64).Length}"); Debug.WriteLine($"Matches: {Support.ArraysEqual(nmsg, Decompress(Compress(nmsg)))}"); return(nmsg); }
public byte[] GetSharedSecret(byte[] pK) { BitReader reader = new BitReader(pK); byte[] x = reader.ReadByteArray(); Point remotePublic = new Point( new BigInteger(x), new BigInteger(reader.ReadByteArray(pK.Length - BinaryHelpers.VarIntSize(x.Length) - x.Length)) ); return(curve.Multiply(remotePublic, priv).X.ToByteArray()); // Use the x-coordinate as the shared secret }
public void LoadData() { BinaryHelpers.ExecuteReader(this, (reader) => { var matrix = new EmmeMatrix(reader); if (matrix.Dimensions != 2) { throw new XTMFRuntimeException(this, "In '" + Name + "' the matrix loaded in from '" + MatrixFile + "' was not an OD binary matrix!"); } Data = SparseTwinIndex <float> .CreateSquareTwinIndex(matrix.Indexes[0], matrix.Indexes[1], matrix.FloatData); Loaded = true; }, MatrixFile); }
private static void CopyMatrix(IZone[] zones, string origin, string destination) { try { BinaryHelpers.ExecuteReader((reader => { var matrix = new EmmeMatrix(reader); SaveData.SaveMatrix(zones, matrix.FloatData, destination); }), origin); } catch (IOException) { } }
/// <summary> /// Sets the value of the patch byte in the Unity executable. /// </summary> private void PatchExecutable(byte b) { try { FileHelpers.CreateFileBackup(UnityExecutable.ExecutablePath); BinaryHelpers.WriteByteToAddress(UnityExecutable.ExecutablePath, b, PatchableByteAddress); ConsoleHelpers.WriteLine("Patch applied successfully", ConsoleColor.Green); Init(); } catch { ConsoleHelpers.ExitOnInput("Failed to write changes to file, make sure you have write permission", ConsoleColor.Red); } }
public void TestStreamRoundTrip() { using var ms = new MemoryStream(); BinaryHelpers.WriteStruct(ms, BenchmarkStructure); ms.Position = 0; Assert.AreEqual(ms.Length, Marshal.SizeOf <SimpleStructure>()); var unmarshalledStructure = BinaryHelpers.ReadStruct <SimpleStructure>(ms); Assert.AreEqual(BenchmarkStructure.StringValue, unmarshalledStructure.StringValue); Assert.AreEqual(BenchmarkStructure.IntValue, unmarshalledStructure.IntValue); Assert.AreEqual(BenchmarkStructure.FloatValue, unmarshalledStructure.FloatValue); CollectionAssert.AreEqual(BenchmarkStructure.ByteArray, unmarshalledStructure.ByteArray); }
/// <summary> /// The sample rate is read from the flac header here. /// This can be extracted from bits 145-164 of the stream. /// More information: https://xiph.org/flac/format.html#metadata_block_streaminfo. /// </summary> /// <param name="stream">The flac file stream.</param> /// <returns>The sample rate.</returns> public static Fin <uint> ReadSampleRate(Stream stream) { long position = stream.Seek(SampleRateOffset, SeekOrigin.Begin); Debug.Assert(position == 18, $"Expected stream.Seek position to return 18, instead returned {position}"); Span <byte> buffer = stackalloc byte[3]; int bytesRead = stream.Read(buffer); if (bytesRead != buffer.Length) { return(FileTooShort); } return(BinaryHelpers.Read20BitUnsignedBigEndianIgnoringLastNibble(buffer)); }
/// <summary> /// The number of channels is read from the flac header here. /// This can be extracted from bits 165-167 of the stream. /// More information: https://xiph.org/flac/format.html#metadata_block_streaminfo. /// </summary> /// <param name="stream">The flac file stream.</param> /// <returns>The number of channels.</returns> public static Fin <byte> ReadNumChannels(Stream stream) { long position = stream.Seek(ChannelOffset, SeekOrigin.Begin); Debug.Assert(position == 20, $"Expected stream.Seek position to return 20, instead returned {position}"); Span <byte> buffer = stackalloc byte[1]; int bytesRead = stream.Read(buffer); if (bytesRead != buffer.Length) { return(FileTooShort); } return((byte)(BinaryHelpers.Read3BitUnsignedBigEndianIgnoringFirstFourAndLastBit(buffer) + 1)); }