/*

 * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.

 * All rights reserved.

 *

 * 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.

 */

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

*  Dependencies

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

#include <limits.h>         /* INT_MAX */

#include <string.h>         /* memset */

#include "cpu.h"

#include "mem.h"

#include "hist.h"           /* HIST_countFast_wksp */

#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_fast.h"

#include "zstd_double_fast.h"

#include "zstd_lazy.h"

#include "zstd_opt.h"

#include "zstd_ldm.h"

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

*  Helper functions

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

size_t ZSTD_compressBound(size_t srcSize) {

    return ZSTD_COMPRESSBOUND(srcSize);

}

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

*  Context memory management

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

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_customMem customMem;

    U32 dictID;

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

ZSTD_CCtx* ZSTD_createCCtx(void)

{

    return ZSTD_createCCtx_advanced(ZSTD_defaultCMem);

}

static void ZSTD_initCCtx(ZSTD_CCtx* cctx, ZSTD_customMem memManager)

{

    assert(cctx != NULL);

    memset(cctx, 0, sizeof(*cctx));

    cctx->customMem = memManager;

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

    {   size_t const err = ZSTD_CCtx_reset(cctx, ZSTD_reset_parameters);

        assert(!ZSTD_isError(err));

        (void)err;

    }

}

ZSTD_CCtx* ZSTD_createCCtx_advanced(ZSTD_customMem customMem)

{

    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_malloc(sizeof(ZSTD_CCtx), customMem);

        if (!cctx) return NULL;

        ZSTD_initCCtx(cctx, customMem);

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

    return cctx;

}

static void ZSTD_freeCCtxContent(ZSTD_CCtx* cctx)

{

    assert(cctx != NULL);

    assert(cctx->staticSize == 0);

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

#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 */

    ZSTD_freeCCtxContent(cctx);

    ZSTD_free(cctx, cctx->customMem);

    return 0;

}

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

}

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_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); }

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) {

    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)

{

    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;

}

ZSTD_bounds ZSTD_cParam_getBounds(ZSTD_cParameter param)

{

    ZSTD_bounds bounds = { 0, 0, 0 };

    switch(param)

    {

    case ZSTD_c_compressionLevel:

        bounds.lowerBound = ZSTD_minCLevel();

        bounds.upperBound = ZSTD_maxCLevel();

        return bounds;

    case ZSTD_c_windowLog:

        bounds.lowerBound = ZSTD_WINDOWLOG_MIN;

        bounds.upperBound = ZSTD_WINDOWLOG_MAX;

        return bounds;

    case ZSTD_c_hashLog:

        bounds.lowerBound = ZSTD_HASHLOG_MIN;

        bounds.upperBound = ZSTD_HASHLOG_MAX;

        return bounds;

    case ZSTD_c_chainLog:

        bounds.lowerBound = ZSTD_CHAINLOG_MIN;

        bounds.upperBound = ZSTD_CHAINLOG_MAX;

        return bounds;

    case ZSTD_c_searchLog:

        bounds.lowerBound = ZSTD_SEARCHLOG_MIN;

        bounds.upperBound = ZSTD_SEARCHLOG_MAX;

        return bounds;

    case ZSTD_c_minMatch:

        bounds.lowerBound = ZSTD_MINMATCH_MIN;

        bounds.upperBound = ZSTD_MINMATCH_MAX;

        return bounds;

    case ZSTD_c_targetLength:

        bounds.lowerBound = ZSTD_TARGETLENGTH_MIN;

        bounds.upperBound = ZSTD_TARGETLENGTH_MAX;

        return bounds;

    case ZSTD_c_strategy:

        bounds.lowerBound = ZSTD_STRATEGY_MIN;

        bounds.upperBound = ZSTD_STRATEGY_MAX;

        return bounds;

    case ZSTD_c_contentSizeFlag:

        bounds.lowerBound = 0;

        bounds.upperBound = 1;

        return bounds;

    case ZSTD_c_checksumFlag:

        bounds.lowerBound = 0;

        bounds.upperBound = 1;

        return bounds;

    case ZSTD_c_dictIDFlag:

        bounds.lowerBound = 0;

        bounds.upperBound = 1;

        return bounds;

    case ZSTD_c_nbWorkers:

        bounds.lowerBound = 0;

#ifdef ZSTD_MULTITHREAD

        bounds.upperBound = ZSTDMT_NBWORKERS_MAX;

#else

        bounds.upperBound = 0;

#endif

        return bounds;

    case ZSTD_c_jobSize:

        bounds.lowerBound = 0;

#ifdef ZSTD_MULTITHREAD

        bounds.upperBound = ZSTDMT_JOBSIZE_MAX;

#else

        bounds.upperBound = 0;

#endif

        return bounds;

    case ZSTD_c_overlapLog:

        bounds.lowerBound = ZSTD_OVERLAPLOG_MIN;

        bounds.upperBound = ZSTD_OVERLAPLOG_MAX;

        return bounds;

    case ZSTD_c_enableLongDistanceMatching:

        bounds.lowerBound = 0;

        bounds.upperBound = 1;

        return bounds;

    case ZSTD_c_ldmHashLog:

        bounds.lowerBound = ZSTD_LDM_HASHLOG_MIN;

        bounds.upperBound = ZSTD_LDM_HASHLOG_MAX;

        return bounds;

    case ZSTD_c_ldmMinMatch:

        bounds.lowerBound = ZSTD_LDM_MINMATCH_MIN;

        bounds.upperBound = ZSTD_LDM_MINMATCH_MAX;

        return bounds;

    case ZSTD_c_ldmBucketSizeLog:

        bounds.lowerBound = ZSTD_LDM_BUCKETSIZELOG_MIN;

        bounds.upperBound = ZSTD_LDM_BUCKETSIZELOG_MAX;

        return bounds;

    case ZSTD_c_ldmHashRateLog:

        bounds.lowerBound = ZSTD_LDM_HASHRATELOG_MIN;

        bounds.upperBound = ZSTD_LDM_HASHRATELOG_MAX;

        return bounds;

    /* experimental parameters */

    case ZSTD_c_rsyncable:

        bounds.lowerBound = 0;

        bounds.upperBound = 1;

        return bounds;

    case ZSTD_c_forceMaxWindow :

        bounds.lowerBound = 0;

        bounds.upperBound = 1;

        return bounds;

    case ZSTD_c_format:

        ZSTD_STATIC_ASSERT(ZSTD_f_zstd1 < ZSTD_f_zstd1_magicless);

        bounds.lowerBound = ZSTD_f_zstd1;

        bounds.upperBound = ZSTD_f_zstd1_magicless;   /* note : how to ensure at compile time that this is the highest value enum ? */

        return bounds;

    case ZSTD_c_forceAttachDict:

        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;

    default:

        {   ZSTD_bounds const boundError = { ERROR(parameter_unsupported), 0, 0 };

            return boundError;

        }

    }

}

{

    ZSTD_bounds const bounds = ZSTD_cParam_getBounds(cParam);

}

static int ZSTD_isUpdateAuthorized(ZSTD_cParameter param)

{

    switch(param)

    {

    case ZSTD_c_compressionLevel:

    case ZSTD_c_hashLog:

    case ZSTD_c_chainLog:

    case ZSTD_c_searchLog:

    case ZSTD_c_minMatch:

    case ZSTD_c_targetLength:

    case ZSTD_c_strategy:

        return 1;

    case ZSTD_c_format:

    case ZSTD_c_windowLog:

    case ZSTD_c_contentSizeFlag:

    case ZSTD_c_checksumFlag:

    case ZSTD_c_dictIDFlag:

    case ZSTD_c_forceMaxWindow :

    case ZSTD_c_nbWorkers:

    case ZSTD_c_jobSize:

    case ZSTD_c_overlapLog:

    case ZSTD_c_rsyncable:

    case ZSTD_c_enableLongDistanceMatching:

    case ZSTD_c_ldmHashLog:

    case ZSTD_c_ldmMinMatch:

    case ZSTD_c_ldmBucketSizeLog:

    case ZSTD_c_ldmHashRateLog:

    case ZSTD_c_forceAttachDict:

    default:

        return 0;

    }

}

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

{

    DEBUGLOG(4, "ZSTD_CCtx_setParameter (%i, %i)", (int)param, value);

    if (cctx->streamStage != zcss_init) {

        if (ZSTD_isUpdateAuthorized(param)) {

            cctx->cParamsChanged = 1;

        } else {

    }   }

    switch(param)

    {

    case ZSTD_c_compressionLevel:

    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:

    case ZSTD_c_contentSizeFlag:

    case ZSTD_c_checksumFlag:

    case ZSTD_c_dictIDFlag:

    case ZSTD_c_forceAttachDict:

    case ZSTD_c_jobSize:

    case ZSTD_c_overlapLog:

    case ZSTD_c_rsyncable:

    case ZSTD_c_enableLongDistanceMatching: