Return to 7zDecode.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / elwix / tools / oldlzma / SRC / 7zip / Archive / 7z_C

Annotation of elwix/tools/oldlzma/SRC/7zip/Archive/7z_C/7zDecode.c, revision 1.1.1.1

1.1       misho       1: /* 7zDecode.c */
                      2: 
                      3: #include "7zDecode.h"
                      4: #ifdef _SZ_ONE_DIRECTORY
                      5: #include "LzmaDecode.h"
                      6: #else
                      7: #include "../../Compress/LZMA_C/LzmaDecode.h"
                      8: #endif
                      9: 
                     10: CMethodID k_Copy = { { 0x0 }, 1 };
                     11: CMethodID k_LZMA = { { 0x3, 0x1, 0x1 }, 3 };
                     12: 
                     13: #ifdef _LZMA_IN_CB
                     14: 
                     15: typedef struct _CLzmaInCallbackImp
                     16: {
                     17:   ILzmaInCallback InCallback;
                     18:   ISzInStream *InStream;
                     19:   size_t Size;
                     20: } CLzmaInCallbackImp;
                     21: 
                     22: int LzmaReadImp(void *object, unsigned char **buffer, UInt32 *size)
                     23: {
                     24:   CLzmaInCallbackImp *cb = (CLzmaInCallbackImp *)object;
                     25:   size_t processedSize;
                     26:   SZ_RESULT res;
                     27:   *size = 0;
                     28:   res = cb->InStream->Read((void *)cb->InStream, (void **)buffer, cb->Size, &processedSize);
                     29:   *size = (UInt32)processedSize;
                     30:   if (processedSize > cb->Size)
                     31:     return (int)SZE_FAIL;
                     32:   cb->Size -= processedSize;
                     33:   if (res == SZ_OK)
                     34:     return 0;
                     35:   return (int)res;
                     36: }
                     37: 
                     38: #endif
                     39: 
                     40: SZ_RESULT SzDecode(CFileSize *packSizes, CFolder *folder,
                     41:     #ifdef _LZMA_IN_CB
                     42:     ISzInStream *inStream,
                     43:     #else
                     44:     Byte *inBuffer,
                     45:     #endif
                     46:     Byte *outBuffer, size_t outSize, 
                     47:     size_t *outSizeProcessed, ISzAlloc *allocMain)
                     48: {
                     49:   UInt32 si;
                     50:   size_t inSize = 0;
                     51:   CCoderInfo *coder;
                     52:   if (folder->NumPackStreams != 1)
                     53:     return SZE_NOTIMPL;
                     54:   if (folder->NumCoders != 1)
                     55:     return SZE_NOTIMPL;
                     56:   coder = folder->Coders;
                     57:   *outSizeProcessed = 0;
                     58: 
                     59:   for (si = 0; si < folder->NumPackStreams; si++)
                     60:     inSize += (size_t)packSizes[si];
                     61: 
                     62:   if (AreMethodsEqual(&coder->MethodID, &k_Copy))
                     63:   {
                     64:     size_t i;
                     65:     if (inSize != outSize)
                     66:       return SZE_DATA_ERROR;
                     67:     #ifdef _LZMA_IN_CB
                     68:     for (i = 0; i < inSize;)
                     69:     {
                     70:       size_t j;
                     71:       Byte *inBuffer;
                     72:       size_t bufferSize;
                     73:       RINOK(inStream->Read((void *)inStream,  (void **)&inBuffer, inSize - i, &bufferSize));
                     74:       if (bufferSize == 0)
                     75:         return SZE_DATA_ERROR;
                     76:       if (bufferSize > inSize - i)
                     77:         return SZE_FAIL;
                     78:       *outSizeProcessed += bufferSize;
                     79:       for (j = 0; j < bufferSize && i < inSize; j++, i++)
                     80:         outBuffer[i] = inBuffer[j];
                     81:     }
                     82:     #else
                     83:     for (i = 0; i < inSize; i++)
                     84:       outBuffer[i] = inBuffer[i];
                     85:     *outSizeProcessed = inSize;
                     86:     #endif
                     87:     return SZ_OK;
                     88:   }
                     89: 
                     90:   if (AreMethodsEqual(&coder->MethodID, &k_LZMA))
                     91:   {
                     92:     #ifdef _LZMA_IN_CB
                     93:     CLzmaInCallbackImp lzmaCallback;
                     94:     #endif
                     95: 
                     96:     int lc, lp, pb;
                     97:     size_t lzmaInternalSize;
                     98:     void *lzmaInternalData;
                     99:     int result;
                    100:     UInt32 outSizeProcessedLoc;
                    101: 
                    102:     #ifdef _LZMA_IN_CB
                    103:     lzmaCallback.Size = inSize;
                    104:     lzmaCallback.InStream = inStream;
                    105:     lzmaCallback.InCallback.Read = LzmaReadImp;
                    106:     #endif
                    107: 
                    108:     if (coder->Properties.Capacity < 5)
                    109:       return SZE_FAIL;
                    110:     lc = (unsigned char)coder->Properties.Items[0];
                    111:     if (lc >= (9 * 5 * 5))
                    112:       return SZE_FAIL;
                    113:     for (pb = 0; lc >= (9 * 5); pb++, lc -= (9 * 5));
                    114:     for (lp = 0; lc >= 9; lp++, lc -= 9);
                    115: 
                    116:     lzmaInternalSize = (LZMA_BASE_SIZE + (LZMA_LIT_SIZE << (lc + lp))) * sizeof(CProb);
                    117:     lzmaInternalData = allocMain->Alloc(lzmaInternalSize);
                    118:     if (lzmaInternalData == 0)
                    119:       return SZE_OUTOFMEMORY;
                    120: 
                    121:     result = LzmaDecode((Byte *)lzmaInternalData, (UInt32)lzmaInternalSize,
                    122:         lc, lp, pb,
                    123:         #ifdef _LZMA_IN_CB
                    124:         &lzmaCallback.InCallback,
                    125:         #else
                    126:         inBuffer, (UInt32)inSize,
                    127:         #endif
                    128:         outBuffer, (UInt32)outSize, 
                    129:         &outSizeProcessedLoc);
                    130:     *outSizeProcessed = (size_t)outSizeProcessedLoc;
                    131:     allocMain->Free(lzmaInternalData);
                    132:     /*
                    133:     NOT_ENOUGH_MEM error is impossible for this code
                    134:     if (result = LZMA_RESULT_NOT_ENOUGH_MEM)
                    135:       return SZE_OUTOFMEMORY;
                    136:     */
                    137:     if (result == LZMA_RESULT_DATA_ERROR)
                    138:       return SZE_DATA_ERROR;
                    139:     if (result != LZMA_RESULT_OK)
                    140:       return SZE_FAIL;
                    141:     return SZ_OK;
                    142:   }
                    143:   return SZE_NOTIMPL;
                    144: }