react-native-update 10.28.10 → 10.28.11

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

@@ -1,344 +0,0 @@
-//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/src/main/cpp/HDiffPatch/compress_parallel.cpp

@@ -1,166 +0,0 @@
-//  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/src/main/cpp/HDiffPatch/compress_parallel.h

@@ -1,59 +0,0 @@
-//  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