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