Lines Matching refs:dctx
213 size_t ZSTD_sizeof_DCtx (const ZSTD_DCtx* dctx)
215 if (dctx==NULL) return 0; /* support sizeof NULL */
216 return sizeof(*dctx)
217 + ZSTD_sizeof_DDict(dctx->ddictLocal)
218 + dctx->inBuffSize + dctx->outBuffSize;
232 static void ZSTD_DCtx_resetParameters(ZSTD_DCtx* dctx)
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;
242 static void ZSTD_initDCtx_internal(ZSTD_DCtx* dctx)
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;
257 dctx->bmi2 = ZSTD_cpuSupportsBmi2();
259 dctx->ddictSet = NULL;
260 ZSTD_DCtx_resetParameters(dctx);
262 dctx->dictContentEndForFuzzing = NULL;
268 ZSTD_DCtx* const dctx = (ZSTD_DCtx*) workspace;
273 ZSTD_initDCtx_internal(dctx);
274 dctx->staticSize = workspaceSize;
275 dctx->inBuff = (char*)(dctx+1);
276 return dctx;
282 { ZSTD_DCtx* const dctx = (ZSTD_DCtx*)ZSTD_customMalloc(sizeof(*dctx), customMem);
283 if (!dctx) return NULL;
284 dctx->customMem = customMem;
285 ZSTD_initDCtx_internal(dctx);
286 return dctx;
301 static void ZSTD_clearDict(ZSTD_DCtx* dctx)
303 ZSTD_freeDDict(dctx->ddictLocal);
304 dctx->ddictLocal = NULL;
305 dctx->ddict = NULL;
306 dctx->dictUses = ZSTD_dont_use;
309 size_t ZSTD_freeDCtx(ZSTD_DCtx* dctx)
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(dctx->inBuff, cMem);
316 dctx->inBuff = NULL;
317 if (dctx->ddictSet) {
318 ZSTD_freeDDictHashSet(dctx->ddictSet, cMem);
319 dctx->ddictSet = NULL;
321 ZSTD_customFree(dctx, cMem);
333 /* Given a dctx with a digested frame params, re-selects the correct ZSTD_DDict based on
341 static void ZSTD_DCtx_selectFrameDDict(ZSTD_DCtx* dctx) {
342 assert(dctx->refMultipleDDicts && dctx->ddictSet);
344 if (dctx->ddict) {
345 const ZSTD_DDict* frameDDict = ZSTD_DDictHashSet_getDDict(dctx->ddictSet, dctx->fParams.dictID);
348 ZSTD_clearDict(dctx);
349 dctx->dictID = dctx->fParams.dictID;
350 dctx->ddict = frameDDict;
351 dctx->dictUses = ZSTD_use_indefinitely;
647 static size_t ZSTD_decodeFrameHeader(ZSTD_DCtx* dctx, const void* src, size_t headerSize)
649 size_t const result = ZSTD_getFrameHeader_advanced(&(dctx->fParams), src, headerSize, dctx->format);
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);
662 RETURN_ERROR_IF(dctx->fParams.dictID && (dctx->dictID != dctx->fParams.dictID),
665 dctx->validateChecksum = (dctx->fParams.checksumFlag && !dctx->forceIgnoreChecksum) ? 1 : 0;
666 if (dctx->validateChecksum) xxh64_reset(&dctx->xxhState, 0);
667 dctx->processedCSize += headerSize;
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)
786 ZSTD_checkContinuity(dctx, blockStart, blockSize);
787 dctx->previousDstEnd = (const char*)blockStart + blockSize;
818 static void ZSTD_DCtx_trace_end(ZSTD_DCtx const* dctx, U64 uncompressedSize, U64 compressedSize, unsigned streaming)
820 (void)dctx;
828 * @dctx must be properly initialized
831 static size_t ZSTD_decompressFrame(ZSTD_DCtx* dctx,
846 remainingSrcSize < ZSTD_FRAMEHEADERSIZE_MIN(dctx->format)+ZSTD_blockHeaderSize,
851 ip, ZSTD_FRAMEHEADERSIZE_PREFIX(dctx->format), dctx->format);
855 FORWARD_IF_ERROR( ZSTD_decodeFrameHeader(dctx, ip, frameHeaderSize) , "");
891 decodedSize = ZSTD_decompressBlock_internal(dctx, op, (size_t)(oBlockEnd-op), ip, cBlockSize, /* frame */ 1, not_streaming);
906 if (dctx->validateChecksum)
907 xxh64_update(&dctx->xxhState, op, decodedSize);
916 if (dctx->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN) {
917 RETURN_ERROR_IF((U64)(op-ostart) != dctx->fParams.frameContentSize,
920 if (dctx->fParams.checksumFlag) { /* Frame content checksum verification */
922 if (!dctx->forceIgnoreChecksum) {
923 U32 const checkCalc = (U32)xxh64_digest(&dctx->xxhState);
931 ZSTD_DCtx_trace_end(dctx, (U64)(op-ostart), (U64)(ip-istart), /* streaming */ 0);
938 static size_t ZSTD_decompressMultiFrame(ZSTD_DCtx* dctx,
955 while (srcSize >= ZSTD_startingInputLength(dctx->format)) {
973 FORWARD_IF_ERROR(ZSTD_decompressBegin_usingDDict(dctx, ddict), "");
977 FORWARD_IF_ERROR(ZSTD_decompressBegin_usingDict(dctx, dict, dictSize), "");
979 ZSTD_checkContinuity(dctx, dst, dstCapacity);
981 { const size_t res = ZSTD_decompressFrame(dctx, dst, dstCapacity,
1008 size_t ZSTD_decompress_usingDict(ZSTD_DCtx* dctx,
1013 return ZSTD_decompressMultiFrame(dctx, dst, dstCapacity, src, srcSize, dict, dictSize, NULL);
1017 static ZSTD_DDict const* ZSTD_getDDict(ZSTD_DCtx* dctx)
1019 switch (dctx->dictUses) {
1024 ZSTD_clearDict(dctx);
1027 return dctx->ddict;
1029 dctx->dictUses = ZSTD_dont_use;
1030 return dctx->ddict;
1034 size_t ZSTD_decompressDCtx(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
1036 return ZSTD_decompress_usingDDict(dctx, dst, dstCapacity, src, srcSize, ZSTD_getDDict(dctx));
1044 ZSTD_DCtx* const dctx = ZSTD_createDCtx_internal(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);
1050 ZSTD_DCtx dctx;
1051 ZSTD_initDCtx_internal(&dctx);
1052 return ZSTD_decompressDCtx(&dctx, dst, dstCapacity, src, srcSize);
1061 size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx) { return dctx->expected; }
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);
1081 ZSTD_nextInputType_e ZSTD_nextInputType(ZSTD_DCtx* dctx) {
1082 switch(dctx->stage)
1106 static int ZSTD_isSkipFrame(ZSTD_DCtx* dctx) { return dctx->stage == ZSTDds_skipFrame; }
1112 size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
1116 RETURN_ERROR_IF(srcSize != ZSTD_nextSrcSizeToDecompressWithInputSize(dctx, srcSize), srcSize_wrong, "not allowed");
1117 ZSTD_checkContinuity(dctx, dst, dstCapacity);
1119 dctx->processedCSize += srcSize;
1121 switch (dctx->stage)
1125 if (dctx->format == ZSTD_f_zstd1) { /* allows header */
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;
1133 dctx->headerSize = ZSTD_frameHeaderSize_internal(src, srcSize, dctx->format);
1134 if (ZSTD_isError(dctx->headerSize)) return dctx->headerSize;
1135 ZSTD_memcpy(dctx->headerBuffer, src, srcSize);
1136 dctx->expected = dctx->headerSize - srcSize;
1137 dctx->stage = ZSTDds_decodeFrameHeader;
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;
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;
1157 dctx->stage = bp.lastBlock ? ZSTDds_decompressLastBlock : ZSTDds_decompressBlock;
1162 if (dctx->fParams.checksumFlag) {
1163 dctx->expected = 4;
1164 dctx->stage = ZSTDds_checkChecksum;
1166 dctx->expected = 0; /* end of frame */
1167 dctx->stage = ZSTDds_getFrameHeaderSize;
1170 dctx->expected = ZSTD_blockHeaderSize; /* jump to next header */
1171 dctx->stage = ZSTDds_decodeBlockHeader;
1180 switch(dctx->bType)
1184 rSize = ZSTD_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize, /* frame */ 1, is_streaming);
1185 dctx->expected = 0; /* Streaming not supported */
1188 assert(srcSize <= dctx->expected);
1192 dctx->expected -= rSize;
1195 rSize = ZSTD_setRleBlock(dst, dstCapacity, *(const BYTE*)src, dctx->rleSize);
1196 dctx->expected = 0; /* Streaming not supported */
1203 RETURN_ERROR_IF(rSize > dctx->fParams.blockSizeMax, corruption_detected, "Decompressed Block Size Exceeds Maximum");
1205 dctx->decodedSize += rSize;
1206 if (dctx->validateChecksum) xxh64_update(&dctx->xxhState, dst, rSize);
1207 dctx->previousDstEnd = (char*)dst + rSize;
1210 if (dctx->expected > 0) {
1214 if (dctx->stage == ZSTDds_decompressLastBlock) { /* end of frame */
1215 DEBUGLOG(4, "ZSTD_decompressContinue: decoded size from frame : %u", (unsigned)dctx->decodedSize);
1217 dctx->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN
1218 && dctx->decodedSize != dctx->fParams.frameContentSize,
1220 if (dctx->fParams.checksumFlag) { /* another round for frame checksum */
1221 dctx->expected = 4;
1222 dctx->stage = ZSTDds_checkChecksum;
1224 ZSTD_DCtx_trace_end(dctx, dctx->decodedSize, dctx->processedCSize, /* streaming */ 1);
1225 dctx->expected = 0; /* ends here */
1226 dctx->stage = ZSTDds_getFrameHeaderSize;
1229 dctx->stage = ZSTDds_decodeBlockHeader;
1230 dctx->expected = ZSTD_blockHeaderSize;
1236 assert(srcSize == 4); /* guaranteed by dctx->expected */
1238 if (dctx->validateChecksum) {
1239 U32 const h32 = (U32)xxh64_digest(&dctx->xxhState);
1244 ZSTD_DCtx_trace_end(dctx, dctx->decodedSize, dctx->processedCSize, /* streaming */ 1);
1245 dctx->expected = 0;
1246 dctx->stage = ZSTDds_getFrameHeaderSize;
1253 ZSTD_memcpy(dctx->headerBuffer + (ZSTD_SKIPPABLEHEADERSIZE - srcSize), src, srcSize); /* complete skippable header */
1254 dctx->expected = MEM_readLE32(dctx->headerBuffer + ZSTD_FRAMEIDSIZE); /* note : dctx->expected can grow seriously large, beyond local buffer size */
1255 dctx->stage = ZSTDds_skipFrame;
1259 dctx->expected = 0;
1260 dctx->stage = ZSTDds_getFrameHeaderSize;
1270 static size_t ZSTD_refDictContent(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
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;
1277 dctx->dictContentBeginForFuzzing = dctx->prefixStart;
1278 dctx->dictContentEndForFuzzing = dctx->previousDstEnd;
1374 static size_t ZSTD_decompress_insertDictionary(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
1376 if (dictSize < 8) return ZSTD_refDictContent(dctx, dict, dictSize);
1379 return ZSTD_refDictContent(dctx, dict, dictSize); /* pure content mode */
1381 dctx->dictID = MEM_readLE32((const char*)dict + ZSTD_FRAMEIDSIZE);
1384 { size_t const eSize = ZSTD_loadDEntropy(&dctx->entropy, dict, dictSize);
1389 dctx->litEntropy = dctx->fseEntropy = 1;
1392 return ZSTD_refDictContent(dctx, dict, dictSize);
1395 size_t ZSTD_decompressBegin(ZSTD_DCtx* dctx)
1397 assert(dctx != NULL);
1398 dctx->expected = ZSTD_startingInputLength(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;
1419 size_t ZSTD_decompressBegin_usingDict(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
1421 FORWARD_IF_ERROR( ZSTD_decompressBegin(dctx) , "");
1424 ZSTD_isError(ZSTD_decompress_insertDictionary(dctx, dict, dictSize)),
1432 size_t ZSTD_decompressBegin_usingDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict)
1435 assert(dctx != NULL);
1440 dctx->ddictIsCold = (dctx->dictEnd != dictEnd);
1442 dctx->ddictIsCold ? "~cold~" : "hot!");
1444 FORWARD_IF_ERROR( ZSTD_decompressBegin(dctx) , "");
1446 ZSTD_copyDDictParameters(dctx, ddict);
1487 size_t ZSTD_decompress_usingDDict(ZSTD_DCtx* dctx,
1493 return ZSTD_decompressMultiFrame(dctx, dst, dstCapacity, src, srcSize,
1530 size_t ZSTD_DCtx_loadDictionary_advanced(ZSTD_DCtx* dctx,
1535 RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
1536 ZSTD_clearDict(dctx);
1538 dctx->ddictLocal = ZSTD_createDDict_advanced(dict, dictSize, dictLoadMethod, dictContentType, dctx->customMem);
1539 RETURN_ERROR_IF(dctx->ddictLocal == NULL, memory_allocation, "NULL pointer!");
1540 dctx->ddict = dctx->ddictLocal;
1541 dctx->dictUses = ZSTD_use_indefinitely;
1546 size_t ZSTD_DCtx_loadDictionary_byReference(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
1548 return ZSTD_DCtx_loadDictionary_advanced(dctx, dict, dictSize, ZSTD_dlm_byRef, ZSTD_dct_auto);
1551 size_t ZSTD_DCtx_loadDictionary(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
1553 return ZSTD_DCtx_loadDictionary_advanced(dctx, dict, dictSize, ZSTD_dlm_byCopy, ZSTD_dct_auto);
1556 size_t ZSTD_DCtx_refPrefix_advanced(ZSTD_DCtx* dctx, const void* prefix, size_t prefixSize, ZSTD_dictContentType_e dictContentType)
1558 FORWARD_IF_ERROR(ZSTD_DCtx_loadDictionary_advanced(dctx, prefix, prefixSize, ZSTD_dlm_byRef, dictContentType), "");
1559 dctx->dictUses = ZSTD_use_once;
1563 size_t ZSTD_DCtx_refPrefix(ZSTD_DCtx* dctx, const void* prefix, size_t prefixSize)
1565 return ZSTD_DCtx_refPrefix_advanced(dctx, prefix, prefixSize, ZSTD_dct_rawContent);
1590 size_t ZSTD_initDStream_usingDDict(ZSTD_DStream* dctx, const ZSTD_DDict* ddict)
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(dctx->format);
1600 size_t ZSTD_resetDStream(ZSTD_DStream* dctx)
1602 FORWARD_IF_ERROR(ZSTD_DCtx_reset(dctx, ZSTD_reset_session_only), "");
1603 return ZSTD_startingInputLength(dctx->format);
1607 size_t ZSTD_DCtx_refDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict)
1609 RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
1610 ZSTD_clearDict(dctx);
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(dctx->customMem);
1617 if (!dctx->ddictSet) {
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), "");
1631 size_t ZSTD_DCtx_setMaxWindowSize(ZSTD_DCtx* dctx, size_t maxWindowSize)
1636 RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
1639 dctx->maxWindowSize = maxWindowSize;
1643 size_t ZSTD_DCtx_setFormat(ZSTD_DCtx* dctx, ZSTD_format_e format)
1645 return ZSTD_DCtx_setParameter(dctx, ZSTD_d_format, (int)format);
1695 size_t ZSTD_DCtx_getParameter(ZSTD_DCtx* dctx, ZSTD_dParameter param, int* value)
1699 *value = (int)ZSTD_highbit32((U32)dctx->maxWindowSize);
1702 *value = (int)dctx->format;
1705 *value = (int)dctx->outBufferMode;
1708 *value = (int)dctx->forceIgnoreChecksum;
1711 *value = (int)dctx->refMultipleDDicts;
1718 size_t ZSTD_DCtx_setParameter(ZSTD_DCtx* dctx, ZSTD_dParameter dParam, int value)
1720 RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
1725 dctx->maxWindowSize = ((size_t)1) << value;
1729 dctx->format = (ZSTD_format_e)value;
1733 dctx->outBufferMode = (ZSTD_bufferMode_e)value;
1737 dctx->forceIgnoreChecksum = (ZSTD_forceIgnoreChecksum_e)value;
1741 if (dctx->staticSize != 0) {
1742 RETURN_ERROR(parameter_unsupported, "Static dctx does not support multiple DDicts!");
1744 dctx->refMultipleDDicts = (ZSTD_refMultipleDDicts_e)value;
1751 size_t ZSTD_DCtx_reset(ZSTD_DCtx* dctx, ZSTD_ResetDirective reset)
1755 dctx->streamStage = zdss_init;
1756 dctx->noForwardProgress = 0;
1760 RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
1761 ZSTD_clearDict(dctx);
1762 ZSTD_DCtx_resetParameters(dctx);
1768 size_t ZSTD_sizeof_DStream(const ZSTD_DStream* dctx)
1770 return ZSTD_sizeof_DCtx(dctx);
1795 U32 const windowSizeMax = 1U << ZSTD_WINDOWLOG_MAX; /* note : should be user-selectable, but requires an additional parameter (or a dctx) */
2139 ZSTD_DCtx* dctx,
2146 size_t const cErr = ZSTD_decompressStream(dctx, &output, &input);