001: package SevenZip.Compression.lzma;
002:
003: import java.io.IOException;
004:
005: import SevenZip.Compression.RangeCoder.BitTreeDecoder;
006: import SevenZip.Compression.lz.OutWindow;
007:
008: public class Decoder {
009: class LenDecoder {
010: short[] m_Choice = new short[2];
011: BitTreeDecoder[] m_LowCoder = new BitTreeDecoder[Base.kNumPosStatesMax];
012: BitTreeDecoder[] m_MidCoder = new BitTreeDecoder[Base.kNumPosStatesMax];
013: BitTreeDecoder m_HighCoder = new BitTreeDecoder(
014: Base.kNumHighLenBits);
015: int m_NumPosStates = 0;
016:
017: public void Create(int numPosStates) {
018: for (; m_NumPosStates < numPosStates; m_NumPosStates++) {
019: m_LowCoder[m_NumPosStates] = new BitTreeDecoder(
020: Base.kNumLowLenBits);
021: m_MidCoder[m_NumPosStates] = new BitTreeDecoder(
022: Base.kNumMidLenBits);
023: }
024: }
025:
026: public void Init() {
027: SevenZip.Compression.RangeCoder.Decoder
028: .InitBitModels(m_Choice);
029: for (int posState = 0; posState < m_NumPosStates; posState++) {
030: m_LowCoder[posState].Init();
031: m_MidCoder[posState].Init();
032: }
033: m_HighCoder.Init();
034: }
035:
036: public int Decode(
037: SevenZip.Compression.RangeCoder.Decoder rangeDecoder,
038: int posState) throws IOException {
039: if (rangeDecoder.DecodeBit(m_Choice, 0) == 0)
040: return m_LowCoder[posState].Decode(rangeDecoder);
041: int symbol = Base.kNumLowLenSymbols;
042: if (rangeDecoder.DecodeBit(m_Choice, 1) == 0)
043: symbol += m_MidCoder[posState].Decode(rangeDecoder);
044: else
045: symbol += Base.kNumMidLenSymbols
046: + m_HighCoder.Decode(rangeDecoder);
047: return symbol;
048: }
049: }
050:
051: class LiteralDecoder {
052: class Decoder2 {
053: short[] m_Decoders = new short[0x300];
054:
055: public void Init() {
056: SevenZip.Compression.RangeCoder.Decoder
057: .InitBitModels(m_Decoders);
058: }
059:
060: public byte DecodeNormal(
061: SevenZip.Compression.RangeCoder.Decoder rangeDecoder)
062: throws IOException {
063: int symbol = 1;
064: do
065: symbol = (symbol << 1)
066: | rangeDecoder
067: .DecodeBit(m_Decoders, symbol);
068: while (symbol < 0x100);
069: return (byte) symbol;
070: }
071:
072: public byte DecodeWithMatchByte(
073: SevenZip.Compression.RangeCoder.Decoder rangeDecoder,
074: byte matchByte) throws IOException {
075: int symbol = 1;
076: do {
077: int matchBit = (matchByte >> 7) & 1;
078: matchByte <<= 1;
079: int bit = rangeDecoder.DecodeBit(m_Decoders,
080: ((1 + matchBit) << 8) + symbol);
081: symbol = (symbol << 1) | bit;
082: if (matchBit != bit) {
083: while (symbol < 0x100)
084: symbol = (symbol << 1)
085: | rangeDecoder.DecodeBit(
086: m_Decoders, symbol);
087: break;
088: }
089: } while (symbol < 0x100);
090: return (byte) symbol;
091: }
092: }
093:
094: Decoder2[] m_Coders;
095: int m_NumPrevBits;
096: int m_NumPosBits;
097: int m_PosMask;
098:
099: public void Create(int numPosBits, int numPrevBits) {
100: if (m_Coders != null && m_NumPrevBits == numPrevBits
101: && m_NumPosBits == numPosBits)
102: return;
103: m_NumPosBits = numPosBits;
104: m_PosMask = (1 << numPosBits) - 1;
105: m_NumPrevBits = numPrevBits;
106: int numStates = 1 << (m_NumPrevBits + m_NumPosBits);
107: m_Coders = new Decoder2[numStates];
108: for (int i = 0; i < numStates; i++)
109: m_Coders[i] = new Decoder2();
110: }
111:
112: public void Init() {
113: int numStates = 1 << (m_NumPrevBits + m_NumPosBits);
114: for (int i = 0; i < numStates; i++)
115: m_Coders[i].Init();
116: }
117:
118: Decoder2 GetDecoder(int pos, byte prevByte) {
119: return m_Coders[((pos & m_PosMask) << m_NumPrevBits)
120: + ((prevByte & 0xFF) >>> (8 - m_NumPrevBits))];
121: }
122: }
123:
124: OutWindow m_OutWindow = new OutWindow();
125: SevenZip.Compression.RangeCoder.Decoder m_RangeDecoder = new SevenZip.Compression.RangeCoder.Decoder();
126:
127: short[] m_IsMatchDecoders = new short[Base.kNumStates << Base.kNumPosStatesBitsMax];
128: short[] m_IsRepDecoders = new short[Base.kNumStates];
129: short[] m_IsRepG0Decoders = new short[Base.kNumStates];
130: short[] m_IsRepG1Decoders = new short[Base.kNumStates];
131: short[] m_IsRepG2Decoders = new short[Base.kNumStates];
132: short[] m_IsRep0LongDecoders = new short[Base.kNumStates << Base.kNumPosStatesBitsMax];
133:
134: BitTreeDecoder[] m_PosSlotDecoder = new BitTreeDecoder[Base.kNumLenToPosStates];
135: short[] m_PosDecoders = new short[Base.kNumFullDistances
136: - Base.kEndPosModelIndex];
137:
138: BitTreeDecoder m_PosAlignDecoder = new BitTreeDecoder(
139: Base.kNumAlignBits);
140:
141: LenDecoder m_LenDecoder = new LenDecoder();
142: LenDecoder m_RepLenDecoder = new LenDecoder();
143:
144: LiteralDecoder m_LiteralDecoder = new LiteralDecoder();
145:
146: int m_DictionarySize = -1;
147: int m_DictionarySizeCheck = -1;
148:
149: int m_PosStateMask;
150:
151: public Decoder() {
152: for (int i = 0; i < Base.kNumLenToPosStates; i++)
153: m_PosSlotDecoder[i] = new BitTreeDecoder(
154: Base.kNumPosSlotBits);
155: }
156:
157: boolean SetDictionarySize(int dictionarySize) {
158: if (dictionarySize < 0)
159: return false;
160: if (m_DictionarySize != dictionarySize) {
161: m_DictionarySize = dictionarySize;
162: m_DictionarySizeCheck = Math.max(m_DictionarySize, 1);
163: m_OutWindow.Create(Math.max(m_DictionarySizeCheck,
164: (1 << 12)));
165: }
166: return true;
167: }
168:
169: boolean SetLcLpPb(int lc, int lp, int pb) {
170: if (lc > Base.kNumLitContextBitsMax || lp > 4
171: || pb > Base.kNumPosStatesBitsMax)
172: return false;
173: m_LiteralDecoder.Create(lp, lc);
174: int numPosStates = 1 << pb;
175: m_LenDecoder.Create(numPosStates);
176: m_RepLenDecoder.Create(numPosStates);
177: m_PosStateMask = numPosStates - 1;
178: return true;
179: }
180:
181: void Init() throws IOException {
182: m_OutWindow.Init(false);
183:
184: SevenZip.Compression.RangeCoder.Decoder
185: .InitBitModels(m_IsMatchDecoders);
186: SevenZip.Compression.RangeCoder.Decoder
187: .InitBitModels(m_IsRep0LongDecoders);
188: SevenZip.Compression.RangeCoder.Decoder
189: .InitBitModels(m_IsRepDecoders);
190: SevenZip.Compression.RangeCoder.Decoder
191: .InitBitModels(m_IsRepG0Decoders);
192: SevenZip.Compression.RangeCoder.Decoder
193: .InitBitModels(m_IsRepG1Decoders);
194: SevenZip.Compression.RangeCoder.Decoder
195: .InitBitModels(m_IsRepG2Decoders);
196: SevenZip.Compression.RangeCoder.Decoder
197: .InitBitModels(m_PosDecoders);
198:
199: m_LiteralDecoder.Init();
200: int i;
201: for (i = 0; i < Base.kNumLenToPosStates; i++)
202: m_PosSlotDecoder[i].Init();
203: m_LenDecoder.Init();
204: m_RepLenDecoder.Init();
205: m_PosAlignDecoder.Init();
206: m_RangeDecoder.Init();
207: }
208:
209: public boolean Code(java.io.InputStream inStream,
210: java.io.OutputStream outStream, long outSize)
211: throws IOException {
212: m_RangeDecoder.SetStream(inStream);
213: m_OutWindow.SetStream(outStream);
214: Init();
215:
216: int state = Base.StateInit();
217: int rep0 = 0, rep1 = 0, rep2 = 0, rep3 = 0;
218:
219: long nowPos64 = 0;
220: byte prevByte = 0;
221: while (outSize < 0 || nowPos64 < outSize) {
222: int posState = (int) nowPos64 & m_PosStateMask;
223: if (m_RangeDecoder.DecodeBit(m_IsMatchDecoders,
224: (state << Base.kNumPosStatesBitsMax) + posState) == 0) {
225: LiteralDecoder.Decoder2 decoder2 = m_LiteralDecoder
226: .GetDecoder((int) nowPos64, prevByte);
227: if (!Base.StateIsCharState(state))
228: prevByte = decoder2.DecodeWithMatchByte(
229: m_RangeDecoder, m_OutWindow.GetByte(rep0));
230: else
231: prevByte = decoder2.DecodeNormal(m_RangeDecoder);
232: m_OutWindow.PutByte(prevByte);
233: state = Base.StateUpdateChar(state);
234: nowPos64++;
235: } else {
236: int len;
237: if (m_RangeDecoder.DecodeBit(m_IsRepDecoders, state) == 1) {
238: len = 0;
239: if (m_RangeDecoder.DecodeBit(m_IsRepG0Decoders,
240: state) == 0) {
241: if (m_RangeDecoder.DecodeBit(
242: m_IsRep0LongDecoders,
243: (state << Base.kNumPosStatesBitsMax)
244: + posState) == 0) {
245: state = Base.StateUpdateShortRep(state);
246: len = 1;
247: }
248: } else {
249: int distance;
250: if (m_RangeDecoder.DecodeBit(m_IsRepG1Decoders,
251: state) == 0)
252: distance = rep1;
253: else {
254: if (m_RangeDecoder.DecodeBit(
255: m_IsRepG2Decoders, state) == 0)
256: distance = rep2;
257: else {
258: distance = rep3;
259: rep3 = rep2;
260: }
261: rep2 = rep1;
262: }
263: rep1 = rep0;
264: rep0 = distance;
265: }
266: if (len == 0) {
267: len = m_RepLenDecoder.Decode(m_RangeDecoder,
268: posState)
269: + Base.kMatchMinLen;
270: state = Base.StateUpdateRep(state);
271: }
272: } else {
273: rep3 = rep2;
274: rep2 = rep1;
275: rep1 = rep0;
276: len = Base.kMatchMinLen
277: + m_LenDecoder.Decode(m_RangeDecoder,
278: posState);
279: state = Base.StateUpdateMatch(state);
280: int posSlot = m_PosSlotDecoder[Base
281: .GetLenToPosState(len)]
282: .Decode(m_RangeDecoder);
283: if (posSlot >= Base.kStartPosModelIndex) {
284: int numDirectBits = (posSlot >> 1) - 1;
285: rep0 = ((2 | (posSlot & 1)) << numDirectBits);
286: if (posSlot < Base.kEndPosModelIndex)
287: rep0 += BitTreeDecoder.ReverseDecode(
288: m_PosDecoders, rep0 - posSlot - 1,
289: m_RangeDecoder, numDirectBits);
290: else {
291: rep0 += (m_RangeDecoder
292: .DecodeDirectBits(numDirectBits
293: - Base.kNumAlignBits) << Base.kNumAlignBits);
294: rep0 += m_PosAlignDecoder
295: .ReverseDecode(m_RangeDecoder);
296: if (rep0 < 0) {
297: if (rep0 == -1)
298: break;
299: return false;
300: }
301: }
302: } else
303: rep0 = posSlot;
304: }
305: if (rep0 >= nowPos64 || rep0 >= m_DictionarySizeCheck) {
306: // m_OutWindow.Flush();
307: return false;
308: }
309: m_OutWindow.CopyBlock(rep0, len);
310: nowPos64 += len;
311: prevByte = m_OutWindow.GetByte(0);
312: }
313: }
314: m_OutWindow.Flush();
315: m_OutWindow.ReleaseStream();
316: m_RangeDecoder.ReleaseStream();
317: return true;
318: }
319:
320: public boolean SetDecoderProperties(byte[] properties) {
321: if (properties.length < 5)
322: return false;
323: int val = properties[0] & 0xFF;
324: int lc = val % 9;
325: int remainder = val / 9;
326: int lp = remainder % 5;
327: int pb = remainder / 5;
328: int dictionarySize = 0;
329: for (int i = 0; i < 4; i++)
330: dictionarySize += ((properties[1 + i]) & 0xFF) << (i * 8);
331: if (!SetLcLpPb(lc, lp, pb))
332: return false;
333: return SetDictionarySize(dictionarySize);
334: }
335: }
|