24 const ZSTD_compressionParameters*
const cParams = &ms->
cParams;
26 U32 const hashLog = cParams->hashLog;
29 U32 const btLog = cParams->chainLog - 1;
30 U32 const btMask = (1 << btLog) - 1;
37 DEBUGLOG(7,
"ZSTD_updateDUBT, from %u to %u (dictLimit:%u)",
45 U32 const matchIndex = hashTable[
h];
47 U32*
const nextCandidatePtr = bt + 2*(
idx&btMask);
48 U32*
const sortMarkPtr = nextCandidatePtr + 1;
52 *nextCandidatePtr = matchIndex;
69 const ZSTD_compressionParameters*
const cParams = &ms->
cParams;
71 U32 const btLog = cParams->chainLog - 1;
72 U32 const btMask = (1 << btLog) - 1;
73 size_t commonLengthSmaller=0, commonLengthLarger=0;
78 const BYTE*
const iend = (
current>=dictLimit) ? inputEnd : dictBase + dictLimit;
79 const BYTE*
const dictEnd = dictBase + dictLimit;
80 const BYTE*
const prefixStart =
base + dictLimit;
83 U32* largerPtr = smallerPtr + 1;
84 U32 matchIndex = *smallerPtr;
87 U32 const maxDistance = 1U << cParams->windowLog;
88 U32 const windowLow = (
current - windowValid > maxDistance) ?
current - maxDistance : windowValid;
91 DEBUGLOG(8,
"ZSTD_insertDUBT1(%u) (dictLimit=%u, lowLimit=%u)",
96 while (nbCompares-- && (matchIndex > windowLow)) {
97 U32*
const nextPtr = bt + 2*(matchIndex & btMask);
98 size_t matchLength =
MIN(commonLengthSmaller, commonLengthLarger);
105 || (matchIndex+matchLength >= dictLimit)
108 || (matchIndex+matchLength >= dictLimit)) ?
110 assert( (matchIndex+matchLength >= dictLimit)
112 match = mBase + matchIndex;
115 match = dictBase + matchIndex;
117 if (matchIndex+matchLength >= dictLimit)
121 DEBUGLOG(8,
"ZSTD_insertDUBT1: comparing %u with %u : found %u common bytes ",
124 if (
ip+matchLength == iend) {
128 if (
match[matchLength] <
ip[matchLength]) {
130 *smallerPtr = matchIndex;
131 commonLengthSmaller = matchLength;
132 if (matchIndex <= btLow) { smallerPtr=&dummy32;
break; }
133 DEBUGLOG(8,
"ZSTD_insertDUBT1: %u (>btLow=%u) is smaller : next => %u",
134 matchIndex, btLow, nextPtr[1]);
135 smallerPtr = nextPtr+1;
136 matchIndex = nextPtr[1];
139 *largerPtr = matchIndex;
140 commonLengthLarger = matchLength;
141 if (matchIndex <= btLow) { largerPtr=&dummy32;
break; }
142 DEBUGLOG(8,
"ZSTD_insertDUBT1: %u (>btLow=%u) is larger => %u",
143 matchIndex, btLow, nextPtr[0]);
145 matchIndex = nextPtr[0];
148 *smallerPtr = *largerPtr = 0;
163 const ZSTD_compressionParameters*
const dmsCParams = &dms->
cParams;
165 U32 const hashLog = dmsCParams->hashLog;
167 U32 dictMatchIndex = dictHashTable[
h];
179 U32 const btLog = dmsCParams->chainLog - 1;
180 U32 const btMask = (1 << btLog) - 1;
181 U32 const btLow = (btMask >= dictHighLimit - dictLowLimit) ? dictLowLimit : dictHighLimit - btMask;
183 size_t commonLengthSmaller=0, commonLengthLarger=0;
188 while (nbCompares-- && (dictMatchIndex > dictLowLimit)) {
189 U32*
const nextPtr = dictBt + 2*(dictMatchIndex & btMask);
190 size_t matchLength =
MIN(commonLengthSmaller, commonLengthLarger);
191 const BYTE*
match = dictBase + dictMatchIndex;
193 if (dictMatchIndex+matchLength >= dictHighLimit)
194 match =
base + dictMatchIndex + dictIndexDelta;
196 if (matchLength > bestLength) {
197 U32 matchIndex = dictMatchIndex + dictIndexDelta;
199 DEBUGLOG(9,
"ZSTD_DUBT_findBetterDictMatch(%u) : found better match length %u -> %u and offsetCode %u -> %u (dictMatchIndex %u, matchIndex %u)",
203 if (
ip+matchLength == iend) {
208 if (
match[matchLength] <
ip[matchLength]) {
209 if (dictMatchIndex <= btLow) {
break; }
210 commonLengthSmaller = matchLength;
211 dictMatchIndex = nextPtr[1];
214 if (dictMatchIndex <= btLow) {
break; }
215 commonLengthLarger = matchLength;
216 dictMatchIndex = nextPtr[0];
222 DEBUGLOG(8,
"ZSTD_DUBT_findBetterDictMatch(%u) : found match of length %u and offsetCode %u (pos %u)",
237 const ZSTD_compressionParameters*
const cParams = &ms->
cParams;
239 U32 const hashLog = cParams->hashLog;
241 U32 matchIndex = hashTable[
h];
248 U32 const btLog = cParams->chainLog - 1;
249 U32 const btMask = (1 << btLog) - 1;
251 U32 const unsortLimit =
MAX(btLow, windowLow);
253 U32* nextCandidate = bt + 2*(matchIndex&btMask);
254 U32* unsortedMark = bt + 2*(matchIndex&btMask) + 1;
255 U32 nbCompares = 1U << cParams->searchLog;
256 U32 nbCandidates = nbCompares;
257 U32 previousCandidate = 0;
263 while ( (matchIndex > unsortLimit)
265 && (nbCandidates > 1) ) {
266 DEBUGLOG(8,
"ZSTD_DUBT_findBestMatch: candidate %u is unsorted",
268 *unsortedMark = previousCandidate;
269 previousCandidate = matchIndex;
270 matchIndex = *nextCandidate;
271 nextCandidate = bt + 2*(matchIndex&btMask);
272 unsortedMark = bt + 2*(matchIndex&btMask) + 1;
278 if ( (matchIndex > unsortLimit)
280 DEBUGLOG(7,
"ZSTD_DUBT_findBestMatch: nullify last unsorted candidate %u",
282 *nextCandidate = *unsortedMark = 0;
286 matchIndex = previousCandidate;
288 U32*
const nextCandidateIdxPtr = bt + 2*(matchIndex&btMask) + 1;
289 U32 const nextCandidateIdx = *nextCandidateIdxPtr;
291 nbCandidates, unsortLimit, dictMode);
292 matchIndex = nextCandidateIdx;
297 {
size_t commonLengthSmaller = 0, commonLengthLarger = 0;
300 const BYTE*
const dictEnd = dictBase + dictLimit;
301 const BYTE*
const prefixStart =
base + dictLimit;
306 size_t bestLength = 0;
308 matchIndex = hashTable[
h];
311 while (nbCompares-- && (matchIndex > windowLow)) {
312 U32*
const nextPtr = bt + 2*(matchIndex & btMask);
313 size_t matchLength =
MIN(commonLengthSmaller, commonLengthLarger);
316 if ((dictMode !=
ZSTD_extDict) || (matchIndex+matchLength >= dictLimit)) {
320 match = dictBase + matchIndex;
322 if (matchIndex+matchLength >= dictLimit)
326 if (matchLength > bestLength) {
327 if (matchLength > matchEndIdx - matchIndex)
328 matchEndIdx = matchIndex + (
U32)matchLength;
331 if (
ip+matchLength == iend) {
341 if (
match[matchLength] <
ip[matchLength]) {
343 *smallerPtr = matchIndex;
344 commonLengthSmaller = matchLength;
345 if (matchIndex <= btLow) { smallerPtr=&dummy32;
break; }
346 smallerPtr = nextPtr+1;
347 matchIndex = nextPtr[1];
350 *largerPtr = matchIndex;
351 commonLengthLarger = matchLength;
352 if (matchIndex <= btLow) { largerPtr=&dummy32;
break; }
354 matchIndex = nextPtr[0];
357 *smallerPtr = *largerPtr = 0;
362 offsetPtr, bestLength, nbCompares,
370 DEBUGLOG(8,
"ZSTD_DUBT_findBestMatch(%u) : found match of length %u and offsetCode %u (pos %u)",
381 const BYTE*
const ip,
const BYTE*
const iLimit,
386 DEBUGLOG(7,
"ZSTD_BtFindBestMatch");
445#define NEXT_IN_CHAIN(d, mask) chainTable[(d) & (mask)]
451 const ZSTD_compressionParameters*
const cParams,
455 const U32 hashLog = cParams->hashLog;
457 const U32 chainMask = (1 << cParams->chainLog) - 1;
474 const ZSTD_compressionParameters*
const cParams = &ms->
cParams;
483 const BYTE*
const ip,
const BYTE*
const iLimit,
487 const ZSTD_compressionParameters*
const cParams = &ms->
cParams;
489 const U32 chainSize = (1 << cParams->chainLog);
490 const U32 chainMask = chainSize-1;
494 const BYTE*
const prefixStart =
base + dictLimit;
495 const BYTE*
const dictEnd = dictBase + dictLimit;
497 const U32 maxDistance = 1U << cParams->windowLog;
499 const U32 withinMaxDistance = (
current - lowestValid > maxDistance) ?
current - maxDistance : lowestValid;
501 const U32 lowLimit = isDictionary ? lowestValid : withinMaxDistance;
503 U32 nbAttempts = 1U << cParams->searchLog;
509 for ( ; (matchIndex>lowLimit) & (nbAttempts>0) ; nbAttempts--) {
511 if ((dictMode !=
ZSTD_extDict) || matchIndex >= dictLimit) {
513 assert(matchIndex >= dictLimit);
517 const BYTE*
const match = dictBase + matchIndex;
524 if (currentMl > ml) {
527 if (
ip+currentMl == iLimit)
break;
530 if (matchIndex <= minChain)
break;
537 const U32 dmsChainSize = (1 << dms->
cParams.chainLog);
538 const U32 dmsChainMask = dmsChainSize - 1;
542 const U32 dmsSize = (
U32)(dmsEnd - dmsBase);
543 const U32 dmsIndexDelta = dictLimit - dmsSize;
544 const U32 dmsMinChain = dmsSize > dmsChainSize ? dmsSize - dmsChainSize : 0;
548 for ( ; (matchIndex>dmsLowestIndex) & (nbAttempts>0) ; nbAttempts--) {
550 const BYTE*
const match = dmsBase + matchIndex;
556 if (currentMl > ml) {
559 if (
ip+currentMl == iLimit)
break;
562 if (matchIndex <= dmsMinChain)
break;
563 matchIndex = dmsChainTable[matchIndex & dmsChainMask];
628 const void*
src,
size_t srcSize,
634 const BYTE* anchor = istart;
635 const BYTE*
const iend = istart + srcSize;
636 const BYTE*
const ilimit = iend - 8;
639 const BYTE*
const prefixLowest =
base + prefixLowestIndex;
641 typedef size_t (*searchMax_f)(
643 const BYTE*
ip,
const BYTE* iLimit,
size_t* offsetPtr);
649 U32 offset_1 = rep[0], offset_2 = rep[1], savedOffset=0;
657 dictBase + dictLowestIndex :
NULL;
661 prefixLowestIndex - (
U32)(dictEnd - dictBase) :
663 const U32 dictAndPrefixLength = (
U32)((
ip - prefixLowest) + (dictEnd - dictLowest));
665 DEBUGLOG(5,
"ZSTD_compressBlock_lazy_generic (dictMode=%u)", (
U32)dictMode);
668 ip += (dictAndPrefixLength == 0);
673 if (offset_2 > maxRep) savedOffset = offset_2, offset_2 = 0;
674 if (offset_1 > maxRep) savedOffset = offset_1, offset_1 = 0;
679 assert(offset_1 <= dictAndPrefixLength);
680 assert(offset_2 <= dictAndPrefixLength);
684#if defined(__GNUC__) && defined(__x86_64__)
690 while (
ip < ilimit) {
691 size_t matchLength=0;
699 && repIndex < prefixLowestIndex) ?
700 dictBase + (repIndex - dictIndexDelta) :
702 if (((
U32)((prefixLowestIndex-1) - repIndex) >= 3 )
704 const BYTE* repMatchEnd = repIndex < prefixLowestIndex ? dictEnd : iend;
706 if (
depth==0)
goto _storeSequence;
712 if (
depth==0)
goto _storeSequence;
716 {
size_t offsetFound = 999999999;
717 size_t const ml2 = searchMax(ms,
ip, iend, &offsetFound);
718 if (ml2 > matchLength)
722 if (matchLength < 4) {
734 int const gain2 = (
int)(mlRep * 3);
736 if ((mlRep >= 4) && (gain2 > gain1))
741 const BYTE* repMatch = repIndex < prefixLowestIndex ?
742 dictBase + (repIndex - dictIndexDelta) :
744 if (((
U32)((prefixLowestIndex-1) - repIndex) >= 3 )
746 const BYTE* repMatchEnd = repIndex < prefixLowestIndex ? dictEnd : iend;
748 int const gain2 = (
int)(mlRep * 3);
750 if ((mlRep >= 4) && (gain2 > gain1))
754 {
size_t offset2=999999999;
755 size_t const ml2 = searchMax(ms,
ip, iend, &offset2);
758 if ((ml2 >= 4) && (gain2 > gain1)) {
764 if ((
depth==2) && (
ip<ilimit)) {
769 int const gain2 = (
int)(mlRep * 4);
771 if ((mlRep >= 4) && (gain2 > gain1))
776 const BYTE* repMatch = repIndex < prefixLowestIndex ?
777 dictBase + (repIndex - dictIndexDelta) :
779 if (((
U32)((prefixLowestIndex-1) - repIndex) >= 3 )
781 const BYTE* repMatchEnd = repIndex < prefixLowestIndex ? dictEnd : iend;
783 int const gain2 = (
int)(mlRep * 4);
785 if ((mlRep >= 4) && (gain2 > gain1))
789 {
size_t offset2=999999999;
790 size_t const ml2 = searchMax(ms,
ip, iend, &offset2);
793 if ((ml2 >= 4) && (gain2 > gain1)) {
810 {
start--; matchLength++; }
814 const BYTE*
match = (matchIndex < prefixLowestIndex) ? dictBase + matchIndex - dictIndexDelta :
base + matchIndex;
815 const BYTE*
const mStart = (matchIndex < prefixLowestIndex) ? dictLowest : prefixLowest;
822 {
size_t const litLength =
start - anchor;
824 anchor =
ip =
start + matchLength;
829 while (
ip <= ilimit) {
831 U32 const repIndex = current2 - offset_2;
833 && repIndex < prefixLowestIndex ?
834 dictBase - dictIndexDelta + repIndex :
836 if ( ((
U32)((prefixLowestIndex-1) - (
U32)repIndex) >= 3 )
838 const BYTE*
const repEnd2 = repIndex < prefixLowestIndex ? dictEnd : iend;
851 while ( ((
ip <= ilimit) & (offset_2>0))
863 rep[0] = offset_1 ? offset_1 : savedOffset;
864 rep[1] = offset_2 ? offset_2 : savedOffset;
867 return (
size_t)(iend - anchor);
873 void const*
src,
size_t srcSize)
880 void const*
src,
size_t srcSize)
887 void const*
src,
size_t srcSize)
894 void const*
src,
size_t srcSize)
901 void const*
src,
size_t srcSize)
908 void const*
src,
size_t srcSize)
915 void const*
src,
size_t srcSize)
922 void const*
src,
size_t srcSize)
932 const void*
src,
size_t srcSize,
937 const BYTE* anchor = istart;
938 const BYTE*
const iend = istart + srcSize;
939 const BYTE*
const ilimit = iend - 8;
942 const BYTE*
const prefixStart =
base + dictLimit;
944 const BYTE*
const dictEnd = dictBase + dictLimit;
948 typedef size_t (*searchMax_f)(
950 const BYTE*
ip,
const BYTE* iLimit,
size_t* offsetPtr);
953 U32 offset_1 = rep[0], offset_2 = rep[1];
955 DEBUGLOG(5,
"ZSTD_compressBlock_lazy_extDict_generic");
958 ip += (
ip == prefixStart);
961#if defined(__GNUC__) && defined(__x86_64__)
967 while (
ip < ilimit) {
968 size_t matchLength=0;
976 const BYTE*
const repBase = repIndex < dictLimit ? dictBase :
base;
977 const BYTE*
const repMatch = repBase + repIndex;
978 if (((
U32)((dictLimit-1) - repIndex) >= 3) & (repIndex > windowLow))
981 const BYTE*
const repEnd = repIndex < dictLimit ? dictEnd : iend;
983 if (
depth==0)
goto _storeSequence;
987 {
size_t offsetFound = 999999999;
988 size_t const ml2 = searchMax(ms,
ip, iend, &offsetFound);
989 if (ml2 > matchLength)
993 if (matchLength < 4) {
1007 const BYTE*
const repBase = repIndex < dictLimit ? dictBase :
base;
1008 const BYTE*
const repMatch = repBase + repIndex;
1009 if (((
U32)((dictLimit-1) - repIndex) >= 3) & (repIndex > windowLow))
1012 const BYTE*
const repEnd = repIndex < dictLimit ? dictEnd : iend;
1014 int const gain2 = (
int)(repLength * 3);
1016 if ((repLength >= 4) && (gain2 > gain1))
1021 {
size_t offset2=999999999;
1022 size_t const ml2 = searchMax(ms,
ip, iend, &offset2);
1025 if ((ml2 >= 4) && (gain2 > gain1)) {
1031 if ((
depth==2) && (
ip<ilimit)) {
1038 const BYTE*
const repBase = repIndex < dictLimit ? dictBase :
base;
1039 const BYTE*
const repMatch = repBase + repIndex;
1040 if (((
U32)((dictLimit-1) - repIndex) >= 3) & (repIndex > windowLow))
1043 const BYTE*
const repEnd = repIndex < dictLimit ? dictEnd : iend;
1045 int const gain2 = (
int)(repLength * 4);
1047 if ((repLength >= 4) && (gain2 > gain1))
1052 {
size_t offset2=999999999;
1053 size_t const ml2 = searchMax(ms,
ip, iend, &offset2);
1056 if ((ml2 >= 4) && (gain2 > gain1)) {
1066 const BYTE*
match = (matchIndex < dictLimit) ? dictBase + matchIndex :
base + matchIndex;
1067 const BYTE*
const mStart = (matchIndex < dictLimit) ? dictStart : prefixStart;
1074 {
size_t const litLength =
start - anchor;
1076 anchor =
ip =
start + matchLength;
1080 while (
ip <= ilimit) {
1083 const U32 repIndex = repCurrent - offset_2;
1084 const BYTE*
const repBase = repIndex < dictLimit ? dictBase :
base;
1085 const BYTE*
const repMatch = repBase + repIndex;
1086 if (((
U32)((dictLimit-1) - repIndex) >= 3) & (repIndex > windowLow))
1089 const BYTE*
const repEnd = repIndex < dictLimit ? dictEnd : iend;
1105 return (
size_t)(iend - anchor);
1111 void const*
src,
size_t srcSize)
1118 void const*
src,
size_t srcSize)
1126 void const*
src,
size_t srcSize)
1134 void const*
src,
size_t srcSize)
void mls(int argc, const char *argv[])
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
MEM_STATIC U32 MEM_read32(const void *memPtr)
GLint GLint GLsizei GLsizei GLsizei depth
GLfloat GLfloat GLfloat GLfloat h
struct task_struct * current
static IHTMLWindow2 * window
__asm__(".p2align 4, 0x90\n" ".seh_proc __seh2_global_filter_func\n" "__seh2_global_filter_func:\n" "\tsub %rbp, %rax\n" "\tpush %rbp\n" "\t.seh_pushreg %rbp\n" "\tsub $32, %rsp\n" "\t.seh_stackalloc 32\n" "\t.seh_endprologue\n" "\tsub %rax, %rdx\n" "\tmov %rdx, %rbp\n" "\tjmp *%r8\n" "__seh2_global_filter_func_exit:\n" "\t.p2align 4\n" "\tadd $32, %rsp\n" "\tpop %rbp\n" "\tret\n" "\t.seh_endproc")
ZSTD_compressionParameters cParams
const ZSTD_matchState_t * dictMatchState
#define FORCE_INLINE_TEMPLATE
MEM_STATIC size_t ZSTD_count_2segments(const BYTE *ip, const BYTE *match, const BYTE *iEnd, const BYTE *mEnd, const BYTE *iStart)
MEM_STATIC size_t ZSTD_hashPtr(const void *p, U32 hBits, U32 mls)
MEM_STATIC U32 ZSTD_getLowestPrefixIndex(const ZSTD_matchState_t *ms, U32 current, unsigned windowLog)
MEM_STATIC U32 ZSTD_getLowestMatchIndex(const ZSTD_matchState_t *ms, U32 current, unsigned windowLog)
MEM_STATIC size_t ZSTD_count(const BYTE *pIn, const BYTE *pMatch, const BYTE *const pInLimit)
HINT_INLINE UNUSED_ATTR void ZSTD_storeSeq(seqStore_t *seqStorePtr, size_t litLength, const BYTE *literals, const BYTE *litLimit, U32 offCode, size_t mlBase)
#define ZSTD_DUBT_UNSORTED_MARK
MEM_STATIC U32 ZSTD_highbit32(U32 val)
size_t ZSTD_compressBlock_btlazy2(ZSTD_matchState_t *ms, seqStore_t *seqStore, U32 rep[ZSTD_REP_NUM], void const *src, size_t srcSize)
FORCE_INLINE_TEMPLATE size_t ZSTD_BtFindBestMatch(ZSTD_matchState_t *ms, const BYTE *const ip, const BYTE *const iLimit, size_t *offsetPtr, const U32 mls, const ZSTD_dictMode_e dictMode)
size_t ZSTD_compressBlock_lazy_extDict(ZSTD_matchState_t *ms, seqStore_t *seqStore, U32 rep[ZSTD_REP_NUM], void const *src, size_t srcSize)
FORCE_INLINE_TEMPLATE size_t ZSTD_HcFindBestMatch_generic(ZSTD_matchState_t *ms, const BYTE *const ip, const BYTE *const iLimit, size_t *offsetPtr, const U32 mls, const ZSTD_dictMode_e dictMode)
static size_t ZSTD_DUBT_findBestMatch(ZSTD_matchState_t *ms, const BYTE *const ip, const BYTE *const iend, size_t *offsetPtr, U32 const mls, const ZSTD_dictMode_e dictMode)
FORCE_INLINE_TEMPLATE size_t ZSTD_HcFindBestMatch_selectMLS(ZSTD_matchState_t *ms, const BYTE *ip, const BYTE *const iLimit, size_t *offsetPtr)
size_t ZSTD_compressBlock_lazy_dictMatchState(ZSTD_matchState_t *ms, seqStore_t *seqStore, U32 rep[ZSTD_REP_NUM], void const *src, size_t srcSize)
static size_t ZSTD_DUBT_findBetterDictMatch(ZSTD_matchState_t *ms, const BYTE *const ip, const BYTE *const iend, size_t *offsetPtr, size_t bestLength, U32 nbCompares, U32 const mls, const ZSTD_dictMode_e dictMode)
static void ZSTD_insertDUBT1(ZSTD_matchState_t *ms, U32 current, const BYTE *inputEnd, U32 nbCompares, U32 btLow, const ZSTD_dictMode_e dictMode)
size_t ZSTD_compressBlock_greedy_dictMatchState(ZSTD_matchState_t *ms, seqStore_t *seqStore, U32 rep[ZSTD_REP_NUM], void const *src, size_t srcSize)
size_t ZSTD_compressBlock_lazy2_dictMatchState(ZSTD_matchState_t *ms, seqStore_t *seqStore, U32 rep[ZSTD_REP_NUM], void const *src, size_t srcSize)
static U32 ZSTD_insertAndFindFirstIndex_internal(ZSTD_matchState_t *ms, const ZSTD_compressionParameters *const cParams, const BYTE *ip, U32 const mls)
size_t ZSTD_compressBlock_btlazy2_extDict(ZSTD_matchState_t *ms, seqStore_t *seqStore, U32 rep[ZSTD_REP_NUM], void const *src, size_t srcSize)
size_t ZSTD_compressBlock_greedy(ZSTD_matchState_t *ms, seqStore_t *seqStore, U32 rep[ZSTD_REP_NUM], void const *src, size_t srcSize)
U32 ZSTD_insertAndFindFirstIndex(ZSTD_matchState_t *ms, const BYTE *ip)
size_t ZSTD_compressBlock_lazy2(ZSTD_matchState_t *ms, seqStore_t *seqStore, U32 rep[ZSTD_REP_NUM], void const *src, size_t srcSize)
static void ZSTD_updateDUBT(ZSTD_matchState_t *ms, const BYTE *ip, const BYTE *iend, U32 mls)
FORCE_INLINE_TEMPLATE size_t ZSTD_compressBlock_lazy_extDict_generic(ZSTD_matchState_t *ms, seqStore_t *seqStore, U32 rep[ZSTD_REP_NUM], const void *src, size_t srcSize, const searchMethod_e searchMethod, const U32 depth)
static size_t ZSTD_BtFindBestMatch_dictMatchState_selectMLS(ZSTD_matchState_t *ms, const BYTE *ip, const BYTE *const iLimit, size_t *offsetPtr)
size_t ZSTD_compressBlock_lazy_generic(ZSTD_matchState_t *ms, seqStore_t *seqStore, U32 rep[ZSTD_REP_NUM], const void *src, size_t srcSize, const searchMethod_e searchMethod, const U32 depth, ZSTD_dictMode_e const dictMode)
size_t ZSTD_compressBlock_lazy2_extDict(ZSTD_matchState_t *ms, seqStore_t *seqStore, U32 rep[ZSTD_REP_NUM], void const *src, size_t srcSize)
size_t ZSTD_compressBlock_lazy(ZSTD_matchState_t *ms, seqStore_t *seqStore, U32 rep[ZSTD_REP_NUM], void const *src, size_t srcSize)
#define NEXT_IN_CHAIN(d, mask)
static size_t ZSTD_BtFindBestMatch_selectMLS(ZSTD_matchState_t *ms, const BYTE *ip, const BYTE *const iLimit, size_t *offsetPtr)
static size_t ZSTD_BtFindBestMatch_extDict_selectMLS(ZSTD_matchState_t *ms, const BYTE *ip, const BYTE *const iLimit, size_t *offsetPtr)
static size_t ZSTD_HcFindBestMatch_dictMatchState_selectMLS(ZSTD_matchState_t *ms, const BYTE *ip, const BYTE *const iLimit, size_t *offsetPtr)
size_t ZSTD_compressBlock_greedy_extDict(ZSTD_matchState_t *ms, seqStore_t *seqStore, U32 rep[ZSTD_REP_NUM], void const *src, size_t srcSize)
FORCE_INLINE_TEMPLATE size_t ZSTD_HcFindBestMatch_extDict_selectMLS(ZSTD_matchState_t *ms, const BYTE *ip, const BYTE *const iLimit, size_t *offsetPtr)
size_t ZSTD_compressBlock_btlazy2_dictMatchState(ZSTD_matchState_t *ms, seqStore_t *seqStore, U32 rep[ZSTD_REP_NUM], void const *src, size_t srcSize)