public void TestUInt64() { var rnd = new System.Random(); for (var c = 0; c < count; c++) { var mem = new byte[sizeof(UInt64) * writeRepeatCount]; var span1 = new SpanStream(mem); var span2 = new SpanStream(mem); var a = new UInt64[writeRepeatCount]; for (var i = 0; i < writeRepeatCount; i++) { var n = rnd.NextUInt64(); a[i] = n; span1.Write(n); } for (var i = 0; i < writeRepeatCount; i++) { var r = span2.ReadUInt64(); Assert.Equal(a[i], r); } } }
public void TestPosition() { var rnd = new Random(); for (var c = 0; c < count; c++) { var memSize = 10_000; var mem = new byte[memSize * 10]; var answer = new byte[memSize]; for (var i = 0; i < memSize; i++) { answer[i] = (byte)rnd.Next(0, 10); } var span1 = new SpanStream(mem); var span2 = new SpanStream(mem); for (var i = 0; i < memSize; i++) { span1.Position += answer[i]; span1.Write(answer[i]); } // Ensure span is not zero for (var i = 0; i < memSize; i++) { span2.Position += answer[i]; var r = span2.ReadByte(); Assert.Equal(answer[i], r); } } }
public void TestStreamReadWrite() { var rnd = new Random(); for (var c = 0; c < count; c++) { var memSize = rnd.Next(1, 10_000); var mem = new byte[(memSize + 4) * writeRepeatCount]; var answer = new byte[memSize * writeRepeatCount]; rnd.NextBytes(answer); for (var bc = 1; bc < writeRepeatCount; bc++) { for (var offset = 0; offset < bc; offset++) { var span1 = new SpanStream(mem); var span2 = new SpanStream(mem); span1.Write(answer, offset, bc - offset); var buffer = new byte[bc + offset]; span2.Read(buffer, offset, bc - offset); Assert.Equal(new Span <byte>(answer).Slice(offset, bc - offset).ToArray(), new Span <byte>(buffer).Slice(offset, bc - offset).ToArray()); } } Assert.Throws <ArgumentNullException>(() => { var s = new SpanStream(mem); s.Read(null, 0, 1); }); } }
public void TestSizedString() { var rnd = new Random(); for (var c = 0; c < count; c++) { var memSize = rnd.Next(0, 1024); var mem = new byte[(memSize + 4) * writeRepeatCount * 4]; var answer = new string[writeRepeatCount]; var span1 = new SpanStream(mem); var span2 = new SpanStream(mem); for (var i = 0; i < writeRepeatCount; i++) { var str = rnd.NextString("abcæøå诶 比西αβγ", memSize); answer[i] = str; span1.WriteSized(str); } for (var i = 0; i < writeRepeatCount; i++) { var r = span2.ReadSizedString(out var len); Assert.Equal(answer[i], r); } } }
public LeafBase(IServiceContainer ctx, SpanStream stream) { this.ctx = ctx; this.stream = stream; reader = LazyFactory.CreateLazy(() => new TypeDataReader(ctx, stream)); }
private unsafe void RefillMaster(ZwinderBuffer.StateInformation state) { var lengthHolder = 0; var lengthHolderSpan = new Span <byte>(&lengthHolder, 4); var zeldas = SpanStream.GetOrBuild(state.GetReadStream()); zeldas.Read(lengthHolderSpan); _masterLength = lengthHolder; fixed(byte *buffer_ = _master) { int *buffer = (int *)buffer_; while (zeldas.Read(lengthHolderSpan) == 4) { if ((lengthHolder & IS_GAP) != 0) { buffer += lengthHolder & ~IS_GAP; } else { zeldas.Read(new Span <byte>(buffer, lengthHolder * 4)); buffer += lengthHolder; } } } _masterFrame = state.Frame; }
private void SaveStateBodyBinary(BinaryWriter writer) { writer.Write(Count); for (var i = _firstStateIndex; i != _nextStateIndex; i = (i + 1) & STATEMASK) { writer.Write(_states[i].Frame); writer.Write(_states[i].Size); } if (Count != 0) { var startByte = _states[_firstStateIndex].Start; var endByte = (_states[HeadStateIndex].Start + _states[HeadStateIndex].Size) & _sizeMask; var destStream = SpanStream.GetOrBuild(writer.BaseStream); if (startByte > endByte) { _backingStore.Position = startByte; WaterboxUtils.CopySome(_backingStore, writer.BaseStream, Size - startByte); startByte = 0; } { _backingStore.Position = startByte; WaterboxUtils.CopySome(_backingStore, writer.BaseStream, endByte - startByte); } } }
public static T Deserilizer <T>(ReadOnlyMemory <byte> buffer) { using (var stream = new SpanStream(buffer)) { return(MessagePackSerializer.Deserialize <T>(stream)); } }
internal static EncryptionInfo ReadEncryptionInfo(ref SpanStream io) { bool? compressed = null; Cipher?cipher = null; byte[] seed = null; byte[] iv = null; Dictionary <string, object> kdf = null;
public LoadStateStream(Stream backingStore, long offset, long size, long mask) { _backingStore = backingStore; _backingStoreSS = SpanStream.GetOrBuild(backingStore); _offset = offset; _size = size; _mask = mask; }
/// <summary> /// /// </summary> /// <param name="backingStore">The ringbuffer to write into</param> /// <param name="offset">Offset into the buffer to start writing (and treat as position 0 in the stream)</param> /// <param name="mask">Buffer size mask, used to wrap values in the ringbuffer correctly</param> /// <param name="notifySize"> /// If the stream will exceed this size, notifySizeReached must be called before clobbering any data /// </param> /// <param name="notifySizeReached"> /// The callback that will be called when notifySize is about to be exceeded. Can either return a new larger notifySize, /// or abort processing with an IOException. This must fail if size is going to exceed buffer.Length, as nothing else /// is preventing that case. /// </param> public SaveStateStream(Stream backingStore, long offset, long mask, long notifySize, Func <long> notifySizeReached) { _backingStore = backingStore; _backingStoreSS = SpanStream.GetOrBuild(backingStore); _offset = offset; _mask = mask; _notifySize = notifySize; _notifySizeReached = notifySizeReached; }
public static Deserialize MakeD(Type type) { return((buffer) => { using (var st = new SpanStream(buffer)) { return Serializer.Deserialize(type, st); } }); }
internal static DatabaseInfo ParseHeader(SpanStream io, byte[] compositeKey) { var header = io.Read <Header>(); if (header.Signature1 != Magic1) { throw MakeInvalidFormatError($"primary file signature is invalid: {header.Signature1:x8}"); } if (!Magic2.Contains(header.Signature2)) { throw MakeInvalidFormatError($"secondary file signature is invalid: {header.Signature2:x8}"); } if (header.MajorVersion != Version4) { throw MakeUnsupportedError($"Version {header.MajorVersion}.{header.MinorVersion}"); } var info = ReadEncryptionInfo(ref io); var headerSize = io.Position; io.Rewind(); var headerBytes = io.ReadBytes(headerSize); var computedHash = Crypto.Sha256(headerBytes); var storedHash = io.ReadBytes(32); if (!Crypto.AreEqual(storedHash, computedHash)) { throw MakeInvalidFormatError("Header hash doesn't match"); } var storedHeaderMac = io.ReadBytes(32); var derivedKey = DeriveMasterKey(compositeKey, info.Kdf); var(encryptionKey, hmacKey) = Util.DeriveDatabaseKeys(derivedKey, info.Seed); var blockHmacKey = Util.ComputeBlockHmacKey(hmacKey, ulong.MaxValue); var computedHeaderMac = Crypto.HmacSha256(blockHmacKey, headerBytes); if (!Crypto.AreEqual(storedHeaderMac, computedHeaderMac)) { throw MakeInvalidFormatError("Header MAC doesn't match"); } return(new DatabaseInfo(headerSize: io.Position, isCompressed: info.IsCompressed, cipher: info.Cipher, encryptionKey: encryptionKey, iv: info.Iv, hmacKey: hmacKey)); }
internal static Deserialize MakeD(Type type) { dynamic dformatter = type.GetProperty("Parser", BindingFlags.Public | BindingFlags.Static)?.GetValue(null); return((buffer) => { using (var stream = new SpanStream(buffer)) { IMessage message = dformatter.ParseFrom(stream); return message; } }); }
public void TestLength() { var mem = new byte[100]; var ss = new SpanStream(mem); Assert.Equal(100, ss.Length); ss.SetLength(0); Assert.Equal(0, ss.Length); Assert.Equal(100, ss.MaxLength); ss.Write((UInt32)0); Assert.Equal(4, ss.Length); ss.Clear(); Assert.Equal(0, ss.Length); }
public void TestSize() { var rnd = new System.Random(); for (var c = 0; c < count; c++) { var mem = new byte[sizeof(UInt32) * writeRepeatCount]; var span1 = new SpanStream(mem); var span2 = new SpanStream(mem); var a = new UInt32[writeRepeatCount]; for (var i = 0; i < writeRepeatCount; i++) { var sr = rnd.Next(0, 4); uint n; switch (sr) { case 0: n = (UInt32)rnd.Next(0, 0b00111111); break; case 1: n = (UInt32)rnd.Next(0b01000000, 0b00111111_11111111); break; case 2: n = (UInt32)rnd.Next(0b01000000_00000000, 0b00111111_11111111_11111111); break; //case 3: default: n = (UInt32)rnd.Next(0b01000000_00000000_00000000, 0b00111111_11111111_11111111_11111111); break; } a[i] = n; span1.WriteSize(n); } for (var i = 0; i < writeRepeatCount; i++) { var r = span2.ReadSize(out var len); Assert.Equal(span2.MeasureWriteSize(a[i]), len); Assert.Equal(a[i], r); } } }
public void TestCanReadCanWrite() { var mem = new byte[2]; var s = new Span <byte>(mem); var ros = new ReadOnlySpan <byte>(mem); var ss = new SpanStream(s); Assert.True(ss.CanRead); Assert.True(ss.CanWrite); Assert.True(ss.CanSeek); var ross = new ReadOnlySpanStream(ros); Assert.True(ross.CanRead); Assert.False(ross.CanWrite); Assert.True(ross.CanSeek); }
// public delegate UIntPtr /*MissingFileResult*/ FileCallback(IntPtr userdata, UIntPtr /*string*/ name); public static WriteCallback MakeCallbackForWriter(Stream s) { var ss = SpanStream.GetOrBuild(s); return((_unused, data, size) => { try { var count = (int)size; ss.Write(new ReadOnlySpan <byte>((void *)data, (int)size)); return 0; } catch { return -1; } }); }
public static ReadCallback MakeCallbackForReader(Stream s) { var ss = SpanStream.GetOrBuild(s); return((_unused, data, size) => { try { var count = (int)size; var n = ss.Read(new Span <byte>((void *)data, count)); return Z.SS(n); } catch { return Z.SS(-1); } }); }
public void TestPosOverflow() { var mem = new byte[2]; { var s = new Span <byte>(mem); var ss = new SpanStream(s); ss.Position = mem.Length; Assert.Equal(mem.Length, ss.Position); ss.Position = 0; Assert.Equal(0, ss.Position); } Assert.Throws <ArgumentOutOfRangeException>(() => { var s = new Span <byte>(mem); var ss = new SpanStream(s); ss.Position = mem.Length + 1; }); }
public void TestSizedReadWriteReadOnlySpan() { var rnd = new Random(); for (var c = 0; c < count; c++) { var memSize = rnd.Next(1, 10_000); var mem = new byte[(memSize + 4) * writeRepeatCount + 10]; var answer = new byte[memSize * writeRepeatCount]; rnd.NextBytes(answer); var span1 = new SpanStream(mem); var span2 = new ReadOnlySpanStream(new ReadOnlySpan <byte>(mem)); span1.WriteSized(new Span <byte>(answer)); span1.Write(1234); var bytes = span2.ReadSizedBytes(out var length); Assert.Equal(answer, bytes); Assert.Equal(1234, span2.ReadInt32()); } }
public static Deserialize Deserialize <T>() where T : IMessage <T> { MessageParser <T> parser = typeof(T).GetProperty("Parser", BindingFlags.Public | BindingFlags.Static)?.GetValue(null) as MessageParser <T>; if (parser == null) { //todo throw new Exception(); } return((buffer) => { using (var stream = new SpanStream(buffer)) { IMessage message = parser.ParseFrom(stream); return message; } }); }
public void TestReadOnlySpan() { var rnd = new Random(); for (var c = 0; c < count; c++) { var memSize = rnd.Next(1, 10_000); var mem = new byte[(memSize + 4) * writeRepeatCount]; var answer = new byte[memSize * writeRepeatCount]; rnd.NextBytes(answer); var span1 = new SpanStream(mem); var span2 = new SpanStream(mem); for (var i = 0; i < writeRepeatCount; i++) { var a = new Span <byte>(answer).Slice(memSize * i, memSize); span1.Write(a); } // Ensure span is not zero var ac = 0; for (var wrc = 0; wrc < writeRepeatCount; wrc++) { var r = span2.ReadBytes(memSize); for (var i = 0; i < r.Length; i++) { Assert.Equal(answer[ac++], r[i]); } } Assert.Throws <ArgumentException>(() => { var s = new SpanStream(mem); s.Write(new Span <byte>(new byte[mem.Length + 1])); }); } }
public void TestGuid() { for (var c = 0; c < count; c++) { var mem = new byte[16 * writeRepeatCount]; var span1 = new SpanStream(mem); var span2 = new SpanStream(mem); var a = new Guid[writeRepeatCount]; for (var i = 0; i < writeRepeatCount; i++) { var n = Guid.NewGuid(); a[i] = n; span1.Write(n); } for (var i = 0; i < writeRepeatCount; i++) { var r = span2.ReadGuid(); Assert.Equal(a[i], r); } } }
static void Main() { byte[] data = File.ReadAllBytes("E:\\Temp\\st_ak_a101.png"); Memory <byte> mem = data; var stream = new SpanStream((ReadOnlyMemory <byte>)mem); _bufStream = new BufferStream(new byte[10], writable: false, publiclyVisible: true); using (var image = new MagickImage(stream)) { if (image.HasAlpha) { // Сначала нужно задать цвет фона. image.BackgroundColor = MagickColors.White; // Затем удалим 4-й канал - прозрачность. image.Alpha(AlphaOption.Remove); } var buf = new byte[5]; int n = _bufStream.Read(buf); var colors = image.TotalColors; image.FilterType = ImageMagick.FilterType.Lanczos; image.Resize(500, 0); //image.Quantize(new QuantizeSettings //{ // Colors = 256, // DitherMethod = DitherMethod.No //}); image.Write("E:\\Temp\\test.png", MagickFormat.Png8); } }
public void TestVLQInt32() { var rnd = new Random(); for (var c = 0; c < count; c++) { var memSize = rnd.Next(1, 10_000); var mem = new byte[memSize * SpanUtils.MeasureVLQ(UInt32.MaxValue) + 1]; var span1 = new SpanStream(mem); var span2 = new SpanStream(mem); var data = new Int32[memSize]; for (var i = 0; i < memSize; i++) { data[i] = rnd.NextInt32(); } for (var i = 0; i < memSize; i++) { span1.WriteVLQ(data[i]); } for (var i = 0; i < memSize; i++) { Assert.Equal(data[i], span2.ReadVLQInt32(out var len)); Assert.Equal(SpanUtils.MeasureVLQ(data[i]), len); } // Check overflow new Span <byte>(mem).Fill(0xFF); Assert.Throws <OverflowException>(() => { var span3 = new SpanStream(mem); span3.ReadVLQInt32(out _); }); } }
public S_BUILDINFO(IServiceContainer ctx, IModule mod, SpanStream stream) : base(ctx, mod, stream) { }
public S_DEFRANGE_FRAMEPOINTER_REL_FULL_SCOPE(IServiceContainer ctx, IModule mod, SpanStream stream) : base(ctx, mod, stream) { }
public S_GMANPROC(IServiceContainer ctx, IModule mod, SpanStream stream) : base(ctx, mod, stream) { }
public LF_MODIFIER_16t(IServiceContainer ctx, SpanStream stream) : base(ctx, stream) { }