Lines Matching defs:zds
1519 size_t ZSTD_freeDStream(ZSTD_DStream* zds)
1521 return ZSTD_freeDCtx(zds);
1572 size_t ZSTD_initDStream_usingDict(ZSTD_DStream* zds, const void* dict, size_t dictSize)
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(zds->format);
1581 size_t ZSTD_initDStream(ZSTD_DStream* zds)
1584 return ZSTD_initDStream_usingDDict(zds, NULL);
1808 static int ZSTD_DCtx_isOverflow(ZSTD_DStream* zds, size_t const neededInBuffSize, size_t const neededOutBuffSize)
1810 return (zds->inBuffSize + zds->outBuffSize) >= (neededInBuffSize + neededOutBuffSize) * ZSTD_WORKSPACETOOLARGE_FACTOR;
1813 static void ZSTD_DCtx_updateOversizedDuration(ZSTD_DStream* zds, size_t const neededInBuffSize, size_t const neededOutBuffSize)
1815 if (ZSTD_DCtx_isOverflow(zds, neededInBuffSize, neededOutBuffSize))
1816 zds->oversizedDuration++;
1818 zds->oversizedDuration = 0;
1821 static int ZSTD_DCtx_isOversizedTooLong(ZSTD_DStream* zds)
1823 return zds->oversizedDuration >= ZSTD_WORKSPACETOOLARGE_MAXDURATION;
1827 static size_t ZSTD_checkOutBuffer(ZSTD_DStream const* zds, ZSTD_outBuffer const* output)
1829 ZSTD_outBuffer const expect = zds->expectedOutBuffer;
1831 if (zds->outBufferMode != ZSTD_bm_stable)
1836 if (zds->streamStage == zdss_init)
1850 ZSTD_DStream* zds, char** op, char* oend,
1852 int const isSkipFrame = ZSTD_isSkipFrame(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(zds,
1856 zds->outBuff + zds->outStart, dstSize, src, srcSize);
1859 zds->streamStage = zdss_read;
1861 zds->outEnd = zds->outStart + decodedSize;
1862 zds->streamStage = zdss_flush;
1867 size_t const decodedSize = ZSTD_decompressContinue(zds, *op, dstSize, src, srcSize);
1871 zds->streamStage = zdss_read;
1873 assert(zds->outBufferMode == ZSTD_bm_stable);
1878 size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inBuffer* input)
1902 FORWARD_IF_ERROR(ZSTD_checkOutBuffer(zds, output), "");
1905 switch(zds->streamStage)
1909 zds->streamStage = zdss_loadHeader;
1910 zds->lhSize = zds->inPos = zds->outStart = zds->outEnd = 0;
1911 zds->hostageByte = 0;
1912 zds->expectedOutBuffer = *output;
1917 { size_t const hSize = ZSTD_getFrameHeader_advanced(&zds->fParams, zds->headerBuffer, zds->lhSize, zds->format);
1918 if (zds->refMultipleDDicts && zds->ddictSet) {
1919 ZSTD_DCtx_selectFrameDDict(zds);
1926 size_t const toLoad = hSize - zds->lhSize; /* if hSize!=0, hSize > zds->lhSize */
1931 ZSTD_memcpy(zds->headerBuffer + zds->lhSize, ip, remainingInput);
1932 zds->lhSize += remainingInput;
1935 return (MAX((size_t)ZSTD_FRAMEHEADERSIZE_MIN(zds->format), hSize) - zds->lhSize) + ZSTD_blockHeaderSize; /* remaining header bytes + next block header */
1938 ZSTD_memcpy(zds->headerBuffer + zds->lhSize, ip, toLoad); zds->lhSize = hSize; ip += toLoad;
1943 if (zds->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN
1944 && zds->fParams.frameType != ZSTD_skippableFrame
1945 && (U64)(size_t)(oend-op) >= zds->fParams.frameContentSize) {
1949 size_t const decompressedSize = ZSTD_decompress_usingDDict(zds, op, (size_t)(oend-op), istart, cSize, ZSTD_getDDict(zds));
1954 zds->expected = 0;
1955 zds->streamStage = zdss_init;
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) {
1970 FORWARD_IF_ERROR(ZSTD_decompressBegin_usingDDict(zds, ZSTD_getDDict(zds)), "");
1972 if ((MEM_readLE32(zds->headerBuffer) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) { /* skippable frame */
1973 zds->expected = MEM_readLE32(zds->headerBuffer + ZSTD_FRAMEIDSIZE);
1974 zds->stage = ZSTDds_skipFrame;
1976 FORWARD_IF_ERROR(ZSTD_decodeFrameHeader(zds, zds->headerBuffer, zds->lhSize), "");
1977 zds->expected = ZSTD_blockHeaderSize;
1978 zds->stage = ZSTDds_decodeBlockHeader;
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,
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(zds->fParams.windowSize, zds->fParams.frameContentSize)
1995 ZSTD_DCtx_updateOversizedDuration(zds, neededInBuffSize, neededOutBuffSize);
1997 { int const tooSmall = (zds->inBuffSize < neededInBuffSize) || (zds->outBuffSize < neededOutBuffSize);
1998 int const tooLarge = ZSTD_DCtx_isOversizedTooLong(zds);
2003 (U32)zds->inBuffSize, (U32)neededInBuffSize);
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 */
2010 bufferSize > zds->staticSize - sizeof(ZSTD_DCtx),
2013 ZSTD_customFree(zds->inBuff, zds->customMem);
2014 zds->inBuffSize = 0;
2015 zds->outBuffSize = 0;
2016 zds->inBuff = (char*)ZSTD_customMalloc(bufferSize, zds->customMem);
2017 RETURN_ERROR_IF(zds->inBuff == NULL, memory_allocation, "");
2019 zds->inBuffSize = neededInBuffSize;
2020 zds->outBuff = zds->inBuff + zds->inBuffSize;
2021 zds->outBuffSize = neededOutBuffSize;
2023 zds->streamStage = zdss_read;
2028 { size_t const neededInSize = ZSTD_nextSrcSizeToDecompressWithInputSize(zds, (size_t)(iend - ip));
2031 zds->streamStage = zdss_init;
2036 FORWARD_IF_ERROR(ZSTD_decompressContinueStream(zds, &op, oend, ip, neededInSize), "");
2042 zds->streamStage = zdss_load;
2046 { size_t const neededInSize = ZSTD_nextSrcSizeToDecompress(zds);
2047 size_t const toLoad = neededInSize - zds->inPos;
2048 int const isSkipFrame = ZSTD_isSkipFrame(zds);
2051 assert(neededInSize == ZSTD_nextSrcSizeToDecompressWithInputSize(zds, iend - ip));
2055 RETURN_ERROR_IF(toLoad > zds->inBuffSize - zds->inPos,
2058 loadedSize = ZSTD_limitCopy(zds->inBuff + zds->inPos, toLoad, ip, (size_t)(iend-ip));
2061 zds->inPos += loadedSize;
2065 zds->inPos = 0; /* input is consumed */
2066 FORWARD_IF_ERROR(ZSTD_decompressContinueStream(zds, &op, oend, zds->inBuff, neededInSize), "");
2071 { size_t const toFlushSize = zds->outEnd - zds->outStart;
2072 size_t const flushedSize = ZSTD_limitCopy(op, (size_t)(oend-op), zds->outBuff + zds->outStart, toFlushSize);
2074 zds->outStart += flushedSize;
2076 zds->streamStage = zdss_read;
2077 if ( (zds->outBuffSize < zds->fParams.frameContentSize)
2078 && (zds->outStart + zds->fParams.blockSizeMax > zds->outBuffSize) ) {
2080 (int)(zds->outBuffSize - zds->outStart),
2081 (U32)zds->fParams.blockSizeMax);
2082 zds->outStart = zds->outEnd = 0;
2100 zds->expectedOutBuffer = *output;
2103 zds->noForwardProgress ++;
2104 if (zds->noForwardProgress >= ZSTD_NO_FORWARD_PROGRESS_MAX) {
2110 zds->noForwardProgress = 0;
2112 { size_t nextSrcSizeHint = ZSTD_nextSrcSizeToDecompress(zds);
2114 if (zds->outEnd == zds->outStart) { /* output fully flushed */
2115 if (zds->hostageByte) {
2118 zds->streamStage = zdss_read;
2122 } /* zds->hostageByte */
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 */
2127 zds->hostageByte=1;
2131 nextSrcSizeHint += ZSTD_blockHeaderSize * (ZSTD_nextInputType(zds) == ZSTDnit_block); /* preload header of next block */
2132 assert(zds->inPos <= nextSrcSizeHint);
2133 nextSrcSizeHint -= zds->inPos; /* part already loaded*/