/// <summary> /// Drains decoder by reading all bytes which are ready. /// </summary> /// <param name="decoder">The decoder instance.</param> /// <param name="target">Target buffer.</param> /// <param name="targetOffset">Offset within target buffer.</param> /// <param name="offset">Offset in decoder relatively to decoder's head. This should be a negative value.</param> /// <param name="length">Number of bytes.</param> public static unsafe void Drain(this ILZ4Decoder decoder, byte[] target, int targetOffset, int offset, int length) { fixed(byte *targetPtr = target) { decoder.Drain(targetPtr + targetOffset, offset, length); } }
/// <summary>Drains decoder by reading all bytes which are ready.</summary> /// <param name="decoder">Decoder.</param> /// <param name="target">Target buffer.</param> /// <param name="offset">Offset in decoder relatively to decoder's head. /// Please note, it should be negative value.</param> /// <param name="length">Number of bytes.</param> public static unsafe void Drain( this ILZ4Decoder decoder, Span <byte> target, int offset, int length) { fixed(byte *targetP = target) decoder.Drain(targetP, offset, length); }
public static unsafe void Drain( this ILZ4Decoder decoder, byte[] target, int targetIndex, int offset, int length) { fixed(byte *targetP = target) decoder.Drain(targetP + targetIndex, offset, length); }
private void ReadFrame() { FlushPeek(); var magic = TryPeek32(); if (magic != 0x184D2204) { throw MagicNumberExpected(); } FlushPeek(); var FLG_BD = Peek16(); var FLG = FLG_BD & 0xFF; var BD = (FLG_BD >> 8) & 0xFF; var version = (FLG >> 6) & 0x11; if (version != 1) { throw UnknownFrameVersion(version); } var blockChaining = ((FLG >> 5) & 0x01) == 0; var blockChecksum = ((FLG >> 4) & 0x01) != 0; var hasContentSize = ((FLG >> 3) & 0x01) != 0; var contentChecksum = ((FLG >> 2) & 0x01) != 0; var hasDictionary = (FLG & 0x01) != 0; var blockSizeCode = (BD >> 4) & 0x07; var contentLength = hasContentSize ? (long?)Peek64() : null; var dictionaryId = hasDictionary ? (uint?)Peek32() : null; var actualHC = (byte)(XXH32.DigestOf(_buffer16, 0, _index16) >> 8); var expectedHC = Peek8(); if (actualHC != expectedHC) { throw InvalidHeaderChecksum(); } var blockSize = MaxBlockSize(blockSizeCode); if (hasDictionary) { throw NotImplemented( "Predefined dictionaries feature is not implemented"); // Write32(dictionaryId); } // ReSharper disable once ExpressionIsAlwaysNull _frameInfo = new LZ4Descriptor( contentLength, contentChecksum, blockChaining, blockChecksum, dictionaryId, blockSize); _decoder = _decoderFactory(_frameInfo); _buffer = new byte[blockSize]; }
/// <summary>Decodes data and immediately drains it into target buffer.</summary> /// <param name="decoder">Decoder.</param> /// <param name="source">Source buffer (with compressed data, to be decoded).</param> /// <param name="target">Target buffer (to drained into).</param> /// <param name="decoded">Number of bytes actually decoded.</param> /// <returns><c>true</c> decoder was drained, <c>false</c> otherwise.</returns> public static unsafe bool DecodeAndDrain( this ILZ4Decoder decoder, ReadOnlySpan <byte> source, Span <byte> target, out int decoded) { fixed(byte *sourceP = source) fixed(byte *targetP = target) return(decoder.DecodeAndDrain( sourceP, source.Length, targetP, target.Length, out decoded)); }
/// <summary>Decodes data and immediately drains it into target buffer.</summary> /// <param name="decoder">Decoder.</param> /// <param name="source">Source buffer (with compressed data, to be decoded).</param> /// <param name="sourceOffset">Offset within source buffer.</param> /// <param name="sourceLength">Source buffer length.</param> /// <param name="target">Target buffer (to drained into).</param> /// <param name="targetOffset">Offset within target buffer.</param> /// <param name="targetLength">Target buffer length.</param> /// <param name="decoded">Number of bytes actually decoded.</param> /// <returns><c>true</c> decoder was drained, <c>false</c> otherwise.</returns> public static unsafe bool DecodeAndDrain( this ILZ4Decoder decoder, byte[] source, int sourceOffset, int sourceLength, byte[] target, int targetOffset, int targetLength, out int decoded) { fixed(byte *sourceP = source) fixed(byte *targetP = target) return(decoder.DecodeAndDrain( sourceP + sourceOffset, sourceLength, targetP + targetOffset, targetLength, out decoded)); }
private void ReadFrame() { Read0(); var magic = TryRead32(); if (magic != 0x184D2204) { throw MagicNumberExpected(); } Read0(); var FLG_BD = Read16(); var FLG = FLG_BD & 0xFF; var BD = (FLG_BD >> 8) & 0xFF; var version = (FLG >> 6) & 0x11; if (version != 1) { throw UnknownFrameVersion(version); } var blockChaining = ((FLG >> 5) & 0x01) == 0; var blockChecksum = ((FLG >> 4) & 0x01) != 0; var hasContentSize = ((FLG >> 3) & 0x01) != 0; var contentChecksum = ((FLG >> 2) & 0x01) != 0; var blockSizeCode = (BD >> 4) & 0x07; var contentLength = hasContentSize ? (long?)Read64() : null; var actualHC = (byte)(XXH32.DigestOf(_buffer16, 0, _index16) >> 8); var expectedHC = Read8(); if (actualHC != expectedHC) { throw InvalidHeaderChecksum(); } var blockSize = MaxBlockSize(blockSizeCode); _frameInfo = new LZ4FrameInfo(contentLength, contentChecksum, blockChaining, blockChecksum, blockSize); _decoder = _decoderFactory(_frameInfo); _buffer = new byte[blockSize]; }
private void ReadFrame() { Read0(); uint? magic = TryRead32(); if (magic != 0x184D2204) throw new InvalidDataException(RS.ExpectLZ4MagicNumber); Read0(); ushort flgBd = Read16(); int flg = flgBd & 0xFF; int bd = (flgBd >> 8) & 0xFF; int version = (flg >> 6) & 0x11; if (version != 1) throw new InvalidDataException(string.Format(RS.LZ4VersionNotSupported, version)); bool blockChaining = ((flg >> 5) & 0x01) == 0; bool blockChecksum = ((flg >> 4) & 0x01) != 0; bool hasContentSize = ((flg >> 3) & 0x01) != 0; bool contentChecksum = ((flg >> 2) & 0x01) != 0; bool hasDictionary = (flg & 0x01) != 0; int blockSizeCode = (bd >> 4) & 0x07; long? contentLength = hasContentSize ? (long?) Read64() : null; uint? dictionaryId = hasDictionary ? (uint?) Read32() : null; byte actualHC = (byte)(XXHash32.DigestOf(_buffer16, 0, _index16) >> 8); byte expectedHC = Read8(); if (actualHC != expectedHC) throw new InvalidDataException(RS.BadLZ4FrameHeaderChecksum); int blockSize = MaxBlockSize(blockSizeCode); if (hasDictionary) { // Write32(dictionaryId); throw new NotImplementedException(string.Format(RS.FeatureNotImplementedInType, "Predefined Dictionaries", GetType().Name)); } _frameInfo = new LZ4FrameDescriptor(contentLength, contentChecksum, blockChaining, blockChecksum, dictionaryId, blockSize); _decoder = _decoderFactory(_frameInfo); _buffer = new byte[blockSize]; }
/// <summary> /// Decodes data and immediately drains it into target buffer. /// </summary> /// <param name="decoder">The decoder instance.</param> /// <param name="source">Source buffer (with compressed data, to be decoded).</param> /// <param name="sourceLength">Source buffer length.</param> /// <param name="target">Target buffer (to drained into).</param> /// <param name="targetLength">Target buffer length.</param> /// <param name="decoded">Number of bytes actually decoded.</param> /// <returns> /// `true` if the decoder was drained; otherwise, `false`. /// </returns> public static unsafe bool DecodeAndDrain(this ILZ4Decoder decoder, byte *source, int sourceLength, byte *target, int targetLength, out int decoded) { decoded = 0; if (sourceLength <= 0) { return(false); } decoded = decoder.Decode(source, sourceLength); if (decoded <= 0 || targetLength < decoded) { return(false); } decoder.Drain(target, -decoded, decoded); return(true); }
private void CloseFrame() { if (_decoder == null) return; try { _frameInfo = null; _buffer = null; // if you need any exceptions throw them here _decoder.Dispose(); } finally { _decoder = null; } }
/// <summary> /// Decodes previously compressed block and caches decompressed block in decoder. /// Returns number of bytes decoded. /// See <see cref="ILZ4Decoder.Decode"/>. /// </summary> /// <param name="decoder">Decoder.</param> /// <param name="buffer">Compressed block.</param> /// <param name="offset">Offset in compressed block.</param> /// <param name="length">Length of compressed block.</param> /// <param name="blockSize">Size of the block. Value <c>0</c> indicates default block size.</param> /// <returns>Number of decoded bytes.</returns> public static unsafe int Decode( this ILZ4Decoder decoder, byte[] buffer, int offset, int length, int blockSize = 0) { fixed(byte *bufferP = buffer) return(decoder.Decode(bufferP + offset, length, blockSize)); }
/// <summary> /// Inject already decompressed block and caches it in decoder. /// Used with uncompressed-yet-chained blocks and pre-made dictionaries. /// See <see cref="ILZ4Decoder.Inject"/>. /// </summary> /// <param name="decoder">Decoder.</param> /// <param name="buffer">Uncompressed block.</param> /// <param name="offset">Offset in uncompressed block.</param> /// <param name="length">Length of uncompressed block.</param> /// <returns>Number of decoded bytes.</returns> public static unsafe int Inject( this ILZ4Decoder decoder, byte[] buffer, int offset, int length) { fixed(byte *bufferP = buffer) return(decoder.Inject(bufferP + offset, length)); }