react-native-update 10.34.1 → 10.34.3

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

@@ -0,0 +1,299 @@
+//stream_serialize.h
+//
+/*
+ The MIT License (MIT)
+ Copyright (c) 2012-2017 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 stream_serialize_h
+#define stream_serialize_h
+#include "covers.h"
+#include "../pack_uint.h" //for packUInt_fixSize
+#include "../mem_buf.h"
+#include "../bytes_rle.h"
+
+struct hdiff_TCompress;
+namespace hdiff_private{
+
+struct TCoversStream:public hpatch_TStreamInput{
+    TCoversStream(const TCovers& _covers,hpatch_StreamPos_t cover_buf_size);
+    ~TCoversStream();
+    static hpatch_StreamPos_t getDataSize(const TCovers& covers);
+private:
+    const TCovers&              covers;
+    TAutoMem                    _code_mem;
+    size_t                      curCodePos;
+    size_t                      curCodePos_end;
+    size_t                      readedCoverCount;
+    hpatch_StreamPos_t          lastOldEnd;
+    hpatch_StreamPos_t          lastNewEnd;
+    hpatch_StreamPos_t          _readFromPos_back;
+    enum { kCodeBufSize = hdiff_kFileIOBufBestSize };
+    
+    static hpatch_BOOL _read(const hpatch_TStreamInput* stream,hpatch_StreamPos_t readFromPos,
+                             unsigned char* out_data,unsigned char* out_data_end);
+};
+
+
+struct TNewDataSubDiffStream:public hpatch_TStreamInput{
+    TNewDataSubDiffStream(const hdiff_TStreamInput* _newData,const hdiff_TStreamInput* _oldData,
+                          const TCovers& _covers,bool _isOnlySubCover=false,bool _isZeroSubDiff=false);
+    inline ~TNewDataSubDiffStream(){ assert(curReadPos==streamSize); }
+private:
+    hpatch_StreamPos_t curReadNewPos;
+    hpatch_StreamPos_t curReadOldPos;
+    hpatch_StreamPos_t curReadPos;
+    hpatch_StreamPos_t curDataLen;
+    size_t nextCoveri;
+    const hdiff_TStreamInput* newData;
+    const hdiff_TStreamInput* oldData;
+    const TCovers& covers;
+    const bool isOnlySubCover;
+    const bool isZeroSubDiff;
+    TAutoMem _cache;
+    void initRead();
+    void readTo(unsigned char* out_data,unsigned char* out_data_end);
+    static hpatch_BOOL _read(const struct hpatch_TStreamInput* stream,hpatch_StreamPos_t readFromPos,
+                             unsigned char* out_data,unsigned char* out_data_end);
+};
+
+struct TNewDataSubDiffStream_mem:public TNewDataSubDiffStream{
+    TNewDataSubDiffStream_mem(const unsigned char* newData,const unsigned char* newData_end,
+                              const unsigned char* oldData,const unsigned char* oldData_end,
+                              const TCovers& _covers,bool _isOnlySubCover=false,bool _isZeroSubDiff=false);
+private:
+    hdiff_TStreamInput mem_newData;
+    hdiff_TStreamInput mem_oldData;
+};
+
+struct TNewDataDiffStream:public hpatch_TStreamInput{
+    inline TNewDataDiffStream(const TCovers& _covers,const hpatch_TStreamInput* _newData,
+                              hpatch_StreamPos_t newDataDiff_size)
+            :covers(_covers),newData(_newData) { _init(newDataDiff_size); }
+    inline TNewDataDiffStream(const TCovers& _covers,const hpatch_TStreamInput* _newData)
+        :covers(_covers),newData(_newData) { _init(getDataSize(_covers,_newData->streamSize)); }
+    inline TNewDataDiffStream(const TCovers& _covers,const hpatch_TStreamInput* _newData,
+                              size_t coveri,hpatch_StreamPos_t newDataPos,hpatch_StreamPos_t newDataPosEnd)
+        :covers(_covers),newData(_newData){ _initByRange(coveri,newDataPos,newDataPosEnd); }
+    static hpatch_StreamPos_t getDataSize(const TCovers& covers,hpatch_StreamPos_t newDataSize);
+private:
+    static hpatch_StreamPos_t getDataSizeByRange(const TCovers& covers,size_t coveri,
+                                                 hpatch_StreamPos_t newDataPos,hpatch_StreamPos_t newDataPosEnd);
+    void _init(hpatch_StreamPos_t newDataDiff_size);
+    void _initByRange(size_t coveri,hpatch_StreamPos_t newDataPos,hpatch_StreamPos_t newDataPosEnd);
+    const TCovers&              covers;
+    const hpatch_TStreamInput*  newData;
+    hpatch_StreamPos_t          curNewPos;
+    hpatch_StreamPos_t          curNewPos_end;
+    hpatch_StreamPos_t          lastNewEnd;
+    size_t                      readedCoverCount;
+    hpatch_StreamPos_t          _readFromPos_back;
+
+    //by range
+    size_t                      _coveri;
+    hpatch_StreamPos_t          _newDataPos;
+
+    static hpatch_BOOL _read(const hpatch_TStreamInput* stream,hpatch_StreamPos_t readFromPos,
+                             unsigned char* out_data,unsigned char* out_data_end);
+};
+
+struct TNewDataSubDiffCoverStream:public hpatch_TStreamInput{
+    TNewDataSubDiffCoverStream(const hpatch_TStreamInput* _newStream,
+                               const hpatch_TStreamInput* _oldStream,bool _isZeroSubDiff);
+    void resetCover(const TCover& _cover);
+    void resetCoverLen(hpatch_StreamPos_t coverLen);
+    const bool isZeroSubDiff;
+private:
+    hpatch_StreamPos_t inStreamLen;
+    size_t curDataLen;
+    const hpatch_TStreamInput* newStream;
+    const hpatch_TStreamInput* oldStream;
+    TCover cover;
+    unsigned char* newData;
+    unsigned char* oldData;
+    TAutoMem _cache;
+    void initRead();
+    hpatch_BOOL _updateCache(hpatch_StreamPos_t readFromPos);
+    hpatch_BOOL readTo(hpatch_StreamPos_t readFromPos,unsigned char* out_data,unsigned char* out_data_end);
+    static hpatch_BOOL _read(const hpatch_TStreamInput* stream,hpatch_StreamPos_t readFromPos,
+                             unsigned char* out_data,unsigned char* out_data_end);
+};
+
+class TStreamClip:public hpatch_TStreamInput{
+public:
+    inline explicit TStreamClip():_decompressHandle(0){ clear(); }
+    inline TStreamClip(const hpatch_TStreamInput* stream,
+                         hpatch_StreamPos_t clipBeginPos,hpatch_StreamPos_t clipEndPos,
+                         hpatch_TDecompress* decompressPlugin=0,hpatch_StreamPos_t uncompressSize=0)
+                         :_decompressHandle(0){ reset(stream,clipBeginPos,clipEndPos,decompressPlugin,uncompressSize); }
+    void reset(const hpatch_TStreamInput* stream,
+               hpatch_StreamPos_t clipBeginPos,hpatch_StreamPos_t clipEndPos,
+               hpatch_TDecompress* decompressPlugin=0,hpatch_StreamPos_t uncompressSize=0);
+    inline ~TStreamClip() { clear(); }
+    inline void clear() { closeDecompressHandle(); streamSize=0; }
+private:
+    const hpatch_TStreamInput*  _src;
+    hpatch_StreamPos_t          _src_begin;
+    hpatch_StreamPos_t          _src_end;
+    hpatch_TDecompress*         _decompressPlugin;
+    hpatch_decompressHandle     _decompressHandle;
+    hpatch_StreamPos_t          _read_uncompress_pos;
+    void closeDecompressHandle();
+    void openDecompressHandle();
+    static hpatch_BOOL _clip_read(const hpatch_TStreamInput* stream,hpatch_StreamPos_t readFromPos,
+                                  unsigned char* out_data,unsigned char* out_data_end);
+};
+
+struct TStepStream:public hpatch_TStreamInput{
+    TStepStream(const hpatch_TStreamInput* newStream,const hpatch_TStreamInput* oldStream,
+                bool isZeroSubDiff,const TCovers& covers,size_t patchStepMemSize);
+    inline size_t getCoverCount()const{ return endCoverCount; }
+    inline size_t getMaxStepMemSize()const{ return endMaxStepMemSize; }
+private:
+    TNewDataSubDiffCoverStream  subDiff;
+    TNewDataDiffStream          newDataDiff;
+    const TCovers&  covers;
+    const size_t    patchStepMemSize;
+    const hpatch_StreamPos_t newDataSize;
+    size_t  curCoverCount;
+    size_t  endCoverCount;
+    size_t  curMaxStepMemSize;
+    size_t  endMaxStepMemSize;
+    hpatch_StreamPos_t lastOldEnd;
+    hpatch_StreamPos_t lastNewEnd;
+    std::vector<unsigned char> step_bufCover;
+    TSingleStreamRLE0  step_bufRle;
+    hpatch_StreamPos_t step_dataDiffSize;
+    hpatch_StreamPos_t newDataDiffReadPos;
+    bool    isHaveLastCover;
+    bool    isHaveLeftCover;
+    bool    isHaveRightCover;
+    TCover  lastCover;
+    TCover  leftCover;
+    TCover  rightCover;
+    size_t  cur_i;
+    TCover  cover;
+    const TCover* pCurCover;
+    bool    isInInit;
+    hpatch_StreamPos_t  sumBufSize_forInit;
+    size_t              step_bufCover_size;
+    std::vector<unsigned char> step_buf;
+    TStreamClip                step_dataDiff;
+    hpatch_StreamPos_t readFromPosBack;
+    hpatch_StreamPos_t         readBufPos;
+    void initStream();
+    void beginStep();
+    bool doStep();
+    void _last_flush_step();
+    void _flush_step_code();
+    hpatch_BOOL readTo(unsigned char* out_data,unsigned char* out_data_end);
+    static hpatch_BOOL _read(const hpatch_TStreamInput* stream,hpatch_StreamPos_t readFromPos,
+                             unsigned char* out_data,unsigned char* out_data_end);
+};
+
+
+struct TDiffStream{
+    explicit TDiffStream(const hpatch_TStreamOutput* _out_diff,
+                         hpatch_StreamPos_t out_diff_curPos=0);
+    ~TDiffStream();
+    
+    void pushBack(const unsigned char* src,size_t n);
+    size_t packUInt(hpatch_StreamPos_t uValue);
+    inline TPlaceholder packUInt_pos(hpatch_StreamPos_t uValue){
+        hpatch_StreamPos_t pos=writePos;
+        packUInt(uValue);
+        return TPlaceholder(pos,writePos);
+    }
+    void packUInt_update(const TPlaceholder& pos,hpatch_StreamPos_t uValue);
+    
+    hpatch_StreamPos_t pushStream(const hpatch_TStreamInput* stream,
+                                  const hdiff_TCompress*     compressPlugin,
+                                  const TPlaceholder&        update_compress_sizePos,
+                                  bool isMustCompress=false,const hpatch_StreamPos_t cancelSizeOnCancelCompress=0);
+    hpatch_StreamPos_t pushStream(const hpatch_TStreamInput* stream,
+                                  const hdiff_TCompress*     compressPlugin,
+                                  bool isMustCompress=false,const hpatch_StreamPos_t cancelSizeOnCancelCompress=0){
+                TPlaceholder nullPos(0,0); return pushStream(stream,compressPlugin,nullPos,
+                                                             isMustCompress,cancelSizeOnCancelCompress); }
+    hpatch_StreamPos_t pushStream(const hpatch_TStreamInput* stream){
+                _pushStream(stream); return stream->streamSize; }
+    hpatch_StreamPos_t getWritedPos()const{ return writePos; }
+    void stream_read(const TPlaceholder& pos,hpatch_byte* out_data);
+    inline TPlaceholder pushBack_pos(const hpatch_byte* src,size_t n){
+        hpatch_StreamPos_t pos=writePos;
+        pushBack(src,n);
+        return TPlaceholder(pos,writePos);
+    }
+    void stream_update(const TPlaceholder& pos,const hpatch_byte* in_data);
+private:
+    const hpatch_TStreamOutput*  out_diff;
+    hpatch_StreamPos_t     writePos;
+    enum{ kBufSize=hdiff_kFileIOBufBestSize };
+    TAutoMem               _temp_mem;
+    
+    void _packUInt_limit(hpatch_StreamPos_t uValue,size_t limitOutSize);
+    
+    //stream->read can return currently readed data size,return <0 error
+    void _pushStream(const hpatch_TStreamInput* stream);
+};
+
+struct TVectorAsStreamOutput:public hpatch_TStreamOutput{
+    explicit TVectorAsStreamOutput(std::vector<unsigned char>& _dst);
+    std::vector<unsigned char>& dst;
+};
+struct TVectorAsStreamInput:public hpatch_TStreamInput{
+    explicit TVectorAsStreamInput(const std::vector<unsigned char>& _src)
+    :src(_src){ mem_as_hStreamInput(this,src.data(),src.data()+src.size()); }
+    const std::vector<unsigned char>& src;
+};
+
+
+
+#define _test_rt(value) { if (!(value)) { LOG_ERR("check "#value" error!\n");  return hpatch_FALSE; } }
+
+struct _TCheckOutNewDataStream:public hpatch_TStreamOutput{
+    _TCheckOutNewDataStream(const hpatch_TStreamInput* _newData,unsigned char* _buf,size_t _bufSize);
+    bool isWriteFinish()const{ return writedLen==newData->streamSize; }
+private:
+    const hpatch_TStreamInput*  newData;
+    hpatch_StreamPos_t          writedLen;
+    unsigned char*              buf;
+    size_t                      bufSize;
+    static hpatch_BOOL _read_writed(const struct hpatch_TStreamOutput* stream,hpatch_StreamPos_t readFromPos,
+                                    unsigned char* out_data,unsigned char* out_data_end);
+    static hpatch_BOOL _write_check(const hpatch_TStreamOutput* stream,hpatch_StreamPos_t writeToPos,
+                                    const unsigned char* data,const unsigned char* data_end);
+};
+
+
+void do_compress(std::vector<unsigned char>& out_code,const hpatch_TStreamInput* data,
+                 const hdiff_TCompress* compressPlugin,bool isMustCompress=false);
+static inline void do_compress(std::vector<unsigned char>& out_code,const std::vector<unsigned char>& data,
+                               const hdiff_TCompress* compressPlugin,bool isMustCompress=false){
+    hpatch_TStreamInput dataStream;
+    mem_as_hStreamInput(&dataStream,data.data(),data.data()+data.size());
+    do_compress(out_code,&dataStream,compressPlugin,isMustCompress);
+}
+
+}//namespace hdiff_private
+#endif

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

@@ -0,0 +1,168 @@
+// match_inplace.cpp
+// hdiff
+/*
+ The MIT License (MIT)
+ Copyright (c) 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.
+ */
+#include "match_inplace.h"
+#include <algorithm> //std::min std::max std::sort
+using namespace hdiff_private;
+
+namespace{
+    static const hpatch_StreamPos_t _kMinCoverLen     =24;
+    static const int _kMaxMatchDeepForResearch = kDefaultMaxMatchDeepForLimit*2;
+
+    static inline bool coverInExtraSafeSize(const hpatch_TCover& cover,hpatch_StreamPos_t kExtraSafeSize){
+        return cover.oldPos+kExtraSafeSize>=cover.newPos;
+    }
+
+    static inline TInplaceSets _limitSets(size_t oldSize, size_t newSize, const TInplaceSets& inplaceSets) {
+        TInplaceSets limitedSets=inplaceSets;
+        limitedSets.extraSafeSize=std::min(limitedSets.extraSafeSize,newSize);
+        return limitedSets;
+    }
+
+//ICoverLinesListener
+static bool _search_cover_limit(ICoverLinesListener* listener,const void* pcovers,size_t coverCount,bool isCover32){
+    TMatchInplace* self=(TMatchInplace*)listener;
+    const hpatch_StreamPos_t kExtraSafeSize=self->inplaceSets.extraSafeSize;
+    std::vector<size_t> researchIndexList;
+    TRefCovers covers(pcovers,coverCount,isCover32);
+    hpatch_StreamPos_t researchLength=0;
+    hpatch_StreamPos_t inExtraSafeLength=0;
+    for (size_t i=0;i<coverCount;++i){
+        hpatch_TCover curCover=covers[i];
+        if (coverInExtraSafeSize(curCover,kExtraSafeSize)){//ok
+            inExtraSafeLength+=curCover.length;
+        }else{
+            researchLength+=curCover.length;
+            researchIndexList.push_back(i);
+        }
+    }
+    self->inExtraSafeLength=inExtraSafeLength;
+    self->researchLength=researchLength;
+    self->researchCount=researchIndexList.size();
+    self->_researchIndexList.swap(researchIndexList);
+    return (!self->_researchIndexList.empty());
+}
+
+
+    struct TDiffSearchCoverListener :public IDiffSearchCoverListener{
+        const size_t kExtraSafeSize;
+        inline explicit TDiffSearchCoverListener(size_t _extraMemSize):kExtraSafeSize(_extraMemSize){ 
+            limitCover=_limitCover;
+            limitCover_front=_limitCover_front;
+        }
+        static bool _limitCover(struct IDiffSearchCoverListener* listener,
+                                const hpatch_TCover* cover,hpatch_StreamPos_t* out_leaveLen){
+            TDiffSearchCoverListener* self=(TDiffSearchCoverListener*)listener;
+            bool isOk=(cover->length>=_kMinCoverLen)&&coverInExtraSafeSize(*cover,self->kExtraSafeSize);
+            if (out_leaveLen) *out_leaveLen=isOk?cover->length:0;
+            return isOk;
+        }
+        static void _limitCover_front(struct IDiffSearchCoverListener* listener,
+                                      const hpatch_TCover* front_cover,hpatch_StreamPos_t* out_leaveLen){
+            TDiffSearchCoverListener* self=(TDiffSearchCoverListener*)listener;
+            assert(coverInExtraSafeSize(*front_cover,self->kExtraSafeSize));
+            *out_leaveLen=front_cover->length;
+        }
+    };
+static void _research_cover(ICoverLinesListener* listener,IDiffResearchCover* diffi,const void* pcovers,size_t coverCount,bool isCover32){
+    TMatchInplace* self=(TMatchInplace*)listener;
+    TRefCovers covers(pcovers,coverCount,isCover32);
+    TDiffSearchCoverListener diffSearchCoverListener(self->inplaceSets.extraSafeSize);
+    std::vector<size_t> researchIndexList;
+    researchIndexList.swap(self->_researchIndexList);
+    for (size_t i=0;i<researchIndexList.size();++i){
+        size_t limitCoverIndex=researchIndexList[i];
+        hpatch_TCover cover=covers[limitCoverIndex];
+        diffi->researchCover(diffi,&diffSearchCoverListener,limitCoverIndex,0,0,cover.length);
+    }
+}
+
+static int _get_max_match_deep(const ICoverLinesListener* listener){
+    return _kMaxMatchDeepForResearch;
+}
+
+static void _search_cover_finish(ICoverLinesListener* listener,void* pcovers,size_t* pcoverCount,bool isCover32,
+                                 hpatch_StreamPos_t* newSize,hpatch_StreamPos_t* oldSize){
+    TMatchInplace* self=(TMatchInplace*)listener;
+    const hpatch_size_t kExtraSafeSize=self->inplaceSets.extraSafeSize;
+
+    //check covers
+    hpatch_StreamPos_t minExtraSafeSize=0;
+    TRefCovers _covers(pcovers,*pcoverCount,isCover32);
+    for (size_t i=0;i<_covers.size();++i){
+        hpatch_TCover cover=_covers[i];
+        if (!coverInExtraSafeSize(cover,kExtraSafeSize))
+            throw std::runtime_error("TMatchInplace limit cover by extraSafeSize ERROR!");
+        if (cover.oldPos<cover.newPos)
+            minExtraSafeSize=std::max(minExtraSafeSize,(hpatch_StreamPos_t)(cover.newPos-cover.oldPos));
+    }
+    if (minExtraSafeSize>kExtraSafeSize)
+       throw std::runtime_error("TMatchInplace extraSafeSize value ERROR!");
+    self->curExtraSafeSize=minExtraSafeSize;
+}
+
+static bool _getInplacePatchExtraSafeSize(ILiteDiffListener* listener,hpi_size_t* out_extraSafeSize){
+    const TMatchInplace* self=(const TMatchInplace*)listener;
+    if (self->inplaceSets.isCompatibleLiteDiff)
+        return false; //not save extraSafeSize
+    *out_extraSafeSize=(hpi_size_t)self->curExtraSafeSize;
+    return true; //save extraSafeSize
+}
+
+}//namespace
+
+
+TMatchInplace::TMatchInplace(size_t _oldSize,size_t _newSize,const TInplaceSets& _inplaceSets)
+:oldSize(_oldSize),newSize(_newSize),inplaceSets(_limitSets(_oldSize,_newSize,_inplaceSets)){
+    this->curExtraSafeSize=inplaceSets.extraSafeSize;
+    this->getInplacePatchExtraSafeSize=0;
+    ICoverLinesListener* cl=this;
+    memset(cl,0,sizeof(*cl));
+    this->search_cover_limit=_search_cover_limit;
+    this->research_cover=_research_cover;
+    this->get_max_match_deep=_get_max_match_deep;
+    this->search_cover_finish=_search_cover_finish;
+    this->getInplacePatchExtraSafeSize=_getInplacePatchExtraSafeSize;
+}
+
+void create_inplace_lite_diff(const hpi_byte* newData,const hpi_byte* newData_end,
+                              const hpi_byte* oldData,const hpi_byte* oldData_end,
+                              std::vector<hpi_byte>& out_inplace_lite_diff,const TInplaceSets& inplaceSets,
+                              const hdiffi_TCompress* compressPlugin,int kMinSingleMatchScore,
+                              bool isUseBigCacheMatch,size_t threadNum){
+    TMatchInplace matchInplace(oldData_end-oldData,newData_end-newData,inplaceSets);
+    create_lite_diff(newData,newData_end,oldData,oldData_end,out_inplace_lite_diff,compressPlugin,
+                     kMinSingleMatchScore,isUseBigCacheMatch,&matchInplace,threadNum);
+
+#ifdef _DEBUG
+    printf("\nDEBUG TMatchInplace info:\n"
+           "    cur extraSafeSize    : %" PRIu64 "\n",matchInplace.curExtraSafeSize);
+    printf("    extraSafe data length: %" PRIu64 "\n",matchInplace.inExtraSafeLength);
+    printf("    research  cover count: %" PRIu64 "\n",(hpatch_StreamPos_t)matchInplace.researchCount);
+    printf("    research  data length: %" PRIu64 "\n\n",matchInplace.researchLength);
+#endif
+}

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

@@ -0,0 +1,44 @@
+// match_inplace.h
+// hdiff
+/*
+ The MIT License (MIT)
+ Copyright (c) 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 hdiff_match_inplace_h
+#define hdiff_match_inplace_h
+#include "../diff_for_hpatch_lite.h" //diffi API
+
+    struct TMatchInplace:public ILiteDiffListener {
+        const size_t oldSize;
+        const size_t newSize;
+        const TInplaceSets inplaceSets;
+        explicit TMatchInplace(size_t _oldSize,size_t _newSize,const TInplaceSets& _inplaceSets);
+        std::vector<size_t> _researchIndexList;
+        size_t              researchCount;
+        hpatch_StreamPos_t  researchLength;
+        hpatch_StreamPos_t  inExtraSafeLength;
+        hpatch_StreamPos_t  curExtraSafeSize;
+    };
+
+#endif //hdiff_match_inplace_h

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

@@ -0,0 +1,72 @@
+//  mem_buf.h
+//
+/*
+ The MIT License (MIT)
+ Copyright (c) 2012-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 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 __mem_buf_h
+#define __mem_buf_h
+#include <stdlib.h> //malloc free
+#include <string.h> //size_t
+#include <stdexcept>  //std::runtime_error
+#include <string>
+namespace hdiff_private{
+
+    struct TAutoMem{
+        inline explicit TAutoMem(size_t size=0) :_data(0),_data_end(0),_capacity_end(0){ realloc(size); }
+        inline ~TAutoMem(){ clear(); }
+        inline unsigned char* data(){ return _data; }
+        inline const unsigned char* data()const{ return _data; }
+        inline unsigned char* data_end(){ return _data_end; }
+        inline const unsigned char* data_end()const{ return _data_end; }
+        inline size_t size()const{ return (size_t)(_data_end-_data); }
+        inline size_t capacity()const{ return (size_t)(_capacity_end-_data); }
+        inline bool empty()const{ return (_data_end==_data); }
+        inline void clear(){ if (_data) { free(_data); _data=0; _data_end=0; _capacity_end=0; } }
+        inline void realloc(size_t newSize){
+            if (newSize<=capacity()){
+                _data_end=_data+newSize;
+            }else{
+                unsigned char* _new_data=(unsigned char*)::realloc(_data,newSize);
+                if (_new_data==0) throw std::runtime_error("TAutoMem::TAutoMem() realloc() error!");
+                _data=_new_data;
+                _data_end=_new_data+newSize;
+                _capacity_end=_data_end;
+            }
+        }
+        inline void reduceSize(size_t reserveSize){
+            if (reserveSize<=capacity())
+                _data_end=_data+reserveSize;
+            else
+                throw std::runtime_error("TAutoMem::reduceSize() error!");
+        }
+    private:
+        unsigned char*  _data;
+        unsigned char*  _data_end;
+        unsigned char*  _capacity_end;
+    };
+
+}//namespace hdiff_private
+#endif //__mem_buf_h