tor-browser

LzmaDecoder.cs (12075B)

---

// LzmaDecoder.cs

using System;

namespace SevenZip.Compression.LZMA
{
using RangeCoder;

public class Decoder : ICoder, ISetDecoderProperties // ,System.IO.Stream
{
	class LenDecoder
	{
		BitDecoder m_Choice = new BitDecoder();
		BitDecoder m_Choice2 = new BitDecoder();
		BitTreeDecoder[] m_LowCoder = new BitTreeDecoder[Base.kNumPosStatesMax];
		BitTreeDecoder[] m_MidCoder = new BitTreeDecoder[Base.kNumPosStatesMax];
		BitTreeDecoder m_HighCoder = new BitTreeDecoder(Base.kNumHighLenBits);
		uint m_NumPosStates = 0;

		public void Create(uint numPosStates)
		{
			for (uint posState = m_NumPosStates; posState < numPosStates; posState++)
			{
				m_LowCoder[posState] = new BitTreeDecoder(Base.kNumLowLenBits);
				m_MidCoder[posState] = new BitTreeDecoder(Base.kNumMidLenBits);
			}
			m_NumPosStates = numPosStates;
		}

		public void Init()
		{
			m_Choice.Init();
			for (uint posState = 0; posState < m_NumPosStates; posState++)
			{
				m_LowCoder[posState].Init();
				m_MidCoder[posState].Init();
			}
			m_Choice2.Init();
			m_HighCoder.Init();
		}

		public uint Decode(RangeCoder.Decoder rangeDecoder, uint posState)
		{
			if (m_Choice.Decode(rangeDecoder) == 0)
				return m_LowCoder[posState].Decode(rangeDecoder);
			else
			{
				uint symbol = Base.kNumLowLenSymbols;
				if (m_Choice2.Decode(rangeDecoder) == 0)
					symbol += m_MidCoder[posState].Decode(rangeDecoder);
				else
				{
					symbol += Base.kNumMidLenSymbols;
					symbol += m_HighCoder.Decode(rangeDecoder);
				}
				return symbol;
			}
		}
	}

	class LiteralDecoder
	{
		struct Decoder2
		{
			BitDecoder[] m_Decoders;
			public void Create() { m_Decoders = new BitDecoder[0x300]; }
			public void Init() { for (int i = 0; i < 0x300; i++) m_Decoders[i].Init(); }

			public byte DecodeNormal(RangeCoder.Decoder rangeDecoder)
			{
				uint symbol = 1;
				do
					symbol = (symbol << 1) | m_Decoders[symbol].Decode(rangeDecoder);
				while (symbol < 0x100);
				return (byte)symbol;
			}

			public byte DecodeWithMatchByte(RangeCoder.Decoder rangeDecoder, byte matchByte)
			{
				uint symbol = 1;
				do
				{
					uint matchBit = (uint)(matchByte >> 7) & 1;
					matchByte <<= 1;
					uint bit = m_Decoders[((1 + matchBit) << 8) + symbol].Decode(rangeDecoder);
					symbol = (symbol << 1) | bit;
					if (matchBit != bit)
					{
						while (symbol < 0x100)
							symbol = (symbol << 1) | m_Decoders[symbol].Decode(rangeDecoder);
						break;
					}
				}
				while (symbol < 0x100);
				return (byte)symbol;
			}
		}

		Decoder2[] m_Coders;
		int m_NumPrevBits;
		int m_NumPosBits;
		uint 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 = ((uint)1 << numPosBits) - 1;
			m_NumPrevBits = numPrevBits;
			uint numStates = (uint)1 << (m_NumPrevBits + m_NumPosBits);
			m_Coders = new Decoder2[numStates];
			for (uint i = 0; i < numStates; i++)
				m_Coders[i].Create();
		}

		public void Init()
		{
			uint numStates = (uint)1 << (m_NumPrevBits + m_NumPosBits);
			for (uint i = 0; i < numStates; i++)
				m_Coders[i].Init();
		}

		uint GetState(uint pos, byte prevByte)
		{ return ((pos & m_PosMask) << m_NumPrevBits) + (uint)(prevByte >> (8 - m_NumPrevBits)); }

		public byte DecodeNormal(RangeCoder.Decoder rangeDecoder, uint pos, byte prevByte)
		{ return m_Coders[GetState(pos, prevByte)].DecodeNormal(rangeDecoder); }

		public byte DecodeWithMatchByte(RangeCoder.Decoder rangeDecoder, uint pos, byte prevByte, byte matchByte)
		{ return m_Coders[GetState(pos, prevByte)].DecodeWithMatchByte(rangeDecoder, matchByte); }
	};

	LZ.OutWindow m_OutWindow = new LZ.OutWindow();
	RangeCoder.Decoder m_RangeDecoder = new RangeCoder.Decoder();

	BitDecoder[] m_IsMatchDecoders = new BitDecoder[Base.kNumStates << Base.kNumPosStatesBitsMax];
	BitDecoder[] m_IsRepDecoders = new BitDecoder[Base.kNumStates];
	BitDecoder[] m_IsRepG0Decoders = new BitDecoder[Base.kNumStates];
	BitDecoder[] m_IsRepG1Decoders = new BitDecoder[Base.kNumStates];
	BitDecoder[] m_IsRepG2Decoders = new BitDecoder[Base.kNumStates];
	BitDecoder[] m_IsRep0LongDecoders = new BitDecoder[Base.kNumStates << Base.kNumPosStatesBitsMax];

	BitTreeDecoder[] m_PosSlotDecoder = new BitTreeDecoder[Base.kNumLenToPosStates];
	BitDecoder[] m_PosDecoders = new BitDecoder[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();

	uint m_DictionarySize;
	uint m_DictionarySizeCheck;

	uint m_PosStateMask;

	public Decoder()
	{
		m_DictionarySize = 0xFFFFFFFF;
		for (int i = 0; i < Base.kNumLenToPosStates; i++)
			m_PosSlotDecoder[i] = new BitTreeDecoder(Base.kNumPosSlotBits);
	}

	void SetDictionarySize(uint dictionarySize)
	{
		if (m_DictionarySize != dictionarySize)
		{
			m_DictionarySize = dictionarySize;
			m_DictionarySizeCheck = Math.Max(m_DictionarySize, 1);
			uint blockSize = Math.Max(m_DictionarySizeCheck, (1 << 12));
			m_OutWindow.Create(blockSize);
		}
	}

	void SetLiteralProperties(int lp, int lc)
	{
		if (lp > 8)
			throw new InvalidParamException();
		if (lc > 8)
			throw new InvalidParamException();
		m_LiteralDecoder.Create(lp, lc);
	}

	void SetPosBitsProperties(int pb)
	{
		if (pb > Base.kNumPosStatesBitsMax)
			throw new InvalidParamException();
		uint numPosStates = (uint)1 << pb;
		m_LenDecoder.Create(numPosStates);
		m_RepLenDecoder.Create(numPosStates);
		m_PosStateMask = numPosStates - 1;
	}

	bool _solid = false;
	void Init(System.IO.Stream inStream, System.IO.Stream outStream)
	{
		m_RangeDecoder.Init(inStream);
		m_OutWindow.Init(outStream, _solid);

		uint i;
		for (i = 0; i < Base.kNumStates; i++)
		{
			for (uint j = 0; j <= m_PosStateMask; j++)
			{
				uint index = (i << Base.kNumPosStatesBitsMax) + j;
				m_IsMatchDecoders[index].Init();
				m_IsRep0LongDecoders[index].Init();
			}
			m_IsRepDecoders[i].Init();
			m_IsRepG0Decoders[i].Init();
			m_IsRepG1Decoders[i].Init();
			m_IsRepG2Decoders[i].Init();
		}

		m_LiteralDecoder.Init();
		for (i = 0; i < Base.kNumLenToPosStates; i++)
			m_PosSlotDecoder[i].Init();
		// m_PosSpecDecoder.Init();
		for (i = 0; i < Base.kNumFullDistances - Base.kEndPosModelIndex; i++)
			m_PosDecoders[i].Init();

		m_LenDecoder.Init();
		m_RepLenDecoder.Init();
		m_PosAlignDecoder.Init();
	}

	public void Code(System.IO.Stream inStream, System.IO.Stream outStream,
		Int64 inSize, Int64 outSize, ICodeProgress progress)
	{
		Init(inStream, outStream);

		Base.State state = new Base.State();
		state.Init();
		uint rep0 = 0, rep1 = 0, rep2 = 0, rep3 = 0;

		UInt64 nowPos64 = 0;
		UInt64 outSize64 = (UInt64)outSize;
		if (nowPos64 < outSize64)
		{
			if (m_IsMatchDecoders[state.Index << Base.kNumPosStatesBitsMax].Decode(m_RangeDecoder) != 0)
				throw new DataErrorException();
			state.UpdateChar();
			byte b = m_LiteralDecoder.DecodeNormal(m_RangeDecoder, 0, 0);
			m_OutWindow.PutByte(b);
			nowPos64++;
		}
		while (nowPos64 < outSize64)
		{
			// UInt64 next = Math.Min(nowPos64 + (1 << 18), outSize64);
				// while(nowPos64 < next)
			{
				uint posState = (uint)nowPos64 & m_PosStateMask;
				if (m_IsMatchDecoders[(state.Index << Base.kNumPosStatesBitsMax) + posState].Decode(m_RangeDecoder) == 0)
				{
					byte b;
					byte prevByte = m_OutWindow.GetByte(0);
					if (!state.IsCharState())
						b = m_LiteralDecoder.DecodeWithMatchByte(m_RangeDecoder,
							(uint)nowPos64, prevByte, m_OutWindow.GetByte(rep0));
					else
						b = m_LiteralDecoder.DecodeNormal(m_RangeDecoder, (uint)nowPos64, prevByte);
					m_OutWindow.PutByte(b);
					state.UpdateChar();
					nowPos64++;
				}
				else
				{
					uint len;
					if (m_IsRepDecoders[state.Index].Decode(m_RangeDecoder) == 1)
					{
						if (m_IsRepG0Decoders[state.Index].Decode(m_RangeDecoder) == 0)
						{
							if (m_IsRep0LongDecoders[(state.Index << Base.kNumPosStatesBitsMax) + posState].Decode(m_RangeDecoder) == 0)
							{
								state.UpdateShortRep();
								m_OutWindow.PutByte(m_OutWindow.GetByte(rep0));
								nowPos64++;
								continue;
							}
						}
						else
						{
							UInt32 distance;
							if (m_IsRepG1Decoders[state.Index].Decode(m_RangeDecoder) == 0)
							{
								distance = rep1;
							}
							else
							{
								if (m_IsRepG2Decoders[state.Index].Decode(m_RangeDecoder) == 0)
									distance = rep2;
								else
								{
									distance = rep3;
									rep3 = rep2;
								}
								rep2 = rep1;
							}
							rep1 = rep0;
							rep0 = distance;
						}
						len = m_RepLenDecoder.Decode(m_RangeDecoder, posState) + Base.kMatchMinLen;
						state.UpdateRep();
					}
					else
					{
						rep3 = rep2;
						rep2 = rep1;
						rep1 = rep0;
						len = Base.kMatchMinLen + m_LenDecoder.Decode(m_RangeDecoder, posState);
						state.UpdateMatch();
						uint posSlot = m_PosSlotDecoder[Base.GetLenToPosState(len)].Decode(m_RangeDecoder);
						if (posSlot >= Base.kStartPosModelIndex)
						{
							int numDirectBits = (int)((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);
							}
						}
						else
							rep0 = posSlot;
					}
					if (rep0 >= m_OutWindow.TrainSize + nowPos64 || rep0 >= m_DictionarySizeCheck)
					{
						if (rep0 == 0xFFFFFFFF)
							break;
						throw new DataErrorException();
					}
					m_OutWindow.CopyBlock(rep0, len);
					nowPos64 += len;
				}
			}
		}
		m_OutWindow.Flush();
		m_OutWindow.ReleaseStream();
		m_RangeDecoder.ReleaseStream();
	}

	public void SetDecoderProperties(byte[] properties)
	{
		if (properties.Length < 5)
			throw new InvalidParamException();
		int lc = properties[0] % 9;
		int remainder = properties[0] / 9;
		int lp = remainder % 5;
		int pb = remainder / 5;
		if (pb > Base.kNumPosStatesBitsMax)
			throw new InvalidParamException();
		UInt32 dictionarySize = 0;
		for (int i = 0; i < 4; i++)
			dictionarySize += ((UInt32)(properties[1 + i])) << (i * 8);
		SetDictionarySize(dictionarySize);
		SetLiteralProperties(lp, lc);
		SetPosBitsProperties(pb);
	}

	public bool Train(System.IO.Stream stream)
	{
		_solid = true;
		return m_OutWindow.Train(stream);
	}

	/*
	public override bool CanRead { get { return true; }}
	public override bool CanWrite { get { return true; }}
	public override bool CanSeek { get { return true; }}
	public override long Length { get { return 0; }}
	public override long Position
	{
		get { return 0;	}
		set { }
	}
	public override void Flush() { }
	public override int Read(byte[] buffer, int offset, int count) 
	{
		return 0;
	}
	public override void Write(byte[] buffer, int offset, int count)
	{
	}
	public override long Seek(long offset, System.IO.SeekOrigin origin)
	{
		return 0;
	}
	public override void SetLength(long value) {}
	*/
}
}