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