react-native-update 10.34.1 → 10.34.3

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

@@ -0,0 +1,133 @@
+//suffix_string.h
+// An implementation of suffix string.
+//
+/*
+ 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 __SUFFIX_STRING_H_
+#define __SUFFIX_STRING_H_
+#include <vector>
+#include <stddef.h> //for ptrdiff_t,size_t
+#ifndef _SSTRING_FAST_MATCH
+#   define _SSTRING_FAST_MATCH 5
+#endif
+#if (_SSTRING_FAST_MATCH>0)
+#   if (_SSTRING_FAST_MATCH<2)
+#       error must _SSTRING_FAST_MATCH>=2!
+#   endif
+#   include "limit_mem_diff/bloom_filter.h"
+#   include "limit_mem_diff/adler_roll.h"
+#endif
+
+#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
+#   include <stdint.h> //for int32_t
+namespace hdiff_private{
+#else
+namespace hdiff_private{
+#   if (_MSC_VER >= 1300)
+    typedef signed __int32 int32_t;
+#   else
+    typedef signed int     int32_t;
+#   endif
+#endif
+
+#if (_SSTRING_FAST_MATCH>0)
+class TFastMatchForSString{
+public:
+    typedef uint32_t      THash;
+    typedef unsigned char TChar;
+    enum { kFMMinStrSize=_SSTRING_FAST_MATCH };
+
+    inline TFastMatchForSString(){}
+    inline void clear(){ bf.clear(); }
+    void buildMatchCache(const TChar* src_begin,const TChar* src_end,size_t threadNum);
+
+    static hpatch_force_inline THash getHash(const TChar* datas) { return fast_adler32_start(datas,kFMMinStrSize); }
+    static hpatch_force_inline THash rollHash(THash h,const TChar* cur) { return fast_adler32_roll(h,kFMMinStrSize,cur[-kFMMinStrSize],cur[0]); }
+
+    hpatch_force_inline bool isHit(THash h) const { return bf.is_hit(h); }
+private:
+    TBloomFilter<THash>  bf;
+};
+#endif
+
+class TSuffixString{
+public:
+    typedef ptrdiff_t     TInt;
+    typedef int32_t       TInt32;
+    typedef unsigned char TChar;
+    explicit TSuffixString(bool isUsedFastMatch=false);
+    ~TSuffixString();
+    
+    //throw std::runtime_error when create SA error
+    TSuffixString(const TChar* src_begin,const TChar* src_end,bool isUsedFastMatch=false,size_t threadNum=1);
+    void resetSuffixString(const TChar* src_begin,const TChar* src_end,size_t threadNum=1);
+
+    inline const TChar* src_begin()const{ return m_src_begin; }
+    inline const TChar* src_end()const{ return m_src_end; }
+    inline size_t SASize()const{ return (size_t)(m_src_end-m_src_begin); }
+    void clear();
+
+    inline TInt SA(TInt i)const{//return m_SA[i];// Sorted suffix string array.
+        if (isUseLargeSA())
+            return m_SA_large[i];
+        else
+            return (TInt)m_SA_limit[i];
+    }
+    TInt lower_bound(const TChar* str,const TChar* str_end)const;//return index in SA; must str_end-str>=2 !
+private:
+    TSuffixString(const TSuffixString &); //empty
+    TSuffixString &operator=(const TSuffixString &); //empty
+private:
+    const TChar*        m_src_begin;// Original string.
+    const TChar*        m_src_end;
+    std::vector<TInt32> m_SA_limit;
+    std::vector<TInt>   m_SA_large;
+    enum{ kLimitSASize= (1<<30)-1 + (1<<30) };//2G-1
+    inline bool isUseLargeSA()const{
+        return (sizeof(TInt)>sizeof(TInt32)) && (SASize()>kLimitSASize);
+    }
+private:
+    // all cache for lower_bound speed
+    const bool              m_isUsedFastMatch;
+#if (_SSTRING_FAST_MATCH>0)
+    TFastMatchForSString    m_fastMatch; //a big memory cache & build slow
+#endif
+    const void*         m_cached_SA_begin;
+    const void*         m_cached_SA_end;
+    const void*         m_cached1char_range[256+1];
+    void*               m_cached2char_range;//[256*256+1]
+    typedef TInt (*t_lower_bound_func)(const void* rbegin,const void* rend,
+                                       const TChar* str,const TChar* str_end,
+                                       const TChar* src_begin,const TChar* src_end,
+                                       const void* SA_begin,size_t min_eq);
+    t_lower_bound_func  m_lower_bound;
+    void                build_cache(size_t threadNum);
+    void                clear_cache();
+};
+
+}//namespace hdiff_private
+#endif //__SUFFIX_STRING_H_

package/harmony/pushy/src/main/cpp/HDiffPatch/libHDiffPatch/HPatch/checksum_plugin.h

@@ -0,0 +1,52 @@
+//checksum_plugin.h
+//  checksum plugin type
+/*
+ The MIT License (MIT)
+ Copyright (c) 2018-2019 HouSisong
+ 
+ Permission is hereby granted, free of charge, to any person
+ obtaining a copy of this software and associated documentation
+ files (the "Software"), to deal in the Software without
+ restriction, including without limitation the rights to use,
+ copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following
+ conditions:
+ 
+ The above copyright notice and this permission notice shall be
+ included in all copies 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 HPatch_checksum_plugin_h
+#define HPatch_checksum_plugin_h
+#include "patch_types.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+    
+    typedef void*  hpatch_checksumHandle;
+    typedef struct hpatch_TChecksum{
+        //return type tag; strlen(result)<=hpatch_kMaxPluginTypeLength; (Note:result lifetime)
+        const char*   (*checksumType)(void); //ascii cstring,cannot contain '&'
+        hpatch_size_t (*checksumByteSize)(void); //result<=hpatch_kStreamCacheSize
+        hpatch_checksumHandle (*open)(struct hpatch_TChecksum* plugin);
+        void                 (*close)(struct hpatch_TChecksum* plugin,hpatch_checksumHandle handle);
+        void                 (*begin)(hpatch_checksumHandle handle);
+        void                (*append)(hpatch_checksumHandle handle,
+                                      const unsigned char* part_data,const unsigned char* part_data_end);
+        void                   (*end)(hpatch_checksumHandle handle,
+                                      unsigned char* checksum,unsigned char* checksum_end);
+    } hpatch_TChecksum;
+    
+#ifdef __cplusplus
+}
+#endif
+#endif

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

@@ -0,0 +1,243 @@
+//  _hcache_old_mt.c
+//  hpatch
+/*
+ The MIT License (MIT)
+ Copyright (c) 2025 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 "_hcache_old_mt.h"
+#include "_patch_private_mt.h"
+#include "../patch_private.h"
+#if (_IS_USED_MULTITHREAD)
+
+typedef struct hcache_old_mt_t{
+    hpatch_TStreamInput         base;
+    const hpatch_TStreamInput*  old_stream;
+    hpatch_TWorkBuf*            curDataBuf;
+    size_t                      curDataBuf_pos;
+    sspatch_coversListener_t    coversListener;
+    sspatch_coversListener_t*   nextCoverlistener;
+    volatile hpatch_StreamPos_t   leaveCoverCount;
+    const volatile unsigned char* covers_cache;
+    const volatile unsigned char* covers_cacheEnd;
+    hpatch_BOOL                 isOnStepCoversInThread;
+    hpatch_mt_base_t            mt_base;
+}hcache_old_mt_t;
+
+static void _hcache_old_mt_free(hcache_old_mt_t* self){
+    if (self==0) return;
+    self->base.streamImport=0;
+    _hpatch_mt_base_free(&self->mt_base);
+}
+
+    static hpatch_force_inline
+    hpatch_BOOL _read_data(const hpatch_TStreamInput* stream,hpatch_StreamPos_t readFromPos,
+                           hpatch_TWorkBuf* wbuf,size_t read_len){
+        unsigned char* out_data=TWorkBuf_data_end(wbuf);
+        return stream->read(stream,readFromPos,out_data,out_data+read_len);
+    }
+
+
+    #define _check_therr(func) { \
+        if (!(func)) { hpatch_mt_base_setOnError_(&self->mt_base); \
+                       _isOnError=hpatch_TRUE; \
+                       break; } }
+
+static void hcache_old_thread_(int threadIndex,void* workData){
+    hcache_old_mt_t* self=(hcache_old_mt_t*)workData;
+    sspatch_covers_t covers;
+    sspatch_covers_init(&covers);
+    while (!hpatch_mt_isOnFinish(self->mt_base.h_mt)){//covers_cache loop
+        unsigned char* covers_cache=0;
+        unsigned char* covers_cacheEnd=0;
+        hpatch_BOOL _isOnError;
+        hpatch_BOOL _isGot_covers_cache=hpatch_FALSE;
+        c_locker_enter(self->mt_base._locker);
+        _isOnError=self->mt_base.isOnError;
+        if (!_isOnError){
+            covers_cache=(unsigned char*)self->covers_cache;
+            covers_cacheEnd=(unsigned char*)self->covers_cacheEnd;
+            _isGot_covers_cache=(covers_cache!=0)|(self->leaveCoverCount==0);
+            if (!_isGot_covers_cache){
+                c_condvar_wait(self->mt_base._waitCondvar,self->mt_base._locker);
+                covers_cache=(unsigned char*)self->covers_cache;
+                covers_cacheEnd=(unsigned char*)self->covers_cacheEnd;
+                _isGot_covers_cache=(covers_cache!=0)|(self->leaveCoverCount==0);
+            }
+            if (_isGot_covers_cache){
+                self->covers_cache=0;
+                self->covers_cacheEnd=0;
+            }
+        }
+        c_locker_leave(self->mt_base._locker);
+        if (_isOnError) break; //exit loop by error
+        if (_isGot_covers_cache&self->isOnStepCoversInThread&(self->nextCoverlistener!=0))
+            self->nextCoverlistener->onStepCovers(self->nextCoverlistener,covers_cache,covers_cacheEnd);
+        if (_isGot_covers_cache&(covers_cache==0)) break; //exit loop by all done
+        if (covers_cache==0) continue; //need covers_cache
+        assert(_isGot_covers_cache);
+
+        {//got covers_cache
+            hpatch_TWorkBuf* wbuf=0;
+            sspatch_covers_setCoversCache(&covers,covers_cache,covers_cacheEnd);
+            while (sspatch_covers_isHaveNextCover(&covers)){//cover loop
+                hpatch_StreamPos_t coverLen;
+                hpatch_StreamPos_t coverPos;
+                _check_therr(sspatch_covers_nextCover(&covers));
+                coverLen=covers.cover.length;
+                coverPos=covers.cover.oldPos;
+                _check_therr((coverPos<=self->old_stream->streamSize)&
+                             (coverLen<=(hpatch_StreamPos_t)(self->old_stream->streamSize-coverPos)));
+                while (coverLen){//buf loop
+                    size_t readLen;
+                    if (wbuf==0){
+                        wbuf=hpatch_mt_base_onceWaitABuf_(&self->mt_base,(hpatch_TWorkBuf**)&self->mt_base.freeBufList,&_isOnError);
+                        if (_isOnError) break; //exit read loop by error
+                        if (wbuf==0) continue; //need buf
+                        wbuf->data_size=0;
+                    }
+
+                    readLen=self->mt_base.workBufSize-wbuf->data_size;
+                    if (readLen>coverLen) readLen=(size_t)coverLen;
+                    _check_therr(_read_data(self->old_stream,coverPos,wbuf,readLen));
+                    wbuf->data_size+=readLen;
+                    coverPos+=readLen;
+                    coverLen-=readLen;
+                    if (wbuf->data_size==self->mt_base.workBufSize){
+                        hpatch_mt_base_pushABufAtEnd_(&self->mt_base,(hpatch_TWorkBuf**)&self->mt_base.dataBufList,wbuf,&_isOnError);
+                        wbuf=0;
+                    }
+                }//end buf loop
+                if (_isOnError) break; //exit loop by error
+            }//end cover loop
+            if (wbuf){
+                hpatch_mt_base_pushABufAtEnd_(&self->mt_base,(hpatch_TWorkBuf**)&self->mt_base.dataBufList,wbuf,&_isOnError);
+                wbuf=0;
+            }
+        }
+        if (_isOnError) break; //exit loop by error
+    }//end covers_cache loop
+
+    hpatch_mt_base_aThreadEnd_(&self->mt_base);
+}
+
+static void _hcache_old_mt_onStepCovers(struct sspatch_coversListener_t* listener,
+                                        const unsigned char* covers_cache,const unsigned char* covers_cacheEnd){
+    hcache_old_mt_t* self=(hcache_old_mt_t*)listener->import;
+    c_locker_enter(self->mt_base._locker);
+    assert(self->curDataBuf==0);
+    assert(self->covers_cache==0);
+    self->covers_cache=covers_cache;
+    self->covers_cacheEnd=covers_cacheEnd;
+    if (covers_cache==0){
+        assert(covers_cacheEnd==0);
+        self->leaveCoverCount=0;
+    }
+    c_condvar_signal(self->mt_base._waitCondvar);
+    c_locker_leave(self->mt_base._locker);
+    if ((!self->isOnStepCoversInThread)&(self->nextCoverlistener!=0))
+        self->nextCoverlistener->onStepCovers(self->nextCoverlistener,covers_cache,covers_cacheEnd);
+}
+static void _hcache_old_mt_onStepCoversReset(struct sspatch_coversListener_t* listener,hpatch_StreamPos_t leaveCoverCount){
+    hcache_old_mt_t* self=(hcache_old_mt_t*)listener->import;
+    c_locker_enter(self->mt_base._locker);
+    assert(self->curDataBuf==0);
+    assert(self->covers_cache==0);
+    self->leaveCoverCount=leaveCoverCount;
+    c_locker_leave(self->mt_base._locker);
+    if ((self->nextCoverlistener)&&(self->nextCoverlistener->onStepCoversReset))
+        self->nextCoverlistener->onStepCoversReset(self->nextCoverlistener,leaveCoverCount);
+}
+
+static hpatch_BOOL _hcache_old_mt_read(const struct hpatch_TStreamInput* stream,hpatch_StreamPos_t readFromPos,
+                                       unsigned char* out_data,unsigned char* out_data_end){
+    hcache_old_mt_t* self=(hcache_old_mt_t*)stream->streamImport;
+    _DEF_hinput_mt_base_read();
+}
+
+hpatch_inline static
+hpatch_BOOL _hcache_old_mt_init(hcache_old_mt_t* self,struct hpatch_mt_t* h_mt,hpatch_TWorkBuf* freeBufList,
+                                hpatch_size_t workBufSize,const hpatch_TStreamInput* old_stream,
+                                sspatch_coversListener_t* nextCoverlistener,hpatch_BOOL isOnStepCoversInThread){
+    memset(self,0,sizeof(*self));
+    assert(freeBufList);
+    if (!_hpatch_mt_base_init(&self->mt_base,h_mt,freeBufList,workBufSize)) return hpatch_FALSE;
+    self->base.streamImport=self;
+    self->base.streamSize=old_stream->streamSize;
+    self->base.read=_hcache_old_mt_read;
+    self->coversListener.import=self;
+    self->coversListener.onStepCovers=_hcache_old_mt_onStepCovers;
+#if (defined(_DEBUG) || defined(DEBUG))
+    if (hpatch_TRUE)
+#else
+    if (nextCoverlistener&&nextCoverlistener->onStepCoversReset)
+#endif
+        self->coversListener.onStepCoversReset=_hcache_old_mt_onStepCoversReset;
+    self->old_stream=old_stream;
+    self->nextCoverlistener=nextCoverlistener;
+    self->isOnStepCoversInThread=isOnStepCoversInThread?1:0;
+    self->leaveCoverCount=~(hpatch_StreamPos_t)0;
+    return hpatch_TRUE;
+}
+
+
+size_t hcache_old_mt_t_memSize(){
+    return sizeof(hcache_old_mt_t);
+}
+
+hpatch_TStreamInput* hcache_old_mt_open(void* pmem,size_t memSize,struct hpatch_mt_t* h_mt,
+                                        struct hpatch_TWorkBuf* freeBufList,hpatch_size_t workBufSize,
+                                        const hpatch_TStreamInput* old_stream,sspatch_coversListener_t** out_coversListener,
+                                        sspatch_coversListener_t* nextCoverlistener,hpatch_BOOL isOnStepCoversInThread){
+    hcache_old_mt_t* self=(hcache_old_mt_t*)pmem;
+    if (memSize<hcache_old_mt_t_memSize()) return 0;
+    if (nextCoverlistener) assert(nextCoverlistener->onStepCovers);
+    if (!_hcache_old_mt_init(self,h_mt,freeBufList,workBufSize,old_stream,nextCoverlistener,isOnStepCoversInThread))
+        goto _on_error;
+
+    if (!hpatch_mt_base_aThreadBegin_(&self->mt_base,hcache_old_thread_,self))
+        goto _on_error;
+
+    *out_coversListener=&self->coversListener;
+    return &self->base;
+
+_on_error:
+    _hcache_old_mt_free(self);
+    return 0;
+}
+
+hpatch_BOOL hcache_old_mt_close(hpatch_TStreamInput* hcache_old_mt_stream){
+    hpatch_BOOL result;
+    hcache_old_mt_t* self=0;
+    if (!hcache_old_mt_stream) return hpatch_TRUE;
+    self=(hcache_old_mt_t*)hcache_old_mt_stream->streamImport;
+    if (!self) return hpatch_TRUE;
+    hcache_old_mt_stream->streamImport=0;
+
+    result=(!self->mt_base.isOnError)&(self->curDataBuf==0)&(self->covers_cache==0)
+            &((self->leaveCoverCount==0)|(self->leaveCoverCount==~(hpatch_StreamPos_t)0));
+    _hcache_old_mt_free(self);
+    return result;
+}
+
+#endif //_IS_USED_MULTITHREAD

package/harmony/pushy/src/main/cpp/HDiffPatch/libHDiffPatch/HPatch/hpatch_mt/_hcache_old_mt.h

@@ -0,0 +1,51 @@
+//  _hcache_old_mt.h
+//  hpatch
+/*
+ The MIT License (MIT)
+ Copyright (c) 2025 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 _hcache_old_mt_h
+#define _hcache_old_mt_h
+#include "_hpatch_mt.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+#if (_IS_USED_MULTITHREAD)
+
+size_t               hcache_old_mt_t_memSize();
+
+// create a new hpatch_TStreamInput* wrapper old_stream;
+//   start a thread to read data from old_stream
+//   isOnStepCoversInThread default true, same as onStepCovers call back in thread
+hpatch_TStreamInput* hcache_old_mt_open(void* pmem,size_t memSize,struct hpatch_mt_t* h_mt,
+                                        struct hpatch_TWorkBuf* freeBufList,hpatch_size_t workBufSize,
+                                        const hpatch_TStreamInput* old_stream,sspatch_coversListener_t** out_coversListener,
+                                        sspatch_coversListener_t* nextCoverlistener,hpatch_BOOL isOnStepCoversInThread);
+hpatch_BOOL          hcache_old_mt_close(hpatch_TStreamInput* hcache_old_mt_stream);
+
+#endif //_IS_USED_MULTITHREAD
+#ifdef __cplusplus
+}
+#endif
+#endif //_hcache_old_mt_h

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

@@ -0,0 +1,153 @@
+//  _hinput_mt.c
+//  hpatch
+/*
+ The MIT License (MIT)
+ Copyright (c) 2025 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 "_hinput_mt.h"
+#include "_patch_private_mt.h"
+#if (_IS_USED_MULTITHREAD)
+
+typedef struct hinput_mt_t{
+    hpatch_TStreamInput         base;
+    const hpatch_TStreamInput*  base_stream;
+    hpatch_TWorkBuf*            curDataBuf;
+    size_t                      curDataBuf_pos;
+    hpatch_StreamPos_t          curReadPos;
+    hpatch_TDecompress*         decompressPlugin;
+    hpatch_decompressHandle*    decompressHandle;
+    volatile hpatch_StreamPos_t curOutedPos;
+    hpatch_mt_base_t            mt_base;
+} hinput_mt_t;
+
+    static hpatch_BOOL hinput_mt_read_(const struct hpatch_TStreamInput* stream,hpatch_StreamPos_t readFromPos,
+                                       unsigned char* out_data,unsigned char* out_data_end);
+
+hpatch_inline static
+hpatch_BOOL _hinput_mt_init(hinput_mt_t* self,struct hpatch_mt_t* h_mt,hpatch_TWorkBuf* freeBufList,hpatch_size_t workBufSize,
+                            const hpatch_TStreamInput* base_stream,hpatch_StreamPos_t curReadPos,hpatch_StreamPos_t endReadPos,
+                            hpatch_TDecompress* decompressPlugin,hpatch_StreamPos_t uncompressedSize){
+    memset(self,0,sizeof(*self));
+    assert(endReadPos<=base_stream->streamSize);
+    assert(freeBufList);
+    if (!_hpatch_mt_base_init(&self->mt_base,h_mt,freeBufList,workBufSize)) return hpatch_FALSE;
+    self->base.streamImport=self;
+    self->base.streamSize=decompressPlugin?(curReadPos+uncompressedSize):endReadPos;
+    self->base.read=hinput_mt_read_;
+    self->base_stream=base_stream;
+    self->curReadPos=curReadPos;
+    self->decompressPlugin=decompressPlugin;
+    self->curOutedPos=curReadPos;
+    if (decompressPlugin)
+        self->decompressHandle=decompressPlugin->open(decompressPlugin,uncompressedSize,
+                                                      base_stream,curReadPos,endReadPos);
+    return (self->decompressPlugin==0)|(self->decompressHandle!=0);
+}
+static void _hinput_mt_free(hinput_mt_t* self){
+    if (self==0) return;
+    self->base.streamImport=0;
+    if (self->decompressHandle) { self->decompressPlugin->close(self->decompressPlugin,self->decompressHandle); self->decompressHandle=0; }
+    _hpatch_mt_base_free(&self->mt_base);
+}
+
+static hpatch_BOOL _hinput_mt_readAData(hinput_mt_t* self,hpatch_TWorkBuf* data){
+    hpatch_StreamPos_t readPos=self->curReadPos;
+    size_t readLen=self->mt_base.workBufSize;
+    if (readPos+readLen>self->base.streamSize)
+        readLen=(size_t)(self->base.streamSize-readPos);
+    self->curReadPos+=readLen;
+    data->data_size=readLen;
+    if (self->decompressHandle)
+        return self->decompressPlugin->decompress_part(self->decompressHandle,TWorkBuf_data(data),TWorkBuf_data_end(data));
+    else
+        return self->base_stream->read(self->base_stream,readPos,TWorkBuf_data(data),TWorkBuf_data_end(data));
+}
+
+static void hinput_thread_(int threadIndex,void* workData){
+    hinput_mt_t* self=(hinput_mt_t*)workData;
+    hpatch_BOOL _isOnError=hpatch_FALSE;
+    while ((!hpatch_mt_isOnFinish(self->mt_base.h_mt))&(!_isOnError)&(self->curReadPos<self->base.streamSize)){
+        hpatch_TWorkBuf* wbuf=hpatch_mt_base_onceWaitABuf_(&self->mt_base,(hpatch_TWorkBuf**)&self->mt_base.freeBufList,&_isOnError);
+        
+        if ((wbuf!=0)&(!_isOnError)){
+            if (_hinput_mt_readAData(self,wbuf)){
+                hpatch_mt_base_pushABufAtEnd_(&self->mt_base,(hpatch_TWorkBuf**)&self->mt_base.dataBufList,wbuf,&_isOnError);
+            }else{
+                hpatch_mt_base_setOnError_(&self->mt_base);
+                _isOnError=hpatch_TRUE;
+            }
+        }
+    }
+
+    hpatch_mt_base_aThreadEnd_(&self->mt_base);
+}
+static hpatch_BOOL hinput_mt_read_(const hpatch_TStreamInput* stream,hpatch_StreamPos_t readFromPos,
+                                   unsigned char* out_data,unsigned char* out_data_end){
+    hinput_mt_t* self=(hinput_mt_t*)stream->streamImport;
+    if (self->curOutedPos!=readFromPos) return hpatch_FALSE;
+    self->curOutedPos+=(out_data_end-out_data);
+    if (self->curOutedPos>self->base.streamSize) return hpatch_FALSE;
+    _DEF_hinput_mt_base_read();
+}
+
+size_t hinput_mt_t_memSize(){
+    return sizeof(hinput_mt_t);
+}
+hpatch_TStreamInput* hinput_dec_mt_open(void* pmem,size_t memSize,struct hpatch_mt_t* h_mt,struct hpatch_TWorkBuf* freeBufList,hpatch_size_t workBufSize,
+                                        const hpatch_TStreamInput* base_stream,hpatch_StreamPos_t curReadPos,hpatch_StreamPos_t endReadPos,
+                                        hpatch_TDecompress* decompressPlugin,hpatch_StreamPos_t uncompressedSize){
+    hinput_mt_t* self=(hinput_mt_t*)pmem;
+    if (memSize<hinput_mt_t_memSize()) return 0;
+    if (!_hinput_mt_init(self,h_mt,freeBufList,workBufSize,base_stream,curReadPos,endReadPos,decompressPlugin,uncompressedSize))
+        goto _on_error;
+
+    if (!hpatch_mt_base_aThreadBegin_(&self->mt_base,hinput_thread_,self))
+        goto _on_error;
+
+    return &self->base;
+
+_on_error:
+    _hinput_mt_free(self);
+    return 0;
+}
+
+hpatch_TStreamInput* hinput_mt_open(void* pmem,size_t memSize,struct hpatch_mt_t* h_mt,hpatch_TWorkBuf* freeBufList,hpatch_size_t workBufSize,
+                                    const hpatch_TStreamInput* base_stream,hpatch_StreamPos_t curReadPos,hpatch_StreamPos_t endReadPos){
+    return hinput_dec_mt_open(pmem,memSize,h_mt,freeBufList,workBufSize,base_stream,curReadPos,endReadPos,0,0);
+}
+
+hpatch_BOOL hinput_mt_close(hpatch_TStreamInput* hinput_mt_stream){
+    hpatch_BOOL result;
+    hinput_mt_t* self=0;
+    if (!hinput_mt_stream) return hpatch_TRUE;
+    self=(hinput_mt_t*)hinput_mt_stream->streamImport;
+    if (!self) return hpatch_TRUE;
+    hinput_mt_stream->streamImport=0;
+
+    result=(!self->mt_base.isOnError)&(self->curOutedPos==self->base.streamSize);
+    _hinput_mt_free(self);
+    return result;
+}
+
+#endif //_IS_USED_MULTITHREAD