seven-zip 1.4.1 → 1.7.0.rc1

data/ext/p7zip/CPP/7zip/Archive/MubHandler.cpp

@@ -4,109 +4,144 @@
 
 #include "../../../C/CpuArch.h"
 
-#include "Common/ComTry.h"
+#include "../../Common/ComTry.h"
+#include "../../Common/IntToString.h"
+#include "../../Common/MyString.h"
 
-#include "Windows/PropVariant.h"
+#include "../../Windows/PropVariant.h"
 
-#include "../Common/LimitedStreams.h"
-#include "../Common/ProgressUtils.h"
 #include "../Common/RegisterArc.h"
 #include "../Common/StreamUtils.h"
 
-#include "../Compress/CopyCoder.h"
+#include "HandlerCont.h"
 
-#define Get32(p) GetBe32(p)
+static UInt32 Get32(const Byte *p, bool be) { if (be) return GetBe32(p); return GetUi32(p); }
+
+using namespace NWindows;
+using namespace NCOM;
 
 namespace NArchive {
 namespace NMub {
 
+#define MACH_CPU_ARCH_ABI64 (1 << 24)
+#define MACH_CPU_TYPE_386    7
+#define MACH_CPU_TYPE_ARM   12
+#define MACH_CPU_TYPE_SPARC 14
+#define MACH_CPU_TYPE_PPC   18
+
+#define MACH_CPU_TYPE_PPC64 (MACH_CPU_ARCH_ABI64 | MACH_CPU_TYPE_PPC)
+#define MACH_CPU_TYPE_AMD64 (MACH_CPU_ARCH_ABI64 | MACH_CPU_TYPE_386)
+
+#define MACH_CPU_SUBTYPE_LIB64 (1 << 31)
+
+#define MACH_CPU_SUBTYPE_I386_ALL 3
+
 struct CItem
 {
   UInt32 Type;
   UInt32 SubType;
-  UInt64 Offset;
-  UInt64 Size;
-  UInt32 Align;
-  bool IsTail;
+  UInt32 Offset;
+  UInt32 Size;
+  // UInt32 Align;
 };
 
-const UInt32 kNumFilesMax = 10;
+static const UInt32 kNumFilesMax = 10;
 
-class CHandler:
-  public IInArchive,
-  public IInArchiveGetStream,
-  public CMyUnknownImp
+class CHandler: public CHandlerCont
 {
-  UInt64 _startPos;
-  CMyComPtr<IInStream> _stream;
+  // UInt64 _startPos;
+  UInt64 _phySize;
   UInt32 _numItems;
-  CItem _items[kNumFilesMax + 1];
+  bool _bigEndian;
+  CItem _items[kNumFilesMax];
+
   HRESULT Open2(IInStream *stream);
+
+  virtual int GetItem_ExtractInfo(UInt32 index, UInt64 &pos, UInt64 &size) const
+  {
+    const CItem &item = _items[index];
+    pos = item.Offset;
+    size = item.Size;
+    return NExtract::NOperationResult::kOK;
+  }
+
 public:
-  MY_UNKNOWN_IMP2(IInArchive, IInArchiveGetStream)
-  INTERFACE_IInArchive(;)
-  STDMETHOD(GetStream)(UInt32 index, ISequentialInStream **stream);
+  INTERFACE_IInArchive_Cont(;)
 };
 
-STATPROPSTG kProps[] =
+static const Byte kArcProps[] =
 {
-  { NULL, kpidSize, VT_UI8}
+  kpidBigEndian
 };
 
-IMP_IInArchive_Props
-IMP_IInArchive_ArcProps_NO
+static const Byte kProps[] =
+{
+  kpidSize
+};
 
-#define MACH_ARCH_ABI64  0x1000000
-#define MACH_MACHINE_386   7
-#define MACH_MACHINE_ARM   12
-#define MACH_MACHINE_SPARC 14
-#define MACH_MACHINE_PPC   18
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
 
-#define MACH_MACHINE_PPC64 (MACH_MACHINE_PPC | MACH_ARCH_ABI64)
-#define MACH_MACHINE_AMD64 (MACH_MACHINE_386 | MACH_ARCH_ABI64)
+STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
+{
+  PropVariant_Clear(value);
+  switch (propID)
+  {
+    case kpidBigEndian: PropVarEm_Set_Bool(value, _bigEndian); break;
+    case kpidPhySize: PropVarEm_Set_UInt64(value, _phySize); break;
+  }
+  return S_OK;
+}
 
 STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value)
 {
-  NWindows::NCOM::CPropVariant prop;
+  PropVariant_Clear(value);
   const CItem &item = _items[index];
-  switch(propID)
+  switch (propID)
   {
     case kpidExtension:
     {
-      const wchar_t *ext;
-      if (item.IsTail)
-        ext = L"tail";
-      else
+      char temp[32];
+      const char *ext = 0;
+      switch (item.Type)
       {
-        switch(item.Type)
-        {
-          case MACH_MACHINE_386:   ext = L"86";    break;
-          case MACH_MACHINE_ARM:   ext = L"arm";   break;
-          case MACH_MACHINE_SPARC: ext = L"sparc"; break;
-          case MACH_MACHINE_PPC:   ext = L"ppc";   break;
-          case MACH_MACHINE_PPC64: ext = L"ppc64"; break;
-          case MACH_MACHINE_AMD64: ext = L"x64";   break;
-          default: ext = L"unknown"; break;
-        }
+        case MACH_CPU_TYPE_386:   ext = "x86";    break;
+        case MACH_CPU_TYPE_ARM:   ext = "arm";   break;
+        case MACH_CPU_TYPE_SPARC: ext = "sparc"; break;
+        case MACH_CPU_TYPE_PPC:   ext = "ppc";   break;
+        case MACH_CPU_TYPE_PPC64: ext = "ppc64"; break;
+        case MACH_CPU_TYPE_AMD64: ext = "x64";   break;
+        default:
+          temp[0] = 'c';
+          temp[1] = 'p';
+          temp[2] = 'u';
+          ConvertUInt32ToString(item.Type, temp + 3);
+          break;
       }
-      prop = ext;
-      break;
+      if (ext)
+        strcpy(temp, ext);
+      if (item.SubType != 0 && (
+          item.Type != MACH_CPU_TYPE_386 &&
+          item.Type != MACH_CPU_TYPE_AMD64 ||
+          (item.SubType & ~(UInt32)MACH_CPU_SUBTYPE_LIB64) != MACH_CPU_SUBTYPE_I386_ALL))
+      {
+        unsigned pos = MyStringLen(temp);
+        temp[pos++] = '-';
+          ConvertUInt32ToString(item.SubType, temp + pos);
+      }
+      return PropVarEm_Set_Str(value, temp);
     }
     case kpidSize:
     case kpidPackSize:
-      prop = (UInt64)item.Size;
+      PropVarEm_Set_UInt64(value, item.Size);
       break;
   }
-  prop.Detach(value);
   return S_OK;
 }
 
-#define MACH_TYPE_ABI64 (1 << 24)
-#define MACH_SUBTYPE_ABI64 (1 << 31)
-
 HRESULT CHandler::Open2(IInStream *stream)
 {
-  RINOK(stream->Seek(0, STREAM_SEEK_SET, &_startPos));
+  // RINOK(stream->Seek(0, STREAM_SEEK_CUR, &_startPos));
 
   const UInt32 kHeaderSize = 8;
   const UInt32 kRecordSize = 5 * 4;
@@ -116,44 +151,45 @@ HRESULT CHandler::Open2(IInStream *stream)
   RINOK(ReadStream(stream, buf, &processed));
   if (processed < kHeaderSize)
     return S_FALSE;
-  UInt32 num = Get32(buf + 4);
-  if (Get32(buf) != 0xCAFEBABE || num > kNumFilesMax || processed < kHeaderSize + num * kRecordSize)
+  
+  bool be;
+  switch (GetBe32(buf))
+  {
+    case 0xCAFEBABE: be = true; break;
+    case 0xB9FAF10E: be = false; break;
+    default: return S_FALSE;
+  }
+  _bigEndian = be;
+  UInt32 num = Get32(buf + 4, be);
+  if (num > kNumFilesMax || processed < kHeaderSize + num * kRecordSize)
+    return S_FALSE;
+  if (num == 0)
     return S_FALSE;
   UInt64 endPosMax = kHeaderSize;
+
   for (UInt32 i = 0; i < num; i++)
   {
     const Byte *p = buf + kHeaderSize + i * kRecordSize;
     CItem &sb = _items[i];
-    sb.IsTail = false;
-    sb.Type = Get32(p);
-    sb.SubType = Get32(p + 4);
-    sb.Offset = Get32(p + 8);
-    sb.Size = Get32(p + 12);
-    sb.Align = Get32(p + 16);
-
-    if ((sb.Type & ~MACH_TYPE_ABI64) >= 0x100 ||
-        (sb.SubType & ~MACH_SUBTYPE_ABI64) >= 0x100 ||
-        sb.Align > 31)
+    sb.Type = Get32(p, be);
+    sb.SubType = Get32(p + 4, be);
+    sb.Offset = Get32(p + 8, be);
+    sb.Size = Get32(p + 12, be);
+    UInt32 align = Get32(p + 16, be);
+    if (align > 31)
+      return S_FALSE;
+    if (sb.Offset < kHeaderSize + num * kRecordSize)
+      return S_FALSE;
+    if ((sb.Type & ~MACH_CPU_ARCH_ABI64) >= 0x100 ||
+        (sb.SubType & ~MACH_CPU_SUBTYPE_LIB64) >= 0x100)
       return S_FALSE;
 
     UInt64 endPos = (UInt64)sb.Offset + sb.Size;
-    if (endPos > endPosMax)
+    if (endPosMax < endPos)
       endPosMax = endPos;
   }
-  UInt64 fileSize;
-  RINOK(stream->Seek(0, STREAM_SEEK_END, &fileSize));
-  fileSize -= _startPos;
   _numItems = num;
-  if (fileSize > endPosMax)
-  {
-    CItem &sb = _items[_numItems++];
-    sb.IsTail = true;
-    sb.Type = 0;
-    sb.SubType = 0;
-    sb.Offset = endPosMax;
-    sb.Size = fileSize - endPosMax;
-    sb.Align = 0;
-  }
+  _phySize = endPosMax;
   return S_OK;
 }
 
@@ -178,6 +214,7 @@ STDMETHODIMP CHandler::Close()
 {
   _stream.Release();
   _numItems = 0;
+  _phySize = 0;
   return S_OK;
 }
 
@@ -187,80 +224,19 @@ STDMETHODIMP CHandler::GetNumberOfItems(UInt32 *numItems)
   return S_OK;
 }
 
-STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
-    Int32 testMode, IArchiveExtractCallback *extractCallback)
-{
-  COM_TRY_BEGIN
-  bool allFilesMode = (numItems == (UInt32)-1);
-  if (allFilesMode)
-    numItems = _numItems;
-  if (numItems == 0)
-    return S_OK;
-  UInt64 totalSize = 0;
-  UInt32 i;
-  for (i = 0; i < numItems; i++)
-    totalSize += _items[allFilesMode ? i : indices[i]].Size;
-  extractCallback->SetTotal(totalSize);
-
-  UInt64 currentTotalSize = 0;
-  
-  NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
-  CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+namespace NBe {
 
-  CLocalProgress *lps = new CLocalProgress;
-  CMyComPtr<ICompressProgressInfo> progress = lps;
-  lps->Init(extractCallback, false);
+static const Byte k_Signature[] = {
+    7, 0xCA, 0xFE, 0xBA, 0xBE, 0, 0, 0,
+    4, 0xB9, 0xFA, 0xF1, 0x0E };
 
-  CLimitedSequentialInStream *streamSpec = new CLimitedSequentialInStream;
-  CMyComPtr<ISequentialInStream> inStream(streamSpec);
-  streamSpec->SetStream(_stream);
-
-  for (i = 0; i < numItems; i++)
-  {
-    lps->InSize = lps->OutSize = currentTotalSize;
-    RINOK(lps->SetCur());
-    CMyComPtr<ISequentialOutStream> realOutStream;
-    Int32 askMode = testMode ?
-        NExtract::NAskMode::kTest :
-        NExtract::NAskMode::kExtract;
-    UInt32 index = allFilesMode ? i : indices[i];
-    const CItem &item = _items[index];
-    RINOK(extractCallback->GetStream(index, &realOutStream, askMode));
-    currentTotalSize += item.Size;
-    
-    if (!testMode && !realOutStream)
-      continue;
-    RINOK(extractCallback->PrepareOperation(askMode));
-    if (testMode)
-    {
-      RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK));
-      continue;
-    }
-    RINOK(_stream->Seek(_startPos + item.Offset, STREAM_SEEK_SET, NULL));
-    streamSpec->Init(item.Size);
-    RINOK(copyCoder->Code(inStream, realOutStream, NULL, NULL, progress));
-    realOutStream.Release();
-    RINOK(extractCallback->SetOperationResult((copyCoderSpec->TotalSize == item.Size) ?
-        NExtract::NOperationResult::kOK:
-        NExtract::NOperationResult::kDataError));
-  }
-  return S_OK;
-  COM_TRY_END
-}
+REGISTER_ARC_I(
+  "Mub", "mub", 0, 0xE2,
+  k_Signature,
+  0,
+  NArcInfoFlags::kMultiSignature,
+  NULL)
 
-STDMETHODIMP CHandler::GetStream(UInt32 index, ISequentialInStream **stream)
-{
-  COM_TRY_BEGIN
-  const CItem &item = _items[index];
-  return CreateLimitedInStream(_stream, _startPos + item.Offset, item.Size, stream);
-  COM_TRY_END
 }
 
-static IInArchive *CreateArc() { return new CHandler; }
-
-static CArcInfo g_ArcInfo =
-  { L"Mub", L"", 0, 0xE2, { 0xCA, 0xFE, 0xBA, 0xBE, 0, 0, 0 }, 7, false, CreateArc, 0 };
-
-REGISTER_ARC(Mub)
-
 }}

data/ext/p7zip/CPP/7zip/Archive/Nsis/NsisDecode.cpp

@@ -2,94 +2,75 @@
 
 #include "StdAfx.h"
 
-#include "NsisDecode.h"
+#include "../../../../C/CpuArch.h"
 
-#include "../../Common/StreamUtils.h"
+#include "NsisDecode.h"
 
+#include "../../Common/CreateCoder.h"
+#include "../../Common/LimitedStreams.h"
 #include "../../Common/MethodId.h"
 
+#include "../../Compress/BcjCoder.h"
 #include "../../Compress/BZip2Decoder.h"
 #include "../../Compress/DeflateDecoder.h"
-#include "../../Compress/LzmaDecoder.h"
+
+#define Get32(p) GetUi32(p)
 
 namespace NArchive {
 namespace NNsis {
 
-static const CMethodId k_BCJ_X86 = 0x03030103;
-
-HRESULT CDecoder::Init(
-    DECL_EXTERNAL_CODECS_LOC_VARS
-    IInStream *inStream, NMethodType::EEnum method, bool thereIsFilterFlag, bool &useFilter)
+HRESULT CDecoder::Init(ISequentialInStream *inStream, bool &useFilter)
 {
   useFilter = false;
-  CObjectVector< CMyComPtr<ISequentialInStream> > inStreams;
 
   if (_decoderInStream)
-    if (method != _method)
+    if (Method != _curMethod)
       Release();
-  _method = method;
+  _curMethod = Method;
   if (!_codecInStream)
   {
-    switch (method)
+    switch (Method)
     {
       // case NMethodType::kCopy: return E_NOTIMPL;
       case NMethodType::kDeflate: _codecInStream = new NCompress::NDeflate::NDecoder::CNsisCOMCoder(); break;
       case NMethodType::kBZip2: _codecInStream = new NCompress::NBZip2::CNsisDecoder(); break;
-      case NMethodType::kLZMA: _codecInStream = new NCompress::NLzma::CDecoder(); break;
+      case NMethodType::kLZMA:
+        _lzmaDecoder = new NCompress::NLzma::CDecoder();
+        _codecInStream = _lzmaDecoder;
+        break;
       default: return E_NOTIMPL;
     }
   }
 
-  if (thereIsFilterFlag)
+  if (FilterFlag)
   {
-    UInt32 processedSize;
-    BYTE flag;
-    RINOK(inStream->Read(&flag, 1, &processedSize));
-    if (processedSize != 1)
-      return E_FAIL;
+    Byte flag;
+    RINOK(ReadStream_FALSE(inStream, &flag, 1));
     if (flag > 1)
       return E_NOTIMPL;
     useFilter = (flag != 0);
   }
   
-  if (useFilter)
+  if (!useFilter)
+    _decoderInStream = _codecInStream;
+  else
   {
     if (!_filterInStream)
     {
-      CMyComPtr<ICompressCoder> coder;
-      RINOK(CreateCoder(
-          EXTERNAL_CODECS_LOC_VARS
-          k_BCJ_X86, coder, false));
-      if (!coder)
-        return E_NOTIMPL;
-      coder.QueryInterface(IID_ISequentialInStream, &_filterInStream);
-      if (!_filterInStream)
-        return E_NOTIMPL;
+      _filter = new CFilterCoder(false);
+      _filterInStream = _filter;
+      _filter->Filter = new NCompress::NBcj::CCoder(false);
     }
-    CMyComPtr<ICompressSetInStream> setInStream;
-    _filterInStream.QueryInterface(IID_ICompressSetInStream, &setInStream);
-    if (!setInStream)
-      return E_NOTIMPL;
-    RINOK(setInStream->SetInStream(_codecInStream));
+    RINOK(_filter->SetInStream(_codecInStream));
     _decoderInStream = _filterInStream;
   }
-  else
-    _decoderInStream = _codecInStream;
 
-  if (method == NMethodType::kLZMA)
+  if (Method == NMethodType::kLZMA)
   {
-    CMyComPtr<ICompressSetDecoderProperties2> setDecoderProperties;
-    _codecInStream.QueryInterface(IID_ICompressSetDecoderProperties2, &setDecoderProperties);
-    if (setDecoderProperties)
-    {
-      static const UInt32 kPropertiesSize = 5;
-      BYTE properties[kPropertiesSize];
-      UInt32 processedSize;
-      RINOK(inStream->Read(properties, kPropertiesSize, &processedSize));
-      if (processedSize != kPropertiesSize)
-        return E_FAIL;
-      RINOK(setDecoderProperties->SetDecoderProperties2((const Byte *)properties, kPropertiesSize));
-    }
+    const unsigned kPropsSize = LZMA_PROPS_SIZE;
+    Byte props[kPropsSize];
+    RINOK(ReadStream_FALSE(inStream, props, kPropsSize));
+    RINOK(_lzmaDecoder->SetDecoderProperties2((const Byte *)props, kPropsSize));
   }
 
   {
@@ -110,21 +91,161 @@ HRESULT CDecoder::Init(
 
   if (useFilter)
   {
-    /*
-    CMyComPtr<ICompressSetOutStreamSize> setOutStreamSize;
-    _filterInStream.QueryInterface(IID_ICompressSetOutStreamSize, &setOutStreamSize);
-    if (!setOutStreamSize)
-      return E_NOTIMPL;
-    RINOK(setOutStreamSize->SetOutStreamSize(NULL));
-    */
+    RINOK(_filter->SetOutStreamSize(NULL));
   }
 
   return S_OK;
 }
 
-HRESULT CDecoder::Read(void *data, size_t *processedSize)
+static const UInt32 kMask_IsCompressed = (UInt32)1 << 31;
+
+HRESULT CDecoder::SetToPos(UInt64 pos, ICompressProgressInfo *progress)
 {
-  return ReadStream(_decoderInStream, data, processedSize);;
+  if (StreamPos > pos)
+    return E_FAIL;
+  UInt64 inSizeStart = 0;
+  if (_lzmaDecoder)
+    inSizeStart = _lzmaDecoder->GetInputProcessedSize();
+  UInt64 offset = 0;
+  while (StreamPos < pos)
+  {
+    size_t size = (size_t)MyMin(pos - StreamPos, (UInt64)Buffer.Size());
+    RINOK(Read(Buffer, &size));
+    if (size == 0)
+      return S_FALSE;
+    StreamPos += size;
+    offset += size;
+
+    UInt64 inSize = 0;
+    if (_lzmaDecoder)
+      inSize = _lzmaDecoder->GetInputProcessedSize() - inSizeStart;
+    RINOK(progress->SetRatioInfo(&inSize, &offset));
+  }
+  return S_OK;
+}
+
+HRESULT CDecoder::Decode(CByteBuffer *outBuf, bool unpackSizeDefined, UInt32 unpackSize,
+    ISequentialOutStream *realOutStream, ICompressProgressInfo *progress,
+    UInt32 &packSizeRes, UInt32 &unpackSizeRes)
+{
+  CLimitedSequentialInStream *limitedStreamSpec = NULL;
+  CMyComPtr<ISequentialInStream> limitedStream;
+  packSizeRes = 0;
+  unpackSizeRes = 0;
+
+  if (Solid)
+  {
+    Byte temp[4];
+    size_t processedSize = 4;
+    RINOK(Read(temp, &processedSize));
+    if (processedSize != 4)
+      return S_FALSE;
+    StreamPos += processedSize;
+    UInt32 size = Get32(temp);
+    if (unpackSizeDefined && size != unpackSize)
+      return S_FALSE;
+    unpackSize = size;
+    unpackSizeDefined = true;
+  }
+  else
+  {
+    Byte temp[4];
+    RINOK(ReadStream_FALSE(InputStream, temp, 4));
+    StreamPos += 4;
+    UInt32 size = Get32(temp);
+
+    if ((size & kMask_IsCompressed) == 0)
+    {
+      if (unpackSizeDefined && size != unpackSize)
+        return S_FALSE;
+      packSizeRes = size;
+      if (outBuf)
+        outBuf->Alloc(size);
+
+      UInt64 offset = 0;
+      
+      while (size > 0)
+      {
+        UInt32 curSize = (UInt32)MyMin((size_t)size, Buffer.Size());
+        UInt32 processedSize;
+        RINOK(InputStream->Read(Buffer, curSize, &processedSize));
+        if (processedSize == 0)
+          return S_FALSE;
+        if (outBuf)
+          memcpy((Byte *)*outBuf + (size_t)offset, Buffer, processedSize);
+        offset += processedSize;
+        size -= processedSize;
+        StreamPos += processedSize;
+        unpackSizeRes += processedSize;
+        if (realOutStream)
+          RINOK(WriteStream(realOutStream, Buffer, processedSize));
+        RINOK(progress->SetRatioInfo(&offset, &offset));
+      }
+
+      return S_OK;
+    }
+    
+    size &= ~kMask_IsCompressed;
+    packSizeRes = size;
+    limitedStreamSpec = new CLimitedSequentialInStream;
+    limitedStream = limitedStreamSpec;
+    limitedStreamSpec->SetStream(InputStream);
+    limitedStreamSpec->Init(size);
+    {
+      bool useFilter;
+      RINOK(Init(limitedStream, useFilter));
+    }
+  }
+  
+  if (outBuf)
+  {
+    if (!unpackSizeDefined)
+      return S_FALSE;
+    outBuf->Alloc(unpackSize);
+  }
+
+  UInt64 inSizeStart = 0;
+  if (_lzmaDecoder)
+    inSizeStart = _lzmaDecoder->GetInputProcessedSize();
+
+  // we don't allow files larger than 4 GB;
+  if (!unpackSizeDefined)
+    unpackSize = 0xFFFFFFFF;
+  UInt32 offset = 0;
+
+  for (;;)
+  {
+    size_t rem = unpackSize - offset;
+    if (rem == 0)
+      break;
+    size_t size = Buffer.Size();
+    if (size > rem)
+      size = rem;
+    RINOK(Read(Buffer, &size));
+    if (size == 0)
+    {
+      if (unpackSizeDefined)
+        return S_FALSE;
+      break;
+    }
+    if (outBuf)
+      memcpy((Byte *)*outBuf + (size_t)offset, Buffer, size);
+    StreamPos += size;
+    offset += (UInt32)size;
+
+    UInt64 inSize = 0; // it can be improved: we need inSize for Deflate and BZip2 too.
+    if (_lzmaDecoder)
+      inSize = _lzmaDecoder->GetInputProcessedSize() - inSizeStart;
+    if (Solid)
+      packSizeRes = (UInt32)inSize;
+    unpackSizeRes += (UInt32)size;
+    
+    UInt64 outSize = offset;
+    RINOK(progress->SetRatioInfo(&inSize, &outSize));
+    if (realOutStream)
+      RINOK(WriteStream(realOutStream, Buffer, size));
+  }
+  return S_OK;
 }
 
 }}