168 lines
6.6 KiB
C
168 lines
6.6 KiB
C
|
/*
|
||
|
|
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
||
|
|
* 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
|
||
|
|
***************************************/
|
||
|
|
#define ZBUFF_STATIC_LINKING_ONLY
|
||
|
|
#include "zbuff.h"
|
||
|
|
#include "../common/error_private.h"
|
||
|
|
|
||
|
|
|
||
|
|
/*-***********************************************************
|
||
|
|
* Streaming compression
|
||
|
|
*
|
||
|
|
* A ZBUFF_CCtx object is required to track streaming operation.
|
||
|
|
* Use ZBUFF_createCCtx() and ZBUFF_freeCCtx() to create/release resources.
|
||
|
|
* Use ZBUFF_compressInit() to start a new compression operation.
|
||
|
|
* ZBUFF_CCtx objects can be reused multiple times.
|
||
|
|
*
|
||
|
|
* Use ZBUFF_compressContinue() repetitively to consume your input.
|
||
|
|
* *srcSizePtr and *dstCapacityPtr can be any size.
|
||
|
|
* The function will report how many bytes were read or written by modifying *srcSizePtr and *dstCapacityPtr.
|
||
|
|
* Note that it may not consume the entire input, in which case it's up to the caller to call again the function with remaining input.
|
||
|
|
* The content of dst will be overwritten (up to *dstCapacityPtr) at each function call, so save its content if it matters or change dst .
|
||
|
|
* @return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to improve latency)
|
||
|
|
* or an error code, which can be tested using ZBUFF_isError().
|
||
|
|
*
|
||
|
|
* ZBUFF_compressFlush() can be used to instruct ZBUFF to compress and output whatever remains within its buffer.
|
||
|
|
* Note that it will not output more than *dstCapacityPtr.
|
||
|
|
* Therefore, some content might still be left into its internal buffer if dst buffer is too small.
|
||
|
|
* @return : nb of bytes still present into internal buffer (0 if it's empty)
|
||
|
|
* or an error code, which can be tested using ZBUFF_isError().
|
||
|
|
*
|
||
|
|
* ZBUFF_compressEnd() instructs to finish a frame.
|
||
|
|
* It will perform a flush and write frame epilogue.
|
||
|
|
* Similar to ZBUFF_compressFlush(), it may not be able to output the entire internal buffer content if *dstCapacityPtr is too small.
|
||
|
|
* @return : nb of bytes still present into internal buffer (0 if it's empty)
|
||
|
|
* or an error code, which can be tested using ZBUFF_isError().
|
||
|
|
*
|
||
|
|
* Hint : recommended buffer sizes (not compulsory)
|
||
|
|
* input : ZSTD_BLOCKSIZE_MAX (128 KB), internal unit size, it improves latency to use this value.
|
||
|
|
* output : ZSTD_compressBound(ZSTD_BLOCKSIZE_MAX) + ZSTD_blockHeaderSize + ZBUFF_endFrameSize : ensures it's always possible to write/flush/end a full block at best speed.
|
||
|
|
* ***********************************************************/
|
||
|
|
|
||
|
|
ZBUFF_CCtx* ZBUFF_createCCtx(void)
|
||
|
|
{
|
||
|
|
return ZSTD_createCStream();
|
||
|
|
}
|
||
|
|
|
||
|
|
ZBUFF_CCtx* ZBUFF_createCCtx_advanced(ZSTD_customMem customMem)
|
||
|
|
{
|
||
|
|
return ZSTD_createCStream_advanced(customMem);
|
||
|
|
}
|
||
|
|
|
||
|
|
size_t ZBUFF_freeCCtx(ZBUFF_CCtx* zbc)
|
||
|
|
{
|
||
|
|
return ZSTD_freeCStream(zbc);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/* ====== Initialization ====== */
|
||
|
|
|
||
|
|
size_t ZBUFF_compressInit_advanced(ZBUFF_CCtx* zbc,
|
||
|
|
const void* dict, size_t dictSize,
|
||
|
|
ZSTD_parameters params, unsigned long long pledgedSrcSize)
|
||
|
|
{
|
||
|
|
if (pledgedSrcSize==0) pledgedSrcSize = ZSTD_CONTENTSIZE_UNKNOWN; /* preserve "0 == unknown" behavior */
|
||
|
|
FORWARD_IF_ERROR(ZSTD_CCtx_reset(zbc, ZSTD_reset_session_only), "");
|
||
|
|
FORWARD_IF_ERROR(ZSTD_CCtx_setPledgedSrcSize(zbc, pledgedSrcSize), "");
|
||
|
|
|
||
|
|
FORWARD_IF_ERROR(ZSTD_checkCParams(params.cParams), "");
|
||
|
|
FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_windowLog, params.cParams.windowLog), "");
|
||
|
|
FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_hashLog, params.cParams.hashLog), "");
|
||
|
|
FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_chainLog, params.cParams.chainLog), "");
|
||
|
|
FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_searchLog, params.cParams.searchLog), "");
|
||
|
|
FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_minMatch, params.cParams.minMatch), "");
|
||
|
|
FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_targetLength, params.cParams.targetLength), "");
|
||
|
|
FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_strategy, params.cParams.strategy), "");
|
||
|
|
|
||
|
|
FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_contentSizeFlag, params.fParams.contentSizeFlag), "");
|
||
|
|
FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_checksumFlag, params.fParams.checksumFlag), "");
|
||
|
|
FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_dictIDFlag, params.fParams.noDictIDFlag), "");
|
||
|
|
|
||
|
|
FORWARD_IF_ERROR(ZSTD_CCtx_loadDictionary(zbc, dict, dictSize), "");
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
size_t ZBUFF_compressInitDictionary(ZBUFF_CCtx* zbc, const void* dict, size_t dictSize, int compressionLevel)
|
||
|
|
{
|
||
|
|
FORWARD_IF_ERROR(ZSTD_CCtx_reset(zbc, ZSTD_reset_session_only), "");
|
||
|
|
FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_compressionLevel, compressionLevel), "");
|
||
|
|
FORWARD_IF_ERROR(ZSTD_CCtx_loadDictionary(zbc, dict, dictSize), "");
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
size_t ZBUFF_compressInit(ZBUFF_CCtx* zbc, int compressionLevel)
|
||
|
|
{
|
||
|
|
return ZSTD_initCStream(zbc, compressionLevel);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* ====== Compression ====== */
|
||
|
|
|
||
|
|
|
||
|
|
size_t ZBUFF_compressContinue(ZBUFF_CCtx* zbc,
|
||
|
|
void* dst, size_t* dstCapacityPtr,
|
||
|
|
const void* src, size_t* srcSizePtr)
|
||
|
|
{
|
||
|
|
size_t result;
|
||
|
|
ZSTD_outBuffer outBuff;
|
||
|
|
ZSTD_inBuffer inBuff;
|
||
|
|
outBuff.dst = dst;
|
||
|
|
outBuff.pos = 0;
|
||
|
|
outBuff.size = *dstCapacityPtr;
|
||
|
|
inBuff.src = src;
|
||
|
|
inBuff.pos = 0;
|
||
|
|
inBuff.size = *srcSizePtr;
|
||
|
|
result = ZSTD_compressStream(zbc, &outBuff, &inBuff);
|
||
|
|
*dstCapacityPtr = outBuff.pos;
|
||
|
|
*srcSizePtr = inBuff.pos;
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/* ====== Finalize ====== */
|
||
|
|
|
||
|
|
size_t ZBUFF_compressFlush(ZBUFF_CCtx* zbc, void* dst, size_t* dstCapacityPtr)
|
||
|
|
{
|
||
|
|
size_t result;
|
||
|
|
ZSTD_outBuffer outBuff;
|
||
|
|
outBuff.dst = dst;
|
||
|
|
outBuff.pos = 0;
|
||
|
|
outBuff.size = *dstCapacityPtr;
|
||
|
|
result = ZSTD_flushStream(zbc, &outBuff);
|
||
|
|
*dstCapacityPtr = outBuff.pos;
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
size_t ZBUFF_compressEnd(ZBUFF_CCtx* zbc, void* dst, size_t* dstCapacityPtr)
|
||
|
|
{
|
||
|
|
size_t result;
|
||
|
|
ZSTD_outBuffer outBuff;
|
||
|
|
outBuff.dst = dst;
|
||
|
|
outBuff.pos = 0;
|
||
|
|
outBuff.size = *dstCapacityPtr;
|
||
|
|
result = ZSTD_endStream(zbc, &outBuff);
|
||
|
|
*dstCapacityPtr = outBuff.pos;
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/* *************************************
|
||
|
|
* Tool functions
|
||
|
|
***************************************/
|
||
|
|
size_t ZBUFF_recommendedCInSize(void) { return ZSTD_CStreamInSize(); }
|
||
|
|
size_t ZBUFF_recommendedCOutSize(void) { return ZSTD_CStreamOutSize(); }
|