react-native-update 10.34.2 → 10.34.3

package/harmony/pushy/src/main/cpp/HDiffPatch/vcdiff_wrapper/vcpatch_wrapper.c

@@ -0,0 +1,950 @@
+// vcpatch_wrapper.c
+// HDiffPatch
+/*
+ The MIT License (MIT)
+ Copyright (c) 2022 HouSisong
+ 
+ Permission is hereby granted, free of charge, to any person
+ obtaining a copy of this software and associated documentation
+ files (the "Software"), to deal in the Software without
+ restriction, including without limitation the rights to use,
+ copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following
+ conditions:
+ 
+ The above copyright notice and this permission notice shall be
+ included in all copies of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ OTHER DEALINGS IN THE SOFTWARE.
+ */
+#include "vcpatch_wrapper.h"
+#include "../libHDiffPatch/HPatch/patch_types.h"
+#include "../libHDiffPatch/HPatch/patch_private.h"
+#include "../libHDiffPatch/HDiff/private_diff/limit_mem_diff/adler_roll.h"
+#include "vcpatch_code_table.h"
+#include <string.h>
+#define _hpatch_FALSE   hpatch_FALSE
+//hpatch_uint __vcpatch_debug_check_false_x=0; //for debug
+//#define _hpatch_FALSE (1/__vcpatch_debug_check_false_x)
+
+#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 out-of-bounds memory access checking to protect against data that may be accidentally or intentionally corrupted.
+#   define __RUN_MEM_SAFE_CHECK
+#endif
+
+static const hpatch_byte kVcDiffType[3]={('V'|(1<<7)),('C'|(1<<7)),('D'|(1<<7))};
+#define     kVcDiffDefaultVersion   0
+#define     kVcDiffGoogleVersion    'S'
+#define     kVcDiffMinHeadLen       (sizeof(kVcDiffType)+1+1)
+
+static const char* kHDiffzAppHead="$hdiffz-VCDIFF&";
+static const char* kHDiffzAppHead_version="#a";
+#define kHDiffzAppHead_len          15 // = strlen(kHDiffzAppHead);
+#define kHDiffzAppHead_version_len  2  // = strlen(kHDiffzAppHead_version);
+#define kHDiffzAppHead_maxLen       (kHDiffzAppHead_len+kHDiffzAppHead_version_len+hpatch_kMaxPluginTypeLength)
+
+#define _clip_unpackUInt64(_clip,_result) { \
+    if (!_TStreamCacheClip_unpackUIntWithTag(_clip,_result,0)) \
+        return _hpatch_FALSE; \
+}
+#define _clip_readUInt8(_clip,_result) { \
+    const hpatch_byte* buf=_TStreamCacheClip_readData(_clip,1); \
+    if (buf!=0) *(_result)=*buf; \
+    else return _hpatch_FALSE; \
+}
+#define _clip_readUInt32_BigEndian(_clip,_result) { \
+    const hpatch_byte* buf=_TStreamCacheClip_readData(_clip,4); \
+    if (buf!=0) *(_result)=(((hpatch_uint32_t)buf[0])<<24)|(((hpatch_uint32_t)buf[1])<<16) \
+                           |(((hpatch_uint32_t)buf[2])<<8)|((hpatch_uint32_t)buf[3]); \
+    else return _hpatch_FALSE; \
+}
+
+
+#define N   vcdiff_code_NOOP
+#define A   vcdiff_code_ADD
+#define R   vcdiff_code_RUN
+#define C   vcdiff_code_COPY
+#define C0  (C+0)
+#define C1  (C+1)
+#define C2  (C+2)
+#define C3  (C+3)
+#define C4  (C+4)
+#define C5  (C+5)
+#define C6  (C+6)
+#define C7  (C+7)
+#define C8  (C+8)
+
+/*
+        TYPE      SIZE     MODE    TYPE     SIZE     MODE     INDEX
+       ---------------------------------------------------------------
+    1.  RUN         0        0     NOOP       0        0        0
+    2.  ADD    0, [1,17]     0     NOOP       0        0      [1,18]
+    3.  COPY   0, [4,18]     0     NOOP       0        0     [19,34]
+    4.  COPY   0, [4,18]     1     NOOP       0        0     [35,50]
+    5.  COPY   0, [4,18]     2     NOOP       0        0     [51,66]
+    6.  COPY   0, [4,18]     3     NOOP       0        0     [67,82]
+    7.  COPY   0, [4,18]     4     NOOP       0        0     [83,98]
+    8.  COPY   0, [4,18]     5     NOOP       0        0     [99,114]
+    9.  COPY   0, [4,18]     6     NOOP       0        0    [115,130]
+   10.  COPY   0, [4,18]     7     NOOP       0        0    [131,146]
+   11.  COPY   0, [4,18]     8     NOOP       0        0    [147,162]
+   12.  ADD       [1,4]      0     COPY     [4,6]      0    [163,174]
+   13.  ADD       [1,4]      0     COPY     [4,6]      1    [175,186]
+   14.  ADD       [1,4]      0     COPY     [4,6]      2    [187,198]
+   15.  ADD       [1,4]      0     COPY     [4,6]      3    [199,210]
+   16.  ADD       [1,4]      0     COPY     [4,6]      4    [211,222]
+   17.  ADD       [1,4]      0     COPY     [4,6]      5    [223,234]
+   18.  ADD       [1,4]      0     COPY       4        6    [235,238]
+   19.  ADD       [1,4]      0     COPY       4        7    [239,242]
+   20.  ADD       [1,4]      0     COPY       4        8    [243,246]
+   21.  COPY        4      [0,8]   ADD        1        0    [247,255]
+       ---------------------------------------------------------------
+*/
+
+/* //gen _vcdiff_code_table_default
+static hpatch_byte* __incset(hpatch_byte* cur,hpatch_byte blockLen,hpatch_byte v,hpatch_byte runCount){
+    while (runCount--){
+        hpatch_byte runLen=blockLen;
+        while (runLen--){
+            *cur=v;
+            cur+=sizeof(vcdiff_code_pair_t);
+        }
+        v++;
+    }
+    return cur;
+}
+
+static hpatch_inline hpatch_byte* _inc(hpatch_byte* cur,hpatch_byte blockLen,hpatch_byte v,hpatch_byte indexs){
+    hpatch_byte runCount=(indexs+1)/blockLen;
+    assert(blockLen*runCount==(indexs+1));
+    return __incset(cur,blockLen,v,runCount);
+}
+
+static hpatch_inline hpatch_byte* _set(hpatch_byte* cur,hpatch_byte v,hpatch_byte indexs){
+                                            return __incset(cur,(indexs+1),v,1); }
+
+static hpatch_byte* _cpy(hpatch_byte* cur, hpatch_byte blockLen, hpatch_byte indexs) {
+    hpatch_byte runCount=(indexs+1)/blockLen;
+    assert(blockLen*runCount==(indexs+1));
+    const hpatch_size_t offset=(hpatch_size_t)blockLen*sizeof(vcdiff_code_pair_t);
+    while (runCount--){
+        hpatch_byte runLen=blockLen;
+        while (runLen--){
+            *cur=cur[-offset];
+            cur+=sizeof(vcdiff_code_pair_t);
+        }
+    }
+    return cur;
+}
+
+static int _set_vcdiff_code_table_default(vcdiff_code_table_t code_table){
+    hpatch_byte* cur0,* cur;
+
+    cur0=&code_table[0].code1.inst;
+    cur=cur0;
+    cur=_set(cur,R,0);
+    cur=_set(cur,A,18-1);
+    cur=_inc(cur,16,C,162-19);
+    cur=_set(cur,A,246-163);
+    cur=_inc(cur,1,C,255-247);
+    assert((cur-cur0)==256*sizeof(vcdiff_code_pair_t));
+
+    cur0=&code_table[0].code2.inst;
+    cur=cur0;
+    cur=_set(cur,N,162-0);
+    cur=_inc(cur,12,C,234-163);
+    cur=_inc(cur,4,C+6,246-235);
+    cur=_set(cur,A,255-247);
+    assert((cur-cur0)==256*sizeof(vcdiff_code_pair_t));
+
+    cur0=&code_table[0].code1.size;
+    cur=cur0;
+    cur=_inc(cur,1,0,0);
+    cur=_inc(cur,1,0,18-1);
+    cur=_inc(cur,1,0,19-19);
+    cur=_inc(cur,1,4,34-20);
+    cur=_cpy(cur,16,162-35);
+    cur=_inc(cur,3,1,174-163);
+    cur=_cpy(cur,12,234-175);
+    cur=_inc(cur,1,1,238-235);
+    cur=_cpy(cur,4,246-239);
+    cur=_set(cur,4,255-247);
+    assert((cur-cur0)==256*sizeof(vcdiff_code_pair_t));
+
+    cur0=&code_table[0].code2.size;
+    cur=cur0;
+    cur=_set(cur,0,162-0);
+    cur=_inc(cur,1,4,165-163);
+    cur=_cpy(cur,3,234-166);
+    cur=_set(cur,4,246-235);
+    cur=_set(cur,1,255-247);
+    assert((cur-cur0)==256*sizeof(vcdiff_code_pair_t));
+
+    return 0;
+}
+
+vcdiff_code_pair_t g_code_table[256];
+int _print_vcdiff_code_table_default(){
+    _set_vcdiff_code_table_default(g_code_table);
+    const char* inst2s[4+8]={" N"," A"," R","C0","C1","C2","C3","C4","C5","C6","C7","C8"};
+    for (int i=0;i<256;++i){
+        vcdiff_code_pair_t c=g_code_table[i];
+        printf("{{%s,%2d},{%s,%2d}},",inst2s[c.code1.inst],c.code1.size,inst2s[c.code2.inst],c.code2.size);
+        if (((i+1)&7)==0) printf("\n");
+    }
+    return 0;
+}
+*/
+
+//_vcdiff_code_table_default gen by _print_vcdiff_code_table_default()
+static const vcdiff_code_pair_t _vcdiff_code_table_default[256]={
+    {{ R, 0},{ N, 0}},{{ A, 0},{ N, 0}},{{ A, 1},{ N, 0}},{{ A, 2},{ N, 0}},{{ A, 3},{ N, 0}},{{ A, 4},{ N, 0}},{{ A, 5},{ N, 0}},{{ A, 6},{ N, 0}},
+    {{ A, 7},{ N, 0}},{{ A, 8},{ N, 0}},{{ A, 9},{ N, 0}},{{ A,10},{ N, 0}},{{ A,11},{ N, 0}},{{ A,12},{ N, 0}},{{ A,13},{ N, 0}},{{ A,14},{ N, 0}},
+    {{ A,15},{ N, 0}},{{ A,16},{ N, 0}},{{ A,17},{ N, 0}},{{C0, 0},{ N, 0}},{{C0, 4},{ N, 0}},{{C0, 5},{ N, 0}},{{C0, 6},{ N, 0}},{{C0, 7},{ N, 0}},
+    {{C0, 8},{ N, 0}},{{C0, 9},{ N, 0}},{{C0,10},{ N, 0}},{{C0,11},{ N, 0}},{{C0,12},{ N, 0}},{{C0,13},{ N, 0}},{{C0,14},{ N, 0}},{{C0,15},{ N, 0}},
+    {{C0,16},{ N, 0}},{{C0,17},{ N, 0}},{{C0,18},{ N, 0}},{{C1, 0},{ N, 0}},{{C1, 4},{ N, 0}},{{C1, 5},{ N, 0}},{{C1, 6},{ N, 0}},{{C1, 7},{ N, 0}},
+    {{C1, 8},{ N, 0}},{{C1, 9},{ N, 0}},{{C1,10},{ N, 0}},{{C1,11},{ N, 0}},{{C1,12},{ N, 0}},{{C1,13},{ N, 0}},{{C1,14},{ N, 0}},{{C1,15},{ N, 0}},
+    {{C1,16},{ N, 0}},{{C1,17},{ N, 0}},{{C1,18},{ N, 0}},{{C2, 0},{ N, 0}},{{C2, 4},{ N, 0}},{{C2, 5},{ N, 0}},{{C2, 6},{ N, 0}},{{C2, 7},{ N, 0}},
+    {{C2, 8},{ N, 0}},{{C2, 9},{ N, 0}},{{C2,10},{ N, 0}},{{C2,11},{ N, 0}},{{C2,12},{ N, 0}},{{C2,13},{ N, 0}},{{C2,14},{ N, 0}},{{C2,15},{ N, 0}},
+    {{C2,16},{ N, 0}},{{C2,17},{ N, 0}},{{C2,18},{ N, 0}},{{C3, 0},{ N, 0}},{{C3, 4},{ N, 0}},{{C3, 5},{ N, 0}},{{C3, 6},{ N, 0}},{{C3, 7},{ N, 0}},
+    {{C3, 8},{ N, 0}},{{C3, 9},{ N, 0}},{{C3,10},{ N, 0}},{{C3,11},{ N, 0}},{{C3,12},{ N, 0}},{{C3,13},{ N, 0}},{{C3,14},{ N, 0}},{{C3,15},{ N, 0}},
+    {{C3,16},{ N, 0}},{{C3,17},{ N, 0}},{{C3,18},{ N, 0}},{{C4, 0},{ N, 0}},{{C4, 4},{ N, 0}},{{C4, 5},{ N, 0}},{{C4, 6},{ N, 0}},{{C4, 7},{ N, 0}},
+    {{C4, 8},{ N, 0}},{{C4, 9},{ N, 0}},{{C4,10},{ N, 0}},{{C4,11},{ N, 0}},{{C4,12},{ N, 0}},{{C4,13},{ N, 0}},{{C4,14},{ N, 0}},{{C4,15},{ N, 0}},
+    {{C4,16},{ N, 0}},{{C4,17},{ N, 0}},{{C4,18},{ N, 0}},{{C5, 0},{ N, 0}},{{C5, 4},{ N, 0}},{{C5, 5},{ N, 0}},{{C5, 6},{ N, 0}},{{C5, 7},{ N, 0}},
+    {{C5, 8},{ N, 0}},{{C5, 9},{ N, 0}},{{C5,10},{ N, 0}},{{C5,11},{ N, 0}},{{C5,12},{ N, 0}},{{C5,13},{ N, 0}},{{C5,14},{ N, 0}},{{C5,15},{ N, 0}},
+    {{C5,16},{ N, 0}},{{C5,17},{ N, 0}},{{C5,18},{ N, 0}},{{C6, 0},{ N, 0}},{{C6, 4},{ N, 0}},{{C6, 5},{ N, 0}},{{C6, 6},{ N, 0}},{{C6, 7},{ N, 0}},
+    {{C6, 8},{ N, 0}},{{C6, 9},{ N, 0}},{{C6,10},{ N, 0}},{{C6,11},{ N, 0}},{{C6,12},{ N, 0}},{{C6,13},{ N, 0}},{{C6,14},{ N, 0}},{{C6,15},{ N, 0}},
+    {{C6,16},{ N, 0}},{{C6,17},{ N, 0}},{{C6,18},{ N, 0}},{{C7, 0},{ N, 0}},{{C7, 4},{ N, 0}},{{C7, 5},{ N, 0}},{{C7, 6},{ N, 0}},{{C7, 7},{ N, 0}},
+    {{C7, 8},{ N, 0}},{{C7, 9},{ N, 0}},{{C7,10},{ N, 0}},{{C7,11},{ N, 0}},{{C7,12},{ N, 0}},{{C7,13},{ N, 0}},{{C7,14},{ N, 0}},{{C7,15},{ N, 0}},
+    {{C7,16},{ N, 0}},{{C7,17},{ N, 0}},{{C7,18},{ N, 0}},{{C8, 0},{ N, 0}},{{C8, 4},{ N, 0}},{{C8, 5},{ N, 0}},{{C8, 6},{ N, 0}},{{C8, 7},{ N, 0}},
+    {{C8, 8},{ N, 0}},{{C8, 9},{ N, 0}},{{C8,10},{ N, 0}},{{C8,11},{ N, 0}},{{C8,12},{ N, 0}},{{C8,13},{ N, 0}},{{C8,14},{ N, 0}},{{C8,15},{ N, 0}},
+    {{C8,16},{ N, 0}},{{C8,17},{ N, 0}},{{C8,18},{ N, 0}},{{ A, 1},{C0, 4}},{{ A, 1},{C0, 5}},{{ A, 1},{C0, 6}},{{ A, 2},{C0, 4}},{{ A, 2},{C0, 5}},
+    {{ A, 2},{C0, 6}},{{ A, 3},{C0, 4}},{{ A, 3},{C0, 5}},{{ A, 3},{C0, 6}},{{ A, 4},{C0, 4}},{{ A, 4},{C0, 5}},{{ A, 4},{C0, 6}},{{ A, 1},{C1, 4}},
+    {{ A, 1},{C1, 5}},{{ A, 1},{C1, 6}},{{ A, 2},{C1, 4}},{{ A, 2},{C1, 5}},{{ A, 2},{C1, 6}},{{ A, 3},{C1, 4}},{{ A, 3},{C1, 5}},{{ A, 3},{C1, 6}},
+    {{ A, 4},{C1, 4}},{{ A, 4},{C1, 5}},{{ A, 4},{C1, 6}},{{ A, 1},{C2, 4}},{{ A, 1},{C2, 5}},{{ A, 1},{C2, 6}},{{ A, 2},{C2, 4}},{{ A, 2},{C2, 5}},
+    {{ A, 2},{C2, 6}},{{ A, 3},{C2, 4}},{{ A, 3},{C2, 5}},{{ A, 3},{C2, 6}},{{ A, 4},{C2, 4}},{{ A, 4},{C2, 5}},{{ A, 4},{C2, 6}},{{ A, 1},{C3, 4}},
+    {{ A, 1},{C3, 5}},{{ A, 1},{C3, 6}},{{ A, 2},{C3, 4}},{{ A, 2},{C3, 5}},{{ A, 2},{C3, 6}},{{ A, 3},{C3, 4}},{{ A, 3},{C3, 5}},{{ A, 3},{C3, 6}},
+    {{ A, 4},{C3, 4}},{{ A, 4},{C3, 5}},{{ A, 4},{C3, 6}},{{ A, 1},{C4, 4}},{{ A, 1},{C4, 5}},{{ A, 1},{C4, 6}},{{ A, 2},{C4, 4}},{{ A, 2},{C4, 5}},
+    {{ A, 2},{C4, 6}},{{ A, 3},{C4, 4}},{{ A, 3},{C4, 5}},{{ A, 3},{C4, 6}},{{ A, 4},{C4, 4}},{{ A, 4},{C4, 5}},{{ A, 4},{C4, 6}},{{ A, 1},{C5, 4}},
+    {{ A, 1},{C5, 5}},{{ A, 1},{C5, 6}},{{ A, 2},{C5, 4}},{{ A, 2},{C5, 5}},{{ A, 2},{C5, 6}},{{ A, 3},{C5, 4}},{{ A, 3},{C5, 5}},{{ A, 3},{C5, 6}},
+    {{ A, 4},{C5, 4}},{{ A, 4},{C5, 5}},{{ A, 4},{C5, 6}},{{ A, 1},{C6, 4}},{{ A, 2},{C6, 4}},{{ A, 3},{C6, 4}},{{ A, 4},{C6, 4}},{{ A, 1},{C7, 4}},
+    {{ A, 2},{C7, 4}},{{ A, 3},{C7, 4}},{{ A, 4},{C7, 4}},{{ A, 1},{C8, 4}},{{ A, 2},{C8, 4}},{{ A, 3},{C8, 4}},{{ A, 4},{C8, 4}},{{C0, 4},{ A, 1}},
+    {{C1, 4},{ A, 1}},{{C2, 4},{ A, 1}},{{C3, 4},{ A, 1}},{{C4, 4},{ A, 1}},{{C5, 4},{ A, 1}},{{C6, 4},{ A, 1}},{{C7, 4},{ A, 1}},{{C8, 4},{ A, 1}}
+};
+
+const vcdiff_code_table_t get_vcdiff_code_table_default(){
+    return &_vcdiff_code_table_default[0];
+}
+
+#undef N
+#undef A
+#undef R
+#undef C
+#undef C0
+#undef C1
+#undef C2
+#undef C3
+#undef C4
+#undef C5
+#undef C6
+#undef C7
+#undef C8
+
+#define _kWindowCacheSize 1024
+static hpatch_BOOL _getVcDiffWindowSizes(hpatch_VcDiffInfo* out_diffinfo,const hpatch_TStreamInput* diffStream);
+
+hpatch_BOOL getVcDiffInfo(hpatch_VcDiffInfo* out_diffinfo,const hpatch_TStreamInput* diffStream,
+                          hpatch_BOOL isNeedWindowSize){
+    TStreamCacheClip  diffClip;
+    hpatch_byte _window_cache[_kWindowCacheSize];
+    hpatch_byte Hdr_Indicator;
+    memset(out_diffinfo,0,sizeof(*out_diffinfo));
+    if (diffStream->streamSize<kVcDiffMinHeadLen)
+        return _hpatch_FALSE;
+    assert(kVcDiffMinHeadLen<=_kWindowCacheSize);
+    _TStreamCacheClip_init(&diffClip,diffStream,0,diffStream->streamSize,_window_cache,sizeof(_window_cache));
+
+    {//head
+        const hpatch_byte* buf=_TStreamCacheClip_readData(&diffClip,kVcDiffMinHeadLen);
+        if (buf==0)
+            return _hpatch_FALSE;
+        if (0!=memcmp(buf,kVcDiffType,sizeof(kVcDiffType)))
+            return _hpatch_FALSE; //not VCDIFF
+        buf+=sizeof(kVcDiffType);
+        switch (*buf++){ // version
+            case kVcDiffDefaultVersion: out_diffinfo->isGoogleVersion=hpatch_FALSE; break;
+            case kVcDiffGoogleVersion: out_diffinfo->isGoogleVersion=hpatch_TRUE; break;
+            default:
+                return _hpatch_FALSE; //unsupport version
+        }
+        Hdr_Indicator=*buf++; // Hdr_Indicator
+    }
+
+    if (Hdr_Indicator&(1<<0)){ // VCD_DECOMPRESS
+        _clip_readUInt8(&diffClip,&out_diffinfo->compressorID);
+    }
+    if (Hdr_Indicator&(1<<1)) // VCD_CODETABLE
+        return _hpatch_FALSE; // unsupport code table
+    if (Hdr_Indicator&(1<<2)) // VCD_APPHEADER
+        _clip_unpackUInt64(&diffClip,&out_diffinfo->appHeadDataLen);
+    out_diffinfo->appHeadDataOffset=_TStreamCacheClip_readPosOfSrcStream(&diffClip);
+    out_diffinfo->windowOffset=out_diffinfo->appHeadDataOffset+out_diffinfo->appHeadDataLen;
+#ifdef __RUN_MEM_SAFE_CHECK
+    {
+        const hpatch_StreamPos_t maxPos=_TStreamCacheClip_leaveSize(&diffClip);
+        if ( (out_diffinfo->appHeadDataLen>maxPos)|(out_diffinfo->windowOffset>maxPos) )
+            return _hpatch_FALSE; //data size error
+    }
+#endif
+    assert(kHDiffzAppHead_len==strlen(kHDiffzAppHead));
+    assert(kHDiffzAppHead_version_len==strlen(kHDiffzAppHead_version));
+    assert(kHDiffzAppHead_maxLen<=_kWindowCacheSize);
+    if ((out_diffinfo->appHeadDataLen>=kHDiffzAppHead_len+kHDiffzAppHead_version_len)
+        &&(out_diffinfo->appHeadDataLen<=kHDiffzAppHead_maxLen)){
+        const hpatch_byte* pAppHead=_TStreamCacheClip_accessData(&diffClip,(size_t)out_diffinfo->appHeadDataLen);
+        if (pAppHead==0)
+            return _hpatch_FALSE;
+        if ((0==memcmp(pAppHead,kHDiffzAppHead,kHDiffzAppHead_len))
+          &&(0==memcmp(pAppHead+out_diffinfo->appHeadDataLen-kHDiffzAppHead_version_len,kHDiffzAppHead_version,kHDiffzAppHead_version_len)))
+            out_diffinfo->isHDiffzAppHead_a=hpatch_TRUE;
+    }
+    if (isNeedWindowSize){
+        return _getVcDiffWindowSizes(out_diffinfo,diffStream);
+    }else{
+        out_diffinfo->maxSrcWindowsSize=hpatch_kNullStreamPos;
+        out_diffinfo->maxTargetWindowsSize=hpatch_kNullStreamPos;
+        out_diffinfo->sumTargetWindowsSize=hpatch_kNullStreamPos;
+        return hpatch_TRUE;
+    }
+}
+
+hpatch_BOOL getVcDiffInfo_mem(hpatch_VcDiffInfo* out_diffinfo,const hpatch_byte* diffData,
+                              const hpatch_byte* diffData_end,hpatch_BOOL isNeedWindowSize){
+    hpatch_TStreamInput diffStream;
+    mem_as_hStreamInput(&diffStream,diffData,diffData_end);
+    return getVcDiffInfo(out_diffinfo,&diffStream,isNeedWindowSize);
+}
+
+hpatch_BOOL getIsVcDiff(const hpatch_TStreamInput* diffData){
+    hpatch_VcDiffInfo diffinfo;
+    return getVcDiffInfo(&diffinfo,diffData,hpatch_FALSE);
+}
+hpatch_BOOL getIsVcDiff_mem(const hpatch_byte* diffData,const hpatch_byte* diffData_end){
+    hpatch_TStreamInput diffStream;
+    mem_as_hStreamInput(&diffStream,diffData,diffData_end);
+    return getIsVcDiff(&diffStream);
+}
+
+typedef struct{
+    hpatch_BOOL isGoogleVersion;
+    hpatch_BOOL isNeedChecksum;
+    hpatch_BOOL     window_isHaveAdler32;
+    hpatch_uint32_t window_savedAdler32;
+    hpatch_uint32_t window_curAdler32;
+
+    const hpatch_TStreamOutput* _dstStream;
+    hpatch_TStreamOutput        _hookStream;
+} vcpatch_checksum_t;
+
+static hpatch_inline void vcpatch_checksum_init(vcpatch_checksum_t* self,hpatch_BOOL isGoogleVersion,
+                                                hpatch_BOOL isNeedChecksum,hpatch_BOOL window_isHaveAdler32){
+    memset(self,0,sizeof(*self));
+    self->isGoogleVersion=isGoogleVersion;
+    self->isNeedChecksum=isNeedChecksum;
+    self->window_isHaveAdler32=window_isHaveAdler32;
+}
+
+#define vcpatch_checksum_readAdler32(self,diffClip){ \
+    if ((self)->window_isHaveAdler32){ \
+        if ((self)->isGoogleVersion){  \
+            hpatch_StreamPos_t _v;     \
+            _clip_unpackUInt64(diffClip,&_v); \
+            if ((_v>>32)>0) return _hpatch_FALSE; /*error data or no data*/ \
+            (self)->window_savedAdler32=(hpatch_uint32_t)_v; \
+        }else{ \
+            _clip_readUInt32_BigEndian(diffClip,&(self)->window_savedAdler32); \
+        } \
+    } }
+
+
+    static hpatch_BOOL __vcpatch_checksum_read_writed(const struct hpatch_TStreamOutput* stream,hpatch_StreamPos_t readFromPos,
+                                                    hpatch_byte* out_data,hpatch_byte* out_data_end){
+        vcpatch_checksum_t* self=(vcpatch_checksum_t*)stream->streamImport;
+        return self->_dstStream->read_writed(self->_dstStream,readFromPos,out_data,out_data_end);      
+    }
+    static hpatch_BOOL __vcpatch_checksum_write(const struct hpatch_TStreamOutput* stream,hpatch_StreamPos_t writeToPos,
+                                                const hpatch_byte* data,const hpatch_byte* data_end){
+        vcpatch_checksum_t* self=(vcpatch_checksum_t*)stream->streamImport;
+        self->window_curAdler32=adler32_append(self->window_curAdler32,data,data_end-data);
+        return self->_dstStream->write(self->_dstStream,writeToPos,data,data_end);
+    }
+static hpatch_BOOL __vcpatch_checksum_begin_(vcpatch_checksum_t* self,_TOutStreamCache* outCache){
+    assert(self->_dstStream==0);
+    assert(_TOutStreamCache_cachedDataSize(outCache)==0);
+
+    self->_hookStream.streamImport=self;
+    self->_hookStream.streamSize=outCache->dstStream->streamSize;
+    self->_hookStream.read_writed=(outCache->dstStream->read_writed?__vcpatch_checksum_read_writed:0);
+    self->_hookStream.write=__vcpatch_checksum_write;
+
+    self->_dstStream=outCache->dstStream;
+    outCache->dstStream=&self->_hookStream;
+    self->window_curAdler32=(self->isGoogleVersion?0:1);
+    return hpatch_TRUE;
+}
+
+static hpatch_BOOL __vcpatch_checksum_end_(vcpatch_checksum_t* self,_TOutStreamCache* outCache){
+    assert(self->_dstStream!=0);
+    assert(outCache->dstStream==&self->_hookStream);
+    assert(_TOutStreamCache_cachedDataSize(outCache)==0);
+
+    outCache->dstStream=self->_dstStream;
+    self->_dstStream=0;
+    return self->window_curAdler32==self->window_savedAdler32;
+}
+
+static hpatch_inline hpatch_BOOL vcpatch_checksum_begin(vcpatch_checksum_t* self,_TOutStreamCache* outCache){
+    if ((self)->isNeedChecksum&(self)->window_isHaveAdler32)
+        return __vcpatch_checksum_begin_(self,outCache);
+    else
+        return hpatch_TRUE;
+}
+
+static hpatch_inline hpatch_BOOL vcpatch_checksum_end(vcpatch_checksum_t* self,_TOutStreamCache* outCache){
+    if ((self)->isNeedChecksum&(self)->window_isHaveAdler32)
+        return __vcpatch_checksum_end_(self,outCache);
+    else
+        return hpatch_TRUE;
+}
+
+
+hpatch_BOOL _vcpatch_delta(_TOutStreamCache* outCache,hpatch_StreamPos_t targetLen,
+                           const hpatch_TStreamInput* srcData,hpatch_StreamPos_t srcPos,hpatch_StreamPos_t srcLen,
+                           TStreamCacheClip* dataClip,TStreamCacheClip* instClip,TStreamCacheClip* addrClip){
+    hpatch_StreamPos_t same_array[vcdiff_s_same*256]={0};
+    hpatch_StreamPos_t near_array[vcdiff_s_near]={0};
+    hpatch_StreamPos_t here=0;
+    hpatch_StreamPos_t near_index=0;
+    const vcdiff_code_table_t code_table=get_vcdiff_code_table_default();
+    while (here<targetLen){
+        const vcdiff_code_t*    codes;
+        const vcdiff_code_t*    codes_end;
+        {
+            hpatch_byte insti;
+            _clip_readUInt8(instClip,&insti);
+            codes=(const vcdiff_code_t*)&code_table[insti];
+            assert(codes[0].inst!=vcdiff_code_NOOP);
+            codes_end=codes+((codes[1].inst==vcdiff_code_NOOP)?1:2);
+        }
+        for (;codes<codes_end;++codes){
+            hpatch_StreamPos_t  addr;
+            hpatch_StreamPos_t  cur_here=here;
+            hpatch_StreamPos_t  size=codes->size;
+            const hpatch_size_t inst=codes->inst;
+            assert(inst<=vcdiff_code_MAX);
+            if (size==0)
+                _clip_unpackUInt64(instClip,&size);
+            here+=size;
+#ifdef __RUN_MEM_SAFE_CHECK
+            if (here>targetLen)
+                return _hpatch_FALSE;
+#endif
+            switch (inst){
+                case vcdiff_code_ADD: {
+                    if (!_TOutStreamCache_copyFromClip(outCache,dataClip,size))
+                        return _hpatch_FALSE;
+                } continue;
+                case vcdiff_code_RUN: {
+                    hpatch_byte v;
+                    _clip_readUInt8(dataClip,&v);
+                    if (!_TOutStreamCache_fill(outCache,v,size))
+                        return _hpatch_FALSE;
+                } continue;
+                case vcdiff_code_COPY_SELF:
+                case vcdiff_code_COPY_HERE:
+                case vcdiff_code_COPY_NEAR0:
+                case vcdiff_code_COPY_NEAR1:
+                case vcdiff_code_COPY_NEAR2:
+                case vcdiff_code_COPY_NEAR3: {
+                    _clip_unpackUInt64(addrClip,&addr);
+                    switch (inst){
+                        case vcdiff_code_COPY_SELF: {
+                        } break;
+                        case vcdiff_code_COPY_HERE: {
+                            addr=srcLen+cur_here-addr;
+                        } break;
+                        default: {
+                            addr+=near_array[inst-vcdiff_code_COPY_NEAR0];
+                        } break;
+                    }
+                } break;
+                default: { // vcdiff_code_COPY_SAME
+                    hpatch_byte samei;
+                    _clip_readUInt8(addrClip,&samei);
+                    addr=same_array[((hpatch_size_t)(inst-vcdiff_code_COPY_SAME0))*256+samei];
+                } break;
+            }//switch inst
+            vcdiff_update_addr(same_array,near_array,&near_index,addr);
+            
+            if (addr<srcLen){//copy from src
+                hpatch_StreamPos_t copyLen=(addr+size<=srcLen)?size:srcLen-addr;
+                if (!_TOutStreamCache_copyFromStream(outCache,srcData,srcPos+addr,copyLen))
+                    return _hpatch_FALSE;
+                cur_here+=copyLen;
+                addr+=copyLen;
+                size-=copyLen;
+            }
+            if (size>0){ //copy from outCache
+                addr-=srcLen;
+#ifdef __RUN_MEM_SAFE_CHECK
+                if (addr>=cur_here)
+                    return _hpatch_FALSE;
+#endif
+                if (!_TOutStreamCache_copyFromSelf(outCache,cur_here-addr,size))
+                    return _hpatch_FALSE;
+            }
+        }//for codes
+    }//while
+    return hpatch_TRUE;
+}
+
+
+static hpatch_BOOL _getStreamClip(TStreamCacheClip* clip,hpatch_byte Delta_Indicator,hpatch_byte index,
+                                  const hpatch_TStreamInput* diffStream,hpatch_StreamPos_t* curDiffOffset,
+                                  hpatch_TDecompress* decompressPlugin,_TDecompressInputStream* decompressers,
+                                  hpatch_StreamPos_t dataLen,hpatch_byte* temp_cache,hpatch_size_t cache_size){
+    hpatch_StreamPos_t uncompressedLen;
+    hpatch_StreamPos_t compressedLen;
+    if ((Delta_Indicator&(1<<index))){
+        hpatch_StreamPos_t readedBytes;
+        TStreamCacheClip   tempClip;
+        hpatch_byte  _temp_cache[hpatch_kMaxPackedUIntBytes];
+        _TStreamCacheClip_init(&tempClip,diffStream,*curDiffOffset,
+                                diffStream->streamSize,_temp_cache,sizeof(_temp_cache));
+        _clip_unpackUInt64(&tempClip,&uncompressedLen);
+        readedBytes=_TStreamCacheClip_readPosOfSrcStream(&tempClip)-(*curDiffOffset);
+        (*curDiffOffset)+=readedBytes;
+        compressedLen=dataLen-readedBytes;
+    }else{
+        uncompressedLen=dataLen;
+        compressedLen=0;
+    }
+    return getStreamClip(clip,&decompressers[index],uncompressedLen,compressedLen,diffStream,
+                         curDiffOffset,decompressPlugin,temp_cache,cache_size);
+}
+
+
+
+static hpatch_BOOL _getVcDiffWindowSizes(hpatch_VcDiffInfo* out_diffinfo,const hpatch_TStreamInput* diffStream){
+    hpatch_StreamPos_t windowOffset=out_diffinfo->windowOffset;
+    hpatch_StreamPos_t maxSrcWindowsSize=0;
+    hpatch_StreamPos_t maxTargetWindowsSize=0;
+    hpatch_StreamPos_t sumTargetWindowsSize=0;
+    hpatch_byte _cacheBuf[1024];
+    //window loop
+    while (windowOffset<diffStream->streamSize){
+        hpatch_StreamPos_t srcPos=0;
+        hpatch_StreamPos_t srcLen=0;
+        hpatch_StreamPos_t targetLen;
+        hpatch_StreamPos_t deltaLen;
+        hpatch_StreamPos_t dataLen;
+        hpatch_StreamPos_t instLen;
+        hpatch_StreamPos_t addrLen;
+        hpatch_StreamPos_t curDiffOffset;
+        hpatch_BOOL isHave_srcData;
+        vcpatch_checksum_t checksumer;
+        hpatch_byte Delta_Indicator;
+        {
+            TStreamCacheClip   diffClip;
+            _TStreamCacheClip_init(&diffClip,diffStream,windowOffset,diffStream->streamSize,
+                                   _cacheBuf,sizeof(_cacheBuf));
+            {
+                hpatch_BOOL window_isHaveAdler32;
+                hpatch_byte Win_Indicator;
+                _clip_readUInt8(&diffClip,&Win_Indicator);
+                window_isHaveAdler32=(0!=(Win_Indicator&VCD_ADLER32));
+                if (window_isHaveAdler32) Win_Indicator-=VCD_ADLER32;
+                vcpatch_checksum_init(&checksumer,out_diffinfo->isGoogleVersion,hpatch_FALSE,window_isHaveAdler32);
+                switch (Win_Indicator){
+                    case 0         :{ isHave_srcData=hpatch_FALSE; } break;
+                    case VCD_SOURCE:
+                    case VCD_TARGET:{ isHave_srcData=hpatch_TRUE; } break;
+                    default: return _hpatch_FALSE; //error data or unsupport
+                }
+            }
+            if (isHave_srcData){
+                _clip_unpackUInt64(&diffClip,&srcLen);
+                _clip_unpackUInt64(&diffClip,&srcPos);
+            }
+            _clip_unpackUInt64(&diffClip,&deltaLen);
+            {
+#ifdef __RUN_MEM_SAFE_CHECK
+                hpatch_StreamPos_t deltaHeadSize=_TStreamCacheClip_readPosOfSrcStream(&diffClip);
+                if (deltaLen>_TStreamCacheClip_leaveSize(&diffClip))
+                    return _hpatch_FALSE; //error data
+#endif
+                _clip_unpackUInt64(&diffClip,&targetLen);
+                _clip_readUInt8(&diffClip,&Delta_Indicator);
+                _clip_unpackUInt64(&diffClip,&dataLen);
+                _clip_unpackUInt64(&diffClip,&instLen);
+                _clip_unpackUInt64(&diffClip,&addrLen);
+                vcpatch_checksum_readAdler32(&checksumer,&diffClip);
+                curDiffOffset=_TStreamCacheClip_readPosOfSrcStream(&diffClip);
+#ifdef __RUN_MEM_SAFE_CHECK
+                deltaHeadSize=curDiffOffset-deltaHeadSize;
+                if (deltaLen!=deltaHeadSize+dataLen+instLen+addrLen)
+                    return _hpatch_FALSE; //error data
+#endif
+            }
+            windowOffset=curDiffOffset+dataLen+instLen+addrLen;
+
+            {
+                hpatch_StreamPos_t sumSize=sumTargetWindowsSize+targetLen;
+#ifdef __RUN_MEM_SAFE_CHECK
+                if (sumSize<sumTargetWindowsSize)
+                    return _hpatch_FALSE; //error data
+#endif
+                sumTargetWindowsSize=sumSize;
+                maxSrcWindowsSize=(maxSrcWindowsSize>=srcLen)?maxSrcWindowsSize:srcLen;
+                maxTargetWindowsSize=(maxTargetWindowsSize>=targetLen)?maxTargetWindowsSize:targetLen;
+            }
+        }
+    }
+    out_diffinfo->maxSrcWindowsSize=maxSrcWindowsSize;
+    out_diffinfo->maxTargetWindowsSize=maxTargetWindowsSize;
+    out_diffinfo->sumTargetWindowsSize=sumTargetWindowsSize;
+    return hpatch_TRUE;
+}
+
+
+#define _kCacheVcDecCount (1+3)
+
+typedef struct{
+    hpatch_TStreamInput srcStream;
+    hpatch_StreamPos_t srcPos_bck;
+    hpatch_size_t      srcLen_bck;
+    hpatch_size_t      mem_offset;
+    hpatch_size_t      mem_size;
+    hpatch_byte*       mem_cache;
+    const hpatch_TStreamInput* srcData_bck;
+}src_cache_t;
+
+static hpatch_inline void _src_cache_move_by_offset(src_cache_t* self,hpatch_size_t dstPos,hpatch_size_t movePos){
+    hpatch_size_t mem_size=self->mem_size;
+    hpatch_StreamPos_t noff=(hpatch_StreamPos_t)self->mem_offset+mem_size+movePos-dstPos;
+    if (noff>mem_size){
+        noff-=mem_size;
+        if (noff>mem_size)
+            noff-=mem_size;
+    }
+    self->mem_offset=(hpatch_size_t)noff;
+}
+static hpatch_BOOL _src_cache_update_by_offset(src_cache_t* self,const hpatch_TStreamInput* srcData,
+                                               hpatch_StreamPos_t srcPos,hpatch_StreamPos_t dstPos,hpatch_size_t updateLen){
+    const hpatch_size_t mem_size=self->mem_size;
+    hpatch_byte*  temp_cache=self->mem_cache;
+    srcPos+=dstPos;
+    dstPos+=self->mem_offset;
+    if (dstPos<mem_size){
+        hpatch_size_t readLen=updateLen;
+        if (dstPos+readLen>mem_size) readLen=mem_size-(hpatch_size_t)dstPos;
+        if (!srcData->read(srcData,srcPos,temp_cache+(hpatch_size_t)dstPos,temp_cache+(hpatch_size_t)dstPos+readLen))
+            return _hpatch_FALSE;
+        srcPos+=readLen;
+        dstPos+=readLen;
+        updateLen-=readLen;
+        if (updateLen==0) return hpatch_TRUE;
+    }
+    dstPos-=mem_size;
+    if (!srcData->read(srcData,srcPos,temp_cache+(hpatch_size_t)dstPos,temp_cache+(hpatch_size_t)dstPos+updateLen))
+        return _hpatch_FALSE;
+    return hpatch_TRUE;
+}
+
+static hpatch_BOOL _src_cache_read(const struct hpatch_TStreamInput* stream,hpatch_StreamPos_t readFromPos,
+                                   unsigned char* out_data,unsigned char* out_data_end){
+    src_cache_t* self=(src_cache_t*)stream->streamImport;
+    hpatch_size_t readLen;
+    const hpatch_size_t mem_size=self->mem_size;
+    assert(mem_size>=readFromPos+(hpatch_size_t)(out_data_end-out_data));
+    readFromPos+=self->mem_offset;
+    if (readFromPos<mem_size){
+        readLen=out_data_end-out_data;
+        if (readFromPos+readLen>mem_size)
+            readLen=mem_size-(hpatch_size_t)readFromPos;
+        memcpy(out_data,self->mem_cache+(hpatch_size_t)readFromPos,readLen);
+        readFromPos+=readLen;
+        out_data+=readLen;
+        if (out_data==out_data_end) return hpatch_TRUE;
+    }
+    readFromPos-=mem_size;
+    readLen=out_data_end-out_data;
+    assert(mem_size>=readFromPos+readLen);
+    memcpy(out_data,self->mem_cache+(hpatch_size_t)readFromPos,readLen);
+    return hpatch_TRUE;
+}
+
+static hpatch_inline void src_cache_init(src_cache_t* self,hpatch_StreamPos_t srcLenMax,hpatch_byte** mem_cache,hpatch_size_t* allCacheSize){
+    hpatch_size_t mem_size=0;
+    if ((srcLenMax>0)&&(srcLenMax+_kCacheVcDecCount*hpatch_kStreamCacheSize<=(*allCacheSize))){
+        mem_size=(hpatch_size_t)srcLenMax;
+    }
+    self->srcPos_bck=0;
+    self->srcData_bck=0;
+    self->mem_cache=*mem_cache;
+    self->mem_offset=0;
+    self->mem_size=mem_size;
+    (*allCacheSize)-=mem_size;
+    (*mem_cache)+=mem_size;
+}
+
+static hpatch_inline hpatch_BOOL src_cache_isCanCache(src_cache_t* self,hpatch_StreamPos_t srcLen){
+    return (srcLen>0)&&(srcLen<=self->mem_size);
+}
+
+static hpatch_TStreamInput* src_cache_update(src_cache_t* self,const hpatch_TStreamInput* srcData,
+                                             hpatch_size_t srcLen,hpatch_StreamPos_t srcPos){
+    if ((self->srcData_bck!=srcData)||(self->srcPos_bck+self->srcLen_bck<=srcPos)||(self->srcPos_bck>=srcPos+srcLen)){
+        self->mem_offset=0;
+        if (!srcData->read(srcData,srcPos,self->mem_cache,self->mem_cache+srcLen))
+            return _hpatch_FALSE;
+    }else{//hit cache
+        hpatch_size_t dstPos;
+        hpatch_size_t movePos;
+        hpatch_size_t moveLen;
+        if (self->srcPos_bck<=srcPos){
+            dstPos=0;
+            movePos=(hpatch_size_t)(srcPos-self->srcPos_bck);
+            moveLen=self->srcLen_bck-movePos;
+        }else{
+            dstPos=(hpatch_size_t)(self->srcPos_bck-srcPos);
+            movePos=0;
+            moveLen=self->srcLen_bck;
+        }
+        if (dstPos+moveLen>=srcLen)
+            moveLen=srcLen-dstPos;
+        _src_cache_move_by_offset(self,dstPos,movePos);
+        if (dstPos>0){
+            if (!_src_cache_update_by_offset(self,srcData,srcPos,0,dstPos))
+                return _hpatch_FALSE;
+        }
+        dstPos+=moveLen;
+        if (dstPos<srcLen){
+            if (!_src_cache_update_by_offset(self,srcData,srcPos,dstPos,srcLen-dstPos))
+                return _hpatch_FALSE;
+        }
+    }
+
+    self->srcStream.streamImport=self;
+    self->srcStream.streamSize=srcLen;
+    self->srcStream.read=_src_cache_read;
+    self->srcStream.streamImport=self;
+    self->srcStream.streamImport=self;
+
+    self->srcPos_bck=srcPos;
+    self->srcLen_bck=srcLen;
+    self->srcData_bck=srcData;
+    return &self->srcStream;
+}
+
+
+hpatch_BOOL _vcpatch_window(const hpatch_TStreamOutput* out_newData,const hpatch_TStreamInput* oldData,
+                            const hpatch_TStreamInput* diffStream,hpatch_TDecompress* decompressPlugin,
+                            _TDecompressInputStream* decompressers,hpatch_StreamPos_t windowOffset,
+                            hpatch_StreamPos_t srcLenMax,hpatch_BOOL isGoogleVersion,
+                            hpatch_BOOL isNeedChecksum,hpatch_byte* tempCaches,hpatch_size_t allCacheSize){
+    src_cache_t src_cache;
+    _TOutStreamCache outCache;
+    if (allCacheSize<hpatch_kMaxPackedUIntBytes*_kCacheVcDecCount) return _hpatch_FALSE;
+    _TOutStreamCache_init(&outCache,out_newData,0,0); //need reset cache
+    src_cache_init(&src_cache,srcLenMax,&tempCaches,&allCacheSize);
+
+    //window loop
+    while (windowOffset<diffStream->streamSize){
+        hpatch_StreamPos_t srcPos=0;
+        hpatch_StreamPos_t srcLen=0;
+        hpatch_StreamPos_t targetLen;
+        hpatch_StreamPos_t deltaLen;
+        hpatch_StreamPos_t dataLen;
+        hpatch_StreamPos_t instLen;
+        hpatch_StreamPos_t addrLen;
+        hpatch_StreamPos_t curDiffOffset;
+        const hpatch_TStreamInput* srcData;
+        vcpatch_checksum_t checksumer;
+        hpatch_byte Delta_Indicator;
+        {
+            TStreamCacheClip   diffClip;
+            hpatch_byte _window_cache[_kWindowCacheSize];
+            _TStreamCacheClip_init(&diffClip,diffStream,windowOffset,diffStream->streamSize,
+                                   _window_cache,sizeof(_window_cache));
+            {
+                hpatch_BOOL window_isHaveAdler32;
+                hpatch_byte Win_Indicator;
+                _clip_readUInt8(&diffClip,&Win_Indicator);
+                window_isHaveAdler32=(0!=(Win_Indicator&VCD_ADLER32));
+                if (window_isHaveAdler32) Win_Indicator-=VCD_ADLER32;
+                vcpatch_checksum_init(&checksumer,isGoogleVersion,isNeedChecksum,window_isHaveAdler32);
+                switch (Win_Indicator){
+                    case 0         :{ srcData=0; } break;
+                    case VCD_SOURCE:{ srcData=oldData; } break;
+                    case VCD_TARGET:{
+                        srcData=(const hpatch_TStreamInput*)outCache.dstStream;
+                        if (srcData->read==0)
+                            return _hpatch_FALSE; //unsupport, target can't read  
+                    } break;
+                    default:
+                        return _hpatch_FALSE; //error data or unsupport
+                }
+            }
+            if (srcData){
+                _clip_unpackUInt64(&diffClip,&srcLen);
+                _clip_unpackUInt64(&diffClip,&srcPos);
+#ifdef __RUN_MEM_SAFE_CHECK
+                {
+                    hpatch_StreamPos_t streamSafeEnd=(srcData==oldData)?srcData->streamSize:outCache.writeToPos;
+                    hpatch_StreamPos_t srcPosEnd=srcPos+srcLen;
+                    if ((srcPosEnd<srcPos)|(srcPosEnd<srcLen)|(srcPosEnd>streamSafeEnd))
+                        return _hpatch_FALSE; //error data
+                }
+#endif
+            }
+            _clip_unpackUInt64(&diffClip,&deltaLen);
+            {
+#ifdef __RUN_MEM_SAFE_CHECK
+                hpatch_StreamPos_t deltaHeadSize=_TStreamCacheClip_readPosOfSrcStream(&diffClip);
+                if (deltaLen>_TStreamCacheClip_leaveSize(&diffClip))
+                    return _hpatch_FALSE; //error data
+#endif
+                _clip_unpackUInt64(&diffClip,&targetLen);
+                _clip_readUInt8(&diffClip,&Delta_Indicator);
+                if (decompressPlugin==0) Delta_Indicator=0;
+                _clip_unpackUInt64(&diffClip,&dataLen);
+                _clip_unpackUInt64(&diffClip,&instLen);
+                _clip_unpackUInt64(&diffClip,&addrLen);
+                vcpatch_checksum_readAdler32(&checksumer,&diffClip);
+                curDiffOffset=_TStreamCacheClip_readPosOfSrcStream(&diffClip);
+#ifdef __RUN_MEM_SAFE_CHECK
+                deltaHeadSize=curDiffOffset-deltaHeadSize;
+                if (deltaLen!=deltaHeadSize+dataLen+instLen+addrLen)
+                    return _hpatch_FALSE; //error data
+#endif
+            }
+            windowOffset=curDiffOffset+dataLen+instLen+addrLen;
+        }
+
+        if (src_cache_isCanCache(&src_cache,srcLen)){//old all in cache?
+            assert(srcData!=0);
+            srcData=src_cache_update(&src_cache,srcData,(hpatch_size_t)srcLen,srcPos);
+            if (srcData==0) return _hpatch_FALSE;
+            srcPos=0;
+        }
+        {
+            hpatch_BOOL       ret;
+            const hpatch_BOOL isInterleaved=((dataLen==0)&(addrLen==0));
+            TStreamCacheClip  dataClip;
+            TStreamCacheClip  instClip;
+            TStreamCacheClip  addrClip;
+            hpatch_byte*      temp_cache=tempCaches;
+            hpatch_size_t     cache_size=allCacheSize;
+            {
+                hpatch_size_t out_cache_size;
+                if ((targetLen>0)&&(targetLen+3*hpatch_kStreamCacheSize<=cache_size)){//target all in cache?
+                    out_cache_size=(hpatch_size_t)targetLen;
+                    cache_size=(cache_size-out_cache_size)/(isInterleaved?1:3);
+                }else{
+                    #define kBetterDecompressBufSize (1024*32)
+                    hpatch_size_t dec_size=cache_size/_kCacheVcDecCount;
+                    dec_size=(dec_size<=kBetterDecompressBufSize)?dec_size:kBetterDecompressBufSize;
+                    out_cache_size=cache_size-dec_size*(isInterleaved?1:3);
+                    cache_size=dec_size;
+                }
+                _TOutStreamCache_resetCache(&outCache,temp_cache,out_cache_size);
+                temp_cache+=out_cache_size;
+            }
+
+            #define __getStreamClip(clip,index,len) { \
+                if (!(_getStreamClip(clip,Delta_Indicator,index,diffStream,&curDiffOffset, \
+                                    decompressPlugin,decompressers,len,temp_cache,cache_size))) \
+                    return _hpatch_FALSE; \
+                temp_cache+=cache_size; }
+
+            if (!isInterleaved){
+                __getStreamClip(&dataClip,0,dataLen);
+                __getStreamClip(&instClip,1,instLen);
+                __getStreamClip(&addrClip,2,addrLen);
+            }else{
+                __getStreamClip(&instClip,0,instLen);
+            }
+            assert(curDiffOffset==windowOffset);
+            if (!vcpatch_checksum_begin(&checksumer,&outCache))
+                return _hpatch_FALSE;
+            ret=_vcpatch_delta(&outCache,targetLen,srcData,srcPos,srcLen,
+                               isInterleaved?&instClip:&dataClip,&instClip,
+                               isInterleaved?&instClip:&addrClip);
+            
+            if (!_TOutStreamCache_flush(&outCache))
+                ret=_hpatch_FALSE;
+            if ((!vcpatch_checksum_end(&checksumer,&outCache))||(!ret))
+                return _hpatch_FALSE;
+        }
+    }
+
+    if (_TOutStreamCache_isFinish(&outCache)||(outCache.dstStream->streamSize==hpatch_kNullStreamPos))
+        return hpatch_TRUE;
+    else
+        return _hpatch_FALSE;
+}
+
+
+hpatch_BOOL vcpatch_with_cache(const hpatch_TStreamOutput* out_newData,
+                               const hpatch_TStreamInput*  oldData,
+                               const hpatch_TStreamInput*  diffStream,
+                               hpatch_TDecompress* decompressPlugin,hpatch_BOOL isNeedChecksum,
+                               hpatch_byte* temp_cache,hpatch_byte* temp_cache_end){
+    hpatch_VcDiffInfo diffInfo;
+    hpatch_size_t i;
+    hpatch_BOOL  result=hpatch_TRUE;
+    _TDecompressInputStream decompressers[3];
+    for (i=0;i<sizeof(decompressers)/sizeof(_TDecompressInputStream);++i)
+        decompressers[i].decompressHandle=0;
+    assert(out_newData!=0);
+    assert(out_newData->write!=0);
+    assert(oldData!=0);
+    assert(oldData->read!=0);
+    assert(diffStream!=0);
+    assert(diffStream->read!=0);
+    if (!getVcDiffInfo(&diffInfo,diffStream,hpatch_TRUE))
+        return _hpatch_FALSE;
+
+    if (diffInfo.compressorID){
+        if (decompressPlugin==0)
+            return _hpatch_FALSE;
+    }else{
+        decompressPlugin=0;
+    }
+
+    result=_vcpatch_window(out_newData,oldData,diffStream,decompressPlugin,decompressers,
+                           diffInfo.windowOffset,diffInfo.maxSrcWindowsSize,diffInfo.isGoogleVersion,
+                           isNeedChecksum,temp_cache,temp_cache_end-temp_cache);
+
+    for (i=0;i<sizeof(decompressers)/sizeof(_TDecompressInputStream);++i) {
+        if (decompressers[i].decompressHandle){
+            if (!decompressPlugin->close(decompressPlugin,decompressers[i].decompressHandle))
+                result=_hpatch_FALSE;
+            decompressers[i].decompressHandle=0;
+        }
+    }
+    return result;
+}