Lines Matching +full:max +full:- +full:frame +full:- +full:size
1 // SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause
6 * This source code is licensed under both the BSD-style license (found in the
9 * You may select, at your option, one of the above-listed licenses.
33 * maximum window size accepted by DStream __by default__.
53 /*-*******************************************************
80 … * So, if count * COUNT_MULT / size * SIZE_MULT != 0, then we've exceeded
88 * Returns an index between [0, hashSet->ddictPtrTableSize]
92 …/* DDict ptr table size is a multiple of 2, use size - 1 as mask to get index within [0, hashSet->… in ZSTD_DDictHashSet_getIndex()
93 return hash & (hashSet->ddictPtrTableSize - 1); in ZSTD_DDictHashSet_getIndex()
103 const size_t idxRangeMask = hashSet->ddictPtrTableSize - 1; in ZSTD_DDictHashSet_emplaceDDict()
104 …RETURN_ERROR_IF(hashSet->ddictPtrCount == hashSet->ddictPtrTableSize, GENERIC, "Hash set is full!"… in ZSTD_DDictHashSet_emplaceDDict()
106 while (hashSet->ddictPtrTable[idx] != NULL) { in ZSTD_DDictHashSet_emplaceDDict()
108 if (ZSTD_getDictID_fromDDict(hashSet->ddictPtrTable[idx]) == dictID) { in ZSTD_DDictHashSet_emplaceDDict()
110 hashSet->ddictPtrTable[idx] = ddict; in ZSTD_DDictHashSet_emplaceDDict()
117 hashSet->ddictPtrTable[idx] = ddict; in ZSTD_DDictHashSet_emplaceDDict()
118 hashSet->ddictPtrCount++; in ZSTD_DDictHashSet_emplaceDDict()
127 size_t newTableSize = hashSet->ddictPtrTableSize * DDICT_HASHSET_RESIZE_FACTOR; in ZSTD_DDictHashSet_expand()
129 const ZSTD_DDict** oldTable = hashSet->ddictPtrTable; in ZSTD_DDictHashSet_expand()
130 size_t oldTableSize = hashSet->ddictPtrTableSize; in ZSTD_DDictHashSet_expand()
133 …DEBUGLOG(4, "Expanding DDict hash table! Old size: %zu new size: %zu", oldTableSize, newTableSize); in ZSTD_DDictHashSet_expand()
135 hashSet->ddictPtrTable = newTable; in ZSTD_DDictHashSet_expand()
136 hashSet->ddictPtrTableSize = newTableSize; in ZSTD_DDictHashSet_expand()
137 hashSet->ddictPtrCount = 0; in ZSTD_DDictHashSet_expand()
144 DEBUGLOG(4, "Finished re-hash"); in ZSTD_DDictHashSet_expand()
153 const size_t idxRangeMask = hashSet->ddictPtrTableSize - 1; in ZSTD_DDictHashSet_getDDict()
156 size_t currDictID = ZSTD_getDictID_fromDDict(hashSet->ddictPtrTable[idx]); in ZSTD_DDictHashSet_getDDict()
166 return hashSet->ddictPtrTable[idx]; in ZSTD_DDictHashSet_getDDict()
178 …ret->ddictPtrTable = (const ZSTD_DDict**)ZSTD_customCalloc(DDICT_HASHSET_TABLE_BASE_SIZE * sizeof(… in ZSTD_createDDictHashSet()
179 if (!ret->ddictPtrTable) { in ZSTD_createDDictHashSet()
183 ret->ddictPtrTableSize = DDICT_HASHSET_TABLE_BASE_SIZE; in ZSTD_createDDictHashSet()
184 ret->ddictPtrCount = 0; in ZSTD_createDDictHashSet()
193 if (hashSet && hashSet->ddictPtrTable) { in ZSTD_freeDDictHashSet()
194 ZSTD_customFree((void*)hashSet->ddictPtrTable, customMem); in ZSTD_freeDDictHashSet()
205 … dict ID: %u to hashset with - Count: %zu Tablesize: %zu", ZSTD_getDictID_fromDDict(ddict), hashSe… in ZSTD_DDictHashSet_addDDict()
206 …if (hashSet->ddictPtrCount * DDICT_HASHSET_MAX_LOAD_FACTOR_COUNT_MULT / hashSet->ddictPtrTableSize… in ZSTD_DDictHashSet_addDDict()
213 /*-*************************************************************
220 + ZSTD_sizeof_DDict(dctx->ddictLocal) in ZSTD_sizeof_DCtx()
221 + dctx->inBuffSize + dctx->outBuffSize; in ZSTD_sizeof_DCtx()
237 assert(dctx->streamStage == zdss_init); in ZSTD_DCtx_resetParameters()
238 dctx->format = ZSTD_f_zstd1; in ZSTD_DCtx_resetParameters()
239 dctx->maxWindowSize = ZSTD_MAXWINDOWSIZE_DEFAULT; in ZSTD_DCtx_resetParameters()
240 dctx->outBufferMode = ZSTD_bm_buffered; in ZSTD_DCtx_resetParameters()
241 dctx->forceIgnoreChecksum = ZSTD_d_validateChecksum; in ZSTD_DCtx_resetParameters()
242 dctx->refMultipleDDicts = ZSTD_rmd_refSingleDDict; in ZSTD_DCtx_resetParameters()
243 dctx->disableHufAsm = 0; in ZSTD_DCtx_resetParameters()
244 dctx->maxBlockSizeParam = 0; in ZSTD_DCtx_resetParameters()
249 dctx->staticSize = 0; in ZSTD_initDCtx_internal()
250 dctx->ddict = NULL; in ZSTD_initDCtx_internal()
251 dctx->ddictLocal = NULL; in ZSTD_initDCtx_internal()
252 dctx->dictEnd = NULL; in ZSTD_initDCtx_internal()
253 dctx->ddictIsCold = 0; in ZSTD_initDCtx_internal()
254 dctx->dictUses = ZSTD_dont_use; in ZSTD_initDCtx_internal()
255 dctx->inBuff = NULL; in ZSTD_initDCtx_internal()
256 dctx->inBuffSize = 0; in ZSTD_initDCtx_internal()
257 dctx->outBuffSize = 0; in ZSTD_initDCtx_internal()
258 dctx->streamStage = zdss_init; in ZSTD_initDCtx_internal()
259 dctx->noForwardProgress = 0; in ZSTD_initDCtx_internal()
260 dctx->oversizedDuration = 0; in ZSTD_initDCtx_internal()
261 dctx->isFrameDecompression = 1; in ZSTD_initDCtx_internal()
263 dctx->bmi2 = ZSTD_cpuSupportsBmi2(); in ZSTD_initDCtx_internal()
265 dctx->ddictSet = NULL; in ZSTD_initDCtx_internal()
268 dctx->dictContentEndForFuzzing = NULL; in ZSTD_initDCtx_internal()
276 if ((size_t)workspace & 7) return NULL; /* 8-aligned */ in ZSTD_initStaticDCtx()
277 if (workspaceSize < sizeof(ZSTD_DCtx)) return NULL; /* minimum size */ in ZSTD_initStaticDCtx()
280 dctx->staticSize = workspaceSize; in ZSTD_initStaticDCtx()
281 dctx->inBuff = (char*)(dctx+1); in ZSTD_initStaticDCtx()
290 dctx->customMem = customMem; in ZSTD_createDCtx_internal()
309 ZSTD_freeDDict(dctx->ddictLocal); in ZSTD_clearDict()
310 dctx->ddictLocal = NULL; in ZSTD_clearDict()
311 dctx->ddict = NULL; in ZSTD_clearDict()
312 dctx->dictUses = ZSTD_dont_use; in ZSTD_clearDict()
318 RETURN_ERROR_IF(dctx->staticSize, memory_allocation, "not compatible with static DCtx"); in ZSTD_freeDCtx()
319 { ZSTD_customMem const cMem = dctx->customMem; in ZSTD_freeDCtx()
321 ZSTD_customFree(dctx->inBuff, cMem); in ZSTD_freeDCtx()
322 dctx->inBuff = NULL; in ZSTD_freeDCtx()
323 if (dctx->ddictSet) { in ZSTD_freeDCtx()
324 ZSTD_freeDDictHashSet(dctx->ddictSet, cMem); in ZSTD_freeDCtx()
325 dctx->ddictSet = NULL; in ZSTD_freeDCtx()
335 size_t const toCopy = (size_t)((char*)(&dstDCtx->inBuff) - (char*)dstDCtx); in ZSTD_copyDCtx()
339 /* Given a dctx with a digested frame params, re-selects the correct ZSTD_DDict based on
340 * the requested dict ID from the frame. If there exists a reference to the correct ZSTD_DDict, then
341 * accordingly sets the ddict to be used to decompress the frame.
343 * If no DDict is found, then no action is taken, and the ZSTD_DCtx::ddict remains as-is.
348 assert(dctx->refMultipleDDicts && dctx->ddictSet); in ZSTD_DCtx_selectFrameDDict()
349 DEBUGLOG(4, "Adjusting DDict based on requested dict ID from frame"); in ZSTD_DCtx_selectFrameDDict()
350 if (dctx->ddict) { in ZSTD_DCtx_selectFrameDDict()
351 … const ZSTD_DDict* frameDDict = ZSTD_DDictHashSet_getDDict(dctx->ddictSet, dctx->fParams.dictID); in ZSTD_DCtx_selectFrameDDict()
355 dctx->dictID = dctx->fParams.dictID; in ZSTD_DCtx_selectFrameDDict()
356 dctx->ddict = frameDDict; in ZSTD_DCtx_selectFrameDDict()
357 dctx->dictUses = ZSTD_use_indefinitely; in ZSTD_DCtx_selectFrameDDict()
363 /*-*************************************************************
364 * Frame header decoding
368 * Tells if the content of `buffer` starts with a valid Frame Identifier.
369 * Note : Frame Identifier is 4 bytes. If `size < 4`, @return will always be 0.
370 * Note 2 : Legacy Frame Identifiers are considered valid only if Legacy Support is enabled.
371 * Note 3 : Skippable Frame Identifiers are considered valid. */
372 unsigned ZSTD_isFrame(const void* buffer, size_t size) in ZSTD_isFrame() argument
374 if (size < ZSTD_FRAMEIDSIZE) return 0; in ZSTD_isFrame()
383 * Tells if the content of `buffer` starts with a valid Frame Identifier for a skippable frame.
384 * Note : Frame Identifier is 4 bytes. If `size < 4`, @return will always be 0.
386 unsigned ZSTD_isSkippableFrame(const void* buffer, size_t size) in ZSTD_isSkippableFrame() argument
388 if (size < ZSTD_FRAMEIDSIZE) return 0; in ZSTD_isSkippableFrame()
396 * srcSize must be large enough to reach header size fields.
398 * @return : size of the Frame Header
405 { BYTE const fhd = ((const BYTE*)src)[minInputSize-1]; in ZSTD_frameHeaderSize_internal()
417 * @return : size of the Frame Header,
426 * decode Frame Header, or require larger `srcSize`.
453 /* not a zstd frame : let's check if it's a skippable frame */ in ZSTD_getFrameHeader_advanced()
467 /* skippable frame */ in ZSTD_getFrameHeader_advanced()
469 return ZSTD_SKIPPABLEHEADERSIZE; /* magic number + frame length */ in ZSTD_getFrameHeader_advanced()
471 zfhPtr->frameType = ZSTD_skippableFrame; in ZSTD_getFrameHeader_advanced()
472 zfhPtr->dictID = MEM_readLE32(src) - ZSTD_MAGIC_SKIPPABLE_START; in ZSTD_getFrameHeader_advanced()
473 zfhPtr->headerSize = ZSTD_SKIPPABLEHEADERSIZE; in ZSTD_getFrameHeader_advanced()
474 zfhPtr->frameContentSize = MEM_readLE32((const char *)src + ZSTD_FRAMEIDSIZE); in ZSTD_getFrameHeader_advanced()
480 /* ensure there is enough `srcSize` to fully read/decode frame header */ in ZSTD_getFrameHeader_advanced()
483 zfhPtr->headerSize = (U32)fhsize; in ZSTD_getFrameHeader_advanced()
486 { BYTE const fhdByte = ip[minInputSize-1]; in ZSTD_getFrameHeader_advanced()
527 zfhPtr->frameType = ZSTD_frame; in ZSTD_getFrameHeader_advanced()
528 zfhPtr->frameContentSize = frameContentSize; in ZSTD_getFrameHeader_advanced()
529 zfhPtr->windowSize = windowSize; in ZSTD_getFrameHeader_advanced()
530 zfhPtr->blockSizeMax = (unsigned) MIN(windowSize, ZSTD_BLOCKSIZE_MAX); in ZSTD_getFrameHeader_advanced()
531 zfhPtr->dictID = dictID; in ZSTD_getFrameHeader_advanced()
532 zfhPtr->checksumFlag = checksumFlag; in ZSTD_getFrameHeader_advanced()
538 * decode Frame Header, or require larger `srcSize`.
550 * @return : decompressed size of the single frame pointed to be `src` if known, otherwise
551 * - ZSTD_CONTENTSIZE_UNKNOWN if the size cannot be determined
552 …* - ZSTD_CONTENTSIZE_ERROR if an error occurred (e.g. invalid magic number, srcSize too sm…
582 * Retrieves content of a skippable frame, and writes it to dst buffer.
584 …* The parameter magicVariant will receive the magicVariant that was supplied when the frame was wr…
585 * i.e. magicNumber - ZSTD_MAGIC_SKIPPABLE_START. This can be NULL if the caller is not interested
588 …urns an error if destination buffer is not large enough, or if this is not a valid skippable frame.
600 size_t skippableContentSize = skippableFrameSize - ZSTD_SKIPPABLEHEADERSIZE; in ZSTD_readSkippableFrame()
611 *magicVariant = magicNumber - ZSTD_MAGIC_SKIPPABLE_START; in ZSTD_readSkippableFrame()
620 * @return : decompressed size of the frames contained */
634 srcSize -= skippableSize; in ZSTD_findDecompressedSize()
645 /* skip to next frame */ in ZSTD_findDecompressedSize()
651 srcSize -= frameSrcSize; in ZSTD_findDecompressedSize()
662 * @return : decompressed size if known, 0 otherwise
664 - frame content is empty
665 - decompressed size field is not present in frame header
666 - frame header unknown / not supported
667 - frame header not complete (`srcSize` too small) */
677 * `headerSize` must be the size provided by ZSTD_frameHeaderSize().
682 …size_t const result = ZSTD_getFrameHeader_advanced(&(dctx->fParams), src, headerSize, dctx->format… in ZSTD_decodeFrameHeader()
686 /* Reference DDict requested by frame if dctx references multiple ddicts */ in ZSTD_decodeFrameHeader()
687 if (dctx->refMultipleDDicts == ZSTD_rmd_refMultipleDDicts && dctx->ddictSet) { in ZSTD_decodeFrameHeader()
695 RETURN_ERROR_IF(dctx->fParams.dictID && (dctx->dictID != dctx->fParams.dictID), in ZSTD_decodeFrameHeader()
698 dctx->validateChecksum = (dctx->fParams.checksumFlag && !dctx->forceIgnoreChecksum) ? 1 : 0; in ZSTD_decodeFrameHeader()
699 if (dctx->validateChecksum) xxh64_reset(&dctx->xxhState, 0); in ZSTD_decodeFrameHeader()
700 dctx->processedCSize += headerSize; in ZSTD_decodeFrameHeader()
731 /* Extract Frame Header */ in ZSTD_findFrameSizeInfo()
740 remainingSize -= zfh.headerSize; in ZSTD_findFrameSizeInfo()
753 remainingSize -= ZSTD_blockHeaderSize + cBlockSize; in ZSTD_findFrameSizeInfo()
759 /* Final frame content checksum */ in ZSTD_findFrameSizeInfo()
767 frameSizeInfo.compressedSize = (size_t)(ip - ipstart); in ZSTD_findFrameSizeInfo()
790 * `src` must point to the start of a ZSTD frame or a skippable frame
791 * `srcSize` must be at least as large as the frame contained
792 * @return : the maximum decompressed size of the compressed source
797 /* Iterate over each frame */ in ZSTD_decompressBound()
806 srcSize -= compressedSize; in ZSTD_decompressBound()
817 /* Iterate over each frame */ in ZSTD_decompressionMargin()
829 /* Add the frame header to our margin */ in ZSTD_decompressionMargin()
836 /* Compute the max block size */ in ZSTD_decompressionMargin()
837 maxBlockSize = MAX(maxBlockSize, zfh.blockSizeMax); in ZSTD_decompressionMargin()
840 /* Add the entire skippable frame size to our margin. */ in ZSTD_decompressionMargin()
846 srcSize -= compressedSize; in ZSTD_decompressionMargin()
849 /* Add the max block size back to the margin. */ in ZSTD_decompressionMargin()
855 /*-*************************************************************
856 * Frame decoding
865 dctx->previousDstEnd = (const char*)blockStart + blockSize; in ZSTD_insertBlock()
908 * to make *srcPtr progress by one frame. */
924 remainingSrcSize < ZSTD_FRAMEHEADERSIZE_MIN(dctx->format)+ZSTD_blockHeaderSize, in ZSTD_decompressFrame()
927 /* Frame Header */ in ZSTD_decompressFrame()
929 ip, ZSTD_FRAMEHEADERSIZE_PREFIX(dctx->format), dctx->format); in ZSTD_decompressFrame()
934 ip += frameHeaderSize; remainingSrcSize -= frameHeaderSize; in ZSTD_decompressFrame()
938 if (dctx->maxBlockSizeParam != 0) in ZSTD_decompressFrame()
939 … dctx->fParams.blockSizeMax = MIN(dctx->fParams.blockSizeMax, (unsigned)dctx->maxBlockSizeParam); in ZSTD_decompressFrame()
950 remainingSrcSize -= ZSTD_blockHeaderSize; in ZSTD_decompressFrame()
954 /* We are decompressing in-place. Limit the output pointer so that we in ZSTD_decompressFrame()
967 oBlockEnd = op + (ip - op); in ZSTD_decompressFrame()
973 assert(dctx->isFrameDecompression == 1); in ZSTD_decompressFrame()
974 …decodedSize = ZSTD_decompressBlock_internal(dctx, op, (size_t)(oBlockEnd-op), ip, cBlockSize, not_… in ZSTD_decompressFrame()
978 decodedSize = ZSTD_copyRawBlock(op, (size_t)(oend-op), ip, cBlockSize); in ZSTD_decompressFrame()
981 … decodedSize = ZSTD_setRleBlock(op, (size_t)(oBlockEnd-op), *ip, blockProperties.origSize); in ZSTD_decompressFrame()
989 if (dctx->validateChecksum) { in ZSTD_decompressFrame()
990 xxh64_update(&dctx->xxhState, op, decodedSize); in ZSTD_decompressFrame()
997 remainingSrcSize -= cBlockSize; in ZSTD_decompressFrame()
1001 if (dctx->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN) { in ZSTD_decompressFrame()
1002 RETURN_ERROR_IF((U64)(op-ostart) != dctx->fParams.frameContentSize, in ZSTD_decompressFrame()
1005 if (dctx->fParams.checksumFlag) { /* Frame content checksum verification */ in ZSTD_decompressFrame()
1007 if (!dctx->forceIgnoreChecksum) { in ZSTD_decompressFrame()
1008 U32 const checkCalc = (U32)xxh64_digest(&dctx->xxhState); in ZSTD_decompressFrame()
1014 remainingSrcSize -= 4; in ZSTD_decompressFrame()
1016 ZSTD_DCtx_trace_end(dctx, (U64)(op-ostart), (U64)(ip-istart), /* streaming */ 0); in ZSTD_decompressFrame()
1017 /* Allow caller to get size read */ in ZSTD_decompressFrame()
1018 …, "ZSTD_decompressFrame: decompressed frame of size %i, consuming %i bytes of input", (int)(op-ost… in ZSTD_decompressFrame()
1021 return (size_t)(op-ostart); in ZSTD_decompressFrame()
1043 while (srcSize >= ZSTD_startingInputLength(dctx->format)) { in ZSTD_decompressMultiFrame()
1046 if (dctx->format == ZSTD_f_zstd1 && srcSize >= 4) { in ZSTD_decompressMultiFrame()
1050 /* skippable frame detected : skip it */ in ZSTD_decompressMultiFrame()
1052 FORWARD_IF_ERROR(skippableSize, "invalid skippable frame"); in ZSTD_decompressMultiFrame()
1056 srcSize -= skippableSize; in ZSTD_decompressMultiFrame()
1057 continue; /* check next frame */ in ZSTD_decompressMultiFrame()
1076 "At least one frame successfully completed, " in ZSTD_decompressMultiFrame()
1079 "specifying more input bytes than size of frame(s). " in ZSTD_decompressMultiFrame()
1087 dstCapacity -= res; in ZSTD_decompressMultiFrame()
1094 return (size_t)((BYTE*)dst - (BYTE*)dststart); in ZSTD_decompressMultiFrame()
1108 switch (dctx->dictUses) { in ZSTD_getDDict()
1116 return dctx->ddict; in ZSTD_getDDict()
1118 dctx->dictUses = ZSTD_dont_use; in ZSTD_getDDict()
1119 return dctx->ddict; in ZSTD_getDDict()
1146 /*-**************************************
1150 size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx) { return dctx->expected; } in ZSTD_nextSrcSizeToDecompress()
1160 * @param inputSize - The total amount of input that the caller currently has.
1163 if (!(dctx->stage == ZSTDds_decompressBlock || dctx->stage == ZSTDds_decompressLastBlock)) in ZSTD_nextSrcSizeToDecompressWithInputSize()
1164 return dctx->expected; in ZSTD_nextSrcSizeToDecompressWithInputSize()
1165 if (dctx->bType != bt_raw) in ZSTD_nextSrcSizeToDecompressWithInputSize()
1166 return dctx->expected; in ZSTD_nextSrcSizeToDecompressWithInputSize()
1167 return BOUNDED(1, inputSize, dctx->expected); in ZSTD_nextSrcSizeToDecompressWithInputSize()
1171 switch(dctx->stage) in ZSTD_nextInputType()
1195 static int ZSTD_isSkipFrame(ZSTD_DCtx* dctx) { return dctx->stage == ZSTDds_skipFrame; } in ZSTD_isSkipFrame()
1208 dctx->processedCSize += srcSize; in ZSTD_decompressContinue()
1210 switch (dctx->stage) in ZSTD_decompressContinue()
1214 if (dctx->format == ZSTD_f_zstd1) { /* allows header */ in ZSTD_decompressContinue()
1216 …E32(src) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) { /* skippable frame */ in ZSTD_decompressContinue()
1217 ZSTD_memcpy(dctx->headerBuffer, src, srcSize); in ZSTD_decompressContinue()
1218 …dctx->expected = ZSTD_SKIPPABLEHEADERSIZE - srcSize; /* remaining to load to get full skippable f… in ZSTD_decompressContinue()
1219 dctx->stage = ZSTDds_decodeSkippableHeader; in ZSTD_decompressContinue()
1222 dctx->headerSize = ZSTD_frameHeaderSize_internal(src, srcSize, dctx->format); in ZSTD_decompressContinue()
1223 if (ZSTD_isError(dctx->headerSize)) return dctx->headerSize; in ZSTD_decompressContinue()
1224 ZSTD_memcpy(dctx->headerBuffer, src, srcSize); in ZSTD_decompressContinue()
1225 dctx->expected = dctx->headerSize - srcSize; in ZSTD_decompressContinue()
1226 dctx->stage = ZSTDds_decodeFrameHeader; in ZSTD_decompressContinue()
1231 ZSTD_memcpy(dctx->headerBuffer + (dctx->headerSize - srcSize), src, srcSize); in ZSTD_decompressContinue()
1232 FORWARD_IF_ERROR(ZSTD_decodeFrameHeader(dctx, dctx->headerBuffer, dctx->headerSize), ""); in ZSTD_decompressContinue()
1233 dctx->expected = ZSTD_blockHeaderSize; in ZSTD_decompressContinue()
1234 dctx->stage = ZSTDds_decodeBlockHeader; in ZSTD_decompressContinue()
1241 …RETURN_ERROR_IF(cBlockSize > dctx->fParams.blockSizeMax, corruption_detected, "Block Size Exceeds … in ZSTD_decompressContinue()
1242 dctx->expected = cBlockSize; in ZSTD_decompressContinue()
1243 dctx->bType = bp.blockType; in ZSTD_decompressContinue()
1244 dctx->rleSize = bp.origSize; in ZSTD_decompressContinue()
1246 dctx->stage = bp.lastBlock ? ZSTDds_decompressLastBlock : ZSTDds_decompressBlock; in ZSTD_decompressContinue()
1251 if (dctx->fParams.checksumFlag) { in ZSTD_decompressContinue()
1252 dctx->expected = 4; in ZSTD_decompressContinue()
1253 dctx->stage = ZSTDds_checkChecksum; in ZSTD_decompressContinue()
1255 dctx->expected = 0; /* end of frame */ in ZSTD_decompressContinue()
1256 dctx->stage = ZSTDds_getFrameHeaderSize; in ZSTD_decompressContinue()
1259 dctx->expected = ZSTD_blockHeaderSize; /* jump to next header */ in ZSTD_decompressContinue()
1260 dctx->stage = ZSTDds_decodeBlockHeader; in ZSTD_decompressContinue()
1269 switch(dctx->bType) in ZSTD_decompressContinue()
1273 assert(dctx->isFrameDecompression == 1); in ZSTD_decompressContinue()
1275 dctx->expected = 0; /* Streaming not supported */ in ZSTD_decompressContinue()
1278 assert(srcSize <= dctx->expected); in ZSTD_decompressContinue()
1282 dctx->expected -= rSize; in ZSTD_decompressContinue()
1285 rSize = ZSTD_setRleBlock(dst, dstCapacity, *(const BYTE*)src, dctx->rleSize); in ZSTD_decompressContinue()
1286 dctx->expected = 0; /* Streaming not supported */ in ZSTD_decompressContinue()
1293 …RETURN_ERROR_IF(rSize > dctx->fParams.blockSizeMax, corruption_detected, "Decompressed Block Size … in ZSTD_decompressContinue()
1294 DEBUGLOG(5, "ZSTD_decompressContinue: decoded size from block : %u", (unsigned)rSize); in ZSTD_decompressContinue()
1295 dctx->decodedSize += rSize; in ZSTD_decompressContinue()
1296 if (dctx->validateChecksum) xxh64_update(&dctx->xxhState, dst, rSize); in ZSTD_decompressContinue()
1297 dctx->previousDstEnd = (char*)dst + rSize; in ZSTD_decompressContinue()
1300 if (dctx->expected > 0) { in ZSTD_decompressContinue()
1304 if (dctx->stage == ZSTDds_decompressLastBlock) { /* end of frame */ in ZSTD_decompressContinue()
1305 … DEBUGLOG(4, "ZSTD_decompressContinue: decoded size from frame : %u", (unsigned)dctx->decodedSize); in ZSTD_decompressContinue()
1307 dctx->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN in ZSTD_decompressContinue()
1308 && dctx->decodedSize != dctx->fParams.frameContentSize, in ZSTD_decompressContinue()
1310 if (dctx->fParams.checksumFlag) { /* another round for frame checksum */ in ZSTD_decompressContinue()
1311 dctx->expected = 4; in ZSTD_decompressContinue()
1312 dctx->stage = ZSTDds_checkChecksum; in ZSTD_decompressContinue()
1314 … ZSTD_DCtx_trace_end(dctx, dctx->decodedSize, dctx->processedCSize, /* streaming */ 1); in ZSTD_decompressContinue()
1315 dctx->expected = 0; /* ends here */ in ZSTD_decompressContinue()
1316 dctx->stage = ZSTDds_getFrameHeaderSize; in ZSTD_decompressContinue()
1319 dctx->stage = ZSTDds_decodeBlockHeader; in ZSTD_decompressContinue()
1320 dctx->expected = ZSTD_blockHeaderSize; in ZSTD_decompressContinue()
1326 assert(srcSize == 4); /* guaranteed by dctx->expected */ in ZSTD_decompressContinue()
1328 if (dctx->validateChecksum) { in ZSTD_decompressContinue()
1329 U32 const h32 = (U32)xxh64_digest(&dctx->xxhState); in ZSTD_decompressContinue()
1334 ZSTD_DCtx_trace_end(dctx, dctx->decodedSize, dctx->processedCSize, /* streaming */ 1); in ZSTD_decompressContinue()
1335 dctx->expected = 0; in ZSTD_decompressContinue()
1336 dctx->stage = ZSTDds_getFrameHeaderSize; in ZSTD_decompressContinue()
1343 assert(dctx->format != ZSTD_f_zstd1_magicless); in ZSTD_decompressContinue()
1344 …ZSTD_memcpy(dctx->headerBuffer + (ZSTD_SKIPPABLEHEADERSIZE - srcSize), src, srcSize); /* complet… in ZSTD_decompressContinue()
1345 …dctx->expected = MEM_readLE32(dctx->headerBuffer + ZSTD_FRAMEIDSIZE); /* note : dctx->expected c… in ZSTD_decompressContinue()
1346 dctx->stage = ZSTDds_skipFrame; in ZSTD_decompressContinue()
1350 dctx->expected = 0; in ZSTD_decompressContinue()
1351 dctx->stage = ZSTDds_getFrameHeaderSize; in ZSTD_decompressContinue()
1363 dctx->dictEnd = dctx->previousDstEnd; in ZSTD_refDictContent()
1364 …dctx->virtualStart = (const char*)dict - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx… in ZSTD_refDictContent()
1365 dctx->prefixStart = dict; in ZSTD_refDictContent()
1366 dctx->previousDstEnd = (const char*)dict + dictSize; in ZSTD_refDictContent()
1368 dctx->dictContentBeginForFuzzing = dctx->prefixStart; in ZSTD_refDictContent()
1369 dctx->dictContentEndForFuzzing = dctx->previousDstEnd; in ZSTD_refDictContent()
1376 * @return : size of entropy tables read */
1388 …entropyDTables_t, OFTable) == offsetof(ZSTD_entropyDTables_t, LLTable) + sizeof(entropy->LLTable)); in ZSTD_loadDEntropy()
1389 …entropyDTables_t, MLTable) == offsetof(ZSTD_entropyDTables_t, OFTable) + sizeof(entropy->OFTable)); in ZSTD_loadDEntropy()
1390 …ZSTD_STATIC_ASSERT(sizeof(entropy->LLTable) + sizeof(entropy->OFTable) + sizeof(entropy->MLTable) … in ZSTD_loadDEntropy()
1391 …{ void* const workspace = &entropy->LLTable; /* use fse tables as temporary workspace; implies… in ZSTD_loadDEntropy()
1392 …size_t const workspaceSize = sizeof(entropy->LLTable) + sizeof(entropy->OFTable) + sizeof(entropy-… in ZSTD_loadDEntropy()
1395 size_t const hSize = HUF_readDTableX1_wksp(entropy->hufTable, in ZSTD_loadDEntropy()
1396 dictPtr, dictEnd - dictPtr, in ZSTD_loadDEntropy()
1399 size_t const hSize = HUF_readDTableX2_wksp(entropy->hufTable, in ZSTD_loadDEntropy()
1400 dictPtr, (size_t)(dictEnd - dictPtr), in ZSTD_loadDEntropy()
1409 …= FSE_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dictPtr, (size_t)(dictEnd-dictPtr)); in ZSTD_loadDEntropy()
1413 ZSTD_buildFSETable( entropy->OFTable, in ZSTD_loadDEntropy()
1417 entropy->workspace, sizeof(entropy->workspace), in ZSTD_loadDEntropy()
1424 …ount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dictPtr, (size_t)(dictEnd-dictPtr)); in ZSTD_loadDEntropy()
1428 ZSTD_buildFSETable( entropy->MLTable, in ZSTD_loadDEntropy()
1432 entropy->workspace, sizeof(entropy->workspace), in ZSTD_loadDEntropy()
1439 …readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dictPtr, (size_t)(dictEnd-dictPtr)); in ZSTD_loadDEntropy()
1443 ZSTD_buildFSETable( entropy->LLTable, in ZSTD_loadDEntropy()
1447 entropy->workspace, sizeof(entropy->workspace), in ZSTD_loadDEntropy()
1454 size_t const dictContentSize = (size_t)(dictEnd - (dictPtr+12)); in ZSTD_loadDEntropy()
1459 entropy->rep[i] = rep; in ZSTD_loadDEntropy()
1462 return (size_t)(dictPtr - (const BYTE*)dict); in ZSTD_loadDEntropy()
1472 dctx->dictID = MEM_readLE32((const char*)dict + ZSTD_FRAMEIDSIZE); in ZSTD_decompress_insertDictionary()
1475 { size_t const eSize = ZSTD_loadDEntropy(&dctx->entropy, dict, dictSize); in ZSTD_decompress_insertDictionary()
1478 dictSize -= eSize; in ZSTD_decompress_insertDictionary()
1480 dctx->litEntropy = dctx->fseEntropy = 1; in ZSTD_decompress_insertDictionary()
1489 … dctx->expected = ZSTD_startingInputLength(dctx->format); /* dctx->format must be properly set */ in ZSTD_decompressBegin()
1490 dctx->stage = ZSTDds_getFrameHeaderSize; in ZSTD_decompressBegin()
1491 dctx->processedCSize = 0; in ZSTD_decompressBegin()
1492 dctx->decodedSize = 0; in ZSTD_decompressBegin()
1493 dctx->previousDstEnd = NULL; in ZSTD_decompressBegin()
1494 dctx->prefixStart = NULL; in ZSTD_decompressBegin()
1495 dctx->virtualStart = NULL; in ZSTD_decompressBegin()
1496 dctx->dictEnd = NULL; in ZSTD_decompressBegin()
1497 …dctx->entropy.hufTable[0] = (HUF_DTable)((ZSTD_HUFFDTABLE_CAPACITY_LOG)*0x1000001); /* cover both… in ZSTD_decompressBegin()
1498 dctx->litEntropy = dctx->fseEntropy = 0; in ZSTD_decompressBegin()
1499 dctx->dictID = 0; in ZSTD_decompressBegin()
1500 dctx->bType = bt_reserved; in ZSTD_decompressBegin()
1501 dctx->isFrameDecompression = 1; in ZSTD_decompressBegin()
1502 ZSTD_STATIC_ASSERT(sizeof(dctx->entropy.rep) == sizeof(repStartValue)); in ZSTD_decompressBegin()
1503 ZSTD_memcpy(dctx->entropy.rep, repStartValue, sizeof(repStartValue)); /* initial repcodes */ in ZSTD_decompressBegin()
1504 dctx->LLTptr = dctx->entropy.LLTable; in ZSTD_decompressBegin()
1505 dctx->MLTptr = dctx->entropy.MLTable; in ZSTD_decompressBegin()
1506 dctx->OFTptr = dctx->entropy.OFTable; in ZSTD_decompressBegin()
1507 dctx->HUFptr = dctx->entropy.hufTable; in ZSTD_decompressBegin()
1532 dctx->ddictIsCold = (dctx->dictEnd != dictEnd); in ZSTD_decompressBegin_usingDDict()
1534 dctx->ddictIsCold ? "~cold~" : "hot!"); in ZSTD_decompressBegin_usingDDict()
1546 * It can still be loaded, but as a content-only dictionary. */
1555 * Provides the dictID required to decompress frame stored within `src`.
1558 * - The frame does not require a dictionary (most common case).
1559 * - The frame was built with dictID intentionally removed.
1561 * Note : this use case also happens when using a non-conformant dictionary.
1562 * - `srcSize` is too small, and as a result, frame header could not be decoded.
1564 * - This is not a Zstandard frame.
1577 * Decompression using a pre-digested Dictionary
1584 /* pass content and size in case legacy frames are encountered */ in ZSTD_decompress_usingDDict()
1627 RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, ""); in ZSTD_DCtx_loadDictionary_advanced()
1630 …dctx->ddictLocal = ZSTD_createDDict_advanced(dict, dictSize, dictLoadMethod, dictContentType, dctx… in ZSTD_DCtx_loadDictionary_advanced()
1631 RETURN_ERROR_IF(dctx->ddictLocal == NULL, memory_allocation, "NULL pointer!"); in ZSTD_DCtx_loadDictionary_advanced()
1632 dctx->ddict = dctx->ddictLocal; in ZSTD_DCtx_loadDictionary_advanced()
1633 dctx->dictUses = ZSTD_use_indefinitely; in ZSTD_DCtx_loadDictionary_advanced()
1651 dctx->dictUses = ZSTD_use_once; in ZSTD_DCtx_refPrefix_advanced()
1662 * return : expected size, aka ZSTD_startingInputLength().
1669 return ZSTD_startingInputLength(zds->format); in ZSTD_initDStream_usingDict()
1678 return ZSTD_startingInputLength(zds->format); in ZSTD_initDStream()
1689 return ZSTD_startingInputLength(dctx->format); in ZSTD_initDStream_usingDDict()
1693 * return : expected size, aka ZSTD_startingInputLength().
1699 return ZSTD_startingInputLength(dctx->format); in ZSTD_resetDStream()
1705 RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, ""); in ZSTD_DCtx_refDDict()
1708 dctx->ddict = ddict; in ZSTD_DCtx_refDDict()
1709 dctx->dictUses = ZSTD_use_indefinitely; in ZSTD_DCtx_refDDict()
1710 if (dctx->refMultipleDDicts == ZSTD_rmd_refMultipleDDicts) { in ZSTD_DCtx_refDDict()
1711 if (dctx->ddictSet == NULL) { in ZSTD_DCtx_refDDict()
1712 dctx->ddictSet = ZSTD_createDDictHashSet(dctx->customMem); in ZSTD_DCtx_refDDict()
1713 if (!dctx->ddictSet) { in ZSTD_DCtx_refDDict()
1717 … assert(!dctx->staticSize); /* Impossible: ddictSet cannot have been allocated if static dctx */ in ZSTD_DCtx_refDDict()
1718 … FORWARD_IF_ERROR(ZSTD_DDictHashSet_addDDict(dctx->ddictSet, ddict, dctx->customMem), ""); in ZSTD_DCtx_refDDict()
1731 size_t const max = (size_t)1 << bounds.upperBound; in ZSTD_DCtx_setMaxWindowSize() local
1732 RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, ""); in ZSTD_DCtx_setMaxWindowSize()
1734 RETURN_ERROR_IF(maxWindowSize > max, parameter_outOfBound, ""); in ZSTD_DCtx_setMaxWindowSize()
1735 dctx->maxWindowSize = maxWindowSize; in ZSTD_DCtx_setMaxWindowSize()
1804 *value = (int)ZSTD_highbit32((U32)dctx->maxWindowSize); in ZSTD_DCtx_getParameter()
1807 *value = (int)dctx->format; in ZSTD_DCtx_getParameter()
1810 *value = (int)dctx->outBufferMode; in ZSTD_DCtx_getParameter()
1813 *value = (int)dctx->forceIgnoreChecksum; in ZSTD_DCtx_getParameter()
1816 *value = (int)dctx->refMultipleDDicts; in ZSTD_DCtx_getParameter()
1819 *value = (int)dctx->disableHufAsm; in ZSTD_DCtx_getParameter()
1822 *value = dctx->maxBlockSizeParam; in ZSTD_DCtx_getParameter()
1831 RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, ""); in ZSTD_DCtx_setParameter()
1836 dctx->maxWindowSize = ((size_t)1) << value; in ZSTD_DCtx_setParameter()
1840 dctx->format = (ZSTD_format_e)value; in ZSTD_DCtx_setParameter()
1844 dctx->outBufferMode = (ZSTD_bufferMode_e)value; in ZSTD_DCtx_setParameter()
1848 dctx->forceIgnoreChecksum = (ZSTD_forceIgnoreChecksum_e)value; in ZSTD_DCtx_setParameter()
1852 if (dctx->staticSize != 0) { in ZSTD_DCtx_setParameter()
1855 dctx->refMultipleDDicts = (ZSTD_refMultipleDDicts_e)value; in ZSTD_DCtx_setParameter()
1859 dctx->disableHufAsm = value != 0; in ZSTD_DCtx_setParameter()
1863 dctx->maxBlockSizeParam = value; in ZSTD_DCtx_setParameter()
1874 dctx->streamStage = zdss_init; in ZSTD_DCtx_reset()
1875 dctx->noForwardProgress = 0; in ZSTD_DCtx_reset()
1876 dctx->isFrameDecompression = 1; in ZSTD_DCtx_reset()
1880 RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, ""); in ZSTD_DCtx_reset()
1926 …U32 const windowSizeMax = 1U << ZSTD_WINDOWLOG_MAX; /* note : should be user-selectable, but req… in ZSTD_estimateDStreamSize_fromFrame()
1941 …return (zds->inBuffSize + zds->outBuffSize) >= (neededInBuffSize + neededOutBuffSize) * ZSTD_WORKS… in ZSTD_DCtx_isOverflow()
1947 zds->oversizedDuration++; in ZSTD_DCtx_updateOversizedDuration()
1949 zds->oversizedDuration = 0; in ZSTD_DCtx_updateOversizedDuration()
1954 return zds->oversizedDuration >= ZSTD_WORKSPACETOOLARGE_MAXDURATION; in ZSTD_DCtx_isOversizedTooLong()
1960 ZSTD_outBuffer const expect = zds->expectedOutBuffer; in ZSTD_checkOutBuffer()
1962 if (zds->outBufferMode != ZSTD_bm_stable) in ZSTD_checkOutBuffer()
1967 if (zds->streamStage == zdss_init) in ZSTD_checkOutBuffer()
1970 if (expect.dst == output->dst && expect.pos == output->pos && expect.size == output->size) in ZSTD_checkOutBuffer()
1984 if (zds->outBufferMode == ZSTD_bm_buffered) { in ZSTD_decompressContinueStream()
1985 size_t const dstSize = isSkipFrame ? 0 : zds->outBuffSize - zds->outStart; in ZSTD_decompressContinueStream()
1987 zds->outBuff + zds->outStart, dstSize, src, srcSize); in ZSTD_decompressContinueStream()
1990 zds->streamStage = zdss_read; in ZSTD_decompressContinueStream()
1992 zds->outEnd = zds->outStart + decodedSize; in ZSTD_decompressContinueStream()
1993 zds->streamStage = zdss_flush; in ZSTD_decompressContinueStream()
1997 size_t const dstSize = isSkipFrame ? 0 : (size_t)(oend - *op); in ZSTD_decompressContinueStream()
2002 zds->streamStage = zdss_read; in ZSTD_decompressContinueStream()
2004 assert(zds->outBufferMode == ZSTD_bm_stable); in ZSTD_decompressContinueStream()
2011 const char* const src = (const char*)input->src; in ZSTD_decompressStream()
2012 const char* const istart = input->pos != 0 ? src + input->pos : src; in ZSTD_decompressStream()
2013 const char* const iend = input->size != 0 ? src + input->size : src; in ZSTD_decompressStream()
2015 char* const dst = (char*)output->dst; in ZSTD_decompressStream()
2016 char* const ostart = output->pos != 0 ? dst + output->pos : dst; in ZSTD_decompressStream()
2017 char* const oend = output->size != 0 ? dst + output->size : dst; in ZSTD_decompressStream()
2024 input->pos > input->size, in ZSTD_decompressStream()
2026 "forbidden. in: pos: %u vs size: %u", in ZSTD_decompressStream()
2027 (U32)input->pos, (U32)input->size); in ZSTD_decompressStream()
2029 output->pos > output->size, in ZSTD_decompressStream()
2031 "forbidden. out: pos: %u vs size: %u", in ZSTD_decompressStream()
2032 (U32)output->pos, (U32)output->size); in ZSTD_decompressStream()
2033 DEBUGLOG(5, "input size : %u", (U32)(input->size - input->pos)); in ZSTD_decompressStream()
2037 switch(zds->streamStage) in ZSTD_decompressStream()
2041 zds->streamStage = zdss_loadHeader; in ZSTD_decompressStream()
2042 zds->lhSize = zds->inPos = zds->outStart = zds->outEnd = 0; in ZSTD_decompressStream()
2043 zds->hostageByte = 0; in ZSTD_decompressStream()
2044 zds->expectedOutBuffer = *output; in ZSTD_decompressStream()
2048 DEBUGLOG(5, "stage zdss_loadHeader (srcSize : %u)", (U32)(iend - ip)); in ZSTD_decompressStream()
2049 …ize_t const hSize = ZSTD_getFrameHeader_advanced(&zds->fParams, zds->headerBuffer, zds->lhSize, zd… in ZSTD_decompressStream()
2050 if (zds->refMultipleDDicts && zds->ddictSet) { in ZSTD_decompressStream()
2057 … size_t const toLoad = hSize - zds->lhSize; /* if hSize!=0, hSize > zds->lhSize */ in ZSTD_decompressStream()
2058 size_t const remainingInput = (size_t)(iend-ip); in ZSTD_decompressStream()
2062 ZSTD_memcpy(zds->headerBuffer + zds->lhSize, ip, remainingInput); in ZSTD_decompressStream()
2063 zds->lhSize += remainingInput; in ZSTD_decompressStream()
2065 input->pos = input->size; in ZSTD_decompressStream()
2068 … ZSTD_getFrameHeader_advanced(&zds->fParams, zds->headerBuffer, zds->lhSize, zds->format), in ZSTD_decompressStream()
2070 /* return hint input size */ in ZSTD_decompressStream()
2071 …return (MAX((size_t)ZSTD_FRAMEHEADERSIZE_MIN(zds->format), hSize) - zds->lhSize) + ZSTD_blockHeade… in ZSTD_decompressStream()
2074 … ZSTD_memcpy(zds->headerBuffer + zds->lhSize, ip, toLoad); zds->lhSize = hSize; ip += toLoad; in ZSTD_decompressStream()
2078 /* check for single-pass mode opportunity */ in ZSTD_decompressStream()
2079 if (zds->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN in ZSTD_decompressStream()
2080 && zds->fParams.frameType != ZSTD_skippableFrame in ZSTD_decompressStream()
2081 && (U64)(size_t)(oend-op) >= zds->fParams.frameContentSize) { in ZSTD_decompressStream()
2082 …_t const cSize = ZSTD_findFrameCompressedSize_advanced(istart, (size_t)(iend-istart), zds->format); in ZSTD_decompressStream()
2083 if (cSize <= (size_t)(iend-istart)) { in ZSTD_decompressStream()
2084 /* shortcut : using single-pass mode */ in ZSTD_decompressStream()
2085 …t const decompressedSize = ZSTD_decompress_usingDDict(zds, op, (size_t)(oend-op), istart, cSize, Z… in ZSTD_decompressStream()
2087 DEBUGLOG(4, "shortcut to single-pass ZSTD_decompress_usingDDict()"); in ZSTD_decompressStream()
2090 … op = op ? op + decompressedSize : op; /* can occur if frameContentSize = 0 (empty frame) */ in ZSTD_decompressStream()
2091 zds->expected = 0; in ZSTD_decompressStream()
2092 zds->streamStage = zdss_init; in ZSTD_decompressStream()
2098 if (zds->outBufferMode == ZSTD_bm_stable in ZSTD_decompressStream()
2099 && zds->fParams.frameType != ZSTD_skippableFrame in ZSTD_decompressStream()
2100 && zds->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN in ZSTD_decompressStream()
2101 && (U64)(size_t)(oend-op) < zds->fParams.frameContentSize) { in ZSTD_decompressStream()
2109 if (zds->format == ZSTD_f_zstd1 in ZSTD_decompressStream()
2110 …&& (MEM_readLE32(zds->headerBuffer) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) { … in ZSTD_decompressStream()
2111 zds->expected = MEM_readLE32(zds->headerBuffer + ZSTD_FRAMEIDSIZE); in ZSTD_decompressStream()
2112 zds->stage = ZSTDds_skipFrame; in ZSTD_decompressStream()
2114 FORWARD_IF_ERROR(ZSTD_decodeFrameHeader(zds, zds->headerBuffer, zds->lhSize), ""); in ZSTD_decompressStream()
2115 zds->expected = ZSTD_blockHeaderSize; in ZSTD_decompressStream()
2116 zds->stage = ZSTDds_decodeBlockHeader; in ZSTD_decompressStream()
2120 DEBUGLOG(4, "Control max memory usage (%u KB <= max %u KB)", in ZSTD_decompressStream()
2121 (U32)(zds->fParams.windowSize >>10), in ZSTD_decompressStream()
2122 (U32)(zds->maxWindowSize >> 10) ); in ZSTD_decompressStream()
2123 … zds->fParams.windowSize = MAX(zds->fParams.windowSize, 1U << ZSTD_WINDOWLOG_ABSOLUTEMIN); in ZSTD_decompressStream()
2124 RETURN_ERROR_IF(zds->fParams.windowSize > zds->maxWindowSize, in ZSTD_decompressStream()
2126 if (zds->maxBlockSizeParam != 0) in ZSTD_decompressStream()
2127 … zds->fParams.blockSizeMax = MIN(zds->fParams.blockSizeMax, (unsigned)zds->maxBlockSizeParam); in ZSTD_decompressStream()
2129 /* Adapt buffer sizes to frame header instructions */ in ZSTD_decompressStream()
2130 … { size_t const neededInBuffSize = MAX(zds->fParams.blockSizeMax, 4 /* frame checksum */); in ZSTD_decompressStream()
2131 size_t const neededOutBuffSize = zds->outBufferMode == ZSTD_bm_buffered in ZSTD_decompressStream()
2132 …? ZSTD_decodingBufferSize_internal(zds->fParams.windowSize, zds->fParams.frameContentSize, zds->fP… in ZSTD_decompressStream()
2137 …{ int const tooSmall = (zds->inBuffSize < neededInBuffSize) || (zds->outBuffSize < neededOutBuff… in ZSTD_decompressStream()
2143 (U32)zds->inBuffSize, (U32)neededInBuffSize); in ZSTD_decompressStream()
2145 (U32)zds->outBuffSize, (U32)neededOutBuffSize); in ZSTD_decompressStream()
2146 if (zds->staticSize) { /* static DCtx */ in ZSTD_decompressStream()
2147 DEBUGLOG(4, "staticSize : %u", (U32)zds->staticSize); in ZSTD_decompressStream()
2148 assert(zds->staticSize >= sizeof(ZSTD_DCtx)); /* controlled at init */ in ZSTD_decompressStream()
2150 bufferSize > zds->staticSize - sizeof(ZSTD_DCtx), in ZSTD_decompressStream()
2153 ZSTD_customFree(zds->inBuff, zds->customMem); in ZSTD_decompressStream()
2154 zds->inBuffSize = 0; in ZSTD_decompressStream()
2155 zds->outBuffSize = 0; in ZSTD_decompressStream()
2156 zds->inBuff = (char*)ZSTD_customMalloc(bufferSize, zds->customMem); in ZSTD_decompressStream()
2157 RETURN_ERROR_IF(zds->inBuff == NULL, memory_allocation, ""); in ZSTD_decompressStream()
2159 zds->inBuffSize = neededInBuffSize; in ZSTD_decompressStream()
2160 zds->outBuff = zds->inBuff + zds->inBuffSize; in ZSTD_decompressStream()
2161 zds->outBuffSize = neededOutBuffSize; in ZSTD_decompressStream()
2163 zds->streamStage = zdss_read; in ZSTD_decompressStream()
2168 … size_t const neededInSize = ZSTD_nextSrcSizeToDecompressWithInputSize(zds, (size_t)(iend - ip)); in ZSTD_decompressStream()
2170 if (neededInSize==0) { /* end of frame */ in ZSTD_decompressStream()
2171 zds->streamStage = zdss_init; in ZSTD_decompressStream()
2175 if ((size_t)(iend-ip) >= neededInSize) { /* decode directly from src */ in ZSTD_decompressStream()
2183 zds->streamStage = zdss_load; in ZSTD_decompressStream()
2188 size_t const toLoad = neededInSize - zds->inPos; in ZSTD_decompressStream()
2192 … assert(neededInSize == ZSTD_nextSrcSizeToDecompressWithInputSize(zds, (size_t)(iend - ip))); in ZSTD_decompressStream()
2194 loadedSize = MIN(toLoad, (size_t)(iend-ip)); in ZSTD_decompressStream()
2196 RETURN_ERROR_IF(toLoad > zds->inBuffSize - zds->inPos, in ZSTD_decompressStream()
2199 … loadedSize = ZSTD_limitCopy(zds->inBuff + zds->inPos, toLoad, ip, (size_t)(iend-ip)); in ZSTD_decompressStream()
2204 zds->inPos += loadedSize; in ZSTD_decompressStream()
2209 zds->inPos = 0; /* input is consumed */ in ZSTD_decompressStream()
2210 … FORWARD_IF_ERROR(ZSTD_decompressContinueStream(zds, &op, oend, zds->inBuff, neededInSize), ""); in ZSTD_decompressStream()
2216 size_t const toFlushSize = zds->outEnd - zds->outStart; in ZSTD_decompressStream()
2217 …size_t const flushedSize = ZSTD_limitCopy(op, (size_t)(oend-op), zds->outBuff + zds->outStart, toF… in ZSTD_decompressStream()
2221 zds->outStart += flushedSize; in ZSTD_decompressStream()
2223 zds->streamStage = zdss_read; in ZSTD_decompressStream()
2224 if ( (zds->outBuffSize < zds->fParams.frameContentSize) in ZSTD_decompressStream()
2225 && (zds->outStart + zds->fParams.blockSizeMax > zds->outBuffSize) ) { in ZSTD_decompressStream()
2227 (int)(zds->outBuffSize - zds->outStart), in ZSTD_decompressStream()
2228 (U32)zds->fParams.blockSizeMax); in ZSTD_decompressStream()
2229 zds->outStart = zds->outEnd = 0; in ZSTD_decompressStream()
2243 input->pos = (size_t)(ip - (const char*)(input->src)); in ZSTD_decompressStream()
2244 output->pos = (size_t)(op - (char*)(output->dst)); in ZSTD_decompressStream()
2247 zds->expectedOutBuffer = *output; in ZSTD_decompressStream()
2250 zds->noForwardProgress ++; in ZSTD_decompressStream()
2251 if (zds->noForwardProgress >= ZSTD_NO_FORWARD_PROGRESS_MAX) { in ZSTD_decompressStream()
2257 zds->noForwardProgress = 0; in ZSTD_decompressStream()
2260 if (!nextSrcSizeHint) { /* frame fully decoded */ in ZSTD_decompressStream()
2261 if (zds->outEnd == zds->outStart) { /* output fully flushed */ in ZSTD_decompressStream()
2262 if (zds->hostageByte) { in ZSTD_decompressStream()
2263 if (input->pos >= input->size) { in ZSTD_decompressStream()
2265 zds->streamStage = zdss_read; in ZSTD_decompressStream()
2268 input->pos++; /* release hostage */ in ZSTD_decompressStream()
2269 } /* zds->hostageByte */ in ZSTD_decompressStream()
2271 } /* zds->outEnd == zds->outStart */ in ZSTD_decompressStream()
2272 …if (!zds->hostageByte) { /* output not fully flushed; keep last byte as hostage; will be released … in ZSTD_decompressStream()
2273 … input->pos--; /* note : pos > 0, otherwise, impossible to finish reading last block */ in ZSTD_decompressStream()
2274 zds->hostageByte=1; in ZSTD_decompressStream()
2279 assert(zds->inPos <= nextSrcSizeHint); in ZSTD_decompressStream()
2280 nextSrcSizeHint -= zds->inPos; /* part already loaded*/ in ZSTD_decompressStream()
2293 output.size = dstCapacity; in ZSTD_decompressStream_simpleArgs()
2296 input.size = srcSize; in ZSTD_decompressStream_simpleArgs()