private async Task <bool> AcquireNextChunkAsync()
{
do
{
ulong?rawVarint = await TryReadVarIntAsync().ConfigureAwait(false);
if (rawVarint == null)
{
return(false);
}
ulong varint = rawVarint.Value;
var flags = (ChunkFlags)varint;
var isCompressed = (flags & ChunkFlags.Compressed) != 0;
var originalLength = (int) await ReadVarIntAync().ConfigureAwait(false);
var compressedLength = isCompressed ? (int) await ReadVarIntAync().ConfigureAwait(false) : originalLength;
if (compressedLength > originalLength)
{
throw EndOfStream(); // corrupted
}
var compressed = new byte[compressedLength];
var chunk = await ReadBlockAsync(compressed, 0, compressedLength).ConfigureAwait(false);
if (chunk != compressedLength)
{
throw EndOfStream(); // corrupted
}
if (!isCompressed)
{
_buffer = compressed; // no compression on this chunk
_bufferLength = compressedLength;
}
else
{
if (_buffer == null || _buffer.Length < originalLength)
{
_buffer = new byte[originalLength];
}
var passes = (int)flags >> 2;
if (passes != 0)
{
throw new NotSupportedException("Chunks with multiple passes are not supported.");
}
LZ4Codec.Decode(compressed, 0, compressedLength, _buffer, 0, originalLength, true);
_bufferLength = originalLength;
}
_bufferOffset = 0;
} while (_bufferLength == 0); // skip empty block (shouldn't happen but...)
return(true);
}
/// <summary>Flushes current chunk.</summary>
private void FlushCurrentChunk()
{
if (_bufferOffset <= 0)
{
return;
}
var compressed = new byte[_bufferOffset];
var compressedLength = _highCompression
? LZ4Codec.EncodeHC(_buffer, 0, _bufferOffset, compressed, 0, _bufferOffset)
: LZ4Codec.Encode(_buffer, 0, _bufferOffset, compressed, 0, _bufferOffset);
if (compressedLength <= 0 || compressedLength >= _bufferOffset)
{
// incompressible block
compressed = _buffer;
compressedLength = _bufferOffset;
}
var isCompressed = compressedLength < _bufferOffset;
if (fileHeaderInfo == null)
{
fileHeaderInfo = new LZ4FileHeaderInfo();
fileHeaderInfo.FrameDescriptor_BD_BlockMaxSize = BlockMaximumSize.Block64K;
fileHeaderInfo.FrameDescriptor_FLG_BChecksum = false;
fileHeaderInfo.FrameDescriptor_FLG_BIndependence = true;
fileHeaderInfo.FrameDescriptor_FLG_ContentChecksum = true;
fileHeaderInfo.FrameDescriptor_FLG_ContentSize = false;
fileHeaderInfo.FrameDescriptor_FLG_Version = 64;
//U32 const xxh = XXH32(header, length, 0);
//return (BYTE)(xxh >> 8);
// *dstPtr = LZ4F_headerChecksum(headerStart, dstPtr - headerStart);
LZ4FileHeaderInfo.WriteHeader(_innerStream, fileHeaderInfo);
}
LZ4HeaderChunkInfo chunkInfo = new LZ4HeaderChunkInfo();
chunkInfo.IsCompressed = true;
chunkInfo.ChunkSize = compressedLength;
LZ4HeaderChunkInfo.WriteHeader(_innerStream, chunkInfo);
_innerStream.Write(compressed, 0, compressedLength);
_bufferOffset = 0;
}
/// <summary>Reads the next chunk from stream.</summary>
/// <returns><c>true</c> if next has been read, or <c>false</c> if it is legitimate end of file.
/// Throws <see cref="EndOfStreamException"/> if end of stream was unexpected.</returns>
private bool AcquireNextChunk()
{
do
{
if (fileHeaderInfo == null)
{
fileHeaderInfo = _formatReader.ReadHeader(_innerStream);
}
if (blockInfo != null && blockInfo.ChunkSize <= 0)
{
return(false);
}
blockInfo = _formatReader.ReadChunkHeader(_innerStream);
int compressedLength = blockInfo.ChunkSize;
if (compressedLength <= 0 || compressedLength > GetBufferSize(fileHeaderInfo.FrameDescriptor_BD_BlockMaxSize))
{
return(false);
}
bool isCompressed = blockInfo.IsCompressed;
var compressed = new byte[compressedLength];
var chunk = ReadBlock(compressed, 0, compressedLength);
if (chunk != compressedLength)
{
throw EndOfStream(); // corrupted
}
if (!isCompressed)
{
_buffer = compressed; // no compression on this chunk
_bufferLength = compressedLength;
}
else
{
int bSize = GetBufferSize(fileHeaderInfo.FrameDescriptor_BD_BlockMaxSize);
if (_buffer == null)
{
_buffer = new byte[bSize];
}
_bufferLength = LZ4Codec.Decode(compressed, 0, compressedLength, _buffer, 0, bSize, false);
}
_bufferOffset = 0;
} while (_bufferLength == 0); // skip empty block (shouldn't happen but...)
return(true);
}
private async Task FlushCurrentChunkAsync()
{
if (_bufferOffset <= 0)
{
return;
}
var compressed = new byte[_bufferOffset];
var compressedLength = _highCompression
? LZ4Codec.EncodeHC(_buffer, 0, _bufferOffset, compressed, 0, _bufferOffset)
: LZ4Codec.Encode(_buffer, 0, _bufferOffset, compressed, 0, _bufferOffset);
if (compressedLength <= 0 || compressedLength >= _bufferOffset)
{
// incompressible block
compressed = _buffer;
compressedLength = _bufferOffset;
}
var isCompressed = compressedLength < _bufferOffset;
var flags = ChunkFlags.None;
if (isCompressed)
{
flags |= ChunkFlags.Compressed;
}
if (_highCompression)
{
flags |= ChunkFlags.HighCompression;
}
await WriteVarIntAsync((ulong)flags).ConfigureAwait(false);
await WriteVarIntAsync((ulong)_bufferOffset).ConfigureAwait(false);
if (isCompressed)
{
await WriteVarIntAsync((ulong)compressedLength).ConfigureAwait(false);
}
await _innerStream.WriteAsync(compressed, 0, compressedLength).ConfigureAwait(false);
_bufferOffset = 0;
}
/// <summary>Flushes current chunk.</summary>
private void FlushCurrentChunk()
{
if (_bufferOffset <= 0)
{
return;
}
var compressed = new byte[_bufferOffset];
var compressedLength = _highCompression
? LZ4Codec.EncodeHC(_buffer, 0, _bufferOffset, compressed, 0, _bufferOffset)
: LZ4Codec.Encode(_buffer, 0, _bufferOffset, compressed, 0, _bufferOffset);
if (compressedLength <= 0 || compressedLength >= _bufferOffset)
{
// incompressible block
compressed = _buffer;
compressedLength = _bufferOffset;
}
var isCompressed = compressedLength < _bufferOffset;
var flags = ChunkFlags.None;
if (isCompressed)
{
flags |= ChunkFlags.Compressed;
}
if (_highCompression)
{
flags |= ChunkFlags.HighCompression;
}
WriteVarInt((ulong)flags);
WriteVarInt((ulong)_bufferOffset);
if (isCompressed)
{
WriteVarInt((ulong)compressedLength);
}
_innerStream.Write(compressed, 0, compressedLength);
_bufferOffset = 0;
}
