seven-zip 1.4.0

data/ext/p7zip/CPP/7zip/Common/OutBuffer.cpp

@@ -0,0 +1,116 @@
+// OutBuffer.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/Alloc.h"
+
+#include "OutBuffer.h"
+
+bool COutBuffer::Create(UInt32 bufferSize)
+{
+  const UInt32 kMinBlockSize = 1;
+  if (bufferSize < kMinBlockSize)
+    bufferSize = kMinBlockSize;
+  if (_buffer != 0 && _bufferSize == bufferSize)
+    return true;
+  Free();
+  _bufferSize = bufferSize;
+  _buffer = (Byte *)::MidAlloc(bufferSize);
+  return (_buffer != 0);
+}
+
+void COutBuffer::Free()
+{
+  ::MidFree(_buffer);
+  _buffer = 0;
+}
+
+void COutBuffer::SetStream(ISequentialOutStream *stream)
+{
+  _stream = stream;
+}
+
+void COutBuffer::Init()
+{
+  _streamPos = 0;
+  _limitPos = _bufferSize;
+  _pos = 0;
+  _processedSize = 0;
+  _overDict = false;
+  #ifdef _NO_EXCEPTIONS
+  ErrorCode = S_OK;
+  #endif
+}
+
+UInt64 COutBuffer::GetProcessedSize() const
+{
+  UInt64 res = _processedSize + _pos - _streamPos;
+  if (_streamPos > _pos)
+    res += _bufferSize;
+  return res;
+}
+
+
+HRESULT COutBuffer::FlushPart()
+{
+  // _streamPos < _bufferSize
+  UInt32 size = (_streamPos >= _pos) ? (_bufferSize - _streamPos) : (_pos - _streamPos);
+  HRESULT result = S_OK;
+  #ifdef _NO_EXCEPTIONS
+  result = ErrorCode;
+  #endif
+  if (_buffer2 != 0)
+  {
+    memmove(_buffer2, _buffer + _streamPos, size);
+    _buffer2 += size;
+  }
+
+  if (_stream != 0
+      #ifdef _NO_EXCEPTIONS
+      && (ErrorCode == S_OK)
+      #endif
+     )
+  {
+    UInt32 processedSize = 0;
+    result = _stream->Write(_buffer + _streamPos, size, &processedSize);
+    size = processedSize;
+  }
+  _streamPos += size;
+  if (_streamPos == _bufferSize)
+    _streamPos = 0;
+  if (_pos == _bufferSize)
+  {
+    _overDict = true;
+    _pos = 0;
+  }
+  _limitPos = (_streamPos > _pos) ? _streamPos : _bufferSize;
+  _processedSize += size;
+  return result;
+}
+
+HRESULT COutBuffer::Flush()
+{
+  #ifdef _NO_EXCEPTIONS
+  if (ErrorCode != S_OK)
+    return ErrorCode;
+  #endif
+
+  while(_streamPos != _pos)
+  {
+    HRESULT result = FlushPart();
+    if (result != S_OK)
+      return result;
+  }
+  return S_OK;
+}
+
+void COutBuffer::FlushWithCheck()
+{
+  HRESULT result = Flush();
+  #ifdef _NO_EXCEPTIONS
+  ErrorCode = result;
+  #else
+  if (result != S_OK)
+    throw COutBufferException(result);
+  #endif
+}

data/ext/p7zip/CPP/7zip/Common/OutBuffer.h

@@ -0,0 +1,64 @@
+// OutBuffer.h
+
+#ifndef __OUTBUFFER_H
+#define __OUTBUFFER_H
+
+#include "../IStream.h"
+#include "../../Common/MyCom.h"
+#include "../../Common/MyException.h"
+
+#ifndef _NO_EXCEPTIONS
+struct COutBufferException: public CSystemException
+{
+  COutBufferException(HRESULT errorCode): CSystemException(errorCode) {}
+};
+#endif
+
+class COutBuffer
+{
+protected:
+  Byte *_buffer;
+  UInt32 _pos;
+  UInt32 _limitPos;
+  UInt32 _streamPos;
+  UInt32 _bufferSize;
+  CMyComPtr<ISequentialOutStream> _stream;
+  UInt64 _processedSize;
+  Byte  *_buffer2;
+  bool _overDict;
+
+  HRESULT FlushPart();
+public:
+  #ifdef _NO_EXCEPTIONS
+  HRESULT ErrorCode;
+  #endif
+
+  COutBuffer(): _buffer(0), _pos(0), _stream(0), _buffer2(0) {}
+  ~COutBuffer() { Free(); }
+  
+  bool Create(UInt32 bufferSize);
+  void Free();
+
+  void SetMemStream(Byte *buffer) { _buffer2 = buffer; }
+  void SetStream(ISequentialOutStream *stream);
+  void Init();
+  HRESULT Flush();
+  void FlushWithCheck();
+  void ReleaseStream() {  _stream.Release(); }
+
+  void WriteByte(Byte b)
+  {
+    _buffer[_pos++] = b;
+    if(_pos == _limitPos)
+      FlushWithCheck();
+  }
+  void WriteBytes(const void *data, size_t size)
+  {
+    for (size_t i = 0; i < size; i++)
+      WriteByte(((const Byte *)data)[i]);
+  }
+
+  UInt64 GetProcessedSize() const;
+};
+
+#endif

data/ext/p7zip/CPP/7zip/Common/OutMemStream.cpp

@@ -0,0 +1,142 @@
+// OutMemStream.cpp
+
+#include "StdAfx.h"
+
+#include "OutMemStream.h"
+
+void COutMemStream::Free()
+{
+  Blocks.Free(_memManager);
+  Blocks.LockMode = true;
+}
+
+void COutMemStream::Init()
+{
+  WriteToRealStreamEvent.Reset();
+  _unlockEventWasSent = false;
+  _realStreamMode = false;
+  Free();
+  _curBlockPos = 0;
+  _curBlockIndex = 0;
+}
+
+void COutMemStream::DetachData(CMemLockBlocks &blocks)
+{
+  Blocks.Detach(blocks, _memManager);
+  Free();
+}
+
+
+HRESULT COutMemStream::WriteToRealStream()
+{
+  RINOK(Blocks.WriteToStream(_memManager->GetBlockSize(), OutSeqStream));
+  Blocks.Free(_memManager);
+  return S_OK;
+}
+
+STDMETHODIMP COutMemStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
+{
+  if (_realStreamMode)
+    return OutSeqStream->Write(data, size, processedSize);
+  if (processedSize != 0)
+    *processedSize = 0;
+  while(size != 0)
+  {
+    if ((int)_curBlockIndex < Blocks.Blocks.Size())
+    {
+      Byte *p = (Byte *)Blocks.Blocks[(int)_curBlockIndex] + _curBlockPos;
+      size_t curSize = _memManager->GetBlockSize() - _curBlockPos;
+      if (size < curSize)
+        curSize = size;
+      memmove(p, data, curSize);
+      if (processedSize != 0)
+        *processedSize += (UInt32)curSize;
+      data = (const void *)((const Byte *)data + curSize);
+      size -= (UInt32)curSize;
+      _curBlockPos += curSize;
+
+      UInt64 pos64 = GetPos();
+      if (pos64 > Blocks.TotalSize)
+        Blocks.TotalSize = pos64;
+      if (_curBlockPos == _memManager->GetBlockSize())
+      {
+        _curBlockIndex++;
+        _curBlockPos = 0;
+      }
+      continue;
+    }
+    HANDLE events[3] = { StopWritingEvent, WriteToRealStreamEvent, /* NoLockEvent, */ _memManager->Semaphore };
+    DWORD waitResult = ::WaitForMultipleObjects((Blocks.LockMode ? 3 : 2), events, FALSE, INFINITE);
+    switch (waitResult)
+    {
+      case (WAIT_OBJECT_0 + 0):
+        return StopWriteResult;
+      case (WAIT_OBJECT_0 + 1):
+      {
+        _realStreamMode = true;
+        RINOK(WriteToRealStream());
+        UInt32 processedSize2;
+        HRESULT res = OutSeqStream->Write(data, size, &processedSize2);
+        if (processedSize != 0)
+          *processedSize += processedSize2;
+        return res;
+      }
+      /*
+      case (WAIT_OBJECT_0 + 2):
+      {
+        // it has bug: no write.
+        if (!Blocks.SwitchToNoLockMode(_memManager))
+          return E_FAIL;
+        break;
+      }
+      */
+      case (WAIT_OBJECT_0 + 2):
+        break;
+      default:
+        return E_FAIL;
+    }
+    Blocks.Blocks.Add(_memManager->AllocateBlock());
+    if (Blocks.Blocks.Back() == 0)
+      return E_FAIL;
+  }
+  return S_OK;
+}
+
+STDMETHODIMP COutMemStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
+{
+  if (_realStreamMode)
+  {
+    if (!OutStream)
+      return E_FAIL;
+    return OutStream->Seek(offset, seekOrigin, newPosition);
+  }
+  if (seekOrigin == STREAM_SEEK_CUR)
+  {
+    if (offset != 0)
+      return E_NOTIMPL;
+  }
+  else if (seekOrigin == STREAM_SEEK_SET)
+  {
+    if (offset != 0)
+      return E_NOTIMPL;
+    _curBlockIndex = 0;
+    _curBlockPos = 0;
+  }
+  else
+    return E_NOTIMPL;
+  if (newPosition != 0)
+    *newPosition = GetPos();
+  return S_OK;
+}
+
+STDMETHODIMP COutMemStream::SetSize(UInt64 newSize)
+{
+  if (_realStreamMode)
+  {
+    if (!OutStream)
+      return E_FAIL;
+    return OutStream->SetSize(newSize);
+  }
+  Blocks.TotalSize = newSize;
+  return S_OK;
+}

data/ext/p7zip/CPP/7zip/Common/OutMemStream.h

@@ -0,0 +1,96 @@
+// OutMemStream.h
+
+#ifndef __OUTMEMSTREAM_H
+#define __OUTMEMSTREAM_H
+
+#include "Common/MyCom.h"
+#include "MemBlocks.h"
+
+class COutMemStream:
+  public IOutStream,
+  public CMyUnknownImp
+{
+  CMemBlockManagerMt *_memManager;
+  size_t _curBlockIndex;
+  size_t _curBlockPos;
+  bool _realStreamMode;
+
+  bool _unlockEventWasSent;
+  NWindows::NSynchronization::CAutoResetEventWFMO StopWritingEvent;
+  NWindows::NSynchronization::CAutoResetEventWFMO WriteToRealStreamEvent;
+  // NWindows::NSynchronization::CAutoResetEvent NoLockEvent;
+
+  HRESULT StopWriteResult;
+  CMemLockBlocks Blocks;
+
+  UInt64 GetPos() const { return (UInt64)_curBlockIndex * _memManager->GetBlockSize() + _curBlockPos; }
+
+  CMyComPtr<ISequentialOutStream> OutSeqStream;
+  CMyComPtr<IOutStream> OutStream;
+
+public:
+
+  HRes CreateEvents(NWindows::NSynchronization::CSynchro *sync)
+  {
+    RINOK(StopWritingEvent.CreateIfNotCreated(sync));
+    return WriteToRealStreamEvent.CreateIfNotCreated(sync);
+  }
+
+  void SetOutStream(IOutStream *outStream)
+  {
+    OutStream = outStream;
+    OutSeqStream = outStream;
+  }
+
+  void SetSeqOutStream(ISequentialOutStream *outStream)
+  {
+    OutStream = NULL;
+    OutSeqStream = outStream;
+  }
+
+  void ReleaseOutStream()
+  {
+    OutStream.Release();
+    OutSeqStream.Release();
+  }
+
+  COutMemStream(CMemBlockManagerMt *memManager): _memManager(memManager)  { }
+
+  ~COutMemStream() { Free(); }
+  void Free();
+
+  void Init();
+  HRESULT WriteToRealStream();
+
+  void DetachData(CMemLockBlocks &blocks);
+
+  bool WasUnlockEventSent() const { return _unlockEventWasSent; }
+
+  void SetRealStreamMode()
+  {
+    _unlockEventWasSent = true;
+    WriteToRealStreamEvent.Set();
+  }
+
+  /*
+  void SetNoLockMode()
+  {
+    _unlockEventWasSent = true;
+    NoLockEvent.Set();
+  }
+  */
+
+  void StopWriting(HRESULT res)
+  {
+    StopWriteResult = res;
+    StopWritingEvent.Set();
+  }
+
+  MY_UNKNOWN_IMP
+
+  STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
+  STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
+  STDMETHOD(SetSize)(UInt64 newSize);
+};
+
+#endif

data/ext/p7zip/CPP/7zip/Common/ProgressMt.cpp

@@ -0,0 +1,53 @@
+// ProgressMt.h
+
+#include "StdAfx.h"
+
+#include "ProgressMt.h"
+
+void CMtCompressProgressMixer::Init(int numItems, ICompressProgressInfo *progress)
+{
+  NWindows::NSynchronization::CCriticalSectionLock lock(CriticalSection);
+  InSizes.Clear();
+  OutSizes.Clear();
+  for (int i = 0; i < numItems; i++)
+  {
+    InSizes.Add(0);
+    OutSizes.Add(0);
+  }
+  TotalInSize = 0;
+  TotalOutSize = 0;
+  _progress = progress;
+}
+
+void CMtCompressProgressMixer::Reinit(int index)
+{
+  NWindows::NSynchronization::CCriticalSectionLock lock(CriticalSection);
+  InSizes[index] = 0;
+  OutSizes[index] = 0;
+}
+
+HRESULT CMtCompressProgressMixer::SetRatioInfo(int index, const UInt64 *inSize, const UInt64 *outSize)
+{
+  NWindows::NSynchronization::CCriticalSectionLock lock(CriticalSection);
+  if (inSize != 0)
+  {
+    UInt64 diff = *inSize - InSizes[index];
+    InSizes[index] = *inSize;
+    TotalInSize += diff;
+  }
+  if (outSize != 0)
+  {
+    UInt64 diff = *outSize - OutSizes[index];
+    OutSizes[index] = *outSize;
+    TotalOutSize += diff;
+  }
+  if (_progress)
+    return _progress->SetRatioInfo(&TotalInSize, &TotalOutSize);
+  return S_OK;
+}
+
+
+STDMETHODIMP CMtCompressProgress::SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize)
+{
+  return _progress->SetRatioInfo(_index, inSize, outSize);
+}

data/ext/p7zip/CPP/7zip/Common/ProgressMt.h

@@ -0,0 +1,46 @@
+// ProgressMt.h
+
+#ifndef __PROGRESSMT_H
+#define __PROGRESSMT_H
+
+#include "../../Common/MyCom.h"
+#include "../../Common/MyVector.h"
+#include "../../Windows/Synchronization.h"
+
+#include "../ICoder.h"
+#include "../IProgress.h"
+
+class CMtCompressProgressMixer
+{
+  CMyComPtr<ICompressProgressInfo> _progress;
+  CRecordVector<UInt64> InSizes;
+  CRecordVector<UInt64> OutSizes;
+  UInt64 TotalInSize;
+  UInt64 TotalOutSize;
+public:
+  NWindows::NSynchronization::CCriticalSection CriticalSection;
+  void Init(int numItems, ICompressProgressInfo *progress);
+  void Reinit(int index);
+  HRESULT SetRatioInfo(int index, const UInt64 *inSize, const UInt64 *outSize);
+};
+
+class CMtCompressProgress:
+  public ICompressProgressInfo,
+  public CMyUnknownImp
+{
+  CMtCompressProgressMixer *_progress;
+  int _index;
+public:
+  void Init(CMtCompressProgressMixer *progress, int index)
+  {
+    _progress = progress;
+    _index = index;
+  }
+  void Reinit() { _progress->Reinit(_index); }
+
+  MY_UNKNOWN_IMP
+
+  STDMETHOD(SetRatioInfo)(const UInt64 *inSize, const UInt64 *outSize);
+};
+
+#endif

data/ext/p7zip/CPP/7zip/Common/ProgressUtils.cpp

@@ -0,0 +1,42 @@
+// ProgressUtils.h
+
+#include "StdAfx.h"
+
+#include "ProgressUtils.h"
+
+CLocalProgress::CLocalProgress()
+{
+  ProgressOffset = InSize = OutSize = 0;
+  SendRatio = SendProgress = true;
+}
+
+void CLocalProgress::Init(IProgress *progress, bool inSizeIsMain)
+{
+  _ratioProgress.Release();
+  _progress = progress;
+  _progress.QueryInterface(IID_ICompressProgressInfo, &_ratioProgress);
+  _inSizeIsMain = inSizeIsMain;
+}
+
+STDMETHODIMP CLocalProgress::SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize)
+{
+  UInt64 inSizeNew = InSize, outSizeNew = OutSize;
+  if (inSize)
+    inSizeNew += (*inSize);
+  if (outSize)
+    outSizeNew += (*outSize);
+  if (SendRatio && _ratioProgress)
+  {
+    RINOK(_ratioProgress->SetRatioInfo(&inSizeNew, &outSizeNew));
+  }
+  inSizeNew += ProgressOffset;
+  outSizeNew += ProgressOffset;
+  if (SendProgress)
+    return _progress->SetCompleted(_inSizeIsMain ? &inSizeNew : &outSizeNew);
+  return S_OK;
+}
+
+HRESULT CLocalProgress::SetCur()
+{
+  return SetRatioInfo(NULL, NULL);
+}

data/ext/p7zip/CPP/7zip/Common/ProgressUtils.h

@@ -0,0 +1,34 @@
+// ProgressUtils.h
+
+#ifndef __PROGRESSUTILS_H
+#define __PROGRESSUTILS_H
+
+#include "../../Common/MyCom.h"
+
+#include "../ICoder.h"
+#include "../IProgress.h"
+
+class CLocalProgress:
+  public ICompressProgressInfo,
+  public CMyUnknownImp
+{
+  CMyComPtr<IProgress> _progress;
+  CMyComPtr<ICompressProgressInfo> _ratioProgress;
+  bool _inSizeIsMain;
+public:
+  UInt64 ProgressOffset;
+  UInt64 InSize;
+  UInt64 OutSize;
+  bool SendRatio;
+  bool SendProgress;
+
+  CLocalProgress();
+  void Init(IProgress *progress, bool inSizeIsMain);
+  HRESULT SetCur();
+
+  MY_UNKNOWN_IMP
+
+  STDMETHOD(SetRatioInfo)(const UInt64 *inSize, const UInt64 *outSize);
+};
+
+#endif

data/ext/p7zip/CPP/7zip/Common/RegisterArc.h

@@ -0,0 +1,32 @@
+// RegisterArc.h
+
+#ifndef __REGISTER_ARC_H
+#define __REGISTER_ARC_H
+
+#include "../Archive/IArchive.h"
+
+typedef IInArchive * (*CreateInArchiveP)();
+typedef IOutArchive * (*CreateOutArchiveP)();
+
+struct CArcInfo
+{
+  const wchar_t *Name;
+  const wchar_t *Ext;
+  const wchar_t *AddExt;
+  Byte ClassId;
+  Byte Signature[28];  // FIXME Byte Signature[16]; adding 22 bytes to insure kSignature[0x1A]!= 0 and  kSignature[0x1B] != 0
+  int SignatureSize;
+  bool KeepName;
+  CreateInArchiveP CreateInArchive;
+  CreateOutArchiveP CreateOutArchive;
+};
+
+void RegisterArc(const CArcInfo *arcInfo);
+
+#define REGISTER_ARC_NAME(x) CRegister ## x
+
+#define REGISTER_ARC(x) struct REGISTER_ARC_NAME(x) { \
+    REGISTER_ARC_NAME(x)() { RegisterArc(&g_ArcInfo); }}; \
+    static REGISTER_ARC_NAME(x) g_RegisterArc;
+
+#endif

data/ext/p7zip/CPP/7zip/Common/RegisterCodec.h

@@ -0,0 +1,33 @@
+// RegisterCodec.h
+
+#ifndef __REGISTERCODEC_H
+#define __REGISTERCODEC_H
+
+#include "../Common/MethodId.h"
+
+typedef void * (*CreateCodecP)();
+struct CCodecInfo
+{
+  CreateCodecP CreateDecoder;
+  CreateCodecP CreateEncoder;
+  CMethodId Id;
+  const wchar_t *Name;
+  UInt32 NumInStreams;
+  bool IsFilter;
+};
+
+void RegisterCodec(const CCodecInfo *codecInfo);
+
+#define REGISTER_CODEC_NAME(x) CRegisterCodec ## x
+
+#define REGISTER_CODEC(x) struct REGISTER_CODEC_NAME(x) { \
+    REGISTER_CODEC_NAME(x)() { RegisterCodec(&g_CodecInfo); }}; \
+    static REGISTER_CODEC_NAME(x) g_RegisterCodec;
+
+#define REGISTER_CODECS_NAME(x) CRegisterCodecs ## x
+#define REGISTER_CODECS(x) struct REGISTER_CODECS_NAME(x) { \
+    REGISTER_CODECS_NAME(x)() { for (int i = 0; i < sizeof(g_CodecsInfo) / sizeof(g_CodecsInfo[0]); i++) \
+    RegisterCodec(&g_CodecsInfo[i]); }}; \
+    static REGISTER_CODECS_NAME(x) g_RegisterCodecs;
+
+#endif