ReactOS  0.4.15-dev-4916-gd519b11
zstd_compress.c File Reference
#include <limits.h>
#include <string.h>
#include "cpu.h"
#include "mem.h"
#include "hist.h"
#include "fse.h"
#include "huf.h"
#include "zstd_compress_internal.h"
#include "zstd_compress_sequences.h"
#include "zstd_compress_literals.h"
#include "zstd_fast.h"
#include "zstd_double_fast.h"
#include "zstd_lazy.h"
#include "zstd_opt.h"
#include "zstd_ldm.h"
#include "zstd_compress_superblock.h"
Include dependency graph for zstd_compress.c:

Go to the source code of this file.

Classes

struct  ZSTD_CDict_s
 

Macros

#define FSE_STATIC_LINKING_ONLY   /* FSE_encodeSymbol */
 
#define HUF_STATIC_LINKING_ONLY
 
#define BOUNDCHECK(cParam, val)
 
#define CLAMP_TYPE(cParam, val, type)
 
#define CLAMP(cParam, val)   CLAMP_TYPE(cParam, val, unsigned)
 
#define ZSTD_INDEXOVERFLOW_MARGIN   (16 MB)
 
#define ZSTD_ROWSIZE   16
 
#define ZSTD_USE_CDICT_PARAMS_SRCSIZE_CUTOFF   (128 KB)
 
#define ZSTD_USE_CDICT_PARAMS_DICTSIZE_MULTIPLIER   (6)
 
#define ZSTD_MAX_CLEVEL   22
 

Enumerations

enum  ZSTD_buffered_policy_e { ZSTDb_not_buffered, ZSTDb_buffered }
 
enum  ZSTD_compResetPolicy_e { ZSTDcrp_makeClean, ZSTDcrp_leaveDirty }
 
enum  ZSTD_indexResetPolicy_e { ZSTDirp_continue, ZSTDirp_reset }
 
enum  ZSTD_resetTarget_e { ZSTD_resetTarget_CDict, ZSTD_resetTarget_CCtx }
 
enum  ZSTD_buildSeqStore_e { ZSTDbss_compress, ZSTDbss_noCompress }
 

Functions

size_t ZSTD_compressBound (size_t srcSize)
 
ZSTD_CCtxZSTD_createCCtx (void)
 
static void ZSTD_initCCtx (ZSTD_CCtx *cctx, ZSTD_customMem memManager)
 
ZSTD_CCtxZSTD_createCCtx_advanced (ZSTD_customMem customMem)
 
ZSTD_CCtxZSTD_initStaticCCtx (void *workspace, size_t workspaceSize)
 
static void ZSTD_clearAllDicts (ZSTD_CCtx *cctx)
 
static size_t ZSTD_sizeof_localDict (ZSTD_localDict dict)
 
static void ZSTD_freeCCtxContent (ZSTD_CCtx *cctx)
 
size_t ZSTD_freeCCtx (ZSTD_CCtx *cctx)
 
static size_t ZSTD_sizeof_mtctx (const ZSTD_CCtx *cctx)
 
size_t ZSTD_sizeof_CCtx (const ZSTD_CCtx *cctx)
 
size_t ZSTD_sizeof_CStream (const ZSTD_CStream *zcs)
 
const seqStore_tZSTD_getSeqStore (const ZSTD_CCtx *ctx)
 
static ZSTD_CCtx_params ZSTD_makeCCtxParamsFromCParams (ZSTD_compressionParameters cParams)
 
static ZSTD_CCtx_params * ZSTD_createCCtxParams_advanced (ZSTD_customMem customMem)
 
ZSTD_CCtx_params * ZSTD_createCCtxParams (void)
 
size_t ZSTD_freeCCtxParams (ZSTD_CCtx_params *params)
 
size_t ZSTD_CCtxParams_reset (ZSTD_CCtx_params *params)
 
size_t ZSTD_CCtxParams_init (ZSTD_CCtx_params *cctxParams, int compressionLevel)
 
size_t ZSTD_CCtxParams_init_advanced (ZSTD_CCtx_params *cctxParams, ZSTD_parameters params)
 
static ZSTD_CCtx_params ZSTD_assignParamsToCCtxParams (const ZSTD_CCtx_params *cctxParams, const ZSTD_parameters *params)
 
ZSTD_bounds ZSTD_cParam_getBounds (ZSTD_cParameter param)
 
static size_t ZSTD_cParam_clampBounds (ZSTD_cParameter cParam, int *value)
 
static int ZSTD_isUpdateAuthorized (ZSTD_cParameter param)
 
size_t ZSTD_CCtx_setParameter (ZSTD_CCtx *cctx, ZSTD_cParameter param, int value)
 
size_t ZSTD_CCtxParams_setParameter (ZSTD_CCtx_params *CCtxParams, ZSTD_cParameter param, int value)
 
size_t ZSTD_CCtx_getParameter (ZSTD_CCtx *cctx, ZSTD_cParameter param, int *value)
 
size_t ZSTD_CCtxParams_getParameter (ZSTD_CCtx_params *CCtxParams, ZSTD_cParameter param, int *value)
 
size_t ZSTD_CCtx_setParametersUsingCCtxParams (ZSTD_CCtx *cctx, const ZSTD_CCtx_params *params)
 
ZSTDLIB_API size_t ZSTD_CCtx_setPledgedSrcSize (ZSTD_CCtx *cctx, unsigned long long pledgedSrcSize)
 
static size_t ZSTD_initLocalDict (ZSTD_CCtx *cctx)
 
size_t ZSTD_CCtx_loadDictionary_advanced (ZSTD_CCtx *cctx, const void *dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType)
 
ZSTDLIB_API size_t ZSTD_CCtx_loadDictionary_byReference (ZSTD_CCtx *cctx, const void *dict, size_t dictSize)
 
ZSTDLIB_API size_t ZSTD_CCtx_loadDictionary (ZSTD_CCtx *cctx, const void *dict, size_t dictSize)
 
size_t ZSTD_CCtx_refCDict (ZSTD_CCtx *cctx, const ZSTD_CDict *cdict)
 
size_t ZSTD_CCtx_refPrefix (ZSTD_CCtx *cctx, const void *prefix, size_t prefixSize)
 
size_t ZSTD_CCtx_refPrefix_advanced (ZSTD_CCtx *cctx, const void *prefix, size_t prefixSize, ZSTD_dictContentType_e dictContentType)
 
size_t ZSTD_CCtx_reset (ZSTD_CCtx *cctx, ZSTD_ResetDirective reset)
 
size_t ZSTD_checkCParams (ZSTD_compressionParameters cParams)
 
static ZSTD_compressionParameters ZSTD_clampCParams (ZSTD_compressionParameters cParams)
 
U32 ZSTD_cycleLog (U32 hashLog, ZSTD_strategy strat)
 
static ZSTD_compressionParameters ZSTD_adjustCParams_internal (ZSTD_compressionParameters cPar, unsigned long long srcSize, size_t dictSize)
 
ZSTD_compressionParameters ZSTD_adjustCParams (ZSTD_compressionParameters cPar, unsigned long long srcSize, size_t dictSize)
 
static ZSTD_compressionParameters ZSTD_getCParams_internal (int compressionLevel, unsigned long long srcSizeHint, size_t dictSize)
 
static ZSTD_parameters ZSTD_getParams_internal (int compressionLevel, unsigned long long srcSizeHint, size_t dictSize)
 
ZSTD_compressionParameters ZSTD_getCParamsFromCCtxParams (const ZSTD_CCtx_params *CCtxParams, U64 srcSizeHint, size_t dictSize)
 
static size_t ZSTD_sizeof_matchState (const ZSTD_compressionParameters *const cParams, const U32 forCCtx)
 
size_t ZSTD_estimateCCtxSize_usingCCtxParams (const ZSTD_CCtx_params *params)
 
size_t ZSTD_estimateCCtxSize_usingCParams (ZSTD_compressionParameters cParams)
 
static size_t ZSTD_estimateCCtxSize_internal (int compressionLevel)
 
size_t ZSTD_estimateCCtxSize (int compressionLevel)
 
size_t ZSTD_estimateCStreamSize_usingCCtxParams (const ZSTD_CCtx_params *params)
 
size_t ZSTD_estimateCStreamSize_usingCParams (ZSTD_compressionParameters cParams)
 
static size_t ZSTD_estimateCStreamSize_internal (int compressionLevel)
 
size_t ZSTD_estimateCStreamSize (int compressionLevel)
 
ZSTD_frameProgression ZSTD_getFrameProgression (const ZSTD_CCtx *cctx)
 
size_t ZSTD_toFlushNow (ZSTD_CCtx *cctx)
 
static void ZSTD_assertEqualCParams (ZSTD_compressionParameters cParams1, ZSTD_compressionParameters cParams2)
 
void ZSTD_reset_compressedBlockState (ZSTD_compressedBlockState_t *bs)
 
static void ZSTD_invalidateMatchState (ZSTD_matchState_t *ms)
 
static size_t ZSTD_reset_matchState (ZSTD_matchState_t *ms, ZSTD_cwksp *ws, const ZSTD_compressionParameters *cParams, const ZSTD_compResetPolicy_e crp, const ZSTD_indexResetPolicy_e forceResetIndex, const ZSTD_resetTarget_e forWho)
 
static int ZSTD_indexTooCloseToMax (ZSTD_window_t w)
 
static size_t ZSTD_resetCCtx_internal (ZSTD_CCtx *zc, ZSTD_CCtx_params params, U64 const pledgedSrcSize, ZSTD_compResetPolicy_e const crp, ZSTD_buffered_policy_e const zbuff)
 
void ZSTD_invalidateRepCodes (ZSTD_CCtx *cctx)
 
static int ZSTD_shouldAttachDict (const ZSTD_CDict *cdict, const ZSTD_CCtx_params *params, U64 pledgedSrcSize)
 
static size_t ZSTD_resetCCtx_byAttachingCDict (ZSTD_CCtx *cctx, const ZSTD_CDict *cdict, ZSTD_CCtx_params params, U64 pledgedSrcSize, ZSTD_buffered_policy_e zbuff)
 
static size_t ZSTD_resetCCtx_byCopyingCDict (ZSTD_CCtx *cctx, const ZSTD_CDict *cdict, ZSTD_CCtx_params params, U64 pledgedSrcSize, ZSTD_buffered_policy_e zbuff)
 
static size_t ZSTD_resetCCtx_usingCDict (ZSTD_CCtx *cctx, const ZSTD_CDict *cdict, const ZSTD_CCtx_params *params, U64 pledgedSrcSize, ZSTD_buffered_policy_e zbuff)
 
static size_t ZSTD_copyCCtx_internal (ZSTD_CCtx *dstCCtx, const ZSTD_CCtx *srcCCtx, ZSTD_frameParameters fParams, U64 pledgedSrcSize, ZSTD_buffered_policy_e zbuff)
 
size_t ZSTD_copyCCtx (ZSTD_CCtx *dstCCtx, const ZSTD_CCtx *srcCCtx, unsigned long long pledgedSrcSize)
 
FORCE_INLINE_TEMPLATE void ZSTD_reduceTable_internal (U32 *const table, U32 const size, U32 const reducerValue, int const preserveMark)
 
static void ZSTD_reduceTable (U32 *const table, U32 const size, U32 const reducerValue)
 
static void ZSTD_reduceTable_btlazy2 (U32 *const table, U32 const size, U32 const reducerValue)
 
static void ZSTD_reduceIndex (ZSTD_matchState_t *ms, ZSTD_CCtx_params const *params, const U32 reducerValue)
 
void ZSTD_seqToCodes (const seqStore_t *seqStorePtr)
 
static int ZSTD_useTargetCBlockSize (const ZSTD_CCtx_params *cctxParams)
 
MEM_STATIC size_t ZSTD_compressSequences_internal (seqStore_t *seqStorePtr, const ZSTD_entropyCTables_t *prevEntropy, ZSTD_entropyCTables_t *nextEntropy, const ZSTD_CCtx_params *cctxParams, void *dst, size_t dstCapacity, void *entropyWorkspace, size_t entropyWkspSize, const int bmi2)
 
MEM_STATIC size_t ZSTD_compressSequences (seqStore_t *seqStorePtr, const ZSTD_entropyCTables_t *prevEntropy, ZSTD_entropyCTables_t *nextEntropy, const ZSTD_CCtx_params *cctxParams, void *dst, size_t dstCapacity, size_t srcSize, void *entropyWorkspace, size_t entropyWkspSize, int bmi2)
 
ZSTD_blockCompressor ZSTD_selectBlockCompressor (ZSTD_strategy strat, ZSTD_dictMode_e dictMode)
 
static void ZSTD_storeLastLiterals (seqStore_t *seqStorePtr, const BYTE *anchor, size_t lastLLSize)
 
void ZSTD_resetSeqStore (seqStore_t *ssPtr)
 
static size_t ZSTD_buildSeqStore (ZSTD_CCtx *zc, const void *src, size_t srcSize)
 
static void ZSTD_copyBlockSequences (ZSTD_CCtx *zc)
 
size_t ZSTD_getSequences (ZSTD_CCtx *zc, ZSTD_Sequence *outSeqs, size_t outSeqsSize, const void *src, size_t srcSize)
 
static int ZSTD_isRLE (const BYTE *ip, size_t length)
 
static int ZSTD_maybeRLE (seqStore_t const *seqStore)
 
static void ZSTD_confirmRepcodesAndEntropyTables (ZSTD_CCtx *zc)
 
static size_t ZSTD_compressBlock_internal (ZSTD_CCtx *zc, void *dst, size_t dstCapacity, const void *src, size_t srcSize, U32 frame)
 
static size_t ZSTD_compressBlock_targetCBlockSize_body (ZSTD_CCtx *zc, void *dst, size_t dstCapacity, const void *src, size_t srcSize, const size_t bss, U32 lastBlock)
 
static size_t ZSTD_compressBlock_targetCBlockSize (ZSTD_CCtx *zc, void *dst, size_t dstCapacity, const void *src, size_t srcSize, U32 lastBlock)
 
static void ZSTD_overflowCorrectIfNeeded (ZSTD_matchState_t *ms, ZSTD_cwksp *ws, ZSTD_CCtx_params const *params, void const *ip, void const *iend)
 
static size_t ZSTD_compress_frameChunk (ZSTD_CCtx *cctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize, U32 lastFrameChunk)
 
static size_t ZSTD_writeFrameHeader (void *dst, size_t dstCapacity, const ZSTD_CCtx_params *params, U64 pledgedSrcSize, U32 dictID)
 
size_t ZSTD_writeLastEmptyBlock (void *dst, size_t dstCapacity)
 
size_t ZSTD_referenceExternalSequences (ZSTD_CCtx *cctx, rawSeq *seq, size_t nbSeq)
 
static size_t ZSTD_compressContinue_internal (ZSTD_CCtx *cctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize, U32 frame, U32 lastFrameChunk)
 
size_t ZSTD_compressContinue (ZSTD_CCtx *cctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize)
 
size_t ZSTD_getBlockSize (const ZSTD_CCtx *cctx)
 
size_t ZSTD_compressBlock (ZSTD_CCtx *cctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize)
 
static size_t ZSTD_loadDictionaryContent (ZSTD_matchState_t *ms, ldmState_t *ls, ZSTD_cwksp *ws, ZSTD_CCtx_params const *params, const void *src, size_t srcSize, ZSTD_dictTableLoadMethod_e dtlm)
 
static size_t ZSTD_checkDictNCount (short *normalizedCounter, unsigned dictMaxSymbolValue, unsigned maxSymbolValue)
 
size_t ZSTD_loadCEntropy (ZSTD_compressedBlockState_t *bs, void *workspace, short *offcodeNCount, unsigned *offcodeMaxValue, const void *const dict, size_t dictSize)
 
static size_t ZSTD_loadZstdDictionary (ZSTD_compressedBlockState_t *bs, ZSTD_matchState_t *ms, ZSTD_cwksp *ws, ZSTD_CCtx_params const *params, const void *dict, size_t dictSize, ZSTD_dictTableLoadMethod_e dtlm, void *workspace)
 
static size_t ZSTD_compress_insertDictionary (ZSTD_compressedBlockState_t *bs, ZSTD_matchState_t *ms, ldmState_t *ls, ZSTD_cwksp *ws, const ZSTD_CCtx_params *params, const void *dict, size_t dictSize, ZSTD_dictContentType_e dictContentType, ZSTD_dictTableLoadMethod_e dtlm, void *workspace)
 
static size_t ZSTD_compressBegin_internal (ZSTD_CCtx *cctx, const void *dict, size_t dictSize, ZSTD_dictContentType_e dictContentType, ZSTD_dictTableLoadMethod_e dtlm, const ZSTD_CDict *cdict, const ZSTD_CCtx_params *params, U64 pledgedSrcSize, ZSTD_buffered_policy_e zbuff)
 
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, const ZSTD_CCtx_params *params, unsigned long long pledgedSrcSize)
 
size_t ZSTD_compressBegin_advanced (ZSTD_CCtx *cctx, const void *dict, size_t dictSize, ZSTD_parameters params, unsigned long long pledgedSrcSize)
 
size_t ZSTD_compressBegin_usingDict (ZSTD_CCtx *cctx, const void *dict, size_t dictSize, int compressionLevel)
 
size_t ZSTD_compressBegin (ZSTD_CCtx *cctx, int compressionLevel)
 
static size_t ZSTD_writeEpilogue (ZSTD_CCtx *cctx, void *dst, size_t dstCapacity)
 
size_t ZSTD_compressEnd (ZSTD_CCtx *cctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize)
 
static size_t ZSTD_compress_internal (ZSTD_CCtx *cctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize, const void *dict, size_t dictSize, const ZSTD_parameters *params)
 
size_t ZSTD_compress_advanced (ZSTD_CCtx *cctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize, const void *dict, size_t dictSize, ZSTD_parameters params)
 
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, const ZSTD_CCtx_params *params)
 
size_t ZSTD_compress_usingDict (ZSTD_CCtx *cctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize, const void *dict, size_t dictSize, int compressionLevel)
 
size_t ZSTD_compressCCtx (ZSTD_CCtx *cctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize, int compressionLevel)
 
size_t ZSTD_compress (void *dst, size_t dstCapacity, const void *src, size_t srcSize, int compressionLevel)
 
size_t ZSTD_estimateCDictSize_advanced (size_t dictSize, ZSTD_compressionParameters cParams, ZSTD_dictLoadMethod_e dictLoadMethod)
 
size_t ZSTD_estimateCDictSize (size_t dictSize, int compressionLevel)
 
size_t ZSTD_sizeof_CDict (const ZSTD_CDict *cdict)
 
static size_t ZSTD_initCDict_internal (ZSTD_CDict *cdict, const void *dictBuffer, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType, ZSTD_compressionParameters cParams)
 
ZSTD_CDictZSTD_createCDict_advanced (const void *dictBuffer, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType, ZSTD_compressionParameters cParams, ZSTD_customMem customMem)
 
ZSTD_CDictZSTD_createCDict (const void *dict, size_t dictSize, int compressionLevel)
 
ZSTD_CDictZSTD_createCDict_byReference (const void *dict, size_t dictSize, int compressionLevel)
 
size_t ZSTD_freeCDict (ZSTD_CDict *cdict)
 
const ZSTD_CDictZSTD_initStaticCDict (void *workspace, size_t workspaceSize, const void *dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType, ZSTD_compressionParameters cParams)
 
ZSTD_compressionParameters ZSTD_getCParamsFromCDict (const ZSTD_CDict *cdict)
 
size_t ZSTD_compressBegin_usingCDict_advanced (ZSTD_CCtx *const cctx, const ZSTD_CDict *const cdict, ZSTD_frameParameters const fParams, unsigned long long const pledgedSrcSize)
 
size_t ZSTD_compressBegin_usingCDict (ZSTD_CCtx *cctx, const ZSTD_CDict *cdict)
 
size_t ZSTD_compress_usingCDict_advanced (ZSTD_CCtx *cctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize, const ZSTD_CDict *cdict, ZSTD_frameParameters fParams)
 
size_t ZSTD_compress_usingCDict (ZSTD_CCtx *cctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize, const ZSTD_CDict *cdict)
 
ZSTD_CStreamZSTD_createCStream (void)
 
ZSTD_CStreamZSTD_initStaticCStream (void *workspace, size_t workspaceSize)
 
ZSTD_CStreamZSTD_createCStream_advanced (ZSTD_customMem customMem)
 
size_t ZSTD_freeCStream (ZSTD_CStream *zcs)
 
size_t ZSTD_CStreamInSize (void)
 
size_t ZSTD_CStreamOutSize (void)
 
static size_t ZSTD_resetCStream_internal (ZSTD_CStream *cctx, const void *const dict, size_t const dictSize, ZSTD_dictContentType_e const dictContentType, const ZSTD_CDict *const cdict, ZSTD_CCtx_params params, unsigned long long const pledgedSrcSize)
 
size_t ZSTD_resetCStream (ZSTD_CStream *zcs, unsigned long long pss)
 
size_t ZSTD_initCStream_internal (ZSTD_CStream *zcs, const void *dict, size_t dictSize, const ZSTD_CDict *cdict, const ZSTD_CCtx_params *params, unsigned long long pledgedSrcSize)
 
size_t ZSTD_initCStream_usingCDict_advanced (ZSTD_CStream *zcs, const ZSTD_CDict *cdict, ZSTD_frameParameters fParams, unsigned long long pledgedSrcSize)
 
size_t ZSTD_initCStream_usingCDict (ZSTD_CStream *zcs, const ZSTD_CDict *cdict)
 
size_t ZSTD_initCStream_advanced (ZSTD_CStream *zcs, const void *dict, size_t dictSize, ZSTD_parameters params, unsigned long long pss)
 
size_t ZSTD_initCStream_usingDict (ZSTD_CStream *zcs, const void *dict, size_t dictSize, int compressionLevel)
 
size_t ZSTD_initCStream_srcSize (ZSTD_CStream *zcs, int compressionLevel, unsigned long long pss)
 
size_t ZSTD_initCStream (ZSTD_CStream *zcs, int compressionLevel)
 
static size_t ZSTD_nextInputSizeHint (const ZSTD_CCtx *cctx)
 
static size_t ZSTD_compressStream_generic (ZSTD_CStream *zcs, ZSTD_outBuffer *output, ZSTD_inBuffer *input, ZSTD_EndDirective const flushMode)
 
static size_t ZSTD_nextInputSizeHint_MTorST (const ZSTD_CCtx *cctx)
 
size_t ZSTD_compressStream (ZSTD_CStream *zcs, ZSTD_outBuffer *output, ZSTD_inBuffer *input)
 
size_t ZSTD_compressStream2 (ZSTD_CCtx *cctx, ZSTD_outBuffer *output, ZSTD_inBuffer *input, ZSTD_EndDirective endOp)
 
size_t ZSTD_compressStream2_simpleArgs (ZSTD_CCtx *cctx, void *dst, size_t dstCapacity, size_t *dstPos, const void *src, size_t srcSize, size_t *srcPos, ZSTD_EndDirective endOp)
 
size_t ZSTD_compress2 (ZSTD_CCtx *cctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize)
 
size_t ZSTD_flushStream (ZSTD_CStream *zcs, ZSTD_outBuffer *output)
 
size_t ZSTD_endStream (ZSTD_CStream *zcs, ZSTD_outBuffer *output)
 
int ZSTD_maxCLevel (void)
 
int ZSTD_minCLevel (void)
 
ZSTD_compressionParameters ZSTD_getCParams (int compressionLevel, unsigned long long srcSizeHint, size_t dictSize)
 
ZSTD_parameters ZSTD_getParams (int compressionLevel, unsigned long long srcSizeHint, size_t dictSize)
 

Variables

static const size_t attachDictSizeCutoffs [ZSTD_STRATEGY_MAX+1]
 
static const ZSTD_compressionParameters ZSTD_defaultCParameters [4][ZSTD_MAX_CLEVEL+1]
 

Macro Definition Documentation

◆ BOUNDCHECK

#define BOUNDCHECK (   cParam,
  val 
)
Value:
{ \
RETURN_ERROR_IF(!ZSTD_cParam_withinBounds(cParam,val), \
parameter_outOfBound, "Param out of bounds"); \
}
MEM_STATIC int ZSTD_cParam_withinBounds(ZSTD_cParameter cParam, int value)
GLuint GLfloat * val
Definition: glext.h:7180

Definition at line 439 of file zstd_compress.c.

◆ CLAMP

#define CLAMP (   cParam,
  val 
)    CLAMP_TYPE(cParam, val, unsigned)

◆ CLAMP_TYPE

#define CLAMP_TYPE (   cParam,
  val,
  type 
)
Value:
{ \
ZSTD_bounds const bounds = ZSTD_cParam_getBounds(cParam); \
if ((int)val<bounds.lowerBound) val=(type)bounds.lowerBound; \
else if ((int)val>bounds.upperBound) val=(type)bounds.upperBound; \
}
if(dx==0 &&dy==0)
Definition: linetemp.h:174
else
Definition: tritemp.h:161
ZSTD_bounds ZSTD_cParam_getBounds(ZSTD_cParameter param)
GLuint GLfloat * val
Definition: glext.h:7180
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545

◆ FSE_STATIC_LINKING_ONLY

#define FSE_STATIC_LINKING_ONLY   /* FSE_encodeSymbol */

Definition at line 19 of file zstd_compress.c.

◆ HUF_STATIC_LINKING_ONLY

#define HUF_STATIC_LINKING_ONLY

Definition at line 21 of file zstd_compress.c.

◆ ZSTD_INDEXOVERFLOW_MARGIN

#define ZSTD_INDEXOVERFLOW_MARGIN   (16 MB)

Definition at line 1411 of file zstd_compress.c.

◆ ZSTD_MAX_CLEVEL

#define ZSTD_MAX_CLEVEL   22

Definition at line 4115 of file zstd_compress.c.

◆ ZSTD_ROWSIZE

#define ZSTD_ROWSIZE   16

Definition at line 1848 of file zstd_compress.c.

◆ ZSTD_USE_CDICT_PARAMS_DICTSIZE_MULTIPLIER

#define ZSTD_USE_CDICT_PARAMS_DICTSIZE_MULTIPLIER   (6)

Definition at line 3077 of file zstd_compress.c.

◆ ZSTD_USE_CDICT_PARAMS_SRCSIZE_CUTOFF

#define ZSTD_USE_CDICT_PARAMS_SRCSIZE_CUTOFF   (128 KB)

Definition at line 3076 of file zstd_compress.c.

Enumeration Type Documentation

◆ ZSTD_buffered_policy_e

Indicates whether this compression proceeds directly from user-provided source buffer to user-provided destination buffer (ZSTDb_not_buffered), or whether the context needs to buffer the input/output (ZSTDb_buffered).

Enumerator
ZSTDb_not_buffered 
ZSTDb_buffered 

Definition at line 1312 of file zstd_compress.c.

◆ ZSTD_buildSeqStore_e

Enumerator
ZSTDbss_compress 
ZSTDbss_noCompress 

Definition at line 2240 of file zstd_compress.c.

◆ ZSTD_compResetPolicy_e

Controls, for this matchState reset, whether the tables need to be cleared / prepared for the coming compression (ZSTDcrp_makeClean), or whether the tables can be left unclean (ZSTDcrp_leaveDirty), because we know that a subsequent operation will overwrite the table space anyways (e.g., copying the matchState contents in from a CDict).

Enumerator
ZSTDcrp_makeClean 
ZSTDcrp_leaveDirty 

Definition at line 1324 of file zstd_compress.c.

◆ ZSTD_indexResetPolicy_e

Controls, for this matchState reset, whether indexing can continue where it left off (ZSTDirp_continue), or whether it needs to be restarted from zero (ZSTDirp_reset).

Enumerator
ZSTDirp_continue 
ZSTDirp_reset 

Definition at line 1334 of file zstd_compress.c.

◆ ZSTD_resetTarget_e

Enumerator
ZSTD_resetTarget_CDict 
ZSTD_resetTarget_CCtx 

Definition at line 1339 of file zstd_compress.c.

Function Documentation

◆ ZSTD_adjustCParams()

ZSTD_compressionParameters ZSTD_adjustCParams ( ZSTD_compressionParameters  cPar,
unsigned long long  srcSize,
size_t  dictSize 
)

Definition at line 1065 of file zstd_compress.c.

1068 {
1069  cPar = ZSTD_clampCParams(cPar); /* resulting cPar is necessarily valid (all parameters within range) */
1070  if (srcSize == 0) srcSize = ZSTD_CONTENTSIZE_UNKNOWN;
1071  return ZSTD_adjustCParams_internal(cPar, srcSize, dictSize);
1072 }
#define ZSTD_CONTENTSIZE_UNKNOWN
Definition: zstd.h:152
static ZSTD_compressionParameters ZSTD_adjustCParams_internal(ZSTD_compressionParameters cPar, unsigned long long srcSize, size_t dictSize)
static ZSTD_compressionParameters ZSTD_clampCParams(ZSTD_compressionParameters cParams)

◆ ZSTD_adjustCParams_internal()

static ZSTD_compressionParameters ZSTD_adjustCParams_internal ( ZSTD_compressionParameters  cPar,
unsigned long long  srcSize,
size_t  dictSize 
)
static

ZSTD_adjustCParams_internal() : optimize cPar for a specified input (srcSize and dictSize). mostly downsize to reduce memory consumption and initialization latency. srcSize can be ZSTD_CONTENTSIZE_UNKNOWN when not known. note : srcSize==0 means 0! condition : cPar is presumed validated (can be checked using ZSTD_checkCParams()).

Definition at line 1032 of file zstd_compress.c.

1035 {
1036  static const U64 minSrcSize = 513; /* (1<<9) + 1 */
1037  static const U64 maxWindowResize = 1ULL << (ZSTD_WINDOWLOG_MAX-1);
1038  assert(ZSTD_checkCParams(cPar)==0);
1039 
1040  if (dictSize && srcSize == ZSTD_CONTENTSIZE_UNKNOWN)
1041  srcSize = minSrcSize;
1042 
1043  /* resize windowLog if input is small enough, to use less memory */
1044  if ( (srcSize < maxWindowResize)
1045  && (dictSize < maxWindowResize) ) {
1046  U32 const tSize = (U32)(srcSize + dictSize);
1047  static U32 const hashSizeMin = 1 << ZSTD_HASHLOG_MIN;
1048  U32 const srcLog = (tSize < hashSizeMin) ? ZSTD_HASHLOG_MIN :
1049  ZSTD_highbit32(tSize-1) + 1;
1050  if (cPar.windowLog > srcLog) cPar.windowLog = srcLog;
1051  }
1052  if (cPar.hashLog > cPar.windowLog+1) cPar.hashLog = cPar.windowLog+1;
1053  { U32 const cycleLog = ZSTD_cycleLog(cPar.chainLog, cPar.strategy);
1054  if (cycleLog > cPar.windowLog)
1055  cPar.chainLog -= (cycleLog - cPar.windowLog);
1056  }
1057 
1058  if (cPar.windowLog < ZSTD_WINDOWLOG_ABSOLUTEMIN)
1059  cPar.windowLog = ZSTD_WINDOWLOG_ABSOLUTEMIN; /* minimum wlog required for valid frame header */
1060 
1061  return cPar;
1062 }
#define ZSTD_CONTENTSIZE_UNKNOWN
Definition: zstd.h:152
#define ZSTD_WINDOWLOG_ABSOLUTEMIN
#define assert(x)
Definition: debug.h:53
#define ULL(a, b)
Definition: format_msg.c:27
size_t ZSTD_checkCParams(ZSTD_compressionParameters cParams)
unsigned long long U64
Definition: xxhash.c:197
MEM_STATIC U32 ZSTD_highbit32(U32 val)
U32 ZSTD_cycleLog(U32 hashLog, ZSTD_strategy strat)
unsigned int U32
Definition: xxhash.c:195

Referenced by ZSTD_adjustCParams(), ZSTD_getCParams_internal(), ZSTD_getCParamsFromCCtxParams(), and ZSTD_resetCCtx_byAttachingCDict().

◆ ZSTD_assertEqualCParams()

static void ZSTD_assertEqualCParams ( ZSTD_compressionParameters  cParams1,
ZSTD_compressionParameters  cParams2 
)
static

Definition at line 1268 of file zstd_compress.c.

1270 {
1271  (void)cParams1;
1272  (void)cParams2;
1273  assert(cParams1.windowLog == cParams2.windowLog);
1274  assert(cParams1.chainLog == cParams2.chainLog);
1275  assert(cParams1.hashLog == cParams2.hashLog);
1276  assert(cParams1.searchLog == cParams2.searchLog);
1277  assert(cParams1.minMatch == cParams2.minMatch);
1278  assert(cParams1.targetLength == cParams2.targetLength);
1279  assert(cParams1.strategy == cParams2.strategy);
1280 }
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
#define assert(x)
Definition: debug.h:53

Referenced by ZSTD_buildSeqStore(), and ZSTD_loadDictionaryContent().

◆ ZSTD_assignParamsToCCtxParams()

static ZSTD_CCtx_params ZSTD_assignParamsToCCtxParams ( const ZSTD_CCtx_params *  cctxParams,
const ZSTD_parameters *  params 
)
static

Definition at line 257 of file zstd_compress.c.

259 {
260  ZSTD_CCtx_params ret = *cctxParams;
261  assert(!ZSTD_checkCParams(params->cParams));
262  ret.cParams = params->cParams;
263  ret.fParams = params->fParams;
264  ret.compressionLevel = ZSTD_CLEVEL_DEFAULT; /* should not matter, as all cParams are presumed properly defined */
265  return ret;
266 }
#define ZSTD_CLEVEL_DEFAULT
Definition: zstd.h:90
#define assert(x)
Definition: debug.h:53
GLenum const GLfloat * params
Definition: glext.h:5645
size_t ZSTD_checkCParams(ZSTD_compressionParameters cParams)
int ret

Referenced by ZSTD_compress_internal(), ZSTD_compress_usingDict(), ZSTD_compressBegin_advanced(), ZSTD_compressBegin_usingDict(), and ZSTD_initCStream_advanced().

◆ ZSTD_buildSeqStore()

static size_t ZSTD_buildSeqStore ( ZSTD_CCtx zc,
const void src,
size_t  srcSize 
)
static

Definition at line 2242 of file zstd_compress.c.

2243 {
2244  ZSTD_matchState_t* const ms = &zc->blockState.matchState;
2245  DEBUGLOG(5, "ZSTD_buildSeqStore (srcSize=%zu)", srcSize);
2246  assert(srcSize <= ZSTD_BLOCKSIZE_MAX);
2247  /* Assert that we have correctly flushed the ctx params into the ms's copy */
2248  ZSTD_assertEqualCParams(zc->appliedParams.cParams, ms->cParams);
2249  if (srcSize < MIN_CBLOCK_SIZE+ZSTD_blockHeaderSize+1) {
2250  ZSTD_ldm_skipSequences(&zc->externSeqStore, srcSize, zc->appliedParams.cParams.minMatch);
2251  return ZSTDbss_noCompress; /* don't even attempt compression below a certain srcSize */
2252  }
2253  ZSTD_resetSeqStore(&(zc->seqStore));
2254  /* required for optimal parser to read stats from dictionary */
2256  /* tell the optimal parser how we expect to compress literals */
2257  ms->opt.literalCompressionMode = zc->appliedParams.literalCompressionMode;
2258  /* a gap between an attached dict and the current window is not safe,
2259  * they must remain adjacent,
2260  * and when that stops being the case, the dict must be unset */
2261  assert(ms->dictMatchState == NULL || ms->loadedDictEnd == ms->window.dictLimit);
2262 
2263  /* limited update after a very long match */
2264  { const BYTE* const base = ms->window.base;
2265  const BYTE* const istart = (const BYTE*)src;
2266  const U32 current = (U32)(istart-base);
2267  if (sizeof(ptrdiff_t)==8) assert(istart - base < (ptrdiff_t)(U32)(-1)); /* ensure no overflow */
2268  if (current > ms->nextToUpdate + 384)
2269  ms->nextToUpdate = current - MIN(192, (U32)(current - ms->nextToUpdate - 384));
2270  }
2271 
2272  /* select and store sequences */
2273  { ZSTD_dictMode_e const dictMode = ZSTD_matchState_dictMode(ms);
2274  size_t lastLLSize;
2275  { int i;
2276  for (i = 0; i < ZSTD_REP_NUM; ++i)
2278  }
2279  if (zc->externSeqStore.pos < zc->externSeqStore.size) {
2280  assert(!zc->appliedParams.ldmParams.enableLdm);
2281  /* Updates ldmSeqStore.pos */
2282  lastLLSize =
2284  ms, &zc->seqStore,
2285  zc->blockState.nextCBlock->rep,
2286  src, srcSize);
2288  } else if (zc->appliedParams.ldmParams.enableLdm) {
2289  rawSeqStore_t ldmSeqStore = {NULL, 0, 0, 0};
2290 
2291  ldmSeqStore.seq = zc->ldmSequences;
2292  ldmSeqStore.capacity = zc->maxNbLdmSequences;
2293  /* Updates ldmSeqStore.size */
2295  &zc->appliedParams.ldmParams,
2296  src, srcSize), "");
2297  /* Updates ldmSeqStore.pos */
2298  lastLLSize =
2299  ZSTD_ldm_blockCompress(&ldmSeqStore,
2300  ms, &zc->seqStore,
2301  zc->blockState.nextCBlock->rep,
2302  src, srcSize);
2303  assert(ldmSeqStore.pos == ldmSeqStore.size);
2304  } else { /* not long range mode */
2305  ZSTD_blockCompressor const blockCompressor = ZSTD_selectBlockCompressor(zc->appliedParams.cParams.strategy, dictMode);
2306  lastLLSize = blockCompressor(ms, &zc->seqStore, zc->blockState.nextCBlock->rep, src, srcSize);
2307  }
2308  { const BYTE* const lastLiterals = (const BYTE*)src + srcSize - lastLLSize;
2309  ZSTD_storeLastLiterals(&zc->seqStore, lastLiterals, lastLLSize);
2310  } }
2311  return ZSTDbss_compress;
2312 }
rawSeqStore_t externSeqStore
#define ZSTD_BLOCKSIZE_MAX
Definition: zstd.h:104
#define assert(x)
Definition: debug.h:53
size_t ZSTD_ldm_blockCompress(rawSeqStore_t *rawSeqStore, ZSTD_matchState_t *ms, seqStore_t *seqStore, U32 rep[ZSTD_REP_NUM], void const *src, size_t srcSize)
Definition: zstd_ldm.c:565
T MIN(T a, T b)
Definition: polytest.cpp:79
#define DEBUGLOG(l,...)
Definition: debug.h:106
static const size_t ZSTD_blockHeaderSize
void ZSTD_resetSeqStore(seqStore_t *ssPtr)
ZSTD_compressionParameters cParams
ZSTD_blockCompressor ZSTD_selectBlockCompressor(ZSTD_strategy strat, ZSTD_dictMode_e dictMode)
ZSTD_CCtx_params appliedParams
ZSTD_blockState_t blockState
static void ZSTD_storeLastLiterals(seqStore_t *seqStorePtr, const BYTE *anchor, size_t lastLLSize)
const ZSTD_matchState_t * dictMatchState
ZSTD_literalCompressionMode_e literalCompressionMode
struct task_struct * current
Definition: linux.c:32
size_t(* ZSTD_blockCompressor)(ZSTD_matchState_t *bs, seqStore_t *seqStore, U32 rep[ZSTD_REP_NUM], void const *src, size_t srcSize)
ZSTD_compressedBlockState_t * nextCBlock
#define MIN_CBLOCK_SIZE
const ZSTD_entropyCTables_t * symbolCosts
ZSTD_matchState_t matchState
GLenum src
Definition: glext.h:6340
unsigned char BYTE
Definition: xxhash.c:193
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
MEM_STATIC ZSTD_dictMode_e ZSTD_matchState_dictMode(const ZSTD_matchState_t *ms)
#define NULL
Definition: types.h:112
__kernel_ptrdiff_t ptrdiff_t
Definition: linux.h:247
size_t ZSTD_ldm_generateSequences(ldmState_t *ldmState, rawSeqStore_t *sequences, ldmParams_t const *params, void const *src, size_t srcSize)
Definition: zstd_ldm.c:429
#define FORWARD_IF_ERROR(err,...)
void ZSTD_ldm_skipSequences(rawSeqStore_t *rawSeqStore, size_t srcSize, U32 const minMatch)
Definition: zstd_ldm.c:506
ZSTD_compressedBlockState_t * prevCBlock
static void ZSTD_assertEqualCParams(ZSTD_compressionParameters cParams1, ZSTD_compressionParameters cParams2)
unsigned int U32
Definition: xxhash.c:195
#define ZSTD_REP_NUM

Referenced by ZSTD_compressBlock_internal(), and ZSTD_compressBlock_targetCBlockSize().

◆ ZSTD_CCtx_getParameter()

size_t ZSTD_CCtx_getParameter ( ZSTD_CCtx cctx,
ZSTD_cParameter  param,
int value 
)

Definition at line 714 of file zstd_compress.c.

715 {
717 }
Definition: pdh_main.c:93
GLfloat param
Definition: glext.h:5796
size_t ZSTD_CCtxParams_getParameter(ZSTD_CCtx_params *CCtxParams, ZSTD_cParameter param, int *value)
ZSTD_CCtx_params requestedParams

◆ ZSTD_CCtx_loadDictionary()

ZSTDLIB_API size_t ZSTD_CCtx_loadDictionary ( ZSTD_CCtx cctx,
const void dict,
size_t  dictSize 
)

ZSTD_CCtx_loadDictionary() : Create an internal CDict from dict buffer. Decompression will have to use same dictionary.

Returns
: 0, or an error code (which can be tested with ZSTD_isError()). Special: Loading a NULL (or 0-size) dictionary invalidates previous dictionary, meaning "return to no-dictionary mode". Note 1 : Dictionary is sticky, it will be used for all future compressed frames. To return to "no-dictionary" situation, load a NULL dictionary (or reset parameters). Note 2 : Loading a dictionary involves building tables. It's also a CPU consuming operation, with non-negligible impact on latency. Tables are dependent on compression parameters, and for this reason, compression parameters can no longer be changed after loading a dictionary. Note 3 :dict content will be copied internally. Use experimental ZSTD_CCtx_loadDictionary_byReference() to reference content instead. In such a case, dictionary buffer must outlive its users. Note 4 : Use ZSTD_CCtx_loadDictionary_advanced() to precisely select how dictionary content must be interpreted.

Definition at line 924 of file zstd_compress.c.

925 {
927  cctx, dict, dictSize, ZSTD_dlm_byCopy, ZSTD_dct_auto);
928 }
size_t ZSTD_CCtx_loadDictionary_advanced(ZSTD_CCtx *cctx, const void *dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType)

Referenced by ZSTD_initCStream_advanced(), ZSTD_initCStream_internal(), and ZSTD_initCStream_usingDict().

◆ ZSTD_CCtx_loadDictionary_advanced()

size_t ZSTD_CCtx_loadDictionary_advanced ( ZSTD_CCtx cctx,
const void dict,
size_t  dictSize,
ZSTD_dictLoadMethod_e  dictLoadMethod,
ZSTD_dictContentType_e  dictContentType 
)

Definition at line 891 of file zstd_compress.c.

894 {
895  RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong,
896  "Can't load a dictionary when ctx is not in init stage.");
897  RETURN_ERROR_IF(cctx->staticSize, memory_allocation,
898  "no malloc for static CCtx");
899  DEBUGLOG(4, "ZSTD_CCtx_loadDictionary_advanced (size: %u)", (U32)dictSize);
900  ZSTD_clearAllDicts(cctx); /* in case one already exists */
901  if (dict == NULL || dictSize == 0) /* no dictionary mode */
902  return 0;
903  if (dictLoadMethod == ZSTD_dlm_byRef) {
904  cctx->localDict.dict = dict;
905  } else {
906  void* dictBuffer = ZSTD_malloc(dictSize, cctx->customMem);
907  RETURN_ERROR_IF(!dictBuffer, memory_allocation, "NULL pointer!");
908  memcpy(dictBuffer, dict, dictSize);
909  cctx->localDict.dictBuffer = dictBuffer;
910  cctx->localDict.dict = dictBuffer;
911  }
912  cctx->localDict.dictSize = dictSize;
913  cctx->localDict.dictContentType = dictContentType;
914  return 0;
915 }
ZSTD_dictContentType_e dictContentType
#define DEBUGLOG(l,...)
Definition: debug.h:106
ZSTD_localDict localDict
#define RETURN_ERROR_IF(cond, err,...)
Definition: zstd_internal.h:91
static void ZSTD_clearAllDicts(ZSTD_CCtx *cctx)
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
void * ZSTD_malloc(size_t size, ZSTD_customMem customMem)
Definition: zstd_common.c:56
#define NULL
Definition: types.h:112
ZSTD_customMem customMem
ZSTD_cStreamStage streamStage
unsigned int U32
Definition: xxhash.c:195

Referenced by ZSTD_CCtx_loadDictionary(), and ZSTD_CCtx_loadDictionary_byReference().

◆ ZSTD_CCtx_loadDictionary_byReference()

ZSTDLIB_API size_t ZSTD_CCtx_loadDictionary_byReference ( ZSTD_CCtx cctx,
const void dict,
size_t  dictSize 
)

Definition at line 917 of file zstd_compress.c.

919 {
921  cctx, dict, dictSize, ZSTD_dlm_byRef, ZSTD_dct_auto);
922 }
size_t ZSTD_CCtx_loadDictionary_advanced(ZSTD_CCtx *cctx, const void *dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType)

◆ ZSTD_CCtx_refCDict()

size_t ZSTD_CCtx_refCDict ( ZSTD_CCtx cctx,
const ZSTD_CDict cdict 
)

ZSTD_CCtx_refCDict() : Reference a prepared dictionary, to be used for all next compressed frames. Note that compression parameters are enforced from within CDict, and supersede any compression parameter previously set within CCtx. The parameters ignored are labled as "superseded-by-cdict" in the ZSTD_cParameter enum docs. The ignored parameters will be used again if the CCtx is returned to no-dictionary mode. The dictionary will remain valid for future compressed frames using same CCtx.

Returns
: 0, or an error code (which can be tested with ZSTD_isError()). Special : Referencing a NULL CDict means "return to no-dictionary mode". Note 1 : Currently, only one dictionary can be managed. Referencing a new dictionary effectively "discards" any previous one. Note 2 : CDict is just referenced, its lifetime must outlive its usage within CCtx.

Definition at line 931 of file zstd_compress.c.

932 {
933  RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong,
934  "Can't ref a dict when ctx not in init stage.");
935  /* Free the existing local cdict (if any) to save memory. */
936  ZSTD_clearAllDicts(cctx);
937  cctx->cdict = cdict;
938  return 0;
939 }
#define RETURN_ERROR_IF(cond, err,...)
Definition: zstd_internal.h:91
static void ZSTD_clearAllDicts(ZSTD_CCtx *cctx)
const ZSTD_CDict * cdict
ZSTD_cStreamStage streamStage

Referenced by ZSTD_initCStream(), ZSTD_initCStream_internal(), ZSTD_initCStream_srcSize(), ZSTD_initCStream_usingCDict(), and ZSTD_initCStream_usingCDict_advanced().

◆ ZSTD_CCtx_refPrefix()

size_t ZSTD_CCtx_refPrefix ( ZSTD_CCtx cctx,
const void prefix,
size_t  prefixSize 
)

ZSTD_CCtx_refPrefix() : Reference a prefix (single-usage dictionary) for next compressed frame. A prefix is only used once. Tables are discarded at end of frame (ZSTD_e_end). Decompression will need same prefix to properly regenerate data. Compressing with a prefix is similar in outcome as performing a diff and compressing it, but performs much faster, especially during decompression (compression speed is tunable with compression level).

Returns
: 0, or an error code (which can be tested with ZSTD_isError()). Special: Adding any prefix (including NULL) invalidates any previous prefix or dictionary Note 1 : Prefix buffer is referenced. It must outlive compression. Its content must remain unmodified during compression. Note 2 : If the intention is to diff some large src data blob with some prior version of itself, ensure that the window size is large enough to contain the entire source. See ZSTD_c_windowLog. Note 3 : Referencing a prefix involves building tables, which are dependent on compression parameters. It's a CPU consuming operation, with non-negligible impact on latency. If there is a need to use the same prefix multiple times, consider loadDictionary instead. Note 4 : By default, the prefix is interpreted as raw content (ZSTD_dct_rawContent). Use experimental ZSTD_CCtx_refPrefix_advanced() to alter dictionary interpretation.

Definition at line 941 of file zstd_compress.c.

942 {
943  return ZSTD_CCtx_refPrefix_advanced(cctx, prefix, prefixSize, ZSTD_dct_rawContent);
944 }
size_t ZSTD_CCtx_refPrefix_advanced(ZSTD_CCtx *cctx, const void *prefix, size_t prefixSize, ZSTD_dictContentType_e dictContentType)

◆ ZSTD_CCtx_refPrefix_advanced()

size_t ZSTD_CCtx_refPrefix_advanced ( ZSTD_CCtx cctx,
const void prefix,
size_t  prefixSize,
ZSTD_dictContentType_e  dictContentType 
)

Definition at line 946 of file zstd_compress.c.

948 {
949  RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong,
950  "Can't ref a prefix when ctx not in init stage.");
951  ZSTD_clearAllDicts(cctx);
952  if (prefix != NULL && prefixSize > 0) {
953  cctx->prefixDict.dict = prefix;
954  cctx->prefixDict.dictSize = prefixSize;
955  cctx->prefixDict.dictContentType = dictContentType;
956  }
957  return 0;
958 }
ZSTD_prefixDict prefixDict
#define RETURN_ERROR_IF(cond, err,...)
Definition: zstd_internal.h:91
ZSTD_dictContentType_e dictContentType
static void ZSTD_clearAllDicts(ZSTD_CCtx *cctx)
#define NULL
Definition: types.h:112
ZSTD_cStreamStage streamStage

Referenced by ZSTD_CCtx_refPrefix().

◆ ZSTD_CCtx_reset()

size_t ZSTD_CCtx_reset ( ZSTD_CCtx cctx,
ZSTD_ResetDirective  reset 
)

ZSTD_CCtx_reset() : Also dumps dictionary

Definition at line 962 of file zstd_compress.c.

963 {
966  cctx->streamStage = zcss_init;
967  cctx->pledgedSrcSizePlusOne = 0;
968  }
969  if ( (reset == ZSTD_reset_parameters)
971  RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong,
972  "Can't reset parameters only when not in init stage.");
973  ZSTD_clearAllDicts(cctx);
974  return ZSTD_CCtxParams_reset(&cctx->requestedParams);
975  }
976  return 0;
977 }
unsigned long long pledgedSrcSizePlusOne
#define RETURN_ERROR_IF(cond, err,...)
Definition: zstd_internal.h:91
static void ZSTD_clearAllDicts(ZSTD_CCtx *cctx)
GLboolean reset
Definition: glext.h:5666
size_t ZSTD_CCtxParams_reset(ZSTD_CCtx_params *params)
ZSTD_cStreamStage streamStage
ZSTD_CCtx_params requestedParams

Referenced by ZSTD_compress2(), ZSTD_compressStream2(), ZSTD_compressStream_generic(), ZSTD_initCCtx(), ZSTD_initCStream(), ZSTD_initCStream_advanced(), ZSTD_initCStream_internal(), ZSTD_initCStream_srcSize(), ZSTD_initCStream_usingCDict(), ZSTD_initCStream_usingCDict_advanced(), ZSTD_initCStream_usingDict(), and ZSTD_resetCStream().

◆ ZSTD_CCtx_setParameter()

size_t ZSTD_CCtx_setParameter ( ZSTD_CCtx cctx,
ZSTD_cParameter  param,
int  value 
)

ZSTD_CCtx_setParameter() : Set one compression parameter, selected by enum ZSTD_cParameter. All parameters have valid bounds. Bounds can be queried using ZSTD_cParam_getBounds(). Providing a value beyond bound will either clamp it, or trigger an error (depending on parameter). Setting a parameter is generally only possible during frame initialization (before starting compression). Exception : when using multi-threading mode (nbWorkers >= 1), the following parameters can be updated during compression (within same frame): => compressionLevel, hashLog, chainLog, searchLog, minMatch, targetLength and strategy. new parameters will be active for next job only (after a flush()).

Returns
: an error code (which can be tested using ZSTD_isError()).

Definition at line 482 of file zstd_compress.c.

483 {
484  DEBUGLOG(4, "ZSTD_CCtx_setParameter (%i, %i)", (int)param, value);
485  if (cctx->streamStage != zcss_init) {
487  cctx->cParamsChanged = 1;
488  } else {
489  RETURN_ERROR(stage_wrong, "can only set params in ctx init stage");
490  } }
491 
492  switch(param)
493  {
494  case ZSTD_c_nbWorkers:
495  RETURN_ERROR_IF((value!=0) && cctx->staticSize, parameter_unsupported,
496  "MT not compatible with static alloc");
497  break;
498 
500  case ZSTD_c_windowLog:
501  case ZSTD_c_hashLog:
502  case ZSTD_c_chainLog:
503  case ZSTD_c_searchLog:
504  case ZSTD_c_minMatch:
505  case ZSTD_c_targetLength:
506  case ZSTD_c_strategy:
508  case ZSTD_c_format:
510  case ZSTD_c_checksumFlag:
511  case ZSTD_c_dictIDFlag:
512  case ZSTD_c_forceMaxWindow:
513  case ZSTD_c_forceAttachDict:
514  case ZSTD_c_literalCompressionMode:
515  case ZSTD_c_jobSize:
516  case ZSTD_c_overlapLog:
517  case ZSTD_c_rsyncable:
519  case ZSTD_c_ldmHashLog:
520  case ZSTD_c_ldmMinMatch:
522  case ZSTD_c_targetCBlockSize:
523  case ZSTD_c_srcSizeHint:
524  break;
525 
526  default: RETURN_ERROR(parameter_unsupported, "unknown parameter");
527  }
529 }
Definition: pdh_main.c:93
#define DEBUGLOG(l,...)
Definition: debug.h:106
#define RETURN_ERROR(StatusCode)
Definition: Base.h:751
#define RETURN_ERROR_IF(cond, err,...)
Definition: zstd_internal.h:91
GLfloat param
Definition: glext.h:5796
size_t ZSTD_CCtxParams_setParameter(ZSTD_CCtx_params *CCtxParams, ZSTD_cParameter param, int value)
ZSTD_cStreamStage streamStage
ZSTD_CCtx_params requestedParams
static int ZSTD_isUpdateAuthorized(ZSTD_cParameter param)

Referenced by ZSTD_initCStream(), ZSTD_initCStream_srcSize(), and ZSTD_initCStream_usingDict().

◆ ZSTD_CCtx_setParametersUsingCCtxParams()

size_t ZSTD_CCtx_setParametersUsingCCtxParams ( ZSTD_CCtx cctx,
const ZSTD_CCtx_params *  params 
)

ZSTD_CCtx_setParametersUsingCCtxParams() : just applies params into cctx no action is performed, parameters are merely stored. If ZSTDMT is enabled, parameters are pushed to cctx->mtctx. This is possible even if a compression is ongoing. In which case, new parameters will be applied on the fly, starting with next compression job.

Definition at line 830 of file zstd_compress.c.

832 {
833  DEBUGLOG(4, "ZSTD_CCtx_setParametersUsingCCtxParams");
834  RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong,
835  "The context is in the wrong stage!");
836  RETURN_ERROR_IF(cctx->cdict, stage_wrong,
837  "Can't override parameters with cdict attached (some must "
838  "be inherited from the cdict).");
839 
840  cctx->requestedParams = *params;
841  return 0;
842 }
#define DEBUGLOG(l,...)
Definition: debug.h:106
GLenum const GLfloat * params
Definition: glext.h:5645
#define RETURN_ERROR_IF(cond, err,...)
Definition: zstd_internal.h:91
const ZSTD_CDict * cdict
ZSTD_cStreamStage streamStage
ZSTD_CCtx_params requestedParams

◆ ZSTD_CCtx_setPledgedSrcSize()

ZSTDLIB_API size_t ZSTD_CCtx_setPledgedSrcSize ( ZSTD_CCtx cctx,
unsigned long long  pledgedSrcSize 
)

ZSTD_CCtx_setPledgedSrcSize() : Total input data size to be compressed as a single frame. Value will be written in frame header, unless if explicitly forbidden using ZSTD_c_contentSizeFlag. This value will also be controlled at end of frame, and trigger an error if not respected.

Returns
: 0, or an error code (which can be tested with ZSTD_isError()). Note 1 : pledgedSrcSize==0 actually means zero, aka an empty frame. In order to mean "unknown content size", pass constant ZSTD_CONTENTSIZE_UNKNOWN. ZSTD_CONTENTSIZE_UNKNOWN is default value for any new frame. Note 2 : pledgedSrcSize is only valid once, for the next frame. It's discarded at the end of the frame, and replaced by ZSTD_CONTENTSIZE_UNKNOWN. Note 3 : Whenever all input data is provided and consumed in a single round, for example with ZSTD_compress2(), or invoking immediately ZSTD_compressStream2(,,,ZSTD_e_end), this value is automatically overridden by srcSize instead.

Definition at line 844 of file zstd_compress.c.

845 {
846  DEBUGLOG(4, "ZSTD_CCtx_setPledgedSrcSize to %u bytes", (U32)pledgedSrcSize);
847  RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong,
848  "Can't set pledgedSrcSize when not in init stage.");
849  cctx->pledgedSrcSizePlusOne = pledgedSrcSize+1;
850  return 0;
851 }
unsigned long long pledgedSrcSizePlusOne
#define DEBUGLOG(l,...)
Definition: debug.h:106
#define RETURN_ERROR_IF(cond, err,...)
Definition: zstd_internal.h:91
ZSTD_cStreamStage streamStage
unsigned int U32
Definition: xxhash.c:195

Referenced by ZSTD_initCStream_advanced(), ZSTD_initCStream_internal(), ZSTD_initCStream_srcSize(), ZSTD_initCStream_usingCDict_advanced(), and ZSTD_resetCStream().

◆ ZSTD_CCtxParams_getParameter()

size_t ZSTD_CCtxParams_getParameter ( ZSTD_CCtx_params *  CCtxParams,
ZSTD_cParameter  param,
int value 
)

Definition at line 719 of file zstd_compress.c.

721 {
722  switch(param)
723  {
724  case ZSTD_c_format :
725  *value = CCtxParams->format;
726  break;
728  *value = CCtxParams->compressionLevel;
729  break;
730  case ZSTD_c_windowLog :
731  *value = (int)CCtxParams->cParams.windowLog;
732  break;
733  case ZSTD_c_hashLog :
734  *value = (int)CCtxParams->cParams.hashLog;
735  break;
736  case ZSTD_c_chainLog :
737  *value = (int)CCtxParams->cParams.chainLog;
738  break;
739  case ZSTD_c_searchLog :
740  *value = CCtxParams->cParams.searchLog;
741  break;
742  case ZSTD_c_minMatch :
743  *value = CCtxParams->cParams.minMatch;
744  break;
745  case ZSTD_c_targetLength :
746  *value = CCtxParams->cParams.targetLength;
747  break;
748  case ZSTD_c_strategy :
749  *value = (unsigned)CCtxParams->cParams.strategy;
750  break;
752  *value = CCtxParams->fParams.contentSizeFlag;
753  break;
754  case ZSTD_c_checksumFlag :
755  *value = CCtxParams->fParams.checksumFlag;
756  break;
757  case ZSTD_c_dictIDFlag :
758  *value = !CCtxParams->fParams.noDictIDFlag;
759  break;
760  case ZSTD_c_forceMaxWindow :
761  *value = CCtxParams->forceWindow;
762  break;
763  case ZSTD_c_forceAttachDict :
764  *value = CCtxParams->attachDictPref;
765  break;
766  case ZSTD_c_literalCompressionMode :
767  *value = CCtxParams->literalCompressionMode;
768  break;
769  case ZSTD_c_nbWorkers :
770 #ifndef ZSTD_MULTITHREAD
771  assert(CCtxParams->nbWorkers == 0);
772 #endif
773  *value = CCtxParams->nbWorkers;
774  break;
775  case ZSTD_c_jobSize :
776 #ifndef ZSTD_MULTITHREAD
777  RETURN_ERROR(parameter_unsupported, "not compiled with multithreading");
778 #else
779  assert(CCtxParams->jobSize <= INT_MAX);
780  *value = (int)CCtxParams->jobSize;
781  break;
782 #endif
783  case ZSTD_c_overlapLog :
784 #ifndef ZSTD_MULTITHREAD
785  RETURN_ERROR(parameter_unsupported, "not compiled with multithreading");
786 #else
787  *value = CCtxParams->overlapLog;
788  break;
789 #endif
790  case ZSTD_c_rsyncable :
791 #ifndef ZSTD_MULTITHREAD
792  RETURN_ERROR(parameter_unsupported, "not compiled with multithreading");
793 #else
794  *value = CCtxParams->rsyncable;
795  break;
796 #endif
798  *value = CCtxParams->ldmParams.enableLdm;
799  break;
800  case ZSTD_c_ldmHashLog :
801  *value = CCtxParams->ldmParams.hashLog;
802  break;
803  case ZSTD_c_ldmMinMatch :
804  *value = CCtxParams->ldmParams.minMatchLength;
805  break;
807  *value = CCtxParams->ldmParams.bucketSizeLog;
808  break;
809  case ZSTD_c_ldmHashRateLog :
810  *value = CCtxParams->ldmParams.hashRateLog;
811  break;
812  case ZSTD_c_targetCBlockSize :
813  *value = (int)CCtxParams->targetCBlockSize;
814  break;
815  case ZSTD_c_srcSizeHint :
816  *value = (int)CCtxParams->srcSizeHint;
817  break;
818  default: RETURN_ERROR(parameter_unsupported, "unknown parameter");
819  }
820  return 0;
821 }
Definition: pdh_main.c:93
#define INT_MAX
Definition: limits.h:40
#define assert(x)
Definition: debug.h:53
#define RETURN_ERROR(StatusCode)
Definition: Base.h:751
GLfloat param
Definition: glext.h:5796
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31

Referenced by ZSTD_CCtx_getParameter().

◆ ZSTD_CCtxParams_init()

size_t ZSTD_CCtxParams_init ( ZSTD_CCtx_params *  cctxParams,
int  compressionLevel 
)

Definition at line 235 of file zstd_compress.c.

235  {
236  RETURN_ERROR_IF(!cctxParams, GENERIC, "NULL pointer!");
237  memset(cctxParams, 0, sizeof(*cctxParams));
238  cctxParams->compressionLevel = compressionLevel;
239  cctxParams->fParams.contentSizeFlag = 1;
240  return 0;
241 }
#define RETURN_ERROR_IF(cond, err,...)
Definition: zstd_internal.h:91
#define memset(x, y, z)
Definition: compat.h:39

Referenced by ZSTD_CCtxParams_reset().

◆ ZSTD_CCtxParams_init_advanced()

size_t ZSTD_CCtxParams_init_advanced ( ZSTD_CCtx_params *  cctxParams,
ZSTD_parameters  params 
)

Definition at line 243 of file zstd_compress.c.

244 {
245  RETURN_ERROR_IF(!cctxParams, GENERIC, "NULL pointer!");
246  FORWARD_IF_ERROR( ZSTD_checkCParams(params.cParams) , "");
247  memset(cctxParams, 0, sizeof(*cctxParams));
248  assert(!ZSTD_checkCParams(params.cParams));
249  cctxParams->cParams = params.cParams;
250  cctxParams->fParams = params.fParams;
251  cctxParams->compressionLevel = ZSTD_CLEVEL_DEFAULT; /* should not matter, as all cParams are presumed properly defined */
252  return 0;
253 }
#define ZSTD_CLEVEL_DEFAULT
Definition: zstd.h:90
#define assert(x)
Definition: debug.h:53
GLenum const GLfloat * params
Definition: glext.h:5645
#define RETURN_ERROR_IF(cond, err,...)
Definition: zstd_internal.h:91
size_t ZSTD_checkCParams(ZSTD_compressionParameters cParams)
#define FORWARD_IF_ERROR(err,...)
#define memset(x, y, z)
Definition: compat.h:39

◆ ZSTD_CCtxParams_reset()

size_t ZSTD_CCtxParams_reset ( ZSTD_CCtx_params *  params)

Definition at line 230 of file zstd_compress.c.

231 {
233 }
#define ZSTD_CLEVEL_DEFAULT
Definition: zstd.h:90
GLenum const GLfloat * params
Definition: glext.h:5645
size_t ZSTD_CCtxParams_init(ZSTD_CCtx_params *cctxParams, int compressionLevel)

Referenced by ZSTD_CCtx_reset().

◆ ZSTD_CCtxParams_setParameter()

size_t ZSTD_CCtxParams_setParameter ( ZSTD_CCtx_params *  CCtxParams,
ZSTD_cParameter  param,
int  value 
)

Definition at line 531 of file zstd_compress.c.

533 {
534  DEBUGLOG(4, "ZSTD_CCtxParams_setParameter (%i, %i)", (int)param, value);
535  switch(param)
536  {
537  case ZSTD_c_format :
538  BOUNDCHECK(ZSTD_c_format, value);
539  CCtxParams->format = (ZSTD_format_e)value;
540  return (size_t)CCtxParams->format;
541 
542  case ZSTD_c_compressionLevel : {
544  if (value) { /* 0 : does not change current level */
545  CCtxParams->compressionLevel = value;
546  }
547  if (CCtxParams->compressionLevel >= 0) return (size_t)CCtxParams->compressionLevel;
548  return 0; /* return type (size_t) cannot represent negative values */
549  }
550 
551  case ZSTD_c_windowLog :
552  if (value!=0) /* 0 => use default */
554  CCtxParams->cParams.windowLog = (U32)value;
555  return CCtxParams->cParams.windowLog;
556 
557  case ZSTD_c_hashLog :
558  if (value!=0) /* 0 => use default */
560  CCtxParams->cParams.hashLog = (U32)value;
561  return CCtxParams->cParams.hashLog;
562 
563  case ZSTD_c_chainLog :
564  if (value!=0) /* 0 => use default */
566  CCtxParams->cParams.chainLog = (U32)value;
567  return CCtxParams->cParams.chainLog;
568 
569  case ZSTD_c_searchLog :
570  if (value!=0) /* 0 => use default */
572  CCtxParams->cParams.searchLog = (U32)value;
573  return (size_t)value;
574 
575  case ZSTD_c_minMatch :
576  if (value!=0) /* 0 => use default */
578  CCtxParams->cParams.minMatch = value;
579  return CCtxParams->cParams.minMatch;
580 
581  case ZSTD_c_targetLength :
583  CCtxParams->cParams.targetLength = value;
584  return CCtxParams->cParams.targetLength;
585 
586  case ZSTD_c_strategy :
587  if (value!=0) /* 0 => use default */
589  CCtxParams->cParams.strategy = (ZSTD_strategy)value;
590  return (size_t)CCtxParams->cParams.strategy;
591 
593  /* Content size written in frame header _when known_ (default:1) */
594  DEBUGLOG(4, "set content size flag = %u", (value!=0));
595  CCtxParams->fParams.contentSizeFlag = value != 0;
596  return CCtxParams->fParams.contentSizeFlag;
597 
598  case ZSTD_c_checksumFlag :
599  /* A 32-bits content checksum will be calculated and written at end of frame (default:0) */
600  CCtxParams->fParams.checksumFlag = value != 0;
601  return CCtxParams->fParams.checksumFlag;
602 
603  case ZSTD_c_dictIDFlag : /* When applicable, dictionary's dictID is provided in frame header (default:1) */
604  DEBUGLOG(4, "set dictIDFlag = %u", (value!=0));
605  CCtxParams->fParams.noDictIDFlag = !value;
606  return !CCtxParams->fParams.noDictIDFlag;
607 
608  case ZSTD_c_forceMaxWindow :
609  CCtxParams->forceWindow = (value != 0);
610  return CCtxParams->forceWindow;
611 
612  case ZSTD_c_forceAttachDict : {
613  const ZSTD_dictAttachPref_e pref = (ZSTD_dictAttachPref_e)value;
614  BOUNDCHECK(ZSTD_c_forceAttachDict, pref);
615  CCtxParams->attachDictPref = pref;
616  return CCtxParams->attachDictPref;
617  }
618 
619  case ZSTD_c_literalCompressionMode : {
620  const ZSTD_literalCompressionMode_e lcm = (ZSTD_literalCompressionMode_e)value;
621  BOUNDCHECK(ZSTD_c_literalCompressionMode, lcm);
622  CCtxParams->literalCompressionMode = lcm;
623  return CCtxParams->literalCompressionMode;
624  }
625 
626  case ZSTD_c_nbWorkers :
627 #ifndef ZSTD_MULTITHREAD
628  RETURN_ERROR_IF(value!=0, parameter_unsupported, "not compiled with multithreading");
629  return 0;
630 #else
632  CCtxParams->nbWorkers = value;
633  return CCtxParams->nbWorkers;
634 #endif
635 
636  case ZSTD_c_jobSize :
637 #ifndef ZSTD_MULTITHREAD
638  RETURN_ERROR_IF(value!=0, parameter_unsupported, "not compiled with multithreading");
639  return 0;
640 #else
641  /* Adjust to the minimum non-default value. */
642  if (value != 0 && value < ZSTDMT_JOBSIZE_MIN)
643  value = ZSTDMT_JOBSIZE_MIN;
645  assert(value >= 0);
646  CCtxParams->jobSize = value;
647  return CCtxParams->jobSize;
648 #endif
649 
650  case ZSTD_c_overlapLog :
651 #ifndef ZSTD_MULTITHREAD
652  RETURN_ERROR_IF(value!=0, parameter_unsupported, "not compiled with multithreading");
653  return 0;
654 #else
656  CCtxParams->overlapLog = value;
657  return CCtxParams->overlapLog;
658 #endif
659 
660  case ZSTD_c_rsyncable :
661 #ifndef ZSTD_MULTITHREAD
662  RETURN_ERROR_IF(value!=0, parameter_unsupported, "not compiled with multithreading");
663  return 0;
664 #else
666  CCtxParams->rsyncable = value;
667  return CCtxParams->rsyncable;
668 #endif
669 
671  CCtxParams->ldmParams.enableLdm = (value!=0);
672  return CCtxParams->ldmParams.enableLdm;
673 
674  case ZSTD_c_ldmHashLog :
675  if (value!=0) /* 0 ==> auto */
677  CCtxParams->ldmParams.hashLog = value;
678  return CCtxParams->ldmParams.hashLog;
679 
680  case ZSTD_c_ldmMinMatch :
681  if (value!=0) /* 0 ==> default */
683  CCtxParams->ldmParams.minMatchLength = value;
684  return CCtxParams->ldmParams.minMatchLength;
685 
687  if (value!=0) /* 0 ==> default */
689  CCtxParams->ldmParams.bucketSizeLog = value;
690  return CCtxParams->ldmParams.bucketSizeLog;
691 
692  case ZSTD_c_ldmHashRateLog :
693  RETURN_ERROR_IF(value > ZSTD_WINDOWLOG_MAX - ZSTD_HASHLOG_MIN,
694  parameter_outOfBound, "Param out of bounds!");
695  CCtxParams->ldmParams.hashRateLog = value;
696  return CCtxParams->ldmParams.hashRateLog;
697 
698  case ZSTD_c_targetCBlockSize :
699  if (value!=0) /* 0 ==> default */
700  BOUNDCHECK(ZSTD_c_targetCBlockSize, value);
701  CCtxParams->targetCBlockSize = value;
702  return CCtxParams->targetCBlockSize;
703 
704  case ZSTD_c_srcSizeHint :
705  if (value!=0) /* 0 ==> default */
706  BOUNDCHECK(ZSTD_c_srcSizeHint, value);
707  CCtxParams->srcSizeHint = value;
708  return CCtxParams->srcSizeHint;
709 
710  default: RETURN_ERROR(parameter_unsupported, "unknown parameter");
711  }
712 }
Definition: pdh_main.c:93
#define assert(x)
Definition: debug.h:53
#define DEBUGLOG(l,...)
Definition: debug.h:106
#define RETURN_ERROR(StatusCode)
Definition: Base.h:751
#define RETURN_ERROR_IF(cond, err,...)
Definition: zstd_internal.h:91
GLfloat param
Definition: glext.h:5796
#define BOUNDCHECK(cParam, val)
GLsizei const GLfloat * value
Definition: glext.h:6069
static size_t ZSTD_cParam_clampBounds(ZSTD_cParameter cParam, int *value)
#define FORWARD_IF_ERROR(err,...)
ZSTD_strategy
Definition: zstd.h:251
unsigned int U32
Definition: xxhash.c:195

Referenced by ZSTD_CCtx_setParameter().

◆ ZSTD_checkCParams()

size_t ZSTD_checkCParams ( ZSTD_compressionParameters  cParams)

ZSTD_checkCParams() : control CParam values remain within authorized range.

Returns
: 0, or an error code if one value is beyond authorized range

Definition at line 983 of file zstd_compress.c.

984 {
985  BOUNDCHECK(ZSTD_c_windowLog, (int)cParams.windowLog);
986  BOUNDCHECK(ZSTD_c_chainLog, (int)cParams.chainLog);
987  BOUNDCHECK(ZSTD_c_hashLog, (int)cParams.hashLog);
988  BOUNDCHECK(ZSTD_c_searchLog, (int)cParams.searchLog);
989  BOUNDCHECK(ZSTD_c_minMatch, (int)cParams.minMatch);
990  BOUNDCHECK(ZSTD_c_targetLength,(int)cParams.targetLength);
991  BOUNDCHECK(ZSTD_c_strategy, cParams.strategy);
992  return 0;
993 }
#define BOUNDCHECK(cParam, val)

Referenced by ZSTD_adjustCParams_internal(), ZSTD_assignParamsToCCtxParams(), ZSTD_CCtxParams_init_advanced(), ZSTD_compress_advanced(), ZSTD_compressBegin_advanced_internal(), ZSTD_compressBegin_internal(), ZSTD_getBlockSize(), ZSTD_getCParamsFromCCtxParams(), ZSTD_initCDict_internal(), ZSTD_initCStream_advanced(), ZSTD_initCStream_internal(), ZSTD_makeCCtxParamsFromCParams(), ZSTD_resetCCtx_internal(), and ZSTD_resetCStream_internal().

◆ ZSTD_checkDictNCount()

static size_t ZSTD_checkDictNCount ( short normalizedCounter,
unsigned  dictMaxSymbolValue,
unsigned  maxSymbolValue 
)
static

Definition at line 2893 of file zstd_compress.c.

2893  {
2894  U32 s;
2895  RETURN_ERROR_IF(dictMaxSymbolValue < maxSymbolValue, dictionary_corrupted, "dict fse tables don't have all symbols");
2896  for (s = 0; s <= maxSymbolValue; ++s) {
2897  RETURN_ERROR_IF(normalizedCounter[s] == 0, dictionary_corrupted, "dict fse tables don't have all symbols");
2898  }
2899  return 0;
2900 }
#define RETURN_ERROR_IF(cond, err,...)
Definition: zstd_internal.h:91
GLdouble s
Definition: gl.h:2039
unsigned int U32
Definition: xxhash.c:195

Referenced by ZSTD_loadCEntropy(), and ZSTD_loadZstdDictionary().

◆ ZSTD_clampCParams()

static ZSTD_compressionParameters ZSTD_clampCParams ( ZSTD_compressionParameters  cParams)
static

ZSTD_clampCParams() : make CParam values within valid range.

Returns
: valid CParams

Definition at line 999 of file zstd_compress.c.

1000 {
1001 # define CLAMP_TYPE(cParam, val, type) { \
1002  ZSTD_bounds const bounds = ZSTD_cParam_getBounds(cParam); \
1003  if ((int)val<bounds.lowerBound) val=(type)bounds.lowerBound; \
1004  else if ((int)val>bounds.upperBound) val=(type)bounds.upperBound; \
1005  }
1006 # define CLAMP(cParam, val) CLAMP_TYPE(cParam, val, unsigned)
1007  CLAMP(ZSTD_c_windowLog, cParams.windowLog);
1008  CLAMP(ZSTD_c_chainLog, cParams.chainLog);
1009  CLAMP(ZSTD_c_hashLog, cParams.hashLog);
1010  CLAMP(ZSTD_c_searchLog, cParams.searchLog);
1011  CLAMP(ZSTD_c_minMatch, cParams.minMatch);
1012  CLAMP(ZSTD_c_targetLength,cParams.targetLength);
1013  CLAMP_TYPE(ZSTD_c_strategy,cParams.strategy, ZSTD_strategy);
1014  return cParams;
1015 }
#define CLAMP(cParam, val)
#define CLAMP_TYPE(cParam, val, type)
ZSTD_strategy
Definition: zstd.h:251

Referenced by ZSTD_adjustCParams().

◆ ZSTD_clearAllDicts()

static void ZSTD_clearAllDicts ( ZSTD_CCtx cctx)
static

Clears and frees all of the dictionaries in the CCtx.

Definition at line 120 of file zstd_compress.c.

121 {
122  ZSTD_free(cctx->localDict.dictBuffer, cctx->customMem);
124  memset(&cctx->localDict, 0, sizeof(cctx->localDict));
125  memset(&cctx->prefixDict, 0, sizeof(cctx->prefixDict));
126  cctx->cdict = NULL;
127 }
void ZSTD_free(void *ptr, ZSTD_customMem customMem)
Definition: zstd_common.c:70
ZSTD_prefixDict prefixDict
ZSTD_localDict localDict
const ZSTD_CDict * cdict
#define NULL
Definition: types.h:112
ZSTD_customMem customMem
#define memset(x, y, z)
Definition: compat.h:39
size_t ZSTD_freeCDict(ZSTD_CDict *cdict)

Referenced by ZSTD_CCtx_loadDictionary_advanced(), ZSTD_CCtx_refCDict(), ZSTD_CCtx_refPrefix_advanced(), ZSTD_CCtx_reset(), and ZSTD_freeCCtxContent().

◆ ZSTD_compress()

size_t ZSTD_compress ( void dst,
size_t  dstCapacity,
const void src,
size_t  srcSize,
int  compressionLevel 
)

ZSTD_compress() : Compresses src content as a single zstd compressed frame into already allocated dst. Hint : compression runs faster if dstCapacity >= ZSTD_compressBound(srcSize).

Returns
: compressed size written into dst (<= `dstCapacity), or an error code if it fails (which can be tested using ZSTD_isError()).

Definition at line 3307 of file zstd_compress.c.

3310 {
3311  size_t result;
3312  ZSTD_CCtx ctxBody;
3313  ZSTD_initCCtx(&ctxBody, ZSTD_defaultCMem);
3314  result = ZSTD_compressCCtx(&ctxBody, dst, dstCapacity, src, srcSize, compressionLevel);
3315  ZSTD_freeCCtxContent(&ctxBody); /* can't free ctxBody itself, as it's on stack; free only heap content */
3316  return result;
3317 }
GLuint64EXT * result
Definition: glext.h:11304
size_t ZSTD_compressCCtx(ZSTD_CCtx *cctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize, int compressionLevel)
static void ZSTD_freeCCtxContent(ZSTD_CCtx *cctx)
GLenum src
Definition: glext.h:6340
static void ZSTD_initCCtx(ZSTD_CCtx *cctx, ZSTD_customMem memManager)
Definition: zstd_compress.c:69
GLenum GLenum dst
Definition: glext.h:6340

◆ ZSTD_compress2()

size_t ZSTD_compress2 ( ZSTD_CCtx cctx,
void dst,
size_t  dstCapacity,
const void src,
size_t  srcSize 
)

ZSTD_compress2() : Behave the same as ZSTD_compressCCtx(), but compression parameters are set using the advanced API. ZSTD_compress2() always starts a new frame. Should cctx hold data from a previously unfinished frame, everything about it is forgotten.

  • Compression parameters are pushed into CCtx before starting compression, using ZSTD_CCtx_set*()
  • The function is always blocking, returns when compression is completed. Hint : compression runs faster if dstCapacity >= ZSTD_compressBound(srcSize).
    Returns
    : compressed size written into dst (<= `dstCapacity), or an error code if it fails (which can be tested using ZSTD_isError()).

Definition at line 4064 of file zstd_compress.c.

4067 {
4068  DEBUGLOG(4, "ZSTD_compress2 (srcSize=%u)", (unsigned)srcSize);
4070  { size_t oPos = 0;
4071  size_t iPos = 0;
4072  size_t const result = ZSTD_compressStream2_simpleArgs(cctx,
4073  dst, dstCapacity, &oPos,
4074  src, srcSize, &iPos,
4075  ZSTD_e_end);
4076  FORWARD_IF_ERROR(result, "ZSTD_compressStream2_simpleArgs failed");
4077  if (result != 0) { /* compression not completed, due to lack of output space */
4078  assert(oPos == dstCapacity);
4079  RETURN_ERROR(dstSize_tooSmall, "");
4080  }
4081  assert(iPos == srcSize); /* all input is expected consumed */
4082  return oPos;
4083  }
4084 }
GLuint64EXT * result
Definition: glext.h:11304
#define assert(x)
Definition: debug.h:53
#define DEBUGLOG(l,...)
Definition: debug.h:106
#define RETURN_ERROR(StatusCode)
Definition: Base.h:751
size_t ZSTD_CCtx_reset(ZSTD_CCtx *cctx, ZSTD_ResetDirective reset)
GLenum src
Definition: glext.h:6340
size_t ZSTD_compressStream2_simpleArgs(ZSTD_CCtx *cctx, void *dst, size_t dstCapacity, size_t *dstPos, const void *src, size_t srcSize, size_t *srcPos, ZSTD_EndDirective endOp)
GLenum GLenum dst
Definition: glext.h:6340
#define FORWARD_IF_ERROR(err,...)

Referenced by ZSTD_getSequences().

◆ ZSTD_compress_advanced()

size_t ZSTD_compress_advanced ( ZSTD_CCtx cctx,
void dst,
size_t  dstCapacity,
const void src,
size_t  srcSize,
const void dict,
size_t  dictSize,
ZSTD_parameters  params 
)

Definition at line 3254 of file zstd_compress.c.

3259 {
3260  DEBUGLOG(4, "ZSTD_compress_advanced");
3262  return ZSTD_compress_internal(cctx,
3263  dst, dstCapacity,
3264  src, srcSize,
3265  dict, dictSize,
3266  &params);
3267 }
static size_t ZSTD_compress_internal(ZSTD_CCtx *cctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize, const void *dict, size_t dictSize, const ZSTD_parameters *params)
#define DEBUGLOG(l,...)
Definition: debug.h:106
GLenum const GLfloat * params
Definition: glext.h:5645
size_t ZSTD_checkCParams(ZSTD_compressionParameters cParams)
GLenum src
Definition: glext.h:6340
GLenum GLenum dst
Definition: glext.h:6340
#define FORWARD_IF_ERROR(err,...)

◆ 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,
const ZSTD_CCtx_params *  params 
)

Definition at line 3270 of file zstd_compress.c.

3276 {
3277  DEBUGLOG(4, "ZSTD_compress_advanced_internal (srcSize:%u)", (unsigned)srcSize);
3279  dict, dictSize, ZSTD_dct_auto, ZSTD_dtlm_fast, NULL,
3280  params, srcSize, ZSTDb_not_buffered) , "");
3281  return ZSTD_compressEnd(cctx, dst, dstCapacity, src, srcSize);
3282 }
static size_t ZSTD_compressBegin_internal(ZSTD_CCtx *cctx, const void *dict, size_t dictSize, ZSTD_dictContentType_e dictContentType, ZSTD_dictTableLoadMethod_e dtlm, const ZSTD_CDict *cdict, const ZSTD_CCtx_params *params, U64 pledgedSrcSize, ZSTD_buffered_policy_e zbuff)
#define DEBUGLOG(l,...)
Definition: debug.h:106
GLenum const GLfloat * params
Definition: glext.h:5645
GLenum src
Definition: glext.h:6340
GLenum GLenum dst
Definition: glext.h:6340
#define NULL
Definition: types.h:112
#define FORWARD_IF_ERROR(err,...)
size_t ZSTD_compressEnd(ZSTD_CCtx *cctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize)

Referenced by ZSTD_compress_internal(), and ZSTD_compress_usingDict().

◆ ZSTD_compress_frameChunk()

static size_t ZSTD_compress_frameChunk ( ZSTD_CCtx cctx,
void dst,
size_t  dstCapacity,
const void src,
size_t  srcSize,
U32  lastFrameChunk 
)
static

ZSTD_compress_frameChunk() : Compress a chunk of data into one or multiple blocks. All blocks will be terminated, all input will be consumed. Function will issue an error if there is not enough dstCapacity to hold the compressed content. Frame is supposed already started (header already produced)

Returns
: compressed size, or an error code

Definition at line 2582 of file zstd_compress.c.

2586 {
2587  size_t blockSize = cctx->blockSize;
2588  size_t remaining = srcSize;
2589  const BYTE* ip = (const BYTE*)src;
2590  BYTE* const ostart = (BYTE*)dst;
2591  BYTE* op = ostart;
2592  U32 const maxDist = (U32)1 << cctx->appliedParams.cParams.windowLog;
2593 
2594  assert(cctx->appliedParams.cParams.windowLog <= ZSTD_WINDOWLOG_MAX);
2595 
2596  DEBUGLOG(5, "ZSTD_compress_frameChunk (blockSize=%u)", (unsigned)blockSize);
2597  if (cctx->appliedParams.fParams.checksumFlag && srcSize)
2598  XXH64_update(&cctx->xxhState, src, srcSize);
2599 
2600  while (remaining) {
2601  ZSTD_matchState_t* const ms = &cctx->blockState.matchState;
2602  U32 const lastBlock = lastFrameChunk & (blockSize >= remaining);
2603 
2605  dstSize_tooSmall,
2606  "not enough space to store compressed block");
2607  if (remaining < blockSize) blockSize = remaining;
2608 
2610  ms, &cctx->workspace, &cctx->appliedParams, ip, ip + blockSize);
2611  ZSTD_checkDictValidity(&ms->window, ip + blockSize, maxDist, &ms->loadedDictEnd, &ms->dictMatchState);
2612 
2613  /* Ensure hash/chain table insertion resumes no sooner than lowlimit */
2614  if (ms->nextToUpdate < ms->window.lowLimit) ms->nextToUpdate = ms->window.lowLimit;
2615 
2616  { size_t cSize;
2618  cSize = ZSTD_compressBlock_targetCBlockSize(cctx, op, dstCapacity, ip, blockSize, lastBlock);
2619  FORWARD_IF_ERROR(cSize, "ZSTD_compressBlock_targetCBlockSize failed");
2620  assert(cSize > 0);
2621  assert(cSize <= blockSize + ZSTD_blockHeaderSize);
2622  } else {
2623  cSize = ZSTD_compressBlock_internal(cctx,
2625  ip, blockSize, 1 /* frame */);
2626  FORWARD_IF_ERROR(cSize, "ZSTD_compressBlock_internal failed");
2627 
2628  if (cSize == 0) { /* block is not compressible */
2629  cSize = ZSTD_noCompressBlock(op, dstCapacity, ip, blockSize, lastBlock);
2630  FORWARD_IF_ERROR(cSize, "ZSTD_noCompressBlock failed");
2631  } else {
2632  U32 const cBlockHeader = cSize == 1 ?
2633  lastBlock + (((U32)bt_rle)<<1) + (U32)(blockSize << 3) :
2634  lastBlock + (((U32)bt_compressed)<<1) + (U32)(cSize << 3);
2635  MEM_writeLE24(op, cBlockHeader);
2636  cSize += ZSTD_blockHeaderSize;
2637  }
2638  }
2639 
2640 
2641  ip += blockSize;
2642  assert(remaining >= blockSize);
2643  remaining -= blockSize;
2644  op += cSize;
2645  assert(dstCapacity >= cSize);
2646  dstCapacity -= cSize;
2647  cctx->isFirstBlock = 0;
2648  DEBUGLOG(5, "ZSTD_compress_frameChunk: adding a block of size %u",
2649  (unsigned)cSize);
2650  } }
2651 
2652  if (lastFrameChunk && (op>ostart)) cctx->stage = ZSTDcs_ending;
2653  return (size_t)(op-ostart);
2654 }
MEM_STATIC size_t ZSTD_noCompressBlock(void *dst, size_t dstCapacity, const void *src, size_t srcSize, U32 lastBlock)
#define assert(x)
Definition: debug.h:53
static size_t ZSTD_compressBlock_targetCBlockSize(ZSTD_CCtx *zc, void *dst, size_t dstCapacity, const void *src, size_t srcSize, U32 lastBlock)
static int ZSTD_useTargetCBlockSize(const ZSTD_CCtx_params *cctxParams)
#define DEBUGLOG(l,...)
Definition: debug.h:106
static const size_t ZSTD_blockHeaderSize
static size_t ZSTD_compressBlock_internal(ZSTD_CCtx *zc, void *dst, size_t dstCapacity, const void *src, size_t srcSize, U32 frame)
ZSTD_compressionStage_e stage
ZSTD_CCtx_params appliedParams
ZSTD_blockState_t blockState
#define RETURN_ERROR_IF(cond, err,...)
Definition: zstd_internal.h:91
Definition: dhcpd.h:61
const ZSTD_matchState_t * dictMatchState
XXH64_state_t xxhState
XXH_PUBLIC_API XXH_errorcode XXH64_update(XXH64_state_t *state_in, const void *input, size_t len)
Definition: xxhash.c:810
UINT op
Definition: effect.c:236
static void ZSTD_overflowCorrectIfNeeded(ZSTD_matchState_t *ms, ZSTD_cwksp *ws, ZSTD_CCtx_params const *params, void const *ip, void const *iend)
#define MIN_CBLOCK_SIZE
ZSTD_matchState_t matchState
GLenum src
Definition: glext.h:6340
MEM_STATIC void ZSTD_checkDictValidity(const ZSTD_window_t *window, const void *blockEnd, U32 maxDist, U32 *loadedDictEndPtr, const ZSTD_matchState_t **dictMatchStatePtr)
unsigned char BYTE
Definition: xxhash.c:193
GLenum GLenum dst
Definition: glext.h:6340
#define FORWARD_IF_ERROR(err,...)
MEM_STATIC void MEM_writeLE24(void *memPtr, U32 val)
Definition: mem.h:340
unsigned int U32
Definition: xxhash.c:195

Referenced by ZSTD_compressContinue_internal().

◆ ZSTD_compress_insertDictionary()

static size_t ZSTD_compress_insertDictionary ( ZSTD_compressedBlockState_t bs,
ZSTD_matchState_t ms,
ldmState_t ls,
ZSTD_cwksp ws,
const ZSTD_CCtx_params *  params,
const void dict,
size_t  dictSize,
ZSTD_dictContentType_e  dictContentType,
ZSTD_dictTableLoadMethod_e  dtlm,
void workspace 
)
static

ZSTD_compress_insertDictionary() :

Returns
: dictID, or an error code

Definition at line 3039 of file zstd_compress.c.

3048 {
3049  DEBUGLOG(4, "ZSTD_compress_insertDictionary (dictSize=%u)", (U32)dictSize);
3050  if ((dict==NULL) || (dictSize<8)) {
3051  RETURN_ERROR_IF(dictContentType == ZSTD_dct_fullDict, dictionary_wrong, "");
3052  return 0;
3053  }
3054 
3056 
3057  /* dict restricted modes */
3058  if (dictContentType == ZSTD_dct_rawContent)
3059  return ZSTD_loadDictionaryContent(ms, ls, ws, params, dict, dictSize, dtlm);
3060 
3061  if (MEM_readLE32(dict) != ZSTD_MAGIC_DICTIONARY) {
3062  if (dictContentType == ZSTD_dct_auto) {
3063  DEBUGLOG(4, "raw content dictionary detected");
3065  ms, ls, ws, params, dict, dictSize, dtlm);
3066  }
3067  RETURN_ERROR_IF(dictContentType == ZSTD_dct_fullDict, dictionary_wrong, "");
3068  assert(0); /* impossible */
3069  }
3070 
3071  /* dict as full zstd dictionary */
3072  return ZSTD_loadZstdDictionary(
3073  bs, ms, ws, params, dict, dictSize, dtlm, workspace);
3074 }
const char * ws
Definition: skip_ws.cpp:7
MEM_STATIC U32 MEM_readLE32(const void *memPtr)
Definition: mem.h:346
#define assert(x)
Definition: debug.h:53
void ls(int argc, const char *argv[])
Definition: cmds.c:1136
#define DEBUGLOG(l,...)
Definition: debug.h:106
GLenum const GLfloat * params
Definition: glext.h:5645
static size_t ZSTD_loadZstdDictionary(ZSTD_compressedBlockState_t *bs, ZSTD_matchState_t *ms, ZSTD_cwksp *ws, ZSTD_CCtx_params const *params, const void *dict, size_t dictSize, ZSTD_dictTableLoadMethod_e dtlm, void *workspace)
#define RETURN_ERROR_IF(cond, err,...)
Definition: zstd_internal.h:91
#define ZSTD_MAGIC_DICTIONARY
Definition: zstd.h:99
static size_t ZSTD_loadDictionaryContent(ZSTD_matchState_t *ms, ldmState_t *ls, ZSTD_cwksp *ws, ZSTD_CCtx_params const *params, const void *src, size_t srcSize, ZSTD_dictTableLoadMethod_e dtlm)
#define NULL
Definition: types.h:112
void ZSTD_reset_compressedBlockState(ZSTD_compressedBlockState_t *bs)
static struct msdos_boot_sector bs
Definition: mkdosfs.c:539
unsigned int U32
Definition: xxhash.c:195

Referenced by ZSTD_compressBegin_internal(), and ZSTD_initCDict_internal().

◆ ZSTD_compress_internal()

static size_t ZSTD_compress_internal ( ZSTD_CCtx cctx,
void dst,
size_t  dstCapacity,
const void src,
size_t  srcSize,
const void dict,
size_t  dictSize,
const ZSTD_parameters *  params 
)
static

Definition at line 3238 of file zstd_compress.c.

3243 {
3244  ZSTD_CCtx_params const cctxParams =
3246  DEBUGLOG(4, "ZSTD_compress_internal");
3247  return ZSTD_compress_advanced_internal(cctx,
3248  dst, dstCapacity,
3249  src, srcSize,
3250  dict, dictSize,
3251  &cctxParams);
3252 }
static ZSTD_CCtx_params ZSTD_assignParamsToCCtxParams(const ZSTD_CCtx_params *cctxParams, const ZSTD_parameters *params)
#define DEBUGLOG(l,...)
Definition: debug.h:106
GLenum const GLfloat * params
Definition: glext.h:5645
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, const ZSTD_CCtx_params *params)
GLenum src
Definition: glext.h:6340
GLenum GLenum dst
Definition: glext.h:6340
ZSTD_CCtx_params requestedParams

Referenced by ZSTD_compress_advanced().

◆ ZSTD_compress_usingCDict()

size_t ZSTD_compress_usingCDict ( ZSTD_CCtx cctx,
void dst,
size_t  dstCapacity,
const void src,
size_t  srcSize,
const ZSTD_CDict cdict 
)

ZSTD_compress_usingCDict() : Compression using a digested Dictionary. Faster startup than ZSTD_compress_usingDict(), recommended when same dictionary is used multiple times. Note that compression parameters are decided at CDict creation time while frame parameters are hardcoded

Definition at line 3596 of file zstd_compress.c.

3600 {
3601  ZSTD_frameParameters const fParams = { 1 /*content*/, 0 /*checksum*/, 0 /*noDictID*/ };
3602  return ZSTD_compress_usingCDict_advanced(cctx, dst, dstCapacity, src, srcSize, cdict, fParams);
3603 }
GLenum src
Definition: glext.h:6340
size_t ZSTD_compress_usingCDict_advanced(ZSTD_CCtx *cctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize, const ZSTD_CDict *cdict, ZSTD_frameParameters fParams)
GLenum GLenum dst
Definition: glext.h:6340

◆ ZSTD_compress_usingCDict_advanced()

size_t ZSTD_compress_usingCDict_advanced ( ZSTD_CCtx cctx,
void dst,
size_t  dstCapacity,
const void src,
size_t  srcSize,
const ZSTD_CDict cdict,
ZSTD_frameParameters  fParams 
)

Definition at line 3582 of file zstd_compress.c.

3586 {
3587  FORWARD_IF_ERROR(ZSTD_compressBegin_usingCDict_advanced(cctx, cdict, fParams, srcSize), ""); /* will check if cdict != NULL */
3588  return ZSTD_compressEnd(cctx, dst, dstCapacity, src, srcSize);
3589 }
size_t ZSTD_compressBegin_usingCDict_advanced(ZSTD_CCtx *const cctx, const ZSTD_CDict *const cdict, ZSTD_frameParameters const fParams, unsigned long long const pledgedSrcSize)
GLenum src
Definition: glext.h:6340
GLenum GLenum dst
Definition: glext.h:6340
#define FORWARD_IF_ERROR(err,...)
size_t ZSTD_compressEnd(ZSTD_CCtx *cctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize)

Referenced by ZSTD_compress_usingCDict().

◆ ZSTD_compress_usingDict()

size_t ZSTD_compress_usingDict ( ZSTD_CCtx ctx,
void dst,
size_t  dstCapacity,
const void src,
size_t  srcSize,
const void dict,
size_t  dictSize,
int  compressionLevel 
)

ZSTD_compress_usingDict() : Compression at an explicit compression level using a Dictionary. A dictionary can be any arbitrary data segment (also called a prefix), or a buffer with specified information (see dictBuilder/zdict.h). Note : This function loads the dictionary, resulting in significant startup delay. It's intended for a dictionary used only once. Note 2 : When dict == NULL || dictSize < 8 no dictionary is used.

Definition at line 3284 of file zstd_compress.c.

3289 {
3290  ZSTD_parameters const params = ZSTD_getParams_internal(compressionLevel, srcSize, dict ? dictSize : 0);
3291  ZSTD_CCtx_params cctxParams = ZSTD_assignParamsToCCtxParams(&cctx->requestedParams, &params);
3292  DEBUGLOG(4, "ZSTD_compress_usingDict (srcSize=%u)", (unsigned)srcSize);
3293  assert(params.fParams.contentSizeFlag == 1);
3294  return ZSTD_compress_advanced_internal(cctx, dst, dstCapacity, src, srcSize, dict, dictSize, &cctxParams);
3295 }
#define assert(x)
Definition: debug.h:53
static ZSTD_CCtx_params ZSTD_assignParamsToCCtxParams(const ZSTD_CCtx_params *cctxParams, const ZSTD_parameters *params)
#define DEBUGLOG(l,...)
Definition: debug.h:106
GLenum const GLfloat * params
Definition: glext.h:5645
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, const ZSTD_CCtx_params *params)
GLenum src
Definition: glext.h:6340
GLenum GLenum dst
Definition: glext.h:6340
ZSTD_CCtx_params requestedParams
static ZSTD_parameters ZSTD_getParams_internal(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize)

Referenced by ZSTD_compressCCtx().

◆ ZSTD_compressBegin()

size_t ZSTD_compressBegin ( ZSTD_CCtx cctx,
int  compressionLevel 
)

Definition at line 3164 of file zstd_compress.c.

3165 {
3166  return ZSTD_compressBegin_usingDict(cctx, NULL, 0, compressionLevel);
3167 }
size_t ZSTD_compressBegin_usingDict(ZSTD_CCtx *cctx, const void *dict, size_t dictSize, int compressionLevel)
#define NULL
Definition: types.h:112

◆ ZSTD_compressBegin_advanced()

size_t ZSTD_compressBegin_advanced ( ZSTD_CCtx cctx,
const void dict,
size_t  dictSize,
ZSTD_parameters  params,
unsigned long long  pledgedSrcSize 
)

ZSTD_compressBegin_advanced() :

Returns
: 0, or an error code

Definition at line 3142 of file zstd_compress.c.

3145 {
3146  ZSTD_CCtx_params const cctxParams =
3149  dict, dictSize, ZSTD_dct_auto, ZSTD_dtlm_fast,
3150  NULL /*cdict*/,
3151  &cctxParams, pledgedSrcSize);
3152 }
static ZSTD_CCtx_params ZSTD_assignParamsToCCtxParams(const ZSTD_CCtx_params *cctxParams, const ZSTD_parameters *params)
GLenum const GLfloat * params
Definition: glext.h:5645
#define NULL
Definition: types.h:112
ZSTD_CCtx_params requestedParams
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, const ZSTD_CCtx_params *params, unsigned long long pledgedSrcSize)

◆ 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,
const ZSTD_CCtx_params *  params,
unsigned long long  pledgedSrcSize 
)

Definition at line 3122 of file zstd_compress.c.

3129 {
3130  DEBUGLOG(4, "ZSTD_compressBegin_advanced_internal: wlog=%u", params->cParams.windowLog);
3131  /* compression parameters verification and optimization */
3132  FORWARD_IF_ERROR( ZSTD_checkCParams(params->cParams) , "");
3133  return ZSTD_compressBegin_internal(cctx,
3134  dict, dictSize, dictContentType, dtlm,
3135  cdict,
3136  params, pledgedSrcSize,
3138 }
static size_t ZSTD_compressBegin_internal(ZSTD_CCtx *cctx, const void *dict, size_t dictSize, ZSTD_dictContentType_e dictContentType, ZSTD_dictTableLoadMethod_e dtlm, const ZSTD_CDict *cdict, const ZSTD_CCtx_params *params, U64 pledgedSrcSize, ZSTD_buffered_policy_e zbuff)
#define DEBUGLOG(l,...)
Definition: debug.h:106
GLenum const GLfloat * params
Definition: glext.h:5645
size_t ZSTD_checkCParams(ZSTD_compressionParameters cParams)
#define FORWARD_IF_ERROR(err,...)

Referenced by ZSTD_compressBegin_advanced().

◆ ZSTD_compressBegin_internal()

static size_t ZSTD_compressBegin_internal ( ZSTD_CCtx cctx,
const void dict,
size_t  dictSize,
ZSTD_dictContentType_e  dictContentType,
ZSTD_dictTableLoadMethod_e  dtlm,
const ZSTD_CDict cdict,
const ZSTD_CCtx_params *  params,
U64  pledgedSrcSize,
ZSTD_buffered_policy_e  zbuff 
)
static

ZSTD_compressBegin_internal() :

Returns
: 0, or an error code

Definition at line 3081 of file zstd_compress.c.

3088 {
3089  DEBUGLOG(4, "ZSTD_compressBegin_internal: wlog=%u", params->cParams.windowLog);
3090  /* params are supposed to be fully validated at this point */
3092  assert(!((dict) && (cdict))); /* either dict or cdict, not both */
3093  if ( (cdict)
3094  && (cdict->dictContentSize > 0)
3095  && ( pledgedSrcSize < ZSTD_USE_CDICT_PARAMS_SRCSIZE_CUTOFF
3096  || pledgedSrcSize < cdict->dictContentSize * ZSTD_USE_CDICT_PARAMS_DICTSIZE_MULTIPLIER
3097  || pledgedSrcSize == ZSTD_CONTENTSIZE_UNKNOWN
3098  || cdict->compressionLevel == 0)
3099  && (params->attachDictPref != ZSTD_dictForceLoad) ) {
3100  return ZSTD_resetCCtx_usingCDict(cctx, cdict, params, pledgedSrcSize, zbuff);
3101  }
3102 
3103  FORWARD_IF_ERROR( ZSTD_resetCCtx_internal(cctx, *params, pledgedSrcSize,
3104  ZSTDcrp_makeClean, zbuff) , "");
3105  { size_t const dictID = cdict ?
3108  &cctx->ldmState, &cctx->workspace, &cctx->appliedParams, cdict->dictContent,
3109  cdict->dictContentSize, dictContentType, dtlm,
3110  cctx->entropyWorkspace)
3112  cctx->blockState.prevCBlock, &cctx->blockState.matchState,
3113  &cctx->ldmState, &cctx->workspace, &cctx->appliedParams, dict, dictSize,
3114  dictContentType, dtlm, cctx->entropyWorkspace);
3115  FORWARD_IF_ERROR(dictID, "ZSTD_compress_insertDictionary failed");
3116  assert(dictID <= UINT_MAX);
3117  cctx->dictID = (U32)dictID;
3118  }
3119  return 0;
3120 }
#define ZSTD_CONTENTSIZE_UNKNOWN
Definition: zstd.h:152
#define assert(x)
Definition: debug.h:53
#define DEBUGLOG(l,...)
Definition: debug.h:106
#define ZSTD_isError
Definition: zstd_internal.h:46
GLenum const GLfloat * params
Definition: glext.h:5645
static size_t ZSTD_resetCCtx_internal(ZSTD_CCtx *zc, ZSTD_CCtx_params params, U64 const pledgedSrcSize, ZSTD_compResetPolicy_e const crp, ZSTD_buffered_policy_e const zbuff)
ZSTD_CCtx_params appliedParams
ZSTD_blockState_t blockState
const void * dictContent
Definition: zstd_compress.c:53
static size_t ZSTD_compress_insertDictionary(ZSTD_compressedBlockState_t *bs, ZSTD_matchState_t *ms, ldmState_t *ls, ZSTD_cwksp *ws, const ZSTD_CCtx_params *params, const void *dict, size_t dictSize, ZSTD_dictContentType_e dictContentType, ZSTD_dictTableLoadMethod_e dtlm, void *workspace)
static size_t ZSTD_resetCCtx_usingCDict(ZSTD_CCtx *cctx, const ZSTD_CDict *cdict, const ZSTD_CCtx_params *params, U64 pledgedSrcSize, ZSTD_buffered_policy_e zbuff)
size_t ZSTD_checkCParams(ZSTD_compressionParameters cParams)
#define ZSTD_USE_CDICT_PARAMS_DICTSIZE_MULTIPLIER
ZSTD_matchState_t matchState
#define UINT_MAX
Definition: limits.h:41
size_t dictContentSize
Definition: zstd_compress.c:54
int compressionLevel
Definition: zstd_compress.c:61
#define FORWARD_IF_ERROR(err,...)
ZSTD_compressedBlockState_t * prevCBlock
#define ZSTD_USE_CDICT_PARAMS_SRCSIZE_CUTOFF
unsigned int U32
Definition: xxhash.c:195

Referenced by ZSTD_compress_advanced_internal(), ZSTD_compressBegin_advanced_internal(), ZSTD_compressBegin_usingCDict_advanced(), ZSTD_compressBegin_usingDict(), and ZSTD_resetCStream_internal().

◆ ZSTD_compressBegin_usingCDict()

size_t ZSTD_compressBegin_usingCDict ( ZSTD_CCtx cctx,
const ZSTD_CDict cdict 
)

Definition at line 3575 of file zstd_compress.c.

3576 {
3577  ZSTD_frameParameters const fParams = { 0 /*content*/, 0 /*checksum*/, 0 /*noDictID*/ };
3578  DEBUGLOG(4, "ZSTD_compressBegin_usingCDict : dictIDFlag == %u", !fParams.noDictIDFlag);
3580 }
#define ZSTD_CONTENTSIZE_UNKNOWN
Definition: zstd.h:152
#define DEBUGLOG(l,...)
Definition: debug.h:106
size_t ZSTD_compressBegin_usingCDict_advanced(ZSTD_CCtx *const cctx, const ZSTD_CDict *const cdict, ZSTD_frameParameters const fParams, unsigned long long const pledgedSrcSize)

◆ ZSTD_compressBegin_usingCDict_advanced()

size_t ZSTD_compressBegin_usingCDict_advanced ( ZSTD_CCtx *const  cctx,
const ZSTD_CDict *const  cdict,
ZSTD_frameParameters const  fParams,
unsigned long long const  pledgedSrcSize 
)

Definition at line 3538 of file zstd_compress.c.

3541 {
3542  DEBUGLOG(4, "ZSTD_compressBegin_usingCDict_advanced");
3543  RETURN_ERROR_IF(cdict==NULL, dictionary_wrong, "NULL pointer!");
3544  { ZSTD_CCtx_params params = cctx->requestedParams;
3545  params.cParams = ( pledgedSrcSize < ZSTD_USE_CDICT_PARAMS_SRCSIZE_CUTOFF
3546  || pledgedSrcSize < cdict->dictContentSize * ZSTD_USE_CDICT_PARAMS_DICTSIZE_MULTIPLIER
3547  || pledgedSrcSize == ZSTD_CONTENTSIZE_UNKNOWN
3548  || cdict->compressionLevel == 0 )
3549  && (params.attachDictPref != ZSTD_dictForceLoad) ?
3551  : ZSTD_getCParams(cdict->compressionLevel,
3552  pledgedSrcSize,
3553  cdict->dictContentSize);
3554  /* Increase window log to fit the entire dictionary and source if the
3555  * source size is known. Limit the increase to 19, which is the
3556  * window log for compression level 1 with the largest source size.
3557  */
3558  if (pledgedSrcSize != ZSTD_CONTENTSIZE_UNKNOWN) {
3559  U32 const limitedSrcSize = (U32)MIN(pledgedSrcSize, 1U << 19);
3560  U32 const limitedSrcLog = limitedSrcSize > 1 ? ZSTD_highbit32(limitedSrcSize - 1) + 1 : 1;
3561  params.cParams.windowLog = MAX(params.cParams.windowLog, limitedSrcLog);
3562  }
3563  params.fParams = fParams;
3564  return ZSTD_compressBegin_internal(cctx,
3565  NULL, 0, ZSTD_dct_auto, ZSTD_dtlm_fast,
3566  cdict,
3567  &params, pledgedSrcSize,
3569  }
3570 }
#define ZSTD_CONTENTSIZE_UNKNOWN
Definition: zstd.h:152
static size_t ZSTD_compressBegin_internal(ZSTD_CCtx *cctx, const void *dict, size_t dictSize, ZSTD_dictContentType_e dictContentType, ZSTD_dictTableLoadMethod_e dtlm, const ZSTD_CDict *cdict, const ZSTD_CCtx_params *params, U64 pledgedSrcSize, ZSTD_buffered_policy_e zbuff)
#define U(x)
Definition: wordpad.c:45
T MIN(T a, T b)
Definition: polytest.cpp:79
#define DEBUGLOG(l,...)
Definition: debug.h:106
GLenum const GLfloat * params
Definition: glext.h:5645
ZSTD_compressionParameters ZSTD_getCParams(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize)
#define RETURN_ERROR_IF(cond, err,...)
Definition: zstd_internal.h:91
ZSTD_compressionParameters ZSTD_getCParamsFromCDict(const ZSTD_CDict *cdict)
#define ZSTD_USE_CDICT_PARAMS_DICTSIZE_MULTIPLIER
T MAX(T a, T b)
Definition: polytest.cpp:85
size_t dictContentSize
Definition: zstd_compress.c:54
int compressionLevel
Definition: zstd_compress.c:61
#define NULL
Definition: types.h:112
MEM_STATIC U32 ZSTD_highbit32(U32 val)
ZSTD_CCtx_params requestedParams
#define ZSTD_USE_CDICT_PARAMS_SRCSIZE_CUTOFF
unsigned int U32
Definition: xxhash.c:195

Referenced by ZSTD_compress_usingCDict_advanced(), and ZSTD_compressBegin_usingCDict().

◆ ZSTD_compressBegin_usingDict()

size_t ZSTD_compressBegin_usingDict ( ZSTD_CCtx cctx,
const void dict,
size_t  dictSize,
int  compressionLevel 
)

Definition at line 3154 of file zstd_compress.c.

3155 {
3156  ZSTD_parameters const params = ZSTD_getParams_internal(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, dictSize);
3157  ZSTD_CCtx_params const cctxParams =
3159  DEBUGLOG(4, "ZSTD_compressBegin_usingDict (dictSize=%u)", (unsigned)dictSize);
3160  return ZSTD_compressBegin_internal(cctx, dict, dictSize, ZSTD_dct_auto, ZSTD_dtlm_fast, NULL,
3162 }
#define ZSTD_CONTENTSIZE_UNKNOWN
Definition: zstd.h:152
static size_t ZSTD_compressBegin_internal(ZSTD_CCtx *cctx, const void *dict, size_t dictSize, ZSTD_dictContentType_e dictContentType, ZSTD_dictTableLoadMethod_e dtlm, const ZSTD_CDict *cdict, const ZSTD_CCtx_params *params, U64 pledgedSrcSize, ZSTD_buffered_policy_e zbuff)
static ZSTD_CCtx_params ZSTD_assignParamsToCCtxParams(const ZSTD_CCtx_params *cctxParams, const ZSTD_parameters *params)
#define DEBUGLOG(l,...)
Definition: debug.h:106
GLenum const GLfloat * params
Definition: glext.h:5645
#define NULL
Definition: types.h:112
ZSTD_CCtx_params requestedParams
static ZSTD_parameters ZSTD_getParams_internal(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize)

Referenced by ZSTD_compressBegin().

◆ ZSTD_compressBlock()

size_t ZSTD_compressBlock ( ZSTD_CCtx cctx,
void dst,
size_t  dstCapacity,
const void src,
size_t  srcSize 
)

Definition at line 2808 of file zstd_compress.c.

2809 {
2810  DEBUGLOG(5, "ZSTD_compressBlock: srcSize = %u", (unsigned)srcSize);
2811  { size_t const blockSizeMax = ZSTD_getBlockSize(cctx);
2812  RETURN_ERROR_IF(srcSize > blockSizeMax, srcSize_wrong, "input is larger than a block"); }
2813 
2814  return ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 0 /* frame mode */, 0 /* last chunk */);
2815 }
#define DEBUGLOG(l,...)
Definition: debug.h:106
#define RETURN_ERROR_IF(cond, err,...)
Definition: zstd_internal.h:91
GLenum src
Definition: glext.h:6340
GLenum GLenum dst
Definition: glext.h:6340
static size_t ZSTD_compressContinue_internal(ZSTD_CCtx *cctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize, U32 frame, U32 lastFrameChunk)
size_t ZSTD_getBlockSize(const ZSTD_CCtx *cctx)

◆ ZSTD_compressBlock_internal()

static size_t ZSTD_compressBlock_internal ( ZSTD_CCtx zc,
void dst,
size_t  dstCapacity,
const void src,
size_t  srcSize,
U32  frame 
)
static

Definition at line 2414 of file zstd_compress.c.

2417 {
2418  /* This the upper bound for the length of an rle block.
2419  * This isn't the actual upper bound. Finding the real threshold
2420  * needs further investigation.
2421  */
2422  const U32 rleMaxLength = 25;
2423  size_t cSize;
2424  const BYTE* ip = (const BYTE*)src;
2425  BYTE* op = (BYTE*)dst;
2426  DEBUGLOG(5, "ZSTD_compressBlock_internal (dstCapacity=%u, dictLimit=%u, nextToUpdate=%u)",
2427  (unsigned)dstCapacity, (unsigned)zc->blockState.matchState.window.dictLimit,
2428  (unsigned)zc->blockState.matchState.nextToUpdate);
2429 
2430  { const size_t bss = ZSTD_buildSeqStore(zc, src, srcSize);
2431  FORWARD_IF_ERROR(bss, "ZSTD_buildSeqStore failed");
2432  if (bss == ZSTDbss_noCompress) { cSize = 0; goto out; }
2433  }
2434 
2435  if (zc->seqCollector.collectSequences) {
2437  return 0;
2438  }
2439 
2440  /* encode sequences and literals */
2441  cSize = ZSTD_compressSequences(&zc->seqStore,
2443  &zc->appliedParams,
2444  dst, dstCapacity,
2445  srcSize,
2446  zc->entropyWorkspace, HUF_WORKSPACE_SIZE /* statically allocated in resetCCtx */,
2447  zc->bmi2);
2448 
2449  if (frame &&
2450  /* We don't want to emit our first block as a RLE even if it qualifies because
2451  * doing so will cause the decoder (cli only) to throw a "should consume all input error."
2452  * This is only an issue for zstd <= v1.4.3
2453  */
2454  !zc->isFirstBlock &&
2455  cSize < rleMaxLength &&
2456  ZSTD_isRLE(ip, srcSize))
2457  {
2458  cSize = 1;
2459  op[0] = ip[0];
2460  }
2461 
2462 out:
2463  if (!ZSTD_isError(cSize) && cSize > 1) {
2465  }
2466  /* We check that dictionaries have offset codes available for the first
2467  * block. After the first block, the offcode table might not have large
2468  * enough codes to represent the offsets in the data.
2469  */
2470  if (zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode == FSE_repeat_valid)
2471  zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode = FSE_repeat_check;
2472 
2473  return cSize;
2474 }
static int ZSTD_isRLE(const BYTE *ip, size_t length)
#define DEBUGLOG(l,...)
Definition: debug.h:106
#define ZSTD_isError
Definition: zstd_internal.h:46
ZSTD_CCtx_params appliedParams
ZSTD_blockState_t blockState
static size_t ZSTD_buildSeqStore(ZSTD_CCtx *zc, const void *src, size_t srcSize)
Definition: dhcpd.h:61
static FILE * out
Definition: regtests2xml.c:44
UINT op
Definition: effect.c:236
ZSTD_compressedBlockState_t * nextCBlock
ZSTD_matchState_t matchState
GLenum src
Definition: glext.h:6340
unsigned char BYTE
Definition: xxhash.c:193
static void ZSTD_copyBlockSequences(ZSTD_CCtx *zc)
MEM_STATIC size_t ZSTD_compressSequences(seqStore_t *seqStorePtr, const ZSTD_entropyCTables_t *prevEntropy, ZSTD_entropyCTables_t *nextEntropy, const ZSTD_CCtx_params *cctxParams, void *dst, size_t dstCapacity, size_t srcSize, void *entropyWorkspace, size_t entropyWkspSize, int bmi2)
GLenum GLenum dst
Definition: glext.h:6340
static void ZSTD_confirmRepcodesAndEntropyTables(ZSTD_CCtx *zc)
#define FORWARD_IF_ERROR(err,...)
#define HUF_WORKSPACE_SIZE
Definition: huf.h:93
ZSTD_compressedBlockState_t * prevCBlock
unsigned int U32
Definition: xxhash.c:195
SeqCollector seqCollector

Referenced by ZSTD_compress_frameChunk(), and ZSTD_compressContinue_internal().

◆ ZSTD_compressBlock_targetCBlockSize()

static size_t ZSTD_compressBlock_targetCBlockSize ( ZSTD_CCtx zc,
void dst,
size_t  dstCapacity,
const void src,
size_t  srcSize,
U32  lastBlock 
)
static

Definition at line 2531 of file zstd_compress.c.

2535 {
2536  size_t cSize = 0;
2537  const size_t bss = ZSTD_buildSeqStore(zc, src, srcSize);
2538  DEBUGLOG(5, "ZSTD_compressBlock_targetCBlockSize (dstCapacity=%u, dictLimit=%u, nextToUpdate=%u, srcSize=%zu)",
2539  (unsigned)dstCapacity, (unsigned)zc->blockState.matchState.window.dictLimit, (unsigned)zc->blockState.matchState.nextToUpdate, srcSize);
2540  FORWARD_IF_ERROR(bss, "ZSTD_buildSeqStore failed");
2541 
2542  cSize = ZSTD_compressBlock_targetCBlockSize_body(zc, dst, dstCapacity, src, srcSize, bss, lastBlock);
2543  FORWARD_IF_ERROR(cSize, "ZSTD_compressBlock_targetCBlockSize_body failed");
2544 
2545  if (zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode == FSE_repeat_valid)
2546  zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode = FSE_repeat_check;
2547 
2548  return cSize;
2549 }
#define DEBUGLOG(l,...)
Definition: debug.h:106
ZSTD_blockState_t blockState
static size_t ZSTD_buildSeqStore(ZSTD_CCtx *zc, const void *src, size_t srcSize)
ZSTD_matchState_t matchState
GLenum src
Definition: glext.h:6340
GLenum GLenum dst
Definition: glext.h:6340
#define FORWARD_IF_ERROR(err,...)
static size_t ZSTD_compressBlock_targetCBlockSize_body(ZSTD_CCtx *zc, void *dst, size_t dstCapacity, const void *src, size_t srcSize, const size_t bss, U32 lastBlock)
ZSTD_compressedBlockState_t * prevCBlock

Referenced by ZSTD_compress_frameChunk().

◆ ZSTD_compressBlock_targetCBlockSize_body()

static size_t ZSTD_compressBlock_targetCBlockSize_body ( ZSTD_CCtx zc,
void dst,
size_t  dstCapacity,
const void src,
size_t  srcSize,
const size_t  bss,
U32  lastBlock 
)
static

Definition at line 2476 of file zstd_compress.c.

2480 {
2481  DEBUGLOG(6, "Attempting ZSTD_compressSuperBlock()");
2482  if (bss == ZSTDbss_compress) {
2483  if (/* We don't want to emit our first block as a RLE even if it qualifies because
2484  * doing so will cause the decoder (cli only) to throw a "should consume all input error."
2485  * This is only an issue for zstd <= v1.4.3
2486  */
2487  !zc->isFirstBlock &&
2488  ZSTD_maybeRLE(&zc->seqStore) &&
2489  ZSTD_isRLE((BYTE const*)src, srcSize))
2490  {
2491  return ZSTD_rleCompressBlock(dst, dstCapacity, *(BYTE const*)src, srcSize, lastBlock);
2492  }
2493  /* Attempt superblock compression.
2494  *
2495  * Note that compressed size of ZSTD_compressSuperBlock() is not bound by the
2496  * standard ZSTD_compressBound(). This is a problem, because even if we have
2497  * space now, taking an extra byte now could cause us to run out of space later
2498  * and violate ZSTD_compressBound().
2499  *
2500  * Define blockBound(blockSize) = blockSize + ZSTD_blockHeaderSize.
2501  *
2502  * In order to respect ZSTD_compressBound() we must attempt to emit a raw
2503  * uncompressed block in these cases:
2504  * * cSize == 0: Return code for an uncompressed block.
2505  * * cSize == dstSize_tooSmall: We may have expanded beyond blockBound(srcSize).
2506  * ZSTD_noCompressBlock() will return dstSize_tooSmall if we are really out of
2507  * output space.
2508  * * cSize >= blockBound(srcSize): We have expanded the block too much so
2509  * emit an uncompressed block.
2510  */
2511  {
2512  size_t const cSize = ZSTD_compressSuperBlock(zc, dst, dstCapacity, src, srcSize, lastBlock);
2513  if (cSize != ERROR(dstSize_tooSmall)) {
2514  size_t const maxCSize = srcSize - ZSTD_minGain(srcSize, zc->appliedParams.cParams.strategy);
2515  FORWARD_IF_ERROR(cSize, "ZSTD_compressSuperBlock failed");
2516  if (cSize != 0 && cSize < maxCSize + ZSTD_blockHeaderSize) {
2518  return cSize;
2519  }
2520  }
2521  }
2522  }
2523 
2524  DEBUGLOG(6, "Resorting to ZSTD_noCompressBlock()");
2525  /* Superblock compression failed, attempt to emit a single no compress block.
2526  * The decoder will be able to stream this block since it is uncompressed.
2527  */
2528  return ZSTD_noCompressBlock(dst, dstCapacity, src, srcSize, lastBlock);
2529 }
static int ZSTD_isRLE(const BYTE *ip, size_t length)
#define ERROR(name)
Definition: error_private.h:53
MEM_STATIC size_t ZSTD_noCompressBlock(void *dst, size_t dstCapacity, const void *src, size_t srcSize, U32 lastBlock)
MEM_STATIC size_t ZSTD_minGain(size_t srcSize, ZSTD_strategy strat)
#define DEBUGLOG(l,...)
Definition: debug.h:106
static const size_t ZSTD_blockHeaderSize
size_t ZSTD_compressSuperBlock(ZSTD_CCtx *zc, void *dst, size_t dstCapacity, void const *src, size_t srcSize, unsigned lastBlock)
ZSTD_CCtx_params appliedParams
GLenum src
Definition: glext.h:6340
unsigned char BYTE
Definition: xxhash.c:193
MEM_STATIC size_t ZSTD_rleCompressBlock(void *dst, size_t dstCapacity, BYTE src, size_t srcSize, U32 lastBlock)
GLenum GLenum dst
Definition: glext.h:6340
static void ZSTD_confirmRepcodesAndEntropyTables(ZSTD_CCtx *zc)
#define FORWARD_IF_ERROR(err,...)
static int ZSTD_maybeRLE(seqStore_t const *seqStore)

Referenced by ZSTD_compressBlock_targetCBlockSize().

◆ ZSTD_compressBound()

size_t ZSTD_compressBound ( size_t  srcSize)

maximum compressed size in worst case single-pass scenario

Definition at line 44 of file zstd_compress.c.

44  {
45  return ZSTD_COMPRESSBOUND(srcSize);
46 }
#define ZSTD_COMPRESSBOUND(srcSize)
Definition: zstd.h:174

Referenced by ZSTD_compressStream_generic(), ZSTD_CStreamOutSize(), ZSTD_estimateCStreamSize_usingCCtxParams(), ZSTD_getSequences(), and ZSTD_resetCCtx_internal().

◆ ZSTD_compressCCtx()

size_t ZSTD_compressCCtx ( ZSTD_CCtx cctx,
void dst,
size_t  dstCapacity,
const void src,
size_t  srcSize,
int  compressionLevel 
)

ZSTD_compressCCtx() : Same as ZSTD_compress(), using an explicit ZSTD_CCtx. Important : in order to behave similarly to ZSTD_compress(), this function compresses at requested compression level, ignoring any other parameter . If any advanced parameter was set using the advanced API, they will all be reset. Only compressionLevel remains.

Definition at line 3297 of file zstd_compress.c.

3301 {
3302  DEBUGLOG(4, "ZSTD_compressCCtx (srcSize=%u)", (unsigned)srcSize);
3303  assert(cctx != NULL);
3304  return ZSTD_compress_usingDict(cctx, dst, dstCapacity, src, srcSize, NULL, 0, compressionLevel);
3305 }
#define assert(x)
Definition: debug.h:53
#define DEBUGLOG(l,...)
Definition: debug.h:106
GLenum src
Definition: glext.h:6340
size_t ZSTD_compress_usingDict(ZSTD_CCtx *cctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize, const void *dict, size_t dictSize, int compressionLevel)
GLenum GLenum dst
Definition: glext.h:6340
#define NULL
Definition: types.h:112

Referenced by ZSTD_compress().

◆ ZSTD_compressContinue()

size_t ZSTD_compressContinue ( ZSTD_CCtx cctx,
void dst,
size_t  dstCapacity,
const void src,
size_t  srcSize 
)

Definition at line 2792 of file zstd_compress.c.

2795 {
2796  DEBUGLOG(5, "ZSTD_compressContinue (srcSize=%u)", (unsigned)srcSize);
2797  return ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 1 /* frame mode */, 0 /* last chunk */);
2798 }
#define DEBUGLOG(l,...)
Definition: debug.h:106
GLenum src
Definition: glext.h:6340
GLenum GLenum dst
Definition: glext.h:6340
static size_t ZSTD_compressContinue_internal(ZSTD_CCtx *cctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize, U32 frame, U32 lastFrameChunk)

Referenced by ZSTD_compressStream_generic().

◆ ZSTD_compressContinue_internal()

static size_t ZSTD_compressContinue_internal ( ZSTD_CCtx cctx,
void dst,
size_t  dstCapacity,
const void src,
size_t  srcSize,
U32  frame,
U32  lastFrameChunk 
)
static

Definition at line 2732 of file zstd_compress.c.

2736 {
2737  ZSTD_matchState_t* const ms = &cctx->blockState.matchState;
2738  size_t fhSize = 0;
2739 
2740  DEBUGLOG(5, "ZSTD_compressContinue_internal, stage: %u, srcSize: %u",
2741  cctx->stage, (unsigned)srcSize);
2742  RETURN_ERROR_IF(cctx->stage==ZSTDcs_created, stage_wrong,
2743  "missing init (ZSTD_compressBegin)");
2744 
2745  if (frame && (cctx->stage==ZSTDcs_init)) {
2746  fhSize = ZSTD_writeFrameHeader(dst, dstCapacity, &cctx->appliedParams,
2747  cctx->pledgedSrcSizePlusOne-1, cctx->dictID);
2748  FORWARD_IF_ERROR(fhSize, "ZSTD_writeFrameHeader failed");
2749  assert(fhSize <= dstCapacity);
2750  dstCapacity -= fhSize;
2751  dst = (char*)dst + fhSize;
2752  cctx->stage = ZSTDcs_ongoing;
2753  }
2754 
2755  if (!srcSize) return fhSize; /* do not generate an empty block if no input */
2756 
2757  if (!ZSTD_window_update(&ms->window, src, srcSize)) {
2758  ms->nextToUpdate = ms->window.dictLimit;
2759  }
2760  if (cctx->appliedParams.ldmParams.enableLdm) {
2761  ZSTD_window_update(&cctx->ldmState.window, src, srcSize);
2762  }
2763 
2764  if (!frame) {
2765  /* overflow check and correction for block mode */
2767  ms, &cctx->workspace, &cctx->appliedParams,
2768  src, (BYTE const*)src + srcSize);
2769  }
2770 
2771  DEBUGLOG(5, "ZSTD_compressContinue_internal (blockSize=%u)", (unsigned)cctx->blockSize);
2772  { size_t const cSize = frame ?
2773  ZSTD_compress_frameChunk (cctx, dst, dstCapacity, src, srcSize, lastFrameChunk) :
2774  ZSTD_compressBlock_internal (cctx, dst, dstCapacity, src, srcSize, 0 /* frame */);
2775  FORWARD_IF_ERROR(cSize, "%s", frame ? "ZSTD_compress_frameChunk failed" : "ZSTD_compressBlock_internal failed");
2776  cctx->consumedSrcSize += srcSize;
2777  cctx->producedCSize += (cSize + fhSize);
2778  assert(!(cctx->appliedParams.fParams.contentSizeFlag && cctx->pledgedSrcSizePlusOne == 0));
2779  if (cctx->pledgedSrcSizePlusOne != 0) { /* control src size */
2780  ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_UNKNOWN == (unsigned long long)-1);
2782  cctx->consumedSrcSize+1 > cctx->pledgedSrcSizePlusOne,
2783  srcSize_wrong,
2784  "error : pledgedSrcSize = %u, while realSrcSize >= %u",
2785  (unsigned)cctx->pledgedSrcSizePlusOne-1,
2786  (unsigned)cctx->consumedSrcSize);
2787  }
2788  return cSize + fhSize;
2789  }
2790 }
unsigned long long consumedSrcSize
unsigned long long pledgedSrcSizePlusOne
#define ZSTD_CONTENTSIZE_UNKNOWN
Definition: zstd.h:152
#define assert(x)
Definition: debug.h:53
static size_t ZSTD_writeFrameHeader(void *dst, size_t dstCapacity, const ZSTD_CCtx_params *params, U64 pledgedSrcSize, U32 dictID)
static size_t ZSTD_compress_frameChunk(ZSTD_CCtx *cctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize, U32 lastFrameChunk)
#define ZSTD_STATIC_ASSERT(c)
Definition: zstd_internal.h:45
#define DEBUGLOG(l,...)
Definition: debug.h:106
static size_t ZSTD_compressBlock_internal(ZSTD_CCtx *zc, void *dst, size_t dstCapacity, const void *src, size_t srcSize, U32 frame)
ZSTD_compressionStage_e stage
ZSTD_CCtx_params appliedParams
ZSTD_blockState_t blockState
#define RETURN_ERROR_IF(cond, err,...)
Definition: zstd_internal.h:91
static void ZSTD_overflowCorrectIfNeeded(ZSTD_matchState_t *ms, ZSTD_cwksp *ws, ZSTD_CCtx_params const *params, void const *ip, void const *iend)
ZSTD_matchState_t matchState
GLenum src
Definition: glext.h:6340
unsigned char BYTE
Definition: xxhash.c:193
GLenum GLenum dst
Definition: glext.h:6340
MEM_STATIC U32 ZSTD_window_update(ZSTD_window_t *window, void const *src, size_t srcSize)
#define FORWARD_IF_ERROR(err,...)
unsigned long long producedCSize
ZSTD_window_t window

Referenced by ZSTD_compressBlock(), ZSTD_compressContinue(), and ZSTD_compressEnd().

◆ ZSTD_compressEnd()

size_t ZSTD_compressEnd ( ZSTD_CCtx cctx,
void dst,
size_t  dstCapacity,
const void src,
size_t  srcSize 
)

Definition at line 3212 of file zstd_compress.c.

3215 {
3216  size_t endResult;
3217  size_t const cSize = ZSTD_compressContinue_internal(cctx,
3218  dst, dstCapacity, src, srcSize,
3219  1 /* frame mode */, 1 /* last chunk */);
3220  FORWARD_IF_ERROR(cSize, "ZSTD_compressContinue_internal failed");
3221  endResult = ZSTD_writeEpilogue(cctx, (char*)dst + cSize, dstCapacity-cSize);
3222  FORWARD_IF_ERROR(endResult, "ZSTD_writeEpilogue failed");
3223  assert(!(cctx->appliedParams.fParams.contentSizeFlag && cctx->pledgedSrcSizePlusOne == 0));
3224  if (cctx->pledgedSrcSizePlusOne != 0) { /* control src size */
3225  ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_UNKNOWN == (unsigned long long)-1);
3226  DEBUGLOG(4, "end of frame : controlling src size");
3228  cctx->pledgedSrcSizePlusOne != cctx->consumedSrcSize+1,
3229  srcSize_wrong,
3230  "error : pledgedSrcSize = %u, while realSrcSize = %u",
3231  (unsigned)cctx->pledgedSrcSizePlusOne-1,
3232  (unsigned)cctx->consumedSrcSize);
3233  }
3234  return cSize + endResult;
3235 }
unsigned long long consumedSrcSize
unsigned long long pledgedSrcSizePlusOne
#define ZSTD_CONTENTSIZE_UNKNOWN
Definition: zstd.h:152
#define assert(x)
Definition: debug.h:53
#define ZSTD_STATIC_ASSERT(c)
Definition: zstd_internal.h:45
#define DEBUGLOG(l,...)
Definition: debug.h:106
ZSTD_CCtx_params appliedParams
#define RETURN_ERROR_IF(cond, err,...)
Definition: zstd_internal.h:91
GLenum src
Definition: glext.h:6340
GLenum GLenum dst
Definition: glext.h:6340
static size_t ZSTD_writeEpilogue(ZSTD_CCtx *cctx, void *dst, size_t dstCapacity)
#define FORWARD_IF_ERROR(err,...)
static size_t ZSTD_compressContinue_internal(ZSTD_CCtx *cctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize, U32 frame, U32 lastFrameChunk)

Referenced by ZSTD_compress_advanced_internal(), ZSTD_compress_usingCDict_advanced(), and ZSTD_compressStream_generic().

◆ ZSTD_compressSequences()

MEM_STATIC size_t ZSTD_compressSequences ( seqStore_t seqStorePtr,
const ZSTD_entropyCTables_t prevEntropy,
ZSTD_entropyCTables_t nextEntropy,
const ZSTD_CCtx_params *  cctxParams,
void dst,
size_t  dstCapacity,
size_t  srcSize,
void entropyWorkspace,
size_t  entropyWkspSize,
int  bmi2 
)

Definition at line 2151 of file zstd_compress.c.

2159 {
2160  size_t const cSize = ZSTD_compressSequences_internal(
2161  seqStorePtr, prevEntropy, nextEntropy, cctxParams,
2162  dst, dstCapacity,
2163  entropyWorkspace, entropyWkspSize, bmi2);
2164  if (cSize == 0) return 0;
2165  /* When srcSize <= dstCapacity, there is enough space to write a raw uncompressed block.
2166  * Since we ran out of space, block must be not compressible, so fall back to raw uncompressed block.
2167  */
2168  if ((cSize == ERROR(dstSize_tooSmall)) & (srcSize <= dstCapacity))
2169  return 0; /* block not compressed */
2170  FORWARD_IF_ERROR(cSize, "ZSTD_compressSequences_internal failed");
2171 
2172  /* Check compressibility */
2173  { size_t const maxCSize = srcSize - ZSTD_minGain(srcSize, cctxParams->cParams.strategy);
2174  if (cSize >= maxCSize) return 0; /* block not compressed */
2175  }
2176 
2177  return cSize;
2178 }
#define ERROR(name)
Definition: error_private.h:53
MEM_STATIC size_t ZSTD_minGain(size_t srcSize, ZSTD_strategy strat)
GLenum GLenum dst
Definition: glext.h:6340
#define FORWARD_IF_ERROR(err,...)
MEM_STATIC size_t ZSTD_compressSequences_internal(seqStore_t *seqStorePtr, const ZSTD_entropyCTables_t *prevEntropy, ZSTD_entropyCTables_t *nextEntropy, const ZSTD_CCtx_params *cctxParams, void *dst, size_t dstCapacity, void *entropyWorkspace, size_t entropyWkspSize, const int bmi2)

Referenced by ZSTD_compressBlock_internal().

◆ ZSTD_compressSequences_internal()

MEM_STATIC size_t ZSTD_compressSequences_internal ( seqStore_t seqStorePtr,
const ZSTD_entropyCTables_t prevEntropy,
ZSTD_entropyCTables_t nextEntropy,
const ZSTD_CCtx_params *  cctxParams,
void dst,
size_t  dstCapacity,
void entropyWorkspace,
size_t  entropyWkspSize,
const int  bmi2 
)

Definition at line 1964 of file zstd_compress.c.

1971 {
1972  const int longOffsets = cctxParams->cParams.windowLog > STREAM_ACCUMULATOR_MIN;
1973  ZSTD_strategy const strategy = cctxParams->cParams.strategy;
1974  unsigned count[MaxSeq+1];
1975  FSE_CTable* CTable_LitLength = nextEntropy->fse.litlengthCTable;
1976  FSE_CTable* CTable_OffsetBits = nextEntropy->fse.offcodeCTable;
1977  FSE_CTable* CTable_MatchLength = nextEntropy->fse.matchlengthCTable;
1978  U32 LLtype, Offtype, MLtype; /* compressed, raw or rle */
1979  const seqDef* const sequences = seqStorePtr->sequencesStart;
1980  const BYTE* const ofCodeTable = seqStorePtr->ofCode;
1981  const BYTE* const llCodeTable = seqStorePtr->llCode;
1982  const BYTE* const mlCodeTable = seqStorePtr->mlCode;
1983  BYTE* const ostart = (BYTE*)dst;
1984  BYTE* const oend = ostart + dstCapacity;
1985  BYTE* op = ostart;
1986  size_t const nbSeq = (size_t)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
1987  BYTE* seqHead;
1988  BYTE* lastNCount = NULL;
1989 
1990  DEBUGLOG(5, "ZSTD_compressSequences_internal (nbSeq=%zu)", nbSeq);
1992 
1993  /* Compress literals */
1994  { const BYTE* const literals = seqStorePtr->litStart;
1995  size_t const litSize = (size_t)(seqStorePtr->lit - literals);
1996  size_t const cSize = ZSTD_compressLiterals(
1997  &prevEntropy->huf, &nextEntropy->huf,
1998  cctxParams->cParams.strategy,
1999  ZSTD_disableLiteralsCompression(cctxParams),
2000  op, dstCapacity,
2001  literals, litSize,
2002  entropyWorkspace, entropyWkspSize,
2003  bmi2);
2004  FORWARD_IF_ERROR(cSize, "ZSTD_compressLiterals failed");
2005  assert(cSize <= dstCapacity);
2006  op += cSize;
2007  }
2008 
2009  /* Sequences Header */
2010  RETURN_ERROR_IF((oend-op) < 3 /*max nbSeq Size*/ + 1 /*seqHead*/,
2011  dstSize_tooSmall, "Can't fit seq hdr in output buf!");
2012  if (nbSeq < 128) {
2013  *op++ = (BYTE)nbSeq;
2014  } else if (nbSeq < LONGNBSEQ) {
2015  op[0] = (BYTE)((nbSeq>>8) + 0x80);
2016  op[1] = (BYTE)nbSeq;
2017  op+=2;
2018  } else {
2019  op[0]=0xFF;
2020  MEM_writeLE16(op+1, (U16)(nbSeq - LONGNBSEQ));
2021  op+=3;
2022  }
2023  assert(op <= oend);
2024  if (nbSeq==0) {
2025  /* Copy the old tables over as if we repeated them */
2026  memcpy(&nextEntropy->fse, &prevEntropy->fse, sizeof(prevEntropy->fse));
2027  return (size_t)(op - ostart);
2028  }
2029 
2030  /* seqHead : flags for FSE encoding type */
2031  seqHead = op++;
2032  assert(op <= oend);
2033 
2034  /* convert length/distances into codes */
2035  ZSTD_seqToCodes(seqStorePtr);
2036  /* build CTable for Literal Lengths */
2037  { unsigned max = MaxLL;
2038  size_t const mostFrequent = HIST_countFast_wksp(count, &max, llCodeTable, nbSeq, entropyWorkspace, entropyWkspSize); /* can't fail */
2039  DEBUGLOG(5, "Building LL table");
2040  nextEntropy->fse.litlength_repeatMode = prevEntropy->fse.litlength_repeatMode;
2041  LLtype = ZSTD_selectEncodingType(&nextEntropy->fse.litlength_repeatMode,
2042  count, max, mostFrequent, nbSeq,
2043  LLFSELog, prevEntropy->fse.litlengthCTable,
2045  ZSTD_defaultAllowed, strategy);
2047  assert(!(LLtype < set_compressed && nextEntropy->fse.litlength_repeatMode != FSE_repeat_none)); /* We don't copy tables */
2048  { size_t const countSize = ZSTD_buildCTable(
2049  op, (size_t)(oend - op),
2050  CTable_LitLength, LLFSELog, (symbolEncodingType_e)LLtype,
2051  count, max, llCodeTable, nbSeq,
2053  prevEntropy->fse.litlengthCTable,
2054  sizeof(prevEntropy->fse.litlengthCTable),
2055  entropyWorkspace, entropyWkspSize);
2056  FORWARD_IF_ERROR(countSize, "ZSTD_buildCTable for LitLens failed");
2057  if (LLtype == set_compressed)
2058  lastNCount = op;
2059  op += countSize;
2060  assert(op <= oend);
2061  } }
2062  /* build CTable for Offsets */
2063  { unsigned max = MaxOff;
2064  size_t const mostFrequent = HIST_countFast_wksp(
2065  count, &max, ofCodeTable, nbSeq, entropyWorkspace, entropyWkspSize); /* can't fail */
2066  /* We can only use the basic table if max <= DefaultMaxOff, otherwise the offsets are too large */
2068  DEBUGLOG(5, "Building OF table");
2069  nextEntropy->fse.offcode_repeatMode = prevEntropy->fse.offcode_repeatMode;
2070  Offtype = ZSTD_selectEncodingType(&nextEntropy->fse.offcode_repeatMode,
2071  count, max, mostFrequent, nbSeq,
2072  OffFSELog, prevEntropy->fse.offcodeCTable,
2074  defaultPolicy, strategy);
2075  assert(!(Offtype < set_compressed && nextEntropy->fse.offcode_repeatMode != FSE_repeat_none)); /* We don't copy tables */
2076  { size_t const countSize = ZSTD_buildCTable(
2077  op, (size_t)(oend - op),
2078  CTable_OffsetBits, OffFSELog, (symbolEncodingType_e)Offtype,
2079  count, max, ofCodeTable, nbSeq,
2081  prevEntropy->fse.offcodeCTable,
2082  sizeof(prevEntropy->fse.offcodeCTable),
2083  entropyWorkspace, entropyWkspSize);
2084  FORWARD_IF_ERROR(countSize, "ZSTD_buildCTable for Offsets failed");
2085  if (Offtype == set_compressed)
2086  lastNCount = op;
2087  op += countSize;
2088  assert(op <= oend);
2089  } }
2090  /* build CTable for MatchLengths */
2091  { unsigned max = MaxML;
2092  size_t const mostFrequent = HIST_countFast_wksp(
2093  count, &max, mlCodeTable, nbSeq, entropyWorkspace, entropyWkspSize); /* can't fail */
2094  DEBUGLOG(5, "Building ML table (remaining space : %i)", (int)(oend-op));
2095  nextEntropy->fse.matchlength_repeatMode = prevEntropy->fse.matchlength_repeatMode;
2096  MLtype = ZSTD_selectEncodingType(&nextEntropy->fse.matchlength_repeatMode,
2097  count, max, mostFrequent, nbSeq,
2098  MLFSELog, prevEntropy->fse.matchlengthCTable,
2100  ZSTD_defaultAllowed, strategy);
2101  assert(!(MLtype < set_compressed && nextEntropy->fse.matchlength_repeatMode != FSE_repeat_none)); /* We don't copy tables */
2102  { size_t const countSize = ZSTD_buildCTable(
2103  op, (size_t)(oend - op),
2104  CTable_MatchLength, MLFSELog, (symbolEncodingType_e)MLtype,
2105  count, max, mlCodeTable, nbSeq,
2107  prevEntropy->fse.matchlengthCTable,
2108  sizeof(prevEntropy->fse.matchlengthCTable),
2109  entropyWorkspace, entropyWkspSize);
2110  FORWARD_IF_ERROR(countSize, "ZSTD_buildCTable for MatchLengths failed");
2111  if (MLtype == set_compressed)
2112  lastNCount = op;
2113  op += countSize;
2114  assert(op <= oend);
2115  } }
2116 
2117  *seqHead = (BYTE)((LLtype<<6) + (Offtype<<4) + (MLtype<<2));
2118 
2119  { size_t const bitstreamSize = ZSTD_encodeSequences(
2120  op, (size_t)(oend - op),
2121  CTable_MatchLength, mlCodeTable,
2122  CTable_OffsetBits, ofCodeTable,
2123  CTable_LitLength, llCodeTable,
2124  sequences, nbSeq,
2125  longOffsets, bmi2);
2126  FORWARD_IF_ERROR(bitstreamSize, "ZSTD_encodeSequences failed");
2127  op += bitstreamSize;
2128  assert(op <= oend);
2129  /* zstd versions <= 1.3.4 mistakenly report corruption when
2130  * FSE_readNCount() receives a buffer < 4 bytes.
2131  * Fixed by https://github.com/facebook/zstd/pull/1146.
2132  * This can happen when the last set_compressed table present is 2
2133  * bytes and the bitstream is only one byte.
2134  * In this exceedingly rare case, we will simply emit an uncompressed
2135  * block, since it isn't worth optimizing.
2136  */
2137  if (lastNCount && (op - lastNCount) < 4) {
2138  /* NCountSize >= 2 && bitstreamSize > 0 ==> lastCountSize == 3 */
2139  assert(op - lastNCount == 3);
2140  DEBUGLOG(5, "Avoiding bug in zstd decoder in versions <= 1.3.4 by "
2141  "emitting an uncompressed block.");
2142  return 0;
2143  }
2144  }
2145 
2146  DEBUGLOG(5, "compressed block size : %u", (unsigned)(op - ostart));
2147  return (size_t)(op - ostart);
2148 }
MEM_STATIC void MEM_writeLE16(void *memPtr, U16 val)
Definition: mem.h:324
symbolEncodingType_e
#define max(a, b)
Definition: svc.c:63
#define MaxSeq
size_t ZSTD_buildCTable(void *dst, size_t dstCapacity, FSE_CTable *nextCTable, U32 FSELog, symbolEncodingType_e type, unsigned *count, U32 max, const BYTE *codeTable, size_t nbSeq, const S16 *defaultNorm, U32 defaultNormLog, U32 defaultMax, const FSE_CTable *prevCTable, size_t prevCTableSize, void *entropyWorkspace, size_t entropyWorkspaceSize)
BYTE * ofCode
GLuint GLuint GLsizei count
Definition: gl.h:1545
#define assert(x)
Definition: debug.h:53
static const U32 ML_defaultNormLog
unsigned FSE_CTable
Definition: fse.h:160
seqDef * sequencesStart
size_t ZSTD_compressLiterals(ZSTD_hufCTables_t const *prevHuf, ZSTD_hufCTables_t *nextHuf, ZSTD_strategy strategy, int disableLiteralCompression, void *dst, size_t dstCapacity, const void *src, size_t srcSize, void *entropyWorkspace, size_t entropyWorkspaceSize, const int bmi2)
void ZSTD_seqToCodes(const seqStore_t *seqStorePtr)
#define ZSTD_STATIC_ASSERT(c)
Definition: zstd_internal.h:45
static const S16 LL_defaultNorm[MaxLL+1]
#define DEBUGLOG(l,...)
Definition: debug.h:106
seqDef * sequences
#define DefaultMaxOff
static const U32 OF_defaultNormLog
ZSTD_defaultPolicy_e
#define MaxML
#define MLFSELog
FSE_CTable offcodeCTable[FSE_CTABLE_SIZE_U32(OffFSELog, MaxOff)]
__kernel_size_t size_t
Definition: linux.h:237
FSE_CTable litlengthCTable[FSE_CTABLE_SIZE_U32(LLFSELog, MaxLL)]
#define RETURN_ERROR_IF(cond, err,...)
Definition: zstd_internal.h:91
#define OffFSELog
UINT op
Definition: effect.c:236
static const U32 LL_defaultNormLog
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define LONGNBSEQ
BYTE * mlCode
unsigned char BYTE
Definition: xxhash.c:193
static struct msg_sequence * sequences[NUM_MSG_SEQUENCES]
Definition: button.c:54
static const S16 OF_defaultNorm[DefaultMaxOff+1]
T MAX(T a, T b)
Definition: polytest.cpp:85
#define STREAM_ACCUMULATOR_MIN
Definition: bitstream.h:47
#define MaxOff
unsigned short U16
Definition: xxhash.c:194
symbolEncodingType_e ZSTD_selectEncodingType(FSE_repeat *repeatMode, unsigned const *count, unsigned const max, size_t const mostFrequent, size_t nbSeq, unsigned const FSELog, FSE_CTable const *prevCTable, short const *defaultNorm, U32 defaultNormLog, ZSTD_defaultPolicy_e const isDefaultAllowed, ZSTD_strategy const strategy)
static const S16 ML_defaultNorm[MaxML+1]
FSE_CTable matchlengthCTable[FSE_CTABLE_SIZE_U32(MLFSELog, MaxML)]
GLenum GLenum dst
Definition: glext.h:6340
#define NULL
Definition: types.h:112
#define FORWARD_IF_ERROR(err,...)
#define MaxLL
#define HUF_WORKSPACE_SIZE
Definition: huf.h:93
#define LLFSELog
BYTE * llCode
ZSTD_strategy
Definition: zstd.h:251
unsigned int U32
Definition: xxhash.c:195
size_t ZSTD_encodeSequences(void *dst, size_t dstCapacity, FSE_CTable const *CTable_MatchLength, BYTE const *mlCodeTable, FSE_CTable const *CTable_OffsetBits, BYTE const *ofCodeTable, FSE_CTable const *CTable_LitLength, BYTE const *llCodeTable, seqDef const *sequences, size_t nbSeq, int longOffsets, int bmi2)
size_t HIST_countFast_wksp(unsigned *count, unsigned *maxSymbolValuePtr, const void *source, size_t sourceSize, void *workSpace, size_t workSpaceSize)
Definition: hist.c:144
BYTE * litStart
MEM_STATIC int ZSTD_disableLiteralsCompression(const ZSTD_CCtx_params *cctxParams)

Referenced by ZSTD_compressSequences().

◆ ZSTD_compressStream()

size_t ZSTD_compressStream ( ZSTD_CStream zcs,
ZSTD_outBuffer output,
ZSTD_inBuffer input 
)

Alternative for ZSTD_compressStream2(zcs, output, input, ZSTD_e_continue). NOTE: The return value is different. ZSTD_compressStream() returns a hint for the next read size (if non-zero and not an error). ZSTD_compressStream2() returns the minimum nb of bytes left to flush (if non-zero and not an error).

Definition at line 3956 of file zstd_compress.c.

3957 {
3959  return ZSTD_nextInputSizeHint_MTorST(zcs);
3960 }
static size_t ZSTD_nextInputSizeHint_MTorST(const ZSTD_CCtx *cctx)
static UCHAR ULONG UCHAR ULONG UCHAR * output
Definition: bcrypt.c:29
GLenum GLenum GLenum input
Definition: glext.h:9031
#define FORWARD_IF_ERROR(err,...)
size_t ZSTD_compressStream2(ZSTD_CCtx *cctx, ZSTD_outBuffer *output, ZSTD_inBuffer *input, ZSTD_EndDirective endOp)

Referenced by zstd_compress().

◆ ZSTD_compressStream2()

size_t ZSTD_compressStream2 ( ZSTD_CCtx cctx,
ZSTD_outBuffer output,
ZSTD_inBuffer input,
ZSTD_EndDirective  endOp 
)

ZSTD_compressStream2() : Behaves about the same as ZSTD_compressStream, with additional control on end directive.

  • Compression parameters are pushed into CCtx before starting compression, using ZSTD_CCtx_set*()
  • Compression parameters cannot be changed once compression is started (save a list of exceptions in multi-threading mode)
  • output->pos must be <= dstCapacity, input->pos must be <= srcSize
  • output->pos and input->pos will be updated. They are guaranteed to remain below their respective limit.
  • When nbWorkers==0 (default), function is blocking : it completes its job before returning to caller.
  • When nbWorkers>=1, function is non-blocking : it just acquires a copy of input, and distributes jobs to internal worker threads, flush whatever is available, and then immediately returns, just indicating that there is some data remaining to be flushed. The function nonetheless guarantees forward progress : it will return only after it reads or write at least 1+ byte.
  • Exception : if the first call requests a ZSTD_e_end directive and provides enough dstCapacity, the function delegates to ZSTD_compress2() which is always blocking.
  • Returns
    provides a minimum amount of data remaining to be flushed from internal buffers or an error code, which can be tested using ZSTD_isError(). if
    != 0, flush is not fully completed, there is still some data left within internal buffers. This is useful for ZSTD_e_flush, since in this case more flushes are necessary to empty all buffers. For ZSTD_e_end,
    == 0 when internal buffers are fully flushed and frame is completed.
  • after a ZSTD_e_end directive, if internal buffer is not fully flushed (
    Returns
    != 0), only ZSTD_e_end or ZSTD_e_flush operations are allowed. Before starting a new compression job, or changing compression parameters, it is required to fully flush internal buffers.

Definition at line 3963 of file zstd_compress.c.

3967 {
3968  DEBUGLOG(5, "ZSTD_compressStream2, endOp=%u ", (unsigned)endOp);
3969  /* check conditions */
3970  RETURN_ERROR_IF(output->pos > output->size, GENERIC, "invalid buffer");
3971  RETURN_ERROR_IF(input->pos > input->size, GENERIC, "invalid buffer");
3972  assert(cctx!=NULL);
3973 
3974  /* transparent initialization stage */
3975  if (cctx->streamStage == zcss_init) {
3976  ZSTD_CCtx_params params = cctx->requestedParams;
3977  ZSTD_prefixDict const prefixDict = cctx->prefixDict;
3978  FORWARD_IF_ERROR( ZSTD_initLocalDict(cctx) , ""); /* Init the local dict if present. */
3979  memset(&cctx->prefixDict, 0, sizeof(cctx->prefixDict)); /* single usage */
3980  assert(prefixDict.dict==NULL || cctx->cdict==NULL); /* only one can be set */
3981  DEBUGLOG(4, "ZSTD_compressStream2 : transparent init stage");
3982  if (endOp == ZSTD_e_end) cctx->pledgedSrcSizePlusOne = input->size + 1; /* auto-fix pledgedSrcSize */
3984  &cctx->requestedParams, cctx->pledgedSrcSizePlusOne-1, 0 /*dictSize*/);
3985 
3986 
3987 #ifdef ZSTD_MULTITHREAD
3988  if ((cctx->pledgedSrcSizePlusOne-1) <= ZSTDMT_JOBSIZE_MIN) {
3989  params.nbWorkers = 0; /* do not invoke multi-threading when src size is too small */
3990  }
3991  if (params.nbWorkers > 0) {
3992  /* mt context creation */
3993  if (cctx->mtctx == NULL) {
3994  DEBUGLOG(4, "ZSTD_compressStream2: creating new mtctx for nbWorkers=%u",
3995  params.nbWorkers);
3996  cctx->mtctx = ZSTDMT_createCCtx_advanced((U32)params.nbWorkers, cctx->customMem);
3997  RETURN_ERROR_IF(cctx->mtctx == NULL, memory_allocation, "NULL pointer!");
3998  }
3999  /* mt compression */
4000  DEBUGLOG(4, "call ZSTDMT_initCStream_internal as nbWorkers=%u", params.nbWorkers);
4001  FORWARD_IF_ERROR( ZSTDMT_initCStream_internal(
4002  cctx->mtctx,
4003  prefixDict.dict, prefixDict.dictSize, prefixDict.dictContentType,
4004  cctx->cdict, params, cctx->pledgedSrcSizePlusOne-1) , "");
4005  cctx->streamStage = zcss_load;
4006  cctx->appliedParams.nbWorkers = params.nbWorkers;
4007  } else
4008 #endif
4010  prefixDict.dict, prefixDict.dictSize, prefixDict.dictContentType,
4011  cctx->cdict,
4012  params, cctx->pledgedSrcSizePlusOne-1) , "");
4013  assert(cctx->streamStage == zcss_load);
4014  assert(cctx->appliedParams.nbWorkers == 0);
4015  } }
4016  /* end of transparent initialization stage */
4017 
4018  /* compression stage */
4019 #ifdef ZSTD_MULTITHREAD
4020  if (cctx->appliedParams.nbWorkers > 0) {
4021  int const forceMaxProgress = (endOp == ZSTD_e_flush || endOp == ZSTD_e_end);
4022  size_t flushMin;
4023  assert(forceMaxProgress || endOp == ZSTD_e_continue /* Protection for a new flush type */);
4024  if (cctx->cParamsChanged) {
4025  ZSTDMT_updateCParams_whileCompressing(cctx->mtctx, &cctx->requestedParams);
4026  cctx->cParamsChanged = 0;
4027  }
4028  do {
4029  flushMin = ZSTDMT_compressStream_generic(cctx->mtctx, output, input, endOp);
4030  if ( ZSTD_isError(flushMin)
4031  || (endOp == ZSTD_e_end && flushMin == 0) ) { /* compression completed */
4033  }
4034  FORWARD_IF_ERROR(flushMin, "ZSTDMT_compressStream_generic failed");
4035  } while (forceMaxProgress && flushMin != 0 && output->pos < output->size);
4036  DEBUGLOG(5, "completed ZSTD_compressStream2 delegating to ZSTDMT_compressStream_generic");
4037  /* Either we don't require maximum forward progress, we've finished the
4038  * flush, or we are out of output space.
4039  */
4040  assert(!forceMaxProgress || flushMin == 0 || output->pos == output->size);
4041  return flushMin;
4042  }
4043 #endif
4045  DEBUGLOG(5, "completed ZSTD_compressStream2");
4046  return cctx->outBuffContentSize - cctx->outBuffFlushedSize; /* remaining to flush */
4047 }
static UCHAR ULONG UCHAR ULONG UCHAR * output
Definition: bcrypt.c:29
unsigned long long pledgedSrcSizePlusOne
static size_t ZSTD_compressStream_generic(ZSTD_CStream *zcs, ZSTD_outBuffer *output, ZSTD_inBuffer *input, ZSTD_EndDirective const flushMode)
#define assert(x)
Definition: debug.h:53
ZSTD_prefixDict prefixDict
#define DEBUGLOG(l,...)
Definition: debug.h:106
#define ZSTD_isError
Definition: zstd_internal.h:46
GLenum const GLfloat * params
Definition: glext.h:5645
ZSTD_CCtx_params appliedParams
#define RETURN_ERROR_IF(cond, err,...)
Definition: zstd_internal.h:91
size_t ZSTD_CCtx_reset(ZSTD_CCtx *cctx, ZSTD_ResetDirective reset)
ZSTD_dictContentType_e dictContentType
GLenum GLenum GLenum input
Definition: glext.h:9031
ZSTD_compressionParameters ZSTD_getCParamsFromCCtxParams(const ZSTD_CCtx_params *CCtxParams, U64 srcSizeHint, size_t dictSize)
const ZSTD_CDict * cdict
#define NULL
Definition: types.h:112
ZSTD_customMem customMem
#define FORWARD_IF_ERROR(err,...)
ZSTD_cStreamStage streamStage
static size_t ZSTD_initLocalDict(ZSTD_CCtx *cctx)
ZSTD_CCtx_params requestedParams
#define memset(x, y, z)
Definition: compat.h:39
unsigned int U32
Definition: xxhash.c:195
static size_t ZSTD_resetCStream_internal(ZSTD_CStream *cctx, const void *const dict, size_t const dictSize, ZSTD_dictContentType_e const dictContentType, const ZSTD_CDict *const cdict, ZSTD_CCtx_params params, unsigned long long const pledgedSrcSize)

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

◆ ZSTD_compressStream2_simpleArgs()

size_t ZSTD_compressStream2_simpleArgs ( ZSTD_CCtx cctx,
void dst,
size_t  dstCapacity,
size_t dstPos,
const void src,
size_t  srcSize,
size_t srcPos,
ZSTD_EndDirective  endOp 
)

Definition at line 4049 of file zstd_compress.c.

4054 {
4055  ZSTD_outBuffer output = { dst, dstCapacity, *dstPos };
4056  ZSTD_inBuffer input = { src, srcSize, *srcPos };
4057  /* ZSTD_compressStream2() will check validity of dstPos and srcPos */
4058  size_t const cErr = ZSTD_compressStream2(cctx, &output, &input, endOp);
4059  *dstPos = output.pos;
4060  *srcPos = input.pos;
4061  return cErr;
4062 }
static UCHAR ULONG UCHAR ULONG UCHAR * output
Definition: bcrypt.c:29
GLenum src
Definition: glext.h:6340
GLenum GLenum GLenum input
Definition: glext.h:9031
GLenum GLenum dst
Definition: glext.h:6340
size_t ZSTD_compressStream2(ZSTD_CCtx *cctx, ZSTD_outBuffer *output, ZSTD_inBuffer *input, ZSTD_EndDirective endOp)

Referenced by ZSTD_compress2().

◆ ZSTD_compressStream_generic()

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

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

Returns
: hint size for next input

Definition at line 3803 of file zstd_compress.c.

3807 {
3808  const char* const istart = (const char*)input->src;
3809  const char* const iend = input->size != 0 ? istart + input->size : istart;
3810  const char* ip = input->pos != 0 ? istart + input->pos : istart;
3811  char* const ostart = (char*)output->dst;
3812  char* const oend = output->size != 0 ? ostart + output->size : ostart;
3813  char* op = output->pos != 0 ? ostart + output->pos : ostart;
3814  U32 someMoreWork = 1;
3815 
3816  /* check expectations */
3817  DEBUGLOG(5, "ZSTD_compressStream_generic, flush=%u", (unsigned)flushMode);
3818  assert(zcs->inBuff != NULL);
3819  assert(zcs->inBuffSize > 0);
3820  assert(zcs->outBuff != NULL);
3821  assert(zcs->outBuffSize > 0);
3822  assert(output->pos <= output->size);
3823  assert(input->pos <= input->size);
3824 
3825  while (someMoreWork) {
3826  switch(zcs->streamStage)
3827  {
3828  case zcss_init:
3829  RETURN_ERROR(init_missing, "call ZSTD_initCStream() first!");
3830 
3831  case zcss_load:
3832  if ( (flushMode == ZSTD_e_end)
3833  && ((size_t)(oend-op) >= ZSTD_compressBound(iend-ip)) /* enough dstCapacity */
3834  && (zcs->inBuffPos == 0) ) {
3835  /* shortcut to compression pass directly into output buffer */
3836  size_t const cSize = ZSTD_compressEnd(zcs,
3837  op, oend-op, ip, iend-ip);
3838  DEBUGLOG(4, "ZSTD_compressEnd : cSize=%u", (unsigned)cSize);
3839  FORWARD_IF_ERROR(cSize, "ZSTD_compressEnd failed");
3840  ip = iend;
3841  op += cSize;
3842  zcs->frameEnded = 1;
3844  someMoreWork = 0; break;
3845  }
3846  /* complete loading into inBuffer */
3847  { size_t const toLoad = zcs->inBuffTarget - zcs->inBuffPos;
3848  size_t const loaded = ZSTD_limitCopy(
3849  zcs->inBuff + zcs->inBuffPos, toLoad,
3850  ip, iend-ip);
3851  zcs->inBuffPos += loaded;
3852  if (loaded != 0)
3853  ip += loaded;
3854  if ( (flushMode == ZSTD_e_continue)
3855  && (zcs->inBuffPos < zcs->inBuffTarget) ) {
3856  /* not enough input to fill full block : stop here */
3857  someMoreWork = 0; break;
3858  }
3859  if ( (flushMode == ZSTD_e_flush)
3860  && (zcs->inBuffPos == zcs->inToCompress) ) {
3861  /* empty */
3862  someMoreWork = 0; break;
3863  }
3864  }
3865  /* compress current block (note : this stage cannot be stopped in the middle) */
3866  DEBUGLOG(5, "stream compression stage (flushMode==%u)", flushMode);
3867  { void* cDst;
3868  size_t cSize;
3869  size_t const iSize = zcs->inBuffPos - zcs->inToCompress;
3870  size_t oSize = oend-op;
3871  unsigned const lastBlock = (flushMode == ZSTD_e_end) && (ip==iend);
3872  if (oSize >= ZSTD_compressBound(iSize))
3873  cDst = op; /* compress into output buffer, to skip flush stage */
3874  else
3875  cDst = zcs->outBuff, oSize = zcs->outBuffSize;
3876  cSize = lastBlock ?
3877  ZSTD_compressEnd(zcs, cDst, oSize,
3878  zcs->inBuff + zcs->inToCompress, iSize) :
3879  ZSTD_compressContinue(zcs, cDst, oSize,
3880  zcs->inBuff + zcs->inToCompress, iSize);
3881  FORWARD_IF_ERROR(cSize, "%s", lastBlock ? "ZSTD_compressEnd failed" : "ZSTD_compressContinue failed");
3882  zcs->frameEnded = lastBlock;
3883  /* prepare next block */
3884  zcs->inBuffTarget = zcs->inBuffPos + zcs->blockSize;
3885  if (zcs->inBuffTarget > zcs->inBuffSize)
3886  zcs->inBuffPos = 0, zcs->inBuffTarget = zcs->blockSize;
3887  DEBUGLOG(5, "inBuffTarget:%u / inBuffSize:%u",
3888  (unsigned)zcs->inBuffTarget, (unsigned)zcs->inBuffSize);
3889  if (!lastBlock)
3890  assert(zcs->inBuffTarget <= zcs->inBuffSize);
3891  zcs->inToCompress = zcs->inBuffPos;
3892  if (cDst == op) { /* no need to flush */
3893  op += cSize;
3894  if (zcs->frameEnded) {
3895  DEBUGLOG(5, "Frame completed directly in outBuffer");
3896  someMoreWork = 0;
3898  }
3899  break;
3900  }
3901  zcs->outBuffContentSize = cSize;
3902  zcs->outBuffFlushedSize = 0;
3903  zcs->streamStage = zcss_flush; /* pass-through to flush stage */
3904  }
3905  /* fall-through */
3906  case zcss_flush:
3907  DEBUGLOG(5, "flush stage");
3908  { size_t const toFlush = zcs->outBuffContentSize - zcs->outBuffFlushedSize;
3909  size_t const flushed = ZSTD_limitCopy(op, (size_t)(oend-op),
3910  zcs->outBuff + zcs->outBuffFlushedSize, toFlush);
3911  DEBUGLOG(5, "toFlush: %u into %u ==> flushed: %u",
3912  (unsigned)toFlush, (unsigned)(oend-op), (unsigned)flushed);
3913  if (flushed)
3914  op += flushed;
3915  zcs->outBuffFlushedSize += flushed;
3916  if (toFlush!=flushed) {
3917  /* flush not fully completed, presumably because dst is too small */
3918  assert(op==oend);
3919  someMoreWork = 0;
3920  break;
3921  }
3922  zcs->outBuffContentSize = zcs->outBuffFlushedSize = 0;
3923  if (zcs->frameEnded) {
3924  DEBUGLOG(5, "Frame completed on flush");
3925  someMoreWork = 0;
3927  break;
3928  }
3929  zcs->streamStage = zcss_load;
3930  break;
3931  }
3932 
3933  default: /* impossible */
3934  assert(0);
3935  }
3936  }
3937 
3938  input->pos = ip - istart;
3939  output->pos = op - ostart;
3940  if (zcs->frameEnded) return 0;
3941  return ZSTD_nextInputSizeHint(zcs);
3942 }
static UCHAR ULONG UCHAR ULONG UCHAR * output
Definition: bcrypt.c:29
MEM_STATIC size_t ZSTD_limitCopy(void *dst, size_t dstCapacity, const void *src, size_t srcSize)
size_t ZSTD_compressContinue(ZSTD_CCtx *cctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize)
#define assert(x)
Definition: debug.h:53
#define DEBUGLOG(l,...)
Definition: debug.h:106
static size_t ZSTD_nextInputSizeHint(const ZSTD_CCtx *cctx)
#define RETURN_ERROR(StatusCode)
Definition: Base.h:751
Definition: dhcpd.h:61
size_t ZSTD_CCtx_reset(ZSTD_CCtx *cctx, ZSTD_ResetDirective reset)
UINT op
Definition: effect.c:236
BOOL loaded
Definition: xmlview.c:54
GLenum GLenum GLenum input
Definition: glext.h:9031
#define NULL
Definition: types.h:112
#define FORWARD_IF_ERROR(err,...)
ZSTD_cStreamStage streamStage
size_t ZSTD_compressEnd(ZSTD_CCtx *cctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize)
unsigned int U32
Definition: xxhash.c:195
size_t ZSTD_compressBound(size_t srcSize)
Definition: zstd_compress.c:44

Referenced by ZSTD_compressStream2().

◆ ZSTD_confirmRepcodesAndEntropyTables()

static void ZSTD_confirmRepcodesAndEntropyTables ( ZSTD_CCtx zc)
static

Definition at line 2407 of file zstd_compress.c.

2408 {
2411  zc->blockState.nextCBlock = tmp;
2412 }
ZSTD_blockState_t blockState
ZSTD_compressedBlockState_t * nextCBlock
ZSTD_compressedBlockState_t * prevCBlock

Referenced by ZSTD_compressBlock_internal(), and ZSTD_compressBlock_targetCBlockSize_body().

◆ ZSTD_copyBlockSequences()

static void ZSTD_copyBlockSequences ( ZSTD_CCtx zc)
static

Defin