react-native-update 10.34.3 → 10.34.5

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/Archive/7z/7zHandlerOut.cpp

@@ -13,16 +13,13 @@
 #include "7zOut.h"
 #include "7zUpdate.h"
 
-#ifndef Z7_EXTRACT_ONLY
+#ifndef EXTRACT_ONLY
 
 using namespace NWindows;
 
 namespace NArchive {
 namespace N7z {
 
-static const UInt32 k_decoderCompatibilityVersion = 2301;
-// 7-Zip version 2301 supports ARM64 filter
-
 #define k_LZMA_Name "LZMA"
 #define kDefaultMethodName "LZMA2"
 #define k_Copy_Name "Copy"
@@ -38,7 +35,7 @@ static const UInt32 k_Dictionary_ForHeaders =
   1 << 20;
   #endif
 
-Z7_COM7F_IMF(CHandler::GetFileTimeType(UInt32 *type))
+STDMETHODIMP CHandler::GetFileTimeType(UInt32 *type)
 {
   *type = NFileTimeType::kWindows;
   return S_OK;
@@ -46,11 +43,10 @@ Z7_COM7F_IMF(CHandler::GetFileTimeType(UInt32 *type))
 
 HRESULT CHandler::PropsMethod_To_FullMethod(CMethodFull &dest, const COneMethodInfo &m)
 {
-  bool isFilter;
   dest.CodecIndex = FindMethod_Index(
       EXTERNAL_CODECS_VARS
       m.MethodName, true,
-      dest.Id, dest.NumStreams, isFilter);
+      dest.Id, dest.NumStreams);
   if (dest.CodecIndex < 0)
     return E_INVALIDARG;
   (CProps &)dest = (CProps &)m;
@@ -73,12 +69,15 @@ HRESULT CHandler::SetHeaderMethod(CCompressionMethodMode &headerMethod)
   return PropsMethod_To_FullMethod(methodFull, m);
 }
 
-
-HRESULT CHandler::SetMainMethod(CCompressionMethodMode &methodMode)
+HRESULT CHandler::SetMainMethod(
+    CCompressionMethodMode &methodMode
+    #ifndef _7ZIP_ST
+    , UInt32 numThreads
+    #endif
+    )
 {
   methodMode.Bonds = _bonds;
 
-  // we create local copy of _methods. So we can modify it.
   CObjectVector<COneMethodInfo> methods = _methods;
 
   {
@@ -111,8 +110,8 @@ HRESULT CHandler::SetMainMethod(CCompressionMethodMode &methodMode)
     }
   }
 
-  const UInt64 kSolidBytes_Min = 1 << 24;
-  const UInt64 kSolidBytes_Max = (UInt64)1 << 32;  // for non-LZMA2 methods
+  const UInt64 kSolidBytes_Min = (1 << 24);
+  const UInt64 kSolidBytes_Max = ((UInt64)1 << 32) - 1;
 
   bool needSolid = false;
   
@@ -121,192 +120,51 @@ HRESULT CHandler::SetMainMethod(CCompressionMethodMode &methodMode)
     COneMethodInfo &oneMethodInfo = methods[i];
 
     SetGlobalLevelTo(oneMethodInfo);
-
-#ifndef Z7_ST
-    const bool numThreads_WasSpecifiedInMethod = (oneMethodInfo.Get_NumThreads() >= 0);
-    if (!numThreads_WasSpecifiedInMethod)
-    {
-      // here we set the (NCoderPropID::kNumThreads) property in each method, only if there is no such property already
-      CMultiMethodProps::SetMethodThreadsTo_IfNotFinded(oneMethodInfo, methodMode.NumThreads);
-    }
-    if (methodMode.NumThreadGroups > 1)
-      CMultiMethodProps::Set_Method_NumThreadGroups_IfNotFinded(oneMethodInfo, methodMode.NumThreadGroups);
-#endif
+    #ifndef _7ZIP_ST
+    CMultiMethodProps::SetMethodThreadsTo(oneMethodInfo, numThreads);
+    #endif
 
     CMethodFull &methodFull = methodMode.Methods.AddNew();
-    RINOK(PropsMethod_To_FullMethod(methodFull, oneMethodInfo))
-
-#ifndef Z7_ST
-    methodFull.Set_NumThreads = true;
-    methodFull.NumThreads = methodMode.NumThreads;
-#endif
+    RINOK(PropsMethod_To_FullMethod(methodFull, oneMethodInfo));
 
     if (methodFull.Id != k_Copy)
       needSolid = true;
 
-    UInt64 dicSize;
+    if (_numSolidBytesDefined)
+      continue;
+
+    UInt32 dicSize;
     switch (methodFull.Id)
     {
       case k_LZMA:
       case k_LZMA2: dicSize = oneMethodInfo.Get_Lzma_DicSize(); break;
       case k_PPMD: dicSize = oneMethodInfo.Get_Ppmd_MemSize(); break;
       case k_Deflate: dicSize = (UInt32)1 << 15; break;
-      case k_Deflate64: dicSize = (UInt32)1 << 16; break;
       case k_BZip2: dicSize = oneMethodInfo.Get_BZip2_BlockSize(); break;
-      // case k_ZSTD: dicSize = 1 << 23; break;
       default: continue;
     }
-
-    UInt64 numSolidBytes;
-
-    /*
-    if (methodFull.Id == k_ZSTD)
-    {
-      // continue;
-      NCompress::NZstd::CEncoderProps encoderProps;
-      RINOK(oneMethodInfo.Set_PropsTo_zstd(encoderProps));
-      CZstdEncProps &zstdProps = encoderProps.EncProps;
-      ZstdEncProps_NormalizeFull(&zstdProps);
-      UInt64 cs = (UInt64)(zstdProps.jobSize);
-      UInt32 winSize = (UInt32)(1 << zstdProps.windowLog);
-      if (cs < winSize)
-        cs = winSize;
-      numSolidBytes = cs << 6;
-      const UInt64 kSolidBytes_Zstd_Max = ((UInt64)1 << 34);
-      if (numSolidBytes > kSolidBytes_Zstd_Max)
-        numSolidBytes = kSolidBytes_Zstd_Max;
-
-      methodFull.Set_NumThreads = false; // we don't use ICompressSetCoderMt::SetNumberOfThreads() for LZMA2 encoder
-
-      #ifndef Z7_ST
-      if (!numThreads_WasSpecifiedInMethod
-          && !methodMode.NumThreads_WasForced
-          && methodMode.MemoryUsageLimit_WasSet
-          )
-      {
-        const UInt32 numThreads_Original = methodMode.NumThreads;
-        const UInt32 numThreads_New = ZstdEncProps_GetNumThreads_for_MemUsageLimit(
-            &zstdProps,
-            methodMode.MemoryUsageLimit,
-            numThreads_Original);
-        if (numThreads_Original != numThreads_New)
-        {
-          CMultiMethodProps::SetMethodThreadsTo_Replace(methodFull, numThreads_New);
-        }
-      }
-      #endif
-    }
-    else
-    */
-    if (methodFull.Id == k_LZMA2)
-    {
-      // he we calculate default chunk Size for LZMA2 as defined in LZMA2 encoder code
-      /* lzma2 code use dictionary up to fake 4 GiB to calculate ChunkSize.
-         So we do same */
-      UInt64 cs = (UInt64)dicSize << 2;
-      const UInt32 kMinSize = (UInt32)1 << 20;
-      const UInt32 kMaxSize = (UInt32)1 << 28;
-      if (cs < kMinSize) cs = kMinSize;
-      if (cs > kMaxSize) cs = kMaxSize;
-      if (cs < dicSize) cs = dicSize;
-      cs += (kMinSize - 1);
-      cs &= ~(UInt64)(kMinSize - 1);
-      // we want to use at least 64 chunks (threads) per one solid block.
-
-      // here we don't use chunkSize property
-      numSolidBytes = cs << 6;
-
-      // here we get real chunkSize
-      cs = oneMethodInfo.Get_Xz_BlockSize();
-      if (dicSize > cs)
-          dicSize = cs;
-
-      const UInt64 kSolidBytes_Lzma2_Max = (UInt64)1 << 34;
-      if (numSolidBytes > kSolidBytes_Lzma2_Max)
-          numSolidBytes = kSolidBytes_Lzma2_Max;
-
-      methodFull.Set_NumThreads = false; // we don't use ICompressSetCoderMt::SetNumberOfThreads() for LZMA2 encoder
-
-      #ifndef Z7_ST
-      if (!numThreads_WasSpecifiedInMethod
-          && !methodMode.NumThreads_WasForced
-          && methodMode.MemoryUsageLimit_WasSet)
-      {
-        const UInt32 lzmaThreads = oneMethodInfo.Get_Lzma_NumThreads();
-        const UInt32 numBlockThreads_Original = methodMode.NumThreads / lzmaThreads;
-
-        if (numBlockThreads_Original > 1)
-        {
-          /*
-            const UInt32 kNumThreads_Max = 1024;
-            if (numBlockThreads > kNumMaxThreads)
-            numBlockThreads = kNumMaxThreads;
-          */
-
-          UInt32 numBlockThreads = numBlockThreads_Original;
-          const UInt64 lzmaMemUsage = oneMethodInfo.Get_Lzma_MemUsage(false); // solid
-          
-          for (; numBlockThreads > 1; numBlockThreads--)
-          {
-            UInt64 size = numBlockThreads * (lzmaMemUsage + cs);
-            UInt32 numPackChunks = numBlockThreads + (numBlockThreads / 8) + 1;
-            if (cs < ((UInt32)1 << 26)) numPackChunks++;
-            if (cs < ((UInt32)1 << 24)) numPackChunks++;
-            if (cs < ((UInt32)1 << 22)) numPackChunks++;
-            size += numPackChunks * cs;
-            // printf("\nnumBlockThreads = %d, size = %d\n", (unsigned)(numBlockThreads), (unsigned)(size >> 20));
-            if (size <= methodMode.MemoryUsageLimit)
-              break;
-          }
-
-          if (numBlockThreads == 0)
-            numBlockThreads = 1;
-          if (numBlockThreads != numBlockThreads_Original)
-          {
-            const UInt32 numThreads_New = numBlockThreads * lzmaThreads;
-            CMultiMethodProps::SetMethodThreadsTo_Replace(methodFull, numThreads_New);
-          }
-        }
-      }
-      #endif
-    }
-    else
-    {
-      numSolidBytes = (UInt64)dicSize << 7;
-      if (numSolidBytes > kSolidBytes_Max)
-          numSolidBytes = kSolidBytes_Max;
-    }
-
-    if (_numSolidBytesDefined)
-      continue;
-
-    if (numSolidBytes < kSolidBytes_Min)
-        numSolidBytes = kSolidBytes_Min;
-    _numSolidBytes = numSolidBytes;
+    
+    _numSolidBytes = (UInt64)dicSize << 7;
+    if (_numSolidBytes < kSolidBytes_Min) _numSolidBytes = kSolidBytes_Min;
+    if (_numSolidBytes > kSolidBytes_Max) _numSolidBytes = kSolidBytes_Max;
     _numSolidBytesDefined = true;
   }
 
   if (!_numSolidBytesDefined)
-  {
     if (needSolid)
       _numSolidBytes = kSolidBytes_Max;
     else
       _numSolidBytes = 0;
-  }
   _numSolidBytesDefined = true;
-
-
   return S_OK;
 }
 
-
-
-static HRESULT GetTime(IArchiveUpdateCallback *updateCallback, unsigned index, PROPID propID, UInt64 &ft, bool &ftDefined)
+static HRESULT GetTime(IArchiveUpdateCallback *updateCallback, int index, PROPID propID, UInt64 &ft, bool &ftDefined)
 {
   // ft = 0;
   // ftDefined = false;
   NCOM::CPropVariant prop;
-  RINOK(updateCallback->GetProperty(index, propID, &prop))
+  RINOK(updateCallback->GetProperty(index, propID, &prop));
   if (prop.vt == VT_FILETIME)
   {
     ft = prop.filetime.dwLowDateTime | ((UInt64)prop.filetime.dwHighDateTime << 32);
@@ -389,13 +247,13 @@ static int AddFolder(CObjectVector<CTreeFolder> &treeFolders, int cur, const USt
 }
 */
 
-Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numItems,
-    IArchiveUpdateCallback *updateCallback))
+STDMETHODIMP CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numItems,
+    IArchiveUpdateCallback *updateCallback)
 {
   COM_TRY_BEGIN
 
-  const CDbEx *db = NULL;
-  #ifdef Z7_7Z_VOL
+  const CDbEx *db = 0;
+  #ifdef _7Z_VOL
   if (_volumes.Size() > 1)
     return E_FAIL;
   const CVolume *volume = 0;
@@ -405,7 +263,7 @@ Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
     db = &volume->Database;
   }
   #else
-  if (_inStream)
+  if (_inStream != 0)
     db = &_db;
   #endif
 
@@ -413,9 +271,8 @@ Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
     return E_NOTIMPL;
 
   /*
-  Z7_DECL_CMyComPtr_QI_FROM(
-      IArchiveGetRawProps,
-      getRawProps, updateCallback)
+  CMyComPtr<IArchiveGetRawProps> getRawProps;
+  updateCallback->QueryInterface(IID_IArchiveGetRawProps, (void **)&getRawProps);
 
   CUniqBlocks secureBlocks;
   secureBlocks.AddUniq(NULL, 0);
@@ -430,16 +287,16 @@ Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
 
   CObjectVector<CUpdateItem> updateItems;
 
-  bool need_CTime = (TimeOptions.Write_CTime.Def && TimeOptions.Write_CTime.Val);
-  bool need_ATime = (TimeOptions.Write_ATime.Def && TimeOptions.Write_ATime.Val);
-  bool need_MTime = (TimeOptions.Write_MTime.Def ? TimeOptions.Write_MTime.Val : true);
-  bool need_Attrib = (Write_Attrib.Def ? Write_Attrib.Val : true);
+  bool need_CTime = (Write_CTime.Def && Write_CTime.Val);
+  bool need_ATime = (Write_ATime.Def && Write_ATime.Val);
+  bool need_MTime = (Write_MTime.Def && Write_MTime.Val || !Write_MTime.Def);
+  bool need_Attrib = (Write_Attrib.Def && Write_Attrib.Val || !Write_Attrib.Def);
   
   if (db && !db->Files.IsEmpty())
   {
-    if (!TimeOptions.Write_CTime.Def) need_CTime = !db->CTime.Defs.IsEmpty();
-    if (!TimeOptions.Write_ATime.Def) need_ATime = !db->ATime.Defs.IsEmpty();
-    if (!TimeOptions.Write_MTime.Def) need_MTime = !db->MTime.Defs.IsEmpty();
+    if (!Write_CTime.Def) need_CTime = !db->CTime.Defs.IsEmpty();
+    if (!Write_ATime.Def) need_ATime = !db->ATime.Defs.IsEmpty();
+    if (!Write_MTime.Def) need_MTime = !db->MTime.Defs.IsEmpty();
     if (!Write_Attrib.Def) need_Attrib = !db->Attrib.Defs.IsEmpty();
   }
 
@@ -452,11 +309,11 @@ Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
     UInt32 indexInArchive;
     if (!updateCallback)
       return E_FAIL;
-    RINOK(updateCallback->GetUpdateItemInfo(i, &newData, &newProps, &indexInArchive))
+    RINOK(updateCallback->GetUpdateItemInfo(i, &newData, &newProps, &indexInArchive));
     CUpdateItem ui;
     ui.NewProps = IntToBool(newProps);
     ui.NewData = IntToBool(newData);
-    ui.IndexInArchive = (int)indexInArchive;
+    ui.IndexInArchive = indexInArchive;
     ui.IndexInClient = i;
     ui.IsAnti = false;
     ui.Size = 0;
@@ -465,23 +322,23 @@ Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
     // bool isAltStream = false;
     if (ui.IndexInArchive != -1)
     {
-      if (!db || (unsigned)ui.IndexInArchive >= db->Files.Size())
+      if (db == 0 || (unsigned)ui.IndexInArchive >= db->Files.Size())
         return E_INVALIDARG;
-      const CFileItem &fi = db->Files[(unsigned)ui.IndexInArchive];
+      const CFileItem &fi = db->Files[ui.IndexInArchive];
       if (!ui.NewProps)
       {
-        _db.GetPath((unsigned)ui.IndexInArchive, name);
+        _db.GetPath(ui.IndexInArchive, name);
       }
       ui.IsDir = fi.IsDir;
       ui.Size = fi.Size;
       // isAltStream = fi.IsAltStream;
-      ui.IsAnti = db->IsItemAnti((unsigned)ui.IndexInArchive);
+      ui.IsAnti = db->IsItemAnti(ui.IndexInArchive);
       
       if (!ui.NewProps)
       {
-        ui.CTimeDefined = db->CTime.GetItem((unsigned)ui.IndexInArchive, ui.CTime);
-        ui.ATimeDefined = db->ATime.GetItem((unsigned)ui.IndexInArchive, ui.ATime);
-        ui.MTimeDefined = db->MTime.GetItem((unsigned)ui.IndexInArchive, ui.MTime);
+        ui.CTimeDefined = db->CTime.GetItem(ui.IndexInArchive, ui.CTime);
+        ui.ATimeDefined = db->ATime.GetItem(ui.IndexInArchive, ui.ATime);
+        ui.MTimeDefined = db->MTime.GetItem(ui.IndexInArchive, ui.MTime);
       }
     }
 
@@ -491,7 +348,7 @@ Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
       if (need_Attrib)
       {
         NCOM::CPropVariant prop;
-        RINOK(updateCallback->GetProperty(i, kpidAttrib, &prop))
+        RINOK(updateCallback->GetProperty(i, kpidAttrib, &prop));
         if (prop.vt == VT_EMPTY)
           ui.AttribDefined = false;
         else if (prop.vt != VT_UI4)
@@ -504,9 +361,9 @@ Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
       }
       
       // we need MTime to sort files.
-      if (need_CTime) RINOK(GetTime(updateCallback, i, kpidCTime, ui.CTime, ui.CTimeDefined))
-      if (need_ATime) RINOK(GetTime(updateCallback, i, kpidATime, ui.ATime, ui.ATimeDefined))
-      if (need_MTime) RINOK(GetTime(updateCallback, i, kpidMTime, ui.MTime, ui.MTimeDefined))
+      if (need_CTime) RINOK(GetTime(updateCallback, i, kpidCTime, ui.CTime, ui.CTimeDefined));
+      if (need_ATime) RINOK(GetTime(updateCallback, i, kpidATime, ui.ATime, ui.ATimeDefined));
+      if (need_MTime) RINOK(GetTime(updateCallback, i, kpidMTime, ui.MTime, ui.MTimeDefined));
 
       /*
       if (getRawProps)
@@ -524,7 +381,7 @@ Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
 
       {
         NCOM::CPropVariant prop;
-        RINOK(updateCallback->GetProperty(i, kpidPath, &prop))
+        RINOK(updateCallback->GetProperty(i, kpidPath, &prop));
         if (prop.vt == VT_EMPTY)
         {
         }
@@ -538,7 +395,7 @@ Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
       }
       {
         NCOM::CPropVariant prop;
-        RINOK(updateCallback->GetProperty(i, kpidIsDir, &prop))
+        RINOK(updateCallback->GetProperty(i, kpidIsDir, &prop));
         if (prop.vt == VT_EMPTY)
           folderStatusIsDefined = false;
         else if (prop.vt != VT_BOOL)
@@ -552,7 +409,7 @@ Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
 
       {
         NCOM::CPropVariant prop;
-        RINOK(updateCallback->GetProperty(i, kpidIsAnti, &prop))
+        RINOK(updateCallback->GetProperty(i, kpidIsAnti, &prop));
         if (prop.vt == VT_EMPTY)
           ui.IsAnti = false;
         else if (prop.vt != VT_BOOL)
@@ -669,7 +526,7 @@ Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
       if (!ui.IsDir)
       {
         NCOM::CPropVariant prop;
-        RINOK(updateCallback->GetProperty(i, kpidSize, &prop))
+        RINOK(updateCallback->GetProperty(i, kpidSize, &prop));
         if (prop.vt != VT_UI8)
           return E_INVALIDARG;
         ui.Size = (UInt64)prop.uhVal.QuadPart;
@@ -693,42 +550,32 @@ Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
 
   CCompressionMethodMode methodMode, headerMethod;
 
-  methodMode.MemoryUsageLimit = _memUsage_Compress;
-  methodMode.MemoryUsageLimit_WasSet = _memUsage_WasSet;
+  HRESULT res = SetMainMethod(methodMode
+    #ifndef _7ZIP_ST
+    , _numThreads
+    #endif
+    );
+  RINOK(res);
 
-  #ifndef Z7_ST
-  {
-    UInt32 numThreads = _numThreads;
-    const UInt32 kNumThreads_Max = 1024;
-    if (numThreads > kNumThreads_Max)
-      numThreads = kNumThreads_Max;
-    methodMode.NumThreads = numThreads;
-    methodMode.NumThreads_WasForced = _numThreads_WasForced;
-    methodMode.MultiThreadMixer = _useMultiThreadMixer;
-#ifdef _WIN32
-    methodMode.NumThreadGroups = _numThreadGroups; // _change it
-#endif
-    // headerMethod.NumThreads = 1;
-    headerMethod.MultiThreadMixer = _useMultiThreadMixer;
-  }
+  RINOK(SetHeaderMethod(headerMethod));
+  
+  #ifndef _7ZIP_ST
+  methodMode.NumThreads = _numThreads;
+  methodMode.MultiThreadMixer = _useMultiThreadMixer;
+  headerMethod.NumThreads = 1;
+  headerMethod.MultiThreadMixer = _useMultiThreadMixer;
   #endif
 
-  const HRESULT res = SetMainMethod(methodMode);
-  RINOK(res)
-
-  RINOK(SetHeaderMethod(headerMethod))
-  
-  Z7_DECL_CMyComPtr_QI_FROM(
-    ICryptoGetTextPassword2,
-    getPassword2, updateCallback)
+  CMyComPtr<ICryptoGetTextPassword2> getPassword2;
+  updateCallback->QueryInterface(IID_ICryptoGetTextPassword2, (void **)&getPassword2);
 
   methodMode.PasswordIsDefined = false;
-  methodMode.Password.Wipe_and_Empty();
+  methodMode.Password.Empty();
   if (getPassword2)
   {
-    CMyComBSTR_Wipe password;
+    CMyComBSTR password;
     Int32 passwordIsDefined;
-    RINOK(getPassword2->CryptoGetTextPassword2(&passwordIsDefined, &password))
+    RINOK(getPassword2->CryptoGetTextPassword2(&passwordIsDefined, &password));
     methodMode.PasswordIsDefined = IntToBool(passwordIsDefined);
     if (methodMode.PasswordIsDefined && password)
       methodMode.Password = password;
@@ -738,7 +585,7 @@ Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
 
   bool encryptHeaders = false;
 
-  #ifndef Z7_NO_CRYPTO
+  #ifndef _NO_CRYPTO
   if (!methodMode.PasswordIsDefined && _passwordIsDefined)
   {
     // if header is compressed, we use that password for updated archive
@@ -751,7 +598,7 @@ Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
   {
     if (_encryptHeadersSpecified)
       encryptHeaders = _encryptHeaders;
-    #ifndef Z7_NO_CRYPTO
+    #ifndef _NO_CRYPTO
     else
       encryptHeaders = _passwordIsDefined;
     #endif
@@ -766,26 +613,15 @@ Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
   if (numItems < 2)
     compressMainHeader = false;
 
-  const int level = GetLevel();
+  int level = GetLevel();
 
   CUpdateOptions options;
-  options.Need_CTime = need_CTime;
-  options.Need_ATime = need_ATime;
-  options.Need_MTime = need_MTime;
-  options.Need_Attrib = need_Attrib;
-  // options.Need_Crc = (_crcSize != 0); // for debug
-
   options.Method = &methodMode;
   options.HeaderMethod = (_compressHeaders || encryptHeaders) ? &headerMethod : NULL;
   options.UseFilters = (level != 0 && _autoFilter && !methodMode.Filter_was_Inserted);
   options.MaxFilter = (level >= 8);
   options.AnalysisLevel = GetAnalysisLevel();
 
-  options.SetFilterSupporting_ver_enabled_disabled(
-      _decoderCompatibilityVersion,
-      _enabledFilters,
-      _disabledFilters);
-
   options.HeaderOptions.CompressMainHeader = compressMainHeader;
   /*
   options.HeaderOptions.WriteCTime = Write_CTime;
@@ -804,6 +640,12 @@ Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
 
   options.MultiThreadMixer = _useMultiThreadMixer;
 
+  COutArchive archive;
+  CArchiveDatabaseOut newDatabase;
+
+  CMyComPtr<ICryptoGetTextPassword> getPassword;
+  updateCallback->QueryInterface(IID_ICryptoGetTextPassword, (void **)&getPassword);
+  
   /*
   if (secureBlocks.Sorted.Size() > 1)
   {
@@ -816,9 +658,9 @@ Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
   }
   */
 
-  return Update(
+  res = Update(
       EXTERNAL_CODECS_VARS
-      #ifdef Z7_7Z_VOL
+      #ifdef _7Z_VOL
       volume ? volume->Stream: 0,
       volume ? db : 0,
       #else
@@ -828,7 +670,18 @@ Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
       updateItems,
       // treeFolders,
       // secureBlocks,
-      outStream, updateCallback, options);
+      archive, newDatabase, outStream, updateCallback, options
+      #ifndef _NO_CRYPTO
+      , getPassword
+      #endif
+      );
+
+  RINOK(res);
+
+  updateItems.ClearAndFree();
+
+  return archive.WriteDatabase(EXTERNAL_CODECS_VARS
+      newDatabase, options.HeaderMethod, options.HeaderOptions);
 
   COM_TRY_END
 }
@@ -837,7 +690,7 @@ static HRESULT ParseBond(UString &srcString, UInt32 &coder, UInt32 &stream)
 {
   stream = 0;
   {
-    const unsigned index = ParseStringToUInt32(srcString, coder);
+    unsigned index = ParseStringToUInt32(srcString, coder);
     if (index == 0)
       return E_INVALIDARG;
     srcString.DeleteFrontal(index);
@@ -845,7 +698,7 @@ static HRESULT ParseBond(UString &srcString, UInt32 &coder, UInt32 &stream)
   if (srcString[0] == 's')
   {
     srcString.Delete(0);
-    const unsigned index = ParseStringToUInt32(srcString, stream);
+    unsigned index = ParseStringToUInt32(srcString, stream);
     if (index == 0)
       return E_INVALIDARG;
     srcString.DeleteFrontal(index);
@@ -861,7 +714,9 @@ void COutHandler::InitProps7z()
   _encryptHeaders = false;
   // _useParents = false;
   
-  TimeOptions.Init();
+  Write_CTime.Init();
+  Write_ATime.Init();
+  Write_MTime.Init();
   Write_Attrib.Init();
 
   _useMultiThreadMixer = true;
@@ -870,10 +725,6 @@ void COutHandler::InitProps7z()
 
   InitSolid();
   _useTypeSorting = false;
-
-  _decoderCompatibilityVersion = k_decoderCompatibilityVersion;
-  _enabledFilters.Clear();
-  _disabledFilters.Clear();
 }
 
 void COutHandler::InitProps()
@@ -900,10 +751,10 @@ HRESULT COutHandler::SetSolidFromString(const UString &s)
       _solidExtension = true;
       continue;
     }
-    i += (unsigned)(end - start);
+    i += (int)(end - start);
     if (i == s2.Len())
       return E_INVALIDARG;
-    const wchar_t c = s2[i++];
+    wchar_t c = s2[i++];
     if (c == 'f')
     {
       if (v < 1)
@@ -955,34 +806,11 @@ HRESULT COutHandler::SetSolidFromPROPVARIANT(const PROPVARIANT &value)
 
 static HRESULT PROPVARIANT_to_BoolPair(const PROPVARIANT &prop, CBoolPair &dest)
 {
-  RINOK(PROPVARIANT_to_bool(prop, dest.Val))
+  RINOK(PROPVARIANT_to_bool(prop, dest.Val));
   dest.Def = true;
   return S_OK;
 }
 
-struct C_Id_Name_pair
-{
-  UInt32 Id;
-  const char *Name;
-};
-
-static const C_Id_Name_pair g_filter_pairs[] =
-{
-  { k_Delta, "Delta" },
-  { k_ARM64, "ARM64" },
-  { k_RISCV, "RISCV" },
-  { k_SWAP2, "SWAP2" },
-  { k_SWAP4, "SWAP4" },
-  { k_BCJ,   "BCJ" },
-  { k_BCJ2 , "BCJ2" },
-  { k_PPC,   "PPC" },
-  { k_IA64,  "IA64" },
-  { k_ARM,   "ARM" },
-  { k_ARMT,  "ARMT" },
-  { k_SPARC, "SPARC" }
-};
-
-
 HRESULT COutHandler::SetProperty(const wchar_t *nameSpec, const PROPVARIANT &value)
 {
   UString name = nameSpec;
@@ -1001,7 +829,7 @@ HRESULT COutHandler::SetProperty(const wchar_t *nameSpec, const PROPVARIANT &val
   }
 
   UInt32 number;
-  const unsigned index = ParseStringToUInt32(name, number);
+  int index = ParseStringToUInt32(name, number);
   // UString realName = name.Ptr(index);
   if (index == 0)
   {
@@ -1012,80 +840,33 @@ HRESULT COutHandler::SetProperty(const wchar_t *nameSpec, const PROPVARIANT &val
     if (name.IsEqualTo("hcf"))
     {
       bool compressHeadersFull = true;
-      RINOK(PROPVARIANT_to_bool(value, compressHeadersFull))
+      RINOK(PROPVARIANT_to_bool(value, compressHeadersFull));
       return compressHeadersFull ? S_OK: E_INVALIDARG;
     }
     
     if (name.IsEqualTo("he"))
     {
-      RINOK(PROPVARIANT_to_bool(value, _encryptHeaders))
+      RINOK(PROPVARIANT_to_bool(value, _encryptHeaders));
       _encryptHeadersSpecified = true;
       return S_OK;
     }
     
-    {
-      bool processed;
-      RINOK(TimeOptions.Parse(name, value, processed))
-      if (processed)
-      {
-        if (   TimeOptions.Prec != (UInt32)(Int32)-1
-            && TimeOptions.Prec != k_PropVar_TimePrec_0
-            && TimeOptions.Prec != k_PropVar_TimePrec_HighPrec
-            && TimeOptions.Prec != k_PropVar_TimePrec_100ns)
-          return E_INVALIDARG;
-        return S_OK;
-      }
-    }
-
+    if (name.IsEqualTo("tc")) return PROPVARIANT_to_BoolPair(value, Write_CTime);
+    if (name.IsEqualTo("ta")) return PROPVARIANT_to_BoolPair(value, Write_ATime);
+    if (name.IsEqualTo("tm")) return PROPVARIANT_to_BoolPair(value, Write_MTime);
+    
     if (name.IsEqualTo("tr")) return PROPVARIANT_to_BoolPair(value, Write_Attrib);
     
     if (name.IsEqualTo("mtf")) return PROPVARIANT_to_bool(value, _useMultiThreadMixer);
 
     if (name.IsEqualTo("qs")) return PROPVARIANT_to_bool(value, _useTypeSorting);
 
-    if (name.IsPrefixedBy_Ascii_NoCase("yv"))
-    {
-      name.Delete(0, 2);
-      UInt32 v = 1 << 16;  // if no number is noit specified, we use big value
-      RINOK(ParsePropToUInt32(name, value, v))
-      _decoderCompatibilityVersion = v;
-      // if (v == 0) _decoderCompatibilityVersion = k_decoderCompatibilityVersion;
-      return S_OK;
-    }
-
-    if (name.IsPrefixedBy_Ascii_NoCase("yf"))
-    {
-      name.Delete(0, 2);
-      CUIntVector *vec;
-           if (name.IsEqualTo_Ascii_NoCase("a")) vec = &_enabledFilters;
-      else if (name.IsEqualTo_Ascii_NoCase("d")) vec = &_disabledFilters;
-      else return E_INVALIDARG;
-
-      if (value.vt != VT_BSTR)
-        return E_INVALIDARG;
-      for (unsigned k = 0;; k++)
-      {
-        if (k == Z7_ARRAY_SIZE(g_filter_pairs))
-        {
-          // maybe we can ignore unsupported filter names here?
-          return E_INVALIDARG;
-        }
-        const C_Id_Name_pair &pair = g_filter_pairs[k];
-        if (StringsAreEqualNoCase_Ascii(value.bstrVal, pair.Name))
-        {
-          vec->AddToUniqueSorted(pair.Id);
-          break;
-        }
-      }
-      return S_OK;
-    }
-
     // if (name.IsEqualTo("v"))  return PROPVARIANT_to_bool(value, _volumeMode);
   }
   return CMultiMethodProps::SetProperty(name, value);
 }
 
-Z7_COM7F_IMF(CHandler::SetProperties(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps))
+STDMETHODIMP CHandler::SetProperties(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps)
 {
   COM_TRY_BEGIN
   _bonds.Clear();
@@ -1100,7 +881,6 @@ Z7_COM7F_IMF(CHandler::SetProperties(const wchar_t * const *names, const PROPVAR
 
     const PROPVARIANT &value = values[i];
 
-    if (name.Find(L':') >= 0) // 'b' was used as NCoderPropID::kBlockSize2 before v23
     if (name[0] == 'b')
     {
       if (value.vt != VT_EMPTY)
@@ -1108,12 +888,12 @@ Z7_COM7F_IMF(CHandler::SetProperties(const wchar_t * const *names, const PROPVAR
       name.Delete(0);
       
       CBond2 bond;
-      RINOK(ParseBond(name, bond.OutCoder, bond.OutStream))
+      RINOK(ParseBond(name, bond.OutCoder, bond.OutStream));
       if (name[0] != ':')
         return E_INVALIDARG;
       name.Delete(0);
       UInt32 inStream = 0;
-      RINOK(ParseBond(name, bond.InCoder, inStream))
+      RINOK(ParseBond(name, bond.InCoder, inStream));
       if (inStream != 0)
         return E_INVALIDARG;
       if (!name.IsEmpty())
@@ -1122,7 +902,7 @@ Z7_COM7F_IMF(CHandler::SetProperties(const wchar_t * const *names, const PROPVAR
       continue;
     }
 
-    RINOK(SetProperty(name, value))
+    RINOK(SetProperty(name, value));
   }
 
   unsigned numEmptyMethods = GetNumEmptyMethods();