react-native-update 10.34.3 → 10.34.4

package/harmony/pushy/src/main/cpp/HDiffPatch/compress_plugin_demo.h

@@ -28,10 +28,8 @@
 #ifndef HDiff_compress_plugin_demo_h
 #define HDiff_compress_plugin_demo_h
 //compress plugin demo:
-//  zlibCompressPlugin      // zlib's deflate encoding
-//  pzlibCompressPlugin     // compatible with zlib's deflate encoding
-//  ldefCompressPlugin      // compatible with zlib's deflate encoding
-//  pldefCompressPlugin     // compatible with zlib's deflate encoding
+//  zlibCompressPlugin
+//  pzlibCompressPlugin
 //  bz2CompressPlugin
 //  pbz2CompressPlugin
 //  lzmaCompressPlugin
@@ -41,9 +39,6 @@
 //  zstdCompressPlugin
 //  brotliCompressPlugin
 //  lzhamCompressPlugin
-//  tuzCompressPlugin
-
-// _7zXZCompressPlugin : support for create_vcdiff(), compatible with "xdelta3 -S lzma ..."
 
 #include "libHDiffPatch/HDiff/diff_types.h"
 #include "compress_parallel.h"
@@ -103,16 +98,13 @@ static const char*  _fun_name(void){            \
     return kCompressType;                       \
 }
 
-#ifndef __DEF_default_maxCompressedSize
-#define __DEF_default_maxCompressedSize
-static hpatch_StreamPos_t _default_maxCompressedSize(hpatch_StreamPos_t dataSize){
-    hpatch_StreamPos_t result=dataSize+(dataSize>>3)+256;
+hpatch_inline static
+hpatch_StreamPos_t _default_maxCompressedSize(hpatch_StreamPos_t dataSize){
+    hpatch_StreamPos_t result=dataSize+(dataSize>>3)+1024*2;
     assert(result>dataSize);
     return result;
 }
-#endif
-
-static
+hpatch_inline static
 int _default_setParallelThreadNumber(hdiff_TCompress* compressPlugin,int threadNum){
     return 1;
 }
@@ -125,7 +117,7 @@ int _default_setParallelThreadNumber(hdiff_TCompress* compressPlugin,int threadN
         hdiff_TCompress base;
         int             compress_level; //0..9
         int             mem_level;
-        signed char     windowBits; // -9..-15
+        signed char     windowBits;
         hpatch_BOOL     isNeedSaveWindowBits;
         int             strategy;
     } TCompressPlugin_zlib;
@@ -136,43 +128,36 @@ int _default_setParallelThreadNumber(hdiff_TCompress* compressPlugin,int threadN
         z_stream        c_stream;
     } _zlib_TCompress;
 
-    static _zlib_TCompress*  _zlib_compress_open_at(const hdiff_TCompress* compressPlugin,
+    static _zlib_TCompress*  _zlib_compress_open_by(const hdiff_TCompress* compressPlugin,
                                                     int compressLevel,int compressMemLevel,
                                                     const hpatch_TStreamOutput* out_code,
-                                                    _zlib_TCompress* self,size_t _self_and_buf_size){
+                                                    unsigned char* _mem_buf,size_t _mem_buf_size){
         const TCompressPlugin_zlib* plugin=(const TCompressPlugin_zlib*)compressPlugin;
-        assert(_self_and_buf_size>sizeof(_zlib_TCompress));
+        _zlib_TCompress* self=0;
+        
+        self=(_zlib_TCompress*)_hpatch_align_upper(_mem_buf,sizeof(hpatch_StreamPos_t));
+        assert((_mem_buf+_mem_buf_size)>((unsigned char*)self+sizeof(_zlib_TCompress)));
+        _mem_buf_size=(_mem_buf+_mem_buf_size)-((unsigned char*)self+sizeof(_zlib_TCompress));
+        _mem_buf=(unsigned char*)self+sizeof(_zlib_TCompress);
+        
         memset(self,0,sizeof(_zlib_TCompress));
-        self->c_buf=((unsigned char*)self)+sizeof(_zlib_TCompress);;
-        self->c_buf_size=_self_and_buf_size-sizeof(_zlib_TCompress);
+        self->c_buf=_mem_buf;
+        self->c_buf_size=_mem_buf_size;
         self->out_code=out_code;
         
-        self->c_stream.next_out = (Bytef*)self->c_buf;
-        self->c_stream.avail_out = (uInt)self->c_buf_size;
+        self->c_stream.next_out = (Bytef*)_mem_buf;
+        self->c_stream.avail_out = (uInt)_mem_buf_size;
         if (Z_OK!=deflateInit2(&self->c_stream,compressLevel,Z_DEFLATED,
                                plugin->windowBits,compressMemLevel,plugin->strategy))
             return 0;
         return self;
     }
-    static _zlib_TCompress*  _zlib_compress_open_by(const hdiff_TCompress* compressPlugin,
-                                                    int compressLevel,int compressMemLevel,
-                                                    const hpatch_TStreamOutput* out_code,
-                                                    unsigned char* _mem_buf,size_t _mem_buf_size){
-        #define __MAX_TS(a,b)  ((a)>=(b)?(a):(b))
-        const hpatch_size_t kZlibAlign=__MAX_TS(__MAX_TS(sizeof(hpatch_StreamPos_t),sizeof(void*)),sizeof(uLongf));
-        #undef __MAX_TS
-        unsigned char* _mem_buf_end=_mem_buf+_mem_buf_size;
-        unsigned char* self_at=(unsigned char*)_hpatch_align_upper(_mem_buf,kZlibAlign);
-        if (self_at>=_mem_buf_end) return 0;
-        return _zlib_compress_open_at(compressPlugin,compressLevel,compressMemLevel,out_code,
-                                      (_zlib_TCompress*)self_at,_mem_buf_end-self_at);
-    }
-    static hpatch_BOOL _zlib_compress_close_by(const hdiff_TCompress* compressPlugin,_zlib_TCompress* self){
-        hpatch_BOOL result=hpatch_TRUE;
+    static int _zlib_compress_close_by(const hdiff_TCompress* compressPlugin,_zlib_TCompress* self){
+        int result=1;//true;
         if (!self) return result;
         if (self->c_stream.state!=0){
             int ret=deflateEnd(&self->c_stream);
-            result=(Z_OK==ret)|(Z_DATA_ERROR==ret);
+            result=(Z_OK==ret);
         }
         memset(self,0,sizeof(_zlib_TCompress));
         return result;
@@ -237,11 +222,11 @@ int _default_setParallelThreadNumber(hdiff_TCompress* compressPlugin,int threadN
         data_buf=_temp_buf+sizeof(_zlib_TCompress)+kCompressBufSize;
         if (!self) _compress_error_return("deflateInit2()");
         if (plugin->isNeedSaveWindowBits){
-            const unsigned char* pchar=(const unsigned char*)&plugin->windowBits;
+            unsigned char* pchar=(unsigned char*)&plugin->windowBits;
             if (!out_code->write(out_code,0,pchar,pchar+1)) _compress_error_return("out_code->write()");
             ++result;
         }
-        while (readFromPos<in_data->streamSize){
+        do {
             size_t readLen=kCompressBufSize;
             if (readLen>(hpatch_StreamPos_t)(in_data->streamSize-readFromPos))
                 readLen=(size_t)(in_data->streamSize-readFromPos);
@@ -251,7 +236,7 @@ int _default_setParallelThreadNumber(hdiff_TCompress* compressPlugin,int threadN
             if (!_zlib_compress_part(self,data_buf,data_buf+readLen,
                                      (readFromPos==in_data->streamSize),&result,&outStream_isCanceled))
                 _compress_error_return("_zlib_compress_part()");
-        }
+        } while (readFromPos<in_data->streamSize);
     clear:
         if (!_zlib_compress_close_by(compressPlugin,self))
             { result=kCompressFailResult; if (strlen(errAt)==0) errAt="deflateEnd()"; }
@@ -276,90 +261,49 @@ int _default_setParallelThreadNumber(hdiff_TCompress* compressPlugin,int threadN
         plugin->thread_num=threadNum;
         return threadNum;
     }
+    static hdiff_compressBlockHandle _pzlib_openBlockCompressor(hdiff_TParallelCompress* pc){
+        return pc;
+    }
     static void _pzlib_closeBlockCompressor(hdiff_TParallelCompress* pc,
                                             hdiff_compressBlockHandle blockCompressor){
-        z_stream* stream=(z_stream*)blockCompressor;
-        if (!stream) return;
-        if (stream->state!=0){
-            int ret=deflateEnd(stream);
-            assert((Z_OK==ret)|(Z_DATA_ERROR==ret));
-        }
-        free(stream);
-    }
-    static hdiff_compressBlockHandle _pzlib_openBlockCompressor(hdiff_TParallelCompress* pc){
-        const TCompressPlugin_pzlib* plugin=(const TCompressPlugin_pzlib*)pc->import;
-        z_stream* stream=(z_stream*)malloc(sizeof(z_stream));
-        if (!stream) return 0;
-        memset(stream,0,sizeof(z_stream));
-        int err = deflateInit2(stream,plugin->base.compress_level,Z_DEFLATED,
-                               plugin->base.windowBits,plugin->base.mem_level,Z_DEFAULT_STRATEGY);
-        if (err!=Z_OK){//error
-            _pzlib_closeBlockCompressor(pc,stream);
-            return 0;
-        }
-        return stream;
+        assert(blockCompressor==pc);
     }
-    static int _pzlib_compress2(Bytef* dest,uLongf* destLen,const unsigned char* block_data,
-                                const unsigned char* block_dictEnd,const unsigned char* block_dataEnd,
-                                int isEndBlock,z_stream* stream){
+    static int _pzlib_compress2(Bytef* dest,uLongf* destLen,const Bytef* source,uLong sourceLen,
+                                int level,int mem_level,int windowBits){
+        z_stream stream;
         int err;
-        #define _check_zlib_err(_must_V) { if (err!=(_must_V)) goto _errorReturn; } 
-        err=deflateReset(stream);
-        _check_zlib_err(Z_OK);
-        stream->next_in   = (Bytef*)block_dictEnd;
-        stream->avail_in  = (uInt)(block_dataEnd-block_dictEnd);
-        stream->next_out  = dest;
-        stream->avail_out = (uInt)*destLen;
-        stream->total_out = 0;
-        if (block_data<block_dictEnd){
-            err=deflateSetDictionary(stream,(Bytef*)block_data,(uInt)(block_dictEnd-block_data));
-            _check_zlib_err(Z_OK);
+        stream.next_in   = (Bytef *)source;
+        stream.avail_in  = (uInt)sourceLen;
+        stream.next_out  = dest;
+        stream.avail_out = (uInt)*destLen;
+        stream.zalloc = 0;
+        stream.zfree  = 0;
+        stream.opaque = 0;
+        err = deflateInit2(&stream,level,Z_DEFLATED,windowBits,mem_level,Z_DEFAULT_STRATEGY);
+        if (err != Z_OK) return err;
+        err = deflate(&stream, Z_FINISH);
+        if (err != Z_STREAM_END){
+            deflateEnd(&stream);
+            return err == Z_OK ? Z_BUF_ERROR : err;
         }
-        if (!isEndBlock){
-            int bits; 
-            err = deflate(stream,Z_BLOCK);
-            _check_zlib_err(Z_OK);
-            // add enough empty blocks to get to a byte boundary
-            err = deflatePending(stream,Z_NULL,&bits);
-            _check_zlib_err(Z_OK);
-            if (bits & 1){
-                err = deflate(stream,Z_SYNC_FLUSH);
-                _check_zlib_err(Z_OK);
-            } else if (bits & 7) {
-                do { // add static empty blocks
-                    err = deflatePrime(stream, 10, 2);
-                    _check_zlib_err(Z_OK);
-                    err = deflatePending(stream,Z_NULL,&bits);
-                    _check_zlib_err(Z_OK);
-                } while (bits & 7);
-                err = deflate(stream,Z_BLOCK);
-                _check_zlib_err(Z_OK);
-            }
-        }else{
-            err = deflate(stream,Z_FINISH);
-            _check_zlib_err(Z_STREAM_END);
-            err=Z_OK;
-        }
-        *destLen = stream->total_out;
+        *destLen = stream.total_out;
+        err = deflateEnd(&stream);
         return err;
-    _errorReturn:
-        return err == Z_OK ? Z_BUF_ERROR : err;
-        #undef _check_zlib_err
     }
     static
     size_t _pzlib_compressBlock(hdiff_TParallelCompress* pc,hdiff_compressBlockHandle blockCompressor,
-                                hpatch_StreamPos_t blockIndex,hpatch_StreamPos_t blockCount,unsigned char* out_code,unsigned char* out_codeEnd,
-                                const unsigned char* block_data,const unsigned char* block_dictEnd,const unsigned char* block_dataEnd){
+                                hpatch_StreamPos_t blockIndex,unsigned char* out_code,unsigned char* out_codeEnd,
+                                const unsigned char* block_data,const unsigned char* block_dataEnd){
         const TCompressPlugin_pzlib* plugin=(const TCompressPlugin_pzlib*)pc->import;
-        const hpatch_BOOL isAdding=(blockIndex==0)&&(plugin->base.isNeedSaveWindowBits);
+        hpatch_BOOL isAdding=(blockIndex==0)&&(plugin->base.isNeedSaveWindowBits);
         if (isAdding){
             if (out_code>=out_codeEnd) return 0;//error;
             out_code[0]=plugin->base.windowBits;
             ++out_code;
         }
         uLongf codeLen=(uLongf)(out_codeEnd-out_code);
-        if (Z_OK!=_pzlib_compress2(out_code,&codeLen,block_data,block_dictEnd,block_dataEnd,
-                                   blockIndex+1==blockCount?1:0,(z_stream*)blockCompressor))
+        if (Z_OK!=_pzlib_compress2(out_code,&codeLen,block_data,(uLong)(block_dataEnd-block_data),
+                                   plugin->base.compress_level,plugin->base.mem_level,plugin->base.windowBits))
             return 0; //error
         return codeLen+(isAdding?1:0);
     }
@@ -367,185 +311,26 @@ int _default_setParallelThreadNumber(hdiff_TCompress* compressPlugin,int threadN
                                               const hpatch_TStreamOutput* out_code,
                                               const hpatch_TStreamInput*  in_data){
         TCompressPlugin_pzlib* plugin=(TCompressPlugin_pzlib*)compressPlugin;
-        const size_t blockSize=256*1024;
+        const size_t blockSize=(plugin->base.compress_level>1)?
+                    1024*128*(plugin->base.compress_level-1):1024*128;
         if ((plugin->thread_num<=1)||(plugin->base.compress_level==0)
                 ||(in_data->streamSize<blockSize*2)){ //same as "zlib"
             return _zlib_compress(compressPlugin,out_code,in_data);
         }else{
-            int dictBits=plugin->base.windowBits;
-            if (dictBits<0) dictBits=-dictBits;
-            if (dictBits>15) dictBits-=16;
-            if (dictBits<9) dictBits=9;
-            else if (dictBits>15) dictBits=15;
             plugin->pc.import=plugin;
-            return parallel_compress_blocks(&plugin->pc,plugin->thread_num,((size_t)1<<dictBits),blockSize,out_code,in_data);
+            return parallel_compress_blocks(&plugin->pc,plugin->thread_num,blockSize,out_code,in_data);
         }
     }
     
+    _def_fun_compressType(_pzlib_compressType,"pzlib");
     static const TCompressPlugin_pzlib pzlibCompressPlugin={
-        { {_zlib_compressType,_default_maxCompressedSize,_pzlib_setThreadNum,_pzlib_compress},
+        { {_pzlib_compressType,_default_maxCompressedSize,_pzlib_setThreadNum,_pzlib_compress},
             6,8,-MAX_WBITS,hpatch_TRUE,Z_DEFAULT_STRATEGY},
         kDefaultCompressThreadNumber ,{0,_default_maxCompressedSize,_pzlib_openBlockCompressor,
             _pzlib_closeBlockCompressor,_pzlib_compressBlock} };
 #   endif // _IS_USED_MULTITHREAD
 #endif//_CompressPlugin_zlib
-
-
-#ifdef  _CompressPlugin_ldef
-#if (_IsNeedIncludeDefaultCompressHead)
-#   include "libdeflate.h" // "libdeflate/libdeflate.h" https://github.com/sisong/libdeflate/tree/stream-mt based on https://github.com/ebiggers/libdeflate
-#endif
-    static const signed char _ldef_kWindowBits=-15; //always as zlib's windowBits -15
-    static const size_t _ldef_kDictSize=(1<<15);
-    static const size_t _ldef_kMax_in_border_nbytes=258;//deflate max match len
-    static size_t _ldef_getBestWorkStepSize(hpatch_StreamPos_t data_size,size_t compress_level,size_t thread_num){
-        const size_t _kMinBaseStep=600000;
-        size_t base_step_size=1024*1024*2;
-        hpatch_StreamPos_t work_count=(data_size+base_step_size-1)/base_step_size;
-        if (work_count>=thread_num) return base_step_size;
-        size_t step_size=(size_t)((data_size+thread_num-1)/thread_num);
-        const size_t minStep=_kMinBaseStep;
-        step_size=(step_size>minStep)?step_size:minStep;
-        return step_size;
-    }
-    typedef struct{
-        hdiff_TCompress base;
-        int             compress_level; //0..12
-        hpatch_BOOL     isNeedSaveWindowBits;
-    } TCompressPlugin_ldef;
-
-    static hpatch_StreamPos_t _ldef_compress(const hdiff_TCompress* compressPlugin,
-                                             const hpatch_TStreamOutput* out_code,
-                                             const hpatch_TStreamInput*  in_data){
-        const TCompressPlugin_ldef* plugin=(const TCompressPlugin_ldef*)compressPlugin;
-        hpatch_StreamPos_t result=0; //writedPos
-        hpatch_StreamPos_t readFromPos=0;
-        const char*        errAt="";
-        int                 outStream_isCanceled=0;
-        unsigned char*     data_buf=0;
-        unsigned char*     code_buf=0;
-        struct libdeflate_compressor* c=0;
-        size_t in_border_nbytes=0;
-        const size_t in_step_size=_ldef_getBestWorkStepSize(in_data->streamSize,plugin->compress_level,1);
-        const size_t _in_buf_size=_ldef_kDictSize+in_step_size+_ldef_kMax_in_border_nbytes;
-        const size_t block_bound=libdeflate_deflate_compress_bound_block(in_step_size);
-
-        data_buf=(unsigned char*)malloc(_in_buf_size+block_bound);
-        if (!data_buf) _compress_error_return("memory alloc");
-        code_buf=data_buf+_in_buf_size;
-
-        c=libdeflate_alloc_compressor(plugin->compress_level);
-        if (!c) _compress_error_return("libdeflate_alloc_compressor()");
-        
-        if (plugin->isNeedSaveWindowBits){//save deflate windowBits
-            const unsigned char* pchar=(const unsigned char*)&_ldef_kWindowBits;
-            if (!out_code->write(out_code,0,pchar,pchar+1)) _compress_error_return("out_code->write()");
-            ++result;
-        }
-        while (readFromPos<in_data->streamSize){
-            const size_t curDictSize=(readFromPos>0)?_ldef_kDictSize:0;
-            size_t readLen=in_step_size;
-            size_t codeLen;
-            if (readLen>(hpatch_StreamPos_t)(in_data->streamSize-readFromPos))
-                readLen=(size_t)(in_data->streamSize-readFromPos);
-            {
-                unsigned char* dst_buf=data_buf+curDictSize+in_border_nbytes;
-                size_t cur_in_border_nbytes=_ldef_kMax_in_border_nbytes;
-                if (readLen+cur_in_border_nbytes>(hpatch_StreamPos_t)(in_data->streamSize-readFromPos))
-                    cur_in_border_nbytes=(size_t)(in_data->streamSize-readFromPos-readLen);
-                if (!in_data->read(in_data,readFromPos+in_border_nbytes,dst_buf,
-                                   dst_buf+readLen+cur_in_border_nbytes-in_border_nbytes))
-                    _compress_error_return("in_data->read()");
-                in_border_nbytes=cur_in_border_nbytes;
-            }
-            readFromPos+=readLen;
-
-            codeLen=libdeflate_deflate_compress_block_continue(c,data_buf,curDictSize,readLen,in_border_nbytes,
-                        (readFromPos==in_data->streamSize),code_buf,block_bound,hpatch_FALSE);
-        
-            if (codeLen>0){
-                _stream_out_code_write(out_code,outStream_isCanceled,result,code_buf,codeLen);
-            }else
-                _compress_error_return("libdeflate_deflate_compress_block_continue()");
-            if (readFromPos<in_data->streamSize){
-                memmove(data_buf,data_buf+readLen+curDictSize-_ldef_kDictSize,_ldef_kDictSize+in_border_nbytes);
-            }
-        }
-    clear:
-        if (c) libdeflate_free_compressor(c);
-        _check_compress_result(result,outStream_isCanceled,"_ldef_compress()",errAt);
-        if (data_buf) free(data_buf);
-        return result;
-    }
-    _def_fun_compressType(_ldef_compressType,"zlib");
-    _def_fun_compressType(_ldef_compressTypeForDisplay,"ldef (zlib compatible)");
-    static const TCompressPlugin_ldef ldefCompressPlugin={
-        {_ldef_compressType,_default_maxCompressedSize,_default_setParallelThreadNumber,
-         _ldef_compress,_ldef_compressTypeForDisplay}, 12,hpatch_TRUE};
-
-#   if (_IS_USED_MULTITHREAD)
-    //pldef
-    typedef struct {
-        TCompressPlugin_ldef base;
-        int                  thread_num; // 1..
-        hdiff_TParallelCompress pc;
-    } TCompressPlugin_pldef;
-    static int _pldef_setThreadNum(hdiff_TCompress* compressPlugin,int threadNum){
-        TCompressPlugin_pldef* plugin=(TCompressPlugin_pldef*)compressPlugin;
-        plugin->thread_num=threadNum;
-        return threadNum;
-    }
-    static hdiff_compressBlockHandle _pldef_openBlockCompressor(hdiff_TParallelCompress* pc){
-        const TCompressPlugin_pldef* plugin=(const TCompressPlugin_pldef*)pc->import;
-        return libdeflate_alloc_compressor(plugin->base.compress_level);
-    }
-    static void _pldef_closeBlockCompressor(hdiff_TParallelCompress* pc,
-                                            hdiff_compressBlockHandle blockCompressor){
-        libdeflate_free_compressor((struct libdeflate_compressor*)blockCompressor);
-    }
-    static
-    size_t _pldef_compressBlock(hdiff_TParallelCompress* pc,hdiff_compressBlockHandle blockCompressor,
-                                hpatch_StreamPos_t blockIndex,hpatch_StreamPos_t blockCount,unsigned char* out_code,unsigned char* out_codeEnd,
-                                const unsigned char* block_data,const unsigned char* block_dictEnd,const unsigned char* block_dataEnd){
-        const TCompressPlugin_pldef* plugin=(const TCompressPlugin_pldef*)pc->import;
-        struct libdeflate_compressor* c=(struct libdeflate_compressor*)blockCompressor;
-        const hpatch_BOOL isAdding=(blockIndex==0)&&plugin->base.isNeedSaveWindowBits;
-        if (isAdding){
-            if (out_code>=out_codeEnd) return 0;//error;
-            out_code[0]=_ldef_kWindowBits;
-            ++out_code;
-        }
-
-        size_t codeLen=libdeflate_deflate_compress_block(c,block_data,block_dictEnd-block_data,block_dataEnd-block_dictEnd,
-                                                         blockIndex+1==blockCount,out_code,out_codeEnd-out_code,1);
-        if (codeLen==0)
-            return 0; //error
-        return codeLen+(isAdding?1:0);
-    }
-    static hpatch_StreamPos_t _pldef_compress(const hdiff_TCompress* compressPlugin,
-                                              const hpatch_TStreamOutput* out_code,
-                                              const hpatch_TStreamInput*  in_data){
-        TCompressPlugin_pldef* plugin=(TCompressPlugin_pldef*)compressPlugin;
-        const size_t blockSize=_ldef_getBestWorkStepSize(in_data->streamSize,plugin->base.compress_level,plugin->thread_num);
-        if ((plugin->thread_num<=1)||(plugin->base.compress_level==0)
-                ||(in_data->streamSize<blockSize*2)){ //same as "zlib"
-            return _ldef_compress(compressPlugin,out_code,in_data);
-        }else{
-            plugin->pc.import=plugin;
-            return parallel_compress_blocks(&plugin->pc,plugin->thread_num,_ldef_kDictSize,blockSize,out_code,in_data);
-        }
-    }
     
-    
-    static const TCompressPlugin_pldef pldefCompressPlugin={
-        { {_ldef_compressType,_default_maxCompressedSize,_pldef_setThreadNum,
-           _pldef_compress,_ldef_compressTypeForDisplay}, 9,hpatch_TRUE},
-        kDefaultCompressThreadNumber ,{0,_default_maxCompressedSize,_pldef_openBlockCompressor,
-            _pldef_closeBlockCompressor,_pldef_compressBlock} };
-#   endif // _IS_USED_MULTITHREAD
-#endif//_CompressPlugin_ldef
-
-
 #ifdef  _CompressPlugin_bz2
 #if (_IsNeedIncludeDefaultCompressHead)
 #   include "bzlib.h" // http://www.bzip.org/  https://github.com/sisong/bzip2
@@ -643,8 +428,8 @@ int _default_setParallelThreadNumber(hdiff_TCompress* compressPlugin,int threadN
     }
     static
     size_t _pbz2_compressBlock(hdiff_TParallelCompress* pc,hdiff_compressBlockHandle blockCompressor,
-                               hpatch_StreamPos_t blockIndex,hpatch_StreamPos_t blockCount,unsigned char* out_code,unsigned char* out_codeEnd,
-                               const unsigned char* block_data,const unsigned char* block_dictEnd,const unsigned char* block_dataEnd){
+                               hpatch_StreamPos_t blockIndex,unsigned char* out_code,unsigned char* out_codeEnd,
+                               const unsigned char* block_data,const unsigned char* block_dataEnd){
         const TCompressPlugin_pbz2* plugin=(const TCompressPlugin_pbz2*)pc->import;
         unsigned int codeLen=(unsigned int)(out_codeEnd-out_code);
         if (BZ_OK!=BZ2_bzBuffToBuffCompress((char*)out_code,&codeLen,(char*)block_data,
@@ -662,7 +447,7 @@ int _default_setParallelThreadNumber(hdiff_TCompress* compressPlugin,int threadN
             return _bz2_compress(compressPlugin,out_code,in_data);
         }else{
             plugin->pc.import=plugin;
-            return parallel_compress_blocks(&plugin->pc,plugin->thread_num,0,blockSize,out_code,in_data);
+            return parallel_compress_blocks(&plugin->pc,plugin->thread_num,blockSize,out_code,in_data);
         }
     }
     
@@ -675,7 +460,7 @@ int _default_setParallelThreadNumber(hdiff_TCompress* compressPlugin,int threadN
 #endif//_CompressPlugin_bz2
 
 
-#if (defined _CompressPlugin_lzma)||(defined _CompressPlugin_lzma2)||(defined _CompressPlugin_7zXZ)
+#if (defined _CompressPlugin_lzma)||(defined _CompressPlugin_lzma2)
 #if (_IsNeedIncludeDefaultCompressHead)
 #   include "LzmaEnc.h" // "lzma/C/LzmaEnc.h" https://github.com/sisong/lzma
 #   ifdef _CompressPlugin_lzma2
@@ -735,7 +520,7 @@ int _default_setParallelThreadNumber(hdiff_TCompress* compressPlugin,int threadN
     typedef struct{
         hdiff_TCompress base;
         int             compress_level; //0..9
-        UInt32          dict_size;      //patch decompress need 4?*lzma_dictSize memory
+        UInt32          dict_size;      //patch decompress need 4*lzma_dictSize memroy
         int             thread_num;     //1..2
     } TCompressPlugin_lzma;
     static int _lzma_setThreadNumber(hdiff_TCompress* compressPlugin,int threadNum){
@@ -772,7 +557,7 @@ int _default_setParallelThreadNumber(hdiff_TCompress* compressPlugin,int threadN
         LzmaEncProps_Normalize(&props);
         if (SZ_OK!=LzmaEnc_SetProps(s,&props)) _compress_error_return("LzmaEnc_SetProps()");
 #       if (IS_NOTICE_compress_canceled)
-        printf("    (used one lzma dictSize: %" PRIu64 "  (input data: %" PRIu64 "))\n",
+        printf("  (used one lzma dictSize: %" PRIu64 "  (input data: %" PRIu64 "))\n",
                (hpatch_StreamPos_t)props.dictSize,in_data->streamSize);
 #       endif
         
@@ -798,7 +583,7 @@ int _default_setParallelThreadNumber(hdiff_TCompress* compressPlugin,int threadN
         }
     clear:
 #if (!IS_REUSE_compress_handle)
-        if (s) { LzmaEnc_Destroy(s,&__lzma_enc_alloc,&__lzma_enc_alloc); s=0; }
+        if (s) LzmaEnc_Destroy(s,&__lzma_enc_alloc,&__lzma_enc_alloc);
 #endif
         _check_compress_result(result,outStream.isCanceled,"_lzma_compress()",errAt);
         return result;
@@ -811,17 +596,17 @@ int _default_setParallelThreadNumber(hdiff_TCompress* compressPlugin,int threadN
     
 #ifdef  _CompressPlugin_lzma2
 #if (_IsNeedIncludeDefaultCompressHead)
-#   include "MtCoder.h" // "lzma/C/MtCoder.h"   for MTCODER__THREADS_MAX
+#   include "MtCoder.h" // // "lzma/C/MtCoder.h"   for MTCODER__THREADS_MAX
 #endif
     struct TCompressPlugin_lzma2{
         hdiff_TCompress base;
         int             compress_level; //0..9
-        UInt32          dict_size;      //patch decompress need 4?*lzma_dictSize memory
+        UInt32          dict_size;      //patch decompress need 4*lzma_dictSize memroy
         int             thread_num;     //1..(64?)
     };
     static int _lzma2_setThreadNumber(hdiff_TCompress* compressPlugin,int threadNum){
         TCompressPlugin_lzma2* plugin=(TCompressPlugin_lzma2*)compressPlugin;
-        if (threadNum>MTCODER_THREADS_MAX) threadNum=MTCODER_THREADS_MAX;
+        if (threadNum>MTCODER__THREADS_MAX) threadNum=MTCODER__THREADS_MAX;
         plugin->thread_num=threadNum;
         return threadNum;
     }
@@ -848,12 +633,12 @@ int _default_setParallelThreadNumber(hdiff_TCompress* compressPlugin,int threadN
         props.lzmaProps.level=plugin->compress_level;
         props.lzmaProps.dictSize=dictSize;
         props.lzmaProps.reduceSize=in_data->streamSize;
-        props.blockSize=LZMA2_ENC_PROPS_BLOCK_SIZE_AUTO;
+        props.blockSize=LZMA2_ENC_PROPS__BLOCK_SIZE__AUTO;
         props.numTotalThreads=plugin->thread_num;
         Lzma2EncProps_Normalize(&props);
         if (SZ_OK!=Lzma2Enc_SetProps(s,&props)) _compress_error_return("Lzma2Enc_SetProps()");
 #       if (IS_NOTICE_compress_canceled)
-        printf("    (used one lzma2 dictSize: %" PRIu64 "  (input data: %" PRIu64 "))\n",
+        printf("  (used one lzma2 dictSize: %" PRIu64 "  (input data: %" PRIu64 "))\n",
                (hpatch_StreamPos_t)props.lzmaProps.dictSize,in_data->streamSize);
 #       endif
         
@@ -877,7 +662,7 @@ int _default_setParallelThreadNumber(hdiff_TCompress* compressPlugin,int threadN
         }
     clear:
 #if (!IS_REUSE_compress_handle)
-        if (s) { Lzma2Enc_Destroy(s); s=0; }
+        if (s) Lzma2Enc_Destroy(s);
 #endif
         _check_compress_result(result,outStream.isCanceled,"_lzma2_compress()",errAt);
         return result;
@@ -888,126 +673,6 @@ int _default_setParallelThreadNumber(hdiff_TCompress* compressPlugin,int threadN
         7,(1<<23),kDefaultCompressThreadNumber};
 #endif//_CompressPlugin_lzma2
 
-#ifdef  _CompressPlugin_7zXZ
-#if (_IsNeedIncludeDefaultCompressHead)
-#   include "XzEnc.h" // "lzma/C/XzEnc.h" https://github.com/sisong/lzma
-#   include "MtCoder.h" // "lzma/C/MtCoder.h"   for MTCODER__THREADS_MAX
-#   include "7zCrc.h" // CrcGenerateTable()
-#endif
-
-#ifndef _init_CompressPlugin_7zXZ_DEF
-#   define _init_CompressPlugin_7zXZ_DEF
-    static int _init_CompressPlugin_7zXZ(){
-        static hpatch_BOOL _isInit=hpatch_FALSE;
-        if (!_isInit){
-            CrcGenerateTable();
-            _isInit=hpatch_TRUE;
-        }
-        return 0;
-    }
-#endif
-
-    typedef struct{
-        hdiff_TCompress base;
-        int             compress_level; //0..9
-        UInt32          dict_size;      //patch decompress need 3?*lzma_dictSize memory
-        int             thread_num;     //1..(64?)
-    } TCompressPlugin_7zXZ;
-    static int _7zXZ_setThreadNumber(hdiff_TCompress* compressPlugin,int threadNum){
-        TCompressPlugin_lzma2* plugin=(TCompressPlugin_lzma2*)compressPlugin;
-        if (threadNum>MTCODER_THREADS_MAX) threadNum=MTCODER_THREADS_MAX;
-        plugin->thread_num=threadNum;
-        return threadNum;
-    }
-    
-    typedef void* _7zXZ_compressHandle;
-    static _7zXZ_compressHandle _7zXZ_compress_open(const hdiff_TCompress* compressPlugin){
-        const TCompressPlugin_7zXZ* plugin=(const TCompressPlugin_7zXZ*)compressPlugin;
-        _7zXZ_compressHandle result=0;
-        const char*        errAt="";
-#if (IS_REUSE_compress_handle)
-        static CXzEncHandle  s=0;
-#else
-        CXzEncHandle         s=0;
-#endif
-        CXzProps           xzprops;
-        hpatch_uint32_t    dictSize=plugin->dict_size;
-        if (!s) s=XzEnc_Create(&__lzma_enc_alloc,&__lzma_enc_alloc);
-        if (!s) _compress_error_return("XzEnc_Create()");
-        XzProps_Init(&xzprops);
-        xzprops.lzma2Props.lzmaProps.level=plugin->compress_level;
-        xzprops.lzma2Props.lzmaProps.dictSize=dictSize;
-        xzprops.lzma2Props.numTotalThreads=plugin->thread_num;
-        Lzma2EncProps_Normalize(&xzprops.lzma2Props);
-        xzprops.numTotalThreads=plugin->thread_num;
-        xzprops.checkId=XZ_CHECK_NO;
-        if (SZ_OK!=XzEnc_SetProps(s,&xzprops)) _compress_error_return("XzEnc_SetProps()");
-        return s;
-    clear:
-#if (!IS_REUSE_compress_handle)
-        if (s) { XzEnc_Destroy(s); s=0; }
-#endif
-        return result;
-    }
-    static hpatch_BOOL _7zXZ_compress_close(const hdiff_TCompress* compressPlugin,
-                                     _7zXZ_compressHandle compressHandle){
-#if (!IS_REUSE_compress_handle)
-        CXzEncHandle s=(CXzEncHandle)compressHandle;
-        if (s) { XzEnc_Destroy(s); s=0; }
-#endif
-        return hpatch_TRUE;
-    }
-
-    static hpatch_StreamPos_t _7zXZ_compress_encode(_7zXZ_compressHandle compressHandle,
-                                                    const hpatch_TStreamOutput* out_code,
-                                                    const hpatch_TStreamInput*  in_data,
-                                                    hpatch_BOOL isWriteHead,hpatch_BOOL isWriteEnd){
-        struct __lzma_SeqOutStream_t outStream={{__lzma_SeqOutStream_Write},out_code,0,0};
-        struct __lzma_SeqInStream_t  inStream={{__lzma_SeqInStream_Read},in_data,0};
-        hpatch_StreamPos_t result=0;
-        const char*        errAt="";
-        CXzEncHandle s=(CXzEncHandle)compressHandle;
-        SRes               ret;
-        XzEnc_SetDataSize(s,in_data->streamSize);
-        
-        ret=XzEnc_Encode_Part(s,&outStream.base,&inStream.base,0,isWriteHead,isWriteEnd);
-        if (SZ_OK==ret){
-            result=outStream.writeToPos;
-        }else{//fail
-            if (ret==SZ_ERROR_READ)
-                _compress_error_return("in_data->read()");
-            else if (ret==SZ_ERROR_WRITE)
-                _compress_error_return("out_code->write()");
-            else
-                _compress_error_return("XzEnc_Encode_Part()");
-        }
-    clear:
-        _check_compress_result(result,outStream.isCanceled,"_7zXZ_compress_encode()",errAt);
-        return result;
-    }
-
-    static hpatch_StreamPos_t _7zXZ_compress(const hdiff_TCompress* compressPlugin,
-                                             const hpatch_TStreamOutput* out_code,
-                                             const hpatch_TStreamInput*  in_data){
-        const TCompressPlugin_7zXZ* plugin=(const TCompressPlugin_7zXZ*)compressPlugin;
-        hpatch_StreamPos_t result=0;
-        const char*        errAt="";
-        _7zXZ_compressHandle s=_7zXZ_compress_open(compressPlugin);
-        if (!s) _compress_error_return("_7zXZ_compress_open()");
-        result=_7zXZ_compress_encode(s,out_code,in_data,hpatch_TRUE,hpatch_TRUE);
-        if (result==0) 
-            _compress_error_return("_7zXZ_compress_encode()");
-    clear:
-        if (s) { _7zXZ_compress_close(compressPlugin,s); s=0; }
-        return result;
-    }
-    _def_fun_compressType(_7zXZ_compressType,"7zXZ");
-    static const TCompressPlugin_7zXZ _7zXZCompressPlugin={
-        {_7zXZ_compressType,_default_maxCompressedSize,_7zXZ_setThreadNumber,_7zXZ_compress},
-        7,(1<<23),kDefaultCompressThreadNumber};
-
-#endif //_CompressPlugin_7zXZ
-
     
 #if (defined(_CompressPlugin_lz4) || defined(_CompressPlugin_lz4hc))
 #if (_IsNeedIncludeDefaultCompressHead)
@@ -1043,7 +708,7 @@ int _default_setParallelThreadNumber(hdiff_TCompress* compressPlugin,int threadN
         LZ4_stream_t*       s=0;
         hpatch_StreamPos_t  readFromPos=0;
         int                 outStream_isCanceled=0;
-        int  kLz4CompressBufSize =1024*510; //patch decompress need 4*2*0.5MB memory
+        int  kLz4CompressBufSize =1024*510; //patch decompress need 4*2*0.5MB memroy
         int  code_buf_size;
         if ((size_t)kLz4CompressBufSize>in_data->streamSize)
             kLz4CompressBufSize=(int)in_data->streamSize;
@@ -1101,7 +766,7 @@ int _default_setParallelThreadNumber(hdiff_TCompress* compressPlugin,int threadN
         LZ4_streamHC_t*     s=0;
         hpatch_StreamPos_t  readFromPos=0;
         int                 outStream_isCanceled=0;
-        int  kLz4CompressBufSize =1024*510; //patch decompress need 4*2*0.5MB memory
+        int  kLz4CompressBufSize =1024*510; //patch decompress need 4*2*0.5MB memroy
         int  code_buf_size;
         if ((size_t)kLz4CompressBufSize>in_data->streamSize)
             kLz4CompressBufSize=(int)in_data->streamSize;
@@ -1159,7 +824,7 @@ int _default_setParallelThreadNumber(hdiff_TCompress* compressPlugin,int threadN
 
 #ifdef  _CompressPlugin_zstd
 #if (_IsNeedIncludeDefaultCompressHead)
-#   include "zstd.h" // "zstd/lib/zstd.h" https://github.com/sisong/zstd
+#   include "zstd.h" // "zstd/lib/zstd.h" https://github.com/facebook/zstd
 #endif
     struct TCompressPlugin_zstd{
         hdiff_TCompress base;
@@ -1184,9 +849,9 @@ int _default_setParallelThreadNumber(hdiff_TCompress* compressPlugin,int threadN
         ZSTD_inBuffer       s_input;
         ZSTD_outBuffer      s_output;
 #if (IS_REUSE_compress_handle)
-        static ZSTD_CCtx*   s=0;
+        static ZSTD_CStream*  s=0;
 #else
-        ZSTD_CCtx*          s=0;
+        ZSTD_CStream*         s=0;
 #endif
         hpatch_StreamPos_t  readFromPos=0;
         int                 outStream_isCanceled=0;
@@ -1200,62 +865,55 @@ int _default_setParallelThreadNumber(hdiff_TCompress* compressPlugin,int threadN
         s_input.src=_temp_buf;
         s_output.dst=_temp_buf+s_input.size;
         
-        if (!s) s=ZSTD_createCCtx();
-        else ZSTD_CCtx_reset(s,ZSTD_reset_session_only);
-        if (!s) _compress_error_return("ZSTD_createCCtx()");
-        ret=ZSTD_CCtx_setParameter(s,ZSTD_c_compressionLevel,plugin->compress_level);
-        if (ZSTD_isError(ret)) _compress_error_return("ZSTD_CCtx_setParameter(,ZSTD_c_compressionLevel)");
-        ZSTD_CCtx_setPledgedSrcSize(s,in_data->streamSize);
+        if (!s) s=ZSTD_createCStream();
+        if (!s) _compress_error_return("ZSTD_createCStream()");
+        ret=ZSTD_initCStream(s,plugin->compress_level);
+        if (ZSTD_isError(ret)) _compress_error_return("ZSTD_initCStream()");
+        
         #define _ZSTD_WINDOWLOG_MIN 10
         dict_bits=plugin->dict_bits;
-        while (((((hpatch_StreamPos_t)1)<<(dict_bits-1)) >= in_data->streamSize)
+         while (((((hpatch_StreamPos_t)1)<<(dict_bits-1)) >= in_data->streamSize)
                 &&((dict_bits-1)>=_ZSTD_WINDOWLOG_MIN)) {
             --dict_bits;
         }
-#       if (IS_NOTICE_compress_canceled)
-        printf("    (used one zstd dictSize: %" PRIu64 "  (input data: %" PRIu64 "))\n",
-               ((hpatch_StreamPos_t)1)<<dict_bits,in_data->streamSize);
-#       endif
-        ret=ZSTD_CCtx_setParameter(s,ZSTD_c_windowLog,dict_bits);
+        ret=ZSTD_CCtx_setParameter(s, ZSTD_c_windowLog,plugin->dict_bits);
         if (ZSTD_isError(ret)) _compress_error_return("ZSTD_CCtx_setParameter(,ZSTD_c_windowLog)");
         if (plugin->thread_num>1){
             ret=ZSTD_CCtx_setParameter(s, ZSTD_c_nbWorkers,plugin->thread_num);
             //if (ZSTD_isError(ret)) printf("  (NOTICE: zstd unsupport multi-threading, warning.)\n");
         }
-
-        for (;;){
-            if (readFromPos<in_data->streamSize){
-                s_input.pos=0;
-                if (s_input.size>(in_data->streamSize-readFromPos))
-                    s_input.size=(size_t)(in_data->streamSize-readFromPos);
-                if (!in_data->read(in_data,readFromPos,(unsigned char*)s_input.src,
-                                (unsigned char*)s_input.src+s_input.size))
-                    _compress_error_return("in_data->read()");
-                readFromPos+=s_input.size;
+        
+        while (readFromPos<in_data->streamSize) {
+            s_input.pos=0;
+            if (s_input.size>(in_data->streamSize-readFromPos))
+                s_input.size=(size_t)(in_data->streamSize-readFromPos);
+            if (!in_data->read(in_data,readFromPos,(unsigned char*)s_input.src,
+                               (unsigned char*)s_input.src+s_input.size))
+                _compress_error_return("in_data->read()");
+            readFromPos+=s_input.size;
+            while (s_input.pos<s_input.size) {
+                s_output.pos=0;
+                ret=ZSTD_compressStream(s,&s_output,&s_input);
+                if (ZSTD_isError(ret)) _compress_error_return("ZSTD_compressStream()");
+                if (s_output.pos>0){
+                    _stream_out_code_write(out_code,outStream_isCanceled,result,
+                                           (const unsigned char*)s_output.dst,s_output.pos);
+                }
             }
-            {
-                const int lastChunk=(readFromPos==in_data->streamSize);
-                const ZSTD_EndDirective mode=lastChunk?ZSTD_e_end:ZSTD_e_continue;
-                int finished;
-                do {
-                    s_output.pos=0;
-                    ret=ZSTD_compressStream2(s,&s_output,&s_input,mode);
-                    if (ZSTD_isError(ret)) _compress_error_return("ZSTD_compressStream2()");
-                    if (s_output.pos>0){
-                        _stream_out_code_write(out_code,outStream_isCanceled,result,
-                                            (const unsigned char*)s_output.dst,s_output.pos);
-                    }
-                    finished=lastChunk?(ret==0):(s_input.pos==s_input.size);
-                } while (!finished);
-                //if (s_input.pos!=s_input.size) _compress_error_return("Impossible: zstd only returns 0 when the input is completely consumed!");
-                if (lastChunk)
-                    break;
+        }
+        while (1) {
+            s_output.pos=0;
+            ret=ZSTD_endStream(s,&s_output);
+            if (s_output.pos>0){
+                _stream_out_code_write(out_code,outStream_isCanceled,result,
+                                       (const unsigned char*)s_output.dst,s_output.pos);
             }
+            if (ret==0) break;
         }
     clear:
 #if (!IS_REUSE_compress_handle)
-        if (0!=ZSTD_freeCCtx(s))
-        { s=0; result=kCompressFailResult; if (strlen(errAt)==0) errAt="ZSTD_freeCStream()"; }
+        if (0!=ZSTD_freeCStream(s))
+        { result=kCompressFailResult; if (strlen(errAt)==0) errAt="ZSTD_freeCStream()"; }
 #endif
         _check_compress_result(result,outStream_isCanceled,"_zstd_compress()",errAt);
         if (_temp_buf) free(_temp_buf);
@@ -1488,38 +1146,6 @@ int _default_setParallelThreadNumber(hdiff_TCompress* compressPlugin,int threadN
          LZHAM_COMP_LEVEL_BETTER,24,kDefaultCompressThreadNumber};
 #endif//_CompressPlugin_lzham
 
-#ifdef _CompressPlugin_tuz
-#if (_IsNeedIncludeDefaultCompressHead)
-#   include "tuz_enc.h" // "tinyuz/compress/tuz_enc.h" https://github.com/sisong/tinyuz
-#endif
-    typedef struct TCompressPlugin_tuz{
-        hdiff_TCompress     base;
-        tuz_TCompressProps  props;
-    } TCompressPlugin_tuz;
-    static int _tuz_setParallelThreadNumber(hdiff_TCompress* compressPlugin,int threadNum){
-        TCompressPlugin_tuz* plugin=(TCompressPlugin_tuz*)compressPlugin;
-        plugin->props.threadNum=threadNum;
-        return threadNum;
-    }
-    static hpatch_StreamPos_t _tuz_compress(const hdiff_TCompress* compressPlugin,
-                                            const hpatch_TStreamOutput* out_code,
-                                            const hpatch_TStreamInput*  in_data){
-        const TCompressPlugin_tuz* plugin=(const TCompressPlugin_tuz*)compressPlugin;
-        tuz_TCompressProps props=plugin->props;
-        if (props.dictSize>=in_data->streamSize)
-            props.dictSize=(in_data->streamSize>1)?(tuz_size_t)(in_data->streamSize-1):1;
-#       if (IS_NOTICE_compress_canceled)
-        printf("    (used one tinyuz dictSize: %" PRIu64 "  (input data: %" PRIu64 "))\n",
-               (hpatch_StreamPos_t)props.dictSize,in_data->streamSize);
-#       endif
-        return tuz_compress(out_code,in_data,&props);
-    }
-    _def_fun_compressType(_tuz_compressType,"tuz");
-    static const TCompressPlugin_tuz tuzCompressPlugin={
-        {_tuz_compressType,_default_maxCompressedSize,_tuz_setParallelThreadNumber,_tuz_compress},
-            {(1<<24),tuz_kMaxOfMaxSaveLength,kDefaultCompressThreadNumber}};
-#endif //_CompressPlugin_tuz
-
 #ifdef __cplusplus
 }
 #endif