1/*
2 * Copyright (c) 2016-present, 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
53ZBUFF_CCtx* ZBUFF_createCCtx(void)
54{
55 return ZSTD_createCStream();
56}
57
58ZBUFF_CCtx* ZBUFF_createCCtx_advanced(ZSTD_customMem customMem)
59{
60 return ZSTD_createCStream_advanced(customMem);
61}
62
63size_t ZBUFF_freeCCtx(ZBUFF_CCtx* zbc)
64{
65 return ZSTD_freeCStream(zbc);
66}
67
68
69/* ====== Initialization ====== */
70
71size_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
80size_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
85size_t ZBUFF_compressInit(ZBUFF_CCtx* zbc, int compressionLevel)
86{
87 return ZSTD_initCStream(zbc, compressionLevel);
88}
89
90/* ====== Compression ====== */
91
92
93size_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
116size_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
129size_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***************************************/
146size_t ZBUFF_recommendedCInSize(void) { return ZSTD_CStreamInSize(); }
147size_t ZBUFF_recommendedCOutSize(void) { return ZSTD_CStreamOutSize(); }
148