tor-browser

Decoder.java (10006B)

---

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);
}
}