public void PickleEntropy(int seed, int length, LZ4CompressionLevel level = LZ4CompressionLevel.Level0)
{
var original = new byte[length];
new Random(seed).NextBytes(original);
var pickled = LZ4Codec.Compress(original, level);
var unpickled = LZ4Codec.Expand(pickled);
Tools.SameBytes(original, unpickled);
}
public void PickleLorem(int length, LZ4CompressionLevel level = LZ4CompressionLevel.Level0)
{
var original = new byte[length];
Lorem.Fill(original, 0, length);
var pickled = LZ4Codec.Compress(original, level);
var unpickled = LZ4Codec.Expand(pickled);
Tools.SameBytes(original, unpickled);
}
/// <summary>
/// Creates a compression stream on top of the <see cref="Stream"/> specified.
/// </summary>
/// <param name="stream">Inner stream.</param>
/// <param name="level">Compression level.</param>
/// <param name="extraMemory">Extra memory used for compression.</param>
/// <param name="leaveOpen">Leave inner stream open after disposing.</param>
/// <returns>
/// The compression stream.
/// </returns>
public static LZ4EncoderStream Encode(Stream stream, LZ4CompressionLevel level, int extraMemory = 0, bool leaveOpen = false)
{
LZ4EncoderSettings settings = new LZ4EncoderSettings
{
ChainBlocks = true,
ExtraMemory = extraMemory,
BlockSize = LZ4MemoryHelper.K64,
CompressionLevel = level
};
return(Encode(stream, settings, leaveOpen));
}
/// <see cref="Compress(byte[], int, int, LZ4CompressionLevel)"/>
public static unsafe byte[] Compress(ReadOnlySpan <byte> source, LZ4CompressionLevel level = LZ4CompressionLevel.Level0)
{
int sourceLength = source.Length;
if (sourceLength <= 0)
{
return(Array.Empty <byte>());
fixed(byte *sourcePtr = &MemoryMarshal.GetReference(source))
{
return(Compress(sourcePtr, sourceLength, level));
}
}
/// <summary>
/// Creates a new instance of the <see cref="LZ4HighChainEncoder"/> class.
/// </summary>
/// <param name="level">Compression level.</param>
/// <param name="blockSize">Block size.</param>
/// <param name="extraBlocks">Number of extra blocks.</param>
public LZ4HighChainEncoder(LZ4CompressionLevel level, int blockSize, int extraBlocks = 0)
: base(true, blockSize, extraBlocks)
{
if (level < LZ4CompressionLevel.Level3)
{
level = LZ4CompressionLevel.Level3;
}
if (level > LZ4CompressionLevel.Level12)
{
level = LZ4CompressionLevel.Level12;
}
_context = (LZ4Context *)LZ4MemoryHelper.AllocZero(sizeof(LZ4Context));
LZ4Engine64HC.ResetStreamHC(_context, (int)level);
}
/// <summary>
/// Creates a compression stream on top of the <see cref="Stream"/> specified.
/// </summary>
/// <param name="stream">Inner stream.</param>
/// <param name="settings">Compression settings.</param>
/// <param name="leaveOpen">Leave inner stream open after disposing.</param>
/// <returns>
/// The compression stream.
/// </returns>
public static LZ4EncoderStream Encode(Stream stream, LZ4EncoderSettings settings = null, bool leaveOpen = false)
{
settings = settings ?? LZ4EncoderSettings.Default;
LZ4FrameDescriptor frameInfo = new LZ4FrameDescriptor(
settings.ContentLength,
settings.ContentChecksum,
settings.ChainBlocks,
settings.BlockChecksum,
settings.Dictionary,
settings.BlockSize);
LZ4CompressionLevel level = settings.CompressionLevel;
int extraMemory = settings.ExtraMemory;
return(new LZ4EncoderStream(
stream,
frameInfo,
i => LZ4EncodingFactory.CreateEncoder(i.Chaining, level, i.BlockSize, ExtraBlocks(i.BlockSize, extraMemory)),
leaveOpen));
}
public static unsafe byte[] Compress(byte *source, int sourceLength, LZ4CompressionLevel level = LZ4CompressionLevel.Level0)
{
if (sourceLength <= 0)
{
return(Array.Empty <byte>());
}
int targetLength = sourceLength - 1;
byte *target = (byte *)LZ4MemoryHelper.Alloc(sourceLength);
try
{
int encodedLength = Encode(source, sourceLength, target, targetLength, level);
return(encodedLength <= 0
? PickleV0(source, sourceLength, sourceLength)
: PickleV0(target, encodedLength, sourceLength));
}
finally
{
LZ4MemoryHelper.Free(target);
}
}
private static ILZ4Encoder CreateHighEncoder(LZ4CompressionLevel level, int blockSize, int extraBlocks)
{
return(new LZ4HighChainEncoder(level, blockSize, extraBlocks));
}
private static ILZ4Encoder CreateBlockEncoder(LZ4CompressionLevel level, int blockSize)
{
return(new LZ4BlockEncoder(level, blockSize));
}
/// <summary>
/// Creates a LZ4 encoder using the parameters specified.
/// </summary>
/// <param name="chaining">Dependent blocks.</param>
/// <param name="level">Compression level.</param>
/// <param name="blockSize">Block size.</param>
/// <param name="extraBlocks">Number of extra blocks.</param>
/// <returns>
/// An instance of LZ4 encoder, using the parameters specified.
/// </returns>
public static ILZ4Encoder CreateEncoder(bool chaining, LZ4CompressionLevel level, int blockSize, int extraBlocks = 0)
{
return(!chaining?CreateBlockEncoder(level, blockSize) :
level == LZ4CompressionLevel.Level0 ? CreateFastEncoder(blockSize, extraBlocks) :
CreateHighEncoder(level, blockSize, extraBlocks));
}
/// <summary>
/// Creates new instance of the <see cref="LZ4BlockEncoder"/> class.
/// </summary>
/// <param name="level">Compression level.</param>
/// <param name="blockSize">Block size.</param>
public LZ4BlockEncoder(LZ4CompressionLevel level, int blockSize)
: base(false, blockSize, 0)
{
_level = level;
}
public static unsafe int Encode(byte *source, int sourceLength, byte *target, int targetLength, LZ4CompressionLevel level = LZ4CompressionLevel.Level0)
{
if (sourceLength <= 0)
{
return(0);
}
int encoded = level == LZ4CompressionLevel.Level0
? LZ4Engine64.CompressDefault(source, target, sourceLength, targetLength)
: LZ4Engine64HC.CompressHC(source, target, sourceLength, targetLength, (int)level);
return(encoded <= 0 ? -1 : encoded);
}
/// <summary>
/// Compresses data from one buffer into another.
/// </summary>
/// <param name="source">Input buffer.</param>
/// <param name="sourceOffset">Input buffer offset.</param>
/// <param name="sourceLength">Input buffer length.</param>
/// <param name="target">Output buffer.</param>
/// <param name="targetOffset">Output buffer offset.</param>
/// <param name="targetLength">Output buffer length.</param>
/// <param name="level">Compression level. Lower compression level offers better speed at the expense of larger compressed size.</param>
/// <returns>
/// Number of bytes written, or negative value if output buffer is too small.
/// </returns>
public static unsafe int Encode(byte[] source, int sourceOffset, int sourceLength, byte[] target, int targetOffset, int targetLength, LZ4CompressionLevel level = LZ4CompressionLevel.Level0)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (sourceOffset < 0)
{
throw new ArgumentOutOfRangeException(nameof(sourceOffset), RS.CannotBeNegativeNumber);
}
if (sourceLength < 0)
{
throw new ArgumentOutOfRangeException(nameof(sourceLength), RS.CannotBeNegativeNumber);
}
if (sourceOffset + sourceLength > source.Length)
{
throw new ArgumentException(RS.OffsetSelectionLargerThanLength);
}
if (target == null)
{
throw new ArgumentNullException(nameof(target));
}
if (targetOffset < 0)
{
throw new ArgumentOutOfRangeException(nameof(targetOffset), RS.CannotBeNegativeNumber);
}
if (targetLength < 0)
{
throw new ArgumentOutOfRangeException(nameof(targetLength), RS.CannotBeNegativeNumber);
}
if (targetOffset + targetLength > target.Length)
{
throw new ArgumentException(RS.OffsetSelectionLargerThanLength);
fixed(byte *sourcePtr = source)
fixed(byte *targetPtr = target)
{
return(Encode(
sourcePtr + sourceOffset, sourceLength,
targetPtr + targetOffset, targetLength,
level));
}
}
/// <see cref="Encode(byte[], int, int, byte[], int, int, LZ4CompressionLevel)"/>
public static unsafe int Encode(ReadOnlySpan <byte> source, Span <byte> target, LZ4CompressionLevel level = LZ4CompressionLevel.Level0)
{
int sourceLength = source.Length;
if (sourceLength <= 0)
{
return(0);
}
int targetLength = target.Length;
fixed(byte *sourcePtr = &MemoryMarshal.GetReference(source))
fixed(byte *targetPtr = &MemoryMarshal.GetReference(target))
{
return(Encode(sourcePtr, sourceLength, targetPtr, targetLength, level));
}
}
/// <see cref="Compress(byte[], int, int, LZ4CompressionLevel)"/>
public static byte[] Compress(byte[] source, LZ4CompressionLevel level = LZ4CompressionLevel.Level0)
{
return(Compress(source, 0, source.Length, level));
}
/// <summary>
/// Create a compression settings object with the specified settings.
/// </summary>
/// <param name="mode">The compression mode which should be used.</param>
/// <param name="level">The compression level which should be used.</param>
public LZ4CompressionSettings(LZ4CompressionMode mode, LZ4CompressionLevel level)
{
CompressionMode = mode;
CompressionLevel = level;
}
public static byte[] Encode(byte[] source, int sourceIndex, int sourceLength, LZ4CompressionLevel level)
{
var bufferLength = LZ4Codec.MaximumOutputSize(sourceLength);
var buffer = new byte[bufferLength];
var targetLength = LZ4Codec.Encode(
source, sourceIndex, sourceLength, buffer, 0, bufferLength, level);
if (targetLength == bufferLength)
{
return(buffer);
}
var target = new byte[targetLength];
Buffer.BlockCopy(buffer, 0, target, 0, targetLength);
return(target);
}
