/// <summary>Compresses input buffer into self-contained package.</summary>
/// <param name="source">Input buffer.</param>
/// <param name="sourceLength">Length of input data.</param>
/// <param name="level">Compression level.</param>
/// <returns>Output buffer.</returns>
public static unsafe byte[] Pickle(
byte *source, int sourceLength, LZ4Level level = LZ4Level.L00_FAST)
{
if (sourceLength <= 0)
{
return(Mem.Empty);
}
var targetLength = sourceLength - 1;
var target = (byte *)Mem.Alloc(sourceLength);
try
{
var encodedLength = LZ4Codec.Encode(
source, sourceLength, target, targetLength, level);
return(encodedLength <= 0
? PickleV0(source, sourceLength, sourceLength)
: PickleV0(target, encodedLength, sourceLength));
}
finally
{
Mem.Free(target);
}
}
internal static byte[] Encode(byte[] source, LZ4Level level = LZ4Level.L00_FAST)
{
unsafe
{
int sourceLength = source.Length;
source.Validate(0, sourceLength);
fixed (byte* sourceTemp = source)
{
if (sourceLength <= 0) return Mem.Empty;
int targetLength1 = sourceLength - 1;
byte* target = (byte*) Mem.Alloc(sourceLength);
try
{
int targetLength2 = LZ4Codec.Encode(
sourceTemp, sourceLength,
target, targetLength1,
level);
return targetLength2 <= 0
? PickleV0(sourceTemp, sourceLength, sourceLength)
: PickleV0(target, targetLength2, sourceLength);
}
finally
{
Mem.Free((void*) target);
}
}
}
}
/// <summary>Creates new instance of block decoder.</summary>
/// <param name="blockSize">Block size. Must be equal or greater to one used for compression.</param>
public LZ4BlockDecoder(int blockSize)
{
blockSize = Mem.RoundUp(Math.Max(blockSize, Mem.K1), Mem.K1);
_blockSize = blockSize;
_outputLength = _blockSize + 8;
_outputIndex = 0;
_outputBuffer = (byte *)Mem.Alloc(_outputLength + 8);
}
protected LZ4EncoderBase(int blockSize, int extraBlocks = 0)
{
blockSize = Mem.RoundUp(Math.Max(blockSize, Mem.K1), Mem.K1);
extraBlocks = Math.Max(extraBlocks, 0);
_blockSize = blockSize;
_inputLength = Mem.K64 + (1 + extraBlocks) * blockSize + 8;
_inputIndex = _inputPointer = 0;
_inputBuffer = (byte *)Mem.Alloc(_inputLength + 8);
}
/// <summary>Creates new instance of <see cref="LZ4ChainDecoder"/>.</summary>
/// <param name="blockSize">Block size.</param>
/// <param name="extraBlocks">Number of extra blocks.</param>
public LZ4ChainDecoder(int blockSize, int extraBlocks)
{
blockSize = Mem.RoundUp(Math.Max(blockSize, Mem.K1), Mem.K1);
extraBlocks = Math.Max(extraBlocks, 0);
_blockSize = blockSize;
_outputLength = Mem.K64 + (1 + extraBlocks) * _blockSize + 32;
_outputIndex = 0;
_outputBuffer = (byte *)Mem.Alloc(_outputLength + 8);
_context = LL.LZ4_createStreamDecode();
}
/// <summary>Creates new instance of encoder.</summary>
/// <param name="chaining">Needs to be <c>true</c> if using dependent blocks.</param>
/// <param name="blockSize">Block size.</param>
/// <param name="extraBlocks">Number of extra blocks.</param>
protected LZ4EncoderBase(bool chaining, int blockSize, int extraBlocks)
{
blockSize = Mem.RoundUp(Math.Max(blockSize, Mem.K1), Mem.K1);
extraBlocks = Math.Max(extraBlocks, 0);
var dictSize = chaining ? Mem.K64 : 0;
_blockSize = blockSize;
_inputLength = dictSize + (1 + extraBlocks) * blockSize + 8;
_inputIndex = _inputPointer = 0;
_inputBuffer = (byte *)Mem.Alloc(_inputLength + 8);
}
public LZ4Decoder(int blockSize, int extraBlocks)
{
blockSize = Mem.RoundUp(Math.Max(blockSize, Mem.K1), Mem.K1);
extraBlocks = Math.Max(extraBlocks, 0);
_blockSize = blockSize;
_outputLength = Mem.K64 + (1 + extraBlocks) * _blockSize + 8;
_outputIndex = 0;
_outputBuffer = (byte *)Mem.Alloc(_outputLength + 8);
_context = (LZ4Context *)Mem.AllocZero(sizeof(LZ4Context));
}
public static LZ4_streamHC_t *LZ4_createStreamHC()
{
LZ4_streamHC_t *LZ4_streamHCPtr = (LZ4_streamHC_t *)Mem.Alloc(sizeof(LZ4_streamHC_t));
if (LZ4_streamHCPtr == null)
{
return(null);
}
LZ4_initStreamHC(LZ4_streamHCPtr);
return(LZ4_streamHCPtr);
}
public uint FastStreamManual(int blockLength, int sourceLength)
{
sourceLength = Mem.RoundUp(sourceLength, blockLength);
var targetLength = 2 * sourceLength;
var context = (LZ4_xx.LZ4_stream_t *)Mem.AllocZero(sizeof(LZ4_xx.LZ4_stream_t));
var source = (byte *)Mem.Alloc(sourceLength);
var target = (byte *)Mem.Alloc(targetLength);
try
{
Lorem.Fill(source, sourceLength);
var sourceP = 0;
var targetP = 0;
while (sourceP < sourceLength && targetP < targetLength)
{
targetP += LZ4_64.LZ4_compress_fast_continue(
context,
source + sourceP,
target + targetP,
Math.Min(blockLength, sourceLength - sourceP),
targetLength - targetP,
1);
sourceP += blockLength;
}
return(Tools.Adler32(target, targetP));
}
finally
{
Mem.Free(context);
Mem.Free(source);
Mem.Free(target);
}
}
public uint FastStreamManual(int blockLength, int sourceLength)
{
sourceLength = Mem.RoundUp(sourceLength, blockLength);
var targetLength = 2 * sourceLength;
var context = new Pubternal.FastContext();
var source = (byte *)Mem.Alloc(sourceLength);
var target = (byte *)Mem.Alloc(targetLength);
try
{
Lorem.Fill(source, sourceLength);
var sourceP = 0;
var targetP = 0;
while (sourceP < sourceLength && targetP < targetLength)
{
targetP += Pubternal.CompressFast(
context,
source + sourceP,
target + targetP,
Math.Min(blockLength, sourceLength - sourceP),
targetLength - targetP,
1);
sourceP += blockLength;
}
return(Tools.Adler32(target, targetP));
}
finally
{
context.Dispose();
Mem.Free(source);
Mem.Free(target);
}
}
public void Setup()
{
_source = (byte *)Mem.Alloc(Size);
_target = (byte *)Mem.Alloc(Size);
}
