/*

 * This source code is licensed under both the BSD-style license (found in the

 * LICENSE file in the root directory of this source tree) and the GPLv2 (found

 * in the COPYING file in the root directory of this source tree).

 * You may select, at your option, one of the above-listed licenses.

*  Tuning parameters

***************************************/

#ifndef ZSTD_CLEVEL_DEFAULT

#  define ZSTD_CLEVEL_DEFAULT 3

#endif

/*-*************************************

#include "cpu.h"

#include "zstd_compress_internal.h"

#include "zstd_fast.h"

#include "zstd_double_fast.h"

#include "zstd_lazy.h"

#include "zstd_opt.h"

#include "zstd_ldm.h"

size_t ZSTD_compressBound(size_t srcSize) {

    return ZSTD_COMPRESSBOUND(srcSize);

struct ZSTD_CDict_s {

    void* dictBuffer;

    const void* dictContent;

    size_t dictContentSize;

    void* workspace;

    size_t workspaceSize;

    ZSTD_matchState_t matchState;

    ZSTD_compressedBlockState_t cBlockState;

    ZSTD_compressionParameters cParams;

    U32 dictID;

};  /* typedef'd to ZSTD_CDict within "zstd.h" */

    return ZSTD_createCCtx_advanced(ZSTD_defaultCMem);

    ZSTD_STATIC_ASSERT(zcss_init==0);

    ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_UNKNOWN==(0ULL - 1));

    if (!customMem.customAlloc ^ !customMem.customFree) return NULL;

    {   ZSTD_CCtx* const cctx = (ZSTD_CCtx*)ZSTD_calloc(sizeof(ZSTD_CCtx), customMem);

        if (!cctx) return NULL;

        cctx->customMem = customMem;

        cctx->requestedParams.compressionLevel = ZSTD_CLEVEL_DEFAULT;

        cctx->requestedParams.fParams.contentSizeFlag = 1;

        cctx->bmi2 = ZSTD_cpuid_bmi2(ZSTD_cpuid());

        return cctx;

    }

}

ZSTD_CCtx* ZSTD_initStaticCCtx(void *workspace, size_t workspaceSize)

{

    ZSTD_CCtx* const cctx = (ZSTD_CCtx*) workspace;

    if (workspaceSize <= sizeof(ZSTD_CCtx)) return NULL;  /* minimum size */

    if ((size_t)workspace & 7) return NULL;  /* must be 8-aligned */

    memset(workspace, 0, workspaceSize);   /* may be a bit generous, could memset be smaller ? */

    cctx->staticSize = workspaceSize;

    cctx->workSpace = (void*)(cctx+1);

    cctx->workSpaceSize = workspaceSize - sizeof(ZSTD_CCtx);

    /* statically sized space. entropyWorkspace never moves (but prev/next block swap places) */

    if (cctx->workSpaceSize < HUF_WORKSPACE_SIZE + 2 * sizeof(ZSTD_compressedBlockState_t)) return NULL;

    assert(((size_t)cctx->workSpace & (sizeof(void*)-1)) == 0);   /* ensure correct alignment */

    cctx->blockState.prevCBlock = (ZSTD_compressedBlockState_t*)cctx->workSpace;

    cctx->blockState.nextCBlock = cctx->blockState.prevCBlock + 1;

    {

        void* const ptr = cctx->blockState.nextCBlock + 1;

        cctx->entropyWorkspace = (U32*)ptr;

    }

    cctx->bmi2 = ZSTD_cpuid_bmi2(ZSTD_cpuid());

    if (cctx->staticSize) return ERROR(memory_allocation);   /* not compatible with static CCtx */

    ZSTD_free(cctx->workSpace, cctx->customMem); cctx->workSpace = NULL;

    ZSTD_freeCDict(cctx->cdictLocal); cctx->cdictLocal = NULL;

#ifdef ZSTD_MULTITHREAD

    ZSTDMT_freeCCtx(cctx->mtctx); cctx->mtctx = NULL;

#endif

static size_t ZSTD_sizeof_mtctx(const ZSTD_CCtx* cctx)

{

#ifdef ZSTD_MULTITHREAD

    return ZSTDMT_sizeof_CCtx(cctx->mtctx);

#else

    (void) cctx;

    return 0;

#endif

}

    return sizeof(*cctx) + cctx->workSpaceSize

           + ZSTD_sizeof_CDict(cctx->cdictLocal)

           + ZSTD_sizeof_mtctx(cctx);

}

size_t ZSTD_sizeof_CStream(const ZSTD_CStream* zcs)

{

    return ZSTD_sizeof_CCtx(zcs);  /* same object */

}

/* private API call, for dictBuilder only */

const seqStore_t* ZSTD_getSeqStore(const ZSTD_CCtx* ctx) { return &(ctx->seqStore); }

ZSTD_compressionParameters ZSTD_getCParamsFromCCtxParams(

        const ZSTD_CCtx_params* CCtxParams, U64 srcSizeHint, size_t dictSize)

{

    ZSTD_compressionParameters cParams = ZSTD_getCParams(CCtxParams->compressionLevel, srcSizeHint, dictSize);

    if (CCtxParams->ldmParams.enableLdm) cParams.windowLog = ZSTD_LDM_DEFAULT_WINDOW_LOG;

    if (CCtxParams->cParams.windowLog) cParams.windowLog = CCtxParams->cParams.windowLog;

    if (CCtxParams->cParams.hashLog) cParams.hashLog = CCtxParams->cParams.hashLog;

    if (CCtxParams->cParams.chainLog) cParams.chainLog = CCtxParams->cParams.chainLog;

    if (CCtxParams->cParams.searchLog) cParams.searchLog = CCtxParams->cParams.searchLog;

    if (CCtxParams->cParams.searchLength) cParams.searchLength = CCtxParams->cParams.searchLength;

    if (CCtxParams->cParams.targetLength) cParams.targetLength = CCtxParams->cParams.targetLength;

    if (CCtxParams->cParams.strategy) cParams.strategy = CCtxParams->cParams.strategy;

    return cParams;

}

static ZSTD_CCtx_params ZSTD_makeCCtxParamsFromCParams(

        ZSTD_compressionParameters cParams)

{

    ZSTD_CCtx_params cctxParams;

    memset(&cctxParams, 0, sizeof(cctxParams));

    cctxParams.cParams = cParams;

    cctxParams.compressionLevel = ZSTD_CLEVEL_DEFAULT;  /* should not matter, as all cParams are presumed properly defined */

    assert(!ZSTD_checkCParams(cParams));

    cctxParams.fParams.contentSizeFlag = 1;

    return cctxParams;

}

static ZSTD_CCtx_params* ZSTD_createCCtxParams_advanced(

        ZSTD_customMem customMem)

{

    ZSTD_CCtx_params* params;

    if (!customMem.customAlloc ^ !customMem.customFree) return NULL;

    params = (ZSTD_CCtx_params*)ZSTD_calloc(

            sizeof(ZSTD_CCtx_params), customMem);

    if (!params) { return NULL; }

    params->customMem = customMem;

    params->compressionLevel = ZSTD_CLEVEL_DEFAULT;

    params->fParams.contentSizeFlag = 1;

    return params;

ZSTD_CCtx_params* ZSTD_createCCtxParams(void)

{

    return ZSTD_createCCtxParams_advanced(ZSTD_defaultCMem);

}

size_t ZSTD_freeCCtxParams(ZSTD_CCtx_params* params)

{

    if (params == NULL) { return 0; }

    ZSTD_free(params, params->customMem);

    return 0;

}

size_t ZSTD_CCtxParams_reset(ZSTD_CCtx_params* params)

{

    return ZSTD_CCtxParams_init(params, ZSTD_CLEVEL_DEFAULT);

}

size_t ZSTD_CCtxParams_init(ZSTD_CCtx_params* cctxParams, int compressionLevel) {

    if (!cctxParams) { return ERROR(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); }

    CHECK_F( 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));

    return 0;

}

/* ZSTD_assignParamsToCCtxParams() :

 * params is presumed valid at this stage */

static ZSTD_CCtx_params ZSTD_assignParamsToCCtxParams(

        ZSTD_CCtx_params cctxParams, ZSTD_parameters params)

{

    ZSTD_CCtx_params ret = cctxParams;

    ret.cParams = params.cParams;

    ret.fParams = params.fParams;

    ret.compressionLevel = ZSTD_CLEVEL_DEFAULT;   /* should not matter, as all cParams are presumed properly defined */

    assert(!ZSTD_checkCParams(params.cParams));

    return ret;

}

#define CLAMPCHECK(val,min,max) {            \

    if (((val)<(min)) | ((val)>(max))) {     \

        return ERROR(parameter_outOfBound);  \

}   }

static int ZSTD_isUpdateAuthorized(ZSTD_cParameter param)

    case ZSTD_p_compressionLevel:

    case ZSTD_p_hashLog:

    case ZSTD_p_chainLog:

    case ZSTD_p_searchLog:

    case ZSTD_p_minMatch:

    case ZSTD_p_targetLength:

    case ZSTD_p_compressionStrategy:

    case ZSTD_p_compressLiterals:

        return 1;

    case ZSTD_p_format:

    case ZSTD_p_windowLog:

    case ZSTD_p_contentSizeFlag:

    case ZSTD_p_checksumFlag:

    case ZSTD_p_dictIDFlag:

    case ZSTD_p_forceMaxWindow :

    case ZSTD_p_nbWorkers:

    case ZSTD_p_jobSize:

    case ZSTD_p_overlapSizeLog:

    case ZSTD_p_enableLongDistanceMatching:

    case ZSTD_p_ldmHashLog:

    case ZSTD_p_ldmMinMatch:

    case ZSTD_p_ldmBucketSizeLog:

    case ZSTD_p_ldmHashEveryLog:

    default:

        return 0;

    }

}

size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, unsigned value)

{

    DEBUGLOG(4, "ZSTD_CCtx_setParameter (%u, %u)", (U32)param, value);

    if (cctx->streamStage != zcss_init) {

        if (ZSTD_isUpdateAuthorized(param)) {

            cctx->cParamsChanged = 1;

        } else {

            return ERROR(stage_wrong);

    }   }

    switch(param)

    {

    case ZSTD_p_format :

        return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);

    case ZSTD_p_compressionLevel:

        if (cctx->cdict) return ERROR(stage_wrong);

        return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);

    case ZSTD_p_windowLog:

    case ZSTD_p_hashLog:

    case ZSTD_p_chainLog:

    case ZSTD_p_searchLog:

    case ZSTD_p_minMatch:

    case ZSTD_p_targetLength:

    case ZSTD_p_compressionStrategy:

        if (cctx->cdict) return ERROR(stage_wrong);

        return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);

    case ZSTD_p_compressLiterals:

    case ZSTD_p_contentSizeFlag:

    case ZSTD_p_checksumFlag:

    case ZSTD_p_dictIDFlag:

        return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);

    case ZSTD_p_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_p_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_p_jobSize:

    case ZSTD_p_overlapSizeLog:

        return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);

    case ZSTD_p_enableLongDistanceMatching:

    case ZSTD_p_ldmHashLog:

    case ZSTD_p_ldmMinMatch:

    case ZSTD_p_ldmBucketSizeLog:

    case ZSTD_p_ldmHashEveryLog:

        if (cctx->cdict) return ERROR(stage_wrong);

        return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);

    default: return ERROR(parameter_unsupported);

size_t ZSTD_CCtxParam_setParameter(

        ZSTD_CCtx_params* CCtxParams, ZSTD_cParameter param, unsigned value)

    DEBUGLOG(4, "ZSTD_CCtxParam_setParameter (%u, %u)", (U32)param, value);

    switch(param)

    {

    case ZSTD_p_format :

        if (value > (unsigned)ZSTD_f_zstd1_magicless)

            return ERROR(parameter_unsupported);

        CCtxParams->format = (ZSTD_format_e)value;

        return (size_t)CCtxParams->format;

    case ZSTD_p_compressionLevel : {

        int cLevel = (int)value;  /* cast expected to restore negative sign */

        if (cLevel > ZSTD_maxCLevel()) cLevel = ZSTD_maxCLevel();

        if (cLevel) {  /* 0 : does not change current level */

            CCtxParams->disableLiteralCompression = (cLevel<0);  /* negative levels disable huffman */

            CCtxParams->compressionLevel = cLevel;

        }

        if (CCtxParams->compressionLevel >= 0) return CCtxParams->compressionLevel;

        return 0;  /* return type (size_t) cannot represent negative values */

    }

    case ZSTD_p_windowLog :

        if (value>0)   /* 0 => use default */

            CLAMPCHECK(value, ZSTD_WINDOWLOG_MIN, ZSTD_WINDOWLOG_MAX);

        CCtxParams->cParams.windowLog = value;

        return CCtxParams->cParams.windowLog;

    case ZSTD_p_hashLog :

        if (value>0)   /* 0 => use default */

            CLAMPCHECK(value, ZSTD_HASHLOG_MIN, ZSTD_HASHLOG_MAX);

        CCtxParams->cParams.hashLog = value;

        return CCtxParams->cParams.hashLog;

    case ZSTD_p_chainLog :

        if (value>0)   /* 0 => use default */

            CLAMPCHECK(value, ZSTD_CHAINLOG_MIN, ZSTD_CHAINLOG_MAX);

        CCtxParams->cParams.chainLog = value;

        return CCtxParams->cParams.chainLog;

    case ZSTD_p_searchLog :

        if (value>0)   /* 0 => use default */

            CLAMPCHECK(value, ZSTD_SEARCHLOG_MIN, ZSTD_SEARCHLOG_MAX);

        CCtxParams->cParams.searchLog = value;

        return value;