react-native-update 10.34.3 → 10.34.4

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

@@ -3,45 +3,26 @@
 #include "StdAfx.h"
 
 #include "../../../../C/7zCrc.h"
-#include "../../../../C/CpuArch.h"
 
 #include "../../../Common/AutoPtr.h"
-// #include "../../../Common/UTFConvert.h"
 
 #include "../../Common/StreamObjects.h"
-#include "../Common/OutStreamWithCRC.h"
 
 #include "7zOut.h"
 
-unsigned BoolVector_CountSum(const CBoolVector &v);
-
-static UInt64 UInt64Vector_CountSum(const CRecordVector<UInt64> &v)
-{
-  UInt64 sum = 0;
-  const unsigned size = v.Size();
-  if (size)
-  {
-    const UInt64 *p = v.ConstData();
-    const UInt64 * const lim = p + size;
-    do
-      sum += *p++;
-    while (p != lim);
-  }
-  return sum;
-}
-
-
 namespace NArchive {
 namespace N7z {
 
-static void FillSignature(Byte *buf)
+HRESULT COutArchive::WriteSignature()
 {
+  Byte buf[8];
   memcpy(buf, kSignature, kSignatureSize);
   buf[kSignatureSize] = kMajorVersion;
   buf[kSignatureSize + 1] = 4;
+  return WriteDirect(buf, 8);
 }
 
-#ifdef Z7_7Z_VOL
+#ifdef _7Z_VOL
 HRESULT COutArchive::WriteFinishSignature()
 {
   RINOK(WriteDirect(kFinishSignature, kSignatureSize));
@@ -67,16 +48,15 @@ static void SetUInt64(Byte *p, UInt64 d)
 
 HRESULT COutArchive::WriteStartHeader(const CStartHeader &h)
 {
-  Byte buf[32];
-  FillSignature(buf);
-  SetUInt64(buf + 8 + 4, h.NextHeaderOffset);
-  SetUInt64(buf + 8 + 12, h.NextHeaderSize);
-  SetUInt32(buf + 8 + 20, h.NextHeaderCRC);
-  SetUInt32(buf + 8, CrcCalc(buf + 8 + 4, 20));
-  return WriteDirect(buf, sizeof(buf));
+  Byte buf[24];
+  SetUInt64(buf + 4, h.NextHeaderOffset);
+  SetUInt64(buf + 12, h.NextHeaderSize);
+  SetUInt32(buf + 20, h.NextHeaderCRC);
+  SetUInt32(buf, CrcCalc(buf + 4, 20));
+  return WriteDirect(buf, 24);
 }
 
-#ifdef Z7_7Z_VOL
+#ifdef _7Z_VOL
 HRESULT COutArchive::WriteFinishHeader(const CFinishHeader &h)
 {
   CCRC crc;
@@ -94,15 +74,15 @@ HRESULT COutArchive::WriteFinishHeader(const CFinishHeader &h)
 }
 #endif
 
-HRESULT COutArchive::Create_and_WriteStartPrefix(ISequentialOutStream *stream /* , bool endMarker */)
+HRESULT COutArchive::Create(ISequentialOutStream *stream, bool endMarker)
 {
   Close();
-  #ifdef Z7_7Z_VOL
+  #ifdef _7Z_VOL
   // endMarker = false;
   _endMarker = endMarker;
   #endif
   SeqStream = stream;
-  // if (!endMarker)
+  if (!endMarker)
   {
     SeqStream.QueryInterface(IID_IOutStream, &Stream);
     if (!Stream)
@@ -110,13 +90,8 @@ HRESULT COutArchive::Create_and_WriteStartPrefix(ISequentialOutStream *stream /*
       return E_NOTIMPL;
       // endMarker = true;
     }
-    RINOK(Stream->Seek(0, STREAM_SEEK_CUR, &_signatureHeaderPos))
-    Byte buf[32];
-    FillSignature(buf);
-    memset(&buf[8], 0, 32 - 8);
-    return WriteDirect(buf, sizeof(buf));
   }
-  #ifdef Z7_7Z_VOL
+  #ifdef _7Z_VOL
   if (endMarker)
   {
     /*
@@ -125,10 +100,17 @@ HRESULT COutArchive::Create_and_WriteStartPrefix(ISequentialOutStream *stream /*
     sh.NextHeaderSize = (UInt32)(Int32)-1;
     sh.NextHeaderCRC = 0;
     WriteStartHeader(sh);
-    return S_OK;
     */
   }
+  else
   #endif
+  {
+    if (!Stream)
+      return E_FAIL;
+    RINOK(WriteSignature());
+    RINOK(Stream->Seek(0, STREAM_SEEK_CUR, &_prefixHeaderPos));
+  }
+  return S_OK;
 }
 
 void COutArchive::Close()
@@ -137,6 +119,17 @@ void COutArchive::Close()
   Stream.Release();
 }
 
+HRESULT COutArchive::SkipPrefixArchiveHeader()
+{
+  #ifdef _7Z_VOL
+  if (_endMarker)
+    return S_OK;
+  #endif
+  Byte buf[24];
+  memset(buf, 0, 24);
+  return WriteDirect(buf, 24);
+}
+
 UInt64 COutArchive::GetPos() const
 {
   if (_countMode)
@@ -153,7 +146,7 @@ void COutArchive::WriteBytes(const void *data, size_t size)
   else if (_writeToStream)
   {
     _outByte.WriteBytes(data, size);
-    // _crc = CrcUpdate(_crc, data, size);
+    _crc = CrcUpdate(_crc, data, size);
   }
   else
     _outByte2.WriteBytes(data, size);
@@ -164,12 +157,14 @@ void COutArchive::WriteByte(Byte b)
   if (_countMode)
     _countSize++;
   else if (_writeToStream)
-    WriteByte_ToStream(b);
+  {
+    _outByte.WriteByte(b);
+    _crc = CRC_UPDATE_BYTE(_crc, b);
+  }
   else
     _outByte2.WriteByte(b);
 }
 
-/*
 void COutArchive::WriteUInt32(UInt32 value)
 {
   for (int i = 0; i < 4; i++)
@@ -187,7 +182,6 @@ void COutArchive::WriteUInt64(UInt64 value)
     value >>= 8;
   }
 }
-*/
 
 void COutArchive::WriteNumber(UInt64 value)
 {
@@ -202,7 +196,7 @@ void COutArchive::WriteNumber(UInt64 value)
       break;
     }
     firstByte |= mask;
-    mask = (Byte)(mask >> 1);
+    mask >>= 1;
   }
   WriteByte(firstByte);
   for (; i > 0; i--)
@@ -212,16 +206,16 @@ void COutArchive::WriteNumber(UInt64 value)
   }
 }
 
-static unsigned GetBigNumberSize(UInt64 value)
+static UInt32 GetBigNumberSize(UInt64 value)
 {
-  unsigned i;
+  int i;
   for (i = 1; i < 9; i++)
     if (value < (((UInt64)1 << (i * 7))))
       break;
   return i;
 }
 
-#ifdef Z7_7Z_VOL
+#ifdef _7Z_VOL
 UInt32 COutArchive::GetVolHeadersSize(UInt64 dataSize, int nameLength, bool props)
 {
   UInt32 result = GetBigNumberSize(dataSize) * 2 + 41;
@@ -270,18 +264,18 @@ void COutArchive::WriteFolder(const CFolder &folder)
       for (idSize = 1; idSize < sizeof(id); idSize++)
         if ((id >> (8 * idSize)) == 0)
           break;
-      // idSize &= 0xF; // idSize is smaller than 16 already
+      idSize &= 0xF;
       Byte temp[16];
       for (unsigned t = idSize; t != 0; t--, id >>= 8)
         temp[t] = (Byte)(id & 0xFF);
   
-      unsigned b = idSize;
-      const bool isComplex = !coder.IsSimpleCoder();
+      Byte b = (Byte)(idSize);
+      bool isComplex = !coder.IsSimpleCoder();
       b |= (isComplex ? 0x10 : 0);
 
-      const size_t propsSize = coder.Props.Size();
+      size_t propsSize = coder.Props.Size();
       b |= ((propsSize != 0) ? 0x20 : 0);
-      temp[0] = (Byte)b;
+      temp[0] = b;
       WriteBytes(temp, idSize + 1);
       if (isComplex)
       {
@@ -307,7 +301,7 @@ void COutArchive::WriteFolder(const CFolder &folder)
       WriteNumber(folder.PackStreams[i]);
 }
 
-void COutArchive::Write_BoolVector(const CBoolVector &boolVector)
+void COutArchive::WriteBoolVector(const CBoolVector &boolVector)
 {
   Byte b = 0;
   Byte mask = 0x80;
@@ -315,7 +309,7 @@ void COutArchive::Write_BoolVector(const CBoolVector &boolVector)
   {
     if (boolVector[i])
       b |= mask;
-    mask = (Byte)(mask >> 1);
+    mask >>= 1;
     if (mask == 0)
     {
       WriteByte(b);
@@ -333,32 +327,31 @@ void COutArchive::WritePropBoolVector(Byte id, const CBoolVector &boolVector)
 {
   WriteByte(id);
   WriteNumber(Bv_GetSizeInBytes(boolVector));
-  Write_BoolVector(boolVector);
-}
-
-void COutArchive::Write_BoolVector_numDefined(const CBoolVector &boolVector, unsigned numDefined)
-{
-  if (numDefined == boolVector.Size())
-    WriteByte(1);
-  else
-  {
-    WriteByte(0);
-    Write_BoolVector(boolVector);
-  }
+  WriteBoolVector(boolVector);
 }
 
+unsigned BoolVector_CountSum(const CBoolVector &v);
 
 void COutArchive::WriteHashDigests(const CUInt32DefVector &digests)
 {
   const unsigned numDefined = BoolVector_CountSum(digests.Defs);
   if (numDefined == 0)
     return;
+
   WriteByte(NID::kCRC);
-  Write_BoolVector_numDefined(digests.Defs, numDefined);
-  Write_UInt32DefVector_numDefined(digests, numDefined);
+  if (numDefined == digests.Defs.Size())
+    WriteByte(1);
+  else
+  {
+    WriteByte(0);
+    WriteBoolVector(digests.Defs);
+  }
+  
+  for (unsigned i = 0; i < digests.Defs.Size(); i++)
+    if (digests.Defs[i])
+      WriteUInt32(digests.Vals[i]);
 }
 
-
 void COutArchive::WritePackInfo(
     UInt64 dataOffset,
     const CRecordVector<UInt64> &packSizes,
@@ -483,46 +476,21 @@ void COutArchive::WriteAlignedBools(const CBoolVector &v, unsigned numDefined, B
 {
   const unsigned bvSize = (numDefined == v.Size()) ? 0 : Bv_GetSizeInBytes(v);
   const UInt64 dataSize = ((UInt64)numDefined << itemSizeShifts) + bvSize + 2;
-  SkipToAligned(3 + bvSize + GetBigNumberSize(dataSize), itemSizeShifts);
+  SkipToAligned(3 + (unsigned)bvSize + (unsigned)GetBigNumberSize(dataSize), itemSizeShifts);
 
   WriteByte(type);
   WriteNumber(dataSize);
-  Write_BoolVector_numDefined(v, numDefined);
-  WriteByte(0); // 0 means no switching to external stream
-}
-
-
-void COutArchive::Write_UInt32DefVector_numDefined(const CUInt32DefVector &v, unsigned numDefined)
-{
-  if (_countMode)
+  if (numDefined == v.Size())
+    WriteByte(1);
+  else
   {
-    _countSize += (size_t)numDefined * 4;
-    return;
+    WriteByte(0);
+    WriteBoolVector(v);
   }
-
-  const bool * const defs = v.Defs.ConstData();
-  const UInt32 * const vals = v.Vals.ConstData();
-  const size_t num = v.Defs.Size();
-
-  for (size_t i = 0; i < num; i++)
-    if (defs[i])
-    {
-      UInt32 value = vals[i];
-      for (int k = 0; k < 4; k++)
-      {
-        if (_writeToStream)
-          WriteByte_ToStream((Byte)value);
-        else
-          _outByte2.WriteByte((Byte)value);
-        // WriteByte((Byte)value);
-        value >>= 8;
-      }
-      // WriteUInt32(v.Vals[i]);
-    }
+  WriteByte(0); // 0 means no switching to external stream
 }
 
-
-void COutArchive::Write_UInt64DefVector_type(const CUInt64DefVector &v, Byte type)
+void COutArchive::WriteUInt64DefVector(const CUInt64DefVector &v, Byte type)
 {
   const unsigned numDefined = BoolVector_CountSum(v.Defs);
   if (numDefined == 0)
@@ -530,58 +498,30 @@ void COutArchive::Write_UInt64DefVector_type(const CUInt64DefVector &v, Byte typ
 
   WriteAlignedBools(v.Defs, numDefined, type, 3);
   
-  if (_countMode)
-  {
-    _countSize += (size_t)numDefined * 8;
-    return;
-  }
-
-  const bool * const defs = v.Defs.ConstData();
-  const UInt64 * const vals = v.Vals.ConstData();
-  const size_t num = v.Defs.Size();
-
-  for (size_t i = 0; i < num; i++)
-    if (defs[i])
-    {
-      UInt64 value = vals[i];
-      for (int k = 0; k < 8; k++)
-      {
-        if (_writeToStream)
-          WriteByte_ToStream((Byte)value);
-        else
-          _outByte2.WriteByte((Byte)value);
-        // WriteByte((Byte)value);
-        value >>= 8;
-      }
-      // WriteUInt64(v.Vals[i]);
-    }
+  for (unsigned i = 0; i < v.Defs.Size(); i++)
+    if (v.Defs[i])
+      WriteUInt64(v.Vals[i]);
 }
 
-
 HRESULT COutArchive::EncodeStream(
     DECL_EXTERNAL_CODECS_LOC_VARS
     CEncoder &encoder, const CByteBuffer &data,
     CRecordVector<UInt64> &packSizes, CObjectVector<CFolder> &folders, COutFolders &outFolders)
 {
-  CMyComPtr2_Create<ISequentialInStream, CBufInStream> streamSpec;
+  CBufInStream *streamSpec = new CBufInStream;
+  CMyComPtr<ISequentialInStream> stream = streamSpec;
   streamSpec->Init(data, data.Size());
   outFolders.FolderUnpackCRCs.Defs.Add(true);
   outFolders.FolderUnpackCRCs.Vals.Add(CrcCalc(data, data.Size()));
   // outFolders.NumUnpackStreamsVector.Add(1);
-  const UInt64 dataSize64 = data.Size();
-  const UInt64 expectSize = data.Size();
-  RINOK(encoder.Encode1(
+  UInt64 dataSize64 = data.Size();
+  UInt64 unpackSize = data.Size();
+  RINOK(encoder.Encode(
       EXTERNAL_CODECS_LOC_VARS
-      streamSpec,
+      stream,
       // NULL,
-      &dataSize64,  // inSizeForReduce
-      expectSize,
-      folders.AddNew(),
-      // outFolders.CoderUnpackSizes, unpackSize,
-      SeqStream, packSizes, NULL))
-  if (!streamSpec->WasFinished())
-    return E_FAIL;
-  encoder.Encode_Post(dataSize64, outFolders.CoderUnpackSizes);
+      &dataSize64,
+      folders.AddNew(), outFolders.CoderUnpackSizes, unpackSize, SeqStream, packSizes, NULL))
   return S_OK;
 }
 
@@ -595,43 +535,17 @@ void COutArchive::WriteHeader(
   */
   _useAlign = true;
 
-  headerOffset = UInt64Vector_CountSum(db.PackSizes);
-
-  WriteByte(NID::kHeader);
-
-  /*
   {
-    // It's example for per archive properies writing
-  
-    WriteByte(NID::kArchiveProperties);
+    UInt64 packSize = 0;
+    FOR_VECTOR (i, db.PackSizes)
+      packSize += db.PackSizes[i];
+    headerOffset = packSize;
+  }
 
-    // you must use random 40-bit number that will identify you
-    // then you can use same kDeveloperID for any properties and methods
-    const UInt64 kDeveloperID = 0x123456789A; // change that value to real random 40-bit number
 
-    #define GENERATE_7Z_ID(developerID, subID) (((UInt64)0x3F << 56) | ((UInt64)developerID << 16) | subID)
+  WriteByte(NID::kHeader);
 
-    {
-      const UInt64 kSubID = 0x1; // you can use small number for subID
-      const UInt64 kID = GENERATE_7Z_ID(kDeveloperID, kSubID);
-      WriteNumber(kID);
-      const unsigned kPropsSize = 3; // it's example size
-      WriteNumber(kPropsSize);
-      for (unsigned i = 0; i < kPropsSize; i++)
-        WriteByte((Byte)(i & 0xFF));
-    }
-    {
-      const UInt64 kSubID = 0x2; // you can use small number for subID
-      const UInt64 kID = GENERATE_7Z_ID(kDeveloperID, kSubID);
-      WriteNumber(kID);
-      const unsigned kPropsSize = 5; // it's example size
-      WriteNumber(kPropsSize);
-      for (unsigned i = 0; i < kPropsSize; i++)
-        WriteByte((Byte)(i + 16));
-    }
-    WriteByte(NID::kEnd);
-  }
-  */
+  // Archive Properties
 
   if (db.Folders.Size() > 0)
   {
@@ -716,97 +630,54 @@ void COutArchive::WriteHeader(
   {
     /* ---------- Names ---------- */
     
+    unsigned numDefined = 0;
     size_t namesDataSize = 0;
+    FOR_VECTOR (i, db.Files)
     {
-      FOR_VECTOR (i, db.Files)
-      {
-        const UString &name = db.Names[i];
-        const size_t numUtfChars =
-        /*
-        #if WCHAR_MAX > 0xffff
-        Get_Num_Utf16_chars_from_wchar_string(name.Ptr());
-        #else
-        */
-        name.Len();
-        // #endif
-        namesDataSize += numUtfChars;
-      }
+      const UString &name = db.Names[i];
+      if (!name.IsEmpty())
+        numDefined++;
+      namesDataSize += (name.Len() + 1) * 2;
     }
-    if (namesDataSize)
+    
+    if (numDefined > 0)
     {
-      namesDataSize += db.Files.Size();  // we will write tail zero wchar for each name
-      namesDataSize *= 2;  // 2 bytes per wchar for UTF16 encoding
-      namesDataSize++;     // for additional switch byte (zero value)
+      namesDataSize++;
       SkipToAligned(2 + GetBigNumberSize(namesDataSize), 4);
+
       WriteByte(NID::kName);
       WriteNumber(namesDataSize);
-
-      if (_countMode)
-        _countSize += namesDataSize;
-      else
+      WriteByte(0);
+      FOR_VECTOR (i, db.Files)
       {
-        WriteByte(0);
-        FOR_VECTOR (i, db.Files)
+        const UString &name = db.Names[i];
+        for (unsigned t = 0; t <= name.Len(); t++)
         {
-          const UString &name = db.Names[i];
-          const wchar_t *p = name.Ptr();
-          const size_t len = (size_t)name.Len() + 1;
-          const wchar_t * const lim = p + len;
-          if (_writeToStream)
-          {
-            do
-            {
-              const wchar_t c = *p++;
-              WriteByte_ToStream((Byte)c);
-              WriteByte_ToStream((Byte)(c >> 8));
-            }
-            while (p != lim);
-          }
-          else
-          {
-            Byte *dest = _outByte2.GetDest_and_Update(len * 2);
-            do
-            {
-              /*
-              #if WCHAR_MAX > 0xffff
-              if (c >= 0x10000)
-              {
-                c -= 0x10000;
-                if (c < (1 << 20))
-                {
-                  unsigned c0 = 0xd800 + ((c >> 10) & 0x3FF);
-                  WriteByte((Byte)c0);
-                  WriteByte((Byte)(c0 >> 8));
-                  c = 0xdc00 + (c & 0x3FF);
-                }
-                else
-                c = '_'; // we change character unsupported by UTF16
-              }
-              #endif
-              */
-              const wchar_t c = *p++;
-              SetUi16(dest, (UInt16)c)
-              dest += 2;
-            }
-            while (p != lim);
-          }
+          wchar_t c = name[t];
+          WriteByte((Byte)c);
+          WriteByte((Byte)(c >> 8));
         }
       }
     }
   }
 
-  /* if (headerOptions.WriteCTime) */ Write_UInt64DefVector_type(db.CTime, NID::kCTime);
-  /* if (headerOptions.WriteATime) */ Write_UInt64DefVector_type(db.ATime, NID::kATime);
-  /* if (headerOptions.WriteMTime) */ Write_UInt64DefVector_type(db.MTime, NID::kMTime);
-  Write_UInt64DefVector_type(db.StartPos, NID::kStartPos);
+  /* if (headerOptions.WriteCTime) */ WriteUInt64DefVector(db.CTime, NID::kCTime);
+  /* if (headerOptions.WriteATime) */ WriteUInt64DefVector(db.ATime, NID::kATime);
+  /* if (headerOptions.WriteMTime) */ WriteUInt64DefVector(db.MTime, NID::kMTime);
+  WriteUInt64DefVector(db.StartPos, NID::kStartPos);
   
   {
     /* ---------- Write Attrib ---------- */
     const unsigned numDefined = BoolVector_CountSum(db.Attrib.Defs);
+    
     if (numDefined != 0)
     {
       WriteAlignedBools(db.Attrib.Defs, numDefined, NID::kWinAttrib, 2);
-      Write_UInt32DefVector_numDefined(db.Attrib, numDefined);
+      FOR_VECTOR (i, db.Attrib.Defs)
+      {
+        if (db.Attrib.Defs[i])
+          WriteUInt32(db.Attrib.Vals[i]);
+      }
     }
   }
 
@@ -842,7 +713,13 @@ void COutArchive::WriteHeader(
       
       WriteByte(NID::kParent);
       WriteNumber(dataSize);
-      Write_BoolVector_numDefined(boolVector, numIsDir);
+      if (numIsDir == boolVector.Size())
+        WriteByte(1);
+      else
+      {
+        WriteByte(0);
+        WriteBoolVector(boolVector);
+      }
       for (i = 0; i < db.Files.Size(); i++)
       {
         const CFileItem &file = db.Files[i];
@@ -889,34 +766,32 @@ HRESULT COutArchive::WriteDatabase(
   if (!db.CheckNumFiles())
     return E_FAIL;
 
-  CStartHeader sh;
-  sh.NextHeaderOffset = 0;
-  sh.NextHeaderSize = 0;
-  sh.NextHeaderCRC = 0; // CrcCalc(NULL, 0);
-
-  if (!db.IsEmpty())
+  UInt64 headerOffset;
+  UInt32 headerCRC;
+  UInt64 headerSize;
+  if (db.IsEmpty())
+  {
+    headerSize = 0;
+    headerOffset = 0;
+    headerCRC = CrcCalc(0, 0);
+  }
+  else
   {
-    CMyComPtr2_Create<ISequentialOutStream, COutStreamWithCRC> crcStream;
-    crcStream->SetStream(SeqStream);
-    crcStream->Init();
-
     bool encodeHeaders = false;
-    if (options)
+    if (options != 0)
       if (options->IsEmpty())
-        options = NULL;
-    if (options)
+        options = 0;
+    if (options != 0)
       if (options->PasswordIsDefined || headerOptions.CompressMainHeader)
         encodeHeaders = true;
 
-    if (!_outByte.Create(1 << 16))
-      return E_OUTOFMEMORY;
-    _outByte.SetStream(crcStream.Interface());
+    _outByte.SetStream(SeqStream);
     _outByte.Init();
-    // _crc = CRC_INIT_VAL;
+    _crc = CRC_INIT_VAL;
     _countMode = encodeHeaders;
     _writeToStream = true;
     _countSize = 0;
-    WriteHeader(db, /* headerOptions, */ sh.NextHeaderOffset);
+    WriteHeader(db, /* headerOptions, */ headerOffset);
 
     if (encodeHeaders)
     {
@@ -925,7 +800,7 @@ HRESULT COutArchive::WriteDatabase(
       
       _countMode = false;
       _writeToStream = false;
-      WriteHeader(db, /* headerOptions, */ sh.NextHeaderOffset);
+      WriteHeader(db, /* headerOptions, */ headerOffset);
       
       if (_countSize != _outByte2.GetPos())
         return E_FAIL;
@@ -941,7 +816,7 @@ HRESULT COutArchive::WriteDatabase(
       RINOK(EncodeStream(
           EXTERNAL_CODECS_LOC_VARS
           encoder, buf,
-          packSizes, folders, outFolders))
+          packSizes, folders, outFolders));
 
       _writeToStream = true;
       
@@ -949,19 +824,17 @@ HRESULT COutArchive::WriteDatabase(
         throw 1;
 
       WriteID(NID::kEncodedHeader);
-      WritePackInfo(sh.NextHeaderOffset, packSizes, CUInt32DefVector());
+      WritePackInfo(headerOffset, packSizes, CUInt32DefVector());
       WriteUnpackInfo(folders, outFolders);
       WriteByte(NID::kEnd);
-
-      sh.NextHeaderOffset += UInt64Vector_CountSum(packSizes);
+      FOR_VECTOR (i, packSizes)
+        headerOffset += packSizes[i];
     }
-    RINOK(_outByte.Flush())
-    sh.NextHeaderCRC = crcStream->GetCRC();
-    // sh.NextHeaderCRC = CRC_GET_DIGEST(_crc);
-    // if (CRC_GET_DIGEST(_crc) != sh.NextHeaderCRC) throw 1;
-    sh.NextHeaderSize = _outByte.GetProcessedSize();
+    RINOK(_outByte.Flush());
+    headerCRC = CRC_GET_DIGEST(_crc);
+    headerSize = _outByte.GetProcessedSize();
   }
-  #ifdef Z7_7Z_VOL
+  #ifdef _7Z_VOL
   if (_endMarker)
   {
     CFinishHeader h;
@@ -977,12 +850,14 @@ HRESULT COutArchive::WriteDatabase(
   }
   else
   #endif
-  if (Stream)
   {
-    RINOK(Stream->Seek((Int64)_signatureHeaderPos, STREAM_SEEK_SET, NULL))
-    return WriteStartHeader(sh);
+    CStartHeader h;
+    h.NextHeaderSize = headerSize;
+    h.NextHeaderCRC = headerCRC;
+    h.NextHeaderOffset = headerOffset;
+    RINOK(Stream->Seek(_prefixHeaderPos, STREAM_SEEK_SET, NULL));
+    return WriteStartHeader(h);
   }
-  return S_OK;
 }
 
 void CUInt32DefVector::SetItem(unsigned index, bool defined, UInt32 value)