react-native-update 10.34.1 → 10.34.3

package/harmony/pushy/src/main/cpp/HDiffPatch/libHDiffPatch/HDiff/match_block.h

@@ -0,0 +1,222 @@
+// match_block.h
+// hdiff
+/*
+ The MIT License (MIT)
+ Copyright (c) 2021 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_match_block_h
+#define hdiff_match_block_h
+#include "diff.h"
+#include <vector>
+static const size_t kDefaultFastMatchBlockSize = 1024*1;
+namespace hdiff_private{
+    struct TAutoMem;
+    
+    struct TMatchBlockBase{
+        typedef hpatch_TCover TPackedCover;
+        TMatchBlockBase(size_t _matchBlockSize,size_t _threadNum)
+        :matchBlockSize(_matchBlockSize),threadNum(_threadNum){}
+    protected:
+        void _getPackedCover(hpatch_StreamPos_t newDataSize,hpatch_StreamPos_t oldDataSize);
+        void _unpackData(IDiffInsertCover* diffi,void*& pcovers,size_t& coverCount,bool isCover32);
+        const size_t   matchBlockSize;
+        const size_t   threadNum;
+        std::vector<hpatch_TCover> blockCovers;
+        std::vector<TPackedCover> packedCoversForOld;
+        std::vector<TPackedCover> packedCoversForNew;
+    };
+
+    //remove some big match block befor diff, in memory
+    struct TMatchBlockMem:public TMatchBlockBase{
+        unsigned char* newData;
+        unsigned char* newData_end;
+        unsigned char* newData_end_cur;
+        unsigned char* oldData;
+        unsigned char* oldData_end;
+        unsigned char* oldData_end_cur;
+        TMatchBlockMem(unsigned char* _newData,unsigned char* _newData_end,
+                       unsigned char* _oldData,unsigned char* _oldData_end,
+                       size_t _matchBlockSize,size_t _threadNumForMem)
+        :TMatchBlockBase(_matchBlockSize,_threadNumForMem),
+         newData(_newData),newData_end(_newData_end),newData_end_cur(_newData_end),
+         oldData(_oldData),oldData_end(_oldData_end),oldData_end_cur(_oldData_end){ }
+        inline hpatch_StreamPos_t curNewDataSize()const{ return (size_t)(newData_end_cur-newData); }
+        inline hpatch_StreamPos_t curOldDataSize()const{ return (size_t)(oldData_end_cur-oldData); }
+        void getBlockCovers();
+        inline void getPackedCover() { _getPackedCover(newData_end-newData,oldData_end-oldData); }
+        void packData();
+        void unpackData(IDiffInsertCover* diffi,void* pcovers,size_t coverCount,bool isCover32);
+    };
+
+    //remove some big match block befor diff, used stream
+    struct TMatchBlockStream:public TMatchBlockBase{
+        unsigned char* newData;
+        unsigned char* newData_end_cur;
+        unsigned char* oldData;
+        unsigned char* oldData_end_cur;
+        const hpatch_TStreamInput* newStream;
+        const hpatch_TStreamInput* oldStream;
+        const size_t    threadNumForStream;
+        TMatchBlockStream(const hpatch_TStreamInput* _newStream,const hpatch_TStreamInput* _oldStream,
+                          size_t _matchBlockSize,size_t _threadNumForMem,size_t _threadNumForStream);
+        ~TMatchBlockStream();
+        inline hpatch_StreamPos_t curNewDataSize()const{ return _isUnpacked?newStream->streamSize:(size_t)(newData_end_cur-newData); }
+        inline hpatch_StreamPos_t curOldDataSize()const{ return _isUnpacked?oldStream->streamSize:(size_t)(oldData_end_cur-oldData); }
+        void getBlockCovers();
+        inline void getPackedCover() { _getPackedCover(newStream->streamSize,oldStream->streamSize); }
+        void packData();
+        void unpackData(IDiffInsertCover* diffi,void* pcovers,size_t coverCount,bool isCover32);
+        void map_streams(const hpatch_TStreamInput** pnewData,const hpatch_TStreamInput** poldData);
+
+        struct TStreamInputMap:public hpatch_TStreamInput{
+            const hpatch_TStreamInput*  baseStream;
+            std::vector<TPackedCover>&  packedCovers;
+            size_t                      curCoverIndex;
+            const unsigned char*        data; //packed data
+            const unsigned char*        data_end;
+            inline TStreamInputMap(const hpatch_TStreamInput* _baseStream,std::vector<TPackedCover>& _packedCovers)
+                :baseStream(_baseStream),packedCovers(_packedCovers),curCoverIndex(0){}
+        };
+    protected:
+        TStreamInputMap _newStreamMap;
+        TStreamInputMap _oldStreamMap;
+        TAutoMem*       _packedNewOldMem;
+        bool            _isUnpacked;
+    };
+
+    template<class _TMatchBlock>
+    struct TCoversOptim:public ICoverLinesListener{
+        explicit TCoversOptim(_TMatchBlock* _matchBlock):matchBlock(_matchBlock){
+            ICoverLinesListener* listener=this;
+            memset(listener,0,sizeof(*listener));
+            insert_cover=_insert_cover;
+        }
+        _TMatchBlock* matchBlock;
+    protected:
+        static void _insert_cover(ICoverLinesListener* listener,IDiffInsertCover* diffi,void* pcovers,size_t coverCount,
+                                  bool isCover32,hpatch_StreamPos_t* newSize,hpatch_StreamPos_t* oldSize){
+            TCoversOptim<_TMatchBlock>* self=(TCoversOptim<_TMatchBlock>*)listener;
+            if (self->matchBlock!=0){
+                assert(self->matchBlock->curNewDataSize()==*newSize);
+                assert(self->matchBlock->curOldDataSize()==*oldSize);
+                self->matchBlock->unpackData(diffi,pcovers,coverCount,isCover32);
+                *newSize=self->matchBlock->curNewDataSize();
+                *oldSize=self->matchBlock->curOldDataSize();
+            }
+        }
+        inline void _doPack(){
+            matchBlock->getBlockCovers();
+            matchBlock->getPackedCover();
+            matchBlock->packData();
+        }
+    };
+
+    struct TCoversOptimMem:public TCoversOptim<TMatchBlockMem>{
+        TCoversOptimMem(unsigned char* newData,unsigned char* newData_end,
+                       unsigned char* oldData,unsigned char* oldData_end,
+                       size_t matchBlockSize,size_t threadNum)
+        :TCoversOptim<TMatchBlockMem>(&_matchBlock),
+         _matchBlock(newData,newData_end,oldData,oldData_end,matchBlockSize,threadNum){
+            _doPack();
+        }
+    protected:
+        TMatchBlockMem _matchBlock;
+    };
+
+    struct TCoversOptimStream:public TCoversOptim<TMatchBlockStream>{
+        TCoversOptimStream(const hpatch_TStreamInput* newStream,const hpatch_TStreamInput* oldStream,
+                       size_t matchBlockSize,size_t threadNumForMem,size_t threadNumForStream)
+        :TCoversOptim<TMatchBlockStream>(&_matchBlock),
+         _matchBlock(newStream,oldStream,matchBlockSize,threadNumForMem,threadNumForStream){
+            map_streams_befor_serialize=_map_streams_befor_serialize;//for ICoverLinesListener
+            _doPack();
+        }
+    protected:
+        TMatchBlockStream _matchBlock;
+        static void _map_streams_befor_serialize(ICoverLinesListener* listener,const hpatch_TStreamInput** pnewData,const hpatch_TStreamInput** poldData){
+            TCoversOptimStream* self=(TCoversOptimStream*)listener;
+            self->_matchBlock.map_streams(pnewData,poldData);
+        }
+    };
+    
+    void loadOldAndNewStream(TAutoMem& out_mem,const hpatch_TStreamInput* oldStream,const hpatch_TStreamInput* newStream);
+
+} //namespace hdiff_private
+
+
+//optimize diff speed by match block
+//note: newData&oldData in memory will be changed
+//see create_compressed_diff | create_single_compressed_diff
+
+void create_compressed_diff_block(const hpatch_TStreamInput* newData,//will load needed in memory
+                                  const hpatch_TStreamInput* oldData,//will load needed in memory
+                                  const hpatch_TStreamOutput* out_diff,
+                                  const hdiff_TCompress* compressPlugin=0,
+                                  int kMinSingleMatchScore=kMinSingleMatchScore_default,
+                                  bool isUseBigCacheMatch=false,
+                                  size_t matchBlockSize=kDefaultFastMatchBlockSize,
+                                  size_t threadNumForMem=1,size_t threadNumForStream=1);
+void create_compressed_diff_block(unsigned char* newData,unsigned char* newData_end,
+                                  unsigned char* oldData,unsigned char* oldData_end,
+                                  const hpatch_TStreamOutput* out_diff,
+                                  const hdiff_TCompress* compressPlugin=0,
+                                  int kMinSingleMatchScore=kMinSingleMatchScore_default,
+                                  bool isUseBigCacheMatch=false,
+                                  size_t matchBlockSize=kDefaultFastMatchBlockSize,
+                                  size_t threadNum=1);
+void create_compressed_diff_block(unsigned char* newData,unsigned char* newData_end,
+                                  unsigned char* oldData,unsigned char* oldData_end,
+                                  std::vector<unsigned char>& out_diff,
+                                  const hdiff_TCompress* compressPlugin=0,
+                                  int kMinSingleMatchScore=kMinSingleMatchScore_default,
+                                  bool isUseBigCacheMatch=false,
+                                  size_t matchBlockSize=kDefaultFastMatchBlockSize,
+                                  size_t threadNum=1);
+
+void create_single_compressed_diff_block(const hpatch_TStreamInput* newData,//will load needed in memory
+                                         const hpatch_TStreamInput* oldData,//will load needed in memory
+                                         const hpatch_TStreamOutput* out_diff,const hdiff_TCompress* compressPlugin=0,
+                                         int kMinSingleMatchScore=kMinSingleMatchScore_default,
+                                         size_t patchStepMemSize=kDefaultPatchStepMemSize,
+                                         bool isUseBigCacheMatch=false,
+                                         size_t matchBlockSize=kDefaultFastMatchBlockSize,
+                                         size_t threadNumForMem=1,size_t threadNumForStream=1);
+void create_single_compressed_diff_block(unsigned char* newData,unsigned char* newData_end,
+                                         unsigned char* oldData,unsigned char* oldData_end,
+                                         const hpatch_TStreamOutput* out_diff,const hdiff_TCompress* compressPlugin=0,
+                                         int kMinSingleMatchScore=kMinSingleMatchScore_default,
+                                         size_t patchStepMemSize=kDefaultPatchStepMemSize,
+                                         bool isUseBigCacheMatch=false,
+                                         size_t matchBlockSize=kDefaultFastMatchBlockSize,
+                                         size_t threadNum=1);
+void create_single_compressed_diff_block(unsigned char* newData,unsigned char* newData_end,
+                                         unsigned char* oldData,unsigned char* oldData_end,
+                                         std::vector<unsigned char>& out_diff,const hdiff_TCompress* compressPlugin=0,
+                                         int kMinSingleMatchScore=kMinSingleMatchScore_default,
+                                         size_t patchStepMemSize=kDefaultPatchStepMemSize,
+                                         bool isUseBigCacheMatch=false,
+                                         size_t matchBlockSize=kDefaultFastMatchBlockSize,
+                                         size_t threadNum=1);
+
+#endif //hdiff_match_block_h

package/harmony/pushy/src/main/cpp/HDiffPatch/libHDiffPatch/HDiff/private_diff/bytes_rle.cpp

@@ -0,0 +1,383 @@
+//bytes_rle.cpp
+//
+/*
+ The MIT License (MIT)
+ Copyright (c) 2012-2021 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 "bytes_rle.h"
+#include <assert.h>
+#include "pack_uint.h"
+#include "../../HPatch/patch_private.h"
+namespace hdiff_private{
+
+namespace {
+    const size_t kStepSize=1024*16;
+    
+    typedef unsigned char TByte;
+    typedef hpatch_StreamPos_t TUInt;
+
+    static void rle_pushSame(std::vector<TByte>& out_ctrl,std::vector<TByte>& out_code,
+                             TByte cur,TUInt count){
+        assert(count>0);
+        while (count>kMaxBytesRleLen){
+            rle_pushSame(out_ctrl,out_code,cur,kMaxBytesRleLen);
+            count-=kMaxBytesRleLen;
+        }
+        enum TByteRleType type;
+        if (cur==0)
+            type=kByteRleType_rle0;
+        else if (cur==255)
+            type=kByteRleType_rle255;
+        else
+            type=kByteRleType_rle;
+        const TUInt packCount=(TUInt)(count-1);
+        packUIntWithTag(out_ctrl,packCount,type,kByteRleType_bit);
+        if (type==kByteRleType_rle)
+            out_code.push_back(cur);
+    }
+
+    static inline void rle_pushNotSameCtrl(std::vector<TByte>& out_ctrl,TUInt count){
+        packUIntWithTag(out_ctrl,(TUInt)(count-1),kByteRleType_unrle,kByteRleType_bit);
+    }
+
+    struct TStreamRLE{
+        std::vector<unsigned char>&  ctrlBuf;
+        std::vector<unsigned char>&  codeBuf;
+        TByte       sameCur;
+        size_t      sameCount;
+        size_t      notSameCount;
+        const size_t kRleMinSameSize;
+        inline explicit TStreamRLE(std::vector<unsigned char>& _ctrlBuf,
+                                   std::vector<unsigned char>& _codeBuf,int rle_parameter)
+        :ctrlBuf(_ctrlBuf),codeBuf(_codeBuf),sameCur(0),
+        sameCount(0),notSameCount(0),kRleMinSameSize(rle_parameter+1){
+            assert((rle_parameter>=kRle_bestSize)&&(rle_parameter<=kRle_bestUnRleSpeed)); }
+        void append(const unsigned char* appendData,const unsigned char* appendData_end){
+            if (sameCount==0){
+                if (appendData!=appendData_end){
+                    sameCur=*appendData++;
+                    sameCount=1;
+                }else{
+                    return;
+                }
+            }
+            while (appendData!=appendData_end){
+                TByte cur=*appendData++;
+                if (cur==sameCur){
+                    ++sameCount;
+                }else{
+                    endSame();
+                    sameCur=cur;
+                    sameCount=1;
+                }
+            }
+        }
+        inline void endSame(){
+            size_t sign=((size_t)(253-(size_t)(TByte)(sameCur-1))) >> (sizeof(size_t)*8-1);
+            if (sameCount+sign>kRleMinSameSize){//can rle
+                endNoSame();
+                rle_pushSame(ctrlBuf,codeBuf,sameCur,sameCount);
+                sameCount=0;
+            }else{
+                notSameCount+=sameCount;
+                while (sameCount--)
+                    codeBuf.push_back(sameCur);
+            }
+        }
+        inline void endNoSame(){
+            if (notSameCount>1){
+                rle_pushNotSameCtrl(ctrlBuf,notSameCount);
+                notSameCount=0;
+            }else if (notSameCount==1){
+                notSameCount=0;
+                TByte cur=codeBuf.back();
+                codeBuf.pop_back();
+                rle_pushSame(ctrlBuf,codeBuf,cur,1);
+            }
+        }
+        inline void finishAppend(){
+            endSame();
+            endNoSame();
+        }
+    };
+    
+}//end namespace
+    
+void bytesRLE_save(std::vector<TByte>& out_ctrlBuf,std::vector<TByte>& out_codeBuf,
+                    const TByte* src,const TByte* src_end,int rle_parameter){
+    TStreamRLE rle(out_ctrlBuf,out_codeBuf,rle_parameter);
+    rle.append(src,src_end);
+    rle.finishAppend();
+}
+
+void bytesRLE_save(std::vector<unsigned char>& out_ctrlBuf,std::vector<unsigned char>& out_codeBuf,
+                   const hpatch_TStreamInput* src,int rle_parameter){
+    TStreamRLE rle(out_ctrlBuf,out_codeBuf,rle_parameter);
+    TByte buf[kStepSize];
+    hpatch_StreamPos_t readPos=0;
+    while (readPos<src->streamSize){
+        size_t len=kStepSize;
+        if (len+readPos>src->streamSize)
+            len=(size_t)(src->streamSize-readPos);
+        if (!src->read(src,readPos,buf,buf+len))
+            throw std::runtime_error("bytesRLE_save() src->read()");
+        rle.append(buf,buf+len);
+        readPos+=len;
+    }
+    rle.finishAppend();
+}
+
+void bytesRLE_save(std::vector<TByte>& out_code,
+                   const TByte* src,const TByte* src_end,int rle_parameter){
+    std::vector<TByte> ctrlBuf;
+    std::vector<TByte> codeBuf;
+
+    bytesRLE_save(ctrlBuf,codeBuf,src,src_end,rle_parameter);
+    packUInt(out_code,(TUInt)ctrlBuf.size());
+    pushBack(out_code,ctrlBuf);
+    pushBack(out_code,codeBuf);
+}
+
+void bytesRLE_save(std::vector<TByte>& out_code,const hpatch_TStreamInput* src,int rle_parameter){
+    std::vector<TByte> ctrlBuf;
+    std::vector<TByte> codeBuf;
+
+    bytesRLE_save(ctrlBuf,codeBuf,src,rle_parameter);
+    packUInt(out_code,(TUInt)ctrlBuf.size());
+    pushBack(out_code,ctrlBuf);
+    pushBack(out_code,codeBuf);
+}
+
+    
+    enum TLastType{
+        lastType_same,
+        lastType_v,
+    };
+    
+    inline TLastType getLastType(const TSingleStreamRLE0& self){
+        if (self.uncompressData.empty()){
+            return lastType_same;
+        }else{
+            assert(self.len0==0);
+            return lastType_v;
+        }
+    }
+    
+    inline void _out_uncompressData(TSingleStreamRLE0& self){
+        size_t saved=0;
+        while (self.uncompressData.size()-saved>kMaxBytesRleLen){
+            packUInt(self.fixed_code, kMaxBytesRleLen);
+            pushBack(self.fixed_code, self.uncompressData.data()+saved,self.uncompressData.data()+saved+kMaxBytesRleLen);
+            packUInt(self.fixed_code,0);
+            saved+=kMaxBytesRleLen;
+        }
+        packUInt(self.fixed_code, self.uncompressData.size()-saved);
+        pushBack(self.fixed_code, self.uncompressData.data()+saved,self.uncompressData.data()+self.uncompressData.size());
+        self.uncompressData.clear();
+    }
+    inline hpatch_StreamPos_t _out_uncompressData_codeSize(hpatch_StreamPos_t dataSize){
+        hpatch_StreamPos_t codeSize=0;
+        hpatch_StreamPos_t saved=0;
+        while (dataSize-saved>kMaxBytesRleLen){
+            codeSize+=hpatch_packUInt_size(kMaxBytesRleLen);
+            codeSize+=kMaxBytesRleLen;
+            codeSize+=hpatch_packUInt_size(0);
+            saved+=kMaxBytesRleLen;
+        }
+        codeSize+=hpatch_packUInt_size(dataSize-saved);
+        codeSize+=(hpatch_StreamPos_t)(dataSize-saved);
+        return codeSize;
+    }
+
+    inline void _out_0Data(TSingleStreamRLE0& self){
+        hpatch_StreamPos_t saved=0;
+        while (self.len0-saved>kMaxBytesRleLen){
+            packUInt(self.fixed_code,kMaxBytesRleLen);
+            packUInt(self.fixed_code,0);
+            saved+=kMaxBytesRleLen;
+        }
+        packUInt(self.fixed_code,(hpatch_StreamPos_t)(self.len0-saved));
+        self.len0=0;
+    }
+    inline hpatch_StreamPos_t _out_0Data_codeSize(hpatch_StreamPos_t len0){
+        hpatch_StreamPos_t codeSize=0;
+        hpatch_StreamPos_t saved=0;
+        while (len0-saved>kMaxBytesRleLen){
+            codeSize+=hpatch_packUInt_size(kMaxBytesRleLen);
+            codeSize+=hpatch_packUInt_size(0);
+            saved+=kMaxBytesRleLen;
+        }
+        codeSize+=hpatch_packUInt_size((hpatch_StreamPos_t)(len0-saved));
+        return codeSize;
+    }
+
+
+    static void _maxCodeSize(TLastType& lastType,hpatch_StreamPos_t& curLen0,hpatch_StreamPos_t& curLenv,
+                             hpatch_StreamPos_t& fixedLen,const unsigned char* appendData,const unsigned char* appendData_end){
+        while (appendData!=appendData_end) {
+            unsigned char v;
+            size_t sLen0=0;
+            do {
+                v=*appendData++;
+                if (0==v)
+                    ++sLen0;
+                else
+                    break;
+            }while (appendData!=appendData_end);
+            if (sLen0>0){
+                if (lastType==lastType_v){
+                    fixedLen += _out_uncompressData_codeSize(curLenv);
+                    curLenv = 0;
+                }
+                curLen0+=sLen0;
+                lastType=lastType_same;
+                if (v==0)
+                    break;//appendData==appendData_end
+            }
+            if (lastType==lastType_same){
+                fixedLen += _out_0Data_codeSize(curLen0);
+                curLen0 = 0;
+            }
+            ++curLenv;
+            lastType=lastType_v;
+        }
+    }
+    static void _maxCodeSize_end(TLastType& lastType,hpatch_StreamPos_t& curLen0,
+                                 hpatch_StreamPos_t& curLenv,hpatch_StreamPos_t& fixedLen){
+        if (curLenv>0){
+            fixedLen += _out_uncompressData_codeSize(curLenv);
+            curLenv=0;
+        }
+        if (curLen0>0){
+            fixedLen += _out_0Data_codeSize(curLen0);
+            curLen0=0;
+        }
+    }
+    
+    hpatch_StreamPos_t TSingleStreamRLE0::maxCodeSize(const unsigned char* appendData,const unsigned char* appendData_end) const{
+        TLastType lastType=getLastType(*this);
+        hpatch_StreamPos_t curLen0=this->len0;
+        hpatch_StreamPos_t curLenv=this->uncompressData.size();
+        hpatch_StreamPos_t fixedLen=this->fixed_code.size();
+        _maxCodeSize(lastType,curLen0,curLenv,fixedLen,appendData,appendData_end);
+        _maxCodeSize_end(lastType,curLen0,curLenv,fixedLen);
+        return fixedLen;
+    }
+    
+    hpatch_StreamPos_t TSingleStreamRLE0::maxCodeSizeByZeroLen(hpatch_StreamPos_t appendZeroLen) const{
+        hpatch_StreamPos_t fixedLen=this->fixed_code.size();
+        if (appendZeroLen==0) return fixedLen;
+        TLastType lastType=getLastType(*this);
+        hpatch_StreamPos_t curLen0=this->len0;
+        hpatch_StreamPos_t curLenv=this->uncompressData.size();
+        curLen0+=appendZeroLen;
+        if (lastType==lastType_v){
+            fixedLen += _out_uncompressData_codeSize(curLenv);
+            curLenv = 0;
+        }
+        lastType=lastType_same;
+        _maxCodeSize_end(lastType,curLen0,curLenv,fixedLen);
+        return fixedLen;
+    }
+
+    hpatch_StreamPos_t TSingleStreamRLE0::maxCodeSize(const hpatch_TStreamInput* appendData) const{
+        TLastType lastType=getLastType(*this);
+        hpatch_StreamPos_t curLen0=this->len0;
+        hpatch_StreamPos_t curLenv=this->uncompressData.size();
+        hpatch_StreamPos_t fixedLen=this->fixed_code.size();
+        
+        TByte buf[kStepSize];
+        hpatch_StreamPos_t readPos=0;
+        while (readPos<appendData->streamSize){
+            size_t len=kStepSize;
+            if (len+readPos>appendData->streamSize)
+                len=(size_t)(appendData->streamSize-readPos);
+            if (!appendData->read(appendData,readPos,buf,buf+len))
+                throw std::runtime_error("TSingleStreamRLE0::maxCodeSize() appendData->read()");
+            _maxCodeSize(lastType,curLen0,curLenv,fixedLen,buf,buf+len);
+            readPos+=len;
+        }
+        _maxCodeSize_end(lastType,curLen0,curLenv,fixedLen);
+        return fixedLen;
+    }
+    
+    
+    void TSingleStreamRLE0::appendByZeroLen(hpatch_StreamPos_t appendZeroLen){
+        if (appendZeroLen){
+            TLastType lastType=getLastType(*this);
+            if (lastType==lastType_v)
+                _out_uncompressData(*this);
+            len0+=appendZeroLen;
+        }
+    }
+
+    void TSingleStreamRLE0::append(const unsigned char* appendData,const unsigned char* appendData_end){
+        TLastType lastType=getLastType(*this);
+        while (appendData!=appendData_end) {
+            unsigned char v;
+            size_t sLen0=0;
+            do {
+                v=*appendData++;
+                if (0==v)
+                    ++sLen0;
+                else
+                    break;
+            }while (appendData!=appendData_end);
+            if (sLen0>0){
+                if (lastType==lastType_v)
+                    _out_uncompressData(*this);
+                len0+=sLen0;
+                lastType=lastType_same;
+                if (v==0)
+                    break;//appendData==appendData_end
+            }
+            if (lastType==lastType_same)
+                _out_0Data(*this);
+            uncompressData.push_back(v);
+            lastType=lastType_v;
+        }
+    }
+    
+    void TSingleStreamRLE0::append(const hpatch_TStreamInput* appendData){
+        TByte buf[kStepSize];
+        hpatch_StreamPos_t readPos=0;
+        while (readPos<appendData->streamSize){
+            size_t len=kStepSize;
+            if (len+readPos>appendData->streamSize)
+                len=(size_t)(appendData->streamSize-readPos);
+            if (!appendData->read(appendData,readPos,buf,buf+len))
+                throw std::runtime_error("TSingleStreamRLE0::append() appendData->read()");
+            append(buf,buf+len);
+            readPos+=len;
+        }
+    }
+    
+    void TSingleStreamRLE0::finishAppend(){
+        if ((fixed_code.empty())||(len0>0))
+            _out_0Data(*this);
+        if (!uncompressData.empty())
+            _out_uncompressData(*this);
+    }
+}//namespace hdiff_private

package/harmony/pushy/src/main/cpp/HDiffPatch/libHDiffPatch/HDiff/private_diff/bytes_rle.h

@@ -0,0 +1,73 @@
+//bytes_rle.h
+//a general-purpose byte stream compression RLE algorithm optimized for fast decompression.
+//
+/*
+ The MIT License (MIT)
+ Copyright (c) 2012-2021 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 __BYTES_RLE_H_
+#define __BYTES_RLE_H_
+#include <string.h>
+#include <vector>
+#include "../../HPatch/patch_types.h" //hpatch_TStreamInput
+namespace hdiff_private{
+
+#ifndef kMaxBytesRleLen
+    static const size_t kMaxBytesRleLen =(size_t)(((size_t)1<<31)-1);
+#endif
+
+enum TRleParameter{ kRle_bestSize=1, kRle_default=3, kRle_bestUnRleSpeed=32 };
+
+void bytesRLE_save(std::vector<unsigned char>& out_code,
+                   const unsigned char* src,const unsigned char* src_end,
+                   int rle_parameter=kRle_default);
+void bytesRLE_save(std::vector<unsigned char>& out_code,
+                   const hpatch_TStreamInput* src,//sequential read
+                   int rle_parameter=kRle_default);
+
+void bytesRLE_save(std::vector<unsigned char>& out_ctrlBuf,std::vector<unsigned char>& out_codeBuf,
+                   const unsigned char* src,const unsigned char* src_end,int rle_parameter);
+void bytesRLE_save(std::vector<unsigned char>& out_ctrlBuf,std::vector<unsigned char>& out_codeBuf,
+                   const hpatch_TStreamInput* src,//sequential read
+                   int rle_parameter);
+    
+    struct TSingleStreamRLE0{
+        std::vector<unsigned char>  fixed_code;
+        std::vector<unsigned char>  uncompressData;
+        hpatch_StreamPos_t          len0;
+        inline TSingleStreamRLE0():len0(0){}
+        inline hpatch_StreamPos_t curCodeSize() const { return maxCodeSize(0,0); }
+        hpatch_StreamPos_t maxCodeSize(const unsigned char* appendData,const unsigned char* appendData_end) const;
+        hpatch_StreamPos_t maxCodeSize(const hpatch_TStreamInput* appendData) const;//sequential read
+        hpatch_StreamPos_t maxCodeSizeByZeroLen(hpatch_StreamPos_t appendZeroLen) const;
+        void append(const unsigned char* appendData,const unsigned char* appendData_end);
+        void append(const hpatch_TStreamInput* appendData);//sequential read
+        void appendByZeroLen(hpatch_StreamPos_t appendZeroLen);
+        void finishAppend();
+        inline void clear() { fixed_code.clear(); uncompressData.clear(); len0=0; }
+    };
+    
+}//namespace hdiff_private
+#endif //__BYTES_RLE_H_