9.18

CPP/7zip/Common/LimitedStreams.h

@@ -17,6 +17,7 @@ class CLimitedSequentialInStream:
   bool _wasFinished;
 public:
   void SetStream(ISequentialInStream *stream) { _stream = stream; }
+  void ReleaseStream() { _stream.Release(); }
   void Init(UInt64 streamSize)
   {
     _size = streamSize;

CPP/7zip/Common/StreamObjects.cpp

@@ -2,20 +2,24 @@
 
 #include "StdAfx.h"
 
+#include "../../../C/Alloc.h"
+
 #include "StreamObjects.h"
 
 STDMETHODIMP CBufInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
 {
-  if (processedSize != NULL)
+  if (processedSize)
     *processedSize = 0;
+  if (size == 0)
+    return S_OK;
   if (_pos > _size)
     return E_FAIL;
   size_t rem = _size - (size_t)_pos;
-  if (size < rem)
+  if (rem > size)
     rem = (size_t)size;
   memcpy(data, _data + (size_t)_pos, rem);
   _pos += rem;
-  if (processedSize != NULL)
+  if (processedSize)
     *processedSize = (UInt32)rem;
   return S_OK;
 }
@@ -34,43 +38,75 @@ STDMETHODIMP CBufInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosi
   return S_OK;
 }
 
-
-void CWriteBuffer::Write(const void *data, size_t size)
+void CByteDynBuffer::Free()
 {
-  size_t newCapacity = _size + size;
-  _buffer.EnsureCapacity(newCapacity);
-  memcpy(_buffer + _size, data, size);
-  _size += size;
+  free(_buf);
+  _buf = 0;
+  _capacity = 0;
 }
 
-STDMETHODIMP CSequentialOutStreamImp::Write(const void *data, UInt32 size, UInt32 *processedSize)
+bool CByteDynBuffer::EnsureCapacity(size_t cap)
 {
-  _writeBuffer.Write(data, (size_t)size);
-  if(processedSize != NULL)
+  if (cap <= _capacity)
+    return true;
+  size_t delta;
+  if (_capacity > 64)
+    delta = _capacity / 4;
+  else if (_capacity > 8)
+    delta = 16;
+  else
+    delta = 4;
+  cap = MyMax(_capacity + delta, cap);
+  Byte *buf = (Byte *)realloc(_buf, cap);
+  if (!buf)
+    return false;
+  _buf = buf;
+  _capacity = cap;
+  return true;
+}
+
+Byte *CDynBufSeqOutStream::GetBufPtrForWriting(size_t addSize)
+{
+  addSize += _size;
+  if (addSize < _size)
+    return NULL;
+  if (!_buffer.EnsureCapacity(addSize))
+    return NULL;
+  return (Byte *)_buffer + _size;
+}
+
+void CDynBufSeqOutStream::CopyToBuffer(CByteBuffer &dest) const
+{
+  dest.SetCapacity(_size);
+  memcpy(dest, _buffer, _size);
+}
+
+STDMETHODIMP CDynBufSeqOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
+{
+  if (processedSize)
+    *processedSize = 0;
+  if (size == 0)
+    return S_OK;
+  Byte *buf = GetBufPtrForWriting(size);
+  if (!buf)
+    return E_OUTOFMEMORY;
+  memcpy(buf, data, size);
+  UpdateSize(size);
+  if (processedSize)
     *processedSize = size;
   return S_OK;
 }
 
-STDMETHODIMP CSequentialOutStreamImp2::Write(const void *data, UInt32 size, UInt32 *processedSize)
+STDMETHODIMP CBufPtrSeqOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
 {
   size_t rem = _size - _pos;
-  if (size < rem)
+  if (rem > size)
     rem = (size_t)size;
   memcpy(_buffer + _pos, data, rem);
   _pos += rem;
-  if (processedSize != NULL)
+  if (processedSize)
     *processedSize = (UInt32)rem;
-  return (rem == size ? S_OK : E_FAIL);
-}
-
-STDMETHODIMP CSequentialInStreamSizeCount::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
-  UInt32 realProcessedSize;
-  HRESULT result = _stream->Read(data, size, &realProcessedSize);
-  _size += realProcessedSize;
-  if (processedSize != 0)
-    *processedSize = realProcessedSize;
-  return result;
+  return (rem != 0 || size == 0) ? S_OK : E_FAIL;
 }
 
 STDMETHODIMP CSequentialOutStreamSizeCount::Write(const void *data, UInt32 size, UInt32 *processedSize)
@@ -78,7 +114,108 @@ STDMETHODIMP CSequentialOutStreamSizeCount::Write(const void *data, UInt32 size,
   UInt32 realProcessedSize;
   HRESULT result = _stream->Write(data, size, &realProcessedSize);
   _size += realProcessedSize;
-  if (processedSize != 0)
+  if (processedSize)
     *processedSize = realProcessedSize;
   return result;
 }
+
+static const UInt64 kEmptyTag = (UInt64)(Int64)-1;
+
+void CCachedInStream::Free()
+{
+  MyFree(_tags);
+  _tags = 0;
+  MidFree(_data);
+  _data = 0;
+}
+
+bool CCachedInStream::Alloc(unsigned blockSizeLog, unsigned numBlocksLog)
+{
+  unsigned sizeLog = blockSizeLog + numBlocksLog;
+  if (sizeLog >= sizeof(size_t) * 8)
+    return false;
+  size_t dataSize = (size_t)1 << sizeLog;
+  if (_data == 0 || dataSize != _dataSize)
+  {
+    MidFree(_data);
+    _data = (Byte *)MidAlloc(dataSize);
+    if (_data == 0)
+      return false;
+    _dataSize = dataSize;
+  }
+  if (_tags == 0 || numBlocksLog != _numBlocksLog)
+  {
+    MyFree(_tags);
+    _tags = (UInt64 *)MyAlloc(sizeof(UInt64) << numBlocksLog);
+    if (_tags == 0)
+      return false;
+    _numBlocksLog = numBlocksLog;
+  }
+  _blockSizeLog = blockSizeLog;
+  return true;
+}
+
+void CCachedInStream::Init(UInt64 size)
+{
+  _size = size;
+  _pos = 0;
+  size_t numBlocks = (size_t)1 << _numBlocksLog;
+  for (size_t i = 0; i < numBlocks; i++)
+    _tags[i] = kEmptyTag;
+}
+
+STDMETHODIMP CCachedInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
+{
+  if (processedSize)
+    *processedSize = 0;
+  if (size == 0)
+    return S_OK;
+  if (_pos > _size)
+    return E_FAIL;
+
+  {
+    UInt64 rem = _size - _pos;
+    if (size > rem)
+      size = (UInt32)rem;
+  }
+
+  while (size != 0)
+  {
+    UInt64 cacheTag = _pos >> _blockSizeLog;
+    size_t cacheIndex = (size_t)cacheTag & (((size_t)1 << _numBlocksLog) - 1);
+    Byte *p = _data + (cacheIndex << _blockSizeLog);
+    if (_tags[cacheIndex] != cacheTag)
+    {
+      UInt64 remInBlock = _size - (cacheTag << _blockSizeLog);
+      size_t blockSize = (size_t)1 << _blockSizeLog;
+      if (blockSize > remInBlock)
+        blockSize = (size_t)remInBlock;
+      RINOK(ReadBlock(cacheTag, p, blockSize));
+      _tags[cacheIndex] = cacheTag;
+    }
+    size_t offset = (size_t)_pos & (((size_t)1 << _blockSizeLog) - 1);
+    UInt32 cur = (UInt32)MyMin(((size_t)1 << _blockSizeLog) - offset, (size_t)size);
+    memcpy(data, p + offset, cur);
+    if (processedSize)
+      *processedSize += cur;
+    data = (void *)((const Byte *)data + cur);
+    _pos += cur;
+    size -= cur;
+  }
+
+  return S_OK;
+}
+ 
+STDMETHODIMP CCachedInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
+{
+  switch(seekOrigin)
+  {
+    case STREAM_SEEK_SET: _pos = offset; break;
+    case STREAM_SEEK_CUR: _pos = _pos + offset; break;
+    case STREAM_SEEK_END: _pos = _size + offset; break;
+    default: return STG_E_INVALIDFUNCTION;
+  }
+  if (newPosition != 0)
+    *newPosition = _pos;
+  return S_OK;
+}

CPP/7zip/Common/StreamObjects.h

@@ -3,7 +3,7 @@
 #ifndef __STREAM_OBJECTS_H
 #define __STREAM_OBJECTS_H
 
-#include "../../Common/DynamicBuffer.h"
+#include "../../Common/Buffer.h"
 #include "../../Common/MyCom.h"
 #include "../IStream.h"
 
@@ -34,39 +34,45 @@ public:
   void Init(CReferenceBuf *ref) { Init(ref->Buf, ref->Buf.GetCapacity(), ref); }
 
   MY_UNKNOWN_IMP1(IInStream)
-
   STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
   STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
 };
 
-class CWriteBuffer
+class CByteDynBuffer
 {
-  CByteDynamicBuffer _buffer;
-  size_t _size;
+  size_t _capacity;
+  Byte *_buf;
 public:
-  CWriteBuffer(): _size(0) {}
-  void Init() { _size = 0;  }
-  void Write(const void *data, size_t size);
-  size_t GetSize() const { return _size; }
-  const CByteDynamicBuffer& GetBuffer() const { return _buffer; }
+  CByteDynBuffer(): _capacity(0), _buf(0) {};
+  // there is no copy constructor. So don't copy this object.
+  ~CByteDynBuffer() { Free(); }
+  void Free();
+  size_t GetCapacity() const { return  _capacity; }
+  operator Byte*() const { return _buf; };
+  operator const Byte*() const { return _buf; };
+  bool EnsureCapacity(size_t capacity);
 };
 
-class CSequentialOutStreamImp:
+class CDynBufSeqOutStream:
   public ISequentialOutStream,
   public CMyUnknownImp
 {
-  CWriteBuffer _writeBuffer;
+  CByteDynBuffer _buffer;
+  size_t _size;
 public:
-  void Init() { _writeBuffer.Init(); }
-  size_t GetSize() const { return _writeBuffer.GetSize(); }
-  const CByteDynamicBuffer& GetBuffer() const { return _writeBuffer.GetBuffer(); }
+  CDynBufSeqOutStream(): _size(0) {}
+  void Init() { _size = 0;  }
+  size_t GetSize() const { return _size; }
+  const Byte *GetBuffer() const { return _buffer; }
+  void CopyToBuffer(CByteBuffer &dest) const;
+  Byte *GetBufPtrForWriting(size_t addSize);
+  void UpdateSize(size_t addSize) { _size += addSize; }
 
   MY_UNKNOWN_IMP
-
   STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
 };
 
-class CSequentialOutStreamImp2:
+class CBufPtrSeqOutStream:
   public ISequentialOutStream,
   public CMyUnknownImp
 {
@@ -74,40 +80,18 @@ class CSequentialOutStreamImp2:
   size_t _size;
   size_t _pos;
 public:
-
   void Init(Byte *buffer, size_t size)
   {
     _buffer = buffer;
     _pos = 0;
     _size = size;
   }
-
   size_t GetPos() const { return _pos; }
 
   MY_UNKNOWN_IMP
-
   STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
 };
 
-class CSequentialInStreamSizeCount:
-  public ISequentialInStream,
-  public CMyUnknownImp
-{
-  CMyComPtr<ISequentialInStream> _stream;
-  UInt64 _size;
-public:
-  void Init(ISequentialInStream *stream)
-  {
-    _stream = stream;
-    _size = 0;
-  }
-  UInt64 GetSize() const { return _size; }
-
-  MY_UNKNOWN_IMP
-
-  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
-};
-
 class CSequentialOutStreamSizeCount:
   public ISequentialOutStream,
   public CMyUnknownImp
@@ -120,8 +104,32 @@ public:
   UInt64 GetSize() const { return _size; }
 
   MY_UNKNOWN_IMP
-
   STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
 };
 
+class CCachedInStream:
+  public IInStream,
+  public CMyUnknownImp
+{
+  UInt64 *_tags;
+  Byte *_data;
+  size_t _dataSize;
+  unsigned _blockSizeLog;
+  unsigned _numBlocksLog;
+  UInt64 _size;
+  UInt64 _pos;
+protected:
+  virtual HRESULT ReadBlock(UInt64 blockIndex, Byte *dest, size_t blockSize) = 0;
+public:
+  CCachedInStream(): _tags(0), _data(0) {}
+  virtual ~CCachedInStream() { Free(); } // the destructor must be virtual (release calls it) !!!
+  void Free();
+  bool Alloc(unsigned blockSizeLog, unsigned numBlocksLog);
+  void Init(UInt64 size);
+
+  MY_UNKNOWN_IMP2(ISequentialInStream, IInStream)
+  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
+  STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
+};
+
 #endif