react-native-update 10.60.0 → 10.61.0

package/android/jni/HDiffPatch/compress_plugin_demo.h

@@ -1,1152 +0,0 @@
-//compress_plugin_demo.h
-//  compress plugin demo for HDiffz
-/*
- The MIT License (MIT)
- Copyright (c) 2012-2017 HouSisong
- 
- Permission is hereby granted, free of charge, to any person
- obtaining a copy of this software and associated documentation
- files (the "Software"), to deal in the Software without
- restriction, including without limitation the rights to use,
- copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the
- Software is furnished to do so, subject to the following
- conditions:
- 
- The above copyright notice and this permission notice shall be
- included in all copies of the Software.
- 
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
- OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
- HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- OTHER DEALINGS IN THE SOFTWARE.
- */
-#ifndef HDiff_compress_plugin_demo_h
-#define HDiff_compress_plugin_demo_h
-//compress plugin demo:
-//  zlibCompressPlugin
-//  pzlibCompressPlugin
-//  bz2CompressPlugin
-//  pbz2CompressPlugin
-//  lzmaCompressPlugin
-//  lzma2CompressPlugin
-//  lz4CompressPlugin
-//  lz4hcCompressPlugin
-//  zstdCompressPlugin
-//  brotliCompressPlugin
-//  lzhamCompressPlugin
-
-#include "libHDiffPatch/HDiff/diff_types.h"
-#include "compress_parallel.h"
-#include <stdio.h>
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef kDefaultCompressThreadNumber
-#if (_IS_USED_MULTITHREAD)
-#   define kDefaultCompressThreadNumber     4
-#else
-#   define kDefaultCompressThreadNumber     1
-#endif
-#endif
-
-#ifndef kCompressBufSize
-#   define kCompressBufSize (1024*32)
-#endif
-#ifndef _IsNeedIncludeDefaultCompressHead
-#   define _IsNeedIncludeDefaultCompressHead 1
-#endif
-#define kCompressFailResult 0
-#define _compress_error_return(_errAt) do{ \
-    result=kCompressFailResult;          \
-    if (strlen(errAt)==0) errAt=_errAt;  \
-    goto clear; } while(0)
-
-#ifndef IS_NOTICE_compress_canceled
-#   define IS_NOTICE_compress_canceled 1
-#endif
-#ifndef IS_REUSE_compress_handle
-#   define IS_REUSE_compress_handle 0
-#endif
-
-
-#define _check_compress_result(result,outStream_isCanceled,_at,_errAt) \
-    if ((result)==kCompressFailResult){      \
-        if (outStream_isCanceled){    \
-            if (IS_NOTICE_compress_canceled) \
-                printf("  (NOTICE: " _at " is canceled, warning.)\n"); \
-        }else{ \
-            printf("  (NOTICE: " _at " is canceled, %s ERROR!)\n",_errAt); \
-        } \
-    }
-
-#define _stream_out_code_write(out_code,isCanceled,writePos,buf,len) { \
-    if (!out_code->write(out_code,writePos,buf,buf+len)){ \
-        isCanceled=1;  \
-        _compress_error_return("out_code->write()");\
-    } \
-    writePos+=len;  }
-
-#define _def_fun_compressType(_fun_name,cstr)   \
-static const char*  _fun_name(void){            \
-    static const char* kCompressType=cstr;      \
-    return kCompressType;                       \
-}
-
-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;
-}
-hpatch_inline static
-int _default_setParallelThreadNumber(hdiff_TCompress* compressPlugin,int threadNum){
-    return 1;
-}
-
-#ifdef  _CompressPlugin_zlib
-#if (_IsNeedIncludeDefaultCompressHead)
-#   include "zlib.h" // http://zlib.net/  https://github.com/madler/zlib
-#endif
-    typedef struct{
-        hdiff_TCompress base;
-        int             compress_level; //0..9
-        int             mem_level;
-        signed char     windowBits;
-        hpatch_BOOL     isNeedSaveWindowBits;
-        int             strategy;
-    } TCompressPlugin_zlib;
-    typedef struct _zlib_TCompress{
-        const hpatch_TStreamOutput* out_code;
-        unsigned char*  c_buf;
-        size_t          c_buf_size;
-        z_stream        c_stream;
-    } _zlib_TCompress;
-
-    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){
-        const TCompressPlugin_zlib* plugin=(const TCompressPlugin_zlib*)compressPlugin;
-        _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=_mem_buf;
-        self->c_buf_size=_mem_buf_size;
-        self->out_code=out_code;
-        
-        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 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);
-        }
-        memset(self,0,sizeof(_zlib_TCompress));
-        return result;
-    }
-    static int _zlib_compress_part(_zlib_TCompress* self,
-                                   const unsigned char* part_data,const unsigned char* part_data_end,
-                                   int is_data_end,hpatch_StreamPos_t* curWritedPos,int* outStream_isCanceled){
-        int                 result=1; //true
-        const char*         errAt="";
-        int                 is_stream_end=0;
-        int                 is_eof=0;
-        assert(part_data<=part_data_end);
-        self->c_stream.next_in=(Bytef*)part_data;
-        self->c_stream.avail_in=(uInt)(part_data_end-part_data);
-        while (1) {
-            if ((self->c_stream.avail_out<self->c_buf_size)|is_stream_end){
-                size_t writeLen=self->c_buf_size-self->c_stream.avail_out;
-                if (writeLen>0){
-                    _stream_out_code_write(self->out_code,*outStream_isCanceled,
-                                           (*curWritedPos),self->c_buf,writeLen);
-                }
-                self->c_stream.next_out=(Bytef*)self->c_buf;
-                self->c_stream.avail_out=(uInt)self->c_buf_size;
-                if (is_stream_end)
-                    break;//end loop
-            }else{
-                if (self->c_stream.avail_in>0){
-                    if (Z_OK!=deflate(&self->c_stream,Z_NO_FLUSH)) _compress_error_return("deflate()");
-                }else if (is_eof){
-                    int ret=deflate(&self->c_stream,Z_FINISH);
-                    is_stream_end= (ret==Z_STREAM_END);
-                    if ((ret!=Z_STREAM_END)&&(ret!=Z_OK))
-                        _compress_error_return("deflate() Z_FINISH");
-                }else{
-                    if (!is_data_end)
-                        break;//part ok
-                    else
-                        is_eof=1;
-                }
-            }
-        }
-    clear:
-        _check_compress_result(result,*outStream_isCanceled,"_zlib_compress_part()",errAt);
-        return result;
-    }
-
-    static hpatch_StreamPos_t _zlib_compress(const hdiff_TCompress* compressPlugin,
-                                             const hpatch_TStreamOutput* out_code,
-                                             const hpatch_TStreamInput*  in_data){
-        const TCompressPlugin_zlib* plugin=(const TCompressPlugin_zlib*)compressPlugin;
-        hpatch_StreamPos_t result=0; //writedPos
-        hpatch_StreamPos_t readFromPos=0;
-        const char*        errAt="";
-        int                 outStream_isCanceled=0;
-        unsigned char*     _temp_buf=0;
-        unsigned char*     data_buf=0;
-        _zlib_TCompress*   self=0;
-        _temp_buf=(unsigned char*)malloc(sizeof(_zlib_TCompress)+kCompressBufSize*2);
-        if (!_temp_buf) _compress_error_return("memory alloc");
-        self=_zlib_compress_open_by(compressPlugin,plugin->compress_level,plugin->mem_level,
-                                    out_code,_temp_buf,sizeof(_zlib_TCompress)+kCompressBufSize);
-        data_buf=_temp_buf+sizeof(_zlib_TCompress)+kCompressBufSize;
-        if (!self) _compress_error_return("deflateInit2()");
-        if (plugin->isNeedSaveWindowBits){
-            unsigned char* pchar=(unsigned char*)&plugin->windowBits;
-            if (!out_code->write(out_code,0,pchar,pchar+1)) _compress_error_return("out_code->write()");
-            ++result;
-        }
-        do {
-            size_t readLen=kCompressBufSize;
-            if (readLen>(hpatch_StreamPos_t)(in_data->streamSize-readFromPos))
-                readLen=(size_t)(in_data->streamSize-readFromPos);
-            if (!in_data->read(in_data,readFromPos,data_buf,data_buf+readLen))
-                _compress_error_return("in_data->read()");
-            readFromPos+=readLen;
-            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()"; }
-        _check_compress_result(result,outStream_isCanceled,"_zlib_compress()",errAt);
-        if (_temp_buf) free(_temp_buf);
-        return result;
-    }
-    _def_fun_compressType(_zlib_compressType,"zlib");
-    static const TCompressPlugin_zlib zlibCompressPlugin={
-        {_zlib_compressType,_default_maxCompressedSize,_default_setParallelThreadNumber,_zlib_compress},
-            9,8,-MAX_WBITS,hpatch_TRUE,Z_DEFAULT_STRATEGY};
-    
-#   if (_IS_USED_MULTITHREAD)
-    //pzlib
-    typedef struct {
-        TCompressPlugin_zlib base;
-        int                  thread_num; // 1..
-        hdiff_TParallelCompress pc;
-    } TCompressPlugin_pzlib;
-    static int _pzlib_setThreadNum(hdiff_TCompress* compressPlugin,int threadNum){
-        TCompressPlugin_pzlib* plugin=(TCompressPlugin_pzlib*)compressPlugin;
-        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){
-        assert(blockCompressor==pc);
-    }
-    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;
-        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;
-        }
-        *destLen = stream.total_out;
-        err = deflateEnd(&stream);
-        return err;
-    }
-    static
-    size_t _pzlib_compressBlock(hdiff_TParallelCompress* pc,hdiff_compressBlockHandle blockCompressor,
-                                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;
-        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,(uLong)(block_dataEnd-block_data),
-                                   plugin->base.compress_level,plugin->base.mem_level,plugin->base.windowBits))
-            return 0; //error
-        return codeLen+(isAdding?1:0);
-    }
-    static hpatch_StreamPos_t _pzlib_compress(const hdiff_TCompress* compressPlugin,
-                                              const hpatch_TStreamOutput* out_code,
-                                              const hpatch_TStreamInput*  in_data){
-        TCompressPlugin_pzlib* plugin=(TCompressPlugin_pzlib*)compressPlugin;
-        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{
-            plugin->pc.import=plugin;
-            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={
-        { {_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_bz2
-#if (_IsNeedIncludeDefaultCompressHead)
-#   include "bzlib.h" // http://www.bzip.org/  https://github.com/sisong/bzip2
-#endif
-    typedef struct{
-        hdiff_TCompress base;
-        int             compress_level; //0..9
-    } TCompressPlugin_bz2;
-    static hpatch_StreamPos_t _bz2_compress(const hdiff_TCompress* compressPlugin,
-                                            const hpatch_TStreamOutput* out_code,
-                                            const hpatch_TStreamInput*  in_data){
-        const TCompressPlugin_bz2* plugin=(const TCompressPlugin_bz2*)compressPlugin;
-        hpatch_StreamPos_t result=0;
-        const char*        errAt="";
-        unsigned char*     _temp_buf=0;
-        bz_stream          s;
-        unsigned char*     code_buf,* data_buf;
-        int                is_eof=0;
-        int                is_stream_end=0;
-        hpatch_StreamPos_t readFromPos=0;
-        int                outStream_isCanceled=0;
-        memset(&s,0,sizeof(s));
-        
-        _temp_buf=(unsigned char*)malloc(kCompressBufSize*2);
-        if (!_temp_buf) _compress_error_return("memory alloc");
-        code_buf=_temp_buf;
-        data_buf=_temp_buf+kCompressBufSize;
-        s.next_out = (char*)code_buf;
-        s.avail_out = kCompressBufSize;
-        if (BZ_OK!=BZ2_bzCompressInit(&s,plugin->compress_level, 0, 0))
-            _compress_error_return("BZ2_bzCompressInit()");
-        while (1) {
-            if ((s.avail_out<kCompressBufSize)|is_stream_end){
-                size_t writeLen=kCompressBufSize-s.avail_out;
-                if (writeLen>0){
-                    _stream_out_code_write(out_code,outStream_isCanceled,result,code_buf,writeLen);
-                }
-                s.next_out=(char*)code_buf;
-                s.avail_out=kCompressBufSize;
-                if (is_stream_end)
-                    break;//end loop
-            }else{
-                if (s.avail_in>0){
-                    if (BZ_RUN_OK!=BZ2_bzCompress(&s,BZ_RUN)) _compress_error_return("BZ2_bzCompress()");
-                }else if (is_eof){
-                    int ret=BZ2_bzCompress(&s,BZ_FINISH);
-                    is_stream_end= (ret==BZ_STREAM_END);
-                    if ((ret!=BZ_STREAM_END)&&(ret!=BZ_FINISH_OK))
-                        _compress_error_return("BZ2_bzCompress() BZ_FINISH");
-                }else{
-                    size_t readLen=kCompressBufSize;
-                    if (readFromPos+readLen>in_data->streamSize)
-                        readLen=(size_t)(in_data->streamSize-readFromPos);
-                    if (readLen==0){
-                        is_eof=1;
-                    }else{
-                        if (!in_data->read(in_data,readFromPos,data_buf,data_buf+readLen))
-                            _compress_error_return("in_data->read()");
-                        readFromPos+=readLen;
-                        s.next_in=(char*)data_buf;
-                        s.avail_in=(unsigned int)readLen;
-                    }
-                }
-            }
-        }
-    clear:
-        if (BZ_OK!=BZ2_bzCompressEnd(&s))
-            { result=kCompressFailResult; if (strlen(errAt)==0) errAt="BZ2_bzCompressEnd()"; }
-        _check_compress_result(result,outStream_isCanceled,"_bz2_compress()",errAt);
-        if (_temp_buf) free(_temp_buf);
-        return result;
-    }
-    _def_fun_compressType(_bz2_compressType,"bz2");
-    static const TCompressPlugin_bz2 bz2CompressPlugin={
-        {_bz2_compressType,_default_maxCompressedSize,_default_setParallelThreadNumber,_bz2_compress}, 9};
-    
-#   if (_IS_USED_MULTITHREAD)
-    //pbz2
-    typedef struct{
-        TCompressPlugin_bz2     base;
-        int                     thread_num; // 1..
-        hdiff_TParallelCompress pc;
-    } TCompressPlugin_pbz2;
-    static int _pbz2_setThreadNum(hdiff_TCompress* compressPlugin,int threadNum){
-        TCompressPlugin_pbz2* plugin=(TCompressPlugin_pbz2*)compressPlugin;
-        plugin->thread_num=threadNum;
-        return threadNum;
-    }
-    static hdiff_compressBlockHandle _pbz2_openBlockCompressor(hdiff_TParallelCompress* pc){
-        return pc;
-    }
-    static void _pbz2_closeBlockCompressor(hdiff_TParallelCompress* pc,
-                                           hdiff_compressBlockHandle blockCompressor){
-        assert(blockCompressor==pc);
-    }
-    static
-    size_t _pbz2_compressBlock(hdiff_TParallelCompress* pc,hdiff_compressBlockHandle blockCompressor,
-                               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,
-                                            (unsigned int)(block_dataEnd-block_data),
-                                            plugin->base.compress_level,0,0)) return 0; //error
-        return codeLen;
-    }
-    static hpatch_StreamPos_t _pbz2_compress(const hdiff_TCompress* compressPlugin,
-                                             const hpatch_TStreamOutput* out_code,
-                                             const hpatch_TStreamInput*  in_data){
-        TCompressPlugin_pbz2* plugin=(TCompressPlugin_pbz2*)compressPlugin;
-        const size_t blockSize=plugin->base.compress_level*100000;
-        if ((plugin->thread_num<=1)||(plugin->base.compress_level==0)
-                ||(in_data->streamSize<blockSize*2)){ //same as "bz2"
-            return _bz2_compress(compressPlugin,out_code,in_data);
-        }else{
-            plugin->pc.import=plugin;
-            return parallel_compress_blocks(&plugin->pc,plugin->thread_num,blockSize,out_code,in_data);
-        }
-    }
-    
-    _def_fun_compressType(_pbz2_compressType,"pbz2");
-    static const TCompressPlugin_pbz2 pbz2CompressPlugin={
-        { {_pbz2_compressType,_default_maxCompressedSize,_pbz2_setThreadNum,_pbz2_compress}, 8},
-        kDefaultCompressThreadNumber ,{0,_default_maxCompressedSize,_pbz2_openBlockCompressor,
-            _pbz2_closeBlockCompressor,_pbz2_compressBlock} };
-#   endif // _IS_USED_MULTITHREAD
-#endif//_CompressPlugin_bz2
-
-
-#if (defined _CompressPlugin_lzma)||(defined _CompressPlugin_lzma2)
-#if (_IsNeedIncludeDefaultCompressHead)
-#   include "LzmaEnc.h" // "lzma/C/LzmaEnc.h" https://github.com/sisong/lzma
-#   ifdef _CompressPlugin_lzma2
-#       include "Lzma2Enc.h"
-#   endif
-#endif
-    static void * __lzma_enc_Alloc(ISzAllocPtr p, size_t size){
-        return malloc(size);
-    }
-    static void __lzma_enc_Free(ISzAllocPtr p, void *address){
-        free(address);
-    }
-    static ISzAlloc __lzma_enc_alloc={__lzma_enc_Alloc,__lzma_enc_Free};
-    
-    struct __lzma_SeqOutStream_t{
-        ISeqOutStream               base;
-        const hpatch_TStreamOutput* out_code;
-        hpatch_StreamPos_t          writeToPos;
-        int                         isCanceled;
-    };
-    static size_t __lzma_SeqOutStream_Write(const ISeqOutStream *p, const void *buf, size_t size){
-        __lzma_SeqOutStream_t* self=(__lzma_SeqOutStream_t*)p;
-        const unsigned char* pdata=(const unsigned char*)buf;
-        if (size>0){
-            if (!self->out_code->write(self->out_code,self->writeToPos,pdata,pdata+size)){
-                self->isCanceled=1;
-                return 0;
-            }
-        }
-        self->writeToPos+=size;
-        return size;
-    }
-    struct __lzma_SeqInStream_t{
-        ISeqInStream                base;
-        const hpatch_TStreamInput*  in_data;
-        hpatch_StreamPos_t          readFromPos;
-    };
-    static SRes __lzma_SeqInStream_Read(const ISeqInStream *p, void *buf, size_t *size){
-        __lzma_SeqInStream_t* self=(__lzma_SeqInStream_t*)p;
-        size_t readLen=*size;
-        if (readLen+self->readFromPos>self->in_data->streamSize)
-            readLen=(size_t)(self->in_data->streamSize-self->readFromPos);
-        if (readLen>0){
-            unsigned char* pdata=(unsigned char*)buf;
-            if (!self->in_data->read(self->in_data,self->readFromPos,pdata,pdata+readLen)){
-                *size=0;
-                return SZ_ERROR_READ;
-            }
-        }
-        self->readFromPos+=readLen;
-        *size=readLen;
-        return SZ_OK;
-    }
-#endif
-    
-#ifdef  _CompressPlugin_lzma
-    typedef struct{
-        hdiff_TCompress base;
-        int             compress_level; //0..9
-        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){
-        TCompressPlugin_lzma* plugin=(TCompressPlugin_lzma*)compressPlugin;
-        if (threadNum>2) threadNum=2;
-        plugin->thread_num=threadNum;
-        return threadNum;
-    }
-    static hpatch_StreamPos_t _lzma_compress(const hdiff_TCompress* compressPlugin,
-                                             const hpatch_TStreamOutput* out_code,
-                                             const hpatch_TStreamInput*  in_data){
-        const TCompressPlugin_lzma* plugin=(const TCompressPlugin_lzma*)compressPlugin;
-        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="";
-#if (IS_REUSE_compress_handle)
-        static CLzmaEncHandle   s=0;
-#else
-        CLzmaEncHandle          s=0;
-#endif
-        CLzmaEncProps      props;
-        unsigned char      properties_buf[LZMA_PROPS_SIZE+1];
-        SizeT              properties_size=LZMA_PROPS_SIZE;
-        SRes               ret;
-        hpatch_uint32_t    dictSize=plugin->dict_size;
-        if (!s) s=LzmaEnc_Create(&__lzma_enc_alloc);
-        if (!s) _compress_error_return("LzmaEnc_Create()");
-        LzmaEncProps_Init(&props);
-        props.level=plugin->compress_level;
-        props.dictSize=dictSize;
-        props.reduceSize=in_data->streamSize;
-        props.numThreads=plugin->thread_num;
-        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",
-               (hpatch_StreamPos_t)props.dictSize,in_data->streamSize);
-#       endif
-        
-        //save properties_size+properties
-        assert(LZMA_PROPS_SIZE<256);
-        if (SZ_OK!=LzmaEnc_WriteProperties(s,properties_buf+1,&properties_size))
-            _compress_error_return("LzmaEnc_WriteProperties()");
-        properties_buf[0]=(unsigned char)properties_size;
-        
-        if (1+properties_size!=__lzma_SeqOutStream_Write(&outStream.base,properties_buf,1+properties_size))
-            _compress_error_return("out_code->write()");
-        
-        ret=LzmaEnc_Encode(s,&outStream.base,&inStream.base,0,&__lzma_enc_alloc,&__lzma_enc_alloc);
-        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("LzmaEnc_Encode()");
-        }
-    clear:
-#if (!IS_REUSE_compress_handle)
-        if (s) LzmaEnc_Destroy(s,&__lzma_enc_alloc,&__lzma_enc_alloc);
-#endif
-        _check_compress_result(result,outStream.isCanceled,"_lzma_compress()",errAt);
-        return result;
-    }
-    _def_fun_compressType(_lzma_compressType,"lzma");
-    static const TCompressPlugin_lzma lzmaCompressPlugin={
-        {_lzma_compressType,_default_maxCompressedSize,_lzma_setThreadNumber,_lzma_compress},
-        7,(1<<23),(kDefaultCompressThreadNumber>=2)?2:kDefaultCompressThreadNumber};
-#endif//_CompressPlugin_lzma
-    
-#ifdef  _CompressPlugin_lzma2
-#if (_IsNeedIncludeDefaultCompressHead)
-#   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 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;
-        plugin->thread_num=threadNum;
-        return threadNum;
-    }
-    static hpatch_StreamPos_t _lzma2_compress(const hdiff_TCompress* compressPlugin,
-                                              const hpatch_TStreamOutput* out_code,
-                                              const hpatch_TStreamInput*  in_data){
-        const TCompressPlugin_lzma2* plugin=(const TCompressPlugin_lzma2*)compressPlugin;
-        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="";
-#if (IS_REUSE_compress_handle)
-        static CLzma2EncHandle  s=0;
-#else
-        CLzma2EncHandle         s=0;
-#endif
-        CLzma2EncProps     props;
-        Byte               properties_size=0;
-        SRes               ret;
-        hpatch_uint32_t    dictSize=plugin->dict_size;
-        if (!s) s=Lzma2Enc_Create(&__lzma_enc_alloc,&__lzma_enc_alloc);
-        if (!s) _compress_error_return("LzmaEnc_Create()");
-        Lzma2EncProps_Init(&props);
-        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.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",
-               (hpatch_StreamPos_t)props.lzmaProps.dictSize,in_data->streamSize);
-#       endif
-        
-        //save properties_size+properties
-        assert(LZMA_PROPS_SIZE<256);
-        properties_size=Lzma2Enc_WriteProperties(s);
-        
-        if (1!=__lzma_SeqOutStream_Write(&outStream.base,&properties_size,1))
-            _compress_error_return("out_code->write()");
-        
-        ret=Lzma2Enc_Encode2(s,&outStream.base,0,0,&inStream.base,0,0,0);
-        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("Lzma2Enc_Encode2()");
-        }
-    clear:
-#if (!IS_REUSE_compress_handle)
-        if (s) Lzma2Enc_Destroy(s);
-#endif
-        _check_compress_result(result,outStream.isCanceled,"_lzma2_compress()",errAt);
-        return result;
-    }
-    _def_fun_compressType(_lzma2_compressType,"lzma2");
-    static const TCompressPlugin_lzma2 lzma2CompressPlugin={
-        {_lzma2_compressType,_default_maxCompressedSize,_lzma2_setThreadNumber,_lzma2_compress},
-        7,(1<<23),kDefaultCompressThreadNumber};
-#endif//_CompressPlugin_lzma2
-
-    
-#if (defined(_CompressPlugin_lz4) || defined(_CompressPlugin_lz4hc))
-#if (_IsNeedIncludeDefaultCompressHead)
-#   include "lz4.h"   // "lz4/lib/lz4.h" https://github.com/lz4/lz4
-#   include "lz4hc.h"
-#endif
-    struct TCompressPlugin_lz4{
-        hdiff_TCompress base;
-        int             compress_level; //1..50 default 50
-    };
-    struct TCompressPlugin_lz4hc{
-        hdiff_TCompress base;
-        int             compress_level; //3..12
-    };
-
-    #define _lz4_write_len4(out_code,isCanceled,writePos,len) { \
-        unsigned char _temp_buf4[4];  \
-        _temp_buf4[0]=(unsigned char)(len);      \
-        _temp_buf4[1]=(unsigned char)((len)>>8); \
-        _temp_buf4[2]=(unsigned char)((len)>>16);\
-        _temp_buf4[3]=(unsigned char)((len)>>24);\
-        _stream_out_code_write(out_code,isCanceled,writePos,_temp_buf4,4); \
-    }
-    static hpatch_StreamPos_t _lz4_compress(const hdiff_TCompress* compressPlugin,
-                                            const hpatch_TStreamOutput* out_code,
-                                            const hpatch_TStreamInput*  in_data){
-        const TCompressPlugin_lz4* plugin=(const TCompressPlugin_lz4*)compressPlugin;
-        const int kLZ4DefaultAcceleration=50-(plugin->compress_level-1);
-        hpatch_StreamPos_t  result=0;
-        const char*         errAt="";
-        unsigned char*      _temp_buf=0;
-        unsigned char*      code_buf,* data_buf,* data_buf_back;
-        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 memroy
-        int  code_buf_size;
-        if ((size_t)kLz4CompressBufSize>in_data->streamSize)
-            kLz4CompressBufSize=(int)in_data->streamSize;
-        code_buf_size=LZ4_compressBound(kLz4CompressBufSize);
-        
-        _temp_buf=(unsigned char*)malloc(kLz4CompressBufSize*2+code_buf_size);
-        if (!_temp_buf) _compress_error_return("memory alloc");
-        data_buf_back=_temp_buf;
-        data_buf=_temp_buf+kLz4CompressBufSize;
-        code_buf=_temp_buf+kLz4CompressBufSize*2;
-        
-        s=LZ4_createStream();
-        if (!s) _compress_error_return("LZ4_createStream()");
-        //out kLz4CompressBufSize
-        _lz4_write_len4(out_code,outStream_isCanceled,result,kLz4CompressBufSize);
-        
-        while (1) {
-            int  codeLen;
-            unsigned char*  _swap=data_buf;
-            data_buf=data_buf_back;
-            data_buf_back=_swap;
-            int dataLen=kLz4CompressBufSize;
-            if ((size_t)dataLen>(in_data->streamSize-readFromPos))
-                dataLen=(int)(in_data->streamSize-readFromPos);
-            if (dataLen==0)
-                break;//finish
-            if (!in_data->read(in_data,readFromPos,data_buf,data_buf+dataLen))
-                _compress_error_return("in_data->read()");
-            readFromPos+=dataLen;
-            
-            codeLen=LZ4_compress_fast_continue(s,(const char*)data_buf,(char*)code_buf,
-                                               dataLen,code_buf_size,kLZ4DefaultAcceleration);
-            if (codeLen<=0) _compress_error_return("LZ4_compress_fast_continue()");
-            //out step codeLen
-            _lz4_write_len4(out_code,outStream_isCanceled,result,codeLen);
-            //out code
-            _stream_out_code_write(out_code,outStream_isCanceled,result,code_buf,codeLen);
-        }
-    clear:
-        if (0!=LZ4_freeStream(s))
-            { result=kCompressFailResult; if (strlen(errAt)==0) errAt="LZ4_freeStream()"; }
-        _check_compress_result(result,outStream_isCanceled,"_lz4_compress()",errAt);
-        if (_temp_buf) free(_temp_buf);
-        return result;
-    }
-
-    static hpatch_StreamPos_t _lz4hc_compress(const hdiff_TCompress* compressPlugin,
-                                              const hpatch_TStreamOutput* out_code,
-                                              const hpatch_TStreamInput*  in_data){
-        const TCompressPlugin_lz4hc* plugin=(const TCompressPlugin_lz4hc*)compressPlugin;
-        hpatch_StreamPos_t  result=0;
-        const char*         errAt="";
-        unsigned char*      _temp_buf=0;
-        unsigned char*      code_buf,* data_buf,* data_buf_back;
-        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 memroy
-        int  code_buf_size;
-        if ((size_t)kLz4CompressBufSize>in_data->streamSize)
-            kLz4CompressBufSize=(int)in_data->streamSize;
-        code_buf_size=LZ4_compressBound(kLz4CompressBufSize);
-        
-        _temp_buf=(unsigned char*)malloc(kLz4CompressBufSize*2+code_buf_size);
-        if (!_temp_buf) _compress_error_return("memory alloc");
-        data_buf_back=_temp_buf;
-        data_buf=_temp_buf+kLz4CompressBufSize;
-        code_buf=_temp_buf+kLz4CompressBufSize*2;
-        
-        s=LZ4_createStreamHC();
-        if (!s) _compress_error_return("LZ4_createStreamHC()");
-        LZ4_resetStreamHC(s,plugin->compress_level);
-        //out kLz4CompressBufSize
-        _lz4_write_len4(out_code,outStream_isCanceled,result,kLz4CompressBufSize);
-        
-        while (1) {
-            int  codeLen;
-            unsigned char*  _swap=data_buf;
-            data_buf=data_buf_back;
-            data_buf_back=_swap;
-            int dataLen=kLz4CompressBufSize;
-            if ((size_t)dataLen>(in_data->streamSize-readFromPos))
-                dataLen=(int)(in_data->streamSize-readFromPos);
-            if (dataLen==0)
-                break;//finish
-            if (!in_data->read(in_data,readFromPos,data_buf,data_buf+dataLen))
-                _compress_error_return("in_data->read()");
-            readFromPos+=dataLen;
-            
-            codeLen=LZ4_compress_HC_continue(s,(const char*)data_buf,(char*)code_buf,
-                                             dataLen,code_buf_size);
-            if (codeLen<=0) _compress_error_return("LZ4_compress_HC_continue()");
-            //out step codeLen
-            _lz4_write_len4(out_code,outStream_isCanceled,result,codeLen);
-            //out code
-            _stream_out_code_write(out_code,outStream_isCanceled,result,code_buf,codeLen);
-        }
-    clear:
-        if (0!=LZ4_freeStreamHC(s))
-            { result=kCompressFailResult; if (strlen(errAt)==0) errAt="LZ4_freeStreamHC()"; }
-        _check_compress_result(result,outStream_isCanceled,"_lz4hc_compress()",errAt);
-        if (_temp_buf) free(_temp_buf);
-        return result;
-    }
-
-    _def_fun_compressType(_lz4_compressType,"lz4");
-    static TCompressPlugin_lz4 lz4CompressPlugin={
-        {_lz4_compressType,_default_maxCompressedSize,_default_setParallelThreadNumber,_lz4_compress}, 50};
-    static TCompressPlugin_lz4hc lz4hcCompressPlugin ={
-        {_lz4_compressType,_default_maxCompressedSize,_default_setParallelThreadNumber,_lz4hc_compress}, 11};
-#endif//_CompressPlugin_lz4 or _CompressPlugin_lz4hc
-
-
-#ifdef  _CompressPlugin_zstd
-#if (_IsNeedIncludeDefaultCompressHead)
-#   include "zstd.h" // "zstd/lib/zstd.h" https://github.com/facebook/zstd
-#endif
-    struct TCompressPlugin_zstd{
-        hdiff_TCompress base;
-        int             compress_level; //0..22
-        int             dict_bits;  // 10..(30 or 31)
-        int             thread_num;     //1..(200?)
-    };
-    static int _zstd_setThreadNumber(hdiff_TCompress* compressPlugin,int threadNum){
-        TCompressPlugin_zstd* plugin=(TCompressPlugin_zstd*)compressPlugin;
-        #define ZSTDMT_NBWORKERS_MAX 200
-        if (threadNum>ZSTDMT_NBWORKERS_MAX) threadNum=ZSTDMT_NBWORKERS_MAX;
-        plugin->thread_num=threadNum;
-        return threadNum;
-    }
-    static hpatch_StreamPos_t _zstd_compress(const hdiff_TCompress* compressPlugin,
-                                             const hpatch_TStreamOutput* out_code,
-                                             const hpatch_TStreamInput*  in_data){
-        const TCompressPlugin_zstd* plugin=(const TCompressPlugin_zstd*)compressPlugin;
-        hpatch_StreamPos_t  result=0;
-        const char*         errAt="";
-        unsigned char*      _temp_buf=0;
-        ZSTD_inBuffer       s_input;
-        ZSTD_outBuffer      s_output;
-#if (IS_REUSE_compress_handle)
-        static ZSTD_CStream*  s=0;
-#else
-        ZSTD_CStream*         s=0;
-#endif
-        hpatch_StreamPos_t  readFromPos=0;
-        int                 outStream_isCanceled=0;
-        int                 dict_bits;
-        size_t              ret;
-
-        s_input.size=ZSTD_CStreamInSize();
-        s_output.size=ZSTD_CStreamOutSize();
-        _temp_buf=(unsigned char*)malloc(s_input.size+s_output.size);
-        if (!_temp_buf) _compress_error_return("memory alloc");
-        s_input.src=_temp_buf;
-        s_output.dst=_temp_buf+s_input.size;
-        
-        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)
-                &&((dict_bits-1)>=_ZSTD_WINDOWLOG_MIN)) {
-            --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");
-        }
-        
-        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);
-                }
-            }
-        }
-        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_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);
-        return result;
-    }
-    _def_fun_compressType(_zstd_compressType,"zstd");
-    static TCompressPlugin_zstd zstdCompressPlugin={
-        {_zstd_compressType,_default_maxCompressedSize,_zstd_setThreadNumber,_zstd_compress},
-        20,24,kDefaultCompressThreadNumber};
-#endif//_CompressPlugin_zstd
-
-
-#ifdef  _CompressPlugin_brotli
-#if (_IsNeedIncludeDefaultCompressHead)
-#   include "brotli/encode.h" // "brotli/c/include/brotli/encode.h" https://github.com/google/brotli
-#endif
-    struct TCompressPlugin_brotli{
-        hdiff_TCompress base;
-        int             compress_level; //0..11
-        int             dict_bits;  // 10..30
-    };
-    static hpatch_StreamPos_t _brotli_compress(const hdiff_TCompress* compressPlugin,
-                                               const hpatch_TStreamOutput* out_code,
-                                               const hpatch_TStreamInput*  in_data){
-        const TCompressPlugin_brotli* plugin=(const TCompressPlugin_brotli*)compressPlugin;
-        hpatch_StreamPos_t  result=0;
-        const char*         errAt="";
-        BrotliEncoderState* s=0;
-        hpatch_StreamPos_t  readFromPos=0;
-        int                 outStream_isCanceled=0;
-        uint8_t*        _temp_buf=0;
-        const size_t    kBufSize=kCompressBufSize;
-        uint8_t*        input;
-        uint8_t*        output;
-        size_t          available_in;
-        size_t          available_out;
-        const uint8_t*  next_in;
-        uint8_t*        next_out;
-        
-        _temp_buf=(uint8_t*)malloc(kBufSize*2);
-        if (!_temp_buf) _compress_error_return("memory alloc");
-        input=_temp_buf;
-        output=_temp_buf+kBufSize;
-        available_in=0;
-        available_out=kBufSize;
-        next_out=output;
-        next_in=input;
-
-        if (!s) s=BrotliEncoderCreateInstance(0,0,0);
-        if (!s) _compress_error_return("BrotliEncoderCreateInstance()");
-        if (!BrotliEncoderSetParameter(s,BROTLI_PARAM_QUALITY,plugin->compress_level))
-            _compress_error_return("BrotliEncoderSetParameter()");
-        {
-            uint32_t lgwin = plugin->dict_bits;
-            #define BROTLI_WINDOW_GAP 16
-            #define BROTLI_MAX_BACKWARD_LIMIT(W) (((hpatch_StreamPos_t)1 << (W)) - BROTLI_WINDOW_GAP)
-            while ((BROTLI_MAX_BACKWARD_LIMIT(lgwin-1) >= in_data->streamSize)
-                    &&((lgwin-1)>= BROTLI_MIN_WINDOW_BITS)) {
-                --lgwin;
-            }
-            if (lgwin > BROTLI_MAX_WINDOW_BITS)
-                BrotliEncoderSetParameter(s, BROTLI_PARAM_LARGE_WINDOW, 1u);
-            BrotliEncoderSetParameter(s, BROTLI_PARAM_LGWIN, lgwin);
-        }
-        if (in_data->streamSize > 0) {
-            uint32_t size_hint = in_data->streamSize < (1 << 30) ?
-                (uint32_t)in_data->streamSize : (1u << 30);
-            BrotliEncoderSetParameter(s, BROTLI_PARAM_SIZE_HINT, size_hint);
-        }
-        
-        while (1) {
-            int s_isFinished;
-            if ((available_in==0)&&(readFromPos<in_data->streamSize)){
-                available_in=kBufSize;
-                if (available_in>(in_data->streamSize-readFromPos))
-                    available_in=(size_t)(in_data->streamSize-readFromPos);
-                if (!in_data->read(in_data,readFromPos,input,input+available_in))
-                    _compress_error_return("in_data->read()");
-                readFromPos+=available_in;
-                next_in=input;
-            }
-
-            if (!BrotliEncoderCompressStream(s,
-                (readFromPos==in_data->streamSize) ? BROTLI_OPERATION_FINISH : BROTLI_OPERATION_PROCESS,
-                &available_in, &next_in, &available_out, &next_out, 0))
-                    _compress_error_return("BrotliEncoderCompressStream()");
-
-            s_isFinished=BrotliEncoderIsFinished(s);
-            if ((available_out == 0)||s_isFinished) {                
-                _stream_out_code_write(out_code,outStream_isCanceled,result,
-                                       output,kBufSize-available_out);
-                next_out=output;
-                available_out=kBufSize;
-            }
-
-            if (s_isFinished)
-                break;
-        }
-    clear:
-        BrotliEncoderDestroyInstance(s);
-        _check_compress_result(result,outStream_isCanceled,"_brotli_compress()",errAt);
-        if (_temp_buf) free(_temp_buf);
-        return result;
-    }
-    _def_fun_compressType(_brotli_compressType,"brotli");
-    static TCompressPlugin_brotli brotliCompressPlugin={
-        {_brotli_compressType,_default_maxCompressedSize,_default_setParallelThreadNumber,_brotli_compress}, 9,24};
-#endif//_CompressPlugin_brotli
-
-
-#ifdef  _CompressPlugin_lzham
-#if (_IsNeedIncludeDefaultCompressHead)
-#   include "lzham.h" // "lzham_codec/include/lzham.h" https://github.com/richgel999/lzham_codec
-#endif
-    struct TCompressPlugin_lzham{
-        hdiff_TCompress base;
-        int             compress_level; //0..5
-        int             dict_bits;  // 15..(26 or 29)
-        int             thread_num; //1..(64?)
-    };
-
-    static int _lzham_setParallelThreadNumber(hdiff_TCompress* compressPlugin,int threadNum){
-        TCompressPlugin_lzham* plugin=(TCompressPlugin_lzham*)compressPlugin;
-        if (threadNum>LZHAM_MAX_HELPER_THREADS) threadNum=LZHAM_MAX_HELPER_THREADS;
-        plugin->thread_num=threadNum;
-        return threadNum;
-    }
-
-    static hpatch_StreamPos_t _lzham_compress(const hdiff_TCompress* compressPlugin,
-                                              const hpatch_TStreamOutput* out_code,
-                                              const hpatch_TStreamInput*  in_data){
-        const TCompressPlugin_lzham* plugin=(const TCompressPlugin_lzham*)compressPlugin;
-        hpatch_StreamPos_t  result=0;
-        const char*         errAt="";
-        lzham_compress_params    params;
-        unsigned char            dict_bits;
-        lzham_compress_state_ptr s=0;
-        hpatch_StreamPos_t  readFromPos=0;
-        int                 outStream_isCanceled=0;
-        unsigned char*      _temp_buf=0;
-        const size_t        kBufSize=kCompressBufSize;
-        unsigned char*          input;
-        unsigned char*          output;
-        size_t                  available_in;
-        size_t                  available_out;
-        const unsigned char*    next_in;
-        unsigned char*          next_out;
-        
-        _temp_buf=(unsigned char*)malloc(kBufSize*2);
-        if (!_temp_buf) _compress_error_return("memory alloc");
-        input=_temp_buf;
-        output=_temp_buf+kBufSize;
-        available_in=0;
-        available_out=kBufSize;
-        next_out=output;
-        next_in=input;
-
-        memset(&params, 0, sizeof(params));
-        params.m_struct_size=sizeof(params);
-        dict_bits= (unsigned char)plugin->dict_bits;
-         while (((((hpatch_StreamPos_t)1)<<(dict_bits-1)) >= in_data->streamSize)
-                &&((dict_bits-1)>=LZHAM_MIN_DICT_SIZE_LOG2)) {
-            --dict_bits;
-        }
-        params.m_dict_size_log2 = dict_bits;
-        if (plugin->compress_level<=LZHAM_COMP_LEVEL_UBER){
-            params.m_level=(lzham_compress_level)plugin->compress_level;
-        }else{
-            params.m_level = LZHAM_COMP_LEVEL_UBER;
-            params.m_compress_flags |= LZHAM_COMP_FLAG_EXTREME_PARSING;
-        }
-        if (plugin->thread_num>1)
-            params.m_max_helper_threads = plugin->thread_num;
-
-        if (!s) s=lzham_compress_init(&params);
-        if (!s) _compress_error_return("lzham_compress_init()");
-                
-        {//save head
-            if (!out_code->write(out_code,0,(&dict_bits),(&dict_bits)+1))
-                _compress_error_return("out_code->write()");
-            ++result;
-        }
-
-        while (1) {
-            lzham_compress_status_t ret;
-            int s_isFinished;
-            if ((available_in==0)&&(readFromPos<in_data->streamSize)){
-                available_in=kBufSize;
-                if (available_in>(in_data->streamSize-readFromPos))
-                    available_in=(size_t)(in_data->streamSize-readFromPos);
-                if (!in_data->read(in_data,readFromPos,input,input+available_in))
-                    _compress_error_return("in_data->read()");
-                readFromPos+=available_in;
-                next_in=input;
-            }
-
-            {
-                size_t available_in_back=available_in;
-                size_t available_out_back=available_out;
-                ret=lzham_compress2(s,next_in,&available_in,next_out,&available_out,
-                                    (readFromPos==in_data->streamSize) ? LZHAM_FINISH : LZHAM_NO_FLUSH);
-                next_out+=available_out;
-                next_in+=available_in;
-                available_in=available_in_back-available_in;
-                available_out=available_out_back-available_out;
-            }
-            if (ret>=LZHAM_COMP_STATUS_FIRST_FAILURE_CODE)
-                _compress_error_return("lzham_compress2()");
-
-            s_isFinished=(ret==LZHAM_COMP_STATUS_SUCCESS);
-            if ((ret==LZHAM_COMP_STATUS_HAS_MORE_OUTPUT)||(available_out == 0)||s_isFinished) {                
-                _stream_out_code_write(out_code,outStream_isCanceled,result,
-                                       output,kBufSize-available_out);
-                next_out=output;
-                available_out=kBufSize;
-            }
-
-            if (s_isFinished)
-                break;
-        }
-    clear:
-        lzham_compress_deinit(s);
-        _check_compress_result(result,outStream_isCanceled,"_lzham_compress()",errAt);
-        if (_temp_buf) free(_temp_buf);
-        return result;
-    }
-    _def_fun_compressType(_lzham_compressType,"lzham");
-    static TCompressPlugin_lzham lzhamCompressPlugin={
-        {_lzham_compressType,_default_maxCompressedSize,_lzham_setParallelThreadNumber,_lzham_compress},
-         LZHAM_COMP_LEVEL_BETTER,24,kDefaultCompressThreadNumber};
-#endif//_CompressPlugin_lzham
-
-#ifdef __cplusplus
-}
-#endif
-#endif