函数源码

Linux Kernel

v5.5.9

Brick Technologies Co., Ltd

Source File:lib\zstd\compress.c Create Date:2022-07-27 08:02:51
首页 Copyright©Brick

2347
2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
2364
2365
2366
2367
2368
2369
2370
2371
2372
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384
2385
2386
2387
2388
2389
2390
2391
2392
2393
2394
2395
2396
2397
2398
2399
2400
2401
2402
2403
2404
2405
2406
2407
2408
2409
2410
2411
2412
2413
2414
2415
2416
2417
2418
2419
2420
2421
2422
2423
2424
2425
2426
2427
2428
/*! 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;
}