/* 7zDecode.c */

#include "7zDecode.h"

#ifdef _SZ_ONE_DIRECTORY

#include "LzmaDecode.h"

#else

#include "../../Compress/LZMA_C/LzmaDecode.h"

#endif

CMethodID k_Copy = { { 0x0 }, 1 };

CMethodID k_LZMA = { { 0x3, 0x1, 0x1 }, 3 };

#ifdef _LZMA_IN_CB

typedef struct _CLzmaInCallbackImp

} CLzmaInCallbackImp;

int LzmaReadImp(void *object, const unsigned char **buffer, SizeT *size)

{

CLzmaInCallbackImp *cb = (CLzmaInCallbackImp *)object;

size_t processedSize;

SZ_RESULT res;

*size = 0;

res = cb->InStream->Read((void *)cb->InStream, (void **)buffer, cb->Size, &processedSize);

*size = (SizeT)processedSize;

if (processedSize > cb->Size)

return (int)SZE_FAIL;

cb->Size -= processedSize;

if (res == SZ_OK)

return 0;

return (int)res;

}

#endif

SZ_RESULT SzDecode(const CFileSize *packSizes, const CFolder *folder,

size_t *outSizeProcessed, ISzAlloc *allocMain)

{

UInt32 si;

size_t inSize = 0;

CCoderInfo *coder;

if (folder->NumPackStreams != 1)

return SZE_NOTIMPL;

if (folder->NumCoders != 1)

return SZE_NOTIMPL;

coder = folder->Coders;

*outSizeProcessed = 0;

for (si = 0; si < folder->NumPackStreams; si++)

inSize += (size_t)packSizes[si];

if (AreMethodsEqual(&coder->MethodID, &k_Copy))

{

size_t i;

if (inSize != outSize)

return SZE_DATA_ERROR;

#ifdef _LZMA_IN_CB

for (i = 0; i < inSize;)

{

size_t j;

void *inBuffer;

size_t bufferSize;

RINOK(inStream->Read((void *)inStream, (void **)&inBuffer, inSize - i, &bufferSize));

if (bufferSize == 0)

return SZE_DATA_ERROR;

if (bufferSize > inSize - i)

return SZE_FAIL;

*outSizeProcessed += bufferSize;

for (j = 0; j < bufferSize && i < inSize; j++, i++)

outBuffer[i] = ((Byte*)inBuffer)[j];

}

#else

for (i = 0; i < inSize; i++)

outBuffer[i] = inBuffer[i];

*outSizeProcessed = inSize;

#endif

return SZ_OK;

}

if (AreMethodsEqual(&coder->MethodID, &k_LZMA))

{

#ifdef _LZMA_IN_CB

CLzmaInCallbackImp lzmaCallback;

#else

SizeT inProcessed;

#endif

CLzmaDecoderState state; /* it's about 24-80 bytes structure, if int is 32-bit */

int result;

SizeT outSizeProcessedLoc;

#ifdef _LZMA_IN_CB

lzmaCallback.Size = inSize;

lzmaCallback.InStream = inStream;

lzmaCallback.InCallback.Read = LzmaReadImp;

#endif

if (LzmaDecodeProperties(&state.Properties, coder->Properties.Items,

coder->Properties.Capacity) != LZMA_RESULT_OK)

return SZE_FAIL;

state.Probs = (CProb *)allocMain->Alloc(LzmaGetNumProbs(&state.Properties) * sizeof(CProb));

if (state.Probs == 0)

return SZE_OUTOFMEMORY;

#ifdef _LZMA_OUT_READ

if (state.Properties.DictionarySize == 0)

state.Dictionary = 0;

else

{

state.Dictionary = (unsigned char *)allocMain->Alloc(state.Properties.DictionarySize);

if (state.Dictionary == 0)

{

allocMain->Free(state.Probs);

return SZE_OUTOFMEMORY;

}

}

LzmaDecoderInit(&state);

#endif

result = LzmaDecode(&state,

#ifdef _LZMA_IN_CB

&lzmaCallback.InCallback,

#else

inBuffer, (SizeT)inSize, &inProcessed,

#endif

outBuffer, (SizeT)outSize, &outSizeProcessedLoc);

*outSizeProcessed = (size_t)outSizeProcessedLoc;

allocMain->Free(state.Probs);

#ifdef _LZMA_OUT_READ

allocMain->Free(state.Dictionary);

#endif

if (result == LZMA_RESULT_DATA_ERROR)

return SZE_DATA_ERROR;

if (result != LZMA_RESULT_OK)

return SZE_FAIL;

return SZ_OK;

}

return SZE_NOTIMPL;

}