4.49 beta

CPP/7zip/Archive/Common/CoderMixerMT.cpp

@@ -45,11 +45,11 @@ STDMETHODIMP CCoderMixerMT::Code(ISequentialInStream *inStream,
       RINOK(_coders[i].Create());
     }
 
-  while (_streamBinders.Size() + 1 < _coders.Size())
+  _streamBinders.Clear();
+  for (i = 0; i + 1 < _coders.Size(); i++)
   {
     _streamBinders.Add(CStreamBinder());
-    int i = _streamBinders.Size() - 1;
-    CStreamBinder &sb = _streamBinders.Back();
+    CStreamBinder &sb = _streamBinders[i];
     RINOK(sb.CreateEvents());
     sb.CreateStreams(&_coders[i + 1].InStream, &_coders[i].OutStream);
   }

CPP/7zip/Archive/Common/CoderMixerMT.h

@@ -3,7 +3,7 @@
 #ifndef __CODER_MIXER_MT_H
 #define __CODER_MIXER_MT_H
 
-#include "../../../Common/Vector.h"
+#include "../../../Common/MyVector.h"
 #include "../../../Common/MyCom.h"
 #include "../../ICoder.h"
 #include "../../Common/StreamBinder.h"

CPP/7zip/Archive/Common/OutStreamWithCRC.cpp

@@ -4,7 +4,7 @@
 
 #include "OutStreamWithCRC.h"
 
-STDMETHODIMP COutStreamWithCRC::Write(const void *data,  UInt32 size, UInt32 *processedSize)
+STDMETHODIMP COutStreamWithCRC::Write(const void *data, UInt32 size, UInt32 *processedSize)
 {
   UInt32 realProcessedSize;
   HRESULT result;
@@ -15,7 +15,7 @@ STDMETHODIMP COutStreamWithCRC::Write(const void *data,  UInt32 size, UInt32 *pr
   }
   else
     result = _stream->Write(data, size, &realProcessedSize);
-  if (_calculateCrc)
+  if (_calculate)
     _crc = CrcUpdate(_crc, data, realProcessedSize);
   _size += realProcessedSize;
   if(processedSize != NULL)

CPP/7zip/Archive/Common/OutStreamWithCRC.h

@@ -15,27 +15,24 @@ class COutStreamWithCRC:
   public ISequentialOutStream,
   public CMyUnknownImp
 {
-public:
-  MY_UNKNOWN_IMP
-
-  STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
-private:
   CMyComPtr<ISequentialOutStream> _stream;
   UInt64 _size;
   UInt32 _crc;
-  bool _calculateCrc;
+  bool _calculate;
 public:
+  MY_UNKNOWN_IMP
+  STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
   void SetStream(ISequentialOutStream *stream) { _stream = stream; }
-  void Init(bool calculateCrc = true)
+  void ReleaseStream() { _stream.Release(); }
+  void Init(bool calculate = true)
   {
     _size = 0;
-    _calculateCrc = calculateCrc;
+    _calculate = calculate;
     _crc = CRC_INIT_VAL;
   }
-  void ReleaseStream() { _stream.Release(); }
+  void InitCRC() { _crc = CRC_INIT_VAL; }
   UInt64 GetSize() const { return _size; }
   UInt32 GetCRC() const { return CRC_GET_DIGEST(_crc); }
-  void InitCRC() { _crc = CRC_INIT_VAL; }
 };
 
 #endif

CPP/7zip/Archive/Common/OutStreamWithSha1.cpp

@@ -0,0 +1,24 @@
+// OutStreamWithSha1.cpp
+
+#include "StdAfx.h"
+
+#include "OutStreamWithSha1.h"
+
+STDMETHODIMP COutStreamWithSha1::Write(const void *data, UInt32 size, UInt32 *processedSize)
+{
+  UInt32 realProcessedSize;
+  HRESULT result;
+  if(!_stream)
+  {
+    realProcessedSize = size;
+    result = S_OK;
+  }
+  else
+    result = _stream->Write(data, size, &realProcessedSize);
+  if (_calculate)
+    _sha.Update((const Byte *)data, realProcessedSize);
+  _size += realProcessedSize;
+  if(processedSize != NULL)
+    *processedSize = realProcessedSize;
+  return result;
+}

CPP/7zip/Archive/Common/OutStreamWithSha1.h

@@ -0,0 +1,38 @@
+// OutStreamWithSha1.h
+
+#ifndef __OUTSTREAMWITHSHA1_H
+#define __OUTSTREAMWITHSHA1_H
+
+#include "../../../Common/MyCom.h"
+#include "../../IStream.h"
+
+
+
+#include "../../Crypto/Hash/Sha1.h"
+
+
+class COutStreamWithSha1: 
+  public ISequentialOutStream,
+  public CMyUnknownImp
+{
+  CMyComPtr<ISequentialOutStream> _stream;
+  UInt64 _size;
+  NCrypto::NSha1::CContext _sha;
+  bool _calculate;
+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(bool calculate = true)
+  {
+    _size = 0;
+    _calculate = calculate;
+    _sha.Init();
+  }
+  void InitSha1() { _sha.Init(); }
+  UInt64 GetSize() const { return _size; }
+  void Final(Byte *digest) { _sha.Final(digest); }
+};
+
+#endif