Add lzma compression for x86 based targets
authorFlorian Fainelli <florian@openwrt.org>
Mon, 16 Apr 2007 06:45:05 +0000 (06:45 +0000)
committerFlorian Fainelli <florian@openwrt.org>
Mon, 16 Apr 2007 06:45:05 +0000 (06:45 +0000)
SVN-Revision: 6960

target/linux/generic-2.6/patches/600-x86_lzma.patch [new file with mode: 0644]

diff --git a/target/linux/generic-2.6/patches/600-x86_lzma.patch b/target/linux/generic-2.6/patches/600-x86_lzma.patch
new file mode 100644 (file)
index 0000000..1a94883
--- /dev/null
@@ -0,0 +1,1167 @@
+diff -Naur linux-old/arch/i386/boot/compressed/LzmaDecode.c linux-lzma/arch/i386/boot/compressed/LzmaDecode.c
+--- linux-old/arch/i386/boot/compressed/LzmaDecode.c   1969-12-31 19:00:00.000000000 -0500
++++ linux-lzma/arch/i386/boot/compressed/LzmaDecode.c  2005-06-05 00:07:38.000000000 -0400
+@@ -0,0 +1,586 @@
++/*
++  LzmaDecode.c
++  LZMA Decoder (optimized for Speed version)
++  
++  LZMA SDK 4.17 Copyright (c) 1999-2005 Igor Pavlov (2005-04-05)
++  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) \
++  { UInt32 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
++
++#ifdef _LZMA_OUT_READ
++
++typedef struct _LzmaVarState
++{
++  Byte *Buffer;
++  Byte *BufferLim;
++  UInt32 Range;
++  UInt32 Code;
++  #ifdef _LZMA_IN_CB
++  ILzmaInCallback *InCallback;
++  #endif
++  Byte *Dictionary;
++  UInt32 DictionarySize;
++  UInt32 DictionaryPos;
++  UInt32 GlobalPos;
++  UInt32 Reps[4];
++  int lc;
++  int lp;
++  int pb;
++  int State;
++  int RemainLen;
++  Byte TempDictionary[4];
++} LzmaVarState;
++
++int LzmaDecoderInit(
++    unsigned char *buffer, UInt32 bufferSize,
++    int lc, int lp, int pb,
++    unsigned char *dictionary, UInt32 dictionarySize,
++    #ifdef _LZMA_IN_CB
++    ILzmaInCallback *InCallback
++    #else
++    unsigned char *inStream, UInt32 inSize
++    #endif
++    )
++{
++  Byte *Buffer;
++  Byte *BufferLim;
++  UInt32 Range;
++  UInt32 Code;
++  LzmaVarState *vs = (LzmaVarState *)buffer;
++  CProb *p = (CProb *)(buffer + sizeof(LzmaVarState));
++  UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (lc + lp));
++  UInt32 i;
++  if (bufferSize < numProbs * sizeof(CProb) + sizeof(LzmaVarState))
++    return LZMA_RESULT_NOT_ENOUGH_MEM;
++  vs->Dictionary = dictionary;
++  vs->DictionarySize = dictionarySize;
++  vs->DictionaryPos = 0;
++  vs->GlobalPos = 0;
++  vs->Reps[0] = vs->Reps[1] = vs->Reps[2] = vs->Reps[3] = 1;
++  vs->lc = lc;
++  vs->lp = lp;
++  vs->pb = pb;
++  vs->State = 0;
++  vs->RemainLen = 0;
++  dictionary[dictionarySize - 1] = 0;
++  for (i = 0; i < numProbs; i++)
++    p[i] = kBitModelTotal >> 1; 
++
++  #ifdef _LZMA_IN_CB
++  RC_INIT;
++  #else
++  RC_INIT(inStream, inSize);
++  #endif
++  vs->Buffer = Buffer;
++  vs->BufferLim = BufferLim;
++  vs->Range = Range;
++  vs->Code = Code;
++  #ifdef _LZMA_IN_CB
++  vs->InCallback = InCallback;
++  #endif
++
++  return LZMA_RESULT_OK;
++}
++
++int LzmaDecode(unsigned char *buffer, 
++    unsigned char *outStream, UInt32 outSize,
++    UInt32 *outSizeProcessed)
++{
++  LzmaVarState *vs = (LzmaVarState *)buffer;
++  Byte *Buffer = vs->Buffer;
++  Byte *BufferLim = vs->BufferLim;
++  UInt32 Range = vs->Range;
++  UInt32 Code = vs->Code;
++  #ifdef _LZMA_IN_CB
++  ILzmaInCallback *InCallback = vs->InCallback;
++  #endif
++  CProb *p = (CProb *)(buffer + sizeof(LzmaVarState));
++  int state = vs->State;
++  Byte previousByte;
++  UInt32 rep0 = vs->Reps[0], rep1 = vs->Reps[1], rep2 = vs->Reps[2], rep3 = vs->Reps[3];
++  UInt32 nowPos = 0;
++  UInt32 posStateMask = (1 << (vs->pb)) - 1;
++  UInt32 literalPosMask = (1 << (vs->lp)) - 1;
++  int lc = vs->lc;
++  int len = vs->RemainLen;
++  UInt32 globalPos = vs->GlobalPos;
++
++  Byte *dictionary = vs->Dictionary;
++  UInt32 dictionarySize = vs->DictionarySize;
++  UInt32 dictionaryPos = vs->DictionaryPos;
++
++  Byte tempDictionary[4];
++  if (dictionarySize == 0)
++  {
++    dictionary = tempDictionary;
++    dictionarySize = 1;
++    tempDictionary[0] = vs->TempDictionary[0];
++  }
++
++  if (len == -1)
++  {
++    *outSizeProcessed = 0;
++    return LZMA_RESULT_OK;
++  }
++
++  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
++
++int LzmaDecode(
++    Byte *buffer, UInt32 bufferSize,
++    int lc, int lp, int pb,
++    #ifdef _LZMA_IN_CB
++    ILzmaInCallback *InCallback,
++    #else
++    unsigned char *inStream, UInt32 inSize,
++    #endif
++    unsigned char *outStream, UInt32 outSize,
++    UInt32 *outSizeProcessed)
++{
++  UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (lc + lp));
++  CProb *p = (CProb *)buffer;
++
++  UInt32 i;
++  int state = 0;
++  Byte previousByte = 0;
++  UInt32 rep0 = 1, rep1 = 1, rep2 = 1, rep3 = 1;
++  UInt32 nowPos = 0;
++  UInt32 posStateMask = (1 << pb) - 1;
++  UInt32 literalPosMask = (1 << lp) - 1;
++  int len = 0;
++  
++  Byte *Buffer;
++  Byte *BufferLim;
++  UInt32 Range;
++  UInt32 Code;
++  
++  if (bufferSize < numProbs * sizeof(CProb))
++    return LZMA_RESULT_NOT_ENOUGH_MEM;
++  for (i = 0; i < numProbs; i++)
++    p[i] = kBitModelTotal >> 1;
++  
++
++  #ifdef _LZMA_IN_CB
++  RC_INIT;
++  #else
++  RC_INIT(inStream, inSize);
++  #endif
++#endif
++
++  *outSizeProcessed = 0;
++  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
++      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);
++            if (nowPos 
++                #ifdef _LZMA_OUT_READ
++                + globalPos
++                #endif
++                == 0)
++              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;
++            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 = -1;
++          break;
++        }
++      }
++
++      len += kMatchMinLen;
++      if (rep0 > nowPos 
++        #ifdef _LZMA_OUT_READ
++        + globalPos || rep0 > dictionarySize
++        #endif
++        ) 
++        return LZMA_RESULT_DATA_ERROR;
++      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->Buffer = Buffer;
++  vs->BufferLim = BufferLim;
++  vs->Range = Range;
++  vs->Code = Code;
++  vs->DictionaryPos = dictionaryPos;
++  vs->GlobalPos = globalPos + nowPos;
++  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
++
++  *outSizeProcessed = nowPos;
++  return LZMA_RESULT_OK;
++}
+diff -Naur linux-old/arch/i386/boot/compressed/LzmaDecode.h linux-lzma/arch/i386/boot/compressed/LzmaDecode.h
+--- linux-old/arch/i386/boot/compressed/LzmaDecode.h   1969-12-31 19:00:00.000000000 -0500
++++ linux-lzma/arch/i386/boot/compressed/LzmaDecode.h  2005-06-05 00:07:39.000000000 -0400
+@@ -0,0 +1,100 @@
++/* 
++  LzmaDecode.h
++  LZMA Decoder interface
++
++  LZMA SDK 4.16 Copyright (c) 1999-2005 Igor Pavlov (2005-03-18)
++  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 */
++
++#ifndef UInt32
++#ifdef _LZMA_UINT32_IS_ULONG
++#define UInt32 unsigned long
++#else
++#define UInt32 unsigned int
++#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
++#define LZMA_RESULT_NOT_ENOUGH_MEM 2
++
++#ifdef _LZMA_IN_CB
++typedef struct _ILzmaInCallback
++{
++  int (*Read)(void *object, unsigned char **buffer, UInt32 *bufferSize);
++} ILzmaInCallback;
++#endif
++
++#define LZMA_BASE_SIZE 1846
++#define LZMA_LIT_SIZE 768
++
++/* 
++bufferSize = (LZMA_BASE_SIZE + (LZMA_LIT_SIZE << (lc + lp)))* sizeof(CProb)
++bufferSize += 100 in case of _LZMA_OUT_READ
++by default CProb is unsigned short, 
++but if specify _LZMA_PROB_32, CProb will be UInt32(unsigned int)
++*/
++
++#ifdef _LZMA_OUT_READ
++int LzmaDecoderInit(
++    unsigned char *buffer, UInt32 bufferSize,
++    int lc, int lp, int pb,
++    unsigned char *dictionary, UInt32 dictionarySize,
++  #ifdef _LZMA_IN_CB
++    ILzmaInCallback *inCallback
++  #else
++    unsigned char *inStream, UInt32 inSize
++  #endif
++);
++#endif
++
++int LzmaDecode(
++    unsigned char *buffer, 
++  #ifndef _LZMA_OUT_READ
++    UInt32 bufferSize,
++    int lc, int lp, int pb,
++  #ifdef _LZMA_IN_CB
++    ILzmaInCallback *inCallback,
++  #else
++    unsigned char *inStream, UInt32 inSize,
++  #endif
++  #endif
++    unsigned char *outStream, UInt32 outSize,
++    UInt32 *outSizeProcessed);
++
++#endif
+diff -Naur linux-old/arch/i386/boot/compressed/Makefile linux-lzma/arch/i386/boot/compressed/Makefile
+--- linux-old/arch/i386/boot/compressed/Makefile       2005-06-04 21:53:40.000000000 -0400
++++ linux-lzma/arch/i386/boot/compressed/Makefile      2005-06-05 00:25:23.000000000 -0400
+@@ -2,24 +2,33 @@
+ # linux/arch/i386/boot/compressed/Makefile
+ #
+ # create a compressed vmlinux image from the original vmlinux
++# patched by Ming-Ching Tiew <mctiew@yahoo.com> for kernel 2.6
++# requires program 'lzma' from LZMA SDK ( http://www.7-zip.org/ ) to work
++#    $ mkdir lzma
++#    $ cd lzma
++#    $ tar tvjf ../lzma417.tar.bz2
++#    $ cd SRC/7zip/Compress/LZMA_Alone
++#    $ dos2unix makefile
++#    $ make
++#    $ su
++#    # cp lzma /usr/bin
+ #
+-
+-targets               := vmlinux vmlinux.bin vmlinux.bin.gz head.o misc.o piggy.o
++targets               := vmlinux vmlinux.bin vmlinux.bin.lzma head.o lzma_misc.o piggy.o
+ EXTRA_AFLAGS  := -traditional
+ LDFLAGS_vmlinux := -Ttext $(IMAGE_OFFSET) -e startup_32
+-$(obj)/vmlinux: $(obj)/head.o $(obj)/misc.o $(obj)/piggy.o FORCE
++$(obj)/vmlinux: $(obj)/head.o $(obj)/lzma_misc.o $(obj)/piggy.o FORCE
+       $(call if_changed,ld)
+       @:
+ $(obj)/vmlinux.bin: vmlinux FORCE
+       $(call if_changed,objcopy)
+-$(obj)/vmlinux.bin.gz: $(obj)/vmlinux.bin FORCE
+-      $(call if_changed,gzip)
++$(obj)/vmlinux.bin.lzma: $(obj)/vmlinux.bin FORCE
++      $(call if_changed,lzma)
+ LDFLAGS_piggy.o := -r --format binary --oformat elf32-i386 -T
+-$(obj)/piggy.o: $(obj)/vmlinux.scr $(obj)/vmlinux.bin.gz FORCE
++$(obj)/piggy.o: $(obj)/vmlinux.scr $(obj)/vmlinux.bin.lzma FORCE
+       $(call if_changed,ld)
+diff -Naur linux-old/arch/i386/boot/compressed/lzma_misc.c linux-lzma/arch/i386/boot/compressed/lzma_misc.c
+--- linux-old/arch/i386/boot/compressed/lzma_misc.c    1969-12-31 19:00:00.000000000 -0500
++++ linux-lzma/arch/i386/boot/compressed/lzma_misc.c   2005-06-04 21:33:48.000000000 -0400
+@@ -0,0 +1,412 @@
++/*
++ * lzma_misc.c
++ * 
++ * Decompress LZMA compressed vmlinuz 
++ * Version 0.9 Copyright (c) Ming-Ching Tiew mctiew@yahoo.com
++ * Program adapted from misc.c for 2.6 kernel
++ * Date: 3 June 2005 
++ * Source released under GPL
++ */
++
++#include <linux/linkage.h>
++#include <linux/vmalloc.h>
++#include <linux/tty.h>
++#include <linux/screen_info.h>
++#include <asm/io.h>
++
++#define OF(args)  args
++#define STATIC static
++
++#undef memset
++#undef memcpy
++
++/*
++ * Why do we do this? Don't ask me..
++ *
++ * Incomprehensible are the ways of bootloaders.
++ */
++static void* memcpy(void *, __const void *, size_t);
++
++typedef unsigned char  uch;
++typedef unsigned short ush;
++typedef unsigned long  ulg;
++
++#define WSIZE 0x8000          /* Window size must be at least 32k, */
++                              /* and a power of two */
++
++static uch *inbuf;         /* input buffer */
++
++static unsigned insize = 0;  /* valid bytes in inbuf */
++static unsigned inptr = 0;   /* index of next byte to be processed in inbuf */
++
++#define get_byte()  (inptr < insize ? inbuf[inptr++] : fill_inbuf())
++              
++/* Diagnostic functions */
++#ifdef DEBUG
++#  define Assert(cond,msg) {if(!(cond)) error(msg);}
++#  define Trace(x) fprintf x
++#  define Tracev(x) {if (verbose) fprintf x ;}
++#  define Tracevv(x) {if (verbose>1) fprintf x ;}
++#  define Tracec(c,x) {if (verbose && (c)) fprintf x ;}
++#  define Tracecv(c,x) {if (verbose>1 && (c)) fprintf x ;}
++#else
++#  define Assert(cond,msg)
++#  define Trace(x)
++#  define Tracev(x)
++#  define Tracevv(x)
++#  define Tracec(c,x)
++#  define Tracecv(c,x)
++#endif
++
++static int  fill_inbuf(void);
++static void error(char *m);
++  
++/*
++ * This is set up by the setup-routine at boot-time
++ */
++static unsigned char *real_mode; /* Pointer to real-mode data */
++
++#define RM_EXT_MEM_K   (*(unsigned short *)(real_mode + 0x2))
++#ifndef STANDARD_MEMORY_BIOS_CALL
++#define RM_ALT_MEM_K   (*(unsigned long *)(real_mode + 0x1e0))
++#endif
++#define RM_SCREEN_INFO (*(struct screen_info *)(real_mode+0))
++
++extern char input_data[];
++extern int input_len;
++
++static long bytes_out = 0;
++static uch *output_data;
++
++static void putstr(const char *);
++
++extern int end;
++static long free_mem_ptr = (long)&end;
++static long free_mem_end_ptr;
++
++#define INPLACE_MOVE_ROUTINE  0x1000
++#define LOW_BUFFER_START      0x2000
++#define LOW_BUFFER_MAX       0x90000
++#define HEAP_SIZE             0x3000
++static unsigned int low_buffer_end, low_buffer_size;
++static int high_loaded =0;
++static uch *high_buffer_start /* = (uch *)(((ulg)&end) + HEAP_SIZE)*/;
++
++static char *vidmem = (char *)0xb8000;
++static int vidport;
++static int lines, cols;
++
++static void scroll(void)
++{
++      int i;
++
++      memcpy ( vidmem, vidmem + cols * 2, ( lines - 1 ) * cols * 2 );
++      for ( i = ( lines - 1 ) * cols * 2; i < lines * cols * 2; i += 2 )
++              vidmem[i] = ' ';
++}
++
++static void putstr(const char *s)
++{
++      int x,y,pos;
++      char c;
++
++      x = RM_SCREEN_INFO.orig_x;
++      y = RM_SCREEN_INFO.orig_y;
++
++      while ( ( c = *s++ ) != '\0' ) {
++              if ( c == '\n' ) {
++                      x = 0;
++                      if ( ++y >= lines ) {
++                              scroll();
++                              y--;
++                      }
++              } else {
++                      vidmem [ ( x + cols * y ) * 2 ] = c; 
++                      if ( ++x >= cols ) {
++                              x = 0;
++                              if ( ++y >= lines ) {
++                                      scroll();
++                                      y--;
++                              }
++                      }
++              }
++      }
++
++      RM_SCREEN_INFO.orig_x = x;
++      RM_SCREEN_INFO.orig_y = y;
++
++      pos = (x + cols * y) * 2;       /* Update cursor position */
++      outb_p(14, vidport);
++      outb_p(0xff & (pos >> 9), vidport+1);
++      outb_p(15, vidport);
++      outb_p(0xff & (pos >> 1), vidport+1);
++}
++
++static void* memcpy(void* __dest, __const void* __src,
++                          size_t __n)
++{
++      int i;
++      char *d = (char *)__dest, *s = (char *)__src;
++
++      for (i=0;i<__n;i++) d[i] = s[i];
++      return __dest;
++}
++
++/* ===========================================================================
++ * Fill the input buffer. This is called only when the buffer is empty
++ * and at least one byte is really needed.
++ */
++static int fill_inbuf(void)
++{
++      if (insize != 0) {
++              error("ran out of input data");
++      }
++
++      inbuf = input_data;
++      insize = input_len;
++      inptr = 1;
++      return inbuf[0];
++}
++
++static void error(char *x)
++{
++      putstr("\n\n");
++      putstr(x);
++      putstr("\n\n -- System halted");
++
++      while(1);       /* Halt */
++}
++
++#define STACK_SIZE (4096)
++
++long user_stack [STACK_SIZE];
++
++struct {
++      long * a;
++      short b;
++      } stack_start = { & user_stack [STACK_SIZE] , __BOOT_DS };
++
++static void setup_normal_output_buffer(void)
++{
++#ifdef STANDARD_MEMORY_BIOS_CALL
++      if (RM_EXT_MEM_K < 1024) error("Less than 2MB of memory");
++#else
++      if ((RM_ALT_MEM_K > RM_EXT_MEM_K ? RM_ALT_MEM_K : RM_EXT_MEM_K) < 1024) error("Less than 2MB of memory");
++#endif
++      output_data = (char *)0x100000; /* Points to 1M */
++      free_mem_end_ptr = (long)real_mode;
++}
++
++struct moveparams {
++      uch *low_buffer_start;  int lcount;
++      uch *high_buffer_start; int hcount;
++};
++
++static void setup_output_buffer_if_we_run_high(struct moveparams *mv)
++{
++      high_buffer_start = (uch *)(((ulg)&end) + HEAP_SIZE);
++#ifdef STANDARD_MEMORY_BIOS_CALL
++      if (RM_EXT_MEM_K < (3*1024)) error("Less than 4MB of memory");
++#else
++      if ((RM_ALT_MEM_K > RM_EXT_MEM_K ? RM_ALT_MEM_K : RM_EXT_MEM_K) <
++                      (3*1024))
++              error("Less than 4MB of memory");
++#endif        
++      mv->low_buffer_start = output_data = (char *)LOW_BUFFER_START;
++      low_buffer_end = ((unsigned int)real_mode > LOW_BUFFER_MAX
++        ? LOW_BUFFER_MAX : (unsigned int)real_mode) & ~0xfff;
++      low_buffer_size = low_buffer_end - LOW_BUFFER_START;
++      high_loaded = 1;
++      free_mem_end_ptr = (long)high_buffer_start;
++      if ( (0x100000 + low_buffer_size) > ((ulg)high_buffer_start)) {
++              high_buffer_start = (uch *)(0x100000 + low_buffer_size);
++              mv->hcount = 0; /* say: we need not to move high_buffer */
++      }
++      else mv->hcount = -1;
++      mv->high_buffer_start = high_buffer_start;
++}
++
++static void close_output_buffer_if_we_run_high(struct moveparams *mv)
++{
++      if (bytes_out > low_buffer_size) {
++              mv->lcount = low_buffer_size;
++              if (mv->hcount)
++                      mv->hcount = bytes_out - low_buffer_size;
++      } else {
++              mv->lcount = bytes_out;
++              mv->hcount = 0;
++      }
++}
++
++// When using LZMA in callback, the compressed length is not needed.
++// Otherwise you need a special version of lzma compression program
++// which will pad the compressed length in the header.
++#define _LZMA_IN_CB
++#include "LzmaDecode.h"
++#include "LzmaDecode.c"
++
++#ifdef  _LZMA_IN_CB
++static int read_byte(void *object, unsigned char **buffer, UInt32 *bufferSize);
++#endif
++
++
++/*
++ * Do the lzma decompression
++ * When using LZMA in callback, the end of input stream is automatically determined
++ */
++static int lzma_unzip(void)
++{
++
++      unsigned int i;  /* temp value */
++        unsigned int lc; /* literal context bits */
++        unsigned int lp; /* literal pos state bits */
++        unsigned int pb; /* pos state bits */
++      unsigned char* workspace;
++      unsigned int uncompressedSize = 0;
++      unsigned char* p;
++        
++#ifdef  _LZMA_IN_CB
++        ILzmaInCallback callback;
++        callback.Read = read_byte;
++#else 
++      unsigned char* inputbuf;
++      unsigned int lzma_workspace_size;
++      unsigned int compressedSize = 0;
++#endif
++
++      /* lzma args */
++      i = get_byte();
++      lc = i % 9, i = i / 9;
++        lp = i % 5, pb = i / 5;
++        
++        /* skip dictionary size */
++        for (i = 0; i < 4; i++) 
++              get_byte();
++        // get uncompressedSize       
++        p= (char*)&uncompressedSize;  
++        for (i = 0; i < 4; i++) 
++            *p++ = get_byte();
++            
++        //get compressedSize 
++#ifdef  _LZMA_IN_CB
++        for (i = 0; i < 4; i++) 
++              get_byte();
++#else
++        p= (char*)&compressedSize;    
++        for (i = 0; i < 4; i++) 
++            *p++ = get_byte();
++#endif
++        
++#if 0 
++        if ( (lc == 5 ) && (lp == 0 ) && ( pb == 0 ))
++        {
++              putstr("got prop!\n");
++        }
++        
++#ifndef  _LZMA_IN_CB
++        if( compressedSize == 496722 )
++        {
++           putstr( "got the right sizes\n");
++        }
++        else if ( compressedSize > 496722 )
++        {
++           putstr( "greater !\n");
++        }
++        else if ( compressedSize < 496722 )
++           putstr( "smaller!\n");
++       
++#endif
++        if ( uncompressedSize == 1187168 )
++        {
++           putstr( "got the right uncompressed size \n");
++        }else if ( uncompressedSize > 1187168 )
++        {
++           putstr( "uncompressedSize greater!\n");
++        }else
++           putstr( "uncompressedSize smaller!|n");
++#endif   
++
++        // point it beyond uncompresedSize
++        workspace = high_buffer_start + uncompressedSize;
++        //
++#ifndef _LZMA_IN_CB
++        lzma_workspace_size =  (LZMA_BASE_SIZE + (LZMA_LIT_SIZE << (lc + lp))) * sizeof(CProb);
++        inputbuf = high_buffer_start + uncompressedSize + lzma_workspace_size;
++        // read the compressed data
++        for( i=0; i < compressedSize; i++)
++        { 
++            if ( i % ( 1024 * 10 ) == 0 )
++               putstr(".");
++            *inputbuf++ = get_byte();
++        }
++#endif 
++        
++      /* decompress kernel */
++#ifdef  _LZMA_IN_CB
++      if (LzmaDecode(workspace, ~0, lc, lp, pb, 
++         &callback, 
++#else
++      if (LzmaDecode(workspace, lzma_workspace_size, lc, lp, pb, 
++         inputbuf - compressedSize, compressedSize,
++#endif
++         (unsigned char*)high_buffer_start, uncompressedSize, &i) == LZMA_RESULT_OK)
++      {
++              if ( i != uncompressedSize )
++                 error( "kernel corrupted!\n");
++              //copy it back to low_buffer
++              if( uncompressedSize > low_buffer_size )
++              {
++                  memcpy((char*)LOW_BUFFER_START, high_buffer_start, low_buffer_size);
++                  memcpy(high_buffer_start, high_buffer_start+low_buffer_size, 
++                      uncompressedSize-low_buffer_size);      
++              }
++              else            
++                  memcpy((char*)LOW_BUFFER_START, high_buffer_start, uncompressedSize );
++              bytes_out = i;
++              return 0;
++      }
++      return 1;
++}
++
++
++#ifdef  _LZMA_IN_CB
++static int read_byte(void *object, unsigned char **buffer, UInt32 *bufferSize)
++{
++      static unsigned int i = 0;
++      static unsigned char val;
++      *bufferSize = 1;
++      val = get_byte();
++      *buffer = &val;
++        if ( i++ % ( 1024 * 50 ) == 0 )
++               putstr(".");
++      return LZMA_RESULT_OK;
++}     
++#endif
++
++asmlinkage int decompress_kernel(struct moveparams *mv, void *rmode)
++{
++      real_mode = rmode;
++
++      if (RM_SCREEN_INFO.orig_video_mode == 7) {
++              vidmem = (char *) 0xb0000;
++              vidport = 0x3b4;
++      } else {
++              vidmem = (char *) 0xb8000;
++              vidport = 0x3d4;
++      }
++
++      lines = RM_SCREEN_INFO.orig_video_lines;
++      cols = RM_SCREEN_INFO.orig_video_cols;
++
++      if (free_mem_ptr < 0x100000) setup_normal_output_buffer();
++      else setup_output_buffer_if_we_run_high(mv);
++
++      putstr("LZMA vmlinuz: Ming-Ching Tiew <mctiew@yahoo.com> ...");
++      if( lzma_unzip() != 0 )
++      {
++         error("inflate error\n");
++      }
++      putstr("Ok, booting the kernel.\n");
++      if (high_loaded) close_output_buffer_if_we_run_high(mv);
++      return high_loaded;
++}
+diff -urN linux-2.6.19.2/scripts/Makefile.lib linux-2.6.19.2.new/scripts/Makefile.lib
+--- linux-2.6.19.2/scripts/Makefile.lib        2007-01-10 20:10:37.000000000 +0100
++++ linux-2.6.19.2.new/scripts/Makefile.lib    2007-04-15 23:51:54.000000000 +0200
+@@ -162,4 +162,9 @@
+ quiet_cmd_gzip = GZIP    $@
+ cmd_gzip = gzip -f -9 < $< > $@
+-
++# LZMA
++#
++quiet_cmd_lzma = LZMA $@
++cmd_lzma = lzma e $< $@ -lc7 -lp0 -pb0
++# to use lzmacomp,
++# cmd_lzma = lzmacomp $< 700 > $@