Lines Matching refs:cctxPtr
481 LZ4F_cctx_t* cctxPtr;
482 result = LZ4F_createCompressionContext(&cctxPtr, LZ4F_VERSION);
487 LZ4F_cctx_t* const cctxPtr = &cctx;
495 cctxPtr->lz4CtxPtr = &lz4ctx;
496 cctxPtr->lz4CtxAlloc = 1;
497 cctxPtr->lz4CtxState = 1;
502 result = LZ4F_compressFrame_usingCDict(cctxPtr, dstBuffer, dstCapacity,
507 LZ4F_freeCompressionContext(cctxPtr);
511 LZ4F_free(cctxPtr->lz4CtxPtr, cctxPtr->cmem);
588 LZ4F_cctx* const cctxPtr =
590 if (cctxPtr==NULL) return NULL;
592 cctxPtr->cmem = customMem;
593 cctxPtr->version = version;
594 cctxPtr->cStage = 0; /* Uninitialized. Next stage : init cctx */
596 return cctxPtr;
620 LZ4F_errorCode_t LZ4F_freeCompressionContext(LZ4F_cctx* cctxPtr)
622 if (cctxPtr != NULL) { /* support free on NULL */
623 LZ4F_free(cctxPtr->lz4CtxPtr, cctxPtr->cmem); /* note: LZ4_streamHC_t and LZ4_stream_t are simple POD types */
624 LZ4F_free(cctxPtr->tmpBuff, cctxPtr->cmem);
625 LZ4F_free(cctxPtr, cctxPtr->cmem);
677 size_t LZ4F_compressBegin_usingCDict(LZ4F_cctx* cctxPtr,
688 cctxPtr->prefs = *preferencesPtr;
691 { U16 const ctxTypeID = (cctxPtr->prefs.compressionLevel < LZ4HC_CLEVEL_MIN) ? 1 : 2;
693 int allocatedSize = ctxTypeID_to_size(cctxPtr->lz4CtxAlloc);
696 LZ4F_free(cctxPtr->lz4CtxPtr, cctxPtr->cmem);
697 if (cctxPtr->prefs.compressionLevel < LZ4HC_CLEVEL_MIN) {
700 cctxPtr->lz4CtxPtr = LZ4F_malloc(sizeof(LZ4_stream_t), cctxPtr->cmem);
701 if (cctxPtr->lz4CtxPtr)
702 LZ4_initStream(cctxPtr->lz4CtxPtr, sizeof(LZ4_stream_t));
704 cctxPtr->lz4CtxPtr = LZ4F_malloc(sizeof(LZ4_streamHC_t), cctxPtr->cmem);
705 if (cctxPtr->lz4CtxPtr)
706 LZ4_initStreamHC(cctxPtr->lz4CtxPtr, sizeof(LZ4_streamHC_t));
708 RETURN_ERROR_IF(cctxPtr->lz4CtxPtr == NULL, allocation_failed);
709 cctxPtr->lz4CtxAlloc = ctxTypeID;
710 cctxPtr->lz4CtxState = ctxTypeID;
711 } else if (cctxPtr->lz4CtxState != ctxTypeID) {
714 if (cctxPtr->prefs.compressionLevel < LZ4HC_CLEVEL_MIN) {
715 LZ4_initStream((LZ4_stream_t*)cctxPtr->lz4CtxPtr, sizeof(LZ4_stream_t));
717 LZ4_initStreamHC((LZ4_streamHC_t*)cctxPtr->lz4CtxPtr, sizeof(LZ4_streamHC_t));
718 LZ4_setCompressionLevel((LZ4_streamHC_t*)cctxPtr->lz4CtxPtr, cctxPtr->prefs.compressionLevel);
720 cctxPtr->lz4CtxState = ctxTypeID;
724 if (cctxPtr->prefs.frameInfo.blockSizeID == 0)
725 cctxPtr->prefs.frameInfo.blockSizeID = LZ4F_BLOCKSIZEID_DEFAULT;
726 cctxPtr->maxBlockSize = LZ4F_getBlockSize(cctxPtr->prefs.frameInfo.blockSizeID);
729 ((cctxPtr->prefs.frameInfo.blockMode == LZ4F_blockLinked) ? 64 KB : 0) : /* only needs past data up to window size */
730 cctxPtr->maxBlockSize + ((cctxPtr->prefs.frameInfo.blockMode == LZ4F_blockLinked) ? 128 KB : 0);
732 if (cctxPtr->maxBufferSize < requiredBuffSize) {
733 cctxPtr->maxBufferSize = 0;
734 LZ4F_free(cctxPtr->tmpBuff, cctxPtr->cmem);
735 cctxPtr->tmpBuff = (BYTE*)LZ4F_calloc(requiredBuffSize, cctxPtr->cmem);
736 RETURN_ERROR_IF(cctxPtr->tmpBuff == NULL, allocation_failed);
737 cctxPtr->maxBufferSize = requiredBuffSize;
739 cctxPtr->tmpIn = cctxPtr->tmpBuff;
740 cctxPtr->tmpInSize = 0;
741 (void)XXH32_reset(&(cctxPtr->xxh), 0);
744 cctxPtr->cdict = cdict;
745 if (cctxPtr->prefs.frameInfo.blockMode == LZ4F_blockLinked) {
747 LZ4F_initStream(cctxPtr->lz4CtxPtr, cdict, cctxPtr->prefs.compressionLevel, LZ4F_blockLinked);
750 LZ4_favorDecompressionSpeed((LZ4_streamHC_t*)cctxPtr->lz4CtxPtr, (int)preferencesPtr->favorDecSpeed);
760 + ((cctxPtr->prefs.frameInfo.blockMode & _1BIT ) << 5)
761 + ((cctxPtr->prefs.frameInfo.blockChecksumFlag & _1BIT ) << 4)
762 + ((unsigned)(cctxPtr->prefs.frameInfo.contentSize > 0) << 3)
763 + ((cctxPtr->prefs.frameInfo.contentChecksumFlag & _1BIT ) << 2)
764 + (cctxPtr->prefs.frameInfo.dictID > 0) );
766 *dstPtr++ = (BYTE)((cctxPtr->prefs.frameInfo.blockSizeID & _3BITS) << 4);
768 if (cctxPtr->prefs.frameInfo.contentSize) {
769 LZ4F_writeLE64(dstPtr, cctxPtr->prefs.frameInfo.contentSize);
771 cctxPtr->totalInSize = 0;
774 if (cctxPtr->prefs.frameInfo.dictID) {
775 LZ4F_writeLE32(dstPtr, cctxPtr->prefs.frameInfo.dictID);
783 cctxPtr->cStage = 1; /* header written, now request input data block */
795 size_t LZ4F_compressBegin(LZ4F_cctx* cctxPtr,
799 return LZ4F_compressBegin_usingCDict(cctxPtr, dstBuffer, dstCapacity,
906 static int LZ4F_localSaveDict(LZ4F_cctx_t* cctxPtr)
908 if (cctxPtr->prefs.compressionLevel < LZ4HC_CLEVEL_MIN)
909 return LZ4_saveDict ((LZ4_stream_t*)(cctxPtr->lz4CtxPtr), (char*)(cctxPtr->tmpBuff), 64 KB);
910 return LZ4_saveDictHC ((LZ4_streamHC_t*)(cctxPtr->lz4CtxPtr), (char*)(cctxPtr->tmpBuff), 64 KB);
930 static size_t LZ4F_compressUpdateImpl(LZ4F_cctx* cctxPtr,
936 size_t const blockSize = cctxPtr->maxBlockSize;
942 compressFunc_t const compress = LZ4F_selectCompression(cctxPtr->prefs.frameInfo.blockMode, cctxPtr->prefs.compressionLevel, blockCompression);
946 RETURN_ERROR_IF(cctxPtr->cStage != 1, compressionState_uninitialized); /* state must be initialized and waiting for next block */
947 if (dstCapacity < LZ4F_compressBound_internal(srcSize, &(cctxPtr->prefs), cctxPtr->tmpInSize))
954 if (cctxPtr->blockCompression != blockCompression) {
955 bytesWritten = LZ4F_flush(cctxPtr, dstBuffer, dstCapacity, compressOptionsPtr);
957 cctxPtr->blockCompression = blockCompression;
963 if (cctxPtr->tmpInSize > 0) { /* some data already within tmp buffer */
964 size_t const sizeToCopy = blockSize - cctxPtr->tmpInSize;
965 assert(blockSize > cctxPtr->tmpInSize);
968 memcpy(cctxPtr->tmpIn + cctxPtr->tmpInSize, srcBuffer, srcSize);
970 cctxPtr->tmpInSize += srcSize;
975 memcpy(cctxPtr->tmpIn + cctxPtr->tmpInSize, srcBuffer, sizeToCopy);
979 cctxPtr->tmpIn, blockSize,
980 compress, cctxPtr->lz4CtxPtr, cctxPtr->prefs.compressionLevel,
981 cctxPtr->cdict,
982 cctxPtr->prefs.frameInfo.blockChecksumFlag);
983 if (cctxPtr->prefs.frameInfo.blockMode==LZ4F_blockLinked) cctxPtr->tmpIn += blockSize;
984 cctxPtr->tmpInSize = 0;
992 compress, cctxPtr->lz4CtxPtr, cctxPtr->prefs.compressionLevel,
993 cctxPtr->cdict,
994 cctxPtr->prefs.frameInfo.blockChecksumFlag);
998 if ((cctxPtr->prefs.autoFlush) && (srcPtr < srcEnd)) {
1003 compress, cctxPtr->lz4CtxPtr, cctxPtr->prefs.compressionLevel,
1004 cctxPtr->cdict,
1005 cctxPtr->prefs.frameInfo.blockChecksumFlag);
1010 if ((cctxPtr->prefs.frameInfo.blockMode==LZ4F_blockLinked) && (lastBlockCompressed==fromSrcBuffer)) {
1014 cctxPtr->tmpIn = cctxPtr->tmpBuff; /* src is stable : dictionary remains in src across invocations */
1016 int const realDictSize = LZ4F_localSaveDict(cctxPtr);
1018 cctxPtr->tmpIn = cctxPtr->tmpBuff + realDictSize;
1023 if (!(cctxPtr->prefs.autoFlush) /* no autoflush : there may be some data left within internal buffer */
1024 && (cctxPtr->tmpIn + blockSize) > (cctxPtr->tmpBuff + cctxPtr->maxBufferSize) ) /* not enough room to store next block */
1028 int const realDictSize = LZ4F_localSaveDict(cctxPtr);
1029 cctxPtr->tmpIn = cctxPtr->tmpBuff + realDictSize;
1030 assert((cctxPtr->tmpIn + blockSize) <= (cctxPtr->tmpBuff + cctxPtr->maxBufferSize));
1037 memcpy(cctxPtr->tmpIn, srcPtr, sizeToCopy);
1038 cctxPtr->tmpInSize = sizeToCopy;
1041 if (cctxPtr->prefs.frameInfo.contentChecksumFlag == LZ4F_contentChecksumEnabled)
1042 (void)XXH32_update(&(cctxPtr->xxh), srcBuffer, srcSize);
1044 cctxPtr->totalInSize += srcSize;
1060 size_t LZ4F_compressUpdate(LZ4F_cctx* cctxPtr,
1065 return LZ4F_compressUpdateImpl(cctxPtr,
1084 size_t LZ4F_uncompressedUpdate(LZ4F_cctx* cctxPtr,
1088 RETURN_ERROR_IF(cctxPtr->prefs.frameInfo.blockMode != LZ4F_blockIndependent, blockMode_invalid);
1089 return LZ4F_compressUpdateImpl(cctxPtr,
1104 size_t LZ4F_flush(LZ4F_cctx* cctxPtr,
1112 if (cctxPtr->tmpInSize == 0) return 0; /* nothing to flush */
1113 RETURN_ERROR_IF(cctxPtr->cStage != 1, compressionState_uninitialized);
1114 RETURN_ERROR_IF(dstCapacity < (cctxPtr->tmpInSize + BHSize + BFSize), dstMaxSize_tooSmall);
1118 compress = LZ4F_selectCompression(cctxPtr->prefs.frameInfo.blockMode, cctxPtr->prefs.compressionLevel, cctxPtr->blockCompression);
1122 cctxPtr->tmpIn, cctxPtr->tmpInSize,
1123 compress, cctxPtr->lz4CtxPtr, cctxPtr->prefs.compressionLevel,
1124 cctxPtr->cdict,
1125 cctxPtr->prefs.frameInfo.blockChecksumFlag);
1128 if (cctxPtr->prefs.frameInfo.blockMode == LZ4F_blockLinked)
1129 cctxPtr->tmpIn += cctxPtr->tmpInSize;
1130 cctxPtr->tmpInSize = 0;
1133 if ((cctxPtr->tmpIn + cctxPtr->maxBlockSize) > (cctxPtr->tmpBuff + cctxPtr->maxBufferSize)) { /* necessarily LZ4F_blockLinked */
1134 int const realDictSize = LZ4F_localSaveDict(cctxPtr);
1135 cctxPtr->tmpIn = cctxPtr->tmpBuff + realDictSize;
1151 size_t LZ4F_compressEnd(LZ4F_cctx* cctxPtr,
1158 size_t const flushSize = LZ4F_flush(cctxPtr, dstBuffer, dstCapacity, compressOptionsPtr);
1170 if (cctxPtr->prefs.frameInfo.contentChecksumFlag == LZ4F_contentChecksumEnabled) {
1171 U32 const xxh = XXH32_digest(&(cctxPtr->xxh));
1178 cctxPtr->cStage = 0; /* state is now re-usable (with identical preferences) */
1179 cctxPtr->maxBufferSize = 0; /* reuse HC context */
1181 if (cctxPtr->prefs.frameInfo.contentSize) {
1182 if (cctxPtr->prefs.frameInfo.contentSize != cctxPtr->totalInSize)