1 /* 2 * Copyright (c) Yann Collet, Facebook, Inc. 3 * All rights reserved. 4 * 5 * This source code is licensed under both the BSD-style license (found in the 6 * LICENSE file in the root directory of this source tree) and the GPLv2 (found 7 * in the COPYING file in the root directory of this source tree). 8 * You may select, at your option, one of the above-listed licenses. 9 */ 10 11 12 13 /* ************************************* 14 * Dependencies 15 ***************************************/ 16 #define ZBUFF_STATIC_LINKING_ONLY 17 #include "zbuff.h" 18 #include "../common/error_private.h" 19 20 21 /*-*********************************************************** 22 * Streaming compression 23 * 24 * A ZBUFF_CCtx object is required to track streaming operation. 25 * Use ZBUFF_createCCtx() and ZBUFF_freeCCtx() to create/release resources. 26 * Use ZBUFF_compressInit() to start a new compression operation. 27 * ZBUFF_CCtx objects can be reused multiple times. 28 * 29 * Use ZBUFF_compressContinue() repetitively to consume your input. 30 * *srcSizePtr and *dstCapacityPtr can be any size. 31 * The function will report how many bytes were read or written by modifying *srcSizePtr and *dstCapacityPtr. 32 * 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. 33 * The content of dst will be overwritten (up to *dstCapacityPtr) at each function call, so save its content if it matters or change dst . 34 * @return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to improve latency) 35 * or an error code, which can be tested using ZBUFF_isError(). 36 * 37 * ZBUFF_compressFlush() can be used to instruct ZBUFF to compress and output whatever remains within its buffer. 38 * Note that it will not output more than *dstCapacityPtr. 39 * Therefore, some content might still be left into its internal buffer if dst buffer is too small. 40 * @return : nb of bytes still present into internal buffer (0 if it's empty) 41 * or an error code, which can be tested using ZBUFF_isError(). 42 * 43 * ZBUFF_compressEnd() instructs to finish a frame. 44 * It will perform a flush and write frame epilogue. 45 * Similar to ZBUFF_compressFlush(), it may not be able to output the entire internal buffer content if *dstCapacityPtr is too small. 46 * @return : nb of bytes still present into internal buffer (0 if it's empty) 47 * or an error code, which can be tested using ZBUFF_isError(). 48 * 49 * Hint : recommended buffer sizes (not compulsory) 50 * input : ZSTD_BLOCKSIZE_MAX (128 KB), internal unit size, it improves latency to use this value. 51 * 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. 52 * ***********************************************************/ 53 54 ZBUFF_CCtx* ZBUFF_createCCtx(void) 55 { 56 return ZSTD_createCStream(); 57 } 58 59 ZBUFF_CCtx* ZBUFF_createCCtx_advanced(ZSTD_customMem customMem) 60 { 61 return ZSTD_createCStream_advanced(customMem); 62 } 63 64 size_t ZBUFF_freeCCtx(ZBUFF_CCtx* zbc) 65 { 66 return ZSTD_freeCStream(zbc); 67 } 68 69 70 /* ====== Initialization ====== */ 71 72 size_t ZBUFF_compressInit_advanced(ZBUFF_CCtx* zbc, 73 const void* dict, size_t dictSize, 74 ZSTD_parameters params, unsigned long long pledgedSrcSize) 75 { 76 if (pledgedSrcSize==0) pledgedSrcSize = ZSTD_CONTENTSIZE_UNKNOWN; /* preserve "0 == unknown" behavior */ 77 FORWARD_IF_ERROR(ZSTD_CCtx_reset(zbc, ZSTD_reset_session_only), ""); 78 FORWARD_IF_ERROR(ZSTD_CCtx_setPledgedSrcSize(zbc, pledgedSrcSize), ""); 79 80 FORWARD_IF_ERROR(ZSTD_checkCParams(params.cParams), ""); 81 FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_windowLog, params.cParams.windowLog), ""); 82 FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_hashLog, params.cParams.hashLog), ""); 83 FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_chainLog, params.cParams.chainLog), ""); 84 FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_searchLog, params.cParams.searchLog), ""); 85 FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_minMatch, params.cParams.minMatch), ""); 86 FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_targetLength, params.cParams.targetLength), ""); 87 FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_strategy, params.cParams.strategy), ""); 88 89 FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_contentSizeFlag, params.fParams.contentSizeFlag), ""); 90 FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_checksumFlag, params.fParams.checksumFlag), ""); 91 FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_dictIDFlag, params.fParams.noDictIDFlag), ""); 92 93 FORWARD_IF_ERROR(ZSTD_CCtx_loadDictionary(zbc, dict, dictSize), ""); 94 return 0; 95 } 96 97 size_t ZBUFF_compressInitDictionary(ZBUFF_CCtx* zbc, const void* dict, size_t dictSize, int compressionLevel) 98 { 99 FORWARD_IF_ERROR(ZSTD_CCtx_reset(zbc, ZSTD_reset_session_only), ""); 100 FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_compressionLevel, compressionLevel), ""); 101 FORWARD_IF_ERROR(ZSTD_CCtx_loadDictionary(zbc, dict, dictSize), ""); 102 return 0; 103 } 104 105 size_t ZBUFF_compressInit(ZBUFF_CCtx* zbc, int compressionLevel) 106 { 107 return ZSTD_initCStream(zbc, compressionLevel); 108 } 109 110 /* ====== Compression ====== */ 111 112 113 size_t ZBUFF_compressContinue(ZBUFF_CCtx* zbc, 114 void* dst, size_t* dstCapacityPtr, 115 const void* src, size_t* srcSizePtr) 116 { 117 size_t result; 118 ZSTD_outBuffer outBuff; 119 ZSTD_inBuffer inBuff; 120 outBuff.dst = dst; 121 outBuff.pos = 0; 122 outBuff.size = *dstCapacityPtr; 123 inBuff.src = src; 124 inBuff.pos = 0; 125 inBuff.size = *srcSizePtr; 126 result = ZSTD_compressStream(zbc, &outBuff, &inBuff); 127 *dstCapacityPtr = outBuff.pos; 128 *srcSizePtr = inBuff.pos; 129 return result; 130 } 131 132 133 134 /* ====== Finalize ====== */ 135 136 size_t ZBUFF_compressFlush(ZBUFF_CCtx* zbc, void* dst, size_t* dstCapacityPtr) 137 { 138 size_t result; 139 ZSTD_outBuffer outBuff; 140 outBuff.dst = dst; 141 outBuff.pos = 0; 142 outBuff.size = *dstCapacityPtr; 143 result = ZSTD_flushStream(zbc, &outBuff); 144 *dstCapacityPtr = outBuff.pos; 145 return result; 146 } 147 148 149 size_t ZBUFF_compressEnd(ZBUFF_CCtx* zbc, void* dst, size_t* dstCapacityPtr) 150 { 151 size_t result; 152 ZSTD_outBuffer outBuff; 153 outBuff.dst = dst; 154 outBuff.pos = 0; 155 outBuff.size = *dstCapacityPtr; 156 result = ZSTD_endStream(zbc, &outBuff); 157 *dstCapacityPtr = outBuff.pos; 158 return result; 159 } 160 161 162 163 /* ************************************* 164 * Tool functions 165 ***************************************/ 166 size_t ZBUFF_recommendedCInSize(void) { return ZSTD_CStreamInSize(); } 167 size_t ZBUFF_recommendedCOutSize(void) { return ZSTD_CStreamOutSize(); } 168