ZSTD_compress

/*! ZSTD_compress_generic() :
*   Compress a chunk of data into one or multiple blocks.
*   All blocks will be terminated, all input will be consumed.
*   Function will issue an error if there is not enough `dstCapacity` to hold the compressed content.
*   Frame is supposed already started (header already produced)
*   @return : compressed size, or an error code
*/
static size_t ZSTD_compress_generic(ZSTD_CCtx *cctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize, U32 lastFrameChunk)
{
    size_t blockSize = cctx->blockSize;
    size_t remaining = srcSize;
    const BYTE *ip = (const BYTE *)src;
    BYTE *const ostart = (BYTE *)dst;
    BYTE *op = ostart;
    U32 const maxDist = 1 << cctx->params.cParams.windowLog;
 
    if (cctx->params.fParams.checksumFlag && srcSize)
        xxh64_update(&cctx->xxhState, src, srcSize);
 
    while (remaining) {
        U32 const lastBlock = lastFrameChunk & (blockSize >= remaining);
        size_t cSize;
 
        if (dstCapacity < ZSTD_blockHeaderSize + MIN_CBLOCK_SIZE)
            return ERROR(dstSize_tooSmall); /* not enough space to store compressed block */
        if (remaining < blockSize)
            blockSize = remaining;
 
        /* preemptive overflow correction */
        if (cctx->lowLimit > (3U << 29)) {
            U32 const cycleMask = (1 << ZSTD_cycleLog(cctx->params.cParams.hashLog, cctx->params.cParams.strategy)) - 1;
            U32 const curr = (U32)(ip - cctx->base);
            U32 const newCurr = (curr & cycleMask) + (1 << cctx->params.cParams.windowLog);
            U32 const correction = curr - newCurr;
            ZSTD_STATIC_ASSERT(ZSTD_WINDOWLOG_MAX_64 <= 30);
            ZSTD_reduceIndex(cctx, correction);
            cctx->base += correction;
            cctx->dictBase += correction;
            cctx->lowLimit -= correction;
            cctx->dictLimit -= correction;
            if (cctx->nextToUpdate < correction)
                cctx->nextToUpdate = 0;
            else
                cctx->nextToUpdate -= correction;
        }
 
        if ((U32)(ip + blockSize - cctx->base) > cctx->loadedDictEnd + maxDist) {
            /* enforce maxDist */
            U32 const newLowLimit = (U32)(ip + blockSize - cctx->base) - maxDist;
            if (cctx->lowLimit < newLowLimit)
                cctx->lowLimit = newLowLimit;
            if (cctx->dictLimit < cctx->lowLimit)
                cctx->dictLimit = cctx->lowLimit;
        }
 
        cSize = ZSTD_compressBlock_internal(cctx, op + ZSTD_blockHeaderSize, dstCapacity - ZSTD_blockHeaderSize, ip, blockSize);
        if (ZSTD_isError(cSize))
            return cSize;
 
        if (cSize == 0) { /* block is not compressible */
            U32 const cBlockHeader24 = lastBlock + (((U32)bt_raw) << 1) + (U32)(blockSize << 3);
            if (blockSize + ZSTD_blockHeaderSize > dstCapacity)
                return ERROR(dstSize_tooSmall);
            ZSTD_writeLE32(op, cBlockHeader24); /* no pb, 4th byte will be overwritten */
            memcpy(op + ZSTD_blockHeaderSize, ip, blockSize);
            cSize = ZSTD_blockHeaderSize + blockSize;
        } else {
            U32 const cBlockHeader24 = lastBlock + (((U32)bt_compressed) << 1) + (U32)(cSize << 3);
            ZSTD_writeLE24(op, cBlockHeader24);
            cSize += ZSTD_blockHeaderSize;
        }
 
        remaining -= blockSize;
        dstCapacity -= cSize;
        ip += blockSize;
        op += cSize;
    }
 
    if (lastFrameChunk && (op > ostart))
        cctx->stage = ZSTDcs_ending;
    return op - ostart;
}
函数源码
