xevion/easy7zip
1
0
Fork 0
mirror of https://github.com/Xevion/easy7zip.git synced 2025-12-07 20:06:59 -06:00
Code Issues Packages Projects Releases Wiki Activity

15.05

Browse Source
This commit is contained in:
Igor Pavlov
2015-06-15 00:00:00 +00:00
committed by Kornel Lesiński
parent 0713a3ab80
commit 54490d51d5
591 changed files with 34932 additions and 16390 deletions
Download Patch File Download Diff File Expand all files Collapse all files

169
CPP/7zip/Compress/Lzma2Decoder.cpp
View File

@@ -24,32 +24,40 @@ static HRESULT SResToHRESULT(SRes res)
namespace NCompress {
namespace NLzma2 {
static const UInt32 kInBufSize = 1 << 20;
CDecoder::CDecoder(): _inBuf(0), _outSizeDefined(false)
CDecoder::CDecoder():
_inBuf(NULL),
_inBufSize(0),
_inBufSizeNew(1 << 20),
_outStepSize(1 << 22),
_outSizeDefined(false),
_finishMode(false)
{
Lzma2Dec_Construct(&_state);
}
static void *SzAlloc(void *p, size_t size) { p = p; return MyAlloc(size); }
static void SzFree(void *p, void *address) { p = p; MyFree(address); }
static ISzAlloc g_Alloc = { SzAlloc, SzFree };
STDMETHODIMP CDecoder::SetInBufSize(UInt32 , UInt32 size) { _inBufSizeNew = size; return S_OK; }
STDMETHODIMP CDecoder::SetOutBufSize(UInt32 , UInt32 size) { _outStepSize = size; return S_OK; }
CDecoder::~CDecoder()
{
Lzma2Dec_Free(&_state, &g_Alloc);
MyFree(_inBuf);
MidFree(_inBuf);
}
STDMETHODIMP CDecoder::SetDecoderProperties2(const Byte *prop, UInt32 size)
{
if (size != 1) return SZ_ERROR_UNSUPPORTED;
if (size != 1)
return E_NOTIMPL;
RINOK(SResToHRESULT(Lzma2Dec_Allocate(&_state, prop[0], &g_Alloc)));
if (_inBuf == 0)
if (!_inBuf || _inBufSize != _inBufSizeNew)
{
_inBuf = (Byte *)MyAlloc(kInBufSize);
if (_inBuf == 0)
MidFree(_inBuf);
_inBufSize = 0;
_inBuf = (Byte *)MidAlloc(_inBufSizeNew);
if (!_inBuf)
return E_OUTOFMEMORY;
_inBufSize = _inBufSizeNew;
}
return S_OK;
@@ -62,6 +70,7 @@ STDMETHODIMP CDecoder::ReleaseInStream() { _inStream.Release(); return S_OK; }
STDMETHODIMP CDecoder::SetOutStreamSize(const UInt64 *outSize)
{
_outSizeDefined = (outSize != NULL);
_outSize = 0;
if (_outSizeDefined)
_outSize = *outSize;
@@ -72,39 +81,55 @@ STDMETHODIMP CDecoder::SetOutStreamSize(const UInt64 *outSize)
return S_OK;
}
STDMETHODIMP CDecoder::SetFinishMode(UInt32 finishMode)
{
_finishMode = (finishMode != 0);
return S_OK;
}
STDMETHODIMP CDecoder::Code(ISequentialInStream *inStream,
ISequentialOutStream *outStream, const UInt64 * /* inSize */,
ISequentialOutStream *outStream, const UInt64 *inSize,
const UInt64 *outSize, ICompressProgressInfo *progress)
{
if (_inBuf == 0)
if (!_inBuf)
return S_FALSE;
SetOutStreamSize(outSize);
UInt32 step = _outStepSize;
const UInt32 kOutStepSize_Min = 1 << 12;
if (step < kOutStepSize_Min)
step = kOutStepSize_Min;
SizeT wrPos = _state.decoder.dicPos;
SizeT next = (_state.decoder.dicBufSize - _state.decoder.dicPos < step) ?
_state.decoder.dicBufSize :
_state.decoder.dicPos + step;
HRESULT hres = S_OK;
for (;;)
{
if (_inPos == _inSize)
{
_inPos = _inSize = 0;
RINOK(inStream->Read(_inBuf, kInBufSize, &_inSize));
hres = inStream->Read(_inBuf, _inBufSize, &_inSize);
if (hres != S_OK)
break;
}
SizeT dicPos = _state.decoder.dicPos;
SizeT curSize = _state.decoder.dicBufSize - dicPos;
const UInt32 kStepSize = ((UInt32)1 << 22);
if (curSize > kStepSize)
curSize = (SizeT)kStepSize;
SizeT curSize = next - dicPos;
ELzmaFinishMode finishMode = LZMA_FINISH_ANY;
if (_outSizeDefined)
{
const UInt64 rem = _outSize - _outSizeProcessed;
if (rem < curSize)
if (curSize >= rem)
{
curSize = (SizeT)rem;
/*
// finishMode = LZMA_FINISH_END;
we can't use LZMA_FINISH_END here to allow partial decoding
*/
if (_finishMode)
finishMode = LZMA_FINISH_END;
}
}
@@ -117,71 +142,123 @@ STDMETHODIMP CDecoder::Code(ISequentialInStream *inStream,
SizeT outSizeProcessed = _state.decoder.dicPos - dicPos;
_outSizeProcessed += outSizeProcessed;
bool finished = (inSizeProcessed == 0 && outSizeProcessed == 0);
bool stopDecoding = (_outSizeDefined && _outSizeProcessed >= _outSize);
bool finished = (inSizeProcessed == 0 && outSizeProcessed == 0
|| status == LZMA_STATUS_FINISHED_WITH_MARK);
bool outFinished = (_outSizeDefined && _outSizeProcessed >= _outSize);
if (res != 0 || _state.decoder.dicPos == _state.decoder.dicBufSize || finished || stopDecoding)
if (res != 0
|| _state.decoder.dicPos >= next
|| finished
|| outFinished)
{
HRESULT res2 = WriteStream(outStream, _state.decoder.dic, _state.decoder.dicPos);
HRESULT res2 = WriteStream(outStream, _state.decoder.dic + wrPos, _state.decoder.dicPos - wrPos);
if (_state.decoder.dicPos == _state.decoder.dicBufSize)
_state.decoder.dicPos = 0;
wrPos = _state.decoder.dicPos;
next = (_state.decoder.dicBufSize - _state.decoder.dicPos < step) ?
_state.decoder.dicBufSize :
_state.decoder.dicPos + step;
if (res != 0)
return S_FALSE;
RINOK(res2);
if (stopDecoding)
return S_OK;
if (finished)
return (status == LZMA_STATUS_FINISHED_WITH_MARK ? S_OK : S_FALSE);
}
if (_state.decoder.dicPos == _state.decoder.dicBufSize)
_state.decoder.dicPos = 0;
if (progress != NULL)
if (finished)
{
if (status == LZMA_STATUS_FINISHED_WITH_MARK)
{
if (_finishMode && inSize && *inSize != _inSizeProcessed)
return S_FALSE;
if (finishMode == LZMA_FINISH_END && !outFinished)
return S_FALSE;
return S_OK;
}
return (finishMode == LZMA_FINISH_END) ? S_FALSE : S_OK;
}
if (outFinished && finishMode == LZMA_FINISH_ANY)
return S_OK;
}
if (progress)
{
RINOK(progress->SetRatioInfo(&_inSizeProcessed, &_outSizeProcessed));
}
}
HRESULT res2 = WriteStream(outStream, _state.decoder.dic + wrPos, _state.decoder.dicPos - wrPos);
if (hres != S_OK)
return hres;
return res2;
}
#ifndef NO_READ_FROM_CODER
STDMETHODIMP CDecoder::Read(void *data, UInt32 size, UInt32 *processedSize)
{
UInt32 totalProcessed = 0;
if (processedSize)
*processedSize = 0;
do
for (;;)
{
if (_inPos == _inSize)
{
_inPos = _inSize = 0;
RINOK(_inStream->Read(_inBuf, kInBufSize, &_inSize));
RINOK(_inStream->Read(_inBuf, _inBufSize, &_inSize));
}
{
SizeT inProcessed = _inSize - _inPos;
ELzmaFinishMode finishMode = LZMA_FINISH_ANY;
if (_outSizeDefined)
{
const UInt64 rem = _outSize - _outSizeProcessed;
if (rem < size)
if (rem <= size)
{
size = (UInt32)rem;
if (_finishMode)
finishMode = LZMA_FINISH_END;
}
}
SizeT outProcessed = size;
SizeT inProcessed = _inSize - _inPos;
ELzmaStatus status;
SRes res = Lzma2Dec_DecodeToBuf(&_state, (Byte *)data, &outProcessed,
_inBuf + _inPos, &inProcessed, LZMA_FINISH_ANY, &status);
_inBuf + _inPos, &inProcessed, finishMode, &status);
_inPos += (UInt32)inProcessed;
_inSizeProcessed += inProcessed;
_outSizeProcessed += outProcessed;
size -= (UInt32)outProcessed;
data = (Byte *)data + outProcessed;
totalProcessed += (UInt32)outProcessed;
if (processedSize)
*processedSize += (UInt32)outProcessed;
RINOK(SResToHRESULT(res));
*processedSize = totalProcessed;
if (res != SZ_OK)
{
if (totalProcessed != 0)
return S_OK;
return SResToHRESULT(res);
}
if (inProcessed == 0 && outProcessed == 0)
return S_OK;
if (status == LZMA_STATUS_FINISHED_WITH_MARK)
return S_OK;
if (outProcessed != 0)
{
if (finishMode != LZMA_FINISH_END || _outSize != _outSizeProcessed)
return S_OK;
}
}
}
while (size != 0);
return S_OK;
}
#endif