Lines Matching refs:dstCapacity
2487 void* dst, size_t dstCapacity,
2503 BYTE* const oend = ostart + dstCapacity;
2525 op, dstCapacity,
2530 assert(cSize <= dstCapacity);
2605 void* dst, size_t dstCapacity,
2612 dst, dstCapacity,
2615 /* When srcSize <= dstCapacity, there is enough space to write a raw uncompressed block.
2618 if ((cSize == ERROR(dstSize_tooSmall)) & (srcSize <= dstCapacity))
2871 const size_t dstCapacity = ZSTD_compressBound(srcSize);
2872 void* dst = ZSTD_customMalloc(dstCapacity, ZSTD_defaultCMem);
2883 ZSTD_compress2(zc, dst, dstCapacity, src, srcSize);
3409 void* dst, size_t dstCapacity,
3425 RETURN_ERROR_IF(dstCapacity < ZSTD_blockHeaderSize, dstSize_tooSmall, "Block header doesn't fit");
3429 op + ZSTD_blockHeaderSize, dstCapacity - ZSTD_blockHeaderSize,
3452 cSize = ZSTD_noCompressBlock(op, dstCapacity, ip, srcSize, lastBlock);
3457 cSize = ZSTD_rleCompressBlock(op, dstCapacity, *ip, srcSize, lastBlock);
3553 ZSTD_compressBlock_splitBlock_internal(ZSTD_CCtx* zc, void* dst, size_t dstCapacity,
3586 DEBUGLOG(4, "ZSTD_compressBlock_splitBlock_internal (dstCapacity=%u, dictLimit=%u, nextToUpdate=%u)",
3587 (unsigned)dstCapacity, (unsigned)zc->blockState.matchState.window.dictLimit,
3593 op, dstCapacity,
3621 op, dstCapacity,
3629 dstCapacity -= cSizeChunk;
3643 void* dst, size_t dstCapacity,
3658 cSize = ZSTD_noCompressBlock(op, dstCapacity, ip, srcSize, lastBlock);
3666 cSize = ZSTD_compressBlock_splitBlock_internal(zc, dst, dstCapacity, src, srcSize, lastBlock, nbSeq);
3673 void* dst, size_t dstCapacity,
3684 DEBUGLOG(5, "ZSTD_compressBlock_internal (dstCapacity=%u, dictLimit=%u, nextToUpdate=%u)",
3685 (unsigned)dstCapacity, (unsigned)zc->blockState.matchState.window.dictLimit,
3703 dst, dstCapacity,
3736 void* dst, size_t dstCapacity,
3750 return ZSTD_rleCompressBlock(dst, dstCapacity, *(BYTE const*)src, srcSize, lastBlock);
3771 size_t const cSize = ZSTD_compressSuperBlock(zc, dst, dstCapacity, src, srcSize, lastBlock);
3787 return ZSTD_noCompressBlock(dst, dstCapacity, src, srcSize, lastBlock);
3791 void* dst, size_t dstCapacity,
3797 DEBUGLOG(5, "ZSTD_compressBlock_targetCBlockSize (dstCapacity=%u, dictLimit=%u, nextToUpdate=%u, srcSize=%zu)",
3798 (unsigned)dstCapacity, (unsigned)zc->blockState.matchState.window.dictLimit, (unsigned)zc->blockState.matchState.nextToUpdate, srcSize);
3801 cSize = ZSTD_compressBlock_targetCBlockSize_body(zc, dst, dstCapacity, src, srcSize, bss, lastBlock);
3837 * Function will issue an error if there is not enough `dstCapacity` to hold the compressed content.
3842 void* dst, size_t dstCapacity,
3863 RETURN_ERROR_IF(dstCapacity < ZSTD_blockHeaderSize + MIN_CBLOCK_SIZE,
3878 cSize = ZSTD_compressBlock_targetCBlockSize(cctx, op, dstCapacity, ip, blockSize, lastBlock);
3883 cSize = ZSTD_compressBlock_splitBlock(cctx, op, dstCapacity, ip, blockSize, lastBlock);
3888 op+ZSTD_blockHeaderSize, dstCapacity-ZSTD_blockHeaderSize,
3893 cSize = ZSTD_noCompressBlock(op, dstCapacity, ip, blockSize, lastBlock);
3909 assert(dstCapacity >= cSize);
3910 dstCapacity -= cSize;
3921 static size_t ZSTD_writeFrameHeader(void* dst, size_t dstCapacity,
3936 RETURN_ERROR_IF(dstCapacity < ZSTD_FRAMEHEADERSIZE_MAX, dstSize_tooSmall,
3975 size_t ZSTD_writeSkippableFrame(void* dst, size_t dstCapacity,
3978 RETURN_ERROR_IF(dstCapacity < srcSize + ZSTD_SKIPPABLEHEADERSIZE /* Skippable frame overhead */,
3992 * or an error code if `dstCapacity` is too small (<ZSTD_blockHeaderSize)
3994 size_t ZSTD_writeLastEmptyBlock(void* dst, size_t dstCapacity)
3996 RETURN_ERROR_IF(dstCapacity < ZSTD_blockHeaderSize, dstSize_tooSmall,
4021 void* dst, size_t dstCapacity,
4034 fhSize = ZSTD_writeFrameHeader(dst, dstCapacity, &cctx->appliedParams,
4037 assert(fhSize <= dstCapacity);
4038 dstCapacity -= fhSize;
4062 ZSTD_compress_frameChunk (cctx, dst, dstCapacity, src, srcSize, lastFrameChunk) :
4063 ZSTD_compressBlock_internal (cctx, dst, dstCapacity, src, srcSize, 0 /* frame */);
4082 void* dst, size_t dstCapacity,
4086 return ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 1 /* frame mode */, 0 /* last chunk */);
4097 size_t ZSTD_compressBlock(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
4103 return ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 0 /* frame mode */, 0 /* last chunk */);
4495 static size_t ZSTD_writeEpilogue(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity)
4506 fhSize = ZSTD_writeFrameHeader(dst, dstCapacity, &cctx->appliedParams, 0, 0);
4508 dstCapacity -= fhSize;
4516 RETURN_ERROR_IF(dstCapacity<4, dstSize_tooSmall, "no room for epilogue");
4519 dstCapacity -= ZSTD_blockHeaderSize;
4524 RETURN_ERROR_IF(dstCapacity<4, dstSize_tooSmall, "no room for checksum");
4541 void* dst, size_t dstCapacity,
4546 dst, dstCapacity, src, srcSize,
4549 endResult = ZSTD_writeEpilogue(cctx, (char*)dst + cSize, dstCapacity-cSize);
4567 void* dst, size_t dstCapacity,
4576 dst, dstCapacity,
4585 void* dst, size_t dstCapacity,
4594 return ZSTD_compressEnd(cctx, dst, dstCapacity, src, srcSize);
4598 void* dst, size_t dstCapacity,
4609 return ZSTD_compress_advanced_internal(cctx, dst, dstCapacity, src, srcSize, dict, dictSize, &cctx->simpleApiParams);
4613 void* dst, size_t dstCapacity,
4619 return ZSTD_compress_usingDict(cctx, dst, dstCapacity, src, srcSize, NULL, 0, compressionLevel);
4622 size_t ZSTD_compress(void* dst, size_t dstCapacity,
4629 result = ZSTD_compressCCtx(cctx, dst, dstCapacity, src, srcSize, compressionLevel);
4998 void* dst, size_t dstCapacity,
5003 return ZSTD_compressEnd(cctx, dst, dstCapacity, src, srcSize);
5010 void* dst, size_t dstCapacity,
5014 return ZSTD_compress_usingCDict_internal(cctx, dst, dstCapacity, src, srcSize, cdict, fParams);
5023 void* dst, size_t dstCapacity,
5028 return ZSTD_compress_usingCDict_internal(cctx, dst, dstCapacity, src, srcSize, cdict, fParams);
5509 void* dst, size_t dstCapacity, size_t* dstPos,
5513 ZSTD_outBuffer output = { dst, dstCapacity, *dstPos };
5523 void* dst, size_t dstCapacity,
5536 dst, dstCapacity, &oPos,
5544 assert(oPos == dstCapacity);
5803 void* dst, size_t dstCapacity,
5822 RETURN_ERROR_IF(dstCapacity<4, dstSize_tooSmall, "No room for empty frame block header");
5825 dstCapacity -= ZSTD_blockHeaderSize;
5843 cBlockSize = ZSTD_noCompressBlock(op, dstCapacity, ip, blockSize, lastBlock);
5850 dstCapacity -= cBlockSize;
5857 op + ZSTD_blockHeaderSize /* Leave space for block header */, dstCapacity - ZSTD_blockHeaderSize,
5876 cBlockSize = ZSTD_noCompressBlock(op, dstCapacity, ip, blockSize, lastBlock);
5880 cBlockSize = ZSTD_rleCompressBlock(op, dstCapacity, *ip, blockSize, lastBlock);
5906 dstCapacity -= cBlockSize;
5914 size_t ZSTD_compressSequences(ZSTD_CCtx* const cctx, void* dst, size_t dstCapacity,
5928 frameHeaderSize = ZSTD_writeFrameHeader(op, dstCapacity, &cctx->appliedParams, srcSize, cctx->dictID);
5930 dstCapacity -= frameHeaderSize;
5937 op, dstCapacity,
5942 dstCapacity -= compressedBlocksSize;
5946 RETURN_ERROR_IF(dstCapacity<4, dstSize_tooSmall, "no room for checksum");