seven-zip 1.4.0

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

@@ -0,0 +1,125 @@
+// LimitedStreams.h
+
+#ifndef __LIMITED_STREAMS_H
+#define __LIMITED_STREAMS_H
+
+#include "../../Common/MyCom.h"
+#include "../../Common/MyVector.h"
+#include "../IStream.h"
+
+class CLimitedSequentialInStream:
+  public ISequentialInStream,
+  public CMyUnknownImp
+{
+  CMyComPtr<ISequentialInStream> _stream;
+  UInt64 _size;
+  UInt64 _pos;
+  bool _wasFinished;
+public:
+  void SetStream(ISequentialInStream *stream) { _stream = stream; }
+  void ReleaseStream() { _stream.Release(); }
+  void Init(UInt64 streamSize)
+  {
+    _size = streamSize;
+    _pos = 0;
+    _wasFinished = false;
+  }
+ 
+  MY_UNKNOWN_IMP
+
+  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
+  UInt64 GetSize() const { return _pos; }
+  bool WasFinished() const { return _wasFinished; }
+};
+
+class CLimitedInStream:
+  public IInStream,
+  public CMyUnknownImp
+{
+  CMyComPtr<IInStream> _stream;
+  UInt64 _virtPos;
+  UInt64 _physPos;
+  UInt64 _size;
+  UInt64 _startOffset;
+
+  HRESULT SeekToPhys() { return _stream->Seek(_physPos, STREAM_SEEK_SET, NULL); }
+public:
+  void SetStream(IInStream *stream) { _stream = stream; }
+  HRESULT InitAndSeek(UInt64 startOffset, UInt64 size)
+  {
+    _startOffset = startOffset;
+    _physPos = startOffset;
+    _virtPos = 0;
+    _size = size;
+    return SeekToPhys();
+  }
+ 
+  MY_UNKNOWN_IMP1(IInStream)
+
+  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
+  STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
+
+  HRESULT SeekToStart() { return Seek(0, STREAM_SEEK_SET, NULL); }
+};
+
+class CClusterInStream:
+  public IInStream,
+  public CMyUnknownImp
+{
+  UInt64 _virtPos;
+  UInt64 _physPos;
+  UInt32 _curRem;
+public:
+  CMyComPtr<IInStream> Stream;
+  UInt64 StartOffset;
+  UInt64 Size;
+  int BlockSizeLog;
+  CRecordVector<UInt32> Vector;
+
+  HRESULT SeekToPhys() { return Stream->Seek(_physPos, STREAM_SEEK_SET, NULL); }
+
+  HRESULT InitAndSeek()
+  {
+    _curRem = 0;
+    _virtPos = 0;
+    _physPos = StartOffset;
+    if (Vector.Size() > 0)
+    {
+      _physPos = StartOffset + (Vector[0] << BlockSizeLog);
+      return SeekToPhys();
+    }
+    return S_OK;
+  }
+
+  MY_UNKNOWN_IMP1(IInStream)
+
+  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
+  STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
+};
+
+HRESULT CreateLimitedInStream(IInStream *inStream, UInt64 pos, UInt64 size, ISequentialInStream **resStream);
+
+class CLimitedSequentialOutStream:
+  public ISequentialOutStream,
+  public CMyUnknownImp
+{
+  CMyComPtr<ISequentialOutStream> _stream;
+  UInt64 _size;
+  bool _overflow;
+  bool _overflowIsAllowed;
+public:
+  MY_UNKNOWN_IMP
+  STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
+  void SetStream(ISequentialOutStream *stream) { _stream = stream; }
+  void ReleaseStream() { _stream.Release(); }
+  void Init(UInt64 size, bool overflowIsAllowed = false)
+  {
+    _size = size;
+    _overflow = false;
+    _overflowIsAllowed = overflowIsAllowed;
+  }
+  bool IsFinishedOK() const { return (_size == 0 && !_overflow); }
+  UInt64 GetRem() const { return _size; }
+};
+
+#endif

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

@@ -0,0 +1,23 @@
+// LockedStream.cpp
+
+#include "StdAfx.h"
+
+#include "LockedStream.h"
+
+HRESULT CLockedInStream::Read(UInt64 startPos, void *data, UInt32 size,
+  UInt32 *processedSize)
+{
+  NWindows::NSynchronization::CCriticalSectionLock lock(_criticalSection);
+  RINOK(_stream->Seek(startPos, STREAM_SEEK_SET, NULL));
+  return _stream->Read(data, size, processedSize);
+}
+
+STDMETHODIMP CLockedSequentialInStreamImp::Read(void *data, UInt32 size, UInt32 *processedSize)
+{
+  UInt32 realProcessedSize = 0;
+  HRESULT result = _lockedInStream->Read(_pos, data, size, &realProcessedSize);
+  _pos += realProcessedSize;
+  if (processedSize != NULL)
+    *processedSize = realProcessedSize;
+  return result;
+}

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

@@ -0,0 +1,38 @@
+// LockedStream.h
+
+#ifndef __LOCKEDSTREAM_H
+#define __LOCKEDSTREAM_H
+
+#include "../../Windows/Synchronization.h"
+#include "../../Common/MyCom.h"
+#include "../IStream.h"
+
+class CLockedInStream
+{
+  CMyComPtr<IInStream> _stream;
+  NWindows::NSynchronization::CCriticalSection _criticalSection;
+public:
+  void Init(IInStream *stream)
+    { _stream = stream; }
+  HRESULT Read(UInt64 startPos, void *data, UInt32 size, UInt32 *processedSize);
+};
+
+class CLockedSequentialInStreamImp:
+  public ISequentialInStream,
+  public CMyUnknownImp
+{
+  CLockedInStream *_lockedInStream;
+  UInt64 _pos;
+public:
+  void Init(CLockedInStream *lockedInStream, UInt64 startPos)
+  {
+    _lockedInStream = lockedInStream;
+    _pos = startPos;
+  }
+
+  MY_UNKNOWN_IMP
+
+  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
+};
+
+#endif

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

@@ -0,0 +1,183 @@
+// MemBlocks.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/Alloc.h"
+
+#include "MemBlocks.h"
+#include "StreamUtils.h"
+
+bool CMemBlockManager::AllocateSpace(size_t numBlocks)
+{
+  FreeSpace();
+  if (_blockSize < sizeof(void *) || numBlocks < 1)
+    return false;
+  size_t totalSize = numBlocks * _blockSize;
+  if (totalSize / _blockSize != numBlocks)
+    return false;
+  _data = ::MidAlloc(totalSize);
+  if (_data == 0)
+    return false;
+  Byte *p = (Byte *)_data;
+  for (size_t i = 0; i + 1 < numBlocks; i++, p += _blockSize)
+    *(Byte **)p = (p + _blockSize);
+  *(Byte **)p = 0;
+  _headFree = _data;
+  return true;
+}
+
+void CMemBlockManager::FreeSpace()
+{
+  ::MidFree(_data);
+  _data = 0;
+  _headFree= 0;
+}
+
+void *CMemBlockManager::AllocateBlock()
+{
+  if (_headFree == 0)
+    return 0;
+  void *p = _headFree;
+  _headFree = *(void **)_headFree;
+  return p;
+}
+
+void CMemBlockManager::FreeBlock(void *p)
+{
+  if (p == 0)
+    return;
+  *(void **)p = _headFree;
+  _headFree = p;
+}
+
+
+HRes CMemBlockManagerMt::AllocateSpace(NWindows::NSynchronization::CSynchro *sync,size_t numBlocks, size_t numNoLockBlocks)
+{
+  if (numNoLockBlocks > numBlocks)
+    return E_INVALIDARG;
+  if (!CMemBlockManager::AllocateSpace(numBlocks))
+    return E_OUTOFMEMORY;
+  size_t numLockBlocks = numBlocks - numNoLockBlocks;
+  Semaphore.Close();
+  return Semaphore.Create(sync,(LONG)numLockBlocks, (LONG)numLockBlocks);
+}
+
+HRes CMemBlockManagerMt::AllocateSpaceAlways(NWindows::NSynchronization::CSynchro *sync,size_t desiredNumberOfBlocks, size_t numNoLockBlocks)
+{
+  if (numNoLockBlocks > desiredNumberOfBlocks)
+    return E_INVALIDARG;
+  for (;;)
+  {
+    if (AllocateSpace(sync,desiredNumberOfBlocks, numNoLockBlocks) == 0)
+      return 0;
+    if (desiredNumberOfBlocks == numNoLockBlocks)
+      return E_OUTOFMEMORY;
+    desiredNumberOfBlocks = numNoLockBlocks + ((desiredNumberOfBlocks - numNoLockBlocks) >> 1);
+  }
+}
+
+void CMemBlockManagerMt::FreeSpace()
+{
+  Semaphore.Close();
+  CMemBlockManager::FreeSpace();
+}
+
+void *CMemBlockManagerMt::AllocateBlock()
+{
+  // Semaphore.Lock();
+  NWindows::NSynchronization::CCriticalSectionLock lock(_criticalSection);
+  return CMemBlockManager::AllocateBlock();
+}
+
+void CMemBlockManagerMt::FreeBlock(void *p, bool lockMode)
+{
+  if (p == 0)
+    return;
+  {
+    NWindows::NSynchronization::CCriticalSectionLock lock(_criticalSection);
+    CMemBlockManager::FreeBlock(p);
+  }
+  if (lockMode)
+    Semaphore.Release();
+}
+
+void CMemBlocks::Free(CMemBlockManagerMt *manager)
+{
+  while(Blocks.Size() > 0)
+  {
+    manager->FreeBlock(Blocks.Back());
+    Blocks.DeleteBack();
+  }
+  TotalSize = 0;
+}
+
+void CMemBlocks::FreeOpt(CMemBlockManagerMt *manager)
+{
+  Free(manager);
+  Blocks.ClearAndFree();
+}
+
+HRESULT CMemBlocks::WriteToStream(size_t blockSize, ISequentialOutStream *outStream) const
+{
+  UInt64 totalSize = TotalSize;
+  for (int blockIndex = 0; totalSize > 0; blockIndex++)
+  {
+    UInt32 curSize = (UInt32)blockSize;
+    if (totalSize < curSize)
+      curSize = (UInt32)totalSize;
+    if (blockIndex >= Blocks.Size())
+      return E_FAIL;
+    RINOK(WriteStream(outStream, Blocks[blockIndex], curSize));
+    totalSize -= curSize;
+  }
+  return S_OK;
+}
+
+
+void CMemLockBlocks::FreeBlock(int index, CMemBlockManagerMt *memManager)
+{
+  memManager->FreeBlock(Blocks[index], LockMode);
+  Blocks[index] = 0;
+}
+
+void CMemLockBlocks::Free(CMemBlockManagerMt *memManager)
+{
+  while (Blocks.Size() > 0)
+  {
+    FreeBlock(Blocks.Size() - 1, memManager);
+    Blocks.DeleteBack();
+  }
+  TotalSize = 0;
+}
+
+HRes CMemLockBlocks::SwitchToNoLockMode(CMemBlockManagerMt *memManager)
+{
+  if (LockMode)
+  {
+    if (Blocks.Size() > 0)
+    {
+      RINOK(memManager->ReleaseLockedBlocks(Blocks.Size()));
+    }
+    LockMode = false;
+  }
+  return 0;
+}
+
+void CMemLockBlocks::Detach(CMemLockBlocks &blocks, CMemBlockManagerMt *memManager)
+{
+  blocks.Free(memManager);
+  blocks.LockMode = LockMode;
+  UInt64 totalSize = 0;
+  size_t blockSize = memManager->GetBlockSize();
+  for (int i = 0; i < Blocks.Size(); i++)
+  {
+    if (totalSize < TotalSize)
+      blocks.Blocks.Add(Blocks[i]);
+    else
+      FreeBlock(i, memManager);
+    Blocks[i] = 0;
+    totalSize += blockSize;
+  }
+  blocks.TotalSize = TotalSize;
+  Free(memManager);
+}

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

@@ -0,0 +1,71 @@
+// MemBlocks.h
+
+#ifndef __MEM_BLOCKS_H
+#define __MEM_BLOCKS_H
+
+#include "Common/MyVector.h"
+
+#include "Windows/Synchronization.h"
+
+#include "../IStream.h"
+
+class CMemBlockManager
+{
+  void *_data;
+  size_t _blockSize;
+  void *_headFree;
+public:
+  CMemBlockManager(size_t blockSize = (1 << 20)): _data(0), _blockSize(blockSize), _headFree(0) {}
+  ~CMemBlockManager() { FreeSpace(); }
+
+  bool AllocateSpace(size_t numBlocks);
+  void FreeSpace();
+  size_t GetBlockSize() const { return _blockSize; }
+  void *AllocateBlock();
+  void FreeBlock(void *p);
+};
+
+
+class CMemBlockManagerMt: public CMemBlockManager
+{
+  NWindows::NSynchronization::CCriticalSection _criticalSection;
+public:
+  NWindows::NSynchronization::CSemaphoreWFMO Semaphore;
+
+  CMemBlockManagerMt(size_t blockSize = (1 << 20)): CMemBlockManager(blockSize) {}
+  ~CMemBlockManagerMt() { FreeSpace(); }
+
+  HRes AllocateSpace(NWindows::NSynchronization::CSynchro *sync, size_t numBlocks, size_t numNoLockBlocks = 0);
+  HRes AllocateSpaceAlways(NWindows::NSynchronization::CSynchro *sync, size_t desiredNumberOfBlocks, size_t numNoLockBlocks = 0);
+  void FreeSpace();
+  void *AllocateBlock();
+  void FreeBlock(void *p, bool lockMode = true);
+  HRes ReleaseLockedBlocks(int number) { return Semaphore.Release(number); }
+};
+
+
+class CMemBlocks
+{
+  void Free(CMemBlockManagerMt *manager);
+public:
+  CRecordVector<void *> Blocks;
+  UInt64 TotalSize;
+  
+  CMemBlocks(): TotalSize(0) {}
+
+  void FreeOpt(CMemBlockManagerMt *manager);
+  HRESULT WriteToStream(size_t blockSize, ISequentialOutStream *outStream) const;
+};
+
+struct CMemLockBlocks: public CMemBlocks
+{
+  bool LockMode;
+
+  CMemLockBlocks(): LockMode(true) {};
+  void Free(CMemBlockManagerMt *memManager);
+  void FreeBlock(int index, CMemBlockManagerMt *memManager);
+  HRes SwitchToNoLockMode(CMemBlockManagerMt *memManager);
+  void Detach(CMemLockBlocks &blocks, CMemBlockManagerMt *memManager);
+};
+
+#endif

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

@@ -0,0 +1,27 @@
+// MethodId.cpp
+
+#include "StdAfx.h"
+
+#include "MethodId.h"
+#include "../../Common/MyString.h"
+
+static inline wchar_t GetHex(Byte value)
+{
+  return (wchar_t)((value < 10) ? ('0' + value) : ('A' + (value - 10)));
+}
+
+UString ConvertMethodIdToString(UInt64 id)
+{
+  wchar_t s[32];
+  int len = 32;
+  s[--len] = 0;
+  do
+  {
+    s[--len] = GetHex((Byte)id & 0xF);
+    id >>= 4;
+    s[--len] = GetHex((Byte)id & 0xF);
+    id >>= 4;
+  }
+  while (id != 0);
+  return s + len;
+}

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

@@ -0,0 +1,10 @@
+// MethodId.h
+
+#ifndef __7Z_METHOD_ID_H
+#define __7Z_METHOD_ID_H
+
+#include "../../Common/Types.h"
+
+typedef UInt64 CMethodId;
+
+#endif

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

@@ -0,0 +1,99 @@
+// MethodProps.cpp
+
+#include "StdAfx.h"
+
+#include "../../Common/MyCom.h"
+
+#include "../ICoder.h"
+
+#include "MethodProps.h"
+
+static const UInt64 k_LZMA = 0x030101;
+static const UInt64 k_LZMA2 = 0x21;
+
+HRESULT SetMethodProperties(const CMethod &method, const UInt64 *inSizeForReduce, IUnknown *coder)
+{
+  bool tryReduce = false;
+  UInt32 reducedDictionarySize = 1 << 10;
+  if (inSizeForReduce != 0 && (method.Id == k_LZMA || method.Id == k_LZMA2))
+  {
+    for (;;)
+    {
+      const UInt32 step = (reducedDictionarySize >> 1);
+      if (reducedDictionarySize >= *inSizeForReduce)
+      {
+        tryReduce = true;
+        break;
+      }
+      reducedDictionarySize += step;
+      if (reducedDictionarySize >= *inSizeForReduce)
+      {
+        tryReduce = true;
+        break;
+      }
+      if (reducedDictionarySize >= ((UInt32)3 << 30))
+        break;
+      reducedDictionarySize += step;
+    }
+  }
+
+  {
+    int numProps = method.Props.Size();
+    CMyComPtr<ICompressSetCoderProperties> setCoderProperties;
+    coder->QueryInterface(IID_ICompressSetCoderProperties, (void **)&setCoderProperties);
+    if (setCoderProperties == NULL)
+    {
+      if (numProps != 0)
+        return E_INVALIDARG;
+    }
+    else
+    {
+      CRecordVector<PROPID> propIDs;
+      NWindows::NCOM::CPropVariant *values = new NWindows::NCOM::CPropVariant[numProps];
+      HRESULT res = S_OK;
+      try
+      {
+        for (int i = 0; i < numProps; i++)
+        {
+          const CProp &prop = method.Props[i];
+          propIDs.Add(prop.Id);
+          NWindows::NCOM::CPropVariant &value = values[i];
+          value = prop.Value;
+          // if (tryReduce && prop.Id == NCoderPropID::kDictionarySize && value.vt == VT_UI4 && reducedDictionarySize < value.ulVal)
+          if (tryReduce)
+            if (prop.Id == NCoderPropID::kDictionarySize)
+              if (value.vt == VT_UI4)
+                if (reducedDictionarySize < value.ulVal)
+            value.ulVal = reducedDictionarySize;
+        }
+        CMyComPtr<ICompressSetCoderProperties> setCoderProperties;
+        coder->QueryInterface(IID_ICompressSetCoderProperties, (void **)&setCoderProperties);
+        res = setCoderProperties->SetCoderProperties(&propIDs.Front(), values, numProps);
+      }
+      catch(...)
+      {
+        delete []values;
+        throw;
+      }
+      delete []values;
+      RINOK(res);
+    }
+  }
+ 
+  /*
+  CMyComPtr<ICompressWriteCoderProperties> writeCoderProperties;
+  coder->QueryInterface(IID_ICompressWriteCoderProperties, (void **)&writeCoderProperties);
+  if (writeCoderProperties != NULL)
+  {
+    CSequentialOutStreamImp *outStreamSpec = new CSequentialOutStreamImp;
+    CMyComPtr<ISequentialOutStream> outStream(outStreamSpec);
+    outStreamSpec->Init();
+    RINOK(writeCoderProperties->WriteCoderProperties(outStream));
+    size_t size = outStreamSpec->GetSize();
+    filterProps.SetCapacity(size);
+    memmove(filterProps, outStreamSpec->GetBuffer(), size);
+  }
+  */
+  return S_OK;
+}
+

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

@@ -0,0 +1,41 @@
+// MethodProps.h
+
+#ifndef __7Z_METHOD_PROPS_H
+#define __7Z_METHOD_PROPS_H
+
+#include "../../Common/MyVector.h"
+
+#include "../../Windows/PropVariant.h"
+
+#include "MethodId.h"
+
+struct CProp
+{
+  PROPID Id;
+  NWindows::NCOM::CPropVariant Value;
+};
+
+struct CMethod
+{
+  CMethodId Id;
+  CObjectVector<CProp> Props;
+};
+
+struct CMethodsMode
+{
+  CObjectVector<CMethod> Methods;
+  #ifndef _7ZIP_ST
+  UInt32 NumThreads;
+  #endif
+
+  CMethodsMode()
+      #ifndef _7ZIP_ST
+      : NumThreads(1)
+      #endif
+  {}
+  bool IsEmpty() const { return Methods.IsEmpty() ; }
+};
+
+HRESULT SetMethodProperties(const CMethod &method, const UInt64 *inSizeForReduce, IUnknown *coder);
+
+#endif

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

@@ -0,0 +1,35 @@
+// OffsetStream.cpp
+
+#include "StdAfx.h"
+
+#include "Common/Defs.h"
+#include "OffsetStream.h"
+
+HRESULT COffsetOutStream::Init(IOutStream *stream, UInt64 offset)
+{
+  _offset = offset;
+  _stream = stream;
+  return _stream->Seek(offset, STREAM_SEEK_SET, NULL);
+}
+
+STDMETHODIMP COffsetOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
+{
+  return _stream->Write(data, size, processedSize);
+}
+
+STDMETHODIMP COffsetOutStream::Seek(Int64 offset, UInt32 seekOrigin,
+    UInt64 *newPosition)
+{
+  UInt64 absoluteNewPosition;
+  if (seekOrigin == STREAM_SEEK_SET)
+    offset += _offset;
+  HRESULT result = _stream->Seek(offset, seekOrigin, &absoluteNewPosition);
+  if (newPosition != NULL)
+    *newPosition = absoluteNewPosition - _offset;
+  return result;
+}
+
+STDMETHODIMP COffsetOutStream::SetSize(UInt64 newSize)
+{
+  return _stream->SetSize(_offset + newSize);
+}

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

@@ -0,0 +1,25 @@
+// OffsetStream.h
+
+#ifndef __OFFSETSTREAM_H
+#define __OFFSETSTREAM_H
+
+#include "Common/MyCom.h"
+#include "../IStream.h"
+
+class COffsetOutStream:
+  public IOutStream,
+  public CMyUnknownImp
+{
+  UInt64 _offset;
+  CMyComPtr<IOutStream> _stream;
+public:
+  HRESULT Init(IOutStream *stream, UInt64 offset);
+  
+  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