react-native-update 10.34.2 → 10.34.4

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

@@ -0,0 +1,116 @@
+//diff.h
+//
+/*
+ The MIT License (MIT)
+ Copyright (c) 2012-2018 HouSisong
+ 
+ Permission is hereby granted, free of charge, to any person
+ obtaining a copy of this software and associated documentation
+ files (the "Software"), to deal in the Software without
+ restriction, including without limitation the rights to use,
+ copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following
+ conditions:
+ 
+ The above copyright notice and this permission notice shall be
+ included in all copies or substantial portions of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#ifndef HDiff_diff_h
+#define HDiff_diff_h
+#include <vector>
+#include "diff_types.h"
+
+static const int kMinSingleMatchScore_default = 6;
+
+//create a diff data between oldData and newData
+//  out_diff is uncompressed, you can use create_compressed_diff()
+//       or create_compressed_diff_stream() create compressed diff data
+//  recommended always use create_compressed_diff() replace create_diff()
+//  kMinSingleMatchScore: default 6, bin: 0--4  text: 4--9
+void create_diff(const unsigned char* newData,const unsigned char* newData_end,
+                 const unsigned char* oldData,const unsigned char* oldData_end,
+                 std::vector<unsigned char>& out_diff,
+                 int kMinSingleMatchScore=kMinSingleMatchScore_default);
+
+//return patch(oldData+diff)==newData?
+bool check_diff(const unsigned char* newData,const unsigned char* newData_end,
+                const unsigned char* oldData,const unsigned char* oldData_end,
+                const unsigned char* diff,const unsigned char* diff_end);
+
+
+
+//create a compressed diffData between oldData and newData
+//  out_diff compressed by compressPlugin
+//  kMinSingleMatchScore: default 6, bin: 0--4  text: 4--9
+void create_compressed_diff(const unsigned char* newData,const unsigned char* newData_end,
+                            const unsigned char* oldData,const unsigned char* oldData_end,
+                            std::vector<unsigned char>& out_diff,
+                            const hdiff_TCompress* compressPlugin=0,
+                            int kMinSingleMatchScore=kMinSingleMatchScore_default);
+//return patch_decompress(oldData+diff)==newData?
+bool check_compressed_diff(const unsigned char* newData,const unsigned char* newData_end,
+                           const unsigned char* oldData,const unsigned char* oldData_end,
+                           const unsigned char* diff,const unsigned char* diff_end,
+                           hpatch_TDecompress* decompressPlugin);
+
+//see check_compressed_diff
+bool check_compressed_diff_stream(const hpatch_TStreamInput*  newData,
+                                  const hpatch_TStreamInput*  oldData,
+                                  const hpatch_TStreamInput*  compressed_diff,
+                                  hpatch_TDecompress* decompressPlugin);
+
+struct ICoverLinesListener {
+    void (*coverLines)(ICoverLinesListener* listener,hpatch_TCover* out_covers,size_t* coverCount,
+                       hpatch_StreamPos_t* newSize,hpatch_StreamPos_t* oldSize);
+};
+const size_t kDefaultStepMemSize =1024*256;
+
+//create a diffData between oldData and newData, the diffData saved as single compressed stream
+//  still under development!
+void create_single_compressed_diff(const unsigned char* newData,const unsigned char* newData_end,
+                                   const unsigned char* oldData,const unsigned char* oldData_end,
+                                   std::vector<unsigned char>& out_diff,ICoverLinesListener* listener=0,
+                                   const hdiff_TCompress* compressPlugin=0,int kMinSingleMatchScore=kMinSingleMatchScore_default,
+                                   size_t patchStepMemSize=kDefaultStepMemSize,bool _is_test_search_cover_by_stream=false);
+bool check_single_compressed_diff(const unsigned char* newData,const unsigned char* newData_end,
+                                  const unsigned char* oldData,const unsigned char* oldData_end,
+                                  const unsigned char* diff,const unsigned char* diff_end,
+                                  hpatch_TDecompress* decompressPlugin);
+
+
+//diff by stream:
+//  can control memory requires and run speed by different kMatchBlockSize value,
+//      but out_diff size is larger than create_compressed_diff()
+//  recommended used in limited environment or support large file
+//  kMatchBlockSize: recommended (1<<4)--(1<<14)
+//    if increase kMatchBlockSize then run faster and require less memory, but out_diff size increase
+//  NOTICE: out_diff->write()'s writeToPos may be back to update headData!
+//  throw std::runtime_error when I/O error,etc.
+static const size_t kMatchBlockSize_default = (1<<6);
+void create_compressed_diff_stream(const hpatch_TStreamInput*  newData,
+                                   const hpatch_TStreamInput*  oldData,
+                                   const hpatch_TStreamOutput* out_diff,
+                                   const hdiff_TCompress* compressPlugin=0,
+                                   size_t kMatchBlockSize=kMatchBlockSize_default);
+
+
+//resave compressed_diff
+//  decompress in_diff and recompress to out_diff
+//  throw std::runtime_error when input file error or I/O error,etc.
+void resave_compressed_diff(const hpatch_TStreamInput*  in_diff,
+                            hpatch_TDecompress*         decompressPlugin,
+                            const hpatch_TStreamOutput* out_diff,
+                            const hdiff_TCompress*      compressPlugin);
+
+#endif

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

@@ -0,0 +1,72 @@
+//diff_types.h
+//
+/*
+ The MIT License (MIT)
+ Copyright (c) 2012-2017 HouSisong
+ 
+ Permission is hereby granted, free of charge, to any person
+ obtaining a copy of this software and associated documentation
+ files (the "Software"), to deal in the Software without
+ restriction, including without limitation the rights to use,
+ copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following
+ conditions:
+ 
+ The above copyright notice and this permission notice shall be
+ included in all copies or substantial portions of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#ifndef HDiff_diff_types_h
+#define HDiff_diff_types_h
+#include "../HPatch/patch_types.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    typedef hpatch_TStreamOutput hdiff_TStreamOutput;
+    typedef hpatch_TStreamInput  hdiff_TStreamInput;
+    //compress plugin
+    typedef struct hdiff_TCompress{
+        //return type tag; strlen(result)<=hpatch_kMaxPluginTypeLength; (Note:result lifetime)
+        const char*             (*compressType)(void);//ascii cstring,cannot contain '&'
+        //return the max compressed size, if input dataSize data;
+        hpatch_StreamPos_t (*maxCompressedSize)(hpatch_StreamPos_t dataSize);
+        //return support threadNumber
+        int          (*setParallelThreadNumber)(struct hdiff_TCompress* compressPlugin,int threadNum);
+        //compress data to out_code; return compressed size, if error or not need compress then return 0;
+        //if out_code->write() return hdiff_stream_kCancelCompress(error) then return 0;
+        //if memory I/O can use hdiff_compress_mem()
+        hpatch_StreamPos_t          (*compress)(const struct hdiff_TCompress* compressPlugin,
+                                                const hpatch_TStreamOutput*   out_code,
+                                                const hpatch_TStreamInput*    in_data);
+    } hdiff_TCompress;
+    
+    static hpatch_inline
+    size_t hdiff_compress_mem(const hdiff_TCompress* compressPlugin,
+                              unsigned char* out_code,unsigned char* out_code_end,
+                              const unsigned char* data,const unsigned char* data_end){
+        hpatch_TStreamOutput codeStream;
+        hpatch_TStreamInput  dataStream;
+        mem_as_hStreamOutput(&codeStream,out_code,out_code_end);
+        mem_as_hStreamInput(&dataStream,data,data_end);
+        hpatch_StreamPos_t codeLen=compressPlugin->compress(compressPlugin,&codeStream,&dataStream);
+        if (codeLen!=(size_t)codeLen) return 0; //error
+        return (size_t)codeLen;
+    }
+    
+#ifdef __cplusplus
+}
+#endif
+#endif //HDiff_diff_types_h

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

@@ -0,0 +1,213 @@
+//bytes_rle.cpp
+//
+/*
+ The MIT License (MIT)
+ Copyright (c) 2012-2017 HouSisong
+
+ Permission is hereby granted, free of charge, to any person
+ obtaining a copy of this software and associated documentation
+ files (the "Software"), to deal in the Software without
+ restriction, including without limitation the rights to use,
+ copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following
+ conditions:
+
+ The above copyright notice and this permission notice shall be
+ included in all copies of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#include "bytes_rle.h"
+#include <assert.h>
+#include "pack_uint.h"
+#include "../../HPatch/patch_private.h"
+namespace hdiff_private{
+
+namespace {
+    
+    typedef unsigned char TByte;
+    typedef size_t TUInt;
+
+    static void rle_pushSame(std::vector<TByte>& out_ctrl,std::vector<TByte>& out_code,
+                             TByte cur,TUInt count){
+        assert(count>0);
+        enum TByteRleType type;
+        if (cur==0)
+            type=kByteRleType_rle0;
+        else if (cur==255)
+            type=kByteRleType_rle255;
+        else
+            type=kByteRleType_rle;
+        const TUInt packCount=(TUInt)(count-1);
+        packUIntWithTag(out_ctrl,packCount,type,kByteRleType_bit);
+        if (type==kByteRleType_rle)
+            out_code.push_back(cur);
+    }
+
+    static void rle_pushNotSame(std::vector<TByte>& out_ctrl,std::vector<TByte>& out_code,
+                                const TByte* byteStream,TUInt count){
+        assert(count>0);
+        if (count==1){
+            rle_pushSame(out_ctrl,out_code,(*byteStream),1);
+            return;
+        }
+
+        packUIntWithTag(out_ctrl,(TUInt)(count-1), kByteRleType_unrle,kByteRleType_bit);
+        out_code.insert(out_code.end(),byteStream,byteStream+count);
+    }
+
+    inline static const TByte* rle_getEqualEnd(const TByte* cur,const TByte* src_end,TByte value){
+        while (cur!=src_end) {
+            if (*cur==value)
+                ++cur;
+            else
+                return cur;
+        }
+        return src_end;
+    }
+    
+}//end namespace
+    
+    void bytesRLE_save(std::vector<TByte>& out_ctrlBuf,std::vector<TByte>& out_codeBuf,
+                       const TByte* src,const TByte* src_end,int rle_parameter){
+        assert(rle_parameter>=kRle_bestSize);
+        assert(rle_parameter<=kRle_bestUnRleSpeed);
+        const TUInt kRleMinSameSize=rle_parameter+1;//增大则压缩率变小,解压稍快.
+
+        const TByte* notSame=src;
+        while (src!=src_end) {
+            //find equal length
+            TByte value=*src;
+            const TByte* eqEnd=rle_getEqualEnd(src+1,src_end,value);
+            const TUInt sameCount=(TUInt)(eqEnd-src);
+            if ( (sameCount>kRleMinSameSize) || (  (sameCount==kRleMinSameSize)
+                                                 &&( (value==0)||(value==255) ) ) ){//可以压缩.
+                if (notSame!=src){
+                    rle_pushNotSame(out_ctrlBuf,out_codeBuf,notSame,(TUInt)(src-notSame));
+                }
+                rle_pushSame(out_ctrlBuf,out_codeBuf,value, sameCount);
+
+                src+=sameCount;
+                notSame=src;
+            }else{
+                src=eqEnd;
+            }
+        }
+        if (notSame!=src_end){
+            rle_pushNotSame(out_ctrlBuf,out_codeBuf,notSame,(TUInt)(src_end-notSame));
+        }
+    }
+
+
+void bytesRLE_save(std::vector<TByte>& out_code,
+                   const TByte* src,const TByte* src_end,int rle_parameter){
+    std::vector<TByte> ctrlBuf;
+    std::vector<TByte> codeBuf;
+
+    bytesRLE_save(ctrlBuf,codeBuf,src,src_end,rle_parameter);
+    packUInt(out_code,(TUInt)ctrlBuf.size());
+    pushBack(out_code,ctrlBuf);
+    pushBack(out_code,codeBuf);
+}
+
+    
+    enum TLastType{
+        lastType_0,
+        lastType_v,
+    };
+    
+    inline TLastType getLastType(const TSangileStreamRLE0& self){
+        if (!self.uncompressData.empty()){
+            assert(self.len0==0);
+            return lastType_v;
+        }else{
+            return lastType_0;
+        }
+    }
+    
+    size_t TSangileStreamRLE0::maxCodeSize(const unsigned char* appendData,const unsigned char* appendData_end) const{
+        TLastType lastType=getLastType(*this);
+        size_t curLen0=this->len0;
+        size_t curLenv=this->uncompressData.size();
+        size_t fixedLen=this->fixed_code.size();
+        while (appendData!=appendData_end) {
+            if (*appendData==0){
+                if (lastType==lastType_v){
+                    fixedLen += hpatch_packUInt_size(curLenv) + curLenv;
+                    curLenv = 0;
+                }
+                ++curLen0;
+                lastType=lastType_0;
+            }else{
+                if (lastType==lastType_0){
+                    fixedLen += hpatch_packUInt_size(curLen0);
+                    curLen0 = 0;
+                }
+                ++curLenv;
+                lastType=lastType_v;
+            }
+            ++appendData;
+        }
+        if (curLenv>0)
+            fixedLen += hpatch_packUInt_size(curLenv) + curLenv;
+        if (curLen0>0)
+            fixedLen += hpatch_packUInt_size(curLen0);
+        return fixedLen;
+    }
+    
+    inline void _out_uncompressData(TSangileStreamRLE0& self){
+        size_t saved=0;
+        while (self.uncompressData.size()-saved>kMaxBytesRle0Len){
+            packUInt(self.fixed_code, kMaxBytesRle0Len);
+            pushBack(self.fixed_code, self.uncompressData.data()+saved,self.uncompressData.data()+saved+kMaxBytesRle0Len);
+            packUInt(self.fixed_code,0);
+            saved+=kMaxBytesRle0Len;
+        }
+        packUInt(self.fixed_code, self.uncompressData.size()-saved);
+        pushBack(self.fixed_code, self.uncompressData.data()+saved,self.uncompressData.data()+self.uncompressData.size());
+        self.uncompressData.clear();
+    }
+    inline void _out_0Data(TSangileStreamRLE0& self){
+        while (self.len0>kMaxBytesRle0Len){
+            packUInt(self.fixed_code,kMaxBytesRle0Len);
+            self.len0-=kMaxBytesRle0Len;
+            packUInt(self.fixed_code,0);
+        }
+        packUInt(self.fixed_code, self.len0);
+        self.len0=0;
+    }
+    
+    void TSangileStreamRLE0::append(const unsigned char* appendData,const unsigned char* appendData_end){
+        TLastType lastType=getLastType(*this);
+        while (appendData!=appendData_end) {
+            if (*appendData==0){
+                if (lastType==lastType_v)
+                    _out_uncompressData(*this);
+                ++len0;
+                lastType=lastType_0;
+            }else{
+                if (lastType==lastType_0)
+                    _out_0Data(*this);
+                uncompressData.push_back(*appendData);
+                lastType=lastType_v;
+            }
+            ++appendData;
+        }
+    }
+    
+    void TSangileStreamRLE0::finishAppend(){
+        if ((fixed_code.empty())||(len0>0))
+            _out_0Data(*this);
+        if (!uncompressData.empty())
+            _out_uncompressData(*this);
+    }
+}//namespace hdiff_private

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

@@ -0,0 +1,63 @@
+//bytes_rle.h
+//快速解压的一个通用字节流压缩rle算法.
+//
+/*
+ The MIT License (MIT)
+ Copyright (c) 2012-2017 HouSisong
+ 
+ Permission is hereby granted, free of charge, to any person
+ obtaining a copy of this software and associated documentation
+ files (the "Software"), to deal in the Software without
+ restriction, including without limitation the rights to use,
+ copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following
+ conditions:
+ 
+ The above copyright notice and this permission notice shall be
+ included in all copies of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#ifndef __BYTES_RLE_H_
+#define __BYTES_RLE_H_
+#include <string.h>
+#include <vector>
+namespace hdiff_private{
+
+enum TRleParameter{ kRle_bestSize=1, kRle_default=3, kRle_bestUnRleSpeed=32 };
+
+void bytesRLE_save(std::vector<unsigned char>& out_code,
+                   const unsigned char* src,const unsigned char* src_end,
+                   int rle_parameter=kRle_default);
+
+
+void bytesRLE_save(std::vector<unsigned char>& out_ctrlBuf,std::vector<unsigned char>& out_codeBuf,
+                   const unsigned char* src,const unsigned char* src_end,int rle_parameter);
+
+#ifndef kMaxBytesRle0Len
+    static const size_t kMaxBytesRle0Len =(size_t)(((size_t)1<<31)-1);
+#endif
+    
+    struct TSangileStreamRLE0{
+        std::vector<unsigned char>  fixed_code;
+        std::vector<unsigned char>  uncompressData;
+        size_t                      len0;
+        inline TSangileStreamRLE0():len0(0){}
+        inline size_t curCodeSize() const { return maxCodeSize(0,0); }
+        size_t maxCodeSize(const unsigned char* appendData,const unsigned char* appendData_end) const;
+        void append(const unsigned char* appendData,const unsigned char* appendData_end);
+        void finishAppend();
+        inline void clear() { fixed_code.clear(); uncompressData.clear(); len0=0; }
+    };
+    
+}//namespace hdiff_private
+#endif //__BYTES_RLE_H_

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

@@ -0,0 +1,170 @@
+//compress_detect.cpp
+//
+/*
+ The MIT License (MIT)
+ Copyright (c) 2012-2017 HouSisong
+ 
+ Permission is hereby granted, free of charge, to any person
+ obtaining a copy of this software and associated documentation
+ files (the "Software"), to deal in the Software without
+ restriction, including without limitation the rights to use,
+ copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following
+ conditions:
+ 
+ The above copyright notice and this permission notice shall be
+ included in all copies of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "compress_detect.h"
+#include <string.h> //memset
+#include <stdexcept> //std::runtime_error
+namespace hdiff_private{
+
+    template<bool is_sub_on,bool is_out_on>
+    size_t _getRegionRleCost(const unsigned char* d,size_t n,const unsigned char* sub,
+                             unsigned char* out_nocompress,size_t* nocompressSize){
+        size_t bufi=0;
+        size_t i=0;
+        size_t cost=0;
+        while ((i<n)&&(d[i]==(is_sub_on?sub[i]:0)))
+            ++i;
+        while(i<n){
+            unsigned char v=(is_sub_on?(unsigned char)(d[i]-sub[i]):d[i]);
+            size_t i0=i; ++i;
+            while ((i<n)&&(v==(is_sub_on?(unsigned char)(d[i]-sub[i]):d[i])))
+                ++i;
+            if ((v==0)|(v==255)){
+                ++cost;
+            }else{
+                cost+=(i-i0<=1)?1:2;
+                if (is_out_on)
+                    out_nocompress[bufi++]=v;
+            }
+        }
+        if (nocompressSize) *nocompressSize=bufi;
+        return cost;
+    }
+
+    
+size_t getRegionRleCost(const unsigned char* d,size_t n,const unsigned char* sub,
+                        unsigned char* out_nocompress,size_t* nocompressSize){
+    assert((nocompressSize==0)||(*nocompressSize>=n));
+    if (sub){
+        if (out_nocompress)
+            return _getRegionRleCost<true,true>(d,n,sub,out_nocompress,nocompressSize);
+        else
+            return _getRegionRleCost<true,false>(d,n,sub,0,nocompressSize);
+    }else{
+        if (out_nocompress)
+            return _getRegionRleCost<false,true>(d,n,0,out_nocompress,nocompressSize);
+        else
+            return _getRegionRleCost<false,false>(d,n,0,0,nocompressSize);
+    }
+}
+
+static const size_t kCacheSize=(1<<19);
+TCompressDetect::TCompressDetect()
+:m_table(0),m_lastChar(-1),
+m_lastPopChar(-1),m_cacheBegin(0),m_cacheEnd(0){
+    m_mem.realloc(sizeof(TCharConvTable)+kCacheSize);
+    m_table=(TCharConvTable*)m_mem.data();
+    memset(m_table,0,sizeof(TCharConvTable));
+}
+TCompressDetect::~TCompressDetect(){
+}
+
+void TCompressDetect::_add_rle(const unsigned char* d,size_t n){
+    if (m_lastChar<0){
+        if (n==0) return;
+        m_lastChar=d[0];
+        ++m_table->sum1char[m_lastChar];
+        ++d;
+        --n;
+    }
+    for (size_t i=0;i<n;++i) {
+        unsigned char cur=d[i];
+        ++m_table->sum1char[cur];
+        ++m_table->sum2char[m_lastChar*256+cur];
+        m_lastChar=cur;
+        
+        if (m_table->sum==kCacheSize){
+            --m_table->sum;
+            unsigned char pop=m_table->cache[m_cacheBegin++];
+            if (m_cacheBegin==kCacheSize) m_cacheBegin=0;
+            --m_table->sum1char[pop];
+            if (m_lastPopChar>=0){
+                --m_table->sum2char[m_lastPopChar*256+pop];
+            }
+            m_lastPopChar=pop;
+        }
+        ++m_table->sum;
+        m_table->cache[m_cacheEnd++]=cur;
+        if (m_cacheEnd==kCacheSize) m_cacheEnd=0;
+    }
+}
+
+size_t TCompressDetect::_cost_rle(const unsigned char* d,size_t n)const{
+    //assert(kCacheSize*2^(kCompressDetectMaxBit-1)<2^32);
+    const unsigned int kCompressDetectDivBit=12;
+    const unsigned int kCompressDetectMaxBit=12;
+    if (n==0) return 0;
+    if (m_lastChar<0) return n;
+    size_t        codeSize=0;
+    unsigned char last=m_lastChar;
+    for (size_t i=0;i<n;++i) {
+        unsigned char cur=d[i];
+        size_t rab=m_table->sum2char[last*256+cur];
+        size_t ra =1+m_table->sum1char[last];
+        last=cur;
+        if ((rab<<(kCompressDetectMaxBit-1))>ra){
+            if ((rab<<8)<ra) { rab<<=8; codeSize+=8; }
+            if ((rab<<4)<ra) { rab<<=4; codeSize+=4; }
+            if ((rab<<2)<ra) { rab<<=2; codeSize+=2; }
+            if ((rab<<1)<ra) { codeSize+=1; }
+            ++codeSize;
+        }else{
+            codeSize+=kCompressDetectMaxBit;
+        }
+    }
+    return (codeSize+((kCompressDetectDivBit>>1)+1))/kCompressDetectDivBit;
+}
+
+static const size_t _kBufSize=1024;
+#define by_step(call)     \
+    size_t rleCtrlCost=0; \
+    unsigned char rcode[_kBufSize]; \
+    while (n>0) {         \
+        size_t readLen=_kBufSize;   \
+        if (readLen>n) readLen=n;   \
+        size_t rcodeLen=readLen;\
+        rleCtrlCost+=getRegionRleCost(d,readLen,sub,rcode,&rcodeLen);\
+        rleCtrlCost-=rcodeLen;  \
+        call(rcode,rcodeLen);   \
+        d+=readLen;             \
+        if (sub) sub+=readLen;  \
+        n-=readLen;             \
+    }  \
+
+
+void TCompressDetect::add_chars(const unsigned char* d,size_t n,const unsigned char* sub){
+    by_step(this->_add_rle);
+}
+
+size_t TCompressDetect::cost(const unsigned char* d,size_t n,const unsigned char* sub)const{
+    size_t result=0;
+    by_step(result+=this->_cost_rle);
+    return result+rleCtrlCost;
+}
+
+}//namespace hdiff_private