org.glassfish.grizzly.compression.lzma.impl.Decoder Maven / Gradle / Ivy
The newest version!
/*
* Copyright (c) 2011, 2020 Oracle and/or its affiliates. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v. 2.0, which is available at
* http://www.eclipse.org/legal/epl-2.0.
*
* This Source Code may also be made available under the following Secondary
* Licenses when the conditions for such availability set forth in the
* Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
* version 2 with the GNU Classpath Exception, which is available at
* https://www.gnu.org/software/classpath/license.html.
*
* SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
*/
package org.glassfish.grizzly.compression.lzma.impl;
import java.io.IOException;
import org.glassfish.grizzly.Buffer;
import org.glassfish.grizzly.compression.lzma.LZMADecoder;
import org.glassfish.grizzly.compression.lzma.LZMADecoder.LZMAInputState;
import org.glassfish.grizzly.compression.lzma.impl.lz.OutWindow;
import org.glassfish.grizzly.compression.lzma.impl.rangecoder.BitTreeDecoder;
import org.glassfish.grizzly.compression.lzma.impl.rangecoder.RangeDecoder;
/**
* RangeDecoder
*
* @author Igor Pavlov
*/
public class Decoder {
public enum State {
ERR, NEED_MORE_DATA, DONE, CONTINUE // internal only
}
static class LenDecoder {
final short[] m_Choice = new short[2];
final BitTreeDecoder[] m_LowCoder = new BitTreeDecoder[Base.kNumPosStatesMax];
final BitTreeDecoder[] m_MidCoder = new BitTreeDecoder[Base.kNumPosStatesMax];
final 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() {
decodeMethodState = 0;
RangeDecoder.initBitModels(m_Choice);
for (int posState = 0; posState < m_NumPosStates; posState++) {
m_LowCoder[posState].init();
m_MidCoder[posState].init();
}
m_HighCoder.init();
}
private int decodeMethodState;
public boolean decode(LZMADecoder.LZMAInputState decoderState, RangeDecoder rangeDecoder, int posState) throws IOException {
do {
switch (decodeMethodState) {
case 0: {
if (!rangeDecoder.decodeBit(decoderState, m_Choice, 0)) {
return false;
}
decodeMethodState = decoderState.lastMethodResult == 0 ? 1 : 2;
continue;
}
case 1: {
if (!m_LowCoder[posState].decode(decoderState, rangeDecoder)) {
return false;
}
// using last result from m_LowCoder[posState].decode(...)
decodeMethodState = 5;
continue;
}
case 2: {
if (!rangeDecoder.decodeBit(decoderState, m_Choice, 1)) {
return false;
}
decodeMethodState = decoderState.lastMethodResult == 0 ? 3 : 4;
continue;
}
case 3: {
if (!m_MidCoder[posState].decode(decoderState, rangeDecoder)) {
return false;
}
decoderState.lastMethodResult += Base.kNumLowLenSymbols;
decodeMethodState = 5;
continue;
}
case 4: {
if (!m_HighCoder.decode(decoderState, rangeDecoder)) {
return false;
}
decoderState.lastMethodResult += Base.kNumLowLenSymbols + Base.kNumMidLenSymbols;
decodeMethodState = 5;
continue;
}
case 5: {
decodeMethodState = 0;
return true;
}
}
} while (true);
}
}
public static class LiteralDecoder {
public static class Decoder2 {
final short[] m_Decoders = new short[0x300];
int decodeNormalMethodState;
int decodeWithMatchByteMethodState;
int symbol;
int matchBit;
byte matchByte;
public void init() {
decodeNormalMethodState = 0;
decodeWithMatchByteMethodState = 0;
RangeDecoder.initBitModels(m_Decoders);
}
public boolean decodeNormal(LZMADecoder.LZMAInputState decoderState, RangeDecoder rangeDecoder) throws IOException {
do {
switch (decodeNormalMethodState) {
case 0: {
symbol = 1;
decodeNormalMethodState = 1;
}
case 1: {
if (!rangeDecoder.decodeBit(decoderState, m_Decoders, symbol)) {
return false;
}
symbol = symbol << 1 | decoderState.lastMethodResult;
if (symbol >= 0x100) {
decodeNormalMethodState = 0;
decoderState.lastMethodResult = symbol;
return true;
}
}
}
} while (true);
}
public boolean decodeWithMatchByte(LZMADecoder.LZMAInputState decoderState, RangeDecoder rangeDecoder, byte matchByteParam) throws IOException {
do {
switch (decodeWithMatchByteMethodState) {
case 0: {
symbol = 1;
this.matchByte = matchByteParam;
// decodeWithMatchByteMethodState = 1;
}
case 1: {
matchBit = matchByte >> 7 & 1;
matchByte <<= 1;
decodeWithMatchByteMethodState = 2;
}
case 2: {
if (!rangeDecoder.decodeBit(decoderState, m_Decoders, (1 + matchBit << 8) + symbol)) {
return false;
}
final int bit = decoderState.lastMethodResult;
symbol = symbol << 1 | bit;
if (matchBit == bit) {
if (symbol >= 0x100) { // outter while(symbol < 0x100)
decodeWithMatchByteMethodState = 4; // break
continue;
}
// loop
decodeWithMatchByteMethodState = 1;
continue;
}
decodeWithMatchByteMethodState = 3;
}
case 3: {
if (symbol >= 0x100) { // inner while(symbol < 0x100)
decodeWithMatchByteMethodState = 4; // break
continue;
}
if (!rangeDecoder.decodeBit(decoderState, m_Decoders, symbol)) {
return false;
}
symbol = symbol << 1 | decoderState.lastMethodResult;
continue;
}
case 4: {
decodeWithMatchByteMethodState = 0;
decoderState.lastMethodResult = symbol;
return true;
}
}
} while (true);
}
}
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)];
}
}
final OutWindow m_OutWindow = new OutWindow();
final RangeDecoder m_RangeDecoder = new RangeDecoder();
final short[] m_IsMatchDecoders = new short[Base.kNumStates << Base.kNumPosStatesBitsMax];
final short[] m_IsRepDecoders = new short[Base.kNumStates];
final short[] m_IsRepG0Decoders = new short[Base.kNumStates];
final short[] m_IsRepG1Decoders = new short[Base.kNumStates];
final short[] m_IsRepG2Decoders = new short[Base.kNumStates];
final short[] m_IsRep0LongDecoders = new short[Base.kNumStates << Base.kNumPosStatesBitsMax];
final BitTreeDecoder[] m_PosSlotDecoder = new BitTreeDecoder[Base.kNumLenToPosStates];
final short[] m_PosDecoders = new short[Base.kNumFullDistances - Base.kEndPosModelIndex];
final BitTreeDecoder m_PosAlignDecoder = new BitTreeDecoder(Base.kNumAlignBits);
final LenDecoder m_LenDecoder = new LenDecoder();
final LenDecoder m_RepLenDecoder = new LenDecoder();
final 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);
}
}
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 += (properties[1 + i] & 0xFF) << i * 8;
}
return setLcLpPb(lc, lp, pb) && setDictionarySize(dictionarySize);
}
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);
RangeDecoder.initBitModels(m_IsMatchDecoders);
RangeDecoder.initBitModels(m_IsRep0LongDecoders);
RangeDecoder.initBitModels(m_IsRepDecoders);
RangeDecoder.initBitModels(m_IsRepG0Decoders);
RangeDecoder.initBitModels(m_IsRepG1Decoders);
RangeDecoder.initBitModels(m_IsRepG2Decoders);
RangeDecoder.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 State code(LZMADecoder.LZMAInputState decoderState, long outSize) throws IOException {
// Init();
final Buffer inputBuffer = decoderState.getSrc();
m_RangeDecoder.initFromState(decoderState);
m_OutWindow.initFromState(decoderState);
if (!decoderState.isInitialized()) {
if (inputBuffer.remaining() < 13) {
return State.NEED_MORE_DATA;
}
decoderState.initialize(inputBuffer);
init();
}
// final RangeDecoder m_RangeDecoder = decoderState.m_RangeDecoder;
// final OutWindow m_OutWindow = decoderState.m_OutWindow;
//
// int state = Base.StateInit();
// int rep0 = 0, rep1 = 0, rep2 = 0, rep3 = 0;
//
// long nowPos64 = 0;
// byte prevByte = 0;
_outter: while (true) {
switch (decoderState.inner1State) {
case 0: {
if (outSize >= 0 && decoderState.nowPos64 >= outSize) {
break _outter;
}
decoderState.inner1State = 1;
}
case 1: {
decoderState.posState = (int) decoderState.nowPos64 & m_PosStateMask;
if (!m_RangeDecoder.decodeBit(decoderState, m_IsMatchDecoders, (decoderState.state << Base.kNumPosStatesBitsMax) + decoderState.posState)) {
return State.NEED_MORE_DATA;
}
final int result = decoderState.lastMethodResult;
decoderState.inner1State = result == 0 ? 2 : 3;
break;
}
case 2: {
if (!processState2(decoderState)) {
return State.NEED_MORE_DATA;
}
decoderState.inner1State = 0;
break;
}
case 3: {
final State internalState = processState3(decoderState);
if (internalState == State.NEED_MORE_DATA || internalState == State.ERR) {
return internalState;
}
decoderState.inner1State = 0;
if (internalState == State.DONE) {
break _outter;
}
}
}
}
m_OutWindow.flush();
m_OutWindow.releaseBuffer();
m_RangeDecoder.releaseBuffer();
return State.DONE;
}
private boolean processState2(final LZMADecoder.LZMAInputState decoderState) throws IOException {
do {
switch (decoderState.inner2State) {
case 0: {
decoderState.decoder2 = m_LiteralDecoder.getDecoder((int) decoderState.nowPos64, decoderState.prevByte);
decoderState.inner2State = !Base.stateIsCharState(decoderState.state) ? 1 : 2;
continue;
}
case 1: {
if (!decoderState.decoder2.decodeWithMatchByte(decoderState, m_RangeDecoder, m_OutWindow.getByte(decoderState.rep0))) {
return false;
}
decoderState.prevByte = (byte) decoderState.lastMethodResult;
decoderState.inner2State = 3;
continue;
}
case 2: {
if (!decoderState.decoder2.decodeNormal(decoderState, m_RangeDecoder)) {
return false;
}
decoderState.prevByte = (byte) decoderState.lastMethodResult;
decoderState.inner2State = 3;
}
case 3: {
// if (!decoderState.decoder2.decodeNormal(
// decoderState, m_RangeDecoder)) {
// return false;
// }
// decoderState.prevByte = (byte) decoderState.lastMethodResult;
m_OutWindow.putByte(decoderState.prevByte);
decoderState.state = Base.stateUpdateChar(decoderState.state);
decoderState.nowPos64++;
decoderState.inner2State = 0;
return true;
}
}
} while (true);
}
private State processState3(final LZMADecoder.LZMAInputState decoderState) throws IOException {
// int len;
do {
switch (decoderState.inner2State) {
case 0: {
if (!m_RangeDecoder.decodeBit(decoderState, m_IsRepDecoders, decoderState.state)) {
return State.NEED_MORE_DATA;
}
decoderState.inner2State = decoderState.lastMethodResult == 1 ? 1 : 2;
continue;
}
case 1: {
if (!processState31(decoderState)) {
return State.NEED_MORE_DATA;
}
decoderState.inner2State = 3;
continue;
}
case 2: {
final State internalResult = processState32(decoderState);
if (internalResult != State.CONTINUE) {
return internalResult;
}
decoderState.inner2State = 3;
}
case 3: {
if (decoderState.rep0 >= decoderState.nowPos64 || decoderState.rep0 >= m_DictionarySizeCheck) {
// m_OutWindow.Flush();
return State.ERR;
}
m_OutWindow.copyBlock(decoderState.rep0, decoderState.state3Len);
decoderState.nowPos64 += decoderState.state3Len;
decoderState.prevByte = m_OutWindow.getByte(0);
decoderState.inner2State = 0;
return State.CONTINUE;
}
}
} while (true);
}
private boolean processState31(final LZMAInputState decoderState) throws IOException {
do {
switch (decoderState.state31) {
case 0: {
decoderState.state3Len = 0;
if (!m_RangeDecoder.decodeBit(decoderState, m_IsRepG0Decoders, decoderState.state)) {
return false;
}
decoderState.state31 = decoderState.lastMethodResult == 0 ? 1 : 2;
continue;
}
case 1: {
if (!m_RangeDecoder.decodeBit(decoderState, m_IsRep0LongDecoders, (decoderState.state << Base.kNumPosStatesBitsMax) + decoderState.posState)) {
return false;
}
if (decoderState.lastMethodResult == 0) {
decoderState.state = Base.stateUpdateShortRep(decoderState.state);
decoderState.state3Len = 1;
}
decoderState.state31 = 3;
continue;
}
case 2: {
if (!processState311(decoderState)) {
return false;
}
decoderState.state31 = 3;
}
case 3: {
if (decoderState.state3Len != 0) {
decoderState.state31 = 0;
return true;
}
decoderState.state31 = 4;
}
case 4: {
if (!m_RepLenDecoder.decode(decoderState, m_RangeDecoder, decoderState.posState)) {
return false;
}
decoderState.state3Len = decoderState.lastMethodResult + Base.kMatchMinLen;
decoderState.state = Base.stateUpdateRep(decoderState.state);
decoderState.state31 = 0;
return true;
}
}
} while (true);
}
private boolean processState311(final LZMAInputState decoderState) throws IOException {
do {
switch (decoderState.state311) {
case 0: {
if (!m_RangeDecoder.decodeBit(decoderState, m_IsRepG1Decoders, decoderState.state)) {
return false;
}
decoderState.state311 = decoderState.lastMethodResult == 0 ? 1 : 2;
continue;
}
case 1: {
decoderState.state311Distance = decoderState.rep1;
decoderState.state311 = 3;
continue;
}
case 2: {
if (!m_RangeDecoder.decodeBit(decoderState, m_IsRepG2Decoders, decoderState.state)) {
return false;
}
if (decoderState.lastMethodResult == 0) {
decoderState.state311Distance = decoderState.rep2;
} else {
decoderState.state311Distance = decoderState.rep3;
decoderState.rep3 = decoderState.rep2;
}
decoderState.rep2 = decoderState.rep1;
}
case 3: {
decoderState.rep1 = decoderState.rep0;
decoderState.rep0 = decoderState.state311Distance;
decoderState.state311 = 0;
return true;
}
}
} while (true);
}
private State processState32(final LZMAInputState decoderState) throws IOException {
do {
switch (decoderState.state32) {
case 0: {
decoderState.rep3 = decoderState.rep2;
decoderState.rep2 = decoderState.rep1;
decoderState.rep1 = decoderState.rep0;
decoderState.state32 = 1;
}
case 1: {
if (!m_LenDecoder.decode(decoderState, m_RangeDecoder, decoderState.posState)) {
return State.NEED_MORE_DATA;
}
decoderState.state3Len = Base.kMatchMinLen + decoderState.lastMethodResult;
decoderState.state = Base.stateUpdateMatch(decoderState.state);
decoderState.state32 = 2;
}
case 2: {
if (!m_PosSlotDecoder[Base.getLenToPosState(decoderState.state3Len)].decode(decoderState, m_RangeDecoder)) {
return State.NEED_MORE_DATA;
}
decoderState.state32PosSlot = decoderState.lastMethodResult;
decoderState.state32 = decoderState.state32PosSlot >= Base.kStartPosModelIndex ? 3 : 4;
continue;
}
case 3: {
final State localState = processState321(decoderState);
if (localState == State.CONTINUE) {
decoderState.state32 = 0;
}
return localState;
}
case 4: {
decoderState.rep0 = decoderState.state32PosSlot;
decoderState.state32 = 0;
return State.CONTINUE;
}
}
} while (true);
}
private State processState321(final LZMAInputState decoderState) throws IOException {
do {
switch (decoderState.state321) {
case 0: {
decoderState.state321NumDirectBits = (decoderState.state32PosSlot >> 1) - 1;
decoderState.rep0 = (2 | decoderState.state32PosSlot & 1) << decoderState.state321NumDirectBits;
decoderState.state321 = decoderState.state32PosSlot < Base.kEndPosModelIndex ? 1 : 2;
continue;
}
case 1: {
if (!BitTreeDecoder.reverseDecode(decoderState, m_PosDecoders, decoderState.rep0 - decoderState.state32PosSlot - 1, m_RangeDecoder,
decoderState.state321NumDirectBits)) {
return State.NEED_MORE_DATA;
}
decoderState.rep0 += decoderState.lastMethodResult;
decoderState.state321 = 0;
return State.CONTINUE;
}
case 2: {
if (!m_RangeDecoder.decodeDirectBits(decoderState, decoderState.state321NumDirectBits - Base.kNumAlignBits)) {
return State.NEED_MORE_DATA;
}
decoderState.rep0 += decoderState.lastMethodResult << Base.kNumAlignBits;
decoderState.state321 = 3;
continue;
}
case 3: {
if (!m_PosAlignDecoder.reverseDecode(decoderState, m_RangeDecoder)) {
return State.NEED_MORE_DATA;
}
decoderState.rep0 += decoderState.lastMethodResult;
decoderState.state321 = 0;
if (decoderState.rep0 < 0) {
if (decoderState.rep0 == -1) {
return State.DONE;
}
return State.ERR;
}
return State.CONTINUE;
}
}
} while (true);
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy