- Zstd source repository : https://www.zstd.net
*/
-/* Note : this file is intended to be included within zstd_compress.c */
-
-
-/*- Local types -*/
-typedef struct {
- U32 off;
- U32 len;
- U32 back;
-} ZSTD_match_t;
-
-typedef struct {
- U32 price;
- U32 off;
- U32 mlen;
- U32 litlen;
- U32 rep;
- U32 rep2;
-} ZSTD_optimal_t;
-
-
-/*- Constants -*/
-#define ZSTD_OPT_NUM (1<<12)
-#define ZSTD_FREQ_START 1
-#define ZSTD_FREQ_STEP 1
-#define ZSTD_FREQ_DIV 6
-
-/*- Debug -*/
-#if defined(ZSTD_OPT_DEBUG) && ZSTD_OPT_DEBUG>=9
- #define ZSTD_LOG_PARSER(...) printf(__VA_ARGS__)
- #define ZSTD_LOG_ENCODE(...) printf(__VA_ARGS__)
- #define ZSTD_LOG_TRY_PRICE(...) printf(__VA_ARGS__)
-#else
- #define ZSTD_LOG_PARSER(...)
- #define ZSTD_LOG_ENCODE(...)
- #define ZSTD_LOG_TRY_PRICE(...)
-#endif
-
-
-#if MINMATCH == 3
- #define MEM_readMINMATCH(ptr) ((U32)(MEM_read32(ptr)<<8))
-#else
- #define MEM_readMINMATCH(ptr) (U32)(MEM_read32(ptr))
-#endif
-
-
-FORCE_INLINE U32 ZSTD_getLiteralPrice(seqStore_t* seqStorePtr, U32 litLength, const BYTE* literals)
-{
- U32 price, u;
-
- /* literals */
- price = litLength * ZSTD_highbit(seqStorePtr->litSum);
- for (u=0; u < litLength; u++)
- price -= ZSTD_highbit(seqStorePtr->litFreq[literals[u]]);
-
- /* literal Length */
- price += ((litLength >= MaxLL)<<3) + ((litLength >= 255+MaxLL)<<4) + ((litLength>=(1<<15))<<3);
- if (litLength >= MaxLL) litLength = MaxLL;
- price += ZSTD_highbit(seqStorePtr->litLengthSum) - ZSTD_highbit(seqStorePtr->litLengthFreq[litLength]);
-
- return price;
-}
+/* Note : this file is intended to be included within zstd_opt_internal.h */
-FORCE_INLINE U32 ZSTD_getPrice(seqStore_t* seqStorePtr, U32 litLength, const BYTE* literals, U32 offset, U32 matchLength)
+FORCE_INLINE U32 ZSTD_GETPRICE(seqStore_t* seqStorePtr, U32 litLength, const BYTE* literals, U32 offset, U32 matchLength)
{
/* offset */
BYTE offCode = offset ? (BYTE)ZSTD_highbit(offset) + 1 : 0;
U32 price = offCode + ZSTD_highbit(seqStorePtr->offCodeSum) - ZSTD_highbit(seqStorePtr->offCodeFreq[offCode]);
/* match Length */
- matchLength -= MINMATCH;
+ matchLength -= MINMATCHOPT;
price += ((matchLength >= MaxML)<<3) + ((matchLength >= 255+MaxML)<<4) + ((matchLength>=(1<<15))<<3);
if (matchLength >= MaxML) matchLength = MaxML;
price += ZSTD_highbit(seqStorePtr->matchLengthSum) - ZSTD_highbit(seqStorePtr->matchLengthFreq[matchLength]);
}
-MEM_STATIC void ZSTD_rescaleFreqs(seqStore_t* ssPtr)
-{
- unsigned u;
-
- // printf("matchLengthSum=%d litLengthSum=%d litSum=%d offCodeSum=%d\n", ssPtr->matchLengthSum, ssPtr->litLengthSum, ssPtr->litSum, ssPtr->offCodeSum);
-
- if (ssPtr->litLengthSum == 0) {
- ssPtr->matchLengthSum = (1<<MLbits);
- ssPtr->litLengthSum = (1<<LLbits);
- ssPtr->litSum = (1<<Litbits);
- ssPtr->offCodeSum = (1<<Offbits);
-
- for (u=0; u<=MaxLit; u++)
- ssPtr->litFreq[u] = 1;
- for (u=0; u<=MaxLL; u++)
- ssPtr->litLengthFreq[u] = 1;
- for (u=0; u<=MaxML; u++)
- ssPtr->matchLengthFreq[u] = 1;
- for (u=0; u<=MaxOff; u++)
- ssPtr->offCodeFreq[u] = 1;
- } else {
- ssPtr->matchLengthSum = 0;
- ssPtr->litLengthSum = 0;
- ssPtr->litSum = 0;
- ssPtr->offCodeSum = 0;
-
- for (u=0; u<=MaxLit; u++) {
- ssPtr->litFreq[u] = ZSTD_FREQ_START + (ssPtr->litFreq[u]>>ZSTD_FREQ_DIV);
- ssPtr->litSum += ssPtr->litFreq[u];
- }
- for (u=0; u<=MaxLL; u++) {
- ssPtr->litLengthFreq[u] = ZSTD_FREQ_START + (ssPtr->litLengthFreq[u]>>ZSTD_FREQ_DIV);
- ssPtr->litLengthSum += ssPtr->litLengthFreq[u];
- }
- for (u=0; u<=MaxML; u++) {
- ssPtr->matchLengthFreq[u] = ZSTD_FREQ_START + (ssPtr->matchLengthFreq[u]>>ZSTD_FREQ_DIV);
- ssPtr->matchLengthSum += ssPtr->matchLengthFreq[u];
- }
- for (u=0; u<=MaxOff; u++) {
- ssPtr->offCodeFreq[u] = ZSTD_FREQ_START + (ssPtr->offCodeFreq[u]>>ZSTD_FREQ_DIV);
- ssPtr->offCodeSum += ssPtr->offCodeFreq[u];
- }
- }
-}
-
-
-MEM_STATIC void ZSTD_updatePrice(seqStore_t* seqStorePtr, U32 litLength, const BYTE* literals, U32 offset, U32 matchLength)
-{
- U32 u;
-
- /* literals */
- seqStorePtr->litSum += litLength * ZSTD_FREQ_STEP;
- for (u=0; u < litLength; u++)
- seqStorePtr->litFreq[literals[u]] += ZSTD_FREQ_STEP;
-
- /* literal Length */
- seqStorePtr->litLengthSum += ZSTD_FREQ_STEP;
- if (litLength >= MaxLL)
- seqStorePtr->litLengthFreq[MaxLL] += ZSTD_FREQ_STEP;
- else
- seqStorePtr->litLengthFreq[litLength] += ZSTD_FREQ_STEP;
-
- /* match offset */
- seqStorePtr->offCodeSum += ZSTD_FREQ_STEP;
- BYTE offCode = offset ? (BYTE)ZSTD_highbit(offset) + 1 : 0;
- seqStorePtr->offCodeFreq[offCode] += ZSTD_FREQ_STEP;
-
- /* match Length */
- seqStorePtr->matchLengthSum += ZSTD_FREQ_STEP;
- if (matchLength >= MaxML)
- seqStorePtr->matchLengthFreq[MaxML] += ZSTD_FREQ_STEP;
- else
- seqStorePtr->matchLengthFreq[matchLength] += ZSTD_FREQ_STEP;
-}
-
-
-#define SET_PRICE(pos, mlen_, offset_, litlen_, price_) \
- { \
- while (last_pos < pos) { opt[last_pos+1].price = 1<<30; last_pos++; } \
- opt[pos].mlen = mlen_; \
- opt[pos].off = offset_; \
- opt[pos].litlen = litlen_; \
- opt[pos].price = price_; \
- ZSTD_LOG_PARSER("%d: SET price[%d/%d]=%d litlen=%d len=%d off=%d\n", (int)(inr-base), (int)pos, (int)last_pos, opt[pos].price, opt[pos].litlen, opt[pos].mlen, opt[pos].off); \
- }
-
-
-
/*-*************************************
* Binary Tree search
***************************************/
-/* Update hashTable3 up to ip (excluded)
- Assumption : always within prefix (ie. not within extDict) */
-#if MINMATCH == 3
-static U32 ZSTD_insertAndFindFirstIndexHash3 (ZSTD_CCtx* zc, const BYTE* ip)
-{
- U32* const hashTable3 = zc->hashTable3;
- const U32 hashLog3 = zc->params.hashLog3;
- const BYTE* const base = zc->base;
- const U32 target = (U32)(ip - base);
- U32 idx = zc->nextToUpdate3;
-
- while(idx < target) {
- hashTable3[ZSTD_hash3Ptr(base+idx, hashLog3)] = idx;
- idx++;
- }
-
- zc->nextToUpdate3 = target;
- return hashTable3[ZSTD_hash3Ptr(ip, hashLog3)];
-}
-#endif
-
-
-static U32 ZSTD_insertBtAndGetAllMatches (
+static U32 ZSTD_INSERTBTANDGETALLMATCHES (
ZSTD_CCtx* zc,
const BYTE* const ip, const BYTE* const iLimit,
U32 nbCompares, const U32 mls,
U32 dummy32; /* to be nullified at the end */
U32 mnum = 0;
- size_t bestLength = MINMATCH-1;
+ size_t bestLength = MINMATCHOPT-1;
hashTable[h] = current; /* Update Hash Table */
-#if MINMATCH == 3
+#if MINMATCHOPT == 3
/* HC3 match finder */
U32 matchIndex3 = ZSTD_insertAndFindFirstIndexHash3 (zc, ip);
size_t currentMl=0;
if ((!extDict) || matchIndex3 >= dictLimit) {
match = base + matchIndex3;
- if (match[bestLength] == ip[bestLength]) currentMl = ZSTD_count(ip, match, iLimit); // faster
- // if (MEM_readMINMATCH(match) == MEM_readMINMATCH(ip)) currentMl = ZSTD_count(ip+MINMATCH, match+MINMATCH, iLimit)+MINMATCH; // stronger
+ if (match[bestLength] == ip[bestLength]) currentMl = ZSTD_count(ip, match, iLimit);
} else {
match = dictBase + matchIndex3;
if (MEM_readMINMATCH(match) == MEM_readMINMATCH(ip)) /* assumption : matchIndex3 <= dictLimit-4 (by table construction) */
- currentMl = ZSTD_count_2segments(ip+MINMATCH, match+MINMATCH, iLimit, dictEnd, prefixStart) + MINMATCH;
+ currentMl = ZSTD_count_2segments(ip+MINMATCHOPT, match+MINMATCHOPT, iLimit, dictEnd, prefixStart) + MINMATCHOPT;
}
/* save best solution */
/** Tree updater, providing best match */
-static U32 ZSTD_BtGetAllMatches (
+static U32 ZSTD_BTGETALLMATCHES (
ZSTD_CCtx* zc,
const BYTE* const ip, const BYTE* const iLimit,
const U32 maxNbAttempts, const U32 mls, ZSTD_match_t* matches)
{
if (ip < zc->base + zc->nextToUpdate) return 0; /* skipped area */
ZSTD_updateTree(zc, ip, iLimit, maxNbAttempts, mls);
- return ZSTD_insertBtAndGetAllMatches(zc, ip, iLimit, maxNbAttempts, mls, 0, matches);
+ return ZSTD_INSERTBTANDGETALLMATCHES(zc, ip, iLimit, maxNbAttempts, mls, 0, matches);
}
-static U32 ZSTD_BtGetAllMatches_selectMLS (
+static U32 ZSTD_BTGETALLMATCHES_SELECTMLS (
ZSTD_CCtx* zc, /* Index table will be updated */
const BYTE* ip, const BYTE* const iLowLimit, const BYTE* const iHighLimit,
const U32 maxNbAttempts, const U32 matchLengthSearch, ZSTD_match_t* matches)
switch(matchLengthSearch)
{
default :
- case 4 : return ZSTD_BtGetAllMatches(zc, ip, iHighLimit, maxNbAttempts, 4, matches);
- case 5 : return ZSTD_BtGetAllMatches(zc, ip, iHighLimit, maxNbAttempts, 5, matches);
- case 6 : return ZSTD_BtGetAllMatches(zc, ip, iHighLimit, maxNbAttempts, 6, matches);
+ case 4 : return ZSTD_BTGETALLMATCHES(zc, ip, iHighLimit, maxNbAttempts, 4, matches);
+ case 5 : return ZSTD_BTGETALLMATCHES(zc, ip, iHighLimit, maxNbAttempts, 5, matches);
+ case 6 : return ZSTD_BTGETALLMATCHES(zc, ip, iHighLimit, maxNbAttempts, 6, matches);
}
}
/** Tree updater, providing best match */
-static U32 ZSTD_BtGetAllMatches_extDict (
+static U32 ZSTD_BTGETALLMATCHES_EXTDICT (
ZSTD_CCtx* zc,
const BYTE* const ip, const BYTE* const iLimit,
const U32 maxNbAttempts, const U32 mls, ZSTD_match_t* matches)
{
if (ip < zc->base + zc->nextToUpdate) return 0; /* skipped area */
ZSTD_updateTree_extDict(zc, ip, iLimit, maxNbAttempts, mls);
- return ZSTD_insertBtAndGetAllMatches(zc, ip, iLimit, maxNbAttempts, mls, 1, matches);
+ return ZSTD_INSERTBTANDGETALLMATCHES(zc, ip, iLimit, maxNbAttempts, mls, 1, matches);
}
-static U32 ZSTD_BtGetAllMatches_selectMLS_extDict (
+static U32 ZSTD_BTGETALLMATCHES_SELECTMLS_EXTDICT (
ZSTD_CCtx* zc, /* Index table will be updated */
const BYTE* ip, const BYTE* const iLowLimit, const BYTE* const iHighLimit,
const U32 maxNbAttempts, const U32 matchLengthSearch, ZSTD_match_t* matches)
switch(matchLengthSearch)
{
default :
- case 4 : return ZSTD_BtGetAllMatches_extDict(zc, ip, iHighLimit, maxNbAttempts, 4, matches);
- case 5 : return ZSTD_BtGetAllMatches_extDict(zc, ip, iHighLimit, maxNbAttempts, 5, matches);
- case 6 : return ZSTD_BtGetAllMatches_extDict(zc, ip, iHighLimit, maxNbAttempts, 6, matches);
+ case 4 : return ZSTD_BTGETALLMATCHES_EXTDICT(zc, ip, iHighLimit, maxNbAttempts, 4, matches);
+ case 5 : return ZSTD_BTGETALLMATCHES_EXTDICT(zc, ip, iHighLimit, maxNbAttempts, 5, matches);
+ case 6 : return ZSTD_BTGETALLMATCHES_EXTDICT(zc, ip, iHighLimit, maxNbAttempts, 6, matches);
}
}
* Optimal parser
*********************************/
FORCE_INLINE
-void ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
+void ZSTD_COMPRESSBLOCK_OPT_GENERIC(ZSTD_CCtx* ctx,
const void* src, size_t srcSize,
const U32 depth)
{
U32 rep_2=REPCODE_STARTVALUE, rep_1=REPCODE_STARTVALUE;
const U32 maxSearches = 1U << ctx->params.searchLog;
const U32 mls = ctx->params.searchLength;
+ const U32 sufficient_len = ctx->params.targetLength;
- ZSTD_optimal_t opt[ZSTD_OPT_NUM+4];
+ ZSTD_optimal_t opt[ZSTD_OPT_NUM+1];
ZSTD_match_t matches[ZSTD_OPT_NUM+1];
const BYTE* inr;
U32 cur, match_num, last_pos, litlen, price;
- const U32 sufficient_len = ctx->params.targetLength;
-
/* init */
ctx->nextToUpdate3 = ctx->nextToUpdate;
ZSTD_resetSeqStore(seqStorePtr);
/* check repCode */
if (MEM_readMINMATCH(ip+1) == MEM_readMINMATCH(ip+1 - rep_1)) {
/* repcode : we take it */
- mlen = (U32)ZSTD_count(ip+1+MINMATCH, ip+1+MINMATCH-rep_1, iend) + MINMATCH;
+ mlen = (U32)ZSTD_count(ip+1+MINMATCHOPT, ip+1+MINMATCHOPT-rep_1, iend) + MINMATCHOPT;
ZSTD_LOG_PARSER("%d: start try REP rep=%d mlen=%d\n", (int)(ip-base), (int)rep_1, (int)mlen);
if (depth==0 || mlen > sufficient_len || mlen >= ZSTD_OPT_NUM) {
litlen = opt[0].litlen + 1;
do {
- price = ZSTD_getPrice(seqStorePtr, litlen, litstart, 0, mlen);
+ price = ZSTD_GETPRICE(seqStorePtr, litlen, litstart, 0, mlen);
if (mlen + 1 > last_pos || price < opt[mlen + 1].price)
SET_PRICE(mlen + 1, mlen, 0, litlen, price); /* note : macro modifies last_pos */
mlen--;
- } while (mlen >= MINMATCH);
+ } while (mlen >= MINMATCHOPT);
}
- match_num = ZSTD_BtGetAllMatches_selectMLS_extDict(ctx, ip, ip, iend, maxSearches, mls, matches); /* first search (depth 0) */
+ match_num = ZSTD_BTGETALLMATCHES_SELECTMLS(ctx, ip, ip, iend, maxSearches, mls, matches); /* first search (depth 0) */
ZSTD_LOG_PARSER("%d: match_num=%d last_pos=%d\n", (int)(ip-base), match_num, last_pos);
if (!last_pos && !match_num) { ip++; continue; }
goto _storeSequence;
}
- best_mlen = (last_pos) ? last_pos : MINMATCH;
+ best_mlen = (last_pos) ? last_pos : MINMATCHOPT;
// set prices using matches at position = 0
for (u = 0; u < match_num; u++) {
ZSTD_LOG_PARSER("%d: start Found mlen=%d off=%d best_mlen=%d last_pos=%d\n", (int)(ip-base), matches[u].len, matches[u].off, (int)best_mlen, (int)last_pos);
litlen = opt[0].litlen;
while (mlen <= best_mlen) {
- price = ZSTD_getPrice(seqStorePtr, litlen, litstart, matches[u].off, mlen);
+ price = ZSTD_GETPRICE(seqStorePtr, litlen, litstart, matches[u].off, mlen);
if (mlen > last_pos || price < opt[mlen].price)
SET_PRICE(mlen, mlen, matches[u].off, litlen, price);
mlen++;
} }
- if (last_pos < MINMATCH) { ip++; continue; }
+ if (last_pos < MINMATCHOPT) { ip++; continue; }
/* check further positions */
for (cur = 1; cur <= last_pos; cur++) {
}
if (MEM_readMINMATCH(inr) == MEM_readMINMATCH(inr - cur_rep)) { // check rep
- mlen = (U32)ZSTD_count(inr+MINMATCH, inr+MINMATCH - cur_rep, iend) + MINMATCH;
+ mlen = (U32)ZSTD_count(inr+MINMATCHOPT, inr+MINMATCHOPT - cur_rep, iend) + MINMATCHOPT;
ZSTD_LOG_PARSER("%d: Found REP mlen=%d off=%d rep=%d opt[%d].off=%d\n", (int)(inr-base), mlen, 0, opt[cur].rep, cur, opt[cur].off);
if (mlen > sufficient_len || cur + mlen >= ZSTD_OPT_NUM) {
if (opt[cur].mlen == 1) {
litlen = opt[cur].litlen;
if (cur > litlen) {
- price = opt[cur - litlen].price + ZSTD_getPrice(seqStorePtr, litlen, inr-litlen, 0, mlen);
+ price = opt[cur - litlen].price + ZSTD_GETPRICE(seqStorePtr, litlen, inr-litlen, 0, mlen);
ZSTD_LOG_TRY_PRICE("%d: TRY5 opt[%d].price=%d price=%d cur=%d litlen=%d\n", (int)(inr-base), cur - litlen, opt[cur - litlen].price, price, cur, litlen);
} else
- price = ZSTD_getPrice(seqStorePtr, litlen, litstart, 0, mlen);
+ price = ZSTD_GETPRICE(seqStorePtr, litlen, litstart, 0, mlen);
} else {
litlen = 0;
- price = opt[cur].price + ZSTD_getPrice(seqStorePtr, 0, NULL, 0, mlen);
- ZSTD_LOG_TRY_PRICE("%d: TRY7 price=%d cur=%d litlen=0 getprice=%d\n", (int)(inr-base), price, cur, (int)ZSTD_getPrice(seqStorePtr, 0, NULL, 0, mlen));
+ price = opt[cur].price + ZSTD_GETPRICE(seqStorePtr, 0, NULL, 0, mlen);
+ ZSTD_LOG_TRY_PRICE("%d: TRY7 price=%d cur=%d litlen=0 getprice=%d\n", (int)(inr-base), price, cur, (int)ZSTD_GETPRICE(seqStorePtr, 0, NULL, 0, mlen));
}
best_mlen = mlen;
if (cur + mlen > last_pos || price <= opt[cur + mlen].price)
SET_PRICE(cur + mlen, mlen, 0, litlen, price);
mlen--;
- } while (mlen >= MINMATCH);
+ } while (mlen >= MINMATCHOPT);
}
- match_num = ZSTD_BtGetAllMatches_selectMLS_extDict(ctx, inr, ip, iend, maxSearches, mls, matches);
+ match_num = ZSTD_BTGETALLMATCHES_SELECTMLS(ctx, inr, ip, iend, maxSearches, mls, matches);
ZSTD_LOG_PARSER("%d: ZSTD_GetAllMatches match_num=%d\n", (int)(inr-base), match_num);
if (match_num > 0 && matches[match_num-1].len > sufficient_len) {
goto _storeSequence;
}
- best_mlen = (best_mlen > MINMATCH) ? best_mlen : MINMATCH;
+ best_mlen = (best_mlen > MINMATCHOPT) ? best_mlen : MINMATCHOPT;
/* set prices using matches at position = cur */
for (u = 0; u < match_num; u++) {
if (opt[cur].mlen == 1) {
litlen = opt[cur].litlen;
if (cur > litlen)
- price = opt[cur - litlen].price + ZSTD_getPrice(seqStorePtr, litlen, ip+cur-litlen, matches[u].off, mlen);
+ price = opt[cur - litlen].price + ZSTD_GETPRICE(seqStorePtr, litlen, ip+cur-litlen, matches[u].off, mlen);
else
- price = ZSTD_getPrice(seqStorePtr, litlen, litstart, matches[u].off, mlen);
+ price = ZSTD_GETPRICE(seqStorePtr, litlen, litstart, matches[u].off, mlen);
} else {
litlen = 0;
- price = opt[cur].price + ZSTD_getPrice(seqStorePtr, 0, NULL, matches[u].off, mlen);
+ price = opt[cur].price + ZSTD_GETPRICE(seqStorePtr, 0, NULL, matches[u].off, mlen);
}
ZSTD_LOG_PARSER("%d: Found2 mlen=%d best_mlen=%d off=%d price=%d litlen=%d\n", (int)(inr-base), mlen, best_mlen, matches[u].off, price, litlen);
else
ml2 = (U32)ZSTD_count(ip, ip-rep_1, iend);
if (offset == 0 || offset >= 8)
- if (ml2 < mlen && ml2 < MINMATCH) {
+ if (ml2 < mlen && ml2 < MINMATCHOPT) {
printf("%d: ERROR iend=%d mlen=%d offset=%d ml2=%d\n", (int)(ip - base), (int)(iend - ip), (int)mlen, (int)offset, (int)ml2); exit(0); }
if (ip < anchor) {
printf("%d: ERROR ip < anchor iend=%d mlen=%d offset=%d\n", (int)(ip - base), (int)(iend - ip), (int)mlen, (int)offset); exit(0); }
printf("%d: ERROR ip - offset < base iend=%d mlen=%d offset=%d\n", (int)(ip - base), (int)(iend - ip), (int)mlen, (int)offset); exit(0); }
if ((int)offset >= (1 << ctx->params.windowLog)) {
printf("%d: offset >= (1 << params.windowLog) iend=%d mlen=%d offset=%d\n", (int)(ip - base), (int)(iend - ip), (int)mlen, (int)offset); exit(0); }
- if (mlen < MINMATCH) {
- printf("%d: ERROR mlen < MINMATCH iend=%d mlen=%d offset=%d\n", (int)(ip - base), (int)(iend - ip), (int)mlen, (int)offset); exit(0); }
+ if (mlen < MINMATCHOPT) {
+ printf("%d: ERROR mlen < MINMATCHOPT iend=%d mlen=%d offset=%d\n", (int)(ip - base), (int)(iend - ip), (int)mlen, (int)offset); exit(0); }
if (ip + mlen > iend) {
printf("%d: ERROR ip + mlen >= iend iend=%d mlen=%d offset=%d\n", (int)(ip - base), (int)(iend - ip), (int)mlen, (int)offset); exit(0); }
#endif
- ZSTD_updatePrice(seqStorePtr, litLength, anchor, offset, mlen-MINMATCH);
- ZSTD_storeSeq(seqStorePtr, litLength, anchor, offset, mlen-MINMATCH);
+ ZSTD_updatePrice(seqStorePtr, litLength, anchor, offset, mlen-MINMATCHOPT);
+ ZSTD_storeSeq(seqStorePtr, litLength, anchor, offset, mlen-MINMATCHOPT);
anchor = ip = ip + mlen;
} /* for (cur=0; cur < last_pos; ) */
while ( (anchor <= ilimit)
&& (MEM_readMINMATCH(anchor) == MEM_readMINMATCH(anchor - rep_2)) ) {
/* store sequence */
- best_mlen = (U32)ZSTD_count(anchor+MINMATCH, anchor+MINMATCH-rep_2, iend);
+ best_mlen = (U32)ZSTD_count(anchor+MINMATCHOPT, anchor+MINMATCHOPT-rep_2, iend);
best_off = rep_2;
rep_2 = rep_1;
rep_1 = best_off;
ZSTD_LOG_ENCODE("%d/%d: ENCODE REP literals=%d mlen=%d off=%d rep1=%d rep2=%d\n", (int)(anchor-base), (int)(iend-base), (int)(0), (int)best_mlen, (int)(0), (int)rep_1, (int)rep_2);
ZSTD_updatePrice(seqStorePtr, 0, anchor, 0, best_mlen);
ZSTD_storeSeq(seqStorePtr, 0, anchor, 0, best_mlen);
- anchor += best_mlen+MINMATCH;
+ anchor += best_mlen+MINMATCHOPT;
continue; /* faster when present ... (?) */
}
if (anchor > ip) ip = anchor;
FORCE_INLINE
-void ZSTD_compressBlock_opt_extDict_generic(ZSTD_CCtx* ctx,
+void ZSTD_COMPRESSBLOCK_OPT_EXTDICT_GENERIC(ZSTD_CCtx* ctx,
const void* src, size_t srcSize,
const U32 depth)
{
U32 rep_2=REPCODE_STARTVALUE, rep_1=REPCODE_STARTVALUE;
const U32 maxSearches = 1U << ctx->params.searchLog;
const U32 mls = ctx->params.searchLength;
+ const U32 sufficient_len = ctx->params.targetLength;
- ZSTD_optimal_t opt[ZSTD_OPT_NUM+4];
+ ZSTD_optimal_t opt[ZSTD_OPT_NUM+1];
ZSTD_match_t matches[ZSTD_OPT_NUM+1];
const BYTE* inr;
U32 cur, match_num, last_pos, litlen, price;
- const U32 sufficient_len = ctx->params.targetLength;
-
/* init */
ctx->nextToUpdate3 = ctx->nextToUpdate;
ZSTD_resetSeqStore(seqStorePtr);
&& (MEM_readMINMATCH(ip+1) == MEM_readMINMATCH(repMatch)) ) {
/* repcode detected we should take it */
const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;
- mlen = (U32)ZSTD_count_2segments(ip+1+MINMATCH, repMatch+MINMATCH, iend, repEnd, prefixStart) + MINMATCH;
+ mlen = (U32)ZSTD_count_2segments(ip+1+MINMATCHOPT, repMatch+MINMATCHOPT, iend, repEnd, prefixStart) + MINMATCHOPT;
ZSTD_LOG_PARSER("%d: start try REP rep=%d mlen=%d\n", (int)(ip-base), (int)rep_1, (int)mlen);
if (depth==0 || mlen > sufficient_len || mlen >= ZSTD_OPT_NUM) {
litlen = opt[0].litlen + 1;
do {
- price = ZSTD_getPrice(seqStorePtr, litlen, litstart, 0, mlen);
+ price = ZSTD_GETPRICE(seqStorePtr, litlen, litstart, 0, mlen);
if (mlen + 1 > last_pos || price < opt[mlen + 1].price)
SET_PRICE(mlen + 1, mlen, 0, litlen, price);
mlen--;
- } while (mlen >= MINMATCH);
+ } while (mlen >= MINMATCHOPT);
} }
- best_mlen = (last_pos) ? last_pos : MINMATCH;
+ best_mlen = (last_pos) ? last_pos : MINMATCHOPT;
- match_num = ZSTD_BtGetAllMatches_selectMLS_extDict(ctx, ip, ip, iend, maxSearches, mls, matches); /* first search (depth 0) */
+ match_num = ZSTD_BTGETALLMATCHES_SELECTMLS_EXTDICT(ctx, ip, ip, iend, maxSearches, mls, matches); /* first search (depth 0) */
ZSTD_LOG_PARSER("%d: match_num=%d last_pos=%d\n", (int)(ip-base), match_num, last_pos);
if (!last_pos && !match_num) { ip++; continue; }
ZSTD_LOG_PARSER("%d: start Found mlen=%d off=%d best_mlen=%d last_pos=%d\n", (int)(ip-base), matches[u].len, matches[u].off, (int)best_mlen, (int)last_pos);
litlen = opt[0].litlen;
while (mlen <= best_mlen) {
- price = ZSTD_getPrice(seqStorePtr, litlen, litstart, matches[u].off, mlen);
+ price = ZSTD_GETPRICE(seqStorePtr, litlen, litstart, matches[u].off, mlen);
if (mlen > last_pos || price < opt[mlen].price)
SET_PRICE(mlen, mlen, matches[u].off, litlen, price);
mlen++;
} }
- if (last_pos < MINMATCH) {
+ if (last_pos < MINMATCHOPT) {
// ip += ((ip-anchor) >> g_searchStrength) + 1; /* jump faster over incompressible sections */
ip++; continue;
}
&&(MEM_readMINMATCH(inr) == MEM_readMINMATCH(repMatch)) ) {
/* repcode detected */
const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;
- mlen = (U32)ZSTD_count_2segments(inr+MINMATCH, repMatch+MINMATCH, iend, repEnd, prefixStart) + MINMATCH;
+ mlen = (U32)ZSTD_count_2segments(inr+MINMATCHOPT, repMatch+MINMATCHOPT, iend, repEnd, prefixStart) + MINMATCHOPT;
ZSTD_LOG_PARSER("%d: Found REP mlen=%d off=%d rep=%d opt[%d].off=%d\n", (int)(inr-base), mlen, 0, opt[cur].rep, cur, opt[cur].off);
if (mlen > sufficient_len || cur + mlen >= ZSTD_OPT_NUM) {
if (opt[cur].mlen == 1) {
litlen = opt[cur].litlen;
if (cur > litlen) {
- price = opt[cur - litlen].price + ZSTD_getPrice(seqStorePtr, litlen, inr-litlen, 0, mlen);
+ price = opt[cur - litlen].price + ZSTD_GETPRICE(seqStorePtr, litlen, inr-litlen, 0, mlen);
ZSTD_LOG_TRY_PRICE("%d: TRY5 opt[%d].price=%d price=%d cur=%d litlen=%d\n", (int)(inr-base), cur - litlen, opt[cur - litlen].price, price, cur, litlen);
} else
- price = ZSTD_getPrice(seqStorePtr, litlen, litstart, 0, mlen);
+ price = ZSTD_GETPRICE(seqStorePtr, litlen, litstart, 0, mlen);
} else {
litlen = 0;
- price = opt[cur].price + ZSTD_getPrice(seqStorePtr, 0, NULL, 0, mlen);
- ZSTD_LOG_TRY_PRICE("%d: TRY7 price=%d cur=%d litlen=0 getprice=%d\n", (int)(inr-base), price, cur, (int)ZSTD_getPrice(seqStorePtr, 0, NULL, 0, mlen));
+ price = opt[cur].price + ZSTD_GETPRICE(seqStorePtr, 0, NULL, 0, mlen);
+ ZSTD_LOG_TRY_PRICE("%d: TRY7 price=%d cur=%d litlen=0 getprice=%d\n", (int)(inr-base), price, cur, (int)ZSTD_GETPRICE(seqStorePtr, 0, NULL, 0, mlen));
}
best_mlen = mlen;
if (cur + mlen > last_pos || price <= opt[cur + mlen].price) // || ((price == opt[cur + mlen].price) && (opt[cur].mlen == 1) && (cur != litlen))) // at equal price prefer REP instead of MATCH
SET_PRICE(cur + mlen, mlen, 0, litlen, price);
mlen--;
- } while (mlen >= MINMATCH);
+ } while (mlen >= MINMATCHOPT);
}
- best_mlen = (best_mlen > MINMATCH) ? best_mlen : MINMATCH;
+ best_mlen = (best_mlen > MINMATCHOPT) ? best_mlen : MINMATCHOPT;
- match_num = ZSTD_BtGetAllMatches_selectMLS_extDict(ctx, inr, ip, iend, maxSearches, mls, matches);
+ match_num = ZSTD_BTGETALLMATCHES_SELECTMLS_EXTDICT(ctx, inr, ip, iend, maxSearches, mls, matches);
ZSTD_LOG_PARSER("%d: ZSTD_GetAllMatches match_num=%d\n", (int)(inr-base), match_num);
if (match_num > 0 && matches[match_num-1].len > sufficient_len) {
if (opt[cur].mlen == 1) {
litlen = opt[cur].litlen;
if (cur > litlen)
- price = opt[cur - litlen].price + ZSTD_getPrice(seqStorePtr, litlen, ip+cur-litlen, matches[u].off, mlen);
+ price = opt[cur - litlen].price + ZSTD_GETPRICE(seqStorePtr, litlen, ip+cur-litlen, matches[u].off, mlen);
else
- price = ZSTD_getPrice(seqStorePtr, litlen, litstart, matches[u].off, mlen);
+ price = ZSTD_GETPRICE(seqStorePtr, litlen, litstart, matches[u].off, mlen);
} else {
litlen = 0;
- price = opt[cur].price + ZSTD_getPrice(seqStorePtr, 0, NULL, matches[u].off, mlen);
+ price = opt[cur].price + ZSTD_GETPRICE(seqStorePtr, 0, NULL, matches[u].off, mlen);
}
ZSTD_LOG_PARSER("%d: Found2 mlen=%d best_mlen=%d off=%d price=%d litlen=%d\n", (int)(inr-base), mlen, best_mlen, matches[u].off, price, litlen);
ml2 = (U32)ZSTD_count(ip, ip-offset, iend);
else
ml2 = (U32)ZSTD_count(ip, ip-rep_1, iend);
- if (ml2 < mlen && ml2 < MINMATCH) {
+ if (ml2 < mlen && ml2 < MINMATCHOPT) {
printf("%d: ERROR iend=%d mlen=%d offset=%d ml2=%d\n", (int)(ip - base), (int)(iend - ip), (int)mlen, (int)offset, (int)ml2); exit(0); }
if (ip < anchor) {
printf("%d: ERROR ip < anchor iend=%d mlen=%d offset=%d\n", (int)(ip - base), (int)(iend - ip), (int)mlen, (int)offset); exit(0); }
printf("%d: ERROR ip - offset < base iend=%d mlen=%d offset=%d\n", (int)(ip - base), (int)(iend - ip), (int)mlen, (int)offset); exit(0); }
if ((int)offset >= (1 << ctx->params.windowLog)) {
printf("%d: offset >= (1 << params.windowLog) iend=%d mlen=%d offset=%d\n", (int)(ip - base), (int)(iend - ip), (int)mlen, (int)offset); exit(0); }
- if (mlen < MINMATCH) {
- printf("%d: ERROR mlen < MINMATCH iend=%d mlen=%d offset=%d\n", (int)(ip - base), (int)(iend - ip), (int)mlen, (int)offset); exit(0); }
+ if (mlen < MINMATCHOPT) {
+ printf("%d: ERROR mlen < MINMATCHOPT iend=%d mlen=%d offset=%d\n", (int)(ip - base), (int)(iend - ip), (int)mlen, (int)offset); exit(0); }
if (ip + mlen > iend) {
printf("%d: ERROR ip + mlen >= iend iend=%d mlen=%d offset=%d\n", (int)(ip - base), (int)(iend - ip), (int)mlen, (int)offset); exit(0); }
#endif
- ZSTD_updatePrice(seqStorePtr, litLength, anchor, offset, mlen-MINMATCH);
- ZSTD_storeSeq(seqStorePtr, litLength, anchor, offset, mlen-MINMATCH);
+ ZSTD_updatePrice(seqStorePtr, litLength, anchor, offset, mlen-MINMATCHOPT);
+ ZSTD_storeSeq(seqStorePtr, litLength, anchor, offset, mlen-MINMATCHOPT);
anchor = ip = ip + mlen;
}
&& (MEM_readMINMATCH(anchor) == MEM_readMINMATCH(repMatch)) ) {
/* repcode detected, let's take it */
const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;
- mlen = (U32)ZSTD_count_2segments(anchor+MINMATCH, repMatch+MINMATCH, iend, repEnd, prefixStart) + MINMATCH;
+ mlen = (U32)ZSTD_count_2segments(anchor+MINMATCHOPT, repMatch+MINMATCHOPT, iend, repEnd, prefixStart) + MINMATCHOPT;
offset = rep_2; rep_2 = rep_1; rep_1 = offset; /* swap offset history */
ZSTD_LOG_ENCODE("%d/%d: ENCODE REP literals=%d mlen=%d off=%d rep1=%d rep2=%d\n", (int)(anchor-base), (int)(iend-base), (int)(0), (int)best_mlen, (int)(0), (int)rep_1, (int)rep_2);
- ZSTD_updatePrice(seqStorePtr, 0, anchor, 0, mlen-MINMATCH);
- ZSTD_storeSeq(seqStorePtr, 0, anchor, 0, mlen-MINMATCH);
+ ZSTD_updatePrice(seqStorePtr, 0, anchor, 0, mlen-MINMATCHOPT);
+ ZSTD_storeSeq(seqStorePtr, 0, anchor, 0, mlen-MINMATCHOPT);
anchor += mlen;
continue; /* faster when present ... (?) */
}
--- /dev/null
+/*
+ zstd_opt_internal - common optimal parser functions to include
+ Header File for include
+ Copyright (C) 2016, Przemyslaw Skibinski, 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 :
+ - zstd source repository : https://github.com/Cyan4973/zstd
+*/
+
+/* Note : this file is intended to be included within zstd_compress.c */
+
+#ifndef ZSTD_OPT_INTERNAL_H_MODULE
+#define ZSTD_OPT_INTERNAL_H_MODULE
+
+
+/*-*******************************************
+* The optimal parser
+*********************************************/
+/*- Constants -*/
+#define ZSTD_OPT_NUM (1<<12)
+#define ZSTD_FREQ_START 1
+#define ZSTD_FREQ_STEP 1
+#define ZSTD_FREQ_DIV 6
+
+/*- Debug -*/
+#if defined(ZSTD_OPT_DEBUG) && ZSTD_OPT_DEBUG>=9
+ #define ZSTD_LOG_PARSER(...) printf(__VA_ARGS__)
+ #define ZSTD_LOG_ENCODE(...) printf(__VA_ARGS__)
+ #define ZSTD_LOG_TRY_PRICE(...) printf(__VA_ARGS__)
+#else
+ #define ZSTD_LOG_PARSER(...)
+ #define ZSTD_LOG_ENCODE(...)
+ #define ZSTD_LOG_TRY_PRICE(...)
+#endif
+
+
+typedef struct {
+ U32 off;
+ U32 len;
+} ZSTD_match_t;
+
+typedef struct {
+ U32 price;
+ U32 off;
+ U32 mlen;
+ U32 litlen;
+ U32 rep;
+ U32 rep2;
+} ZSTD_optimal_t;
+
+
+MEM_STATIC void ZSTD_rescaleFreqs(seqStore_t* ssPtr)
+{
+ unsigned u;
+
+ // printf("matchLengthSum=%d litLengthSum=%d litSum=%d offCodeSum=%d\n", ssPtr->matchLengthSum, ssPtr->litLengthSum, ssPtr->litSum, ssPtr->offCodeSum);
+
+ if (ssPtr->litLengthSum == 0) {
+ ssPtr->matchLengthSum = (1<<MLbits);
+ ssPtr->litLengthSum = (1<<LLbits);
+ ssPtr->litSum = (1<<Litbits);
+ ssPtr->offCodeSum = (1<<Offbits);
+
+ for (u=0; u<=MaxLit; u++)
+ ssPtr->litFreq[u] = 1;
+ for (u=0; u<=MaxLL; u++)
+ ssPtr->litLengthFreq[u] = 1;
+ for (u=0; u<=MaxML; u++)
+ ssPtr->matchLengthFreq[u] = 1;
+ for (u=0; u<=MaxOff; u++)
+ ssPtr->offCodeFreq[u] = 1;
+ } else {
+ ssPtr->matchLengthSum = 0;
+ ssPtr->litLengthSum = 0;
+ ssPtr->litSum = 0;
+ ssPtr->offCodeSum = 0;
+
+ for (u=0; u<=MaxLit; u++) {
+ ssPtr->litFreq[u] = ZSTD_FREQ_START + (ssPtr->litFreq[u]>>ZSTD_FREQ_DIV);
+ ssPtr->litSum += ssPtr->litFreq[u];
+ }
+ for (u=0; u<=MaxLL; u++) {
+ ssPtr->litLengthFreq[u] = ZSTD_FREQ_START + (ssPtr->litLengthFreq[u]>>ZSTD_FREQ_DIV);
+ ssPtr->litLengthSum += ssPtr->litLengthFreq[u];
+ }
+ for (u=0; u<=MaxML; u++) {
+ ssPtr->matchLengthFreq[u] = ZSTD_FREQ_START + (ssPtr->matchLengthFreq[u]>>ZSTD_FREQ_DIV);
+ ssPtr->matchLengthSum += ssPtr->matchLengthFreq[u];
+ }
+ for (u=0; u<=MaxOff; u++) {
+ ssPtr->offCodeFreq[u] = ZSTD_FREQ_START + (ssPtr->offCodeFreq[u]>>ZSTD_FREQ_DIV);
+ ssPtr->offCodeSum += ssPtr->offCodeFreq[u];
+ }
+ }
+}
+
+MEM_STATIC void ZSTD_updatePrice(seqStore_t* seqStorePtr, U32 litLength, const BYTE* literals, U32 offset, U32 matchLength)
+{
+ U32 u;
+
+ /* literals */
+ seqStorePtr->litSum += litLength * ZSTD_FREQ_STEP;
+ for (u=0; u < litLength; u++)
+ seqStorePtr->litFreq[literals[u]] += ZSTD_FREQ_STEP;
+
+ /* literal Length */
+ seqStorePtr->litLengthSum += ZSTD_FREQ_STEP;
+ if (litLength >= MaxLL)
+ seqStorePtr->litLengthFreq[MaxLL] += ZSTD_FREQ_STEP;
+ else
+ seqStorePtr->litLengthFreq[litLength] += ZSTD_FREQ_STEP;
+
+ /* match offset */
+ seqStorePtr->offCodeSum += ZSTD_FREQ_STEP;
+ BYTE offCode = offset ? (BYTE)ZSTD_highbit(offset) + 1 : 0;
+ seqStorePtr->offCodeFreq[offCode] += ZSTD_FREQ_STEP;
+
+ /* match Length */
+ seqStorePtr->matchLengthSum += ZSTD_FREQ_STEP;
+ if (matchLength >= MaxML)
+ seqStorePtr->matchLengthFreq[MaxML] += ZSTD_FREQ_STEP;
+ else
+ seqStorePtr->matchLengthFreq[matchLength] += ZSTD_FREQ_STEP;
+}
+
+FORCE_INLINE U32 ZSTD_getLiteralPrice(seqStore_t* seqStorePtr, U32 litLength, const BYTE* literals)
+{
+ U32 price, u;
+
+ /* literals */
+ price = litLength * ZSTD_highbit(seqStorePtr->litSum);
+ for (u=0; u < litLength; u++)
+ price -= ZSTD_highbit(seqStorePtr->litFreq[literals[u]]);
+
+ /* literal Length */
+ price += ((litLength >= MaxLL)<<3) + ((litLength >= 255+MaxLL)<<4) + ((litLength>=(1<<15))<<3);
+ if (litLength >= MaxLL) litLength = MaxLL;
+ price += ZSTD_highbit(seqStorePtr->litLengthSum) - ZSTD_highbit(seqStorePtr->litLengthFreq[litLength]);
+
+ return price;
+}
+
+#define SET_PRICE(pos, mlen_, offset_, litlen_, price_) \
+ { \
+ while (last_pos < pos) { opt[last_pos+1].price = 1<<30; last_pos++; } \
+ opt[pos].mlen = mlen_; \
+ opt[pos].off = offset_; \
+ opt[pos].litlen = litlen_; \
+ opt[pos].price = price_; \
+ ZSTD_LOG_PARSER("%d: SET price[%d/%d]=%d litlen=%d len=%d off=%d\n", (int)(inr-base), (int)pos, (int)last_pos, opt[pos].price, opt[pos].litlen, opt[pos].mlen, opt[pos].off); \
+ }
+
+/* Update hashTable3 up to ip (excluded)
+ Assumption : always within prefix (ie. not within extDict) */
+static U32 ZSTD_insertAndFindFirstIndexHash3 (ZSTD_CCtx* zc, const BYTE* ip)
+{
+ U32* const hashTable3 = zc->hashTable3;
+ const U32 hashLog3 = zc->params.hashLog3;
+ const BYTE* const base = zc->base;
+ const U32 target = (U32)(ip - base);
+ U32 idx = zc->nextToUpdate3;
+
+ while(idx < target) {
+ hashTable3[ZSTD_hash3Ptr(base+idx, hashLog3)] = idx;
+ idx++;
+ }
+
+ zc->nextToUpdate3 = target;
+ return hashTable3[ZSTD_hash3Ptr(ip, hashLog3)];
+}
+
+
+#define MINMATCHOPT 4
+#define MEM_readMINMATCH(ptr) (U32)(MEM_read32(ptr))
+#define ZSTD_GETPRICE ZSTD_getPrice4
+#define ZSTD_INSERTBTANDGETALLMATCHES ZSTD_insertBtAndGetAllMatches4
+#define ZSTD_BTGETALLMATCHES ZSTD_BtGetAllMatches4
+#define ZSTD_BTGETALLMATCHES_SELECTMLS ZSTD_BtGetAllMatches_selectMLS4
+#define ZSTD_BTGETALLMATCHES_EXTDICT ZSTD_BtGetAllMatches_extDict4
+#define ZSTD_BTGETALLMATCHES_SELECTMLS_EXTDICT ZSTD_BtGetAllMatches_selectMLS_extDict4
+#define ZSTD_COMPRESSBLOCK_OPT_GENERIC ZSTD_compressBlock_opt_generic4
+#define ZSTD_COMPRESSBLOCK_OPT_EXTDICT_GENERIC ZSTD_compressBlock_opt_extDict_generic4
+#include "zstd_opt.h"
+#undef MINMATCHOPT
+#undef MEM_readMINMATCH
+#undef ZSTD_GETPRICE
+#undef ZSTD_INSERTBTANDGETALLMATCHES
+#undef ZSTD_BTGETALLMATCHES
+#undef ZSTD_BTGETALLMATCHES_SELECTMLS
+#undef ZSTD_BTGETALLMATCHES_EXTDICT
+#undef ZSTD_BTGETALLMATCHES_SELECTMLS_EXTDICT
+#undef ZSTD_COMPRESSBLOCK_OPT_GENERIC
+#undef ZSTD_COMPRESSBLOCK_OPT_EXTDICT_GENERIC
+
+#define MINMATCHOPT 3
+#define MEM_readMINMATCH(ptr) ((U32)(MEM_read32(ptr)<<8))
+#define ZSTD_GETPRICE ZSTD_getPrice3
+#define ZSTD_INSERTBTANDGETALLMATCHES ZSTD_insertBtAndGetAllMatches3
+#define ZSTD_BTGETALLMATCHES ZSTD_BtGetAllMatches3
+#define ZSTD_BTGETALLMATCHES_SELECTMLS ZSTD_BtGetAllMatches_selectMLS3
+#define ZSTD_BTGETALLMATCHES_EXTDICT ZSTD_BtGetAllMatches_extDict3
+#define ZSTD_BTGETALLMATCHES_SELECTMLS_EXTDICT ZSTD_BtGetAllMatches_selectMLS_extDict3
+#define ZSTD_COMPRESSBLOCK_OPT_GENERIC ZSTD_compressBlock_opt_generic3
+#define ZSTD_COMPRESSBLOCK_OPT_EXTDICT_GENERIC ZSTD_compressBlock_opt_extDict_generic3
+#include "zstd_opt.h"
+
+
+#endif /* ZSTD_OPT_INTERNAL_H_MODULE */
projects / thirdparty / zstd.git / commitdiff
