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)
{
}
