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
ZBUFF_createCCtx(void)54 ZBUFF_CCtx* ZBUFF_createCCtx(void)
55 {
56 return ZSTD_createCStream();
57 }
58
ZBUFF_createCCtx_advanced(ZSTD_customMem customMem)59 ZBUFF_CCtx* ZBUFF_createCCtx_advanced(ZSTD_customMem customMem)
60 {
61 return ZSTD_createCStream_advanced(customMem);
62 }
63
ZBUFF_freeCCtx(ZBUFF_CCtx * zbc)64 size_t ZBUFF_freeCCtx(ZBUFF_CCtx* zbc)
65 {
66 return ZSTD_freeCStream(zbc);
67 }
68
69
70 /* ====== Initialization ====== */
71
ZBUFF_compressInit_advanced(ZBUFF_CCtx * zbc,const void * dict,size_t dictSize,ZSTD_parameters params,unsigned long long pledgedSrcSize)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
ZBUFF_compressInitDictionary(ZBUFF_CCtx * zbc,const void * dict,size_t dictSize,int compressionLevel)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
ZBUFF_compressInit(ZBUFF_CCtx * zbc,int compressionLevel)105 size_t ZBUFF_compressInit(ZBUFF_CCtx* zbc, int compressionLevel)
106 {
107 return ZSTD_initCStream(zbc, compressionLevel);
108 }
109
110 /* ====== Compression ====== */
111
112
ZBUFF_compressContinue(ZBUFF_CCtx * zbc,void * dst,size_t * dstCapacityPtr,const void * src,size_t * srcSizePtr)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
ZBUFF_compressFlush(ZBUFF_CCtx * zbc,void * dst,size_t * dstCapacityPtr)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
ZBUFF_compressEnd(ZBUFF_CCtx * zbc,void * dst,size_t * dstCapacityPtr)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 ***************************************/
ZBUFF_recommendedCInSize(void)166 size_t ZBUFF_recommendedCInSize(void) { return ZSTD_CStreamInSize(); }
ZBUFF_recommendedCOutSize(void)167 size_t ZBUFF_recommendedCOutSize(void) { return ZSTD_CStreamOutSize(); }
168