react-native-update 10.34.3 → 10.34.4

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

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

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

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

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

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

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