react-native-update 10.34.3 → 10.34.5

package/harmony/pushy/src/main/cpp/HDiffPatch/libHDiffPatch/HPatch/patch.c

@@ -31,12 +31,16 @@
 #endif
 #include "patch_private.h"
 
+#ifndef  _IS_NEED_MIN_CODE_SIZE
+#   define _IS_NEED_MIN_CODE_SIZE  0   //default used fast code
+#endif
+
 #ifndef _IS_RUN_MEM_SAFE_CHECK
 #   define _IS_RUN_MEM_SAFE_CHECK  1
 #endif
 
 #if (_IS_RUN_MEM_SAFE_CHECK)
-// __RUN_MEM_SAFE_CHECK : enables bounds checking for memory access to defend against potentially corrupted or maliciously crafted data.
+//__RUN_MEM_SAFE_CHECK用来启动内存访问越界检查,用以防御可能被意外或故意损坏的数据.
 #   define __RUN_MEM_SAFE_CHECK
 #endif
 
@@ -47,13 +51,13 @@
 #endif
 
 #define _hpatch_FALSE   hpatch_FALSE
-//hpatch_uint __hpatch_debug_check_false_x=0; //for debug
-//#define _hpatch_FALSE (1/__hpatch_debug_check_false_x)
+//hpatch_uint __debug_check_false_x=0; //for debug
+//#define _hpatch_FALSE (1/__debug_check_false_x)
 
 typedef unsigned char TByte;
 
 
-//Variable-length positive integer encoding scheme (x bits for additional type flags, x<=7), outputs 1--n bytes from high:
+//变长正整数编码方案(x bit额外类型标志位,x<=7),从高位开始输出1--n byte:
 // x0*  7-x bit
 // x1* 0*  7+7-x bit
 // x1* 1* 0*  7+7+7-x bit
@@ -62,7 +66,7 @@ typedef unsigned char TByte;
 // ......
 hpatch_BOOL hpatch_packUIntWithTag(TByte** out_code,TByte* out_code_end,
                                    hpatch_StreamPos_t uValue,hpatch_uint highTag,
-                                   const hpatch_uint kTagBit){//write out integer and advance pointer.
+                                   const hpatch_uint kTagBit){//写入整数并前进指针.
     TByte*          pcode=*out_code;
     const hpatch_StreamPos_t kMaxValueWithTag=((hpatch_StreamPos_t)1<<(7-kTagBit))-1;
     TByte           codeBuf[hpatch_kMaxPackedUIntBytes];
@@ -84,7 +88,7 @@ hpatch_BOOL hpatch_packUIntWithTag(TByte** out_code,TByte* out_code_end,
     ++pcode;
     while (codeBuf!=codeEnd) {
         --codeEnd;
-        *pcode=(*codeEnd) | (TByte)(((codeBuf!=codeEnd)?1:0)<<7);
+        *pcode=(*codeEnd) | (((codeBuf!=codeEnd)?1:0)<<7);
         ++pcode;
     }
     *out_code=pcode;
@@ -103,7 +107,7 @@ hpatch_uint hpatch_packUIntWithTag_size(hpatch_StreamPos_t uValue,const hpatch_u
 }
 
 hpatch_BOOL hpatch_unpackUIntWithTag(const TByte** src_code,const TByte* src_code_end,
-                                     hpatch_StreamPos_t* result,const hpatch_uint kTagBit){//read integer and advance pointer.
+                                     hpatch_StreamPos_t* result,const hpatch_uint kTagBit){//读出整数并前进指针.
 #ifdef __RUN_MEM_SAFE_CHECK
     //const hpatch_uint kPackMaxTagBit=7;
 #endif
@@ -144,12 +148,11 @@ hpatch_BOOL hpatch_unpackUIntWithTag(const TByte** src_code,const TByte* src_cod
         memcpy(out_data,src+readFromPos,readLen);
         return hpatch_TRUE;
     }
-const hpatch_TStreamInput* mem_as_hStreamInput(hpatch_TStreamInput* out_stream,
-                                               const unsigned char* mem,const unsigned char* mem_end){
+void mem_as_hStreamInput(hpatch_TStreamInput* out_stream,
+                         const unsigned char* mem,const unsigned char* mem_end){
     out_stream->streamImport=(void*)mem;
     out_stream->streamSize=mem_end-mem;
     out_stream->read=_read_mem_stream;
-    return out_stream;
 }
 
     static hpatch_BOOL _write_mem_stream(const hpatch_TStreamOutput* stream,hpatch_StreamPos_t writeToPos,
@@ -165,13 +168,12 @@ const hpatch_TStreamInput* mem_as_hStreamInput(hpatch_TStreamInput* out_stream,
     }
     typedef hpatch_BOOL (*_read_mem_stream_t)(const hpatch_TStreamOutput* stream,hpatch_StreamPos_t readFromPos,
                                               unsigned char* out_data,unsigned char* out_data_end);
-const hpatch_TStreamOutput* mem_as_hStreamOutput(hpatch_TStreamOutput* out_stream,
-                                                 unsigned char* mem,unsigned char* mem_end){
+void mem_as_hStreamOutput(hpatch_TStreamOutput* out_stream,
+                          unsigned char* mem,unsigned char* mem_end){
     out_stream->streamImport=mem;
     out_stream->streamSize=mem_end-mem;
     out_stream->read_writed=(_read_mem_stream_t)_read_mem_stream;
     out_stream->write=_write_mem_stream;
-    return out_stream;
 }
 
 hpatch_BOOL hpatch_deccompress_mem(hpatch_TDecompress* decompressPlugin,
@@ -323,9 +325,30 @@ hpatch_BOOL patch(TByte* out_newData,TByte* out_newData_end,
         return _hpatch_FALSE;
 }
 
+#if (_IS_NEED_MIN_CODE_SIZE)
 hpatch_inline static void addData(TByte* dst,const TByte* src,hpatch_size_t length){
     while (length--) { *dst++ += *src++; }
 }
+#else
+static void addData(TByte* dst,const TByte* src,hpatch_size_t length){
+    hpatch_size_t length_fast,i;
+    
+    length_fast=length&(~(hpatch_size_t)7);
+    for (i=0;i<length_fast;i+=8){
+        dst[i  ]+=src[i  ];
+        dst[i+1]+=src[i+1];
+        dst[i+2]+=src[i+2];
+        dst[i+3]+=src[i+3];
+        dst[i+4]+=src[i+4];
+        dst[i+5]+=src[i+5];
+        dst[i+6]+=src[i+6];
+        dst[i+7]+=src[i+7];
+    }
+    for (;i<length;++i)
+        dst[i]+=src[i];
+}
+#endif
+
 
 static hpatch_BOOL _bytesRle_load(TByte* out_data,TByte* out_dataEnd,
                                   const TByte* rle_code,const TByte* rle_code_end){
@@ -437,13 +460,13 @@ void TStreamOutputClip_init(TStreamOutputClip* self,const hpatch_TStreamOutput*
 struct __private_hpatch_check_kMaxCompressTypeLength {
     char _[(hpatch_kStreamCacheSize>=(hpatch_kMaxPluginTypeLength+1))?1:-1];};
 
-hpatch_BOOL _TStreamCacheClip_readStr_end(TStreamCacheClip* sclip,TByte endTag,
-                                          char* out_type,size_t typeBufLen){
+hpatch_BOOL _TStreamCacheClip_readType_end(TStreamCacheClip* sclip,TByte endTag,
+                                           char out_type[hpatch_kMaxPluginTypeLength+1]){
     const TByte* type_begin;
     hpatch_size_t i;
-    hpatch_size_t readLen=typeBufLen;
-    if (readLen>_TStreamCacheClip_leaveSize(sclip))
-        readLen=(hpatch_size_t)_TStreamCacheClip_leaveSize(sclip);
+    hpatch_size_t readLen=hpatch_kMaxPluginTypeLength+1;
+    if (readLen>_TStreamCacheClip_streamSize(sclip))
+        readLen=(hpatch_size_t)_TStreamCacheClip_streamSize(sclip);
     type_begin=_TStreamCacheClip_accessData(sclip,readLen);
     if (type_begin==0) return _hpatch_FALSE;//not found
     for (i=0; i<readLen; ++i) {
@@ -499,7 +522,7 @@ struct __private_hpatch_check_hpatch_kMaxPackedUIntBytes {
 hpatch_BOOL _TStreamCacheClip_unpackUIntWithTag(TStreamCacheClip* sclip,hpatch_StreamPos_t* result,const hpatch_uint kTagBit){
     TByte* curCode,*codeBegin;
     hpatch_size_t readSize=hpatch_kMaxPackedUIntBytes;
-    const hpatch_StreamPos_t dataSize=_TStreamCacheClip_leaveSize(sclip);
+    const hpatch_StreamPos_t dataSize=_TStreamCacheClip_streamSize(sclip);
     if (readSize>dataSize)
         readSize=(hpatch_size_t)dataSize;
     codeBegin=_TStreamCacheClip_accessData(sclip,readSize);
@@ -510,6 +533,28 @@ hpatch_BOOL _TStreamCacheClip_unpackUIntWithTag(TStreamCacheClip* sclip,hpatch_S
     return hpatch_TRUE;
 }
 
+hpatch_BOOL _TStreamCacheClip_readUInt(TStreamCacheClip* sclip,hpatch_StreamPos_t* result,hpatch_size_t uintSize){
+    // assert(uintSize<=sizeof(hpatch_StreamPos_t));
+    const TByte* buf=_TStreamCacheClip_readData(sclip,uintSize);
+    hpatch_StreamPos_t v=0;
+    if (buf!=0){
+        switch (uintSize) {
+            case 8: v|=((hpatch_StreamPos_t)buf[7])<<(7*8);
+            case 7: v|=((hpatch_StreamPos_t)buf[6])<<(6*8);
+            case 6: v|=((hpatch_StreamPos_t)buf[5])<<(5*8);
+            case 5: v|=((hpatch_StreamPos_t)buf[4])<<(4*8);
+            case 4: v|=((hpatch_StreamPos_t)buf[3])<<(3*8);
+            case 3: v|=((hpatch_StreamPos_t)buf[2])<<(2*8);
+            case 2: v|=((hpatch_StreamPos_t)buf[1])<<(1*8);
+            case 1: v|=((hpatch_StreamPos_t)buf[0]);
+            case 0: { *result=v; return hpatch_TRUE; }
+            default: return _hpatch_FALSE;
+        }
+    }else{
+        return _hpatch_FALSE;
+    }
+}
+
 hpatch_BOOL _TStreamCacheClip_readDataTo(TStreamCacheClip* sclip,TByte* out_buf,TByte* bufEnd){
     hpatch_size_t readLen=_TStreamCacheClip_cachedSize(sclip);
     hpatch_size_t outLen=bufEnd-out_buf;
@@ -517,31 +562,16 @@ hpatch_BOOL _TStreamCacheClip_readDataTo(TStreamCacheClip* sclip,TByte* out_buf,
         readLen=outLen;
     memcpy(out_buf,&sclip->cacheBuf[sclip->cacheBegin],readLen);
     sclip->cacheBegin+=readLen;
+    out_buf+=readLen;
     outLen-=readLen;
     if (outLen){
-        out_buf += readLen;
-        if (outLen<(sclip->cacheEnd>>1)){
-            if (!_TStreamCacheClip_updateCache(sclip)) return _hpatch_FALSE;
-#ifdef __RUN_MEM_SAFE_CHECK
-            if (outLen>_TStreamCacheClip_cachedSize(sclip)) return _hpatch_FALSE;
-#endif
-            return _TStreamCacheClip_readDataTo(sclip, out_buf, bufEnd);
-        }else{
-            if (!sclip->srcStream->read(sclip->srcStream,sclip->streamPos,
-                                        out_buf,bufEnd)) return _hpatch_FALSE;
-            sclip->streamPos+=outLen;
-        }
+        if (!sclip->srcStream->read(sclip->srcStream,sclip->streamPos,
+                                    out_buf,bufEnd)) return _hpatch_FALSE;
+        sclip->streamPos+=outLen;
     }
     return hpatch_TRUE;
 }
 
-hpatch_BOOL _TStreamCacheClip_addDataTo(TStreamCacheClip* self,unsigned char* dst,hpatch_size_t addLen){
-    const unsigned char* src=_TStreamCacheClip_readData(self,addLen);
-    if (src==0) return _hpatch_FALSE;
-    addData(dst,src,addLen);
-    return hpatch_TRUE;
-}
-
     static hpatch_BOOL _decompress_read(const hpatch_TStreamInput* stream,
                                         const hpatch_StreamPos_t  readFromPos,
                                         TByte* out_data,TByte* out_data_end){
@@ -571,15 +601,9 @@ hpatch_BOOL getStreamClip(TStreamCacheClip* out_clip,_TDecompressInputStream* ou
             out_stream->IInputStream.streamSize=dataSize;
             out_stream->IInputStream.read=_decompress_read;
             out_stream->decompressPlugin=decompressPlugin;
-            if (out_stream->decompressHandle==0){
-                out_stream->decompressHandle=decompressPlugin->open(decompressPlugin,dataSize,stream,
-                                                                    curStreamPos,curStreamPos+compressedSize);
-                if (!out_stream->decompressHandle) return _hpatch_FALSE;
-            }else{
-                if (decompressPlugin->reset_code==0) return _hpatch_FALSE;
-                if (!decompressPlugin->reset_code(out_stream->decompressHandle,dataSize,stream,curStreamPos,
-                                                  curStreamPos+compressedSize)) return _hpatch_FALSE;
-            }
+            out_stream->decompressHandle=decompressPlugin->open(decompressPlugin,dataSize,stream,
+                                                                curStreamPos,curStreamPos+compressedSize);
+            if (!out_stream->decompressHandle) return _hpatch_FALSE;
             _TStreamCacheClip_init(out_clip,&out_stream->IInputStream,0,
                                    out_stream->IInputStream.streamSize,aCache,cacheSize);
         }
@@ -591,29 +615,50 @@ hpatch_BOOL getStreamClip(TStreamCacheClip* out_clip,_TDecompressInputStream* ou
 
 ///////
 
-static hpatch_force_inline hpatch_BOOL __TOutStreamCache_writeStream(_TOutStreamCache* self,const TByte* data,hpatch_size_t dataSize){
+// Stream Clip cache
+typedef struct {
+    hpatch_StreamPos_t           writeToPos;
+    const hpatch_TStreamOutput*  dstStream;
+    unsigned char*  cacheBuf;
+    hpatch_size_t   cacheCur;
+    hpatch_size_t   cacheEnd;
+} TOutStreamCache;
+
+static hpatch_inline void TOutStreamCache_init(TOutStreamCache* self,const hpatch_TStreamOutput*  dstStream,
+                                               TByte* aCache,hpatch_size_t aCacheSize){
+    self->writeToPos=0;
+    self->dstStream=dstStream;
+    self->cacheBuf=aCache;
+    self->cacheCur=0;
+    self->cacheEnd=aCacheSize;
+}
+static hpatch_inline hpatch_BOOL TOutStreamCache_isFinish(const TOutStreamCache* self){
+    return self->writeToPos==self->dstStream->streamSize;
+}
+
+static hpatch_inline hpatch_BOOL _TOutStreamCache_write(TOutStreamCache* self,const TByte* data,hpatch_size_t dataSize){
     if (!self->dstStream->write(self->dstStream,self->writeToPos,data,data+dataSize))
         return _hpatch_FALSE;
     self->writeToPos+=dataSize;
     return hpatch_TRUE;
 }
 
-hpatch_BOOL _TOutStreamCache_flush(_TOutStreamCache* self){
+static hpatch_BOOL TOutStreamCache_flush(TOutStreamCache* self){
     hpatch_size_t curSize=self->cacheCur;
     if (curSize>0){
-        if (!__TOutStreamCache_writeStream(self,self->cacheBuf,curSize))
+        if (!_TOutStreamCache_write(self,self->cacheBuf,curSize))
             return _hpatch_FALSE;
         self->cacheCur=0;
     }
     return hpatch_TRUE;
 }
 
-hpatch_BOOL _TOutStreamCache_write(_TOutStreamCache* self,const TByte* data,hpatch_size_t dataSize){
+static hpatch_BOOL TOutStreamCache_write(TOutStreamCache* self,const TByte* data,hpatch_size_t dataSize){
     while (dataSize>0) {
         hpatch_size_t copyLen;
         hpatch_size_t curSize=self->cacheCur;
         if ((dataSize>=self->cacheEnd)&&(curSize==0)){
-            return __TOutStreamCache_writeStream(self,data,dataSize);
+            return _TOutStreamCache_write(self,data,dataSize);
         }
         copyLen=self->cacheEnd-curSize;
         copyLen=(copyLen<=dataSize)?copyLen:dataSize;
@@ -622,137 +667,28 @@ hpatch_BOOL _TOutStreamCache_write(_TOutStreamCache* self,const TByte* data,hpat
         data+=copyLen;
         dataSize-=copyLen;
         if (self->cacheCur==self->cacheEnd){
-            if (!_TOutStreamCache_flush(self))
-                return _hpatch_FALSE;
-        }
-    }
-    return hpatch_TRUE;
-}
-
-hpatch_BOOL _TOutStreamCache_fill(_TOutStreamCache* self,hpatch_byte fillValue,hpatch_StreamPos_t fillLength){
-    assert(self->cacheBuf);
-    if (self->cacheBuf==0) return _hpatch_FALSE;
-    while (fillLength>0){
-        hpatch_size_t curSize=self->cacheCur;
-        hpatch_size_t runStep=self->cacheEnd-curSize;
-        runStep=(runStep<=fillLength)?runStep:(hpatch_size_t)fillLength;
-        memset(self->cacheBuf+curSize,fillValue,runStep);
-        self->cacheCur=curSize+runStep;
-        fillLength-=runStep;
-        if (self->cacheCur==self->cacheEnd){
-            if (!_TOutStreamCache_flush(self))
-                return _hpatch_FALSE;
+            if (!TOutStreamCache_flush(self)) return _hpatch_FALSE;
         }
     }
     return hpatch_TRUE;
 }
 
-hpatch_BOOL _TOutStreamCache_copyFromStream(_TOutStreamCache* self,const hpatch_TStreamInput* src,
-                                            hpatch_StreamPos_t srcPos,hpatch_StreamPos_t copyLength){
-    assert(self->cacheBuf);
-    if (self->cacheBuf==0) return _hpatch_FALSE;
-    while (copyLength>0){
-        hpatch_size_t curSize=self->cacheCur;
-        hpatch_size_t runStep=self->cacheEnd-curSize;
-        hpatch_byte* buf=self->cacheBuf+curSize;
-        runStep=(runStep<=copyLength)?runStep:(hpatch_size_t)copyLength;
-        if (!src->read(src,srcPos,buf,buf+runStep))
-             return _hpatch_FALSE;
-        srcPos+=runStep;
-        self->cacheCur=curSize+runStep;
-        copyLength-=runStep;
-        if (self->cacheCur==self->cacheEnd){
-            if (!_TOutStreamCache_flush(self))
-                return _hpatch_FALSE;
-        }
-    }
-    return hpatch_TRUE;
-}
 
-hpatch_BOOL _TOutStreamCache_copyFromClip(_TOutStreamCache* self,TStreamCacheClip* src,hpatch_StreamPos_t copyLength){
+static  hpatch_BOOL _patch_copy_diff_by_outCache(TOutStreamCache* outCache,TStreamCacheClip* diff,hpatch_StreamPos_t copyLength){
     while (copyLength>0){
         const TByte* data;
-        hpatch_size_t runStep=(src->cacheEnd<=copyLength)?src->cacheEnd:(hpatch_size_t)copyLength;
-        data=_TStreamCacheClip_readData(src,runStep);
-        if (data==0)
+        hpatch_size_t decodeStep=diff->cacheEnd;
+        if (decodeStep>copyLength)
+            decodeStep=(hpatch_size_t)copyLength;
+        data=_TStreamCacheClip_readData(diff,decodeStep);
+        if (data==0) return _hpatch_FALSE;
+        if (!TOutStreamCache_write(outCache,data,decodeStep))
             return _hpatch_FALSE;
-        if (!_TOutStreamCache_write(self,data,runStep))
-            return _hpatch_FALSE;
-        copyLength-=runStep;
+        copyLength-=decodeStep;
     }
     return hpatch_TRUE;
 }
 
-hpatch_BOOL _TOutStreamCache_copyFromSelf(_TOutStreamCache* self,hpatch_StreamPos_t aheadLength,hpatch_StreamPos_t copyLength){
-    //      [          writed                 ]
-    //                                        [    cached buf    |        empty buf         ]
-    const hpatch_TStreamInput* src=(const hpatch_TStreamInput*)self->dstStream;
-    hpatch_StreamPos_t srcPos=self->writeToPos+self->cacheCur-aheadLength;
-    if (src->read==0) //can't read
-        return _hpatch_FALSE;
-    if ((aheadLength<1)|(aheadLength>self->writeToPos+self->cacheCur))
-            return _hpatch_FALSE;
-    
-    if (srcPos+copyLength<=self->writeToPos){//copy from stream
-        //    [        copyLength          ]
-__copy_in_stream:
-        return _TOutStreamCache_copyFromStream(self,src,srcPos,copyLength);
-    }else if (srcPos>=self->writeToPos){ //copy in mem
-        //                                      [        copyLength        ]
-__copy_in_mem:
-        while (copyLength>0){
-            hpatch_byte* dstBuf=self->cacheBuf+self->cacheCur;
-            hpatch_byte* srcBuf=dstBuf-(hpatch_size_t)aheadLength;
-            hpatch_size_t runLen=(self->cacheCur+copyLength<=self->cacheEnd)?(hpatch_size_t)copyLength:(self->cacheEnd-self->cacheCur);
-            hpatch_size_t i;
-            for (i=0;i<runLen;i++)
-                dstBuf[i]=srcBuf[i];
-            copyLength-=runLen;
-            self->cacheCur+=runLen;
-            if (self->cacheCur==self->cacheEnd){
-                if (!_TOutStreamCache_flush(self))
-                    return _hpatch_FALSE;
-                runLen=(hpatch_size_t)((aheadLength<=copyLength)?aheadLength:copyLength);
-                memmove(self->cacheBuf,self->cacheBuf+self->cacheEnd-(hpatch_size_t)aheadLength,runLen);
-                self->cacheCur=runLen;
-                copyLength-=runLen;
-            }else{
-                assert(copyLength==0);
-            }
-        }
-        return hpatch_TRUE;
-    }else if (self->writeToPos+self->cacheCur<=srcPos+self->cacheEnd){ 
-        // small data in stream，can as copy in mem
-        hpatch_byte* dstBuf=self->cacheBuf+self->cacheCur;
-        hpatch_size_t runLen=(hpatch_size_t)(self->writeToPos-srcPos);
-        if (!src->read(src,srcPos,dstBuf,dstBuf+runLen))
-            return _hpatch_FALSE;
-        //srcPos+=runLen; //not used
-        copyLength-=runLen;
-        self->cacheCur+=runLen;
-        if (self->cacheCur==self->cacheEnd){
-            while (hpatch_TRUE){
-                if (self->cacheCur==self->cacheEnd){
-                    if (!_TOutStreamCache_flush(self))
-                        return _hpatch_FALSE;
-                }
-                if (copyLength>0){
-                    runLen=(self->cacheEnd<=copyLength)?self->cacheEnd:(hpatch_size_t)copyLength;
-                    //srcPos+=runLen; //not used
-                    copyLength-=runLen;
-                    self->cacheCur=runLen;
-                }else{
-                    return hpatch_TRUE;
-                }
-            }
-        }else{
-            goto __copy_in_mem;
-        }
-    }else{
-        goto __copy_in_stream;
-    }
-}
-
 
 typedef struct _TBytesRle_load_stream{
     hpatch_StreamPos_t  memCopyLength;
@@ -771,9 +707,29 @@ static void _TBytesRle_load_stream_init(_TBytesRle_load_stream* loader){
     _TStreamCacheClip_init(&loader->rleCodeClip,0,0,0,0,0);
 }
 
+#if (_IS_NEED_MIN_CODE_SIZE)
 hpatch_inline static void memSet_add(TByte* dst,const TByte src,hpatch_size_t length){
-    while (length--) { (*dst++) += src; }
+    while (length--) { *dst++ += src; }
 }
+#else
+static void memSet_add(TByte* dst,const TByte src,hpatch_size_t length){
+    hpatch_size_t length_fast,i;
+
+    length_fast=length&(~(hpatch_size_t)7);
+    for (i=0;i<length_fast;i+=8){
+        dst[i  ]+=src;
+        dst[i+1]+=src;
+        dst[i+2]+=src;
+        dst[i+3]+=src;
+        dst[i+4]+=src;
+        dst[i+5]+=src;
+        dst[i+6]+=src;
+        dst[i+7]+=src;
+    }
+    for (;i<length;++i)
+        dst[i]+=src;
+}
+#endif
 
 static hpatch_BOOL _TBytesRle_load_stream_mem_add(_TBytesRle_load_stream* loader,
                                                   hpatch_size_t* _decodeSize,TByte** _out_data){
@@ -872,7 +828,7 @@ static hpatch_BOOL _TBytesRle_load_stream_decode_add(_TBytesRle_load_stream* loa
 #define _TBytesRle_load_stream_decode_skip(loader,decodeSize) \
         _TBytesRle_load_stream_decode_add(loader,0,decodeSize)
 
-static  hpatch_BOOL _patch_add_old_with_rle(_TOutStreamCache* outCache,_TBytesRle_load_stream* rle_loader,
+static  hpatch_BOOL _patch_add_old_with_rle(TOutStreamCache* outCache,_TBytesRle_load_stream* rle_loader,
                                             const hpatch_TStreamInput* old,hpatch_StreamPos_t oldPos,
                                             hpatch_StreamPos_t addLength,TByte* aCache,hpatch_size_t aCacheSize){
     while (addLength>0){
@@ -881,7 +837,7 @@ static  hpatch_BOOL _patch_add_old_with_rle(_TOutStreamCache* outCache,_TBytesRl
             decodeStep=(hpatch_size_t)addLength;
         if (!old->read(old,oldPos,aCache,aCache+decodeStep)) return _hpatch_FALSE;
         if (!_TBytesRle_load_stream_decode_add(rle_loader,aCache,decodeStep)) return _hpatch_FALSE;
-        if (!_TOutStreamCache_write(outCache,aCache,decodeStep)) return _hpatch_FALSE;
+        if (!TOutStreamCache_write(outCache,aCache,decodeStep)) return _hpatch_FALSE;
         oldPos+=decodeStep;
         addLength-=decodeStep;
     }
@@ -981,48 +937,51 @@ static hpatch_BOOL _rle_decode_skip(struct _TBytesRle_load_stream* rle_loader,hp
     return hpatch_TRUE;
 }
 
-static hpatch_BOOL patchByClip(_TOutStreamCache* outCache,
+static hpatch_BOOL patchByClip(const hpatch_TStreamOutput* out_newData,
                                const hpatch_TStreamInput*  oldData,
                                hpatch_TCovers* covers,
                                TStreamCacheClip* code_newDataDiffClip,
                                struct _TBytesRle_load_stream* rle_loader,
                                TByte* temp_cache,hpatch_size_t cache_size){
-    const hpatch_StreamPos_t newDataSize=_TOutStreamCache_leaveSize(outCache);
+    const hpatch_StreamPos_t newDataSize=out_newData->streamSize;
     const hpatch_StreamPos_t oldDataSize=oldData->streamSize;
     hpatch_StreamPos_t coverCount=covers->leave_cover_count(covers);
+    TOutStreamCache          outCache;
     hpatch_StreamPos_t newPosBack=0;
     assert(cache_size>=hpatch_kMaxPackedUIntBytes);
+    TOutStreamCache_init(&outCache,out_newData,temp_cache+cache_size,cache_size);
     
     while (coverCount--){
         hpatch_TCover cover;
         if(!covers->read_cover(covers,&cover)) return _hpatch_FALSE;
 #ifdef __RUN_MEM_SAFE_CHECK
-        if (cover.newPos<newPosBack) return _hpatch_FALSE;
+        if (cover.newPos>newDataSize) return _hpatch_FALSE;
         if (cover.length>(hpatch_StreamPos_t)(newDataSize-cover.newPos)) return _hpatch_FALSE;
         if (cover.oldPos>oldDataSize) return _hpatch_FALSE;
         if (cover.length>(hpatch_StreamPos_t)(oldDataSize-cover.oldPos)) return _hpatch_FALSE;
+        if (cover.newPos<newPosBack) return _hpatch_FALSE;
 #endif
         if (newPosBack<cover.newPos){
             hpatch_StreamPos_t copyLength=cover.newPos-newPosBack;
-            if (!_TOutStreamCache_copyFromClip(outCache,code_newDataDiffClip,copyLength)) return _hpatch_FALSE;
+            if (!_patch_copy_diff_by_outCache(&outCache,code_newDataDiffClip,copyLength)) return _hpatch_FALSE;
             if (!_rle_decode_skip(rle_loader,copyLength)) return _hpatch_FALSE;
         }
-        if (!_patch_add_old_with_rle(outCache,rle_loader,oldData,cover.oldPos,cover.length,
+        if (!_patch_add_old_with_rle(&outCache,rle_loader,oldData,cover.oldPos,cover.length,
                                      temp_cache,cache_size)) return _hpatch_FALSE;
         newPosBack=cover.newPos+cover.length;
     }
     
     if (newPosBack<newDataSize){
         hpatch_StreamPos_t copyLength=newDataSize-newPosBack;
-        if (!_TOutStreamCache_copyFromClip(outCache,code_newDataDiffClip,copyLength)) return _hpatch_FALSE;
+        if (!_patch_copy_diff_by_outCache(&outCache,code_newDataDiffClip,copyLength)) return _hpatch_FALSE;
         if (!_rle_decode_skip(rle_loader,copyLength)) return _hpatch_FALSE;
         newPosBack=newDataSize;
     }
-    if (!_TOutStreamCache_flush(outCache))
+    if (!TOutStreamCache_flush(&outCache))
         return _hpatch_FALSE;
     if (   _TBytesRle_load_stream_isFinish(rle_loader)
         && covers->is_finish(covers)
-        && _TOutStreamCache_isFinish(outCache)
+        && TOutStreamCache_isFinish(&outCache)
         && _TStreamCacheClip_isFinish(code_newDataDiffClip)
         && (newPosBack==newDataSize) )
         return hpatch_TRUE;
@@ -1104,14 +1063,12 @@ static hpatch_BOOL _packedCovers_open(_TPackedCovers** out_self,
         diffPos0=out_diffHead->headEndPos;
         _TStreamCacheClip_init(&self->code_lengthsClip,serializedDiff,diffPos0,
                                diffPos0+out_diffHead->lengthSize,temp_cache,cacheSize);
-        temp_cache+=cacheSize;
         diffPos0+=out_diffHead->lengthSize;
         _TStreamCacheClip_init(&self->code_inc_newPosClip,serializedDiff,diffPos0,
-                               diffPos0+out_diffHead->inc_newPosSize,temp_cache,cacheSize);
-        temp_cache+=cacheSize;
+                               diffPos0+out_diffHead->inc_newPosSize,temp_cache+cacheSize*1,cacheSize);
         diffPos0+=out_diffHead->inc_newPosSize;
         _TStreamCacheClip_init(&self->code_inc_oldPosClip,serializedDiff,diffPos0,
-                               diffPos0+out_diffHead->inc_oldPosSize,temp_cache,cacheSize);
+                               diffPos0+out_diffHead->inc_oldPosSize,temp_cache+cacheSize*2,cacheSize);
     }
     
      _covers_init(&self->base,out_diffHead->coverCount,&self->code_inc_oldPosClip,
@@ -1153,8 +1110,7 @@ static hpatch_BOOL _patch_stream_with_cache(const hpatch_TStreamOutput* out_newD
     //newDataDiff
     diffPos0=diffHead.coverEndPos;
     _TStreamCacheClip_init(&code_newDataDiffClip,serializedDiff,diffPos0,
-                           diffPos0+diffHead.newDataDiffSize,temp_cache,cacheSize);
-    temp_cache+=cacheSize;
+                           diffPos0+diffHead.newDataDiffSize,temp_cache+cacheSize*0,cacheSize);
     diffPos0+=diffHead.newDataDiffSize;
         
     {//rle
@@ -1165,7 +1121,7 @@ static hpatch_BOOL _patch_stream_with_cache(const hpatch_TStreamOutput* out_newD
         if (cacheSize<hpatch_kMaxPackedUIntBytes) return _hpatch_FALSE;
 #endif
         _TStreamCacheClip_init(rleHeadClip,serializedDiff,diffPos0,diffPos_end,
-                               temp_cache,hpatch_kMaxPackedUIntBytes);
+                               temp_cache+cacheSize*1,hpatch_kMaxPackedUIntBytes);
         _clip_unpackUIntTo(&rleCtrlSize,rleHeadClip);
         rlePos0=(hpatch_StreamPos_t)(_TStreamCacheClip_readPosOfSrcStream(rleHeadClip));
 #ifdef __RUN_MEM_SAFE_CHECK
@@ -1173,19 +1129,13 @@ static hpatch_BOOL _patch_stream_with_cache(const hpatch_TStreamOutput* out_newD
 #endif
         _TBytesRle_load_stream_init(&rle_loader);
         _TStreamCacheClip_init(&rle_loader.ctrlClip,serializedDiff,rlePos0,rlePos0+rleCtrlSize,
-                               temp_cache,cacheSize);
-        temp_cache+=cacheSize;
+                               temp_cache+cacheSize*1,cacheSize);
         _TStreamCacheClip_init(&rle_loader.rleCodeClip,serializedDiff,rlePos0+rleCtrlSize,diffPos_end,
-                               temp_cache,cacheSize);
-        temp_cache+=cacheSize;
-    }
-    {
-        _TOutStreamCache outCache;
-        _TOutStreamCache_init(&outCache,out_newData,temp_cache,cacheSize);
-        temp_cache+=cacheSize;
-        return patchByClip(&outCache,oldData,pcovers,&code_newDataDiffClip,
-                           &rle_loader,temp_cache,cacheSize);
+                               temp_cache+cacheSize*2,cacheSize);
     }
+    
+    return patchByClip(out_newData,oldData,pcovers,&code_newDataDiffClip,
+                       &rle_loader,temp_cache+cacheSize*3,cacheSize);
 }
 
 
@@ -1200,7 +1150,7 @@ hpatch_BOOL read_diffz_head(hpatch_compressedDiffInfo* out_diffInfo,_THDiffzHead
         const char* kVersionType="HDIFF13";
         char* tempType=out_diffInfo->compressType;
         if (!_TStreamCacheClip_readType_end(diffHeadClip,'&',tempType)) return _hpatch_FALSE;
-        if (0!=strcmp(tempType,kVersionType)) return hpatch_FALSE;
+        if (0!=strcmp(tempType,kVersionType)) return _hpatch_FALSE;
     }
     {//read compressType
         if (!_TStreamCacheClip_readType_end(diffHeadClip,'\0',
@@ -1247,6 +1197,7 @@ hpatch_BOOL getCompressedDiffInfo(hpatch_compressedDiffInfo* out_diffInfo,
 
 static
 hpatch_BOOL _patch_decompress_cache(const hpatch_TStreamOutput*  out_newData,
+                                    hpatch_TStreamInput*         once_in_newData,
                                     const hpatch_TStreamInput*   oldData,
                                     const hpatch_TStreamInput*   compressedDiff,
                                     hpatch_TDecompress*          decompressPlugin,
@@ -1258,7 +1209,7 @@ hpatch_BOOL _patch_decompress_cache(const hpatch_TStreamOutput*  out_newData,
     _THDiffzHead                head;
     hpatch_compressedDiffInfo   diffInfo;
     _TDecompressInputStream     decompressers[4];
-    hpatch_size_t               i;
+    hpatch_uint                 i;
     hpatch_StreamPos_t          coverCount;
     hpatch_BOOL  result=hpatch_TRUE;
     hpatch_StreamPos_t        diffPos0=0;
@@ -1295,35 +1246,29 @@ hpatch_BOOL _patch_decompress_cache(const hpatch_TStreamOutput*  out_newData,
     }
     if (!getStreamClip(&rle_loader.ctrlClip,&decompressers[1],
                        head.rle_ctrlBuf_size,head.compress_rle_ctrlBuf_size,compressedDiff,&diffPos0,
-                       decompressPlugin,temp_cache,cacheSize)) _clear_return(_hpatch_FALSE);
-    temp_cache+=cacheSize;
+                       decompressPlugin,temp_cache+cacheSize*0,cacheSize)) _clear_return(_hpatch_FALSE);
     if (!getStreamClip(&rle_loader.rleCodeClip,&decompressers[2],
                        head.rle_codeBuf_size,head.compress_rle_codeBuf_size,compressedDiff,&diffPos0,
-                       decompressPlugin,temp_cache,cacheSize)) _clear_return(_hpatch_FALSE);
-    temp_cache+=cacheSize;
+                       decompressPlugin,temp_cache+cacheSize*1,cacheSize)) _clear_return(_hpatch_FALSE);
     if (!getStreamClip(&code_newDataDiffClip,&decompressers[3],
                        head.newDataDiff_size,head.compress_newDataDiff_size,compressedDiff,&diffPos0,
-                       decompressPlugin,temp_cache,cacheSize)) _clear_return(_hpatch_FALSE);
-    temp_cache+=cacheSize;
+                       decompressPlugin,temp_cache+cacheSize*2,cacheSize)) _clear_return(_hpatch_FALSE);
 #ifdef __RUN_MEM_SAFE_CHECK
     if (diffPos0!=diffPos_end) _clear_return(_hpatch_FALSE);
 #endif
     
     coverCount=head.coverCount;
     {
-        _TCovers         covers;
-        hpatch_TCovers*  pcovers=0;
-        _TOutStreamCache outCache;
-        _TOutStreamCache_init(&outCache,out_newData,temp_cache,cacheSize);
-        temp_cache+=cacheSize;
+        _TCovers covers;
+        hpatch_TCovers* pcovers=0;
         if (cached_covers){
             pcovers=cached_covers;
         }else{
             _covers_init(&covers,coverCount,&coverClip,&coverClip,&coverClip,hpatch_TRUE);
             pcovers=&covers.ICovers;  //not need close before return
         }
-        result=patchByClip(&outCache,oldData,pcovers,&code_newDataDiffClip,&rle_loader,
-                           temp_cache,cacheSize);
+        result=patchByClip(out_newData,oldData,pcovers,&code_newDataDiffClip,&rle_loader,
+                           temp_cache+cacheSize*3,cacheSize);
         //if ((pcovers!=cached_covers)&&(!pcovers->close(pcovers))) result=_hpatch_FALSE;
     }
 clear:
@@ -1408,7 +1353,7 @@ typedef struct hpatch_TCCover32{
     hpatch_uint32_t oldPos;
     hpatch_uint32_t newPos;
     hpatch_uint32_t length;
-    hpatch_uint32_t cachePos; //Consider moving to temporary memory and releasing after use? Logic would be more complex;
+    hpatch_uint32_t cachePos; //todo:放到临时内存中,用完释放?逻辑会比较复杂;
 } hpatch_TCCover32;
 
 typedef struct hpatch_TCCover64{
@@ -1464,22 +1409,6 @@ static hpatch_BOOL _arrayCovers_read_cover(struct hpatch_TCovers* covers,hpatch_
     }
 }
 
-static hpatch_force_inline void _arrayCovers_push_cover(_TArrayCovers* self,const hpatch_TCover* cover){
-    hpatch_size_t i=self->coverCount;
-    if (self->is32){
-        hpatch_TCCover32* pCover=((hpatch_TCCover32*)self->pCCovers)+i;
-        pCover->oldPos=(hpatch_uint32_t)cover->oldPos;
-        pCover->newPos=(hpatch_uint32_t)cover->newPos;
-        pCover->length=(hpatch_uint32_t)cover->length;
-    }else{
-        hpatch_TCCover64* pCover=((hpatch_TCCover64*)self->pCCovers)+i;
-        pCover->oldPos=cover->oldPos;
-        pCover->newPos=cover->newPos;
-        pCover->length=cover->length;
-    }
-    self->coverCount=i+1;
-}
-
 static hpatch_BOOL _arrayCovers_load(_TArrayCovers** out_self,hpatch_TCovers* src_covers,
                                      hpatch_BOOL isUsedCover32,hpatch_BOOL* out_isReadError,
                                      TByte** ptemp_cache,TByte* temp_cache_end){
@@ -1534,45 +1463,37 @@ static hpatch_BOOL _arrayCovers_load(_TArrayCovers** out_self,hpatch_TCovers* sr
     _uint_t y=((const _uint_t*)_y)[item]; \
     return (x<y)?(-1):((x>y)?1:0); \
 }
-#ifdef _MSC_VER
-#   define __CALL_BACK_C    __cdecl
-#else
-#   define __CALL_BACK_C
-#endif
-static hpatch_int __CALL_BACK_C _arrayCovers_comp_by_old_32(const void* _x, const void *_y){
+static hpatch_int _arrayCovers_comp_by_old_32(const void* _x, const void *_y){
     _arrayCovers_comp(hpatch_uint32_t,_x,_y,0);
 }
-static hpatch_int __CALL_BACK_C _arrayCovers_comp_by_old(const void* _x, const void *_y){
+static hpatch_int _arrayCovers_comp_by_old(const void* _x, const void *_y){
     _arrayCovers_comp(hpatch_StreamPos_t,_x,_y,0);
 }
-static hpatch_int __CALL_BACK_C _arrayCovers_comp_by_new_32(const void* _x, const void *_y){
+static hpatch_int _arrayCovers_comp_by_new_32(const void* _x, const void *_y){
     _arrayCovers_comp(hpatch_uint32_t,_x,_y,1);
 }
-static hpatch_int __CALL_BACK_C _arrayCovers_comp_by_new(const void* _x, const void *_y){
+static hpatch_int _arrayCovers_comp_by_new(const void* _x, const void *_y){
     _arrayCovers_comp(hpatch_StreamPos_t,_x,_y,1);
 }
-static hpatch_int __CALL_BACK_C _arrayCovers_comp_by_len_32(const void* _x, const void *_y){
+static hpatch_int _arrayCovers_comp_by_len_32(const void* _x, const void *_y){
     _arrayCovers_comp(hpatch_uint32_t,_x,_y,2);
 }
-static hpatch_int __CALL_BACK_C _arrayCovers_comp_by_len(const void* _x, const void *_y){
+static hpatch_int _arrayCovers_comp_by_len(const void* _x, const void *_y){
     _arrayCovers_comp(hpatch_StreamPos_t,_x,_y,2);
 }
 
-hpatch_force_inline
 static void _arrayCovers_sort_by_old(_TArrayCovers* self){
     if (self->is32)
         qsort(self->pCCovers,self->coverCount,sizeof(hpatch_TCCover32),_arrayCovers_comp_by_old_32);
     else
         qsort(self->pCCovers,self->coverCount,sizeof(hpatch_TCCover64),_arrayCovers_comp_by_old);
 }
-hpatch_force_inline
 static void _arrayCovers_sort_by_new(_TArrayCovers* self){
     if (self->is32)
         qsort(self->pCCovers,self->coverCount,sizeof(hpatch_TCCover32),_arrayCovers_comp_by_new_32);
     else
         qsort(self->pCCovers,self->coverCount,sizeof(hpatch_TCCover64),_arrayCovers_comp_by_new);
 }
-hpatch_force_inline
 static void _arrayCovers_sort_by_len(_TArrayCovers* self){
     if (self->is32)
         qsort(self->pCCovers,self->coverCount,sizeof(hpatch_TCCover32),_arrayCovers_comp_by_len_32);
@@ -1580,27 +1501,22 @@ static void _arrayCovers_sort_by_len(_TArrayCovers* self){
         qsort(self->pCCovers,self->coverCount,sizeof(hpatch_TCCover64),_arrayCovers_comp_by_len);
 }
 
-static hpatch_StreamPos_t _getCacheSumLen(const _TArrayCovers* src_covers,hpatch_StreamPos_t maxCachedLen){
-    const hpatch_size_t coverCount=src_covers->coverCount;
-    hpatch_StreamPos_t  sumLen=0;
-    hpatch_size_t i;
-    for (i=0; i<coverCount;++i) {
-        hpatch_StreamPos_t mlen=_arrayCovers_get_len(src_covers,i);
-        sumLen+=(mlen<=maxCachedLen)?mlen:0;
-    }
-    return sumLen;
-}
-
-static hpatch_size_t _getMaxCachedLen(_TArrayCovers* arrayCovers,hpatch_size_t cacheSize){
-    const hpatch_size_t kMaxCachedLen  =(~((hpatch_size_t)0))/2;//max allowed length for a single cached data item;
+static hpatch_size_t _getMaxCachedLen(const _TArrayCovers* src_covers,
+                                      TByte* temp_cache,TByte* temp_cache_end,TByte* cache_buf_end){
+    const hpatch_size_t kMaxCachedLen  =~((hpatch_size_t)0);//允许缓存的最长单个数据长度;
     hpatch_StreamPos_t mlen=0;
     hpatch_StreamPos_t sum=0;
-    const hpatch_size_t coverCount=arrayCovers->coverCount;
+    const hpatch_size_t coverCount=src_covers->coverCount;
     hpatch_size_t i;
-    _arrayCovers_sort_by_len(arrayCovers);
+    _TArrayCovers cur_covers=*src_covers;
+    hpatch_size_t cacheSize=temp_cache_end-temp_cache;
+    hpatch_StreamPos_t memSize=arrayCovers_memSize(src_covers->coverCount,src_covers->is32);
+    _cache_alloc(cur_covers.pCCovers,void,memSize,temp_cache,temp_cache_end); //fail return 0
+    memcpy(cur_covers.pCCovers,src_covers->pCCovers,(hpatch_size_t)memSize);
+    _arrayCovers_sort_by_len(&cur_covers);
     
     for (i=0; i<coverCount;++i) {
-        mlen=_arrayCovers_get_len(arrayCovers,i);
+        mlen=_arrayCovers_get_len(&cur_covers,i);
         sum+=mlen;
         if (sum<=cacheSize){
             continue;
@@ -1611,15 +1527,14 @@ static hpatch_size_t _getMaxCachedLen(_TArrayCovers* arrayCovers,hpatch_size_t c
     }
     if (mlen>kMaxCachedLen)
         mlen=kMaxCachedLen;
-    _arrayCovers_sort_by_new(arrayCovers);
     return (hpatch_size_t)mlen;
 }
 
 static hpatch_size_t _set_cache_pos(_TArrayCovers* covers,hpatch_size_t maxCachedLen,
-                                    hpatch_StreamPos_t* poldPosBegin,hpatch_StreamPos_t* poldPosEnd,
-                                    hpatch_size_t kMinCacheCoverCount){
+                                    hpatch_StreamPos_t* poldPosBegin,hpatch_StreamPos_t* poldPosEnd){
     const hpatch_size_t coverCount=covers->coverCount;
-    hpatch_StreamPos_t oldPosBegin=hpatch_kNullStreamPos;
+    const hpatch_size_t kMinCacheCoverCount=coverCount/8+1; //控制最小缓存数量,否则缓存的意义太小;
+    hpatch_StreamPos_t oldPosBegin=~(hpatch_StreamPos_t)0;
     hpatch_StreamPos_t oldPosEnd=0;
     hpatch_size_t cacheCoverCount=0;
     hpatch_size_t sum=0;//result
@@ -1644,17 +1559,17 @@ static hpatch_size_t _set_cache_pos(_TArrayCovers* covers,hpatch_size_t maxCache
     return sum;
 }
 
-//a simple caching strategy:
-//  1. select a batch of shortest cover lines to cache based on buffer size limit;
-//  2. sequentially access the oldData file once to fill these caches;
-//  3. skip large intermediate regions that are useless for caching during sequential access;
+//一个比较简单的缓存策略:
+//  1. 根据缓冲区大小限制，选择出最短的一批覆盖线来缓存;
+//  2. 顺序访问一次oldData文件，填充这些缓存;
+//  3. 顺序访问时跳过中间过大的对缓存无用的区域;
 
 static hpatch_BOOL _cache_old_load(const hpatch_TStreamInput*oldData,
                                    hpatch_StreamPos_t oldPos,hpatch_StreamPos_t oldPosAllEnd,
                                    _TArrayCovers* arrayCovers,hpatch_size_t maxCachedLen,hpatch_size_t sumCacheLen,
                                    TByte* old_cache,TByte* old_cache_end,TByte* cache_buf_end){
-    const hpatch_size_t kMinSpaceLen   =(1<<18);//skip space of length seekTime*speed (can be smaller for SSD) if time-efficient, otherwise sequential access;
-    const hpatch_size_t kAccessPageSize=4096;//disk page-aligned access (affects only speed, but impact is minimal);
+    const hpatch_size_t kMinSpaceLen   =(1<<(20+2));//跳过seekTime*speed长度的空间(SSD可以更小)时间上划得来,否则就顺序访问;
+    const hpatch_size_t kAccessPageSize=(1<<(10+2));//页面对齐访问;
     hpatch_BOOL result=hpatch_TRUE;
     hpatch_size_t cur_i=0,i;
     const hpatch_size_t coverCount=arrayCovers->coverCount;
@@ -1682,7 +1597,7 @@ static hpatch_BOOL _cache_old_load(const hpatch_TStreamInput*oldData,
         for (i=cur_i;i<coverCount;++i){
             hpatch_StreamPos_t ioldPos,ioldPosEnd;
             hpatch_StreamPos_t ilen=_arrayCovers_get_len(arrayCovers,i);
-            if (ilen>maxCachedLen){//cover line too long to cache, proceed to next cover line;
+            if (ilen>maxCachedLen){//覆盖线比较长不需要缓存,下一个覆盖线;
                 if (i==cur_i)
                     ++cur_i;
                 continue;
@@ -1692,7 +1607,7 @@ static hpatch_BOOL _cache_old_load(const hpatch_TStreamInput*oldData,
             if (ioldPosEnd>oldPos){
                 //        [oldPos                  oldPosEnd]
                 //                           ioldPosEnd]----or----]
-                if (ioldPos<oldPosEnd){//intersection exists, needs cache
+                if (ioldPos<oldPosEnd){//有交集,需要cache
                 //  [----or----[ioldPos      ioldPosEnd]----or----]
                     hpatch_StreamPos_t from;
                     hpatch_size_t      copyLen;
@@ -1713,14 +1628,14 @@ static hpatch_BOOL _cache_old_load(const hpatch_TStreamInput*oldData,
                     sumCacheLen-=copyLen;
                     if ((i==cur_i)&(oldPosEnd>=ioldPosEnd))
                         ++cur_i;
-                }else{//no more intersections with current data for following cover lines, move to next data block;
+                }else{//后面覆盖线暂时都不会与当前数据有交集了,下一块数据;
                 //  [oldPos     oldPosEnd]
                 //                        [ioldPos      ioldPosEnd]
                     if ((i==cur_i)&&(ioldPos-oldPosEnd>=kMinSpaceLen))
                         oldPosEnd=_hpatch_align_type_lower(hpatch_StreamPos_t,ioldPos,kAccessPageSize);
                     break;
                 }
-            }else{//current cover line is behind current data, proceed to next cover line;
+            }else{//当前覆盖线已经落后于当前数据,下一个覆盖线;
                 //                        [oldPos     oldPosEnd]
                 // [ioldPos    ioldPosEnd]
                 if (i==cur_i)
@@ -1743,27 +1658,18 @@ typedef struct _cache_old_TStreamInput{
     const TByte*        caches;
     const TByte*        cachesEnd;
     const hpatch_TStreamInput* oldData;
-    void*               _cacheImport;
-    hpatch_BOOL         (*_doUpdateCacheCovers)(void* _cacheImport);
 } _cache_old_TStreamInput;
 
 static hpatch_BOOL _cache_old_StreamInput_read(const hpatch_TStreamInput* stream,
                                                hpatch_StreamPos_t readFromPos,
                                                unsigned char* out_data,unsigned char* out_data_end){
     _cache_old_TStreamInput* self=(_cache_old_TStreamInput*)stream->streamImport;
-    hpatch_size_t readLen;
     hpatch_StreamPos_t dataLen=(hpatch_size_t)(self->readFromPosEnd-self->readFromPos);
+    hpatch_size_t readLen;
     if (dataLen==0){//next cover
         hpatch_StreamPos_t oldPos;
         hpatch_size_t i=self->arrayCovers.cur_index++;
-        if (i>=self->arrayCovers.coverCount){
-            if ((self->_doUpdateCacheCovers)&&(self->_doUpdateCacheCovers(self->_cacheImport))){
-                i=self->arrayCovers.cur_index++;
-                if (i>=self->arrayCovers.coverCount)
-                    return _hpatch_FALSE;//update error;
-            }else
-                return _hpatch_FALSE;//error;
-        }
+        if (i>=self->arrayCovers.coverCount) return _hpatch_FALSE;//error;
         oldPos=_arrayCovers_get_oldPos(&self->arrayCovers,i);
         dataLen=_arrayCovers_get_len(&self->arrayCovers,i);
         self->isInHitCache=(dataLen<=self->maxCachedLen);
@@ -1771,7 +1677,7 @@ static hpatch_BOOL _cache_old_StreamInput_read(const hpatch_TStreamInput* stream
         self->readFromPosEnd=oldPos+dataLen;
     }
     readLen=out_data_end-out_data;
-    if ((readLen>dataLen)|(self->readFromPos!=readFromPos)) return _hpatch_FALSE; //error
+    if ((readLen>dataLen)||(self->readFromPos!=readFromPos)) return _hpatch_FALSE; //error
     self->readFromPos=readFromPos+readLen;
     if (self->isInHitCache){
         assert(readLen<=(hpatch_size_t)(self->cachesEnd-self->caches));
@@ -1792,16 +1698,15 @@ static hpatch_BOOL _cache_old(hpatch_TStreamInput** out_cachedOld,const hpatch_T
     hpatch_StreamPos_t oldPosEnd;
     hpatch_size_t      sumCacheLen;
     hpatch_size_t      maxCachedLen;
-    const hpatch_size_t kMinCacheCoverCount=arrayCovers->coverCount/8+1; //control min cache count, otherwise caching becomes ineffective;
     *out_isReadError=hpatch_FALSE;
     _cache_alloc(*out_cachedOld,hpatch_TStreamInput,sizeof(hpatch_TStreamInput),
                  temp_cache,temp_cache_end);
     _cache_alloc(self,_cache_old_TStreamInput,sizeof(_cache_old_TStreamInput),
                  temp_cache,temp_cache_end);
     
-    maxCachedLen=_getMaxCachedLen(arrayCovers,temp_cache_end-temp_cache);
+    maxCachedLen=_getMaxCachedLen(arrayCovers,temp_cache,temp_cache_end,cache_buf_end);
     if (maxCachedLen==0) return hpatch_FALSE;
-    sumCacheLen=_set_cache_pos(arrayCovers,maxCachedLen,&oldPosBegin,&oldPosEnd,kMinCacheCoverCount);
+    sumCacheLen=_set_cache_pos(arrayCovers,maxCachedLen,&oldPosBegin,&oldPosEnd);
     if (sumCacheLen==0) return hpatch_FALSE;
     temp_cache_end=temp_cache+sumCacheLen;
     
@@ -1829,14 +1734,26 @@ static hpatch_BOOL _cache_old(hpatch_TStreamInput** out_cachedOld,const hpatch_T
 
 #endif //_IS_NEED_CACHE_OLD_BY_COVERS
 
-#if (_IS_NEED_CACHE_OLD_ALL)
-hpatch_BOOL _patch_cache_all_old(const hpatch_TStreamInput** poldData,size_t kMinTempCacheSize,
-                                 TByte** ptemp_cache,TByte** ptemp_cache_end,hpatch_BOOL* out_isReadError){
+
+static hpatch_BOOL _patch_cache(hpatch_TCovers** out_covers,
+                                const hpatch_TStreamInput** poldData,hpatch_StreamPos_t newDataSize,
+                                const hpatch_TStreamInput*  diffData,hpatch_BOOL isCompressedDiff,
+                                hpatch_TDecompress* decompressPlugin,size_t kCacheCount,
+                                TByte** ptemp_cache,TByte** ptemp_cache_end,hpatch_BOOL* out_isReadError){
     const hpatch_TStreamInput* oldData=*poldData;
+    const hpatch_size_t kMinCacheSize=hpatch_kStreamCacheSize*kCacheCount;
+#if (_IS_NEED_CACHE_OLD_BY_COVERS)
+    const hpatch_size_t kBestACacheSize=hpatch_kFileIOBufBetterSize;   //内存足够时比较好的hpatch_kStreamCacheSize值;
+    const hpatch_size_t _minActiveSize=(1<<20)*8;
+    const hpatch_StreamPos_t _betterActiveSize=kBestACacheSize*kCacheCount*2+oldData->streamSize/8;
+    const hpatch_size_t kActiveCacheOldMemorySize = //尝试激活CacheOld功能的内存下限;
+                (_betterActiveSize>_minActiveSize)?_minActiveSize:(hpatch_size_t)_betterActiveSize;
+#endif //_IS_NEED_CACHE_OLD_BY_COVERS
     TByte* temp_cache=*ptemp_cache;
     TByte* temp_cache_end=*ptemp_cache_end;
     *out_isReadError=hpatch_FALSE;
-    if (_patch_is_can_cache_all_old(oldData->streamSize,kMinTempCacheSize,temp_cache_end-temp_cache)){//load all oldData
+    if ((hpatch_size_t)(temp_cache_end-temp_cache)>=oldData->streamSize+kMinCacheSize
+        +sizeof(hpatch_TStreamInput)+sizeof(hpatch_StreamPos_t)){//load all oldData
         hpatch_TStreamInput* replace_oldData=0;
         _cache_alloc(replace_oldData,hpatch_TStreamInput,sizeof(hpatch_TStreamInput),
                      temp_cache,temp_cache_end);
@@ -1847,36 +1764,14 @@ hpatch_BOOL _patch_cache_all_old(const hpatch_TStreamInput** poldData,size_t kMi
         temp_cache_end-=oldData->streamSize;
         // [          patch cache            |       oldData cache     ]
         // [ (cacheSize-oldData->streamSize) |  (oldData->streamSize)  ]
+        *out_covers=0;
         *poldData=replace_oldData;
         *ptemp_cache=temp_cache;
         *ptemp_cache_end=temp_cache_end;
         return hpatch_TRUE;
     }
-    return hpatch_FALSE;
-}
-#endif //_IS_NEED_CACHE_OLD_ALL
-
-static hpatch_BOOL _patch_cache(hpatch_TCovers** out_covers,
-                                const hpatch_TStreamInput** poldData,hpatch_StreamPos_t newDataSize,
-                                const hpatch_TStreamInput*  diffData,hpatch_BOOL isCompressedDiff,
-                                hpatch_TDecompress* decompressPlugin,size_t kCacheCount,
-                                TByte** ptemp_cache,TByte** ptemp_cache_end,hpatch_BOOL* out_isReadError){
-    const hpatch_TStreamInput* oldData=*poldData;
 #if (_IS_NEED_CACHE_OLD_BY_COVERS)
-    const hpatch_size_t kBestACacheSize=hpatch_kFileIOBufBetterSize;   //optimal hpatch_kStreamCacheSize value when sufficient memory is available;
-    const hpatch_size_t _minActiveSize=(1<<20)*3+kBestACacheSize*kCacheCount*2;
-    const hpatch_StreamPos_t _betterActiveSize=oldData->streamSize/16+kBestACacheSize*kCacheCount*2;
-    const hpatch_size_t kActiveCacheOldMemorySize = //min memory threshold for attempting to activate CacheOld functionality;
-                (_minActiveSize>_betterActiveSize)?_minActiveSize:(hpatch_size_t)_betterActiveSize;
-#endif //_IS_NEED_CACHE_OLD_BY_COVERS
-    TByte* temp_cache=*ptemp_cache;
-    TByte* temp_cache_end=*ptemp_cache_end;
-    *out_covers=0;
-    if (_patch_cache_all_old(poldData,kCacheCount*hpatch_kStreamCacheSize,ptemp_cache,ptemp_cache_end,out_isReadError))
-        return hpatch_TRUE;//cache all oldData
-    if (*out_isReadError) return hpatch_FALSE;
-#if (_IS_NEED_CACHE_OLD_BY_COVERS)
-    if ((hpatch_size_t)(temp_cache_end-temp_cache)>=kActiveCacheOldMemorySize) {// try cache part of oldData
+    else if ((hpatch_size_t)(temp_cache_end-temp_cache)>=kActiveCacheOldMemorySize) {
         hpatch_BOOL         isUsedCover32;
         TByte*              temp_cache_end_back=temp_cache_end;
         _TArrayCovers*      arrayCovers=0;
@@ -1894,7 +1789,7 @@ static hpatch_BOOL _patch_cache(hpatch_TCovers** out_covers,
             // [                       ...                                 |   compressedCovers cache   ]
             // [           (cacheSize-kBestACacheSize)                     |      (kBestACacheSize)     ]
             *out_covers=&compressedCovers->base.ICovers;
-            isUsedCover32=(diffInfo.oldDataSize|diffInfo.newDataSize)<((hpatch_uint64_t)1<<32);
+            isUsedCover32=(diffInfo.oldDataSize|diffInfo.newDataSize)<((hpatch_StreamPos_t)1<<32);
         }else{
             _TPackedCovers* packedCovers=0;
             _THDiffHead     diffHead;
@@ -1906,7 +1801,7 @@ static hpatch_BOOL _patch_cache(hpatch_TCovers** out_covers,
             // [                       ...                                 |     packedCovers cache     ]
             // [          (cacheSize-kBestACacheSize*3)                    |    (kBestACacheSize*3)     ]
             *out_covers=&packedCovers->base.ICovers;
-            isUsedCover32=(oldDataSize|newDataSize)<((hpatch_uint64_t)1<<32);
+            isUsedCover32=(oldDataSize|newDataSize)<((hpatch_StreamPos_t)1<<32);
         }
         
         if (!_arrayCovers_load(&arrayCovers,*out_covers,isUsedCover32,
@@ -1990,7 +1885,7 @@ hpatch_BOOL patch_decompress_with_cache(const hpatch_TStreamOutput* out_newData,
     _patch_cache(&covers,&oldData,out_newData->streamSize,compressedDiff,hpatch_TRUE,
                  decompressPlugin,_kCacheDecCount,&temp_cache,&temp_cache_end,&isReadError);
     if (isReadError) return _hpatch_FALSE;
-    result=_patch_decompress_cache(out_newData,oldData,compressedDiff,decompressPlugin,
+    result=_patch_decompress_cache(out_newData,0,oldData,compressedDiff,decompressPlugin,
                                    covers,temp_cache,temp_cache_end);
     if ((covers!=0)&&(!covers->close(covers))) result=_hpatch_FALSE;
     return result;
@@ -2001,7 +1896,7 @@ hpatch_BOOL patch_decompress(const hpatch_TStreamOutput* out_newData,
                              const hpatch_TStreamInput*  compressedDiff,
                              hpatch_TDecompress* decompressPlugin){
     TByte temp_cache[hpatch_kStreamCacheSize*_kCacheDecCount];
-    return _patch_decompress_cache(out_newData,oldData,compressedDiff,decompressPlugin,
+    return _patch_decompress_cache(out_newData,0,oldData,compressedDiff,decompressPlugin,
                                    0,temp_cache,temp_cache+sizeof(temp_cache)/sizeof(TByte));
 }
 
@@ -2040,74 +1935,32 @@ hpatch_BOOL hpatch_coverList_open_compressedDiff(hpatch_TCoverList* out_coverLis
 
 //
 
-#if (_HPATCH_IS_USED_MULTITHREAD)
-#   include "hpatch_mt/hpatch_mt.h"
-#endif
+#define     _kCacheSgCount  3
 
-hpatch_BOOL _patch_single_compressed_diff_mt(const hpatch_TStreamOutput* out_newData,
-                                             const hpatch_TStreamInput*  oldData,
-                                             const hpatch_TStreamInput*  singleCompressedDiff,
-                                             hpatch_StreamPos_t          diffData_pos,
-                                             hpatch_StreamPos_t          uncompressedSize,
-                                             hpatch_StreamPos_t          compressedSize,
-                                             hpatch_TDecompress*         decompressPlugin,
-                                             hpatch_StreamPos_t coverCount,hpatch_size_t stepMemSize,
-                                             unsigned char* temp_cache,unsigned char* temp_cache_end,
-                                             sspatch_coversListener_t* coversListener,
-                                             size_t maxThreadNum,hpatchMTSets_t hpatchMTSets){
-#if (_HPATCH_IS_USED_MULTITHREAD)
-    struct hpatch_mt_manager_t* hpatch_mt_manager=0;
-    hpatchMTSets_t mtsets=hpatch_getMTSets(out_newData->streamSize,oldData->streamSize,singleCompressedDiff->streamSize-diffData_pos,
-                                           decompressPlugin,_kCacheSgCount,stepMemSize,
-                                           temp_cache_end-temp_cache,maxThreadNum,hpatchMTSets);
-#endif
+hpatch_BOOL patch_single_compressed_diff(const hpatch_TStreamOutput* out_newData,
+                                         const hpatch_TStreamInput*  oldData,
+                                         const hpatch_TStreamInput*  singleCompressedDiff,
+                                         hpatch_StreamPos_t          diffData_pos,
+                                         hpatch_StreamPos_t          uncompressedSize,
+                                         hpatch_TDecompress*         decompressPlugin,
+                                         hpatch_StreamPos_t coverCount,hpatch_size_t stepMemSize,
+                                         unsigned char* temp_cache,unsigned char* temp_cache_end){
     hpatch_BOOL result;
-    hpatch_BOOL isNeedOutCache=hpatch_TRUE;
     hpatch_TUncompresser_t uncompressedStream;
-    hpatch_StreamPos_t diffData_posEnd;
     memset(&uncompressedStream,0,sizeof(uncompressedStream));
-    if (compressedSize==0){
-        decompressPlugin=0;
-    }else{
-        if (decompressPlugin==0) return _hpatch_FALSE;
-    }
-    diffData_posEnd=(decompressPlugin?compressedSize:uncompressedSize)+diffData_pos;
-    if (diffData_posEnd>singleCompressedDiff->streamSize) return _hpatch_FALSE;
-#if (_HPATCH_IS_USED_MULTITHREAD)
-    mtsets.decompressDiff_isMT=decompressPlugin? mtsets.decompressDiff_isMT:0;
-    if (_hpatchMTSets_threadNum(mtsets)>1){
-        isNeedOutCache=!mtsets.writeNew_isMT;
-        hpatch_mt_manager=hpatch_mt_manager_open(&out_newData,&oldData,&singleCompressedDiff,
-                                                 &diffData_pos,&diffData_posEnd,uncompressedSize,&decompressPlugin,
-                                                 stepMemSize,&temp_cache,&temp_cache_end,&coversListener,hpatch_TRUE,
-                                                 _kCacheSgCount-(isNeedOutCache?0:1),mtsets);
-        if (!hpatch_mt_manager) return _hpatch_FALSE;
-    }
-#endif
     if (decompressPlugin){
         if (!compressed_stream_as_uncompressed(&uncompressedStream,uncompressedSize,decompressPlugin,singleCompressedDiff,
-                                               diffData_pos,diffData_posEnd)) return _hpatch_FALSE;
+                                               diffData_pos,singleCompressedDiff->streamSize)) return _hpatch_FALSE;
         singleCompressedDiff=&uncompressedStream.base;
         diffData_pos=0;
-        diffData_posEnd=singleCompressedDiff->streamSize;
     }
-
-    result=patch_single_stream_diff(out_newData,oldData,singleCompressedDiff,diffData_pos,diffData_posEnd,
-                                    coverCount,stepMemSize,temp_cache,temp_cache_end,coversListener,isNeedOutCache);
-
+    result=patch_single_stream_diff(out_newData,oldData,singleCompressedDiff,diffData_pos,
+                                    coverCount,stepMemSize,temp_cache,temp_cache_end);
     if (decompressPlugin)
         close_compressed_stream_as_uncompressed(&uncompressedStream);
-#if (_HPATCH_IS_USED_MULTITHREAD)
-    if (hpatch_mt_manager){
-        if (!hpatch_mt_manager_close(hpatch_mt_manager,!result))
-            result=_hpatch_FALSE;
-        hpatch_mt_manager=0;
-    }
-#endif
     return result;
 }
 
-static const size_t _kStepMemSizeSafeLimit =(1<<20)*16;
 hpatch_BOOL getSingleCompressedDiffInfo(hpatch_singleCompressedDiffInfo* out_diffInfo,
                                         const hpatch_TStreamInput* singleCompressedDiff,
                                         hpatch_StreamPos_t         diffInfo_pos){
@@ -2133,11 +1986,7 @@ hpatch_BOOL getSingleCompressedDiffInfo(hpatch_singleCompressedDiffInfo* out_dif
     _clip_unpackUIntTo(&out_diffInfo->uncompressedSize,diffHeadClip);
     _clip_unpackUIntTo(&out_diffInfo->compressedSize,diffHeadClip);
     out_diffInfo->diffDataPos=_TStreamCacheClip_readPosOfSrcStream(diffHeadClip)-diffInfo_pos;
-    if (out_diffInfo->compressedSize>out_diffInfo->uncompressedSize)
-        return _hpatch_FALSE;
-    if (out_diffInfo->stepMemSize>(out_diffInfo->newDataSize>=_kStepMemSizeSafeLimit?out_diffInfo->newDataSize:_kStepMemSizeSafeLimit))
-        return _hpatch_FALSE;
-    if (out_diffInfo->stepMemSize>out_diffInfo->uncompressedSize)
+    if (out_diffInfo->stepMemSize>(size_t)((~(size_t)0)-hpatch_kStreamCacheSize*_kCacheSgCount)) 
         return _hpatch_FALSE;
     return hpatch_TRUE;
 }
@@ -2241,7 +2090,7 @@ static hpatch_BOOL _rle0_decoder_add(rle0_decoder_t* self,TByte* out_data,hpatch
 }
 
 
-static  hpatch_BOOL _patch_add_old_with_rle0(_TOutStreamCache* outCache,rle0_decoder_t* rle0_decoder,
+static  hpatch_BOOL _patch_add_old_with_rle0(TOutStreamCache* outCache,rle0_decoder_t* rle0_decoder,
                                              const hpatch_TStreamInput* old,hpatch_StreamPos_t oldPos,
                                              hpatch_StreamPos_t addLength,TByte* aCache,hpatch_size_t aCacheSize){
     while (addLength>0){
@@ -2250,286 +2099,87 @@ static  hpatch_BOOL _patch_add_old_with_rle0(_TOutStreamCache* outCache,rle0_dec
             decodeStep=(hpatch_size_t)addLength;
         if (!old->read(old,oldPos,aCache,aCache+decodeStep)) return _hpatch_FALSE;
         if (!_rle0_decoder_add(rle0_decoder,aCache,decodeStep)) return _hpatch_FALSE;
-        if (!_TOutStreamCache_write(outCache,aCache,decodeStep)) return _hpatch_FALSE;
+        if (!TOutStreamCache_write(outCache,aCache,decodeStep)) return _hpatch_FALSE;
         oldPos+=decodeStep;
         addLength-=decodeStep;
     }
     return hpatch_TRUE;
 }
 
-hpatch_BOOL sspatch_covers_nextCover(sspatch_covers_t* self){
-    hpatch_BOOL inc_oldPos_sign=(*(self->covers_cache))>>(8-1);
-    self->lastOldEnd=self->cover.oldPos+self->cover.length;
-    self->lastNewEnd=self->cover.newPos+self->cover.length;
-    if (!hpatch_unpackUIntWithTag(&self->covers_cache,self->covers_cacheEnd,&self->cover.oldPos,1)) return _hpatch_FALSE;
-    if (inc_oldPos_sign==0)
-        self->cover.oldPos+=self->lastOldEnd;
-    else
-        self->cover.oldPos=self->lastOldEnd-self->cover.oldPos;
-    if (!hpatch_unpackUInt(&self->covers_cache,self->covers_cacheEnd,&self->cover.newPos)) return _hpatch_FALSE;
-    self->cover.newPos+=self->lastNewEnd;
-    if (!hpatch_unpackUInt(&self->covers_cache,self->covers_cacheEnd,&self->cover.length)) return _hpatch_FALSE;
-    return hpatch_TRUE;
-}
-
-
-#if (_IS_NEED_CACHE_OLD_BY_COVERS)
-
-#define     _kMaxCachedLen_min      (32*1024)   // 1M is big value, 256k is middle value, 32k is small value
-#define     _kMaxCachedLen_max      (32*_kMaxCachedLen_min)
-#define     _kMemForReadOldSize     (hpatch_kFileIOBufBetterSize*2)
-
-typedef struct{
-    _cache_old_TStreamInput     cache_old;
-    hpatch_TStreamInput         base;
-    sspatch_covers_t            covers;
-    hpatch_BOOL                 isHaveACover;
-    hpatch_size_t               sumCacheLen;
-    hpatch_byte*                cache_buf_end;
-    const hpatch_byte*          covers_cache;
-    const hpatch_byte*          covers_cacheEnd;
-} _step_cache_old_t;
-
-static hpatch_force_inline hpatch_size_t _step_cache_old_sumBufSize(const _step_cache_old_t* self){
-                                                return self->cache_old.cachesEnd-(const hpatch_byte*)self->cache_old.arrayCovers.pCCovers; }
-static hpatch_force_inline hpatch_size_t _step_cache_old_coverBufSize(const _step_cache_old_t* self){
-                                                return (hpatch_size_t)arrayCovers_memSize(self->cache_old.arrayCovers.coverCount,self->cache_old.arrayCovers.is32); }
-static hpatch_force_inline hpatch_StreamPos_t _step_cache_old_incCoverBufSize(const _step_cache_old_t* self){
-                                                return arrayCovers_memSize(self->cache_old.arrayCovers.coverCount+1,self->cache_old.arrayCovers.is32); }
-
-
-static hpatch_BOOL _step_cache_old_addCover(_step_cache_old_t* self,const hpatch_TCover* cover){
-    const hpatch_StreamPos_t _incCoverBufSize=_step_cache_old_incCoverBufSize(self);
-    while (hpatch_TRUE){
-        const hpatch_size_t _addCachedLen=(cover->length<=self->cache_old.maxCachedLen)?(hpatch_size_t)cover->length:0;
-        if (_incCoverBufSize+self->sumCacheLen+_addCachedLen<=_step_cache_old_sumBufSize(self)){
-            self->sumCacheLen+=_addCachedLen;
-            _arrayCovers_push_cover(&self->cache_old.arrayCovers,cover);
-            return hpatch_TRUE;
-        }else{
-            assert(self->cache_old.maxCachedLen>=_kMaxCachedLen_min);
-            if (self->cache_old.maxCachedLen==_kMaxCachedLen_min) return hpatch_FALSE;
-            self->cache_old.maxCachedLen/=2;
-            self->sumCacheLen=(hpatch_size_t)_getCacheSumLen(&self->cache_old.arrayCovers,self->cache_old.maxCachedLen);
-        }
-    }
-}
-
-static hpatch_BOOL _patch_step_cache_old_update(void* _self){
-    _step_cache_old_t* self=(_step_cache_old_t*)_self;
-    hpatch_StreamPos_t oldPosBegin;
-    hpatch_StreamPos_t oldPosEnd;
-    const hpatch_size_t kMinCacheCoverCount=0; //no limit
-    assert(self->cache_old.arrayCovers.coverCount<=self->cache_old.arrayCovers.cur_index);
-    assert(self->cache_old.caches==self->cache_old.cachesEnd);
-    self->sumCacheLen=0;
-    self->cache_old.arrayCovers.coverCount=0;
-    self->cache_old.arrayCovers.cur_index=0;
-    self->cache_old.cachesEnd=self->cache_buf_end-_kMemForReadOldSize; //limit covers + cached data 's size
-    self->cache_old.maxCachedLen=_kMaxCachedLen_max;
-    while ((self->cache_old.maxCachedLen>=_step_cache_old_sumBufSize(self))&(self->cache_old.maxCachedLen>_kMaxCachedLen_min))
-        self->cache_old.maxCachedLen/=2;
-
-    //read some cover from self->covers to self->cache_old.arrayCovers
-    if (self->isHaveACover){
-        self->isHaveACover=hpatch_FALSE;
-        assert(self->covers.cover.length>0);
-        if (!_step_cache_old_addCover(self,&self->covers.cover)) assert(hpatch_FALSE);
-    }
-    while (sspatch_covers_isHaveNextCover(&self->covers)){
-        if (!sspatch_covers_nextCover(&self->covers))
-            return hpatch_FALSE;
-        if (self->covers.cover.length>0){
-            if (_step_cache_old_addCover(self,&self->covers.cover)){
-                //ok
-            }else{
-                self->isHaveACover=hpatch_TRUE;
-                break; //arrayCovers full
-            }
-        }
-    }
-
-    self->cache_old.maxCachedLen=_getMaxCachedLen(&self->cache_old.arrayCovers,_step_cache_old_sumBufSize(self)-_step_cache_old_coverBufSize(self));
-    assert(self->cache_old.maxCachedLen>0);
-    self->sumCacheLen=_set_cache_pos(&self->cache_old.arrayCovers,self->cache_old.maxCachedLen,&oldPosBegin,&oldPosEnd,kMinCacheCoverCount);
-    self->cache_old.caches=((hpatch_byte*)self->cache_old.arrayCovers.pCCovers)+_step_cache_old_coverBufSize(self);
-    self->cache_old.cachesEnd=self->cache_old.caches+self->sumCacheLen;
-    if (self->sumCacheLen>0){
-        if (!_cache_old_load(self->cache_old.oldData,oldPosBegin,oldPosEnd,&self->cache_old.arrayCovers,
-                             self->cache_old.maxCachedLen,self->sumCacheLen, (hpatch_byte*)self->cache_old.caches,
-                             (hpatch_byte*)self->cache_old.cachesEnd,self->cache_buf_end))
-            return _hpatch_FALSE;
-    }
-    return hpatch_TRUE;
-}
-
-static hpatch_inline
-void _patch_step_cache_old_init(_step_cache_old_t* self,hpatch_size_t canUsedMemSize,
-                                const hpatch_TStreamInput* oldData,hpatch_BOOL isUsedCover32){
-    memset(self,0,sizeof(*self));
-    assert(canUsedMemSize>=_kMemForReadOldSize*2);
-    self->base.streamImport=&self->cache_old;
-    self->base.streamSize=oldData->streamSize;
-    self->base.read=_cache_old_StreamInput_read;
-    //todo: _cache_old_StreamInput_read call back
-    self->cache_old.oldData=oldData;
-    self->cache_old._cacheImport=self;
-    self->cache_old._doUpdateCacheCovers=_patch_step_cache_old_update;
-    self->cache_buf_end=((hpatch_byte*)self) + canUsedMemSize;
-
-    self->cache_old.arrayCovers.is32=isUsedCover32;
-    self->cache_old.arrayCovers.pCCovers=(void*)_hpatch_align_upper((self+1),sizeof(hpatch_StreamPos_t));
-    self->cache_old.arrayCovers.ICovers.leave_cover_count=_arrayCovers_leaveCoverCount;
-    self->cache_old.arrayCovers.ICovers.read_cover=_arrayCovers_read_cover;
-}
-
-
-hpatch_BOOL _patch_step_cache_old_onStepCovers(const hpatch_TStreamInput* _self,const unsigned char* covers_cache,const unsigned char* covers_cacheEnd){
-    _step_cache_old_t* self=(_step_cache_old_t*)_self->streamImport;
-    assert(!sspatch_covers_isHaveNextCover(&self->covers));
-    assert(!self->isHaveACover);
-    self->covers_cache=covers_cache;
-    self->covers_cacheEnd=covers_cacheEnd;
-    sspatch_covers_setCoversCache(&self->covers,covers_cache,covers_cacheEnd);
-    return covers_cache?_patch_step_cache_old_update(self):hpatch_TRUE;
-}
-
-
-hpatch_size_t _patch_step_cache_old_canUsedSize(hpatch_size_t stepCoversMemSize,hpatch_size_t kMinTempCacheSize,hpatch_size_t tempCacheSize){
-    const hpatch_size_t  kActiveCacheOldMemorySize=(1<<20)*3+_kMemForReadOldSize*2;
-    hpatch_size_t cacheStepSize,multiple;
-    if (tempCacheSize<kActiveCacheOldMemorySize+stepCoversMemSize+kMinTempCacheSize)
-        return 0;
-    cacheStepSize=tempCacheSize-(stepCoversMemSize+kMinTempCacheSize+sizeof(hpatch_StreamPos_t));
-    multiple=cacheStepSize/((kActiveCacheOldMemorySize+kMinTempCacheSize+_kMemForReadOldSize)/4);
-    cacheStepSize-=(hpatch_size_t)((hpatch_StreamPos_t)(kMinTempCacheSize+_kMemForReadOldSize)*((multiple>4)?(hpatch_size_t)(multiple-4):0)/8);
-    return cacheStepSize;
-}
-
-hpatch_BOOL _patch_step_cache_old(const hpatch_TStreamInput** poldData,hpatch_StreamPos_t newDataSize,size_t stepCoversMemSize,
-                                  size_t kMinTempCacheSize,hpatch_byte** ptemp_cache,hpatch_byte** ptemp_cache_end){
-    const hpatch_TStreamInput* oldData=*poldData;
-    _step_cache_old_t*  self;
-    const hpatch_BOOL   isUsedCover32=(oldData->streamSize|newDataSize)<((hpatch_uint64_t)1<<32);
-    hpatch_byte* temp_cache=*ptemp_cache;
-    hpatch_byte* const temp_cache_end=*ptemp_cache_end;
-
-    hpatch_size_t canUsedMemSize=_patch_step_cache_old_canUsedSize(stepCoversMemSize,kMinTempCacheSize,temp_cache_end-temp_cache);
-    if (canUsedMemSize==0)
-        return hpatch_FALSE; //not enough memory for cache part of oldData
-    _cache_alloc(self,_step_cache_old_t,canUsedMemSize,temp_cache,temp_cache_end);
-    _patch_step_cache_old_init(self,canUsedMemSize,oldData,isUsedCover32);
-
-    *poldData=&self->base;
-    *ptemp_cache=temp_cache;
-    return hpatch_TRUE;
-}
-
-#endif // _IS_NEED_CACHE_OLD_BY_COVERS
-
-
 hpatch_BOOL patch_single_stream_diff(const hpatch_TStreamOutput*  out_newData,
                                      const hpatch_TStreamInput*   oldData,
                                      const hpatch_TStreamInput*   uncompressedDiffData,
                                      hpatch_StreamPos_t           diffData_pos,
-                                     hpatch_StreamPos_t           diffData_posEnd,
                                      hpatch_StreamPos_t coverCount,hpatch_size_t stepMemSize,
-                                     unsigned char* temp_cache,unsigned char* temp_cache_end,
-                                     sspatch_coversListener_t* coversListener,hpatch_BOOL isNeedOutCache){
-    unsigned char*      step_cache;
+                                     unsigned char* temp_cache,unsigned char* temp_cache_end){
+    unsigned char*      step_cache=temp_cache;
+    hpatch_StreamPos_t  lastOldEnd=0;
+    hpatch_StreamPos_t  lastNewEnd=0;
     hpatch_size_t       cache_size;
     TStreamCacheClip    inClip;
-    _TOutStreamCache    outCache;
-    const size_t        kCacheCount=_kCacheSgCount-(isNeedOutCache?0:1);
-    sspatch_covers_t    covers;
-#if (_IS_NEED_CACHE_OLD_BY_COVERS)
-    hpatch_BOOL         isCachedOldByStep=hpatch_FALSE;
-#endif
-
-    step_cache=temp_cache;
-    assert(diffData_posEnd<=uncompressedDiffData->streamSize);
-    sspatch_covers_init(&covers);
-    if (coversListener) assert(coversListener->onStepCovers);
-    {//cache
-        hpatch_BOOL isCachedAllOld;
-        hpatch_BOOL isReadError=hpatch_FALSE;
-        if ((size_t)(temp_cache_end-temp_cache)<stepMemSize+hpatch_kStreamCacheSize*kCacheCount) return _hpatch_FALSE;
-        temp_cache+=stepMemSize;
-        isCachedAllOld=_patch_cache_all_old(&oldData,kCacheCount*hpatch_kStreamCacheSize,&temp_cache,&temp_cache_end,&isReadError);
-        if (isReadError) return _hpatch_FALSE;
-    #if (_IS_NEED_CACHE_OLD_BY_COVERS)
-        if (!isCachedAllOld)
-            isCachedOldByStep=_patch_step_cache_old(&oldData,out_newData->streamSize,stepMemSize,
-                                                    kCacheCount*hpatch_kFileIOBufBetterSize,&temp_cache,&temp_cache_end);
-    #endif
-        cache_size=(temp_cache_end-temp_cache)/kCacheCount;
-        _TStreamCacheClip_init(&inClip,uncompressedDiffData,diffData_pos,diffData_posEnd,
-                               temp_cache,cache_size);
-        temp_cache+=cache_size;
-        _TOutStreamCache_init(&outCache,out_newData,isNeedOutCache?(temp_cache+cache_size):0,isNeedOutCache?cache_size:0);
-    }
+    TOutStreamCache     outCache;
+    if ((size_t)(temp_cache_end-temp_cache)<stepMemSize+hpatch_kStreamCacheSize*_kCacheSgCount) return _hpatch_FALSE;
+    temp_cache+=stepMemSize;
+    cache_size=(temp_cache_end-temp_cache)/_kCacheSgCount;
+    _TStreamCacheClip_init(&inClip,uncompressedDiffData,diffData_pos,uncompressedDiffData->streamSize,
+                           temp_cache,cache_size);
+    temp_cache+=cache_size;
+    TOutStreamCache_init(&outCache,out_newData,temp_cache+cache_size,cache_size);
     while (coverCount) {//step loop
+        const unsigned char* covers_cache     = step_cache;
+        const unsigned char* covers_cache_end;
         rle0_decoder_t       rle0_decoder;
         {//read step info
-            unsigned char*      covers_cacheEnd;
-            unsigned char*      bufRle_cache_end;
-            {
-                hpatch_StreamPos_t  bufCover_size;
-                hpatch_StreamPos_t  bufRle_size;
-                _clip_unpackUIntTo(&bufCover_size,&inClip);
-                _clip_unpackUIntTo(&bufRle_size,&inClip);
-                #ifdef __RUN_MEM_SAFE_CHECK
-                    if ((bufCover_size>stepMemSize)|(bufRle_size>stepMemSize)|
-                        (bufCover_size+bufRle_size>stepMemSize)) return _hpatch_FALSE;
-                #endif
-                covers_cacheEnd=step_cache+(size_t)bufCover_size;
-                bufRle_cache_end=covers_cacheEnd+(size_t)bufRle_size;
-            }
-            if (coversListener&&coversListener->onStepCoversReset)
-                coversListener->onStepCoversReset(coversListener,coverCount);
-            if (!_TStreamCacheClip_readDataTo(&inClip,step_cache,bufRle_cache_end))
-                return _hpatch_FALSE;
-            if (coversListener)
-                coversListener->onStepCovers(coversListener,step_cache,covers_cacheEnd);
-        #if (_IS_NEED_CACHE_OLD_BY_COVERS)
-            if (isCachedOldByStep)
-                _patch_step_cache_old_onStepCovers(oldData,step_cache,covers_cacheEnd);
-        #endif
-            sspatch_covers_setCoversCache(&covers,step_cache,covers_cacheEnd);
-            _rle0_decoder_init(&rle0_decoder,covers_cacheEnd,bufRle_cache_end);
+            hpatch_StreamPos_t bufCover_size;
+            hpatch_StreamPos_t bufRle_size;
+            _clip_unpackUIntTo(&bufCover_size,&inClip);
+            _clip_unpackUIntTo(&bufRle_size,&inClip);
+            if (bufCover_size+bufRle_size>stepMemSize) return _hpatch_FALSE;
+            if (!_TStreamCacheClip_readDataTo(&inClip,step_cache,step_cache+bufCover_size+bufRle_size)) return _hpatch_FALSE;
+            covers_cache_end=covers_cache+bufCover_size;
+            _rle0_decoder_init(&rle0_decoder,covers_cache_end,covers_cache_end+bufRle_size);
         }
-        while (sspatch_covers_isHaveNextCover(&covers)) {//cover loop
-            if (!sspatch_covers_nextCover(&covers)) 
-                return _hpatch_FALSE;
-            if (covers.cover.newPos>covers.lastNewEnd){
-                if (!_TOutStreamCache_copyFromClip(&outCache,&inClip,covers.cover.newPos-covers.lastNewEnd))
-                    return _hpatch_FALSE;
+        while (covers_cache!=covers_cache_end) {// cover loop
+            hpatch_StreamPos_t oldPos;
+            hpatch_StreamPos_t newPos;
+            hpatch_StreamPos_t coverLen;
+            {//read cover
+                hpatch_BOOL inc_oldPos_sign;
+                if (covers_cache==covers_cache_end) return _hpatch_FALSE;
+                inc_oldPos_sign=(*covers_cache)>>7;
+                if (!hpatch_unpackUIntWithTag(&covers_cache,covers_cache_end,&oldPos,1)) return _hpatch_FALSE;
+                if (inc_oldPos_sign==0)
+                    oldPos+=lastOldEnd;
+                else
+                    oldPos=lastOldEnd-oldPos;
+                if (!hpatch_unpackUInt(&covers_cache,covers_cache_end,&newPos)) return _hpatch_FALSE;
+                newPos+=lastNewEnd;
+                if (!hpatch_unpackUInt(&covers_cache,covers_cache_end,&coverLen)) return _hpatch_FALSE;
+            }
+            
+            if (newPos>lastNewEnd){
+                if (!_patch_copy_diff_by_outCache(&outCache,&inClip,newPos-lastNewEnd)) return _hpatch_FALSE;
             }
             
             --coverCount;
-            if (covers.cover.length){
+            if (coverLen){
                 #ifdef __RUN_MEM_SAFE_CHECK
-                    if ((covers.cover.oldPos>oldData->streamSize)|
-                        (covers.cover.length>(hpatch_StreamPos_t)(oldData->streamSize-covers.cover.oldPos))) return _hpatch_FALSE;
+                    if (oldPos>oldData->streamSize) return _hpatch_FALSE;
+                    if (coverLen>(hpatch_StreamPos_t)(oldData->streamSize-oldPos)) return _hpatch_FALSE;
                 #endif
-                if (!_patch_add_old_with_rle0(&outCache,&rle0_decoder,oldData,covers.cover.oldPos,covers.cover.length,
+                if (!_patch_add_old_with_rle0(&outCache,&rle0_decoder,oldData,oldPos,coverLen,
                                               temp_cache,cache_size)) return _hpatch_FALSE;
+                lastOldEnd=oldPos+coverLen;
+                lastNewEnd=newPos+coverLen;
             }else{
-                #ifdef __RUN_MEM_SAFE_CHECK
-                    if (coverCount!=0) return _hpatch_FALSE;
-                #endif
+                if (coverCount!=0) return _hpatch_FALSE;
             }
         }
     }
-    if (coversListener){
-        if (coversListener->onStepCoversReset)
-            coversListener->onStepCoversReset(coversListener,0);
-        coversListener->onStepCovers(coversListener,0,0);
-    }
     
-    if (!_TOutStreamCache_flush(&outCache))
+    if (!TOutStreamCache_flush(&outCache))
         return _hpatch_FALSE;
-    if (_TStreamCacheClip_isFinish(&inClip)&_TOutStreamCache_isFinish(&outCache)&(coverCount==0))
+    if (_TStreamCacheClip_isFinish(&inClip)&TOutStreamCache_isFinish(&outCache)&(coverCount==0))
         return hpatch_TRUE;
     else
         return _hpatch_FALSE;
@@ -2599,14 +2249,12 @@ void TDiffToSingleStream_init(TDiffToSingleStream* self,const hpatch_TStreamInpu
     self->isInSingleStream=hpatch_FALSE;
 }
 
-hpatch_BOOL _patch_single_stream_mt(sspatch_listener_t* listener,
-                                    const hpatch_TStreamOutput* __out_newData,
-                                    const hpatch_TStreamInput*  oldData,
-                                    const hpatch_TStreamInput*  singleCompressedDiff, 
-                                    hpatch_StreamPos_t  diffInfo_pos,
-                                    sspatch_coversListener_t* coversListener,
-                                    size_t maxThreadNum,hpatchMTSets_t hpatchMTSets){
-    hpatch_BOOL result=hpatch_TRUE;
+hpatch_BOOL patch_single_stream_by(sspatch_listener_t* listener,
+                                   const hpatch_TStreamOutput* __out_newData,
+                                   const hpatch_TStreamInput*  oldData,
+                                   const hpatch_TStreamInput*  singleCompressedDiff, 
+                                   hpatch_StreamPos_t  diffInfo_pos){
+    hpatch_BOOL result;
     hpatch_TDecompress*     decompressPlugin=0;
     unsigned char*          temp_cache=0;
     unsigned char*          temp_cacheEnd=0;
@@ -2625,19 +2273,20 @@ hpatch_BOOL _patch_single_stream_mt(sspatch_listener_t* listener,
     out_newData->streamSize=diffInfo.newDataSize;
     if (diffInfo.oldDataSize!=oldData->streamSize)
         return _hpatch_FALSE;
-    if (!listener->onDiffInfo(listener,&diffInfo,&decompressPlugin,&temp_cache,&temp_cacheEnd))
+    if ((diffInfo.compressedSize?diffInfo.compressedSize:diffInfo.uncompressedSize)
+        !=(singleCompressedDiff->streamSize-diffInfo.diffDataPos))
         return _hpatch_FALSE;
 
+    if (!listener->onDiffInfo(listener,&diffInfo,&decompressPlugin,&temp_cache,&temp_cacheEnd))
+        return _hpatch_FALSE;
     if ((temp_cache==0)||(temp_cache>=temp_cacheEnd))
-        result=_hpatch_FALSE;
-    if (result){
-        result=_patch_single_compressed_diff_mt(out_newData,oldData,singleCompressedDiff,diffInfo.diffDataPos,
-                                                diffInfo.uncompressedSize,diffInfo.compressedSize,decompressPlugin,
-                                                diffInfo.coverCount,(size_t)diffInfo.stepMemSize,
-                                                temp_cache,temp_cacheEnd,coversListener,maxThreadNum,hpatchMTSets);
-    }
+        return _hpatch_FALSE;
+    result=(diffInfo.compressType[0]=='\0')?(decompressPlugin==0):(decompressPlugin!=0);
+    result=result&&patch_single_compressed_diff(out_newData,oldData,singleCompressedDiff,
+                                                diffInfo.diffDataPos,diffInfo.uncompressedSize,
+                                                decompressPlugin,diffInfo.coverCount,
+                                                (size_t)diffInfo.stepMemSize,temp_cache,temp_cacheEnd);
     if (listener->onPatchFinish)
         listener->onPatchFinish(listener,temp_cache,temp_cacheEnd);
     return result;
 }
-