react-native-update 10.34.3 → 10.34.4

package/harmony/pushy/src/main/cpp/HDiffPatch/libHDiffPatch/HDiff/diff.cpp

@@ -29,7 +29,7 @@
 #include "diff.h"
 #include <string.h> //strlen memcmp
 #include <stdio.h>  //fprintf
-#include <algorithm> //std::max std::sort
+#include <algorithm> //std::max
 #include <vector>
 #include "private_diff/suffix_string.h"
 #include "private_diff/bytes_rle.h"
@@ -41,15 +41,13 @@
 #include "private_diff/limit_mem_diff/covers.h"
 #include "private_diff/limit_mem_diff/digest_matcher.h"
 #include "private_diff/limit_mem_diff/stream_serialize.h"
-#include "../../libParallel/parallel_import.h"
-#if (_IS_USED_MULTITHREAD)
-#include <thread>   //if used vc++, need >= vc2012
-#include <atomic>
-#endif
 using namespace hdiff_private;
-#if (_IS_OUT_DIFF_INFO)
-int _hdiff_is_out_diff_info=1;
-#endif
+
+static void getCovers_by_stream(const hpatch_TStreamInput*  newData,
+                                const hpatch_TStreamInput*  oldData,
+                                size_t kMatchBlockSize,bool kIsSkipSameRange,
+                                TCovers& out_covers);
+
 
 static const char* kHDiffVersionType  ="HDIFF13";
 static const char* kHDiffSFVersionType="HDIFFSF20";
@@ -57,22 +55,14 @@ static const char* kHDiffSFVersionType="HDIFFSF20";
 #define checki(value,info) { if (!(value)) { throw std::runtime_error(info); } }
 #define check(value) checki(value,"check "#value" error!")
 
-#if (_SSTRING_FAST_MATCH>0)
-static const int kMinMatchLen   = (_SSTRING_FAST_MATCH>kCoverMinMatchLen)?_SSTRING_FAST_MATCH:kCoverMinMatchLen;
-#else
-static const int kMinMatchLen   = kCoverMinMatchLen; //min length for match search.
-#endif
-static const int kMinMatchScore = 2; //min match benefit threshold for cover search.
-static const hpatch_uint64_t kDefaultLimitCoverLen=((hpatch_uint64_t)1<<30); //<=2GB-1
-
 namespace{
     
     typedef unsigned char TByte;
     typedef size_t        TUInt;
     typedef ptrdiff_t     TInt;
-    static const int kMaxLinkSpaceLength=(1<<9)-1; //max allowed distance for merging across cover lines.
+    static const int kMaxLinkSpaceLength=(1<<9)-1; //跨覆盖线合并时,允许合并的最远距离.
     
-    //cover line.
+    //覆盖线.
     struct TOldCover {
         TInt   oldPos;
         TInt   newPos;
@@ -83,16 +73,16 @@ namespace{
         inline TOldCover(const TOldCover& cover)
             :oldPos(cover.oldPos),newPos(cover.newPos),length(cover.length) { }
         
-        inline bool isCanLink(const TOldCover& next)const{//whether the cover lines can be linked.
+        inline bool isCanLink(const TOldCover& next)const{//覆盖线是否可以连接.
             return isCollinear(next)&&(linkSpaceLength(next)<=kMaxLinkSpaceLength);
         }
-        inline bool isCollinear(const TOldCover& next)const{//whether the cover lines are collinear.
-            return cover_is_collinear(*this,next);
+        inline bool isCollinear(const TOldCover& next)const{//覆盖线是否在同一条直线上.
+            return (oldPos-next.oldPos==newPos-next.newPos);
         }
-        inline TInt linkSpaceLength(const TOldCover& next)const{//the space between cover lines.
+        inline TInt linkSpaceLength(const TOldCover& next)const{//覆盖线间的间距.
             return next.oldPos-(oldPos+length);
         }
-        inline void Link(const TOldCover& next){// link&merge two collinear cover lines.
+        inline void Link(const TOldCover& next){//共线的2覆盖线合并链接.
             assert(isCollinear(next));
             assert(oldPos<=next.oldPos);
             length = (next.oldPos-oldPos)+next.length;
@@ -105,106 +95,41 @@ struct TDiffData{
     const TByte*            newData_end;
     const TByte*            oldData;
     const TByte*            oldData_end;
-    inline TDiffData():newData(0),newData_end(0),oldData(0),oldData_end(0){}
-    inline TDiffData(const TByte* _newData,const TByte* _newData_end,
-                     const TByte* _oldData,const TByte* _oldData_end)
-        :newData(_newData),newData_end(_newData_end),oldData(_oldData),oldData_end(_oldData_end){}
-    inline TDiffData(const TDiffData& src)
-        :newData(src.newData),newData_end(src.newData_end),
-        oldData(src.oldData),oldData_end(src.oldData_end){}
+    std::vector<TOldCover>  covers;         //选出的覆盖线.
+    std::vector<TByte>      newDataDiff;    //集中储存newData中没有被覆盖线覆盖住的字节数据.
+    std::vector<TByte>      newDataSubDiff; //newData中的每个数值减去对应的cover线条的oldData数值和newDataDiff的数值.
 };
 
 
-//Find the length of the matching substring.
-template<TInt kMaxEqLenLimit>
-static TInt getEqualLengthLimit(const TByte* x,const TByte* x_end,
-                          const TByte* y,const TByte* y_end){
+//查找相等的字符串长度.
+static TInt getEqualLength(const TByte* x,const TByte* x_end,
+                           const TByte* y,const TByte* y_end){
     const TInt xLen=(TInt)(x_end-x);
     const TInt yLen=(TInt)(y_end-y);
-    TInt maxEqLen=(xLen<yLen)?xLen:yLen;
-    if (kMaxEqLenLimit)
-        maxEqLen=(maxEqLen<=kMaxEqLenLimit)?maxEqLen:kMaxEqLenLimit;
+    const TInt maxEqLen=(xLen<yLen)?xLen:yLen;
     for (TInt i=0; i<maxEqLen; ++i) {
         if (x[i]!=y[i])
             return i;
     }
     return maxEqLen;
 }
-#define getEqualLength(x,x_end,y,y_end) getEqualLengthLimit<0>(x,x_end,y,y_end)
 
-struct TDiffLimit{
-    IDiffSearchCoverListener* listener;
-    size_t      newPos;
-    size_t      newEnd;
-    size_t      recoverOldPos;
-    size_t      recoverOldEnd;
-    TCompressDetect& nocover_detect;
-    TCompressDetect& cover_detect;
-    TOldCover        lastCover_back;
-    int              kMaxMatchDeep;
-};
-
- 
-//Get the longest match length and its position.
+//得到最长的一个匹配长度和其位置.
 static TInt getBestMatch(TInt* out_pos,const TSuffixString& sstring,
-                         const TByte* newData,const TByte* newData_end,
-                         TInt curNewPos,TDiffLimit* diffLimit=0,size_t* out_limitSkip=0){
+                         const TByte* newData,const TByte* newData_end){
     TInt sai=sstring.lower_bound(newData,newData_end);
-    if (sai<0) return 0;
-    const TInt matchDeep = diffLimit?diffLimit->kMaxMatchDeep:2;
-    const TInt kLimitOldPos=(TInt)(diffLimit?diffLimit->recoverOldPos:0);
-    const TInt kLimitOldEnd=(TInt)(diffLimit?diffLimit->recoverOldEnd:sstring.SASize());
     
     const TByte* src_begin=sstring.src_begin();
     const TByte* src_end=sstring.src_end();
-    TInt bestLength= kMinMatchLen -1;
+    TInt bestLength=-1;
     TInt bestOldPos=-1;
-    bool leftOk = false;
-    bool rightOk = false;
-    for (TInt mdi= 0; mdi< matchDeep; ++mdi) {
-        if (mdi&1){
-            if (rightOk) continue;
-        } else {
-            if (leftOk) continue;
-        }
-        TInt i = sai + (1-(mdi&1)*2) * ((mdi+1)/2);
-        if ((i<0)|(i>=(src_end-src_begin))) continue;
+    for (TInt i=sai-1; i<=sai; ++i) {
+        if ((i<0)||(i>=(src_end-src_begin))) continue;
         TInt curOldPos=sstring.SA(i);
-
-        TInt curLength;
-        #define kTryEqLenLimit (1024*1+17)
-        if (0==diffLimit){
-            curLength=getEqualLength(newData,newData_end,src_begin+curOldPos,src_end);
-        }else{
-            curLength=getEqualLengthLimit<kTryEqLenLimit>(newData,newData_end,src_begin+curOldPos,src_end);
-            if ((kLimitOldPos<=curOldPos)&&(curOldPos<kLimitOldEnd)){
-                if (curLength==kTryEqLenLimit)
-                    *out_limitSkip=kTryEqLenLimit/2;
-                continue;
-            }
-        }
-         
+        TInt curLength=getEqualLength(newData,newData_end,src_begin+curOldPos,src_end);
         if (curLength>bestLength){
-            if (diffLimit){
-                hpatch_TCover cover={(size_t)curOldPos,(size_t)curNewPos,(size_t)curLength};
-                hpatch_StreamPos_t hitPos;
-                diffLimit->listener->limitCover(diffLimit->listener,&cover,&hitPos);
-                if (hitPos<=(size_t)bestLength)
-                    continue;
-                if (hitPos==kTryEqLenLimit){
-                    curLength=getEqualLength(newData,newData_end,src_begin+curOldPos,src_end);
-                    hpatch_TCover cover={(size_t)curOldPos,(size_t)curNewPos,(size_t)curLength};
-                    diffLimit->listener->limitCover(diffLimit->listener,&cover,&hitPos);
-                }
-                curLength=(TInt)hitPos;
-            }
-            bestLength = curLength;
-            bestOldPos= curOldPos;
-        }
-        if (mdi&1){
-            rightOk=true; if (leftOk) break;
-        } else {
-            leftOk=true; if (rightOk) break;
+            bestLength=curLength;
+            bestOldPos=curOldPos;
         }
     }
     *out_pos=bestOldPos;
@@ -212,7 +137,7 @@ static TInt getBestMatch(TInt* out_pos,const TSuffixString& sstring,
 }
 
     
-    //Roughly estimate the control data cost of the cover line;
+    //粗略估算覆盖线的控制数据成本;
     inline static TInt getCoverCtrlCost(const TOldCover& cover,const TOldCover& lastCover){
         static const int kUnLinkOtherScore=0;//0--2
         return _getIntCost<TInt,TUInt>((TInt)(cover.oldPos-lastCover.oldPos))
@@ -220,53 +145,37 @@ static TInt getBestMatch(TInt* out_pos,const TSuffixString& sstring,
              + _getUIntCost((TUInt)(cover.newPos-lastCover.newPos)) + kUnLinkOtherScore;
     }
     
-    //Roughly estimate the possible storage cost if the region is treated as a cover.
+    //粗略估算 区域内当作覆盖时的可能存储成本.
+    inline static bool checkGetCoverCost(TInt* out_cost,TInt newPos,TInt oldPos,
+                                         TInt length,const TDiffData& diff){
+        if ((oldPos<0)||(oldPos+length>(diff.oldData_end-diff.oldData)))
+            return false;
+        *out_cost=(TInt)getRegionRleCost(diff.newData+newPos,length,diff.oldData+oldPos);
+        return true;
+    }
     inline static TInt getCoverCost(const TOldCover& cover,const TDiffData& diff){
         return (TInt)getRegionRleCost(diff.newData+cover.newPos,cover.length,diff.oldData+cover.oldPos);
     }
     
-// Attempt to extend lastCover to completely replace matchCover;
-static bool tryLinkExtend(TOldCover& lastCover,const TOldCover& matchCover,const TDiffData& diff,TDiffLimit* diffLimit){
+//尝试延长lastCover来完全代替matchCover;
+static bool tryLinkExtend(TOldCover& lastCover,const TOldCover& matchCover,const TDiffData& diff){
     if (lastCover.length<=0) return false;
     const TInt linkSpaceLength=(matchCover.newPos-(lastCover.newPos+lastCover.length));
-    assert(linkSpaceLength>=0);
-    if (linkSpaceLength>kMaxLinkSpaceLength)
-        return false;
-    TInt linkOldPos=lastCover.oldPos+lastCover.length+linkSpaceLength;
-    if (linkOldPos+matchCover.length>(diff.oldData_end-diff.oldData))
+    if ((linkSpaceLength>kMaxLinkSpaceLength)||(matchCover.newPos==0))
         return false;
-    const bool isCollinear=lastCover.isCollinear(matchCover);
-    if (diffLimit){
-        size_t cnewPos=lastCover.newPos+lastCover.length;
-        hpatch_TCover cover={(size_t)(lastCover.oldPos+lastCover.length),cnewPos,
-                             (size_t)(linkSpaceLength+(isCollinear?0:matchCover.length))};
-        if (!diffLimit->listener->limitCover(diffLimit->listener,&cover,0))
-            return false;
-    }
-    if (isCollinear){// Already collinear;
+    if (lastCover.isCollinear(matchCover)){//已经共线;
         lastCover.Link(matchCover);
         return true;
     }
-
+    TInt linkOldPos=lastCover.oldPos+lastCover.length+linkSpaceLength;
     TInt matchCost=getCoverCtrlCost(matchCover,lastCover);
-    TInt lastLinkCost=(TInt)getRegionRleCost(diff.newData+matchCover.newPos,matchCover.length,diff.oldData+linkOldPos);
+    TInt lastLinkCost;
+    if (!checkGetCoverCost(&lastLinkCost,matchCover.newPos,linkOldPos,matchCover.length,diff)) return false;
     if (lastLinkCost>matchCost)
         return false;
-    TInt len=lastCover.length+linkSpaceLength+(matchCover.length*2/3);// Extend most of it, leaving the remaining possible extension to extend_cover.
+    TInt len=lastCover.length+linkSpaceLength+(matchCover.length*2/3);//扩展大部分,剩下的可能扩展留给extend_cover.
     len+=getEqualLength(diff.newData+lastCover.newPos+len,diff.newData_end,
                         diff.oldData+lastCover.oldPos+len,diff.oldData_end);
-    if (diffLimit){
-        TInt limitLen=diffLimit->newEnd-lastCover.newPos;
-        len=len<limitLen?len:limitLen;
-        TInt safeLen=lastCover.length+linkSpaceLength+matchCover.length;
-        if (len>safeLen){
-            hpatch_TCover cover={(size_t)(lastCover.oldPos+safeLen),(size_t)(lastCover.newPos+safeLen),
-                                 (size_t)(len-safeLen)};
-            hpatch_StreamPos_t hitPos;
-            diffLimit->listener->limitCover(diffLimit->listener,&cover,&hitPos);
-            len=(TInt)(safeLen+hitPos);
-        }
-    }
     while ((len>0) && (diff.newData[lastCover.newPos+len-1]
                        !=diff.oldData[lastCover.oldPos+len-1])) {
         --len;
@@ -275,122 +184,73 @@ static bool tryLinkExtend(TOldCover& lastCover,const TOldCover& matchCover,const
     return true;
 }
     
-// Attempt to set lastCover as an extension of the line where matchCover is located, achieving collinearity (increasing merge possibilities, etc.);
-static void tryCollinear(TOldCover& lastCover,const TOldCover& matchCover,const TDiffData& diff,TDiffLimit* diffLimit){
+//尝试设置lastCover为matchCover所在直线的延长线,实现共线(增加合并可能等);
+static void tryCollinear(TOldCover& lastCover,const TOldCover& matchCover,const TDiffData& diff){
     if (lastCover.length<=0) return;
-    if (lastCover.isCollinear(matchCover)) return; // Already collinear;
-    
+    if (lastCover.isCollinear(matchCover)) return; //已经共线;
     TInt linkOldPos=matchCover.oldPos-(matchCover.newPos-lastCover.newPos);
-    if ((linkOldPos<0)||(linkOldPos+lastCover.length>(diff.oldData_end-diff.oldData)))
-        return;
-    if (diffLimit){
-        hpatch_TCover cover={ (size_t)linkOldPos,(size_t)lastCover.newPos,(size_t)lastCover.length};
-        if (!diffLimit->listener->limitCover(diffLimit->listener,&cover,0))
-            return;
-    }
     TInt lastCost=getCoverCost(lastCover,diff);
-    TInt matchLinkCost=(TInt)getRegionRleCost(diff.newData+lastCover.newPos,lastCover.length,diff.oldData+linkOldPos);
+    TInt matchLinkCost;
+    if (!checkGetCoverCost(&matchLinkCost,lastCover.newPos,linkOldPos,lastCover.length,diff)) return;
     if (lastCost>=matchLinkCost)
         lastCover.oldPos=linkOldPos;
 }
 
-
-// Find suitable cover lines.
-static void _search_cover(std::vector<TOldCover>& covers,const TDiffData& diff,
-                          const TSuffixString& sstring,TDiffLimit* diffLimit,bool isCanExtendCover){
+//寻找合适的覆盖线.
+static void search_cover(TDiffData& diff,const TSuffixString& sstring){
     if (sstring.SASize()<=0) return;
-    TInt newPos=diffLimit?diffLimit->newPos:0;
-    const TInt newEnd=diffLimit?diffLimit->newEnd:(diff.newData_end-diff.newData);
-    if (newEnd-newPos<=kMinMatchLen) return;
-    const TInt maxSearchNewPos=newEnd-kMinMatchLen;
-    const size_t cover_begin=covers.size();
-
+    static const int kMinMatchScore = 2; //最小搜寻覆盖收益.
+    const TInt maxSearchNewPos=(diff.newData_end-diff.newData)-kMinMatchScore;
+    TInt newPos=0;
     TOldCover lastCover(0,0,0);
     while (newPos<=maxSearchNewPos) {
         TInt matchOldPos=0;
-        size_t limitSkip=1;
-        TInt matchEqLength=getBestMatch(&matchOldPos,sstring,diff.newData+newPos,diff.newData+newEnd,newPos,
-                                        diffLimit,&limitSkip);
-        if (matchEqLength<kMinMatchLen){
-            newPos+=limitSkip;
-            continue;
-        }
+        TInt matchEqLength=getBestMatch(&matchOldPos,sstring,diff.newData+newPos,diff.newData_end);
         TOldCover matchCover(matchOldPos,newPos,matchEqLength);
         if (matchEqLength-getCoverCtrlCost(matchCover,lastCover)<kMinMatchScore){
-            ++newPos;// The next string to match (matching byte by byte is relatively slow).
+            ++newPos;//下一个需要匹配的字符串(逐位置匹配速度会比较慢).
             continue;
         }//else matched
         
-        if (isCanExtendCover){
-            if (tryLinkExtend(lastCover,matchCover,diff,diffLimit)){//use link
-                if (covers.size()==cover_begin)
-                    covers.push_back(lastCover);
-                else
-                    covers.back()=lastCover;
-            }else{ //use match
-                if (covers.size()>cover_begin)// Attempt collinearity;
-                    tryCollinear(covers.back(),matchCover,diff,diffLimit);
-                covers.push_back(matchCover);
-            }
-        }else{
-            covers.push_back(matchCover);
+        if (tryLinkExtend(lastCover,matchCover,diff)){//use link
+            if (diff.covers.empty())
+                diff.covers.push_back(lastCover);
+            else
+                diff.covers.back()=lastCover;
+        }else{ //use match
+            if (!diff.covers.empty())//尝试共线;
+                tryCollinear(diff.covers.back(),matchCover,diff);
+            diff.covers.push_back(matchCover);
         }
-        lastCover=covers.back();
-        newPos=std::max(newPos+1,lastCover.newPos+lastCover.length);// The selected cover does not allow overlap, which may not be the optimal strategy;
+        lastCover=diff.covers.back();
+        newPos=std::max(newPos+1,lastCover.newPos+lastCover.length);//选出的cover不允许重叠,这可能不是最优策略;
     }
 }
 
+//选择合适的覆盖线,去掉不合适的.
+static void select_cover(TDiffData& diff,int kMinSingleMatchScore){
+    std::vector<TOldCover>&  covers=diff.covers;
+    TCompressDetect  nocover_detect;
+    TCompressDetect  cover_detect;
 
-//Select the appropriate cover lines and remove the unsuitable ones.
-static void _select_cover(std::vector<TOldCover>& covers,size_t cover_begin,const TDiffData& diff,int kMinSingleMatchScore,
-                          TCompressDetect& nocover_detect,TCompressDetect& cover_detect,
-                          TDiffLimit* diffLimit,bool isCanExtendCover){
     TOldCover lastCover(0,0,0);
-    if (diffLimit)
-        lastCover=diffLimit->lastCover_back;
-    const size_t coverSize_old=covers.size();
-    size_t insertIndex=cover_begin;
-    for (size_t i=cover_begin;i<coverSize_old;++i){
-        if (covers[i].length<=0) continue;// Skip the already deleted ones.
+    const TInt coverSize_old=(TInt)covers.size();
+    TInt insertIndex=0;
+    for (TInt i=0;i<coverSize_old;++i){
+        if (covers[i].oldPos<0) continue;//处理已经del的.
         bool isNeedSave=false;
-        bool isCanLink=false;
-        if (isCanExtendCover&&(!isNeedSave)){// Possibility for forward merging.
-            if ((insertIndex>cover_begin)&&(covers[insertIndex-1].isCanLink(covers[i]))){
-                if (diffLimit){
-                    const TOldCover& fc=covers[insertIndex-1];
-                    hpatch_TCover cover={(size_t)(fc.oldPos+fc.length),(size_t)(fc.newPos+fc.length),
-                                         (size_t)fc.linkSpaceLength(covers[i])};
-                    if (diffLimit->listener->limitCover(diffLimit->listener,&cover,0)){
-                        isCanLink=true;
-                        isNeedSave=true;
-                    }
-                }else{
-                    isCanLink=true;
-                    isNeedSave=true;
-                }
-            }
+        if (!isNeedSave){//向前合并可能.
+            if ((insertIndex>0)&&(covers[insertIndex-1].isCanLink(covers[i])))
+                isNeedSave=true;
         }
-        if (isCanExtendCover&&(i+1<coverSize_old)){// Check possibility for backward link merging
-            for (size_t j=i+1;j<coverSize_old; ++j) {
+        if (i+1<coverSize_old){//查询向后合并可能link
+            for (TInt j=i+1;j<coverSize_old; ++j) {
                 if (!covers[i].isCanLink(covers[j])) break;
-                if (diffLimit){
-                    const TOldCover& fc=covers[i];
-                    hpatch_TCover cover={(size_t)(fc.oldPos+fc.length),(size_t)(fc.newPos+fc.length),
-                                         (size_t)fc.linkSpaceLength(covers[j])};
-                    if (diffLimit->listener->limitCover(diffLimit->listener,&cover,0)){
-                        covers[i].Link(covers[j]);
-                        covers[j].length=0;//del
-                    }else{
-                        break;
-                    }
-                }else{
-                    covers[i].Link(covers[j]);
-                    covers[j].length=0;//del
-                }
-
+                covers[i].Link(covers[j]);
+                covers[j].oldPos=-1;//del
             }
         }
-        if (!isNeedSave){// Whether to keep the single cover.
+        if (!isNeedSave){//单覆盖是否保留.
             TInt noCoverCost=nocover_detect.cost(diff.newData+covers[i].newPos,covers[i].length);
             TInt coverCost=cover_detect.cost(diff.newData+covers[i].newPos,covers[i].length,
                                              diff.oldData+covers[i].oldPos);
@@ -399,7 +259,7 @@ static void _select_cover(std::vector<TOldCover>& covers,size_t cover_begin,cons
         }
         
         if (isNeedSave){
-            if (isCanLink){// Link merging.
+            if ((insertIndex>0)&&(covers[insertIndex-1].isCanLink(covers[i]))){//link合并.
                 covers[insertIndex-1].Link(covers[i]);
                 cover_detect.add_chars(diff.newData+lastCover.newPos+lastCover.length,
                                        covers[insertIndex-1].length-lastCover.length,
@@ -416,24 +276,11 @@ static void _select_cover(std::vector<TOldCover>& covers,size_t cover_begin,cons
     }
     covers.resize(insertIndex);
 }
-
-static void select_cover(std::vector<TOldCover>& covers,size_t cover_begin,const TDiffData& diff,
-                         int kMinSingleMatchScore,TDiffLimit* diffLimit,bool isCanExtendCover){
-    if (diffLimit==0){
-        TCompressDetect  nocover_detect;
-        TCompressDetect  cover_detect;
-        _select_cover(covers,cover_begin,diff,kMinSingleMatchScore,nocover_detect,cover_detect,0,isCanExtendCover);
-    }else{
-        _select_cover(covers,cover_begin,diff,kMinSingleMatchScore,diffLimit->nocover_detect,
-                      diffLimit->cover_detect,diffLimit,isCanExtendCover);
-    }
-}
-
     
-    typedef size_t TFixedFloatSmooth; // Fixed-point number.
-    static const TFixedFloatSmooth kFixedFloatSmooth_base=1024;// Position of fixed-point decimal point.
+    typedef size_t TFixedFloatSmooth; //定点数.
+    static const TFixedFloatSmooth kFixedFloatSmooth_base=1024;//定点数小数点位置.
 
-    // Get the length of positions that can be extended.
+    //得到可以扩展位置的长度.
     static TInt getCanExtendLength(TInt oldPos,TInt newPos,int inc,TInt newPos_min,TInt lastNewEnd,
                                    const TDiffData& diff,const TFixedFloatSmooth kExtendMinSameRatio){
         static const unsigned int kSmoothLength=4;
@@ -463,39 +310,17 @@ static void select_cover(std::vector<TOldCover>& covers,size_t cover_begin,const
         return curBestLength;
     }
 
-// Attempt to extend the cover area.
-static void extend_cover(std::vector<TOldCover>& covers,size_t cover_begin,const TDiffData& diff,
-                         const TFixedFloatSmooth kExtendMinSameRatio,TDiffLimit* diffLimit=0){
-    TInt lastNewEnd=diffLimit?diffLimit->newPos:0;
-    for (size_t i=cover_begin; i<covers.size(); ++i) {
-        TInt newPos_next;
-        if (i+1<covers.size())
+//尝试延长覆盖区域.
+static void extend_cover(TDiffData& diff,const TFixedFloatSmooth kExtendMinSameRatio){
+    std::vector<TOldCover>&  covers=diff.covers;
+
+    TInt lastNewEnd=0;
+    for (TInt i=0; i<(TInt)covers.size(); ++i) {
+        TInt newPos_next=(TInt)(diff.newData_end-diff.newData);
+        if (i+1<(TInt)covers.size())
             newPos_next=covers[i+1].newPos;
-        else
-            newPos_next=diffLimit?diffLimit->newEnd:(TInt)(diff.newData_end-diff.newData);
         TOldCover& curCover=covers[i];
-        if (diffLimit){
-            TInt limit_front=std::min(curCover.newPos-lastNewEnd,curCover.oldPos);
-            if (limit_front>0){
-                hpatch_TCover cover={(size_t)(curCover.oldPos-limit_front),
-                                     (size_t)(curCover.newPos-limit_front),(size_t)limit_front};
-                hpatch_StreamPos_t lenLimit;
-                diffLimit->listener->limitCover_front(diffLimit->listener,&cover,&lenLimit);
-                lastNewEnd=curCover.newPos-(TInt)lenLimit;
-            }
-
-            TInt limit_back=newPos_next-(curCover.newPos+curCover.length);
-            if ((curCover.oldPos+curCover.length)+limit_back>(diff.oldData_end-diff.oldData))
-                limit_back=(diff.oldData_end-diff.oldData)-(curCover.oldPos+curCover.length);
-            if (limit_back>0){
-                hpatch_TCover cover={(size_t)(curCover.oldPos+curCover.length),
-                                     (size_t)(curCover.newPos+curCover.length),(size_t)limit_back};
-                hpatch_StreamPos_t lenLimit;
-                diffLimit->listener->limitCover(diffLimit->listener,&cover,&lenLimit);
-                newPos_next=(curCover.newPos+curCover.length)+ (TInt)lenLimit;
-            }
-        }
-        // Extend forward.
+        //向前延伸.
         TInt extendLength_front=getCanExtendLength(curCover.oldPos-1,curCover.newPos-1,
                                                    -1,lastNewEnd,newPos_next,diff,kExtendMinSameRatio);
         if (extendLength_front>0){
@@ -503,7 +328,7 @@ static void extend_cover(std::vector<TOldCover>& covers,size_t cover_begin,const
             curCover.newPos-=extendLength_front;
             curCover.length+=extendLength_front;
         }
-        // Extend backward.
+        //向后延伸.
         TInt extendLength_back=getCanExtendLength(curCover.oldPos+curCover.length,
                                                   curCover.newPos+curCover.length,
                                                   1,lastNewEnd,newPos_next,diff,kExtendMinSameRatio);
@@ -528,66 +353,38 @@ static void extend_cover(std::vector<TOldCover>& covers,size_t cover_begin,const
         check(cover.oldPos+cover.length<=oldSize);
     }
 
-    static void assert_covers_safe(const TCovers& covers,hpatch_StreamPos_t newSize,hpatch_StreamPos_t oldSize){
-        hpatch_StreamPos_t lastNewEnd=0;
-        for (size_t i=0;i<covers.coverCount();++i){
-            TCover cover;
-            covers.covers(i,&cover);
-            assert_cover_safe(cover,lastNewEnd,newSize,oldSize);
-            lastNewEnd=cover.newPos+cover.length;
-        }
-    }
-    static void assert_covers_safe(const std::vector<TOldCover>& covers,hpatch_StreamPos_t newSize,hpatch_StreamPos_t oldSize){
-        const TCovers _covers((void*)covers.data(),covers.size(),
-                              sizeof(*covers.data())==sizeof(hpatch_TCover32));
-        assert_covers_safe(_covers,newSize,oldSize);
-    }
-
-    static inline hpatch_StreamPos_t _clipLenByLimit(hpatch_StreamPos_t& clen,hpatch_StreamPos_t kMaxLen){
-        hpatch_StreamPos_t alen=clen;
-        assert(alen>kMaxLen);
-        do{
-            alen=(alen+1)>>1;
-        } while (alen>kMaxLen);
-        clen-=alen;
-        return alen;
-    }
-    static void _limitCoverLenth(std::vector<TOldCover>& covers,hpatch_StreamPos_t kMaxLen){
-        assert((0<kMaxLen)&&(0<(TInt)kMaxLen)&&(kMaxLen==(TInt)kMaxLen));
-        size_t csize=covers.size();
-        size_t isize=0;
-        for (size_t i=0;i<csize;++i){
-            hpatch_StreamPos_t clen=covers[i].length;
-            while (clen>kMaxLen){
-                ++isize;
-                _clipLenByLimit(clen,kMaxLen);
-            }
-        }
-        if (isize==0) return;
+//用覆盖线得到差异数据.
+static void sub_cover(TDiffData& diff){
+    std::vector<TOldCover>& covers=diff.covers;
+    const TByte*            newData=diff.newData;
+    const TByte*            oldData=diff.oldData;
 
-        covers.resize(csize+isize);
-        memmove(covers.data()+isize,covers.data(),sizeof(TOldCover)*csize);
-        size_t insertIndex=0;
-        for (size_t i=isize;i<covers.size();++i){
-            hpatch_StreamPos_t clen=covers[i].length;
-            while (clen>kMaxLen){
-                --isize;
-                TInt clipLen=(TInt)_clipLenByLimit(clen,kMaxLen);
-                assert(insertIndex<i);
-                covers[insertIndex++]=TOldCover(covers[i].oldPos,covers[i].newPos,clipLen);
-                covers[i].oldPos+=clipLen;
-                covers[i].newPos+=clipLen;
-                covers[i].length-=clipLen;
-                assert(covers[i].length==clen);
-            }
-            covers[insertIndex++]=covers[i];
-        }
-        assert(isize==0);
-    }
+    diff.newDataSubDiff.resize(0);
+    diff.newDataSubDiff.resize(diff.newData_end-diff.newData,0);
+    TByte*  newDataSubDiff=diff.newDataSubDiff.data();
+    diff.newDataDiff.resize(0);
+    diff.newDataDiff.reserve((diff.newData_end-diff.newData)>>2);
+    
+    TInt lastNewEnd=0;
+    for (TInt i=0;i<(TInt)covers.size();++i){
+        assert_cover_safe(covers[i],lastNewEnd,
+                          diff.newData_end-diff.newData,diff.oldData_end-diff.oldData);
+        const TInt newPos=covers[i].newPos;
+        if (newPos>lastNewEnd)
+            pushBack(diff.newDataDiff,newData+lastNewEnd,newData+newPos);
+        const TInt oldPos=covers[i].oldPos;
+        const TInt length=covers[i].length;
+        for (TInt si=0; si<length;++si)
+            newDataSubDiff[si+newPos]=(newData[si+newPos]-oldData[si+oldPos]);
+        lastNewEnd=newPos+length;
+    }
+    if (lastNewEnd<diff.newData_end-newData)
+        pushBack(diff.newDataDiff,newData+lastNewEnd,diff.newData_end);
+}
 
-// Serialized output of diff result.
-static void serialize_diff(const TDiffData& diff,const std::vector<TOldCover>& covers,std::vector<TByte>& out_diff){
-    const TUInt coverCount=(TUInt)covers.size();
+//diff结果序列化输出.
+static void serialize_diff(const TDiffData& diff,std::vector<TByte>& out_diff){
+    const TUInt coverCount=(TUInt)diff.covers.size();
     std::vector<TByte> length_buf;
     std::vector<TByte> inc_newPos_buf;
     std::vector<TByte> inc_oldPos_buf;
@@ -595,40 +392,61 @@ static void serialize_diff(const TDiffData& diff,const std::vector<TOldCover>& c
         TInt oldPosBack=0;
         TInt lastNewEnd=0;
         for (TUInt i=0; i<coverCount; ++i) {
-            packUInt(length_buf, (TUInt)covers[i].length);
-            assert(covers[i].newPos>=lastNewEnd);
-            packUInt(inc_newPos_buf,(TUInt)(covers[i].newPos-lastNewEnd)); //save inc_newPos
-            if (covers[i].oldPos>=oldPosBack){ //save inc_oldPos
-                packUIntWithTag(inc_oldPos_buf,(TUInt)(covers[i].oldPos-oldPosBack), 0, 1);
+            packUInt(length_buf, (TUInt)diff.covers[i].length);
+            assert(diff.covers[i].newPos>=lastNewEnd);
+            packUInt(inc_newPos_buf,(TUInt)(diff.covers[i].newPos-lastNewEnd)); //save inc_newPos
+            if (diff.covers[i].oldPos>=oldPosBack){ //save inc_oldPos
+                packUIntWithTag(inc_oldPos_buf,(TUInt)(diff.covers[i].oldPos-oldPosBack), 0, 1);
             }else{
-                packUIntWithTag(inc_oldPos_buf,(TUInt)(oldPosBack-covers[i].oldPos), 1, 1);//sub safe
+                packUIntWithTag(inc_oldPos_buf,(TUInt)(oldPosBack-diff.covers[i].oldPos), 1, 1);//sub safe
             }
-            oldPosBack=covers[i].oldPos;
-            lastNewEnd=covers[i].newPos+covers[i].length;
+            oldPosBack=diff.covers[i].oldPos;
+            lastNewEnd=diff.covers[i].newPos+diff.covers[i].length;
         }
     }
-    
-    const TCovers _covers((void*)covers.data(),covers.size(),
-                          sizeof(*covers.data())==sizeof(hpatch_TCover32));
-    hpatch_TStreamInput _newDataStream;
-    mem_as_hStreamInput(&_newDataStream,diff.newData,diff.newData_end);
-    TNewDataDiffStream newDataDiffStream(_covers,&_newDataStream);
 
     packUInt(out_diff, (TUInt)coverCount);
     packUInt(out_diff, (TUInt)length_buf.size());
     packUInt(out_diff, (TUInt)inc_newPos_buf.size());
     packUInt(out_diff, (TUInt)inc_oldPos_buf.size());
-    packUInt(out_diff, newDataDiffStream.streamSize);
+    packUInt(out_diff, (TUInt)diff.newDataDiff.size());
     pushBack(out_diff,length_buf);
     pushBack(out_diff,inc_newPos_buf);
     pushBack(out_diff,inc_oldPos_buf);
-    pushBack(out_diff,&newDataDiffStream);
+    pushBack(out_diff,diff.newDataDiff);
     
-    TNewDataSubDiffStream_mem newDataSubDiff(diff.newData,diff.newData_end,
-                                             diff.oldData,diff.oldData_end,_covers);
-    bytesRLE_save(out_diff,&newDataSubDiff,kRle_bestSize);
+    const TByte* newDataSubDiff=diff.newDataSubDiff.data();
+    bytesRLE_save(out_diff,newDataSubDiff,
+                  newDataSubDiff+diff.newDataSubDiff.size(),kRle_bestSize);
 }
     
+    
+    static void do_compress(std::vector<TByte>& out_code,const std::vector<TByte>& data,
+                            const hdiff_TCompress* compressPlugin,bool isMustCompress=false){
+        out_code.clear();
+        if (!compressPlugin) return;
+        if (data.empty()) return;
+        hpatch_StreamPos_t maxCodeSize=compressPlugin->maxCompressedSize(data.size());
+        if ((maxCodeSize<=data.size())||(maxCodeSize!=(size_t)maxCodeSize)) return; //error
+        out_code.resize((size_t)maxCodeSize);
+        const TByte* data0=&data[0];
+        TByte* out_code0=&out_code[0];
+        size_t codeSize=hdiff_compress_mem(compressPlugin,out_code0,out_code0+out_code.size(),
+                                           data0,data0+data.size());
+        if ((codeSize>0)&&(isMustCompress||(codeSize<data.size())))
+            out_code.resize(codeSize); //ok
+        else
+            out_code.clear();//error or cancel
+    }
+    inline static void pushCompressCode(std::vector<TByte>& out_diff,
+                                        const std::vector<TByte>& compress_code,
+                                        const std::vector<TByte>& data){
+        if (compress_code.empty())
+            pushBack(out_diff,data);
+        else
+            pushBack(out_diff,compress_code);
+    }
+    
     template<class T>
     static void _outType(std::vector<TByte>& out_data,T* compressPlugin,const char* versionType=kHDiffVersionType){
         //type version
@@ -647,300 +465,117 @@ static void serialize_diff(const TDiffData& diff,const std::vector<TOldCover>& c
         pushBack(out_data,&_cstrEndTag,(&_cstrEndTag)+1);
     }
     
-
-static void _dispose_cover(std::vector<TOldCover>& covers,size_t cover_begin,const TDiffData& diff,
-                          int kMinSingleMatchScore,TDiffLimit* diffLimit,bool isCanExtendCover){
-    if (isCanExtendCover){
-        TFixedFloatSmooth kExtendMinSameRatio=kMinSingleMatchScore*36+254;
-        if  (kExtendMinSameRatio<200) kExtendMinSameRatio=200;
-        if (kExtendMinSameRatio>800) kExtendMinSameRatio=800;
-
-        extend_cover(covers,cover_begin,diff,kExtendMinSameRatio,diffLimit);// First try to extend.
-        select_cover(covers,cover_begin,diff,kMinSingleMatchScore,diffLimit,isCanExtendCover);
-        extend_cover(covers,cover_begin,diff,kExtendMinSameRatio,diffLimit);// select_cover will delete some cover lines, so re-extend.
-    }else{
-        select_cover(covers,cover_begin,diff,kMinSingleMatchScore,diffLimit,isCanExtendCover);
-    }
-}
-
-
-static void search_and_dispose_cover(std::vector<TOldCover>& covers,const TDiffData& diff,
-                                     const TSuffixString& sstring,int kMinSingleMatchScore,
-                                     TDiffLimit* diffLimit,bool isCanExtendCover){
-    const size_t cover_begin=covers.size();
-    _search_cover(covers,diff,sstring,diffLimit,isCanExtendCover);
-    if (covers.size()>cover_begin)
-        _dispose_cover(covers,cover_begin,diff,kMinSingleMatchScore,diffLimit,isCanExtendCover);
-}
-
-#define first_search_and_dispose_cover(covers,diff,sstring,kMinSingleMatchScore,isCanExtendCover) search_and_dispose_cover(covers,diff,sstring,kMinSingleMatchScore,0,isCanExtendCover);
-
-#if (_IS_USED_MULTITHREAD)
-    const size_t kPartPepeatSize=1024*2;
-    struct mt_data_t{
-        const TDiffData*        diff;
-        const TSuffixString*    sstring;
-        ICoverLinesListener*    listener;
-        int                     kMinSingleMatchScore;
-        size_t                  workBlockSize;
-        bool                    isCanExtendCover;
-        std::atomic<size_t>     workIndex;
-        bool nextBlock(hdiff_TRange* out_newRange){
-            const size_t kNewSize=(diff->newData_end-diff->newData);
-            if (listener)
-                return listener->next_search_block_MT(listener,out_newRange);
-            size_t i=workIndex++;
-            hpatch_StreamPos_t pos=i*(hpatch_StreamPos_t)workBlockSize;
-            if (pos<kNewSize){
-                out_newRange->beginPos=pos;
-                pos+=workBlockSize+kPartPepeatSize;
-                pos=(pos<=kNewSize)?pos:kNewSize;
-                out_newRange->endPos=pos;
-                return true;
+static void serialize_compressed_diff(const TDiffData& diff,std::vector<TByte>& out_diff,
+                                      const hdiff_TCompress* compressPlugin){
+    const TUInt coverCount=(TUInt)diff.covers.size();
+    std::vector<TByte> cover_buf;
+    {
+        TInt lastOldEnd=0;
+        TInt lastNewEnd=0;
+        for (TUInt i=0; i<coverCount; ++i) {
+            if (diff.covers[i].oldPos>=lastOldEnd){ //save inc_oldPos
+                packUIntWithTag(cover_buf,(TUInt)(diff.covers[i].oldPos-lastOldEnd), 0, 1);
             }else{
-                return false;
+                packUIntWithTag(cover_buf,(TUInt)(lastOldEnd-diff.covers[i].oldPos), 1, 1);//sub safe
             }
-        }
-    };
-
-    static void _fsearch_and_dispose_cover_thread(std::vector<TOldCover>* _covers,mt_data_t* mt){
-        std::vector<TOldCover>& covers=*_covers;
-        const TDiffData& diff=*mt->diff;
-        hdiff_TRange newRange;
-        while (mt->nextBlock(&newRange)){
-            TDiffData diff_part(diff);
-            diff_part.newData=diff.newData+(size_t)newRange.beginPos;
-            diff_part.newData_end=diff.newData+(size_t)newRange.endPos;
-            size_t coverCountBack=covers.size();
-            first_search_and_dispose_cover(covers,diff_part,*mt->sstring,mt->kMinSingleMatchScore,mt->isCanExtendCover);
-            for (size_t i=coverCountBack;i<covers.size();++i)
-                covers[i].newPos+=(TInt)newRange.beginPos;
+            assert(diff.covers[i].newPos>=lastNewEnd);
+            packUInt(cover_buf,(TUInt)(diff.covers[i].newPos-lastNewEnd)); //save inc_newPos
+            packUInt(cover_buf,(TUInt)diff.covers[i].length);
+            lastOldEnd=diff.covers[i].oldPos+diff.covers[i].length;//! +length
+            lastNewEnd=diff.covers[i].newPos+diff.covers[i].length;
         }
     }
-#endif
-
-static void first_search_and_dispose_cover_MT(std::vector<TOldCover>& covers,const TDiffData& diff,
-                                              const TSuffixString& sstring,int kMinSingleMatchScore,
-                                              ICoverLinesListener* listener,size_t threadNum,bool isCanExtendCover){
-#if (_IS_USED_MULTITHREAD)
-    const size_t kMinParallelSize=1024*1024*2;
-    const size_t kBestParallelSize=1024*1024*8;
-    size_t newSize=diff.newData_end-diff.newData;
-    if ((threadNum>1)&&(diff.oldData!=diff.oldData_end)&&(newSize>=kMinParallelSize)){
-        const size_t maxThreanNum=newSize/(kMinParallelSize/2);
-        threadNum=(threadNum<=maxThreanNum)?threadNum:maxThreanNum;
-        size_t workCount=(newSize+kBestParallelSize-1)/kBestParallelSize;
-        workCount=(threadNum>workCount)?threadNum:workCount;
-
-        const size_t threadCount=threadNum-1;
-        std::vector<std::thread> threads(threadCount);
-        std::vector<std::vector<TOldCover> > threadCovers(threadCount);
-        mt_data_t mt_data;
-        mt_data.diff=&diff;
-        mt_data.sstring=&sstring;
-        mt_data.listener=(listener&&listener->next_search_block_MT)?listener:0;
-        mt_data.kMinSingleMatchScore=kMinSingleMatchScore;
-        mt_data.workBlockSize=(newSize+workCount-1)/workCount;
-        mt_data.workIndex=0;
-        mt_data.isCanExtendCover=isCanExtendCover;
-        if (mt_data.listener&&listener->begin_search_block)
-            listener->begin_search_block(listener,newSize,mt_data.workBlockSize,kPartPepeatSize);
-        for (size_t i=0;i<threadCount;i++)
-            threads[i]=std::thread(_fsearch_and_dispose_cover_thread,&threadCovers[i],&mt_data);
-        _fsearch_and_dispose_cover_thread(&covers,&mt_data);
-        for (size_t i=0;i<threadCount;i++){
-            threads[i].join();
-            covers.insert(covers.end(),threadCovers[i].begin(),threadCovers[i].end());
-            { std::vector<TOldCover> tmp; tmp.swap(threadCovers[i]); }
-        }
-        tm_collate_covers(covers);
-    }else
-#endif
-    {
-        first_search_and_dispose_cover(covers,diff,sstring,kMinSingleMatchScore,isCanExtendCover);
-    }
+    
+    std::vector<TByte> rle_ctrlBuf;
+    std::vector<TByte> rle_codeBuf;
+    const TByte* newDataSubDiff=diff.newDataSubDiff.data();
+    bytesRLE_save(rle_ctrlBuf,rle_codeBuf,newDataSubDiff,
+                  newDataSubDiff+diff.newDataSubDiff.size(),kRle_bestSize);
+    
+    std::vector<TByte> compress_cover_buf;
+    std::vector<TByte> compress_rle_ctrlBuf;
+    std::vector<TByte> compress_rle_codeBuf;
+    std::vector<TByte> compress_newDataDiff;
+    do_compress(compress_cover_buf,cover_buf,compressPlugin);
+    do_compress(compress_rle_ctrlBuf,rle_ctrlBuf,compressPlugin);
+    do_compress(compress_rle_codeBuf,rle_codeBuf,compressPlugin);
+    do_compress(compress_newDataDiff,diff.newDataDiff,compressPlugin);
+
+    _outType(out_diff,compressPlugin);
+    const TUInt newDataSize=(TUInt)(diff.newData_end-diff.newData);
+    const TUInt oldDataSize=(TUInt)(diff.oldData_end-diff.oldData);
+    packUInt(out_diff, newDataSize);
+    packUInt(out_diff, oldDataSize);
+    packUInt(out_diff, coverCount);
+    packUInt(out_diff, (TUInt)cover_buf.size());
+    packUInt(out_diff, (TUInt)compress_cover_buf.size());
+    packUInt(out_diff, (TUInt)rle_ctrlBuf.size());
+    packUInt(out_diff, (TUInt)compress_rle_ctrlBuf.size());
+    packUInt(out_diff, (TUInt)rle_codeBuf.size());
+    packUInt(out_diff, (TUInt)compress_rle_codeBuf.size());
+    packUInt(out_diff, (TUInt)diff.newDataDiff.size());
+    packUInt(out_diff, (TUInt)compress_newDataDiff.size());
+    
+    pushCompressCode(out_diff,compress_cover_buf,cover_buf);
+    pushCompressCode(out_diff,compress_rle_ctrlBuf,rle_ctrlBuf);
+    pushCompressCode(out_diff,compress_rle_codeBuf,rle_codeBuf);
+    pushCompressCode(out_diff,compress_newDataDiff,diff.newDataDiff);
 }
-
-static const hpatch_StreamPos_t _kNullCoverHitEndPos =hpatch_kNullStreamPos;
-struct TDiffResearchCover:public IDiffResearchCover{
-    TDiffResearchCover(TDiffData& diff_,std::vector<TOldCover>& covers_,const TSuffixString& sstring_,
-                       int kMinSingleMatchScore_,int kMaxMatchDeep_,bool _isCanExtendCover)
-        :diff(diff_), covers(covers_),sstring(sstring_),
-        kMinSingleMatchScore(kMinSingleMatchScore_),kMaxMatchDeep(kMaxMatchDeep_),
-        limitCoverIndex_back(~(size_t)0),limitCoverHitEndPos_back(_kNullCoverHitEndPos),
-        isCanExtendCover(_isCanExtendCover){ researchCover=_researchCover; }
-
-    void _researchRange(TDiffLimit* diffLimit){
-        search_and_dispose_cover(curCovers,diff,sstring,kMinSingleMatchScore,diffLimit,isCanExtendCover);
-        if (curCovers.empty()) return;
-        reCovers.insert(reCovers.end(),curCovers.begin(),curCovers.end());
-        curCovers.clear();
-    }
-
-    inline void endResearchCover(){
-        if (limitCoverHitEndPos_back!=_kNullCoverHitEndPos){
-            TOldCover& cover=covers[limitCoverIndex_back];
-            cover.oldPos+=(TInt)limitCoverHitEndPos_back;
-            cover.newPos+=(TInt)limitCoverHitEndPos_back;
-            cover.length-=(TInt)limitCoverHitEndPos_back;
-            limitCoverHitEndPos_back=_kNullCoverHitEndPos;
-        }
-    }
-    inline void doResearchCover(IDiffSearchCoverListener* listener,size_t limitCoverIndex,
-                                hpatch_StreamPos_t endPosBack,hpatch_StreamPos_t hitPos,hpatch_StreamPos_t hitLen){
-        if (limitCoverIndex_back!=limitCoverIndex)
-            endResearchCover();
-        limitCoverIndex_back=limitCoverIndex;
-        limitCoverHitEndPos_back=hitPos+hitLen;
-        
-        const TOldCover& cover=covers[limitCoverIndex];
-        TOldCover lastCover_back(0,0,0);
-        if (endPosBack<hitPos){
-            lastCover_back.oldPos=cover.oldPos+(TInt)endPosBack;
-            lastCover_back.newPos=cover.newPos+(TInt)endPosBack;
-            lastCover_back.length=(TInt)(hitPos-endPosBack);
-            reCovers.push_back(lastCover_back);
-        }else {
-            assert(endPosBack==hitPos);
-            if (limitCoverIndex>0)
-                lastCover_back=covers[limitCoverIndex-1];
-            if ((!reCovers.empty())&&(reCovers.back().newPos>lastCover_back.newPos))
-                lastCover_back=reCovers.back();
-        }
-
-        TDiffLimit diffLimit={listener,cover.newPos+(size_t)hitPos,cover.newPos+(size_t)(hitPos+hitLen),
-                              cover.oldPos+(size_t)hitPos,cover.oldPos+(size_t)(hitPos+hitLen),   
-                              nocover_detect,cover_detect,lastCover_back,kMaxMatchDeep};
-        _researchRange(&diffLimit);
-    }
-
-    static void _researchCover(struct IDiffResearchCover* diffi,struct IDiffSearchCoverListener* listener,size_t limitCoverIndex,
-                               hpatch_StreamPos_t endPosBack,hpatch_StreamPos_t hitPos,hpatch_StreamPos_t hitLen){
-        TDiffResearchCover* self=(TDiffResearchCover*)diffi;
-        self->doResearchCover(listener,limitCoverIndex,endPosBack,hitPos,hitLen);
-    }
     
-    void researchFinish(){
-        endResearchCover();
-        size_t insert=0;
-        for (size_t i=0;i<covers.size();++i){
-            if (covers[i].length>0)
-                covers[insert++]=covers[i];
-        }
-        covers.resize(insert);
-        covers.insert(covers.end(),reCovers.begin(),reCovers.end());
-        std::inplace_merge(covers.begin(),covers.begin()+insert,
-                           covers.end(),cover_cmp_by_new_t<TOldCover>());
-    }
-
-    TDiffData&              diff;
-    std::vector<TOldCover>& covers;
-    const TSuffixString&    sstring;
-    int                     kMinSingleMatchScore;
-    int                     kMaxMatchDeep;
-    std::vector<TOldCover>  reCovers;
-    std::vector<TOldCover>  curCovers;
-    size_t                  limitCoverIndex_back;
-    hpatch_StreamPos_t      limitCoverHitEndPos_back;
-    const bool              isCanExtendCover;
-    TCompressDetect  nocover_detect;
-    TCompressDetect  cover_detect;
-};
-
-struct TDiffInsertCover:public IDiffInsertCover{
-    inline TDiffInsertCover(std::vector<TOldCover>& _covers)
-    :covers(_covers){
-        insertCover=_insertCover;
-    }
-    static void* _insertCover(IDiffInsertCover* diffi,const void* pInsertCovers,size_t insertCoverCount,bool insertIsCover32){
-        TDiffInsertCover* self=(TDiffInsertCover*)diffi;
-        return self->_insertCover(pInsertCovers,insertCoverCount,insertIsCover32);
-    }
-    void* _insertCover(const void* pInsertCovers,size_t insertCoverCount,bool insertIsCover32){
-        const bool isCover32=sizeof(*covers.data())==sizeof(hpatch_TCover32);
-        if (insertIsCover32==isCover32){
-            covers.insert(covers.end(),(const TOldCover*)pInsertCovers,
-                          ((const TOldCover*)pInsertCovers)+insertCoverCount);
-        }else{
-            size_t oldSize=covers.size();
-            covers.resize(oldSize +insertCoverCount);
-            for (size_t i=0;i<insertCoverCount;i++){
-                if (insertIsCover32){
-                    const hpatch_TCover32& s=((const hpatch_TCover32*)pInsertCovers)[i];
-                    covers[oldSize+i]=TOldCover((TInt)s.oldPos,(TInt)s.newPos,(TInt)s.length);
-                }else{
-                    const hpatch_TCover& s=((const hpatch_TCover*)pInsertCovers)[i];
-                    covers[oldSize+i]=TOldCover((TInt)s.oldPos,(TInt)s.newPos,(TInt)s.length);
-                }
-            }
+    static void search_cover_by_stream(TDiffData& diff,size_t kMatchBlockSize,bool isSkipSameRange){
+        hdiff_TStreamInput oldData;
+        mem_as_hStreamInput(&oldData,diff.oldData,diff.oldData_end);
+        hdiff_TStreamInput newData;
+        mem_as_hStreamInput(&newData,diff.newData,diff.newData_end);
+        TCovers covers(oldData.streamSize,newData.streamSize);
+        getCovers_by_stream(&newData,&oldData,kMatchBlockSize,isSkipSameRange,covers);
+       
+        size_t coverCount=covers.coverCount();
+        diff.covers.resize(coverCount);
+        TOldCover* outCover=diff.covers.data();
+        for (size_t i=0;i<coverCount;++i,++outCover){
+            TCover cover;
+            covers.covers(i,&cover);
+            outCover->oldPos=(TInt)cover.oldPos;
+            outCover->newPos=(TInt)cover.newPos;
+            outCover->length=(TInt)cover.length;
         }
-        return covers.data();
     }
-    std::vector<TOldCover>& covers;
-};
-  
-
-static void get_diff(TDiffData& diff,std::vector<TOldCover>& covers,
-                     int kMinSingleMatchScore,
-                     bool isUseBigCacheMatch,ICoverLinesListener* listener,
-                     const TSuffixString* sstring,size_t threadNum,
-                     bool isCanExtendCover=true){
-    _out_diff_info("  match covers by suffix string ...\n");
-    const bool isCover32=sizeof(*covers.data())==sizeof(hpatch_TCover32);
-    if (!isCover32)
-        assert(sizeof(*covers.data())==sizeof(hpatch_TCover));
-    const hpatch_StreamPos_t maxCoverLen=(listener&&listener->get_limit_cover_length)?
-                                            listener->get_limit_cover_length(listener):kDefaultLimitCoverLen;
-    {
-        TSuffixString _sstring_default(isUseBigCacheMatch);
+    
+static void get_diff(const TByte* newData,const TByte* newData_end,
+                     const TByte* oldData,const TByte* oldData_end,
+                     TDiffData&   out_diff,int kMinSingleMatchScore,
+                     const TSuffixString* sstring=0, bool isDoSubCover=true,
+                     bool _is_search_cover_by_stream=false){
+    assert(newData<=newData_end);
+    assert(oldData<=oldData_end);
+    TDiffData& diff=out_diff;
+    diff.newData=newData;
+    diff.newData_end=newData_end;
+    diff.oldData=oldData;
+    diff.oldData_end=oldData_end;
+    
+    if (_is_search_cover_by_stream){
+        search_cover_by_stream(diff,8,true);
+    }else{
+        TSuffixString _sstring_default(0,0);
         if (sstring==0){
-        _out_diff_info("    create suffix string ...\n");
-            _sstring_default.resetSuffixString(diff.oldData,diff.oldData_end,threadNum);
+            _sstring_default.resetSuffixString(oldData,oldData_end);
             sstring=&_sstring_default;
         }
-
-        _out_diff_info("    search covers by suffix string ...\n");
-        first_search_and_dispose_cover_MT(covers,diff,*sstring,kMinSingleMatchScore,listener,threadNum,isCanExtendCover);
-        _limitCoverLenth(covers,maxCoverLen);
-        assert_covers_safe(covers,diff.newData_end-diff.newData,diff.oldData_end-diff.oldData);
-        if (listener&&listener->search_cover_limit&&
-            listener->search_cover_limit(listener,covers.data(),covers.size(),isCover32)){
-            _out_diff_info("    research covers by limit ...\n");
-            TDiffResearchCover diffResearchCover(diff,covers,*sstring,kMinSingleMatchScore,
-                                    listener->get_max_match_deep?listener->get_max_match_deep(listener):kDefaultMaxMatchDeepForLimit,
-                                    isCanExtendCover);
-            listener->research_cover(listener,&diffResearchCover,covers.data(),covers.size(),isCover32);
-            diffResearchCover.researchFinish();
-            _limitCoverLenth(covers,maxCoverLen);
-            assert_covers_safe(covers,diff.newData_end-diff.newData,diff.oldData_end-diff.oldData);
-        }
+        search_cover(diff,*sstring);
         sstring=0;
         _sstring_default.clear();
     }
-    if (listener&&listener->insert_cover){
-        TDiffInsertCover diffInsertCover(covers);
-        hpatch_StreamPos_t newDataSize=(size_t)(diff.newData_end-diff.newData);
-        hpatch_StreamPos_t oldDataSize=(size_t)(diff.oldData_end-diff.oldData);
-        listener->insert_cover(listener,&diffInsertCover,covers.data(),covers.size(),isCover32,
-                               &newDataSize,&oldDataSize);
-        diff.newData_end=diff.newData+(size_t)newDataSize;
-        diff.oldData_end=diff.oldData+(size_t)oldDataSize;
-        _limitCoverLenth(covers,maxCoverLen);
-        assert_covers_safe(covers,diff.newData_end-diff.newData,diff.oldData_end-diff.oldData);
-    }
-    if (listener&&listener->search_cover_finish){
-        hpatch_StreamPos_t newDataSize=(size_t)(diff.newData_end-diff.newData);
-        hpatch_StreamPos_t oldDataSize=(size_t)(diff.oldData_end-diff.oldData);
-        size_t newCoverCount=covers.size();
-        listener->search_cover_finish(listener,covers.data(),&newCoverCount,isCover32,
-                                      &newDataSize,&oldDataSize);
-        check(newCoverCount<=covers.size());
-        covers.resize(newCoverCount);
-        diff.newData_end=diff.newData+(size_t)newDataSize;
-        diff.oldData_end=diff.oldData+(size_t)oldDataSize;
-        _limitCoverLenth(covers,maxCoverLen);
-        assert_covers_safe(covers,diff.newData_end-diff.newData,diff.oldData_end-diff.oldData);
-    }
+    
+    TFixedFloatSmooth kExtendMinSameRatio=kMinSingleMatchScore*36+254;
+    if  (kExtendMinSameRatio<200) kExtendMinSameRatio=200;
+    if (kExtendMinSameRatio>800) kExtendMinSameRatio=800;
+    
+    extend_cover(diff,kExtendMinSameRatio);//先尝试扩展.
+    select_cover(diff,kMinSingleMatchScore);
+    extend_cover(diff,kExtendMinSameRatio);//select_cover会删除一些覆盖线,所以重新扩展.
+    if (isDoSubCover) sub_cover(diff);
 }
     
 }//end namespace
@@ -949,227 +584,269 @@ static void get_diff(TDiffData& diff,std::vector<TOldCover>& covers,
 void create_diff(const TByte* newData,const TByte* newData_end,
                  const TByte* oldData,const TByte* oldData_end,
                  std::vector<TByte>& out_diff,
-                 int kMinSingleMatchScore,bool isUseBigCacheMatch,size_t threadNum){
-    TDiffData diff(newData,newData_end,oldData,oldData_end);
-    std::vector<TOldCover> covers;
-    get_diff(diff,covers,kMinSingleMatchScore,isUseBigCacheMatch,0,0,threadNum);
-    serialize_diff(diff,covers,out_diff);
+                 int kMinSingleMatchScore){
+    TDiffData diff;
+    get_diff(newData,newData_end,oldData,oldData_end,diff,kMinSingleMatchScore);
+    serialize_diff(diff,out_diff);
 }
 
-void create_compressed_diff(const TByte* newData,const TByte* newData_end,
-                            const TByte* oldData,const TByte* oldData_end,
-                            std::vector<TByte>& out_diff,const hdiff_TCompress* compressPlugin,
-                            int kMinSingleMatchScore,bool isUseBigCacheMatch,
-                            ICoverLinesListener* listener,size_t threadNum){
-    TVectorAsStreamOutput outDiffStream(out_diff);
-    create_compressed_diff(newData,newData_end,oldData,oldData_end,&outDiffStream,
-                           compressPlugin,kMinSingleMatchScore,isUseBigCacheMatch,listener,threadNum);
+bool check_diff(const TByte* newData,const TByte* newData_end,
+                const TByte* oldData,const TByte* oldData_end,
+                const TByte* diff,const TByte* diff_end){
+    TAutoMem updateNewData(newData_end-newData);
+    TByte* updateNew0=updateNewData.data();
+    if (!patch(updateNew0,updateNew0+updateNewData.size(),
+               oldData,oldData_end, diff,diff_end)) return false;
+    return (0==memcmp(updateNew0,newData,updateNewData.size()));
 }
 
-    static void serialize_compressed_diff(const hpatch_TStreamInput*  newData,
-                                          const hpatch_TStreamInput*  oldData,
-                                          bool isZeroSubDiff,const TCovers& covers,
-                                          const hpatch_TStreamOutput* out_diff,
-                                          const hdiff_TCompress* compressPlugin);
 void create_compressed_diff(const TByte* newData,const TByte* newData_end,
                             const TByte* oldData,const TByte* oldData_end,
-                            const hpatch_TStreamOutput* out_diff,const hdiff_TCompress* compressPlugin,
-                            int kMinSingleMatchScore,bool isUseBigCacheMatch,
-                            ICoverLinesListener* listener,size_t threadNum){
-    TDiffData diff(newData,newData_end,oldData,oldData_end);
-    std::vector<TOldCover> covers;
-    get_diff(diff,covers,kMinSingleMatchScore,isUseBigCacheMatch,listener,0,threadNum);
-
-    hpatch_TStreamInput _newStream;  hpatch_TStreamInput* newStream=&_newStream;
-    hpatch_TStreamInput _oldStream;  hpatch_TStreamInput* oldStream=&_oldStream;
-    mem_as_hStreamInput(newStream,diff.newData,diff.newData_end);
-    mem_as_hStreamInput(oldStream,diff.oldData,diff.oldData_end);
-    if (listener&&listener->map_streams_befor_serialize)
-        listener->map_streams_befor_serialize(listener,(const hpatch_TStreamInput **)&newStream,(const hpatch_TStreamInput **)&oldStream);
-    const TCovers _covers((void*)covers.data(),covers.size(),
-                          sizeof(*covers.data())==sizeof(hpatch_TCover32));
-    serialize_compressed_diff(newStream,oldStream,false,_covers,out_diff,compressPlugin);
+                            std::vector<TByte>& out_diff,
+                            const hdiff_TCompress* compressPlugin,int kMinSingleMatchScore){
+    TDiffData diff;
+    get_diff(newData,newData_end,oldData,oldData_end,diff,kMinSingleMatchScore);
+    serialize_compressed_diff(diff,out_diff,compressPlugin);
 }
 
-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){
-    _out_diff_info("  serialize single compressed diffData ...\n");
-    check(patchStepMemSize>=hpatch_kStreamCacheSize);
-    if (patchStepMemSize>newStream->streamSize){
-        patchStepMemSize=(size_t)newStream->streamSize;
-        if (patchStepMemSize<hpatch_kStreamCacheSize)
-            patchStepMemSize=hpatch_kStreamCacheSize;
-    }
-    TStepStream stepStream(newStream,oldStream,isZeroSubDiff,covers,patchStepMemSize);
-    
-    TDiffStream outDiff(out_diff);
-    {//type
-        std::vector<TByte> out_type;
-        _outType(out_type,compressPlugin,kHDiffSFVersionType);
-        outDiff.pushBack(out_type.data(),out_type.size());
-    }
-    outDiff.packUInt(newStream->streamSize);
-    outDiff.packUInt(oldStream->streamSize);
-    outDiff.packUInt(stepStream.getCoverCount());
-    outDiff.packUInt(stepStream.getMaxStepMemSize());
-    outDiff.packUInt(stepStream.streamSize);
-    TPlaceholder compressed_sizePos=outDiff.packUInt_pos(compressPlugin?stepStream.streamSize:0);
-    outDiff.pushStream(&stepStream,compressPlugin,compressed_sizePos);
-}
-
-void create_single_compressed_diff(const TByte* newData,const TByte* newData_end,
-                                   const TByte* oldData,const TByte* oldData_end,
-                                   std::vector<unsigned char>& out_diff,
-                                   const hdiff_TCompress* compressPlugin,int kMinSingleMatchScore,
-                                   size_t patchStepMemSize,bool isUseBigCacheMatch,
-                                   ICoverLinesListener* listener,size_t threadNum){
-    TVectorAsStreamOutput outDiffStream(out_diff);
-    create_single_compressed_diff(newData,newData_end,oldData,oldData_end,&outDiffStream,
-                                  compressPlugin,kMinSingleMatchScore,patchStepMemSize,
-                                  isUseBigCacheMatch,listener,threadNum);
+bool check_compressed_diff(const TByte* newData,const TByte* newData_end,
+                           const TByte* oldData,const TByte* oldData_end,
+                           const TByte* diff,const TByte* diff_end,
+                           hpatch_TDecompress* decompressPlugin){
+    TAutoMem updateNewData(newData_end-newData);
+    TByte* updateNew0=updateNewData.data();
+    if (!patch_decompress_mem(updateNew0,updateNew0+updateNewData.size(),
+                              oldData,oldData_end, diff,diff_end, decompressPlugin)) return false;
+    return (0==memcmp(updateNew0,newData,updateNewData.size()));
 }
 
-void create_single_compressed_diff(const TByte* newData,const TByte* newData_end,
-                                   const TByte* oldData,const TByte* oldData_end,
-                                   const hpatch_TStreamOutput* out_diff,
-                                   const hdiff_TCompress* compressPlugin,int kMinSingleMatchScore,
-                                   size_t patchStepMemSize,bool isUseBigCacheMatch,
-                                   ICoverLinesListener* listener,size_t threadNum){
-    TDiffData diff(newData,newData_end,oldData,oldData_end);
-    std::vector<TOldCover> covers;
-    get_diff(diff,covers,kMinSingleMatchScore,isUseBigCacheMatch,listener,0,threadNum);
-
-    hpatch_TStreamInput _newStream;  hpatch_TStreamInput* newStream=&_newStream;
-    hpatch_TStreamInput _oldStream;  hpatch_TStreamInput* oldStream=&_oldStream;
-    mem_as_hStreamInput(newStream,diff.newData,diff.newData_end);
-    mem_as_hStreamInput(oldStream,diff.oldData,diff.oldData_end);
-    if (listener&&listener->map_streams_befor_serialize)
-        listener->map_streams_befor_serialize(listener,(const hpatch_TStreamInput **)&newStream,(const hpatch_TStreamInput **)&oldStream);
-    const TCovers _covers((void*)covers.data(),covers.size(),
-                          sizeof(*covers.data())==sizeof(hpatch_TCover32));
-    serialize_single_compressed_diff(newStream,oldStream,false,_covers,
-                                     out_diff,compressPlugin,patchStepMemSize);
-}
 
-void create_single_compressed_diff_stream(const hpatch_TStreamInput*  newData,
-                                          const hpatch_TStreamInput*  oldData,
-                                          const hpatch_TStreamOutput* out_diff,
-                                          const hdiff_TCompress* compressPlugin,
-                                          size_t kMatchBlockSize,size_t patchStepMemSize,
-                                          const hdiff_TMTSets_s* mtsets){
-    TCoversBuf covers(newData->streamSize,oldData->streamSize);
-    get_match_covers_by_block(newData,oldData,&covers,kMatchBlockSize,mtsets);
-    serialize_single_compressed_diff(newData,oldData,true,covers,
-                                     out_diff,compressPlugin,patchStepMemSize);
+static void _flush_step_code(std::vector<TByte> &buf, std::vector<TByte> &step_bufCover, std::vector<TByte> &step_bufData,
+                             hdiff_private::TSangileStreamRLE0 &step_bufRle,size_t& curMaxStepMemSize) {
+    step_bufRle.finishAppend();
+    packUInt(buf,step_bufCover.size()); //general saved data
+    packUInt(buf,step_bufRle.curCodeSize());
+    size_t bufSize_back=buf.size();
+    pushBack(buf,step_bufCover);            step_bufCover.clear();
+    pushBack(buf,step_bufRle.fixed_code);   step_bufRle.clear();
+    size_t curStepMemSize=buf.size()-bufSize_back;
+    pushBack(buf,step_bufData);             step_bufData.clear();
+    if (curMaxStepMemSize<curStepMemSize)
+        curMaxStepMemSize=curStepMemSize;
 }
 
+static void serialize_single_compressed_diff(TDiffData& diff,std::vector<TByte>& out_diff,
+                                             const hdiff_TCompress* compressPlugin,size_t patchStepMemSize){
+    check(patchStepMemSize>=hpatch_kStreamCacheSize);
+    std::vector<TOldCover>& covers=diff.covers;
+    const TUInt newDataSize=(TUInt)(diff.newData_end-diff.newData);
+    const TUInt oldDataSize=(TUInt)(diff.oldData_end-diff.oldData);
+    if (covers.empty()){
+        covers.push_back(TOldCover(0,newDataSize,0));
+    }else{
+        const TOldCover& back=covers[covers.size()-1];
+        if ((TUInt)back.newPos+(TUInt)back.length<newDataSize){
+            covers.push_back(TOldCover(back.oldPos+back.length,newDataSize,0));
+        }
+    }
+    size_t curMaxStepMemSize=0;
+    std::vector<TByte> buf;
+    {
+        TInt lastOldEnd=0;
+        TInt lastNewEnd=0;
+        TUInt curNewDiff=0;
+        std::vector<TByte> step_bufCover;
+        TSangileStreamRLE0 step_bufRle;
+        std::vector<TByte> step_bufData;
+        TUInt i=0;
+        while ( i<covers.size()) {
+            const size_t step_bufCover_backSize=step_bufCover.size();
+            
+            const TOldCover& cover=covers[i];
+            const TByte* subDiff=diff.newDataSubDiff.data()+cover.newPos;
+            if (cover.oldPos>=lastOldEnd){ //save inc_oldPos
+                packUIntWithTag(step_bufCover,(TUInt)(cover.oldPos-lastOldEnd), 0, 1);
+            }else{
+                packUIntWithTag(step_bufCover,(TUInt)(lastOldEnd-cover.oldPos), 1, 1);//sub safe
+            }
+            TInt backNewLen=cover.newPos-lastNewEnd;
+            assert(backNewLen>=0);
+            packUInt(step_bufCover,(TUInt)backNewLen); //save inc_newPos
+            packUInt(step_bufCover,cover.length);
+            
+            const TUInt curMaxNeedSize = step_bufCover.size() + step_bufRle.maxCodeSize(subDiff,subDiff+cover.length);
+            if (curMaxNeedSize<=patchStepMemSize){ //append
+                step_bufRle.append(subDiff,subDiff+cover.length);
+                if (backNewLen>0){
+                    const TByte* newDataDiff=diff.newDataDiff.data()+curNewDiff;
+                    pushBack(step_bufData,newDataDiff,newDataDiff+backNewLen);
+                    curNewDiff+=backNewLen;
+                }
 
-bool check_diff(const TByte* newData,const TByte* newData_end,
-                const TByte* oldData,const TByte* oldData_end,
-                const TByte* diff,const TByte* diff_end){
-    hpatch_TStreamInput  newStream;
-    hpatch_TStreamInput  oldStream;
-    hpatch_TStreamInput  diffStream;
-    mem_as_hStreamInput(&newStream,newData,newData_end);
-    mem_as_hStreamInput(&oldStream,oldData,oldData_end);
-    mem_as_hStreamInput(&diffStream,diff,diff_end);
-    return check_diff(&newStream,&oldStream,&diffStream);
+                //next i
+                lastOldEnd=cover.oldPos+cover.length;//! +length
+                lastNewEnd=cover.newPos+cover.length;
+                ++i;
+            }else{
+                if (step_bufCover_backSize+step_bufRle.curCodeSize()>=(patchStepMemSize/2)){//flush step
+                    step_bufCover.resize(step_bufCover_backSize);
+                    _flush_step_code(buf,step_bufCover,step_bufData,step_bufRle,curMaxStepMemSize);
+                    continue;  // old i!
+                }else{ //clip one cover to two cover
+                    TOldCover& cover_l=covers[i];
+                    TUInt clen=cover_l.length;
+                    while (1) {
+                        clen=clen*3/4;
+                        check(clen>0); // stepMemSize error
+                        const TUInt _curMaxNeedSize = step_bufCover.size() + step_bufRle.maxCodeSize(subDiff,subDiff+clen);
+                        if (_curMaxNeedSize<=patchStepMemSize)
+                            break;
+                    }
+                    TOldCover cover_r=cover_l;
+                    cover_l.length=clen;
+                    cover_r.length-=clen;
+                    cover_r.oldPos+=clen;
+                    cover_r.newPos+=clen;
+                    covers.insert(covers.begin()+(i+1),cover_r);
+                    
+                    step_bufCover.resize(step_bufCover_backSize);
+                    continue;  // old i!
+                }
+            }
+        }
+        check(diff.newDataDiff.size()==curNewDiff);
+        if (!step_bufCover.empty())
+            _flush_step_code(buf,step_bufCover,step_bufData,step_bufRle,curMaxStepMemSize);
+    }
+    assert(curMaxStepMemSize<=patchStepMemSize);
+    
+    std::vector<TByte> compress_buf;
+    do_compress(compress_buf,buf,compressPlugin);
+    
+    _outType(out_diff,compress_buf.empty()?0:compressPlugin,kHDiffSFVersionType);
+    packUInt(out_diff, newDataSize);
+    packUInt(out_diff, oldDataSize);
+    packUInt(out_diff, covers.size());
+    packUInt(out_diff, curMaxStepMemSize);
+    packUInt(out_diff, (TUInt)buf.size());
+    packUInt(out_diff, (TUInt)compress_buf.size());
+    
+    pushCompressCode(out_diff,compress_buf,buf);
 }
 
-bool check_diff(const hpatch_TStreamInput*  newData,
-                const hpatch_TStreamInput*  oldData,
-                const hpatch_TStreamInput*  diff){
-    const size_t kACacheBufSize=hdiff_kFileIOBufBestSize;
-    TAutoMem _cache(kACacheBufSize*(1+16));
-    _TCheckOutNewDataStream out_newData(newData,_cache.data(),kACacheBufSize);
-    _test_rt(patch_stream_with_cache(&out_newData,oldData,diff,
-                                     _cache.data()+kACacheBufSize,_cache.data_end()));
-    _test_rt(out_newData.isWriteFinish());
-    return true;
+void create_single_compressed_diff(const TByte* newData,const TByte* newData_end,
+                                   const TByte* oldData,const TByte* oldData_end,
+                                   std::vector<unsigned char>& out_diff,ICoverLinesListener* listener,const hdiff_TCompress* compressPlugin,
+                                   int kMinSingleMatchScore,size_t patchStepMemSize,bool _is_search_cover_by_stream){
+    TDiffData diff;
+    get_diff(newData,newData_end,oldData,oldData_end,diff,kMinSingleMatchScore,0,false,_is_search_cover_by_stream);
+    if (listener){
+        std::vector<hpatch_TCover> _covers(diff.covers.size());
+        for (size_t i=0; i<diff.covers.size(); ++i) {
+            _covers[i].oldPos=diff.covers[i].oldPos;
+            _covers[i].newPos=diff.covers[i].newPos;
+            _covers[i].length=diff.covers[i].length;
+        }
+        hpatch_StreamPos_t newDataSize=(size_t)(diff.newData_end-diff.newData);
+        hpatch_StreamPos_t oldDataSize=(size_t)(diff.oldData_end-diff.oldData);
+        size_t coverCount=_covers.size();
+        listener->coverLines(listener,_covers.data(),&coverCount,&newDataSize,&oldDataSize);
+        assert(coverCount<=_covers.size());
+        diff.covers.resize(coverCount);
+        diff.newData_end=diff.newData+newDataSize;
+        diff.oldData_end=diff.oldData+oldDataSize;
+        for (size_t i=0; i<diff.covers.size(); ++i){
+            diff.covers[i].oldPos=(TInt)_covers[i].oldPos;
+            diff.covers[i].newPos=(TInt)_covers[i].newPos;
+            diff.covers[i].length=(TInt)_covers[i].length;
+        }
+    }
+    sub_cover(diff);
+    serialize_single_compressed_diff(diff,out_diff,compressPlugin,patchStepMemSize);
 }
 
-bool check_compressed_diff(const TByte* newData,const TByte* newData_end,
-                           const TByte* oldData,const TByte* oldData_end,
-                           const TByte* diff,const TByte* diff_end,
-                           hpatch_TDecompress* decompressPlugin){
-    hpatch_TStreamInput  newStream;
-    hpatch_TStreamInput  oldStream;
-    hpatch_TStreamInput  diffStream;
-    mem_as_hStreamInput(&newStream,newData,newData_end);
-    mem_as_hStreamInput(&oldStream,oldData,oldData_end);
-    mem_as_hStreamInput(&diffStream,diff,diff_end);
-    return check_compressed_diff(&newStream,&oldStream,&diffStream,decompressPlugin);
+static hpatch_BOOL _check_single_onDiffInfo(struct sspatch_listener_t* listener,
+                                            const hpatch_singleCompressedDiffInfo* info,
+                                            hpatch_TDecompress** out_decompressPlugin,
+                                            unsigned char** out_temp_cache,
+                                            unsigned char** out_temp_cacheEnd){
+    size_t memSize=(size_t)(info->stepMemSize+hpatch_kStreamCacheSize*3);
+    *out_temp_cache=(unsigned char*)malloc(memSize);
+    *out_temp_cacheEnd=(*out_temp_cache)+memSize;   
+    *out_decompressPlugin=(hpatch_TDecompress*)listener->import;
+    return hpatch_TRUE;
 }
-
-bool check_compressed_diff(const hpatch_TStreamInput*  newData,
-                           const hpatch_TStreamInput*  oldData,
-                           const hpatch_TStreamInput*  compressed_diff,
-                           hpatch_TDecompress* decompressPlugin){
-    const size_t kACacheBufSize=hdiff_kFileIOBufBestSize;
-    TAutoMem _cache(kACacheBufSize*(1+16));
-    _TCheckOutNewDataStream out_newData(newData,_cache.data(),kACacheBufSize);
-    _test_rt(patch_decompress_with_cache(&out_newData,oldData,compressed_diff,decompressPlugin,
-                                         _cache.data()+kACacheBufSize,_cache.data_end()));
-    _test_rt(out_newData.isWriteFinish());
-    return true;
+static void _check_single_onPatchFinish(struct sspatch_listener_t* listener,
+                                        unsigned char* temp_cache, unsigned char* temp_cacheEnd){
+    if (temp_cache) free(temp_cache);
 }
 
 bool check_single_compressed_diff(const TByte* newData,const TByte* newData_end,
                                   const TByte* oldData,const TByte* oldData_end,
                                   const TByte* diff,const TByte* diff_end,
-                                  hpatch_TDecompress* decompressPlugin,size_t threadNum){
-    hpatch_TStreamInput  newStream;
-    hpatch_TStreamInput  oldStream;
-    hpatch_TStreamInput  diffStream;
-    mem_as_hStreamInput(&newStream,newData,newData_end);
-    mem_as_hStreamInput(&oldStream,oldData,oldData_end);
-    mem_as_hStreamInput(&diffStream,diff,diff_end);
-    return check_single_compressed_diff(&newStream,&oldStream,&diffStream,decompressPlugin,threadNum);
-}
-
-bool check_single_compressed_diff(const hpatch_TStreamInput* newData,
-                                  const TByte* oldData,const TByte* oldData_end,
-                                  const hpatch_TStreamInput* diff,
-                                  hpatch_TDecompress* decompressPlugin,size_t threadNum){ 
-    hpatch_TStreamInput  oldStream;
-    mem_as_hStreamInput(&oldStream,oldData,oldData_end);
-    return check_single_compressed_diff(newData,&oldStream,diff,decompressPlugin,threadNum);
-}
-
-    static hpatch_BOOL _check_single_onDiffInfo(struct sspatch_listener_t* listener,
-                                                const hpatch_singleCompressedDiffInfo* info,
-                                                hpatch_TDecompress** out_decompressPlugin,
-                                                unsigned char** out_temp_cache,
-                                                unsigned char** out_temp_cacheEnd){
-        size_t memSize=(size_t)(info->stepMemSize+hdiff_kFileIOBufBestSize*(1+16));
-        *out_temp_cache=(unsigned char*)malloc(memSize);
-        *out_temp_cacheEnd=(*out_temp_cache)+memSize;   
-        *out_decompressPlugin=(info->compressType[0]=='\0')?0:(hpatch_TDecompress*)listener->import;
-        return hpatch_TRUE;
-    }
-    static void _check_single_onPatchFinish(struct sspatch_listener_t* listener,
-                                            unsigned char* temp_cache, unsigned char* temp_cacheEnd){
-        if (temp_cache) free(temp_cache);
-    }
-bool check_single_compressed_diff(const hpatch_TStreamInput* newData,
-                                  const hpatch_TStreamInput* oldData,
-                                  const hpatch_TStreamInput* diff,
-                                  hpatch_TDecompress* decompressPlugin,size_t threadNum){
+                                  hpatch_TDecompress* decompressPlugin){
     sspatch_listener_t listener={0};
     listener.import=decompressPlugin;
     listener.onDiffInfo=_check_single_onDiffInfo;
     listener.onPatchFinish=_check_single_onPatchFinish;
-        
-    const size_t kACacheBufSize=hdiff_kFileIOBufBestSize;
-    TAutoMem _cache(kACacheBufSize*(1+16));
-    _TCheckOutNewDataStream out_newData(newData,_cache.data(),kACacheBufSize);
+    TAutoMem updateNewData(newData_end-newData);
+    TByte* updateNew0=updateNewData.data();
+    if (!patch_single_stream_by_mem(&listener,updateNew0,updateNew0+updateNewData.size(),
+                                    oldData,oldData_end,diff,diff_end)) return false;
+    return (0==memcmp(updateNew0,newData,updateNewData.size()));
+}
+
+
+#define _test(value) { if (!(value)) { fprintf(stderr,"patch check "#value" error!\n");  return hpatch_FALSE; } }
+
+bool check_compressed_diff_stream(const hpatch_TStreamInput*  newData,
+                                  const hpatch_TStreamInput*  oldData,
+                                  const hpatch_TStreamInput*  compressed_diff,
+                                  hpatch_TDecompress* decompressPlugin){
 
-    _test_rt(patch_single_stream(&listener,&out_newData,oldData,diff,0,0,threadNum));
-    _test_rt(out_newData.isWriteFinish());
+    struct _TCheckOutNewDataStream:public hpatch_TStreamOutput{
+        explicit _TCheckOutNewDataStream(const hpatch_TStreamInput*  _newData,
+                                         TByte* _buf,size_t _bufSize)
+        :newData(_newData),writedLen(0),buf(_buf),bufSize(_bufSize){
+            streamImport=this;
+            streamSize=newData->streamSize;
+            read_writed=0;
+            write=_write_check;
+        }
+        static hpatch_BOOL _write_check(const hpatch_TStreamOutput* stream,hpatch_StreamPos_t writeToPos,
+                                        const TByte* data,const TByte* data_end){
+            _TCheckOutNewDataStream* self=(_TCheckOutNewDataStream*)stream->streamImport;
+            _test(self->writedLen==writeToPos);
+            self->writedLen+=(size_t)(data_end-data);
+            _test(self->writedLen<=self->streamSize);
+            
+            hpatch_StreamPos_t readPos=writeToPos;
+            while (data<data_end) {
+                size_t readLen=(size_t)(data_end-data);
+                if (readLen>self->bufSize) readLen=self->bufSize;
+                _test(self->newData->read(self->newData,readPos,self->buf,self->buf+readLen));
+                _test(0==memcmp(data,self->buf,readLen));
+                data+=readLen;
+                readPos+=readLen;
+            }
+            return hpatch_TRUE;
+        }
+        bool isWriteFinish()const{ return writedLen==newData->streamSize; }
+        const hpatch_TStreamInput*  newData;
+        hpatch_StreamPos_t          writedLen;
+        TByte*                      buf;
+        size_t                      bufSize;
+    };
+    
+    const size_t kACacheBufSize=hpatch_kFileIOBufBetterSize;
+    TAutoMem _cache(kACacheBufSize*8);
+    _TCheckOutNewDataStream out_newData(newData,_cache.data(),kACacheBufSize);
+    _test(patch_decompress_with_cache(&out_newData,oldData,compressed_diff,decompressPlugin,
+                                             _cache.data()+kACacheBufSize,_cache.data_end()));
+    _test(out_newData.isWriteFinish());
     return true;
 }
-
+#undef _test
 
 //for test
 void __hdiff_private__create_compressed_diff(const TByte* newData,const TByte* newData_end,
@@ -1177,87 +854,49 @@ void __hdiff_private__create_compressed_diff(const TByte* newData,const TByte* n
                                              std::vector<TByte>& out_diff,
                                              const hdiff_TCompress* compressPlugin,int kMinSingleMatchScore,
                                              const TSuffixString* sstring){
-    TDiffData diff(newData,newData_end,oldData,oldData_end);
-    std::vector<TOldCover> covers;
-    get_diff(diff,covers,kMinSingleMatchScore,false,0,sstring,1);
-    TVectorAsStreamOutput outDiffStream(out_diff);
-
-    hpatch_TStreamInput _newStream;  hpatch_TStreamInput* newStream=&_newStream;
-    hpatch_TStreamInput _oldStream;  hpatch_TStreamInput* oldStream=&_oldStream;
-    mem_as_hStreamInput(newStream,diff.newData,diff.newData_end);
-    mem_as_hStreamInput(oldStream,diff.oldData,diff.oldData_end);
-    const TCovers _covers((void*)covers.data(),covers.size(),
-                          sizeof(*covers.data())==sizeof(hpatch_TCover32));
-    serialize_compressed_diff(newStream,oldStream,false,_covers,&outDiffStream,compressPlugin);
+    TDiffData diff;
+    get_diff(newData,newData_end,oldData,oldData_end,diff,kMinSingleMatchScore,sstring);
+    serialize_compressed_diff(diff,out_diff,compressPlugin);
 }
 
 
 //======================
+#include "private_diff/limit_mem_diff/digest_matcher.h"
+#include "private_diff/limit_mem_diff/stream_serialize.h"
 
-void get_match_covers_by_block(const hpatch_TStreamInput* newData,const hpatch_TStreamInput* oldData,
-                               hpatch_TOutputCovers* out_covers,size_t kMatchBlockSize,const hdiff_TMTSets_s* mtsets){
-    assert(out_covers->push_cover!=0);
-    TDigestMatcher matcher(oldData,newData,kMatchBlockSize,mtsets?*mtsets:hdiff_TMTSets_s_kEmpty);
-    matcher.search_cover(out_covers);
-}
-void get_match_covers_by_block(const unsigned char* newData,const unsigned char* newData_end,
-                               const unsigned char* oldData,const unsigned char* oldData_end,
-                               hpatch_TOutputCovers* out_covers,size_t kMatchBlockSize,size_t threadNum){
-    hdiff_TStreamInput oldData_stream;
-    mem_as_hStreamInput(&oldData_stream,oldData,oldData_end);
-    hdiff_TStreamInput newData_stream;
-    mem_as_hStreamInput(&newData_stream,newData,newData_end);
-    hdiff_TMTSets_s mtsets={threadNum,threadNum,true,true};
-    get_match_covers_by_block(&newData_stream,&oldData_stream,out_covers,kMatchBlockSize,&mtsets);
-}
-
-void get_match_covers_by_sstring(const unsigned char* newData,const unsigned char* newData_end,
-                                 const unsigned char* oldData,const unsigned char* oldData_end,
-                                 std::vector<hpatch_TCover_sz>& out_covers,int kMinSingleMatchScore,
-                                 bool isUseBigCacheMatch,ICoverLinesListener* listener,
-                                 size_t threadNum,bool isCanExtendCover){
-    TDiffData diff(newData,newData_end,oldData,oldData_end);
-    std::vector<TOldCover> covers;
-    assert(sizeof(TOldCover)==sizeof(hpatch_TCover_sz));
-    { std::vector<hpatch_TCover_sz> tmp; tmp.swap(out_covers); }
-    get_diff(diff,covers,kMinSingleMatchScore,isUseBigCacheMatch,listener,0,threadNum,isCanExtendCover);
-    void* pcovers=&covers;
-    out_covers.swap(*(std::vector<hpatch_TCover_sz>*)pcovers);
-}
-void get_match_covers_by_sstring(const unsigned char* newData,const unsigned char* newData_end,
-                                 const unsigned char* oldData,const unsigned char* oldData_end,
-                                 hpatch_TOutputCovers* out_covers,int kMinSingleMatchScore,
-                                 bool isUseBigCacheMatch,ICoverLinesListener* listener,
-                                 size_t threadNum,bool isCanExtendCover){
-    std::vector<hpatch_TCover_sz> covers;
-    get_match_covers_by_sstring(newData,newData_end,oldData,oldData_end,covers,
-                                kMinSingleMatchScore,isUseBigCacheMatch,listener,threadNum,isCanExtendCover);
-    const hpatch_TCover_sz* pcovers=covers.data();
-    for (size_t i=0;i<covers.size();++i,++pcovers){
-        if (sizeof(*pcovers)==sizeof(hpatch_TCover)){
-            out_covers->push_cover(out_covers,(const hpatch_TCover*)pcovers);
-        }else{
-            hpatch_TCover cover; 
-            cover.oldPos=pcovers->oldPos;
-            cover.newPos=pcovers->newPos;
-            cover.length=pcovers->length;
-            out_covers->push_cover(out_covers,&cover);
+static void getCovers_by_stream(const hpatch_TStreamInput*  newData,
+                                const hpatch_TStreamInput*  oldData,
+                                size_t kMatchBlockSize,bool kIsSkipSameRange,
+                                TCovers& out_covers){
+    {
+        TDigestMatcher matcher(oldData,kMatchBlockSize,kIsSkipSameRange);
+        matcher.search_cover(newData,&out_covers);
+    }
+    {//check cover
+        TCover cover;
+        hpatch_StreamPos_t lastNewEnd=0;
+        size_t coverCount=out_covers.coverCount();
+        for (size_t i=0;i<coverCount;++i){
+            out_covers.covers(i,&cover);
+            assert_cover_safe(cover,lastNewEnd,newData->streamSize,oldData->streamSize);
+            lastNewEnd=cover.newPos+cover.length;
         }
     }
+    //todo: + extend_cover_stream ?
 }
 
-
-static void serialize_compressed_diff(const hpatch_TStreamInput*  newData,
-                                      const hpatch_TStreamInput*  oldData,
-                                      bool isZeroSubDiff,const TCovers& covers,
-                                      const hpatch_TStreamOutput* out_diff,
-                                      const hdiff_TCompress* compressPlugin){
-    _out_diff_info("  serialize compressed diffData ...\n");
+static void stream_serialize(const hpatch_TStreamInput*  newData,
+                             hpatch_StreamPos_t          oldDataSize,
+                             const hpatch_TStreamOutput* out_diff,
+                             const hdiff_TCompress* compressPlugin,
+                             const TCovers& covers){
+    
     std::vector<TByte> rle_ctrlBuf;
     std::vector<TByte> rle_codeBuf;
-    {//now rle datas used buf, not used stream
-        TNewDataSubDiffStream subStream(newData,oldData,covers,false,isZeroSubDiff);
-        bytesRLE_save(rle_ctrlBuf,rle_codeBuf,&subStream,kRle_bestSize);
+    {//empty rle //todo: suport rle data
+        if (newData->streamSize>0)
+          packUIntWithTag(rle_ctrlBuf,newData->streamSize-1,kByteRleType_rle0,kByteRleType_bit);
+        assert(rle_codeBuf.empty());
     }
     
     TDiffStream outDiff(out_diff);
@@ -1267,18 +906,16 @@ static void serialize_compressed_diff(const hpatch_TStreamInput*  newData,
         outDiff.pushBack(out_type.data(),out_type.size());
     }
     outDiff.packUInt(newData->streamSize);
-    outDiff.packUInt(oldData->streamSize);
+    outDiff.packUInt(oldDataSize);
     outDiff.packUInt(covers.coverCount());
     const hpatch_StreamPos_t cover_buf_size=TCoversStream::getDataSize(covers);
     outDiff.packUInt(cover_buf_size);
     TPlaceholder compress_cover_buf_sizePos=
         outDiff.packUInt_pos(compressPlugin?cover_buf_size:0); //compress_cover_buf size
     outDiff.packUInt(rle_ctrlBuf.size());//rle_ctrlBuf size
-    TPlaceholder compress_rle_ctrlBuf_sizePos=
-        outDiff.packUInt_pos(compressPlugin?rle_ctrlBuf.size():0); //compress_rle_ctrlBuf size
+    outDiff.packUInt(0);//compress_rle_ctrlBuf size
     outDiff.packUInt(rle_codeBuf.size());//rle_codeBuf size
-    TPlaceholder compress_rle_codeBuf_sizePos=
-        outDiff.packUInt_pos(compressPlugin?rle_codeBuf.size():0); //compress_rle_codeBuf size
+    outDiff.packUInt(0);//compress_rle_codeBuf size
     const hpatch_StreamPos_t newDataDiff_size=
                                 TNewDataDiffStream::getDataSize(covers,newData->streamSize);
     outDiff.packUInt(newDataDiff_size);
@@ -1289,11 +926,9 @@ static void serialize_compressed_diff(const hpatch_TStreamInput*  newData,
         TCoversStream cover_buf(covers,cover_buf_size);
         outDiff.pushStream(&cover_buf,compressPlugin,compress_cover_buf_sizePos);
     }
-    {//save rle
-        TVectorAsStreamInput rle_ctrlStream(rle_ctrlBuf);
-        TVectorAsStreamInput rle_codeStream(rle_codeBuf);
-        outDiff.pushStream(&rle_ctrlStream,compressPlugin,compress_rle_ctrlBuf_sizePos);
-        outDiff.pushStream(&rle_codeStream,compressPlugin,compress_rle_codeBuf_sizePos);
+    {//rle
+        outDiff.pushBack(rle_ctrlBuf.data(),rle_ctrlBuf.size());
+        outDiff.pushBack(rle_codeBuf.data(),rle_codeBuf.size());
     }
     {//save newDataDiff
         TNewDataDiffStream newDataDiff(covers,newData,newDataDiff_size);
@@ -1304,19 +939,18 @@ static void serialize_compressed_diff(const hpatch_TStreamInput*  newData,
 void create_compressed_diff_stream(const hpatch_TStreamInput*  newData,
                                    const hpatch_TStreamInput*  oldData,
                                    const hpatch_TStreamOutput* out_diff,
-                                   const hdiff_TCompress* compressPlugin,
-                                   size_t kMatchBlockSize,const hdiff_TMTSets_s* mtsets){
-    TCoversBuf covers(newData->streamSize,oldData->streamSize);
-    get_match_covers_by_block(newData,oldData,&covers,kMatchBlockSize,mtsets);
-    serialize_compressed_diff(newData,oldData,true,covers,out_diff,compressPlugin);
+                                   const hdiff_TCompress* compressPlugin,size_t kMatchBlockSize){
+    const bool isSkipSameRange=(compressPlugin!=0);
+    TCovers covers(oldData->streamSize,newData->streamSize);
+    getCovers_by_stream(newData,oldData,kMatchBlockSize,isSkipSameRange,covers);
+    stream_serialize(newData,oldData->streamSize,out_diff,compressPlugin,covers);
 }
 
 
 void resave_compressed_diff(const hpatch_TStreamInput*  in_diff,
                             hpatch_TDecompress*         decompressPlugin,
                             const hpatch_TStreamOutput* out_diff,
-                            const hdiff_TCompress*      compressPlugin,
-                            hpatch_StreamPos_t          out_diff_curPos){
+                            const hdiff_TCompress*      compressPlugin){
     _THDiffzHead              head;
     hpatch_compressedDiffInfo diffInfo;
     assert(in_diff!=0);
@@ -1335,7 +969,7 @@ void resave_compressed_diff(const hpatch_TStreamInput*  in_diff,
         }
     }
     
-    TDiffStream outDiff(out_diff,out_diff_curPos);
+    TDiffStream outDiff(out_diff);
     {//type
         std::vector<TByte> out_type;
         _outType(out_type,compressPlugin);
@@ -1389,358 +1023,3 @@ void resave_compressed_diff(const hpatch_TStreamInput*  in_diff,
         diffPos0+=bufSize;
     }
 }
-
-
-hpatch_StreamPos_t
-     resave_single_compressed_diff(const hpatch_TStreamInput*  in_diff,
-                                   hpatch_TDecompress*         decompressPlugin,
-                                   const hpatch_TStreamOutput* out_diff,
-                                   const hdiff_TCompress*      compressPlugin,
-                                   const hpatch_singleCompressedDiffInfo* diffInfo,
-                                   hpatch_StreamPos_t          in_diff_curPos,
-                                   hpatch_StreamPos_t          out_diff_curPos){
-    hpatch_singleCompressedDiffInfo _diffInfo;
-    if (diffInfo==0){
-        checki(getSingleCompressedDiffInfo(&_diffInfo,in_diff,in_diff_curPos),
-               "getSingleCompressedDiffInfo() return fail!");
-        diffInfo=&_diffInfo;
-    }
-    const bool isCompressed=(diffInfo->compressedSize>0);
-    if (isCompressed){ //check
-        checki(diffInfo->compressedSize+(in_diff_curPos+diffInfo->diffDataPos)==in_diff->streamSize,
-               "resave_single_compressed_diff() diffInfo error!");
-        checki((decompressPlugin!=0)&&(decompressPlugin->is_can_open(diffInfo->compressType)),
-               "resave_single_compressed_diff() decompressPlugin error!");
-    }
-
-    TDiffStream outDiff(out_diff,out_diff_curPos);
-    {//type & head
-        std::vector<TByte> outBuf;
-        _outType(outBuf, compressPlugin,kHDiffSFVersionType);
-        packUInt(outBuf, diffInfo->newDataSize);
-        packUInt(outBuf, diffInfo->oldDataSize);
-        packUInt(outBuf, diffInfo->coverCount);
-        packUInt(outBuf, diffInfo->stepMemSize);
-        packUInt(outBuf, diffInfo->uncompressedSize);
-        outDiff.pushBack(outBuf.data(),outBuf.size());
-        //no compressedSize
-    }
-    {//save single stream data
-        TStreamClip clip(in_diff,diffInfo->diffDataPos+in_diff_curPos,in_diff->streamSize,
-                         isCompressed?decompressPlugin:0,diffInfo->uncompressedSize);
-        TPlaceholder compressedSize_pos=outDiff.packUInt_pos(compressPlugin?diffInfo->uncompressedSize:0);
-        outDiff.pushStream(&clip,compressPlugin,compressedSize_pos);
-    }
-    return outDiff.getWritedPos();
-}
-
-
-//----------------------------------------------------------------------------------------------------
-
-#include "diff_for_hpatch_lite.h"
-#include "../HPatchLite/hpatch_lite.h"
-
-namespace{
-    static const char*      kHPatchLite_versionType="hI";
-    static const hpi_byte   kHPatchLite_versionCode=1;
-    static const hpi_byte   kHPatchLite_inplaceCode=2; //for inplace-patch, just adding extraSafeSize
-
-    static inline void hpi_packUInt(std::vector<TByte>& buf,TUInt v){
-        check(v==(hpi_pos_t)v);
-        packUInt(buf,v);
-    }
-    static inline void hpi_packUIntWithTag(std::vector<TByte>& buf,TUInt v,TByte tag,TByte bit){
-        check(v==(hpi_pos_t)v);
-        packUIntWithTag(buf,v,tag,bit);
-    }
-    
-    static inline TByte hpi_getSavedSizeBytes(TUInt size){
-        check(size==(hpi_pos_t)size);
-        TByte bytes=0; 
-        while (size>0){
-            ++bytes;
-            size>>=8;
-        }
-        return bytes;
-    }
-    static inline void hpi_saveSize(std::vector<TByte>& buf,TUInt size){
-        check(size==(hpi_pos_t)size);
-        while (size>0){
-            buf.push_back((TByte)size);
-            size>>=8;
-        }
-    }
-    
-    static bool _getIs0(const TByte* data,size_t length){
-        for (size_t i=0; i<length; ++i) {
-            if (data[i]==0)
-                continue;
-            else
-                return false;
-        }
-        return true;
-    }
-
-    static void _getSubDiff(std::vector<TByte>& subDiff,const TDiffData& diff,const TOldCover& cover){
-        subDiff.resize(cover.length);
-        const TByte* pnew=diff.newData+cover.newPos;
-        const TByte* pold=diff.oldData+cover.oldPos;
-        for (size_t i=0;i<subDiff.size();++i)
-            subDiff[i]=pnew[i]-pold[i];
-    }
-
-    struct TInlpacePatchSets{
-        bool        isInplacePatchByExtra;
-        hpi_size_t  extraSafeSize;
-    };
-
-static void serialize_lite_diff(const TDiffData& diff,const std::vector<TOldCover>& covers,
-                                std::vector<TByte>& out_diff,const hdiffi_TCompress* compressPlugin,
-                                const TInlpacePatchSets& inlpacePatchSets){
-    const TUInt coverCount=(TUInt)covers.size();
-    const bool isInplacePatch= inlpacePatchSets.isInplacePatchByExtra;
-    std::vector<TByte> subDiff;
-    std::vector<TByte> buf;
-    hpi_packUInt(buf,coverCount);
-    const TUInt newSize=(TUInt)(diff.newData_end-diff.newData);
-    {
-        TUInt lastOldEnd=0;
-        TUInt lastNewEnd=0;
-        for (TUInt i=0; i<coverCount; ++i) {
-            const TOldCover& cover=covers[i];
-            hpi_packUInt(buf, cover.length);
-            _getSubDiff(subDiff,diff,cover);
-            const TByte isNullSubDiff=_getIs0(subDiff.data(),cover.length)?1:0;
-            if ((TUInt)cover.oldPos>=lastOldEnd){ //save inc_oldPos
-                hpi_packUIntWithTag(buf,(TUInt)(cover.oldPos-lastOldEnd), 0+isNullSubDiff*2,2);
-            }else{
-                hpi_packUIntWithTag(buf,(TUInt)(lastOldEnd-cover.oldPos), 1+isNullSubDiff*2,2);
-            }
-            TUInt backNewLen=cover.newPos-lastNewEnd;
-            assert(backNewLen>=0);
-            hpi_packUInt(buf,(TUInt)backNewLen); //save inc_newPos
-            
-            if (backNewLen>0){
-                const TByte* newDataDiff=diff.newData+lastNewEnd;
-                pushBack(buf,newDataDiff,newDataDiff+backNewLen);
-            }
-            if (!isNullSubDiff){
-                pushBack(buf,subDiff.data(),subDiff.data()+cover.length);
-            }
-            
-            lastOldEnd=cover.oldPos+cover.length;
-            lastNewEnd=cover.newPos+cover.length;
-        }
-        
-        TUInt backNewLen=(newSize-lastNewEnd);
-        check(backNewLen==0);
-    }
-    
-    std::vector<TByte> compress_buf;
-    do_compress(compress_buf,buf,compressPlugin->compress);
-    out_diff.push_back(kHPatchLite_versionType[0]);
-    out_diff.push_back(kHPatchLite_versionType[1]);
-    out_diff.push_back(compress_buf.empty()?hpi_compressType_no:compressPlugin->compress_type);
-    TUInt savedUncompressSize=compress_buf.empty()?0:buf.size();
-    const TByte savedVersionCode=isInplacePatch?kHPatchLite_inplaceCode:kHPatchLite_versionCode;
-    out_diff.push_back((savedVersionCode<<6)|
-                       (hpi_getSavedSizeBytes(newSize))|
-                       (hpi_getSavedSizeBytes(savedUncompressSize)<<3));
-    if (isInplacePatch)
-        out_diff.push_back(hpi_getSavedSizeBytes(inlpacePatchSets.extraSafeSize));
-    hpi_saveSize(out_diff,newSize);
-    hpi_saveSize(out_diff,savedUncompressSize);
-    if (isInplacePatch)
-        hpi_saveSize(out_diff,inlpacePatchSets.extraSafeSize);
-    pushBack(out_diff,compress_buf.empty()?buf:compress_buf);
-}
-
-} //end namespace
-
-void create_lite_diff(const unsigned char* newData,const unsigned char* newData_end,
-                      const unsigned char* oldData,const unsigned char* oldData_end,
-                      std::vector<hpi_byte>& out_lite_diff,const hdiffi_TCompress* compressPlugin,
-                      int kMinSingleMatchScore,bool isUseBigCacheMatch,
-                      ILiteDiffListener* listener,size_t threadNum){
-    static const int _kMatchScore_optim4bin=6;
-    TDiffData diff(newData,newData_end,oldData,oldData_end);
-    std::vector<TOldCover> covers;
-    get_diff(diff,covers,kMinSingleMatchScore-_kMatchScore_optim4bin,isUseBigCacheMatch,listener,0,threadNum);
-    size_t oldPosEnd=0;
-    size_t newPosEnd=0;
-    if (!covers.empty()){
-        const TOldCover& c=covers.back();
-        oldPosEnd=c.oldPos+c.length;
-        newPosEnd=c.newPos+c.length;
-    }
-    const size_t newSize=newData_end-newData;
-    if (newPosEnd<newSize)
-        covers.push_back(TOldCover(oldPosEnd,newSize,0));
-
-    TInlpacePatchSets inlpacePatchSets={};
-    if (listener&&listener->getInplacePatchExtraSafeSize){
-        if (listener->getInplacePatchExtraSafeSize(listener,&inlpacePatchSets.extraSafeSize))
-            inlpacePatchSets.isInplacePatchByExtra=true;
-    }
-    serialize_lite_diff(diff,covers,out_lite_diff,compressPlugin,inlpacePatchSets);
-}
-
-namespace{
-struct TPatchiListener:public hpatchi_listener_t{
-    hpatch_decompressHandle decompresser;
-    hpatch_TDecompress*     decompressPlugin;
-    inline TPatchiListener():decompresser(0),newData_cur_pos(0){}
-    inline ~TPatchiListener(){ if (decompresser) decompressPlugin->close(decompressPlugin,decompresser); }
-    const hpi_byte* diffData_cur;
-    const hpi_byte* diffData_end;
-    hpatch_TStreamInput diffStream;
-    hpi_pos_t           uncompressSize;
-    const hpi_byte* newData_cur;
-    const hpi_byte* newData_end;
-    const hpi_byte* oldData;
-    const hpi_byte* oldData_end;
-    bool          isInplacePatch;
-    hpi_size_t    extraSafeSize;//for inplace-patch
-    hpatch_size_t newData_cur_pos;//for inplace-patch
-
-    static hpi_BOOL _read_diff(hpi_TInputStreamHandle inputStream,hpi_byte* out_data,hpi_size_t* data_size){
-        TPatchiListener& self=*(TPatchiListener*)inputStream;
-        const hpi_byte* cur=self.diffData_cur;
-        size_t d_size=self.diffData_end-cur;
-        size_t r_size=*data_size;
-        if (r_size>d_size){
-            r_size=d_size;
-            *data_size=(hpi_size_t)r_size;
-        }
-        memcpy(out_data,cur,r_size);
-        self.diffData_cur=cur+r_size;
-        return hpi_TRUE;
-    }
-    static hpi_BOOL _read_diff_dec(hpi_TInputStreamHandle inputStream,hpi_byte* out_data,hpi_size_t* data_size){
-        TPatchiListener& self=*(TPatchiListener*)inputStream;
-        hpi_size_t r_size=*data_size;
-        if (r_size>self.uncompressSize){
-            r_size=(hpi_size_t)self.uncompressSize;
-            *data_size=(hpi_size_t)self.uncompressSize;
-        }
-        if (!self.decompressPlugin->decompress_part(self.decompresser,out_data,out_data+r_size))
-            return hpi_FALSE;
-        self.uncompressSize-=r_size;
-        return hpi_TRUE;
-    }
-    static hpi_BOOL _write_new(struct hpatchi_listener_t* listener,const hpi_byte* data,hpi_size_t data_size){
-        TPatchiListener& self=*(TPatchiListener*)listener;
-        if (data_size>(size_t)(self.newData_end-self.newData_cur)) 
-            return hpi_FALSE;
-        if (0!=memcmp(self.newData_cur,data,data_size))
-            return hpi_FALSE;
-        self.newData_cur+=data_size;
-        self.newData_cur_pos+=data_size;
-        return hpi_TRUE;
-    }
-    static hpi_BOOL _read_old(struct hpatchi_listener_t* listener,hpi_pos_t read_from_pos,hpi_byte* out_data,hpi_size_t data_size){
-        TPatchiListener& self=*(TPatchiListener*)listener;
-        size_t dsize=self.oldData_end-self.oldData;
-        if ((read_from_pos>dsize)|(data_size>(size_t)(dsize-read_from_pos))) return hpi_FALSE;
-        memcpy(out_data,self.oldData+(size_t)read_from_pos,data_size);
-        if (self.isInplacePatch){
-            if (read_from_pos<self.newData_cur_pos)
-                return hpi_FALSE;
-        }
-        return hpi_TRUE;
-    }
-};
-}// end namespace
-
-static
-bool _try_open_hpatchi_and_inplace(TPatchiListener& listener,hpi_compressType* out_compress_type,
-                                   hpi_pos_t* out_newSize,hpi_pos_t* out_uncompressSize){
-    listener.isInplacePatch=false;
-    listener.extraSafeSize=0;
-    const hpi_byte* diffData_cur_bck=listener.diffData_cur;
-    if (hpatch_lite_open(&listener,listener._read_diff,out_compress_type,out_newSize,out_uncompressSize))
-        return true;
-    listener.diffData_cur=diffData_cur_bck;//reread diffData from 0 pos
-    if (hpatchi_inplace_open(&listener,listener._read_diff,out_compress_type,out_newSize,out_uncompressSize,&listener.extraSafeSize)){
-        listener.isInplacePatch=true;
-        return true;
-    }
-    return false;
-}
-
-bool check_lite_diff_open(const hpi_byte* lite_diff,const hpi_byte* lite_diff_end,
-                          hpi_compressType* out_compress_type){
-    TPatchiListener listener;
-    listener.diffData_cur=lite_diff;
-    listener.diffData_end=lite_diff_end;
-    hpi_pos_t saved_newSize;
-    hpi_pos_t saved_uncompressSize;
-    if (!_try_open_hpatchi_and_inplace(listener,out_compress_type,
-                                       &saved_newSize,&saved_uncompressSize)) return false;
-    return true;
-}
-
-bool check_lite_diff(const hpi_byte* newData,const hpi_byte* newData_end,
-                     const hpi_byte* oldData,const hpi_byte* oldData_end,
-                     const hpi_byte* lite_diff,const hpi_byte* lite_diff_end,
-                     hpatch_TDecompress* decompressPlugin){
-    TPatchiListener listener;
-    listener.diffData_cur=lite_diff;
-    listener.diffData_end=lite_diff_end;
-    hpi_compressType _compress_type;
-    hpi_pos_t saved_newSize;
-    hpi_pos_t saved_uncompressSize;
-    if (!_try_open_hpatchi_and_inplace(listener,&_compress_type,
-                                       &saved_newSize,&saved_uncompressSize)) return false;
-    if (saved_newSize!=(size_t)(newData_end-newData)) return false;
-    listener.diff_data=&listener;
-    listener.decompressPlugin=(_compress_type!=hpi_compressType_no)?decompressPlugin:0;
-    if (listener.decompressPlugin){
-        listener.uncompressSize=saved_uncompressSize;
-        mem_as_hStreamInput(&listener.diffStream,listener.diffData_cur,lite_diff_end);
-        listener.decompresser=decompressPlugin->open(decompressPlugin,saved_uncompressSize,&listener.diffStream,
-                                                     0,(size_t)(lite_diff_end-listener.diffData_cur));
-        if (listener.decompresser==0) return false;
-        listener.read_diff=listener._read_diff_dec;
-    }else{
-        listener.read_diff=listener._read_diff;
-    }
-    listener.newData_cur=newData;
-    listener.newData_end=newData_end;
-    listener.write_new=listener._write_new;
-    listener.oldData=oldData;
-    listener.oldData_end=oldData_end;
-    listener.read_old=listener._read_old;
-
-    const size_t kACacheBufSize=hpatch_kFileIOBufBetterSize;
-    hdiff_private::TAutoMem _cache(kACacheBufSize+listener.extraSafeSize);
-    
-    if (listener.isInplacePatch){
-        if (!hpatchi_inplaceB(&listener,saved_newSize,_cache.data(),listener.extraSafeSize,(hpi_size_t)_cache.size()))
-            return false;
-    }else if (!hpatch_lite_patch(&listener,saved_newSize,_cache.data(),(hpi_size_t)_cache.size())){
-        return false;
-    }
-    return listener.newData_cur==listener.newData_end;
-}
-
-
-hpatch_BOOL hdiff_streamDataIsEqual(const hpatch_TStreamInput* x,const hpatch_TStreamInput* y){
-    const hpatch_StreamPos_t ssize=x->streamSize;
-    if (ssize!=y->streamSize) return hpatch_FALSE;
-    const size_t kACacheBufSize=hdiff_kFileIOBufBestSize;
-    hdiff_private::TAutoMem _cache(kACacheBufSize*2);
-    hpatch_byte* bufx=_cache.data();
-    hpatch_byte* bufy=bufx+kACacheBufSize;
-    for (hpatch_StreamPos_t i=0; i<ssize; ){
-        const hpatch_StreamPos_t maxdSize=ssize-i;
-        size_t dataSize=(size_t)(kACacheBufSize<=maxdSize?kACacheBufSize:maxdSize);
-        check(x->read(x,i,bufx,bufx+dataSize));
-        check(y->read(y,i,bufy,bufy+dataSize));
-        if (0!=memcmp(bufx,bufy,dataSize))
-            return hpatch_FALSE;
-        i+=dataSize;
-    }
-    return hpatch_TRUE;
-}
-