Parolin 0.7.9 6796
Console (soon DLLs) to do a tar like job
Loading...
Searching...
No Matches
zstd_legacy.h
Go to the documentation of this file.
1/*
2 * Copyright (c) Meta Platforms, Inc. and affiliates.
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#ifndef ZSTD_LEGACY_H
12#define ZSTD_LEGACY_H
13
14#if defined (__cplusplus)
15extern "C" {
16#endif
17
18/* *************************************
19* Includes
20***************************************/
21#include "../common/mem.h" /* MEM_STATIC */
22#include "../common/error_private.h" /* ERROR */
23#include "../common/zstd_internal.h" /* ZSTD_inBuffer, ZSTD_outBuffer, ZSTD_frameSizeInfo */
24
25#if !defined (ZSTD_LEGACY_SUPPORT) || (ZSTD_LEGACY_SUPPORT == 0)
26# undef ZSTD_LEGACY_SUPPORT
27# define ZSTD_LEGACY_SUPPORT 8
28#endif
29
30#if (ZSTD_LEGACY_SUPPORT <= 1)
31# include "zstd_v01.h"
32#endif
33#if (ZSTD_LEGACY_SUPPORT <= 2)
34# include "zstd_v02.h"
35#endif
36#if (ZSTD_LEGACY_SUPPORT <= 3)
37# include "zstd_v03.h"
38#endif
39#if (ZSTD_LEGACY_SUPPORT <= 4)
40# include "zstd_v04.h"
41#endif
42#if (ZSTD_LEGACY_SUPPORT <= 5)
43# include "zstd_v05.h"
44#endif
45#if (ZSTD_LEGACY_SUPPORT <= 6)
46# include "zstd_v06.h"
47#endif
48#if (ZSTD_LEGACY_SUPPORT <= 7)
49# include "zstd_v07.h"
50#endif
51
56MEM_STATIC unsigned ZSTD_isLegacy(const void* src, size_t srcSize)
57{
58 U32 magicNumberLE;
59 if (srcSize<4) return 0;
60 magicNumberLE = MEM_readLE32(src);
61 switch(magicNumberLE)
62 {
63#if (ZSTD_LEGACY_SUPPORT <= 1)
64 case ZSTDv01_magicNumberLE:return 1;
65#endif
66#if (ZSTD_LEGACY_SUPPORT <= 2)
67 case ZSTDv02_magicNumber : return 2;
68#endif
69#if (ZSTD_LEGACY_SUPPORT <= 3)
70 case ZSTDv03_magicNumber : return 3;
71#endif
72#if (ZSTD_LEGACY_SUPPORT <= 4)
73 case ZSTDv04_magicNumber : return 4;
74#endif
75#if (ZSTD_LEGACY_SUPPORT <= 5)
76 case ZSTDv05_MAGICNUMBER : return 5;
77#endif
78#if (ZSTD_LEGACY_SUPPORT <= 6)
79 case ZSTDv06_MAGICNUMBER : return 6;
80#endif
81#if (ZSTD_LEGACY_SUPPORT <= 7)
82 case ZSTDv07_MAGICNUMBER : return 7;
83#endif
84 default : return 0;
85 }
86}
87
88
89MEM_STATIC unsigned long long ZSTD_getDecompressedSize_legacy(const void* src, size_t srcSize)
90{
91 U32 const version = ZSTD_isLegacy(src, srcSize);
92 if (version < 5) return 0; /* no decompressed size in frame header, or not a legacy format */
93#if (ZSTD_LEGACY_SUPPORT <= 5)
94 if (version==5) {
95 ZSTDv05_parameters fParams;
96 size_t const frResult = ZSTDv05_getFrameParams(&fParams, src, srcSize);
97 if (frResult != 0) return 0;
98 return fParams.srcSize;
99 }
100#endif
101#if (ZSTD_LEGACY_SUPPORT <= 6)
102 if (version==6) {
103 ZSTDv06_frameParams fParams;
104 size_t const frResult = ZSTDv06_getFrameParams(&fParams, src, srcSize);
105 if (frResult != 0) return 0;
106 return fParams.frameContentSize;
107 }
108#endif
109#if (ZSTD_LEGACY_SUPPORT <= 7)
110 if (version==7) {
111 ZSTDv07_frameParams fParams;
112 size_t const frResult = ZSTDv07_getFrameParams(&fParams, src, srcSize);
113 if (frResult != 0) return 0;
114 return fParams.frameContentSize;
115 }
116#endif
117 return 0; /* should not be possible */
118}
119
120
121MEM_STATIC size_t ZSTD_decompressLegacy(
122 void* dst, size_t dstCapacity,
123 const void* src, size_t compressedSize,
124 const void* dict,size_t dictSize)
125{
126 U32 const version = ZSTD_isLegacy(src, compressedSize);
127 char x;
128 /* Avoid passing NULL to legacy decoding. */
129 if (dst == NULL) {
130 assert(dstCapacity == 0);
131 dst = &x;
132 }
133 if (src == NULL) {
134 assert(compressedSize == 0);
135 src = &x;
136 }
137 if (dict == NULL) {
138 assert(dictSize == 0);
139 dict = &x;
140 }
141 (void)dst; (void)dstCapacity; (void)dict; (void)dictSize; /* unused when ZSTD_LEGACY_SUPPORT >= 8 */
142 switch(version)
143 {
144#if (ZSTD_LEGACY_SUPPORT <= 1)
145 case 1 :
146 return ZSTDv01_decompress(dst, dstCapacity, src, compressedSize);
147#endif
148#if (ZSTD_LEGACY_SUPPORT <= 2)
149 case 2 :
150 return ZSTDv02_decompress(dst, dstCapacity, src, compressedSize);
151#endif
152#if (ZSTD_LEGACY_SUPPORT <= 3)
153 case 3 :
154 return ZSTDv03_decompress(dst, dstCapacity, src, compressedSize);
155#endif
156#if (ZSTD_LEGACY_SUPPORT <= 4)
157 case 4 :
158 return ZSTDv04_decompress(dst, dstCapacity, src, compressedSize);
159#endif
160#if (ZSTD_LEGACY_SUPPORT <= 5)
161 case 5 :
162 { size_t result;
163 ZSTDv05_DCtx* const zd = ZSTDv05_createDCtx();
164 if (zd==NULL) return ERROR(memory_allocation);
165 result = ZSTDv05_decompress_usingDict(zd, dst, dstCapacity, src, compressedSize, dict, dictSize);
166 ZSTDv05_freeDCtx(zd);
167 return result;
168 }
169#endif
170#if (ZSTD_LEGACY_SUPPORT <= 6)
171 case 6 :
172 { size_t result;
173 ZSTDv06_DCtx* const zd = ZSTDv06_createDCtx();
174 if (zd==NULL) return ERROR(memory_allocation);
175 result = ZSTDv06_decompress_usingDict(zd, dst, dstCapacity, src, compressedSize, dict, dictSize);
176 ZSTDv06_freeDCtx(zd);
177 return result;
178 }
179#endif
180#if (ZSTD_LEGACY_SUPPORT <= 7)
181 case 7 :
182 { size_t result;
183 ZSTDv07_DCtx* const zd = ZSTDv07_createDCtx();
184 if (zd==NULL) return ERROR(memory_allocation);
185 result = ZSTDv07_decompress_usingDict(zd, dst, dstCapacity, src, compressedSize, dict, dictSize);
186 ZSTDv07_freeDCtx(zd);
187 return result;
188 }
189#endif
190 default :
191 return ERROR(prefix_unknown);
192 }
193}
194
195MEM_STATIC ZSTD_frameSizeInfo ZSTD_findFrameSizeInfoLegacy(const void *src, size_t srcSize)
196{
197 ZSTD_frameSizeInfo frameSizeInfo;
198 U32 const version = ZSTD_isLegacy(src, srcSize);
199 switch(version)
200 {
201#if (ZSTD_LEGACY_SUPPORT <= 1)
202 case 1 :
203 ZSTDv01_findFrameSizeInfoLegacy(src, srcSize,
204 &frameSizeInfo.compressedSize,
205 &frameSizeInfo.decompressedBound);
206 break;
207#endif
208#if (ZSTD_LEGACY_SUPPORT <= 2)
209 case 2 :
210 ZSTDv02_findFrameSizeInfoLegacy(src, srcSize,
211 &frameSizeInfo.compressedSize,
212 &frameSizeInfo.decompressedBound);
213 break;
214#endif
215#if (ZSTD_LEGACY_SUPPORT <= 3)
216 case 3 :
217 ZSTDv03_findFrameSizeInfoLegacy(src, srcSize,
218 &frameSizeInfo.compressedSize,
219 &frameSizeInfo.decompressedBound);
220 break;
221#endif
222#if (ZSTD_LEGACY_SUPPORT <= 4)
223 case 4 :
224 ZSTDv04_findFrameSizeInfoLegacy(src, srcSize,
225 &frameSizeInfo.compressedSize,
226 &frameSizeInfo.decompressedBound);
227 break;
228#endif
229#if (ZSTD_LEGACY_SUPPORT <= 5)
230 case 5 :
231 ZSTDv05_findFrameSizeInfoLegacy(src, srcSize,
232 &frameSizeInfo.compressedSize,
233 &frameSizeInfo.decompressedBound);
234 break;
235#endif
236#if (ZSTD_LEGACY_SUPPORT <= 6)
237 case 6 :
238 ZSTDv06_findFrameSizeInfoLegacy(src, srcSize,
239 &frameSizeInfo.compressedSize,
240 &frameSizeInfo.decompressedBound);
241 break;
242#endif
243#if (ZSTD_LEGACY_SUPPORT <= 7)
244 case 7 :
245 ZSTDv07_findFrameSizeInfoLegacy(src, srcSize,
246 &frameSizeInfo.compressedSize,
247 &frameSizeInfo.decompressedBound);
248 break;
249#endif
250 default :
251 frameSizeInfo.compressedSize = ERROR(prefix_unknown);
252 frameSizeInfo.decompressedBound = ZSTD_CONTENTSIZE_ERROR;
253 break;
254 }
255 if (!ZSTD_isError(frameSizeInfo.compressedSize) && frameSizeInfo.compressedSize > srcSize) {
256 frameSizeInfo.compressedSize = ERROR(srcSize_wrong);
257 frameSizeInfo.decompressedBound = ZSTD_CONTENTSIZE_ERROR;
258 }
259 /* In all cases, decompressedBound == nbBlocks * ZSTD_BLOCKSIZE_MAX.
260 * So we can compute nbBlocks without having to change every function.
261 */
262 if (frameSizeInfo.decompressedBound != ZSTD_CONTENTSIZE_ERROR) {
263 assert((frameSizeInfo.decompressedBound & (ZSTD_BLOCKSIZE_MAX - 1)) == 0);
264 frameSizeInfo.nbBlocks = (size_t)(frameSizeInfo.decompressedBound / ZSTD_BLOCKSIZE_MAX);
265 }
266 return frameSizeInfo;
267}
268
269MEM_STATIC size_t ZSTD_findFrameCompressedSizeLegacy(const void *src, size_t srcSize)
270{
271 ZSTD_frameSizeInfo frameSizeInfo = ZSTD_findFrameSizeInfoLegacy(src, srcSize);
272 return frameSizeInfo.compressedSize;
273}
274
275MEM_STATIC size_t ZSTD_freeLegacyStreamContext(void* legacyContext, U32 version)
276{
277 switch(version)
278 {
279 default :
280 case 1 :
281 case 2 :
282 case 3 :
283 (void)legacyContext;
284 return ERROR(version_unsupported);
285#if (ZSTD_LEGACY_SUPPORT <= 4)
286 case 4 : return ZBUFFv04_freeDCtx((ZBUFFv04_DCtx*)legacyContext);
287#endif
288#if (ZSTD_LEGACY_SUPPORT <= 5)
289 case 5 : return ZBUFFv05_freeDCtx((ZBUFFv05_DCtx*)legacyContext);
290#endif
291#if (ZSTD_LEGACY_SUPPORT <= 6)
292 case 6 : return ZBUFFv06_freeDCtx((ZBUFFv06_DCtx*)legacyContext);
293#endif
294#if (ZSTD_LEGACY_SUPPORT <= 7)
295 case 7 : return ZBUFFv07_freeDCtx((ZBUFFv07_DCtx*)legacyContext);
296#endif
297 }
298}
299
300
301MEM_STATIC size_t ZSTD_initLegacyStream(void** legacyContext, U32 prevVersion, U32 newVersion,
302 const void* dict, size_t dictSize)
303{
304 char x;
305 /* Avoid passing NULL to legacy decoding. */
306 if (dict == NULL) {
307 assert(dictSize == 0);
308 dict = &x;
309 }
310 DEBUGLOG(5, "ZSTD_initLegacyStream for v0.%u", newVersion);
311 if (prevVersion != newVersion) ZSTD_freeLegacyStreamContext(*legacyContext, prevVersion);
312 switch(newVersion)
313 {
314 default :
315 case 1 :
316 case 2 :
317 case 3 :
318 (void)dict; (void)dictSize;
319 return 0;
320#if (ZSTD_LEGACY_SUPPORT <= 4)
321 case 4 :
322 {
323 ZBUFFv04_DCtx* dctx = (prevVersion != newVersion) ? ZBUFFv04_createDCtx() : (ZBUFFv04_DCtx*)*legacyContext;
324 if (dctx==NULL) return ERROR(memory_allocation);
325 ZBUFFv04_decompressInit(dctx);
326 ZBUFFv04_decompressWithDictionary(dctx, dict, dictSize);
327 *legacyContext = dctx;
328 return 0;
329 }
330#endif
331#if (ZSTD_LEGACY_SUPPORT <= 5)
332 case 5 :
333 {
334 ZBUFFv05_DCtx* dctx = (prevVersion != newVersion) ? ZBUFFv05_createDCtx() : (ZBUFFv05_DCtx*)*legacyContext;
335 if (dctx==NULL) return ERROR(memory_allocation);
336 ZBUFFv05_decompressInitDictionary(dctx, dict, dictSize);
337 *legacyContext = dctx;
338 return 0;
339 }
340#endif
341#if (ZSTD_LEGACY_SUPPORT <= 6)
342 case 6 :
343 {
344 ZBUFFv06_DCtx* dctx = (prevVersion != newVersion) ? ZBUFFv06_createDCtx() : (ZBUFFv06_DCtx*)*legacyContext;
345 if (dctx==NULL) return ERROR(memory_allocation);
346 ZBUFFv06_decompressInitDictionary(dctx, dict, dictSize);
347 *legacyContext = dctx;
348 return 0;
349 }
350#endif
351#if (ZSTD_LEGACY_SUPPORT <= 7)
352 case 7 :
353 {
354 ZBUFFv07_DCtx* dctx = (prevVersion != newVersion) ? ZBUFFv07_createDCtx() : (ZBUFFv07_DCtx*)*legacyContext;
355 if (dctx==NULL) return ERROR(memory_allocation);
356 ZBUFFv07_decompressInitDictionary(dctx, dict, dictSize);
357 *legacyContext = dctx;
358 return 0;
359 }
360#endif
361 }
362}
363
364
365
366MEM_STATIC size_t ZSTD_decompressLegacyStream(void* legacyContext, U32 version,
367 ZSTD_outBuffer* output, ZSTD_inBuffer* input)
368{
369 static char x;
370 /* Avoid passing NULL to legacy decoding. */
371 if (output->dst == NULL) {
372 assert(output->size == 0);
373 output->dst = &x;
374 }
375 if (input->src == NULL) {
376 assert(input->size == 0);
377 input->src = &x;
378 }
379 DEBUGLOG(5, "ZSTD_decompressLegacyStream for v0.%u", version);
380 switch(version)
381 {
382 default :
383 case 1 :
384 case 2 :
385 case 3 :
386 (void)legacyContext; (void)output; (void)input;
387 return ERROR(version_unsupported);
388#if (ZSTD_LEGACY_SUPPORT <= 4)
389 case 4 :
390 {
391 ZBUFFv04_DCtx* dctx = (ZBUFFv04_DCtx*) legacyContext;
392 const void* src = (const char*)input->src + input->pos;
393 size_t readSize = input->size - input->pos;
394 void* dst = (char*)output->dst + output->pos;
395 size_t decodedSize = output->size - output->pos;
396 size_t const hintSize = ZBUFFv04_decompressContinue(dctx, dst, &decodedSize, src, &readSize);
397 output->pos += decodedSize;
398 input->pos += readSize;
399 return hintSize;
400 }
401#endif
402#if (ZSTD_LEGACY_SUPPORT <= 5)
403 case 5 :
404 {
405 ZBUFFv05_DCtx* dctx = (ZBUFFv05_DCtx*) legacyContext;
406 const void* src = (const char*)input->src + input->pos;
407 size_t readSize = input->size - input->pos;
408 void* dst = (char*)output->dst + output->pos;
409 size_t decodedSize = output->size - output->pos;
410 size_t const hintSize = ZBUFFv05_decompressContinue(dctx, dst, &decodedSize, src, &readSize);
411 output->pos += decodedSize;
412 input->pos += readSize;
413 return hintSize;
414 }
415#endif
416#if (ZSTD_LEGACY_SUPPORT <= 6)
417 case 6 :
418 {
419 ZBUFFv06_DCtx* dctx = (ZBUFFv06_DCtx*) legacyContext;
420 const void* src = (const char*)input->src + input->pos;
421 size_t readSize = input->size - input->pos;
422 void* dst = (char*)output->dst + output->pos;
423 size_t decodedSize = output->size - output->pos;
424 size_t const hintSize = ZBUFFv06_decompressContinue(dctx, dst, &decodedSize, src, &readSize);
425 output->pos += decodedSize;
426 input->pos += readSize;
427 return hintSize;
428 }
429#endif
430#if (ZSTD_LEGACY_SUPPORT <= 7)
431 case 7 :
432 {
433 ZBUFFv07_DCtx* dctx = (ZBUFFv07_DCtx*) legacyContext;
434 const void* src = (const char*)input->src + input->pos;
435 size_t readSize = input->size - input->pos;
436 void* dst = (char*)output->dst + output->pos;
437 size_t decodedSize = output->size - output->pos;
438 size_t const hintSize = ZBUFFv07_decompressContinue(dctx, dst, &decodedSize, src, &readSize);
439 output->pos += decodedSize;
440 input->pos += readSize;
441 return hintSize;
442 }
443#endif
444 }
445}
446
447
448#if defined (__cplusplus)
449}
450#endif
451
452#endif /* ZSTD_LEGACY_H */
DEBUGLOG
#define DEBUGLOG(l,...)
Definition lz4.c:289
U32
unsigned int U32
Definition lz4.c:316
assert
#define assert(condition)
Definition lz4.c:273
dst
char * dst
Definition lz4.h:833
srcSize
char int srcSize
Definition lz4.h:806
compressedSize
char int compressedSize
Definition lz4.h:833
src
const char * src
Definition lz4.h:866
input
#define input(b, o, c, n, m)
Definition compress42.c:610
output
#define output(b, o, c, n)
Definition compress42.c:592
ZBUFFv04_DCtx_s
Definition zstd_v04.c:3353
ZBUFFv05_DCtx_s
Definition zstd_v05.c:3833
ZBUFFv06_DCtx_s
Definition zstd_v06.c:3948
ZBUFFv07_DCtx_s
Definition zstd_v07.c:4313
ZSTD_frameSizeInfo
Definition zstd_internal.h:349
ZSTD_frameSizeInfo::decompressedBound
unsigned long long decompressedBound
Definition zstd_internal.h:351
ZSTD_frameSizeInfo::compressedSize
size_t compressedSize
Definition zstd_internal.h:350
ZSTD_frameSizeInfo::nbBlocks
size_t nbBlocks
Definition zstd_internal.h:345
ZSTD_inBuffer_s
Definition zstd.h:596
ZSTD_outBuffer_s
Definition zstd.h:602
ZSTDv05_DCtx_s
Definition zstd_v05.c:2644
ZSTDv05_parameters
Definition zstd_v05.h:86
ZSTDv05_parameters::srcSize
U64 srcSize
Definition zstd_v05.h:87
ZSTDv06_DCtx_s
Definition zstd_v06.c:2805
ZSTDv06_frameParams_s
Definition zstd_v06.h:97
ZSTDv06_frameParams_s::frameContentSize
unsigned long long frameContentSize
Definition zstd_v06.h:97
ZSTDv07_DCtx_s
Definition zstd_v07.c:2930
ZSTDv07_frameParams
Definition zstd_v07.h:114
ZSTDv07_frameParams::frameContentSize
unsigned long long frameContentSize
Definition zstd_v07.h:115
NULL
#define NULL
Definition getopt1.c:37
MEM_STATIC
#define MEM_STATIC
Definition mem.h:27
MEM_readLE32
MEM_STATIC U32 MEM_readLE32(const void *memPtr)
Definition mem.h:169
ERROR
#define ERROR(name)
Definition zstdseek_compress.c:27
ZSTD_isError
#define ZSTD_isError
Definition zstd_internal.h:49
dict
const void * dict
Definition zbuff.h:76
dictSize
const void size_t dictSize
Definition zbuff.h:76
ZSTD_isLegacy
MEM_STATIC unsigned ZSTD_isLegacy(const void *src, size_t srcSize)
Definition zstd_legacy.h:56
ZSTD_decompressLegacy
MEM_STATIC size_t ZSTD_decompressLegacy(void *dst, size_t dstCapacity, const void *src, size_t compressedSize, const void *dict, size_t dictSize)
Definition zstd_legacy.h:121
ZSTD_freeLegacyStreamContext
MEM_STATIC size_t ZSTD_freeLegacyStreamContext(void *legacyContext, U32 version)
Definition zstd_legacy.h:254
ZSTD_decompressLegacyStream
MEM_STATIC size_t ZSTD_decompressLegacyStream(void *legacyContext, U32 version, ZSTD_outBuffer *output, ZSTD_inBuffer *input)
Definition zstd_legacy.h:339
ZSTD_findFrameCompressedSizeLegacy
MEM_STATIC size_t ZSTD_findFrameCompressedSizeLegacy(const void *src, size_t srcSize)
Definition zstd_legacy.h:248
ZSTD_getDecompressedSize_legacy
MEM_STATIC unsigned long long ZSTD_getDecompressedSize_legacy(const void *src, size_t srcSize)
Definition zstd_legacy.h:89
ZSTD_findFrameSizeInfoLegacy
MEM_STATIC ZSTD_frameSizeInfo ZSTD_findFrameSizeInfoLegacy(const void *src, size_t srcSize)
Definition zstd_legacy.h:181
ZSTD_initLegacyStream
MEM_STATIC size_t ZSTD_initLegacyStream(void **legacyContext, U32 prevVersion, U32 newVersion, const void *dict, size_t dictSize)
Definition zstd_legacy.h:280
ZSTDv01_decompress
size_t ZSTDv01_decompress(void *dst, size_t maxDstSize, const void *src, size_t srcSize)
Definition zstd_v01.c:1997
ZSTD_CONTENTSIZE_ERROR
#define ZSTD_CONTENTSIZE_ERROR
Definition zstd_v01.c:1342
ZSTDv01_findFrameSizeInfoLegacy
void ZSTDv01_findFrameSizeInfoLegacy(const void *src, size_t srcSize, size_t *cSize, unsigned long long *dBound)
Definition zstd_v01.c:2012
ZSTDv01_magicNumberLE
#define ZSTDv01_magicNumberLE
Definition zstd_v01.h:87
ZSTDv02_decompress
size_t ZSTDv02_decompress(void *dst, size_t maxOriginalSize, const void *src, size_t compressedSize)
Definition zstd_v02.c:3489
ZSTDv02_findFrameSizeInfoLegacy
void ZSTDv02_findFrameSizeInfoLegacy(const void *src, size_t srcSize, size_t *cSize, unsigned long long *dBound)
Definition zstd_v02.c:3335
ZSTDv02_magicNumber
#define ZSTDv02_magicNumber
Definition zstd_v02.h:86
ZSTDv03_findFrameSizeInfoLegacy
void ZSTDv03_findFrameSizeInfoLegacy(const void *src, size_t srcSize, size_t *cSize, unsigned long long *dBound)
Definition zstd_v03.c:2976
ZSTDv03_decompress
size_t ZSTDv03_decompress(void *dst, size_t maxOriginalSize, const void *src, size_t compressedSize)
Definition zstd_v03.c:3131
ZSTDv03_magicNumber
#define ZSTDv03_magicNumber
Definition zstd_v03.h:86
ZSTDv04_findFrameSizeInfoLegacy
void ZSTDv04_findFrameSizeInfoLegacy(const void *src, size_t srcSize, size_t *cSize, unsigned long long *dBound)
Definition zstd_v04.c:3143
ZBUFFv04_decompressWithDictionary
size_t ZBUFFv04_decompressWithDictionary(ZBUFFv04_DCtx *dctx, const void *src, size_t srcSize)
Definition zstd_v04.c:3637
ZBUFFv04_createDCtx
ZBUFFv04_DCtx * ZBUFFv04_createDCtx(void)
Definition zstd_v04.c:3633
ZBUFFv04_freeDCtx
size_t ZBUFFv04_freeDCtx(ZBUFFv04_DCtx *dctx)
Definition zstd_v04.c:3634
ZBUFFv04_decompressContinue
size_t ZBUFFv04_decompressContinue(ZBUFFv04_DCtx *dctx, void *dst, size_t *maxDstSizePtr, const void *src, size_t *srcSizePtr)
Definition zstd_v04.c:3640
ZSTDv04_decompress
size_t ZSTDv04_decompress(void *dst, size_t maxDstSize, const void *src, size_t srcSize)
Definition zstd_v04.c:3604
ZBUFFv04_decompressInit
size_t ZBUFFv04_decompressInit(ZBUFFv04_DCtx *dctx)
Definition zstd_v04.c:3636
ZSTDv04_magicNumber
#define ZSTDv04_magicNumber
Definition zstd_v04.h:135
ZBUFFv05_decompressInitDictionary
size_t ZBUFFv05_decompressInitDictionary(ZBUFFv05_DCtx *zbc, const void *dict, size_t dictSize)
Definition zstd_v05.c:3872
ZSTDv05_getFrameParams
size_t ZSTDv05_getFrameParams(ZSTDv05_parameters *params, const void *src, size_t srcSize)
Definition zstd_v05.c:2803
ZSTDv05_freeDCtx
size_t ZSTDv05_freeDCtx(ZSTDv05_DCtx *dctx)
Definition zstd_v05.c:2689
ZBUFFv05_createDCtx
ZBUFFv05_DCtx * ZBUFFv05_createDCtx(void)
Definition zstd_v05.c:3849
ZBUFFv05_freeDCtx
size_t ZBUFFv05_freeDCtx(ZBUFFv05_DCtx *zbc)
Definition zstd_v05.c:3859
ZSTDv05_findFrameSizeInfoLegacy
void ZSTDv05_findFrameSizeInfoLegacy(const void *src, size_t srcSize, size_t *cSize, unsigned long long *dBound)
Definition zstd_v05.c:3530
ZSTDv05_decompress_usingDict
size_t ZSTDv05_decompress_usingDict(ZSTDv05_DCtx *dctx, void *dst, size_t maxDstSize, const void *src, size_t srcSize, const void *dict, size_t dictSize)
Definition zstd_v05.c:3491
ZSTDv05_createDCtx
ZSTDv05_DCtx * ZSTDv05_createDCtx(void)
Definition zstd_v05.c:2681
ZBUFFv05_decompressContinue
size_t ZBUFFv05_decompressContinue(ZBUFFv05_DCtx *zbc, void *dst, size_t *maxDstSizePtr, const void *src, size_t *srcSizePtr)
Definition zstd_v05.c:3887
ZSTDv05_MAGICNUMBER
#define ZSTDv05_MAGICNUMBER
Definition zstd_v05.h:153
ZSTDv06_getFrameParams
size_t ZSTDv06_getFrameParams(ZSTDv06_frameParams *fparamsPtr, const void *src, size_t srcSize)
Definition zstd_v06.c:2980
ZBUFFv06_createDCtx
ZBUFFv06_DCtx * ZBUFFv06_createDCtx(void)
Definition zstd_v06.c:3965
ZBUFFv06_decompressInitDictionary
size_t ZBUFFv06_decompressInitDictionary(ZBUFFv06_DCtx *zbd, const void *dict, size_t dictSize)
Definition zstd_v06.c:3988
ZSTDv06_findFrameSizeInfoLegacy
void ZSTDv06_findFrameSizeInfoLegacy(const void *src, size_t srcSize, size_t *cSize, unsigned long long *dBound)
Definition zstd_v06.c:3667
ZSTDv06_freeDCtx
size_t ZSTDv06_freeDCtx(ZSTDv06_DCtx *dctx)
Definition zstd_v06.c:2850
ZSTDv06_createDCtx
ZSTDv06_DCtx * ZSTDv06_createDCtx(void)
Definition zstd_v06.c:2842
ZBUFFv06_decompressContinue
size_t ZBUFFv06_decompressContinue(ZBUFFv06_DCtx *zbd, void *dst, size_t *dstCapacityPtr, const void *src, size_t *srcSizePtr)
Definition zstd_v06.c:4014
ZSTDv06_decompress_usingDict
size_t ZSTDv06_decompress_usingDict(ZSTDv06_DCtx *dctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize, const void *dict, size_t dictSize)
Definition zstd_v06.c:3627
ZBUFFv06_freeDCtx
size_t ZBUFFv06_freeDCtx(ZBUFFv06_DCtx *zbd)
Definition zstd_v06.c:3975
ZSTDv06_MAGICNUMBER
#define ZSTDv06_MAGICNUMBER
Definition zstd_v06.h:164
ZSTDv07_getFrameParams
size_t ZSTDv07_getFrameParams(ZSTDv07_frameParams *fparamsPtr, const void *src, size_t srcSize)
Definition zstd_v07.c:3150
ZBUFFv07_decompressInitDictionary
size_t ZBUFFv07_decompressInitDictionary(ZBUFFv07_DCtx *zbd, const void *dict, size_t dictSize)
Definition zstd_v07.c:4370
ZSTDv07_findFrameSizeInfoLegacy
void ZSTDv07_findFrameSizeInfoLegacy(const void *src, size_t srcSize, size_t *cSize, unsigned long long *dBound)
Definition zstd_v07.c:3912
ZSTDv07_createDCtx
ZSTDv07_DCtx * ZSTDv07_createDCtx(void)
Definition zstd_v07.c:2994
ZBUFFv07_freeDCtx
size_t ZBUFFv07_freeDCtx(ZBUFFv07_DCtx *zbd)
Definition zstd_v07.c:4357
ZSTDv07_freeDCtx
size_t ZSTDv07_freeDCtx(ZSTDv07_DCtx *dctx)
Definition zstd_v07.c:2999
ZBUFFv07_createDCtx
ZBUFFv07_DCtx * ZBUFFv07_createDCtx(void)
Definition zstd_v07.c:4332
ZSTDv07_decompress_usingDict
size_t ZSTDv07_decompress_usingDict(ZSTDv07_DCtx *dctx, void *dst, size_t dstCapacity, const void *src, size_t srcSize, const void *dict, size_t dictSize)
Definition zstd_v07.c:3872
ZBUFFv07_decompressContinue
size_t ZBUFFv07_decompressContinue(ZBUFFv07_DCtx *zbd, void *dst, size_t *dstCapacityPtr, const void *src, size_t *srcSizePtr)
Definition zstd_v07.c:4396
ZSTDv07_MAGICNUMBER
#define ZSTDv07_MAGICNUMBER
Definition zstd_v07.h:180
ZSTD_BLOCKSIZE_MAX
#define ZSTD_BLOCKSIZE_MAX
Definition zstd.h:111
error_private.h
zstd_internal.h
zstd_v01.h
zstd_v02.h
zstd_v03.h
zstd_v04.h
zstd_v05.h
zstd_v06.h
zstd_v07.h
Generated by doxygen 1.12.0