react-native-update 10.34.1 → 10.34.3

package/harmony/pushy/src/main/cpp/HDiffPatch/libhsync/sign_diff/_match_in_old_sign.cpp

@@ -0,0 +1,254 @@
+//match_in_old_sign.cpp
+//sign_diff
+//Created by housisong on 2025-04-16.
+/*
+ The MIT License (MIT)
+ Copyright (c) 2025 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 "_match_in_old_sign.h"
+#include "../sync_client/match_in_types.h"
+namespace sync_private{
+
+    #define check(value,info) { if (!(value)) { throw std::runtime_error(info); } }
+    #define checkv(value)     check(value,"check "#value" error!")
+
+    static  const size_t kMinMatchedLength = 16;
+
+#if (_IS_USED_MULTITHREAD)
+    struct _TMatchSDatas;
+    namespace{
+        struct TMt:public TMtByChannel{
+            inline explicit TMt(struct _TMatchSDatas& _matchDatas)
+                :matchDatas(_matchDatas),workIndex(0){}
+            CHLocker readLocker;
+            CHLocker writeLocker;
+            std::atomic<size_t>  workIndex;
+            struct _TMatchSDatas& matchDatas;
+        };
+    }
+#endif //_IS_USED_MULTITHREAD
+
+static bool matchRange(hpatch_TOutputCovers* out_covers,const uint32_t* range_begin,const uint32_t* range_end,
+                       TStreamDataCache_base& newData,const TNewDataSyncInfo* oldSyncInfo,uint32_t& oldBlockIndex_bck,void* _mt){
+    const TByte* newPartStrongChecksum=0;
+    const size_t outPartChecksumSize=_bitsToBytes(oldSyncInfo->savedStrongChecksumBits);
+    int hitOutLimit=kMatchHitOutLimit;
+    do {
+        uint32_t oldBlockIndex=*range_begin;
+        if (newPartStrongChecksum==0)
+            newPartStrongChecksum=newData.calcPartStrongChecksum(oldSyncInfo->savedStrongChecksumBits);
+        const TByte* oldPairStrongChecksum=oldSyncInfo->partChecksums+oldBlockIndex*outPartChecksumSize;
+        if (0==memcmp(newPartStrongChecksum,oldPairStrongChecksum,outPartChecksumSize)){
+            const hpatch_uint32_t nextIndex=oldBlockIndex_bck+1;
+            if (nextIndex!=oldBlockIndex){ //try continuous
+                const uint32_t kBlockCount=(uint32_t)TNewDataSyncInfo_blockCount(oldSyncInfo);
+                const size_t kRollHashByteSize=oldSyncInfo->savedRollHashByteSize;
+                if ((nextIndex<kBlockCount)
+                  &&(0==memcmp(newPartStrongChecksum,oldSyncInfo->partChecksums+nextIndex*outPartChecksumSize,outPartChecksumSize))
+                  &&(0==memcmp(oldSyncInfo->rollHashs+oldBlockIndex*kRollHashByteSize,oldSyncInfo->rollHashs+nextIndex*kRollHashByteSize,kRollHashByteSize))){
+                    oldBlockIndex=nextIndex;
+                }
+            }
+            oldBlockIndex_bck=oldBlockIndex;
+            return true;
+        }else{
+            if ((--hitOutLimit)<=0) break;
+        }
+    }while ((++range_begin)!=range_end);
+    return false;
+}
+
+    inline static bool _tryCombine(hpatch_TCover& lastCover,const hpatch_TCover& cover){
+        if ((lastCover.oldPos+lastCover.length==cover.oldPos)
+          &&(lastCover.newPos+lastCover.length==cover.newPos)){
+            lastCover.length+=cover.length;
+            return true;
+        }else
+            return false;
+    }
+    
+    inline static void _outACover(hpatch_TOutputCovers* out_covers,hpatch_TCover& cover,void *_mt){
+        if (cover.length>=kMinMatchedLength){
+    #if (_IS_USED_MULTITHREAD)
+            TMt* mt=(TMt*)_mt;
+            CAutoLocker _autoLocker(mt?mt->writeLocker.locker:0);
+    #endif
+            out_covers->push_cover(out_covers,&cover);
+        }
+    }
+
+    struct _TMatchSDatas{
+        hpatch_TOutputCovers*       out_covers;
+        const TOldDataSyncInfo*     oldSyncInfo;
+        const hpatch_TStreamInput*  newStream;
+        const void*         filter;
+        const uint32_t*     sorted_oldIndexs;
+        const uint32_t*     sorted_oldIndexs_table;
+        size_t              kMatchBlockCount;
+        unsigned int        kTableHashShlBit;
+        uint32_t            threadNum;
+    };
+
+static void _rollMatch(_TMatchSDatas& rd,hpatch_StreamPos_t newRollBegin,
+                       hpatch_StreamPos_t newRollEnd,void* _mt=0){
+    const hpatch_uint32_t kSyncBlockSize=rd.oldSyncInfo->kSyncBlockSize;
+    const hpatch_StreamPos_t oldSize=rd.oldSyncInfo->newDataSize;
+    const hpatch_StreamPos_t newSize=rd.newStream->streamSize;
+    const uint32_t kBlockCount=(uint32_t)TNewDataSyncInfo_blockCount(rd.oldSyncInfo);
+    TIndex_comp0 icomp0(rd.oldSyncInfo->rollHashs,rd.oldSyncInfo->savedRollHashByteSize);
+    TStreamDataRoll newData(rd.newStream,newRollBegin,newRollEnd,kSyncBlockSize,rd.oldSyncInfo->strongChecksumPlugin
+                        #if (_IS_USED_MULTITHREAD)
+                            ,_mt?((TMt*)_mt)->readLocker.locker:0
+                        #endif
+                            );
+    uint8_t part[sizeof(tm_roll_uint)]={0};
+    const size_t savedRollHashBits=rd.oldSyncInfo->savedRollHashBits;
+    const TBloomFilter<tm_roll_uint>& filter=*(TBloomFilter<tm_roll_uint>*)rd.filter;
+    tm_roll_uint digestFull_back=~newData.hashValue(); //not same digest
+    uint32_t oldBlockIndex_bck=-1;
+    hpatch_TCover cover_prev={0};
+    while (true) {
+        tm_roll_uint digest=newData.hashValue();
+        if (digestFull_back!=digest){
+            digestFull_back=digest;
+            digest=toSavedPartRollHash(digest,savedRollHashBits);
+            if (!filter.is_hit(digest))
+                { if (newData.roll()) continue; else break; }//finish
+        }else{
+            if (newData.roll()) continue; else break; //finish
+        }
+        
+        const uint32_t* ti_pos=&rd.sorted_oldIndexs_table[digest>>rd.kTableHashShlBit];
+        writeRollHashBytes(part,digest,rd.oldSyncInfo->savedRollHashByteSize);
+        TIndex_comp0::TDigest digest_value(part);
+        std::pair<const uint32_t*,const uint32_t*>
+        //range=std::equal_range(rd.sorted_oldIndexs,rd.sorted_oldIndexs+(kBlockCount-rd.oldSyncInfo->samePairCount),digest_value,icomp0);
+        range=std::equal_range(rd.sorted_oldIndexs+ti_pos[0],
+                               rd.sorted_oldIndexs+ti_pos[1],digest_value,icomp0);
+        if (range.first==range.second)
+            { if (newData.roll()) continue; else break; }//finish
+
+        bool isMatched=matchRange(rd.out_covers,range.first,range.second,
+                                  newData,rd.oldSyncInfo,oldBlockIndex_bck,_mt);
+        if (isMatched){
+            hpatch_TCover cover;
+            cover.oldPos=oldBlockIndex_bck*(hpatch_StreamPos_t)kSyncBlockSize;
+            cover.newPos=newData.curStreamPos();
+            cover.length=kSyncBlockSize;
+            assert(cover.oldPos<oldSize);
+            assert(cover.newPos<newSize);
+            if (cover.oldPos+cover.length>oldSize) cover.length=oldSize-cover.oldPos;
+            if (cover.newPos+cover.length>newSize) cover.length=newSize-cover.newPos;
+            if (!_tryCombine(cover_prev,cover)){
+                _outACover(rd.out_covers,cover_prev,_mt);
+                cover_prev=cover;
+            }
+            if (newData.nextBlock()){ digestFull_back=~newData.hashValue(); continue; } else break;
+        }//else roll
+        if (newData.roll()) continue; else break;
+    }
+    _outACover(rd.out_covers,cover_prev,_mt);
+}
+
+
+#if (_IS_USED_MULTITHREAD)
+static void _rollMatch_mt(int threadIndex,void* workData){
+    TMt& mt=*(TMt*)workData;
+    TMtByChannel::TAutoThreadEnd __auto_thread_end(mt);
+
+    hpatch_StreamPos_t clipSize=kBestMTClipSize;
+    hpatch_StreamPos_t _minClipSize=(hpatch_StreamPos_t)(mt.matchDatas.oldSyncInfo->kSyncBlockSize)*4;
+    if (clipSize<_minClipSize) clipSize=_minClipSize;
+    uint32_t threadNum=mt.matchDatas.threadNum;
+    hpatch_StreamPos_t newSize=mt.matchDatas.newStream->streamSize;
+    hpatch_StreamPos_t _maxClipSize=(newSize+threadNum-1)/threadNum;
+    if (clipSize>_maxClipSize) clipSize=_maxClipSize;
+    size_t workCount=(size_t)((newSize+clipSize-1)/clipSize);
+    assert(workCount*clipSize>=newSize);
+    try{
+        std::atomic<size_t>& workIndex=*(std::atomic<size_t>*)&mt.workIndex;
+        while (true){
+            size_t curWorkIndex=workIndex++;
+            if (curWorkIndex>=workCount) break;
+            hpatch_StreamPos_t newPosBegin=curWorkIndex*clipSize;
+            hpatch_StreamPos_t newPosEnd = newPosBegin+clipSize;
+            if (newPosEnd>newSize) newPosEnd=newSize;
+            _rollMatch(mt.matchDatas,newPosBegin,newPosEnd,&mt);
+        }
+    }catch(...){
+        mt.on_error();
+    }
+}
+#endif
+
+static void _matchNewDataInOldSign(_TMatchSDatas& matchDatas,int threadNum){
+    const TOldDataSyncInfo* oldSyncInfo=matchDatas.oldSyncInfo;
+    const uint32_t kBlockCount=(uint32_t)TNewDataSyncInfo_blockCount(oldSyncInfo);
+    const uint32_t kMatchBlockCount=kBlockCount-oldSyncInfo->samePairCount;
+    
+    const hpatch_StreamPos_t newDataSize=matchDatas.newStream->streamSize;
+    if (newDataSize==0) return;
+
+    TAutoMem _mem_sorted;
+    TBloomFilter<tm_roll_uint> filter;
+    filter.init(kMatchBlockCount);
+    const uint32_t* sorted_oldIndexs=getSortedIndexs(_mem_sorted,oldSyncInfo,filter);
+    
+    TAutoMem _mem_table;
+    unsigned int kTableHashShlBit=0;
+    const uint32_t* sorted_oldIndexs_table=getSortedIndexsTable(_mem_table,oldSyncInfo,sorted_oldIndexs,&kTableHashShlBit);
+
+    matchDatas.filter=&filter;
+    matchDatas.sorted_oldIndexs=sorted_oldIndexs;
+    matchDatas.sorted_oldIndexs_table=sorted_oldIndexs_table;
+    matchDatas.kTableHashShlBit=kTableHashShlBit;
+#if (_IS_USED_MULTITHREAD)
+    const hpatch_StreamPos_t _bestWorkCount=matchDatas.newStream->streamSize/kBestMTClipSize;
+    threadNum=(_bestWorkCount<=threadNum)?(int)_bestWorkCount:threadNum;
+    if (threadNum>1){
+        matchDatas.threadNum=threadNum;
+        TMt mt(matchDatas);
+        checkv(mt.start_threads(threadNum,_rollMatch_mt,&mt,true));
+        mt.wait_all_thread_end();
+        checkv(!mt.is_on_error());
+    }else
+#endif
+    {
+        _rollMatch(matchDatas,0,matchDatas.newStream->streamSize);
+    }
+    matchDatas.out_covers->collate_covers(matchDatas.out_covers);
+}
+
+
+void matchNewDataInOldSign(hpatch_TOutputCovers* out_covers,const hpatch_TStreamInput* newStream,
+                           const TOldDataSyncInfo* oldSyncInfo,int threadNum){
+    checkv(oldSyncInfo->strongChecksumPlugin!=0);
+    _TMatchSDatas matchDatas; memset(&matchDatas,0,sizeof(matchDatas));
+    matchDatas.out_covers=out_covers;
+    matchDatas.oldSyncInfo=oldSyncInfo;
+    matchDatas.newStream=newStream;
+    _matchNewDataInOldSign(matchDatas,threadNum);
+}
+
+} //namespace sync_private

package/harmony/pushy/src/main/cpp/HDiffPatch/libhsync/sign_diff/_match_in_old_sign.h

@@ -0,0 +1,39 @@
+//_match_in_old_sign.h
+//sign_diff
+//Created by housisong on 2025-04-16.
+/*
+ The MIT License (MIT)
+ Copyright (c) 2025 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 match_in_old_sign_h
+#define match_in_old_sign_h
+#include "_sign_diff_type.h"
+namespace sync_private{
+
+void matchNewDataInOldSign(hpatch_TOutputCovers* out_covers,const hpatch_TStreamInput* newStream,
+                           const TOldDataSyncInfo* oldSyncInfo,int threadNum);
+
+}//namespace sync_private
+#endif

package/harmony/pushy/src/main/cpp/HDiffPatch/libhsync/sign_diff/_sign_diff_type.h

@@ -0,0 +1,37 @@
+//_sign_diff_type.h
+//sign_diff
+//Created by housisong on 2025-04-11.
+/*
+ The MIT License (MIT)
+ Copyright (c) 2025 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 or substantial portions 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 hsign_diff_type_h
+#define hsign_diff_type_h
+#include "../../libHDiffPatch/HDiff/diff.h"
+#include "../sync_client/sync_client_type.h"
+
+typedef TNewDataSyncInfo TOldDataSyncInfo;
+
+#endif

package/harmony/pushy/src/main/cpp/HDiffPatch/libhsync/sign_diff/sign_diff.cpp

@@ -0,0 +1,62 @@
+//sign_diff.cpp
+//sign_diff
+//Created by housisong on 2025-04-15.
+/*
+ The MIT License (MIT)
+ Copyright (c) 2025 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 or substantial portions 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 "sign_diff.h"
+#include <stdexcept>
+#include "../../libHDiffPatch/HDiff/private_diff/limit_mem_diff/covers.h"
+#include "_match_in_old_sign.h"
+using namespace hdiff_private;
+using namespace sync_private;
+
+static void get_match_covers_by_sign(const hpatch_TStreamInput* newData,const TOldDataSyncInfo* oldSyncInfo,
+                                     TCoversBuf* out_covers,size_t threadNum){
+    assert(out_covers->push_cover!=0);
+    matchNewDataInOldSign(out_covers,newData,oldSyncInfo,(int)threadNum);
+}
+
+
+    void serialize_single_compressed_diff(const hpatch_TStreamInput* newStream,const hpatch_TStreamInput* oldStream,
+                                          bool isZeroSubDiff,const TCovers& covers,const hpatch_TStreamOutput* out_diff,
+                                          const hdiff_TCompress* compressPlugin,size_t patchStepMemSize);
+
+void create_hdiff_by_sign(const hpatch_TStreamInput* newData,const TOldDataSyncInfo* oldSyncInfo,
+                          const hpatch_TStreamOutput* out_diff,const hdiff_TCompress* compressPlugin,
+                          size_t patchStepMemSize,size_t threadNum){
+    if (oldSyncInfo->_decompressPlugin){
+        if (oldSyncInfo->isDirSyncInfo)
+            throw std::runtime_error("create_hdiff_by_sign() unsupport compressed old dir!");
+        else
+            printf("WARNING: This diff file format, requires uncompressed old file when patch!");
+    }
+    TCoversBuf covers(newData->streamSize,oldSyncInfo->newDataSize);
+    get_match_covers_by_sign(newData,oldSyncInfo,&covers,threadNum);
+    hpatch_TStreamInput oldData={0};
+    oldData.streamSize=oldSyncInfo->newDataSize;
+    serialize_single_compressed_diff(newData,&oldData,true,covers,
+                                     out_diff,compressPlugin,patchStepMemSize);
+}

package/harmony/pushy/src/main/cpp/HDiffPatch/libhsync/sign_diff/sign_diff.h

@@ -0,0 +1,44 @@
+//sign_diff.h
+//sign_diff
+//Created by housisong on 2025-04-11.
+/*
+ The MIT License (MIT)
+ Copyright (c) 2025 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 or substantial portions 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 hsign_diff_h
+#define hsign_diff_h
+#include "_sign_diff_type.h"
+
+//create a hdiff data by .hsyni:
+//  newData: new data stream
+//  oldSyncInfo: oldData's hsyni_file, is created by hsign_diff cmdline; oldData can't dir, can't compressed 
+//  out_diff: output diff stream for hpatchz, i.e newData=hpatchz(oldData,out_diff); or call patch_single_stream() or patch_single_compressed_diff()
+//  compressPlugin: for compress diff data, if null, not compress
+//  throw std::runtime_error when I/O error,etc.
+void create_hdiff_by_sign(const hpatch_TStreamInput* newData,const TOldDataSyncInfo* oldSyncInfo,
+                          const hpatch_TStreamOutput* out_diff,const hdiff_TCompress* compressPlugin=0,
+                          size_t patchStepMemSize=kDefaultPatchStepMemSize,size_t threadNum=1);
+
+#endif

package/harmony/pushy/src/main/cpp/HDiffPatch/libhsync/sync_client/dict_decompress_plugin.h

@@ -0,0 +1,156 @@
+//  dict_decompress_plugin.h
+//  sync_client
+//  Created by housisong on 2022-12-08.
+/*
+ The MIT License (MIT)
+ Copyright (c) 2020-2023 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 dict_decompress_plugin_h
+#define dict_decompress_plugin_h
+#include "../../libHDiffPatch/HPatch/patch_types.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+    
+    typedef void*  hsync_dictDecompressHandle;
+    
+    //dict decompress plugin
+    typedef struct hsync_TDictDecompress{
+        hpatch_BOOL                       (*is_can_open)(const char* compresseType);
+        hpatch_StreamPos_t          (*maxCompressedSize)(hpatch_StreamPos_t in_dataSize);
+        //error return 0.
+        hsync_dictDecompressHandle (*dictDecompressOpen)(struct hsync_TDictDecompress* decompressPlugin,size_t blockCount,size_t blockSize,
+                                                         const hpatch_byte* in_info,const hpatch_byte* in_infoEnd);
+        void                      (*dictDecompressClose)(struct hsync_TDictDecompress* decompressPlugin,
+                                                         hsync_dictDecompressHandle dictHandle);
+        //dictDecompress() must out (out_dataEnd-out_dataBegin), otherwise error return hpatch_FALSE
+        hpatch_BOOL                    (*dictDecompress)(hsync_dictDecompressHandle dictHandle,size_t blockIndex,
+                                                         const hpatch_byte* in_code,const hpatch_byte* in_codeEnd,
+                                                         hpatch_byte* out_dataBegin,hpatch_byte* out_dataEnd,hpatch_byte skipBitsInFirstCodeByte);
+        void                           (*dictUncompress)(hsync_dictDecompressHandle dictHandle,size_t blockIndex,size_t lastCompressedBlockIndex,
+                                                         const hpatch_byte* dataBegin,const hpatch_byte* dataEnd);
+        //needFillAlignCode can NULL, used for align lastByteHalfBits when need
+        size_t                       (*needFillAlignCode)(hpatch_byte* last_code,hpatch_byte lastByteHalfBits);  
+    } hsync_TDictDecompress;
+
+
+    typedef struct{
+        size_t          blockCount;
+        size_t          block_cache_i;
+        size_t          block_dec_i;
+        size_t          blockSize;
+        size_t          dictSize;
+        hpatch_byte*    uncompress;
+        hpatch_byte*    uncompressEnd;
+        hpatch_byte*    uncompressCur;
+    } _CacheBlockDict_t;
+
+    #define _kMinCacheBlockDictMemSize ((1<<10)*256)
+    #define _kMinCacheBlockDictSize_r  4    // dictSize/_kMinCacheBlockDictSize_r
+    //return 0 or >=dictSize
+    static size_t _getCacheBlockDictSizeUp(size_t dictSize,size_t kBlockCount,size_t kBlockSize,
+                                           const size_t bestMinDictMemSize){
+        size_t bestMem;
+        size_t blockCount;
+        if (kBlockCount<=1)
+            return 0; //not need cache
+        bestMem=dictSize+dictSize/_kMinCacheBlockDictSize_r;
+        if (bestMem<_kMinCacheBlockDictMemSize)
+            bestMem=_kMinCacheBlockDictMemSize;
+        blockCount=(bestMem+kBlockSize-1)/kBlockSize;
+        if (blockCount>=kBlockCount)
+            blockCount=kBlockCount-1;
+        return blockCount*kBlockSize;
+    }
+    
+    static size_t _getCacheBlockDictSize(size_t dictSize,size_t kBlockCount,size_t kBlockSize){
+        return _getCacheBlockDictSizeUp(dictSize,kBlockCount,kBlockSize,_kMinCacheBlockDictMemSize);
+    }
+
+    static 
+    void _CacheBlockDict_init(_CacheBlockDict_t* self,hpatch_byte* cacheDict,size_t cacheDictSize,
+                              size_t dictSize,size_t blockCount,size_t blockSize){
+        memset(self,0,sizeof(*self));
+        self->dictSize=dictSize;
+        self->blockCount=blockCount;
+        self->blockSize=blockSize;
+        if (cacheDictSize){
+            self->uncompress=cacheDict;
+            self->uncompressCur=self->uncompress;
+            self->uncompressEnd=self->uncompress+cacheDictSize;
+        }
+    }
+    static hpatch_inline 
+    hpatch_BOOL _CacheBlockDict_isHaveDict(const _CacheBlockDict_t* self){
+        return (self->uncompressCur>self->uncompress);
+    }
+    static hpatch_inline 
+    hpatch_BOOL _CacheBlockDict_isMustResetDict(const _CacheBlockDict_t* self,size_t blockIndex){
+        hpatch_BOOL result=_CacheBlockDict_isHaveDict(self)&&(blockIndex>self->block_dec_i);
+        assert(blockIndex>=self->block_dec_i);
+        if (result) assert(blockIndex==self->block_cache_i);
+        return result;
+    }
+    static hpatch_inline 
+    void _CacheBlockDict_usedDict(_CacheBlockDict_t* self,size_t blockIndex,
+                                  hpatch_byte** out_dict,size_t* out_dictSize){
+        size_t dsize=self->uncompressCur-self->uncompress;
+        if (dsize>self->dictSize) dsize=self->dictSize;
+        *out_dict=self->uncompressCur-dsize;
+        *out_dictSize=dsize;
+        self->block_dec_i=blockIndex+1;
+    }
+    static 
+    void _CacheBlockDict_dictUncompress(_CacheBlockDict_t* self,size_t blockIndex,size_t lastCompressedBlockIndex,
+                                        const hpatch_byte* dataBegin,const hpatch_byte* dataEnd){
+        size_t dataSize=dataEnd-dataBegin;
+        if (blockIndex!=self->block_cache_i)
+            self->uncompressCur=self->uncompress;
+        self->block_cache_i=blockIndex+1;
+        if (self->uncompress==0) return;
+        hpatch_StreamPos_t distance=(hpatch_StreamPos_t)self->blockSize * (size_t)(lastCompressedBlockIndex-blockIndex-1);
+        if (distance>=self->dictSize){
+            self->uncompressCur=self->uncompress;
+            return;
+        }
+
+        if (dataSize>(size_t)(self->uncompressEnd-self->uncompressCur)){
+            if (dataSize<self->dictSize){
+                size_t msize=self->dictSize-dataSize;
+                memmove(self->uncompress,self->uncompressCur-msize,msize);
+                self->uncompressCur=self->uncompress+msize;
+            }else{
+                dataBegin+=(dataSize-self->dictSize);
+                dataSize=dataEnd-dataBegin;
+                self->uncompressCur=self->uncompress;
+            }
+        }
+        memcpy(self->uncompressCur,dataBegin,dataSize);
+        self->uncompressCur+=dataSize;
+    }
+
+#ifdef __cplusplus
+}
+#endif
+#endif // dict_decompress_plugin_h