Lines Matching refs:dctx
82 ZSTDLIBv07_API size_t ZSTDv07_sizeofDCtx(const ZSTDv07_DCtx* dctx);
89 ZSTDLIBv07_API size_t ZSTDv07_decompressBegin(ZSTDv07_DCtx* dctx);
90 ZSTDLIBv07_API size_t ZSTDv07_decompressBegin_usingDict(ZSTDv07_DCtx* dctx, const void* dict, size_t dictSize);
91 ZSTDLIBv07_API void ZSTDv07_copyDCtx(ZSTDv07_DCtx* dctx, const ZSTDv07_DCtx* preparedDCtx);
93 ZSTDLIBv07_API size_t ZSTDv07_nextSrcSizeToDecompress(ZSTDv07_DCtx* dctx);
94 ZSTDLIBv07_API size_t ZSTDv07_decompressContinue(ZSTDv07_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
175 ZSTDLIBv07_API size_t ZSTDv07_decompressBlock(ZSTDv07_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
176 ZSTDLIBv07_API size_t ZSTDv07_insertBlock(ZSTDv07_DCtx* dctx, const void* blockStart, size_t blockSize); /**< insert block into `dctx` history. Useful for uncompressed blocks */
1085 size_t HUFv07_decompress4X_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< decodes RLE and uncompressed */
1086 size_t HUFv07_decompress4X_hufOnly(HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< considers RLE and uncompressed as errors */
1087 size_t HUFv07_decompress4X2_DCtx(HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< single-symbol decoder */
1088 size_t HUFv07_decompress4X4_DCtx(HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< double-symbols decoder */
1090 size_t HUFv07_decompress1X_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);
1091 size_t HUFv07_decompress1X2_DCtx(HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< single-symbol decoder */
1092 size_t HUFv07_decompress1X4_DCtx(HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< double-symbols decoder */
2028 size_t HUFv07_decompress4X2_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
2032 size_t const hSize = HUFv07_readDTableX2 (dctx, cSrc, cSrcSize);
2037 return HUFv07_decompress4X2_usingDTable_internal (dst, dstSize, ip, cSrcSize, dctx);
2439 size_t HUFv07_decompress4X4_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
2443 size_t hSize = HUFv07_readDTableX4 (dctx, cSrc, cSrcSize);
2448 return HUFv07_decompress4X4_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx);
2541 size_t HUFv07_decompress4X_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
2550 return algoNb ? HUFv07_decompress4X4_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) :
2551 HUFv07_decompress4X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) ;
2555 size_t HUFv07_decompress4X_hufOnly (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
2562 return algoNb ? HUFv07_decompress4X4_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) :
2563 HUFv07_decompress4X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) ;
2567 size_t HUFv07_decompress1X_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
2576 return algoNb ? HUFv07_decompress1X4_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) :
2577 HUFv07_decompress1X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) ;
2960 int ZSTDv07_isSkipFrame(ZSTDv07_DCtx* dctx);
2962 size_t ZSTDv07_sizeofDCtx (const ZSTDv07_DCtx* dctx) { return sizeof(*dctx); }
2966 size_t ZSTDv07_decompressBegin(ZSTDv07_DCtx* dctx)
2968 dctx->expected = ZSTDv07_frameHeaderSize_min;
2969 dctx->stage = ZSTDds_getFrameHeaderSize;
2970 dctx->previousDstEnd = NULL;
2971 dctx->base = NULL;
2972 dctx->vBase = NULL;
2973 dctx->dictEnd = NULL;
2974 dctx->hufTable[0] = (HUFv07_DTable)((HufLog)*0x1000001);
2975 dctx->litEntropy = dctx->fseEntropy = 0;
2976 dctx->dictID = 0;
2977 { int i; for (i=0; i<ZSTDv07_REP_NUM; i++) dctx->rep[i] = repStartValue[i]; }
2983 ZSTDv07_DCtx* dctx;
2991 dctx = (ZSTDv07_DCtx*) customMem.customAlloc(customMem.opaque, sizeof(ZSTDv07_DCtx));
2992 if (!dctx) return NULL;
2993 memcpy(&dctx->customMem, &customMem, sizeof(ZSTDv07_customMem));
2994 ZSTDv07_decompressBegin(dctx);
2995 return dctx;
3003 size_t ZSTDv07_freeDCtx(ZSTDv07_DCtx* dctx)
3005 if (dctx==NULL) return 0; /* support free on NULL */
3006 dctx->customMem.customFree(dctx->customMem.opaque, dctx);
3242 static size_t ZSTDv07_decodeFrameHeader(ZSTDv07_DCtx* dctx, const void* src, size_t srcSize)
3244 size_t const result = ZSTDv07_getFrameParams(&(dctx->fParams), src, srcSize);
3245 if (dctx->fParams.dictID && (dctx->dictID != dctx->fParams.dictID)) return ERROR(dictionary_wrong);
3246 if (dctx->fParams.checksumFlag) XXH64_reset(&dctx->xxhState, 0);
3288 static size_t ZSTDv07_decodeLiteralsBlock(ZSTDv07_DCtx* dctx,
3327 HUFv07_decompress1X2_DCtx(dctx->hufTable, dctx->litBuffer, litSize, istart+lhSize, litCSize) :
3328 HUFv07_decompress4X_hufOnly (dctx->hufTable, dctx->litBuffer, litSize, istart+lhSize, litCSize) ))
3331 dctx->litPtr = dctx->litBuffer;
3332 dctx->litSize = litSize;
3333 dctx->litEntropy = 1;
3334 memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);
3342 if (dctx->litEntropy==0)
3351 { size_t const errorCode = HUFv07_decompress1X4_usingDTable(dctx->litBuffer, litSize, istart+lhSize, litCSize, dctx->hufTable);
3354 dctx->litPtr = dctx->litBuffer;
3355 dctx->litSize = litSize;
3356 memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);
3378 memcpy(dctx->litBuffer, istart+lhSize, litSize);
3379 dctx->litPtr = dctx->litBuffer;
3380 dctx->litSize = litSize;
3381 memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);
3385 dctx->litPtr = istart+lhSize;
3386 dctx->litSize = litSize;
3407 memset(dctx->litBuffer, istart[lhSize], litSize + WILDCOPY_OVERLENGTH);
3408 dctx->litPtr = dctx->litBuffer;
3409 dctx->litSize = litSize;
3669 ZSTDv07_DCtx* dctx,
3678 const BYTE* litPtr = dctx->litPtr;
3679 const BYTE* const litEnd = litPtr + dctx->litSize;
3680 FSEv07_DTable* DTableLL = dctx->LLTable;
3681 FSEv07_DTable* DTableML = dctx->MLTable;
3682 FSEv07_DTable* DTableOffb = dctx->OffTable;
3683 const BYTE* const base = (const BYTE*) (dctx->base);
3684 const BYTE* const vBase = (const BYTE*) (dctx->vBase);
3685 const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd);
3689 { size_t const seqHSize = ZSTDv07_decodeSeqHeaders(&nbSeq, DTableLL, DTableML, DTableOffb, dctx->fseEntropy, ip, seqSize);
3697 dctx->fseEntropy = 1;
3698 { U32 i; for (i=0; i<ZSTDv07_REP_INIT; i++) seqState.prevOffset[i] = dctx->rep[i]; }
3716 { U32 i; for (i=0; i<ZSTDv07_REP_INIT; i++) dctx->rep[i] = (U32)(seqState.prevOffset[i]); }
3733 static void ZSTDv07_checkContinuity(ZSTDv07_DCtx* dctx, const void* dst)
3735 if (dst != dctx->previousDstEnd) { /* not contiguous */
3736 dctx->dictEnd = dctx->previousDstEnd;
3737 dctx->vBase = (const char*)dst - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->base));
3738 dctx->base = dst;
3739 dctx->previousDstEnd = dst;
3744 static size_t ZSTDv07_decompressBlock_internal(ZSTDv07_DCtx* dctx,
3753 { size_t const litCSize = ZSTDv07_decodeLiteralsBlock(dctx, src, srcSize);
3758 return ZSTDv07_decompressSequences(dctx, dst, dstCapacity, ip, srcSize);
3762 size_t ZSTDv07_decompressBlock(ZSTDv07_DCtx* dctx,
3767 ZSTDv07_checkContinuity(dctx, dst);
3768 dSize = ZSTDv07_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize);
3769 dctx->previousDstEnd = (char*)dst + dSize;
3775 insert `src` block into `dctx` history. Useful to track uncompressed blocks. */
3776 ZSTDLIBv07_API size_t ZSTDv07_insertBlock(ZSTDv07_DCtx* dctx, const void* blockStart, size_t blockSize)
3778 ZSTDv07_checkContinuity(dctx, blockStart);
3779 dctx->previousDstEnd = (const char*)blockStart + blockSize;
3795 * `dctx` must be properly initialized */
3796 static size_t ZSTDv07_decompressFrame(ZSTDv07_DCtx* dctx,
3814 if (ZSTDv07_decodeFrameHeader(dctx, src, frameHeaderSize)) return ERROR(corruption_detected);
3832 decodedSize = ZSTDv07_decompressBlock_internal(dctx, op, oend-op, ip, cBlockSize);
3851 if (dctx->fParams.checksumFlag) XXH64_update(&dctx->xxhState, op, decodedSize);
3865 * Requires 2 contexts : 1 for reference (preparedDCtx), which will not be modified, and 1 to run the decompression operation (dctx) */
3866 static size_t ZSTDv07_decompress_usingPreparedDCtx(ZSTDv07_DCtx* dctx, const ZSTDv07_DCtx* refDCtx,
3870 ZSTDv07_copyDCtx(dctx, refDCtx);
3871 ZSTDv07_checkContinuity(dctx, dst);
3872 return ZSTDv07_decompressFrame(dctx, dst, dstCapacity, src, srcSize);
3876 size_t ZSTDv07_decompress_usingDict(ZSTDv07_DCtx* dctx,
3881 ZSTDv07_decompressBegin_usingDict(dctx, dict, dictSize);
3882 ZSTDv07_checkContinuity(dctx, dst);
3883 return ZSTDv07_decompressFrame(dctx, dst, dstCapacity, src, srcSize);
3887 size_t ZSTDv07_decompressDCtx(ZSTDv07_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
3889 return ZSTDv07_decompress_usingDict(dctx, dst, dstCapacity, src, srcSize, NULL, 0);
3897 ZSTDv07_DCtx* const dctx = ZSTDv07_createDCtx();
3898 if (dctx==NULL) return ERROR(memory_allocation);
3899 regenSize = ZSTDv07_decompressDCtx(dctx, dst, dstCapacity, src, srcSize);
3900 ZSTDv07_freeDCtx(dctx);
3903 ZSTDv07_DCtx dctx;
3904 return ZSTDv07_decompressDCtx(&dctx, dst, dstCapacity, src, srcSize);
3976 size_t ZSTDv07_nextSrcSizeToDecompress(ZSTDv07_DCtx* dctx)
3978 return dctx->expected;
3981 int ZSTDv07_isSkipFrame(ZSTDv07_DCtx* dctx)
3983 return dctx->stage == ZSTDds_skipFrame;
3989 size_t ZSTDv07_decompressContinue(ZSTDv07_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
3992 if (srcSize != dctx->expected) return ERROR(srcSize_wrong);
3993 if (dstCapacity) ZSTDv07_checkContinuity(dctx, dst);
3995 switch (dctx->stage)
4000 memcpy(dctx->headerBuffer, src, ZSTDv07_frameHeaderSize_min);
4001 dctx->expected = ZSTDv07_skippableHeaderSize - ZSTDv07_frameHeaderSize_min; /* magic number + skippable frame length */
4002 dctx->stage = ZSTDds_decodeSkippableHeader;
4005 dctx->headerSize = ZSTDv07_frameHeaderSize(src, ZSTDv07_frameHeaderSize_min);
4006 if (ZSTDv07_isError(dctx->headerSize)) return dctx->headerSize;
4007 memcpy(dctx->headerBuffer, src, ZSTDv07_frameHeaderSize_min);
4008 if (dctx->headerSize > ZSTDv07_frameHeaderSize_min) {
4009 dctx->expected = dctx->headerSize - ZSTDv07_frameHeaderSize_min;
4010 dctx->stage = ZSTDds_decodeFrameHeader;
4013 dctx->expected = 0; /* not necessary to copy more */
4017 memcpy(dctx->headerBuffer + ZSTDv07_frameHeaderSize_min, src, dctx->expected);
4018 result = ZSTDv07_decodeFrameHeader(dctx, dctx->headerBuffer, dctx->headerSize);
4020 dctx->expected = ZSTDv07_blockHeaderSize;
4021 dctx->stage = ZSTDds_decodeBlockHeader;
4029 if (dctx->fParams.checksumFlag) {
4030 U64 const h64 = XXH64_digest(&dctx->xxhState);
4036 dctx->expected = 0;
4037 dctx->stage = ZSTDds_getFrameHeaderSize;
4039 dctx->expected = cBlockSize;
4040 dctx->bType = bp.blockType;
4041 dctx->stage = ZSTDds_decompressBlock;
4047 switch(dctx->bType)
4050 rSize = ZSTDv07_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize);
4064 dctx->stage = ZSTDds_decodeBlockHeader;
4065 dctx->expected = ZSTDv07_blockHeaderSize;
4066 dctx->previousDstEnd = (char*)dst + rSize;
4068 if (dctx->fParams.checksumFlag) XXH64_update(&dctx->xxhState, dst, rSize);
4072 { memcpy(dctx->headerBuffer + ZSTDv07_frameHeaderSize_min, src, dctx->expected);
4073 dctx->expected = MEM_readLE32(dctx->headerBuffer + 4);
4074 dctx->stage = ZSTDds_skipFrame;
4078 { dctx->expected = 0;
4079 dctx->stage = ZSTDds_getFrameHeaderSize;
4088 static size_t ZSTDv07_refDictContent(ZSTDv07_DCtx* dctx, const void* dict, size_t dictSize)
4090 dctx->dictEnd = dctx->previousDstEnd;
4091 dctx->vBase = (const char*)dict - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->base));
4092 dctx->base = dict;
4093 dctx->previousDstEnd = (const char*)dict + dictSize;
4097 static size_t ZSTDv07_loadEntropy(ZSTDv07_DCtx* dctx, const void* const dict, size_t const dictSize)
4102 { size_t const hSize = HUFv07_readDTableX4(dctx->hufTable, dict, dictSize);
4112 { size_t const errorCode = FSEv07_buildDTable(dctx->OffTable, offcodeNCount, offcodeMaxValue, offcodeLog);
4122 { size_t const errorCode = FSEv07_buildDTable(dctx->MLTable, matchlengthNCount, matchlengthMaxValue, matchlengthLog);
4132 { size_t const errorCode = FSEv07_buildDTable(dctx->LLTable, litlengthNCount, litlengthMaxValue, litlengthLog);
4138 dctx->rep[0] = MEM_readLE32(dictPtr+0); if (dctx->rep[0] == 0 || dctx->rep[0] >= dictSize) return ERROR(dictionary_corrupted);
4139 dctx->rep[1] = MEM_readLE32(dictPtr+4); if (dctx->rep[1] == 0 || dctx->rep[1] >= dictSize) return ERROR(dictionary_corrupted);
4140 dctx->rep[2] = MEM_readLE32(dictPtr+8); if (dctx->rep[2] == 0 || dctx->rep[2] >= dictSize) return ERROR(dictionary_corrupted);
4143 dctx->litEntropy = dctx->fseEntropy = 1;
4147 static size_t ZSTDv07_decompress_insertDictionary(ZSTDv07_DCtx* dctx, const void* dict, size_t dictSize)
4149 if (dictSize < 8) return ZSTDv07_refDictContent(dctx, dict, dictSize);
4152 return ZSTDv07_refDictContent(dctx, dict, dictSize); /* pure content mode */
4154 dctx->dictID = MEM_readLE32((const char*)dict + 4);
4159 { size_t const eSize = ZSTDv07_loadEntropy(dctx, dict, dictSize);
4166 return ZSTDv07_refDictContent(dctx, dict, dictSize);
4170 size_t ZSTDv07_decompressBegin_usingDict(ZSTDv07_DCtx* dctx, const void* dict, size_t dictSize)
4172 { size_t const errorCode = ZSTDv07_decompressBegin(dctx);
4176 size_t const errorCode = ZSTDv07_decompress_insertDictionary(dctx, dict, dictSize);
4200 ZSTDv07_DCtx* const dctx = ZSTDv07_createDCtx_advanced(customMem);
4202 if (!dictContent || !ddict || !dctx) {
4205 customMem.customFree(customMem.opaque, dctx);
4210 { size_t const errorCode = ZSTDv07_decompressBegin_usingDict(dctx, dictContent, dictSize);
4214 customMem.customFree(customMem.opaque, dctx);
4220 ddict->refContext = dctx;
4247 ZSTDLIBv07_API size_t ZSTDv07_decompress_usingDDict(ZSTDv07_DCtx* dctx,
4252 return ZSTDv07_decompress_usingPreparedDCtx(dctx, ddict->refContext,