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	* Tuning parameters
14	*****************************************************************/
15	/*!
16	* HEAPMODE :
17	* Select how default decompression function ZSTD_decompress() allocates its context,
18	* on stack (0), or into heap (1, default; requires malloc()).
19	* Note that functions with explicit context such as ZSTD_decompressDCtx() are unaffected.
20	*/
21	#ifndef ZSTD_HEAPMODE
22	# define ZSTD_HEAPMODE 1
23	#endif
24
25	/*!
26	* LEGACY_SUPPORT :
27	* if set to 1+, ZSTD_decompress() can decode older formats (v0.1+)
28	*/
29
30	/*!
31	* MAXWINDOWSIZE_DEFAULT :
32	* maximum window size accepted by DStream __by default__.
33	* Frames requiring more memory will be rejected.
34	* It's possible to set a different limit using ZSTD_DCtx_setMaxWindowSize().
35	*/
36	#ifndef ZSTD_MAXWINDOWSIZE_DEFAULT
37	# define ZSTD_MAXWINDOWSIZE_DEFAULT (((U32)1 << ZSTD_WINDOWLOG_LIMIT_DEFAULT) + 1)
38	#endif
39
40	/*!
41	* NO_FORWARD_PROGRESS_MAX :
42	* maximum allowed nb of calls to ZSTD_decompressStream()
43	* without any forward progress
44	* (defined as: no byte read from input, and no byte flushed to output)
45	* before triggering an error.
46	*/
47	#ifndef ZSTD_NO_FORWARD_PROGRESS_MAX
48	# define ZSTD_NO_FORWARD_PROGRESS_MAX 16
49	#endif
50
51
52	/*-*******************************************************
53	* Dependencies
54	*********************************************************/
55	#include "../common/zstd_deps.h" /* ZSTD_memcpy, ZSTD_memmove, ZSTD_memset */
56	#include "../common/mem.h" /* low level memory routines */
57	#define FSE_STATIC_LINKING_ONLY
58	#include "../common/fse.h"
59	#define HUF_STATIC_LINKING_ONLY
60	#include "../common/huf.h"
61	#include <linux/xxhash.h> /* xxh64_reset, xxh64_update, xxh64_digest, XXH64 */
62	#include "../common/zstd_internal.h" /* blockProperties_t */
63	#include "zstd_decompress_internal.h" /* ZSTD_DCtx */
64	#include "zstd_ddict.h" /* ZSTD_DDictDictContent */
65	#include "zstd_decompress_block.h" /* ZSTD_decompressBlock_internal */
66
67
68
69
70	/* ***********************************
71	* Multiple DDicts Hashset internals *
72	*************************************/
73
74	#define DDICT_HASHSET_MAX_LOAD_FACTOR_COUNT_MULT 4
75	#define DDICT_HASHSET_MAX_LOAD_FACTOR_SIZE_MULT 3 /* These two constants represent SIZE_MULT/COUNT_MULT load factor without using a float.
76	* Currently, that means a 0.75 load factor.
77	* So, if count * COUNT_MULT / size * SIZE_MULT != 0, then we've exceeded
78	* the load factor of the ddict hash set.
79	*/
80
81	#define DDICT_HASHSET_TABLE_BASE_SIZE 64
82	#define DDICT_HASHSET_RESIZE_FACTOR 2
83
84	/* Hash function to determine starting position of dict insertion within the table
85	* Returns an index between [0, hashSet->ddictPtrTableSize]
86	*/
87	static size_t ZSTD_DDictHashSet_getIndex(const ZSTD_DDictHashSet* hashSet, U32 dictID) {
88	const U64 hash = xxh64(input: &dictID, length: sizeof(U32), seed: 0);
89	/* DDict ptr table size is a multiple of 2, use size - 1 as mask to get index within [0, hashSet->ddictPtrTableSize) */
90	return hash & (hashSet->ddictPtrTableSize - 1);
91	}
92
93	/* Adds DDict to a hashset without resizing it.
94	* If inserting a DDict with a dictID that already exists in the set, replaces the one in the set.
95	* Returns 0 if successful, or a zstd error code if something went wrong.
96	*/
97	static size_t ZSTD_DDictHashSet_emplaceDDict(ZSTD_DDictHashSet* hashSet, const ZSTD_DDict* ddict) {
98	const U32 dictID = ZSTD_getDictID_fromDDict(ddict);
99	size_t idx = ZSTD_DDictHashSet_getIndex(hashSet, dictID);
100	const size_t idxRangeMask = hashSet->ddictPtrTableSize - 1;
101	RETURN_ERROR_IF(hashSet->ddictPtrCount == hashSet->ddictPtrTableSize, GENERIC, "Hash set is full!");
102	DEBUGLOG(4, "Hashed index: for dictID: %u is %zu", dictID, idx);
103	while (hashSet->ddictPtrTable[idx] != NULL) {
104	/* Replace existing ddict if inserting ddict with same dictID */
105	if (ZSTD_getDictID_fromDDict(ddict: hashSet->ddictPtrTable[idx]) == dictID) {
106	DEBUGLOG(4, "DictID already exists, replacing rather than adding");
107	hashSet->ddictPtrTable[idx] = ddict;
108	return 0;
109	}
110	idx &= idxRangeMask;
111	idx++;
112	}
113	DEBUGLOG(4, "Final idx after probing for dictID %u is: %zu", dictID, idx);
114	hashSet->ddictPtrTable[idx] = ddict;
115	hashSet->ddictPtrCount++;
116	return 0;
117	}
118
119	/* Expands hash table by factor of DDICT_HASHSET_RESIZE_FACTOR and
120	* rehashes all values, allocates new table, frees old table.
121	* Returns 0 on success, otherwise a zstd error code.
122	*/
123	static size_t ZSTD_DDictHashSet_expand(ZSTD_DDictHashSet* hashSet, ZSTD_customMem customMem) {
124	size_t newTableSize = hashSet->ddictPtrTableSize * DDICT_HASHSET_RESIZE_FACTOR;
125	const ZSTD_DDict** newTable = (const ZSTD_DDict**)ZSTD_customCalloc(size: sizeof(ZSTD_DDict*) * newTableSize, customMem);
126	const ZSTD_DDict** oldTable = hashSet->ddictPtrTable;
127	size_t oldTableSize = hashSet->ddictPtrTableSize;
128	size_t i;
129
130	DEBUGLOG(4, "Expanding DDict hash table! Old size: %zu new size: %zu", oldTableSize, newTableSize);
131	RETURN_ERROR_IF(!newTable, memory_allocation, "Expanded hashset allocation failed!");
132	hashSet->ddictPtrTable = newTable;
133	hashSet->ddictPtrTableSize = newTableSize;
134	hashSet->ddictPtrCount = 0;
135	for (i = 0; i < oldTableSize; ++i) {
136	if (oldTable[i] != NULL) {
137	FORWARD_IF_ERROR(ZSTD_DDictHashSet_emplaceDDict(hashSet, oldTable[i]), "");
138	}
139	}
140	ZSTD_customFree(ptr: (void*)oldTable, customMem);
141	DEBUGLOG(4, "Finished re-hash");
142	return 0;
143	}
144
145	/* Fetches a DDict with the given dictID
146	* Returns the ZSTD_DDict* with the requested dictID. If it doesn't exist, then returns NULL.
147	*/
148	static const ZSTD_DDict* ZSTD_DDictHashSet_getDDict(ZSTD_DDictHashSet* hashSet, U32 dictID) {
149	size_t idx = ZSTD_DDictHashSet_getIndex(hashSet, dictID);
150	const size_t idxRangeMask = hashSet->ddictPtrTableSize - 1;
151	DEBUGLOG(4, "Hashed index: for dictID: %u is %zu", dictID, idx);
152	for (;;) {
153	size_t currDictID = ZSTD_getDictID_fromDDict(ddict: hashSet->ddictPtrTable[idx]);
154	if (currDictID == dictID || currDictID == 0) {
155	/* currDictID == 0 implies a NULL ddict entry */
156	break;
157	} else {
158	idx &= idxRangeMask; /* Goes to start of table when we reach the end */
159	idx++;
160	}
161	}
162	DEBUGLOG(4, "Final idx after probing for dictID %u is: %zu", dictID, idx);
163	return hashSet->ddictPtrTable[idx];
164	}
165
166	/* Allocates space for and returns a ddict hash set
167	* The hash set's ZSTD_DDict* table has all values automatically set to NULL to begin with.
168	* Returns NULL if allocation failed.
169	*/
170	static ZSTD_DDictHashSet* ZSTD_createDDictHashSet(ZSTD_customMem customMem) {
171	ZSTD_DDictHashSet* ret = (ZSTD_DDictHashSet*)ZSTD_customMalloc(size: sizeof(ZSTD_DDictHashSet), customMem);
172	DEBUGLOG(4, "Allocating new hash set");
173	if (!ret)
174	return NULL;
175	ret->ddictPtrTable = (const ZSTD_DDict**)ZSTD_customCalloc(DDICT_HASHSET_TABLE_BASE_SIZE * sizeof(ZSTD_DDict*), customMem);
176	if (!ret->ddictPtrTable) {
177	ZSTD_customFree(ptr: ret, customMem);
178	return NULL;
179	}
180	ret->ddictPtrTableSize = DDICT_HASHSET_TABLE_BASE_SIZE;
181	ret->ddictPtrCount = 0;
182	return ret;
183	}
184
185	/* Frees the table of ZSTD_DDict* within a hashset, then frees the hashset itself.
186	* Note: The ZSTD_DDict* within the table are NOT freed.
187	*/
188	static void ZSTD_freeDDictHashSet(ZSTD_DDictHashSet* hashSet, ZSTD_customMem customMem) {
189	DEBUGLOG(4, "Freeing ddict hash set");
190	if (hashSet && hashSet->ddictPtrTable) {
191	ZSTD_customFree(ptr: (void*)hashSet->ddictPtrTable, customMem);
192	}
193	if (hashSet) {
194	ZSTD_customFree(ptr: hashSet, customMem);
195	}
196	}
197
198	/* Public function: Adds a DDict into the ZSTD_DDictHashSet, possibly triggering a resize of the hash set.
199	* Returns 0 on success, or a ZSTD error.
200	*/
201	static size_t ZSTD_DDictHashSet_addDDict(ZSTD_DDictHashSet* hashSet, const ZSTD_DDict* ddict, ZSTD_customMem customMem) {
202	DEBUGLOG(4, "Adding dict ID: %u to hashset with - Count: %zu Tablesize: %zu", ZSTD_getDictID_fromDDict(ddict), hashSet->ddictPtrCount, hashSet->ddictPtrTableSize);
203	if (hashSet->ddictPtrCount * DDICT_HASHSET_MAX_LOAD_FACTOR_COUNT_MULT / hashSet->ddictPtrTableSize * DDICT_HASHSET_MAX_LOAD_FACTOR_SIZE_MULT != 0) {
204	FORWARD_IF_ERROR(ZSTD_DDictHashSet_expand(hashSet, customMem), "");
205	}
206	FORWARD_IF_ERROR(ZSTD_DDictHashSet_emplaceDDict(hashSet, ddict), "");
207	return 0;
208	}
209
210	/*-*************************************************************
211	* Context management
212	***************************************************************/
213	size_t ZSTD_sizeof_DCtx (const ZSTD_DCtx* dctx)
214	{
215	if (dctx==NULL) return 0; /* support sizeof NULL */
216	return sizeof(*dctx)
217	+ ZSTD_sizeof_DDict(ddict: dctx->ddictLocal)
218	+ dctx->inBuffSize + dctx->outBuffSize;
219	}
220
221	size_t ZSTD_estimateDCtxSize(void) { return sizeof(ZSTD_DCtx); }
222
223
224	static size_t ZSTD_startingInputLength(ZSTD_format_e format)
225	{
226	size_t const startingInputLength = ZSTD_FRAMEHEADERSIZE_PREFIX(format);
227	/* only supports formats ZSTD_f_zstd1 and ZSTD_f_zstd1_magicless */
228	assert( (format == ZSTD_f_zstd1) || (format == ZSTD_f_zstd1_magicless) );
229	return startingInputLength;
230	}
231
232	static void ZSTD_DCtx_resetParameters(ZSTD_DCtx* dctx)
233	{
234	assert(dctx->streamStage == zdss_init);
235	dctx->format = ZSTD_f_zstd1;
236	dctx->maxWindowSize = ZSTD_MAXWINDOWSIZE_DEFAULT;
237	dctx->outBufferMode = ZSTD_bm_buffered;
238	dctx->forceIgnoreChecksum = ZSTD_d_validateChecksum;
239	dctx->refMultipleDDicts = ZSTD_rmd_refSingleDDict;
240	}
241
242	static void ZSTD_initDCtx_internal(ZSTD_DCtx* dctx)
243	{
244	dctx->staticSize = 0;
245	dctx->ddict = NULL;
246	dctx->ddictLocal = NULL;
247	dctx->dictEnd = NULL;
248	dctx->ddictIsCold = 0;
249	dctx->dictUses = ZSTD_dont_use;
250	dctx->inBuff = NULL;
251	dctx->inBuffSize = 0;
252	dctx->outBuffSize = 0;
253	dctx->streamStage = zdss_init;
254	dctx->noForwardProgress = 0;
255	dctx->oversizedDuration = 0;
256	#if DYNAMIC_BMI2
257	dctx->bmi2 = ZSTD_cpuSupportsBmi2();
258	#endif
259	dctx->ddictSet = NULL;
260	ZSTD_DCtx_resetParameters(dctx);
261	#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
262	dctx->dictContentEndForFuzzing = NULL;
263	#endif
264	}
265
266	ZSTD_DCtx* ZSTD_initStaticDCtx(void *workspace, size_t workspaceSize)
267	{
268	ZSTD_DCtx* const dctx = (ZSTD_DCtx*) workspace;
269
270	if ((size_t)workspace & 7) return NULL; /* 8-aligned */
271	if (workspaceSize < sizeof(ZSTD_DCtx)) return NULL; /* minimum size */
272
273	ZSTD_initDCtx_internal(dctx);
274	dctx->staticSize = workspaceSize;
275	dctx->inBuff = (char*)(dctx+1);
276	return dctx;
277	}
278
279	static ZSTD_DCtx* ZSTD_createDCtx_internal(ZSTD_customMem customMem) {
280	if ((!customMem.customAlloc) ^ (!customMem.customFree)) return NULL;
281
282	{ ZSTD_DCtx* const dctx = (ZSTD_DCtx*)ZSTD_customMalloc(size: sizeof(*dctx), customMem);
283	if (!dctx) return NULL;
284	dctx->customMem = customMem;
285	ZSTD_initDCtx_internal(dctx);
286	return dctx;
287	}
288	}
289
290	ZSTD_DCtx* ZSTD_createDCtx_advanced(ZSTD_customMem customMem)
291	{
292	return ZSTD_createDCtx_internal(customMem);
293	}
294
295	ZSTD_DCtx* ZSTD_createDCtx(void)
296	{
297	DEBUGLOG(3, "ZSTD_createDCtx");
298	return ZSTD_createDCtx_internal(customMem: ZSTD_defaultCMem);
299	}
300
301	static void ZSTD_clearDict(ZSTD_DCtx* dctx)
302	{
303	ZSTD_freeDDict(ddict: dctx->ddictLocal);
304	dctx->ddictLocal = NULL;
305	dctx->ddict = NULL;
306	dctx->dictUses = ZSTD_dont_use;
307	}
308
309	size_t ZSTD_freeDCtx(ZSTD_DCtx* dctx)
310	{
311	if (dctx==NULL) return 0; /* support free on NULL */
312	RETURN_ERROR_IF(dctx->staticSize, memory_allocation, "not compatible with static DCtx");
313	{ ZSTD_customMem const cMem = dctx->customMem;
314	ZSTD_clearDict(dctx);
315	ZSTD_customFree(ptr: dctx->inBuff, customMem: cMem);
316	dctx->inBuff = NULL;
317	if (dctx->ddictSet) {
318	ZSTD_freeDDictHashSet(hashSet: dctx->ddictSet, customMem: cMem);
319	dctx->ddictSet = NULL;
320	}
321	ZSTD_customFree(ptr: dctx, customMem: cMem);
322	return 0;
323	}
324	}
325
326	/* no longer useful */
327	void ZSTD_copyDCtx(ZSTD_DCtx* dstDCtx, const ZSTD_DCtx* srcDCtx)
328	{
329	size_t const toCopy = (size_t)((char*)(&dstDCtx->inBuff) - (char*)dstDCtx);
330	ZSTD_memcpy(dstDCtx, srcDCtx, toCopy); /* no need to copy workspace */
331	}
332
333	/* Given a dctx with a digested frame params, re-selects the correct ZSTD_DDict based on
334	* the requested dict ID from the frame. If there exists a reference to the correct ZSTD_DDict, then
335	* accordingly sets the ddict to be used to decompress the frame.
336	*
337	* If no DDict is found, then no action is taken, and the ZSTD_DCtx::ddict remains as-is.
338	*
339	* ZSTD_d_refMultipleDDicts must be enabled for this function to be called.
340	*/
341	static void ZSTD_DCtx_selectFrameDDict(ZSTD_DCtx* dctx) {
342	assert(dctx->refMultipleDDicts && dctx->ddictSet);
343	DEBUGLOG(4, "Adjusting DDict based on requested dict ID from frame");
344	if (dctx->ddict) {
345	const ZSTD_DDict* frameDDict = ZSTD_DDictHashSet_getDDict(hashSet: dctx->ddictSet, dictID: dctx->fParams.dictID);
346	if (frameDDict) {
347	DEBUGLOG(4, "DDict found!");
348	ZSTD_clearDict(dctx);
349	dctx->dictID = dctx->fParams.dictID;
350	dctx->ddict = frameDDict;
351	dctx->dictUses = ZSTD_use_indefinitely;
352	}
353	}
354	}
355
356
357	/*-*************************************************************
358	* Frame header decoding
359	***************************************************************/
360
361	/*! ZSTD_isFrame() :
362	* Tells if the content of `buffer` starts with a valid Frame Identifier.
363	* Note : Frame Identifier is 4 bytes. If `size < 4`, @return will always be 0.
364	* Note 2 : Legacy Frame Identifiers are considered valid only if Legacy Support is enabled.
365	* Note 3 : Skippable Frame Identifiers are considered valid. */
366	unsigned ZSTD_isFrame(const void* buffer, size_t size)
367	{
368	if (size < ZSTD_FRAMEIDSIZE) return 0;
369	{ U32 const magic = MEM_readLE32(memPtr: buffer);
370	if (magic == ZSTD_MAGICNUMBER) return 1;
371	if ((magic & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) return 1;
372	}
373	return 0;
374	}
375
376	/*! ZSTD_isSkippableFrame() :
377	* Tells if the content of `buffer` starts with a valid Frame Identifier for a skippable frame.
378	* Note : Frame Identifier is 4 bytes. If `size < 4`, @return will always be 0.
379	*/
380	unsigned ZSTD_isSkippableFrame(const void* buffer, size_t size)
381	{
382	if (size < ZSTD_FRAMEIDSIZE) return 0;
383	{ U32 const magic = MEM_readLE32(memPtr: buffer);
384	if ((magic & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) return 1;
385	}
386	return 0;
387	}
388
389	/* ZSTD_frameHeaderSize_internal() :
390	* srcSize must be large enough to reach header size fields.
391	* note : only works for formats ZSTD_f_zstd1 and ZSTD_f_zstd1_magicless.
392	* @return : size of the Frame Header
393	* or an error code, which can be tested with ZSTD_isError() */
394	static size_t ZSTD_frameHeaderSize_internal(const void* src, size_t srcSize, ZSTD_format_e format)
395	{
396	size_t const minInputSize = ZSTD_startingInputLength(format);
397	RETURN_ERROR_IF(srcSize < minInputSize, srcSize_wrong, "");
398
399	{ BYTE const fhd = ((const BYTE*)src)[minInputSize-1];
400	U32 const dictID= fhd & 3;
401	U32 const singleSegment = (fhd >> 5) & 1;
402	U32 const fcsId = fhd >> 6;
403	return minInputSize + !singleSegment
404	+ ZSTD_did_fieldSize[dictID] + ZSTD_fcs_fieldSize[fcsId]
405	+ (singleSegment && !fcsId);
406	}
407	}
408
409	/* ZSTD_frameHeaderSize() :
410	* srcSize must be >= ZSTD_frameHeaderSize_prefix.
411	* @return : size of the Frame Header,
412	* or an error code (if srcSize is too small) */
413	size_t ZSTD_frameHeaderSize(const void* src, size_t srcSize)
414	{
415	return ZSTD_frameHeaderSize_internal(src, srcSize, format: ZSTD_f_zstd1);
416	}
417
418
419	/* ZSTD_getFrameHeader_advanced() :
420	* decode Frame Header, or require larger `srcSize`.
421	* note : only works for formats ZSTD_f_zstd1 and ZSTD_f_zstd1_magicless
422	* @return : 0, `zfhPtr` is correctly filled,
423	* >0, `srcSize` is too small, value is wanted `srcSize` amount,
424	* or an error code, which can be tested using ZSTD_isError() */
425	size_t ZSTD_getFrameHeader_advanced(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize, ZSTD_format_e format)
426	{
427	const BYTE* ip = (const BYTE*)src;
428	size_t const minInputSize = ZSTD_startingInputLength(format);
429
430	ZSTD_memset(zfhPtr, 0, sizeof(*zfhPtr)); /* not strictly necessary, but static analyzer do not understand that zfhPtr is only going to be read only if return value is zero, since they are 2 different signals */
431	if (srcSize < minInputSize) return minInputSize;
432	RETURN_ERROR_IF(src==NULL, GENERIC, "invalid parameter");
433
434	if ( (format != ZSTD_f_zstd1_magicless)
435	&& (MEM_readLE32(memPtr: src) != ZSTD_MAGICNUMBER) ) {
436	if ((MEM_readLE32(memPtr: src) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {
437	/* skippable frame */
438	if (srcSize < ZSTD_SKIPPABLEHEADERSIZE)
439	return ZSTD_SKIPPABLEHEADERSIZE; /* magic number + frame length */
440	ZSTD_memset(zfhPtr, 0, sizeof(*zfhPtr));
441	zfhPtr->frameContentSize = MEM_readLE32(memPtr: (const char *)src + ZSTD_FRAMEIDSIZE);
442	zfhPtr->frameType = ZSTD_skippableFrame;
443	return 0;
444	}
445	RETURN_ERROR(prefix_unknown, "");
446	}
447
448	/* ensure there is enough `srcSize` to fully read/decode frame header */
449	{ size_t const fhsize = ZSTD_frameHeaderSize_internal(src, srcSize, format);
450	if (srcSize < fhsize) return fhsize;
451	zfhPtr->headerSize = (U32)fhsize;
452	}
453
454	{ BYTE const fhdByte = ip[minInputSize-1];
455	size_t pos = minInputSize;
456	U32 const dictIDSizeCode = fhdByte&3;
457	U32 const checksumFlag = (fhdByte>>2)&1;
458	U32 const singleSegment = (fhdByte>>5)&1;
459	U32 const fcsID = fhdByte>>6;
460	U64 windowSize = 0;
461	U32 dictID = 0;
462	U64 frameContentSize = ZSTD_CONTENTSIZE_UNKNOWN;
463	RETURN_ERROR_IF((fhdByte & 0x08) != 0, frameParameter_unsupported,
464	"reserved bits, must be zero");
465
466	if (!singleSegment) {
467	BYTE const wlByte = ip[pos++];
468	U32 const windowLog = (wlByte >> 3) + ZSTD_WINDOWLOG_ABSOLUTEMIN;
469	RETURN_ERROR_IF(windowLog > ZSTD_WINDOWLOG_MAX, frameParameter_windowTooLarge, "");
470	windowSize = (1ULL << windowLog);
471	windowSize += (windowSize >> 3) * (wlByte&7);
472	}
473	switch(dictIDSizeCode)
474	{
475	default:
476	assert(0); /* impossible */
477	ZSTD_FALLTHROUGH;
478	case 0 : break;
479	case 1 : dictID = ip[pos]; pos++; break;
480	case 2 : dictID = MEM_readLE16(memPtr: ip+pos); pos+=2; break;
481	case 3 : dictID = MEM_readLE32(memPtr: ip+pos); pos+=4; break;
482	}
483	switch(fcsID)
484	{
485	default:
486	assert(0); /* impossible */
487	ZSTD_FALLTHROUGH;
488	case 0 : if (singleSegment) frameContentSize = ip[pos]; break;
489	case 1 : frameContentSize = MEM_readLE16(memPtr: ip+pos)+256; break;
490	case 2 : frameContentSize = MEM_readLE32(memPtr: ip+pos); break;
491	case 3 : frameContentSize = MEM_readLE64(memPtr: ip+pos); break;
492	}
493	if (singleSegment) windowSize = frameContentSize;
494
495	zfhPtr->frameType = ZSTD_frame;
496	zfhPtr->frameContentSize = frameContentSize;
497	zfhPtr->windowSize = windowSize;
498	zfhPtr->blockSizeMax = (unsigned) MIN(windowSize, ZSTD_BLOCKSIZE_MAX);
499	zfhPtr->dictID = dictID;
500	zfhPtr->checksumFlag = checksumFlag;
501	}
502	return 0;
503	}
504
505	/* ZSTD_getFrameHeader() :
506	* decode Frame Header, or require larger `srcSize`.
507	* note : this function does not consume input, it only reads it.
508	* @return : 0, `zfhPtr` is correctly filled,
509	* >0, `srcSize` is too small, value is wanted `srcSize` amount,
510	* or an error code, which can be tested using ZSTD_isError() */
511	size_t ZSTD_getFrameHeader(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize)
512	{
513	return ZSTD_getFrameHeader_advanced(zfhPtr, src, srcSize, format: ZSTD_f_zstd1);
514	}
515
516	/* ZSTD_getFrameContentSize() :
517	* compatible with legacy mode
518	* @return : decompressed size of the single frame pointed to be `src` if known, otherwise
519	* - ZSTD_CONTENTSIZE_UNKNOWN if the size cannot be determined
520	* - ZSTD_CONTENTSIZE_ERROR if an error occurred (e.g. invalid magic number, srcSize too small) */
521	unsigned long long ZSTD_getFrameContentSize(const void *src, size_t srcSize)
522	{
523	{ ZSTD_frameHeader zfh;
524	if (ZSTD_getFrameHeader(zfhPtr: &zfh, src, srcSize) != 0)
525	return ZSTD_CONTENTSIZE_ERROR;
526	if (zfh.frameType == ZSTD_skippableFrame) {
527	return 0;
528	} else {
529	return zfh.frameContentSize;
530	} }
531	}
532
533	static size_t readSkippableFrameSize(void const* src, size_t srcSize)
534	{
535	size_t const skippableHeaderSize = ZSTD_SKIPPABLEHEADERSIZE;
536	U32 sizeU32;
537
538	RETURN_ERROR_IF(srcSize < ZSTD_SKIPPABLEHEADERSIZE, srcSize_wrong, "");
539
540	sizeU32 = MEM_readLE32(memPtr: (BYTE const*)src + ZSTD_FRAMEIDSIZE);
541	RETURN_ERROR_IF((U32)(sizeU32 + ZSTD_SKIPPABLEHEADERSIZE) < sizeU32,
542	frameParameter_unsupported, "");
543	{
544	size_t const skippableSize = skippableHeaderSize + sizeU32;
545	RETURN_ERROR_IF(skippableSize > srcSize, srcSize_wrong, "");
546	return skippableSize;
547	}
548	}
549
550	/*! ZSTD_readSkippableFrame() :
551	* Retrieves a zstd skippable frame containing data given by src, and writes it to dst buffer.
552	*
553	* The parameter magicVariant will receive the magicVariant that was supplied when the frame was written,
554	* i.e. magicNumber - ZSTD_MAGIC_SKIPPABLE_START. This can be NULL if the caller is not interested
555	* in the magicVariant.
556	*
557	* Returns an error if destination buffer is not large enough, or if the frame is not skippable.
558	*
559	* @return : number of bytes written or a ZSTD error.
560	*/
561	ZSTDLIB_API size_t ZSTD_readSkippableFrame(void* dst, size_t dstCapacity, unsigned* magicVariant,
562	const void* src, size_t srcSize)
563	{
564	U32 const magicNumber = MEM_readLE32(memPtr: src);
565	size_t skippableFrameSize = readSkippableFrameSize(src, srcSize);
566	size_t skippableContentSize = skippableFrameSize - ZSTD_SKIPPABLEHEADERSIZE;
567
568	/* check input validity */
569	RETURN_ERROR_IF(!ZSTD_isSkippableFrame(src, srcSize), frameParameter_unsupported, "");
570	RETURN_ERROR_IF(skippableFrameSize < ZSTD_SKIPPABLEHEADERSIZE || skippableFrameSize > srcSize, srcSize_wrong, "");
571	RETURN_ERROR_IF(skippableContentSize > dstCapacity, dstSize_tooSmall, "");
572
573	/* deliver payload */
574	if (skippableContentSize > 0 && dst != NULL)
575	ZSTD_memcpy(dst, (const BYTE *)src + ZSTD_SKIPPABLEHEADERSIZE, skippableContentSize);
576	if (magicVariant != NULL)
577	*magicVariant = magicNumber - ZSTD_MAGIC_SKIPPABLE_START;
578	return skippableContentSize;
579	}
580
581	/* ZSTD_findDecompressedSize() :
582	* compatible with legacy mode
583	* `srcSize` must be the exact length of some number of ZSTD compressed and/or
584	* skippable frames
585	* @return : decompressed size of the frames contained */
586	unsigned long long ZSTD_findDecompressedSize(const void* src, size_t srcSize)
587	{
588	unsigned long long totalDstSize = 0;
589
590	while (srcSize >= ZSTD_startingInputLength(format: ZSTD_f_zstd1)) {
591	U32 const magicNumber = MEM_readLE32(memPtr: src);
592
593	if ((magicNumber & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {
594	size_t const skippableSize = readSkippableFrameSize(src, srcSize);
595	if (ZSTD_isError(code: skippableSize)) {
596	return ZSTD_CONTENTSIZE_ERROR;
597	}
598	assert(skippableSize <= srcSize);
599
600	src = (const BYTE *)src + skippableSize;
601	srcSize -= skippableSize;
602	continue;
603	}
604
605	{ unsigned long long const ret = ZSTD_getFrameContentSize(src, srcSize);
606	if (ret >= ZSTD_CONTENTSIZE_ERROR) return ret;
607
608	/* check for overflow */
609	if (totalDstSize + ret < totalDstSize) return ZSTD_CONTENTSIZE_ERROR;
610	totalDstSize += ret;
611	}
612	{ size_t const frameSrcSize = ZSTD_findFrameCompressedSize(src, srcSize);
613	if (ZSTD_isError(code: frameSrcSize)) {
614	return ZSTD_CONTENTSIZE_ERROR;
615	}
616
617	src = (const BYTE *)src + frameSrcSize;
618	srcSize -= frameSrcSize;
619	}
620	} /* while (srcSize >= ZSTD_frameHeaderSize_prefix) */
621
622	if (srcSize) return ZSTD_CONTENTSIZE_ERROR;
623
624	return totalDstSize;
625	}
626
627	/* ZSTD_getDecompressedSize() :
628	* compatible with legacy mode
629	* @return : decompressed size if known, 0 otherwise
630	note : 0 can mean any of the following :
631	- frame content is empty
632	- decompressed size field is not present in frame header
633	- frame header unknown / not supported
634	- frame header not complete (`srcSize` too small) */
635	unsigned long long ZSTD_getDecompressedSize(const void* src, size_t srcSize)
636	{
637	unsigned long long const ret = ZSTD_getFrameContentSize(src, srcSize);
638	ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_ERROR < ZSTD_CONTENTSIZE_UNKNOWN);
639	return (ret >= ZSTD_CONTENTSIZE_ERROR) ? 0 : ret;
640	}
641
642
643	/* ZSTD_decodeFrameHeader() :
644	* `headerSize` must be the size provided by ZSTD_frameHeaderSize().
645	* If multiple DDict references are enabled, also will choose the correct DDict to use.
646	* @return : 0 if success, or an error code, which can be tested using ZSTD_isError() */
647	static size_t ZSTD_decodeFrameHeader(ZSTD_DCtx* dctx, const void* src, size_t headerSize)
648	{
649	size_t const result = ZSTD_getFrameHeader_advanced(zfhPtr: &(dctx->fParams), src, srcSize: headerSize, format: dctx->format);
650	if (ZSTD_isError(code: result)) return result; /* invalid header */
651	RETURN_ERROR_IF(result>0, srcSize_wrong, "headerSize too small");
652
653	/* Reference DDict requested by frame if dctx references multiple ddicts */
654	if (dctx->refMultipleDDicts == ZSTD_rmd_refMultipleDDicts && dctx->ddictSet) {
655	ZSTD_DCtx_selectFrameDDict(dctx);
656	}
657
658	#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
659	/* Skip the dictID check in fuzzing mode, because it makes the search
660	* harder.
661	*/
662	RETURN_ERROR_IF(dctx->fParams.dictID && (dctx->dictID != dctx->fParams.dictID),
663	dictionary_wrong, "");
664	#endif
665	dctx->validateChecksum = (dctx->fParams.checksumFlag && !dctx->forceIgnoreChecksum) ? 1 : 0;
666	if (dctx->validateChecksum) xxh64_reset(state: &dctx->xxhState, seed: 0);
667	dctx->processedCSize += headerSize;
668	return 0;
669	}
670
671	static ZSTD_frameSizeInfo ZSTD_errorFrameSizeInfo(size_t ret)
672	{
673	ZSTD_frameSizeInfo frameSizeInfo;
674	frameSizeInfo.compressedSize = ret;
675	frameSizeInfo.decompressedBound = ZSTD_CONTENTSIZE_ERROR;
676	return frameSizeInfo;
677	}
678
679	static ZSTD_frameSizeInfo ZSTD_findFrameSizeInfo(const void* src, size_t srcSize)
680	{
681	ZSTD_frameSizeInfo frameSizeInfo;
682	ZSTD_memset(&frameSizeInfo, 0, sizeof(ZSTD_frameSizeInfo));
683
684
685	if ((srcSize >= ZSTD_SKIPPABLEHEADERSIZE)
686	&& (MEM_readLE32(memPtr: src) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {
687	frameSizeInfo.compressedSize = readSkippableFrameSize(src, srcSize);
688	assert(ZSTD_isError(frameSizeInfo.compressedSize) ||
689	frameSizeInfo.compressedSize <= srcSize);
690	return frameSizeInfo;
691	} else {
692	const BYTE* ip = (const BYTE*)src;
693	const BYTE* const ipstart = ip;
694	size_t remainingSize = srcSize;
695	size_t nbBlocks = 0;
696	ZSTD_frameHeader zfh;
697
698	/* Extract Frame Header */
699	{ size_t const ret = ZSTD_getFrameHeader(zfhPtr: &zfh, src, srcSize);
700	if (ZSTD_isError(code: ret))
701	return ZSTD_errorFrameSizeInfo(ret);
702	if (ret > 0)
703	return ZSTD_errorFrameSizeInfo(ERROR(srcSize_wrong));
704	}
705
706	ip += zfh.headerSize;
707	remainingSize -= zfh.headerSize;
708
709	/* Iterate over each block */
710	while (1) {
711	blockProperties_t blockProperties;
712	size_t const cBlockSize = ZSTD_getcBlockSize(src: ip, srcSize: remainingSize, bpPtr: &blockProperties);
713	if (ZSTD_isError(code: cBlockSize))
714	return ZSTD_errorFrameSizeInfo(ret: cBlockSize);
715
716	if (ZSTD_blockHeaderSize + cBlockSize > remainingSize)
717	return ZSTD_errorFrameSizeInfo(ERROR(srcSize_wrong));
718
719	ip += ZSTD_blockHeaderSize + cBlockSize;
720	remainingSize -= ZSTD_blockHeaderSize + cBlockSize;
721	nbBlocks++;
722
723	if (blockProperties.lastBlock) break;
724	}
725
726	/* Final frame content checksum */
727	if (zfh.checksumFlag) {
728	if (remainingSize < 4)
729	return ZSTD_errorFrameSizeInfo(ERROR(srcSize_wrong));
730	ip += 4;
731	}
732
733	frameSizeInfo.compressedSize = (size_t)(ip - ipstart);
734	frameSizeInfo.decompressedBound = (zfh.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN)
735	? zfh.frameContentSize
736	: nbBlocks * zfh.blockSizeMax;
737	return frameSizeInfo;
738	}
739	}
740
741	/* ZSTD_findFrameCompressedSize() :
742	* compatible with legacy mode
743	* `src` must point to the start of a ZSTD frame, ZSTD legacy frame, or skippable frame
744	* `srcSize` must be at least as large as the frame contained
745	* @return : the compressed size of the frame starting at `src` */
746	size_t ZSTD_findFrameCompressedSize(const void *src, size_t srcSize)
747	{
748	ZSTD_frameSizeInfo const frameSizeInfo = ZSTD_findFrameSizeInfo(src, srcSize);
749	return frameSizeInfo.compressedSize;
750	}
751
752	/* ZSTD_decompressBound() :
753	* compatible with legacy mode
754	* `src` must point to the start of a ZSTD frame or a skippeable frame
755	* `srcSize` must be at least as large as the frame contained
756	* @return : the maximum decompressed size of the compressed source
757	*/
758	unsigned long long ZSTD_decompressBound(const void* src, size_t srcSize)
759	{
760	unsigned long long bound = 0;
761	/* Iterate over each frame */
762	while (srcSize > 0) {
763	ZSTD_frameSizeInfo const frameSizeInfo = ZSTD_findFrameSizeInfo(src, srcSize);
764	size_t const compressedSize = frameSizeInfo.compressedSize;
765	unsigned long long const decompressedBound = frameSizeInfo.decompressedBound;
766	if (ZSTD_isError(code: compressedSize) || decompressedBound == ZSTD_CONTENTSIZE_ERROR)
767	return ZSTD_CONTENTSIZE_ERROR;
768	assert(srcSize >= compressedSize);
769	src = (const BYTE*)src + compressedSize;
770	srcSize -= compressedSize;
771	bound += decompressedBound;
772	}
773	return bound;
774	}
775
776
777	/*-*************************************************************
778	* Frame decoding
779	***************************************************************/
780
781	/* ZSTD_insertBlock() :
782	* insert `src` block into `dctx` history. Useful to track uncompressed blocks. */
783	size_t ZSTD_insertBlock(ZSTD_DCtx* dctx, const void* blockStart, size_t blockSize)
784	{
785	DEBUGLOG(5, "ZSTD_insertBlock: %u bytes", (unsigned)blockSize);
786	ZSTD_checkContinuity(dctx, dst: blockStart, dstSize: blockSize);
787	dctx->previousDstEnd = (const char*)blockStart + blockSize;
788	return blockSize;
789	}
790
791
792	static size_t ZSTD_copyRawBlock(void* dst, size_t dstCapacity,
793	const void* src, size_t srcSize)
794	{
795	DEBUGLOG(5, "ZSTD_copyRawBlock");
796	RETURN_ERROR_IF(srcSize > dstCapacity, dstSize_tooSmall, "");
797	if (dst == NULL) {
798	if (srcSize == 0) return 0;
799	RETURN_ERROR(dstBuffer_null, "");
800	}
801	ZSTD_memmove(dst, src, srcSize);
802	return srcSize;
803	}
804
805	static size_t ZSTD_setRleBlock(void* dst, size_t dstCapacity,
806	BYTE b,
807	size_t regenSize)
808	{
809	RETURN_ERROR_IF(regenSize > dstCapacity, dstSize_tooSmall, "");
810	if (dst == NULL) {
811	if (regenSize == 0) return 0;
812	RETURN_ERROR(dstBuffer_null, "");
813	}
814	ZSTD_memset(dst, b, regenSize);
815	return regenSize;
816	}
817
818	static void ZSTD_DCtx_trace_end(ZSTD_DCtx const* dctx, U64 uncompressedSize, U64 compressedSize, unsigned streaming)
819	{
820	(void)dctx;
821	(void)uncompressedSize;
822	(void)compressedSize;
823	(void)streaming;
824	}
825
826
827	/*! ZSTD_decompressFrame() :
828	* @dctx must be properly initialized
829	* will update *srcPtr and *srcSizePtr,
830	* to make *srcPtr progress by one frame. */
831	static size_t ZSTD_decompressFrame(ZSTD_DCtx* dctx,
832	void* dst, size_t dstCapacity,
833	const void** srcPtr, size_t *srcSizePtr)
834	{
835	const BYTE* const istart = (const BYTE*)(*srcPtr);
836	const BYTE* ip = istart;
837	BYTE* const ostart = (BYTE*)dst;
838	BYTE* const oend = dstCapacity != 0 ? ostart + dstCapacity : ostart;
839	BYTE* op = ostart;
840	size_t remainingSrcSize = *srcSizePtr;
841
842	DEBUGLOG(4, "ZSTD_decompressFrame (srcSize:%i)", (int)*srcSizePtr);
843
844	/* check */
845	RETURN_ERROR_IF(
846	remainingSrcSize < ZSTD_FRAMEHEADERSIZE_MIN(dctx->format)+ZSTD_blockHeaderSize,
847	srcSize_wrong, "");
848
849	/* Frame Header */
850	{ size_t const frameHeaderSize = ZSTD_frameHeaderSize_internal(
851	src: ip, ZSTD_FRAMEHEADERSIZE_PREFIX(dctx->format), format: dctx->format);
852	if (ZSTD_isError(code: frameHeaderSize)) return frameHeaderSize;
853	RETURN_ERROR_IF(remainingSrcSize < frameHeaderSize+ZSTD_blockHeaderSize,
854	srcSize_wrong, "");
855	FORWARD_IF_ERROR( ZSTD_decodeFrameHeader(dctx, ip, frameHeaderSize) , "");
856	ip += frameHeaderSize; remainingSrcSize -= frameHeaderSize;
857	}
858
859	/* Loop on each block */
860	while (1) {
861	BYTE* oBlockEnd = oend;
862	size_t decodedSize;
863	blockProperties_t blockProperties;
864	size_t const cBlockSize = ZSTD_getcBlockSize(src: ip, srcSize: remainingSrcSize, bpPtr: &blockProperties);
865	if (ZSTD_isError(code: cBlockSize)) return cBlockSize;
866
867	ip += ZSTD_blockHeaderSize;
868	remainingSrcSize -= ZSTD_blockHeaderSize;
869	RETURN_ERROR_IF(cBlockSize > remainingSrcSize, srcSize_wrong, "");
870
871	if (ip >= op && ip < oBlockEnd) {
872	/* We are decompressing in-place. Limit the output pointer so that we
873	* don't overwrite the block that we are currently reading. This will
874	* fail decompression if the input & output pointers aren't spaced
875	* far enough apart.
876	*
877	* This is important to set, even when the pointers are far enough
878	* apart, because ZSTD_decompressBlock_internal() can decide to store
879	* literals in the output buffer, after the block it is decompressing.
880	* Since we don't want anything to overwrite our input, we have to tell
881	* ZSTD_decompressBlock_internal to never write past ip.
882	*
883	* See ZSTD_allocateLiteralsBuffer() for reference.
884	*/
885	oBlockEnd = op + (ip - op);
886	}
887
888	switch(blockProperties.blockType)
889	{
890	case bt_compressed:
891	decodedSize = ZSTD_decompressBlock_internal(dctx, dst: op, dstCapacity: (size_t)(oBlockEnd-op), src: ip, srcSize: cBlockSize, /* frame */ 1, streaming: not_streaming);
892	break;
893	case bt_raw :
894	/* Use oend instead of oBlockEnd because this function is safe to overlap. It uses memmove. */
895	decodedSize = ZSTD_copyRawBlock(dst: op, dstCapacity: (size_t)(oend-op), src: ip, srcSize: cBlockSize);
896	break;
897	case bt_rle :
898	decodedSize = ZSTD_setRleBlock(dst: op, dstCapacity: (size_t)(oBlockEnd-op), b: *ip, regenSize: blockProperties.origSize);
899	break;
900	case bt_reserved :
901	default:
902	RETURN_ERROR(corruption_detected, "invalid block type");
903	}
904
905	if (ZSTD_isError(code: decodedSize)) return decodedSize;
906	if (dctx->validateChecksum)
907	xxh64_update(state: &dctx->xxhState, input: op, length: decodedSize);
908	if (decodedSize != 0)
909	op += decodedSize;
910	assert(ip != NULL);
911	ip += cBlockSize;
912	remainingSrcSize -= cBlockSize;
913	if (blockProperties.lastBlock) break;
914	}
915
916	if (dctx->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN) {
917	RETURN_ERROR_IF((U64)(op-ostart) != dctx->fParams.frameContentSize,
918	corruption_detected, "");
919	}
920	if (dctx->fParams.checksumFlag) { /* Frame content checksum verification */
921	RETURN_ERROR_IF(remainingSrcSize<4, checksum_wrong, "");
922	if (!dctx->forceIgnoreChecksum) {
923	U32 const checkCalc = (U32)xxh64_digest(state: &dctx->xxhState);
924	U32 checkRead;
925	checkRead = MEM_readLE32(memPtr: ip);
926	RETURN_ERROR_IF(checkRead != checkCalc, checksum_wrong, "");
927	}
928	ip += 4;
929	remainingSrcSize -= 4;
930	}
931	ZSTD_DCtx_trace_end(dctx, uncompressedSize: (U64)(op-ostart), compressedSize: (U64)(ip-istart), /* streaming */ 0);
932	/* Allow caller to get size read */
933	*srcPtr = ip;
934	*srcSizePtr = remainingSrcSize;
935	return (size_t)(op-ostart);
936	}
937
938	static size_t ZSTD_decompressMultiFrame(ZSTD_DCtx* dctx,
939	void* dst, size_t dstCapacity,
940	const void* src, size_t srcSize,
941	const void* dict, size_t dictSize,
942	const ZSTD_DDict* ddict)
943	{
944	void* const dststart = dst;
945	int moreThan1Frame = 0;
946
947	DEBUGLOG(5, "ZSTD_decompressMultiFrame");
948	assert(dict==NULL || ddict==NULL); /* either dict or ddict set, not both */
949
950	if (ddict) {
951	dict = ZSTD_DDict_dictContent(ddict);
952	dictSize = ZSTD_DDict_dictSize(ddict);
953	}
954
955	while (srcSize >= ZSTD_startingInputLength(format: dctx->format)) {
956
957
958	{ U32 const magicNumber = MEM_readLE32(memPtr: src);
959	DEBUGLOG(4, "reading magic number %08X (expecting %08X)",
960	(unsigned)magicNumber, ZSTD_MAGICNUMBER);
961	if ((magicNumber & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {
962	size_t const skippableSize = readSkippableFrameSize(src, srcSize);
963	FORWARD_IF_ERROR(skippableSize, "readSkippableFrameSize failed");
964	assert(skippableSize <= srcSize);
965
966	src = (const BYTE *)src + skippableSize;
967	srcSize -= skippableSize;
968	continue;
969	} }
970
971	if (ddict) {
972	/* we were called from ZSTD_decompress_usingDDict */
973	FORWARD_IF_ERROR(ZSTD_decompressBegin_usingDDict(dctx, ddict), "");
974	} else {
975	/* this will initialize correctly with no dict if dict == NULL, so
976	* use this in all cases but ddict */
977	FORWARD_IF_ERROR(ZSTD_decompressBegin_usingDict(dctx, dict, dictSize), "");
978	}
979	ZSTD_checkContinuity(dctx, dst, dstSize: dstCapacity);
980
981	{ const size_t res = ZSTD_decompressFrame(dctx, dst, dstCapacity,
982	srcPtr: &src, srcSizePtr: &srcSize);
983	RETURN_ERROR_IF(
984	(ZSTD_getErrorCode(res) == ZSTD_error_prefix_unknown)
985	&& (moreThan1Frame==1),
986	srcSize_wrong,
987	"At least one frame successfully completed, "
988	"but following bytes are garbage: "
989	"it's more likely to be a srcSize error, "
990	"specifying more input bytes than size of frame(s). "
991	"Note: one could be unlucky, it might be a corruption error instead, "
992	"happening right at the place where we expect zstd magic bytes. "
993	"But this is _much_ less likely than a srcSize field error.");
994	if (ZSTD_isError(code: res)) return res;
995	assert(res <= dstCapacity);
996	if (res != 0)
997	dst = (BYTE*)dst + res;
998	dstCapacity -= res;
999	}
1000	moreThan1Frame = 1;
1001	} /* while (srcSize >= ZSTD_frameHeaderSize_prefix) */
1002
1003	RETURN_ERROR_IF(srcSize, srcSize_wrong, "input not entirely consumed");
1004
1005	return (size_t)((BYTE*)dst - (BYTE*)dststart);
1006	}
1007
1008	size_t ZSTD_decompress_usingDict(ZSTD_DCtx* dctx,
1009	void* dst, size_t dstCapacity,
1010	const void* src, size_t srcSize,
1011	const void* dict, size_t dictSize)
1012	{
1013	return ZSTD_decompressMultiFrame(dctx, dst, dstCapacity, src, srcSize, dict, dictSize, NULL);
1014	}
1015
1016
1017	static ZSTD_DDict const* ZSTD_getDDict(ZSTD_DCtx* dctx)
1018	{
1019	switch (dctx->dictUses) {
1020	default:
1021	assert(0 /* Impossible */);
1022	ZSTD_FALLTHROUGH;
1023	case ZSTD_dont_use:
1024	ZSTD_clearDict(dctx);
1025	return NULL;
1026	case ZSTD_use_indefinitely:
1027	return dctx->ddict;
1028	case ZSTD_use_once:
1029	dctx->dictUses = ZSTD_dont_use;
1030	return dctx->ddict;
1031	}
1032	}
1033
1034	size_t ZSTD_decompressDCtx(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
1035	{
1036	return ZSTD_decompress_usingDDict(dctx, dst, dstCapacity, src, srcSize, ddict: ZSTD_getDDict(dctx));
1037	}
1038
1039
1040	size_t ZSTD_decompress(void* dst, size_t dstCapacity, const void* src, size_t srcSize)
1041	{
1042	#if defined(ZSTD_HEAPMODE) && (ZSTD_HEAPMODE>=1)
1043	size_t regenSize;
1044	ZSTD_DCtx* const dctx = ZSTD_createDCtx_internal(customMem: ZSTD_defaultCMem);
1045	RETURN_ERROR_IF(dctx==NULL, memory_allocation, "NULL pointer!");
1046	regenSize = ZSTD_decompressDCtx(dctx, dst, dstCapacity, src, srcSize);
1047	ZSTD_freeDCtx(dctx);
1048	return regenSize;
1049	#else /* stack mode */
1050	ZSTD_DCtx dctx;
1051	ZSTD_initDCtx_internal(&dctx);
1052	return ZSTD_decompressDCtx(&dctx, dst, dstCapacity, src, srcSize);
1053	#endif
1054	}
1055
1056
1057	/*-**************************************
1058	* Advanced Streaming Decompression API
1059	* Bufferless and synchronous
1060	****************************************/
1061	size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx) { return dctx->expected; }
1062
1063	/*
1064	* Similar to ZSTD_nextSrcSizeToDecompress(), but when a block input can be streamed,
1065	* we allow taking a partial block as the input. Currently only raw uncompressed blocks can
1066	* be streamed.
1067	*
1068	* For blocks that can be streamed, this allows us to reduce the latency until we produce
1069	* output, and avoid copying the input.
1070	*
1071	* @param inputSize - The total amount of input that the caller currently has.
1072	*/
1073	static size_t ZSTD_nextSrcSizeToDecompressWithInputSize(ZSTD_DCtx* dctx, size_t inputSize) {
1074	if (!(dctx->stage == ZSTDds_decompressBlock || dctx->stage == ZSTDds_decompressLastBlock))
1075	return dctx->expected;
1076	if (dctx->bType != bt_raw)
1077	return dctx->expected;
1078	return BOUNDED(1, inputSize, dctx->expected);
1079	}
1080
1081	ZSTD_nextInputType_e ZSTD_nextInputType(ZSTD_DCtx* dctx) {
1082	switch(dctx->stage)
1083	{
1084	default: /* should not happen */
1085	assert(0);
1086	ZSTD_FALLTHROUGH;
1087	case ZSTDds_getFrameHeaderSize:
1088	ZSTD_FALLTHROUGH;
1089	case ZSTDds_decodeFrameHeader:
1090	return ZSTDnit_frameHeader;
1091	case ZSTDds_decodeBlockHeader:
1092	return ZSTDnit_blockHeader;
1093	case ZSTDds_decompressBlock:
1094	return ZSTDnit_block;
1095	case ZSTDds_decompressLastBlock:
1096	return ZSTDnit_lastBlock;
1097	case ZSTDds_checkChecksum:
1098	return ZSTDnit_checksum;
1099	case ZSTDds_decodeSkippableHeader:
1100	ZSTD_FALLTHROUGH;
1101	case ZSTDds_skipFrame:
1102	return ZSTDnit_skippableFrame;
1103	}
1104	}
1105
1106	static int ZSTD_isSkipFrame(ZSTD_DCtx* dctx) { return dctx->stage == ZSTDds_skipFrame; }
1107
1108	/* ZSTD_decompressContinue() :
1109	* srcSize : must be the exact nb of bytes expected (see ZSTD_nextSrcSizeToDecompress())
1110	* @return : nb of bytes generated into `dst` (necessarily <= `dstCapacity)
1111	* or an error code, which can be tested using ZSTD_isError() */
1112	size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
1113	{
1114	DEBUGLOG(5, "ZSTD_decompressContinue (srcSize:%u)", (unsigned)srcSize);
1115	/* Sanity check */
1116	RETURN_ERROR_IF(srcSize != ZSTD_nextSrcSizeToDecompressWithInputSize(dctx, srcSize), srcSize_wrong, "not allowed");
1117	ZSTD_checkContinuity(dctx, dst, dstSize: dstCapacity);
1118
1119	dctx->processedCSize += srcSize;
1120
1121	switch (dctx->stage)
1122	{
1123	case ZSTDds_getFrameHeaderSize :
1124	assert(src != NULL);
1125	if (dctx->format == ZSTD_f_zstd1) { /* allows header */
1126	assert(srcSize >= ZSTD_FRAMEIDSIZE); /* to read skippable magic number */
1127	if ((MEM_readLE32(memPtr: src) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) { /* skippable frame */
1128	ZSTD_memcpy(dctx->headerBuffer, src, srcSize);
1129	dctx->expected = ZSTD_SKIPPABLEHEADERSIZE - srcSize; /* remaining to load to get full skippable frame header */
1130	dctx->stage = ZSTDds_decodeSkippableHeader;
1131	return 0;
1132	} }
1133	dctx->headerSize = ZSTD_frameHeaderSize_internal(src, srcSize, format: dctx->format);
1134	if (ZSTD_isError(code: dctx->headerSize)) return dctx->headerSize;
1135	ZSTD_memcpy(dctx->headerBuffer, src, srcSize);
1136	dctx->expected = dctx->headerSize - srcSize;
1137	dctx->stage = ZSTDds_decodeFrameHeader;
1138	return 0;
1139
1140	case ZSTDds_decodeFrameHeader:
1141	assert(src != NULL);
1142	ZSTD_memcpy(dctx->headerBuffer + (dctx->headerSize - srcSize), src, srcSize);
1143	FORWARD_IF_ERROR(ZSTD_decodeFrameHeader(dctx, dctx->headerBuffer, dctx->headerSize), "");
1144	dctx->expected = ZSTD_blockHeaderSize;
1145	dctx->stage = ZSTDds_decodeBlockHeader;
1146	return 0;
1147
1148	case ZSTDds_decodeBlockHeader:
1149	{ blockProperties_t bp;
1150	size_t const cBlockSize = ZSTD_getcBlockSize(src, srcSize: ZSTD_blockHeaderSize, bpPtr: &bp);
1151	if (ZSTD_isError(code: cBlockSize)) return cBlockSize;
1152	RETURN_ERROR_IF(cBlockSize > dctx->fParams.blockSizeMax, corruption_detected, "Block Size Exceeds Maximum");
1153	dctx->expected = cBlockSize;
1154	dctx->bType = bp.blockType;
1155	dctx->rleSize = bp.origSize;
1156	if (cBlockSize) {
1157	dctx->stage = bp.lastBlock ? ZSTDds_decompressLastBlock : ZSTDds_decompressBlock;
1158	return 0;
1159	}
1160	/* empty block */
1161	if (bp.lastBlock) {
1162	if (dctx->fParams.checksumFlag) {
1163	dctx->expected = 4;
1164	dctx->stage = ZSTDds_checkChecksum;
1165	} else {
1166	dctx->expected = 0; /* end of frame */
1167	dctx->stage = ZSTDds_getFrameHeaderSize;
1168	}
1169	} else {
1170	dctx->expected = ZSTD_blockHeaderSize; /* jump to next header */
1171	dctx->stage = ZSTDds_decodeBlockHeader;
1172	}
1173	return 0;
1174	}
1175
1176	case ZSTDds_decompressLastBlock:
1177	case ZSTDds_decompressBlock:
1178	DEBUGLOG(5, "ZSTD_decompressContinue: case ZSTDds_decompressBlock");
1179	{ size_t rSize;
1180	switch(dctx->bType)
1181	{
1182	case bt_compressed:
1183	DEBUGLOG(5, "ZSTD_decompressContinue: case bt_compressed");
1184	rSize = ZSTD_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize, /* frame */ 1, streaming: is_streaming);
1185	dctx->expected = 0; /* Streaming not supported */
1186	break;
1187	case bt_raw :
1188	assert(srcSize <= dctx->expected);
1189	rSize = ZSTD_copyRawBlock(dst, dstCapacity, src, srcSize);
1190	FORWARD_IF_ERROR(rSize, "ZSTD_copyRawBlock failed");
1191	assert(rSize == srcSize);
1192	dctx->expected -= rSize;
1193	break;
1194	case bt_rle :
1195	rSize = ZSTD_setRleBlock(dst, dstCapacity, b: *(const BYTE*)src, regenSize: dctx->rleSize);
1196	dctx->expected = 0; /* Streaming not supported */
1197	break;
1198	case bt_reserved : /* should never happen */
1199	default:
1200	RETURN_ERROR(corruption_detected, "invalid block type");
1201	}
1202	FORWARD_IF_ERROR(rSize, "");
1203	RETURN_ERROR_IF(rSize > dctx->fParams.blockSizeMax, corruption_detected, "Decompressed Block Size Exceeds Maximum");
1204	DEBUGLOG(5, "ZSTD_decompressContinue: decoded size from block : %u", (unsigned)rSize);
1205	dctx->decodedSize += rSize;
1206	if (dctx->validateChecksum) xxh64_update(state: &dctx->xxhState, input: dst, length: rSize);
1207	dctx->previousDstEnd = (char*)dst + rSize;
1208
1209	/* Stay on the same stage until we are finished streaming the block. */
1210	if (dctx->expected > 0) {
1211	return rSize;
1212	}
1213
1214	if (dctx->stage == ZSTDds_decompressLastBlock) { /* end of frame */
1215	DEBUGLOG(4, "ZSTD_decompressContinue: decoded size from frame : %u", (unsigned)dctx->decodedSize);
1216	RETURN_ERROR_IF(
1217	dctx->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN
1218	&& dctx->decodedSize != dctx->fParams.frameContentSize,
1219	corruption_detected, "");
1220	if (dctx->fParams.checksumFlag) { /* another round for frame checksum */
1221	dctx->expected = 4;
1222	dctx->stage = ZSTDds_checkChecksum;
1223	} else {
1224	ZSTD_DCtx_trace_end(dctx, uncompressedSize: dctx->decodedSize, compressedSize: dctx->processedCSize, /* streaming */ 1);
1225	dctx->expected = 0; /* ends here */
1226	dctx->stage = ZSTDds_getFrameHeaderSize;
1227	}
1228	} else {
1229	dctx->stage = ZSTDds_decodeBlockHeader;
1230	dctx->expected = ZSTD_blockHeaderSize;
1231	}
1232	return rSize;
1233	}
1234
1235	case ZSTDds_checkChecksum:
1236	assert(srcSize == 4); /* guaranteed by dctx->expected */
1237	{
1238	if (dctx->validateChecksum) {
1239	U32 const h32 = (U32)xxh64_digest(state: &dctx->xxhState);
1240	U32 const check32 = MEM_readLE32(memPtr: src);
1241	DEBUGLOG(4, "ZSTD_decompressContinue: checksum : calculated %08X :: %08X read", (unsigned)h32, (unsigned)check32);
1242	RETURN_ERROR_IF(check32 != h32, checksum_wrong, "");
1243	}
1244	ZSTD_DCtx_trace_end(dctx, uncompressedSize: dctx->decodedSize, compressedSize: dctx->processedCSize, /* streaming */ 1);
1245	dctx->expected = 0;
1246	dctx->stage = ZSTDds_getFrameHeaderSize;
1247	return 0;
1248	}
1249
1250	case ZSTDds_decodeSkippableHeader:
1251	assert(src != NULL);
1252	assert(srcSize <= ZSTD_SKIPPABLEHEADERSIZE);
1253	ZSTD_memcpy(dctx->headerBuffer + (ZSTD_SKIPPABLEHEADERSIZE - srcSize), src, srcSize); /* complete skippable header */
1254	dctx->expected = MEM_readLE32(memPtr: dctx->headerBuffer + ZSTD_FRAMEIDSIZE); /* note : dctx->expected can grow seriously large, beyond local buffer size */
1255	dctx->stage = ZSTDds_skipFrame;
1256	return 0;
1257
1258	case ZSTDds_skipFrame:
1259	dctx->expected = 0;
1260	dctx->stage = ZSTDds_getFrameHeaderSize;
1261	return 0;
1262
1263	default:
1264	assert(0); /* impossible */
1265	RETURN_ERROR(GENERIC, "impossible to reach"); /* some compiler require default to do something */
1266	}
1267	}
1268
1269
1270	static size_t ZSTD_refDictContent(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
1271	{
1272	dctx->dictEnd = dctx->previousDstEnd;
1273	dctx->virtualStart = (const char*)dict - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->prefixStart));
1274	dctx->prefixStart = dict;
1275	dctx->previousDstEnd = (const char*)dict + dictSize;
1276	#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
1277	dctx->dictContentBeginForFuzzing = dctx->prefixStart;
1278	dctx->dictContentEndForFuzzing = dctx->previousDstEnd;
1279	#endif
1280	return 0;
1281	}
1282
1283	/*! ZSTD_loadDEntropy() :
1284	* dict : must point at beginning of a valid zstd dictionary.
1285	* @return : size of entropy tables read */
1286	size_t
1287	ZSTD_loadDEntropy(ZSTD_entropyDTables_t* entropy,
1288	const void* const dict, size_t const dictSize)
1289	{
1290	const BYTE* dictPtr = (const BYTE*)dict;
1291	const BYTE* const dictEnd = dictPtr + dictSize;
1292
1293	RETURN_ERROR_IF(dictSize <= 8, dictionary_corrupted, "dict is too small");
1294	assert(MEM_readLE32(dict) == ZSTD_MAGIC_DICTIONARY); /* dict must be valid */
1295	dictPtr += 8; /* skip header = magic + dictID */
1296
1297	ZSTD_STATIC_ASSERT(offsetof(ZSTD_entropyDTables_t, OFTable) == offsetof(ZSTD_entropyDTables_t, LLTable) + sizeof(entropy->LLTable));
1298	ZSTD_STATIC_ASSERT(offsetof(ZSTD_entropyDTables_t, MLTable) == offsetof(ZSTD_entropyDTables_t, OFTable) + sizeof(entropy->OFTable));
1299	ZSTD_STATIC_ASSERT(sizeof(entropy->LLTable) + sizeof(entropy->OFTable) + sizeof(entropy->MLTable) >= HUF_DECOMPRESS_WORKSPACE_SIZE);
1300	{ void* const workspace = &entropy->LLTable; /* use fse tables as temporary workspace; implies fse tables are grouped together */
1301	size_t const workspaceSize = sizeof(entropy->LLTable) + sizeof(entropy->OFTable) + sizeof(entropy->MLTable);
1302	#ifdef HUF_FORCE_DECOMPRESS_X1
1303	/* in minimal huffman, we always use X1 variants */
1304	size_t const hSize = HUF_readDTableX1_wksp(entropy->hufTable,
1305	dictPtr, dictEnd - dictPtr,
1306	workspace, workspaceSize);
1307	#else
1308	size_t const hSize = HUF_readDTableX2_wksp(DTable: entropy->hufTable,
1309	src: dictPtr, srcSize: (size_t)(dictEnd - dictPtr),
1310	workSpace: workspace, wkspSize: workspaceSize);
1311	#endif
1312	RETURN_ERROR_IF(HUF_isError(hSize), dictionary_corrupted, "");
1313	dictPtr += hSize;
1314	}
1315
1316	{ short offcodeNCount[MaxOff+1];
1317	unsigned offcodeMaxValue = MaxOff, offcodeLog;
1318	size_t const offcodeHeaderSize = FSE_readNCount(normalizedCounter: offcodeNCount, maxSymbolValuePtr: &offcodeMaxValue, tableLogPtr: &offcodeLog, rBuffer: dictPtr, rBuffSize: (size_t)(dictEnd-dictPtr));
1319	RETURN_ERROR_IF(FSE_isError(offcodeHeaderSize), dictionary_corrupted, "");
1320	RETURN_ERROR_IF(offcodeMaxValue > MaxOff, dictionary_corrupted, "");
1321	RETURN_ERROR_IF(offcodeLog > OffFSELog, dictionary_corrupted, "");
1322	ZSTD_buildFSETable( dt: entropy->OFTable,
1323	normalizedCounter: offcodeNCount, maxSymbolValue: offcodeMaxValue,
1324	baseValue: OF_base, nbAdditionalBits: OF_bits,
1325	tableLog: offcodeLog,
1326	wksp: entropy->workspace, wkspSize: sizeof(entropy->workspace),
1327	/* bmi2 */0);
1328	dictPtr += offcodeHeaderSize;
1329	}
1330
1331	{ short matchlengthNCount[MaxML+1];
1332	unsigned matchlengthMaxValue = MaxML, matchlengthLog;
1333	size_t const matchlengthHeaderSize = FSE_readNCount(normalizedCounter: matchlengthNCount, maxSymbolValuePtr: &matchlengthMaxValue, tableLogPtr: &matchlengthLog, rBuffer: dictPtr, rBuffSize: (size_t)(dictEnd-dictPtr));
1334	RETURN_ERROR_IF(FSE_isError(matchlengthHeaderSize), dictionary_corrupted, "");
1335	RETURN_ERROR_IF(matchlengthMaxValue > MaxML, dictionary_corrupted, "");
1336	RETURN_ERROR_IF(matchlengthLog > MLFSELog, dictionary_corrupted, "");
1337	ZSTD_buildFSETable( dt: entropy->MLTable,
1338	normalizedCounter: matchlengthNCount, maxSymbolValue: matchlengthMaxValue,
1339	baseValue: ML_base, nbAdditionalBits: ML_bits,
1340	tableLog: matchlengthLog,
1341	wksp: entropy->workspace, wkspSize: sizeof(entropy->workspace),
1342	/* bmi2 */ 0);
1343	dictPtr += matchlengthHeaderSize;
1344	}
1345
1346	{ short litlengthNCount[MaxLL+1];
1347	unsigned litlengthMaxValue = MaxLL, litlengthLog;
1348	size_t const litlengthHeaderSize = FSE_readNCount(normalizedCounter: litlengthNCount, maxSymbolValuePtr: &litlengthMaxValue, tableLogPtr: &litlengthLog, rBuffer: dictPtr, rBuffSize: (size_t)(dictEnd-dictPtr));
1349	RETURN_ERROR_IF(FSE_isError(litlengthHeaderSize), dictionary_corrupted, "");
1350	RETURN_ERROR_IF(litlengthMaxValue > MaxLL, dictionary_corrupted, "");
1351	RETURN_ERROR_IF(litlengthLog > LLFSELog, dictionary_corrupted, "");
1352	ZSTD_buildFSETable( dt: entropy->LLTable,
1353	normalizedCounter: litlengthNCount, maxSymbolValue: litlengthMaxValue,
1354	baseValue: LL_base, nbAdditionalBits: LL_bits,
1355	tableLog: litlengthLog,
1356	wksp: entropy->workspace, wkspSize: sizeof(entropy->workspace),
1357	/* bmi2 */ 0);
1358	dictPtr += litlengthHeaderSize;
1359	}
1360
1361	RETURN_ERROR_IF(dictPtr+12 > dictEnd, dictionary_corrupted, "");
1362	{ int i;
1363	size_t const dictContentSize = (size_t)(dictEnd - (dictPtr+12));
1364	for (i=0; i<3; i++) {
1365	U32 const rep = MEM_readLE32(memPtr: dictPtr); dictPtr += 4;
1366	RETURN_ERROR_IF(rep==0 || rep > dictContentSize,
1367	dictionary_corrupted, "");
1368	entropy->rep[i] = rep;
1369	} }
1370
1371	return (size_t)(dictPtr - (const BYTE*)dict);
1372	}
1373
1374	static size_t ZSTD_decompress_insertDictionary(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
1375	{
1376	if (dictSize < 8) return ZSTD_refDictContent(dctx, dict, dictSize);
1377	{ U32 const magic = MEM_readLE32(memPtr: dict);
1378	if (magic != ZSTD_MAGIC_DICTIONARY) {
1379	return ZSTD_refDictContent(dctx, dict, dictSize); /* pure content mode */
1380	} }
1381	dctx->dictID = MEM_readLE32(memPtr: (const char*)dict + ZSTD_FRAMEIDSIZE);
1382
1383	/* load entropy tables */
1384	{ size_t const eSize = ZSTD_loadDEntropy(entropy: &dctx->entropy, dict, dictSize);
1385	RETURN_ERROR_IF(ZSTD_isError(eSize), dictionary_corrupted, "");
1386	dict = (const char*)dict + eSize;
1387	dictSize -= eSize;
1388	}
1389	dctx->litEntropy = dctx->fseEntropy = 1;
1390
1391	/* reference dictionary content */
1392	return ZSTD_refDictContent(dctx, dict, dictSize);
1393	}
1394
1395	size_t ZSTD_decompressBegin(ZSTD_DCtx* dctx)
1396	{
1397	assert(dctx != NULL);
1398	dctx->expected = ZSTD_startingInputLength(format: dctx->format); /* dctx->format must be properly set */
1399	dctx->stage = ZSTDds_getFrameHeaderSize;
1400	dctx->processedCSize = 0;
1401	dctx->decodedSize = 0;
1402	dctx->previousDstEnd = NULL;
1403	dctx->prefixStart = NULL;
1404	dctx->virtualStart = NULL;
1405	dctx->dictEnd = NULL;
1406	dctx->entropy.hufTable[0] = (HUF_DTable)((HufLog)*0x1000001); /* cover both little and big endian */
1407	dctx->litEntropy = dctx->fseEntropy = 0;
1408	dctx->dictID = 0;
1409	dctx->bType = bt_reserved;
1410	ZSTD_STATIC_ASSERT(sizeof(dctx->entropy.rep) == sizeof(repStartValue));
1411	ZSTD_memcpy(dctx->entropy.rep, repStartValue, sizeof(repStartValue)); /* initial repcodes */
1412	dctx->LLTptr = dctx->entropy.LLTable;
1413	dctx->MLTptr = dctx->entropy.MLTable;
1414	dctx->OFTptr = dctx->entropy.OFTable;
1415	dctx->HUFptr = dctx->entropy.hufTable;
1416	return 0;
1417	}
1418
1419	size_t ZSTD_decompressBegin_usingDict(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
1420	{
1421	FORWARD_IF_ERROR( ZSTD_decompressBegin(dctx) , "");
1422	if (dict && dictSize)
1423	RETURN_ERROR_IF(
1424	ZSTD_isError(ZSTD_decompress_insertDictionary(dctx, dict, dictSize)),
1425	dictionary_corrupted, "");
1426	return 0;
1427	}
1428
1429
1430	/* ====== ZSTD_DDict ====== */
1431
1432	size_t ZSTD_decompressBegin_usingDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict)
1433	{
1434	DEBUGLOG(4, "ZSTD_decompressBegin_usingDDict");
1435	assert(dctx != NULL);
1436	if (ddict) {
1437	const char* const dictStart = (const char*)ZSTD_DDict_dictContent(ddict);
1438	size_t const dictSize = ZSTD_DDict_dictSize(ddict);
1439	const void* const dictEnd = dictStart + dictSize;
1440	dctx->ddictIsCold = (dctx->dictEnd != dictEnd);
1441	DEBUGLOG(4, "DDict is %s",
1442	dctx->ddictIsCold ? "~cold~" : "hot!");
1443	}
1444	FORWARD_IF_ERROR( ZSTD_decompressBegin(dctx) , "");
1445	if (ddict) { /* NULL ddict is equivalent to no dictionary */
1446	ZSTD_copyDDictParameters(dctx, ddict);
1447	}
1448	return 0;
1449	}
1450
1451	/*! ZSTD_getDictID_fromDict() :
1452	* Provides the dictID stored within dictionary.
1453	* if @return == 0, the dictionary is not conformant with Zstandard specification.
1454	* It can still be loaded, but as a content-only dictionary. */
1455	unsigned ZSTD_getDictID_fromDict(const void* dict, size_t dictSize)
1456	{
1457	if (dictSize < 8) return 0;
1458	if (MEM_readLE32(memPtr: dict) != ZSTD_MAGIC_DICTIONARY) return 0;
1459	return MEM_readLE32(memPtr: (const char*)dict + ZSTD_FRAMEIDSIZE);
1460	}
1461
1462	/*! ZSTD_getDictID_fromFrame() :
1463	* Provides the dictID required to decompress frame stored within `src`.
1464	* If @return == 0, the dictID could not be decoded.
1465	* This could for one of the following reasons :
1466	* - The frame does not require a dictionary (most common case).
1467	* - The frame was built with dictID intentionally removed.
1468	* Needed dictionary is a hidden information.
1469	* Note : this use case also happens when using a non-conformant dictionary.
1470	* - `srcSize` is too small, and as a result, frame header could not be decoded.
1471	* Note : possible if `srcSize < ZSTD_FRAMEHEADERSIZE_MAX`.
1472	* - This is not a Zstandard frame.
1473	* When identifying the exact failure cause, it's possible to use
1474	* ZSTD_getFrameHeader(), which will provide a more precise error code. */
1475	unsigned ZSTD_getDictID_fromFrame(const void* src, size_t srcSize)
1476	{
1477	ZSTD_frameHeader zfp = { 0, 0, 0, ZSTD_frame, 0, 0, 0 };
1478	size_t const hError = ZSTD_getFrameHeader(zfhPtr: &zfp, src, srcSize);
1479	if (ZSTD_isError(code: hError)) return 0;
1480	return zfp.dictID;
1481	}
1482
1483
1484	/*! ZSTD_decompress_usingDDict() :
1485	* Decompression using a pre-digested Dictionary
1486	* Use dictionary without significant overhead. */
1487	size_t ZSTD_decompress_usingDDict(ZSTD_DCtx* dctx,
1488	void* dst, size_t dstCapacity,
1489	const void* src, size_t srcSize,
1490	const ZSTD_DDict* ddict)
1491	{
1492	/* pass content and size in case legacy frames are encountered */
1493	return ZSTD_decompressMultiFrame(dctx, dst, dstCapacity, src, srcSize,
1494	NULL, dictSize: 0,
1495	ddict);
1496	}
1497
1498
1499	/*=====================================
1500	* Streaming decompression
1501	*====================================*/
1502
1503	ZSTD_DStream* ZSTD_createDStream(void)
1504	{
1505	DEBUGLOG(3, "ZSTD_createDStream");
1506	return ZSTD_createDCtx_internal(customMem: ZSTD_defaultCMem);
1507	}
1508
1509	ZSTD_DStream* ZSTD_initStaticDStream(void *workspace, size_t workspaceSize)
1510	{
1511	return ZSTD_initStaticDCtx(workspace, workspaceSize);
1512	}
1513
1514	ZSTD_DStream* ZSTD_createDStream_advanced(ZSTD_customMem customMem)
1515	{
1516	return ZSTD_createDCtx_internal(customMem);
1517	}
1518
1519	size_t ZSTD_freeDStream(ZSTD_DStream* zds)
1520	{
1521	return ZSTD_freeDCtx(dctx: zds);
1522	}
1523
1524
1525	/* *** Initialization *** */
1526
1527	size_t ZSTD_DStreamInSize(void) { return ZSTD_BLOCKSIZE_MAX + ZSTD_blockHeaderSize; }
1528	size_t ZSTD_DStreamOutSize(void) { return ZSTD_BLOCKSIZE_MAX; }
1529
1530	size_t ZSTD_DCtx_loadDictionary_advanced(ZSTD_DCtx* dctx,
1531	const void* dict, size_t dictSize,
1532	ZSTD_dictLoadMethod_e dictLoadMethod,
1533	ZSTD_dictContentType_e dictContentType)
1534	{
1535	RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
1536	ZSTD_clearDict(dctx);
1537	if (dict && dictSize != 0) {
1538	dctx->ddictLocal = ZSTD_createDDict_advanced(dict, dictSize, dictLoadMethod, dictContentType, customMem: dctx->customMem);
1539	RETURN_ERROR_IF(dctx->ddictLocal == NULL, memory_allocation, "NULL pointer!");
1540	dctx->ddict = dctx->ddictLocal;
1541	dctx->dictUses = ZSTD_use_indefinitely;
1542	}
1543	return 0;
1544	}
1545
1546	size_t ZSTD_DCtx_loadDictionary_byReference(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
1547	{
1548	return ZSTD_DCtx_loadDictionary_advanced(dctx, dict, dictSize, dictLoadMethod: ZSTD_dlm_byRef, dictContentType: ZSTD_dct_auto);
1549	}
1550
1551	size_t ZSTD_DCtx_loadDictionary(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
1552	{
1553	return ZSTD_DCtx_loadDictionary_advanced(dctx, dict, dictSize, dictLoadMethod: ZSTD_dlm_byCopy, dictContentType: ZSTD_dct_auto);
1554	}
1555
1556	size_t ZSTD_DCtx_refPrefix_advanced(ZSTD_DCtx* dctx, const void* prefix, size_t prefixSize, ZSTD_dictContentType_e dictContentType)
1557	{
1558	FORWARD_IF_ERROR(ZSTD_DCtx_loadDictionary_advanced(dctx, prefix, prefixSize, ZSTD_dlm_byRef, dictContentType), "");
1559	dctx->dictUses = ZSTD_use_once;
1560	return 0;
1561	}
1562
1563	size_t ZSTD_DCtx_refPrefix(ZSTD_DCtx* dctx, const void* prefix, size_t prefixSize)
1564	{
1565	return ZSTD_DCtx_refPrefix_advanced(dctx, prefix, prefixSize, dictContentType: ZSTD_dct_rawContent);
1566	}
1567
1568
1569	/* ZSTD_initDStream_usingDict() :
1570	* return : expected size, aka ZSTD_startingInputLength().
1571	* this function cannot fail */
1572	size_t ZSTD_initDStream_usingDict(ZSTD_DStream* zds, const void* dict, size_t dictSize)
1573	{
1574	DEBUGLOG(4, "ZSTD_initDStream_usingDict");
1575	FORWARD_IF_ERROR( ZSTD_DCtx_reset(zds, ZSTD_reset_session_only) , "");
1576	FORWARD_IF_ERROR( ZSTD_DCtx_loadDictionary(zds, dict, dictSize) , "");
1577	return ZSTD_startingInputLength(format: zds->format);
1578	}
1579
1580	/* note : this variant can't fail */
1581	size_t ZSTD_initDStream(ZSTD_DStream* zds)
1582	{
1583	DEBUGLOG(4, "ZSTD_initDStream");
1584	return ZSTD_initDStream_usingDDict(zds, NULL);
1585	}
1586
1587	/* ZSTD_initDStream_usingDDict() :
1588	* ddict will just be referenced, and must outlive decompression session
1589	* this function cannot fail */
1590	size_t ZSTD_initDStream_usingDDict(ZSTD_DStream* dctx, const ZSTD_DDict* ddict)
1591	{
1592	FORWARD_IF_ERROR( ZSTD_DCtx_reset(dctx, ZSTD_reset_session_only) , "");
1593	FORWARD_IF_ERROR( ZSTD_DCtx_refDDict(dctx, ddict) , "");
1594	return ZSTD_startingInputLength(format: dctx->format);
1595	}
1596
1597	/* ZSTD_resetDStream() :
1598	* return : expected size, aka ZSTD_startingInputLength().
1599	* this function cannot fail */
1600	size_t ZSTD_resetDStream(ZSTD_DStream* dctx)
1601	{
1602	FORWARD_IF_ERROR(ZSTD_DCtx_reset(dctx, ZSTD_reset_session_only), "");
1603	return ZSTD_startingInputLength(format: dctx->format);
1604	}
1605
1606
1607	size_t ZSTD_DCtx_refDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict)
1608	{
1609	RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
1610	ZSTD_clearDict(dctx);
1611	if (ddict) {
1612	dctx->ddict = ddict;
1613	dctx->dictUses = ZSTD_use_indefinitely;
1614	if (dctx->refMultipleDDicts == ZSTD_rmd_refMultipleDDicts) {
1615	if (dctx->ddictSet == NULL) {
1616	dctx->ddictSet = ZSTD_createDDictHashSet(customMem: dctx->customMem);
1617	if (!dctx->ddictSet) {
1618	RETURN_ERROR(memory_allocation, "Failed to allocate memory for hash set!");
1619	}
1620	}
1621	assert(!dctx->staticSize); /* Impossible: ddictSet cannot have been allocated if static dctx */
1622	FORWARD_IF_ERROR(ZSTD_DDictHashSet_addDDict(dctx->ddictSet, ddict, dctx->customMem), "");
1623	}
1624	}
1625	return 0;
1626	}
1627
1628	/* ZSTD_DCtx_setMaxWindowSize() :
1629	* note : no direct equivalence in ZSTD_DCtx_setParameter,
1630	* since this version sets windowSize, and the other sets windowLog */
1631	size_t ZSTD_DCtx_setMaxWindowSize(ZSTD_DCtx* dctx, size_t maxWindowSize)
1632	{
1633	ZSTD_bounds const bounds = ZSTD_dParam_getBounds(dParam: ZSTD_d_windowLogMax);
1634	size_t const min = (size_t)1 << bounds.lowerBound;
1635	size_t const max = (size_t)1 << bounds.upperBound;
1636	RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
1637	RETURN_ERROR_IF(maxWindowSize < min, parameter_outOfBound, "");
1638	RETURN_ERROR_IF(maxWindowSize > max, parameter_outOfBound, "");
1639	dctx->maxWindowSize = maxWindowSize;
1640	return 0;
1641	}
1642
1643	size_t ZSTD_DCtx_setFormat(ZSTD_DCtx* dctx, ZSTD_format_e format)
1644	{
1645	return ZSTD_DCtx_setParameter(dctx, ZSTD_d_format, value: (int)format);
1646	}
1647
1648	ZSTD_bounds ZSTD_dParam_getBounds(ZSTD_dParameter dParam)
1649	{
1650	ZSTD_bounds bounds = { 0, 0, 0 };
1651	switch(dParam) {
1652	case ZSTD_d_windowLogMax:
1653	bounds.lowerBound = ZSTD_WINDOWLOG_ABSOLUTEMIN;
1654	bounds.upperBound = ZSTD_WINDOWLOG_MAX;
1655	return bounds;
1656	case ZSTD_d_format:
1657	bounds.lowerBound = (int)ZSTD_f_zstd1;
1658	bounds.upperBound = (int)ZSTD_f_zstd1_magicless;
1659	ZSTD_STATIC_ASSERT(ZSTD_f_zstd1 < ZSTD_f_zstd1_magicless);
1660	return bounds;
1661	case ZSTD_d_stableOutBuffer:
1662	bounds.lowerBound = (int)ZSTD_bm_buffered;
1663	bounds.upperBound = (int)ZSTD_bm_stable;
1664	return bounds;
1665	case ZSTD_d_forceIgnoreChecksum:
1666	bounds.lowerBound = (int)ZSTD_d_validateChecksum;
1667	bounds.upperBound = (int)ZSTD_d_ignoreChecksum;
1668	return bounds;
1669	case ZSTD_d_refMultipleDDicts:
1670	bounds.lowerBound = (int)ZSTD_rmd_refSingleDDict;
1671	bounds.upperBound = (int)ZSTD_rmd_refMultipleDDicts;
1672	return bounds;
1673	default:;
1674	}
1675	bounds.error = ERROR(parameter_unsupported);
1676	return bounds;
1677	}
1678
1679	/* ZSTD_dParam_withinBounds:
1680	* @return 1 if value is within dParam bounds,
1681	* 0 otherwise */
1682	static int ZSTD_dParam_withinBounds(ZSTD_dParameter dParam, int value)
1683	{
1684	ZSTD_bounds const bounds = ZSTD_dParam_getBounds(dParam);
1685	if (ZSTD_isError(code: bounds.error)) return 0;
1686	if (value < bounds.lowerBound) return 0;
1687	if (value > bounds.upperBound) return 0;
1688	return 1;
1689	}
1690
1691	#define CHECK_DBOUNDS(p,v) { \
1692	RETURN_ERROR_IF(!ZSTD_dParam_withinBounds(p, v), parameter_outOfBound, ""); \
1693	}
1694
1695	size_t ZSTD_DCtx_getParameter(ZSTD_DCtx* dctx, ZSTD_dParameter param, int* value)
1696	{
1697	switch (param) {
1698	case ZSTD_d_windowLogMax:
1699	*value = (int)ZSTD_highbit32(val: (U32)dctx->maxWindowSize);
1700	return 0;
1701	case ZSTD_d_format:
1702	*value = (int)dctx->format;
1703	return 0;
1704	case ZSTD_d_stableOutBuffer:
1705	*value = (int)dctx->outBufferMode;
1706	return 0;
1707	case ZSTD_d_forceIgnoreChecksum:
1708	*value = (int)dctx->forceIgnoreChecksum;
1709	return 0;
1710	case ZSTD_d_refMultipleDDicts:
1711	*value = (int)dctx->refMultipleDDicts;
1712	return 0;
1713	default:;
1714	}
1715	RETURN_ERROR(parameter_unsupported, "");
1716	}
1717
1718	size_t ZSTD_DCtx_setParameter(ZSTD_DCtx* dctx, ZSTD_dParameter dParam, int value)
1719	{
1720	RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
1721	switch(dParam) {
1722	case ZSTD_d_windowLogMax:
1723	if (value == 0) value = ZSTD_WINDOWLOG_LIMIT_DEFAULT;
1724	CHECK_DBOUNDS(ZSTD_d_windowLogMax, value);
1725	dctx->maxWindowSize = ((size_t)1) << value;
1726	return 0;
1727	case ZSTD_d_format:
1728	CHECK_DBOUNDS(ZSTD_d_format, value);
1729	dctx->format = (ZSTD_format_e)value;
1730	return 0;
1731	case ZSTD_d_stableOutBuffer:
1732	CHECK_DBOUNDS(ZSTD_d_stableOutBuffer, value);
1733	dctx->outBufferMode = (ZSTD_bufferMode_e)value;
1734	return 0;
1735	case ZSTD_d_forceIgnoreChecksum:
1736	CHECK_DBOUNDS(ZSTD_d_forceIgnoreChecksum, value);
1737	dctx->forceIgnoreChecksum = (ZSTD_forceIgnoreChecksum_e)value;
1738	return 0;
1739	case ZSTD_d_refMultipleDDicts:
1740	CHECK_DBOUNDS(ZSTD_d_refMultipleDDicts, value);
1741	if (dctx->staticSize != 0) {
1742	RETURN_ERROR(parameter_unsupported, "Static dctx does not support multiple DDicts!");
1743	}
1744	dctx->refMultipleDDicts = (ZSTD_refMultipleDDicts_e)value;
1745	return 0;
1746	default:;
1747	}
1748	RETURN_ERROR(parameter_unsupported, "");
1749	}
1750
1751	size_t ZSTD_DCtx_reset(ZSTD_DCtx* dctx, ZSTD_ResetDirective reset)
1752	{
1753	if ( (reset == ZSTD_reset_session_only)
1754	|| (reset == ZSTD_reset_session_and_parameters) ) {
1755	dctx->streamStage = zdss_init;
1756	dctx->noForwardProgress = 0;
1757	}
1758	if ( (reset == ZSTD_reset_parameters)
1759	|| (reset == ZSTD_reset_session_and_parameters) ) {
1760	RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
1761	ZSTD_clearDict(dctx);
1762	ZSTD_DCtx_resetParameters(dctx);
1763	}
1764	return 0;
1765	}
1766
1767
1768	size_t ZSTD_sizeof_DStream(const ZSTD_DStream* dctx)
1769	{
1770	return ZSTD_sizeof_DCtx(dctx);
1771	}
1772
1773	size_t ZSTD_decodingBufferSize_min(unsigned long long windowSize, unsigned long long frameContentSize)
1774	{
1775	size_t const blockSize = (size_t) MIN(windowSize, ZSTD_BLOCKSIZE_MAX);
1776	/* space is needed to store the litbuffer after the output of a given block without stomping the extDict of a previous run, as well as to cover both windows against wildcopy*/
1777	unsigned long long const neededRBSize = windowSize + blockSize + ZSTD_BLOCKSIZE_MAX + (WILDCOPY_OVERLENGTH * 2);
1778	unsigned long long const neededSize = MIN(frameContentSize, neededRBSize);
1779	size_t const minRBSize = (size_t) neededSize;
1780	RETURN_ERROR_IF((unsigned long long)minRBSize != neededSize,
1781	frameParameter_windowTooLarge, "");
1782	return minRBSize;
1783	}
1784
1785	size_t ZSTD_estimateDStreamSize(size_t windowSize)
1786	{
1787	size_t const blockSize = MIN(windowSize, ZSTD_BLOCKSIZE_MAX);
1788	size_t const inBuffSize = blockSize; /* no block can be larger */
1789	size_t const outBuffSize = ZSTD_decodingBufferSize_min(windowSize, ZSTD_CONTENTSIZE_UNKNOWN);
1790	return ZSTD_estimateDCtxSize() + inBuffSize + outBuffSize;
1791	}
1792
1793	size_t ZSTD_estimateDStreamSize_fromFrame(const void* src, size_t srcSize)
1794	{
1795	U32 const windowSizeMax = 1U << ZSTD_WINDOWLOG_MAX; /* note : should be user-selectable, but requires an additional parameter (or a dctx) */
1796	ZSTD_frameHeader zfh;
1797	size_t const err = ZSTD_getFrameHeader(zfhPtr: &zfh, src, srcSize);
1798	if (ZSTD_isError(code: err)) return err;
1799	RETURN_ERROR_IF(err>0, srcSize_wrong, "");
1800	RETURN_ERROR_IF(zfh.windowSize > windowSizeMax,
1801	frameParameter_windowTooLarge, "");
1802	return ZSTD_estimateDStreamSize(windowSize: (size_t)zfh.windowSize);
1803	}
1804
1805
1806	/* ***** Decompression ***** */
1807
1808	static int ZSTD_DCtx_isOverflow(ZSTD_DStream* zds, size_t const neededInBuffSize, size_t const neededOutBuffSize)
1809	{
1810	return (zds->inBuffSize + zds->outBuffSize) >= (neededInBuffSize + neededOutBuffSize) * ZSTD_WORKSPACETOOLARGE_FACTOR;
1811	}
1812
1813	static void ZSTD_DCtx_updateOversizedDuration(ZSTD_DStream* zds, size_t const neededInBuffSize, size_t const neededOutBuffSize)
1814	{
1815	if (ZSTD_DCtx_isOverflow(zds, neededInBuffSize, neededOutBuffSize))
1816	zds->oversizedDuration++;
1817	else
1818	zds->oversizedDuration = 0;
1819	}
1820
1821	static int ZSTD_DCtx_isOversizedTooLong(ZSTD_DStream* zds)
1822	{
1823	return zds->oversizedDuration >= ZSTD_WORKSPACETOOLARGE_MAXDURATION;
1824	}
1825
1826	/* Checks that the output buffer hasn't changed if ZSTD_obm_stable is used. */
1827	static size_t ZSTD_checkOutBuffer(ZSTD_DStream const* zds, ZSTD_outBuffer const* output)
1828	{
1829	ZSTD_outBuffer const expect = zds->expectedOutBuffer;
1830	/* No requirement when ZSTD_obm_stable is not enabled. */
1831	if (zds->outBufferMode != ZSTD_bm_stable)
1832	return 0;
1833	/* Any buffer is allowed in zdss_init, this must be the same for every other call until
1834	* the context is reset.
1835	*/
1836	if (zds->streamStage == zdss_init)
1837	return 0;
1838	/* The buffer must match our expectation exactly. */
1839	if (expect.dst == output->dst && expect.pos == output->pos && expect.size == output->size)
1840	return 0;
1841	RETURN_ERROR(dstBuffer_wrong, "ZSTD_d_stableOutBuffer enabled but output differs!");
1842	}
1843
1844	/* Calls ZSTD_decompressContinue() with the right parameters for ZSTD_decompressStream()
1845	* and updates the stage and the output buffer state. This call is extracted so it can be
1846	* used both when reading directly from the ZSTD_inBuffer, and in buffered input mode.
1847	* NOTE: You must break after calling this function since the streamStage is modified.
1848	*/
1849	static size_t ZSTD_decompressContinueStream(
1850	ZSTD_DStream* zds, char** op, char* oend,
1851	void const* src, size_t srcSize) {
1852	int const isSkipFrame = ZSTD_isSkipFrame(dctx: zds);
1853	if (zds->outBufferMode == ZSTD_bm_buffered) {
1854	size_t const dstSize = isSkipFrame ? 0 : zds->outBuffSize - zds->outStart;
1855	size_t const decodedSize = ZSTD_decompressContinue(dctx: zds,
1856	dst: zds->outBuff + zds->outStart, dstCapacity: dstSize, src, srcSize);
1857	FORWARD_IF_ERROR(decodedSize, "");
1858	if (!decodedSize && !isSkipFrame) {
1859	zds->streamStage = zdss_read;
1860	} else {
1861	zds->outEnd = zds->outStart + decodedSize;
1862	zds->streamStage = zdss_flush;
1863	}
1864	} else {
1865	/* Write directly into the output buffer */
1866	size_t const dstSize = isSkipFrame ? 0 : (size_t)(oend - *op);
1867	size_t const decodedSize = ZSTD_decompressContinue(dctx: zds, dst: *op, dstCapacity: dstSize, src, srcSize);
1868	FORWARD_IF_ERROR(decodedSize, "");
1869	*op += decodedSize;
1870	/* Flushing is not needed. */
1871	zds->streamStage = zdss_read;
1872	assert(*op <= oend);
1873	assert(zds->outBufferMode == ZSTD_bm_stable);
1874	}
1875	return 0;
1876	}
1877
1878	size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inBuffer* input)
1879	{
1880	const char* const src = (const char*)input->src;
1881	const char* const istart = input->pos != 0 ? src + input->pos : src;
1882	const char* const iend = input->size != 0 ? src + input->size : src;
1883	const char* ip = istart;
1884	char* const dst = (char*)output->dst;
1885	char* const ostart = output->pos != 0 ? dst + output->pos : dst;
1886	char* const oend = output->size != 0 ? dst + output->size : dst;
1887	char* op = ostart;
1888	U32 someMoreWork = 1;
1889
1890	DEBUGLOG(5, "ZSTD_decompressStream");
1891	RETURN_ERROR_IF(
1892	input->pos > input->size,
1893	srcSize_wrong,
1894	"forbidden. in: pos: %u vs size: %u",
1895	(U32)input->pos, (U32)input->size);
1896	RETURN_ERROR_IF(
1897	output->pos > output->size,
1898	dstSize_tooSmall,
1899	"forbidden. out: pos: %u vs size: %u",
1900	(U32)output->pos, (U32)output->size);
1901	DEBUGLOG(5, "input size : %u", (U32)(input->size - input->pos));
1902	FORWARD_IF_ERROR(ZSTD_checkOutBuffer(zds, output), "");
1903
1904	while (someMoreWork) {
1905	switch(zds->streamStage)
1906	{
1907	case zdss_init :
1908	DEBUGLOG(5, "stage zdss_init => transparent reset ");
1909	zds->streamStage = zdss_loadHeader;
1910	zds->lhSize = zds->inPos = zds->outStart = zds->outEnd = 0;
1911	zds->hostageByte = 0;
1912	zds->expectedOutBuffer = *output;
1913	ZSTD_FALLTHROUGH;
1914
1915	case zdss_loadHeader :
1916	DEBUGLOG(5, "stage zdss_loadHeader (srcSize : %u)", (U32)(iend - ip));
1917	{ size_t const hSize = ZSTD_getFrameHeader_advanced(zfhPtr: &zds->fParams, src: zds->headerBuffer, srcSize: zds->lhSize, format: zds->format);
1918	if (zds->refMultipleDDicts && zds->ddictSet) {
1919	ZSTD_DCtx_selectFrameDDict(dctx: zds);
1920	}
1921	DEBUGLOG(5, "header size : %u", (U32)hSize);
1922	if (ZSTD_isError(code: hSize)) {
1923	return hSize; /* error */
1924	}
1925	if (hSize != 0) { /* need more input */
1926	size_t const toLoad = hSize - zds->lhSize; /* if hSize!=0, hSize > zds->lhSize */
1927	size_t const remainingInput = (size_t)(iend-ip);
1928	assert(iend >= ip);
1929	if (toLoad > remainingInput) { /* not enough input to load full header */
1930	if (remainingInput > 0) {
1931	ZSTD_memcpy(zds->headerBuffer + zds->lhSize, ip, remainingInput);
1932	zds->lhSize += remainingInput;
1933	}
1934	input->pos = input->size;
1935	return (MAX((size_t)ZSTD_FRAMEHEADERSIZE_MIN(zds->format), hSize) - zds->lhSize) + ZSTD_blockHeaderSize; /* remaining header bytes + next block header */
1936	}
1937	assert(ip != NULL);
1938	ZSTD_memcpy(zds->headerBuffer + zds->lhSize, ip, toLoad); zds->lhSize = hSize; ip += toLoad;
1939	break;
1940	} }
1941
1942	/* check for single-pass mode opportunity */
1943	if (zds->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN
1944	&& zds->fParams.frameType != ZSTD_skippableFrame
1945	&& (U64)(size_t)(oend-op) >= zds->fParams.frameContentSize) {
1946	size_t const cSize = ZSTD_findFrameCompressedSize(src: istart, srcSize: (size_t)(iend-istart));
1947	if (cSize <= (size_t)(iend-istart)) {
1948	/* shortcut : using single-pass mode */
1949	size_t const decompressedSize = ZSTD_decompress_usingDDict(dctx: zds, dst: op, dstCapacity: (size_t)(oend-op), src: istart, srcSize: cSize, ddict: ZSTD_getDDict(dctx: zds));
1950	if (ZSTD_isError(code: decompressedSize)) return decompressedSize;
1951	DEBUGLOG(4, "shortcut to single-pass ZSTD_decompress_usingDDict()")
1952	ip = istart + cSize;
1953	op += decompressedSize;
1954	zds->expected = 0;
1955	zds->streamStage = zdss_init;
1956	someMoreWork = 0;
1957	break;
1958	} }
1959
1960	/* Check output buffer is large enough for ZSTD_odm_stable. */
1961	if (zds->outBufferMode == ZSTD_bm_stable
1962	&& zds->fParams.frameType != ZSTD_skippableFrame
1963	&& zds->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN
1964	&& (U64)(size_t)(oend-op) < zds->fParams.frameContentSize) {
1965	RETURN_ERROR(dstSize_tooSmall, "ZSTD_obm_stable passed but ZSTD_outBuffer is too small");
1966	}
1967
1968	/* Consume header (see ZSTDds_decodeFrameHeader) */
1969	DEBUGLOG(4, "Consume header");
1970	FORWARD_IF_ERROR(ZSTD_decompressBegin_usingDDict(zds, ZSTD_getDDict(zds)), "");
1971
1972	if ((MEM_readLE32(memPtr: zds->headerBuffer) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) { /* skippable frame */
1973	zds->expected = MEM_readLE32(memPtr: zds->headerBuffer + ZSTD_FRAMEIDSIZE);
1974	zds->stage = ZSTDds_skipFrame;
1975	} else {
1976	FORWARD_IF_ERROR(ZSTD_decodeFrameHeader(zds, zds->headerBuffer, zds->lhSize), "");
1977	zds->expected = ZSTD_blockHeaderSize;
1978	zds->stage = ZSTDds_decodeBlockHeader;
1979	}
1980
1981	/* control buffer memory usage */
1982	DEBUGLOG(4, "Control max memory usage (%u KB <= max %u KB)",
1983	(U32)(zds->fParams.windowSize >>10),
1984	(U32)(zds->maxWindowSize >> 10) );
1985	zds->fParams.windowSize = MAX(zds->fParams.windowSize, 1U << ZSTD_WINDOWLOG_ABSOLUTEMIN);
1986	RETURN_ERROR_IF(zds->fParams.windowSize > zds->maxWindowSize,
1987	frameParameter_windowTooLarge, "");
1988
1989	/* Adapt buffer sizes to frame header instructions */
1990	{ size_t const neededInBuffSize = MAX(zds->fParams.blockSizeMax, 4 /* frame checksum */);
1991	size_t const neededOutBuffSize = zds->outBufferMode == ZSTD_bm_buffered
1992	? ZSTD_decodingBufferSize_min(windowSize: zds->fParams.windowSize, frameContentSize: zds->fParams.frameContentSize)
1993	: 0;
1994
1995	ZSTD_DCtx_updateOversizedDuration(zds, neededInBuffSize, neededOutBuffSize);
1996
1997	{ int const tooSmall = (zds->inBuffSize < neededInBuffSize) || (zds->outBuffSize < neededOutBuffSize);
1998	int const tooLarge = ZSTD_DCtx_isOversizedTooLong(zds);
1999
2000	if (tooSmall || tooLarge) {
2001	size_t const bufferSize = neededInBuffSize + neededOutBuffSize;
2002	DEBUGLOG(4, "inBuff : from %u to %u",
2003	(U32)zds->inBuffSize, (U32)neededInBuffSize);
2004	DEBUGLOG(4, "outBuff : from %u to %u",
2005	(U32)zds->outBuffSize, (U32)neededOutBuffSize);
2006	if (zds->staticSize) { /* static DCtx */
2007	DEBUGLOG(4, "staticSize : %u", (U32)zds->staticSize);
2008	assert(zds->staticSize >= sizeof(ZSTD_DCtx)); /* controlled at init */
2009	RETURN_ERROR_IF(
2010	bufferSize > zds->staticSize - sizeof(ZSTD_DCtx),
2011	memory_allocation, "");
2012	} else {
2013	ZSTD_customFree(ptr: zds->inBuff, customMem: zds->customMem);
2014	zds->inBuffSize = 0;
2015	zds->outBuffSize = 0;
2016	zds->inBuff = (char*)ZSTD_customMalloc(size: bufferSize, customMem: zds->customMem);
2017	RETURN_ERROR_IF(zds->inBuff == NULL, memory_allocation, "");
2018	}
2019	zds->inBuffSize = neededInBuffSize;
2020	zds->outBuff = zds->inBuff + zds->inBuffSize;
2021	zds->outBuffSize = neededOutBuffSize;
2022	} } }
2023	zds->streamStage = zdss_read;
2024	ZSTD_FALLTHROUGH;
2025
2026	case zdss_read:
2027	DEBUGLOG(5, "stage zdss_read");
2028	{ size_t const neededInSize = ZSTD_nextSrcSizeToDecompressWithInputSize(dctx: zds, inputSize: (size_t)(iend - ip));
2029	DEBUGLOG(5, "neededInSize = %u", (U32)neededInSize);
2030	if (neededInSize==0) { /* end of frame */
2031	zds->streamStage = zdss_init;
2032	someMoreWork = 0;
2033	break;
2034	}
2035	if ((size_t)(iend-ip) >= neededInSize) { /* decode directly from src */
2036	FORWARD_IF_ERROR(ZSTD_decompressContinueStream(zds, &op, oend, ip, neededInSize), "");
2037	ip += neededInSize;
2038	/* Function modifies the stage so we must break */
2039	break;
2040	} }
2041	if (ip==iend) { someMoreWork = 0; break; } /* no more input */
2042	zds->streamStage = zdss_load;
2043	ZSTD_FALLTHROUGH;
2044
2045	case zdss_load:
2046	{ size_t const neededInSize = ZSTD_nextSrcSizeToDecompress(dctx: zds);
2047	size_t const toLoad = neededInSize - zds->inPos;
2048	int const isSkipFrame = ZSTD_isSkipFrame(dctx: zds);
2049	size_t loadedSize;
2050	/* At this point we shouldn't be decompressing a block that we can stream. */
2051	assert(neededInSize == ZSTD_nextSrcSizeToDecompressWithInputSize(zds, iend - ip));
2052	if (isSkipFrame) {
2053	loadedSize = MIN(toLoad, (size_t)(iend-ip));
2054	} else {
2055	RETURN_ERROR_IF(toLoad > zds->inBuffSize - zds->inPos,
2056	corruption_detected,
2057	"should never happen");
2058	loadedSize = ZSTD_limitCopy(dst: zds->inBuff + zds->inPos, dstCapacity: toLoad, src: ip, srcSize: (size_t)(iend-ip));
2059	}
2060	ip += loadedSize;
2061	zds->inPos += loadedSize;
2062	if (loadedSize < toLoad) { someMoreWork = 0; break; } /* not enough input, wait for more */
2063
2064	/* decode loaded input */
2065	zds->inPos = 0; /* input is consumed */
2066	FORWARD_IF_ERROR(ZSTD_decompressContinueStream(zds, &op, oend, zds->inBuff, neededInSize), "");
2067	/* Function modifies the stage so we must break */
2068	break;
2069	}
2070	case zdss_flush:
2071	{ size_t const toFlushSize = zds->outEnd - zds->outStart;
2072	size_t const flushedSize = ZSTD_limitCopy(dst: op, dstCapacity: (size_t)(oend-op), src: zds->outBuff + zds->outStart, srcSize: toFlushSize);
2073	op += flushedSize;
2074	zds->outStart += flushedSize;
2075	if (flushedSize == toFlushSize) { /* flush completed */
2076	zds->streamStage = zdss_read;
2077	if ( (zds->outBuffSize < zds->fParams.frameContentSize)
2078	&& (zds->outStart + zds->fParams.blockSizeMax > zds->outBuffSize) ) {
2079	DEBUGLOG(5, "restart filling outBuff from beginning (left:%i, needed:%u)",
2080	(int)(zds->outBuffSize - zds->outStart),
2081	(U32)zds->fParams.blockSizeMax);
2082	zds->outStart = zds->outEnd = 0;
2083	}
2084	break;
2085	} }
2086	/* cannot complete flush */
2087	someMoreWork = 0;
2088	break;
2089
2090	default:
2091	assert(0); /* impossible */
2092	RETURN_ERROR(GENERIC, "impossible to reach"); /* some compiler require default to do something */
2093	} }
2094
2095	/* result */
2096	input->pos = (size_t)(ip - (const char*)(input->src));
2097	output->pos = (size_t)(op - (char*)(output->dst));
2098
2099	/* Update the expected output buffer for ZSTD_obm_stable. */
2100	zds->expectedOutBuffer = *output;
2101
2102	if ((ip==istart) && (op==ostart)) { /* no forward progress */
2103	zds->noForwardProgress ++;
2104	if (zds->noForwardProgress >= ZSTD_NO_FORWARD_PROGRESS_MAX) {
2105	RETURN_ERROR_IF(op==oend, dstSize_tooSmall, "");
2106	RETURN_ERROR_IF(ip==iend, srcSize_wrong, "");
2107	assert(0);
2108	}
2109	} else {
2110	zds->noForwardProgress = 0;
2111	}
2112	{ size_t nextSrcSizeHint = ZSTD_nextSrcSizeToDecompress(dctx: zds);
2113	if (!nextSrcSizeHint) { /* frame fully decoded */
2114	if (zds->outEnd == zds->outStart) { /* output fully flushed */
2115	if (zds->hostageByte) {
2116	if (input->pos >= input->size) {
2117	/* can't release hostage (not present) */
2118	zds->streamStage = zdss_read;
2119	return 1;
2120	}
2121	input->pos++; /* release hostage */
2122	} /* zds->hostageByte */
2123	return 0;
2124	} /* zds->outEnd == zds->outStart */
2125	if (!zds->hostageByte) { /* output not fully flushed; keep last byte as hostage; will be released when all output is flushed */
2126	input->pos--; /* note : pos > 0, otherwise, impossible to finish reading last block */
2127	zds->hostageByte=1;
2128	}
2129	return 1;
2130	} /* nextSrcSizeHint==0 */
2131	nextSrcSizeHint += ZSTD_blockHeaderSize * (ZSTD_nextInputType(dctx: zds) == ZSTDnit_block); /* preload header of next block */
2132	assert(zds->inPos <= nextSrcSizeHint);
2133	nextSrcSizeHint -= zds->inPos; /* part already loaded*/
2134	return nextSrcSizeHint;
2135	}
2136	}
2137
2138	size_t ZSTD_decompressStream_simpleArgs (
2139	ZSTD_DCtx* dctx,
2140	void* dst, size_t dstCapacity, size_t* dstPos,
2141	const void* src, size_t srcSize, size_t* srcPos)
2142	{
2143	ZSTD_outBuffer output = { dst, dstCapacity, *dstPos };
2144	ZSTD_inBuffer input = { src, srcSize, *srcPos };
2145	/* ZSTD_compress_generic() will check validity of dstPos and srcPos */
2146	size_t const cErr = ZSTD_decompressStream(zds: dctx, output: &output, input: &input);
2147	*dstPos = output.pos;
2148	*srcPos = input.pos;
2149	return cErr;
2150	}
2151