dragonleo/NSIS
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

- lzma exehead is now 34kb instead of 34.5kb thanks to the new LZMA C SDK and should be much faster due to removal of critical section usage (not tested too much, test before usage)

Browse source 
- applied some parts of patch #875485


git-svn-id: https://svn.code.sf.net/p/nsis/code/NSIS/trunk@3508 212acab6-be3b-0410-9dea-997c60f758d6
This commit is contained in:
kichik 2004-03-06 18:37:19 +00:00
parent ca9582c925
commit d18cea205c
23 changed files with 761 additions and 1267 deletions
Download patch file Download diff file Expand all files Collapse all files

29
Source/7zip/7zip/Compress/LZMA_SMALL/InBuffer.h
View file

@ -1,29 +0,0 @@
// Stream/InByte.h
#include "LZMAState.h"
#ifndef __STREAM_INBYTE_H
#define __STREAM_INBYTE_H
class CInBuffer
{
CLZMAStateP m_lzmaState;
public:
void Init(CLZMAStateP lzmaState)
{
m_lzmaState = lzmaState;
}
BYTE ReadByte()
{
if (!m_lzmaState->avail_in)
{
LZMAGetIO(m_lzmaState);
}
if (!m_lzmaState->avail_in)
return 0;
m_lzmaState->avail_in--;
return *m_lzmaState->next_in++;
}
};
#endif

62
Source/7zip/7zip/Compress/LZMA_SMALL/LZMA.h
View file

@ -1,62 +0,0 @@
// LZMA.h
#include "LZMALenCoder.h"
#ifndef __LZMA_H
#define __LZMA_H
const int kNumRepDistances = 4;
const int kNumStates = 12;
const BYTE kLiteralNextStates[kNumStates] = {0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 4, 5};
const BYTE kMatchNextStates[kNumStates] = {7, 7, 7, 7, 7, 7, 7, 10, 10, 10, 10, 10};
const BYTE kRepNextStates[kNumStates] = {8, 8, 8, 8, 8, 8, 8, 11, 11, 11, 11, 11};
const BYTE kShortRepNextStates[kNumStates]= {9, 9, 9, 9, 9, 9, 9, 11, 11, 11, 11, 11};
class CState
{
public:
int Index;
void Init() { Index = 0; }
void UpdateChar() { Index = kLiteralNextStates[Index]; }
void UpdateMatch() { Index = kMatchNextStates[Index]; }
void UpdateRep() { Index = kRepNextStates[Index]; }
void UpdateShortRep() { Index = kShortRepNextStates[Index]; }
};
const int kNumPosSlotBits = 6;
const int kNumLenToPosStates = 4;
/*
inline int GetLenToPosState(int len)
{
if (len < kNumLenToPosStates + 2)
return len - 2;
return kNumLenToPosStates - 1;
}
*/
inline int GetLenToPosState2(int len)
{
if (len < kNumLenToPosStates)
return len;
return kNumLenToPosStates - 1;
}
const int kMatchMinLen = 2;
const int kMatchMaxLen = kMatchMinLen + kLenNumSymbolsTotal - 1;
const int kNumAlignBits = 4;
const int kAlignTableSize = 1 << kNumAlignBits;
const int kStartPosModelIndex = 4;
const int kEndPosModelIndex = 14;
const int kNumPosModels = kEndPosModelIndex - kStartPosModelIndex;
const int kNumFullDistances = 1 << (kEndPosModelIndex / 2);
const int kNumLitPosStatesBitsEncodingMax = 4;
const int kNumLitContextBitsMax = 8;
#endif

25
Source/7zip/7zip/Compress/LZMA_SMALL/LZMAConf.h
View file

@ -1,25 +0,0 @@
#ifndef __LZMACONF_H
#define __LZMACONF_H
// define __LOC_OPT for some speed optimization:
// It converts some class-member variables to local variables
// before some loops and it use inline code substitution
#define __LOC_OPT
// #define __UNROLL
#include <windows.h>
#ifdef __cplusplus
extern "C" {
#endif
#include "../../../../exehead/util.h"
#ifdef __cplusplus
}
#endif
#define LZMAAlloc my_GlobalAlloc
#define LZMAFree GlobalFree
#define LZMAMemCopy mini_memcpy
#endif

171
Source/7zip/7zip/Compress/LZMA_SMALL/LZMADecoder.cpp
View file

@ -1,171 +0,0 @@
// LZMADecoder.cpp
#include "LZMADecoder.h"
void CLZMADecoder::Create(BYTE *memoryPointer,
int numLiteralContextBits,
int numLiteralPosStateBits,
int numPosStateBits)
{
int numPosStates = 1 << numPosStateBits;
m_PosStateMask = numPosStates - 1;
m_LiteralDecoder.Create(memoryPointer, numLiteralPosStateBits, numLiteralContextBits);
}
UINT32 CLZMADecoder::Code(CLZMAStateP lzmaState)
{
m_RangeDecoder.Init(lzmaState);
m_OutWindowStream.Init(lzmaState);
int i;
for (i = 0; i < sizeof(m_Decoders) / sizeof(CBitDecoder); i++)
{
((CBitDecoder *) &m_Decoders)[i].Init();
}
m_LiteralDecoder.Init();
for (i = 0; i < kNumLenToPosStates; i++)
m_PosSlotDecoder[i].Init();
m_PosDecoder.Init();
m_PosAlignDecoder.Init();
// m_LenDecoder.Init(m_PosStateMask + 1);
// m_RepMatchLenDecoder.Init(m_PosStateMask + 1);
m_LenDecoder.Init();
m_RepMatchLenDecoder.Init();
////////////////////////
// code
CState state;
state.Init();
bool peviousIsMatch = false;
BYTE previousByte = 0;
// kNumRepDistances == 4
UINT32 repDistances[kNumRepDistances] = {1, 1, 1, 1};
/*for(i = 0 ; i < kNumRepDistances; i++)
repDistances[i] = 1;*/
UINT32 nowPos = 0;
while(nowPos < 0xFFFFFFFF)
{
int posState = nowPos & m_PosStateMask;
if (!m_Decoders.MainChoiceDecoders[state.Index][posState].Decode(&m_RangeDecoder))
{
state.UpdateChar();
if(peviousIsMatch)
{
BYTE matchByte = m_OutWindowStream.GetOneByte(0 - repDistances[0]);
previousByte = m_LiteralDecoder.DecodeWithMatchByte(&m_RangeDecoder,
nowPos, previousByte, matchByte);
peviousIsMatch = false;
}
else
previousByte = m_LiteralDecoder.DecodeNormal(&m_RangeDecoder,
nowPos, previousByte);
m_OutWindowStream.PutOneByte(previousByte);
nowPos++;
}
else
{
peviousIsMatch = true;
UINT32 distance;
int len;
if(m_Decoders.MatchChoiceDecoders[state.Index].Decode(&m_RangeDecoder))
{
if(!m_Decoders.MatchRepChoiceDecoders[state.Index].Decode(&m_RangeDecoder))
{
if(!m_Decoders.MatchRepShortChoiceDecoders[state.Index][posState].Decode(&m_RangeDecoder))
{
state.UpdateShortRep();
previousByte = m_OutWindowStream.GetOneByte(0 - repDistances[0]);
m_OutWindowStream.PutOneByte(previousByte);
nowPos++;
continue;
}
distance = repDistances[0];
}
else
{
if(!m_Decoders.MatchRep1ChoiceDecoders[state.Index].Decode(&m_RangeDecoder))
distance = repDistances[1];
else
{
if (!m_Decoders.MatchRep2ChoiceDecoders[state.Index].Decode(&m_RangeDecoder))
distance = repDistances[2];
else
{
distance = repDistances[3];
repDistances[3] = repDistances[2];
}
repDistances[2] = repDistances[1];
}
repDistances[1] = repDistances[0];
repDistances[0] = distance;
}
len = m_RepMatchLenDecoder.Decode(&m_RangeDecoder, posState);
state.UpdateRep();
}
else
{
len = m_LenDecoder.Decode(&m_RangeDecoder, posState);
state.UpdateMatch();
int posSlot = m_PosSlotDecoder[GetLenToPosState2(len)].Decode(&m_RangeDecoder);
if (posSlot >= kStartPosModelIndex)
{
int numDirectBits = ((posSlot >> 1) - 1);
distance = ((2 | (posSlot & 1)) << numDirectBits);
if (posSlot < kEndPosModelIndex)
distance += m_PosDecoder.Decode(&m_RangeDecoder, posSlot);
else
{
distance += (m_RangeDecoder.DecodeDirectBits(
numDirectBits - kNumAlignBits) << kNumAlignBits);
distance += m_PosAlignDecoder.Decode(&m_RangeDecoder);
}
}
else
distance = posSlot;
distance++;
repDistances[3] = repDistances[2];
repDistances[2] = repDistances[1];
repDistances[1] = repDistances[0];
repDistances[0] = distance;
//LZMAMemCopy(repDistances, repDistances + 1, kNumRepDistances * sizeof(UINT32));
}
// it's for stream version (without knowing uncompressed size)
//if (distance >= _dictionarySizeCheck)
if (!distance)
break;
if (distance > nowPos)
return (-1);
len += kMatchMinLen;
nowPos += len;
// CopyBackBlock
{
UINT32 fromPos = m_OutWindowStream._pos - distance;
if (fromPos >= m_OutWindowStream._windowSize)
fromPos += m_OutWindowStream._windowSize;
while (len--)
{
m_OutWindowStream._buffer[m_OutWindowStream._pos++] = m_OutWindowStream._buffer[fromPos++];
if (fromPos >= m_OutWindowStream._windowSize)
fromPos = 0;
m_OutWindowStream.Flush();
}
}
previousByte = m_OutWindowStream.GetOneByte((UINT32)(-1));
}
}
m_OutWindowStream._windowSize = 0;
m_OutWindowStream.Flush();
return 0;
}

85
Source/7zip/7zip/Compress/LZMA_SMALL/LZMADecoder.h
View file

@ -1,85 +0,0 @@
// LZMADecoder.h
#ifndef __LZMADECODER_H
#define __LZMADECODER_H
#include "LZMAConf.h"
#include "LZMAState.h"
#include "LZMA.h"
#include "LZMALiteralCoder.h"
#include "LZOutWindow.h"
class CPosSpecDecoder
{
CBitDecoder m_Models[kNumFullDistances - kEndPosModelIndex];
public:
void Init()
{
for(int i = 0; i < kNumFullDistances - kEndPosModelIndex; i++)
m_Models[i].Init();
}
int Decode(CRangeDecoder *rangeDecoder, int slot)
{
int numLeveles = (slot >> 1) - 1;
CBitDecoder *models =
m_Models + (((2 | (slot & 1)) << numLeveles)) - slot - 1;
int modelIndex = 1;
int symbol = 0;
#ifdef __LOC_OPT
RC_INIT_VAR
#endif
for(int bitIndex = 0; bitIndex < numLeveles; bitIndex++)
{
#ifdef __LOC_OPT
RC_GETBIT2(models[modelIndex].Probability, modelIndex, ; , symbol |= (1 << bitIndex))
#else
int bit = models[modelIndex].Decode(rangeDecoder);
modelIndex <<= 1;
modelIndex += bit;
symbol |= (bit << bitIndex);
#endif
}
#ifdef __LOC_OPT
RC_FLUSH_VAR
#endif
return symbol;
};
};
class CLZMADecoder
{
CLZOutWindow m_OutWindowStream;
CRangeDecoder m_RangeDecoder;
struct
{
CBitDecoder MainChoiceDecoders[kNumStates][kLenNumPosStatesMax];
CBitDecoder MatchRepShortChoiceDecoders[kNumStates][kLenNumPosStatesMax];
CBitDecoder MatchChoiceDecoders[kNumStates];
CBitDecoder MatchRepChoiceDecoders[kNumStates];
CBitDecoder MatchRep1ChoiceDecoders[kNumStates];
CBitDecoder MatchRep2ChoiceDecoders[kNumStates];
} m_Decoders;
CLZMALiteralDecoder m_LiteralDecoder;
CBitTreeDecoder6 m_PosSlotDecoder[kNumLenToPosStates];
CPosSpecDecoder m_PosDecoder;
CReverseBitTreeDecoder4 m_PosAlignDecoder;
CLZMALenDecoder m_LenDecoder;
CLZMALenDecoder m_RepMatchLenDecoder;
int m_PosStateMask;
public:
void Create(BYTE *memoryPointer,
int numLiteralContextBits,
int numLiteralPosStateBits,
int numPosStateBits);
UINT32 Code(CLZMAStateP lzmaState);
};
#endif

53
Source/7zip/7zip/Compress/LZMA_SMALL/LZMALenCoder.h
View file

@ -1,53 +0,0 @@
// LZMALenCoder.h
#ifndef __LZMALENCODER_H
#define __LZMALENCODER_H
#include "RangeCoderBitTree.h"
const int kLenNumPosStatesBitsMax = 4;
const int kLenNumPosStatesMax = (1 << kLenNumPosStatesBitsMax);
const int kLenNumPosStatesBitsEncodingMax = 4;
const int kLenNumPosStatesEncodingMax = (1 << kLenNumPosStatesBitsEncodingMax);
const int kLenNumLowBits = 3;
const int kLenNumLowSymbols = 1 << kLenNumLowBits;
const int kLenNumMidBits = 3;
const int kLenNumMidSymbols = 1 << kLenNumMidBits;
const int kLenNumHighBits = 8;
const int kLenNumSymbolsTotal = kLenNumLowSymbols + kLenNumMidSymbols + (1 << kLenNumHighBits);
#define LOW 0
#define HIGH 1
class CLZMALenDecoder
{
CBitDecoder m_Choice;
CBitDecoder m_Choice2;
CBitTreeDecoder3 m_Coder[2][kLenNumPosStatesMax];
CBitTreeDecoder8 m_HighCoder;
public:
// void Init(int numPosStates)
void Init()
{
m_Choice.Init();
m_Choice2.Init();
for (int posState = 0; posState < kLenNumPosStatesMax * 2; posState++)
{
((CBitTreeDecoder3 *) m_Coder)[posState].Init();
}
m_HighCoder.Init();
}
int Decode(CRangeDecoder *rangeDecoder, int posState)
{
if(m_Choice.Decode(rangeDecoder) == 0)
return m_Coder[LOW][posState].Decode(rangeDecoder);
if(m_Choice2.Decode(rangeDecoder) == 0)
return kLenNumLowSymbols + m_Coder[HIGH][posState].Decode(rangeDecoder);
return kLenNumLowSymbols + kLenNumMidSymbols + m_HighCoder.Decode(rangeDecoder);
}
};
#endif

104
Source/7zip/7zip/Compress/LZMA_SMALL/LZMALiteralCoder.h
View file

@ -1,104 +0,0 @@
// LZMALiteralCoder.h
#ifndef __LZMALITERALCODER_H
#define __LZMALITERALCODER_H
#include "RangeCoderBit.h"
#include "RangeCoderOpt.h"
class CLZMALiteralDecoder2
{
CBitDecoder m_Decoders[3][1 << 8];
public:
void Init()
{
for (int i = 0; i < sizeof(m_Decoders) / sizeof(CBitDecoder); i++)
((CBitDecoder *) m_Decoders)[i].Init();
}
BYTE DecodeNormal(CRangeDecoder *rangeDecoder)
{
int symbol = 1;
#ifdef __LOC_OPT
RC_INIT_VAR
#endif
do
{
#ifdef __LOC_OPT
RC_GETBIT(m_Decoders[0][symbol].Probability, symbol)
#else
symbol = (symbol + symbol) | m_Decoders[0][symbol].Decode(rangeDecoder);
#endif
}
while (symbol < 0x100);
#ifdef __LOC_OPT
RC_FLUSH_VAR
#endif
return symbol;
}
BYTE DecodeWithMatchByte(CRangeDecoder *rangeDecoder, BYTE matchByte)
{
int symbol = 1;
#ifdef __LOC_OPT
RC_INIT_VAR
#endif
do
{
int matchBit = (matchByte >> 7) & 1;
matchByte <<= 1;
#ifdef __LOC_OPT
int bit;
RC_GETBIT2(m_Decoders[1 + matchBit][symbol].Probability, symbol,
bit = 0, bit = 1)
#else
int bit = m_Decoders[1 + matchBit][symbol].Decode(rangeDecoder);
symbol = (symbol + symbol) | bit;
#endif
if (matchBit != bit)
{
while (symbol < 0x100)
{
#ifdef __LOC_OPT
RC_GETBIT(m_Decoders[0][symbol].Probability, symbol)
#else
symbol = (symbol + symbol) | m_Decoders[0][symbol].Decode(rangeDecoder);
#endif
}
break;
}
}
while (symbol < 0x100);
#ifdef __LOC_OPT
RC_FLUSH_VAR
#endif
return symbol;
}
};
class CLZMALiteralDecoder
{
CLZMALiteralDecoder2 *m_Coders;
int m_NumPrevBits;
int m_PosMask;
public:
CLZMALiteralDecoder(): m_Coders(0) {}
void Create(BYTE *memory, int numPosBits, int numPrevBits)
{
m_PosMask = (1 << numPosBits) - 1;
m_NumPrevBits = numPrevBits;
m_Coders = (CLZMALiteralDecoder2 *) memory;
}
void Init()
{
int numStates = (m_PosMask + 1) << m_NumPrevBits;
for (int i = 0; i < numStates; i++)
m_Coders[i].Init();
}
int GetState(int pos, BYTE prevByte) const
{ return ((pos & m_PosMask) << m_NumPrevBits) + (prevByte >> (8 - m_NumPrevBits)); }
BYTE DecodeNormal(CRangeDecoder *rangeDecoder, int pos, BYTE prevByte)
{ return m_Coders[GetState(pos, prevByte)].DecodeNormal(rangeDecoder); }
BYTE DecodeWithMatchByte(CRangeDecoder *rangeDecoder, int pos, BYTE prevByte, BYTE matchByte)
{ return m_Coders[GetState(pos, prevByte)].DecodeWithMatchByte(rangeDecoder, matchByte); }
};
#endif

39
Source/7zip/7zip/Compress/LZMA_SMALL/LZMAState.h
View file

@ -1,39 +0,0 @@
#include <Windows.h>
#ifndef __LZMA_STATE__H___
#define __LZMA_STATE__H___
typedef struct
{
void *lzmaDecoder;
void *DynamicData;
void *Dictionary;
UINT32 DictionarySize;
BYTE FirstProp;
HANDLE hThread; /* decompression thread */
BYTE *next_in; /* next input byte */
UINT avail_in; /* number of bytes available at next_in */
BYTE *next_out; /* next output byte should be put there */
UINT avail_out; /* remaining free space at next_out */
CRITICAL_SECTION cs;
BOOL cs_initialized;
BOOL it_locked; /* installer thread locked */
BOOL dt_locked; /* decompression thread locked */
BOOL finished;
int res;
} CLZMAState;
typedef CLZMAState
#ifndef __cplusplus
FAR
#endif
*CLZMAStateP;
void __stdcall LZMAGetIO(CLZMAStateP lzmaState);
#endif

64
Source/7zip/7zip/Compress/LZMA_SMALL/LZOutWindow.h
View file

@ -1,64 +0,0 @@
// LZOutWindow.h
#ifndef __LZOUTWINDOW_H
#define __LZOUTWINDOW_H
#include "Types.h"
#include "LZMAState.h"
#include "LZMAConf.h"
class CLZOutWindow
{
public:
BYTE *_buffer;
UINT32 _pos;
UINT32 _windowSize;
UINT32 _streamPos;
CLZMAStateP m_lzmaState;
void Init(CLZMAStateP lzmaState)
{
m_lzmaState = lzmaState;
_buffer = (LPBYTE) lzmaState->Dictionary;
_windowSize = lzmaState->DictionarySize;
_streamPos = 0;
_pos = 0;
}
void PutOneByte(BYTE b)
{
_buffer[_pos++] = b;
Flush();
}
void Flush()
{
UINT32 size = _pos - _streamPos;
if (size < 65536 && _pos < _windowSize)
return;
CLZMAStateP lzmaState = m_lzmaState;
while (size--)
{
if (!lzmaState->avail_out)
{
LZMAGetIO(lzmaState);
}
*lzmaState->next_out = _buffer[_streamPos];
lzmaState->next_out++;
lzmaState->avail_out--;
_streamPos++;
}
if (_pos >= _windowSize)
{
_pos = 0;
_streamPos = 0;
}
}
BYTE GetOneByte(UINT32 index) const
{
UINT32 pos = _pos + index;
if (pos >= _windowSize)
pos += _windowSize;
return _buffer[pos];
}
};
#endif

87
Source/7zip/7zip/Compress/LZMA_SMALL/RangeCoder.h
View file

@ -1,87 +0,0 @@
// Compression/RangeCoder.h
#ifndef __COMPRESSION_RANGECODER_H
#define __COMPRESSION_RANGECODER_H
#include "InBuffer.h"
const int kNumTopBits = 24;
const UINT32 kTopValue = (1 << kNumTopBits);
class CRangeDecoder
{
public:
CInBuffer Stream;
UINT32 Range;
UINT32 Code;
void Normalize()
{
while (Range < kTopValue)
{
Code = (Code << 8) | Stream.ReadByte();
Range <<= 8;
}
}
void Init(CLZMAStateP state)
{
Stream.Init(state);
Code = 0;
Range = UINT32(-1);
for(int i = 0; i < 5; i++)
Code = (Code << 8) | Stream.ReadByte();
}
UINT32 DecodeDirectBits(int numTotalBits)
{
UINT32 range = Range;
UINT32 code = Code;
UINT32 result = 0;
for (int i = numTotalBits; i > 0; i--)
{
range >>= 1;
result <<= 1;
if (code >= range)
{
code -= range;
result |= 1;
}
/*UINT32 t = (code - range) >> 31;
code -= range & (t - 1);
// range = aRangeTmp + ((range & 1) & (1 - t));
result = (result + result) | (1 - t);*/
if (range < kTopValue)
{
code = (code << 8) | Stream.ReadByte();
range <<= 8;
}
}
Range = range;
Code = code;
return result;
}
int DecodeBit(UINT32 size0, int numTotalBits)
{
UINT32 newBound = (Range >> numTotalBits) * size0;
int symbol;
if (Code < newBound)
{
symbol = 0;
Range = newBound;
}
else
{
symbol = 1;
Code -= newBound;
Range -= newBound;
}
Normalize();
return symbol;
}
};
#endif

62
Source/7zip/7zip/Compress/LZMA_SMALL/RangeCoderBit.h
View file

@ -1,62 +0,0 @@
// RangeCoderBit.h
#ifndef __RANGECODERBIT_H
#define __RANGECODERBIT_H
#include "Types.h"
#include "RangeCoder.h"
const int kNumBitModelTotalBits = 11;
const int kBitModelTotal = (1 << kNumBitModelTotalBits);
const int kNumMoveBits = 5;
struct CBitModel
{
UINT32 Probability; // it's fast version on 32-bit systems
// unsigned short Probability; // use it if you want to reduce memory twice
void UpdateModel(int symbol)
{
/*
Probability -= (Probability + ((symbol - 1) & ((1 << numMoveBits) - 1))) >> numMoveBits;
Probability += (1 - symbol) << (kNumBitModelTotalBits - numMoveBits);
*/
if (symbol == 0)
Probability += (kBitModelTotal - Probability) >> kNumMoveBits;
else
Probability -= (Probability) >> kNumMoveBits;
}
void Init() { Probability = kBitModelTotal / 2; }
};
struct CBitDecoder: public CBitModel
{
int Decode(CRangeDecoder *rangeDecoder)
{
UINT32 newBound = (rangeDecoder->Range >> kNumBitModelTotalBits) * Probability;
int ret = 0;
if (rangeDecoder->Code < newBound)
{
rangeDecoder->Range = newBound;
Probability += (kBitModelTotal - Probability) >> kNumMoveBits;
}
else
{
rangeDecoder->Range -= newBound;
rangeDecoder->Code -= newBound;
Probability -= (Probability) >> kNumMoveBits;
ret = 1;
}
if (rangeDecoder->Range < kTopValue)
{
rangeDecoder->Code = (rangeDecoder->Code << 8) | rangeDecoder->Stream.ReadByte();
rangeDecoder->Range <<= 8;
}
return ret;
}
};
#endif

183
Source/7zip/7zip/Compress/LZMA_SMALL/RangeCoderBitTree.h
View file

@ -1,183 +0,0 @@
// RangeCoderBitTree.h
#ifndef __RANGECODERBITTREE_H
#define __RANGECODERBITTREE_H
#include "RangeCoderBit.h"
#include "RangeCoderOpt.h"
class CBitTreeDecoder3
{
CBitDecoder m_Models[1 << 3];
public:
void Init()
{
for(int i = 1; i < (1 << 3); i++)
m_Models[i].Init();
}
int Decode(CRangeDecoder *rangeDecoder)
{
int modelIndex = 1;
#ifdef __LOC_OPT
RC_INIT_VAR
#endif
#ifndef __UNROLL
for(int bitIndex = 3; bitIndex > 0; bitIndex--)
#endif
{
#ifdef __LOC_OPT
RC_GETBIT(m_Models[modelIndex].Probability, modelIndex)
#ifdef __UNROLL
RC_GETBIT(m_Models[modelIndex].Probability, modelIndex)
RC_GETBIT(m_Models[modelIndex].Probability, modelIndex)
#endif
#else
modelIndex = (modelIndex + modelIndex) + m_Models[modelIndex].Decode(rangeDecoder);
#ifdef __UNROLL
modelIndex = (modelIndex + modelIndex) + m_Models[modelIndex].Decode(rangeDecoder);
modelIndex = (modelIndex + modelIndex) + m_Models[modelIndex].Decode(rangeDecoder);
#endif
#endif
}
#ifdef __LOC_OPT
RC_FLUSH_VAR
#endif
return modelIndex - (1 << 3);
};
};
class CBitTreeDecoder6
{
CBitDecoder m_Models[1 << 6];
public:
void Init()
{
for(int i = 1; i < (1 << 6); i++)
m_Models[i].Init();
}
int Decode(CRangeDecoder *rangeDecoder)
{
int modelIndex = 1;
#ifdef __LOC_OPT
RC_INIT_VAR
#endif
#ifndef __UNROLL
for(int bitIndex = 6; bitIndex > 0; bitIndex--)
#endif
{
#ifdef __LOC_OPT
RC_GETBIT(m_Models[modelIndex].Probability, modelIndex)
#ifdef __UNROLL
RC_GETBIT(m_Models[modelIndex].Probability, modelIndex)
RC_GETBIT(m_Models[modelIndex].Probability, modelIndex)
RC_GETBIT(m_Models[modelIndex].Probability, modelIndex)
RC_GETBIT(m_Models[modelIndex].Probability, modelIndex)
RC_GETBIT(m_Models[modelIndex].Probability, modelIndex)
#endif
#else
modelIndex = (modelIndex + modelIndex) + m_Models[modelIndex].Decode(rangeDecoder);
#ifdef __UNROLL
modelIndex = (modelIndex + modelIndex) + m_Models[modelIndex].Decode(rangeDecoder);
modelIndex = (modelIndex + modelIndex) + m_Models[modelIndex].Decode(rangeDecoder);
modelIndex = (modelIndex + modelIndex) + m_Models[modelIndex].Decode(rangeDecoder);
modelIndex = (modelIndex + modelIndex) + m_Models[modelIndex].Decode(rangeDecoder);
modelIndex = (modelIndex + modelIndex) + m_Models[modelIndex].Decode(rangeDecoder);
#endif
#endif
}
#ifdef __LOC_OPT
RC_FLUSH_VAR
#endif
return modelIndex - (1 << 6);
};
};
class CBitTreeDecoder8
{
CBitDecoder m_Models[1 << 8];
public:
void Init()
{
for(int i = 1; i < (1 << 8); i++)
m_Models[i].Init();
}
int Decode(CRangeDecoder *rangeDecoder)
{
int modelIndex = 1;
#ifdef __LOC_OPT
RC_INIT_VAR
#endif
for(int bitIndex = 8; bitIndex > 0; bitIndex--)
{
#ifdef __LOC_OPT
RC_GETBIT(m_Models[modelIndex].Probability, modelIndex)
#else
modelIndex = (modelIndex + modelIndex) + m_Models[modelIndex].Decode(rangeDecoder);
#endif
}
#ifdef __LOC_OPT
RC_FLUSH_VAR
#endif
return modelIndex - (1 << 8);
};
};
class CReverseBitTreeDecoder4
{
CBitDecoder m_Models[1 << 4];
public:
void Init()
{
for(int i = 1; i < (1 << 4); i++)
m_Models[i].Init();
}
int Decode(CRangeDecoder *rangeDecoder)
{
int modelIndex = 1;
int symbol = 0;
#ifdef __LOC_OPT
RC_INIT_VAR
#endif
#ifndef __UNROLL
for(int bitIndex = 0; bitIndex < 4; bitIndex++)
#endif
{
#ifdef __LOC_OPT
#ifndef __UNROLL
RC_GETBIT2(m_Models[modelIndex].Probability, modelIndex, ; , symbol |= (1 << bitIndex))
#else
RC_GETBIT2(m_Models[modelIndex].Probability, modelIndex, ; , symbol |= (1 << 0))
RC_GETBIT2(m_Models[modelIndex].Probability, modelIndex, ; , symbol |= (1 << 1))
RC_GETBIT2(m_Models[modelIndex].Probability, modelIndex, ; , symbol |= (1 << 2))
RC_GETBIT2(m_Models[modelIndex].Probability, modelIndex, ; , symbol |= (1 << 3))
#endif
#else
#ifndef __UNROLL
int bit = m_Models[modelIndex].Decode(rangeDecoder);
modelIndex = modelIndex + modelIndex + bit;
symbol |= (bit << bitIndex);
#else
int bit = m_Models[modelIndex].Decode(rangeDecoder);
modelIndex = modelIndex + modelIndex + bit;
symbol |= (bit << 0);
bit = m_Models[modelIndex].Decode(rangeDecoder);
modelIndex = modelIndex + modelIndex + bit;
symbol |= (bit << 1);
bit = m_Models[modelIndex].Decode(rangeDecoder);
modelIndex = modelIndex + modelIndex + bit;
symbol |= (bit << 2);
bit = m_Models[modelIndex].Decode(rangeDecoder);
modelIndex = modelIndex + modelIndex + bit;
symbol |= (bit << 3);
#endif
#endif
}
#ifdef __LOC_OPT
RC_FLUSH_VAR
#endif
return symbol;
}
};
#endif

43
Source/7zip/7zip/Compress/LZMA_SMALL/RangeCoderOpt.h
View file

@ -1,43 +0,0 @@
// RangeCoderOpt.h
#ifndef __RANGECODEROPT_H
#define __RANGECODEROPT_H
#include "RangeCoderBit.h"
#define RC_INIT_VAR \
UINT32 range = rangeDecoder->Range; \
UINT32 code = rangeDecoder->Code;
#define RC_FLUSH_VAR \
rangeDecoder->Range = range; \
rangeDecoder->Code = code;
#define RC_NORMALIZE \
if (range < kTopValue) \
{ range <<= 8; code = (code << 8) | rangeDecoder->Stream.ReadByte(); }
#define RC_GETBIT2(prob, modelIndex, Action0, Action1) \
{UINT32 newBound = (range >> kNumBitModelTotalBits) * prob; \
if (code < newBound) \
{ \
Action0; \
range = newBound; \
prob += (kBitModelTotal - prob) >> kNumMoveBits; \
modelIndex <<= 1; \
} \
else \
{ \
Action1; \
range -= newBound; \
code -= newBound; \
prob -= (prob) >> kNumMoveBits; \
modelIndex = (modelIndex + modelIndex) + 1; \
}} \
RC_NORMALIZE
//modelIndex <<= 1; if (code >= newBound) modelIndex++;
#define RC_GETBIT(prob, modelIndex) RC_GETBIT2(prob, modelIndex, ; , ;)
#endif

17
Source/7zip/7zip/Compress/LZMA_SMALL/Types.h
View file

@ -1,17 +0,0 @@
// Common/Types.h
#ifndef __COMMON_TYPES_H
#define __COMMON_TYPES_H
#ifdef WIN32
#include <basetsd.h>
#else
typedef unsigned int UINT32;
#endif
#ifndef _WINDOWS_
typedef unsigned char BYTE;
#endif
#endif