--- /dev/null
+From d37394e9ca1b85407408719feb2468c5affefa4a Mon Sep 17 00:00:00 2001
+From: Gabor Juhos <juhosg at openwrt.org>
+Date: Fri, 9 May 2008 17:26:14 +0200
+Subject: [PATCH] add LZMA decompression support
+
+---
+ common/cmd_bootm.c | 18 ++
+ common/image.c | 1 +
+ include/LzmaWrapper.h | 36 +++
+ include/image.h | 1 +
+ lib_generic/LzmaDecode.c | 602 +++++++++++++++++++++++++++++++++++++++++++++
+ lib_generic/LzmaDecode.h | 113 +++++++++
+ lib_generic/LzmaTypes.h | 45 ++++
+ lib_generic/LzmaWrapper.c | 197 +++++++++++++++
+ lib_generic/Makefile | 2 +
+ 9 files changed, 1015 insertions(+), 0 deletions(-)
+ create mode 100644 include/LzmaWrapper.h
+ create mode 100644 lib_generic/LzmaDecode.c
+ create mode 100644 lib_generic/LzmaDecode.h
+ create mode 100644 lib_generic/LzmaTypes.h
+ create mode 100644 lib_generic/LzmaWrapper.c
+
+diff --git a/common/cmd_bootm.c b/common/cmd_bootm.c
+index 0d67132..6071817 100644
+--- a/common/cmd_bootm.c
++++ b/common/cmd_bootm.c
+@@ -32,6 +32,7 @@
+ #include <malloc.h>
+ #include <zlib.h>
+ #include <bzlib.h>
++#include <LzmaWrapper.h>
+ #include <environment.h>
+ #include <lmb.h>
+ #include <asm/byteorder.h>
+@@ -237,6 +238,7 @@ int do_bootm (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
+ puts("OK\n");
+ }
+ break;
++#ifndef CONFIG_NO_GZIP
+ case IH_COMP_GZIP:
+ printf (" Uncompressing %s ... ", type_name);
+ if (gunzip ((void *)load_start, unc_len,
+@@ -249,6 +251,7 @@ int do_bootm (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
+
+ load_end = load_start + os_len;
+ break;
++#endif
+ #ifdef CONFIG_BZIP2
+ case IH_COMP_BZIP2:
+ printf (" Uncompressing %s ... ", type_name);
+@@ -270,6 +273,21 @@ int do_bootm (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
+ load_end = load_start + unc_len;
+ break;
+ #endif /* CONFIG_BZIP2 */
++#ifdef CONFIG_LZMA
++ case IH_COMP_LZMA:
++ printf (" Uncompressing %s ... ", type_name);
++ int i = lzma_inflate ((unsigned char *)os_data, os_len,
++ (unsigned char *)load_start, &unc_len);
++ if (i != LZMA_RESULT_OK) {
++ printf ("LZMA: uncompress or overwrite error %d "
++ "- must RESET board to recover\n", i);
++ show_boot_progress (-6);
++ do_reset (cmdtp, flag, argc, argv);
++ }
++
++ load_end = load_start + unc_len;
++ break;
++#endif /* CONFIG_LZMA */
+ default:
+ if (iflag)
+ enable_interrupts();
+diff --git a/common/image.c b/common/image.c
+index 67e594d..9b42ae9 100644
+--- a/common/image.c
++++ b/common/image.c
+@@ -148,6 +148,7 @@ static table_entry_t uimage_comp[] = {
+ { IH_COMP_NONE, "none", "uncompressed", },
+ { IH_COMP_BZIP2, "bzip2", "bzip2 compressed", },
+ { IH_COMP_GZIP, "gzip", "gzip compressed", },
++ { IH_COMP_LZMA, "lzma", "lzma compressed", },
+ { -1, "", "", },
+ };
+
+diff --git a/include/LzmaWrapper.h b/include/LzmaWrapper.h
+new file mode 100644
+index 0000000..2f9a3ff
+--- /dev/null
++++ b/include/LzmaWrapper.h
+@@ -0,0 +1,36 @@
++/******************************************************************************
++**
++** FILE NAME : LzmaWrapper.h
++** PROJECT : bootloader
++** MODULES : U-boot
++**
++** DATE : 2 Nov 2006
++** AUTHOR : Lin Mars
++** DESCRIPTION : LZMA decoder support for U-boot 1.1.5
++** COPYRIGHT : Copyright (c) 2006
++** Infineon Technologies AG
++** Am Campeon 1-12, 85579 Neubiberg, Germany
++**
++** This program is free software; you can redistribute it and/or modify
++** it under the terms of the GNU General Public License as published by
++** the Free Software Foundation; either version 2 of the License, or
++** (at your option) any later version.
++**
++** HISTORY
++** $Date $Author $Comment
++** 2 Nov 2006 Lin Mars init version which derived from LzmaTest.c from
++** LZMA v4.43 SDK
++*******************************************************************************/
++#ifndef __LZMA_WRAPPER_H__
++#define __LZMA_WRAPPER_H__
++
++#ifndef LZMA_RESULT_OK
++#define LZMA_RESULT_OK 0
++#endif
++#ifndef LZMA_RESULT_DATA_ERROR
++#define LZMA_RESULT_DATA_ERROR 1
++#endif
++
++extern int lzma_inflate(unsigned char *source, int s_len, unsigned char *dest, int *d_len);
++
++#endif /*__LZMA_WRAPPER_H__*/
+diff --git a/include/image.h b/include/image.h
+index 664e51e..6de51c4 100644
+--- a/include/image.h
++++ b/include/image.h
+@@ -164,6 +164,7 @@
+ #define IH_COMP_NONE 0 /* No Compression Used */
+ #define IH_COMP_GZIP 1 /* gzip Compression Used */
+ #define IH_COMP_BZIP2 2 /* bzip2 Compression Used */
++#define IH_COMP_LZMA 3 /* lzma Compression used */
+
+ #define IH_MAGIC 0x27051956 /* Image Magic Number */
+ #define IH_NMLEN 32 /* Image Name Length */
+diff --git a/lib_generic/LzmaDecode.c b/lib_generic/LzmaDecode.c
+new file mode 100644
+index 0000000..d876e8b
+--- /dev/null
++++ b/lib_generic/LzmaDecode.c
+@@ -0,0 +1,602 @@
++/*
++ LzmaDecode.c
++ LZMA Decoder (optimized for Speed version)
++
++ LZMA SDK 4.40 Copyright (c) 1999-2006 Igor Pavlov (2006-05-01)
++ 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 <config.h>
++
++#ifdef CONFIG_LZMA
++
++#include "LzmaDecode.h"
++
++#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) { printf("ERROR, %s, %d\n", __FILE__, __LINE__); return result; } \
++ BufferLim = Buffer + size; if (size == 0) { printf("ERROR, %s, %d\n", __FILE__, __LINE__); return LZMA_RESULT_DATA_ERROR; } }}
++
++#define RC_INIT Buffer = BufferLim = 0; RC_INIT2
++
++#else
++
++#define RC_TEST { if (Buffer == BufferLim) { printf("ERROR, %s, %d\n", __FILE__, __LINE__); 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
++
++int LzmaDecodeProperties(CLzmaProperties *propsRes, const unsigned char *propsData, int size)
++{
++ unsigned char prop0;
++ if (size < LZMA_PROPERTIES_SIZE)
++ {
++ printf("ERROR: %s, %d\n", __FILE__, __LINE__);
++ return LZMA_RESULT_DATA_ERROR;
++ }
++ prop0 = propsData[0];
++ if (prop0 >= (9 * 5 * 5))
++ {
++ printf("ERROR: %s, %d\n", __FILE__, __LINE__);
++ 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;
++}
++
++#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
++ {
++ printf("ERROR: %s, %d\n", __FILE__, __LINE__);
++ 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
++ {
++ printf("ERROR: %s, %d\n", __FILE__, __LINE__);
++ 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;
++}
++
++#endif /* CONFIG_LZMA */
+diff --git a/lib_generic/LzmaDecode.h b/lib_generic/LzmaDecode.h
+new file mode 100644
+index 0000000..2870eeb
+--- /dev/null
++++ b/lib_generic/LzmaDecode.h
+@@ -0,0 +1,113 @@
++/*
++ LzmaDecode.h
++ LZMA Decoder interface
++
++ LZMA SDK 4.40 Copyright (c) 1999-2006 Igor Pavlov (2006-05-01)
++ 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
++
++#include "LzmaTypes.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 */
++
++#ifdef _LZMA_PROB32
++#define CProb UInt32
++#else
++#define CProb UInt16
++#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
+diff --git a/lib_generic/LzmaTypes.h b/lib_generic/LzmaTypes.h
+new file mode 100644
+index 0000000..288c5e4
+--- /dev/null
++++ b/lib_generic/LzmaTypes.h
+@@ -0,0 +1,45 @@
++/*
++LzmaTypes.h
++
++Types for LZMA Decoder
++
++This file written and distributed to public domain by Igor Pavlov.
++This file is part of LZMA SDK 4.40 (2006-05-01)
++*/
++
++#ifndef __LZMATYPES_H
++#define __LZMATYPES_H
++
++#ifndef _7ZIP_BYTE_DEFINED
++#define _7ZIP_BYTE_DEFINED
++typedef unsigned char Byte;
++#endif
++
++#ifndef _7ZIP_UINT16_DEFINED
++#define _7ZIP_UINT16_DEFINED
++typedef unsigned short UInt16;
++#endif
++
++#ifndef _7ZIP_UINT32_DEFINED
++#define _7ZIP_UINT32_DEFINED
++#ifdef _LZMA_UINT32_IS_ULONG
++typedef unsigned long UInt32;
++#else
++typedef unsigned int UInt32;
++#endif
++#endif
++
++/* #define _LZMA_SYSTEM_SIZE_T */
++/* Use system's size_t. You can use it to enable 64-bit sizes supporting */
++
++#ifndef _7ZIP_SIZET_DEFINED
++#define _7ZIP_SIZET_DEFINED
++#ifdef _LZMA_SYSTEM_SIZE_T
++#include <stddef.h>
++typedef size_t SizeT;
++#else
++typedef UInt32 SizeT;
++#endif
++#endif
++
++#endif
+diff --git a/lib_generic/LzmaWrapper.c b/lib_generic/LzmaWrapper.c
+new file mode 100644
+index 0000000..6c3d702
+--- /dev/null
++++ b/lib_generic/LzmaWrapper.c
+@@ -0,0 +1,197 @@
++/******************************************************************************
++**
++** FILE NAME : LzmaWrapper.c
++** PROJECT : bootloader
++** MODULES : U-boot
++**
++** DATE : 2 Nov 2006
++** AUTHOR : Lin Mars
++** DESCRIPTION : LZMA decoder support for U-boot 1.1.5
++** COPYRIGHT : Copyright (c) 2006
++** Infineon Technologies AG
++** Am Campeon 1-12, 85579 Neubiberg, Germany
++**
++** This program is free software; you can redistribute it and/or modify
++** it under the terms of the GNU General Public License as published by
++** the Free Software Foundation; either version 2 of the License, or
++** (at your option) any later version.
++**
++** HISTORY
++** $Date $Author $Comment
++** 2 Nov 2006 Lin Mars init version which derived from LzmaTest.c from
++** LZMA v4.43 SDK
++*******************************************************************************/
++#define LZMA_NO_STDIO
++#ifndef LZMA_NO_STDIO
++#include <stdio.h>
++#include <stdlib.h>
++#include <string.h>
++#endif
++
++#include <config.h>
++#include <common.h>
++#include <linux/types.h>
++#include <linux/string.h>
++#include <linux/ctype.h>
++#include <malloc.h>
++
++#ifdef CONFIG_LZMA
++
++#include "LzmaDecode.h"
++#include "LzmaWrapper.h"
++
++static const char *kCantReadMessage = "Can not read from source buffer";
++static const char *kCantAllocateMessage = "Not enough buffer for decompression";
++
++static size_t rpos=0, dpos=0;
++
++static int MyReadFileAndCheck(unsigned char *src, void *dest, size_t size)
++{
++ if (size == 0)
++ return 0;
++ memcpy(dest, src + rpos, size);
++ rpos += size;
++ return 1;
++}
++
++int lzma_inflate(unsigned char *source, int s_len, unsigned char *dest, int *d_len)
++{
++ /* We use two 32-bit integers to construct 64-bit integer for file size.
++ You can remove outSizeHigh, if you don't need >= 4GB supporting,
++ or you can use UInt64 outSize, if your compiler supports 64-bit integers*/
++ UInt32 outSize = 0;
++ UInt32 outSizeHigh = 0;
++ SizeT outSizeFull;
++ unsigned char *outStream;
++
++ int waitEOS = 1;
++ /* waitEOS = 1, if there is no uncompressed size in headers,
++ so decoder will wait EOS (End of Stream Marker) in compressed stream */
++
++ SizeT compressedSize;
++ unsigned char *inStream;
++
++ CLzmaDecoderState state; /* it's about 24-80 bytes structure, if int is 32-bit */
++ unsigned char properties[LZMA_PROPERTIES_SIZE];
++
++ int res;
++
++ if (sizeof(UInt32) < 4)
++ {
++ printf("LZMA decoder needs correct UInt32\n");
++ return LZMA_RESULT_DATA_ERROR;
++ }
++
++ {
++ long length=s_len;
++ if ((long)(SizeT)length != length)
++ {
++ printf("Too big compressed stream\n");
++ return LZMA_RESULT_DATA_ERROR;
++ }
++ compressedSize = (SizeT)(length - (LZMA_PROPERTIES_SIZE + 8));
++ }
++
++ /* Read LZMA properties for compressed stream */
++
++ if (!MyReadFileAndCheck(source, properties, sizeof(properties)))
++ {
++ printf("%s\n", kCantReadMessage);
++ return LZMA_RESULT_DATA_ERROR;
++ }
++
++ /* Read uncompressed size */
++ {
++ int i;
++ for (i = 0; i < 8; i++)
++ {
++ unsigned char b;
++ if (!MyReadFileAndCheck(source, &b, 1))
++ {
++ printf("%s\n", kCantReadMessage);
++ return LZMA_RESULT_DATA_ERROR;
++ }
++ if (b != 0xFF)
++ waitEOS = 0;
++ if (i < 4)
++ outSize += (UInt32)(b) << (i * 8);
++ else
++ outSizeHigh += (UInt32)(b) << ((i - 4) * 8);
++ }
++
++ if (waitEOS)
++ {
++ printf("Stream with EOS marker is not supported");
++ return LZMA_RESULT_DATA_ERROR;
++ }
++ outSizeFull = (SizeT)outSize;
++ if (sizeof(SizeT) >= 8)
++ outSizeFull |= (((SizeT)outSizeHigh << 16) << 16);
++ else if (outSizeHigh != 0 || (UInt32)(SizeT)outSize != outSize)
++ {
++ printf("Too big uncompressed stream");
++ return LZMA_RESULT_DATA_ERROR;
++ }
++ }
++
++ /* Decode LZMA properties and allocate memory */
++ if (LzmaDecodeProperties(&state.Properties, properties, LZMA_PROPERTIES_SIZE) != LZMA_RESULT_OK)
++ {
++ printf("Incorrect stream properties");
++ return LZMA_RESULT_DATA_ERROR;
++ }
++ state.Probs = (CProb *)malloc(LzmaGetNumProbs(&state.Properties) * sizeof(CProb));
++
++ if (outSizeFull == 0)
++ outStream = 0;
++ else
++ {
++ if (outSizeFull > d_len)
++ outStream = 0;
++ else
++ outStream = dest;
++ }
++
++ if (compressedSize == 0)
++ inStream = 0;
++ else
++ {
++ if ((compressedSize+rpos) > s_len )
++ inStream = 0;
++ else
++ inStream = source + rpos;
++ }
++
++ if (state.Probs == 0
++ || (outStream == 0 && outSizeFull != 0)
++ || (inStream == 0 && compressedSize != 0)
++ )
++ {
++ free(state.Probs);
++ printf("%s\n", kCantAllocateMessage);
++ return LZMA_RESULT_DATA_ERROR;
++ }
++
++ /* Decompress */
++ {
++ SizeT inProcessed;
++ SizeT outProcessed;
++ res = LzmaDecode(&state,
++ inStream, compressedSize, &inProcessed,
++ outStream, outSizeFull, &outProcessed);
++ if (res != 0)
++ {
++ printf("\nDecoding error = %d\n", res);
++ res = 1;
++ }
++ else
++ {
++ *d_len = outProcessed;
++ }
++ }
++
++ free(state.Probs);
++ return res;
++}
++
++#endif /* CONFIG_LZMA */
+diff --git a/lib_generic/Makefile b/lib_generic/Makefile
+index abee19a..449e994 100644
+--- a/lib_generic/Makefile
++++ b/lib_generic/Makefile
+@@ -41,6 +41,8 @@ COBJS-y += sha1.o
+ COBJS-y += string.o
+ COBJS-y += vsprintf.o
+ COBJS-y += zlib.o
++COBJS-y += LzmaDecode.o
++COBJS-y += LzmaWrapper.o
+
+ COBJS := $(COBJS-y)
+ SRCS := $(COBJS:.o=.c)
+--
+1.5.3.2
+
projects / openwrt.git / commitdiff