summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/lzma/CPP/7zip/Archive/7z/7zFolderInStream.cpp
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/lzma/CPP/7zip/Archive/7z/7zFolderInStream.cpp')
-rw-r--r--3rdparty/lzma/CPP/7zip/Archive/7z/7zFolderInStream.cpp224
1 files changed, 176 insertions, 48 deletions
diff --git a/3rdparty/lzma/CPP/7zip/Archive/7z/7zFolderInStream.cpp b/3rdparty/lzma/CPP/7zip/Archive/7z/7zFolderInStream.cpp
index 14cdc436452..08231893905 100644
--- a/3rdparty/lzma/CPP/7zip/Archive/7z/7zFolderInStream.cpp
+++ b/3rdparty/lzma/CPP/7zip/Archive/7z/7zFolderInStream.cpp
@@ -2,6 +2,8 @@
#include "StdAfx.h"
+#include "../../../Windows/TimeUtils.h"
+
#include "7zFolderInStream.h"
namespace NArchive {
@@ -13,66 +15,129 @@ void CFolderInStream::Init(IArchiveUpdateCallback *updateCallback,
_updateCallback = updateCallback;
_indexes = indexes;
_numFiles = numFiles;
- _index = 0;
+
+ _totalSize_for_Coder = 0;
+ ClearFileInfo();
Processed.ClearAndReserve(numFiles);
- CRCs.ClearAndReserve(numFiles);
Sizes.ClearAndReserve(numFiles);
-
- _pos = 0;
- _crc = CRC_INIT_VAL;
- _size_Defined = false;
- _size = 0;
+ CRCs.ClearAndReserve(numFiles);
+ TimesDefined.ClearAndReserve(numFiles);
+ MTimes.ClearAndReserve(Need_MTime ? numFiles : (unsigned)0);
+ CTimes.ClearAndReserve(Need_CTime ? numFiles : (unsigned)0);
+ ATimes.ClearAndReserve(Need_ATime ? numFiles : (unsigned)0);
+ Attribs.ClearAndReserve(Need_Attrib ? numFiles : (unsigned)0);
+ // FolderCrc = CRC_INIT_VAL;
_stream.Release();
}
-HRESULT CFolderInStream::OpenStream()
+void CFolderInStream::ClearFileInfo()
{
_pos = 0;
_crc = CRC_INIT_VAL;
_size_Defined = false;
+ _times_Defined = false;
_size = 0;
+ FILETIME_Clear(_mTime);
+ FILETIME_Clear(_cTime);
+ FILETIME_Clear(_aTime);
+ _attrib = 0;
+}
- while (_index < _numFiles)
+HRESULT CFolderInStream::OpenStream()
+{
+ while (Processed.Size() < _numFiles)
{
CMyComPtr<ISequentialInStream> stream;
- HRESULT result = _updateCallback->GetStream(_indexes[_index], &stream);
- if (result != S_OK)
- {
- if (result != S_FALSE)
- return result;
- }
+ const HRESULT result = _updateCallback->GetStream(_indexes[Processed.Size()], &stream);
+ if (result != S_OK && result != S_FALSE)
+ return result;
_stream = stream;
if (stream)
{
- CMyComPtr<IStreamGetSize> streamGetSize;
- stream.QueryInterface(IID_IStreamGetSize, &streamGetSize);
- if (streamGetSize)
{
- if (streamGetSize->GetSize(&_size) == S_OK)
- _size_Defined = true;
+ CMyComPtr<IStreamGetProps> getProps;
+ stream.QueryInterface(IID_IStreamGetProps, (void **)&getProps);
+ if (getProps)
+ {
+ // access could be changed in first myx pass
+ if (getProps->GetProps(&_size,
+ Need_CTime ? &_cTime : NULL,
+ Need_ATime ? &_aTime : NULL,
+ Need_MTime ? &_mTime : NULL,
+ Need_Attrib ? &_attrib : NULL)
+ == S_OK)
+ {
+ _size_Defined = true;
+ _times_Defined = true;
+ }
+ return S_OK;
+ }
+ }
+ {
+ CMyComPtr<IStreamGetSize> streamGetSize;
+ stream.QueryInterface(IID_IStreamGetSize, &streamGetSize);
+ if (streamGetSize)
+ {
+ if (streamGetSize->GetSize(&_size) == S_OK)
+ _size_Defined = true;
+ }
+ return S_OK;
}
- return S_OK;
}
- _index++;
- RINOK(_updateCallback->SetOperationResult(NArchive::NUpdate::NOperationResult::kOK));
- AddFileInfo(result == S_OK);
+ RINOK(AddFileInfo(result == S_OK))
}
return S_OK;
}
-void CFolderInStream::AddFileInfo(bool isProcessed)
+static void AddFt(CRecordVector<UInt64> &vec, const FILETIME &ft)
{
- Processed.Add(isProcessed);
- Sizes.Add(_pos);
- CRCs.Add(CRC_GET_DIGEST(_crc));
+ vec.AddInReserved(FILETIME_To_UInt64(ft));
}
-STDMETHODIMP CFolderInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
+/*
+HRESULT ReportItemProps(IArchiveUpdateCallbackArcProp *reportArcProp,
+ UInt32 index, UInt64 size, const UInt32 *crc)
+{
+ PROPVARIANT prop;
+ prop.vt = VT_EMPTY;
+ prop.wReserved1 = 0;
+
+ NWindows::NCOM::PropVarEm_Set_UInt64(&prop, size);
+ RINOK(reportArcProp->ReportProp(NEventIndexType::kOutArcIndex, index, kpidSize, &prop));
+ if (crc)
+ {
+ NWindows::NCOM::PropVarEm_Set_UInt32(&prop, *crc);
+ RINOK(reportArcProp->ReportProp(NEventIndexType::kOutArcIndex, index, kpidCRC, &prop));
+ }
+ return reportArcProp->ReportFinished(NEventIndexType::kOutArcIndex, index, NUpdate::NOperationResult::kOK);
+}
+*/
+
+HRESULT CFolderInStream::AddFileInfo(bool isProcessed)
+{
+ // const UInt32 index = _indexes[Processed.Size()];
+ Processed.AddInReserved(isProcessed);
+ Sizes.AddInReserved(_pos);
+ CRCs.AddInReserved(CRC_GET_DIGEST(_crc));
+ if (Need_Attrib) Attribs.AddInReserved(_attrib);
+ TimesDefined.AddInReserved(_times_Defined);
+ if (Need_MTime) AddFt(MTimes, _mTime);
+ if (Need_CTime) AddFt(CTimes, _cTime);
+ if (Need_ATime) AddFt(ATimes, _aTime);
+ ClearFileInfo();
+ /*
+ if (isProcessed && _reportArcProp)
+ RINOK(ReportItemProps(_reportArcProp, index, _pos, &crc))
+ */
+ return _updateCallback->SetOperationResult(NArchive::NUpdate::NOperationResult::kOK);
+}
+
+Z7_COM7F_IMF(CFolderInStream::Read(void *data, UInt32 size, UInt32 *processedSize))
{
if (processedSize)
*processedSize = 0;
@@ -80,43 +145,65 @@ STDMETHODIMP CFolderInStream::Read(void *data, UInt32 size, UInt32 *processedSiz
{
if (_stream)
{
- UInt32 processed2;
- RINOK(_stream->Read(data, size, &processed2));
- if (processed2 != 0)
+ /*
+ if (_pos == 0)
+ {
+ const UInt32 align = (UInt32)1 << AlignLog;
+ const UInt32 offset = (UInt32)_totalSize_for_Coder & (align - 1);
+ if (offset != 0)
+ {
+ UInt32 cur = align - offset;
+ if (cur > size)
+ cur = size;
+ memset(data, 0, cur);
+ data = (Byte *)data + cur;
+ size -= cur;
+ // _pos += cur; // for debug
+ _totalSize_for_Coder += cur;
+ if (processedSize)
+ *processedSize += cur;
+ continue;
+ }
+ }
+ */
+ UInt32 cur = size;
+ const UInt32 kMax = (UInt32)1 << 20;
+ if (cur > kMax)
+ cur = kMax;
+ RINOK(_stream->Read(data, cur, &cur))
+ if (cur != 0)
{
- _crc = CrcUpdate(_crc, data, processed2);
- _pos += processed2;
+ // if (Need_Crc)
+ _crc = CrcUpdate(_crc, data, cur);
+ /*
+ if (FolderCrc)
+ FolderCrc = CrcUpdate(FolderCrc, data, cur);
+ */
+ _pos += cur;
+ _totalSize_for_Coder += cur;
if (processedSize)
- *processedSize = processed2;
+ *processedSize = cur; // use +=cur, if continue is possible in loop
return S_OK;
}
_stream.Release();
- _index++;
- AddFileInfo(true);
-
- _pos = 0;
- _crc = CRC_INIT_VAL;
- _size_Defined = false;
- _size = 0;
-
- RINOK(_updateCallback->SetOperationResult(NArchive::NUpdate::NOperationResult::kOK));
+ RINOK(AddFileInfo(true))
}
- if (_index >= _numFiles)
+ if (Processed.Size() >= _numFiles)
break;
- RINOK(OpenStream());
+ RINOK(OpenStream())
}
return S_OK;
}
-STDMETHODIMP CFolderInStream::GetSubStreamSize(UInt64 subStream, UInt64 *value)
+Z7_COM7F_IMF(CFolderInStream::GetSubStreamSize(UInt64 subStream, UInt64 *value))
{
*value = 0;
if (subStream > Sizes.Size())
return S_FALSE; // E_FAIL;
- unsigned index = (unsigned)subStream;
+ const unsigned index = (unsigned)subStream;
if (index < Sizes.Size())
{
*value = Sizes[index];
@@ -133,4 +220,45 @@ STDMETHODIMP CFolderInStream::GetSubStreamSize(UInt64 subStream, UInt64 *value)
return S_OK;
}
+
+/*
+HRESULT CFolderInStream::CloseCrcStream()
+{
+ if (!_crcStream)
+ return S_OK;
+ if (!_crcStream_Spec->WasFinished())
+ return E_FAIL;
+ _crc = _crcStream_Spec->GetCRC() ^ CRC_INIT_VAL; // change it
+ const UInt64 size = _crcStream_Spec->GetSize();
+ _pos = size;
+ _totalSize_for_Coder += size;
+ _crcStream.Release();
+ // _crcStream->ReleaseStream();
+ _stream.Release();
+ return AddFileInfo(true);
+}
+
+Z7_COM7F_IMF(CFolderInStream::GetNextInSubStream(UInt64 *streamIndexRes, ISequentialInStream **stream)
+{
+ RINOK(CloseCrcStream())
+ *stream = NULL;
+ *streamIndexRes = Processed.Size();
+ if (Processed.Size() >= _numFiles)
+ return S_OK;
+ RINOK(OpenStream());
+ if (!_stream)
+ return S_OK;
+ if (!_crcStream)
+ {
+ _crcStream_Spec = new CSequentialInStreamWithCRC;
+ _crcStream = _crcStream_Spec;
+ }
+ _crcStream_Spec->Init();
+ _crcStream_Spec->SetStream(_stream);
+ *stream = _crcStream;
+ _crcStream->AddRef();
+ return S_OK;
+}
+*/
+
}}