aaru-dps/Aaru.Compression.Native
1
0
Fork 0
mirror of https://github.com/aaru-dps/Aaru.Compression.Native.git synced 2025-12-16 19:24:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update to lzma 23.01.

Browse Source
This commit is contained in:
Natalia Portillo
2023-09-24 03:13:03 +01:00
parent 5a6a32f513
commit dda9bcac54
530 changed files with 31937 additions and 14468 deletions
Download Patch File Download Diff File Expand all files Collapse all files

213
3rdparty/lzma/CPP/7zip/Archive/7z/7zFolderInStream.cpp vendored
View File

@@ -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,46 +145,65 @@ STDMETHODIMP CFolderInStream::Read(void *data, UInt32 size, UInt32 *processedSiz
{
if (_stream)
{
/*
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));
RINOK(_stream->Read(data, cur, &cur))
if (cur != 0)
{
// if (Need_Crc)
_crc = CrcUpdate(_crc, data, cur);
/*
if (FolderCrc)
FolderCrc = CrcUpdate(FolderCrc, data, cur);
*/
_pos += cur;
_totalSize_for_Coder += cur;
if (processedSize)
*processedSize = cur;
*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];
@@ -136,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;
}
*/
}}