react-native-update 10.34.2 → 10.34.4

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

@@ -0,0 +1,344 @@
+//checksum_plugin_demo.h
+//  checksum plugin demo for HDiffz\HPatchz
+/*
+ The MIT License (MIT)
+ Copyright (c) 2018-2019 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 HPatch_checksum_plugin_demo_h
+#define HPatch_checksum_plugin_demo_h
+//checksum plugin demo:
+//  crc32ChecksumPlugin
+//  adler32ChecksumPlugin
+//  adler64ChecksumPlugin
+//  fadler32ChecksumPlugin
+//  fadler64ChecksumPlugin
+//  fadler128ChecksumPlugin
+//  md5ChecksumPlugin
+
+#include "libHDiffPatch/HPatch/checksum_plugin.h"
+
+#ifndef _IsNeedIncludeDefaultChecksumHead
+#   define _IsNeedIncludeDefaultChecksumHead 1
+#endif
+
+#define __out_checksum4__(out_code,i0,v,shr) {    \
+    (out_code)[i0  ]=(unsigned char)((v)>>(shr));   \
+    (out_code)[i0+1]=(unsigned char)((v)>>(shr+8)); \
+    (out_code)[i0+2]=(unsigned char)((v)>>(shr+16));\
+    (out_code)[i0+3]=(unsigned char)((v)>>(shr+24));\
+}
+#define __out_checksum4(out_code,v)     __out_checksum4__(out_code,0,v,0)
+#define __out_checksum8(out_code,v)  {  __out_checksum4__(out_code,0,v,0); \
+                                        __out_checksum4__(out_code,4,v,32); }
+
+
+#ifdef  _ChecksumPlugin_crc32
+#if (_IsNeedIncludeDefaultChecksumHead)
+#   include "zlib.h" // http://zlib.net/  https://github.com/madler/zlib
+#endif
+static const char* _crc32_checksumType(void){
+    static const char* type="crc32";
+    return type;
+}
+static size_t _crc32_checksumByteSize(void){
+    return sizeof(hpatch_uint32_t);
+}
+static hpatch_checksumHandle _crc32_open(hpatch_TChecksum* plugin){
+    return malloc(sizeof(hpatch_uint32_t));
+}
+static void _crc32_close(hpatch_TChecksum* plugin,hpatch_checksumHandle handle){
+    if (handle) free(handle);
+}
+static void  _crc32_begin(hpatch_checksumHandle handle){
+    hpatch_uint32_t* pv=(hpatch_uint32_t*)handle;
+    *pv=(hpatch_uint32_t)crc32(0,0,0);
+}
+static void _crc32_append(hpatch_checksumHandle handle,
+                          const unsigned char* part_data,const unsigned char* part_data_end){
+    hpatch_uint32_t* pv=(hpatch_uint32_t*)handle;
+    uLong v=*pv;
+    while (part_data!=part_data_end) {
+        size_t dataSize=(size_t)(part_data_end-part_data);
+        uInt  len=~(uInt)0;
+        //assert(len>0);
+        if (len>dataSize)
+            len=(uInt)dataSize;
+        v=crc32(v,part_data,len);
+        part_data+=len;
+    }
+    *pv=(hpatch_uint32_t)v;
+}
+static void _crc32_end(hpatch_checksumHandle handle,
+                       unsigned char* checksum,unsigned char* checksum_end){
+    hpatch_uint32_t v=*(hpatch_uint32_t*)handle;
+    assert(4==checksum_end-checksum);
+    __out_checksum4(checksum,v);
+}
+static hpatch_TChecksum crc32ChecksumPlugin={ _crc32_checksumType,_crc32_checksumByteSize,_crc32_open,
+                                              _crc32_close,_crc32_begin,_crc32_append,_crc32_end};
+#endif//_ChecksumPlugin_crc32
+
+
+#ifdef  _ChecksumPlugin_adler32
+#   ifndef _ChecksumPlugin_crc32
+#       include "libHDiffPatch/HDiff/private_diff/limit_mem_diff/adler_roll.h"
+#   endif
+static const char* _adler32_checksumType(void){
+    static const char* type="adler32";
+    return type;
+}
+static size_t _adler32_checksumByteSize(void){
+    return sizeof(hpatch_uint32_t);
+}
+static hpatch_checksumHandle _adler32_open(hpatch_TChecksum* plugin){
+    return malloc(sizeof(hpatch_uint32_t));
+}
+static void _adler32_close(hpatch_TChecksum* plugin,hpatch_checksumHandle handle){
+    if (handle) free(handle);
+}
+static void  _adler32_begin(hpatch_checksumHandle handle){
+    hpatch_uint32_t* pv=(hpatch_uint32_t*)handle;
+#ifdef _ChecksumPlugin_crc32
+    *pv=(hpatch_uint32_t)adler32(0,0,0);
+#else
+    *pv=adler32_start(0,0);
+#endif
+}
+static void _adler32_append(hpatch_checksumHandle handle,
+                          const unsigned char* part_data,const unsigned char* part_data_end){
+    hpatch_uint32_t* pv=(hpatch_uint32_t*)handle;
+#ifdef _ChecksumPlugin_crc32
+    uLong v=*pv;
+    while (part_data!=part_data_end) {
+        size_t dataSize=(size_t)(part_data_end-part_data);
+        uInt  len=~(uInt)0;
+        //assert(len>0);
+        if (len>dataSize)
+            len=(uInt)dataSize;
+        v=adler32(v,part_data,len);
+        part_data+=len;
+    }
+    *pv=(hpatch_uint32_t)v;
+#else
+    *pv=_adler32_append(*pv,part_data,(size_t)(part_data_end-part_data));
+#endif
+}
+static void _adler32_end(hpatch_checksumHandle handle,
+                       unsigned char* checksum,unsigned char* checksum_end){
+    hpatch_uint32_t v=*(hpatch_uint32_t*)handle;
+    assert(4==checksum_end-checksum);
+    __out_checksum4(checksum,v);
+}
+static hpatch_TChecksum adler32ChecksumPlugin={ _adler32_checksumType,_adler32_checksumByteSize,_adler32_open,
+                                                _adler32_close,_adler32_begin,_adler32_append,_adler32_end};
+#endif//_ChecksumPlugin_adler32
+
+
+#ifdef  _ChecksumPlugin_adler64
+#include "libHDiffPatch/HDiff/private_diff/limit_mem_diff/adler_roll.h"
+static const char* _adler64_checksumType(void){
+    static const char* type="adler64";
+    return type;
+}
+static size_t _adler64_checksumByteSize(void){
+    return sizeof(hpatch_uint64_t);
+}
+static hpatch_checksumHandle _adler64_open(hpatch_TChecksum* plugin){
+    return malloc(sizeof(hpatch_uint64_t));
+}
+static void _adler64_close(hpatch_TChecksum* plugin,hpatch_checksumHandle handle){
+    if (handle) free(handle);
+}
+static void  _adler64_begin(hpatch_checksumHandle handle){
+    hpatch_uint64_t* pv=(hpatch_uint64_t*)handle;
+    *pv=adler64_start(0,0);
+}
+static void _adler64_append(hpatch_checksumHandle handle,
+                            const unsigned char* part_data,const unsigned char* part_data_end){
+    hpatch_uint64_t* pv=(hpatch_uint64_t*)handle;
+    *pv=adler64_append(*pv,part_data,part_data_end-part_data);
+}
+static void _adler64_end(hpatch_checksumHandle handle,
+                         unsigned char* checksum,unsigned char* checksum_end){
+    hpatch_uint64_t v=*(hpatch_uint64_t*)handle;
+    assert(8==checksum_end-checksum);
+    __out_checksum8(checksum,v);
+}
+static hpatch_TChecksum adler64ChecksumPlugin={ _adler64_checksumType,_adler64_checksumByteSize,_adler64_open,
+                                                _adler64_close,_adler64_begin,_adler64_append,_adler64_end};
+#endif//_ChecksumPlugin_adler64
+
+
+#ifdef  _ChecksumPlugin_fadler32
+#include "libHDiffPatch/HDiff/private_diff/limit_mem_diff/adler_roll.h"
+static const char* _fadler32_checksumType(void){
+    static const char* type="fadler32";
+    return type;
+}
+static size_t _fadler32_checksumByteSize(void){
+    return sizeof(hpatch_uint32_t);
+}
+static hpatch_checksumHandle _fadler32_open(hpatch_TChecksum* plugin){
+    return malloc(sizeof(hpatch_uint32_t));
+}
+static void _fadler32_close(hpatch_TChecksum* plugin,hpatch_checksumHandle handle){
+    if (handle) free(handle);
+}
+static void  _fadler32_begin(hpatch_checksumHandle handle){
+    hpatch_uint32_t* pv=(hpatch_uint32_t*)handle;
+    *pv=*pv=fast_adler32_start(0,0);
+}
+static void _fadler32_append(hpatch_checksumHandle handle,
+                             const unsigned char* part_data,const unsigned char* part_data_end){
+    hpatch_uint32_t* pv=(hpatch_uint32_t*)handle;
+    *pv=fast_adler32_append(*pv,part_data,part_data_end-part_data);
+}
+static void _fadler32_end(hpatch_checksumHandle handle,
+                         unsigned char* checksum,unsigned char* checksum_end){
+    hpatch_uint32_t v=*(hpatch_uint32_t*)handle;
+    assert(4==checksum_end-checksum);
+    __out_checksum4(checksum,v);
+}
+static hpatch_TChecksum fadler32ChecksumPlugin={ _fadler32_checksumType,_fadler32_checksumByteSize,_fadler32_open,
+                                                 _fadler32_close,_fadler32_begin,_fadler32_append,_fadler32_end};
+#endif//_ChecksumPlugin_fadler32
+
+
+#ifdef  _ChecksumPlugin_fadler64
+#include "libHDiffPatch/HDiff/private_diff/limit_mem_diff/adler_roll.h"
+static const char* _fadler64_checksumType(void){
+    static const char* type="fadler64";
+    return type;
+}
+static size_t _fadler64_checksumByteSize(void){
+    return sizeof(hpatch_uint64_t);
+}
+static hpatch_checksumHandle _fadler64_open(hpatch_TChecksum* plugin){
+    return malloc(sizeof(hpatch_uint64_t));
+}
+static void _fadler64_close(hpatch_TChecksum* plugin,hpatch_checksumHandle handle){
+    if (handle) free(handle);
+}
+static void  _fadler64_begin(hpatch_checksumHandle handle){
+    hpatch_uint64_t* pv=(hpatch_uint64_t*)handle;
+    *pv=fast_adler64_start(0,0);
+}
+static void _fadler64_append(hpatch_checksumHandle handle,
+                            const unsigned char* part_data,const unsigned char* part_data_end){
+    hpatch_uint64_t* pv=(hpatch_uint64_t*)handle;
+    *pv=fast_adler64_append(*pv,part_data,part_data_end-part_data);
+}
+static void _fadler64_end(hpatch_checksumHandle handle,
+                         unsigned char* checksum,unsigned char* checksum_end){
+    hpatch_uint64_t v=*(hpatch_uint64_t*)handle;
+    assert(8==checksum_end-checksum);
+    __out_checksum8(checksum,v);
+}
+static hpatch_TChecksum fadler64ChecksumPlugin={ _fadler64_checksumType,_fadler64_checksumByteSize,_fadler64_open,
+                                                 _fadler64_close,_fadler64_begin,_fadler64_append,_fadler64_end};
+#endif//_ChecksumPlugin_fadler64
+
+
+#ifdef  _ChecksumPlugin_fadler128
+#include "libHDiffPatch/HDiff/private_diff/limit_mem_diff/adler_roll.h"
+static const char* _fadler128_checksumType(void){
+    static const char* type="fadler128";
+    return type;
+}
+static size_t _fadler128_checksumByteSize(void){
+    return sizeof(adler128_t);
+}
+static hpatch_checksumHandle _fadler128_open(hpatch_TChecksum* plugin){
+    return malloc(sizeof(adler128_t));
+}
+static void _fadler128_close(hpatch_TChecksum* plugin,hpatch_checksumHandle handle){
+    if (handle) free(handle);
+}
+static void  _fadler128_begin(hpatch_checksumHandle handle){
+    adler128_t* pv=(adler128_t*)handle;
+    *pv=fast_adler128_start(0,0);
+}
+static void _fadler128_append(hpatch_checksumHandle handle,
+                             const unsigned char* part_data,const unsigned char* part_data_end){
+    adler128_t* pv=(adler128_t*)handle;
+    *pv=fast_adler128_append(*pv,part_data,part_data_end-part_data);
+}
+static void _fadler128_end(hpatch_checksumHandle handle,
+                          unsigned char* checksum,unsigned char* checksum_end){
+    const adler128_t* pv=(const adler128_t*)handle;
+    assert(16==checksum_end-checksum);
+    __out_checksum8(checksum,pv->adler);
+    __out_checksum8(checksum+8,pv->sum);
+}
+static hpatch_TChecksum fadler128ChecksumPlugin={ _fadler128_checksumType,_fadler128_checksumByteSize,
+                            _fadler128_open,_fadler128_close,_fadler128_begin,_fadler128_append,_fadler128_end};
+#endif//_ChecksumPlugin_fadler128
+
+
+#ifdef  _ChecksumPlugin_md5
+#if (_IsNeedIncludeDefaultChecksumHead)
+#   include "md5.h" // https://sourceforge.net/projects/libmd5-rfc  https://github.com/sisong/libmd5
+#endif
+static const char* _md5_checksumType(void){
+    static const char* type="md5";
+    return type;
+}
+static size_t _md5_checksumByteSize(void){
+    return 16;
+}
+static hpatch_checksumHandle _md5_open(hpatch_TChecksum* plugin){
+    return malloc(sizeof(md5_state_t));
+}
+static void _md5_close(hpatch_TChecksum* plugin,hpatch_checksumHandle handle){
+    if (handle) free(handle);
+}
+static void  _md5_begin(hpatch_checksumHandle handle){
+    md5_state_t* ps=(md5_state_t*)handle;
+    md5_init(ps);
+}
+static void _md5_append(hpatch_checksumHandle handle,
+                          const unsigned char* part_data,const unsigned char* part_data_end){
+    md5_state_t* ps=(md5_state_t*)handle;
+    while (part_data!=part_data_end) {
+        size_t dataSize=(size_t)(part_data_end-part_data);
+        int  len=(int)((~(unsigned int)0)>>1);
+        //assert(len>0);
+        if ((unsigned int)len>dataSize)
+            len=(int)dataSize;
+        md5_append(ps,part_data,len);
+        part_data+=len;
+    }
+}
+static void _md5_end(hpatch_checksumHandle handle,
+                       unsigned char* checksum,unsigned char* checksum_end){
+    md5_state_t* ps=(md5_state_t*)handle;
+    assert(16==checksum_end-checksum);
+    md5_finish(ps,checksum);
+}
+static hpatch_TChecksum md5ChecksumPlugin={ _md5_checksumType,_md5_checksumByteSize,_md5_open,
+                                            _md5_close,_md5_begin,_md5_append,_md5_end};
+#endif//_ChecksumPlugin_md5
+
+
+#endif

package/harmony/pushy/src/main/cpp/HDiffPatch/compress_parallel.cpp

@@ -0,0 +1,166 @@
+//  compress_parallel.cpp
+//  parallel compress for HDiffz
+/*
+ The MIT License (MIT)
+ Copyright (c) 2019 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.
+ */
+#include "compress_parallel.h"
+#if (_IS_USED_MULTITHREAD)
+#include <stdio.h>
+#include <exception>
+#include <vector>
+#include "libParallel/parallel_channel.h"
+#include "libHDiffPatch/HDiff/private_diff/mem_buf.h"
+
+
+#define check(value) { \
+    if (!(value)) throw std::runtime_error("parallel_compress_blocks() check "#value" error!"); }
+
+
+
+struct TBlockCompressor {
+    hdiff_compressBlockHandle       handle;
+    inline explicit TBlockCompressor():handle(0) { }
+    inline ~TBlockCompressor() { if ((_pc!=0)&&(handle!=0)) _pc->closeBlockCompressor(_pc,handle); }
+    inline void open(hdiff_TParallelCompress* pc){
+        _pc=pc;
+        handle=pc->openBlockCompressor(pc);
+        check(handle!=0);
+    }
+    hdiff_TParallelCompress*  _pc;
+};
+
+struct TWorkData{
+    hdiff_TParallelCompress*        pc;
+    size_t                          blockSize;
+    size_t                          threadMemSize;
+    const hpatch_TStreamOutput*     out_code;
+    const hpatch_TStreamInput*      in_data;
+    
+    bool                            isInError;
+    hpatch_StreamPos_t              inDataPos;
+    hpatch_StreamPos_t              outCodePos;
+    hpatch_StreamPos_t              outBlockIndex;
+    std::vector<TBlockCompressor>   blockCompressors;
+    hdiff_private::TAutoMem         mem;
+    CHLocker                        ioLocker;
+    int                             chanWaitCount;
+    CChannel                        chanForWaitWrite;
+    CChannel                        chanForWorkEnd;
+};
+
+void _threadRunCallBack(int threadIndex,void* _workData){
+    #define _check_br(value){ \
+        if (!(value)) { fprintf(stderr,"parallel_compress_blocks() check "#value" error!\n"); \
+        wd.isInError=true; wd.chanForWaitWrite.close(); wd.chanForWorkEnd.close(); break; } }
+    TWorkData& wd=*(TWorkData*)_workData;
+    hdiff_compressBlockHandle cbhandle=wd.blockCompressors[threadIndex].handle;
+    unsigned char* dataBuf=wd.mem.data()+threadIndex*wd.threadMemSize;
+    unsigned char* codeBuf=dataBuf+wd.blockSize;
+    unsigned char* codeBufEnd=dataBuf+wd.threadMemSize;
+    while (true) {
+        size_t readLen=wd.blockSize;
+        hpatch_StreamPos_t blockIndex;
+        {//read data
+            CAutoLocker _autoLoker(wd.ioLocker.locker);
+            if (wd.isInError) break;
+            blockIndex=wd.inDataPos/wd.blockSize;
+            if (readLen+wd.inDataPos>wd.in_data->streamSize)
+                readLen=(size_t)(wd.in_data->streamSize-wd.inDataPos);
+            if (readLen==0) break;
+            _check_br(wd.in_data->read(wd.in_data,wd.inDataPos,dataBuf,dataBuf+readLen));
+            wd.inDataPos+=readLen;
+        }
+        //compress
+        size_t codeLen=wd.pc->compressBlock(wd.pc,cbhandle,blockIndex,
+                                            codeBuf,codeBufEnd,dataBuf,dataBuf+readLen);
+        while (true) {//write code
+            {//write or wait ?
+                CAutoLocker _autoLoker(wd.ioLocker.locker);
+                if (wd.isInError) break;
+                _check_br(codeLen>0);
+                //write
+                const bool isWrite=(blockIndex==wd.outBlockIndex);
+                if (isWrite){
+                    _check_br(wd.out_code->write(wd.out_code,wd.outCodePos,codeBuf,codeBuf+codeLen));
+                    wd.outCodePos+=codeLen;
+                    ++wd.outBlockIndex;
+                }
+                //wake all
+                for (int i=0; i<wd.chanWaitCount; ++i)
+                    wd.chanForWaitWrite.send((TChanData)(1+(size_t)i),true);
+                wd.chanWaitCount=0;
+                //continue work or wait
+                if (isWrite)
+                    break;//continue work
+                else
+                    ++wd.chanWaitCount; //continue wait
+            }
+            //wait
+            wd.chanForWaitWrite.accept(true);
+        }
+    }
+    wd.chanForWorkEnd.send((TChanData)(1+(size_t)threadIndex),true); //can't send null
+    #undef _check_br
+}
+
+
+hpatch_StreamPos_t parallel_compress_blocks(hdiff_TParallelCompress* pc,
+                                            int threadNum,size_t blockSize,
+                                            const hpatch_TStreamOutput* out_code,
+                                            const hpatch_TStreamInput*  in_data){
+    assert(blockSize>0);
+    assert(threadNum>0);
+    if (threadNum<1) threadNum=1;
+    hpatch_StreamPos_t blockCount=(in_data->streamSize+blockSize-1)/blockSize;
+    if ((hpatch_StreamPos_t)threadNum>blockCount) threadNum=(int)blockCount;
+    try {
+        TWorkData workData;
+        workData.isInError=false;
+        workData.chanWaitCount=0;
+        workData.pc=pc;
+        workData.blockSize=blockSize;
+        workData.out_code=out_code;
+        workData.outCodePos=0;
+        workData.outBlockIndex=0;
+        workData.in_data=in_data;
+        workData.inDataPos=0;
+        workData.threadMemSize=(size_t)(blockSize + pc->maxCompressedSize(blockSize));
+        workData.mem.realloc(workData.threadMemSize*threadNum);
+        workData.blockCompressors.resize(threadNum);
+        for (int t=0; t<threadNum; ++t)
+            workData.blockCompressors[t].open(pc);
+        
+        thread_parallel(threadNum,_threadRunCallBack,&workData,hpatch_TRUE,0);
+        
+        for (int t=0;t<threadNum; ++t) //wait all thread end
+            workData.chanForWorkEnd.accept(true);
+        return workData.isInError?0:workData.outCodePos;
+    } catch (const std::exception& e) {
+        fprintf(stderr,"parallel_compress_blocks run error! %s\n",e.what());
+        return 0; //error
+    }
+}
+
+#endif// _IS_USED_MULTITHREAD

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

@@ -0,0 +1,59 @@
+//  compress_parallel.h
+//  parallel compress for HDiffz
+/*
+ The MIT License (MIT)
+ Copyright (c) 2019 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_parallel_h
+#define HDiff_compress_parallel_h
+#include "libHDiffPatch/HDiff/diff_types.h"
+#include "libParallel/parallel_import.h"
+#if (_IS_USED_MULTITHREAD)
+#ifdef __cplusplus
+extern "C" {
+#endif
+    
+    typedef void* hdiff_compressBlockHandle;
+    typedef struct hdiff_TParallelCompress{
+        void*                                    import;
+        hpatch_StreamPos_t          (*maxCompressedSize)(hpatch_StreamPos_t dataSize);
+        hdiff_compressBlockHandle (*openBlockCompressor)(struct hdiff_TParallelCompress* pc);
+        void                     (*closeBlockCompressor)(struct hdiff_TParallelCompress* pc,
+                                                         hdiff_compressBlockHandle blockCompressor);
+        //compressBlock() called multiple times by thread
+        size_t  (*compressBlock)(struct 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);
+    } hdiff_TParallelCompress;
+    
+    hpatch_StreamPos_t parallel_compress_blocks(hdiff_TParallelCompress* pc,
+                                                int threadNum,size_t blockSize,
+                                                const hpatch_TStreamOutput* out_code,
+                                                const hpatch_TStreamInput*  in_data);
+#ifdef __cplusplus
+}
+#endif
+#endif
+#endif