Signed-off-by: Luigi 'Comio' Mantellini <luigi.mantellini@idf-hit.com> Signed-off-by: Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>master
parent
508eb85db7
commit
fc9c1727b5
@ -0,0 +1,31 @@ |
|||||||
|
/*
|
||||||
|
* Fake include for LzmaDecode.h |
||||||
|
* |
||||||
|
* Copyright (C) 2007-2008 Industrie Dial Face S.p.A. |
||||||
|
* Luigi 'Comio' Mantellini (luigi.mantellini@idf-hit.com) |
||||||
|
* |
||||||
|
* See file CREDITS for list of people who contributed to this |
||||||
|
* project. |
||||||
|
* |
||||||
|
* 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. |
||||||
|
* |
||||||
|
* This program is distributed in the hope that it will be useful, |
||||||
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||||
|
* GNU General Public License for more details. |
||||||
|
* |
||||||
|
* You should have received a copy of the GNU General Public License |
||||||
|
* along with this program; if not, write to the Free Software |
||||||
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, |
||||||
|
* MA 02111-1307 USA |
||||||
|
*/ |
||||||
|
|
||||||
|
#ifndef __LZMADECODE_H__FAKE__ |
||||||
|
#define __LZMADECODE_H__FAKE__ |
||||||
|
|
||||||
|
#include "../../lib_generic/lzma/LzmaDecode.h" |
||||||
|
|
||||||
|
#endif |
@ -0,0 +1,31 @@ |
|||||||
|
/*
|
||||||
|
* Fake include for LzmaTools.h |
||||||
|
* |
||||||
|
* Copyright (C) 2007-2008 Industrie Dial Face S.p.A. |
||||||
|
* Luigi 'Comio' Mantellini (luigi.mantellini@idf-hit.com) |
||||||
|
* |
||||||
|
* See file CREDITS for list of people who contributed to this |
||||||
|
* project. |
||||||
|
* |
||||||
|
* 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. |
||||||
|
* |
||||||
|
* This program is distributed in the hope that it will be useful, |
||||||
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||||
|
* GNU General Public License for more details. |
||||||
|
* |
||||||
|
* You should have received a copy of the GNU General Public License |
||||||
|
* along with this program; if not, write to the Free Software |
||||||
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, |
||||||
|
* MA 02111-1307 USA |
||||||
|
*/ |
||||||
|
|
||||||
|
#ifndef __LZMATOOLS_H__FAKE__ |
||||||
|
#define __LZMATOOLS_H__FAKE__ |
||||||
|
|
||||||
|
#include "../../lib_generic/lzma/LzmaTools.h" |
||||||
|
|
||||||
|
#endif |
@ -0,0 +1,31 @@ |
|||||||
|
/*
|
||||||
|
* Fake include for LzmaTypes.h |
||||||
|
* |
||||||
|
* Copyright (C) 2007-2008 Industrie Dial Face S.p.A. |
||||||
|
* Luigi 'Comio' Mantellini (luigi.mantellini@idf-hit.com) |
||||||
|
* |
||||||
|
* See file CREDITS for list of people who contributed to this |
||||||
|
* project. |
||||||
|
* |
||||||
|
* 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. |
||||||
|
* |
||||||
|
* This program is distributed in the hope that it will be useful, |
||||||
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||||
|
* GNU General Public License for more details. |
||||||
|
* |
||||||
|
* You should have received a copy of the GNU General Public License |
||||||
|
* along with this program; if not, write to the Free Software |
||||||
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, |
||||||
|
* MA 02111-1307 USA |
||||||
|
*/ |
||||||
|
|
||||||
|
#ifndef __LZMATYPES_H__FAKE__ |
||||||
|
#define __LZMATYPES_H__FAKE__ |
||||||
|
|
||||||
|
#include "../../lib_generic/lzma/LzmaTypes.h" |
||||||
|
|
||||||
|
#endif |
@ -0,0 +1,584 @@ |
|||||||
|
/*
|
||||||
|
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 "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) 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 |
||||||
|
|
||||||
|
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; |
||||||
|
} |
||||||
|
|
||||||
|
#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; |
||||||
|
} |
@ -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 |
@ -0,0 +1,142 @@ |
|||||||
|
/*
|
||||||
|
* Usefuls routines based on the LzmaTest.c file from LZMA SDK 4.57 |
||||||
|
* |
||||||
|
* Copyright (C) 2007-2008 Industrie Dial Face S.p.A. |
||||||
|
* Luigi 'Comio' Mantellini (luigi.mantellini@idf-hit.com) |
||||||
|
* |
||||||
|
* Copyright (C) 1999-2005 Igor Pavlov |
||||||
|
* |
||||||
|
* See file CREDITS for list of people who contributed to this |
||||||
|
* project. |
||||||
|
* |
||||||
|
* 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. |
||||||
|
* |
||||||
|
* This program is distributed in the hope that it will be useful, |
||||||
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||||
|
* GNU General Public License for more details. |
||||||
|
* |
||||||
|
* You should have received a copy of the GNU General Public License |
||||||
|
* along with this program; if not, write to the Free Software |
||||||
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, |
||||||
|
* MA 02111-1307 USA |
||||||
|
*/ |
||||||
|
|
||||||
|
/*
|
||||||
|
* LZMA_Alone stream format: |
||||||
|
* |
||||||
|
* uchar Properties[5] |
||||||
|
* uint64 Uncompressed size |
||||||
|
* uchar data[*] |
||||||
|
* |
||||||
|
*/ |
||||||
|
|
||||||
|
#include <config.h> |
||||||
|
#include <common.h> |
||||||
|
|
||||||
|
#ifdef CONFIG_LZMA |
||||||
|
|
||||||
|
#define LZMA_PROPERTIES_OFFSET 0 |
||||||
|
#define LZMA_SIZE_OFFSET LZMA_PROPERTIES_SIZE |
||||||
|
#define LZMA_DATA_OFFSET LZMA_SIZE_OFFSET+sizeof(uint64_t) |
||||||
|
|
||||||
|
#include "LzmaTools.h" |
||||||
|
#include "LzmaDecode.h" |
||||||
|
|
||||||
|
#include <linux/string.h> |
||||||
|
#include <malloc.h> |
||||||
|
|
||||||
|
int lzmaBuffToBuffDecompress (unsigned char *outStream, SizeT *uncompressedSize, |
||||||
|
unsigned char *inStream, SizeT length) |
||||||
|
{ |
||||||
|
int res = LZMA_RESULT_DATA_ERROR; |
||||||
|
int i; |
||||||
|
|
||||||
|
SizeT outSizeFull = 0xFFFFFFFF; /* 4GBytes limit */ |
||||||
|
SizeT inProcessed; |
||||||
|
SizeT outProcessed; |
||||||
|
SizeT outSize; |
||||||
|
SizeT outSizeHigh; |
||||||
|
CLzmaDecoderState state; /* it's about 24-80 bytes structure, if int is 32-bit */ |
||||||
|
unsigned char properties[LZMA_PROPERTIES_SIZE]; |
||||||
|
SizeT compressedSize = (SizeT)(length - LZMA_DATA_OFFSET); |
||||||
|
|
||||||
|
debug ("LZMA: Image address............... 0x%lx\n", inStream); |
||||||
|
debug ("LZMA: Properties address.......... 0x%lx\n", inStream + LZMA_PROPERTIES_OFFSET); |
||||||
|
debug ("LZMA: Uncompressed size address... 0x%lx\n", inStream + LZMA_SIZE_OFFSET); |
||||||
|
debug ("LZMA: Compressed data address..... 0x%lx\n", inStream + LZMA_DATA_OFFSET); |
||||||
|
debug ("LZMA: Destination address......... 0x%lx\n", outStream); |
||||||
|
|
||||||
|
memcpy(properties, inStream + LZMA_PROPERTIES_OFFSET, LZMA_PROPERTIES_SIZE); |
||||||
|
|
||||||
|
memset(&state, 0, sizeof(state)); |
||||||
|
res = LzmaDecodeProperties(&state.Properties, |
||||||
|
properties, |
||||||
|
LZMA_PROPERTIES_SIZE); |
||||||
|
if (res != LZMA_RESULT_OK) { |
||||||
|
return res; |
||||||
|
} |
||||||
|
|
||||||
|
outSize = 0; |
||||||
|
outSizeHigh = 0; |
||||||
|
/* Read the uncompressed size */ |
||||||
|
for (i = 0; i < 8; i++) { |
||||||
|
unsigned char b = inStream[LZMA_SIZE_OFFSET + i]; |
||||||
|
if (i < 4) { |
||||||
|
outSize += (UInt32)(b) << (i * 8); |
||||||
|
} else { |
||||||
|
outSizeHigh += (UInt32)(b) << ((i - 4) * 8); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
outSizeFull = (SizeT)outSize; |
||||||
|
if (sizeof(SizeT) >= 8) { |
||||||
|
/*
|
||||||
|
* SizeT is a 64 bit uint => We can manage files larger than 4GB! |
||||||
|
* |
||||||
|
*/ |
||||||
|
outSizeFull |= (((SizeT)outSizeHigh << 16) << 16); |
||||||
|
} else if (outSizeHigh != 0 || (UInt32)(SizeT)outSize != outSize) { |
||||||
|
/*
|
||||||
|
* SizeT is a 32 bit uint => We cannot manage files larger than |
||||||
|
* 4GB! |
||||||
|
* |
||||||
|
*/ |
||||||
|
debug ("LZMA: 64bit support not enabled.\n"); |
||||||
|
return LZMA_RESULT_DATA_ERROR; |
||||||
|
} |
||||||
|
|
||||||
|
debug ("LZMA: Uncompresed size............ 0x%lx\n", outSizeFull); |
||||||
|
debug ("LZMA: Compresed size.............. 0x%lx\n", compressedSize); |
||||||
|
debug ("LZMA: Dynamic memory needed....... 0x%lx", LzmaGetNumProbs(&state.Properties) * sizeof(CProb)); |
||||||
|
|
||||||
|
state.Probs = (CProb *)malloc(LzmaGetNumProbs(&state.Properties) * sizeof(CProb)); |
||||||
|
|
||||||
|
if (state.Probs == 0 |
||||||
|
|| (outStream == 0 && outSizeFull != 0) |
||||||
|
|| (inStream == 0 && compressedSize != 0)) { |
||||||
|
free(state.Probs); |
||||||
|
debug ("\n"); |
||||||
|
return LZMA_RESULT_DATA_ERROR; |
||||||
|
} |
||||||
|
|
||||||
|
debug (" allocated.\n"); |
||||||
|
|
||||||
|
/* Decompress */ |
||||||
|
|
||||||
|
res = LzmaDecode(&state, |
||||||
|
inStream + LZMA_DATA_OFFSET, compressedSize, &inProcessed, |
||||||
|
outStream, outSizeFull, &outProcessed); |
||||||
|
if (res != LZMA_RESULT_OK) { |
||||||
|
return res; |
||||||
|
} |
||||||
|
|
||||||
|
*uncompressedSize = outProcessed; |
||||||
|
free(state.Probs); |
||||||
|
return res; |
||||||
|
} |
||||||
|
|
||||||
|
#endif |
@ -0,0 +1,35 @@ |
|||||||
|
/*
|
||||||
|
* Usefuls routines based on the LzmaTest.c file from LZMA SDK 4.57 |
||||||
|
* |
||||||
|
* Copyright (C) 2007-2008 Industrie Dial Face S.p.A. |
||||||
|
* Luigi 'Comio' Mantellini (luigi.mantellini@idf-hit.com) |
||||||
|
* |
||||||
|
* Copyright (C) 1999-2005 Igor Pavlov |
||||||
|
* |
||||||
|
* See file CREDITS for list of people who contributed to this |
||||||
|
* project. |
||||||
|
* |
||||||
|
* 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. |
||||||
|
* |
||||||
|
* This program is distributed in the hope that it will be useful, |
||||||
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||||
|
* GNU General Public License for more details. |
||||||
|
* |
||||||
|
* You should have received a copy of the GNU General Public License |
||||||
|
* along with this program; if not, write to the Free Software |
||||||
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, |
||||||
|
* MA 02111-1307 USA |
||||||
|
*/ |
||||||
|
|
||||||
|
#ifndef __LZMA_TOOL_H__ |
||||||
|
#define __LZMA_TOOL_H__ |
||||||
|
|
||||||
|
#include "LzmaTypes.h" |
||||||
|
|
||||||
|
extern int lzmaBuffToBuffDecompress (unsigned char *outStream, SizeT *uncompressedSize, |
||||||
|
unsigned char *inStream, SizeT length); |
||||||
|
#endif |
@ -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_NO_SYSTEM_SIZE_T */ |
||||||
|
/* You can use it, if you don't want <stddef.h> */ |
||||||
|
|
||||||
|
#ifndef _7ZIP_SIZET_DEFINED |
||||||
|
#define _7ZIP_SIZET_DEFINED |
||||||
|
#ifdef _LZMA_NO_SYSTEM_SIZE_T |
||||||
|
typedef UInt32 SizeT; |
||||||
|
#else |
||||||
|
#include <stddef.h> |
||||||
|
typedef size_t SizeT; |
||||||
|
#endif |
||||||
|
#endif |
||||||
|
|
||||||
|
#endif |
@ -0,0 +1,49 @@ |
|||||||
|
#
|
||||||
|
# Copyright (C) 2007-2008 Industrie Dial Face S.p.A.
|
||||||
|
# Luigi 'Comio' Mantellini (luigi.mantellini@idf-hit.com)
|
||||||
|
#
|
||||||
|
# (C) Copyright 2003-2006
|
||||||
|
# Wolfgang Denk, DENX Software Engineering, wd@denx.de.
|
||||||
|
#
|
||||||
|
# See file CREDITS for list of people who contributed to this
|
||||||
|
# project.
|
||||||
|
#
|
||||||
|
# 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.
|
||||||
|
#
|
||||||
|
# This program is distributed in the hope that it will be useful,
|
||||||
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
# GNU General Public License for more details.
|
||||||
|
#
|
||||||
|
# You should have received a copy of the GNU General Public License
|
||||||
|
# along with this program; if not, write to the Free Software
|
||||||
|
# Foundation, Inc., 59 Temple Place, Suite 330, Boston,
|
||||||
|
# MA 02111-1307 USA
|
||||||
|
#
|
||||||
|
|
||||||
|
include $(TOPDIR)/config.mk |
||||||
|
|
||||||
|
LIB = $(obj)liblzma.a
|
||||||
|
|
||||||
|
SOBJS =
|
||||||
|
|
||||||
|
COBJS-$(CONFIG_LZMA) += LzmaDecode.o LzmaTools.o
|
||||||
|
|
||||||
|
COBJS = $(COBJS-y)
|
||||||
|
SRCS := $(SOBJS:.o=.S) $(COBJS:.o=.c)
|
||||||
|
OBJS := $(addprefix $(obj),$(SOBJS) $(COBJS))
|
||||||
|
|
||||||
|
$(LIB): $(obj).depend $(OBJS) |
||||||
|
$(AR) $(ARFLAGS) $@ $(OBJS)
|
||||||
|
|
||||||
|
#########################################################################
|
||||||
|
|
||||||
|
# defines $(obj).depend target
|
||||||
|
include $(SRCTREE)/rules.mk |
||||||
|
|
||||||
|
sinclude $(obj).depend |
||||||
|
|
||||||
|
#########################################################################
|
@ -0,0 +1,28 @@ |
|||||||
|
The lib_lzma functionality was written by Igor Pavlov. |
||||||
|
The original source cames from the LZMA SDK web page: |
||||||
|
|
||||||
|
URL: http://www.7-zip.org/sdk.html |
||||||
|
Author: Igor Pavlov |
||||||
|
|
||||||
|
The import is made using the import_lzmasdk.sh script that: |
||||||
|
|
||||||
|
* untars the lzmaXYY.tar.bz2 file (from the download web page) |
||||||
|
* copies the files LzmaDecode.h, LzmaTypes.h, LzmaDecode.c, history.txt, |
||||||
|
LGPL.txt, and lzma.txt from source archive into the lib_lzma directory (pwd). |
||||||
|
|
||||||
|
Example: |
||||||
|
|
||||||
|
./import_lzmasdk.sh ~/lzma457.tar.bz2 |
||||||
|
|
||||||
|
Notice: The files from lzma sdk are not _modified_ by this script! |
||||||
|
|
||||||
|
The files LzmaTools.{c,h} are provided to export the lzmaBuffToBuffDecompress() |
||||||
|
function that wraps the complex LzmaDecode() function from the LZMA SDK. The |
||||||
|
do_bootm() function uses the lzmaBuffToBuffDecopress() function to expand the |
||||||
|
compressed image. |
||||||
|
|
||||||
|
The directory U-BOOT/include/lzma contains stubs files that permit to use the |
||||||
|
library directly from U-BOOT code without touching the original LZMA SDK's |
||||||
|
files. |
||||||
|
|
||||||
|
Luigi 'Comio' Mantellini <luigi.mantellini@idf-hit.com> |
@ -0,0 +1,198 @@ |
|||||||
|
HISTORY of the LZMA SDK |
||||||
|
----------------------- |
||||||
|
|
||||||
|
4.57 2007-12-12 |
||||||
|
------------------------- |
||||||
|
- Speed optimizations in Ñ++ LZMA Decoder. |
||||||
|
- Small changes for more compatibility with some C/C++ compilers. |
||||||
|
|
||||||
|
|
||||||
|
4.49 beta 2007-07-05 |
||||||
|
------------------------- |
||||||
|
- .7z ANSI-C Decoder: |
||||||
|
- now it supports BCJ and BCJ2 filters |
||||||
|
- now it supports files larger than 4 GB. |
||||||
|
- now it supports "Last Write Time" field for files. |
||||||
|
- C++ code for .7z archives compressing/decompressing from 7-zip |
||||||
|
was included to LZMA SDK. |
||||||
|
|
||||||
|
|
||||||
|
4.43 2006-06-04 |
||||||
|
------------------------- |
||||||
|
- Small changes for more compatibility with some C/C++ compilers. |
||||||
|
|
||||||
|
|
||||||
|
4.42 2006-05-15 |
||||||
|
------------------------- |
||||||
|
- Small changes in .h files in ANSI-C version. |
||||||
|
|
||||||
|
|
||||||
|
4.39 beta 2006-04-14 |
||||||
|
------------------------- |
||||||
|
- Bug in versions 4.33b:4.38b was fixed: |
||||||
|
C++ version of LZMA encoder could not correctly compress |
||||||
|
files larger than 2 GB with HC4 match finder (-mfhc4). |
||||||
|
|
||||||
|
|
||||||
|
4.37 beta 2005-04-06 |
||||||
|
------------------------- |
||||||
|
- Fixes in C++ code: code could no be compiled if _NO_EXCEPTIONS was defined. |
||||||
|
|
||||||
|
|
||||||
|
4.35 beta 2005-03-02 |
||||||
|
------------------------- |
||||||
|
- Bug was fixed in C++ version of LZMA Decoder: |
||||||
|
If encoded stream was corrupted, decoder could access memory |
||||||
|
outside of allocated range. |
||||||
|
|
||||||
|
|
||||||
|
4.34 beta 2006-02-27 |
||||||
|
------------------------- |
||||||
|
- Compressing speed and memory requirements for compressing were increased |
||||||
|
- LZMA now can use only these match finders: HC4, BT2, BT3, BT4 |
||||||
|
|
||||||
|
|
||||||
|
4.32 2005-12-09 |
||||||
|
------------------------- |
||||||
|
- Java version of LZMA SDK was included |
||||||
|
|
||||||
|
|
||||||
|
4.30 2005-11-20 |
||||||
|
------------------------- |
||||||
|
- Compression ratio was improved in -a2 mode |
||||||
|
- Speed optimizations for compressing in -a2 mode |
||||||
|
- -fb switch now supports values up to 273 |
||||||
|
- Bug in 7z_C (7zIn.c) was fixed: |
||||||
|
It used Alloc/Free functions from different memory pools. |
||||||
|
So if program used two memory pools, it worked incorrectly. |
||||||
|
- 7z_C: .7z format supporting was improved |
||||||
|
- LZMA# SDK (C#.NET version) was included |
||||||
|
|
||||||
|
|
||||||
|
4.27 (Updated) 2005-09-21 |
||||||
|
------------------------- |
||||||
|
- Some GUIDs/interfaces in C++ were changed. |
||||||
|
IStream.h: |
||||||
|
ISequentialInStream::Read now works as old ReadPart |
||||||
|
ISequentialOutStream::Write now works as old WritePart |
||||||
|
|
||||||
|
|
||||||
|
4.27 2005-08-07 |
||||||
|
------------------------- |
||||||
|
- Bug in LzmaDecodeSize.c was fixed: |
||||||
|
if _LZMA_IN_CB and _LZMA_OUT_READ were defined, |
||||||
|
decompressing worked incorrectly. |
||||||
|
|
||||||
|
|
||||||
|
4.26 2005-08-05 |
||||||
|
------------------------- |
||||||
|
- Fixes in 7z_C code and LzmaTest.c: |
||||||
|
previous versions could work incorrectly, |
||||||
|
if malloc(0) returns 0 |
||||||
|
|
||||||
|
|
||||||
|
4.23 2005-06-29 |
||||||
|
------------------------- |
||||||
|
- Small fixes in C++ code |
||||||
|
|
||||||
|
|
||||||
|
4.22 2005-06-10 |
||||||
|
------------------------- |
||||||
|
- Small fixes |
||||||
|
|
||||||
|
|
||||||
|
4.21 2005-06-08 |
||||||
|
------------------------- |
||||||
|
- Interfaces for ANSI-C LZMA Decoder (LzmaDecode.c) were changed |
||||||
|
- New additional version of ANSI-C LZMA Decoder with zlib-like interface: |
||||||
|
- LzmaStateDecode.h |
||||||
|
- LzmaStateDecode.c |
||||||
|
- LzmaStateTest.c |
||||||
|
- ANSI-C LZMA Decoder now can decompress files larger than 4 GB |
||||||
|
|
||||||
|
|
||||||
|
4.17 2005-04-18 |
||||||
|
------------------------- |
||||||
|
- New example for RAM->RAM compressing/decompressing: |
||||||
|
LZMA + BCJ (filter for x86 code): |
||||||
|
- LzmaRam.h |
||||||
|
- LzmaRam.cpp |
||||||
|
- LzmaRamDecode.h |
||||||
|
- LzmaRamDecode.c |
||||||
|
- -f86 switch for lzma.exe |
||||||
|
|
||||||
|
|
||||||
|
4.16 2005-03-29 |
||||||
|
------------------------- |
||||||
|
- Bug was fixed in LzmaDecode.c (ANSI-C LZMA Decoder): |
||||||
|
If _LZMA_OUT_READ was defined, and if encoded stream was corrupted, |
||||||
|
decoder could access memory outside of allocated range. |
||||||
|
- Speed optimization of ANSI-C LZMA Decoder (now it's about 20% faster). |
||||||
|
Old version of LZMA Decoder now is in file LzmaDecodeSize.c. |
||||||
|
LzmaDecodeSize.c can provide slightly smaller code than LzmaDecode.c |
||||||
|
- Small speed optimization in LZMA C++ code |
||||||
|
- filter for SPARC's code was added |
||||||
|
- Simplified version of .7z ANSI-C Decoder was included |
||||||
|
|
||||||
|
|
||||||
|
4.06 2004-09-05 |
||||||
|
------------------------- |
||||||
|
- Bug in v4.05 was fixed: |
||||||
|
LZMA-Encoder didn't release output stream in some cases. |
||||||
|
|
||||||
|
|
||||||
|
4.05 2004-08-25 |
||||||
|
------------------------- |
||||||
|
- Source code of filters for x86, IA-64, ARM, ARM-Thumb |
||||||
|
and PowerPC code was included to SDK |
||||||
|
- Some internal minor changes |
||||||
|
|
||||||
|
|
||||||
|
4.04 2004-07-28 |
||||||
|
------------------------- |
||||||
|
- More compatibility with some C++ compilers |
||||||
|
|
||||||
|
|
||||||
|
4.03 2004-06-18 |
||||||
|
------------------------- |
||||||
|
- "Benchmark" command was added. It measures compressing |
||||||
|
and decompressing speed and shows rating values. |
||||||
|
Also it checks hardware errors. |
||||||
|
|
||||||
|
|
||||||
|
4.02 2004-06-10 |
||||||
|
------------------------- |
||||||
|
- C++ LZMA Encoder/Decoder code now is more portable |
||||||
|
and it can be compiled by GCC on Linux. |
||||||
|
|
||||||
|
|
||||||
|
4.01 2004-02-15 |
||||||
|
------------------------- |
||||||
|
- Some detection of data corruption was enabled. |
||||||
|
LzmaDecode.c / RangeDecoderReadByte |
||||||
|
..... |
||||||
|
{ |
||||||
|
rd->ExtraBytes = 1; |
||||||
|
return 0xFF; |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
4.00 2004-02-13 |
||||||
|
------------------------- |
||||||
|
- Original version of LZMA SDK |
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
HISTORY of the LZMA |
||||||
|
------------------- |
||||||
|
2001-2007: Improvements to LZMA compressing/decompressing code, |
||||||
|
keeping compatibility with original LZMA format |
||||||
|
1996-2001: Development of LZMA compression format |
||||||
|
|
||||||
|
Some milestones: |
||||||
|
|
||||||
|
2001-08-30: LZMA compression was added to 7-Zip |
||||||
|
1999-01-02: First version of 7-Zip was released |
||||||
|
|
||||||
|
|
||||||
|
End of document |
@ -0,0 +1,38 @@ |
|||||||
|
#!/bin/sh |
||||||
|
|
||||||
|
usage() { |
||||||
|
echo "Usage: $0 lzmaVERSION.tar.bz2" >&2 |
||||||
|
echo >&2 |
||||||
|
exit 1 |
||||||
|
} |
||||||
|
|
||||||
|
if [ "$1" = "" ] ; then |
||||||
|
usage |
||||||
|
fi |
||||||
|
|
||||||
|
if [ ! -f $1 ] ; then |
||||||
|
echo "$1 doesn't exist!" >&2 |
||||||
|
exit 1 |
||||||
|
fi |
||||||
|
|
||||||
|
BASENAME=`basename $1 .tar.bz2` |
||||||
|
TMPDIR=/tmp/tmp_lib_$BASENAME |
||||||
|
FILES="C/Compress/Lzma/LzmaDecode.h |
||||||
|
C/Compress/Lzma/LzmaTypes.h |
||||||
|
C/Compress/Lzma/LzmaDecode.c |
||||||
|
history.txt |
||||||
|
LGPL.txt |
||||||
|
lzma.txt" |
||||||
|
|
||||||
|
|
||||||
|
mkdir -p $TMPDIR |
||||||
|
echo "Untar $1 -> $TMPDIR" |
||||||
|
tar -jxf $1 -C $TMPDIR |
||||||
|
|
||||||
|
for i in $FILES; do |
||||||
|
echo Copying $TMPDIR/$i \-\> `basename $i` |
||||||
|
cp $TMPDIR/$i . |
||||||
|
chmod -x `basename $i` |
||||||
|
done |
||||||
|
|
||||||
|
echo "done!" |
@ -0,0 +1,663 @@ |
|||||||
|
LZMA SDK 4.57 |
||||||
|
------------- |
||||||
|
|
||||||
|
LZMA SDK Copyright (C) 1999-2007 Igor Pavlov |
||||||
|
|
||||||
|
LZMA SDK provides the documentation, samples, header files, libraries, |
||||||
|
and tools you need to develop applications that use LZMA compression. |
||||||
|
|
||||||
|
LZMA is default and general compression method of 7z format |
||||||
|
in 7-Zip compression program (www.7-zip.org). LZMA provides high |
||||||
|
compression ratio and very fast decompression. |
||||||
|
|
||||||
|
LZMA is an improved version of famous LZ77 compression algorithm. |
||||||
|
It was improved in way of maximum increasing of compression ratio, |
||||||
|
keeping high decompression speed and low memory requirements for |
||||||
|
decompressing. |
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
LICENSE |
||||||
|
------- |
||||||
|
|
||||||
|
LZMA SDK is available under any of the following licenses: |
||||||
|
|
||||||
|
1) GNU Lesser General Public License (GNU LGPL) |
||||||
|
2) Common Public License (CPL) |
||||||
|
3) Simplified license for unmodified code (read SPECIAL EXCEPTION) |
||||||
|
4) Proprietary license |
||||||
|
|
||||||
|
It means that you can select one of these four options and follow rules of that license. |
||||||
|
|
||||||
|
|
||||||
|
1,2) GNU LGPL and CPL licenses are pretty similar and both these |
||||||
|
licenses are classified as |
||||||
|
- "Free software licenses" at http://www.gnu.org/ |
||||||
|
- "OSI-approved" at http://www.opensource.org/ |
||||||
|
|
||||||
|
|
||||||
|
3) 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 files from LZMA SDK without subjecting your linked |
||||||
|
code to the terms of the CPL or GNU LGPL. |
||||||
|
Any modifications or additions to files from LZMA SDK, however, |
||||||
|
are subject to the GNU LGPL or CPL terms. |
||||||
|
|
||||||
|
SPECIAL EXCEPTION allows you to use LZMA SDK in applications with closed code, |
||||||
|
while you keep LZMA SDK code unmodified. |
||||||
|
|
||||||
|
|
||||||
|
SPECIAL EXCEPTION #2: Igor Pavlov, as the author of this code, expressly permits |
||||||
|
you to use this code under the same terms and conditions contained in the License |
||||||
|
Agreement you have for any previous version of LZMA SDK developed by Igor Pavlov. |
||||||
|
|
||||||
|
SPECIAL EXCEPTION #2 allows owners of proprietary licenses to use latest version |
||||||
|
of LZMA SDK as update for previous versions. |
||||||
|
|
||||||
|
|
||||||
|
SPECIAL EXCEPTION #3: Igor Pavlov, as the author of this code, expressly permits |
||||||
|
you to use code of the following files: |
||||||
|
BranchTypes.h, LzmaTypes.h, LzmaTest.c, LzmaStateTest.c, LzmaAlone.cpp, |
||||||
|
LzmaAlone.cs, LzmaAlone.java |
||||||
|
as public domain code. |
||||||
|
|
||||||
|
|
||||||
|
4) Proprietary license |
||||||
|
|
||||||
|
LZMA SDK also can be available under a proprietary license which |
||||||
|
can include: |
||||||
|
|
||||||
|
1) Right to modify code without subjecting modified code to the |
||||||
|
terms of the CPL or GNU LGPL |
||||||
|
2) Technical support for code |
||||||
|
|
||||||
|
To request such proprietary license or any additional consultations, |
||||||
|
send email message from that page: |
||||||
|
http://www.7-zip.org/support.html |
||||||
|
|
||||||
|
|
||||||
|
You should have received a copy of the GNU Lesser General Public |
||||||
|
License along with this library; if not, write to the Free Software |
||||||
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
||||||
|
|
||||||
|
You should have received a copy of the Common Public License |
||||||
|
along with this library. |
||||||
|
|
||||||
|
|
||||||
|
LZMA SDK Contents |
||||||
|
----------------- |
||||||
|
|
||||||
|
LZMA SDK includes: |
||||||
|
|
||||||
|
- C++ source code of LZMA compressing and decompressing |
||||||
|
- ANSI-C compatible source code for LZMA decompressing |
||||||
|
- C# source code for LZMA compressing and decompressing |
||||||
|
- Java source code for LZMA compressing and decompressing |
||||||
|
- Compiled file->file LZMA compressing/decompressing program for Windows system |
||||||
|
|
||||||
|
ANSI-C LZMA decompression code was ported from original C++ sources to C. |
||||||
|
Also it was simplified and optimized for code size. |
||||||
|
But it is fully compatible with LZMA from 7-Zip. |
||||||
|
|
||||||
|
|
||||||
|
UNIX/Linux version |
||||||
|
------------------ |
||||||
|
To compile C++ version of file->file LZMA, go to directory |
||||||
|
C/7zip/Compress/LZMA_Alone |
||||||
|
and type "make" or "make clean all" to recompile all. |
||||||
|
|
||||||
|
In some UNIX/Linux versions you must compile LZMA with static libraries. |
||||||
|
To compile with static libraries, change string in makefile |
||||||
|
LIB = -lm |
||||||
|
to string |
||||||
|
LIB = -lm -static |
||||||
|
|
||||||
|
|
||||||
|
Files |
||||||
|
--------------------- |
||||||
|
C - C source code |
||||||
|
CPP - CPP source code |
||||||
|
CS - C# source code |
||||||
|
Java - Java source code |
||||||
|
lzma.txt - LZMA SDK description (this file) |
||||||
|
7zFormat.txt - 7z Format description |
||||||
|
7zC.txt - 7z ANSI-C Decoder description (this file) |
||||||
|
methods.txt - Compression method IDs for .7z |
||||||
|
LGPL.txt - GNU Lesser General Public License |
||||||
|
CPL.html - Common Public License |
||||||
|
lzma.exe - Compiled file->file LZMA encoder/decoder for Windows |
||||||
|
history.txt - history of the LZMA SDK |
||||||
|
|
||||||
|
|
||||||
|
Source code structure |
||||||
|
--------------------- |
||||||
|
|
||||||
|
C - C files |
||||||
|
Compress - files related to compression/decompression |
||||||
|
Lz - files related to LZ (Lempel-Ziv) compression algorithm |
||||||
|
Lzma - ANSI-C compatible LZMA decompressor |
||||||
|
|
||||||
|
LzmaDecode.h - interface for LZMA decoding on ANSI-C |
||||||
|
LzmaDecode.c - LZMA decoding on ANSI-C (new fastest version) |
||||||
|
LzmaDecodeSize.c - LZMA decoding on ANSI-C (old size-optimized version) |
||||||
|
LzmaTest.c - test application that decodes LZMA encoded file |
||||||
|
LzmaTypes.h - basic types for LZMA Decoder |
||||||
|
LzmaStateDecode.h - interface for LZMA decoding (State version) |
||||||
|
LzmaStateDecode.c - LZMA decoding on ANSI-C (State version) |
||||||
|
LzmaStateTest.c - test application (State version) |
||||||
|
|
||||||
|
Branch - Filters for x86, IA-64, ARM, ARM-Thumb, PowerPC and SPARC code |
||||||
|
|
||||||
|
Archive - files related to archiving |
||||||
|
7z_C - 7z ANSI-C Decoder |
||||||
|
|
||||||
|
|
||||||
|
CPP -- CPP files |
||||||
|
|
||||||
|
Common - common files for C++ projects |
||||||
|
Windows - common files for Windows related code |
||||||
|
7zip - files related to 7-Zip Project |
||||||
|
|
||||||
|
Common - common files for 7-Zip |
||||||
|
|
||||||
|
Compress - files related to compression/decompression |
||||||
|
|
||||||
|
LZ - files related to LZ (Lempel-Ziv) compression algorithm |
||||||
|
|
||||||
|
Copy - Copy coder |
||||||
|
RangeCoder - Range Coder (special code of compression/decompression) |
||||||
|
LZMA - LZMA compression/decompression on C++ |
||||||
|
LZMA_Alone - file->file LZMA compression/decompression |
||||||
|
|
||||||
|
Branch - Filters for x86, IA-64, ARM, ARM-Thumb, PowerPC and SPARC code |
||||||
|
|
||||||
|
Archive - files related to archiving |
||||||
|
|
||||||
|
Common - common files for archive handling |
||||||
|
7z - 7z C++ Encoder/Decoder |
||||||
|
|
||||||
|
Bundles - Modules that are bundles of other modules |
||||||
|
|
||||||
|
Alone7z - 7zr.exe: Standalone version of 7z.exe that supports only 7z/LZMA/BCJ/BCJ2 |
||||||
|
Format7zR - 7zr.dll: Reduced version of 7za.dll: extracting/compressing to 7z/LZMA/BCJ/BCJ2 |
||||||
|
Format7zExtractR - 7zxr.dll: Reduced version of 7zxa.dll: extracting from 7z/LZMA/BCJ/BCJ2. |
||||||
|
|
||||||
|
UI - User Interface files |
||||||
|
|
||||||
|
Client7z - Test application for 7za.dll, 7zr.dll, 7zxr.dll |
||||||
|
Common - Common UI files |
||||||
|
Console - Code for console archiver |
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
CS - C# files |
||||||
|
7zip |
||||||
|
Common - some common files for 7-Zip |
||||||
|
Compress - files related to compression/decompression |
||||||
|
LZ - files related to LZ (Lempel-Ziv) compression algorithm |
||||||
|
LZMA - LZMA compression/decompression |
||||||
|
LzmaAlone - file->file LZMA compression/decompression |
||||||
|
RangeCoder - Range Coder (special code of compression/decompression) |
||||||
|
|
||||||
|
Java - Java files |
||||||
|
SevenZip |
||||||
|
Compression - files related to compression/decompression |
||||||
|
LZ - files related to LZ (Lempel-Ziv) compression algorithm |
||||||
|
LZMA - LZMA compression/decompression |
||||||
|
RangeCoder - Range Coder (special code of compression/decompression) |
||||||
|
|
||||||
|
C/C++ source code of LZMA SDK is part of 7-Zip project. |
||||||
|
|
||||||
|
You can find ANSI-C LZMA decompressing code at folder |
||||||
|
C/7zip/Compress/Lzma |
||||||
|
7-Zip doesn't use that ANSI-C LZMA code and that code was developed |
||||||
|
specially for this SDK. And files from C/7zip/Compress/Lzma do not need |
||||||
|
files from other directories of SDK for compiling. |
||||||
|
|
||||||
|
7-Zip source code can be downloaded from 7-Zip's SourceForge page: |
||||||
|
|
||||||
|
http://sourceforge.net/projects/sevenzip/ |
||||||
|
|
||||||
|
|
||||||
|
LZMA features |
||||||
|
------------- |
||||||
|
- Variable dictionary size (up to 1 GB) |
||||||
|
- Estimated compressing speed: about 1 MB/s on 1 GHz CPU |
||||||
|
- Estimated decompressing speed: |
||||||
|
- 8-12 MB/s on 1 GHz Intel Pentium 3 or AMD Athlon |
||||||
|
- 500-1000 KB/s on 100 MHz ARM, MIPS, PowerPC or other simple RISC |
||||||
|
- Small memory requirements for decompressing (8-32 KB + DictionarySize) |
||||||
|
- Small code size for decompressing: 2-8 KB (depending from |
||||||
|
speed optimizations) |
||||||
|
|
||||||
|
LZMA decoder uses only integer operations and can be |
||||||
|
implemented in any modern 32-bit CPU (or on 16-bit CPU with some conditions). |
||||||
|
|
||||||
|
Some critical operations that affect to speed of LZMA decompression: |
||||||
|
1) 32*16 bit integer multiply |
||||||
|
2) Misspredicted branches (penalty mostly depends from pipeline length) |
||||||
|
3) 32-bit shift and arithmetic operations |
||||||
|
|
||||||
|
Speed of LZMA decompressing mostly depends from CPU speed. |
||||||
|
Memory speed has no big meaning. But if your CPU has small data cache, |
||||||
|
overall weight of memory speed will slightly increase. |
||||||
|
|
||||||
|
|
||||||
|
How To Use |
||||||
|
---------- |
||||||
|
|
||||||
|
Using LZMA encoder/decoder executable |
||||||
|
-------------------------------------- |
||||||
|
|
||||||
|
Usage: LZMA <e|d> inputFile outputFile [<switches>...] |
||||||
|
|
||||||
|
e: encode file |
||||||
|
|
||||||
|
d: decode file |
||||||
|
|
||||||
|
b: Benchmark. There are two tests: compressing and decompressing |
||||||
|
with LZMA method. Benchmark shows rating in MIPS (million |
||||||
|
instructions per second). Rating value is calculated from |
||||||
|
measured speed and it is normalized with AMD Athlon 64 X2 CPU |
||||||
|
results. Also Benchmark checks possible hardware errors (RAM |
||||||
|
errors in most cases). Benchmark uses these settings: |
||||||
|
(-a1, -d21, -fb32, -mfbt4). You can change only -d. Also you |
||||||
|
can change number of iterations. Example for 30 iterations: |
||||||
|
LZMA b 30 |
||||||
|
Default number of iterations is 10. |
||||||
|
|
||||||
|
<Switches> |
||||||
|
|
||||||
|
|
||||||
|
-a{N}: set compression mode 0 = fast, 1 = normal |
||||||
|
default: 1 (normal) |
||||||
|
|
||||||
|
d{N}: Sets Dictionary size - [0, 30], default: 23 (8MB) |
||||||
|
The maximum value for dictionary size is 1 GB = 2^30 bytes. |
||||||
|
Dictionary size is calculated as DictionarySize = 2^N bytes. |
||||||
|
For decompressing file compressed by LZMA method with dictionary |
||||||
|
size D = 2^N you need about D bytes of memory (RAM). |
||||||
|
|
||||||
|
-fb{N}: set number of fast bytes - [5, 273], default: 128 |
||||||
|
Usually big number gives a little bit better compression ratio |
||||||
|
and slower compression process. |
||||||
|
|
||||||
|
-lc{N}: set number of literal context bits - [0, 8], default: 3 |
||||||
|
Sometimes lc=4 gives gain for big files. |
||||||
|
|
||||||
|
-lp{N}: set number of literal pos bits - [0, 4], default: 0 |
||||||
|
lp switch is intended for periodical data when period is |
||||||
|
equal 2^N. For example, for 32-bit (4 bytes) |
||||||
|
periodical data you can use lp=2. Often it's better to set lc0, |
||||||
|
if you change lp switch. |
||||||
|
|
||||||
|
-pb{N}: set number of pos bits - [0, 4], default: 2 |
||||||
|
pb switch is intended for periodical data |
||||||
|
when period is equal 2^N. |
||||||
|
|
||||||
|
-mf{MF_ID}: set Match Finder. Default: bt4. |
||||||
|
Algorithms from hc* group doesn't provide good compression |
||||||
|
ratio, but they often works pretty fast in combination with |
||||||
|
fast mode (-a0). |
||||||
|
|
||||||
|
Memory requirements depend from dictionary size |
||||||
|
(parameter "d" in table below). |
||||||
|
|
||||||
|
MF_ID Memory Description |
||||||
|
|
||||||
|
bt2 d * 9.5 + 4MB Binary Tree with 2 bytes hashing. |
||||||
|
bt3 d * 11.5 + 4MB Binary Tree with 3 bytes hashing. |
||||||
|
bt4 d * 11.5 + 4MB Binary Tree with 4 bytes hashing. |
||||||
|
hc4 d * 7.5 + 4MB Hash Chain with 4 bytes hashing. |
||||||
|
|
||||||
|
-eos: write End Of Stream marker. By default LZMA doesn't write |
||||||
|
eos marker, since LZMA decoder knows uncompressed size |
||||||
|
stored in .lzma file header. |
||||||
|
|
||||||
|
-si: Read data from stdin (it will write End Of Stream marker). |
||||||
|
-so: Write data to stdout |
||||||
|
|
||||||
|
|
||||||
|
Examples: |
||||||
|
|
||||||
|
1) LZMA e file.bin file.lzma -d16 -lc0 |
||||||
|
|
||||||
|
compresses file.bin to file.lzma with 64 KB dictionary (2^16=64K) |
||||||
|
and 0 literal context bits. -lc0 allows to reduce memory requirements |
||||||
|
for decompression. |
||||||
|
|
||||||
|
|
||||||
|
2) LZMA e file.bin file.lzma -lc0 -lp2 |
||||||
|
|
||||||
|
compresses file.bin to file.lzma with settings suitable |
||||||
|
for 32-bit periodical data (for example, ARM or MIPS code). |
||||||
|
|
||||||
|
3) LZMA d file.lzma file.bin |
||||||
|
|
||||||
|
decompresses file.lzma to file.bin. |
||||||
|
|
||||||
|
|
||||||
|
Compression ratio hints |
||||||
|
----------------------- |
||||||
|
|
||||||
|
Recommendations |
||||||
|
--------------- |
||||||
|
|
||||||
|
To increase compression ratio for LZMA compressing it's desirable |
||||||
|
to have aligned data (if it's possible) and also it's desirable to locate |
||||||
|
data in such order, where code is grouped in one place and data is |
||||||
|
grouped in other place (it's better than such mixing: code, data, code, |
||||||
|
data, ...). |
||||||
|
|
||||||
|
|
||||||
|
Using Filters |
||||||
|
------------- |
||||||
|
You can increase compression ratio for some data types, using |
||||||
|
special filters before compressing. For example, it's possible to |
||||||
|
increase compression ratio on 5-10% for code for those CPU ISAs: |
||||||
|
x86, IA-64, ARM, ARM-Thumb, PowerPC, SPARC. |
||||||
|
|
||||||
|
You can find C/C++ source code of such filters in folder "7zip/Compress/Branch" |
||||||
|
|
||||||
|
You can check compression ratio gain of these filters with such |
||||||
|
7-Zip commands (example for ARM code): |
||||||
|
No filter: |
||||||
|
7z a a1.7z a.bin -m0=lzma |
||||||
|
|
||||||
|
With filter for little-endian ARM code: |
||||||
|
7z a a2.7z a.bin -m0=bc_arm -m1=lzma |
||||||
|
|
||||||
|
With filter for big-endian ARM code (using additional Swap4 filter): |
||||||
|
7z a a3.7z a.bin -m0=swap4 -m1=bc_arm -m2=lzma |
||||||
|
|
||||||
|
It works in such manner: |
||||||
|
Compressing = Filter_encoding + LZMA_encoding |
||||||
|
Decompressing = LZMA_decoding + Filter_decoding |
||||||
|
|
||||||
|
Compressing and decompressing speed of such filters is very high, |
||||||
|
so it will not increase decompressing time too much. |
||||||
|
Moreover, it reduces decompression time for LZMA_decoding, |
||||||
|
since compression ratio with filtering is higher. |
||||||
|
|
||||||
|
These filters convert CALL (calling procedure) instructions |
||||||
|
from relative offsets to absolute addresses, so such data becomes more |
||||||
|
compressible. Source code of these CALL filters is pretty simple |
||||||
|
(about 20 lines of C++), so you can convert it from C++ version yourself. |
||||||
|
|
||||||
|
For some ISAs (for example, for MIPS) it's impossible to get gain from such filter. |
||||||
|
|
||||||
|
|
||||||
|
LZMA compressed file format |
||||||
|
--------------------------- |
||||||
|
Offset Size Description |
||||||
|
0 1 Special LZMA properties for compressed data |
||||||
|
1 4 Dictionary size (little endian) |
||||||
|
5 8 Uncompressed size (little endian). -1 means unknown size |
||||||
|
13 Compressed data |
||||||
|
|
||||||
|
|
||||||
|
ANSI-C LZMA Decoder |
||||||
|
~~~~~~~~~~~~~~~~~~~ |
||||||
|
|
||||||
|
To compile ANSI-C LZMA Decoder you can use one of the following files sets: |
||||||
|
1) LzmaDecode.h + LzmaDecode.c + LzmaTest.c (fastest version) |
||||||
|
2) LzmaDecode.h + LzmaDecodeSize.c + LzmaTest.c (old size-optimized version) |
||||||
|
3) LzmaStateDecode.h + LzmaStateDecode.c + LzmaStateTest.c (zlib-like interface) |
||||||
|
|
||||||
|
|
||||||
|
Memory requirements for LZMA decoding |
||||||
|
------------------------------------- |
||||||
|
|
||||||
|
LZMA decoder doesn't allocate memory itself, so you must |
||||||
|
allocate memory and send it to LZMA. |
||||||
|
|
||||||
|
Stack usage of LZMA decoding function for local variables is not |
||||||
|
larger than 200 bytes. |
||||||
|
|
||||||
|
How To decompress data |
||||||
|
---------------------- |
||||||
|
|
||||||
|
LZMA Decoder (ANSI-C version) now supports 5 interfaces: |
||||||
|
1) Single-call Decompressing |
||||||
|
2) Single-call Decompressing with input stream callback |
||||||
|
3) Multi-call Decompressing with output buffer |
||||||
|
4) Multi-call Decompressing with input callback and output buffer |
||||||
|
5) Multi-call State Decompressing (zlib-like interface) |
||||||
|
|
||||||
|
Variant-5 is similar to Variant-4, but Variant-5 doesn't use callback functions. |
||||||
|
|
||||||
|
Decompressing steps |
||||||
|
------------------- |
||||||
|
|
||||||
|
1) read LZMA properties (5 bytes): |
||||||
|
unsigned char properties[LZMA_PROPERTIES_SIZE]; |
||||||
|
|
||||||
|
2) read uncompressed size (8 bytes, little-endian) |
||||||
|
|
||||||
|
3) Decode properties: |
||||||
|
|
||||||
|
CLzmaDecoderState state; /* it's 24-140 bytes structure, if int is 32-bit */ |
||||||
|
|
||||||
|
if (LzmaDecodeProperties(&state.Properties, properties, LZMA_PROPERTIES_SIZE) != LZMA_RESULT_OK) |
||||||
|
return PrintError(rs, "Incorrect stream properties"); |
||||||
|
|
||||||
|
4) Allocate memory block for internal Structures: |
||||||
|
|
||||||
|
state.Probs = (CProb *)malloc(LzmaGetNumProbs(&state.Properties) * sizeof(CProb)); |
||||||
|
if (state.Probs == 0) |
||||||
|
return PrintError(rs, kCantAllocateMessage); |
||||||
|
|
||||||
|
LZMA decoder uses array of CProb variables as internal structure. |
||||||
|
By default, CProb is unsigned_short. But you can define _LZMA_PROB32 to make |
||||||
|
it unsigned_int. It can increase speed on some 32-bit CPUs, but memory |
||||||
|
usage will be doubled in that case. |
||||||
|
|
||||||
|
|
||||||
|
5) Main Decompressing |
||||||
|
|
||||||
|
You must use one of the following interfaces: |
||||||
|
|
||||||
|
5.1 Single-call Decompressing |
||||||
|
----------------------------- |
||||||
|
When to use: RAM->RAM decompressing |
||||||
|
Compile files: LzmaDecode.h, LzmaDecode.c |
||||||
|
Compile defines: no defines |
||||||
|
Memory Requirements: |
||||||
|
- Input buffer: compressed size |
||||||
|
- Output buffer: uncompressed size |
||||||
|
- LZMA Internal Structures (~16 KB for default settings) |
||||||
|
|
||||||
|
Interface: |
||||||
|
int res = LzmaDecode(&state, |
||||||
|
inStream, compressedSize, &inProcessed, |
||||||
|
outStream, outSize, &outProcessed); |
||||||
|
|
||||||
|
|
||||||
|
5.2 Single-call Decompressing with input stream callback |
||||||
|
-------------------------------------------------------- |
||||||
|
When to use: File->RAM or Flash->RAM decompressing. |
||||||
|
Compile files: LzmaDecode.h, LzmaDecode.c |
||||||
|
Compile defines: _LZMA_IN_CB |
||||||
|
Memory Requirements: |
||||||
|
- Buffer for input stream: any size (for example, 16 KB) |
||||||
|
- Output buffer: uncompressed size |
||||||
|
- LZMA Internal Structures (~16 KB for default settings) |
||||||
|
|
||||||
|
Interface: |
||||||
|
typedef struct _CBuffer |
||||||
|
{ |
||||||
|
ILzmaInCallback InCallback; |
||||||
|
FILE *File; |
||||||
|
unsigned char Buffer[kInBufferSize]; |
||||||
|
} CBuffer; |
||||||
|
|
||||||
|
int LzmaReadCompressed(void *object, const unsigned char **buffer, SizeT *size) |
||||||
|
{ |
||||||
|
CBuffer *bo = (CBuffer *)object; |
||||||
|
*buffer = bo->Buffer; |
||||||
|
*size = MyReadFile(bo->File, bo->Buffer, kInBufferSize); |
||||||
|
return LZMA_RESULT_OK; |
||||||
|
} |
||||||
|
|
||||||
|
CBuffer g_InBuffer; |
||||||
|
|
||||||
|
g_InBuffer.File = inFile; |
||||||
|
g_InBuffer.InCallback.Read = LzmaReadCompressed; |
||||||
|
int res = LzmaDecode(&state, |
||||||
|
&g_InBuffer.InCallback, |
||||||
|
outStream, outSize, &outProcessed); |
||||||
|
|
||||||
|
|
||||||
|
5.3 Multi-call decompressing with output buffer |
||||||
|
----------------------------------------------- |
||||||
|
When to use: RAM->File decompressing |
||||||
|
Compile files: LzmaDecode.h, LzmaDecode.c |
||||||
|
Compile defines: _LZMA_OUT_READ |
||||||
|
Memory Requirements: |
||||||
|
- Input buffer: compressed size |
||||||
|
- Buffer for output stream: any size (for example, 16 KB) |
||||||
|
- LZMA Internal Structures (~16 KB for default settings) |
||||||
|
- LZMA dictionary (dictionary size is encoded in stream properties) |
||||||
|
|
||||||
|
Interface: |
||||||
|
|
||||||
|
state.Dictionary = (unsigned char *)malloc(state.Properties.DictionarySize); |
||||||
|
|
||||||
|
LzmaDecoderInit(&state); |
||||||
|
do |
||||||
|
{ |
||||||
|
LzmaDecode(&state, |
||||||
|
inBuffer, inAvail, &inProcessed, |
||||||
|
g_OutBuffer, outAvail, &outProcessed); |
||||||
|
inAvail -= inProcessed; |
||||||
|
inBuffer += inProcessed; |
||||||
|
} |
||||||
|
while you need more bytes |
||||||
|
|
||||||
|
see LzmaTest.c for more details. |
||||||
|
|
||||||
|
|
||||||
|
5.4 Multi-call decompressing with input callback and output buffer |
||||||
|
------------------------------------------------------------------ |
||||||
|
When to use: File->File decompressing |
||||||
|
Compile files: LzmaDecode.h, LzmaDecode.c |
||||||
|
Compile defines: _LZMA_IN_CB, _LZMA_OUT_READ |
||||||
|
Memory Requirements: |
||||||
|
- Buffer for input stream: any size (for example, 16 KB) |
||||||
|
- Buffer for output stream: any size (for example, 16 KB) |
||||||
|
- LZMA Internal Structures (~16 KB for default settings) |
||||||
|
- LZMA dictionary (dictionary size is encoded in stream properties) |
||||||
|
|
||||||
|
Interface: |
||||||
|
|
||||||
|
state.Dictionary = (unsigned char *)malloc(state.Properties.DictionarySize); |
||||||
|
|
||||||
|
LzmaDecoderInit(&state); |
||||||
|
do |
||||||
|
{ |
||||||
|
LzmaDecode(&state, |
||||||
|
&bo.InCallback, |
||||||
|
g_OutBuffer, outAvail, &outProcessed); |
||||||
|
} |
||||||
|
while you need more bytes |
||||||
|
|
||||||
|
see LzmaTest.c for more details: |
||||||
|
|
||||||
|
|
||||||
|
5.5 Multi-call State Decompressing (zlib-like interface) |
||||||
|
------------------------------------------------------------------ |
||||||
|
When to use: file->file decompressing |
||||||
|
Compile files: LzmaStateDecode.h, LzmaStateDecode.c |
||||||
|
Compile defines: |
||||||
|
Memory Requirements: |
||||||
|
- Buffer for input stream: any size (for example, 16 KB) |
||||||
|
- Buffer for output stream: any size (for example, 16 KB) |
||||||
|
- LZMA Internal Structures (~16 KB for default settings) |
||||||
|
- LZMA dictionary (dictionary size is encoded in stream properties) |
||||||
|
|
||||||
|
Interface: |
||||||
|
|
||||||
|
state.Dictionary = (unsigned char *)malloc(state.Properties.DictionarySize); |
||||||
|
|
||||||
|
|
||||||
|
LzmaDecoderInit(&state); |
||||||
|
do |
||||||
|
{ |
||||||
|
res = LzmaDecode(&state, |
||||||
|
inBuffer, inAvail, &inProcessed, |
||||||
|
g_OutBuffer, outAvail, &outProcessed, |
||||||
|
finishDecoding); |
||||||
|
inAvail -= inProcessed; |
||||||
|
inBuffer += inProcessed; |
||||||
|
} |
||||||
|
while you need more bytes |
||||||
|
|
||||||
|
see LzmaStateTest.c for more details: |
||||||
|
|
||||||
|
|
||||||
|
6) Free all allocated blocks |
||||||
|
|
||||||
|
|
||||||
|
Note |
||||||
|
---- |
||||||
|
LzmaDecodeSize.c is size-optimized version of LzmaDecode.c. |
||||||
|
But compiled code of LzmaDecodeSize.c can be larger than |
||||||
|
compiled code of LzmaDecode.c. So it's better to use |
||||||
|
LzmaDecode.c in most cases. |
||||||
|
|
||||||
|
|
||||||
|
EXIT codes |
||||||
|
----------- |
||||||
|
|
||||||
|
LZMA decoder can return one of the following codes: |
||||||
|
|
||||||
|
#define LZMA_RESULT_OK 0 |
||||||
|
#define LZMA_RESULT_DATA_ERROR 1 |
||||||
|
|
||||||
|
If you use callback function for input data and you return some |
||||||
|
error code, LZMA Decoder also returns that code. |
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
LZMA Defines |
||||||
|
------------ |
||||||
|
|
||||||
|
_LZMA_IN_CB - Use callback for input data |
||||||
|
|
||||||
|
_LZMA_OUT_READ - Use read function for output data |
||||||
|
|
||||||
|
_LZMA_LOC_OPT - Enable local speed optimizations inside code. |
||||||
|
_LZMA_LOC_OPT is only for LzmaDecodeSize.c (size-optimized version). |
||||||
|
_LZMA_LOC_OPT doesn't affect LzmaDecode.c (speed-optimized version) |
||||||
|
and LzmaStateDecode.c |
||||||
|
|
||||||
|
_LZMA_PROB32 - It can increase speed on some 32-bit CPUs, |
||||||
|
but memory usage will be doubled in that case |
||||||
|
|
||||||
|
_LZMA_UINT32_IS_ULONG - Define it if int is 16-bit on your compiler |
||||||
|
and long is 32-bit. |
||||||
|
|
||||||
|
_LZMA_SYSTEM_SIZE_T - Define it if you want to use system's size_t. |
||||||
|
You can use it to enable 64-bit sizes supporting |
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
C++ LZMA Encoder/Decoder |
||||||
|
~~~~~~~~~~~~~~~~~~~~~~~~ |
||||||
|
C++ LZMA code use COM-like interfaces. So if you want to use it, |
||||||
|
you can study basics of COM/OLE. |
||||||
|
|
||||||
|
By default, LZMA Encoder contains all Match Finders. |
||||||
|
But for compressing it's enough to have just one of them. |
||||||
|
So for reducing size of compressing code you can define: |
||||||
|
#define COMPRESS_MF_BT |
||||||
|
#define COMPRESS_MF_BT4 |
||||||
|
and it will use only bt4 match finder. |
||||||
|
|
||||||
|
|
||||||
|
--- |
||||||
|
|
||||||
|
http://www.7-zip.org |
||||||
|
http://www.7-zip.org/support.html |
Loading…
Reference in new issue