mirror of
https://github.com/aaru-dps/libaaruformat.git
synced 2025-12-16 19:24:40 +00:00
Add LZMA.
This commit is contained in:
329
3rdparty/lzma-21.03beta/Java/SevenZip/Compression/LZMA/Decoder.java
vendored
Normal file
329
3rdparty/lzma-21.03beta/Java/SevenZip/Compression/LZMA/Decoder.java
vendored
Normal file
@@ -0,0 +1,329 @@
|
||||
package SevenZip.Compression.LZMA;
|
||||
|
||||
import SevenZip.Compression.RangeCoder.BitTreeDecoder;
|
||||
import SevenZip.Compression.LZMA.Base;
|
||||
import SevenZip.Compression.LZ.OutWindow;
|
||||
import java.io.IOException;
|
||||
|
||||
public class Decoder
|
||||
{
|
||||
class LenDecoder
|
||||
{
|
||||
short[] m_Choice = new short[2];
|
||||
BitTreeDecoder[] m_LowCoder = new BitTreeDecoder[Base.kNumPosStatesMax];
|
||||
BitTreeDecoder[] m_MidCoder = new BitTreeDecoder[Base.kNumPosStatesMax];
|
||||
BitTreeDecoder m_HighCoder = new BitTreeDecoder(Base.kNumHighLenBits);
|
||||
int m_NumPosStates = 0;
|
||||
|
||||
public void Create(int numPosStates)
|
||||
{
|
||||
for (; m_NumPosStates < numPosStates; m_NumPosStates++)
|
||||
{
|
||||
m_LowCoder[m_NumPosStates] = new BitTreeDecoder(Base.kNumLowLenBits);
|
||||
m_MidCoder[m_NumPosStates] = new BitTreeDecoder(Base.kNumMidLenBits);
|
||||
}
|
||||
}
|
||||
|
||||
public void Init()
|
||||
{
|
||||
SevenZip.Compression.RangeCoder.Decoder.InitBitModels(m_Choice);
|
||||
for (int posState = 0; posState < m_NumPosStates; posState++)
|
||||
{
|
||||
m_LowCoder[posState].Init();
|
||||
m_MidCoder[posState].Init();
|
||||
}
|
||||
m_HighCoder.Init();
|
||||
}
|
||||
|
||||
public int Decode(SevenZip.Compression.RangeCoder.Decoder rangeDecoder, int posState) throws IOException
|
||||
{
|
||||
if (rangeDecoder.DecodeBit(m_Choice, 0) == 0)
|
||||
return m_LowCoder[posState].Decode(rangeDecoder);
|
||||
int symbol = Base.kNumLowLenSymbols;
|
||||
if (rangeDecoder.DecodeBit(m_Choice, 1) == 0)
|
||||
symbol += m_MidCoder[posState].Decode(rangeDecoder);
|
||||
else
|
||||
symbol += Base.kNumMidLenSymbols + m_HighCoder.Decode(rangeDecoder);
|
||||
return symbol;
|
||||
}
|
||||
}
|
||||
|
||||
class LiteralDecoder
|
||||
{
|
||||
class Decoder2
|
||||
{
|
||||
short[] m_Decoders = new short[0x300];
|
||||
|
||||
public void Init()
|
||||
{
|
||||
SevenZip.Compression.RangeCoder.Decoder.InitBitModels(m_Decoders);
|
||||
}
|
||||
|
||||
public byte DecodeNormal(SevenZip.Compression.RangeCoder.Decoder rangeDecoder) throws IOException
|
||||
{
|
||||
int symbol = 1;
|
||||
do
|
||||
symbol = (symbol << 1) | rangeDecoder.DecodeBit(m_Decoders, symbol);
|
||||
while (symbol < 0x100);
|
||||
return (byte)symbol;
|
||||
}
|
||||
|
||||
public byte DecodeWithMatchByte(SevenZip.Compression.RangeCoder.Decoder rangeDecoder, byte matchByte) throws IOException
|
||||
{
|
||||
int symbol = 1;
|
||||
do
|
||||
{
|
||||
int matchBit = (matchByte >> 7) & 1;
|
||||
matchByte <<= 1;
|
||||
int bit = rangeDecoder.DecodeBit(m_Decoders, ((1 + matchBit) << 8) + symbol);
|
||||
symbol = (symbol << 1) | bit;
|
||||
if (matchBit != bit)
|
||||
{
|
||||
while (symbol < 0x100)
|
||||
symbol = (symbol << 1) | rangeDecoder.DecodeBit(m_Decoders, symbol);
|
||||
break;
|
||||
}
|
||||
}
|
||||
while (symbol < 0x100);
|
||||
return (byte)symbol;
|
||||
}
|
||||
}
|
||||
|
||||
Decoder2[] m_Coders;
|
||||
int m_NumPrevBits;
|
||||
int m_NumPosBits;
|
||||
int m_PosMask;
|
||||
|
||||
public void Create(int numPosBits, int numPrevBits)
|
||||
{
|
||||
if (m_Coders != null && m_NumPrevBits == numPrevBits && m_NumPosBits == numPosBits)
|
||||
return;
|
||||
m_NumPosBits = numPosBits;
|
||||
m_PosMask = (1 << numPosBits) - 1;
|
||||
m_NumPrevBits = numPrevBits;
|
||||
int numStates = 1 << (m_NumPrevBits + m_NumPosBits);
|
||||
m_Coders = new Decoder2[numStates];
|
||||
for (int i = 0; i < numStates; i++)
|
||||
m_Coders[i] = new Decoder2();
|
||||
}
|
||||
|
||||
public void Init()
|
||||
{
|
||||
int numStates = 1 << (m_NumPrevBits + m_NumPosBits);
|
||||
for (int i = 0; i < numStates; i++)
|
||||
m_Coders[i].Init();
|
||||
}
|
||||
|
||||
Decoder2 GetDecoder(int pos, byte prevByte)
|
||||
{
|
||||
return m_Coders[((pos & m_PosMask) << m_NumPrevBits) + ((prevByte & 0xFF) >>> (8 - m_NumPrevBits))];
|
||||
}
|
||||
}
|
||||
|
||||
OutWindow m_OutWindow = new OutWindow();
|
||||
SevenZip.Compression.RangeCoder.Decoder m_RangeDecoder = new SevenZip.Compression.RangeCoder.Decoder();
|
||||
|
||||
short[] m_IsMatchDecoders = new short[Base.kNumStates << Base.kNumPosStatesBitsMax];
|
||||
short[] m_IsRepDecoders = new short[Base.kNumStates];
|
||||
short[] m_IsRepG0Decoders = new short[Base.kNumStates];
|
||||
short[] m_IsRepG1Decoders = new short[Base.kNumStates];
|
||||
short[] m_IsRepG2Decoders = new short[Base.kNumStates];
|
||||
short[] m_IsRep0LongDecoders = new short[Base.kNumStates << Base.kNumPosStatesBitsMax];
|
||||
|
||||
BitTreeDecoder[] m_PosSlotDecoder = new BitTreeDecoder[Base.kNumLenToPosStates];
|
||||
short[] m_PosDecoders = new short[Base.kNumFullDistances - Base.kEndPosModelIndex];
|
||||
|
||||
BitTreeDecoder m_PosAlignDecoder = new BitTreeDecoder(Base.kNumAlignBits);
|
||||
|
||||
LenDecoder m_LenDecoder = new LenDecoder();
|
||||
LenDecoder m_RepLenDecoder = new LenDecoder();
|
||||
|
||||
LiteralDecoder m_LiteralDecoder = new LiteralDecoder();
|
||||
|
||||
int m_DictionarySize = -1;
|
||||
int m_DictionarySizeCheck = -1;
|
||||
|
||||
int m_PosStateMask;
|
||||
|
||||
public Decoder()
|
||||
{
|
||||
for (int i = 0; i < Base.kNumLenToPosStates; i++)
|
||||
m_PosSlotDecoder[i] = new BitTreeDecoder(Base.kNumPosSlotBits);
|
||||
}
|
||||
|
||||
boolean SetDictionarySize(int dictionarySize)
|
||||
{
|
||||
if (dictionarySize < 0)
|
||||
return false;
|
||||
if (m_DictionarySize != dictionarySize)
|
||||
{
|
||||
m_DictionarySize = dictionarySize;
|
||||
m_DictionarySizeCheck = Math.max(m_DictionarySize, 1);
|
||||
m_OutWindow.Create(Math.max(m_DictionarySizeCheck, (1 << 12)));
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
boolean SetLcLpPb(int lc, int lp, int pb)
|
||||
{
|
||||
if (lc > Base.kNumLitContextBitsMax || lp > 4 || pb > Base.kNumPosStatesBitsMax)
|
||||
return false;
|
||||
m_LiteralDecoder.Create(lp, lc);
|
||||
int numPosStates = 1 << pb;
|
||||
m_LenDecoder.Create(numPosStates);
|
||||
m_RepLenDecoder.Create(numPosStates);
|
||||
m_PosStateMask = numPosStates - 1;
|
||||
return true;
|
||||
}
|
||||
|
||||
void Init() throws IOException
|
||||
{
|
||||
m_OutWindow.Init(false);
|
||||
|
||||
SevenZip.Compression.RangeCoder.Decoder.InitBitModels(m_IsMatchDecoders);
|
||||
SevenZip.Compression.RangeCoder.Decoder.InitBitModels(m_IsRep0LongDecoders);
|
||||
SevenZip.Compression.RangeCoder.Decoder.InitBitModels(m_IsRepDecoders);
|
||||
SevenZip.Compression.RangeCoder.Decoder.InitBitModels(m_IsRepG0Decoders);
|
||||
SevenZip.Compression.RangeCoder.Decoder.InitBitModels(m_IsRepG1Decoders);
|
||||
SevenZip.Compression.RangeCoder.Decoder.InitBitModels(m_IsRepG2Decoders);
|
||||
SevenZip.Compression.RangeCoder.Decoder.InitBitModels(m_PosDecoders);
|
||||
|
||||
m_LiteralDecoder.Init();
|
||||
int i;
|
||||
for (i = 0; i < Base.kNumLenToPosStates; i++)
|
||||
m_PosSlotDecoder[i].Init();
|
||||
m_LenDecoder.Init();
|
||||
m_RepLenDecoder.Init();
|
||||
m_PosAlignDecoder.Init();
|
||||
m_RangeDecoder.Init();
|
||||
}
|
||||
|
||||
public boolean Code(java.io.InputStream inStream, java.io.OutputStream outStream,
|
||||
long outSize) throws IOException
|
||||
{
|
||||
m_RangeDecoder.SetStream(inStream);
|
||||
m_OutWindow.SetStream(outStream);
|
||||
Init();
|
||||
|
||||
int state = Base.StateInit();
|
||||
int rep0 = 0, rep1 = 0, rep2 = 0, rep3 = 0;
|
||||
|
||||
long nowPos64 = 0;
|
||||
byte prevByte = 0;
|
||||
while (outSize < 0 || nowPos64 < outSize)
|
||||
{
|
||||
int posState = (int)nowPos64 & m_PosStateMask;
|
||||
if (m_RangeDecoder.DecodeBit(m_IsMatchDecoders, (state << Base.kNumPosStatesBitsMax) + posState) == 0)
|
||||
{
|
||||
LiteralDecoder.Decoder2 decoder2 = m_LiteralDecoder.GetDecoder((int)nowPos64, prevByte);
|
||||
if (!Base.StateIsCharState(state))
|
||||
prevByte = decoder2.DecodeWithMatchByte(m_RangeDecoder, m_OutWindow.GetByte(rep0));
|
||||
else
|
||||
prevByte = decoder2.DecodeNormal(m_RangeDecoder);
|
||||
m_OutWindow.PutByte(prevByte);
|
||||
state = Base.StateUpdateChar(state);
|
||||
nowPos64++;
|
||||
}
|
||||
else
|
||||
{
|
||||
int len;
|
||||
if (m_RangeDecoder.DecodeBit(m_IsRepDecoders, state) == 1)
|
||||
{
|
||||
len = 0;
|
||||
if (m_RangeDecoder.DecodeBit(m_IsRepG0Decoders, state) == 0)
|
||||
{
|
||||
if (m_RangeDecoder.DecodeBit(m_IsRep0LongDecoders, (state << Base.kNumPosStatesBitsMax) + posState) == 0)
|
||||
{
|
||||
state = Base.StateUpdateShortRep(state);
|
||||
len = 1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
int distance;
|
||||
if (m_RangeDecoder.DecodeBit(m_IsRepG1Decoders, state) == 0)
|
||||
distance = rep1;
|
||||
else
|
||||
{
|
||||
if (m_RangeDecoder.DecodeBit(m_IsRepG2Decoders, state) == 0)
|
||||
distance = rep2;
|
||||
else
|
||||
{
|
||||
distance = rep3;
|
||||
rep3 = rep2;
|
||||
}
|
||||
rep2 = rep1;
|
||||
}
|
||||
rep1 = rep0;
|
||||
rep0 = distance;
|
||||
}
|
||||
if (len == 0)
|
||||
{
|
||||
len = m_RepLenDecoder.Decode(m_RangeDecoder, posState) + Base.kMatchMinLen;
|
||||
state = Base.StateUpdateRep(state);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
rep3 = rep2;
|
||||
rep2 = rep1;
|
||||
rep1 = rep0;
|
||||
len = Base.kMatchMinLen + m_LenDecoder.Decode(m_RangeDecoder, posState);
|
||||
state = Base.StateUpdateMatch(state);
|
||||
int posSlot = m_PosSlotDecoder[Base.GetLenToPosState(len)].Decode(m_RangeDecoder);
|
||||
if (posSlot >= Base.kStartPosModelIndex)
|
||||
{
|
||||
int numDirectBits = (posSlot >> 1) - 1;
|
||||
rep0 = ((2 | (posSlot & 1)) << numDirectBits);
|
||||
if (posSlot < Base.kEndPosModelIndex)
|
||||
rep0 += BitTreeDecoder.ReverseDecode(m_PosDecoders,
|
||||
rep0 - posSlot - 1, m_RangeDecoder, numDirectBits);
|
||||
else
|
||||
{
|
||||
rep0 += (m_RangeDecoder.DecodeDirectBits(
|
||||
numDirectBits - Base.kNumAlignBits) << Base.kNumAlignBits);
|
||||
rep0 += m_PosAlignDecoder.ReverseDecode(m_RangeDecoder);
|
||||
if (rep0 < 0)
|
||||
{
|
||||
if (rep0 == -1)
|
||||
break;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
rep0 = posSlot;
|
||||
}
|
||||
if (rep0 >= nowPos64 || rep0 >= m_DictionarySizeCheck)
|
||||
{
|
||||
// m_OutWindow.Flush();
|
||||
return false;
|
||||
}
|
||||
m_OutWindow.CopyBlock(rep0, len);
|
||||
nowPos64 += len;
|
||||
prevByte = m_OutWindow.GetByte(0);
|
||||
}
|
||||
}
|
||||
m_OutWindow.Flush();
|
||||
m_OutWindow.ReleaseStream();
|
||||
m_RangeDecoder.ReleaseStream();
|
||||
return true;
|
||||
}
|
||||
|
||||
public boolean SetDecoderProperties(byte[] properties)
|
||||
{
|
||||
if (properties.length < 5)
|
||||
return false;
|
||||
int val = properties[0] & 0xFF;
|
||||
int lc = val % 9;
|
||||
int remainder = val / 9;
|
||||
int lp = remainder % 5;
|
||||
int pb = remainder / 5;
|
||||
int dictionarySize = 0;
|
||||
for (int i = 0; i < 4; i++)
|
||||
dictionarySize += ((int)(properties[1 + i]) & 0xFF) << (i * 8);
|
||||
if (!SetLcLpPb(lc, lp, pb))
|
||||
return false;
|
||||
return SetDictionarySize(dictionarySize);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user