1 /* 2 * Copyright (c) 2016-2020, 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 19 20 /*-*********************************************************** 21 * Streaming compression 22 * 23 * A ZBUFF_CCtx object is required to track streaming operation. 24 * Use ZBUFF_createCCtx() and ZBUFF_freeCCtx() to create/release resources. 25 * Use ZBUFF_compressInit() to start a new compression operation. 26 * ZBUFF_CCtx objects can be reused multiple times. 27 * 28 * Use ZBUFF_compressContinue() repetitively to consume your input. 29 * *srcSizePtr and *dstCapacityPtr can be any size. 30 * The function will report how many bytes were read or written by modifying *srcSizePtr and *dstCapacityPtr. 31 * 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. 32 * The content of dst will be overwritten (up to *dstCapacityPtr) at each function call, so save its content if it matters or change dst . 33 * @return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to improve latency) 34 * or an error code, which can be tested using ZBUFF_isError(). 35 * 36 * ZBUFF_compressFlush() can be used to instruct ZBUFF to compress and output whatever remains within its buffer. 37 * Note that it will not output more than *dstCapacityPtr. 38 * Therefore, some content might still be left into its internal buffer if dst buffer is too small. 39 * @return : nb of bytes still present into internal buffer (0 if it's empty) 40 * or an error code, which can be tested using ZBUFF_isError(). 41 * 42 * ZBUFF_compressEnd() instructs to finish a frame. 43 * It will perform a flush and write frame epilogue. 44 * Similar to ZBUFF_compressFlush(), it may not be able to output the entire internal buffer content if *dstCapacityPtr is too small. 45 * @return : nb of bytes still present into internal buffer (0 if it's empty) 46 * or an error code, which can be tested using ZBUFF_isError(). 47 * 48 * Hint : recommended buffer sizes (not compulsory) 49 * input : ZSTD_BLOCKSIZE_MAX (128 KB), internal unit size, it improves latency to use this value. 50 * 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. 51 * ***********************************************************/ 52 53 ZBUFF_CCtx* ZBUFF_createCCtx(void) 54 { 55 return ZSTD_createCStream(); 56 } 57 58 ZBUFF_CCtx* ZBUFF_createCCtx_advanced(ZSTD_customMem customMem) 59 { 60 return ZSTD_createCStream_advanced(customMem); 61 } 62 63 size_t ZBUFF_freeCCtx(ZBUFF_CCtx* zbc) 64 { 65 return ZSTD_freeCStream(zbc); 66 } 67 68 69 /* ====== Initialization ====== */ 70 71 size_t ZBUFF_compressInit_advanced(ZBUFF_CCtx* zbc, 72 const void* dict, size_t dictSize, 73 ZSTD_parameters params, unsigned long long pledgedSrcSize) 74 { 75 if (pledgedSrcSize==0) pledgedSrcSize = ZSTD_CONTENTSIZE_UNKNOWN; /* preserve "0 == unknown" behavior */ 76 return ZSTD_initCStream_advanced(zbc, dict, dictSize, params, pledgedSrcSize); 77 } 78 79 80 size_t ZBUFF_compressInitDictionary(ZBUFF_CCtx* zbc, const void* dict, size_t dictSize, int compressionLevel) 81 { 82 return ZSTD_initCStream_usingDict(zbc, dict, dictSize, compressionLevel); 83 } 84 85 size_t ZBUFF_compressInit(ZBUFF_CCtx* zbc, int compressionLevel) 86 { 87 return ZSTD_initCStream(zbc, compressionLevel); 88 } 89 90 /* ====== Compression ====== */ 91 92 93 size_t ZBUFF_compressContinue(ZBUFF_CCtx* zbc, 94 void* dst, size_t* dstCapacityPtr, 95 const void* src, size_t* srcSizePtr) 96 { 97 size_t result; 98 ZSTD_outBuffer outBuff; 99 ZSTD_inBuffer inBuff; 100 outBuff.dst = dst; 101 outBuff.pos = 0; 102 outBuff.size = *dstCapacityPtr; 103 inBuff.src = src; 104 inBuff.pos = 0; 105 inBuff.size = *srcSizePtr; 106 result = ZSTD_compressStream(zbc, &outBuff, &inBuff); 107 *dstCapacityPtr = outBuff.pos; 108 *srcSizePtr = inBuff.pos; 109 return result; 110 } 111 112 113 114 /* ====== Finalize ====== */ 115 116 size_t ZBUFF_compressFlush(ZBUFF_CCtx* zbc, void* dst, size_t* dstCapacityPtr) 117 { 118 size_t result; 119 ZSTD_outBuffer outBuff; 120 outBuff.dst = dst; 121 outBuff.pos = 0; 122 outBuff.size = *dstCapacityPtr; 123 result = ZSTD_flushStream(zbc, &outBuff); 124 *dstCapacityPtr = outBuff.pos; 125 return result; 126 } 127 128 129 size_t ZBUFF_compressEnd(ZBUFF_CCtx* zbc, void* dst, size_t* dstCapacityPtr) 130 { 131 size_t result; 132 ZSTD_outBuffer outBuff; 133 outBuff.dst = dst; 134 outBuff.pos = 0; 135 outBuff.size = *dstCapacityPtr; 136 result = ZSTD_endStream(zbc, &outBuff); 137 *dstCapacityPtr = outBuff.pos; 138 return result; 139 } 140 141 142 143 /* ************************************* 144 * Tool functions 145 ***************************************/ 146 size_t ZBUFF_recommendedCInSize(void) { return ZSTD_CStreamInSize(); } 147 size_t ZBUFF_recommendedCOutSize(void) { return ZSTD_CStreamOutSize(); } 148