zstd_compress_internal.h File Reference

#include "zstd_internal.h"

Include dependency graph for zstd_compress_internal.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	ZSTD_prefixDict_s
struct	ZSTD_hufCTables_t
struct	ZSTD_fseCTables_t
struct	ZSTD_entropyCTables_t
struct	ZSTD_match_t
struct	ZSTD_optimal_t
struct	optState_t
struct	ZSTD_compressedBlockState_t
struct	ZSTD_window_t
struct	ZSTD_matchState_t
struct	ZSTD_blockState_t
struct	ldmEntry_t
struct	ldmState_t
struct	ldmParams_t
struct	rawSeq
struct	rawSeqStore_t
struct	ZSTD_CCtx_params_s
struct	ZSTD_CCtx_s

Macros
#define	kSearchStrength   8
#define	HASH_READ_SIZE   8
#define	ZSTD_DUBT_UNSORTED_MARK
#define	ZSTD_CURRENT_MAX   ((3U << 29) + (1U << ZSTD_WINDOWLOG_MAX))
#define	ZSTD_CHUNKSIZE_MAX

Typedefs
typedef struct ZSTD_prefixDict_s	ZSTD_prefixDict
typedef struct ZSTD_matchState_t	ZSTD_matchState_t
typedef size_t(*	ZSTD_blockCompressor) (ZSTD_matchState_t *bs, seqStore_t *seqStore, U32 rep[ZSTD_REP_NUM], void const *src, size_t srcSize)

Enumerations
enum	ZSTD_compressionStage_e { ZSTDcs_created =0, ZSTDcs_init, ZSTDcs_ongoing, ZSTDcs_ending }
enum	ZSTD_cStreamStage { zcss_init =0, zcss_load, zcss_flush }
enum	ZSTD_dictAttachPref_e { ZSTD_dictDefaultAttach = 0, ZSTD_dictForceAttach = 1, ZSTD_dictForceCopy = -1 }
enum	ZSTD_OptPrice_e { zop_dynamic =0, zop_predef }
enum	ZSTD_dictTableLoadMethod_e { ZSTD_dtlm_fast, ZSTD_dtlm_full }
enum	ZSTD_dictMode_e { ZSTD_noDict = 0, ZSTD_extDict = 1, ZSTD_dictMatchState = 2 }

Functions
ZSTD_blockCompressor	ZSTD_selectBlockCompressor (ZSTD_strategy strat, ZSTD_dictMode_e dictMode)
MEM_STATIC U32	ZSTD_LLcode (U32 litLength)
MEM_STATIC U32	ZSTD_MLcode (U32 mlBase)
MEM_STATIC void	ZSTD_storeSeq (seqStore_t *seqStorePtr, size_t litLength, const void *literals, U32 offsetCode, size_t mlBase)
static unsigned	ZSTD_NbCommonBytes (size_t val)
MEM_STATIC size_t	ZSTD_count (const BYTE *pIn, const BYTE *pMatch, const BYTE *const pInLimit)
MEM_STATIC size_t	ZSTD_count_2segments (const BYTE *ip, const BYTE *match, const BYTE *iEnd, const BYTE *mEnd, const BYTE *iStart)
static U32	ZSTD_hash3 (U32 u, U32 h)
MEM_STATIC size_t	ZSTD_hash3Ptr (const void *ptr, U32 h)
static U32	ZSTD_hash4 (U32 u, U32 h)
static size_t	ZSTD_hash4Ptr (const void *ptr, U32 h)
static size_t	ZSTD_hash5 (U64 u, U32 h)
static size_t	ZSTD_hash5Ptr (const void *p, U32 h)
static size_t	ZSTD_hash6 (U64 u, U32 h)
static size_t	ZSTD_hash6Ptr (const void *p, U32 h)
static size_t	ZSTD_hash7 (U64 u, U32 h)
static size_t	ZSTD_hash7Ptr (const void *p, U32 h)
static size_t	ZSTD_hash8 (U64 u, U32 h)
static size_t	ZSTD_hash8Ptr (const void *p, U32 h)
MEM_STATIC size_t	ZSTD_hashPtr (const void *p, U32 hBits, U32 mls)
MEM_STATIC void	ZSTD_window_clear (ZSTD_window_t *window)
MEM_STATIC U32	ZSTD_window_hasExtDict (ZSTD_window_t const window)
MEM_STATIC ZSTD_dictMode_e	ZSTD_matchState_dictMode (const ZSTD_matchState_t *ms)
MEM_STATIC U32	ZSTD_window_needOverflowCorrection (ZSTD_window_t const window, void const *srcEnd)
MEM_STATIC U32	ZSTD_window_correctOverflow (ZSTD_window_t *window, U32 cycleLog, U32 maxDist, void const *src)
MEM_STATIC void	ZSTD_window_enforceMaxDist (ZSTD_window_t *window, void const *srcEnd, U32 maxDist, U32 *loadedDictEndPtr, const ZSTD_matchState_t **dictMatchStatePtr)
MEM_STATIC U32	ZSTD_window_update (ZSTD_window_t *window, void const *src, size_t srcSize)
MEM_STATIC double	ZSTD_fWeight (U32 rawStat)
MEM_STATIC void	ZSTD_debugTable (const U32 *table, U32 max)
ZSTD_compressionParameters	ZSTD_getCParamsFromCCtxParams (const ZSTD_CCtx_params *CCtxParams, U64 srcSizeHint, size_t dictSize)
size_t	ZSTD_initCStream_internal (ZSTD_CStream *zcs, const void *dict, size_t dictSize, const ZSTD_CDict *cdict, ZSTD_CCtx_params params, unsigned long long pledgedSrcSize)
void	ZSTD_resetSeqStore (seqStore_t *ssPtr)
size_t	ZSTD_compressStream_generic (ZSTD_CStream *zcs, ZSTD_outBuffer *output, ZSTD_inBuffer *input, ZSTD_EndDirective const flushMode)
ZSTD_compressionParameters	ZSTD_getCParamsFromCDict (const ZSTD_CDict *cdict)
size_t	ZSTD_compressBegin_advanced_internal (ZSTD_CCtx *cctx, const void *dict, size_t dictSize, ZSTD_dictContentType_e dictContentType, ZSTD_dictTableLoadMethod_e dtlm, const ZSTD_CDict *cdict, ZSTD_CCtx_params params, unsigned long long pledgedSrcSize)
size_t	ZSTD_compress_advanced_internal (ZSTD_CCtx *cctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize, const void *dict, size_t dictSize, ZSTD_CCtx_params params)
size_t	ZSTD_writeLastEmptyBlock (void *dst, size_t dstCapacity)
size_t	ZSTD_referenceExternalSequences (ZSTD_CCtx *cctx, rawSeq *seq, size_t nbSeq)

Variables
static const U32	prime3bytes = 506832829U
static const U32	prime4bytes = 2654435761U
static const U64	prime5bytes = 889523592379ULL
static const U64	prime6bytes = 227718039650203ULL
static const U64	prime7bytes = 58295818150454627ULL
static const U64	prime8bytes = 0xCF1BBCDCB7A56463ULL

Macro Definition Documentation

HASH_READ_SIZE

#define HASH_READ_SIZE   8

Definition at line 35 of file zstd_compress_internal.h.

kSearchStrength

#define kSearchStrength   8

Definition at line 34 of file zstd_compress_internal.h.

ZSTD_CHUNKSIZE_MAX

#define ZSTD_CHUNKSIZE_MAX

Value:

( ((U32)-1)                  /* Maximum ending current index */            \
    - ZSTD_CURRENT_MAX)          /* Maximum beginning lowLimit */

Definition at line 507 of file zstd_compress_internal.h.

ZSTD_CURRENT_MAX

#define ZSTD_CURRENT_MAX   ((3U << 29) + (1U << ZSTD_WINDOWLOG_MAX))

Definition at line 505 of file zstd_compress_internal.h.

ZSTD_DUBT_UNSORTED_MARK

#define ZSTD_DUBT_UNSORTED_MARK

Value:

1   /* For btlazy2 strategy, index 1 now means "unsorted".
                                       It could be confused for a real successor at index "1", if sorted as larger than its predecessor.
                                       It's not a big deal though : candidate will just be sorted again.
                                       Additionnally, candidate position 1 will be lost.
                                       But candidate 1 cannot hide a large tree of candidates, so it's a minimal loss.
                                       The benefit is that ZSTD_DUBT_UNSORTED_MARK cannot be misdhandled after table re-use with a different strategy
                                       Constant required by ZSTD_compressBlock_btlazy2() and ZSTD_reduceTable_internal() */

Definition at line 36 of file zstd_compress_internal.h.

Typedef Documentation

ZSTD_blockCompressor

typedef size_t(* ZSTD_blockCompressor) (ZSTD_matchState_t *bs, seqStore_t *seqStore, U32 rep[ZSTD_REP_NUM], void const *src, size_t srcSize)

Definition at line 266 of file zstd_compress_internal.h.

ZSTD_matchState_t

typedef struct ZSTD_matchState_t ZSTD_matchState_t

Definition at line 131 of file zstd_compress_internal.h.

ZSTD_prefixDict

typedef struct ZSTD_prefixDict_s ZSTD_prefixDict

Enumeration Type Documentation

ZSTD_compressionStage_e

enum ZSTD_compressionStage_e

Enumerator
ZSTDcs_created
ZSTDcs_init
ZSTDcs_ongoing
ZSTDcs_ending

Definition at line 48 of file zstd_compress_internal.h.

{ ZSTDcs_created=0, ZSTDcs_init, ZSTDcs_ongoing, ZSTDcs_ending } ZSTD_compressionStage_e;

ZSTD_cStreamStage

enum ZSTD_cStreamStage

Enumerator
zcss_init
zcss_load
zcss_flush

Definition at line 49 of file zstd_compress_internal.h.

{ zcss_init=0, zcss_load, zcss_flush } ZSTD_cStreamStage;

ZSTD_dictAttachPref_e

enum ZSTD_dictAttachPref_e

Enumerator
ZSTD_dictDefaultAttach
ZSTD_dictForceAttach
ZSTD_dictForceCopy

Definition at line 51 of file zstd_compress_internal.h.

             {
    ZSTD_dictDefaultAttach = 0,
    ZSTD_dictForceAttach = 1,
    ZSTD_dictForceCopy = -1,
} ZSTD_dictAttachPref_e;

ZSTD_dictMode_e

enum ZSTD_dictMode_e

Enumerator
ZSTD_noDict
ZSTD_extDict
ZSTD_dictMatchState

Definition at line 263 of file zstd_compress_internal.h.

{ ZSTD_noDict = 0, ZSTD_extDict = 1, ZSTD_dictMatchState = 2 } ZSTD_dictMode_e;

ZSTD_dictTableLoadMethod_e

enum ZSTD_dictTableLoadMethod_e

Enumerator
ZSTD_dtlm_fast
ZSTD_dtlm_full

Definition at line 261 of file zstd_compress_internal.h.

{ ZSTD_dtlm_fast, ZSTD_dtlm_full } ZSTD_dictTableLoadMethod_e;

ZSTD_OptPrice_e

enum ZSTD_OptPrice_e

Enumerator
zop_dynamic
zop_predef

Definition at line 95 of file zstd_compress_internal.h.

{ zop_dynamic=0, zop_predef } ZSTD_OptPrice_e;

Function Documentation

ZSTD_compress_advanced_internal()

size_t ZSTD_compress_advanced_internal	(	ZSTD_CCtx *	cctx,
		void *	dst,
		size_t	dstCapacity,
		const void *	src,
		size_t	srcSize,
		const void *	dict,
		size_t	dictSize,
		ZSTD_CCtx_params	params
	)

Definition at line 3135 of file zstd_compress.c.

{
    DEBUGLOG(4, "ZSTD_compress_advanced_internal (srcSize:%u)", (U32)srcSize);
    CHECK_F( ZSTD_compressBegin_internal(cctx,
                         dict, dictSize, ZSTD_dct_auto, ZSTD_dtlm_fast, NULL,
                         params, srcSize, ZSTDb_not_buffered) );
    return ZSTD_compressEnd(cctx, dst, dstCapacity, src, srcSize);
}

Referenced by ZSTD_compress_internal(), and ZSTD_compress_usingDict().

ZSTD_compressBegin_advanced_internal()

size_t ZSTD_compressBegin_advanced_internal	(	ZSTD_CCtx *	cctx,
		const void *	dict,
		size_t	dictSize,
		ZSTD_dictContentType_e	dictContentType,
		ZSTD_dictTableLoadMethod_e	dtlm,
		const ZSTD_CDict *	cdict,
		ZSTD_CCtx_params	params,
		unsigned long long	pledgedSrcSize
	)

Definition at line 2989 of file zstd_compress.c.

{
    DEBUGLOG(4, "ZSTD_compressBegin_advanced_internal: wlog=%u", params.cParams.windowLog);
    /* compression parameters verification and optimization */
    CHECK_F( ZSTD_checkCParams(params.cParams) );
    return ZSTD_compressBegin_internal(cctx,
                                       dict, dictSize, dictContentType, dtlm,
                                       cdict,
                                       params, pledgedSrcSize,
                                       ZSTDb_not_buffered);
}

Referenced by ZSTD_compressBegin_advanced().

ZSTD_compressStream_generic()

size_t ZSTD_compressStream_generic	(	ZSTD_CStream *	zcs,
		ZSTD_outBuffer *	output,
		ZSTD_inBuffer *	input,
		ZSTD_EndDirective const	flushMode
	)

ZSTD_compressStream_generic() : Private use only. To be called from zstdmt_compress.c in single-thread mode.

ZSTD_compressStream_generic(): internal function for all compressStream() variants and *compress_generic() non-static, because can be called from zstdmt_compress.c

Returns

: hint size for next input

Definition at line 3627 of file zstd_compress.c.

{
    const char* const istart = (const char*)input->src;
    const char* const iend = istart + input->size;
    const char* ip = istart + input->pos;
    char* const ostart = (char*)output->dst;
    char* const oend = ostart + output->size;
    char* op = ostart + output->pos;
    U32 someMoreWork = 1;

    /* check expectations */
    DEBUGLOG(5, "ZSTD_compressStream_generic, flush=%u", (U32)flushMode);
    assert(zcs->inBuff != NULL);
    assert(zcs->inBuffSize > 0);
    assert(zcs->outBuff !=  NULL);
    assert(zcs->outBuffSize > 0);
    assert(output->pos <= output->size);
    assert(input->pos <= input->size);

    while (someMoreWork) {
        switch(zcs->streamStage)
        {
        case zcss_init:
            /* call ZSTD_initCStream() first ! */
            return ERROR(init_missing);

        case zcss_load:
            if ( (flushMode == ZSTD_e_end)
              && ((size_t)(oend-op) >= ZSTD_compressBound(iend-ip))  /* enough dstCapacity */
              && (zcs->inBuffPos == 0) ) {
                /* shortcut to compression pass directly into output buffer */
                size_t const cSize = ZSTD_compressEnd(zcs,
                                                op, oend-op, ip, iend-ip);
                DEBUGLOG(4, "ZSTD_compressEnd : %u", (U32)cSize);
                if (ZSTD_isError(cSize)) return cSize;
                ip = iend;
                op += cSize;
                zcs->frameEnded = 1;
                ZSTD_CCtx_reset(zcs);
                someMoreWork = 0; break;
            }
            /* complete loading into inBuffer */
            {   size_t const toLoad = zcs->inBuffTarget - zcs->inBuffPos;
                size_t const loaded = ZSTD_limitCopy(
                                        zcs->inBuff + zcs->inBuffPos, toLoad,
                                        ip, iend-ip);
                zcs->inBuffPos += loaded;
                ip += loaded;
                if ( (flushMode == ZSTD_e_continue)
                  && (zcs->inBuffPos < zcs->inBuffTarget) ) {
                    /* not enough input to fill full block : stop here */
                    someMoreWork = 0; break;
                }
                if ( (flushMode == ZSTD_e_flush)
                  && (zcs->inBuffPos == zcs->inToCompress) ) {
                    /* empty */
                    someMoreWork = 0; break;
                }
            }
            /* compress current block (note : this stage cannot be stopped in the middle) */
            DEBUGLOG(5, "stream compression stage (flushMode==%u)", flushMode);
            {   void* cDst;
                size_t cSize;
                size_t const iSize = zcs->inBuffPos - zcs->inToCompress;
                size_t oSize = oend-op;
                unsigned const lastBlock = (flushMode == ZSTD_e_end) && (ip==iend);
                if (oSize >= ZSTD_compressBound(iSize))
                    cDst = op;   /* compress into output buffer, to skip flush stage */
                else
                    cDst = zcs->outBuff, oSize = zcs->outBuffSize;
                cSize = lastBlock ?
                        ZSTD_compressEnd(zcs, cDst, oSize,
                                    zcs->inBuff + zcs->inToCompress, iSize) :
                        ZSTD_compressContinue(zcs, cDst, oSize,
                                    zcs->inBuff + zcs->inToCompress, iSize);
                if (ZSTD_isError(cSize)) return cSize;
                zcs->frameEnded = lastBlock;
                /* prepare next block */
                zcs->inBuffTarget = zcs->inBuffPos + zcs->blockSize;
                if (zcs->inBuffTarget > zcs->inBuffSize)
                    zcs->inBuffPos = 0, zcs->inBuffTarget = zcs->blockSize;
                DEBUGLOG(5, "inBuffTarget:%u / inBuffSize:%u",
                         (U32)zcs->inBuffTarget, (U32)zcs->inBuffSize);
                if (!lastBlock)
                    assert(zcs->inBuffTarget <= zcs->inBuffSize);
                zcs->inToCompress = zcs->inBuffPos;
                if (cDst == op) {  /* no need to flush */
                    op += cSize;
                    if (zcs->frameEnded) {
                        DEBUGLOG(5, "Frame completed directly in outBuffer");
                        someMoreWork = 0;
                        ZSTD_CCtx_reset(zcs);
                    }
                    break;
                }
                zcs->outBuffContentSize = cSize;
                zcs->outBuffFlushedSize = 0;
                zcs->streamStage = zcss_flush; /* pass-through to flush stage */
            }
        /* fall-through */
        case zcss_flush:
            DEBUGLOG(5, "flush stage");
            {   size_t const toFlush = zcs->outBuffContentSize - zcs->outBuffFlushedSize;
                size_t const flushed = ZSTD_limitCopy(op, oend-op,
                            zcs->outBuff + zcs->outBuffFlushedSize, toFlush);
                DEBUGLOG(5, "toFlush: %u into %u ==> flushed: %u",
                            (U32)toFlush, (U32)(oend-op), (U32)flushed);
                op += flushed;
                zcs->outBuffFlushedSize += flushed;
                if (toFlush!=flushed) {
                    /* flush not fully completed, presumably because dst is too small */
                    assert(op==oend);
                    someMoreWork = 0;
                    break;
                }
                zcs->outBuffContentSize = zcs->outBuffFlushedSize = 0;
                if (zcs->frameEnded) {
                    DEBUGLOG(5, "Frame completed on flush");
                    someMoreWork = 0;
                    ZSTD_CCtx_reset(zcs);
                    break;
                }
                zcs->streamStage = zcss_load;
                break;
            }

        default: /* impossible */
            assert(0);
        }
    }

    input->pos = ip - istart;
    output->pos = op - ostart;
    if (zcs->frameEnded) return 0;
    {   size_t hintInSize = zcs->inBuffTarget - zcs->inBuffPos;
        if (hintInSize==0) hintInSize = zcs->blockSize;
        return hintInSize;
    }
}

Referenced by ZSTD_compress_generic(), ZSTD_compressStream(), ZSTD_endStream(), and ZSTD_flushStream().

ZSTD_count()

MEM_STATIC size_t ZSTD_count	(	const BYTE *	pIn,
		const BYTE *	pMatch,
		const BYTE *const	pInLimit
	)

Definition at line 420 of file zstd_compress_internal.h.

{
    const BYTE* const pStart = pIn;
    const BYTE* const pInLoopLimit = pInLimit - (sizeof(size_t)-1);

    if (pIn < pInLoopLimit) {
        { size_t const diff = MEM_readST(pMatch) ^ MEM_readST(pIn);
          if (diff) return ZSTD_NbCommonBytes(diff); }
        pIn+=sizeof(size_t); pMatch+=sizeof(size_t);
        while (pIn < pInLoopLimit) {
            size_t const diff = MEM_readST(pMatch) ^ MEM_readST(pIn);
            if (!diff) { pIn+=sizeof(size_t); pMatch+=sizeof(size_t); continue; }
            pIn += ZSTD_NbCommonBytes(diff);
            return (size_t)(pIn - pStart);
    }   }
    if (MEM_64bits() && (pIn<(pInLimit-3)) && (MEM_read32(pMatch) == MEM_read32(pIn))) { pIn+=4; pMatch+=4; }
    if ((pIn<(pInLimit-1)) && (MEM_read16(pMatch) == MEM_read16(pIn))) { pIn+=2; pMatch+=2; }
    if ((pIn<pInLimit) && (*pMatch == *pIn)) pIn++;
    return (size_t)(pIn - pStart);
}

Referenced by ZSTD_compressBlock_doubleFast_generic(), ZSTD_compressBlock_fast_generic(), ZSTD_compressBlock_lazy_generic(), ZSTD_count_2segments(), ZSTD_DUBT_findBestMatch(), ZSTD_HcFindBestMatch_generic(), ZSTD_insertBt1(), ZSTD_insertBtAndGetAllMatches(), ZSTD_insertDUBT1(), and ZSTD_ldm_generateSequences_internal().

ZSTD_count_2segments()

MEM_STATIC size_t ZSTD_count_2segments	(	const BYTE *	ip,
		const BYTE *	match,
		const BYTE *	iEnd,
		const BYTE *	mEnd,
		const BYTE *	iStart
	)

ZSTD_count_2segments() : can count match length with ip & match in 2 different segments. convention : on reaching mEnd, match count continue starting from iStart

Definition at line 446 of file zstd_compress_internal.h.

{
    const BYTE* const vEnd = MIN( ip + (mEnd - match), iEnd);
    size_t const matchLength = ZSTD_count(ip, match, vEnd);
    if (match + matchLength != mEnd) return matchLength;
    DEBUGLOG(7, "ZSTD_count_2segments: found a 2-parts match (current length==%zu)", matchLength);
    DEBUGLOG(7, "distance from match beginning to end dictionary = %zi", mEnd - match);
    DEBUGLOG(7, "distance from current pos to end buffer = %zi", iEnd - ip);
    DEBUGLOG(7, "next byte : ip==%02X, istart==%02X", ip[matchLength], *iStart);
    DEBUGLOG(7, "final match length = %zu", matchLength + ZSTD_count(ip+matchLength, iStart, iEnd));
    return matchLength + ZSTD_count(ip+matchLength, iStart, iEnd);
}

Referenced by ZSTD_compressBlock_doubleFast_extDict_generic(), ZSTD_compressBlock_doubleFast_generic(), ZSTD_compressBlock_fast_extDict_generic(), ZSTD_compressBlock_fast_generic(), ZSTD_compressBlock_lazy_extDict_generic(), ZSTD_compressBlock_lazy_generic(), ZSTD_DUBT_findBestMatch(), ZSTD_DUBT_findBetterDictMatch(), ZSTD_HcFindBestMatch_generic(), ZSTD_insertBt1(), ZSTD_insertBtAndGetAllMatches(), ZSTD_insertDUBT1(), and ZSTD_ldm_generateSequences_internal().

ZSTD_debugTable()

MEM_STATIC void ZSTD_debugTable	(	const U32 *	table,
		U32	max
	)

Definition at line 707 of file zstd_compress_internal.h.

{
    unsigned u, sum;
    for (u=0, sum=0; u<=max; u++) sum += table[u];
    DEBUGLOG(2, "total nb elts: %u", sum);
    for (u=0; u<=max; u++) {
        DEBUGLOG(2, "%2u: %5u  (%.2f)",
                u, table[u], ZSTD_fWeight(sum) - ZSTD_fWeight(table[u]) );
    }
}

ZSTD_fWeight()

MEM_STATIC double ZSTD_fWeight

(

U32

rawStat

)

Definition at line 694 of file zstd_compress_internal.h.

{
    U32 const fp_accuracy = 8;
    U32 const fp_multiplier = (1 << fp_accuracy);
    U32 const stat = rawStat + 1;
    U32 const hb = ZSTD_highbit32(stat);
    U32 const BWeight = hb * fp_multiplier;
    U32 const FWeight = (stat << fp_accuracy) >> hb;
    U32 const weight = BWeight + FWeight;
    assert(hb + fp_accuracy < 31);
    return (double)weight / fp_multiplier;
}

Referenced by ZSTD_debugTable().

ZSTD_getCParamsFromCCtxParams()

ZSTD_compressionParameters ZSTD_getCParamsFromCCtxParams	(	const ZSTD_CCtx_params *	CCtxParams,
		U64	srcSizeHint,
		size_t	dictSize
	)

Definition at line 768 of file zstd_compress.c.

{
    ZSTD_compressionParameters cParams = ZSTD_getCParams(CCtxParams->compressionLevel, srcSizeHint, dictSize);
    if (CCtxParams->ldmParams.enableLdm) cParams.windowLog = ZSTD_LDM_DEFAULT_WINDOW_LOG;
    if (CCtxParams->cParams.windowLog) cParams.windowLog = CCtxParams->cParams.windowLog;
    if (CCtxParams->cParams.hashLog) cParams.hashLog = CCtxParams->cParams.hashLog;
    if (CCtxParams->cParams.chainLog) cParams.chainLog = CCtxParams->cParams.chainLog;
    if (CCtxParams->cParams.searchLog) cParams.searchLog = CCtxParams->cParams.searchLog;
    if (CCtxParams->cParams.searchLength) cParams.searchLength = CCtxParams->cParams.searchLength;
    if (CCtxParams->cParams.targetLength) cParams.targetLength = CCtxParams->cParams.targetLength;
    if (CCtxParams->cParams.strategy) cParams.strategy = CCtxParams->cParams.strategy;
    assert(!ZSTD_checkCParams(cParams));
    return ZSTD_adjustCParams_internal(cParams, srcSizeHint, dictSize);
}

Referenced by ZSTD_CCtx_loadDictionary_advanced(), ZSTD_compress_generic(), ZSTD_estimateCCtxSize_usingCCtxParams(), ZSTD_initCStream_internal(), and ZSTD_resetCStream_internal().

ZSTD_getCParamsFromCDict()

ZSTD_compressionParameters ZSTD_getCParamsFromCDict

(

const ZSTD_CDict *

cdict

)

ZSTD_getCParamsFromCDict() : as the name implies

Definition at line 3370 of file zstd_compress.c.

{
    assert(cdict != NULL);
    return cdict->matchState.cParams;
}

Referenced by ZSTD_compressBegin_usingCDict_advanced(), ZSTD_initCStream_internal(), and ZSTD_initCStream_usingCDict_advanced().

ZSTD_hash3()

static U32 ZSTD_hash3 ( U32  u, U32  h  )

static

Definition at line 465 of file zstd_compress_internal.h.

{ return ((u << (32-24)) * prime3bytes)  >> (32-h) ; }

Referenced by ZSTD_hash3Ptr().

ZSTD_hash3Ptr()

MEM_STATIC size_t ZSTD_hash3Ptr	(	const void *	ptr,
		U32	h
	)

Definition at line 466 of file zstd_compress_internal.h.

{ return ZSTD_hash3(MEM_readLE32(ptr), h); } /* only in zstd_opt.h */

Referenced by ZSTD_insertAndFindFirstIndexHash3().

ZSTD_hash4()

static U32 ZSTD_hash4 ( U32  u, U32  h  )

static

Definition at line 469 of file zstd_compress_internal.h.

{ return (u * prime4bytes) >> (32-h) ; }

Referenced by ZSTD_hash4Ptr().

ZSTD_hash4Ptr()

static size_t ZSTD_hash4Ptr ( const void *  ptr, U32  h  )

static

Definition at line 470 of file zstd_compress_internal.h.

{ return ZSTD_hash4(MEM_read32(ptr), h); }

Referenced by ZSTD_hashPtr().

ZSTD_hash5()

static size_t ZSTD_hash5 ( U64  u, U32  h  )

static

Definition at line 473 of file zstd_compress_internal.h.

{ return (size_t)(((u  << (64-40)) * prime5bytes) >> (64-h)) ; }

Referenced by ZSTD_hash5Ptr().

ZSTD_hash5Ptr()

static size_t ZSTD_hash5Ptr ( const void *  p, U32  h  )

static

Definition at line 474 of file zstd_compress_internal.h.

{ return ZSTD_hash5(MEM_readLE64(p), h); }

Referenced by ZSTD_hashPtr().

ZSTD_hash6()

static size_t ZSTD_hash6 ( U64  u, U32  h  )

static

Definition at line 477 of file zstd_compress_internal.h.

{ return (size_t)(((u  << (64-48)) * prime6bytes) >> (64-h)) ; }

Referenced by ZSTD_hash6Ptr().

ZSTD_hash6Ptr()

static size_t ZSTD_hash6Ptr ( const void *  p, U32  h  )

static

Definition at line 478 of file zstd_compress_internal.h.

{ return ZSTD_hash6(MEM_readLE64(p), h); }

Referenced by ZSTD_hashPtr().

ZSTD_hash7()

static size_t ZSTD_hash7 ( U64  u, U32  h  )

static

Definition at line 481 of file zstd_compress_internal.h.

{ return (size_t)(((u  << (64-56)) * prime7bytes) >> (64-h)) ; }

Referenced by ZSTD_hash7Ptr().

ZSTD_hash7Ptr()

static size_t ZSTD_hash7Ptr ( const void *  p, U32  h  )

static

Definition at line 482 of file zstd_compress_internal.h.

{ return ZSTD_hash7(MEM_readLE64(p), h); }

Referenced by ZSTD_hashPtr().

ZSTD_hash8()

static size_t ZSTD_hash8 ( U64  u, U32  h  )

static

Definition at line 485 of file zstd_compress_internal.h.

{ return (size_t)(((u) * prime8bytes) >> (64-h)) ; }

Referenced by ZSTD_hash8Ptr().

ZSTD_hash8Ptr()

static size_t ZSTD_hash8Ptr ( const void *  p, U32  h  )

static

Definition at line 486 of file zstd_compress_internal.h.

{ return ZSTD_hash8(MEM_readLE64(p), h); }

Referenced by ZSTD_hashPtr().

ZSTD_hashPtr()

MEM_STATIC size_t ZSTD_hashPtr	(	const void *	p,
		U32	hBits,
		U32	mls
	)

Definition at line 488 of file zstd_compress_internal.h.

{
    switch(mls)
    {
    default:
    case 4: return ZSTD_hash4Ptr(p, hBits);
    case 5: return ZSTD_hash5Ptr(p, hBits);
    case 6: return ZSTD_hash6Ptr(p, hBits);
    case 7: return ZSTD_hash7Ptr(p, hBits);
    case 8: return ZSTD_hash8Ptr(p, hBits);
    }
}

Referenced by ZSTD_compressBlock_doubleFast_extDict_generic(), ZSTD_compressBlock_doubleFast_generic(), ZSTD_compressBlock_fast_extDict_generic(), ZSTD_compressBlock_fast_generic(), ZSTD_DUBT_findBestMatch(), ZSTD_DUBT_findBetterDictMatch(), ZSTD_fillDoubleHashTable(), ZSTD_fillHashTable(), ZSTD_HcFindBestMatch_generic(), ZSTD_insertAndFindFirstIndex_internal(), ZSTD_insertBt1(), ZSTD_insertBtAndGetAllMatches(), and ZSTD_updateDUBT().

ZSTD_initCStream_internal()

size_t ZSTD_initCStream_internal	(	ZSTD_CStream *	zcs,
		const void *	dict,
		size_t	dictSize,
		const ZSTD_CDict *	cdict,
		ZSTD_CCtx_params	params,
		unsigned long long	pledgedSrcSize
	)

ZSTD_initCStream_internal() : Private use only. Init streaming operation. expects params to be valid. must receive dict, or cdict, or none, but not both.

Returns

: 0, or an error code

ZSTD_initCStream_internal() : Note : for lib/compress only. Used by zstdmt_compress.c. Assumption 1 : params are valid Assumption 2 : either dict, or cdict, is defined, not both

Definition at line 3518 of file zstd_compress.c.

{
    DEBUGLOG(4, "ZSTD_initCStream_internal");
    params.cParams = ZSTD_getCParamsFromCCtxParams(&params, pledgedSrcSize, dictSize);
    assert(!ZSTD_isError(ZSTD_checkCParams(params.cParams)));
    assert(!((dict) && (cdict)));  /* either dict or cdict, not both */

    if (dict && dictSize >= 8) {
        DEBUGLOG(4, "loading dictionary of size %u", (U32)dictSize);
        if (zcs->staticSize) {   /* static CCtx : never uses malloc */
            /* incompatible with internal cdict creation */
            return ERROR(memory_allocation);
        }
        ZSTD_freeCDict(zcs->cdictLocal);
        zcs->cdictLocal = ZSTD_createCDict_advanced(dict, dictSize,
                                            ZSTD_dlm_byCopy, ZSTD_dct_auto,
                                            params.cParams, zcs->customMem);
        zcs->cdict = zcs->cdictLocal;
        if (zcs->cdictLocal == NULL) return ERROR(memory_allocation);
    } else {
        if (cdict) {
            params.cParams = ZSTD_getCParamsFromCDict(cdict);  /* cParams are enforced from cdict; it includes windowLog */
        }
        ZSTD_freeCDict(zcs->cdictLocal);
        zcs->cdictLocal = NULL;
        zcs->cdict = cdict;
    }

    return ZSTD_resetCStream_internal(zcs, NULL, 0, ZSTD_dct_auto, zcs->cdict, params, pledgedSrcSize);
}

Referenced by ZSTD_initCStream_advanced(), ZSTD_initCStream_srcSize(), ZSTD_initCStream_usingCDict_advanced(), and ZSTD_initCStream_usingDict().

ZSTD_LLcode()

MEM_STATIC U32 ZSTD_LLcode

(

U32

litLength

)

Definition at line 272 of file zstd_compress_internal.h.

{
    static const BYTE LL_Code[64] = {  0,  1,  2,  3,  4,  5,  6,  7,
                                       8,  9, 10, 11, 12, 13, 14, 15,
                                      16, 16, 17, 17, 18, 18, 19, 19,
                                      20, 20, 20, 20, 21, 21, 21, 21,
                                      22, 22, 22, 22, 22, 22, 22, 22,
                                      23, 23, 23, 23, 23, 23, 23, 23,
                                      24, 24, 24, 24, 24, 24, 24, 24,
                                      24, 24, 24, 24, 24, 24, 24, 24 };
    static const U32 LL_deltaCode = 19;
    return (litLength > 63) ? ZSTD_highbit32(litLength) + LL_deltaCode : LL_Code[litLength];
}

Referenced by ZSTD_litLengthContribution(), ZSTD_litLengthPrice(), ZSTD_seqToCodes(), and ZSTD_updateStats().

ZSTD_matchState_dictMode()

MEM_STATIC ZSTD_dictMode_e ZSTD_matchState_dictMode

(

const ZSTD_matchState_t *

ms

)

ZSTD_matchState_dictMode(): Inspects the provided matchState and figures out what dictMode should be passed to the compressor.

Definition at line 538 of file zstd_compress_internal.h.

{
    return ZSTD_window_hasExtDict(ms->window) ?
        ZSTD_extDict :
        ms->dictMatchState != NULL ?
            ZSTD_dictMatchState :
            ZSTD_noDict;
}

Referenced by ZSTD_compressBlock_internal(), and ZSTD_ldm_blockCompress().

ZSTD_MLcode()

MEM_STATIC U32 ZSTD_MLcode

(

U32

mlBase

)

Definition at line 289 of file zstd_compress_internal.h.

{
    static const BYTE ML_Code[128] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
                                      16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
                                      32, 32, 33, 33, 34, 34, 35, 35, 36, 36, 36, 36, 37, 37, 37, 37,
                                      38, 38, 38, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 39, 39, 39,
                                      40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
                                      41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
                                      42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
                                      42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42 };
    static const U32 ML_deltaCode = 36;
    return (mlBase > 127) ? ZSTD_highbit32(mlBase) + ML_deltaCode : ML_Code[mlBase];
}

Referenced by ZSTD_getMatchPrice(), ZSTD_seqToCodes(), and ZSTD_updateStats().

ZSTD_NbCommonBytes()

static unsigned ZSTD_NbCommonBytes ( size_t  val )

static

Definition at line 351 of file zstd_compress_internal.h.

{
    if (MEM_isLittleEndian()) {
        if (MEM_64bits()) {
#       if defined(_MSC_VER) && defined(_WIN64)
            unsigned long r = 0;
            _BitScanForward64( &r, (U64)val );
            return (unsigned)(r>>3);
#       elif defined(__GNUC__) && (__GNUC__ >= 4)
            return (__builtin_ctzll((U64)val) >> 3);
#       else
            static const int DeBruijnBytePos[64] = { 0, 0, 0, 0, 0, 1, 1, 2,
                                                     0, 3, 1, 3, 1, 4, 2, 7,
                                                     0, 2, 3, 6, 1, 5, 3, 5,
                                                     1, 3, 4, 4, 2, 5, 6, 7,
                                                     7, 0, 1, 2, 3, 3, 4, 6,
                                                     2, 6, 5, 5, 3, 4, 5, 6,
                                                     7, 1, 2, 4, 6, 4, 4, 5,
                                                     7, 2, 6, 5, 7, 6, 7, 7 };
            return DeBruijnBytePos[((U64)((val & -(long long)val) * 0x0218A392CDABBD3FULL)) >> 58];
#       endif
        } else { /* 32 bits */
#       if defined(_MSC_VER)
            unsigned long r=0;
            _BitScanForward( &r, (U32)val );
            return (unsigned)(r>>3);
#       elif defined(__GNUC__) && (__GNUC__ >= 3)
            return (__builtin_ctz((U32)val) >> 3);
#       else
            static const int DeBruijnBytePos[32] = { 0, 0, 3, 0, 3, 1, 3, 0,
                                                     3, 2, 2, 1, 3, 2, 0, 1,
                                                     3, 3, 1, 2, 2, 2, 2, 0,
                                                     3, 1, 2, 0, 1, 0, 1, 1 };
            return DeBruijnBytePos[((U32)((val & -(S32)val) * 0x077CB531U)) >> 27];
#       endif
        }
    } else {  /* Big Endian CPU */
        if (MEM_64bits()) {
#       if defined(_MSC_VER) && defined(_WIN64)
            unsigned long r = 0;
            _BitScanReverse64( &r, val );
            return (unsigned)(r>>3);
#       elif defined(__GNUC__) && (__GNUC__ >= 4)
            return (__builtin_clzll(val) >> 3);
#       else
            unsigned r;
            const unsigned n32 = sizeof(size_t)*4;   /* calculate this way due to compiler complaining in 32-bits mode */
            if (!(val>>n32)) { r=4; } else { r=0; val>>=n32; }
            if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; }
            r += (!val);
            return r;
#       endif
        } else { /* 32 bits */
#       if defined(_MSC_VER)
            unsigned long r = 0;
            _BitScanReverse( &r, (unsigned long)val );
            return (unsigned)(r>>3);
#       elif defined(__GNUC__) && (__GNUC__ >= 3)
            return (__builtin_clz((U32)val) >> 3);
#       else
            unsigned r;
            if (!(val>>16)) { r=2; val>>=8; } else { r=0; val>>=24; }
            r += (!val);
            return r;
#       endif
    }   }
}

Referenced by ZSTD_count().

ZSTD_referenceExternalSequences()

size_t ZSTD_referenceExternalSequences	(	ZSTD_CCtx *	cctx,
		rawSeq *	seq,
		size_t	nbSeq
	)

Definition at line 2652 of file zstd_compress.c.

{
    if (cctx->stage != ZSTDcs_init)
        return ERROR(stage_wrong);
    if (cctx->appliedParams.ldmParams.enableLdm)
        return ERROR(parameter_unsupported);
    cctx->externSeqStore.seq = seq;
    cctx->externSeqStore.size = nbSeq;
    cctx->externSeqStore.capacity = nbSeq;
    cctx->externSeqStore.pos = 0;
    return 0;
}

Referenced by ZSTD_continueCCtx(), and ZSTD_resetCCtx_internal().

ZSTD_resetSeqStore()

void ZSTD_resetSeqStore

(

seqStore_t *

ssPtr

)

Definition at line 2411 of file zstd_compress.c.

{
    ssPtr->lit = ssPtr->litStart;
    ssPtr->sequences = ssPtr->sequencesStart;
    ssPtr->longLengthID = 0;
}

Referenced by ZSTD_compressBlock_btultra(), and ZSTD_compressBlock_internal().

ZSTD_selectBlockCompressor()

ZSTD_blockCompressor ZSTD_selectBlockCompressor	(	ZSTD_strategy	strat,
		ZSTD_dictMode_e	dictMode
	)

Definition at line 2363 of file zstd_compress.c.

{
    static const ZSTD_blockCompressor blockCompressor[3][(unsigned)ZSTD_btultra+1] = {
        { ZSTD_compressBlock_fast  /* default for 0 */,
          ZSTD_compressBlock_fast,
          ZSTD_compressBlock_doubleFast,
          ZSTD_compressBlock_greedy,
          ZSTD_compressBlock_lazy,
          ZSTD_compressBlock_lazy2,
          ZSTD_compressBlock_btlazy2,
          ZSTD_compressBlock_btopt,
          ZSTD_compressBlock_btultra },
        { ZSTD_compressBlock_fast_extDict  /* default for 0 */,
          ZSTD_compressBlock_fast_extDict,
          ZSTD_compressBlock_doubleFast_extDict,
          ZSTD_compressBlock_greedy_extDict,
          ZSTD_compressBlock_lazy_extDict,
          ZSTD_compressBlock_lazy2_extDict,
          ZSTD_compressBlock_btlazy2_extDict,
          ZSTD_compressBlock_btopt_extDict,
          ZSTD_compressBlock_btultra_extDict },
        { ZSTD_compressBlock_fast_dictMatchState  /* default for 0 */,
          ZSTD_compressBlock_fast_dictMatchState,
          ZSTD_compressBlock_doubleFast_dictMatchState,
          ZSTD_compressBlock_greedy_dictMatchState,
          ZSTD_compressBlock_lazy_dictMatchState,
          ZSTD_compressBlock_lazy2_dictMatchState,
          ZSTD_compressBlock_btlazy2_dictMatchState,
          ZSTD_compressBlock_btopt_dictMatchState,
          ZSTD_compressBlock_btultra_dictMatchState }
    };
    ZSTD_blockCompressor selectedCompressor;
    ZSTD_STATIC_ASSERT((unsigned)ZSTD_fast == 1);

    assert((U32)strat >= (U32)ZSTD_fast);
    assert((U32)strat <= (U32)ZSTD_btultra);
    selectedCompressor = blockCompressor[(int)dictMode][(U32)strat];
    assert(selectedCompressor != NULL);
    return selectedCompressor;
}

Referenced by ZSTD_compressBlock_internal(), and ZSTD_ldm_blockCompress().

ZSTD_storeSeq()

MEM_STATIC void ZSTD_storeSeq	(	seqStore_t *	seqStorePtr,
		size_t	litLength,
		const void *	literals,
		U32	offsetCode,
		size_t	mlBase
	)

ZSTD_storeSeq() : Store a sequence (literal length, literals, offset code and match length code) into seqStore_t. offsetCode : distance to match + 3 (values 1-3 are repCodes). mlBase : matchLength - MINMATCH

Definition at line 308 of file zstd_compress_internal.h.

{
#if defined(DEBUGLEVEL) && (DEBUGLEVEL >= 6)
    static const BYTE* g_start = NULL;
    if (g_start==NULL) g_start = (const BYTE*)literals;  /* note : index only works for compression within a single segment */
    {   U32 const pos = (U32)((const BYTE*)literals - g_start);
        DEBUGLOG(6, "Cpos%7u :%3u literals, match%4u bytes at offCode%7u",
               pos, (U32)litLength, (U32)mlBase+MINMATCH, (U32)offsetCode);
    }
#endif
    assert((size_t)(seqStorePtr->sequences - seqStorePtr->sequencesStart) < seqStorePtr->maxNbSeq);
    /* copy Literals */
    assert(seqStorePtr->maxNbLit <= 128 KB);
    assert(seqStorePtr->lit + litLength <= seqStorePtr->litStart + seqStorePtr->maxNbLit);
    ZSTD_wildcopy(seqStorePtr->lit, literals, litLength);
    seqStorePtr->lit += litLength;

    /* literal Length */
    if (litLength>0xFFFF) {
        assert(seqStorePtr->longLengthID == 0); /* there can only be a single long length */
        seqStorePtr->longLengthID = 1;
        seqStorePtr->longLengthPos = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
    }
    seqStorePtr->sequences[0].litLength = (U16)litLength;

    /* match offset */
    seqStorePtr->sequences[0].offset = offsetCode + 1;

    /* match Length */
    if (mlBase>0xFFFF) {
        assert(seqStorePtr->longLengthID == 0); /* there can only be a single long length */
        seqStorePtr->longLengthID = 2;
        seqStorePtr->longLengthPos = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
    }
    seqStorePtr->sequences[0].matchLength = (U16)mlBase;

    seqStorePtr->sequences++;
}

Referenced by ZSTD_compressBlock_doubleFast_extDict_generic(), ZSTD_compressBlock_doubleFast_generic(), ZSTD_compressBlock_fast_extDict_generic(), ZSTD_compressBlock_fast_generic(), ZSTD_compressBlock_lazy_extDict_generic(), ZSTD_compressBlock_lazy_generic(), ZSTD_compressBlock_opt_generic(), and ZSTD_ldm_blockCompress().

ZSTD_window_clear()

MEM_STATIC void ZSTD_window_clear

(

ZSTD_window_t *

window

)

ZSTD_window_clear(): Clears the window containing the history by simply setting it to empty.

Definition at line 515 of file zstd_compress_internal.h.

{
    size_t const endT = (size_t)(window->nextSrc - window->base);
    U32 const end = (U32)endT;

    window->lowLimit = end;
    window->dictLimit = end;
}

Referenced by ZSTD_continueCCtx(), ZSTD_invalidateMatchState(), ZSTD_resetCCtx_byAttachingCDict(), and ZSTD_resetCCtx_internal().

ZSTD_window_correctOverflow()

MEM_STATIC U32 ZSTD_window_correctOverflow	(	ZSTD_window_t *	window,
		U32	cycleLog,
		U32	maxDist,
		void const *	src
	)

ZSTD_window_correctOverflow(): Reduces the indices to protect from index overflow. Returns the correction made to the indices, which must be applied to every stored index.

The least significant cycleLog bits of the indices must remain the same, which may be 0. Every index up to maxDist in the past must be valid. NOTE: (maxDist & cycleMask) must be zero.

Definition at line 569 of file zstd_compress_internal.h.

{
    /* preemptive overflow correction:
     * 1. correction is large enough:
     *    lowLimit > (3<<29) ==> current > 3<<29 + 1<<windowLog
     *    1<<windowLog <= newCurrent < 1<<chainLog + 1<<windowLog
     *
     *    current - newCurrent
     *    > (3<<29 + 1<<windowLog) - (1<<windowLog + 1<<chainLog)
     *    > (3<<29) - (1<<chainLog)
     *    > (3<<29) - (1<<30)             (NOTE: chainLog <= 30)
     *    > 1<<29
     *
     * 2. (ip+ZSTD_CHUNKSIZE_MAX - cctx->base) doesn't overflow:
     *    After correction, current is less than (1<<chainLog + 1<<windowLog).
     *    In 64-bit mode we are safe, because we have 64-bit ptrdiff_t.
     *    In 32-bit mode we are safe, because (chainLog <= 29), so
     *    ip+ZSTD_CHUNKSIZE_MAX - cctx->base < 1<<32.
     * 3. (cctx->lowLimit + 1<<windowLog) < 1<<32:
     *    windowLog <= 31 ==> 3<<29 + 1<<windowLog < 7<<29 < 1<<32.
     */
    U32 const cycleMask = (1U << cycleLog) - 1;
    U32 const current = (U32)((BYTE const*)src - window->base);
    U32 const newCurrent = (current & cycleMask) + maxDist;
    U32 const correction = current - newCurrent;
    assert((maxDist & cycleMask) == 0);
    assert(current > newCurrent);
    /* Loose bound, should be around 1<<29 (see above) */
    assert(correction > 1<<28);

    window->base += correction;
    window->dictBase += correction;
    window->lowLimit -= correction;
    window->dictLimit -= correction;

    DEBUGLOG(4, "Correction of 0x%x bytes to lowLimit=0x%x", correction,
             window->lowLimit);
    return correction;
}

Referenced by ZSTD_compress_frameChunk(), ZSTD_compressContinue_internal(), and ZSTD_ldm_generateSequences().

ZSTD_window_enforceMaxDist()

MEM_STATIC void ZSTD_window_enforceMaxDist	(	ZSTD_window_t *	window,
		void const *	srcEnd,
		U32	maxDist,
		U32 *	loadedDictEndPtr,
		const ZSTD_matchState_t **	dictMatchStatePtr
	)

ZSTD_window_enforceMaxDist(): Updates lowLimit so that: (srcEnd - base) - lowLimit == maxDist + loadedDictEnd

This allows a simple check that index >= lowLimit to see if index is valid. This must be called before a block compression call, with srcEnd as the block source end.

If loadedDictEndPtr is not NULL, we set it to zero once we update lowLimit. This is because dictionaries are allowed to be referenced as long as the last byte of the dictionary is in the window, but once they are out of range, they cannot be referenced. If loadedDictEndPtr is NULL, we use loadedDictEnd == 0.

In normal dict mode, the dict is between lowLimit and dictLimit. In dictMatchState mode, lowLimit and dictLimit are the same, and the dictionary is below them. forceWindow and dictMatchState are therefore incompatible.

Definition at line 629 of file zstd_compress_internal.h.

{
    U32 const current = (U32)((BYTE const*)srcEnd - window->base);
    U32 loadedDictEnd = loadedDictEndPtr != NULL ? *loadedDictEndPtr : 0;
    DEBUGLOG(5, "ZSTD_window_enforceMaxDist: current=%u, maxDist=%u", current, maxDist);
    if (current > maxDist + loadedDictEnd) {
        U32 const newLowLimit = current - maxDist;
        if (window->lowLimit < newLowLimit) window->lowLimit = newLowLimit;
        if (window->dictLimit < window->lowLimit) {
            DEBUGLOG(5, "Update dictLimit to match lowLimit, from %u to %u",
                        window->dictLimit, window->lowLimit);
            window->dictLimit = window->lowLimit;
        }
        if (loadedDictEndPtr)
            *loadedDictEndPtr = 0;
        if (dictMatchStatePtr)
            *dictMatchStatePtr = NULL;
    }
}

Referenced by ZSTD_compress_frameChunk(), and ZSTD_ldm_generateSequences().

ZSTD_window_hasExtDict()

MEM_STATIC U32 ZSTD_window_hasExtDict

(

ZSTD_window_t const

window

)

ZSTD_window_hasExtDict(): Returns non-zero if the window has a non-empty extDict.

Definition at line 528 of file zstd_compress_internal.h.

{
    return window.lowLimit < window.dictLimit;
}

Referenced by ZSTD_invalidateRepCodes(), ZSTD_ldm_generateSequences_internal(), and ZSTD_matchState_dictMode().

ZSTD_window_needOverflowCorrection()

MEM_STATIC U32 ZSTD_window_needOverflowCorrection	(	ZSTD_window_t const	window,
		void const *	srcEnd
	)

ZSTD_window_needOverflowCorrection(): Returns non-zero if the indices are getting too large and need overflow protection.

Definition at line 552 of file zstd_compress_internal.h.

{
    U32 const current = (U32)((BYTE const*)srcEnd - window.base);
    return current > ZSTD_CURRENT_MAX;
}

Referenced by ZSTD_compress_frameChunk(), ZSTD_compressContinue_internal(), and ZSTD_ldm_generateSequences().

ZSTD_window_update()

MEM_STATIC U32 ZSTD_window_update	(	ZSTD_window_t *	window,
		void const *	src,
		size_t	srcSize
	)

ZSTD_window_update(): Updates the window by appending [src, src + srcSize) to the window. If it is not contiguous, the current prefix becomes the extDict, and we forget about the extDict. Handles overlap of the prefix and extDict. Returns non-zero if the segment is contiguous.

Definition at line 659 of file zstd_compress_internal.h.

{
    BYTE const* const ip = (BYTE const*)src;
    U32 contiguous = 1;
    DEBUGLOG(5, "ZSTD_window_update");
    /* Check if blocks follow each other */
    if (src != window->nextSrc) {
        /* not contiguous */
        size_t const distanceFromBase = (size_t)(window->nextSrc - window->base);
        DEBUGLOG(5, "Non contiguous blocks, new segment starts at %u", window->dictLimit);
        window->lowLimit = window->dictLimit;
        assert(distanceFromBase == (size_t)(U32)distanceFromBase);  /* should never overflow */
        window->dictLimit = (U32)distanceFromBase;
        window->dictBase = window->base;
        window->base = ip - distanceFromBase;
        // ms->nextToUpdate = window->dictLimit;
        if (window->dictLimit - window->lowLimit < HASH_READ_SIZE) window->lowLimit = window->dictLimit;   /* too small extDict */
        contiguous = 0;
    }
    window->nextSrc = ip + srcSize;
    /* if input and dictionary overlap : reduce dictionary (area presumed modified by input) */
    if ( (ip+srcSize > window->dictBase + window->lowLimit)
       & (ip < window->dictBase + window->dictLimit)) {
        ptrdiff_t const highInputIdx = (ip + srcSize) - window->dictBase;
        U32 const lowLimitMax = (highInputIdx > (ptrdiff_t)window->dictLimit) ? window->dictLimit : (U32)highInputIdx;
        window->lowLimit = lowLimitMax;
        DEBUGLOG(5, "Overlapping extDict and input : new lowLimit = %u", window->lowLimit);
    }
    return contiguous;
}

Referenced by ZSTD_compressContinue_internal(), and ZSTD_loadDictionaryContent().

ZSTD_writeLastEmptyBlock()

size_t ZSTD_writeLastEmptyBlock	(	void *	dst,
		size_t	dstCapacity
	)

Definition at line 2643 of file zstd_compress.c.

{
    if (dstCapacity < ZSTD_blockHeaderSize) return ERROR(dstSize_tooSmall);
    {   U32 const cBlockHeader24 = 1 /*lastBlock*/ + (((U32)bt_raw)<<1);  /* 0 size */
        MEM_writeLE24(dst, cBlockHeader24);
        return ZSTD_blockHeaderSize;
    }
}

Variable Documentation

prime3bytes

const U32 prime3bytes = 506832829U

static

Definition at line 464 of file zstd_compress_internal.h.

Referenced by ZSTD_hash3().

prime4bytes

const U32 prime4bytes = 2654435761U

static

Definition at line 468 of file zstd_compress_internal.h.

Referenced by ZSTD_hash4().

prime5bytes

const U64 prime5bytes = 889523592379ULL

static

Definition at line 472 of file zstd_compress_internal.h.

Referenced by ZSTD_hash5().

prime6bytes

const U64 prime6bytes = 227718039650203ULL

static

Definition at line 476 of file zstd_compress_internal.h.

Referenced by ZSTD_hash6().

prime7bytes

const U64 prime7bytes = 58295818150454627ULL

static

Definition at line 480 of file zstd_compress_internal.h.

Referenced by ZSTD_hash7().

prime8bytes

const U64 prime8bytes = 0xCF1BBCDCB7A56463ULL

static

Definition at line 484 of file zstd_compress_internal.h.

Referenced by ZSTD_hash8(), ZSTD_ldm_getHashPower(), ZSTD_ldm_getRollingHash(), and ZSTD_ldm_updateHash().