-/*\r
- LzmaDecode.c\r
- LZMA Decoder (optimized for Speed version)\r
- \r
- LZMA SDK 4.22 Copyright (c) 1999-2005 Igor Pavlov (2005-06-10)\r
- http://www.7-zip.org/\r
-\r
- LZMA SDK is licensed under two licenses:\r
- 1) GNU Lesser General Public License (GNU LGPL)\r
- 2) Common Public License (CPL)\r
- It means that you can select one of these two licenses and \r
- follow rules of that license.\r
-\r
- SPECIAL EXCEPTION:\r
- Igor Pavlov, as the author of this Code, expressly permits you to \r
- statically or dynamically link your Code (or bind by name) to the \r
- interfaces of this file without subjecting your linked Code to the \r
- terms of the CPL or GNU LGPL. Any modifications or additions \r
- to this file, however, are subject to the LGPL or CPL terms.\r
-*/\r
-\r
-#include "LzmaDecode.h"\r
-\r
-#ifndef Byte\r
-#define Byte unsigned char\r
-#endif\r
-\r
-#define kNumTopBits 24\r
-#define kTopValue ((UInt32)1 << kNumTopBits)\r
-\r
-#define kNumBitModelTotalBits 11\r
-#define kBitModelTotal (1 << kNumBitModelTotalBits)\r
-#define kNumMoveBits 5\r
-\r
-#define RC_READ_BYTE (*Buffer++)\r
-\r
-#define RC_INIT2 Code = 0; Range = 0xFFFFFFFF; \\r
- { int i; for(i = 0; i < 5; i++) { RC_TEST; Code = (Code << 8) | RC_READ_BYTE; }}\r
-\r
-#ifdef _LZMA_IN_CB\r
-\r
-#define RC_TEST { if (Buffer == BufferLim) \\r
- { SizeT size; int result = InCallback->Read(InCallback, &Buffer, &size); if (result != LZMA_RESULT_OK) return result; \\r
- BufferLim = Buffer + size; if (size == 0) return LZMA_RESULT_DATA_ERROR; }}\r
-\r
-#define RC_INIT Buffer = BufferLim = 0; RC_INIT2\r
-\r
-#else\r
-\r
-#define RC_TEST { if (Buffer == BufferLim) return LZMA_RESULT_DATA_ERROR; }\r
-\r
-#define RC_INIT(buffer, bufferSize) Buffer = buffer; BufferLim = buffer + bufferSize; RC_INIT2\r
- \r
-#endif\r
-\r
-#define RC_NORMALIZE if (Range < kTopValue) { RC_TEST; Range <<= 8; Code = (Code << 8) | RC_READ_BYTE; }\r
-\r
-#define IfBit0(p) RC_NORMALIZE; bound = (Range >> kNumBitModelTotalBits) * *(p); if (Code < bound)\r
-#define UpdateBit0(p) Range = bound; *(p) += (kBitModelTotal - *(p)) >> kNumMoveBits;\r
-#define UpdateBit1(p) Range -= bound; Code -= bound; *(p) -= (*(p)) >> kNumMoveBits;\r
-\r
-#define RC_GET_BIT2(p, mi, A0, A1) IfBit0(p) \\r
- { UpdateBit0(p); mi <<= 1; A0; } else \\r
- { UpdateBit1(p); mi = (mi + mi) + 1; A1; } \r
- \r
-#define RC_GET_BIT(p, mi) RC_GET_BIT2(p, mi, ; , ;) \r
-\r
-#define RangeDecoderBitTreeDecode(probs, numLevels, res) \\r
- { int i = numLevels; res = 1; \\r
- do { CProb *p = probs + res; RC_GET_BIT(p, res) } while(--i != 0); \\r
- res -= (1 << numLevels); }\r
-\r
-\r
-#define kNumPosBitsMax 4\r
-#define kNumPosStatesMax (1 << kNumPosBitsMax)\r
-\r
-#define kLenNumLowBits 3\r
-#define kLenNumLowSymbols (1 << kLenNumLowBits)\r
-#define kLenNumMidBits 3\r
-#define kLenNumMidSymbols (1 << kLenNumMidBits)\r
-#define kLenNumHighBits 8\r
-#define kLenNumHighSymbols (1 << kLenNumHighBits)\r
-\r
-#define LenChoice 0\r
-#define LenChoice2 (LenChoice + 1)\r
-#define LenLow (LenChoice2 + 1)\r
-#define LenMid (LenLow + (kNumPosStatesMax << kLenNumLowBits))\r
-#define LenHigh (LenMid + (kNumPosStatesMax << kLenNumMidBits))\r
-#define kNumLenProbs (LenHigh + kLenNumHighSymbols) \r
-\r
-\r
-#define kNumStates 12\r
-#define kNumLitStates 7\r
-\r
-#define kStartPosModelIndex 4\r
-#define kEndPosModelIndex 14\r
-#define kNumFullDistances (1 << (kEndPosModelIndex >> 1))\r
-\r
-#define kNumPosSlotBits 6\r
-#define kNumLenToPosStates 4\r
-\r
-#define kNumAlignBits 4\r
-#define kAlignTableSize (1 << kNumAlignBits)\r
-\r
-#define kMatchMinLen 2\r
-\r
-#define IsMatch 0\r
-#define IsRep (IsMatch + (kNumStates << kNumPosBitsMax))\r
-#define IsRepG0 (IsRep + kNumStates)\r
-#define IsRepG1 (IsRepG0 + kNumStates)\r
-#define IsRepG2 (IsRepG1 + kNumStates)\r
-#define IsRep0Long (IsRepG2 + kNumStates)\r
-#define PosSlot (IsRep0Long + (kNumStates << kNumPosBitsMax))\r
-#define SpecPos (PosSlot + (kNumLenToPosStates << kNumPosSlotBits))\r
-#define Align (SpecPos + kNumFullDistances - kEndPosModelIndex)\r
-#define LenCoder (Align + kAlignTableSize)\r
-#define RepLenCoder (LenCoder + kNumLenProbs)\r
-#define Literal (RepLenCoder + kNumLenProbs)\r
-\r
-#if Literal != LZMA_BASE_SIZE\r
-StopCompilingDueBUG\r
-#endif\r
-\r
-#if 0\r
-int LzmaDecodeProperties(CLzmaProperties *propsRes, const unsigned char *propsData, int size)\r
-{\r
- unsigned char prop0;\r
- if (size < LZMA_PROPERTIES_SIZE)\r
- return LZMA_RESULT_DATA_ERROR;\r
- prop0 = propsData[0];\r
- if (prop0 >= (9 * 5 * 5))\r
- return LZMA_RESULT_DATA_ERROR;\r
- {\r
- for (propsRes->pb = 0; prop0 >= (9 * 5); propsRes->pb++, prop0 -= (9 * 5));\r
- for (propsRes->lp = 0; prop0 >= 9; propsRes->lp++, prop0 -= 9);\r
- propsRes->lc = prop0;\r
- /*\r
- unsigned char remainder = (unsigned char)(prop0 / 9);\r
- propsRes->lc = prop0 % 9;\r
- propsRes->pb = remainder / 5;\r
- propsRes->lp = remainder % 5;\r
- */\r
- }\r
-\r
- #ifdef _LZMA_OUT_READ\r
- {\r
- int i;\r
- propsRes->DictionarySize = 0;\r
- for (i = 0; i < 4; i++)\r
- propsRes->DictionarySize += (UInt32)(propsData[1 + i]) << (i * 8);\r
- if (propsRes->DictionarySize == 0)\r
- propsRes->DictionarySize = 1;\r
- }\r
- #endif\r
- return LZMA_RESULT_OK;\r
-}\r
-#endif\r
-\r
-#define kLzmaStreamWasFinishedId (-1)\r
-\r
-int LzmaDecode(CLzmaDecoderState *vs,\r
- #ifdef _LZMA_IN_CB\r
- ILzmaInCallback *InCallback,\r
- #else\r
- const unsigned char *inStream, SizeT inSize, SizeT *inSizeProcessed,\r
- #endif\r
- unsigned char *outStream, SizeT outSize, SizeT *outSizeProcessed)\r
-{\r
- CProb *p = vs->Probs;\r
- SizeT nowPos = 0;\r
- Byte previousByte = 0;\r
- UInt32 posStateMask = (1 << (vs->Properties.pb)) - 1;\r
- UInt32 literalPosMask = (1 << (vs->Properties.lp)) - 1;\r
- int lc = vs->Properties.lc;\r
-\r
- #ifdef _LZMA_OUT_READ\r
- \r
- UInt32 Range = vs->Range;\r
- UInt32 Code = vs->Code;\r
- #ifdef _LZMA_IN_CB\r
- const Byte *Buffer = vs->Buffer;\r
- const Byte *BufferLim = vs->BufferLim;\r
- #else\r
- const Byte *Buffer = inStream;\r
- const Byte *BufferLim = inStream + inSize;\r
- #endif\r
- int state = vs->State;\r
- UInt32 rep0 = vs->Reps[0], rep1 = vs->Reps[1], rep2 = vs->Reps[2], rep3 = vs->Reps[3];\r
- int len = vs->RemainLen;\r
- UInt32 globalPos = vs->GlobalPos;\r
- UInt32 distanceLimit = vs->DistanceLimit;\r
-\r
- Byte *dictionary = vs->Dictionary;\r
- UInt32 dictionarySize = vs->Properties.DictionarySize;\r
- UInt32 dictionaryPos = vs->DictionaryPos;\r
-\r
- Byte tempDictionary[4];\r
-\r
- #ifndef _LZMA_IN_CB\r
- *inSizeProcessed = 0;\r
- #endif\r
- *outSizeProcessed = 0;\r
- if (len == kLzmaStreamWasFinishedId)\r
- return LZMA_RESULT_OK;\r
-\r
- if (dictionarySize == 0)\r
- {\r
- dictionary = tempDictionary;\r
- dictionarySize = 1;\r
- tempDictionary[0] = vs->TempDictionary[0];\r
- }\r
-\r
- if (len == kLzmaNeedInitId)\r
- {\r
- {\r
- UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (lc + vs->Properties.lp));\r
- UInt32 i;\r
- for (i = 0; i < numProbs; i++)\r
- p[i] = kBitModelTotal >> 1; \r
- rep0 = rep1 = rep2 = rep3 = 1;\r
- state = 0;\r
- globalPos = 0;\r
- distanceLimit = 0;\r
- dictionaryPos = 0;\r
- dictionary[dictionarySize - 1] = 0;\r
- #ifdef _LZMA_IN_CB\r
- RC_INIT;\r
- #else\r
- RC_INIT(inStream, inSize);\r
- #endif\r
- }\r
- len = 0;\r
- }\r
- while(len != 0 && nowPos < outSize)\r
- {\r
- UInt32 pos = dictionaryPos - rep0;\r
- if (pos >= dictionarySize)\r
- pos += dictionarySize;\r
- outStream[nowPos++] = dictionary[dictionaryPos] = dictionary[pos];\r
- if (++dictionaryPos == dictionarySize)\r
- dictionaryPos = 0;\r
- len--;\r
- }\r
- if (dictionaryPos == 0)\r
- previousByte = dictionary[dictionarySize - 1];\r
- else\r
- previousByte = dictionary[dictionaryPos - 1];\r
-\r
- #else /* if !_LZMA_OUT_READ */\r
-\r
- int state = 0;\r
- UInt32 rep0 = 1, rep1 = 1, rep2 = 1, rep3 = 1;\r
- int len = 0;\r
- const Byte *Buffer;\r
- const Byte *BufferLim;\r
- UInt32 Range;\r
- UInt32 Code;\r
-\r
- #ifndef _LZMA_IN_CB\r
- *inSizeProcessed = 0;\r
- #endif\r
- *outSizeProcessed = 0;\r
-\r
- {\r
- UInt32 i;\r
- UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (lc + vs->Properties.lp));\r
- for (i = 0; i < numProbs; i++)\r
- p[i] = kBitModelTotal >> 1;\r
- }\r
- \r
- #ifdef _LZMA_IN_CB\r
- RC_INIT;\r
- #else\r
- RC_INIT(inStream, inSize);\r
- #endif\r
-\r
- #endif /* _LZMA_OUT_READ */\r
-\r
- while(nowPos < outSize)\r
- {\r
- CProb *prob;\r
- UInt32 bound;\r
- int posState = (int)(\r
- (nowPos \r
- #ifdef _LZMA_OUT_READ\r
- + globalPos\r
- #endif\r
- )\r
- & posStateMask);\r
-\r
- prob = p + IsMatch + (state << kNumPosBitsMax) + posState;\r
- IfBit0(prob)\r
- {\r
- int symbol = 1;\r
- UpdateBit0(prob)\r
- prob = p + Literal + (LZMA_LIT_SIZE * \r
- (((\r
- (nowPos \r
- #ifdef _LZMA_OUT_READ\r
- + globalPos\r
- #endif\r
- )\r
- & literalPosMask) << lc) + (previousByte >> (8 - lc))));\r
-\r
- if (state >= kNumLitStates)\r
- {\r
- int matchByte;\r
- #ifdef _LZMA_OUT_READ\r
- UInt32 pos = dictionaryPos - rep0;\r
- if (pos >= dictionarySize)\r
- pos += dictionarySize;\r
- matchByte = dictionary[pos];\r
- #else\r
- matchByte = outStream[nowPos - rep0];\r
- #endif\r
- do\r
- {\r
- int bit;\r
- CProb *probLit;\r
- matchByte <<= 1;\r
- bit = (matchByte & 0x100);\r
- probLit = prob + 0x100 + bit + symbol;\r
- RC_GET_BIT2(probLit, symbol, if (bit != 0) break, if (bit == 0) break)\r
- }\r
- while (symbol < 0x100);\r
- }\r
- while (symbol < 0x100)\r
- {\r
- CProb *probLit = prob + symbol;\r
- RC_GET_BIT(probLit, symbol)\r
- }\r
- previousByte = (Byte)symbol;\r
-\r
- outStream[nowPos++] = previousByte;\r
- #ifdef _LZMA_OUT_READ\r
- if (distanceLimit < dictionarySize)\r
- distanceLimit++;\r
-\r
- dictionary[dictionaryPos] = previousByte;\r
- if (++dictionaryPos == dictionarySize)\r
- dictionaryPos = 0;\r
- #endif\r
- if (state < 4) state = 0;\r
- else if (state < 10) state -= 3;\r
- else state -= 6;\r
- }\r
- else \r
- {\r
- UpdateBit1(prob);\r
- prob = p + IsRep + state;\r
- IfBit0(prob)\r
- {\r
- UpdateBit0(prob);\r
- rep3 = rep2;\r
- rep2 = rep1;\r
- rep1 = rep0;\r
- state = state < kNumLitStates ? 0 : 3;\r
- prob = p + LenCoder;\r
- }\r
- else\r
- {\r
- UpdateBit1(prob);\r
- prob = p + IsRepG0 + state;\r
- IfBit0(prob)\r
- {\r
- UpdateBit0(prob);\r
- prob = p + IsRep0Long + (state << kNumPosBitsMax) + posState;\r
- IfBit0(prob)\r
- {\r
- #ifdef _LZMA_OUT_READ\r
- UInt32 pos;\r
- #endif\r
- UpdateBit0(prob);\r
- \r
- #ifdef _LZMA_OUT_READ\r
- if (distanceLimit == 0)\r
- #else\r
- if (nowPos == 0)\r
- #endif\r
- return LZMA_RESULT_DATA_ERROR;\r
- \r
- state = state < kNumLitStates ? 9 : 11;\r
- #ifdef _LZMA_OUT_READ\r
- pos = dictionaryPos - rep0;\r
- if (pos >= dictionarySize)\r
- pos += dictionarySize;\r
- previousByte = dictionary[pos];\r
- dictionary[dictionaryPos] = previousByte;\r
- if (++dictionaryPos == dictionarySize)\r
- dictionaryPos = 0;\r
- #else\r
- previousByte = outStream[nowPos - rep0];\r
- #endif\r
- outStream[nowPos++] = previousByte;\r
- #ifdef _LZMA_OUT_READ\r
- if (distanceLimit < dictionarySize)\r
- distanceLimit++;\r
- #endif\r
-\r
- continue;\r
- }\r
- else\r
- {\r
- UpdateBit1(prob);\r
- }\r
- }\r
- else\r
- {\r
- UInt32 distance;\r
- UpdateBit1(prob);\r
- prob = p + IsRepG1 + state;\r
- IfBit0(prob)\r
- {\r
- UpdateBit0(prob);\r
- distance = rep1;\r
- }\r
- else \r
- {\r
- UpdateBit1(prob);\r
- prob = p + IsRepG2 + state;\r
- IfBit0(prob)\r
- {\r
- UpdateBit0(prob);\r
- distance = rep2;\r
- }\r
- else\r
- {\r
- UpdateBit1(prob);\r
- distance = rep3;\r
- rep3 = rep2;\r
- }\r
- rep2 = rep1;\r
- }\r
- rep1 = rep0;\r
- rep0 = distance;\r
- }\r
- state = state < kNumLitStates ? 8 : 11;\r
- prob = p + RepLenCoder;\r
- }\r
- {\r
- int numBits, offset;\r
- CProb *probLen = prob + LenChoice;\r
- IfBit0(probLen)\r
- {\r
- UpdateBit0(probLen);\r
- probLen = prob + LenLow + (posState << kLenNumLowBits);\r
- offset = 0;\r
- numBits = kLenNumLowBits;\r
- }\r
- else\r
- {\r
- UpdateBit1(probLen);\r
- probLen = prob + LenChoice2;\r
- IfBit0(probLen)\r
- {\r
- UpdateBit0(probLen);\r
- probLen = prob + LenMid + (posState << kLenNumMidBits);\r
- offset = kLenNumLowSymbols;\r
- numBits = kLenNumMidBits;\r
- }\r
- else\r
- {\r
- UpdateBit1(probLen);\r
- probLen = prob + LenHigh;\r
- offset = kLenNumLowSymbols + kLenNumMidSymbols;\r
- numBits = kLenNumHighBits;\r
- }\r
- }\r
- RangeDecoderBitTreeDecode(probLen, numBits, len);\r
- len += offset;\r
- }\r
-\r
- if (state < 4)\r
- {\r
- int posSlot;\r
- state += kNumLitStates;\r
- prob = p + PosSlot +\r
- ((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) << \r
- kNumPosSlotBits);\r
- RangeDecoderBitTreeDecode(prob, kNumPosSlotBits, posSlot);\r
- if (posSlot >= kStartPosModelIndex)\r
- {\r
- int numDirectBits = ((posSlot >> 1) - 1);\r
- rep0 = (2 | ((UInt32)posSlot & 1));\r
- if (posSlot < kEndPosModelIndex)\r
- {\r
- rep0 <<= numDirectBits;\r
- prob = p + SpecPos + rep0 - posSlot - 1;\r
- }\r
- else\r
- {\r
- numDirectBits -= kNumAlignBits;\r
- do\r
- {\r
- RC_NORMALIZE\r
- Range >>= 1;\r
- rep0 <<= 1;\r
- if (Code >= Range)\r
- {\r
- Code -= Range;\r
- rep0 |= 1;\r
- }\r
- }\r
- while (--numDirectBits != 0);\r
- prob = p + Align;\r
- rep0 <<= kNumAlignBits;\r
- numDirectBits = kNumAlignBits;\r
- }\r
- {\r
- int i = 1;\r
- int mi = 1;\r
- do\r
- {\r
- CProb *prob3 = prob + mi;\r
- RC_GET_BIT2(prob3, mi, ; , rep0 |= i);\r
- i <<= 1;\r
- }\r
- while(--numDirectBits != 0);\r
- }\r
- }\r
- else\r
- rep0 = posSlot;\r
- if (++rep0 == (UInt32)(0))\r
- {\r
- /* it's for stream version */\r
- len = kLzmaStreamWasFinishedId;\r
- break;\r
- }\r
- }\r
-\r
- len += kMatchMinLen;\r
- #ifdef _LZMA_OUT_READ\r
- if (rep0 > distanceLimit) \r
- #else\r
- if (rep0 > nowPos)\r
- #endif\r
- return LZMA_RESULT_DATA_ERROR;\r
-\r
- #ifdef _LZMA_OUT_READ\r
- if (dictionarySize - distanceLimit > (UInt32)len)\r
- distanceLimit += len;\r
- else\r
- distanceLimit = dictionarySize;\r
- #endif\r
-\r
- do\r
- {\r
- #ifdef _LZMA_OUT_READ\r
- UInt32 pos = dictionaryPos - rep0;\r
- if (pos >= dictionarySize)\r
- pos += dictionarySize;\r
- previousByte = dictionary[pos];\r
- dictionary[dictionaryPos] = previousByte;\r
- if (++dictionaryPos == dictionarySize)\r
- dictionaryPos = 0;\r
- #else\r
- previousByte = outStream[nowPos - rep0];\r
- #endif\r
- len--;\r
- outStream[nowPos++] = previousByte;\r
- }\r
- while(len != 0 && nowPos < outSize);\r
- }\r
- }\r
- RC_NORMALIZE;\r
-\r
- #ifdef _LZMA_OUT_READ\r
- vs->Range = Range;\r
- vs->Code = Code;\r
- vs->DictionaryPos = dictionaryPos;\r
- vs->GlobalPos = globalPos + (UInt32)nowPos;\r
- vs->DistanceLimit = distanceLimit;\r
- vs->Reps[0] = rep0;\r
- vs->Reps[1] = rep1;\r
- vs->Reps[2] = rep2;\r
- vs->Reps[3] = rep3;\r
- vs->State = state;\r
- vs->RemainLen = len;\r
- vs->TempDictionary[0] = tempDictionary[0];\r
- #endif\r
-\r
- #ifdef _LZMA_IN_CB\r
- vs->Buffer = Buffer;\r
- vs->BufferLim = BufferLim;\r
- #else\r
- *inSizeProcessed = (SizeT)(Buffer - inStream);\r
- #endif\r
- *outSizeProcessed = nowPos;\r
- return LZMA_RESULT_OK;\r
-}\r
+/*
+ LzmaDecode.c
+ LZMA Decoder (optimized for Speed version)
+
+ LZMA SDK 4.22 Copyright (c) 1999-2005 Igor Pavlov (2005-06-10)
+ http://www.7-zip.org/
+
+ LZMA SDK is licensed under two licenses:
+ 1) GNU Lesser General Public License (GNU LGPL)
+ 2) Common Public License (CPL)
+ It means that you can select one of these two licenses and
+ follow rules of that license.
+
+ SPECIAL EXCEPTION:
+ Igor Pavlov, as the author of this Code, expressly permits you to
+ statically or dynamically link your Code (or bind by name) to the
+ interfaces of this file without subjecting your linked Code to the
+ terms of the CPL or GNU LGPL. Any modifications or additions
+ to this file, however, are subject to the LGPL or CPL terms.
+*/
+
+#include "LzmaDecode.h"
+
+#ifndef Byte
+#define Byte unsigned char
+#endif
+
+#define kNumTopBits 24
+#define kTopValue ((UInt32)1 << kNumTopBits)
+
+#define kNumBitModelTotalBits 11
+#define kBitModelTotal (1 << kNumBitModelTotalBits)
+#define kNumMoveBits 5
+
+#define RC_READ_BYTE (*Buffer++)
+
+#define RC_INIT2 Code = 0; Range = 0xFFFFFFFF; \
+ { int i; for(i = 0; i < 5; i++) { RC_TEST; Code = (Code << 8) | RC_READ_BYTE; }}
+
+#ifdef _LZMA_IN_CB
+
+#define RC_TEST { if (Buffer == BufferLim) \
+ { SizeT size; int result = InCallback->Read(InCallback, &Buffer, &size); if (result != LZMA_RESULT_OK) return result; \
+ BufferLim = Buffer + size; if (size == 0) return LZMA_RESULT_DATA_ERROR; }}
+
+#define RC_INIT Buffer = BufferLim = 0; RC_INIT2
+
+#else
+
+#define RC_TEST { if (Buffer == BufferLim) return LZMA_RESULT_DATA_ERROR; }
+
+#define RC_INIT(buffer, bufferSize) Buffer = buffer; BufferLim = buffer + bufferSize; RC_INIT2
+
+#endif
+
+#define RC_NORMALIZE if (Range < kTopValue) { RC_TEST; Range <<= 8; Code = (Code << 8) | RC_READ_BYTE; }
+
+#define IfBit0(p) RC_NORMALIZE; bound = (Range >> kNumBitModelTotalBits) * *(p); if (Code < bound)
+#define UpdateBit0(p) Range = bound; *(p) += (kBitModelTotal - *(p)) >> kNumMoveBits;
+#define UpdateBit1(p) Range -= bound; Code -= bound; *(p) -= (*(p)) >> kNumMoveBits;
+
+#define RC_GET_BIT2(p, mi, A0, A1) IfBit0(p) \
+ { UpdateBit0(p); mi <<= 1; A0; } else \
+ { UpdateBit1(p); mi = (mi + mi) + 1; A1; }
+
+#define RC_GET_BIT(p, mi) RC_GET_BIT2(p, mi, ; , ;)
+
+#define RangeDecoderBitTreeDecode(probs, numLevels, res) \
+ { int i = numLevels; res = 1; \
+ do { CProb *p = probs + res; RC_GET_BIT(p, res) } while(--i != 0); \
+ res -= (1 << numLevels); }
+
+
+#define kNumPosBitsMax 4
+#define kNumPosStatesMax (1 << kNumPosBitsMax)
+
+#define kLenNumLowBits 3
+#define kLenNumLowSymbols (1 << kLenNumLowBits)
+#define kLenNumMidBits 3
+#define kLenNumMidSymbols (1 << kLenNumMidBits)
+#define kLenNumHighBits 8
+#define kLenNumHighSymbols (1 << kLenNumHighBits)
+
+#define LenChoice 0
+#define LenChoice2 (LenChoice + 1)
+#define LenLow (LenChoice2 + 1)
+#define LenMid (LenLow + (kNumPosStatesMax << kLenNumLowBits))
+#define LenHigh (LenMid + (kNumPosStatesMax << kLenNumMidBits))
+#define kNumLenProbs (LenHigh + kLenNumHighSymbols)
+
+
+#define kNumStates 12
+#define kNumLitStates 7
+
+#define kStartPosModelIndex 4
+#define kEndPosModelIndex 14
+#define kNumFullDistances (1 << (kEndPosModelIndex >> 1))
+
+#define kNumPosSlotBits 6
+#define kNumLenToPosStates 4
+
+#define kNumAlignBits 4
+#define kAlignTableSize (1 << kNumAlignBits)
+
+#define kMatchMinLen 2
+
+#define IsMatch 0
+#define IsRep (IsMatch + (kNumStates << kNumPosBitsMax))
+#define IsRepG0 (IsRep + kNumStates)
+#define IsRepG1 (IsRepG0 + kNumStates)
+#define IsRepG2 (IsRepG1 + kNumStates)
+#define IsRep0Long (IsRepG2 + kNumStates)
+#define PosSlot (IsRep0Long + (kNumStates << kNumPosBitsMax))
+#define SpecPos (PosSlot + (kNumLenToPosStates << kNumPosSlotBits))
+#define Align (SpecPos + kNumFullDistances - kEndPosModelIndex)
+#define LenCoder (Align + kAlignTableSize)
+#define RepLenCoder (LenCoder + kNumLenProbs)
+#define Literal (RepLenCoder + kNumLenProbs)
+
+#if Literal != LZMA_BASE_SIZE
+StopCompilingDueBUG
+#endif
+
+#if 0
+int LzmaDecodeProperties(CLzmaProperties *propsRes, const unsigned char *propsData, int size)
+{
+ unsigned char prop0;
+ if (size < LZMA_PROPERTIES_SIZE)
+ return LZMA_RESULT_DATA_ERROR;
+ prop0 = propsData[0];
+ if (prop0 >= (9 * 5 * 5))
+ return LZMA_RESULT_DATA_ERROR;
+ {
+ for (propsRes->pb = 0; prop0 >= (9 * 5); propsRes->pb++, prop0 -= (9 * 5));
+ for (propsRes->lp = 0; prop0 >= 9; propsRes->lp++, prop0 -= 9);
+ propsRes->lc = prop0;
+ /*
+ unsigned char remainder = (unsigned char)(prop0 / 9);
+ propsRes->lc = prop0 % 9;
+ propsRes->pb = remainder / 5;
+ propsRes->lp = remainder % 5;
+ */
+ }
+
+ #ifdef _LZMA_OUT_READ
+ {
+ int i;
+ propsRes->DictionarySize = 0;
+ for (i = 0; i < 4; i++)
+ propsRes->DictionarySize += (UInt32)(propsData[1 + i]) << (i * 8);
+ if (propsRes->DictionarySize == 0)
+ propsRes->DictionarySize = 1;
+ }
+ #endif
+ return LZMA_RESULT_OK;
+}
+#endif
+
+#define kLzmaStreamWasFinishedId (-1)
+
+int LzmaDecode(CLzmaDecoderState *vs,
+ #ifdef _LZMA_IN_CB
+ ILzmaInCallback *InCallback,
+ #else
+ const unsigned char *inStream, SizeT inSize, SizeT *inSizeProcessed,
+ #endif
+ unsigned char *outStream, SizeT outSize, SizeT *outSizeProcessed)
+{
+ CProb *p = vs->Probs;
+ SizeT nowPos = 0;
+ Byte previousByte = 0;
+ UInt32 posStateMask = (1 << (vs->Properties.pb)) - 1;
+ UInt32 literalPosMask = (1 << (vs->Properties.lp)) - 1;
+ int lc = vs->Properties.lc;
+
+ #ifdef _LZMA_OUT_READ
+
+ UInt32 Range = vs->Range;
+ UInt32 Code = vs->Code;
+ #ifdef _LZMA_IN_CB
+ const Byte *Buffer = vs->Buffer;
+ const Byte *BufferLim = vs->BufferLim;
+ #else
+ const Byte *Buffer = inStream;
+ const Byte *BufferLim = inStream + inSize;
+ #endif
+ int state = vs->State;
+ UInt32 rep0 = vs->Reps[0], rep1 = vs->Reps[1], rep2 = vs->Reps[2], rep3 = vs->Reps[3];
+ int len = vs->RemainLen;
+ UInt32 globalPos = vs->GlobalPos;
+ UInt32 distanceLimit = vs->DistanceLimit;
+
+ Byte *dictionary = vs->Dictionary;
+ UInt32 dictionarySize = vs->Properties.DictionarySize;
+ UInt32 dictionaryPos = vs->DictionaryPos;
+
+ Byte tempDictionary[4];
+
+ #ifndef _LZMA_IN_CB
+ *inSizeProcessed = 0;
+ #endif
+ *outSizeProcessed = 0;
+ if (len == kLzmaStreamWasFinishedId)
+ return LZMA_RESULT_OK;
+
+ if (dictionarySize == 0)
+ {
+ dictionary = tempDictionary;
+ dictionarySize = 1;
+ tempDictionary[0] = vs->TempDictionary[0];
+ }
+
+ if (len == kLzmaNeedInitId)
+ {
+ {
+ UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (lc + vs->Properties.lp));
+ UInt32 i;
+ for (i = 0; i < numProbs; i++)
+ p[i] = kBitModelTotal >> 1;
+ rep0 = rep1 = rep2 = rep3 = 1;
+ state = 0;
+ globalPos = 0;
+ distanceLimit = 0;
+ dictionaryPos = 0;
+ dictionary[dictionarySize - 1] = 0;
+ #ifdef _LZMA_IN_CB
+ RC_INIT;
+ #else
+ RC_INIT(inStream, inSize);
+ #endif
+ }
+ len = 0;
+ }
+ while(len != 0 && nowPos < outSize)
+ {
+ UInt32 pos = dictionaryPos - rep0;
+ if (pos >= dictionarySize)
+ pos += dictionarySize;
+ outStream[nowPos++] = dictionary[dictionaryPos] = dictionary[pos];
+ if (++dictionaryPos == dictionarySize)
+ dictionaryPos = 0;
+ len--;
+ }
+ if (dictionaryPos == 0)
+ previousByte = dictionary[dictionarySize - 1];
+ else
+ previousByte = dictionary[dictionaryPos - 1];
+
+ #else /* if !_LZMA_OUT_READ */
+
+ int state = 0;
+ UInt32 rep0 = 1, rep1 = 1, rep2 = 1, rep3 = 1;
+ int len = 0;
+ const Byte *Buffer;
+ const Byte *BufferLim;
+ UInt32 Range;
+ UInt32 Code;
+
+ #ifndef _LZMA_IN_CB
+ *inSizeProcessed = 0;
+ #endif
+ *outSizeProcessed = 0;
+
+ {
+ UInt32 i;
+ UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (lc + vs->Properties.lp));
+ for (i = 0; i < numProbs; i++)
+ p[i] = kBitModelTotal >> 1;
+ }
+
+ #ifdef _LZMA_IN_CB
+ RC_INIT;
+ #else
+ RC_INIT(inStream, inSize);
+ #endif
+
+ #endif /* _LZMA_OUT_READ */
+
+ while(nowPos < outSize)
+ {
+ CProb *prob;
+ UInt32 bound;
+ int posState = (int)(
+ (nowPos
+ #ifdef _LZMA_OUT_READ
+ + globalPos
+ #endif
+ )
+ & posStateMask);
+
+ prob = p + IsMatch + (state << kNumPosBitsMax) + posState;
+ IfBit0(prob)
+ {
+ int symbol = 1;
+ UpdateBit0(prob)
+ prob = p + Literal + (LZMA_LIT_SIZE *
+ (((
+ (nowPos
+ #ifdef _LZMA_OUT_READ
+ + globalPos
+ #endif
+ )
+ & literalPosMask) << lc) + (previousByte >> (8 - lc))));
+
+ if (state >= kNumLitStates)
+ {
+ int matchByte;
+ #ifdef _LZMA_OUT_READ
+ UInt32 pos = dictionaryPos - rep0;
+ if (pos >= dictionarySize)
+ pos += dictionarySize;
+ matchByte = dictionary[pos];
+ #else
+ matchByte = outStream[nowPos - rep0];
+ #endif
+ do
+ {
+ int bit;
+ CProb *probLit;
+ matchByte <<= 1;
+ bit = (matchByte & 0x100);
+ probLit = prob + 0x100 + bit + symbol;
+ RC_GET_BIT2(probLit, symbol, if (bit != 0) break, if (bit == 0) break)
+ }
+ while (symbol < 0x100);
+ }
+ while (symbol < 0x100)
+ {
+ CProb *probLit = prob + symbol;
+ RC_GET_BIT(probLit, symbol)
+ }
+ previousByte = (Byte)symbol;
+
+ outStream[nowPos++] = previousByte;
+ #ifdef _LZMA_OUT_READ
+ if (distanceLimit < dictionarySize)
+ distanceLimit++;
+
+ dictionary[dictionaryPos] = previousByte;
+ if (++dictionaryPos == dictionarySize)
+ dictionaryPos = 0;
+ #endif
+ if (state < 4) state = 0;
+ else if (state < 10) state -= 3;
+ else state -= 6;
+ }
+ else
+ {
+ UpdateBit1(prob);
+ prob = p + IsRep + state;
+ IfBit0(prob)
+ {
+ UpdateBit0(prob);
+ rep3 = rep2;
+ rep2 = rep1;
+ rep1 = rep0;
+ state = state < kNumLitStates ? 0 : 3;
+ prob = p + LenCoder;
+ }
+ else
+ {
+ UpdateBit1(prob);
+ prob = p + IsRepG0 + state;
+ IfBit0(prob)
+ {
+ UpdateBit0(prob);
+ prob = p + IsRep0Long + (state << kNumPosBitsMax) + posState;
+ IfBit0(prob)
+ {
+ #ifdef _LZMA_OUT_READ
+ UInt32 pos;
+ #endif
+ UpdateBit0(prob);
+
+ #ifdef _LZMA_OUT_READ
+ if (distanceLimit == 0)
+ #else
+ if (nowPos == 0)
+ #endif
+ return LZMA_RESULT_DATA_ERROR;
+
+ state = state < kNumLitStates ? 9 : 11;
+ #ifdef _LZMA_OUT_READ
+ pos = dictionaryPos - rep0;
+ if (pos >= dictionarySize)
+ pos += dictionarySize;
+ previousByte = dictionary[pos];
+ dictionary[dictionaryPos] = previousByte;
+ if (++dictionaryPos == dictionarySize)
+ dictionaryPos = 0;
+ #else
+ previousByte = outStream[nowPos - rep0];
+ #endif
+ outStream[nowPos++] = previousByte;
+ #ifdef _LZMA_OUT_READ
+ if (distanceLimit < dictionarySize)
+ distanceLimit++;
+ #endif
+
+ continue;
+ }
+ else
+ {
+ UpdateBit1(prob);
+ }
+ }
+ else
+ {
+ UInt32 distance;
+ UpdateBit1(prob);
+ prob = p + IsRepG1 + state;
+ IfBit0(prob)
+ {
+ UpdateBit0(prob);
+ distance = rep1;
+ }
+ else
+ {
+ UpdateBit1(prob);
+ prob = p + IsRepG2 + state;
+ IfBit0(prob)
+ {
+ UpdateBit0(prob);
+ distance = rep2;
+ }
+ else
+ {
+ UpdateBit1(prob);
+ distance = rep3;
+ rep3 = rep2;
+ }
+ rep2 = rep1;
+ }
+ rep1 = rep0;
+ rep0 = distance;
+ }
+ state = state < kNumLitStates ? 8 : 11;
+ prob = p + RepLenCoder;
+ }
+ {
+ int numBits, offset;
+ CProb *probLen = prob + LenChoice;
+ IfBit0(probLen)
+ {
+ UpdateBit0(probLen);
+ probLen = prob + LenLow + (posState << kLenNumLowBits);
+ offset = 0;
+ numBits = kLenNumLowBits;
+ }
+ else
+ {
+ UpdateBit1(probLen);
+ probLen = prob + LenChoice2;
+ IfBit0(probLen)
+ {
+ UpdateBit0(probLen);
+ probLen = prob + LenMid + (posState << kLenNumMidBits);
+ offset = kLenNumLowSymbols;
+ numBits = kLenNumMidBits;
+ }
+ else
+ {
+ UpdateBit1(probLen);
+ probLen = prob + LenHigh;
+ offset = kLenNumLowSymbols + kLenNumMidSymbols;
+ numBits = kLenNumHighBits;
+ }
+ }
+ RangeDecoderBitTreeDecode(probLen, numBits, len);
+ len += offset;
+ }
+
+ if (state < 4)
+ {
+ int posSlot;
+ state += kNumLitStates;
+ prob = p + PosSlot +
+ ((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) <<
+ kNumPosSlotBits);
+ RangeDecoderBitTreeDecode(prob, kNumPosSlotBits, posSlot);
+ if (posSlot >= kStartPosModelIndex)
+ {
+ int numDirectBits = ((posSlot >> 1) - 1);
+ rep0 = (2 | ((UInt32)posSlot & 1));
+ if (posSlot < kEndPosModelIndex)
+ {
+ rep0 <<= numDirectBits;
+ prob = p + SpecPos + rep0 - posSlot - 1;
+ }
+ else
+ {
+ numDirectBits -= kNumAlignBits;
+ do
+ {
+ RC_NORMALIZE
+ Range >>= 1;
+ rep0 <<= 1;
+ if (Code >= Range)
+ {
+ Code -= Range;
+ rep0 |= 1;
+ }
+ }
+ while (--numDirectBits != 0);
+ prob = p + Align;
+ rep0 <<= kNumAlignBits;
+ numDirectBits = kNumAlignBits;
+ }
+ {
+ int i = 1;
+ int mi = 1;
+ do
+ {
+ CProb *prob3 = prob + mi;
+ RC_GET_BIT2(prob3, mi, ; , rep0 |= i);
+ i <<= 1;
+ }
+ while(--numDirectBits != 0);
+ }
+ }
+ else
+ rep0 = posSlot;
+ if (++rep0 == (UInt32)(0))
+ {
+ /* it's for stream version */
+ len = kLzmaStreamWasFinishedId;
+ break;
+ }
+ }
+
+ len += kMatchMinLen;
+ #ifdef _LZMA_OUT_READ
+ if (rep0 > distanceLimit)
+ #else
+ if (rep0 > nowPos)
+ #endif
+ return LZMA_RESULT_DATA_ERROR;
+
+ #ifdef _LZMA_OUT_READ
+ if (dictionarySize - distanceLimit > (UInt32)len)
+ distanceLimit += len;
+ else
+ distanceLimit = dictionarySize;
+ #endif
+
+ do
+ {
+ #ifdef _LZMA_OUT_READ
+ UInt32 pos = dictionaryPos - rep0;
+ if (pos >= dictionarySize)
+ pos += dictionarySize;
+ previousByte = dictionary[pos];
+ dictionary[dictionaryPos] = previousByte;
+ if (++dictionaryPos == dictionarySize)
+ dictionaryPos = 0;
+ #else
+ previousByte = outStream[nowPos - rep0];
+ #endif
+ len--;
+ outStream[nowPos++] = previousByte;
+ }
+ while(len != 0 && nowPos < outSize);
+ }
+ }
+ RC_NORMALIZE;
+
+ #ifdef _LZMA_OUT_READ
+ vs->Range = Range;
+ vs->Code = Code;
+ vs->DictionaryPos = dictionaryPos;
+ vs->GlobalPos = globalPos + (UInt32)nowPos;
+ vs->DistanceLimit = distanceLimit;
+ vs->Reps[0] = rep0;
+ vs->Reps[1] = rep1;
+ vs->Reps[2] = rep2;
+ vs->Reps[3] = rep3;
+ vs->State = state;
+ vs->RemainLen = len;
+ vs->TempDictionary[0] = tempDictionary[0];
+ #endif
+
+ #ifdef _LZMA_IN_CB
+ vs->Buffer = Buffer;
+ vs->BufferLim = BufferLim;
+ #else
+ *inSizeProcessed = (SizeT)(Buffer - inStream);
+ #endif
+ *outSizeProcessed = nowPos;
+ return LZMA_RESULT_OK;
+}
-/* \r
- LzmaDecode.h\r
- LZMA Decoder interface\r
-\r
- LZMA SDK 4.21 Copyright (c) 1999-2005 Igor Pavlov (2005-06-08)\r
- http://www.7-zip.org/\r
-\r
- LZMA SDK is licensed under two licenses:\r
- 1) GNU Lesser General Public License (GNU LGPL)\r
- 2) Common Public License (CPL)\r
- It means that you can select one of these two licenses and \r
- follow rules of that license.\r
-\r
- SPECIAL EXCEPTION:\r
- Igor Pavlov, as the author of this code, expressly permits you to \r
- statically or dynamically link your code (or bind by name) to the \r
- interfaces of this file without subjecting your linked code to the \r
- terms of the CPL or GNU LGPL. Any modifications or additions \r
- to this file, however, are subject to the LGPL or CPL terms.\r
-*/\r
-\r
-#ifndef __LZMADECODE_H\r
-#define __LZMADECODE_H\r
-\r
-/* #define _LZMA_IN_CB */\r
-/* Use callback for input data */\r
-\r
-/* #define _LZMA_OUT_READ */\r
-/* Use read function for output data */\r
-\r
-/* #define _LZMA_PROB32 */\r
-/* It can increase speed on some 32-bit CPUs, \r
- but memory usage will be doubled in that case */\r
-\r
-/* #define _LZMA_LOC_OPT */\r
-/* Enable local speed optimizations inside code */\r
-\r
-/* #define _LZMA_SYSTEM_SIZE_T */\r
-/* Use system's size_t. You can use it to enable 64-bit sizes supporting*/\r
-\r
-#ifndef UInt32\r
-#ifdef _LZMA_UINT32_IS_ULONG\r
-#define UInt32 unsigned long\r
-#else\r
-#define UInt32 unsigned int\r
-#endif\r
-#endif\r
-\r
-#ifndef SizeT\r
-#ifdef _LZMA_SYSTEM_SIZE_T\r
-#include <stddef.h>\r
-#define SizeT size_t\r
-#else\r
-#define SizeT UInt32\r
-#endif\r
-#endif\r
-\r
-#ifdef _LZMA_PROB32\r
-#define CProb UInt32\r
-#else\r
-#define CProb unsigned short\r
-#endif\r
-\r
-#define LZMA_RESULT_OK 0\r
-#define LZMA_RESULT_DATA_ERROR 1\r
-\r
-#ifdef _LZMA_IN_CB\r
-typedef struct _ILzmaInCallback\r
-{\r
- int (*Read)(void *object, const unsigned char **buffer, SizeT *bufferSize);\r
-} ILzmaInCallback;\r
-#endif\r
-\r
-#define LZMA_BASE_SIZE 1846\r
-#define LZMA_LIT_SIZE 768\r
-\r
-#define LZMA_PROPERTIES_SIZE 5\r
-\r
-typedef struct _CLzmaProperties\r
-{\r
- int lc;\r
- int lp;\r
- int pb;\r
- #ifdef _LZMA_OUT_READ\r
- UInt32 DictionarySize;\r
- #endif\r
-}CLzmaProperties;\r
-\r
-int LzmaDecodeProperties(CLzmaProperties *propsRes, const unsigned char *propsData, int size);\r
-\r
-#define LzmaGetNumProbs(Properties) (LZMA_BASE_SIZE + (LZMA_LIT_SIZE << ((Properties)->lc + (Properties)->lp)))\r
-\r
-#define kLzmaNeedInitId (-2)\r
-\r
-typedef struct _CLzmaDecoderState\r
-{\r
- CLzmaProperties Properties;\r
- CProb *Probs;\r
-\r
- #ifdef _LZMA_IN_CB\r
- const unsigned char *Buffer;\r
- const unsigned char *BufferLim;\r
- #endif\r
-\r
- #ifdef _LZMA_OUT_READ\r
- unsigned char *Dictionary;\r
- UInt32 Range;\r
- UInt32 Code;\r
- UInt32 DictionaryPos;\r
- UInt32 GlobalPos;\r
- UInt32 DistanceLimit;\r
- UInt32 Reps[4];\r
- int State;\r
- int RemainLen;\r
- unsigned char TempDictionary[4];\r
- #endif\r
-} CLzmaDecoderState;\r
-\r
-#ifdef _LZMA_OUT_READ\r
-#define LzmaDecoderInit(vs) { (vs)->RemainLen = kLzmaNeedInitId; }\r
-#endif\r
-\r
-int LzmaDecode(CLzmaDecoderState *vs,\r
- #ifdef _LZMA_IN_CB\r
- ILzmaInCallback *inCallback,\r
- #else\r
- const unsigned char *inStream, SizeT inSize, SizeT *inSizeProcessed,\r
- #endif\r
- unsigned char *outStream, SizeT outSize, SizeT *outSizeProcessed);\r
-\r
-#endif\r
+/*
+ LzmaDecode.h
+ LZMA Decoder interface
+
+ LZMA SDK 4.21 Copyright (c) 1999-2005 Igor Pavlov (2005-06-08)
+ http://www.7-zip.org/
+
+ LZMA SDK is licensed under two licenses:
+ 1) GNU Lesser General Public License (GNU LGPL)
+ 2) Common Public License (CPL)
+ It means that you can select one of these two licenses and
+ follow rules of that license.
+
+ SPECIAL EXCEPTION:
+ Igor Pavlov, as the author of this code, expressly permits you to
+ statically or dynamically link your code (or bind by name) to the
+ interfaces of this file without subjecting your linked code to the
+ terms of the CPL or GNU LGPL. Any modifications or additions
+ to this file, however, are subject to the LGPL or CPL terms.
+*/
+
+#ifndef __LZMADECODE_H
+#define __LZMADECODE_H
+
+/* #define _LZMA_IN_CB */
+/* Use callback for input data */
+
+/* #define _LZMA_OUT_READ */
+/* Use read function for output data */
+
+/* #define _LZMA_PROB32 */
+/* It can increase speed on some 32-bit CPUs,
+ but memory usage will be doubled in that case */
+
+/* #define _LZMA_LOC_OPT */
+/* Enable local speed optimizations inside code */
+
+/* #define _LZMA_SYSTEM_SIZE_T */
+/* Use system's size_t. You can use it to enable 64-bit sizes supporting*/
+
+#ifndef UInt32
+#ifdef _LZMA_UINT32_IS_ULONG
+#define UInt32 unsigned long
+#else
+#define UInt32 unsigned int
+#endif
+#endif
+
+#ifndef SizeT
+#ifdef _LZMA_SYSTEM_SIZE_T
+#include <stddef.h>
+#define SizeT size_t
+#else
+#define SizeT UInt32
+#endif
+#endif
+
+#ifdef _LZMA_PROB32
+#define CProb UInt32
+#else
+#define CProb unsigned short
+#endif
+
+#define LZMA_RESULT_OK 0
+#define LZMA_RESULT_DATA_ERROR 1
+
+#ifdef _LZMA_IN_CB
+typedef struct _ILzmaInCallback
+{
+ int (*Read)(void *object, const unsigned char **buffer, SizeT *bufferSize);
+} ILzmaInCallback;
+#endif
+
+#define LZMA_BASE_SIZE 1846
+#define LZMA_LIT_SIZE 768
+
+#define LZMA_PROPERTIES_SIZE 5
+
+typedef struct _CLzmaProperties
+{
+ int lc;
+ int lp;
+ int pb;
+ #ifdef _LZMA_OUT_READ
+ UInt32 DictionarySize;
+ #endif
+}CLzmaProperties;
+
+int LzmaDecodeProperties(CLzmaProperties *propsRes, const unsigned char *propsData, int size);
+
+#define LzmaGetNumProbs(Properties) (LZMA_BASE_SIZE + (LZMA_LIT_SIZE << ((Properties)->lc + (Properties)->lp)))
+
+#define kLzmaNeedInitId (-2)
+
+typedef struct _CLzmaDecoderState
+{
+ CLzmaProperties Properties;
+ CProb *Probs;
+
+ #ifdef _LZMA_IN_CB
+ const unsigned char *Buffer;
+ const unsigned char *BufferLim;
+ #endif
+
+ #ifdef _LZMA_OUT_READ
+ unsigned char *Dictionary;
+ UInt32 Range;
+ UInt32 Code;
+ UInt32 DictionaryPos;
+ UInt32 GlobalPos;
+ UInt32 DistanceLimit;
+ UInt32 Reps[4];
+ int State;
+ int RemainLen;
+ unsigned char TempDictionary[4];
+ #endif
+} CLzmaDecoderState;
+
+#ifdef _LZMA_OUT_READ
+#define LzmaDecoderInit(vs) { (vs)->RemainLen = kLzmaNeedInitId; }
+#endif
+
+int LzmaDecode(CLzmaDecoderState *vs,
+ #ifdef _LZMA_IN_CB
+ ILzmaInCallback *inCallback,
+ #else
+ const unsigned char *inStream, SizeT inSize, SizeT *inSizeProcessed,
+ #endif
+ unsigned char *outStream, SizeT outSize, SizeT *outSizeProcessed);
+
+#endif
projects / openwrt.git / commitdiff