mercurial-scm/hg: comparison contrib/python-zstandard/zstd/compress/zstd

equal deleted inserted replaced

-:2da754532dd3
+:69de49c4e39c
 #define FSE_STATIC_LINKING_ONLY   /* FSE_encodeSymbol */
 #include "fse.h"
 #define HUF_STATIC_LINKING_ONLY
 #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"
 }
 cctx->bmi2 = ZSTD_cpuid_bmi2(ZSTD_cpuid());
 return cctx;
 }
+/**
+* Clears and frees all of the dictionaries in the CCtx.
+*/
+static void ZSTD_clearAllDicts(ZSTD_CCtx* cctx)
+{
+ZSTD_free(cctx->localDict.dictBuffer, cctx->customMem);
+ZSTD_freeCDict(cctx->localDict.cdict);
+memset(&cctx->localDict, 0, sizeof(cctx->localDict));
+memset(&cctx->prefixDict, 0, sizeof(cctx->prefixDict));
+cctx->cdict = NULL;
+}
+static size_t ZSTD_sizeof_localDict(ZSTD_localDict dict)
+{
+size_t const bufferSize = dict.dictBuffer != NULL ? dict.dictSize : 0;
+size_t const cdictSize = ZSTD_sizeof_CDict(dict.cdict);
+return bufferSize + cdictSize;
+}
 static void ZSTD_freeCCtxContent(ZSTD_CCtx* cctx)
 {
 assert(cctx != NULL);
 assert(cctx->staticSize == 0);
 ZSTD_free(cctx->workSpace, cctx->customMem); cctx->workSpace = NULL;
-ZSTD_freeCDict(cctx->cdictLocal); cctx->cdictLocal = NULL;
+ZSTD_clearAllDicts(cctx);
 #ifdef ZSTD_MULTITHREAD
 ZSTDMT_freeCCtx(cctx->mtctx); cctx->mtctx = NULL;
 #endif
 }
 size_t ZSTD_freeCCtx(ZSTD_CCtx* cctx)
 {
 if (cctx==NULL) return 0;   /* support free on NULL */
-if (cctx->staticSize) return ERROR(memory_allocation);   /* not compatible with static CCtx */
+RETURN_ERROR_IF(cctx->staticSize, memory_allocation,
+"not compatible with static CCtx");
 ZSTD_freeCCtxContent(cctx);
 ZSTD_free(cctx, cctx->customMem);
 return 0;
 }
 size_t ZSTD_sizeof_CCtx(const ZSTD_CCtx* cctx)
 {
 if (cctx==NULL) return 0;   /* support sizeof on NULL */
 return sizeof(*cctx) + cctx->workSpaceSize
-+ ZSTD_sizeof_CDict(cctx->cdictLocal)
++ ZSTD_sizeof_localDict(cctx->localDict)
 + ZSTD_sizeof_mtctx(cctx);
 }
 size_t ZSTD_sizeof_CStream(const ZSTD_CStream* zcs)
 {
 {
 return ZSTD_CCtxParams_init(params, ZSTD_CLEVEL_DEFAULT);
 }
 size_t ZSTD_CCtxParams_init(ZSTD_CCtx_params* cctxParams, int compressionLevel) {
-if (!cctxParams) { return ERROR(GENERIC); }
+RETURN_ERROR_IF(!cctxParams, GENERIC);
 memset(cctxParams, 0, sizeof(*cctxParams));
 cctxParams->compressionLevel = compressionLevel;
 cctxParams->fParams.contentSizeFlag = 1;
 return 0;
 }
 size_t ZSTD_CCtxParams_init_advanced(ZSTD_CCtx_params* cctxParams, ZSTD_parameters params)
 {
-if (!cctxParams) { return ERROR(GENERIC); }
+RETURN_ERROR_IF(!cctxParams, GENERIC);
-CHECK_F( ZSTD_checkCParams(params.cParams) );
+FORWARD_IF_ERROR( ZSTD_checkCParams(params.cParams) );
 memset(cctxParams, 0, sizeof(*cctxParams));
 cctxParams->cParams = params.cParams;
 cctxParams->fParams = params.fParams;
 cctxParams->compressionLevel = ZSTD_CLEVEL_DEFAULT;   /* should not matter, as all cParams are presumed properly defined */
 assert(!ZSTD_checkCParams(params.cParams));
 ZSTD_STATIC_ASSERT(ZSTD_dictDefaultAttach < ZSTD_dictForceCopy);
 bounds.lowerBound = ZSTD_dictDefaultAttach;
 bounds.upperBound = ZSTD_dictForceCopy;       /* note : how to ensure at compile time that this is the highest value enum ? */
 return bounds;
+case ZSTD_c_literalCompressionMode:
+ZSTD_STATIC_ASSERT(ZSTD_lcm_auto < ZSTD_lcm_huffman && ZSTD_lcm_huffman < ZSTD_lcm_uncompressed);
+bounds.lowerBound = ZSTD_lcm_auto;
+bounds.upperBound = ZSTD_lcm_uncompressed;
+return bounds;
+case ZSTD_c_targetCBlockSize:
+bounds.lowerBound = ZSTD_TARGETCBLOCKSIZE_MIN;
+bounds.upperBound = ZSTD_TARGETCBLOCKSIZE_MAX;
+return bounds;
 default:
 {   ZSTD_bounds const boundError = { ERROR(parameter_unsupported), 0, 0 };
 return boundError;
 }
 }
 }
-/* ZSTD_cParam_withinBounds:
+/* ZSTD_cParam_clampBounds:
-* @return 1 if value is within cParam bounds,
+* Clamps the value into the bounded range.
-* 0 otherwise */
+*/
-static int ZSTD_cParam_withinBounds(ZSTD_cParameter cParam, int value)
+static size_t ZSTD_cParam_clampBounds(ZSTD_cParameter cParam, int* value)
 {
 ZSTD_bounds const bounds = ZSTD_cParam_getBounds(cParam);
-if (ZSTD_isError(bounds.error)) return 0;
+if (ZSTD_isError(bounds.error)) return bounds.error;
-if (value < bounds.lowerBound) return 0;
+if (*value < bounds.lowerBound) *value = bounds.lowerBound;
-if (value > bounds.upperBound) return 0;
+if (*value > bounds.upperBound) *value = bounds.upperBound;
-return 1;
+return 0;
 }
-#define BOUNDCHECK(cParam, val) {                  \
+#define BOUNDCHECK(cParam, val) { \
-if (!ZSTD_cParam_withinBounds(cParam,val)) {   \
+RETURN_ERROR_IF(!ZSTD_cParam_withinBounds(cParam,val), \
-return ERROR(parameter_outOfBound);        \
+parameter_outOfBound); \
-}   }
+}
 static int ZSTD_isUpdateAuthorized(ZSTD_cParameter param)
 {
 switch(param)
 case ZSTD_c_ldmHashLog:
 case ZSTD_c_ldmMinMatch:
 case ZSTD_c_ldmBucketSizeLog:
 case ZSTD_c_ldmHashRateLog:
 case ZSTD_c_forceAttachDict:
+case ZSTD_c_literalCompressionMode:
+case ZSTD_c_targetCBlockSize:
 default:
 return 0;
 }
 }
 DEBUGLOG(4, "ZSTD_CCtx_setParameter (%i, %i)", (int)param, value);
 if (cctx->streamStage != zcss_init) {
 if (ZSTD_isUpdateAuthorized(param)) {
 cctx->cParamsChanged = 1;
 } else {
-return ERROR(stage_wrong);
+RETURN_ERROR(stage_wrong);
 }   }
 switch(param)
 {
-case ZSTD_c_format :
+case ZSTD_c_nbWorkers:
-return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);
+RETURN_ERROR_IF((value!=0) && cctx->staticSize, parameter_unsupported,
+"MT not compatible with static alloc");
+break;
 case ZSTD_c_compressionLevel:
-if (cctx->cdict) return ERROR(stage_wrong);
-return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);
 case ZSTD_c_windowLog:
 case ZSTD_c_hashLog:
 case ZSTD_c_chainLog:
 case ZSTD_c_searchLog:
 case ZSTD_c_minMatch:
 case ZSTD_c_targetLength:
 case ZSTD_c_strategy:
-if (cctx->cdict) return ERROR(stage_wrong);
+case ZSTD_c_ldmHashRateLog:
-return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);
+case ZSTD_c_format:
 case ZSTD_c_contentSizeFlag:
 case ZSTD_c_checksumFlag:
 case ZSTD_c_dictIDFlag:
-return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);
+case ZSTD_c_forceMaxWindow:
-case ZSTD_c_forceMaxWindow :  /* Force back-references to remain < windowSize,
-* even when referencing into Dictionary content.
-* default : 0 when using a CDict, 1 when using a Prefix */
-return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);
 case ZSTD_c_forceAttachDict:
-return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);
+case ZSTD_c_literalCompressionMode:
-case ZSTD_c_nbWorkers:
-if ((value!=0) && cctx->staticSize) {
-return ERROR(parameter_unsupported);  /* MT not compatible with static alloc */
-}
-return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);
 case ZSTD_c_jobSize:
 case ZSTD_c_overlapLog:
 case ZSTD_c_rsyncable:
-return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);
 case ZSTD_c_enableLongDistanceMatching:
 case ZSTD_c_ldmHashLog:
 case ZSTD_c_ldmMinMatch:
 case ZSTD_c_ldmBucketSizeLog:
-case ZSTD_c_ldmHashRateLog:
+case ZSTD_c_targetCBlockSize:
-if (cctx->cdict) return ERROR(stage_wrong);
+break;
-return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);
+default: RETURN_ERROR(parameter_unsupported);
-default: return ERROR(parameter_unsupported);
+}
-}
+return ZSTD_CCtxParams_setParameter(&cctx->requestedParams, param, value);
 }
-size_t ZSTD_CCtxParam_setParameter(ZSTD_CCtx_params* CCtxParams,
+size_t ZSTD_CCtxParams_setParameter(ZSTD_CCtx_params* CCtxParams,
 ZSTD_cParameter param, int value)
 {
-DEBUGLOG(4, "ZSTD_CCtxParam_setParameter (%i, %i)", (int)param, value);
+DEBUGLOG(4, "ZSTD_CCtxParams_setParameter (%i, %i)", (int)param, value);
 switch(param)
 {
 case ZSTD_c_format :
 BOUNDCHECK(ZSTD_c_format, value);
 CCtxParams->format = (ZSTD_format_e)value;
 return (size_t)CCtxParams->format;
 case ZSTD_c_compressionLevel : {
-int cLevel = value;
+FORWARD_IF_ERROR(ZSTD_cParam_clampBounds(param, &value));
-if (cLevel > ZSTD_maxCLevel()) cLevel = ZSTD_maxCLevel();
+if (value) {  /* 0 : does not change current level */
-if (cLevel < ZSTD_minCLevel()) cLevel = ZSTD_minCLevel();
+CCtxParams->compressionLevel = value;
-if (cLevel) {  /* 0 : does not change current level */
-CCtxParams->compressionLevel = cLevel;
 }
 if (CCtxParams->compressionLevel >= 0) return CCtxParams->compressionLevel;
 return 0;  /* return type (size_t) cannot represent negative values */
 }
 BOUNDCHECK(ZSTD_c_forceAttachDict, pref);
 CCtxParams->attachDictPref = pref;
 return CCtxParams->attachDictPref;
 }
+case ZSTD_c_literalCompressionMode : {
+const ZSTD_literalCompressionMode_e lcm = (ZSTD_literalCompressionMode_e)value;
+BOUNDCHECK(ZSTD_c_literalCompressionMode, lcm);
+CCtxParams->literalCompressionMode = lcm;
+return CCtxParams->literalCompressionMode;
+}
 case ZSTD_c_nbWorkers :
 #ifndef ZSTD_MULTITHREAD
-if (value!=0) return ERROR(parameter_unsupported);
+RETURN_ERROR_IF(value!=0, parameter_unsupported, "not compiled with multithreading");
 return 0;
 #else
-return ZSTDMT_CCtxParam_setNbWorkers(CCtxParams, value);
+FORWARD_IF_ERROR(ZSTD_cParam_clampBounds(param, &value));
+CCtxParams->nbWorkers = value;
+return CCtxParams->nbWorkers;
 #endif
 case ZSTD_c_jobSize :
 #ifndef ZSTD_MULTITHREAD
-return ERROR(parameter_unsupported);
+RETURN_ERROR_IF(value!=0, parameter_unsupported, "not compiled with multithreading");
+return 0;
 #else
-return ZSTDMT_CCtxParam_setMTCtxParameter(CCtxParams, ZSTDMT_p_jobSize, value);
+/* Adjust to the minimum non-default value. */
+if (value != 0 && value < ZSTDMT_JOBSIZE_MIN)
+value = ZSTDMT_JOBSIZE_MIN;
+FORWARD_IF_ERROR(ZSTD_cParam_clampBounds(param, &value));
+assert(value >= 0);
+CCtxParams->jobSize = value;
+return CCtxParams->jobSize;
 #endif
 case ZSTD_c_overlapLog :
 #ifndef ZSTD_MULTITHREAD
-return ERROR(parameter_unsupported);
+RETURN_ERROR_IF(value!=0, parameter_unsupported, "not compiled with multithreading");
+return 0;
 #else
-return ZSTDMT_CCtxParam_setMTCtxParameter(CCtxParams, ZSTDMT_p_overlapLog, value);
+FORWARD_IF_ERROR(ZSTD_cParam_clampBounds(ZSTD_c_overlapLog, &value));
+CCtxParams->overlapLog = value;
+return CCtxParams->overlapLog;
 #endif
 case ZSTD_c_rsyncable :
 #ifndef ZSTD_MULTITHREAD
-return ERROR(parameter_unsupported);
+RETURN_ERROR_IF(value!=0, parameter_unsupported, "not compiled with multithreading");
+return 0;
 #else
-return ZSTDMT_CCtxParam_setMTCtxParameter(CCtxParams, ZSTDMT_p_rsyncable, value);
+FORWARD_IF_ERROR(ZSTD_cParam_clampBounds(ZSTD_c_overlapLog, &value));
+CCtxParams->rsyncable = value;
+return CCtxParams->rsyncable;
 #endif
 case ZSTD_c_enableLongDistanceMatching :
 CCtxParams->ldmParams.enableLdm = (value!=0);
 return CCtxParams->ldmParams.enableLdm;
 BOUNDCHECK(ZSTD_c_ldmBucketSizeLog, value);
 CCtxParams->ldmParams.bucketSizeLog = value;
 return CCtxParams->ldmParams.bucketSizeLog;
 case ZSTD_c_ldmHashRateLog :
-if (value > ZSTD_WINDOWLOG_MAX - ZSTD_HASHLOG_MIN)
+RETURN_ERROR_IF(value > ZSTD_WINDOWLOG_MAX - ZSTD_HASHLOG_MIN,
-return ERROR(parameter_outOfBound);
+parameter_outOfBound);
 CCtxParams->ldmParams.hashRateLog = value;
 return CCtxParams->ldmParams.hashRateLog;
-default: return ERROR(parameter_unsupported);
+case ZSTD_c_targetCBlockSize :
+if (value!=0)   /* 0 ==> default */
+BOUNDCHECK(ZSTD_c_targetCBlockSize, value);
+CCtxParams->targetCBlockSize = value;
+return CCtxParams->targetCBlockSize;
+default: RETURN_ERROR(parameter_unsupported, "unknown parameter");
 }
 }
 size_t ZSTD_CCtx_getParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, int* value)
 {
-return ZSTD_CCtxParam_getParameter(&cctx->requestedParams, param, value);
+return ZSTD_CCtxParams_getParameter(&cctx->requestedParams, param, value);
 }
-size_t ZSTD_CCtxParam_getParameter(
+size_t ZSTD_CCtxParams_getParameter(
 ZSTD_CCtx_params* CCtxParams, ZSTD_cParameter param, int* value)
 {
 switch(param)
 {
 case ZSTD_c_format :
 break;
 case ZSTD_c_compressionLevel :
 *value = CCtxParams->compressionLevel;
 break;
 case ZSTD_c_windowLog :
-*value = CCtxParams->cParams.windowLog;
+*value = (int)CCtxParams->cParams.windowLog;
 break;
 case ZSTD_c_hashLog :
-*value = CCtxParams->cParams.hashLog;
+*value = (int)CCtxParams->cParams.hashLog;
 break;
 case ZSTD_c_chainLog :
-*value = CCtxParams->cParams.chainLog;
+*value = (int)CCtxParams->cParams.chainLog;
 break;
 case ZSTD_c_searchLog :
 *value = CCtxParams->cParams.searchLog;
 break;
 case ZSTD_c_minMatch :
 *value = CCtxParams->forceWindow;
 break;
 case ZSTD_c_forceAttachDict :
 *value = CCtxParams->attachDictPref;
 break;
+case ZSTD_c_literalCompressionMode :
+*value = CCtxParams->literalCompressionMode;
+break;
 case ZSTD_c_nbWorkers :
 #ifndef ZSTD_MULTITHREAD
 assert(CCtxParams->nbWorkers == 0);
 #endif
 *value = CCtxParams->nbWorkers;
 break;
 case ZSTD_c_jobSize :
 #ifndef ZSTD_MULTITHREAD
-return ERROR(parameter_unsupported);
+RETURN_ERROR(parameter_unsupported, "not compiled with multithreading");
 #else
 assert(CCtxParams->jobSize <= INT_MAX);
 *value = (int)CCtxParams->jobSize;
 break;
 #endif
 case ZSTD_c_overlapLog :
 #ifndef ZSTD_MULTITHREAD
-return ERROR(parameter_unsupported);
+RETURN_ERROR(parameter_unsupported, "not compiled with multithreading");
 #else
 *value = CCtxParams->overlapLog;
 break;
 #endif
 case ZSTD_c_rsyncable :
 #ifndef ZSTD_MULTITHREAD
-return ERROR(parameter_unsupported);
+RETURN_ERROR(parameter_unsupported, "not compiled with multithreading");
 #else
 *value = CCtxParams->rsyncable;
 break;
 #endif
 case ZSTD_c_enableLongDistanceMatching :
 *value = CCtxParams->ldmParams.bucketSizeLog;
 break;
 case ZSTD_c_ldmHashRateLog :
 *value = CCtxParams->ldmParams.hashRateLog;
 break;
-default: return ERROR(parameter_unsupported);
+case ZSTD_c_targetCBlockSize :
+*value = (int)CCtxParams->targetCBlockSize;
+break;
+default: RETURN_ERROR(parameter_unsupported, "unknown parameter");
 }
 return 0;
 }
 /** ZSTD_CCtx_setParametersUsingCCtxParams() :
 */
 size_t ZSTD_CCtx_setParametersUsingCCtxParams(
 ZSTD_CCtx* cctx, const ZSTD_CCtx_params* params)
 {
 DEBUGLOG(4, "ZSTD_CCtx_setParametersUsingCCtxParams");
-if (cctx->streamStage != zcss_init) return ERROR(stage_wrong);
+RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong);
-if (cctx->cdict) return ERROR(stage_wrong);
+RETURN_ERROR_IF(cctx->cdict, stage_wrong);
 cctx->requestedParams = *params;
 return 0;
 }
 ZSTDLIB_API size_t ZSTD_CCtx_setPledgedSrcSize(ZSTD_CCtx* cctx, unsigned long long pledgedSrcSize)
 {
 DEBUGLOG(4, "ZSTD_CCtx_setPledgedSrcSize to %u bytes", (U32)pledgedSrcSize);
-if (cctx->streamStage != zcss_init) return ERROR(stage_wrong);
+RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong);
 cctx->pledgedSrcSizePlusOne = pledgedSrcSize+1;
+return 0;
+}
+/**
+* Initializes the local dict using the requested parameters.
+* NOTE: This does not use the pledged src size, because it may be used for more
+* than one compression.
+*/
+static size_t ZSTD_initLocalDict(ZSTD_CCtx* cctx)
+{
+ZSTD_localDict* const dl = &cctx->localDict;
+ZSTD_compressionParameters const cParams = ZSTD_getCParamsFromCCtxParams(
+&cctx->requestedParams, 0, dl->dictSize);
+if (dl->dict == NULL) {
+/* No local dictionary. */
+assert(dl->dictBuffer == NULL);
+assert(dl->cdict == NULL);
+assert(dl->dictSize == 0);
+return 0;
+}
+if (dl->cdict != NULL) {
+assert(cctx->cdict == dl->cdict);
+/* Local dictionary already initialized. */
+return 0;
+}
+assert(dl->dictSize > 0);
+assert(cctx->cdict == NULL);
+assert(cctx->prefixDict.dict == NULL);
+dl->cdict = ZSTD_createCDict_advanced(
+dl->dict,
+dl->dictSize,
+ZSTD_dlm_byRef,
+dl->dictContentType,
+cParams,
+cctx->customMem);
+RETURN_ERROR_IF(!dl->cdict, memory_allocation);
+cctx->cdict = dl->cdict;
 return 0;
 }
 size_t ZSTD_CCtx_loadDictionary_advanced(
 ZSTD_CCtx* cctx, const void* dict, size_t dictSize,
 ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType)
 {
-if (cctx->streamStage != zcss_init) return ERROR(stage_wrong);
+RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong);
-if (cctx->staticSize) return ERROR(memory_allocation);  /* no malloc for static CCtx */
+RETURN_ERROR_IF(cctx->staticSize, memory_allocation,
+"no malloc for static CCtx");
 DEBUGLOG(4, "ZSTD_CCtx_loadDictionary_advanced (size: %u)", (U32)dictSize);
-ZSTD_freeCDict(cctx->cdictLocal);  /* in case one already exists */
+ZSTD_clearAllDicts(cctx);  /* in case one already exists */
-if (dict==NULL || dictSize==0) {   /* no dictionary mode */
+if (dict == NULL || dictSize == 0)  /* no dictionary mode */
-cctx->cdictLocal = NULL;
+return 0;
-cctx->cdict = NULL;
+if (dictLoadMethod == ZSTD_dlm_byRef) {
+cctx->localDict.dict = dict;
 } else {
-ZSTD_compressionParameters const cParams =
+void* dictBuffer = ZSTD_malloc(dictSize, cctx->customMem);
-ZSTD_getCParamsFromCCtxParams(&cctx->requestedParams, cctx->pledgedSrcSizePlusOne-1, dictSize);
+RETURN_ERROR_IF(!dictBuffer, memory_allocation);
-cctx->cdictLocal = ZSTD_createCDict_advanced(
+memcpy(dictBuffer, dict, dictSize);
-dict, dictSize,
+cctx->localDict.dictBuffer = dictBuffer;
-dictLoadMethod, dictContentType,
+cctx->localDict.dict = dictBuffer;
-cParams, cctx->customMem);
+}
-cctx->cdict = cctx->cdictLocal;
+cctx->localDict.dictSize = dictSize;
-if (cctx->cdictLocal == NULL)
+cctx->localDict.dictContentType = dictContentType;
-return ERROR(memory_allocation);
-}
 return 0;
 }
 ZSTDLIB_API size_t ZSTD_CCtx_loadDictionary_byReference(
 ZSTD_CCtx* cctx, const void* dict, size_t dictSize)
 }
 size_t ZSTD_CCtx_refCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict)
 {
-if (cctx->streamStage != zcss_init) return ERROR(stage_wrong);
+RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong);
+/* Free the existing local cdict (if any) to save memory. */
+ZSTD_clearAllDicts(cctx);
 cctx->cdict = cdict;
-memset(&cctx->prefixDict, 0, sizeof(cctx->prefixDict));  /* exclusive */
 return 0;
 }
 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)
 {
-if (cctx->streamStage != zcss_init) return ERROR(stage_wrong);
+RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong);
-cctx->cdict = NULL;   /* prefix discards any prior cdict */
+ZSTD_clearAllDicts(cctx);
 cctx->prefixDict.dict = prefix;
 cctx->prefixDict.dictSize = prefixSize;
 cctx->prefixDict.dictContentType = dictContentType;
 return 0;
 }
 cctx->streamStage = zcss_init;
 cctx->pledgedSrcSizePlusOne = 0;
 }
 if ( (reset == ZSTD_reset_parameters)
 || (reset == ZSTD_reset_session_and_parameters) ) {
-if (cctx->streamStage != zcss_init) return ERROR(stage_wrong);
+RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong);
-cctx->cdict = NULL;
+ZSTD_clearAllDicts(cctx);
 return ZSTD_CCtxParams_reset(&cctx->requestedParams);
 }
 return 0;
 }
 /** ZSTD_checkCParams() :
 control CParam values remain within authorized range.
 @return : 0, or an error code if one value is beyond authorized range */
 size_t ZSTD_checkCParams(ZSTD_compressionParameters cParams)
 {
-BOUNDCHECK(ZSTD_c_windowLog, cParams.windowLog);
+BOUNDCHECK(ZSTD_c_windowLog, (int)cParams.windowLog);
-BOUNDCHECK(ZSTD_c_chainLog,  cParams.chainLog);
+BOUNDCHECK(ZSTD_c_chainLog,  (int)cParams.chainLog);
-BOUNDCHECK(ZSTD_c_hashLog,   cParams.hashLog);
+BOUNDCHECK(ZSTD_c_hashLog,   (int)cParams.hashLog);
-BOUNDCHECK(ZSTD_c_searchLog, cParams.searchLog);
+BOUNDCHECK(ZSTD_c_searchLog, (int)cParams.searchLog);
-BOUNDCHECK(ZSTD_c_minMatch,  cParams.minMatch);
+BOUNDCHECK(ZSTD_c_minMatch,  (int)cParams.minMatch);
-BOUNDCHECK(ZSTD_c_targetLength,cParams.targetLength);
+BOUNDCHECK(ZSTD_c_targetLength,(int)cParams.targetLength);
 BOUNDCHECK(ZSTD_c_strategy,  cParams.strategy);
 return 0;
 }
 /** ZSTD_clampCParams() :
 #   define CLAMP_TYPE(cParam, val, type) {                                \
 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; \
 }
-#   define CLAMP(cParam, val) CLAMP_TYPE(cParam, val, int)
+#   define CLAMP(cParam, val) CLAMP_TYPE(cParam, val, unsigned)
 CLAMP(ZSTD_c_windowLog, cParams.windowLog);
 CLAMP(ZSTD_c_chainLog,  cParams.chainLog);
 CLAMP(ZSTD_c_hashLog,   cParams.hashLog);
 CLAMP(ZSTD_c_searchLog, cParams.searchLog);
 CLAMP(ZSTD_c_minMatch,  cParams.minMatch);
 U32 const btScale = ((U32)strat >= (U32)ZSTD_btlazy2);
 return hashLog - btScale;
 }
 /** ZSTD_adjustCParams_internal() :
-optimize `cPar` for a given input (`srcSize` and `dictSize`).
+*  optimize `cPar` for a specified input (`srcSize` and `dictSize`).
-mostly downsizing to reduce memory consumption and initialization latency.
+*  mostly downsize to reduce memory consumption and initialization latency.
-Both `srcSize` and `dictSize` are optional (use 0 if unknown).
+* `srcSize` can be ZSTD_CONTENTSIZE_UNKNOWN when not known.
-Note : cPar is assumed validated. Use ZSTD_checkCParams() to ensure this condition. */
+*  note : for the time being, `srcSize==0` means "unknown" too, for compatibility with older convention.
+*  condition : cPar is presumed validated (can be checked using ZSTD_checkCParams()). */
 static ZSTD_compressionParameters
 ZSTD_adjustCParams_internal(ZSTD_compressionParameters cPar,
 unsigned long long srcSize,
 size_t dictSize)
 {
 static const U64 minSrcSize = 513; /* (1<<9) + 1 */
 static const U64 maxWindowResize = 1ULL << (ZSTD_WINDOWLOG_MAX-1);
 assert(ZSTD_checkCParams(cPar)==0);
-if (dictSize && (srcSize+1<2) /* srcSize unknown */ )
+if (dictSize && (srcSize+1<2) /* ZSTD_CONTENTSIZE_UNKNOWN and 0 mean "unknown" */ )
 srcSize = minSrcSize;  /* presumed small when there is a dictionary */
 else if (srcSize == 0)
 srcSize = ZSTD_CONTENTSIZE_UNKNOWN;  /* 0 == unknown : presumed large */
 /* resize windowLog if input is small enough, to use less memory */
 if (cycleLog > cPar.windowLog)
 cPar.chainLog -= (cycleLog - cPar.windowLog);
 }
 if (cPar.windowLog < ZSTD_WINDOWLOG_ABSOLUTEMIN)
-cPar.windowLog = ZSTD_WINDOWLOG_ABSOLUTEMIN;  /* required for frame header */
+cPar.windowLog = ZSTD_WINDOWLOG_ABSOLUTEMIN;  /* minimum wlog required for valid frame header */
 return cPar;
 }
 ZSTD_compressionParameters
 ZSTD_adjustCParams(ZSTD_compressionParameters cPar,
 unsigned long long srcSize,
 size_t dictSize)
 {
-cPar = ZSTD_clampCParams(cPar);
+cPar = ZSTD_clampCParams(cPar);   /* resulting cPar is necessarily valid (all parameters within range) */
 return ZSTD_adjustCParams_internal(cPar, srcSize, dictSize);
 }
 ZSTD_compressionParameters ZSTD_getCParamsFromCCtxParams(
 const ZSTD_CCtx_params* CCtxParams, U64 srcSizeHint, size_t dictSize)
 return tableSpace + optSpace;
 }
 size_t ZSTD_estimateCCtxSize_usingCCtxParams(const ZSTD_CCtx_params* params)
 {
-/* Estimate CCtx size is supported for single-threaded compression only. */
+RETURN_ERROR_IF(params->nbWorkers > 0, GENERIC, "Estimate CCtx size is supported for single-threaded compression only.");
-if (params->nbWorkers > 0) { return ERROR(GENERIC); }
 {   ZSTD_compressionParameters const cParams =
 ZSTD_getCParamsFromCCtxParams(params, 0, 0);
 size_t const blockSize = MIN(ZSTD_BLOCKSIZE_MAX, (size_t)1 << cParams.windowLog);
 U32    const divider = (cParams.minMatch==3) ? 3 : 4;
 size_t const maxNbSeq = blockSize / divider;
 return memBudget;
 }
 size_t ZSTD_estimateCStreamSize_usingCCtxParams(const ZSTD_CCtx_params* params)
 {
-if (params->nbWorkers > 0) { return ERROR(GENERIC); }
+RETURN_ERROR_IF(params->nbWorkers > 0, GENERIC, "Estimate CCtx size is supported for single-threaded compression only.");
-{   size_t const CCtxSize = ZSTD_estimateCCtxSize_usingCCtxParams(params);
+{   ZSTD_compressionParameters const cParams =
-size_t const blockSize = MIN(ZSTD_BLOCKSIZE_MAX, (size_t)1 << params->cParams.windowLog);
+ZSTD_getCParamsFromCCtxParams(params, 0, 0);
-size_t const inBuffSize = ((size_t)1 << params->cParams.windowLog) + blockSize;
+size_t const CCtxSize = ZSTD_estimateCCtxSize_usingCCtxParams(params);
+size_t const blockSize = MIN(ZSTD_BLOCKSIZE_MAX, (size_t)1 << cParams.windowLog);
+size_t const inBuffSize = ((size_t)1 << cParams.windowLog) + blockSize;
 size_t const outBuffSize = ZSTD_compressBound(blockSize) + 1;
 size_t const streamingSize = inBuffSize + outBuffSize;
 return CCtxSize + streamingSize;
 }
 bs->entropy.fse.matchlength_repeatMode = FSE_repeat_none;
 bs->entropy.fse.litlength_repeatMode = FSE_repeat_none;
 }
 /*! ZSTD_invalidateMatchState()
-* Invalidate all the matches in the match finder tables.
+*  Invalidate all the matches in the match finder tables.
-* Requires nextSrc and base to be set (can be NULL).
+*  Requires nextSrc and base to be set (can be NULL).
 */
 static void ZSTD_invalidateMatchState(ZSTD_matchState_t* ms)
 {
 ZSTD_window_clear(&ms->window);
 ms->nextToUpdate = ms->window.dictLimit;
-ms->nextToUpdate3 = ms->window.dictLimit;
 ms->loadedDictEnd = 0;
 ms->opt.litLengthSum = 0;  /* force reset of btopt stats */
 ms->dictMatchState = NULL;
 }
 return 0;
 }
 typedef enum { ZSTDcrp_continue, ZSTDcrp_noMemset } ZSTD_compResetPolicy_e;
+typedef enum { ZSTD_resetTarget_CDict, ZSTD_resetTarget_CCtx } ZSTD_resetTarget_e;
 static void*
 ZSTD_reset_matchState(ZSTD_matchState_t* ms,
 void* ptr,
 const ZSTD_compressionParameters* cParams,
-ZSTD_compResetPolicy_e const crp, U32 const forCCtx)
+ZSTD_compResetPolicy_e const crp, ZSTD_resetTarget_e const forWho)
 {
 size_t const chainSize = (cParams->strategy == ZSTD_fast) ? 0 : ((size_t)1 << cParams->chainLog);
 size_t const hSize = ((size_t)1) << cParams->hashLog;
-U32    const hashLog3 = (forCCtx && cParams->minMatch==3) ? MIN(ZSTD_HASHLOG3_MAX, cParams->windowLog) : 0;
+U32    const hashLog3 = ((forWho == ZSTD_resetTarget_CCtx) && cParams->minMatch==3) ? MIN(ZSTD_HASHLOG3_MAX, cParams->windowLog) : 0;
 size_t const h3Size = ((size_t)1) << hashLog3;
 size_t const tableSpace = (chainSize + hSize + h3Size) * sizeof(U32);
 assert(((size_t)ptr & 3) == 0);
 ms->window.lowLimit = 1;     /* it ensures first and later CCtx usages compress the same */
 ms->window.nextSrc = ms->window.base + 1;   /* see issue #1241 */
 ZSTD_invalidateMatchState(ms);
 /* opt parser space */
-if (forCCtx && (cParams->strategy >= ZSTD_btopt)) {
+if ((forWho == ZSTD_resetTarget_CCtx) && (cParams->strategy >= ZSTD_btopt)) {
 DEBUGLOG(4, "reserving optimal parser space");
 ms->opt.litFreq = (unsigned*)ptr;
 ms->opt.litLengthFreq = ms->opt.litFreq + (1<<Litbits);
 ms->opt.matchLengthFreq = ms->opt.litLengthFreq + (MaxLL+1);
 ms->opt.offCodeFreq = ms->opt.matchLengthFreq + (MaxML+1);
 assert(((size_t)ptr & 3) == 0);
 return ptr;
 }
+/* ZSTD_indexTooCloseToMax() :
+* minor optimization : prefer memset() rather than reduceIndex()
+* which is measurably slow in some circumstances (reported for Visual Studio).
+* Works when re-using a context for a lot of smallish inputs :
+* if all inputs are smaller than ZSTD_INDEXOVERFLOW_MARGIN,
+* memset() will be triggered before reduceIndex().
+*/
+#define ZSTD_INDEXOVERFLOW_MARGIN (16 MB)
+static int ZSTD_indexTooCloseToMax(ZSTD_window_t w)
+{
+return (size_t)(w.nextSrc - w.base) > (ZSTD_CURRENT_MAX - ZSTD_INDEXOVERFLOW_MARGIN);
+}
 #define ZSTD_WORKSPACETOOLARGE_FACTOR 3 /* define "workspace is too large" as this number of times larger than needed */
 #define ZSTD_WORKSPACETOOLARGE_MAXDURATION 128  /* when workspace is continuously too large
 * during at least this number of times,
 * context's memory usage is considered wasteful,
 * because it's sized to handle a worst case scenario which rarely happens.
 /*! ZSTD_resetCCtx_internal() :
 note : `params` are assumed fully validated at this stage */
 static size_t ZSTD_resetCCtx_internal(ZSTD_CCtx* zc,
 ZSTD_CCtx_params params,
-U64 pledgedSrcSize,
+U64 const pledgedSrcSize,
 ZSTD_compResetPolicy_e const crp,
 ZSTD_buffered_policy_e const zbuff)
 {
 DEBUGLOG(4, "ZSTD_resetCCtx_internal: pledgedSrcSize=%u, wlog=%u",
 (U32)pledgedSrcSize, params.cParams.windowLog);
 if (crp == ZSTDcrp_continue) {
 if (ZSTD_equivalentParams(zc->appliedParams, params,
 zc->inBuffSize,
 zc->seqStore.maxNbSeq, zc->seqStore.maxNbLit,
-zbuff, pledgedSrcSize)) {
+zbuff, pledgedSrcSize) ) {
-DEBUGLOG(4, "ZSTD_equivalentParams()==1 -> continue mode (wLog1=%u, blockSize1=%zu)",
+DEBUGLOG(4, "ZSTD_equivalentParams()==1 -> consider continue mode");
-zc->appliedParams.cParams.windowLog, zc->blockSize);
 zc->workSpaceOversizedDuration += (zc->workSpaceOversizedDuration > 0);   /* if it was too large, it still is */
-if (zc->workSpaceOversizedDuration <= ZSTD_WORKSPACETOOLARGE_MAXDURATION)
+if (zc->workSpaceOversizedDuration <= ZSTD_WORKSPACETOOLARGE_MAXDURATION) {
+DEBUGLOG(4, "continue mode confirmed (wLog1=%u, blockSize1=%zu)",
+zc->appliedParams.cParams.windowLog, zc->blockSize);
+if (ZSTD_indexTooCloseToMax(zc->blockState.matchState.window)) {
+/* prefer a reset, faster than a rescale */
+ZSTD_reset_matchState(&zc->blockState.matchState,
+zc->entropyWorkspace + HUF_WORKSPACE_SIZE_U32,
+&params.cParams,
+crp, ZSTD_resetTarget_CCtx);
+}
 return ZSTD_continueCCtx(zc, params, pledgedSrcSize);
-}   }
+}   }   }
 DEBUGLOG(4, "ZSTD_equivalentParams()==0 -> reset CCtx");
 if (params.ldmParams.enableLdm) {
 /* Adjust long distance matching parameters */
 ZSTD_ldm_adjustParameters(&params.ldmParams, &params.cParams);
 DEBUGLOG(4, "Need %zuKB workspace, including %zuKB for match state, and %zuKB for buffers",
 neededSpace>>10, matchStateSize>>10, bufferSpace>>10);
 DEBUGLOG(4, "windowSize: %zu - blockSize: %zu", windowSize, blockSize);
 if (workSpaceTooSmall || workSpaceWasteful) {
-DEBUGLOG(4, "Need to resize workSpaceSize from %zuKB to %zuKB",
+DEBUGLOG(4, "Resize workSpaceSize from %zuKB to %zuKB",
 zc->workSpaceSize >> 10,
 neededSpace >> 10);
-/* static cctx : no resize, error out */
-if (zc->staticSize) return ERROR(memory_allocation);
+RETURN_ERROR_IF(zc->staticSize, memory_allocation, "static cctx : no resize");
 zc->workSpaceSize = 0;
 ZSTD_free(zc->workSpace, zc->customMem);
 zc->workSpace = ZSTD_malloc(neededSpace, zc->customMem);
-if (zc->workSpace == NULL) return ERROR(memory_allocation);
+RETURN_ERROR_IF(zc->workSpace == NULL, memory_allocation);
 zc->workSpaceSize = neededSpace;
 zc->workSpaceOversizedDuration = 0;
 /* Statically sized space.
 * entropyWorkspace never moves,
 zc->stage = ZSTDcs_init;
 zc->dictID = 0;
 ZSTD_reset_compressedBlockState(zc->blockState.prevCBlock);
-ptr = zc->entropyWorkspace + HUF_WORKSPACE_SIZE_U32;
+ptr = ZSTD_reset_matchState(&zc->blockState.matchState,
+zc->entropyWorkspace + HUF_WORKSPACE_SIZE_U32,
+&params.cParams,
+crp, ZSTD_resetTarget_CCtx);
 /* ldm hash table */
 /* initialize bucketOffsets table later for pointer alignment */
 if (params.ldmParams.enableLdm) {
 size_t const ldmHSize = ((size_t)1) << params.ldmParams.hashLog;
 zc->maxNbLdmSequences = maxNbLdmSeq;
 memset(&zc->ldmState.window, 0, sizeof(zc->ldmState.window));
 }
 assert(((size_t)ptr & 3) == 0); /* ensure ptr is properly aligned */
-ptr = ZSTD_reset_matchState(&zc->blockState.matchState, ptr, &params.cParams, crp, /* forCCtx */ 1);
 /* sequences storage */
 zc->seqStore.maxNbSeq = maxNbSeq;
 zc->seqStore.sequencesStart = (seqDef*)ptr;
 ptr = zc->seqStore.sequencesStart + maxNbSeq;
 && params.attachDictPref != ZSTD_dictForceCopy
 && !params.forceWindow; /* dictMatchState isn't correctly
 * handled in _enforceMaxDist */
 }
-static size_t ZSTD_resetCCtx_byAttachingCDict(
+static size_t
-ZSTD_CCtx* cctx,
+ZSTD_resetCCtx_byAttachingCDict(ZSTD_CCtx* cctx,
 const ZSTD_CDict* cdict,
 ZSTD_CCtx_params params,
 U64 pledgedSrcSize,
 ZSTD_buffered_policy_e zbuff)
 {
-{
+{   const ZSTD_compressionParameters* const cdict_cParams = &cdict->matchState.cParams;
-const ZSTD_compressionParameters *cdict_cParams = &cdict->matchState.cParams;
 unsigned const windowLog = params.cParams.windowLog;
 assert(windowLog != 0);
 /* Resize working context table params for input only, since the dict
 * has its own tables. */
 params.cParams = ZSTD_adjustCParams_internal(*cdict_cParams, pledgedSrcSize, 0);
 ZSTD_resetCCtx_internal(cctx, params, pledgedSrcSize,
 ZSTDcrp_continue, zbuff);
 assert(cctx->appliedParams.cParams.strategy == cdict_cParams->strategy);
 }
-{
+{   const U32 cdictEnd = (U32)( cdict->matchState.window.nextSrc
-const U32 cdictEnd = (U32)( cdict->matchState.window.nextSrc
 - cdict->matchState.window.base);
 const U32 cdictLen = cdictEnd - cdict->matchState.window.dictLimit;
 if (cdictLen == 0) {
 /* don't even attach dictionaries with no contents */
 DEBUGLOG(4, "skipping attaching empty dictionary");
 if (cctx->blockState.matchState.window.dictLimit < cdictEnd) {
 cctx->blockState.matchState.window.nextSrc =
 cctx->blockState.matchState.window.base + cdictEnd;
 ZSTD_window_clear(&cctx->blockState.matchState.window);
 }
+/* loadedDictEnd is expressed within the referential of the active context */
 cctx->blockState.matchState.loadedDictEnd = cctx->blockState.matchState.window.dictLimit;
-}
+}   }
-}
 cctx->dictID = cdict->dictID;
 /* copy block state */
 memcpy(cctx->blockState.prevCBlock, &cdict->cBlockState, sizeof(cdict->cBlockState));
 /* copy dictionary offsets */
 {   ZSTD_matchState_t const* srcMatchState = &cdict->matchState;
 ZSTD_matchState_t* dstMatchState = &cctx->blockState.matchState;
 dstMatchState->window       = srcMatchState->window;
 dstMatchState->nextToUpdate = srcMatchState->nextToUpdate;
-dstMatchState->nextToUpdate3= srcMatchState->nextToUpdate3;
 dstMatchState->loadedDictEnd= srcMatchState->loadedDictEnd;
 }
 cctx->dictID = cdict->dictID;
 ZSTD_frameParameters fParams,
 U64 pledgedSrcSize,
 ZSTD_buffered_policy_e zbuff)
 {
 DEBUGLOG(5, "ZSTD_copyCCtx_internal");
-if (srcCCtx->stage!=ZSTDcs_init) return ERROR(stage_wrong);
+RETURN_ERROR_IF(srcCCtx->stage!=ZSTDcs_init, stage_wrong);
 memcpy(&dstCCtx->customMem, &srcCCtx->customMem, sizeof(ZSTD_customMem));
 {   ZSTD_CCtx_params params = dstCCtx->requestedParams;
 /* Copy only compression parameters related to tables. */
 params.cParams = srcCCtx->appliedParams.cParams;
 {
 const ZSTD_matchState_t* srcMatchState = &srcCCtx->blockState.matchState;
 ZSTD_matchState_t* dstMatchState = &dstCCtx->blockState.matchState;
 dstMatchState->window       = srcMatchState->window;
 dstMatchState->nextToUpdate = srcMatchState->nextToUpdate;
-dstMatchState->nextToUpdate3= srcMatchState->nextToUpdate3;
 dstMatchState->loadedDictEnd= srcMatchState->loadedDictEnd;
 }
 dstCCtx->dictID = srcCCtx->dictID;
 /* copy block state */
 ZSTD_reduceTable_internal(table, size, reducerValue, 1);
 }
 /*! ZSTD_reduceIndex() :
 *   rescale all indexes to avoid future overflow (indexes are U32) */
-static void ZSTD_reduceIndex (ZSTD_CCtx* zc, const U32 reducerValue)
+static void ZSTD_reduceIndex (ZSTD_matchState_t* ms, ZSTD_CCtx_params const* params, const U32 reducerValue)
 {
-ZSTD_matchState_t* const ms = &zc->blockState.matchState;
+{   U32 const hSize = (U32)1 << params->cParams.hashLog;
-{   U32 const hSize = (U32)1 << zc->appliedParams.cParams.hashLog;
 ZSTD_reduceTable(ms->hashTable, hSize, reducerValue);
 }
-if (zc->appliedParams.cParams.strategy != ZSTD_fast) {
+if (params->cParams.strategy != ZSTD_fast) {
-U32 const chainSize = (U32)1 << zc->appliedParams.cParams.chainLog;
+U32 const chainSize = (U32)1 << params->cParams.chainLog;
-if (zc->appliedParams.cParams.strategy == ZSTD_btlazy2)
+if (params->cParams.strategy == ZSTD_btlazy2)
 ZSTD_reduceTable_btlazy2(ms->chainTable, chainSize, reducerValue);
 else
 ZSTD_reduceTable(ms->chainTable, chainSize, reducerValue);
 }
 /* See doc/zstd_compression_format.md for detailed format description */
 static size_t ZSTD_noCompressBlock (void* dst, size_t dstCapacity, const void* src, size_t srcSize, U32 lastBlock)
 {
 U32 const cBlockHeader24 = lastBlock + (((U32)bt_raw)<<1) + (U32)(srcSize << 3);
-if (srcSize + ZSTD_blockHeaderSize > dstCapacity) return ERROR(dstSize_tooSmall);
+RETURN_ERROR_IF(srcSize + ZSTD_blockHeaderSize > dstCapacity,
+dstSize_tooSmall);
 MEM_writeLE24(dst, cBlockHeader24);
 memcpy((BYTE*)dst + ZSTD_blockHeaderSize, src, srcSize);
 return ZSTD_blockHeaderSize + srcSize;
 }
-static size_t ZSTD_noCompressLiterals (void* dst, size_t dstCapacity, const void* src, size_t srcSize)
-{
-BYTE* const ostart = (BYTE* const)dst;
-U32   const flSize = 1 + (srcSize>31) + (srcSize>4095);
-if (srcSize + flSize > dstCapacity) return ERROR(dstSize_tooSmall);
-switch(flSize)
-{
-case 1: /* 2 - 1 - 5 */
-ostart[0] = (BYTE)((U32)set_basic + (srcSize<<3));
-break;
-case 2: /* 2 - 2 - 12 */
-MEM_writeLE16(ostart, (U16)((U32)set_basic + (1<<2) + (srcSize<<4)));
-break;
-case 3: /* 2 - 2 - 20 */
-MEM_writeLE32(ostart, (U32)((U32)set_basic + (3<<2) + (srcSize<<4)));
-break;
-default:   /* not necessary : flSize is {1,2,3} */
-assert(0);
-}
-memcpy(ostart + flSize, src, srcSize);
-return srcSize + flSize;
-}
-static size_t ZSTD_compressRleLiteralsBlock (void* dst, size_t dstCapacity, const void* src, size_t srcSize)
-{
-BYTE* const ostart = (BYTE* const)dst;
-U32   const flSize = 1 + (srcSize>31) + (srcSize>4095);
-(void)dstCapacity;  /* dstCapacity already guaranteed to be >=4, hence large enough */
-switch(flSize)
-{
-case 1: /* 2 - 1 - 5 */
-ostart[0] = (BYTE)((U32)set_rle + (srcSize<<3));
-break;
-case 2: /* 2 - 2 - 12 */
-MEM_writeLE16(ostart, (U16)((U32)set_rle + (1<<2) + (srcSize<<4)));
-break;
-case 3: /* 2 - 2 - 20 */
-MEM_writeLE32(ostart, (U32)((U32)set_rle + (3<<2) + (srcSize<<4)));
-break;
-default:   /* not necessary : flSize is {1,2,3} */
-assert(0);
-}
-ostart[flSize] = *(const BYTE*)src;
-return flSize+1;
-}
-/* ZSTD_minGain() :
-* minimum compression required
-* to generate a compress block or a compressed literals section.
-* note : use same formula for both situations */
-static size_t ZSTD_minGain(size_t srcSize, ZSTD_strategy strat)
-{
-U32 const minlog = (strat>=ZSTD_btultra) ? (U32)(strat) - 1 : 6;
-ZSTD_STATIC_ASSERT(ZSTD_btultra == 8);
-assert(ZSTD_cParam_withinBounds(ZSTD_c_strategy, strat));
-return (srcSize >> minlog) + 2;
-}
-static 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* workspace, size_t wkspSize,
-const int bmi2)
-{
-size_t const minGain = ZSTD_minGain(srcSize, strategy);
-size_t const lhSize = 3 + (srcSize >= 1 KB) + (srcSize >= 16 KB);
-BYTE*  const ostart = (BYTE*)dst;
-U32 singleStream = srcSize < 256;
-symbolEncodingType_e hType = set_compressed;
-size_t cLitSize;
-DEBUGLOG(5,"ZSTD_compressLiterals (disableLiteralCompression=%i)",
-disableLiteralCompression);
-/* Prepare nextEntropy assuming reusing the existing table */
-memcpy(nextHuf, prevHuf, sizeof(*prevHuf));
-if (disableLiteralCompression)
-return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize);
-/* small ? don't even attempt compression (speed opt) */
-#   define COMPRESS_LITERALS_SIZE_MIN 63
-{   size_t const minLitSize = (prevHuf->repeatMode == HUF_repeat_valid) ? 6 : COMPRESS_LITERALS_SIZE_MIN;
-if (srcSize <= minLitSize) return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize);
-}
-if (dstCapacity < lhSize+1) return ERROR(dstSize_tooSmall);   /* not enough space for compression */
-{   HUF_repeat repeat = prevHuf->repeatMode;
-int const preferRepeat = strategy < ZSTD_lazy ? srcSize <= 1024 : 0;
-if (repeat == HUF_repeat_valid && lhSize == 3) singleStream = 1;
-cLitSize = singleStream ? HUF_compress1X_repeat(ostart+lhSize, dstCapacity-lhSize, src, srcSize, 255, 11,
-workspace, wkspSize, (HUF_CElt*)nextHuf->CTable, &repeat, preferRepeat, bmi2)
-: HUF_compress4X_repeat(ostart+lhSize, dstCapacity-lhSize, src, srcSize, 255, 11,
-workspace, wkspSize, (HUF_CElt*)nextHuf->CTable, &repeat, preferRepeat, bmi2);
-if (repeat != HUF_repeat_none) {
-/* reused the existing table */
-hType = set_repeat;
-}
-}
-if ((cLitSize==0) | (cLitSize >= srcSize - minGain) | ERR_isError(cLitSize)) {
-memcpy(nextHuf, prevHuf, sizeof(*prevHuf));
-return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize);
-}
-if (cLitSize==1) {
-memcpy(nextHuf, prevHuf, sizeof(*prevHuf));
-return ZSTD_compressRleLiteralsBlock(dst, dstCapacity, src, srcSize);
-}
-if (hType == set_compressed) {
-/* using a newly constructed table */
-nextHuf->repeatMode = HUF_repeat_check;
-}
-/* Build header */
-switch(lhSize)
-{
-case 3: /* 2 - 2 - 10 - 10 */
-{   U32 const lhc = hType + ((!singleStream) << 2) + ((U32)srcSize<<4) + ((U32)cLitSize<<14);
-MEM_writeLE24(ostart, lhc);
-break;
-}
-case 4: /* 2 - 2 - 14 - 14 */
-{   U32 const lhc = hType + (2 << 2) + ((U32)srcSize<<4) + ((U32)cLitSize<<18);
-MEM_writeLE32(ostart, lhc);
-break;
-}
-case 5: /* 2 - 2 - 18 - 18 */
-{   U32 const lhc = hType + (3 << 2) + ((U32)srcSize<<4) + ((U32)cLitSize<<22);
-MEM_writeLE32(ostart, lhc);
-ostart[4] = (BYTE)(cLitSize >> 10);
-break;
-}
-default:  /* not possible : lhSize is {3,4,5} */
-assert(0);
-}
-return lhSize+cLitSize;
-}
 void ZSTD_seqToCodes(const seqStore_t* seqStorePtr)
 {
 const seqDef* const sequences = seqStorePtr->sequencesStart;
 BYTE* const llCodeTable = seqStorePtr->llCode;
 llCodeTable[seqStorePtr->longLengthPos] = MaxLL;
 if (seqStorePtr->longLengthID==2)
 mlCodeTable[seqStorePtr->longLengthPos] = MaxML;
 }
+static int ZSTD_disableLiteralsCompression(const ZSTD_CCtx_params* cctxParams)
-/**
+{
-* -log2(x / 256) lookup table for x in [0, 256).
+switch (cctxParams->literalCompressionMode) {
-* If x == 0: Return 0
+case ZSTD_lcm_huffman:
-* Else: Return floor(-log2(x / 256) * 256)
+return 0;
-*/
+case ZSTD_lcm_uncompressed:
-static unsigned const kInverseProbabiltyLog256[256] = {
-0,    2048, 1792, 1642, 1536, 1453, 1386, 1329, 1280, 1236, 1197, 1162,
-1130, 1100, 1073, 1047, 1024, 1001, 980,  960,  941,  923,  906,  889,
-874,  859,  844,  830,  817,  804,  791,  779,  768,  756,  745,  734,
-724,  714,  704,  694,  685,  676,  667,  658,  650,  642,  633,  626,
-618,  610,  603,  595,  588,  581,  574,  567,  561,  554,  548,  542,
-535,  529,  523,  517,  512,  506,  500,  495,  489,  484,  478,  473,
-468,  463,  458,  453,  448,  443,  438,  434,  429,  424,  420,  415,
-411,  407,  402,  398,  394,  390,  386,  382,  377,  373,  370,  366,
-362,  358,  354,  350,  347,  343,  339,  336,  332,  329,  325,  322,
-318,  315,  311,  308,  305,  302,  298,  295,  292,  289,  286,  282,
-279,  276,  273,  270,  267,  264,  261,  258,  256,  253,  250,  247,
-244,  241,  239,  236,  233,  230,  228,  225,  222,  220,  217,  215,
-212,  209,  207,  204,  202,  199,  197,  194,  192,  190,  187,  185,
-182,  180,  178,  175,  173,  171,  168,  166,  164,  162,  159,  157,
-155,  153,  151,  149,  146,  144,  142,  140,  138,  136,  134,  132,
-130,  128,  126,  123,  121,  119,  117,  115,  114,  112,  110,  108,
-106,  104,  102,  100,  98,   96,   94,   93,   91,   89,   87,   85,
-83,   82,   80,   78,   76,   74,   73,   71,   69,   67,   66,   64,
-62,   61,   59,   57,   55,   54,   52,   50,   49,   47,   46,   44,
-42,   41,   39,   37,   36,   34,   33,   31,   30,   28,   26,   25,
-23,   22,   20,   19,   17,   16,   14,   13,   11,   10,   8,    7,
-5,    4,    2,    1,
-};
-/**
-* Returns the cost in bits of encoding the distribution described by count
-* using the entropy bound.
-*/
-static size_t ZSTD_entropyCost(unsigned const* count, unsigned const max, size_t const total)
-{
-unsigned cost = 0;
-unsigned s;
-for (s = 0; s <= max; ++s) {
-unsigned norm = (unsigned)((256 * count[s]) / total);
-if (count[s] != 0 && norm == 0)
-norm = 1;
-assert(count[s] < total);
-cost += count[s] * kInverseProbabiltyLog256[norm];
-}
-return cost >> 8;
-}
-/**
-* Returns the cost in bits of encoding the distribution in count using the
-* table described by norm. The max symbol support by norm is assumed >= max.
-* norm must be valid for every symbol with non-zero probability in count.
-*/
-static size_t ZSTD_crossEntropyCost(short const* norm, unsigned accuracyLog,
-unsigned const* count, unsigned const max)
-{
-unsigned const shift = 8 - accuracyLog;
-size_t cost = 0;
-unsigned s;
-assert(accuracyLog <= 8);
-for (s = 0; s <= max; ++s) {
-unsigned const normAcc = norm[s] != -1 ? norm[s] : 1;
-unsigned const norm256 = normAcc << shift;
-assert(norm256 > 0);
-assert(norm256 < 256);
-cost += count[s] * kInverseProbabiltyLog256[norm256];
-}
-return cost >> 8;
-}
-static unsigned ZSTD_getFSEMaxSymbolValue(FSE_CTable const* ctable) {
-void const* ptr = ctable;
-U16 const* u16ptr = (U16 const*)ptr;
-U32 const maxSymbolValue = MEM_read16(u16ptr + 1);
-return maxSymbolValue;
-}
-/**
-* Returns the cost in bits of encoding the distribution in count using ctable.
-* Returns an error if ctable cannot represent all the symbols in count.
-*/
-static size_t ZSTD_fseBitCost(
-FSE_CTable const* ctable,
-unsigned const* count,
-unsigned const max)
-{
-unsigned const kAccuracyLog = 8;
-size_t cost = 0;
-unsigned s;
-FSE_CState_t cstate;
-FSE_initCState(&cstate, ctable);
-if (ZSTD_getFSEMaxSymbolValue(ctable) < max) {
-DEBUGLOG(5, "Repeat FSE_CTable has maxSymbolValue %u < %u",
-ZSTD_getFSEMaxSymbolValue(ctable), max);
-return ERROR(GENERIC);
-}
-for (s = 0; s <= max; ++s) {
-unsigned const tableLog = cstate.stateLog;
-unsigned const badCost = (tableLog + 1) << kAccuracyLog;
-unsigned const bitCost = FSE_bitCost(cstate.symbolTT, tableLog, s, kAccuracyLog);
-if (count[s] == 0)
-continue;
-if (bitCost >= badCost) {
-DEBUGLOG(5, "Repeat FSE_CTable has Prob[%u] == 0", s);
-return ERROR(GENERIC);
-}
-cost += count[s] * bitCost;
-}
-return cost >> kAccuracyLog;
-}
-/**
-* Returns the cost in bytes of encoding the normalized count header.
-* Returns an error if any of the helper functions return an error.
-*/
-static size_t ZSTD_NCountCost(unsigned const* count, unsigned const max,
-size_t const nbSeq, unsigned const FSELog)
-{
-BYTE wksp[FSE_NCOUNTBOUND];
-S16 norm[MaxSeq + 1];
-const U32 tableLog = FSE_optimalTableLog(FSELog, nbSeq, max);
-CHECK_F(FSE_normalizeCount(norm, tableLog, count, nbSeq, max));
-return FSE_writeNCount(wksp, sizeof(wksp), norm, max, tableLog);
-}
-typedef enum {
-ZSTD_defaultDisallowed = 0,
-ZSTD_defaultAllowed = 1
-} ZSTD_defaultPolicy_e;
-MEM_STATIC 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)
-{
-ZSTD_STATIC_ASSERT(ZSTD_defaultDisallowed == 0 && ZSTD_defaultAllowed != 0);
-if (mostFrequent == nbSeq) {
-*repeatMode = FSE_repeat_none;
-if (isDefaultAllowed && nbSeq <= 2) {
-/* Prefer set_basic over set_rle when there are 2 or less symbols,
-* since RLE uses 1 byte, but set_basic uses 5-6 bits per symbol.
-* If basic encoding isn't possible, always choose RLE.
-*/
-DEBUGLOG(5, "Selected set_basic");
-return set_basic;
-}
-DEBUGLOG(5, "Selected set_rle");
-return set_rle;
-}
-if (strategy < ZSTD_lazy) {
-if (isDefaultAllowed) {
-size_t const staticFse_nbSeq_max = 1000;
-size_t const mult = 10 - strategy;
-size_t const baseLog = 3;
-size_t const dynamicFse_nbSeq_min = (((size_t)1 << defaultNormLog) * mult) >> baseLog;  /* 28-36 for offset, 56-72 for lengths */
-assert(defaultNormLog >= 5 && defaultNormLog <= 6);  /* xx_DEFAULTNORMLOG */
-assert(mult <= 9 && mult >= 7);
-if ( (*repeatMode == FSE_repeat_valid)
-&& (nbSeq < staticFse_nbSeq_max) ) {
-DEBUGLOG(5, "Selected set_repeat");
-return set_repeat;
-}
-if ( (nbSeq < dynamicFse_nbSeq_min)
-|| (mostFrequent < (nbSeq >> (defaultNormLog-1))) ) {
-DEBUGLOG(5, "Selected set_basic");
-/* The format allows default tables to be repeated, but it isn't useful.
-* When using simple heuristics to select encoding type, we don't want
-* to confuse these tables with dictionaries. When running more careful
-* analysis, we don't need to waste time checking both repeating tables
-* and default tables.
-*/
-*repeatMode = FSE_repeat_none;
-return set_basic;
-}
-}
-} else {
-size_t const basicCost = isDefaultAllowed ? ZSTD_crossEntropyCost(defaultNorm, defaultNormLog, count, max) : ERROR(GENERIC);
-size_t const repeatCost = *repeatMode != FSE_repeat_none ? ZSTD_fseBitCost(prevCTable, count, max) : ERROR(GENERIC);
-size_t const NCountCost = ZSTD_NCountCost(count, max, nbSeq, FSELog);
-size_t const compressedCost = (NCountCost << 3) + ZSTD_entropyCost(count, max, nbSeq);
-if (isDefaultAllowed) {
-assert(!ZSTD_isError(basicCost));
-assert(!(*repeatMode == FSE_repeat_valid && ZSTD_isError(repeatCost)));
-}
-assert(!ZSTD_isError(NCountCost));
-assert(compressedCost < ERROR(maxCode));
-DEBUGLOG(5, "Estimated bit costs: basic=%u\trepeat=%u\tcompressed=%u",
-(unsigned)basicCost, (unsigned)repeatCost, (unsigned)compressedCost);
-if (basicCost <= repeatCost && basicCost <= compressedCost) {
-DEBUGLOG(5, "Selected set_basic");
-assert(isDefaultAllowed);
-*repeatMode = FSE_repeat_none;
-return set_basic;
-}
-if (repeatCost <= compressedCost) {
-DEBUGLOG(5, "Selected set_repeat");
-assert(!ZSTD_isError(repeatCost));
-return set_repeat;
-}
-assert(compressedCost < basicCost && compressedCost < repeatCost);
-}
-DEBUGLOG(5, "Selected set_compressed");
-*repeatMode = FSE_repeat_check;
-return set_compressed;
-}
-MEM_STATIC 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* workspace, size_t workspaceSize)
-{
-BYTE* op = (BYTE*)dst;
-const BYTE* const oend = op + dstCapacity;
-DEBUGLOG(6, "ZSTD_buildCTable (dstCapacity=%u)", (unsigned)dstCapacity);
-switch (type) {
-case set_rle:
-CHECK_F(FSE_buildCTable_rle(nextCTable, (BYTE)max));
-if (dstCapacity==0) return ERROR(dstSize_tooSmall);
-*op = codeTable[0];
 return 1;
-case set_repeat:
+default:
-memcpy(nextCTable, prevCTable, prevCTableSize);
+assert(0 /* impossible: pre-validated */);
-return 0;
+/* fall-through */
-case set_basic:
+case ZSTD_lcm_auto:
-CHECK_F(FSE_buildCTable_wksp(nextCTable, defaultNorm, defaultMax, defaultNormLog, workspace, workspaceSize));  /* note : could be pre-calculated */
+return (cctxParams->cParams.strategy == ZSTD_fast) && (cctxParams->cParams.targetLength > 0);
-return 0;
+}
-case set_compressed: {
-S16 norm[MaxSeq + 1];
-size_t nbSeq_1 = nbSeq;
-const U32 tableLog = FSE_optimalTableLog(FSELog, nbSeq, max);
-if (count[codeTable[nbSeq-1]] > 1) {
-count[codeTable[nbSeq-1]]--;
-nbSeq_1--;
-}
-assert(nbSeq_1 > 1);
-CHECK_F(FSE_normalizeCount(norm, tableLog, count, nbSeq_1, max));
-{   size_t const NCountSize = FSE_writeNCount(op, oend - op, norm, max, tableLog);   /* overflow protected */
-if (FSE_isError(NCountSize)) return NCountSize;
-CHECK_F(FSE_buildCTable_wksp(nextCTable, norm, max, tableLog, workspace, workspaceSize));
-return NCountSize;
-}
-}
-default: return assert(0), ERROR(GENERIC);
-}
-}
-FORCE_INLINE_TEMPLATE size_t
-ZSTD_encodeSequences_body(
-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)
-{
-BIT_CStream_t blockStream;
-FSE_CState_t  stateMatchLength;
-FSE_CState_t  stateOffsetBits;
-FSE_CState_t  stateLitLength;
-CHECK_E(BIT_initCStream(&blockStream, dst, dstCapacity), dstSize_tooSmall); /* not enough space remaining */
-DEBUGLOG(6, "available space for bitstream : %i  (dstCapacity=%u)",
-(int)(blockStream.endPtr - blockStream.startPtr),
-(unsigned)dstCapacity);
-/* first symbols */
-FSE_initCState2(&stateMatchLength, CTable_MatchLength, mlCodeTable[nbSeq-1]);
-FSE_initCState2(&stateOffsetBits,  CTable_OffsetBits,  ofCodeTable[nbSeq-1]);
-FSE_initCState2(&stateLitLength,   CTable_LitLength,   llCodeTable[nbSeq-1]);
-BIT_addBits(&blockStream, sequences[nbSeq-1].litLength, LL_bits[llCodeTable[nbSeq-1]]);
-if (MEM_32bits()) BIT_flushBits(&blockStream);
-BIT_addBits(&blockStream, sequences[nbSeq-1].matchLength, ML_bits[mlCodeTable[nbSeq-1]]);
-if (MEM_32bits()) BIT_flushBits(&blockStream);
-if (longOffsets) {
-U32 const ofBits = ofCodeTable[nbSeq-1];
-int const extraBits = ofBits - MIN(ofBits, STREAM_ACCUMULATOR_MIN-1);
-if (extraBits) {
-BIT_addBits(&blockStream, sequences[nbSeq-1].offset, extraBits);
-BIT_flushBits(&blockStream);
-}
-BIT_addBits(&blockStream, sequences[nbSeq-1].offset >> extraBits,
-ofBits - extraBits);
-} else {
-BIT_addBits(&blockStream, sequences[nbSeq-1].offset, ofCodeTable[nbSeq-1]);
-}
-BIT_flushBits(&blockStream);
-{   size_t n;
-for (n=nbSeq-2 ; n<nbSeq ; n--) {      /* intentional underflow */
-BYTE const llCode = llCodeTable[n];
-BYTE const ofCode = ofCodeTable[n];
-BYTE const mlCode = mlCodeTable[n];
-U32  const llBits = LL_bits[llCode];
-U32  const ofBits = ofCode;
-U32  const mlBits = ML_bits[mlCode];
-DEBUGLOG(6, "encoding: litlen:%2u - matchlen:%2u - offCode:%7u",
-(unsigned)sequences[n].litLength,
-(unsigned)sequences[n].matchLength + MINMATCH,
-(unsigned)sequences[n].offset);
-/* 32b*/  /* 64b*/
-/* (7)*/  /* (7)*/
-FSE_encodeSymbol(&blockStream, &stateOffsetBits, ofCode);       /* 15 */  /* 15 */
-FSE_encodeSymbol(&blockStream, &stateMatchLength, mlCode);      /* 24 */  /* 24 */
-if (MEM_32bits()) BIT_flushBits(&blockStream);                  /* (7)*/
-FSE_encodeSymbol(&blockStream, &stateLitLength, llCode);        /* 16 */  /* 33 */
-if (MEM_32bits() || (ofBits+mlBits+llBits >= 64-7-(LLFSELog+MLFSELog+OffFSELog)))
-BIT_flushBits(&blockStream);                                /* (7)*/
-BIT_addBits(&blockStream, sequences[n].litLength, llBits);
-if (MEM_32bits() && ((llBits+mlBits)>24)) BIT_flushBits(&blockStream);
-BIT_addBits(&blockStream, sequences[n].matchLength, mlBits);
-if (MEM_32bits() || (ofBits+mlBits+llBits > 56)) BIT_flushBits(&blockStream);
-if (longOffsets) {
-int const extraBits = ofBits - MIN(ofBits, STREAM_ACCUMULATOR_MIN-1);
-if (extraBits) {
-BIT_addBits(&blockStream, sequences[n].offset, extraBits);
-BIT_flushBits(&blockStream);                            /* (7)*/
-}
-BIT_addBits(&blockStream, sequences[n].offset >> extraBits,
-ofBits - extraBits);                            /* 31 */
-} else {
-BIT_addBits(&blockStream, sequences[n].offset, ofBits);     /* 31 */
-}
-BIT_flushBits(&blockStream);                                    /* (7)*/
-DEBUGLOG(7, "remaining space : %i", (int)(blockStream.endPtr - blockStream.ptr));
-}   }
-DEBUGLOG(6, "ZSTD_encodeSequences: flushing ML state with %u bits", stateMatchLength.stateLog);
-FSE_flushCState(&blockStream, &stateMatchLength);
-DEBUGLOG(6, "ZSTD_encodeSequences: flushing Off state with %u bits", stateOffsetBits.stateLog);
-FSE_flushCState(&blockStream, &stateOffsetBits);
-DEBUGLOG(6, "ZSTD_encodeSequences: flushing LL state with %u bits", stateLitLength.stateLog);
-FSE_flushCState(&blockStream, &stateLitLength);
-{   size_t const streamSize = BIT_closeCStream(&blockStream);
-if (streamSize==0) return ERROR(dstSize_tooSmall);   /* not enough space */
-return streamSize;
-}
-}
-static size_t
-ZSTD_encodeSequences_default(
-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)
-{
-return ZSTD_encodeSequences_body(dst, dstCapacity,
-CTable_MatchLength, mlCodeTable,
-CTable_OffsetBits, ofCodeTable,
-CTable_LitLength, llCodeTable,
-sequences, nbSeq, longOffsets);
-}
-#if DYNAMIC_BMI2
-static TARGET_ATTRIBUTE("bmi2") size_t
-ZSTD_encodeSequences_bmi2(
-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)
-{
-return ZSTD_encodeSequences_body(dst, dstCapacity,
-CTable_MatchLength, mlCodeTable,
-CTable_OffsetBits, ofCodeTable,
-CTable_LitLength, llCodeTable,
-sequences, nbSeq, longOffsets);
-}
-#endif
-static 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)
-{
-DEBUGLOG(5, "ZSTD_encodeSequences: dstCapacity = %u", (unsigned)dstCapacity);
-#if DYNAMIC_BMI2
-if (bmi2) {
-return ZSTD_encodeSequences_bmi2(dst, dstCapacity,
-CTable_MatchLength, mlCodeTable,
-CTable_OffsetBits, ofCodeTable,
-CTable_LitLength, llCodeTable,
-sequences, nbSeq, longOffsets);
-}
-#endif
-(void)bmi2;
-return ZSTD_encodeSequences_default(dst, dstCapacity,
-CTable_MatchLength, mlCodeTable,
-CTable_OffsetBits, ofCodeTable,
-CTable_LitLength, llCodeTable,
-sequences, nbSeq, longOffsets);
 }
 /* ZSTD_compressSequences_internal():
 * actually compresses both literals and sequences */
 MEM_STATIC size_t
 const BYTE* const llCodeTable = seqStorePtr->llCode;
 const BYTE* const mlCodeTable = seqStorePtr->mlCode;
 BYTE* const ostart = (BYTE*)dst;
 BYTE* const oend = ostart + dstCapacity;
 BYTE* op = ostart;
-size_t const nbSeq = seqStorePtr->sequences - seqStorePtr->sequencesStart;
+size_t const nbSeq = (size_t)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
 BYTE* seqHead;
 BYTE* lastNCount = NULL;
+DEBUGLOG(5, "ZSTD_compressSequences_internal (nbSeq=%zu)", nbSeq);
 ZSTD_STATIC_ASSERT(HUF_WORKSPACE_SIZE >= (1<<MAX(MLFSELog,LLFSELog)));
-DEBUGLOG(5, "ZSTD_compressSequences_internal");
 /* Compress literals */
 {   const BYTE* const literals = seqStorePtr->litStart;
-size_t const litSize = seqStorePtr->lit - literals;
+size_t const litSize = (size_t)(seqStorePtr->lit - literals);
-int const disableLiteralCompression = (cctxParams->cParams.strategy == ZSTD_fast) && (cctxParams->cParams.targetLength > 0);
 size_t const cSize = ZSTD_compressLiterals(
 &prevEntropy->huf, &nextEntropy->huf,
-cctxParams->cParams.strategy, disableLiteralCompression,
+cctxParams->cParams.strategy,
+ZSTD_disableLiteralsCompression(cctxParams),
 op, dstCapacity,
 literals, litSize,
 workspace, wkspSize,
 bmi2);
-if (ZSTD_isError(cSize))
+FORWARD_IF_ERROR(cSize);
-return cSize;
 assert(cSize <= dstCapacity);
 op += cSize;
 }
 /* Sequences Header */
-if ((oend-op) < 3 /*max nbSeq Size*/ + 1 /*seqHead*/) return ERROR(dstSize_tooSmall);
+RETURN_ERROR_IF((oend-op) < 3 /*max nbSeq Size*/ + 1 /*seqHead*/,
+dstSize_tooSmall);
 if (nbSeq < 0x7F)
 *op++ = (BYTE)nbSeq;
 else if (nbSeq < LONGNBSEQ)
 op[0] = (BYTE)((nbSeq>>8) + 0x80), op[1] = (BYTE)nbSeq, op+=2;
 else
 op[0]=0xFF, MEM_writeLE16(op+1, (U16)(nbSeq - LONGNBSEQ)), op+=3;
+assert(op <= oend);
 if (nbSeq==0) {
 /* Copy the old tables over as if we repeated them */
 memcpy(&nextEntropy->fse, &prevEntropy->fse, sizeof(prevEntropy->fse));
-return op - ostart;
+return (size_t)(op - ostart);
 }
 /* seqHead : flags for FSE encoding type */
 seqHead = op++;
+assert(op <= oend);
 /* convert length/distances into codes */
 ZSTD_seqToCodes(seqStorePtr);
 /* build CTable for Literal Lengths */
 {   unsigned max = MaxLL;
 LLFSELog, prevEntropy->fse.litlengthCTable,
 LL_defaultNorm, LL_defaultNormLog,
 ZSTD_defaultAllowed, strategy);
 assert(set_basic < set_compressed && set_rle < set_compressed);
 assert(!(LLtype < set_compressed && nextEntropy->fse.litlength_repeatMode != FSE_repeat_none)); /* We don't copy tables */
-{   size_t const countSize = ZSTD_buildCTable(op, oend - op, CTable_LitLength, LLFSELog, (symbolEncodingType_e)LLtype,
+{   size_t const countSize = ZSTD_buildCTable(op, (size_t)(oend - op), CTable_LitLength, LLFSELog, (symbolEncodingType_e)LLtype,
 count, max, llCodeTable, nbSeq, LL_defaultNorm, LL_defaultNormLog, MaxLL,
 prevEntropy->fse.litlengthCTable, sizeof(prevEntropy->fse.litlengthCTable),
 workspace, wkspSize);
-if (ZSTD_isError(countSize)) return countSize;
+FORWARD_IF_ERROR(countSize);
 if (LLtype == set_compressed)
 lastNCount = op;
 op += countSize;
+assert(op <= oend);
 }   }
 /* build CTable for Offsets */
 {   unsigned max = MaxOff;
 size_t const mostFrequent = HIST_countFast_wksp(count, &max, ofCodeTable, nbSeq, workspace, wkspSize);  /* can't fail */
 /* We can only use the basic table if max <= DefaultMaxOff, otherwise the offsets are too large */
 count, max, mostFrequent, nbSeq,
 OffFSELog, prevEntropy->fse.offcodeCTable,
 OF_defaultNorm, OF_defaultNormLog,
 defaultPolicy, strategy);
 assert(!(Offtype < set_compressed && nextEntropy->fse.offcode_repeatMode != FSE_repeat_none)); /* We don't copy tables */
-{   size_t const countSize = ZSTD_buildCTable(op, oend - op, CTable_OffsetBits, OffFSELog, (symbolEncodingType_e)Offtype,
+{   size_t const countSize = ZSTD_buildCTable(op, (size_t)(oend - op), CTable_OffsetBits, OffFSELog, (symbolEncodingType_e)Offtype,
 count, max, ofCodeTable, nbSeq, OF_defaultNorm, OF_defaultNormLog, DefaultMaxOff,
 prevEntropy->fse.offcodeCTable, sizeof(prevEntropy->fse.offcodeCTable),
 workspace, wkspSize);
-if (ZSTD_isError(countSize)) return countSize;
+FORWARD_IF_ERROR(countSize);
 if (Offtype == set_compressed)
 lastNCount = op;
 op += countSize;
+assert(op <= oend);
 }   }
 /* build CTable for MatchLengths */
 {   unsigned max = MaxML;
 size_t const mostFrequent = HIST_countFast_wksp(count, &max, mlCodeTable, nbSeq, workspace, wkspSize);   /* can't fail */
 DEBUGLOG(5, "Building ML table (remaining space : %i)", (int)(oend-op));
 count, max, mostFrequent, nbSeq,
 MLFSELog, prevEntropy->fse.matchlengthCTable,
 ML_defaultNorm, ML_defaultNormLog,
 ZSTD_defaultAllowed, strategy);
 assert(!(MLtype < set_compressed && nextEntropy->fse.matchlength_repeatMode != FSE_repeat_none)); /* We don't copy tables */
-{   size_t const countSize = ZSTD_buildCTable(op, oend - op, CTable_MatchLength, MLFSELog, (symbolEncodingType_e)MLtype,
+{   size_t const countSize = ZSTD_buildCTable(op, (size_t)(oend - op), CTable_MatchLength, MLFSELog, (symbolEncodingType_e)MLtype,
 count, max, mlCodeTable, nbSeq, ML_defaultNorm, ML_defaultNormLog, MaxML,
 prevEntropy->fse.matchlengthCTable, sizeof(prevEntropy->fse.matchlengthCTable),
 workspace, wkspSize);
-if (ZSTD_isError(countSize)) return countSize;
+FORWARD_IF_ERROR(countSize);
 if (MLtype == set_compressed)
 lastNCount = op;
 op += countSize;
+assert(op <= oend);
 }   }
 *seqHead = (BYTE)((LLtype<<6) + (Offtype<<4) + (MLtype<<2));
 {   size_t const bitstreamSize = ZSTD_encodeSequences(
-op, oend - op,
+op, (size_t)(oend - op),
 CTable_MatchLength, mlCodeTable,
 CTable_OffsetBits, ofCodeTable,
 CTable_LitLength, llCodeTable,
 sequences, nbSeq,
 longOffsets, bmi2);
-if (ZSTD_isError(bitstreamSize)) return bitstreamSize;
+FORWARD_IF_ERROR(bitstreamSize);
 op += bitstreamSize;
+assert(op <= oend);
 /* zstd versions <= 1.3.4 mistakenly report corruption when
-* FSE_readNCount() recieves a buffer < 4 bytes.
+* FSE_readNCount() receives a buffer < 4 bytes.
 * Fixed by https://github.com/facebook/zstd/pull/1146.
 * This can happen when the last set_compressed table present is 2
 * bytes and the bitstream is only one byte.
 * In this exceedingly rare case, we will simply emit an uncompressed
 * block, since it isn't worth optimizing.
 return 0;
 }
 }
 DEBUGLOG(5, "compressed block size : %u", (unsigned)(op - ostart));
-return op - ostart;
+return (size_t)(op - ostart);
 }
 MEM_STATIC size_t
 ZSTD_compressSequences(seqStore_t* seqStorePtr,
 const ZSTD_entropyCTables_t* prevEntropy,
 /* When srcSize <= dstCapacity, there is enough space to write a raw uncompressed block.
 * Since we ran out of space, block must be not compressible, so fall back to raw uncompressed block.
 */
 if ((cSize == ERROR(dstSize_tooSmall)) & (srcSize <= dstCapacity))
 return 0;  /* block not compressed */
-if (ZSTD_isError(cSize)) return cSize;
+FORWARD_IF_ERROR(cSize);
 /* Check compressibility */
 {   size_t const maxCSize = srcSize - ZSTD_minGain(srcSize, cctxParams->cParams.strategy);
 if (cSize >= maxCSize) return 0;  /* block not compressed */
 }
 ssPtr->lit = ssPtr->litStart;
 ssPtr->sequences = ssPtr->sequencesStart;
 ssPtr->longLengthID = 0;
 }
-static size_t ZSTD_compressBlock_internal(ZSTD_CCtx* zc,
+typedef enum { ZSTDbss_compress, ZSTDbss_noCompress } ZSTD_buildSeqStore_e;
-void* dst, size_t dstCapacity,
-const void* src, size_t srcSize)
+static size_t ZSTD_buildSeqStore(ZSTD_CCtx* zc, const void* src, size_t srcSize)
 {
 ZSTD_matchState_t* const ms = &zc->blockState.matchState;
-size_t cSize;
+DEBUGLOG(5, "ZSTD_buildSeqStore (srcSize=%zu)", srcSize);
-DEBUGLOG(5, "ZSTD_compressBlock_internal (dstCapacity=%u, dictLimit=%u, nextToUpdate=%u)",
-(unsigned)dstCapacity, (unsigned)ms->window.dictLimit, (unsigned)ms->nextToUpdate);
 assert(srcSize <= ZSTD_BLOCKSIZE_MAX);
 /* Assert that we have correctly flushed the ctx params into the ms's copy */
 ZSTD_assertEqualCParams(zc->appliedParams.cParams, ms->cParams);
 if (srcSize < MIN_CBLOCK_SIZE+ZSTD_blockHeaderSize+1) {
 ZSTD_ldm_skipSequences(&zc->externSeqStore, srcSize, zc->appliedParams.cParams.minMatch);
-cSize = 0;
+return ZSTDbss_noCompress; /* don't even attempt compression below a certain srcSize */
-goto out;  /* don't even attempt compression below a certain srcSize */
 }
 ZSTD_resetSeqStore(&(zc->seqStore));
-ms->opt.symbolCosts = &zc->blockState.prevCBlock->entropy;   /* required for optimal parser to read stats from dictionary */
+/* required for optimal parser to read stats from dictionary */
+ms->opt.symbolCosts = &zc->blockState.prevCBlock->entropy;
+/* tell the optimal parser how we expect to compress literals */
+ms->opt.literalCompressionMode = zc->appliedParams.literalCompressionMode;
 /* a gap between an attached dict and the current window is not safe,
 * they must remain adjacent,
 * and when that stops being the case, the dict must be unset */
 assert(ms->dictMatchState == NULL || ms->loadedDictEnd == ms->window.dictLimit);
 rawSeqStore_t ldmSeqStore = {NULL, 0, 0, 0};
 ldmSeqStore.seq = zc->ldmSequences;
 ldmSeqStore.capacity = zc->maxNbLdmSequences;
 /* Updates ldmSeqStore.size */
-CHECK_F(ZSTD_ldm_generateSequences(&zc->ldmState, &ldmSeqStore,
+FORWARD_IF_ERROR(ZSTD_ldm_generateSequences(&zc->ldmState, &ldmSeqStore,
 &zc->appliedParams.ldmParams,
 src, srcSize));
 /* Updates ldmSeqStore.pos */
 lastLLSize =
 ZSTD_ldm_blockCompress(&ldmSeqStore,
 lastLLSize = blockCompressor(ms, &zc->seqStore, zc->blockState.nextCBlock->rep, src, srcSize);
 }
 {   const BYTE* const lastLiterals = (const BYTE*)src + srcSize - lastLLSize;
 ZSTD_storeLastLiterals(&zc->seqStore, lastLiterals, lastLLSize);
 }   }
+return ZSTDbss_compress;
+}
+static size_t ZSTD_compressBlock_internal(ZSTD_CCtx* zc,
+void* dst, size_t dstCapacity,
+const void* src, size_t srcSize)
+{
+size_t cSize;
+DEBUGLOG(5, "ZSTD_compressBlock_internal (dstCapacity=%u, dictLimit=%u, nextToUpdate=%u)",
+(unsigned)dstCapacity, (unsigned)zc->blockState.matchState.window.dictLimit,
+(unsigned)zc->blockState.matchState.nextToUpdate);
+{   const size_t bss = ZSTD_buildSeqStore(zc, src, srcSize);
+FORWARD_IF_ERROR(bss);
+if (bss == ZSTDbss_noCompress) { cSize = 0; goto out; }
+}
 /* encode sequences and literals */
 cSize = ZSTD_compressSequences(&zc->seqStore,
 &zc->blockState.prevCBlock->entropy, &zc->blockState.nextCBlock->entropy,
 &zc->appliedParams,
 */
 if (zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode == FSE_repeat_valid)
 zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode = FSE_repeat_check;
 return cSize;
+}
+static void ZSTD_overflowCorrectIfNeeded(ZSTD_matchState_t* ms, ZSTD_CCtx_params const* params, void const* ip, void const* iend)
+{
+if (ZSTD_window_needOverflowCorrection(ms->window, iend)) {
+U32 const maxDist = (U32)1 << params->cParams.windowLog;
+U32 const cycleLog = ZSTD_cycleLog(params->cParams.chainLog, params->cParams.strategy);
+U32 const correction = ZSTD_window_correctOverflow(&ms->window, cycleLog, maxDist, ip);
+ZSTD_STATIC_ASSERT(ZSTD_CHAINLOG_MAX <= 30);
+ZSTD_STATIC_ASSERT(ZSTD_WINDOWLOG_MAX_32 <= 30);
+ZSTD_STATIC_ASSERT(ZSTD_WINDOWLOG_MAX <= 31);
+ZSTD_reduceIndex(ms, params, correction);
+if (ms->nextToUpdate < correction) ms->nextToUpdate = 0;
+else ms->nextToUpdate -= correction;
+/* invalidate dictionaries on overflow correction */
+ms->loadedDictEnd = 0;
+ms->dictMatchState = NULL;
+}
 }
 /*! ZSTD_compress_frameChunk() :
 *   Compress a chunk of data into one or multiple blocks.
 size_t remaining = srcSize;
 const BYTE* ip = (const BYTE*)src;
 BYTE* const ostart = (BYTE*)dst;
 BYTE* op = ostart;
 U32 const maxDist = (U32)1 << cctx->appliedParams.cParams.windowLog;
-assert(cctx->appliedParams.cParams.windowLog <= 31);
+assert(cctx->appliedParams.cParams.windowLog <= ZSTD_WINDOWLOG_MAX);
 DEBUGLOG(5, "ZSTD_compress_frameChunk (blockSize=%u)", (unsigned)blockSize);
 if (cctx->appliedParams.fParams.checksumFlag && srcSize)
 XXH64_update(&cctx->xxhState, src, srcSize);
 while (remaining) {
 ZSTD_matchState_t* const ms = &cctx->blockState.matchState;
 U32 const lastBlock = lastFrameChunk & (blockSize >= remaining);
-if (dstCapacity < ZSTD_blockHeaderSize + MIN_CBLOCK_SIZE)
+RETURN_ERROR_IF(dstCapacity < ZSTD_blockHeaderSize + MIN_CBLOCK_SIZE,
-return ERROR(dstSize_tooSmall);   /* not enough space to store compressed block */
+dstSize_tooSmall,
+"not enough space to store compressed block");
 if (remaining < blockSize) blockSize = remaining;
-if (ZSTD_window_needOverflowCorrection(ms->window, ip + blockSize)) {
+ZSTD_overflowCorrectIfNeeded(ms, &cctx->appliedParams, ip, ip + blockSize);
-U32 const cycleLog = ZSTD_cycleLog(cctx->appliedParams.cParams.chainLog, cctx->appliedParams.cParams.strategy);
+ZSTD_checkDictValidity(&ms->window, ip + blockSize, maxDist, &ms->loadedDictEnd, &ms->dictMatchState);
-U32 const correction = ZSTD_window_correctOverflow(&ms->window, cycleLog, maxDist, ip);
-ZSTD_STATIC_ASSERT(ZSTD_CHAINLOG_MAX <= 30);
+/* Ensure hash/chain table insertion resumes no sooner than lowlimit */
-ZSTD_STATIC_ASSERT(ZSTD_WINDOWLOG_MAX_32 <= 30);
-ZSTD_STATIC_ASSERT(ZSTD_WINDOWLOG_MAX <= 31);
-ZSTD_reduceIndex(cctx, correction);
-if (ms->nextToUpdate < correction) ms->nextToUpdate = 0;
-else ms->nextToUpdate -= correction;
-ms->loadedDictEnd = 0;
-ms->dictMatchState = NULL;
-}
-ZSTD_window_enforceMaxDist(&ms->window, ip + blockSize, maxDist, &ms->loadedDictEnd, &ms->dictMatchState);
 if (ms->nextToUpdate < ms->window.lowLimit) ms->nextToUpdate = ms->window.lowLimit;
 {   size_t cSize = ZSTD_compressBlock_internal(cctx,
 op+ZSTD_blockHeaderSize, dstCapacity-ZSTD_blockHeaderSize,
 ip, blockSize);
-if (ZSTD_isError(cSize)) return cSize;
+FORWARD_IF_ERROR(cSize);
 if (cSize == 0) {  /* block is not compressible */
 cSize = ZSTD_noCompressBlock(op, dstCapacity, ip, blockSize, lastBlock);
-if (ZSTD_isError(cSize)) return cSize;
+FORWARD_IF_ERROR(cSize);
 } else {
 U32 const cBlockHeader24 = lastBlock + (((U32)bt_compressed)<<1) + (U32)(cSize << 3);
 MEM_writeLE24(op, cBlockHeader24);
 cSize += ZSTD_blockHeaderSize;
 }
 DEBUGLOG(5, "ZSTD_compress_frameChunk: adding a block of size %u",
 (unsigned)cSize);
 }   }
 if (lastFrameChunk && (op>ostart)) cctx->stage = ZSTDcs_ending;
-return op-ostart;
+return (size_t)(op-ostart);
 }
 static size_t ZSTD_writeFrameHeader(void* dst, size_t dstCapacity,
 ZSTD_CCtx_params params, U64 pledgedSrcSize, U32 dictID)
 U32   const windowSize = (U32)1 << params.cParams.windowLog;
 U32   const singleSegment = params.fParams.contentSizeFlag && (windowSize >= pledgedSrcSize);
 BYTE  const windowLogByte = (BYTE)((params.cParams.windowLog - ZSTD_WINDOWLOG_ABSOLUTEMIN) << 3);
 U32   const fcsCode = params.fParams.contentSizeFlag ?
 (pledgedSrcSize>=256) + (pledgedSrcSize>=65536+256) + (pledgedSrcSize>=0xFFFFFFFFU) : 0;  /* 0-3 */
-BYTE  const frameHeaderDecriptionByte = (BYTE)(dictIDSizeCode + (checksumFlag<<2) + (singleSegment<<5) + (fcsCode<<6) );
+BYTE  const frameHeaderDescriptionByte = (BYTE)(dictIDSizeCode + (checksumFlag<<2) + (singleSegment<<5) + (fcsCode<<6) );
 size_t pos=0;
 assert(!(params.fParams.contentSizeFlag && pledgedSrcSize == ZSTD_CONTENTSIZE_UNKNOWN));
-if (dstCapacity < ZSTD_FRAMEHEADERSIZE_MAX) return ERROR(dstSize_tooSmall);
+RETURN_ERROR_IF(dstCapacity < ZSTD_FRAMEHEADERSIZE_MAX, dstSize_tooSmall);
 DEBUGLOG(4, "ZSTD_writeFrameHeader : dictIDFlag : %u ; dictID : %u ; dictIDSizeCode : %u",
 !params.fParams.noDictIDFlag, (unsigned)dictID, (unsigned)dictIDSizeCode);
 if (params.format == ZSTD_f_zstd1) {
 MEM_writeLE32(dst, ZSTD_MAGICNUMBER);
 pos = 4;
 }
-op[pos++] = frameHeaderDecriptionByte;
+op[pos++] = frameHeaderDescriptionByte;
 if (!singleSegment) op[pos++] = windowLogByte;
 switch(dictIDSizeCode)
 {
 default:  assert(0); /* impossible */
 case 0 : break;
 }
 /* ZSTD_writeLastEmptyBlock() :
 * output an empty Block with end-of-frame mark to complete a frame
 * @return : size of data written into `dst` (== ZSTD_blockHeaderSize (defined in zstd_internal.h))
-*           or an error code if `dstCapcity` is too small (<ZSTD_blockHeaderSize)
+*           or an error code if `dstCapacity` is too small (<ZSTD_blockHeaderSize)
 */
 size_t ZSTD_writeLastEmptyBlock(void* dst, size_t dstCapacity)
 {
-if (dstCapacity < ZSTD_blockHeaderSize) return ERROR(dstSize_tooSmall);
+RETURN_ERROR_IF(dstCapacity < ZSTD_blockHeaderSize, dstSize_tooSmall);
 {   U32 const cBlockHeader24 = 1 /*lastBlock*/ + (((U32)bt_raw)<<1);  /* 0 size */
 MEM_writeLE24(dst, cBlockHeader24);
 return ZSTD_blockHeaderSize;
 }
 }
 size_t ZSTD_referenceExternalSequences(ZSTD_CCtx* cctx, rawSeq* seq, size_t nbSeq)
 {
-if (cctx->stage != ZSTDcs_init)
+RETURN_ERROR_IF(cctx->stage != ZSTDcs_init, stage_wrong);
-return ERROR(stage_wrong);
+RETURN_ERROR_IF(cctx->appliedParams.ldmParams.enableLdm,
-if (cctx->appliedParams.ldmParams.enableLdm)
+parameter_unsupported);
-return ERROR(parameter_unsupported);
 cctx->externSeqStore.seq = seq;
 cctx->externSeqStore.size = nbSeq;
 cctx->externSeqStore.capacity = nbSeq;
 cctx->externSeqStore.pos = 0;
 return 0;
 ZSTD_matchState_t* const ms = &cctx->blockState.matchState;
 size_t fhSize = 0;
 DEBUGLOG(5, "ZSTD_compressContinue_internal, stage: %u, srcSize: %u",
 cctx->stage, (unsigned)srcSize);
-if (cctx->stage==ZSTDcs_created) return ERROR(stage_wrong);   /* missing init (ZSTD_compressBegin) */
+RETURN_ERROR_IF(cctx->stage==ZSTDcs_created, stage_wrong,
+"missing init (ZSTD_compressBegin)");
 if (frame && (cctx->stage==ZSTDcs_init)) {
 fhSize = ZSTD_writeFrameHeader(dst, dstCapacity, cctx->appliedParams,
 cctx->pledgedSrcSizePlusOne-1, cctx->dictID);
-if (ZSTD_isError(fhSize)) return fhSize;
+FORWARD_IF_ERROR(fhSize);
+assert(fhSize <= dstCapacity);
 dstCapacity -= fhSize;
 dst = (char*)dst + fhSize;
 cctx->stage = ZSTDcs_ongoing;
 }
 ZSTD_window_update(&cctx->ldmState.window, src, srcSize);
 }
 if (!frame) {
 /* overflow check and correction for block mode */
-if (ZSTD_window_needOverflowCorrection(ms->window, (const char*)src + srcSize)) {
+ZSTD_overflowCorrectIfNeeded(ms, &cctx->appliedParams, src, (BYTE const*)src + srcSize);
-U32 const cycleLog = ZSTD_cycleLog(cctx->appliedParams.cParams.chainLog, cctx->appliedParams.cParams.strategy);
-U32 const correction = ZSTD_window_correctOverflow(&ms->window, cycleLog, 1 << cctx->appliedParams.cParams.windowLog, src);
-ZSTD_STATIC_ASSERT(ZSTD_CHAINLOG_MAX <= 30);
-ZSTD_STATIC_ASSERT(ZSTD_WINDOWLOG_MAX_32 <= 30);
-ZSTD_STATIC_ASSERT(ZSTD_WINDOWLOG_MAX <= 31);
-ZSTD_reduceIndex(cctx, correction);
-if (ms->nextToUpdate < correction) ms->nextToUpdate = 0;
-else ms->nextToUpdate -= correction;
-ms->loadedDictEnd = 0;
-ms->dictMatchState = NULL;
-}
 }
 DEBUGLOG(5, "ZSTD_compressContinue_internal (blockSize=%u)", (unsigned)cctx->blockSize);
 {   size_t const cSize = frame ?
 ZSTD_compress_frameChunk (cctx, dst, dstCapacity, src, srcSize, lastFrameChunk) :
 ZSTD_compressBlock_internal (cctx, dst, dstCapacity, src, srcSize);
-if (ZSTD_isError(cSize)) return cSize;
+FORWARD_IF_ERROR(cSize);
 cctx->consumedSrcSize += srcSize;
 cctx->producedCSize += (cSize + fhSize);
 assert(!(cctx->appliedParams.fParams.contentSizeFlag && cctx->pledgedSrcSizePlusOne == 0));
 if (cctx->pledgedSrcSizePlusOne != 0) {  /* control src size */
 ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_UNKNOWN == (unsigned long long)-1);
-if (cctx->consumedSrcSize+1 > cctx->pledgedSrcSizePlusOne) {
+RETURN_ERROR_IF(
-DEBUGLOG(4, "error : pledgedSrcSize = %u, while realSrcSize >= %u",
+cctx->consumedSrcSize+1 > cctx->pledgedSrcSizePlusOne,
-(unsigned)cctx->pledgedSrcSizePlusOne-1, (unsigned)cctx->consumedSrcSize);
+srcSize_wrong,
-return ERROR(srcSize_wrong);
+"error : pledgedSrcSize = %u, while realSrcSize >= %u",
-}
+(unsigned)cctx->pledgedSrcSizePlusOne-1,
+(unsigned)cctx->consumedSrcSize);
 }
 return cSize + fhSize;
 }
 }
 return MIN (ZSTD_BLOCKSIZE_MAX, (U32)1 << cParams.windowLog);
 }
 size_t ZSTD_compressBlock(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
 {
-size_t const blockSizeMax = ZSTD_getBlockSize(cctx);
+DEBUGLOG(5, "ZSTD_compressBlock: srcSize = %u", (unsigned)srcSize);
-if (srcSize > blockSizeMax) return ERROR(srcSize_wrong);
+{ size_t const blockSizeMax = ZSTD_getBlockSize(cctx);
+RETURN_ERROR_IF(srcSize > blockSizeMax, srcSize_wrong); }
 return ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 0 /* frame mode */, 0 /* last chunk */);
 }
 /*! ZSTD_loadDictionaryContent() :
 static size_t ZSTD_loadDictionaryContent(ZSTD_matchState_t* ms,
 ZSTD_CCtx_params const* params,
 const void* src, size_t srcSize,
 ZSTD_dictTableLoadMethod_e dtlm)
 {
-const BYTE* const ip = (const BYTE*) src;
+const BYTE* ip = (const BYTE*) src;
 const BYTE* const iend = ip + srcSize;
 ZSTD_window_update(&ms->window, src, srcSize);
 ms->loadedDictEnd = params->forceWindow ? 0 : (U32)(iend - ms->window.base);
 /* Assert that we the ms params match the params we're being given */
 ZSTD_assertEqualCParams(params->cParams, ms->cParams);
 if (srcSize <= HASH_READ_SIZE) return 0;
-switch(params->cParams.strategy)
+while (iend - ip > HASH_READ_SIZE) {
-{
+size_t const remaining = (size_t)(iend - ip);
-case ZSTD_fast:
+size_t const chunk = MIN(remaining, ZSTD_CHUNKSIZE_MAX);
-ZSTD_fillHashTable(ms, iend, dtlm);
+const BYTE* const ichunk = ip + chunk;
-break;
-case ZSTD_dfast:
+ZSTD_overflowCorrectIfNeeded(ms, params, ip, ichunk);
-ZSTD_fillDoubleHashTable(ms, iend, dtlm);
-break;
+switch(params->cParams.strategy)
+{
-case ZSTD_greedy:
+case ZSTD_fast:
-case ZSTD_lazy:
+ZSTD_fillHashTable(ms, ichunk, dtlm);
-case ZSTD_lazy2:
+break;
-if (srcSize >= HASH_READ_SIZE)
+case ZSTD_dfast:
-ZSTD_insertAndFindFirstIndex(ms, iend-HASH_READ_SIZE);
+ZSTD_fillDoubleHashTable(ms, ichunk, dtlm);
 break;
-case ZSTD_btlazy2:   /* we want the dictionary table fully sorted */
+case ZSTD_greedy:
-case ZSTD_btopt:
+case ZSTD_lazy:
-case ZSTD_btultra:
+case ZSTD_lazy2:
-case ZSTD_btultra2:
+if (chunk >= HASH_READ_SIZE)
-if (srcSize >= HASH_READ_SIZE)
+ZSTD_insertAndFindFirstIndex(ms, ichunk-HASH_READ_SIZE);
-ZSTD_updateTree(ms, iend-HASH_READ_SIZE, iend);
+break;
-break;
+case ZSTD_btlazy2:   /* we want the dictionary table fully sorted */
-default:
+case ZSTD_btopt:
-assert(0);  /* not possible : not a valid strategy id */
+case ZSTD_btultra:
+case ZSTD_btultra2:
+if (chunk >= HASH_READ_SIZE)
+ZSTD_updateTree(ms, ichunk-HASH_READ_SIZE, ichunk);
+break;
+default:
+assert(0);  /* not possible : not a valid strategy id */
+}
+ip = ichunk;
 }
 ms->nextToUpdate = (U32)(iend - ms->window.base);
 return 0;
 }
 when FSE encoding.  Refuse dictionaries that assign zero probability to symbols
 that we may encounter during compression.
 NOTE: This behavior is not standard and could be improved in the future. */
 static size_t ZSTD_checkDictNCount(short* normalizedCounter, unsigned dictMaxSymbolValue, unsigned maxSymbolValue) {
 U32 s;
-if (dictMaxSymbolValue < maxSymbolValue) return ERROR(dictionary_corrupted);
+RETURN_ERROR_IF(dictMaxSymbolValue < maxSymbolValue, dictionary_corrupted);
 for (s = 0; s <= maxSymbolValue; ++s) {
-if (normalizedCounter[s] == 0) return ERROR(dictionary_corrupted);
+RETURN_ERROR_IF(normalizedCounter[s] == 0, dictionary_corrupted);
 }
 return 0;
 }
 dictID = params->fParams.noDictIDFlag ? 0 :  MEM_readLE32(dictPtr);
 dictPtr += 4;
 {   unsigned maxSymbolValue = 255;
 size_t const hufHeaderSize = HUF_readCTable((HUF_CElt*)bs->entropy.huf.CTable, &maxSymbolValue, dictPtr, dictEnd-dictPtr);
-if (HUF_isError(hufHeaderSize)) return ERROR(dictionary_corrupted);
+RETURN_ERROR_IF(HUF_isError(hufHeaderSize), dictionary_corrupted);
-if (maxSymbolValue < 255) return ERROR(dictionary_corrupted);
+RETURN_ERROR_IF(maxSymbolValue < 255, dictionary_corrupted);
 dictPtr += hufHeaderSize;
 }
 {   unsigned offcodeLog;
 size_t const offcodeHeaderSize = FSE_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dictPtr, dictEnd-dictPtr);
-if (FSE_isError(offcodeHeaderSize)) return ERROR(dictionary_corrupted);
+RETURN_ERROR_IF(FSE_isError(offcodeHeaderSize), dictionary_corrupted);
-if (offcodeLog > OffFSELog) return ERROR(dictionary_corrupted);
+RETURN_ERROR_IF(offcodeLog > OffFSELog, dictionary_corrupted);
 /* Defer checking offcodeMaxValue because we need to know the size of the dictionary content */
 /* fill all offset symbols to avoid garbage at end of table */
-CHECK_E( FSE_buildCTable_wksp(bs->entropy.fse.offcodeCTable,
+RETURN_ERROR_IF(FSE_isError(FSE_buildCTable_wksp(
-offcodeNCount, MaxOff, offcodeLog,
+bs->entropy.fse.offcodeCTable,
-workspace, HUF_WORKSPACE_SIZE),
+offcodeNCount, MaxOff, offcodeLog,
-dictionary_corrupted);
+workspace, HUF_WORKSPACE_SIZE)),
+dictionary_corrupted);
 dictPtr += offcodeHeaderSize;
 }
 {   short matchlengthNCount[MaxML+1];
 unsigned matchlengthMaxValue = MaxML, matchlengthLog;
 size_t const matchlengthHeaderSize = FSE_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dictPtr, dictEnd-dictPtr);
-if (FSE_isError(matchlengthHeaderSize)) return ERROR(dictionary_corrupted);
+RETURN_ERROR_IF(FSE_isError(matchlengthHeaderSize), dictionary_corrupted);
-if (matchlengthLog > MLFSELog) return ERROR(dictionary_corrupted);
+RETURN_ERROR_IF(matchlengthLog > MLFSELog, dictionary_corrupted);
 /* Every match length code must have non-zero probability */
-CHECK_F( ZSTD_checkDictNCount(matchlengthNCount, matchlengthMaxValue, MaxML));
+FORWARD_IF_ERROR( ZSTD_checkDictNCount(matchlengthNCount, matchlengthMaxValue, MaxML));
-CHECK_E( FSE_buildCTable_wksp(bs->entropy.fse.matchlengthCTable,
+RETURN_ERROR_IF(FSE_isError(FSE_buildCTable_wksp(
-matchlengthNCount, matchlengthMaxValue, matchlengthLog,
+bs->entropy.fse.matchlengthCTable,
-workspace, HUF_WORKSPACE_SIZE),
+matchlengthNCount, matchlengthMaxValue, matchlengthLog,
-dictionary_corrupted);
+workspace, HUF_WORKSPACE_SIZE)),
+dictionary_corrupted);
 dictPtr += matchlengthHeaderSize;
 }
 {   short litlengthNCount[MaxLL+1];
 unsigned litlengthMaxValue = MaxLL, litlengthLog;
 size_t const litlengthHeaderSize = FSE_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dictPtr, dictEnd-dictPtr);
-if (FSE_isError(litlengthHeaderSize)) return ERROR(dictionary_corrupted);
+RETURN_ERROR_IF(FSE_isError(litlengthHeaderSize), dictionary_corrupted);
-if (litlengthLog > LLFSELog) return ERROR(dictionary_corrupted);
+RETURN_ERROR_IF(litlengthLog > LLFSELog, dictionary_corrupted);
 /* Every literal length code must have non-zero probability */
-CHECK_F( ZSTD_checkDictNCount(litlengthNCount, litlengthMaxValue, MaxLL));
+FORWARD_IF_ERROR( ZSTD_checkDictNCount(litlengthNCount, litlengthMaxValue, MaxLL));
-CHECK_E( FSE_buildCTable_wksp(bs->entropy.fse.litlengthCTable,
+RETURN_ERROR_IF(FSE_isError(FSE_buildCTable_wksp(
-litlengthNCount, litlengthMaxValue, litlengthLog,
+bs->entropy.fse.litlengthCTable,
-workspace, HUF_WORKSPACE_SIZE),
+litlengthNCount, litlengthMaxValue, litlengthLog,
-dictionary_corrupted);
+workspace, HUF_WORKSPACE_SIZE)),
+dictionary_corrupted);
 dictPtr += litlengthHeaderSize;
 }
-if (dictPtr+12 > dictEnd) return ERROR(dictionary_corrupted);
+RETURN_ERROR_IF(dictPtr+12 > dictEnd, dictionary_corrupted);
 bs->rep[0] = MEM_readLE32(dictPtr+0);
 bs->rep[1] = MEM_readLE32(dictPtr+4);
 bs->rep[2] = MEM_readLE32(dictPtr+8);
 dictPtr += 12;
 if (dictContentSize <= ((U32)-1) - 128 KB) {
 U32 const maxOffset = (U32)dictContentSize + 128 KB; /* The maximum offset that must be supported */
 offcodeMax = ZSTD_highbit32(maxOffset); /* Calculate minimum offset code required to represent maxOffset */
 }
 /* All offset values <= dictContentSize + 128 KB must be representable */
-CHECK_F (ZSTD_checkDictNCount(offcodeNCount, offcodeMaxValue, MIN(offcodeMax, MaxOff)));
+FORWARD_IF_ERROR(ZSTD_checkDictNCount(offcodeNCount, offcodeMaxValue, MIN(offcodeMax, MaxOff)));
 /* All repCodes must be <= dictContentSize and != 0*/
 {   U32 u;
 for (u=0; u<3; u++) {
-if (bs->rep[u] == 0) return ERROR(dictionary_corrupted);
+RETURN_ERROR_IF(bs->rep[u] == 0, dictionary_corrupted);
-if (bs->rep[u] > dictContentSize) return ERROR(dictionary_corrupted);
+RETURN_ERROR_IF(bs->rep[u] > dictContentSize, dictionary_corrupted);
 }   }
 bs->entropy.huf.repeatMode = HUF_repeat_valid;
 bs->entropy.fse.offcode_repeatMode = FSE_repeat_valid;
 bs->entropy.fse.matchlength_repeatMode = FSE_repeat_valid;
 bs->entropy.fse.litlength_repeatMode = FSE_repeat_valid;
-CHECK_F(ZSTD_loadDictionaryContent(ms, params, dictPtr, dictContentSize, dtlm));
+FORWARD_IF_ERROR(ZSTD_loadDictionaryContent(ms, params, dictPtr, dictContentSize, dtlm));
 return dictID;
 }
 }
 /** ZSTD_compress_insertDictionary() :
 if (MEM_readLE32(dict) != ZSTD_MAGIC_DICTIONARY) {
 if (dictContentType == ZSTD_dct_auto) {
 DEBUGLOG(4, "raw content dictionary detected");
 return ZSTD_loadDictionaryContent(ms, params, dict, dictSize, dtlm);
 }
-if (dictContentType == ZSTD_dct_fullDict)
+RETURN_ERROR_IF(dictContentType == ZSTD_dct_fullDict, dictionary_wrong);
-return ERROR(dictionary_wrong);
 assert(0);   /* impossible */
 }
 /* dict as full zstd dictionary */
 return ZSTD_loadZstdDictionary(bs, ms, params, dict, dictSize, dtlm, workspace);
 if (cdict && cdict->dictContentSize>0) {
 return ZSTD_resetCCtx_usingCDict(cctx, cdict, params, pledgedSrcSize, zbuff);
 }
-CHECK_F( ZSTD_resetCCtx_internal(cctx, params, pledgedSrcSize,
+FORWARD_IF_ERROR( ZSTD_resetCCtx_internal(cctx, params, pledgedSrcSize,
 ZSTDcrp_continue, zbuff) );
-{
+{   size_t const dictID = ZSTD_compress_insertDictionary(
-size_t const dictID = ZSTD_compress_insertDictionary(
 cctx->blockState.prevCBlock, &cctx->blockState.matchState,
 &params, dict, dictSize, dictContentType, dtlm, cctx->entropyWorkspace);
-if (ZSTD_isError(dictID)) return dictID;
+FORWARD_IF_ERROR(dictID);
-assert(dictID <= (size_t)(U32)-1);
+assert(dictID <= UINT_MAX);
 cctx->dictID = (U32)dictID;
 }
 return 0;
 }
 ZSTD_CCtx_params params,
 unsigned long long pledgedSrcSize)
 {
 DEBUGLOG(4, "ZSTD_compressBegin_advanced_internal: wlog=%u", params.cParams.windowLog);
 /* compression parameters verification and optimization */
-CHECK_F( ZSTD_checkCParams(params.cParams) );
+FORWARD_IF_ERROR( ZSTD_checkCParams(params.cParams) );
 return ZSTD_compressBegin_internal(cctx,
 dict, dictSize, dictContentType, dtlm,
 cdict,
 params, pledgedSrcSize,
 ZSTDb_not_buffered);
 BYTE* const ostart = (BYTE*)dst;
 BYTE* op = ostart;
 size_t fhSize = 0;
 DEBUGLOG(4, "ZSTD_writeEpilogue");
-if (cctx->stage == ZSTDcs_created) return ERROR(stage_wrong);  /* init missing */
+RETURN_ERROR_IF(cctx->stage == ZSTDcs_created, stage_wrong, "init missing");
 /* special case : empty frame */
 if (cctx->stage == ZSTDcs_init) {
 fhSize = ZSTD_writeFrameHeader(dst, dstCapacity, cctx->appliedParams, 0, 0);
-if (ZSTD_isError(fhSize)) return fhSize;
+FORWARD_IF_ERROR(fhSize);
 dstCapacity -= fhSize;
 op += fhSize;
 cctx->stage = ZSTDcs_ongoing;
 }
 if (cctx->stage != ZSTDcs_ending) {
 /* write one last empty block, make it the "last" block */
 U32 const cBlockHeader24 = 1 /* last block */ + (((U32)bt_raw)<<1) + 0;
-if (dstCapacity<4) return ERROR(dstSize_tooSmall);
+RETURN_ERROR_IF(dstCapacity<4, dstSize_tooSmall);
 MEM_writeLE32(op, cBlockHeader24);
 op += ZSTD_blockHeaderSize;
 dstCapacity -= ZSTD_blockHeaderSize;
 }
 if (cctx->appliedParams.fParams.checksumFlag) {
 U32 const checksum = (U32) XXH64_digest(&cctx->xxhState);
-if (dstCapacity<4) return ERROR(dstSize_tooSmall);
+RETURN_ERROR_IF(dstCapacity<4, dstSize_tooSmall);
 DEBUGLOG(4, "ZSTD_writeEpilogue: write checksum : %08X", (unsigned)checksum);
 MEM_writeLE32(op, checksum);
 op += 4;
 }
 {
 size_t endResult;
 size_t const cSize = ZSTD_compressContinue_internal(cctx,
 dst, dstCapacity, src, srcSize,
 1 /* frame mode */, 1 /* last chunk */);
-if (ZSTD_isError(cSize)) return cSize;
+FORWARD_IF_ERROR(cSize);
 endResult = ZSTD_writeEpilogue(cctx, (char*)dst + cSize, dstCapacity-cSize);
-if (ZSTD_isError(endResult)) return endResult;
+FORWARD_IF_ERROR(endResult);
 assert(!(cctx->appliedParams.fParams.contentSizeFlag && cctx->pledgedSrcSizePlusOne == 0));
 if (cctx->pledgedSrcSizePlusOne != 0) {  /* control src size */
 ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_UNKNOWN == (unsigned long long)-1);
 DEBUGLOG(4, "end of frame : controlling src size");
-if (cctx->pledgedSrcSizePlusOne != cctx->consumedSrcSize+1) {
+RETURN_ERROR_IF(
-DEBUGLOG(4, "error : pledgedSrcSize = %u, while realSrcSize = %u",
+cctx->pledgedSrcSizePlusOne != cctx->consumedSrcSize+1,
-(unsigned)cctx->pledgedSrcSizePlusOne-1, (unsigned)cctx->consumedSrcSize);
+srcSize_wrong,
-return ERROR(srcSize_wrong);
+"error : pledgedSrcSize = %u, while realSrcSize = %u",
-}   }
+(unsigned)cctx->pledgedSrcSizePlusOne-1,
+(unsigned)cctx->consumedSrcSize);
+}
 return cSize + endResult;
 }
 static size_t ZSTD_compress_internal (ZSTD_CCtx* cctx,
 const void* src, size_t srcSize,
 const void* dict,size_t dictSize,
 ZSTD_parameters params)
 {
 DEBUGLOG(4, "ZSTD_compress_advanced");
-CHECK_F(ZSTD_checkCParams(params.cParams));
+FORWARD_IF_ERROR(ZSTD_checkCParams(params.cParams));
 return ZSTD_compress_internal(cctx,
 dst, dstCapacity,
 src, srcSize,
 dict, dictSize,
 params);
 const void* src, size_t srcSize,
 const void* dict,size_t dictSize,
 ZSTD_CCtx_params params)
 {
 DEBUGLOG(4, "ZSTD_compress_advanced_internal (srcSize:%u)", (unsigned)srcSize);
-CHECK_F( ZSTD_compressBegin_internal(cctx,
+FORWARD_IF_ERROR( ZSTD_compressBegin_internal(cctx,
 dict, dictSize, ZSTD_dct_auto, ZSTD_dtlm_fast, NULL,
 params, srcSize, ZSTDb_not_buffered) );
 return ZSTD_compressEnd(cctx, dst, dstCapacity, src, srcSize);
 }
 cdict->dictContent = dictBuffer;
 } else {
 void* const internalBuffer = ZSTD_malloc(dictSize, cdict->customMem);
 cdict->dictBuffer = internalBuffer;
 cdict->dictContent = internalBuffer;
-if (!internalBuffer) return ERROR(memory_allocation);
+RETURN_ERROR_IF(!internalBuffer, memory_allocation);
 memcpy(internalBuffer, dictBuffer, dictSize);
 }
 cdict->dictContentSize = dictSize;
 /* Reset the state to no dictionary */
 ZSTD_reset_compressedBlockState(&cdict->cBlockState);
-{   void* const end = ZSTD_reset_matchState(
+{   void* const end = ZSTD_reset_matchState(&cdict->matchState,
-&cdict->matchState,
+(U32*)cdict->workspace + HUF_WORKSPACE_SIZE_U32,
-(U32*)cdict->workspace + HUF_WORKSPACE_SIZE_U32,
+&cParams,
-&cParams, ZSTDcrp_continue, /* forCCtx */ 0);
+ZSTDcrp_continue, ZSTD_resetTarget_CDict);
 assert(end == (char*)cdict->workspace + cdict->workspaceSize);
 (void)end;
 }
 /* (Maybe) load the dictionary
 * Skips loading the dictionary if it is <= 8 bytes.
 params.cParams = cParams;
 {   size_t const dictID = ZSTD_compress_insertDictionary(
 &cdict->cBlockState, &cdict->matchState, &params,
 cdict->dictContent, cdict->dictContentSize,
 dictContentType, ZSTD_dtlm_full, cdict->workspace);
-if (ZSTD_isError(dictID)) return dictID;
+FORWARD_IF_ERROR(dictID);
 assert(dictID <= (size_t)(U32)-1);
 cdict->dictID = (U32)dictID;
 }
 }
 size_t ZSTD_compressBegin_usingCDict_advanced(
 ZSTD_CCtx* const cctx, const ZSTD_CDict* const cdict,
 ZSTD_frameParameters const fParams, unsigned long long const pledgedSrcSize)
 {
 DEBUGLOG(4, "ZSTD_compressBegin_usingCDict_advanced");
-if (cdict==NULL) return ERROR(dictionary_wrong);
+RETURN_ERROR_IF(cdict==NULL, dictionary_wrong);
 {   ZSTD_CCtx_params params = cctx->requestedParams;
 params.cParams = ZSTD_getCParamsFromCDict(cdict);
 /* Increase window log to fit the entire dictionary and source if the
 * source size is known. Limit the increase to 19, which is the
 * window log for compression level 1 with the largest source size.
 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)
 {
-CHECK_F (ZSTD_compressBegin_usingCDict_advanced(cctx, cdict, fParams, srcSize));   /* will check if cdict != NULL */
+FORWARD_IF_ERROR(ZSTD_compressBegin_usingCDict_advanced(cctx, cdict, fParams, srcSize));   /* will check if cdict != NULL */
 return ZSTD_compressEnd(cctx, dst, dstCapacity, src, srcSize);
 }
 /*! ZSTD_compress_usingCDict() :
 *  Compression using a digested Dictionary.
 params.cParams = ZSTD_getCParamsFromCCtxParams(&params, pledgedSrcSize, dictSize);
 /* params are supposed to be fully validated at this point */
 assert(!ZSTD_isError(ZSTD_checkCParams(params.cParams)));
 assert(!((dict) && (cdict)));  /* either dict or cdict, not both */
-CHECK_F( ZSTD_compressBegin_internal(cctx,
+FORWARD_IF_ERROR( ZSTD_compressBegin_internal(cctx,
 dict, dictSize, dictContentType, ZSTD_dtlm_fast,
 cdict,
 params, pledgedSrcSize,
 ZSTDb_buffered) );
 return 0;   /* ready to go */
 }
 /* ZSTD_resetCStream():
 * pledgedSrcSize == 0 means "unknown" */
-size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pledgedSrcSize)
+size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pss)
 {
-ZSTD_CCtx_params params = zcs->requestedParams;
+/* temporary : 0 interpreted as "unknown" during transition period.
+* Users willing to specify "unknown" **must** use ZSTD_CONTENTSIZE_UNKNOWN.
+* 0 will be interpreted as "empty" in the future.
+*/
+U64 const pledgedSrcSize = (pss==0) ? ZSTD_CONTENTSIZE_UNKNOWN : pss;
 DEBUGLOG(4, "ZSTD_resetCStream: pledgedSrcSize = %u", (unsigned)pledgedSrcSize);
-if (pledgedSrcSize==0) pledgedSrcSize = ZSTD_CONTENTSIZE_UNKNOWN;
+FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) );
-params.fParams.contentSizeFlag = 1;
+FORWARD_IF_ERROR( ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize) );
-return ZSTD_resetCStream_internal(zcs, NULL, 0, ZSTD_dct_auto, zcs->cdict, params, pledgedSrcSize);
+return 0;
 }
 /*! ZSTD_initCStream_internal() :
 *  Note : for lib/compress only. Used by zstdmt_compress.c.
 *  Assumption 1 : params are valid
 size_t ZSTD_initCStream_internal(ZSTD_CStream* zcs,
 const void* dict, size_t dictSize, const ZSTD_CDict* cdict,
 ZSTD_CCtx_params params, unsigned long long pledgedSrcSize)
 {
 DEBUGLOG(4, "ZSTD_initCStream_internal");
-params.cParams = ZSTD_getCParamsFromCCtxParams(&params, pledgedSrcSize, dictSize);
+FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) );
+FORWARD_IF_ERROR( ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize) );
 assert(!ZSTD_isError(ZSTD_checkCParams(params.cParams)));
+zcs->requestedParams = params;
 assert(!((dict) && (cdict)));  /* either dict or cdict, not both */
+if (dict) {
-if (dict && dictSize >= 8) {
+FORWARD_IF_ERROR( ZSTD_CCtx_loadDictionary(zcs, dict, dictSize) );
-DEBUGLOG(4, "loading dictionary of size %u", (unsigned)dictSize);
-if (zcs->staticSize) {   /* static CCtx : never uses malloc */
-/* incompatible with internal cdict creation */
-return ERROR(memory_allocation);
-}
-ZSTD_freeCDict(zcs->cdictLocal);
-zcs->cdictLocal = ZSTD_createCDict_advanced(dict, dictSize,
-ZSTD_dlm_byCopy, ZSTD_dct_auto,
-params.cParams, zcs->customMem);
-zcs->cdict = zcs->cdictLocal;
-if (zcs->cdictLocal == NULL) return ERROR(memory_allocation);
 } else {
-if (cdict) {
+/* Dictionary is cleared if !cdict */
-params.cParams = ZSTD_getCParamsFromCDict(cdict);  /* cParams are enforced from cdict; it includes windowLog */
+FORWARD_IF_ERROR( ZSTD_CCtx_refCDict(zcs, cdict) );
 }
-ZSTD_freeCDict(zcs->cdictLocal);
+return 0;
-zcs->cdictLocal = NULL;
-zcs->cdict = cdict;
-}
-return ZSTD_resetCStream_internal(zcs, NULL, 0, ZSTD_dct_auto, zcs->cdict, params, pledgedSrcSize);
 }
 /* ZSTD_initCStream_usingCDict_advanced() :
 * same as ZSTD_initCStream_usingCDict(), with control over frame parameters */
 size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs,
 const ZSTD_CDict* cdict,
 ZSTD_frameParameters fParams,
 unsigned long long pledgedSrcSize)
 {
 DEBUGLOG(4, "ZSTD_initCStream_usingCDict_advanced");
-if (!cdict) return ERROR(dictionary_wrong); /* cannot handle NULL cdict (does not know what to do) */
+FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) );
-{   ZSTD_CCtx_params params = zcs->requestedParams;
+FORWARD_IF_ERROR( ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize) );
-params.cParams = ZSTD_getCParamsFromCDict(cdict);
+zcs->requestedParams.fParams = fParams;
-params.fParams = fParams;
+FORWARD_IF_ERROR( ZSTD_CCtx_refCDict(zcs, cdict) );
-return ZSTD_initCStream_internal(zcs,
+return 0;
-NULL, 0, cdict,
-params, pledgedSrcSize);
-}
 }
 /* note : cdict must outlive compression session */
 size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict)
 {
-ZSTD_frameParameters const fParams = { 0 /* contentSizeFlag */, 0 /* checksum */, 0 /* hideDictID */ };
 DEBUGLOG(4, "ZSTD_initCStream_usingCDict");
-return ZSTD_initCStream_usingCDict_advanced(zcs, cdict, fParams, ZSTD_CONTENTSIZE_UNKNOWN);  /* note : will check that cdict != NULL */
+FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) );
+FORWARD_IF_ERROR( ZSTD_CCtx_refCDict(zcs, cdict) );
+return 0;
 }
 /* ZSTD_initCStream_advanced() :
 * pledgedSrcSize must be exact.
 * if srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN.
 * dict is loaded with default parameters ZSTD_dm_auto and ZSTD_dlm_byCopy. */
 size_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs,
 const void* dict, size_t dictSize,
-ZSTD_parameters params, unsigned long long pledgedSrcSize)
+ZSTD_parameters params, unsigned long long pss)
 {
-DEBUGLOG(4, "ZSTD_initCStream_advanced: pledgedSrcSize=%u, flag=%u",
+/* for compatibility with older programs relying on this behavior.
-(unsigned)pledgedSrcSize, params.fParams.contentSizeFlag);
+* Users should now specify ZSTD_CONTENTSIZE_UNKNOWN.
-CHECK_F( ZSTD_checkCParams(params.cParams) );
+* This line will be removed in the future.
-if ((pledgedSrcSize==0) && (params.fParams.contentSizeFlag==0)) pledgedSrcSize = ZSTD_CONTENTSIZE_UNKNOWN;  /* for compatibility with older programs relying on this behavior. Users should now specify ZSTD_CONTENTSIZE_UNKNOWN. This line will be removed in the future. */
+*/
+U64 const pledgedSrcSize = (pss==0 && params.fParams.contentSizeFlag==0) ? ZSTD_CONTENTSIZE_UNKNOWN : pss;
+DEBUGLOG(4, "ZSTD_initCStream_advanced");
+FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) );
+FORWARD_IF_ERROR( ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize) );
+FORWARD_IF_ERROR( ZSTD_checkCParams(params.cParams) );
 zcs->requestedParams = ZSTD_assignParamsToCCtxParams(zcs->requestedParams, params);
-return ZSTD_initCStream_internal(zcs, dict, dictSize, NULL /*cdict*/, zcs->requestedParams, pledgedSrcSize);
+FORWARD_IF_ERROR( ZSTD_CCtx_loadDictionary(zcs, dict, dictSize) );
+return 0;
 }
 size_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs, const void* dict, size_t dictSize, int compressionLevel)
 {
-ZSTD_CCtxParams_init(&zcs->requestedParams, compressionLevel);
+DEBUGLOG(4, "ZSTD_initCStream_usingDict");
-return ZSTD_initCStream_internal(zcs, dict, dictSize, NULL, zcs->requestedParams, ZSTD_CONTENTSIZE_UNKNOWN);
+FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) );
+FORWARD_IF_ERROR( ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel) );
+FORWARD_IF_ERROR( ZSTD_CCtx_loadDictionary(zcs, dict, dictSize) );
+return 0;
 }
 size_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs, int compressionLevel, unsigned long long pss)
 {
-U64 const pledgedSrcSize = (pss==0) ? ZSTD_CONTENTSIZE_UNKNOWN : pss;  /* temporary : 0 interpreted as "unknown" during transition period. Users willing to specify "unknown" **must** use ZSTD_CONTENTSIZE_UNKNOWN. `0` will be interpreted as "empty" in the future */
+/* temporary : 0 interpreted as "unknown" during transition period.
-ZSTD_CCtxParams_init(&zcs->requestedParams, compressionLevel);
+* Users willing to specify "unknown" **must** use ZSTD_CONTENTSIZE_UNKNOWN.
-return ZSTD_initCStream_internal(zcs, NULL, 0, NULL, zcs->requestedParams, pledgedSrcSize);
+* 0 will be interpreted as "empty" in the future.
+*/
+U64 const pledgedSrcSize = (pss==0) ? ZSTD_CONTENTSIZE_UNKNOWN : pss;
+DEBUGLOG(4, "ZSTD_initCStream_srcSize");
+FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) );
+FORWARD_IF_ERROR( ZSTD_CCtx_refCDict(zcs, NULL) );
+FORWARD_IF_ERROR( ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel) );
+FORWARD_IF_ERROR( ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize) );
+return 0;
 }
 size_t ZSTD_initCStream(ZSTD_CStream* zcs, int compressionLevel)
 {
 DEBUGLOG(4, "ZSTD_initCStream");
-return ZSTD_initCStream_srcSize(zcs, compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN);
+FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) );
+FORWARD_IF_ERROR( ZSTD_CCtx_refCDict(zcs, NULL) );
+FORWARD_IF_ERROR( ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel) );
+return 0;
 }
 /*======   Compression   ======*/
 static size_t ZSTD_nextInputSizeHint(const ZSTD_CCtx* cctx)
 /** ZSTD_compressStream_generic():
 *  internal function for all *compressStream*() variants
 *  non-static, because can be called from zstdmt_compress.c
 * @return : hint size for next input */
-size_t ZSTD_compressStream_generic(ZSTD_CStream* zcs,
+static size_t ZSTD_compressStream_generic(ZSTD_CStream* zcs,
 ZSTD_outBuffer* output,
 ZSTD_inBuffer* input,
 ZSTD_EndDirective const flushMode)
 {
 const char* const istart = (const char*)input->src;
 const char* const iend = istart + input->size;
 const char* ip = istart + input->pos;
 char* const ostart = (char*)output->dst;
 while (someMoreWork) {
 switch(zcs->streamStage)
 {
 case zcss_init:
-/* call ZSTD_initCStream() first ! */
+RETURN_ERROR(init_missing, "call ZSTD_initCStream() first!");
-return ERROR(init_missing);
 case zcss_load:
 if ( (flushMode == ZSTD_e_end)
 && ((size_t)(oend-op) >= ZSTD_compressBound(iend-ip))  /* enough dstCapacity */
 && (zcs->inBuffPos == 0) ) {
 /* shortcut to compression pass directly into output buffer */
 size_t const cSize = ZSTD_compressEnd(zcs,
 op, oend-op, ip, iend-ip);
 DEBUGLOG(4, "ZSTD_compressEnd : cSize=%u", (unsigned)cSize);
-if (ZSTD_isError(cSize)) return cSize;
+FORWARD_IF_ERROR(cSize);
 ip = iend;
 op += cSize;
 zcs->frameEnded = 1;
 ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
 someMoreWork = 0; break;
 cSize = lastBlock ?
 ZSTD_compressEnd(zcs, cDst, oSize,
 zcs->inBuff + zcs->inToCompress, iSize) :
 ZSTD_compressContinue(zcs, cDst, oSize,
 zcs->inBuff + zcs->inToCompress, iSize);
-if (ZSTD_isError(cSize)) return cSize;
+FORWARD_IF_ERROR(cSize);
 zcs->frameEnded = lastBlock;
 /* prepare next block */
 zcs->inBuffTarget = zcs->inBuffPos + zcs->blockSize;
 if (zcs->inBuffTarget > zcs->inBuffSize)
 zcs->inBuffPos = 0, zcs->inBuffTarget = zcs->blockSize;
 }
 	    /* fall-through */
 case zcss_flush:
 DEBUGLOG(5, "flush stage");
 {   size_t const toFlush = zcs->outBuffContentSize - zcs->outBuffFlushedSize;
-size_t const flushed = ZSTD_limitCopy(op, oend-op,
+size_t const flushed = ZSTD_limitCopy(op, (size_t)(oend-op),
 zcs->outBuff + zcs->outBuffFlushedSize, toFlush);
 DEBUGLOG(5, "toFlush: %u into %u ==> flushed: %u",
 (unsigned)toFlush, (unsigned)(oend-op), (unsigned)flushed);
 op += flushed;
 zcs->outBuffFlushedSize += flushed;
 }
 size_t ZSTD_compressStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input)
 {
-CHECK_F( ZSTD_compressStream2(zcs, output, input, ZSTD_e_continue) );
+FORWARD_IF_ERROR( ZSTD_compressStream2(zcs, output, input, ZSTD_e_continue) );
 return ZSTD_nextInputSizeHint_MTorST(zcs);
 }
 size_t ZSTD_compressStream2( ZSTD_CCtx* cctx,
 ZSTD_inBuffer* input,
 ZSTD_EndDirective endOp)
 {
 DEBUGLOG(5, "ZSTD_compressStream2, endOp=%u ", (unsigned)endOp);
 /* check conditions */
-if (output->pos > output->size) return ERROR(GENERIC);
+RETURN_ERROR_IF(output->pos > output->size, GENERIC);
-if (input->pos  > input->size)  return ERROR(GENERIC);
+RETURN_ERROR_IF(input->pos  > input->size, GENERIC);
 assert(cctx!=NULL);
 /* transparent initialization stage */
 if (cctx->streamStage == zcss_init) {
 ZSTD_CCtx_params params = cctx->requestedParams;
 ZSTD_prefixDict const prefixDict = cctx->prefixDict;
+FORWARD_IF_ERROR( ZSTD_initLocalDict(cctx) ); /* Init the local dict if present. */
 memset(&cctx->prefixDict, 0, sizeof(cctx->prefixDict));   /* single usage */
 assert(prefixDict.dict==NULL || cctx->cdict==NULL);    /* only one can be set */
 DEBUGLOG(4, "ZSTD_compressStream2 : transparent init stage");
 if (endOp == ZSTD_e_end) cctx->pledgedSrcSizePlusOne = input->size + 1;  /* auto-fix pledgedSrcSize */
 params.cParams = ZSTD_getCParamsFromCCtxParams(
 /* mt context creation */
 if (cctx->mtctx == NULL) {
 DEBUGLOG(4, "ZSTD_compressStream2: creating new mtctx for nbWorkers=%u",
 params.nbWorkers);
 cctx->mtctx = ZSTDMT_createCCtx_advanced(params.nbWorkers, cctx->customMem);
-if (cctx->mtctx == NULL) return ERROR(memory_allocation);
+RETURN_ERROR_IF(cctx->mtctx == NULL, memory_allocation);
 }
 /* mt compression */
 DEBUGLOG(4, "call ZSTDMT_initCStream_internal as nbWorkers=%u", params.nbWorkers);
-CHECK_F( ZSTDMT_initCStream_internal(
+FORWARD_IF_ERROR( ZSTDMT_initCStream_internal(
 cctx->mtctx,
 prefixDict.dict, prefixDict.dictSize, ZSTD_dct_rawContent,
 cctx->cdict, params, cctx->pledgedSrcSizePlusOne-1) );
 cctx->streamStage = zcss_load;
 cctx->appliedParams.nbWorkers = params.nbWorkers;
 } else
 #endif
-{   CHECK_F( ZSTD_resetCStream_internal(cctx,
+{   FORWARD_IF_ERROR( ZSTD_resetCStream_internal(cctx,
 prefixDict.dict, prefixDict.dictSize, prefixDict.dictContentType,
 cctx->cdict,
 params, cctx->pledgedSrcSizePlusOne-1) );
 assert(cctx->streamStage == zcss_load);
 assert(cctx->appliedParams.nbWorkers == 0);
 /* end of transparent initialization stage */
 /* compression stage */
 #ifdef ZSTD_MULTITHREAD
 if (cctx->appliedParams.nbWorkers > 0) {
+int const forceMaxProgress = (endOp == ZSTD_e_flush || endOp == ZSTD_e_end);
+size_t flushMin;
+assert(forceMaxProgress || endOp == ZSTD_e_continue /* Protection for a new flush type */);
 if (cctx->cParamsChanged) {
 ZSTDMT_updateCParams_whileCompressing(cctx->mtctx, &cctx->requestedParams);
 cctx->cParamsChanged = 0;
 }
-{   size_t const flushMin = ZSTDMT_compressStream_generic(cctx->mtctx, output, input, endOp);
+do {
+flushMin = ZSTDMT_compressStream_generic(cctx->mtctx, output, input, endOp);
 if ( ZSTD_isError(flushMin)
 || (endOp == ZSTD_e_end && flushMin == 0) ) { /* compression completed */
 ZSTD_CCtx_reset(cctx, ZSTD_reset_session_only);
 }
-DEBUGLOG(5, "completed ZSTD_compressStream2 delegating to ZSTDMT_compressStream_generic");
+FORWARD_IF_ERROR(flushMin);
-return flushMin;
+} while (forceMaxProgress && flushMin != 0 && output->pos < output->size);
-}   }
+DEBUGLOG(5, "completed ZSTD_compressStream2 delegating to ZSTDMT_compressStream_generic");
+/* Either we don't require maximum forward progress, we've finished the
+* flush, or we are out of output space.
+*/
+assert(!forceMaxProgress || flushMin == 0 || output->pos == output->size);
+return flushMin;
+}
 #endif
-CHECK_F( ZSTD_compressStream_generic(cctx, output, input, endOp) );
+FORWARD_IF_ERROR( ZSTD_compressStream_generic(cctx, output, input, endOp) );
 DEBUGLOG(5, "completed ZSTD_compressStream2");
 return cctx->outBuffContentSize - cctx->outBuffFlushedSize; /* remaining to flush */
 }
 size_t ZSTD_compressStream2_simpleArgs (
 size_t iPos = 0;
 size_t const result = ZSTD_compressStream2_simpleArgs(cctx,
 dst, dstCapacity, &oPos,
 src, srcSize, &iPos,
 ZSTD_e_end);
-if (ZSTD_isError(result)) return result;
+FORWARD_IF_ERROR(result);
 if (result != 0) {  /* compression not completed, due to lack of output space */
 assert(oPos == dstCapacity);
-return ERROR(dstSize_tooSmall);
+RETURN_ERROR(dstSize_tooSmall);
 }
 assert(iPos == srcSize);   /* all input is expected consumed */
 return oPos;
 }
 }
 size_t ZSTD_endStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output)
 {
 ZSTD_inBuffer input = { NULL, 0, 0 };
 size_t const remainingToFlush = ZSTD_compressStream2(zcs, output, &input, ZSTD_e_end);
-CHECK_F( remainingToFlush );
+FORWARD_IF_ERROR( remainingToFlush );
 if (zcs->appliedParams.nbWorkers > 0) return remainingToFlush;   /* minimal estimation */
 /* single thread mode : attempt to calculate remaining to flush more precisely */
 {   size_t const lastBlockSize = zcs->frameEnded ? 0 : ZSTD_BLOCKHEADERSIZE;
-size_t const checksumSize = zcs->frameEnded ? 0 : zcs->appliedParams.fParams.checksumFlag * 4;
+size_t const checksumSize = (size_t)(zcs->frameEnded ? 0 : zcs->appliedParams.fParams.checksumFlag * 4);
 size_t const toFlush = remainingToFlush + lastBlockSize + checksumSize;
 DEBUGLOG(4, "ZSTD_endStream : remaining to flush : %u", (unsigned)toFlush);
 return toFlush;
 }
 }
 #define ZSTD_MAX_CLEVEL     22
 int ZSTD_maxCLevel(void) { return ZSTD_MAX_CLEVEL; }
 int ZSTD_minCLevel(void) { return (int)-ZSTD_TARGETLENGTH_MAX; }
 static const ZSTD_compressionParameters ZSTD_defaultCParameters[4][ZSTD_MAX_CLEVEL+1] = {
-{   /* "default" - guarantees a monotonically increasing memory budget */
+{   /* "default" - for any srcSize > 256 KB */
 /* W,  C,  H,  S,  L, TL, strat */
 { 19, 12, 13,  1,  6,  1, ZSTD_fast    },  /* base for negative levels */
 { 19, 13, 14,  1,  7,  0, ZSTD_fast    },  /* level  1 */
 { 20, 15, 16,  1,  6,  0, ZSTD_fast    },  /* level  2 */
 { 21, 16, 17,  1,  5,  1, ZSTD_dfast   },  /* level  3 */
 { 14, 15, 15, 10,  3,999, ZSTD_btultra2},  /* level 22.*/
 },
 };
 /*! ZSTD_getCParams() :
-*  @return ZSTD_compressionParameters structure for a selected compression level, srcSize and dictSize.
+* @return ZSTD_compressionParameters structure for a selected compression level, srcSize and dictSize.
-*   Size values are optional, provide 0 if not known or unused */
+*  Size values are optional, provide 0 if not known or unused */
 ZSTD_compressionParameters ZSTD_getCParams(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize)
 {
 size_t const addedSize = srcSizeHint ? 0 : 500;
-U64 const rSize = srcSizeHint+dictSize ? srcSizeHint+dictSize+addedSize : (U64)-1;
+U64 const rSize = srcSizeHint+dictSize ? srcSizeHint+dictSize+addedSize : ZSTD_CONTENTSIZE_UNKNOWN;  /* intentional overflow for srcSizeHint == ZSTD_CONTENTSIZE_UNKNOWN */
-U32 const tableID = (rSize <= 256 KB) + (rSize <= 128 KB) + (rSize <= 16 KB);   /* intentional underflow for srcSizeHint == 0 */
+U32 const tableID = (rSize <= 256 KB) + (rSize <= 128 KB) + (rSize <= 16 KB);
 int row = compressionLevel;
 DEBUGLOG(5, "ZSTD_getCParams (cLevel=%i)", compressionLevel);
 if (compressionLevel == 0) row = ZSTD_CLEVEL_DEFAULT;   /* 0 == default */
 if (compressionLevel < 0) row = 0;   /* entry 0 is baseline for fast mode */
 if (compressionLevel > ZSTD_MAX_CLEVEL) row = ZSTD_MAX_CLEVEL;
 {   ZSTD_compressionParameters cp = ZSTD_defaultCParameters[tableID][row];
 if (compressionLevel < 0) cp.targetLength = (unsigned)(-compressionLevel);   /* acceleration factor */
-return ZSTD_adjustCParams_internal(cp, srcSizeHint, dictSize);
+return ZSTD_adjustCParams_internal(cp, srcSizeHint, dictSize);               /* refine parameters based on srcSize & dictSize */
 }
 }
 /*! ZSTD_getParams() :
-*   same as ZSTD_getCParams(), but @return a `ZSTD_parameters` object (instead of `ZSTD_compressionParameters`).
+*  same idea as ZSTD_getCParams()
-*   All fields of `ZSTD_frameParameters` are set to default (0) */
+* @return a `ZSTD_parameters` structure (instead of `ZSTD_compressionParameters`).
+*  Fields of `ZSTD_frameParameters` are set to default values */
 ZSTD_parameters ZSTD_getParams(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize) {
 ZSTD_parameters params;
 ZSTD_compressionParameters const cParams = ZSTD_getCParams(compressionLevel, srcSizeHint, dictSize);
 DEBUGLOG(5, "ZSTD_getParams (cLevel=%i)", compressionLevel);
 memset(&params, 0, sizeof(params));

changeset 42937	69de49c4e39c
parent 42070	675775c33ab6
child 43994	de7838053207