react-native-update 10.34.3 → 10.34.5

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/Common/FilterCoder.cpp

@@ -2,8 +2,6 @@
 
 #include "StdAfx.h"
 
-// #include <stdio.h>
-
 #include "../../Common/Defs.h"
 
 #include "FilterCoder.h"
@@ -35,17 +33,13 @@ void CAlignedMidBuffer::AllocAligned(size_t size)
 
   Some filters (BCJ and others) don't process data at the end of stream in some cases.
   So the encoder and decoder write such last bytes without change.
-
-  Most filters process all data, if we send aligned size to filter.
-     But  BCJ filter can process up 4 bytes less than sent size.
-     And ARMT filter can process    2 bytes less than sent size.
 */
 
 
-static const UInt32 kBufSize = 1 << 21;
+static const UInt32 kBufSize = 1 << 20;
 
-Z7_COM7F_IMF(CFilterCoder::SetInBufSize(UInt32 , UInt32 size)) { _inBufSize = size; return S_OK; }
-Z7_COM7F_IMF(CFilterCoder::SetOutBufSize(UInt32 , UInt32 size)) { _outBufSize = size; return S_OK; }
+STDMETHODIMP CFilterCoder::SetInBufSize(UInt32 , UInt32 size) { _inBufSize = size; return S_OK; }
+STDMETHODIMP CFilterCoder::SetOutBufSize(UInt32 , UInt32 size) { _outBufSize = size; return S_OK; }
 
 HRESULT CFilterCoder::Alloc()
 {
@@ -57,7 +51,6 @@ HRESULT CFilterCoder::Alloc()
   size &= ~(UInt32)(kMinSize - 1);
   if (size < kMinSize)
     size = kMinSize;
-  // size = (1 << 12); // + 117; // for debug
   if (!_buf || _bufSize != size)
   {
     AllocAligned(size);
@@ -70,7 +63,7 @@ HRESULT CFilterCoder::Alloc()
 
 HRESULT CFilterCoder::Init_and_Alloc()
 {
-  RINOK(Filter->Init())
+  RINOK(Filter->Init());
   return Alloc();
 }
 
@@ -79,198 +72,78 @@ CFilterCoder::CFilterCoder(bool encodeMode):
     _inBufSize(kBufSize),
     _outBufSize(kBufSize),
     _encodeMode(encodeMode),
-    _outSize_Defined(false),
+    _outSizeIsDefined(false),
     _outSize(0),
     _nowPos64(0)
   {}
 
+CFilterCoder::~CFilterCoder()
+{
+}
 
-Z7_COM7F_IMF(CFilterCoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
-    const UInt64 * /* inSize */, const UInt64 *outSize, ICompressProgressInfo *progress))
+STDMETHODIMP CFilterCoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+    const UInt64 * /* inSize */, const UInt64 *outSize, ICompressProgressInfo *progress)
 {
-  RINOK(Init_and_Alloc())
-
-  /*
-     It's expected that BCJ/ARMT filter can process up to 4 bytes less
-     than sent data size. For such BCJ/ARMT cases with non-filtered data we:
-       - write some filtered data to output stream
-       - move non-written data (filtered and non-filtered data) to start of buffer
-       - read more new data from input stream to position after end of non-filtered data
-       - call Filter() for concatenated data in buffer.
-
-     For all cases, even for cases with partial filtering (BCJ/ARMT),
-     we try to keep real/virtual alignment for all operations
-       (memmove, Read(), Filter(), Write()).
-     We use (kAlignSize=64) alignmnent that is larger than (16-bytes)
-     required for AES filter alignment.
-
-     AES-CBC uses 16-bytes blocks, that is simple case for processing here,
-     if we call Filter() for aligned size for all calls except of last call (last block).
-     And now there are no filters that use blocks with non-power2 size,
-     but we try to support such non-power2 filters too here at Code().
-  */
-    
-  UInt64 prev = 0;
+  RINOK(Init_and_Alloc());
+  
   UInt64 nowPos64 = 0;
   bool inputFinished = false;
-  UInt32 readPos = 0;
-  UInt32 filterPos = 0;
+  UInt32 pos = 0;
 
   while (!outSize || nowPos64 < *outSize)
   {
-    HRESULT hres = S_OK;
+    UInt32 endPos = pos;
+    
     if (!inputFinished)
     {
-      size_t processedSize = _bufSize - readPos;
-      /* for AES filters we need at least max(16, kAlignSize) bytes in buffer.
-         But we try to read full buffer to reduce the number of Filter() and Write() calls.
-      */
-      hres = ReadStream(inStream, _buf + readPos, &processedSize);
-      readPos += (UInt32)processedSize;
-      inputFinished = (readPos != _bufSize);
-      if (hres != S_OK)
-      {
-        // do we need to stop encoding after reading error?
-        // if (_encodeMode) return hres;
-        inputFinished = true;
-      }
+      size_t processedSize = _bufSize - pos;
+      RINOK(ReadStream(inStream, _buf + pos, &processedSize));
+      endPos = pos + (UInt32)processedSize;
+      inputFinished = (endPos != _bufSize);
     }
 
-    if (readPos == 0)
-      return hres;
-
-    /* we set (needMoreInput = true), if it's block-filter (like AES-CBC)
-         that needs more data for current block filtering:
-       We read full input buffer with Read(), and _bufSize is aligned,
-       So the possible cases when we set (needMoreInput = true) are:
-         1) decode : filter needs more data after the end of input stream.
-           another cases are possible for non-power2-block-filter,
-           because buffer size is not aligned for filter_non_power2_block_size:
-         2) decode/encode : filter needs more data from non-finished input stream
-         3) encode        : filter needs more space for zeros after the end of input stream
-    */
-    bool needMoreInput = false;
-
-    while (readPos != filterPos)
+    pos = Filter->Filter(_buf, endPos);
+    
+    if (pos > endPos)
     {
-      /* Filter() is allowed to process part of data.
-         Here we use the loop to filter as max as possible.
-         when we call Filter(data, size):
-         if (size < 16), AES-CTR filter uses internal 16-byte buffer.
-         new (since v23.00) AES-CTR filter allows (size < 16) for non-last block,
-         but it will work less efficiently than calls with aligned (size).
-         We still support old (before v23.00) AES-CTR filters here.
-         We have aligned (size) for AES-CTR, if it's not last block.
-         We have aligned (readPos) for any filter, if (!inputFinished).
-         We also meet the requirements for (data) pointer in Filter() call:
-         {
-           (virtual_stream_offset % aligment_size) == (data_ptr % aligment_size)
-           (aligment_size == 2^N)
-           (aligment_size  >= 16)
-         }
-      */
-      const UInt32 cur = Filter->Filter(_buf + filterPos, readPos - filterPos);
-      if (cur == 0)
-        break;
-      const UInt32 f = filterPos + cur;
-      if (cur > readPos - filterPos)
-      {
-        // AES-CBC
-        if (hres != S_OK)
-          break;
-
-        if (!_encodeMode
-            || cur > _bufSize - filterPos
-            || !inputFinished)
-        {
-          /* (cur > _bufSize - filterPos) is unexpected for AES filter, if _bufSize is multiply of 16.
-             But we support this case, if some future filter will use block with non-power2-size.
-          */
-          needMoreInput = true;
-          break;
-        }
-
-        /* (_encodeMode && inputFinished).
-           We add zero bytes as pad in current block after the end of read data. */
-        Byte *buf = _buf;
-        do
-          buf[readPos] = 0;
-        while (++readPos != f);
-        // (readPos) now is (size_of_real_input_data + size_of_zero_pad)
-        if (cur != Filter->Filter(buf + filterPos, cur))
-          return E_FAIL;
-      }
-      filterPos = f;
+      // AES
+      if (!inputFinished || pos > _bufSize)
+        return E_FAIL;
+      if (!_encodeMode)
+        return S_FALSE;
+      
+      do
+        _buf[endPos] = 0;
+      while (++endPos != pos);
+      
+      if (pos != Filter->Filter(_buf, pos))
+        return E_FAIL;
     }
 
-    UInt32 size = filterPos;
-    if (hres == S_OK)
-    {
-      /* If we need more Read() or Filter() calls, then we need to Write()
-         some data and move unwritten data to get additional space in buffer.
-         We try to keep alignment for data moves, Read(), Filter() and Write() calls.
-      */
-      const UInt32 kAlignSize = 1 << 6;
-      const UInt32 alignedFiltered = filterPos & ~(kAlignSize - 1);
-      if (inputFinished)
-      {
-        if (!needMoreInput)
-          size = readPos; // for risc/bcj filters in last block we write data after filterPos.
-        else if (_encodeMode)
-          size = alignedFiltered; // for non-power2-block-encode-filter
-      }
-      else
-        size = alignedFiltered;
-    }
+    if (endPos == 0)
+      return S_OK;
 
+    UInt32 size = (pos != 0 ? pos : endPos);
+    if (outSize)
     {
-      UInt32 writeSize = size;
-      if (outSize)
-      {
-        const UInt64 rem = *outSize - nowPos64;
-        if (writeSize > rem)
-          writeSize = (UInt32)rem;
-      }
-      RINOK(WriteStream(outStream, _buf, writeSize))
-      nowPos64 += writeSize;
+      UInt64 remSize = *outSize - nowPos64;
+      if (size > remSize)
+        size = (UInt32)remSize;
     }
+    
+    RINOK(WriteStream(outStream, _buf, size));
+    nowPos64 += size;
 
-    if (hres != S_OK)
-      return hres;
+    if (pos == 0)
+      return S_OK;
 
-    if (inputFinished)
-    {
-      if (readPos == size)
-        return hres;
-      if (!_encodeMode)
-      {
-        // block-decode-filter (AES-CBS) has non-full last block
-        // we don't want unaligned data move for more iterations with this error case.
-        return S_FALSE;
-      }
-    }
+    if (progress)
+      RINOK(progress->SetRatioInfo(&nowPos64, &nowPos64));
 
-    if (size == 0)
-    {
-      // it's unexpected that we have no any move in this iteration.
-      return E_FAIL;
-    }
-    // if (size != 0)
-    {
-      if (filterPos < size)
-        return E_FAIL; // filterPos = 0; else
-      filterPos -= size;
-      readPos -= size;
-      if (readPos != 0)
-        memmove(_buf, _buf + size, readPos);
-    }
-    // printf("\nnowPos64=%x, readPos=%x, filterPos=%x\n", (unsigned)nowPos64, (unsigned)readPos, (unsigned)filterPos);
-
-    if (progress && (nowPos64 - prev) >= (1 << 22))
-    {
-      prev = nowPos64;
-      RINOK(progress->SetRatioInfo(&nowPos64, &nowPos64))
-    }
+    UInt32 i = 0;
+    while (pos < endPos)
+      _buf[i++] = _buf[pos++];
+    pos = i;
   }
 
   return S_OK;
@@ -280,13 +153,13 @@ Z7_COM7F_IMF(CFilterCoder::Code(ISequentialInStream *inStream, ISequentialOutStr
 
 // ---------- Write to Filter ----------
 
-Z7_COM7F_IMF(CFilterCoder::SetOutStream(ISequentialOutStream *outStream))
+STDMETHODIMP CFilterCoder::SetOutStream(ISequentialOutStream *outStream)
 {
   _outStream = outStream;
   return S_OK;
 }
 
-Z7_COM7F_IMF(CFilterCoder::ReleaseOutStream())
+STDMETHODIMP CFilterCoder::ReleaseOutStream()
 {
   _outStream.Release();
   return S_OK;
@@ -297,9 +170,9 @@ HRESULT CFilterCoder::Flush2()
   while (_convSize != 0)
   {
     UInt32 num = _convSize;
-    if (_outSize_Defined)
+    if (_outSizeIsDefined)
     {
-      const UInt64 rem = _outSize - _nowPos64;
+      UInt64 rem = _outSize - _nowPos64;
       if (num > rem)
         num = (UInt32)rem;
       if (num == 0)
@@ -307,23 +180,21 @@ HRESULT CFilterCoder::Flush2()
     }
     
     UInt32 processed = 0;
-    const HRESULT res = _outStream->Write(_buf + _convPos, num, &processed);
+    HRESULT res = _outStream->Write(_buf + _convPos, num, &processed);
     if (processed == 0)
       return res != S_OK ? res : E_FAIL;
     
     _convPos += processed;
     _convSize -= processed;
     _nowPos64 += processed;
-    RINOK(res)
+    RINOK(res);
   }
     
-  const UInt32 convPos = _convPos;
-  if (convPos != 0)
+  if (_convPos != 0)
   {
-    const UInt32 num = _bufPos - convPos;
-    Byte *buf = _buf;
+    UInt32 num = _bufPos - _convPos;
     for (UInt32 i = 0; i < num; i++)
-      buf[i] = buf[convPos + i];
+      _buf[i] = _buf[_convPos + i];
     _bufPos = num;
     _convPos = 0;
   }
@@ -331,14 +202,14 @@ HRESULT CFilterCoder::Flush2()
   return S_OK;
 }
 
-Z7_COM7F_IMF(CFilterCoder::Write(const void *data, UInt32 size, UInt32 *processedSize))
+STDMETHODIMP CFilterCoder::Write(const void *data, UInt32 size, UInt32 *processedSize)
 {
   if (processedSize)
     *processedSize = 0;
   
   while (size != 0)
   {
-    RINOK(Flush2())
+    RINOK(Flush2());
 
     // _convSize is 0
     // _convPos is 0
@@ -373,22 +244,20 @@ Z7_COM7F_IMF(CFilterCoder::Write(const void *data, UInt32 size, UInt32 *processe
   return S_OK;
 }
 
-Z7_COM7F_IMF(CFilterCoder::OutStreamFinish())
+STDMETHODIMP CFilterCoder::OutStreamFinish()
 {
   for (;;)
   {
-    RINOK(Flush2())
+    RINOK(Flush2());
     if (_bufPos == 0)
       break;
-    const UInt32 convSize = Filter->Filter(_buf, _bufPos);
-    _convSize = convSize;
-    UInt32 bufPos = _bufPos;
-    if (convSize == 0)
-      _convSize = bufPos;
-    else if (convSize > bufPos)
+    _convSize = Filter->Filter(_buf, _bufPos);
+    if (_convSize == 0)
+      _convSize = _bufPos;
+    else if (_convSize > _bufPos)
     {
       // AES
-      if (convSize > _bufSize)
+      if (_convSize > _bufSize)
       {
         _convSize = 0;
         return E_FAIL;
@@ -398,11 +267,9 @@ Z7_COM7F_IMF(CFilterCoder::OutStreamFinish())
         _convSize = 0;
         return S_FALSE;
       }
-      Byte *buf = _buf;
-      for (; bufPos < convSize; bufPos++)
-        buf[bufPos] = 0;
-      _bufPos = bufPos;
-      _convSize = Filter->Filter(_buf, bufPos);
+      for (; _bufPos < _convSize; _bufPos++)
+        _buf[_bufPos] = 0;
+      _convSize = Filter->Filter(_buf, _bufPos);
       if (_convSize != _bufPos)
         return E_FAIL;
     }
@@ -417,7 +284,7 @@ Z7_COM7F_IMF(CFilterCoder::OutStreamFinish())
 
 // ---------- Init functions ----------
 
-Z7_COM7F_IMF(CFilterCoder::InitEncoder())
+STDMETHODIMP CFilterCoder::InitEncoder()
 {
   InitSpecVars();
   return Init_and_Alloc();
@@ -429,33 +296,33 @@ HRESULT CFilterCoder::Init_NoSubFilterInit()
   return Alloc();
 }
 
-Z7_COM7F_IMF(CFilterCoder::SetOutStreamSize(const UInt64 *outSize))
+STDMETHODIMP CFilterCoder::SetOutStreamSize(const UInt64 *outSize)
 {
   InitSpecVars();
   if (outSize)
   {
     _outSize = *outSize;
-    _outSize_Defined = true;
+    _outSizeIsDefined = true;
   }
   return Init_and_Alloc();
 }
 
 // ---------- Read from Filter ----------
 
-Z7_COM7F_IMF(CFilterCoder::SetInStream(ISequentialInStream *inStream))
+STDMETHODIMP CFilterCoder::SetInStream(ISequentialInStream *inStream)
 {
   _inStream = inStream;
   return S_OK;
 }
 
-Z7_COM7F_IMF(CFilterCoder::ReleaseInStream())
+STDMETHODIMP CFilterCoder::ReleaseInStream()
 {
   _inStream.Release();
   return S_OK;
 }
 
 
-Z7_COM7F_IMF(CFilterCoder::Read(void *data, UInt32 size, UInt32 *processedSize))
+STDMETHODIMP CFilterCoder::Read(void *data, UInt32 size, UInt32 *processedSize)
 {
   if (processedSize)
     *processedSize = 0;
@@ -466,9 +333,9 @@ Z7_COM7F_IMF(CFilterCoder::Read(void *data, UInt32 size, UInt32 *processedSize))
     {
       if (size > _convSize)
         size = _convSize;
-      if (_outSize_Defined)
+      if (_outSizeIsDefined)
       {
-        const UInt64 rem = _outSize - _nowPos64;
+        UInt64 rem = _outSize - _nowPos64;
         if (size > rem)
           size = (UInt32)rem;
       }
@@ -481,51 +348,46 @@ Z7_COM7F_IMF(CFilterCoder::Read(void *data, UInt32 size, UInt32 *processedSize))
       break;
     }
   
-    const UInt32 convPos = _convPos;
-    if (convPos != 0)
+    if (_convPos != 0)
     {
-      const UInt32 num = _bufPos - convPos;
-      Byte *buf = _buf;
+      UInt32 num = _bufPos - _convPos;
       for (UInt32 i = 0; i < num; i++)
-        buf[i] = buf[convPos + i];
+        _buf[i] = _buf[_convPos + i];
       _bufPos = num;
       _convPos = 0;
     }
     
     {
       size_t readSize = _bufSize - _bufPos;
-      const HRESULT res = ReadStream(_inStream, _buf + _bufPos, &readSize);
+      HRESULT res = ReadStream(_inStream, _buf + _bufPos, &readSize);
       _bufPos += (UInt32)readSize;
-      RINOK(res)
+      RINOK(res);
     }
     
-    const UInt32 convSize = Filter->Filter(_buf, _bufPos);
-    _convSize = convSize;
+    _convSize = Filter->Filter(_buf, _bufPos);
     
-    UInt32 bufPos = _bufPos;
-
-    if (convSize == 0)
+    if (_convSize == 0)
     {
-      if (bufPos == 0)
+      if (_bufPos == 0)
         break;
       // BCJ
-      _convSize = bufPos;
+      _convSize = _bufPos;
       continue;
     }
     
-    if (convSize > bufPos)
+    if (_convSize > _bufPos)
     {
       // AES
-      if (convSize > _bufSize)
+      if (_convSize > _bufSize)
         return E_FAIL;
       if (!_encodeMode)
         return S_FALSE;
-      Byte *buf = _buf;
+      
       do
-        buf[bufPos] = 0;
-      while (++bufPos != convSize);
-      _bufPos = bufPos;
-      _convSize = Filter->Filter(_buf, convSize);
+        _buf[_bufPos] = 0;
+      while (++_bufPos != _convSize);
+      
+      _convSize = Filter->Filter(_buf, _convSize);
       if (_convSize != _bufPos)
         return E_FAIL;
     }
@@ -535,43 +397,39 @@ Z7_COM7F_IMF(CFilterCoder::Read(void *data, UInt32 size, UInt32 *processedSize))
 }
 
 
-#ifndef Z7_NO_CRYPTO
+#ifndef _NO_CRYPTO
 
-Z7_COM7F_IMF(CFilterCoder::CryptoSetPassword(const Byte *data, UInt32 size))
-  { return _setPassword->CryptoSetPassword(data, size); }
+STDMETHODIMP CFilterCoder::CryptoSetPassword(const Byte *data, UInt32 size)
+  { return _SetPassword->CryptoSetPassword(data, size); }
 
-Z7_COM7F_IMF(CFilterCoder::SetKey(const Byte *data, UInt32 size))
-  { return _cryptoProperties->SetKey(data, size); }
+STDMETHODIMP CFilterCoder::SetKey(const Byte *data, UInt32 size)
+  { return _CryptoProperties->SetKey(data, size); }
 
-Z7_COM7F_IMF(CFilterCoder::SetInitVector(const Byte *data, UInt32 size))
-  { return _cryptoProperties->SetInitVector(data, size); }
+STDMETHODIMP CFilterCoder::SetInitVector(const Byte *data, UInt32 size)
+  { return _CryptoProperties->SetInitVector(data, size); }
 
 #endif
 
 
-#ifndef Z7_EXTRACT_ONLY
-
-Z7_COM7F_IMF(CFilterCoder::SetCoderProperties(const PROPID *propIDs,
-    const PROPVARIANT *properties, UInt32 numProperties))
-  { return _setCoderProperties->SetCoderProperties(propIDs, properties, numProperties); }
+#ifndef EXTRACT_ONLY
 
-Z7_COM7F_IMF(CFilterCoder::WriteCoderProperties(ISequentialOutStream *outStream))
-  { return _writeCoderProperties->WriteCoderProperties(outStream); }
+STDMETHODIMP CFilterCoder::SetCoderProperties(const PROPID *propIDs,
+    const PROPVARIANT *properties, UInt32 numProperties)
+  { return _SetCoderProperties->SetCoderProperties(propIDs, properties, numProperties); }
 
-Z7_COM7F_IMF(CFilterCoder::SetCoderPropertiesOpt(const PROPID *propIDs,
-    const PROPVARIANT *properties, UInt32 numProperties))
-  { return _setCoderPropertiesOpt->SetCoderPropertiesOpt(propIDs, properties, numProperties); }
+STDMETHODIMP CFilterCoder::WriteCoderProperties(ISequentialOutStream *outStream)
+  { return _WriteCoderProperties->WriteCoderProperties(outStream); }
 
 /*
-Z7_COM7F_IMF(CFilterCoder::ResetSalt()
-  { return _cryptoResetSalt->ResetSalt(); }
+STDMETHODIMP CFilterCoder::ResetSalt()
+  { return _CryptoResetSalt->ResetSalt(); }
 */
 
-Z7_COM7F_IMF(CFilterCoder::ResetInitVector())
-  { return _cryptoResetInitVector->ResetInitVector(); }
+STDMETHODIMP CFilterCoder::ResetInitVector()
+  { return _CryptoResetInitVector->ResetInitVector(); }
 
 #endif
 
 
-Z7_COM7F_IMF(CFilterCoder::SetDecoderProperties2(const Byte *data, UInt32 size))
-  { return _setDecoderProperties2->SetDecoderProperties2(data, size); }
+STDMETHODIMP CFilterCoder::SetDecoderProperties2(const Byte *data, UInt32 size)
+  { return _SetDecoderProperties2->SetDecoderProperties2(data, size); }