// -------------------------------------------------------------------------------
private static unsafe byte[] PickleV0(byte *target, int targetLength, int sourceLength)
{
int diff = sourceLength - targetLength;
int llen = diff == 0 ? 0
: diff < 0x100 ? 1
: diff < 0x10000 ? 2
: 4;
byte[] result = new byte[targetLength + 1 + llen];
fixed(byte *resultPtr = result)
{
int llenFlags = llen == 4 ? 3 : llen; // 2 bits
byte flags = (byte)((llenFlags << 6) | CurrentVersion);
LZ4MemoryHelper.Poke8(resultPtr + 0, flags);
if (llen == 1)
{
LZ4MemoryHelper.Poke8(resultPtr + 1, (byte)diff);
}
else if (llen == 2)
{
LZ4MemoryHelper.Poke16(resultPtr + 1, (ushort)diff);
}
else if (llen == 4)
{
LZ4MemoryHelper.Poke32(resultPtr + 1, (uint)diff);
}
LZ4MemoryHelper.Move(resultPtr + llen + 1, target, targetLength);
}
return(result);
}
private static uint ReverseCountPattern(byte *ip, byte *iLow, uint pattern)
{
byte *iStart = ip;
while (ip >= iLow + 4)
{
if (LZ4MemoryHelper.Peek32(ip - 4) != pattern)
{
break;
}
ip -= 4;
}
{
// works for any endianess
byte *bytePtr = (byte *)&pattern + 3;
while (ip > iLow)
{
if (ip[-1] != *bytePtr)
{
break;
}
ip--;
bytePtr--;
}
}
return((uint)(iStart - ip));
}
public static int SaveDictHC(CCtxT *streamHCPtr, byte *safeBuffer, int dictSize)
{
CCtxT *streamPtr = streamHCPtr;
int prefixSize = (int)(streamPtr->End - (streamPtr->BaseP + streamPtr->DictLimit));
if (dictSize > 64 * KB)
{
dictSize = 64 * KB;
}
if (dictSize < 4)
{
dictSize = 0;
}
if (dictSize > prefixSize)
{
dictSize = prefixSize;
}
LZ4MemoryHelper.Move(safeBuffer, streamPtr->End - dictSize, dictSize);
uint endIndex = (uint)(streamPtr->End - streamPtr->BaseP);
streamPtr->End = safeBuffer + dictSize;
streamPtr->BaseP = streamPtr->End - endIndex;
streamPtr->DictLimit = endIndex - (uint)dictSize;
streamPtr->LowLimit = endIndex - (uint)dictSize;
if (streamPtr->NextToUpdate < streamPtr->DictLimit)
{
streamPtr->NextToUpdate = streamPtr->DictLimit;
}
return(dictSize);
}
private static uint HashPosition(void *p, TableTypeT tableType)
{
#if !BIT32
if (tableType != TableTypeT.ByU16)
{
return(Hash5(ReadArch(p), tableType));
}
#endif
return(Hash4(LZ4MemoryHelper.Peek32(p), tableType));
}
public static void InitializeHC(CCtxT *hc4, byte *start)
{
LZ4MemoryHelper.Zero((byte *)hc4->HashTable, HashTableSizeHC * sizeof(uint));
LZ4MemoryHelper.Fill((byte *)hc4->ChainTable, 0xFF, MaxD * sizeof(ushort));
hc4->NextToUpdate = 64 * KB;
hc4->BaseP = start - 64 * KB;
hc4->End = start;
hc4->DictBase = start - 64 * KB;
hc4->DictLimit = 64 * KB;
hc4->LowLimit = 64 * KB;
}
protected static uint Count(byte *pIn, byte *pMatch, byte *pInLimit)
{
byte *pStart = pIn;
if (pIn < pInLimit - (StepSize - 1))
{
ulong diff = ReadArch(pMatch) ^ ReadArch(pIn);
if (diff != 0)
{
return(NbCommonBytes(diff));
}
pIn += StepSize;
pMatch += StepSize;
}
while (pIn < pInLimit - (StepSize - 1))
{
ulong diff = ReadArch(pMatch) ^ ReadArch(pIn);
if (diff != 0)
{
return((uint)(pIn + NbCommonBytes(diff) - pStart));
}
pIn += StepSize;
pMatch += StepSize;
}
#if !BIT32
if ((pIn < pInLimit - 3) && (LZ4MemoryHelper.Peek32(pMatch) == LZ4MemoryHelper.Peek32(pIn)))
{
pIn += 4;
pMatch += 4;
}
#endif
if ((pIn < pInLimit - 1) && (LZ4MemoryHelper.Peek16(pMatch) == LZ4MemoryHelper.Peek16(pIn)))
{
pIn += 2;
pMatch += 2;
}
if ((pIn < pInLimit) && (*pMatch == *pIn))
{
pIn++;
}
return((uint)(pIn - pStart));
}
private static MatchT FindLongerMatch(CCtxT *ctx, byte *ip, byte *iHighLimit, int minLen, int nbSearches)
{
MatchT match;
LZ4MemoryHelper.Zero((byte *)&match, sizeof(MatchT));
byte *matchPtr = null;
int matchLength = InsertAndGetWiderMatch(ctx, ip, ip, iHighLimit, minLen, &matchPtr, &ip, nbSearches, 1);
if (matchLength <= minLen)
{
return(match);
}
match.Len = matchLength;
match.Off = (int)(ip - matchPtr);
return(match);
}
public static int SaveDict(StreamT *dict, byte *safeBuffer, int dictSize)
{
byte *previousDictEnd = dict->Dictionary + dict->DictSize;
if ((uint)dictSize > 64 * KB)
{
dictSize = 64 * KB;
}
if ((uint)dictSize > dict->DictSize)
{
dictSize = (int)dict->DictSize;
}
LZ4MemoryHelper.Move(safeBuffer, previousDictEnd - dictSize, dictSize);
dict->Dictionary = safeBuffer;
dict->DictSize = (uint)dictSize;
return(dictSize);
}
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);
}
}
public static int DecompressGeneric(byte *src, byte *dst, int srcSize, int outputSize,
EndConditionDirective endOnInput, EarlyEndDirective partialDecoding,
int targetOutputSize, DictDirective dict, byte *lowPrefix, byte *dictStart, int dictSize)
{
byte *ip = src;
byte *iend = ip + srcSize;
byte *op = dst;
byte *oend = op + outputSize;
byte *oexit = op + targetOutputSize;
byte *dictEnd = dictStart + dictSize;
bool safeDecode = endOnInput == EndConditionDirective.EndOnInputSize;
bool checkOffset = safeDecode && dictSize < 64 * KB;
if ((partialDecoding != EarlyEndDirective.Full) && (oexit > oend - MFLimit))
{
oexit = oend - MFLimit;
}
if ((endOnInput == EndConditionDirective.EndOnInputSize) && (outputSize == 0))
{
return(srcSize == 1 && *ip == 0 ? 0 : -1);
}
if ((endOnInput != EndConditionDirective.EndOnInputSize) && (outputSize == 0))
{
return(*ip == 0 ? 1 : -1);
}
for (; ;)
{
int length;
uint token = *ip++;
if ((ip + 14 + 2 <= iend) &&
(op + 14 + 18 <= oend) &&
(token < 15 << MLBits) &&
((token & MLMask) != 15))
{
int ll = (int)(token >> MLBits);
int off = LZ4MemoryHelper.Peek16(ip + ll);
byte *matchPtr = op + ll - off;
if (off >= 18 && matchPtr >= lowPrefix)
{
int ml = (int)((token & MLMask) + MinMatch);
LZ4MemoryHelper.Copy16(op, ip);
op += ll;
ip += ll + 2;
LZ4MemoryHelper.Copy18(op, matchPtr);
op += ml;
continue;
}
}
if ((length = (int)(token >> MLBits)) == RunMask)
{
uint s;
do
{
s = *ip++;
length += (int)s;
}while (
(endOnInput != EndConditionDirective.EndOnInputSize || ip < iend - RunMask) &&
(s == 255));
if (safeDecode && op + length < op)
{
goto _output_error;
}
if (safeDecode && ip + length < ip)
{
goto _output_error;
}
}
byte *cpy = op + length;
if ((endOnInput == EndConditionDirective.EndOnInputSize) &&
((cpy > (partialDecoding == EarlyEndDirective.Partial ? oexit : oend - MFLimit)) ||
(ip + length > iend - (2 + 1 + LastLiterals))) ||
(endOnInput != EndConditionDirective.EndOnInputSize) && (cpy > oend - WildCopyLength))
{
if (partialDecoding == EarlyEndDirective.Partial)
{
if (cpy > oend)
{
goto _output_error;
}
if ((endOnInput == EndConditionDirective.EndOnInputSize) && (ip + length > iend))
{
goto _output_error;
}
}
else
{
if ((endOnInput != EndConditionDirective.EndOnInputSize) && (cpy != oend))
{
goto _output_error;
}
if ((endOnInput == EndConditionDirective.EndOnInputSize) &&
(ip + length != iend || cpy > oend))
{
goto _output_error;
}
}
LZ4MemoryHelper.Copy(op, ip, length);
ip += length;
op += length;
break;
}
LZ4MemoryHelper.WildCopy(op, ip, cpy);
ip += length;
op = cpy;
int offset = LZ4MemoryHelper.Peek16(ip);
ip += 2;
byte *match = op - offset;
if (checkOffset && match + dictSize < lowPrefix)
{
goto _output_error;
}
LZ4MemoryHelper.Poke32(op, (uint)offset);
length = (int)(token & MLMask);
if (length == MLMask)
{
uint s;
do
{
s = *ip++;
if ((endOnInput == EndConditionDirective.EndOnInputSize) && (ip > iend - LastLiterals))
{
goto _output_error;
}
length += (int)s;
}while (s == 255);
if (safeDecode && (op + length < op))
{
goto _output_error;
}
}
length += MinMatch;
if ((dict == DictDirective.UsingExtDict) && (match < lowPrefix))
{
if (op + length > oend - LastLiterals)
{
goto _output_error;
}
if (length <= lowPrefix - match)
{
LZ4MemoryHelper.Move(op, dictEnd - (lowPrefix - match), length);
op += length;
}
else
{
int copySize = (int)(lowPrefix - match);
int restSize = length - copySize;
LZ4MemoryHelper.Copy(op, dictEnd - copySize, copySize);
op += copySize;
if (restSize > (int)(op - lowPrefix))
{
byte *endOfMatch = op + restSize;
byte *copyFrom = lowPrefix;
while (op < endOfMatch)
{
*op++ = *copyFrom++;
}
}
else
{
LZ4MemoryHelper.Copy(op, lowPrefix, restSize);
op += restSize;
}
}
continue;
}
cpy = op + length;
if (offset < 8)
{
op[0] = match[0];
op[1] = match[1];
op[2] = match[2];
op[3] = match[3];
match += _inc32table[offset];
LZ4MemoryHelper.Copy(op + 4, match, 4);
match -= _dec64table[offset];
}
else
{
LZ4MemoryHelper.Copy8(op, match);
match += 8;
}
op += 8;
if (cpy > oend - 12)
{
byte *oCopyLimit = oend - (WildCopyLength - 1);
if (cpy > oend - LastLiterals)
{
goto _output_error;
}
if (op < oCopyLimit)
{
LZ4MemoryHelper.WildCopy(op, match, oCopyLimit);
match += oCopyLimit - op;
op = oCopyLimit;
}
while (op < cpy)
{
*op++ = *match++;
}
}
else
{
LZ4MemoryHelper.Copy8(op, match);
if (length > 16)
{
LZ4MemoryHelper.WildCopy(op + 8, match + 8, cpy);
}
}
op = cpy; // correction
}
// end of decoding
if (endOnInput == EndConditionDirective.EndOnInputSize)
{
return((int)(op - dst)); // Nb of output bytes decoded
}
return((int)(ip - src)); // Nb of input bytes read
// Overflow error detected
_output_error:
return((int)-(ip - src) - 1);
}
private static void FreeCtx(CCtxT *context)
{
LZ4MemoryHelper.Free(context);
}
private static int CompressDestSizeGeneric(StreamT *ctx, byte *src, byte *dst, int *srcSizePtr, int targetDstSize, TableTypeT tableType)
{
byte *ip = src;
byte *srcBase = src;
byte *lowLimit = src;
byte *anchor = ip;
byte *iend = ip + *srcSizePtr;
byte *mflimit = iend - MFLimit;
byte *matchlimit = iend - LastLiterals;
byte *op = dst;
byte *oend = op + targetDstSize;
byte *oMaxLit = op + targetDstSize - 2 - 8 - 1;
byte *oMaxMatch = op + targetDstSize - (LastLiterals + 1);
byte *oMaxSeq = oMaxLit - 1;
if (targetDstSize < 1)
{
return(0);
}
if (*srcSizePtr > MaxInputSize)
{
return(0);
}
if ((tableType == TableTypeT.ByU16) && (*srcSizePtr >= Limit64k))
{
return(0);
}
if (*srcSizePtr < LZ4MinLength)
{
goto _last_literals; // Input too small, no compression (all literals)
}
*srcSizePtr = 0;
PutPosition(ip, ctx->HashTable, tableType, srcBase);
ip++;
uint forwardH = HashPosition(ip, tableType);
for (; ;)
{
byte *match;
byte *token;
{
byte *forwardIp = ip;
uint step = 1u;
uint searchMatchNb = 1u << SkipTrigger;
do
{
uint h = forwardH;
ip = forwardIp;
forwardIp += step;
step = searchMatchNb++ >> SkipTrigger;
if (forwardIp > mflimit)
{
goto _last_literals;
}
match = GetPositionOnHash(h, ctx->HashTable, tableType, srcBase);
forwardH = HashPosition(forwardIp, tableType);
PutPositionOnHash(ip, h, ctx->HashTable, tableType, srcBase);
}while ((tableType != TableTypeT.ByU16) && (match + MaxDistance < ip) ||
(LZ4MemoryHelper.Peek32(match) != LZ4MemoryHelper.Peek32(ip)));
}
while ((ip > anchor) && (match > lowLimit) && (ip[-1] == match[-1]))
{
ip--;
match--;
}
{
uint litLength = (uint)(ip - anchor);
token = op++;
if (op + (litLength + 240) / 255 + litLength > oMaxLit)
{
op--;
goto _last_literals;
}
if (litLength >= RunMask)
{
uint len = litLength - RunMask;
*token = (byte)(RunMask << MLBits);
for (; len >= 255; len -= 255)
{
*op++ = 255;
}
*op++ = (byte)len;
}
else
{
*token = (byte)(litLength << MLBits);
}
LZ4MemoryHelper.WildCopy(op, anchor, op + litLength);
op += litLength;
}
_next_match:
LZ4MemoryHelper.Poke16(op, (ushort)(ip - match));
op += 2;
{
int matchLength = (int)Count(ip + MinMatch, match + MinMatch, matchlimit);
if (op + (matchLength + 240) / 255 > oMaxMatch)
{
matchLength = (int)(15 - 1 + (oMaxMatch - op) * 255);
}
ip += MinMatch + matchLength;
if (matchLength >= MLMask)
{
*token += (byte)MLMask;
matchLength -= (int)MLMask;
while (matchLength >= 255)
{
matchLength -= 255;
*op++ = 255;
}
*op++ = (byte)matchLength;
}
else
{
*token += (byte)matchLength;
}
}
anchor = ip;
if (ip > mflimit)
{
break;
}
if (op > oMaxSeq)
{
break;
}
PutPosition(ip - 2, ctx->HashTable, tableType, srcBase);
match = GetPosition(ip, ctx->HashTable, tableType, srcBase);
PutPosition(ip, ctx->HashTable, tableType, srcBase);
if ((match + MaxDistance >= ip) && (LZ4MemoryHelper.Peek32(match) == LZ4MemoryHelper.Peek32(ip)))
{
token = op++;
*token = 0;
goto _next_match;
}
forwardH = HashPosition(++ip, tableType);
}
_last_literals:
{
int lastRunSize = (int)(iend - anchor);
if (op + 1 + (lastRunSize + 240) / 255 + lastRunSize > oend)
{
lastRunSize = (int)(oend - op) - 1;
lastRunSize -= (lastRunSize + 240) / 255;
}
ip = anchor + lastRunSize;
if (lastRunSize >= RunMask)
{
long accumulator = lastRunSize - RunMask;
*op++ = (byte)(RunMask << MLBits);
for (; accumulator >= 255; accumulator -= 255)
{
*op++ = 255;
}
*op++ = (byte)accumulator;
}
else
{
*op++ = (byte)(lastRunSize << MLBits);
}
LZ4MemoryHelper.Copy(op, anchor, lastRunSize);
op += lastRunSize;
}
*srcSizePtr = (int)(ip - src);
return((int)(op - dst));
}
private static int EncodeSequence(byte **ip, byte **op, byte **anchor, int matchLength, byte *match, LimitedOutputDirective limit, byte *oend)
{
byte *token = (*op)++;
size_t length = (size_t)(*ip - *anchor);
if ((limit != LimitedOutputDirective.NoLimit) &&
(*op + (length >> 8) + length + (2 + 1 + LastLiterals) > oend))
{
return(1);
}
if (length >= RunMask)
{
size_t len = length - RunMask;
* token = (byte)(RunMask << MLBits);
for (; len >= 255; len -= 255)
{
*(*op)++ = 255;
}
*(*op)++ = (byte)len;
}
else
{
*token = (byte)(length << MLBits);
}
LZ4MemoryHelper.WildCopy(*op, *anchor, (*op) + length);
*op += length;
LZ4MemoryHelper.Poke16(*op, (ushort)(*ip - match));
*op += 2;
length = (size_t)(matchLength - MinMatch);
if ((limit != LimitedOutputDirective.NoLimit) &&
(*op + (length >> 8) + (1 + LastLiterals) > oend))
{
return(1);
}
if (length >= MLMask)
{
*token += (byte)MLMask;
length -= MLMask;
for (; length >= 510; length -= 510)
{
*(*op)++ = 255;
*(*op)++ = 255;
}
if (length >= 255)
{
length -= 255;
*(*op)++ = 255;
}
*(*op)++ = (byte)length;
}
else
{
*token += (byte)(length);
}
*ip += matchLength;
*anchor = *ip;
return(0);
}
private static int InsertAndGetWiderMatch(CCtxT *hc4, byte *ip, byte *iLowLimit, byte *iHighLimit, int longest,
byte **matchpos, byte **startpos, int maxNbAttempts, int patternAnalysis)
{
ushort *chainTable = hc4->ChainTable;
uint * hashTable = hc4->HashTable;
byte * basep = hc4->BaseP;
uint dictLimit = hc4->DictLimit;
byte * lowPrefixPtr = basep + dictLimit;
uint lowLimit = hc4->LowLimit + 64 * KB > (uint)(ip - basep)
? hc4->LowLimit
: (uint)(ip - basep) - MaxDistance;
byte * dictBase = hc4->DictBase;
int delta = (int)(ip - iLowLimit);
int nbAttempts = maxNbAttempts;
uint pattern = LZ4MemoryHelper.Peek32(ip);
RepeatStateE repeat = RepeatStateE.RepUntested;
int srcPatternLength = 0;
// First Match
Insert(hc4, ip);
uint matchIndex = hashTable[HashPtr(ip)];
while ((matchIndex >= lowLimit) && (nbAttempts != 0))
{
nbAttempts--;
if (matchIndex >= dictLimit)
{
byte *matchPtr = basep + matchIndex;
if (*(iLowLimit + longest) == *(matchPtr - delta + longest))
{
if (LZ4MemoryHelper.Peek32(matchPtr) == pattern)
{
int mlt = MinMatch + (int)Count(ip + MinMatch, matchPtr + MinMatch, iHighLimit);
int back = 0;
while ((ip + back > iLowLimit) &&
(matchPtr + back > lowPrefixPtr) &&
(ip[back - 1] == matchPtr[back - 1]))
{
back--;
}
mlt -= back;
if (mlt > longest)
{
longest = mlt;
*matchpos = matchPtr + back;
*startpos = ip + back;
}
}
}
}
else
{
byte *matchPtr = dictBase + matchIndex;
if (LZ4MemoryHelper.Peek32(matchPtr) == pattern)
{
int back = 0;
byte *vLimit = ip + (dictLimit - matchIndex);
if (vLimit > iHighLimit)
{
vLimit = iHighLimit;
}
int mlt = MinMatch + (int)Count(ip + MinMatch, matchPtr + MinMatch, vLimit);
if ((ip + mlt == vLimit) && (vLimit < iHighLimit))
{
mlt += (int)Count(ip + mlt, basep + dictLimit, iHighLimit);
}
while ((ip + back > iLowLimit) &&
(matchIndex + back > lowLimit) &&
(ip[back - 1] == matchPtr[back - 1]))
{
back--;
}
mlt -= back;
if (mlt > longest)
{
longest = mlt;
*matchpos = basep + matchIndex + back;
*startpos = ip + back;
}
}
}
{
ushort nextOffset = DeltaNextU16(chainTable, (ushort)matchIndex);
matchIndex -= nextOffset;
if ((patternAnalysis != 0) && (nextOffset == 1))
{
// may be a repeated pattern
if (repeat == RepeatStateE.RepUntested)
{
if (((pattern & 0xFFFF) == pattern >> 16) &
((pattern & 0xFF) == pattern >> 24))
{
repeat = RepeatStateE.RepConfirmed;
srcPatternLength = (int)CountPattern(ip + 4, iHighLimit, pattern) + 4;
}
else
{
repeat = RepeatStateE.RepNot;
}
}
if ((repeat == RepeatStateE.RepConfirmed) && (matchIndex >= dictLimit))
{
byte *matchPtr = basep + matchIndex;
if (LZ4MemoryHelper.Peek32(matchPtr) == pattern)
{
int forwardPatternLength = (int)CountPattern(matchPtr + sizeof(uint), iHighLimit, pattern) + sizeof(uint);
byte *maxLowPtr = lowPrefixPtr + MaxDistance >= ip
? lowPrefixPtr
: ip - MaxDistance;
int backLength = (int)ReverseCountPattern(matchPtr, maxLowPtr, pattern);
int currentSegmentLength = backLength + forwardPatternLength;
if ((currentSegmentLength >= srcPatternLength) &&
(forwardPatternLength <= srcPatternLength))
{
matchIndex += (uint)(forwardPatternLength - srcPatternLength);
}
else
{
matchIndex -= (uint)backLength;
}
}
}
}
}
}
return(longest);
}
private static uint HashPtr(void *ptr)
{
return((LZ4MemoryHelper.Peek32(ptr) * 2654435761U) >> (MinMatch * 8 - HashLogHC));
}
public static int CompressGeneric(StreamT *cctx, byte *source, byte *dest, int inputSize, int maxOutputSize,
LimitedOutputDirective outputLimited, TableTypeT tableType,
DictDirective dict, DictIssueDirective dictIssue, uint acceleration)
{
byte *ip = source;
byte *ibase;
byte *lowLimit;
byte *lowRefLimit = ip - cctx->DictSize;
byte *dictionary = cctx->Dictionary;
byte *dictEnd = dictionary + cctx->DictSize;
long dictDelta = dictEnd - source;
byte *anchor = source;
byte *iend = ip + inputSize;
byte *mflimit = iend - MFLimit;
byte *matchlimit = iend - LastLiterals;
byte *op = dest;
byte *olimit = op + maxOutputSize;
if (inputSize > MaxInputSize)
{
return(0);
}
switch (dict)
{
case DictDirective.WithPrefix64k:
ibase = source - cctx->CurrentOffset;
lowLimit = source - cctx->DictSize;
break;
case DictDirective.UsingExtDict:
ibase = source - cctx->CurrentOffset;
lowLimit = source;
break;
default:
ibase = source;
lowLimit = source;
break;
}
if ((tableType == TableTypeT.ByU16) && (inputSize >= Limit64k))
{
return(0);
}
if (inputSize < LZ4MinLength)
{
goto _last_literals;
}
PutPosition(ip, cctx->HashTable, tableType, ibase);
ip++;
uint forwardH = HashPosition(ip, tableType);
for (; ;)
{
long refDelta = 0L;
byte *match;
byte *token;
{
byte *forwardIp = ip;
uint step = 1u;
uint searchMatchNb = acceleration << SkipTrigger;
do
{
uint h = forwardH;
ip = forwardIp;
forwardIp += step;
step = searchMatchNb++ >> SkipTrigger;
if (forwardIp > mflimit)
{
goto _last_literals;
}
match = GetPositionOnHash(h, cctx->HashTable, tableType, ibase);
if (dict == DictDirective.UsingExtDict)
{
if (match < source)
{
refDelta = dictDelta;
lowLimit = dictionary;
}
else
{
refDelta = 0;
lowLimit = source;
}
}
forwardH = HashPosition(forwardIp, tableType);
PutPositionOnHash(ip, h, cctx->HashTable, tableType, ibase);
}while ((dictIssue == DictIssueDirective.DictSmall) && (match < lowRefLimit) ||
(tableType != TableTypeT.ByU16) && (match + MaxDistance < ip) ||
(LZ4MemoryHelper.Peek32(match + refDelta) != LZ4MemoryHelper.Peek32(ip)));
}
while ((ip > anchor) && (match + refDelta > lowLimit) && (ip[-1] == match[refDelta - 1]))
{
ip--;
match--;
}
{
uint litLength = (uint)(ip - anchor);
token = op++;
if ((outputLimited == LimitedOutputDirective.LimitedOutput) &&
(op + litLength + (2 + 1 + LastLiterals) + litLength / 255 > olimit))
{
return(0);
}
if (litLength >= RunMask)
{
int len = (int)(litLength - RunMask);
*token = (byte)(RunMask << MLBits);
for (; len >= 255; len -= 255)
{
*op++ = 255;
}
*op++ = (byte)len;
}
else
{
*token = (byte)(litLength << MLBits);
}
LZ4MemoryHelper.WildCopy(op, anchor, op + litLength);
op += litLength;
}
_next_match:
LZ4MemoryHelper.Poke16(op, (ushort)(ip - match));
op += 2;
{
uint matchCode;
if ((dict == DictDirective.UsingExtDict) && (lowLimit == dictionary))
{
match += refDelta;
byte *limit = ip + (dictEnd - match);
if (limit > matchlimit)
{
limit = matchlimit;
}
matchCode = Count(ip + MinMatch, match + MinMatch, limit);
ip += MinMatch + matchCode;
if (ip == limit)
{
uint more = Count(ip, source, matchlimit);
matchCode += more;
ip += more;
}
}
else
{
matchCode = Count(ip + MinMatch, match + MinMatch, matchlimit);
ip += MinMatch + matchCode;
}
if ((outputLimited == LimitedOutputDirective.LimitedOutput) &&
(op + (1 + LastLiterals) + (matchCode >> 8) > olimit))
{
return(0);
}
if (matchCode >= MLMask)
{
*token += (byte)MLMask;
matchCode -= MLMask;
LZ4MemoryHelper.Poke32(op, 0xFFFFFFFF);
while (matchCode >= 4 * 255)
{
op += 4;
LZ4MemoryHelper.Poke32(op, 0xFFFFFFFF);
matchCode -= 4 * 255;
}
op += matchCode / 255;
*op++ = (byte)(matchCode % 255);
}
else
{
*token += (byte)matchCode;
}
}
anchor = ip;
if (ip > mflimit)
{
break;
}
PutPosition(ip - 2, cctx->HashTable, tableType, ibase);
match = GetPosition(ip, cctx->HashTable, tableType, ibase);
if (dict == DictDirective.UsingExtDict)
{
if (match < source)
{
refDelta = dictDelta;
lowLimit = dictionary;
}
else
{
refDelta = 0;
lowLimit = source;
}
}
PutPosition(ip, cctx->HashTable, tableType, ibase);
if ((dictIssue != DictIssueDirective.DictSmall || match >= lowRefLimit) &&
(match + MaxDistance >= ip) &&
(LZ4MemoryHelper.Peek32(match + refDelta) == LZ4MemoryHelper.Peek32(ip)))
{
token = op++;
*token = 0;
goto _next_match;
}
forwardH = HashPosition(++ip, tableType);
}
_last_literals:
{
int lastRun = (int)(iend - anchor);
if ((outputLimited == LimitedOutputDirective.LimitedOutput) &&
(op - dest + lastRun + 1 + (lastRun + 255 - RunMask) / 255 > (uint)maxOutputSize))
{
return(0);
}
if (lastRun >= RunMask)
{
int accumulator = (int)(lastRun - RunMask);
*op++ = (byte)(RunMask << MLBits);
for (; accumulator >= 255; accumulator -= 255)
{
*op++ = 255;
}
*op++ = (byte)accumulator;
}
else
{
*op++ = (byte)(lastRun << MLBits);
}
LZ4MemoryHelper.Copy(op, anchor, lastRun);
op += lastRun;
}
return((int)(op - dest));
}
public static void ResetStream(StreamT *state)
{
LZ4MemoryHelper.Zero((byte *)state, sizeof(StreamT));
}
// -----------------------------------------------------------------
private static int CompressOptimal(CCtxT *ctx, byte *source, byte *dst, int *srcSizePtr, int dstCapacity,
int nbSearches, size_t sufficientLen, LimitedOutputDirective limit, int fullUpdate)
{
const int TrailingLiterals = 3;
OptimalT *opt = stackalloc OptimalT[OptNum + TrailingLiterals];
byte *ip = source;
byte *anchor = ip;
byte *iend = ip + *srcSizePtr;
byte *mflimit = iend - MFLimit;
byte *matchlimit = iend - LastLiterals;
byte *op = dst;
byte *opSaved;
byte *oend = op + dstCapacity;
*srcSizePtr = 0;
if (limit == LimitedOutputDirective.LimitedDestSize)
{
oend -= LastLiterals;
}
if (sufficientLen >= OptNum)
{
sufficientLen = OptNum - 1;
}
// Main Loop
while (ip < mflimit)
{
int llen = (int)(ip - anchor);
int bestMlen, bestOff;
int cur, lastMatchPos;
MatchT firstMatch = FindLongerMatch(ctx, ip, matchlimit, MinMatch - 1, nbSearches);
if (firstMatch.Len == 0)
{
ip++;
continue;
}
if ((size_t)firstMatch.Len > sufficientLen)
{
int firstML = firstMatch.Len;
byte *matchPos = ip - firstMatch.Off;
opSaved = op;
if (EncodeSequence(&ip, &op, &anchor, firstML, matchPos, limit, oend) != 0)
{
goto _dest_overflow;
}
continue;
}
// set prices for first positions (literals)
{
int rPos;
for (rPos = 0; rPos < MinMatch; rPos++)
{
int cost = LiteralsPrice(llen + rPos);
opt[rPos].Mlen = 1;
opt[rPos].Off = 0;
opt[rPos].Litlen = llen + rPos;
opt[rPos].Price = cost;
}
}
// set prices using initial match
{
int mlen = MinMatch;
int matchML = firstMatch.Len; // necessarily < sufficient_len < LZ4_OPT_NUM
int offset = firstMatch.Off;
for (; mlen <= matchML; mlen++)
{
int cost = SequencePrice(llen, mlen);
opt[mlen].Mlen = mlen;
opt[mlen].Off = offset;
opt[mlen].Litlen = llen;
opt[mlen].Price = cost;
}
}
lastMatchPos = firstMatch.Len;
{
int addLit;
for (addLit = 1; addLit <= TrailingLiterals; addLit++)
{
opt[lastMatchPos + addLit].Mlen = 1;
opt[lastMatchPos + addLit].Off = 0;
opt[lastMatchPos + addLit].Litlen = addLit;
opt[lastMatchPos + addLit].Price = opt[lastMatchPos].Price + LiteralsPrice(addLit);
}
}
// check further positions
for (cur = 1; cur < lastMatchPos; cur++)
{
byte *curPtr = ip + cur;
if (curPtr >= mflimit)
{
break;
}
if (fullUpdate != 0)
{
if ((opt[cur + 1].Price <= opt[cur].Price) &&
(opt[cur + MinMatch].Price < opt[cur].Price + 3))
{
continue;
}
}
else
{
if (opt[cur + 1].Price <= opt[cur].Price)
{
continue;
}
}
MatchT newMatch = FindLongerMatch(
ctx,
curPtr,
matchlimit,
fullUpdate != 0 ? MinMatch - 1 : lastMatchPos - cur,
nbSearches);
if (newMatch.Len == 0)
{
continue;
}
if ((size_t)newMatch.Len > sufficientLen || newMatch.Len + cur >= OptNum)
{
// immediate encoding
bestMlen = newMatch.Len;
bestOff = newMatch.Off;
lastMatchPos = cur + 1;
goto encode;
}
// before match : set price with literals at beginning
{
int baseLitlen = opt[cur].Litlen;
for (int litlen = 1; litlen < MinMatch; litlen++)
{
int price = opt[cur].Price - LiteralsPrice(baseLitlen) + LiteralsPrice(baseLitlen + litlen);
int pos = cur + litlen;
if (price >= opt[pos].Price)
{
continue;
}
opt[pos].Mlen = 1;
opt[pos].Off = 0;
opt[pos].Litlen = baseLitlen + litlen;
opt[pos].Price = price;
}
}
// set prices using match at position = cur
{
int matchML = newMatch.Len;
int ml = MinMatch;
for (; ml <= matchML; ml++)
{
int pos = cur + ml;
int offset = newMatch.Off;
int price;
int ll;
if (opt[cur].Mlen == 1)
{
ll = opt[cur].Litlen;
price = ((cur > ll) ? opt[cur - ll].Price : 0) + SequencePrice(ll, ml);
}
else
{
ll = 0;
price = opt[cur].Price + SequencePrice(0, ml);
}
if ((pos > lastMatchPos + TrailingLiterals) || (price <= opt[pos].Price))
{
if (ml == matchML && lastMatchPos < pos)
{
lastMatchPos = pos;
}
opt[pos].Mlen = ml;
opt[pos].Off = offset;
opt[pos].Litlen = ll;
opt[pos].Price = price;
}
}
}
{
int addLit;
for (addLit = 1; addLit <= TrailingLiterals; addLit++)
{
opt[lastMatchPos + addLit].Mlen = 1;
opt[lastMatchPos + addLit].Off = 0;
opt[lastMatchPos + addLit].Litlen = addLit;
opt[lastMatchPos + addLit].Price = opt[lastMatchPos].Price + LiteralsPrice(addLit);
}
}
}
bestMlen = opt[lastMatchPos].Mlen;
bestOff = opt[lastMatchPos].Off;
cur = lastMatchPos - bestMlen;
encode: // cur, last_match_pos, best_mlen, best_off must be set
{
int candidate_pos = cur;
int selected_matchLength = bestMlen;
int selected_offset = bestOff;
while (true)
{
int next_matchLength = opt[candidate_pos].Mlen;
int next_offset = opt[candidate_pos].Off;
opt[candidate_pos].Mlen = selected_matchLength;
opt[candidate_pos].Off = selected_offset;
selected_matchLength = next_matchLength;
selected_offset = next_offset;
if (next_matchLength > candidate_pos)
{
break;
}
candidate_pos -= next_matchLength;
}
}
{
int rPos = 0;
while (rPos < lastMatchPos)
{
int ml = opt[rPos].Mlen;
int offset = opt[rPos].Off;
if (ml == 1)
{
ip++;
rPos++;
continue;
}
rPos += ml;
opSaved = op;
if (EncodeSequence(&ip, &op, &anchor, ml, ip - offset, limit, oend) != 0)
{
goto _dest_overflow;
}
}
}
}
_last_literals:
{
size_t lastRunSize = (size_t)(iend - anchor);
size_t litLength = (lastRunSize + 255 - RunMask) / 255;
size_t totalSize = 1 + litLength + lastRunSize;
if (limit == LimitedOutputDirective.LimitedDestSize)
{
oend += LastLiterals;
}
if (limit != 0 && op + totalSize > oend)
{
if (limit == LimitedOutputDirective.LimitedOutput)
{
return(0);
}
lastRunSize = (size_t)(oend - op) - 1;
litLength = (lastRunSize + 255 - RunMask) / 255;
lastRunSize -= litLength;
}
ip = anchor + lastRunSize;
if (lastRunSize >= RunMask)
{
size_t accumulator = lastRunSize - RunMask;
* op++ = (byte)(RunMask << MLBits);
for (; accumulator >= 255; accumulator -= 255)
{
*op++ = 255;
}
*op++ = (byte)accumulator;
}
else
{
*op++ = (byte)(lastRunSize << MLBits);
}
LZ4MemoryHelper.Copy(op, anchor, (int)lastRunSize);
op += lastRunSize;
}
// End
*srcSizePtr = (int)(ip - source);
return((int)(op - dst));
_dest_overflow:
if (limit != LimitedOutputDirective.LimitedDestSize)
{
return(0);
}
op = opSaved; // restore correct out pointer
goto _last_literals;
}
private static int CompressHashChain(CCtxT *ctx, byte *source, byte *dest, int *srcSizePtr, int maxOutputSize, uint maxNbAttempts, LimitedOutputDirective limit)
{
int inputSize = *srcSizePtr;
int patternAnalysis = maxNbAttempts > 64 ? 1 : 0; // levels 8+
byte *ip = source;
byte *anchor = ip;
byte *iend = ip + inputSize;
byte *mflimit = iend - MFLimit;
byte *matchlimit = (iend - LastLiterals);
byte *optr;
byte *op = dest;
byte *oend = op + maxOutputSize;
byte *refPos = null;
byte *start2 = null;
byte *ref2 = null;
byte *start3 = null;
byte *ref3 = null;
// init
*srcSizePtr = 0;
if (limit == LimitedOutputDirective.LimitedDestSize)
{
oend -= LastLiterals; // Hack for support LZ4 format restriction
}
if (inputSize < LZ4MinLength)
{
goto _last_literals; // Input too small, no compression (all literals)
}
// Main Loop
while (ip < mflimit)
{
int ml = InsertAndFindBestMatch(
ctx,
ip,
matchlimit,
&refPos,
(int)maxNbAttempts,
patternAnalysis);
if (ml < MinMatch)
{
ip++;
continue;
}
// saved, in case we would skip too much
byte *start0 = ip;
byte *ref0 = refPos;
int ml0 = ml;
_Search2:
int ml2;
if (ip + ml < mflimit)
{
ml2 = InsertAndGetWiderMatch(
ctx,
ip + ml - 2,
ip + 0,
matchlimit,
ml,
&ref2,
&start2,
(int)maxNbAttempts,
patternAnalysis);
}
else
{
ml2 = ml;
}
if (ml2 == ml)
{
// No better match
optr = op;
if (EncodeSequence(&ip, &op, &anchor, ml, refPos, limit, oend) != 0)
{
goto _dest_overflow;
}
continue;
}
if (start0 < ip)
{
if (start2 < ip + ml0)
{
// empirical
ip = start0;
refPos = ref0;
ml = ml0;
}
}
// Here, start0==ip
if (start2 - ip < 3)
{
// First Match too small : removed
ml = ml2;
ip = start2;
refPos = ref2;
goto _Search2;
}
_Search3:
// At this stage, we have :
// ml2 > ml1, and
// ip1+3 <= ip2 (usually < ip1+ml1)
if ((start2 - ip) < OptimalML)
{
int newMl = ml;
if (newMl > OptimalML)
{
newMl = OptimalML;
}
if (ip + newMl > start2 + ml2 - MinMatch)
{
newMl = (int)(start2 - ip) + ml2 - MinMatch;
}
int correction = newMl - (int)(start2 - ip);
if (correction > 0)
{
start2 += correction;
ref2 += correction;
ml2 -= correction;
}
}
// Now, we have start2 = ip+new_ml, with new_ml = min(ml, OPTIMAL_ML=18)
int ml3;
if (start2 + ml2 < mflimit)
{
ml3 = InsertAndGetWiderMatch(
ctx,
start2 + ml2 - 3,
start2,
matchlimit,
ml2,
&ref3,
&start3,
(int)maxNbAttempts,
patternAnalysis);
}
else
{
ml3 = ml2;
}
if (ml3 == ml2)
{
// No better match : 2 sequences to encode
// ip & ref are known; Now for ml
if (start2 < ip + ml)
{
ml = (int)(start2 - ip);
}
// Now, encode 2 sequences
optr = op;
if (EncodeSequence(&ip, &op, &anchor, ml, refPos, limit, oend) != 0)
{
goto _dest_overflow;
}
ip = start2;
optr = op;
if (EncodeSequence(&ip, &op, &anchor, ml2, ref2, limit, oend) != 0)
{
goto _dest_overflow;
}
continue;
}
if (start3 < ip + ml + 3)
{
// Not enough space for match 2 : remove it
if (start3 >= (ip + ml))
{
// can write Seq1 immediately ==> Seq2 is removed, so Seq3 becomes Seq1
if (start2 < ip + ml)
{
int correction = (int)(ip + ml - start2);
start2 += correction;
ref2 += correction;
ml2 -= correction;
if (ml2 < MinMatch)
{
start2 = start3;
ref2 = ref3;
ml2 = ml3;
}
}
optr = op;
if (EncodeSequence(&ip, &op, &anchor, ml, refPos, limit, oend) != 0)
{
goto _dest_overflow;
}
ip = start3;
refPos = ref3;
ml = ml3;
start0 = start2;
ref0 = ref2;
ml0 = ml2;
goto _Search2;
}
start2 = start3;
ref2 = ref3;
ml2 = ml3;
goto _Search3;
}
// OK, now we have 3 ascending matches; let's write at least the first one
// ip & ref are known; Now for ml
if (start2 < ip + ml)
{
if (start2 - ip < (int)MLMask)
{
if (ml > OptimalML)
{
ml = OptimalML;
}
if (ip + ml > start2 + ml2 - MinMatch)
{
ml = (int)(start2 - ip) + ml2 - MinMatch;
}
int correction = ml - (int)(start2 - ip);
if (correction > 0)
{
start2 += correction;
ref2 += correction;
ml2 -= correction;
}
}
else
{
ml = (int)(start2 - ip);
}
}
optr = op;
if (EncodeSequence(&ip, &op, &anchor, ml, refPos, limit, oend) != 0)
{
goto _dest_overflow;
}
ip = start2;
refPos = ref2;
ml = ml2;
start2 = start3;
ref2 = ref3;
ml2 = ml3;
goto _Search3;
}
_last_literals: // Encode last literals
{
size_t lastRunSize = (size_t)(iend - anchor); // literals
size_t litLength = (lastRunSize + 255 - RunMask) / 255;
size_t totalSize = 1 + litLength + lastRunSize;
if (limit == LimitedOutputDirective.LimitedDestSize)
{
oend += LastLiterals; // restore correct value
}
if ((limit != 0) && (op + totalSize > oend))
{
if (limit == LimitedOutputDirective.LimitedOutput)
{
return(0); // Check output limit
}
// adapt lastRunSize to fill 'dest'
lastRunSize = (size_t)(oend - op) - 1;
litLength = (lastRunSize + 255 - RunMask) / 255;
lastRunSize -= litLength;
}
ip = anchor + lastRunSize;
if (lastRunSize >= RunMask)
{
size_t accumulator = lastRunSize - RunMask;
*op++ = (byte)(RunMask << MLBits);
for (; accumulator >= 255; accumulator -= 255)
{
*op++ = 255;
}
*op++ = (byte)accumulator;
}
else
{
*op++ = (byte)(lastRunSize << MLBits);
}
LZ4MemoryHelper.Copy(op, anchor, (int)lastRunSize);
op += lastRunSize;
}
// End
*srcSizePtr = (int)(ip - source);
return((int)(op - dest));
_dest_overflow:
if (limit != LimitedOutputDirective.LimitedDestSize)
{
return(0);
}
op = optr; // restore correct out pointer
goto _last_literals;
}
private static CCtxT *AllocCtx()
{
return((CCtxT *)LZ4MemoryHelper.Alloc(sizeof(CCtxT)));
}
