lib/compress/zstd_opt.c

6  * LICENSE file in the root directory of this source tree) and the GPLv2 (found
7  * in the COPYING file in the root directory of this source tree).
8  * You may select, at your option, one of the above-listed licenses.
84  * return the resulting sum of elements */
159             {   unsigned of;
163                 for (of=0; of<=MaxOff; of++) {
165                     U32 const bitCost = FSE_getMaxNbBits(ofstate.symbolTT, of);
167                     optPtr->offCodeFreq[of] = bitCost ? 1 << (scaleLog-bitCost) : 1 /*minimum to calculate cost*/;
168                     optPtr->offCodeSum += optPtr->offCodeFreq[of];
192             {   unsigned of;
193                 for (of=0; of<=MaxOff; of++)
194                     optPtr->offCodeFreq[of] = 1;
213  * price of literals (only) in specified segment (which length can be 0).
214  * does not include price of literalLength symbol */
239  * cost of literalLength symbol */
253  * Provides the cost of the match part (offset + matchLength) of a sequence
254  * Must be combined with ZSTD_fullLiteralsCost() to get the full cost of a sequence.
324  * assumption : memPtr must be at least 4 bytes before end of buffer */
368  * @return : nb of positions added */
413         size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */
422             smallerPtr = nextPtr+1;               /* new "smaller" => larger of match */
445                 match = base + matchIndex;   /* to prepare for next usage of match[matchLength] */
455             break;   /* drop , to guarantee consistency ; miss a bit of compression, but other solutions can corrupt tree */
541     U32 matchEndIdx = current+8+1;   /* farthest referenced position of any match => detects repetitive patterns */
573                  * valid offset range shrinks when the dictionary goes out of bounds.
597                 DEBUGLOG(8, "found repCode %u (ll0:%u, offset:%u) of length %u",
624                 DEBUGLOG(8, "found small match with hlog3, of length %u",
645         size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */
651             if (matchIndex >= dictLimit) assert(memcmp(match, ip, matchLength) == 0);  /* ensure early section of match is equal as expected */
655             assert(memcmp(match, ip, matchLength) == 0);  /* ensure early section of match is equal as expected */
662             DEBUGLOG(8, "found match of length %u at distance %u (offCode=%u)",
674                 break; /* drop, to preserve bt consistency (miss a little bit of compression) */
702             size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */
706                 match = base + dictMatchIndex + dmsIndexDelta;   /* to prepare for next usage of match[matchLength] */
710                 DEBUGLOG(8, "found dms match of length %u at distance %u (offCode=%u)",
720                     break;   /* drop, to guarantee consistency (miss a little bit of compression) */
842             /* We don't need to include the actual price of the literals because
843              * it is static for the duration of the forward pass, and is included
852                 DEBUGLOG(6, "found %u matches of maxLength=%u and maxOffCode=%u at cPos=%u => start new series",
918             /* Set the repcodes of the current position. We must do it here
919              * because we rely on the repcodes of the 2nd to last sequence being
933             /* last match must start at a minimum distance of 8 from oend */
956                     DEBUGLOG(7, "cPos:%zi==rPos:%u, found %u matches, of maxLength=%u",
1007         /* Set the next chunk's repcodes based on the repcodes of the beginning
1008          * of the last match, and the last sequence. This avoids us having to
1048                     if (mlen==0) {  /* only literals => must be last "sequence", actually starting a new stream of sequences */
1050                         ip = anchor + llen;     /* last "sequence" is a bunch of literals => don't progress anchor */
1130     /* re-inforce weight of collected statistics */
1161       && (current == ms->window.dictLimit)   /* start of frame, nothing already loaded nor skipped */