/*

 * 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 <string.h>         /* memset */

#include "cpu.h"

#include "mem.h"

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

}

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;

        if (!cctx) return NULL;

        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;

}

{

    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

    ZSTD_free(cctx, cctx->customMem);

}

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

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)

{

    switch(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:

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

    case ZSTD_p_minMatch :

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

            CLAMPCHECK(value, ZSTD_SEARCHLENGTH_MIN, ZSTD_SEARCHLENGTH_MAX);

        CCtxParams->cParams.searchLength = value;

        return CCtxParams->cParams.searchLength;

    case ZSTD_p_targetLength :

        /* all values are valid. 0 => use default */

        CCtxParams->cParams.targetLength = value;

        return CCtxParams->cParams.targetLength;

    case ZSTD_p_compressionStrategy :

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

            CLAMPCHECK(value, (unsigned)ZSTD_fast, (unsigned)ZSTD_btultra);

        CCtxParams->cParams.strategy = (ZSTD_strategy)value;

        return (size_t)CCtxParams->cParams.strategy;

    case ZSTD_p_contentSizeFlag :

        /* Content size written in frame header _when known_ (default:1) */

        DEBUGLOG(4, "set content size flag = %u", (value>0));

        CCtxParams->fParams.contentSizeFlag = value > 0;

        return CCtxParams->fParams.contentSizeFlag;

    case ZSTD_p_checksumFlag :

        /* A 32-bits content checksum will be calculated and written at end of frame (default:0) */

        CCtxParams->fParams.checksumFlag = value > 0;

        return CCtxParams->fParams.checksumFlag;

    case ZSTD_p_dictIDFlag : /* When applicable, dictionary's dictID is provided in frame header (default:1) */

        DEBUGLOG(4, "set dictIDFlag = %u", (value>0));

        CCtxParams->fParams.noDictIDFlag = !value;

        return !CCtxParams->fParams.noDictIDFlag;

    case ZSTD_p_forceMaxWindow :

        CCtxParams->forceWindow = (value > 0);

        return CCtxParams->forceWindow;

    case ZSTD_p_nbWorkers :

#ifndef ZSTD_MULTITHREAD

        if (value>0) return ERROR(parameter_unsupported);

        return 0;

#else

        return ZSTDMT_CCtxParam_setNbWorkers(CCtxParams, value);

#endif

    case ZSTD_p_jobSize :

#ifndef ZSTD_MULTITHREAD

        return ERROR(parameter_unsupported);

#else

        return ZSTDMT_CCtxParam_setMTCtxParameter(CCtxParams, ZSTDMT_p_jobSize, value);

#endif

    case ZSTD_p_overlapSizeLog :

#ifndef ZSTD_MULTITHREAD

        return ERROR(parameter_unsupported);

#else

        return ZSTDMT_CCtxParam_setMTCtxParameter(CCtxParams, ZSTDMT_p_overlapSectionLog, value);

#endif

    case ZSTD_p_enableLongDistanceMatching :

        CCtxParams->ldmParams.enableLdm = (value>0);

        return CCtxParams->ldmParams.enableLdm;

    case ZSTD_p_ldmHashLog :

        if (value>0)   /* 0 ==> auto */

            CLAMPCHECK(value, ZSTD_HASHLOG_MIN, ZSTD_HASHLOG_MAX);

        CCtxParams->ldmParams.hashLog = value;

        return CCtxParams->ldmParams.hashLog;

    case ZSTD_p_ldmMinMatch :

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

            CLAMPCHECK(value, ZSTD_LDM_MINMATCH_MIN, ZSTD_LDM_MINMATCH_MAX);

        CCtxParams->ldmParams.minMatchLength = value;

        return CCtxParams->ldmParams.minMatchLength;

    case ZSTD_p_ldmBucketSizeLog :

        if (value > ZSTD_LDM_BUCKETSIZELOG_MAX)

            return ERROR(parameter_outOfBound);

        CCtxParams->ldmParams.bucketSizeLog = value;

        return CCtxParams->ldmParams.bucketSizeLog;

    case ZSTD_p_ldmHashEveryLog :

        if (value > ZSTD_WINDOWLOG_MAX - ZSTD_HASHLOG_MIN)

            return ERROR(parameter_outOfBound);

        CCtxParams->ldmParams.hashEveryLog = value;

        return CCtxParams->ldmParams.hashEveryLog;

    default: return ERROR(parameter_unsupported);

    }

}