mirror of
git://projects.qi-hardware.com/openwrt-xburst.git
synced 2024-12-25 02:48:37 +02:00
temporary, hackish, etc, etc.. lzma support for the arm zImage loader
git-svn-id: svn://svn.openwrt.org/openwrt/trunk@16284 3c298f89-4303-0410-b956-a3cf2f4a3e73
This commit is contained in:
parent
51b5579c3f
commit
224b54bdaa
@ -0,0 +1,911 @@
|
||||
--- /dev/null
|
||||
+++ b/arch/arm/boot/compressed/LzmaDecode.c
|
||||
@@ -0,0 +1,590 @@
|
||||
+/*
|
||||
+ 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;
|
||||
+}
|
||||
--- /dev/null
|
||||
+++ b/arch/arm/boot/compressed/LzmaDecode.h
|
||||
@@ -0,0 +1,131 @@
|
||||
+/*
|
||||
+ 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
|
||||
--- a/arch/arm/boot/compressed/Makefile
|
||||
+++ b/arch/arm/boot/compressed/Makefile
|
||||
@@ -5,7 +5,7 @@
|
||||
#
|
||||
|
||||
HEAD = head.o
|
||||
-OBJS = misc.o
|
||||
+OBJS = misc.o ../../lib/lib1funcs.o
|
||||
FONTC = $(srctree)/drivers/video/console/font_acorn_8x8.c
|
||||
|
||||
#
|
||||
@@ -63,7 +63,7 @@ endif
|
||||
|
||||
SEDFLAGS = s/TEXT_START/$(ZTEXTADDR)/;s/BSS_START/$(ZBSSADDR)/
|
||||
|
||||
-targets := vmlinux vmlinux.lds piggy.gz piggy.o font.o font.c \
|
||||
+targets := vmlinux vmlinux.lds piggy.lzma piggy.o font.o font.c \
|
||||
head.o misc.o $(OBJS)
|
||||
|
||||
ifeq ($(CONFIG_FUNCTION_TRACER),y)
|
||||
@@ -96,10 +96,10 @@ $(obj)/vmlinux: $(obj)/vmlinux.lds $(obj
|
||||
$(call if_changed,ld)
|
||||
@:
|
||||
|
||||
-$(obj)/piggy.gz: $(obj)/../Image FORCE
|
||||
- $(call if_changed,gzip)
|
||||
+$(obj)/piggy.lzma: $(obj)/../Image FORCE
|
||||
+ $(call if_changed,lzma)
|
||||
|
||||
-$(obj)/piggy.o: $(obj)/piggy.gz FORCE
|
||||
+$(obj)/piggy.o: $(obj)/piggy.lzma FORCE
|
||||
|
||||
CFLAGS_font.o := -Dstatic=
|
||||
|
||||
--- a/arch/arm/boot/compressed/misc.c
|
||||
+++ b/arch/arm/boot/compressed/misc.c
|
||||
@@ -202,8 +202,8 @@ typedef unsigned long ulg;
|
||||
static uch *inbuf; /* input buffer */
|
||||
static uch window[WSIZE]; /* Sliding window buffer */
|
||||
|
||||
-static unsigned insize; /* valid bytes in inbuf */
|
||||
-static unsigned inptr; /* index of next byte to be processed in inbuf */
|
||||
+static unsigned insize = 0; /* valid bytes in inbuf */
|
||||
+static unsigned inptr = 0; /* index of next byte to be processed in inbuf */
|
||||
static unsigned outcnt; /* bytes in output buffer */
|
||||
|
||||
/* gzip flag byte */
|
||||
@@ -242,7 +242,7 @@ extern char input_data[];
|
||||
extern char input_data_end[];
|
||||
|
||||
static uch *output_data;
|
||||
-static ulg output_ptr;
|
||||
+static ulg output_ptr = 0;
|
||||
static ulg bytes_out;
|
||||
|
||||
static void error(char *m);
|
||||
@@ -259,7 +259,7 @@ static ulg free_mem_end_ptr;
|
||||
|
||||
#define ARCH_HAS_DECOMP_WDOG
|
||||
|
||||
-#include "../../../../lib/inflate.c"
|
||||
+/* #include "../../../../lib/inflate.c" */
|
||||
|
||||
/* ===========================================================================
|
||||
* Fill the input buffer. This is called only when the buffer is empty
|
||||
@@ -277,6 +277,76 @@ int fill_inbuf(void)
|
||||
return inbuf[0];
|
||||
}
|
||||
|
||||
+#define _LZMA_IN_CB
|
||||
+#include "LzmaDecode.h"
|
||||
+#include "LzmaDecode.c"
|
||||
+
|
||||
+void __div0(void)
|
||||
+{
|
||||
+}
|
||||
+
|
||||
+static int read_byte(void *object, const unsigned char **buffer, SizeT *bufferSize);
|
||||
+
|
||||
+/*
|
||||
+ * Do the lzma decompression
|
||||
+ */
|
||||
+static int unlzma(void)
|
||||
+{
|
||||
+
|
||||
+ unsigned int i;
|
||||
+ CLzmaDecoderState state;
|
||||
+ unsigned int uncompressedSize = 0;
|
||||
+
|
||||
+ ILzmaInCallback callback;
|
||||
+ callback.Read = read_byte;
|
||||
+
|
||||
+ /* lzma args */
|
||||
+ i = get_byte();
|
||||
+ state.Properties.lc = i % 9, i = i / 9;
|
||||
+ state.Properties.lp = i % 5, state.Properties.pb = i / 5;
|
||||
+
|
||||
+ /* skip dictionary size */
|
||||
+ for (i = 0; i < 4; i++)
|
||||
+ get_byte();
|
||||
+ /* get uncompressed size */
|
||||
+ uncompressedSize = (get_byte()) +
|
||||
+ (get_byte() << 8) +
|
||||
+ (get_byte() << 16) +
|
||||
+ (get_byte() << 24);
|
||||
+
|
||||
+ /* skip high order bytes */
|
||||
+ for (i = 0; i < 4; i++)
|
||||
+ get_byte();
|
||||
+ /* point it beyond uncompresedSize */
|
||||
+ state.Probs = (CProb *) (output_data + uncompressedSize);
|
||||
+
|
||||
+ /* decompress kernel */
|
||||
+ if (LzmaDecode(&state, &callback,
|
||||
+ (unsigned char *)output_data, uncompressedSize, &i) == LZMA_RESULT_OK) {
|
||||
+ if (i != uncompressedSize)
|
||||
+ error("kernel corrupted!\n");
|
||||
+ /* copy it back to low_buffer */
|
||||
+ bytes_out = i;
|
||||
+ output_ptr = i;
|
||||
+ return 0;
|
||||
+ }
|
||||
+ return 1;
|
||||
+}
|
||||
+
|
||||
+static unsigned int icnt = 0;
|
||||
+
|
||||
+static int read_byte(void *object, const unsigned char **buffer, SizeT *bufferSize)
|
||||
+{
|
||||
+ static unsigned char val;
|
||||
+ *bufferSize = 1;
|
||||
+ val = get_byte();
|
||||
+ *buffer = &val;
|
||||
+ if (icnt++ % (1024 * 10) == 0)
|
||||
+ putstr(".");
|
||||
+ return LZMA_RESULT_OK;
|
||||
+}
|
||||
+
|
||||
+#if 0
|
||||
/* ===========================================================================
|
||||
* Write the output window window[0..outcnt-1] and update crc and bytes_out.
|
||||
* (Used for the decompressed data only.)
|
||||
@@ -299,6 +369,7 @@ void flush_window(void)
|
||||
outcnt = 0;
|
||||
putstr(".");
|
||||
}
|
||||
+#endif
|
||||
|
||||
#ifndef arch_error
|
||||
#define arch_error(x)
|
||||
@@ -328,9 +399,9 @@ decompress_kernel(ulg output_start, ulg
|
||||
|
||||
arch_decomp_setup();
|
||||
|
||||
- makecrc();
|
||||
+ /* makecrc(); */
|
||||
putstr("Uncompressing Linux...");
|
||||
- gunzip();
|
||||
+ unlzma();
|
||||
putstr(" done, booting the kernel.\n");
|
||||
return output_ptr;
|
||||
}
|
||||
@@ -342,9 +413,9 @@ int main()
|
||||
{
|
||||
output_data = output_buffer;
|
||||
|
||||
- makecrc();
|
||||
+ /* makecrc(); */
|
||||
putstr("Uncompressing Linux...");
|
||||
- gunzip();
|
||||
+ unlzma();
|
||||
putstr("done.\n");
|
||||
return 0;
|
||||
}
|
||||
--- a/arch/arm/boot/compressed/piggy.S
|
||||
+++ b/arch/arm/boot/compressed/piggy.S
|
||||
@@ -1,6 +1,6 @@
|
||||
.section .piggydata,#alloc
|
||||
.globl input_data
|
||||
input_data:
|
||||
- .incbin "arch/arm/boot/compressed/piggy.gz"
|
||||
+ .incbin "arch/arm/boot/compressed/piggy.lzma"
|
||||
.globl input_data_end
|
||||
input_data_end:
|
Loading…
Reference in New Issue
Block a user