/*

LZ4 HC - High Compression Mode of LZ4

Copyright (C) 2011-2020, Yann Collet.

BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions are

met:

* Redistributions of source code must retain the above copyright

notice, this list of conditions and the following disclaimer.

* Redistributions in binary form must reproduce the above

copyright notice, this list of conditions and the following disclaimer

in the documentation and/or other materials provided with the

distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

You can contact the author at :

- LZ4 source repository : https://github.com/lz4/lz4

- LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c

*/

/* note : lz4hc is not an independent module, it requires lz4.h/lz4.c for proper compilation */

/* *************************************

* Tuning Parameter

***************************************/

/*! HEAPMODE :

* Select how default compression function will allocate workplace memory,

* in stack (0:fastest), or in heap (1:requires malloc()).

* Since workplace is rather large, heap mode is recommended.

**/

#ifndef LZ4HC_HEAPMODE

# define LZ4HC_HEAPMODE 1

#endif

/*=== Dependency ===*/

#define LZ4_HC_STATIC_LINKING_ONLY

#include "lz4hc.h"

/*=== Common definitions ===*/

#if defined(__GNUC__)

# pragma GCC diagnostic ignored "-Wunused-function"

#endif

#if defined (__clang__)

# pragma clang diagnostic ignored "-Wunused-function"

#endif

#define LZ4_COMMONDEFS_ONLY

#ifndef LZ4_SRC_INCLUDED

#include "lz4.c" /* LZ4_count, constants, mem */

#endif

/*=== Enums ===*/

typedef enum { noDictCtx, usingDictCtxHc } dictCtx_directive;

/*=== Constants ===*/

#define OPTIMAL_ML (int)((ML_MASK-1)+MINMATCH)

#define LZ4_OPT_NUM (1<<12)

/*=== Macros ===*/

#define MIN(a,b) ( (a) < (b) ? (a) : (b) )

#define MAX(a,b) ( (a) > (b) ? (a) : (b) )

#define HASH_FUNCTION(i) (((i) * 2654435761U) >> ((MINMATCH*8)-LZ4HC_HASH_LOG))

#define DELTANEXTMAXD(p) chainTable[(p) & LZ4HC_MAXD_MASK] /* flexible, LZ4HC_MAXD dependent */

#define DELTANEXTU16(table, pos) table[(U16)(pos)] /* faster */

/* Make fields passed to, and updated by LZ4HC_encodeSequence explicit */

#define UPDATABLE(ip, op, anchor) &ip, &op, &anchor

static U32 LZ4HC_hashPtr(const void* ptr) { return HASH_FUNCTION(LZ4_read32(ptr)); }

/**************************************

* HC Compression

**************************************/

static void LZ4HC_clearTables (LZ4HC_CCtx_internal* hc4)

{

MEM_INIT(hc4->hashTable, 0, sizeof(hc4->hashTable));

MEM_INIT(hc4->chainTable, 0xFF, sizeof(hc4->chainTable));

}

static void LZ4HC_init_internal (LZ4HC_CCtx_internal* hc4, const BYTE* start)

{

size_t const bufferSize = (size_t)(hc4->end - hc4->prefixStart);

size_t newStartingOffset = bufferSize + hc4->dictLimit;

assert(newStartingOffset >= bufferSize); /* check overflow */

if (newStartingOffset > 1 GB) {

LZ4HC_clearTables(hc4);

newStartingOffset = 0;

}

newStartingOffset += 64 KB;

hc4->nextToUpdate = (U32)newStartingOffset;

hc4->prefixStart = start;

hc4->end = start;

hc4->dictStart = start;

hc4->dictLimit = (U32)newStartingOffset;

hc4->lowLimit = (U32)newStartingOffset;

}

/* Update chains up to ip (excluded) */

LZ4_FORCE_INLINE void LZ4HC_Insert (LZ4HC_CCtx_internal* hc4, const BYTE* ip)

{

U16* const chainTable = hc4->chainTable;

U32* const hashTable = hc4->hashTable;

const BYTE* const prefixPtr = hc4->prefixStart;

U32 const prefixIdx = hc4->dictLimit;

U32 const target = (U32)(ip - prefixPtr) + prefixIdx;

U32 idx = hc4->nextToUpdate;

assert(ip >= prefixPtr);

assert(target >= prefixIdx);

while (idx < target) {

U32 const h = LZ4HC_hashPtr(prefixPtr+idx-prefixIdx);

size_t delta = idx - hashTable[h];

if (delta>LZ4_DISTANCE_MAX) delta = LZ4_DISTANCE_MAX;

DELTANEXTU16(chainTable, idx) = (U16)delta;

hashTable[h] = idx;

idx++;

}

hc4->nextToUpdate = target;

}

/** LZ4HC_countBack() :

* @return : negative value, nb of common bytes before ip/match */

LZ4_FORCE_INLINE

int LZ4HC_countBack(const BYTE* const ip, const BYTE* const match,

const BYTE* const iMin, const BYTE* const mMin)

{

int back = 0;

int const min = (int)MAX(iMin - ip, mMin - match);

assert(min <= 0);

assert(ip >= iMin); assert((size_t)(ip-iMin) < (1U<<31));

assert(match >= mMin); assert((size_t)(match - mMin) < (1U<<31));

while ( (back > min)

&& (ip[back-1] == match[back-1]) )

back--;

return back;

}

#if defined(_MSC_VER)

# define LZ4HC_rotl32(x,r) _rotl(x,r)

#else

# define LZ4HC_rotl32(x,r) ((x << r) | (x >> (32 - r)))

#endif

static U32 LZ4HC_rotatePattern(size_t const rotate, U32 const pattern)

{

size_t const bitsToRotate = (rotate & (sizeof(pattern) - 1)) << 3;

if (bitsToRotate == 0) return pattern;

return LZ4HC_rotl32(pattern, (int)bitsToRotate);

}

/* LZ4HC_countPattern() :

* pattern32 must be a sample of repetitive pattern of length 1, 2 or 4 (but not 3!) */

static unsigned

LZ4HC_countPattern(const BYTE* ip, const BYTE* const iEnd, U32 const pattern32)

{

const BYTE* const iStart = ip;

reg_t const pattern = (sizeof(pattern)==8) ?

(reg_t)pattern32 + (((reg_t)pattern32) << (sizeof(pattern)*4)) : pattern32;

while (likely(ip < iEnd-(sizeof(pattern)-1))) {

reg_t const diff = LZ4_read_ARCH(ip) ^ pattern;

if (!diff) { ip+=sizeof(pattern); continue; }

ip += LZ4_NbCommonBytes(diff);

return (unsigned)(ip - iStart);

}

if (LZ4_isLittleEndian()) {

reg_t patternByte = pattern;

while ((ip<iEnd) && (*ip == (BYTE)patternByte)) {

ip++; patternByte >>= 8;

}

} else { /* big endian */

U32 bitOffset = (sizeof(pattern)*8) - 8;

while (ip < iEnd) {

BYTE const byte = (BYTE)(pattern >> bitOffset);

if (*ip != byte) break;

ip ++; bitOffset -= 8;

} }

return (unsigned)(ip - iStart);

}

/* LZ4HC_reverseCountPattern() :

* pattern must be a sample of repetitive pattern of length 1, 2 or 4 (but not 3!)

* read using natural platform endianness */

static unsigned

LZ4HC_reverseCountPattern(const BYTE* ip, const BYTE* const iLow, U32 pattern)

{

const BYTE* const iStart = ip;

while (likely(ip >= iLow+4)) {

if (LZ4_read32(ip-4) != pattern) break;

ip -= 4;

}

{ const BYTE* bytePtr = (const BYTE*)(&pattern) + 3; /* works for any endianness */

while (likely(ip>iLow)) {

if (ip[-1] != *bytePtr) break;

ip--; bytePtr--;

} }

return (unsigned)(iStart - ip);

}

/* LZ4HC_protectDictEnd() :

* Checks if the match is in the last 3 bytes of the dictionary, so reading the

* 4 byte MINMATCH would overflow.

* @returns true if the match index is okay.

*/

static int LZ4HC_protectDictEnd(U32 const dictLimit, U32 const matchIndex)

{

return ((U32)((dictLimit - 1) - matchIndex) >= 3);

}

typedef enum { rep_untested, rep_not, rep_confirmed } repeat_state_e;

typedef enum { favorCompressionRatio=0, favorDecompressionSpeed } HCfavor_e;

LZ4_FORCE_INLINE int

LZ4HC_InsertAndGetWiderMatch (

const HCfavor_e favorDecSpeed)

{

U16* const chainTable = hc4->chainTable;

U32* const HashTable = hc4->hashTable;

const LZ4HC_CCtx_internal * const dictCtx = hc4->dictCtx;

const BYTE* const prefixPtr = hc4->prefixStart;

const U32 prefixIdx = hc4->dictLimit;

const U32 ipIndex = (U32)(ip - prefixPtr) + prefixIdx;

const int withinStartDistance = (hc4->lowLimit + (LZ4_DISTANCE_MAX + 1) > ipIndex);

const U32 lowestMatchIndex = (withinStartDistance) ? hc4->lowLimit : ipIndex - LZ4_DISTANCE_MAX;

const BYTE* const dictStart = hc4->dictStart;

const U32 dictIdx = hc4->lowLimit;

const BYTE* const dictEnd = dictStart + prefixIdx - dictIdx;

int const lookBackLength = (int)(ip-iLowLimit);

int nbAttempts = maxNbAttempts;

U32 matchChainPos = 0;

U32 const pattern = LZ4_read32(ip);

U32 matchIndex;

repeat_state_e repeat = rep_untested;

size_t srcPatternLength = 0;

DEBUGLOG(7, "LZ4HC_InsertAndGetWiderMatch");

/* First Match */

LZ4HC_Insert(hc4, ip);

matchIndex = HashTable[LZ4HC_hashPtr(ip)];

DEBUGLOG(7, "First match at index %u / %u (lowestMatchIndex)",

matchIndex, lowestMatchIndex);

while ((matchIndex>=lowestMatchIndex) && (nbAttempts>0)) {

int matchLength=0;

nbAttempts--;

assert(matchIndex < ipIndex);

if (favorDecSpeed && (ipIndex - matchIndex < 8)) {

/* do nothing */

} else if (matchIndex >= prefixIdx) { /* within current Prefix */

const BYTE* const matchPtr = prefixPtr + matchIndex - prefixIdx;

assert(matchPtr < ip);

assert(longest >= 1);

if (LZ4_read16(iLowLimit + longest - 1) == LZ4_read16(matchPtr - lookBackLength + longest - 1)) {

if (LZ4_read32(matchPtr) == pattern) {

int const back = lookBackLength ? LZ4HC_countBack(ip, matchPtr, iLowLimit, prefixPtr) : 0;

matchLength = MINMATCH + (int)LZ4_count(ip+MINMATCH, matchPtr+MINMATCH, iHighLimit);

matchLength -= back;

if (matchLength > longest) {

longest = matchLength;

*matchpos = matchPtr + back;

*startpos = ip + back;

} } }

} else { /* lowestMatchIndex <= matchIndex < dictLimit */

const BYTE* const matchPtr = dictStart + (matchIndex - dictIdx);

assert(matchIndex >= dictIdx);

if ( likely(matchIndex <= prefixIdx - 4)

&& (LZ4_read32(matchPtr) == pattern) ) {

int back = 0;

const BYTE* vLimit = ip + (prefixIdx - matchIndex);

if (vLimit > iHighLimit) vLimit = iHighLimit;

matchLength = (int)LZ4_count(ip+MINMATCH, matchPtr+MINMATCH, vLimit) + MINMATCH;

if ((ip+matchLength == vLimit) && (vLimit < iHighLimit))

matchLength += LZ4_count(ip+matchLength, prefixPtr, iHighLimit);

back = lookBackLength ? LZ4HC_countBack(ip, matchPtr, iLowLimit, dictStart) : 0;

matchLength -= back;

if (matchLength > longest) {

longest = matchLength;

*matchpos = prefixPtr - prefixIdx + matchIndex + back; /* virtual pos, relative to ip, to retrieve offset */

*startpos = ip + back;

} } }

if (chainSwap && matchLength==longest) { /* better match => select a better chain */

assert(lookBackLength==0); /* search forward only */

if (matchIndex + (U32)longest <= ipIndex) {

int const kTrigger = 4;

U32 distanceToNextMatch = 1;

int const end = longest - MINMATCH + 1;

int step = 1;

int accel = 1 << kTrigger;

int pos;

for (pos = 0; pos < end; pos += step) {

U32 const candidateDist = DELTANEXTU16(chainTable, matchIndex + (U32)pos);

step = (accel++ >> kTrigger);

if (candidateDist > distanceToNextMatch) {

distanceToNextMatch = candidateDist;

matchChainPos = (U32)pos;

accel = 1 << kTrigger;

} }

if (distanceToNextMatch > 1) {

if (distanceToNextMatch > matchIndex) break; /* avoid overflow */

matchIndex -= distanceToNextMatch;

continue;

} } }

{ U32 const distNextMatch = DELTANEXTU16(chainTable, matchIndex);

if (patternAnalysis && distNextMatch==1 && matchChainPos==0) {

U32 const matchCandidateIdx = matchIndex-1;

/* may be a repeated pattern */

if (repeat == rep_untested) {

if ( ((pattern & 0xFFFF) == (pattern >> 16))

& ((pattern & 0xFF) == (pattern >> 24)) ) {

repeat = rep_confirmed;

srcPatternLength = LZ4HC_countPattern(ip+sizeof(pattern), iHighLimit, pattern) + sizeof(pattern);

} else {

repeat = rep_not;

} }

if ( (repeat == rep_confirmed) && (matchCandidateIdx >= lowestMatchIndex)

&& LZ4HC_protectDictEnd(prefixIdx, matchCandidateIdx) ) {

const int extDict = matchCandidateIdx < prefixIdx;

const BYTE* const matchPtr = (extDict ? dictStart - dictIdx : prefixPtr - prefixIdx) + matchCandidateIdx;

if (LZ4_read32(matchPtr) == pattern) { /* good candidate */

const BYTE* const iLimit = extDict ? dictEnd : iHighLimit;

size_t forwardPatternLength = LZ4HC_countPattern(matchPtr+sizeof(pattern), iLimit, pattern) + sizeof(pattern);

if (extDict && matchPtr + forwardPatternLength == iLimit) {

U32 const rotatedPattern = LZ4HC_rotatePattern(forwardPatternLength, pattern);

forwardPatternLength += LZ4HC_countPattern(prefixPtr, iHighLimit, rotatedPattern);

}

{ const BYTE* const lowestMatchPtr = extDict ? dictStart : prefixPtr;

size_t backLength = LZ4HC_reverseCountPattern(matchPtr, lowestMatchPtr, pattern);

size_t currentSegmentLength;

if (!extDict

&& matchPtr - backLength == prefixPtr

&& dictIdx < prefixIdx) {

U32 const rotatedPattern = LZ4HC_rotatePattern((U32)(-(int)backLength), pattern);

backLength += LZ4HC_reverseCountPattern(dictEnd, dictStart, rotatedPattern);

}

/* Limit backLength not go further than lowestMatchIndex */

backLength = matchCandidateIdx - MAX(matchCandidateIdx - (U32)backLength, lowestMatchIndex);

assert(matchCandidateIdx - backLength >= lowestMatchIndex);

currentSegmentLength = backLength + forwardPatternLength;

/* Adjust to end of pattern if the source pattern fits, otherwise the beginning of the pattern */

if ( (currentSegmentLength >= srcPatternLength) /* current pattern segment large enough to contain full srcPatternLength */

&& (forwardPatternLength <= srcPatternLength) ) { /* haven't reached this position yet */

U32 const newMatchIndex = matchCandidateIdx + (U32)forwardPatternLength - (U32)srcPatternLength; /* best position, full pattern, might be followed by more match */

if (LZ4HC_protectDictEnd(prefixIdx, newMatchIndex))

matchIndex = newMatchIndex;

else {

/* Can only happen if started in the prefix */

assert(newMatchIndex >= prefixIdx - 3 && newMatchIndex < prefixIdx && !extDict);

matchIndex = prefixIdx;

}

} else {

U32 const newMatchIndex = matchCandidateIdx - (U32)backLength; /* farthest position in current segment, will find a match of length currentSegmentLength + maybe some back */

if (!LZ4HC_protectDictEnd(prefixIdx, newMatchIndex)) {

assert(newMatchIndex >= prefixIdx - 3 && newMatchIndex < prefixIdx && !extDict);

matchIndex = prefixIdx;

} else {

matchIndex = newMatchIndex;

if (lookBackLength==0) { /* no back possible */

size_t const maxML = MIN(currentSegmentLength, srcPatternLength);

if ((size_t)longest < maxML) {

assert(prefixPtr - prefixIdx + matchIndex != ip);

if ((size_t)(ip - prefixPtr) + prefixIdx - matchIndex > LZ4_DISTANCE_MAX) break;

assert(maxML < 2 GB);

longest = (int)maxML;

*matchpos = prefixPtr - prefixIdx + matchIndex; /* virtual pos, relative to ip, to retrieve offset */

*startpos = ip;

}

{ U32 const distToNextPattern = DELTANEXTU16(chainTable, matchIndex);

if (distToNextPattern > matchIndex) break; /* avoid overflow */

matchIndex -= distToNextPattern;

} } } } }

continue;

} }

} } /* PA optimization */

/* follow current chain */

matchIndex -= DELTANEXTU16(chainTable, matchIndex + matchChainPos);

} /* while ((matchIndex>=lowestMatchIndex) && (nbAttempts)) */

if ( dict == usingDictCtxHc

&& nbAttempts > 0

&& ipIndex - lowestMatchIndex < LZ4_DISTANCE_MAX) {

size_t const dictEndOffset = (size_t)(dictCtx->end - dictCtx->prefixStart) + dictCtx->dictLimit;

U32 dictMatchIndex = dictCtx->hashTable[LZ4HC_hashPtr(ip)];

assert(dictEndOffset <= 1 GB);

matchIndex = dictMatchIndex + lowestMatchIndex - (U32)dictEndOffset;

while (ipIndex - matchIndex <= LZ4_DISTANCE_MAX && nbAttempts--) {

const BYTE* const matchPtr = dictCtx->prefixStart - dictCtx->dictLimit + dictMatchIndex;

if (LZ4_read32(matchPtr) == pattern) {

int mlt;

int back = 0;

const BYTE* vLimit = ip + (dictEndOffset - dictMatchIndex);

if (vLimit > iHighLimit) vLimit = iHighLimit;

mlt = (int)LZ4_count(ip+MINMATCH, matchPtr+MINMATCH, vLimit) + MINMATCH;

back = lookBackLength ? LZ4HC_countBack(ip, matchPtr, iLowLimit, dictCtx->prefixStart) : 0;

mlt -= back;

if (mlt > longest) {

longest = mlt;

*matchpos = prefixPtr - prefixIdx + matchIndex + back;

*startpos = ip + back;

} }

{ U32 const nextOffset = DELTANEXTU16(dictCtx->chainTable, dictMatchIndex);

dictMatchIndex -= nextOffset;

matchIndex -= nextOffset;

} } }

return longest;

}

LZ4_FORCE_INLINE int

LZ4HC_InsertAndFindBestMatch(LZ4HC_CCtx_internal* const hc4, /* Index table will be updated */

const dictCtx_directive dict)

{

const BYTE* uselessPtr = ip;

/* note : LZ4HC_InsertAndGetWiderMatch() is able to modify the starting position of a match (*startpos),

* but this won't be the case here, as we define iLowLimit==ip,

* so LZ4HC_InsertAndGetWiderMatch() won't be allowed to search past ip */

return LZ4HC_InsertAndGetWiderMatch(hc4, ip, ip, iLimit, MINMATCH-1, matchpos, &uselessPtr, maxNbAttempts, patternAnalysis, 0 /*chainSwap*/, dict, favorCompressionRatio);

}

/* LZ4HC_encodeSequence() :

* @return : 0 if ok,

* 1 if buffer issue detected */

LZ4_FORCE_INLINE int LZ4HC_encodeSequence (

BYTE* oend)

{

#define ip (*_ip)

#define op (*_op)

#define anchor (*_anchor)

size_t length;

BYTE* const token = op++;

#if defined(LZ4_DEBUG) && (LZ4_DEBUG >= 6)

static const BYTE* start = NULL;

static U32 totalCost = 0;

U32 const pos = (start==NULL) ? 0 : (U32)(anchor - start);

U32 const ll = (U32)(ip - anchor);

U32 const llAdd = (ll>=15) ? ((ll-15) / 255) + 1 : 0;

U32 const mlAdd = (matchLength>=19) ? ((matchLength-19) / 255) + 1 : 0;

U32 const cost = 1 + llAdd + ll + 2 + mlAdd;

if (start==NULL) start = anchor; /* only works for single segment */

/* g_debuglog_enable = (pos >= 2228) & (pos <= 2262); */

DEBUGLOG(6, "pos:%7u -- literals:%4u, match:%4i, offset:%5u, cost:%4u + %5u",

pos,

(U32)(ip - anchor), matchLength, (U32)(ip-match),

cost, totalCost);

totalCost += cost;

#endif

/* Encode Literal length */

length = (size_t)(ip - anchor);

LZ4_STATIC_ASSERT(notLimited == 0);

/* Check output limit */

if (limit && ((op + (length / 255) + length + (2 + 1 + LASTLITERALS)) > oend)) {

DEBUGLOG(6, "Not enough room to write %i literals (%i bytes remaining)",

(int)length, (int)(oend - op));

return 1;

}

if (length >= RUN_MASK) {

size_t len = length - RUN_MASK;

*token = (RUN_MASK << ML_BITS);

for(; len >= 255 ; len -= 255) *op++ = 255;

*op++ = (BYTE)len;

} else {

*token = (BYTE)(length << ML_BITS);

}

/* Copy Literals */

LZ4_wildCopy8(op, anchor, op + length);

op += length;

/* Encode Offset */

assert( (ip - match) <= LZ4_DISTANCE_MAX ); /* note : consider providing offset as a value, rather than as a pointer difference */

LZ4_writeLE16(op, (U16)(ip - match)); op += 2;

/* Encode MatchLength */

assert(matchLength >= MINMATCH);

length = (size_t)matchLength - MINMATCH;

if (limit && (op + (length / 255) + (1 + LASTLITERALS) > oend)) {

DEBUGLOG(6, "Not enough room to write match length");

return 1; /* Check output limit */

}

if (length >= ML_MASK) {

*token += ML_MASK;

length -= ML_MASK;

for(; length >= 510 ; length -= 510) { *op++ = 255; *op++ = 255; }

if (length >= 255) { length -= 255; *op++ = 255; }

*op++ = (BYTE)length;

} else {

*token += (BYTE)(length);

}

/* Prepare next loop */

ip += matchLength;

anchor = ip;

return 0;

}

#undef ip

#undef op

#undef anchor

LZ4_FORCE_INLINE int LZ4HC_compress_hashChain (

)

{

const int inputSize = *srcSizePtr;

const int patternAnalysis = (maxNbAttempts > 128); /* levels 9+ */

const BYTE* ip = (const BYTE*) source;

const BYTE* anchor = ip;

const BYTE* const iend = ip + inputSize;

const BYTE* const mflimit = iend - MFLIMIT;

const BYTE* const matchlimit = (iend - LASTLITERALS);

BYTE* optr = (BYTE*) dest;

BYTE* op = (BYTE*) dest;

BYTE* oend = op + maxOutputSize;

int ml0, ml, ml2, ml3;

const BYTE* start0;

const BYTE* ref0;

const BYTE* ref = NULL;

const BYTE* start2 = NULL;

const BYTE* ref2 = NULL;

const BYTE* start3 = NULL;

const BYTE* ref3 = NULL;

/* init */

*srcSizePtr = 0;

if (limit == fillOutput) oend -= LASTLITERALS; /* Hack for support LZ4 format restriction */

if (inputSize < LZ4_minLength) goto _last_literals; /* Input too small, no compression (all literals) */

/* Main Loop */

while (ip <= mflimit) {

ml = LZ4HC_InsertAndFindBestMatch(ctx, ip, matchlimit, &ref, maxNbAttempts, patternAnalysis, dict);

if (ml<MINMATCH) { ip++; continue; }

/* saved, in case we would skip too much */

start0 = ip; ref0 = ref; ml0 = ml;

_Search2:

if (ip+ml <= mflimit) {

ml2 = LZ4HC_InsertAndGetWiderMatch(ctx,

ip + ml - 2, ip + 0, matchlimit, ml, &ref2, &start2,

maxNbAttempts, patternAnalysis, 0, dict, favorCompressionRatio);

} else {

ml2 = ml;

}

if (ml2 == ml) { /* No better match => encode ML1 */

optr = op;

if (LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor), ml, ref, limit, oend)) goto _dest_overflow;

continue;

}

if (start0 < ip) { /* first match was skipped at least once */

if (start2 < ip + ml0) { /* squeezing ML1 between ML0(original ML1) and ML2 */

ip = start0; ref = ref0; ml = ml0; /* restore initial ML1 */

} }

/* Here, start0==ip */

if ((start2 - ip) < 3) { /* First Match too small : removed */

ml = ml2;

ip = start2;

ref =ref2;

goto _Search2;

}

_Search3:

/* At this stage, we have :

* ml2 > ml1, and

* ip1+3 <= ip2 (usually < ip1+ml1) */

if ((start2 - ip) < OPTIMAL_ML) {

int correction;

int new_ml = ml;

if (new_ml > OPTIMAL_ML) new_ml = OPTIMAL_ML;

if (ip+new_ml > start2 + ml2 - MINMATCH) new_ml = (int)(start2 - ip) + ml2 - MINMATCH;

correction = new_ml - (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) */

if (start2 + ml2 <= mflimit) {

ml3 = LZ4HC_InsertAndGetWiderMatch(ctx,

start2 + ml2 - 3, start2, matchlimit, ml2, &ref3, &start3,

maxNbAttempts, patternAnalysis, 0, dict, favorCompressionRatio);

} else {

ml3 = ml2;

}

if (ml3 == ml2) { /* No better match => encode ML1 and ML2 */

/* ip & ref are known; Now for ml */

if (start2 < ip+ml) ml = (int)(start2 - ip);

/* Now, encode 2 sequences */

optr = op;

if (LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor), ml, ref, limit, oend)) goto _dest_overflow;

ip = start2;

optr = op;

if (LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor), ml2, ref2, limit, oend)) {

ml = ml2;

ref = ref2;

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 (LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor), ml, ref, limit, oend)) goto _dest_overflow;

ip = start3;

ref = 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 the first one ML1.

* ip & ref are known; Now decide ml.

*/

if (start2 < ip+ml) {

if ((start2 - ip) < OPTIMAL_ML) {

int correction;

if (ml > OPTIMAL_ML) ml = OPTIMAL_ML;

if (ip + ml > start2 + ml2 - MINMATCH) ml = (int)(start2 - ip) + ml2 - MINMATCH;

correction = ml - (int)(start2 - ip);

if (correction > 0) {

start2 += correction;

ref2 += correction;

ml2 -= correction;

}

} else {

ml = (int)(start2 - ip);

}

}

optr = op;

if (LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor), ml, ref, limit, oend)) goto _dest_overflow;

/* ML2 becomes ML1 */

ip = start2; ref = ref2; ml = ml2;

/* ML3 becomes ML2 */

start2 = start3; ref2 = ref3; ml2 = ml3;

/* let's find a new ML3 */

goto _Search3;

}

_last_literals:

/* Encode Last Literals */

{ size_t lastRunSize = (size_t)(iend - anchor); /* literals */

size_t llAdd = (lastRunSize + 255 - RUN_MASK) / 255;

size_t const totalSize = 1 + llAdd + lastRunSize;

if (limit == fillOutput) oend += LASTLITERALS; /* restore correct value */

if (limit && (op + totalSize > oend)) {

if (limit == limitedOutput) return 0;

/* adapt lastRunSize to fill 'dest' */

lastRunSize = (size_t)(oend - op) - 1 /*token*/;

llAdd = (lastRunSize + 256 - RUN_MASK) / 256;

lastRunSize -= llAdd;

}

DEBUGLOG(6, "Final literal run : %i literals", (int)lastRunSize);

ip = anchor + lastRunSize; /* can be != iend if limit==fillOutput */

if (lastRunSize >= RUN_MASK) {

size_t accumulator = lastRunSize - RUN_MASK;

*op++ = (RUN_MASK << ML_BITS);

for(; accumulator >= 255 ; accumulator -= 255) *op++ = 255;

*op++ = (BYTE) accumulator;

} else {

*op++ = (BYTE)(lastRunSize << ML_BITS);

}

LZ4_memcpy(op, anchor, lastRunSize);

op += lastRunSize;

}

/* End */

*srcSizePtr = (int) (((const char*)ip) - source);

return (int) (((char*)op)-dest);

_dest_overflow:

if (limit == fillOutput) {

/* Assumption : ip, anchor, ml and ref must be set correctly */

size_t const ll = (size_t)(ip - anchor);

size_t const ll_addbytes = (ll + 240) / 255;

size_t const ll_totalCost = 1 + ll_addbytes + ll;

BYTE* const maxLitPos = oend - 3; /* 2 for offset, 1 for token */

DEBUGLOG(6, "Last sequence overflowing");

op = optr; /* restore correct out pointer */

if (op + ll_totalCost <= maxLitPos) {

/* ll validated; now adjust match length */

size_t const bytesLeftForMl = (size_t)(maxLitPos - (op+ll_totalCost));

size_t const maxMlSize = MINMATCH + (ML_MASK-1) + (bytesLeftForMl * 255);

assert(maxMlSize < INT_MAX); assert(ml >= 0);

if ((size_t)ml > maxMlSize) ml = (int)maxMlSize;

if ((oend + LASTLITERALS) - (op + ll_totalCost + 2) - 1 + ml >= MFLIMIT) {

LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor), ml, ref, notLimited, oend);

} }

goto _last_literals;

}

/* compression failed */

return 0;

}

static int LZ4HC_compress_optimal( LZ4HC_CCtx_internal* ctx,

const HCfavor_e favorDecSpeed);

LZ4_FORCE_INLINE int LZ4HC_compress_generic_internal (

)

{

typedef enum { lz4hc, lz4opt } lz4hc_strat_e;

typedef struct {

lz4hc_strat_e strat;

int nbSearches;

U32 targetLength;

} cParams_t;

static const cParams_t clTable[LZ4HC_CLEVEL_MAX+1] = {

{ lz4hc, 2, 16 }, /* 0, unused */

{ lz4hc, 2, 16 }, /* 1, unused */

{ lz4hc, 2, 16 }, /* 2, unused */

{ lz4hc, 4, 16 }, /* 3 */

{ lz4hc, 8, 16 }, /* 4 */

{ lz4hc, 16, 16 }, /* 5 */

{ lz4hc, 32, 16 }, /* 6 */

{ lz4hc, 64, 16 }, /* 7 */

{ lz4hc, 128, 16 }, /* 8 */

{ lz4hc, 256, 16 }, /* 9 */

{ lz4opt, 96, 64 }, /*10==LZ4HC_CLEVEL_OPT_MIN*/

{ lz4opt, 512,128 }, /*11 */

{ lz4opt,16384,LZ4_OPT_NUM }, /* 12==LZ4HC_CLEVEL_MAX */

};

DEBUGLOG(4, "LZ4HC_compress_generic(ctx=%p, src=%p, srcSize=%d, limit=%d)",

ctx, src, *srcSizePtr, limit);

if (limit == fillOutput && dstCapacity < 1) return 0; /* Impossible to store anything */

if ((U32)*srcSizePtr > (U32)LZ4_MAX_INPUT_SIZE) return 0; /* Unsupported input size (too large or negative) */

ctx->end += *srcSizePtr;

if (cLevel < 1) cLevel = LZ4HC_CLEVEL_DEFAULT; /* note : convention is different from lz4frame, maybe something to review */

cLevel = MIN(LZ4HC_CLEVEL_MAX, cLevel);

{ cParams_t const cParam = clTable[cLevel];

HCfavor_e const favor = ctx->favorDecSpeed ? favorDecompressionSpeed : favorCompressionRatio;

int result;

if (cParam.strat == lz4hc) {

result = LZ4HC_compress_hashChain(ctx,

src, dst, srcSizePtr, dstCapacity,

cParam.nbSearches, limit, dict);

} else {

assert(cParam.strat == lz4opt);

result = LZ4HC_compress_optimal(ctx,

src, dst, srcSizePtr, dstCapacity,

cParam.nbSearches, cParam.targetLength, limit,

cLevel == LZ4HC_CLEVEL_MAX, /* ultra mode */

dict, favor);

}

if (result <= 0) ctx->dirty = 1;

return result;

}

}

static void LZ4HC_setExternalDict(LZ4HC_CCtx_internal* ctxPtr, const BYTE* newBlock);

static int

LZ4HC_compress_generic_noDictCtx (

)

{

assert(ctx->dictCtx == NULL);

return LZ4HC_compress_generic_internal(ctx, src, dst, srcSizePtr, dstCapacity, cLevel, limit, noDictCtx);

}

static int

LZ4HC_compress_generic_dictCtx (

)

{

const size_t position = (size_t)(ctx->end - ctx->prefixStart) + (ctx->dictLimit - ctx->lowLimit);

assert(ctx->dictCtx != NULL);

if (position >= 64 KB) {

ctx->dictCtx = NULL;

return LZ4HC_compress_generic_noDictCtx(ctx, src, dst, srcSizePtr, dstCapacity, cLevel, limit);

} else if (position == 0 && *srcSizePtr > 4 KB) {

LZ4_memcpy(ctx, ctx->dictCtx, sizeof(LZ4HC_CCtx_internal));

LZ4HC_setExternalDict(ctx, (const BYTE *)src);

ctx->compressionLevel = (short)cLevel;

return LZ4HC_compress_generic_noDictCtx(ctx, src, dst, srcSizePtr, dstCapacity, cLevel, limit);

} else {

return LZ4HC_compress_generic_internal(ctx, src, dst, srcSizePtr, dstCapacity, cLevel, limit, usingDictCtxHc);

}

}

static int

LZ4HC_compress_generic (

)

{

if (ctx->dictCtx == NULL) {

return LZ4HC_compress_generic_noDictCtx(ctx, src, dst, srcSizePtr, dstCapacity, cLevel, limit);

} else {

return LZ4HC_compress_generic_dictCtx(ctx, src, dst, srcSizePtr, dstCapacity, cLevel, limit);

}

}

int LZ4_sizeofStateHC(void) { return (int)sizeof(LZ4_streamHC_t); }

static size_t LZ4_streamHC_t_alignment(void)

{

#if LZ4_ALIGN_TEST

typedef struct { char c; LZ4_streamHC_t t; } t_a;

return sizeof(t_a) - sizeof(LZ4_streamHC_t);

#else

return 1; /* effectively disabled */

#endif

}

/* state is presumed correctly initialized,

* in which case its size and alignment have already been validate */

int LZ4_compress_HC_extStateHC_fastReset (void* state, const char* src, char* dst, int srcSize, int dstCapacity, int compressionLevel)

{

LZ4HC_CCtx_internal* const ctx = &((LZ4_streamHC_t*)state)->internal_donotuse;

if (!LZ4_isAligned(state, LZ4_streamHC_t_alignment())) return 0;

LZ4_resetStreamHC_fast((LZ4_streamHC_t*)state, compressionLevel);

LZ4HC_init_internal (ctx, (const BYTE*)src);

if (dstCapacity < LZ4_compressBound(srcSize))

return LZ4HC_compress_generic (ctx, src, dst, &srcSize, dstCapacity, compressionLevel, limitedOutput);

else

return LZ4HC_compress_generic (ctx, src, dst, &srcSize, dstCapacity, compressionLevel, notLimited);

}

int LZ4_compress_HC_extStateHC (void* state, const char* src, char* dst, int srcSize, int dstCapacity, int compressionLevel)

{

LZ4_streamHC_t* const ctx = LZ4_initStreamHC(state, sizeof(*ctx));

if (ctx==NULL) return 0; /* init failure */

return LZ4_compress_HC_extStateHC_fastReset(state, src, dst, srcSize, dstCapacity, compressionLevel);

}

int LZ4_compress_HC(const char* src, char* dst, int srcSize, int dstCapacity, int compressionLevel)

{

int cSize;

#if defined(LZ4HC_HEAPMODE) && LZ4HC_HEAPMODE==1

LZ4_streamHC_t* const statePtr = (LZ4_streamHC_t*)ALLOC(sizeof(LZ4_streamHC_t));

if (statePtr==NULL) return 0;

#else

LZ4_streamHC_t state;

LZ4_streamHC_t* const statePtr = &state;

#endif

cSize = LZ4_compress_HC_extStateHC(statePtr, src, dst, srcSize, dstCapacity, compressionLevel);

#if defined(LZ4HC_HEAPMODE) && LZ4HC_HEAPMODE==1

FREEMEM(statePtr);

#endif

return cSize;

}

/* state is presumed sized correctly (>= sizeof(LZ4_streamHC_t)) */

int LZ4_compress_HC_destSize(void* state, const char* source, char* dest, int* sourceSizePtr, int targetDestSize, int cLevel)

{

LZ4_streamHC_t* const ctx = LZ4_initStreamHC(state, sizeof(*ctx));

if (ctx==NULL) return 0; /* init failure */

LZ4HC_init_internal(&ctx->internal_donotuse, (const BYTE*) source);

LZ4_setCompressionLevel(ctx, cLevel);

return LZ4HC_compress_generic(&ctx->internal_donotuse, source, dest, sourceSizePtr, targetDestSize, cLevel, fillOutput);

}

/**************************************

* Streaming Functions

**************************************/

/* allocation */

#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION)

LZ4_streamHC_t* LZ4_createStreamHC(void)

{

LZ4_streamHC_t* const state =

(LZ4_streamHC_t*)ALLOC_AND_ZERO(sizeof(LZ4_streamHC_t));

if (state == NULL) return NULL;

LZ4_setCompressionLevel(state, LZ4HC_CLEVEL_DEFAULT);

return state;

}