aaru-dps/Aaru.Compression.Native
1
0
Fork 0
mirror of https://github.com/aaru-dps/Aaru.Compression.Native.git synced 2025-12-16 19:24:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

Move placement of lzma.

Browse Source
This commit is contained in:
Natalia Portillo
2023-09-24 02:41:01 +01:00
parent fb79a7ddf6
commit 7cc2d1c72e
687 changed files with 2 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
3rdparty/lzma/Java/SevenZip/CRC.java vendored Normal file
View File

@@ -0,0 +1,52 @@
// SevenZip/CRC.java
package SevenZip;
public class CRC
{
static public int[] Table = new int[256];
static
{
for (int i = 0; i < 256; i++)
{
int r = i;
for (int j = 0; j < 8; j++)
if ((r & 1) != 0)
r = (r >>> 1) ^ 0xEDB88320;
else
r >>>= 1;
Table[i] = r;
}
}
int _value = -1;
public void Init()
{
_value = -1;
}
public void Update(byte[] data, int offset, int size)
{
for (int i = 0; i < size; i++)
_value = Table[(_value ^ data[offset + i]) & 0xFF] ^ (_value >>> 8);
}
public void Update(byte[] data)
{
int size = data.length;
for (int i = 0; i < size; i++)
_value = Table[(_value ^ data[i]) & 0xFF] ^ (_value >>> 8);
}
public void UpdateByte(int b)
{
_value = Table[(_value ^ b) & 0xFF] ^ (_value >>> 8);
}
public int GetDigest()
{
return _value ^ (-1);
}
}

382
3rdparty/lzma/Java/SevenZip/Compression/LZ/BinTree.java vendored Normal file
View File

@@ -0,0 +1,382 @@
// LZ.BinTree
package SevenZip.Compression.LZ;
import java.io.IOException;
public class BinTree extends InWindow
{
int _cyclicBufferPos;
int _cyclicBufferSize = 0;
int _matchMaxLen;
int[] _son;
int[] _hash;
int _cutValue = 0xFF;
int _hashMask;
int _hashSizeSum = 0;
boolean HASH_ARRAY = true;
static final int kHash2Size = 1 << 10;
static final int kHash3Size = 1 << 16;
static final int kBT2HashSize = 1 << 16;
static final int kStartMaxLen = 1;
static final int kHash3Offset = kHash2Size;
static final int kEmptyHashValue = 0;
static final int kMaxValForNormalize = (1 << 30) - 1;
int kNumHashDirectBytes = 0;
int kMinMatchCheck = 4;
int kFixHashSize = kHash2Size + kHash3Size;
public void SetType(int numHashBytes)
{
HASH_ARRAY = (numHashBytes > 2);
if (HASH_ARRAY)
{
kNumHashDirectBytes = 0;
kMinMatchCheck = 4;
kFixHashSize = kHash2Size + kHash3Size;
}
else
{
kNumHashDirectBytes = 2;
kMinMatchCheck = 2 + 1;
kFixHashSize = 0;
}
}
public void Init() throws IOException
{
super.Init();
for (int i = 0; i < _hashSizeSum; i++)
_hash[i] = kEmptyHashValue;
_cyclicBufferPos = 0;
ReduceOffsets(-1);
}
public void MovePos() throws IOException
{
if (++_cyclicBufferPos >= _cyclicBufferSize)
_cyclicBufferPos = 0;
super.MovePos();
if (_pos == kMaxValForNormalize)
Normalize();
}
public boolean Create(int historySize, int keepAddBufferBefore,
int matchMaxLen, int keepAddBufferAfter)
{
if (historySize > kMaxValForNormalize - 256)
return false;
_cutValue = 16 + (matchMaxLen >> 1);
int windowReservSize = (historySize + keepAddBufferBefore +
matchMaxLen + keepAddBufferAfter) / 2 + 256;
super.Create(historySize + keepAddBufferBefore, matchMaxLen + keepAddBufferAfter, windowReservSize);
_matchMaxLen = matchMaxLen;
int cyclicBufferSize = historySize + 1;
if (_cyclicBufferSize != cyclicBufferSize)
_son = new int[(_cyclicBufferSize = cyclicBufferSize) * 2];
int hs = kBT2HashSize;
if (HASH_ARRAY)
{
hs = historySize - 1;
hs |= (hs >> 1);
hs |= (hs >> 2);
hs |= (hs >> 4);
hs |= (hs >> 8);
hs >>= 1;
hs |= 0xFFFF;
if (hs > (1 << 24))
hs >>= 1;
_hashMask = hs;
hs++;
hs += kFixHashSize;
}
if (hs != _hashSizeSum)
_hash = new int [_hashSizeSum = hs];
return true;
}
public int GetMatches(int[] distances) throws IOException
{
int lenLimit;
if (_pos + _matchMaxLen <= _streamPos)
lenLimit = _matchMaxLen;
else
{
lenLimit = _streamPos - _pos;
if (lenLimit < kMinMatchCheck)
{
MovePos();
return 0;
}
}
int offset = 0;
int matchMinPos = (_pos > _cyclicBufferSize) ? (_pos - _cyclicBufferSize) : 0;
int cur = _bufferOffset + _pos;
int maxLen = kStartMaxLen; // to avoid items for len < hashSize;
int hashValue, hash2Value = 0, hash3Value = 0;
if (HASH_ARRAY)
{
int temp = CrcTable[_bufferBase[cur] & 0xFF] ^ (_bufferBase[cur + 1] & 0xFF);
hash2Value = temp & (kHash2Size - 1);
temp ^= ((int)(_bufferBase[cur + 2] & 0xFF) << 8);
hash3Value = temp & (kHash3Size - 1);
hashValue = (temp ^ (CrcTable[_bufferBase[cur + 3] & 0xFF] << 5)) & _hashMask;
}
else
hashValue = ((_bufferBase[cur] & 0xFF) ^ ((int)(_bufferBase[cur + 1] & 0xFF) << 8));
int curMatch = _hash[kFixHashSize + hashValue];
if (HASH_ARRAY)
{
int curMatch2 = _hash[hash2Value];
int curMatch3 = _hash[kHash3Offset + hash3Value];
_hash[hash2Value] = _pos;
_hash[kHash3Offset + hash3Value] = _pos;
if (curMatch2 > matchMinPos)
if (_bufferBase[_bufferOffset + curMatch2] == _bufferBase[cur])
{
distances[offset++] = maxLen = 2;
distances[offset++] = _pos - curMatch2 - 1;
}
if (curMatch3 > matchMinPos)
if (_bufferBase[_bufferOffset + curMatch3] == _bufferBase[cur])
{
if (curMatch3 == curMatch2)
offset -= 2;
distances[offset++] = maxLen = 3;
distances[offset++] = _pos - curMatch3 - 1;
curMatch2 = curMatch3;
}
if (offset != 0 && curMatch2 == curMatch)
{
offset -= 2;
maxLen = kStartMaxLen;
}
}
_hash[kFixHashSize + hashValue] = _pos;
int ptr0 = (_cyclicBufferPos << 1) + 1;
int ptr1 = (_cyclicBufferPos << 1);
int len0, len1;
len0 = len1 = kNumHashDirectBytes;
if (kNumHashDirectBytes != 0)
{
if (curMatch > matchMinPos)
{
if (_bufferBase[_bufferOffset + curMatch + kNumHashDirectBytes] !=
_bufferBase[cur + kNumHashDirectBytes])
{
distances[offset++] = maxLen = kNumHashDirectBytes;
distances[offset++] = _pos - curMatch - 1;
}
}
}
int count = _cutValue;
while (true)
{
if (curMatch <= matchMinPos || count-- == 0)
{
_son[ptr0] = _son[ptr1] = kEmptyHashValue;
break;
}
int delta = _pos - curMatch;
int cyclicPos = ((delta <= _cyclicBufferPos) ?
(_cyclicBufferPos - delta) :
(_cyclicBufferPos - delta + _cyclicBufferSize)) << 1;
int pby1 = _bufferOffset + curMatch;
int len = Math.min(len0, len1);
if (_bufferBase[pby1 + len] == _bufferBase[cur + len])
{
while(++len != lenLimit)
if (_bufferBase[pby1 + len] != _bufferBase[cur + len])
break;
if (maxLen < len)
{
distances[offset++] = maxLen = len;
distances[offset++] = delta - 1;
if (len == lenLimit)
{
_son[ptr1] = _son[cyclicPos];
_son[ptr0] = _son[cyclicPos + 1];
break;
}
}
}
if ((_bufferBase[pby1 + len] & 0xFF) < (_bufferBase[cur + len] & 0xFF))
{
_son[ptr1] = curMatch;
ptr1 = cyclicPos + 1;
curMatch = _son[ptr1];
len1 = len;
}
else
{
_son[ptr0] = curMatch;
ptr0 = cyclicPos;
curMatch = _son[ptr0];
len0 = len;
}
}
MovePos();
return offset;
}
public void Skip(int num) throws IOException
{
do
{
int lenLimit;
if (_pos + _matchMaxLen <= _streamPos)
lenLimit = _matchMaxLen;
else
{
lenLimit = _streamPos - _pos;
if (lenLimit < kMinMatchCheck)
{
MovePos();
continue;
}
}
int matchMinPos = (_pos > _cyclicBufferSize) ? (_pos - _cyclicBufferSize) : 0;
int cur = _bufferOffset + _pos;
int hashValue;
if (HASH_ARRAY)
{
int temp = CrcTable[_bufferBase[cur] & 0xFF] ^ (_bufferBase[cur + 1] & 0xFF);
int hash2Value = temp & (kHash2Size - 1);
_hash[hash2Value] = _pos;
temp ^= ((int)(_bufferBase[cur + 2] & 0xFF) << 8);
int hash3Value = temp & (kHash3Size - 1);
_hash[kHash3Offset + hash3Value] = _pos;
hashValue = (temp ^ (CrcTable[_bufferBase[cur + 3] & 0xFF] << 5)) & _hashMask;
}
else
hashValue = ((_bufferBase[cur] & 0xFF) ^ ((int)(_bufferBase[cur + 1] & 0xFF) << 8));
int curMatch = _hash[kFixHashSize + hashValue];
_hash[kFixHashSize + hashValue] = _pos;
int ptr0 = (_cyclicBufferPos << 1) + 1;
int ptr1 = (_cyclicBufferPos << 1);
int len0, len1;
len0 = len1 = kNumHashDirectBytes;
int count = _cutValue;
while (true)
{
if (curMatch <= matchMinPos || count-- == 0)
{
_son[ptr0] = _son[ptr1] = kEmptyHashValue;
break;
}
int delta = _pos - curMatch;
int cyclicPos = ((delta <= _cyclicBufferPos) ?
(_cyclicBufferPos - delta) :
(_cyclicBufferPos - delta + _cyclicBufferSize)) << 1;
int pby1 = _bufferOffset + curMatch;
int len = Math.min(len0, len1);
if (_bufferBase[pby1 + len] == _bufferBase[cur + len])
{
while (++len != lenLimit)
if (_bufferBase[pby1 + len] != _bufferBase[cur + len])
break;
if (len == lenLimit)
{
_son[ptr1] = _son[cyclicPos];
_son[ptr0] = _son[cyclicPos + 1];
break;
}
}
if ((_bufferBase[pby1 + len] & 0xFF) < (_bufferBase[cur + len] & 0xFF))
{
_son[ptr1] = curMatch;
ptr1 = cyclicPos + 1;
curMatch = _son[ptr1];
len1 = len;
}
else
{
_son[ptr0] = curMatch;
ptr0 = cyclicPos;
curMatch = _son[ptr0];
len0 = len;
}
}
MovePos();
}
while (--num != 0);
}
void NormalizeLinks(int[] items, int numItems, int subValue)
{
for (int i = 0; i < numItems; i++)
{
int value = items[i];
if (value <= subValue)
value = kEmptyHashValue;
else
value -= subValue;
items[i] = value;
}
}
void Normalize()
{
int subValue = _pos - _cyclicBufferSize;
NormalizeLinks(_son, _cyclicBufferSize * 2, subValue);
NormalizeLinks(_hash, _hashSizeSum, subValue);
ReduceOffsets(subValue);
}
public void SetCutValue(int cutValue) { _cutValue = cutValue; }
private static final int[] CrcTable = new int[256];
static
{
for (int i = 0; i < 256; i++)
{
int r = i;
for (int j = 0; j < 8; j++)
if ((r & 1) != 0)
r = (r >>> 1) ^ 0xEDB88320;
else
r >>>= 1;
CrcTable[i] = r;
}
}
}

131
3rdparty/lzma/Java/SevenZip/Compression/LZ/InWindow.java vendored Normal file
View File

@@ -0,0 +1,131 @@
// LZ.InWindow
package SevenZip.Compression.LZ;
import java.io.IOException;
public class InWindow
{
public byte[] _bufferBase; // pointer to buffer with data
java.io.InputStream _stream;
int _posLimit; // offset (from _buffer) of first byte when new block reading must be done
boolean _streamEndWasReached; // if (true) then _streamPos shows real end of stream
int _pointerToLastSafePosition;
public int _bufferOffset;
public int _blockSize; // Size of Allocated memory block
public int _pos; // offset (from _buffer) of curent byte
int _keepSizeBefore; // how many BYTEs must be kept in buffer before _pos
int _keepSizeAfter; // how many BYTEs must be kept buffer after _pos
public int _streamPos; // offset (from _buffer) of first not read byte from Stream
public void MoveBlock()
{
int offset = _bufferOffset + _pos - _keepSizeBefore;
// we need one additional byte, since MovePos moves on 1 byte.
if (offset > 0)
offset--;
int numBytes = _bufferOffset + _streamPos - offset;
// check negative offset ????
for (int i = 0; i < numBytes; i++)
_bufferBase[i] = _bufferBase[offset + i];
_bufferOffset -= offset;
}
public void ReadBlock() throws IOException
{
if (_streamEndWasReached)
return;
while (true)
{
int size = (0 - _bufferOffset) + _blockSize - _streamPos;
if (size == 0)
return;
int numReadBytes = _stream.read(_bufferBase, _bufferOffset + _streamPos, size);
if (numReadBytes == -1)
{
_posLimit = _streamPos;
int pointerToPostion = _bufferOffset + _posLimit;
if (pointerToPostion > _pointerToLastSafePosition)
_posLimit = _pointerToLastSafePosition - _bufferOffset;
_streamEndWasReached = true;
return;
}
_streamPos += numReadBytes;
if (_streamPos >= _pos + _keepSizeAfter)
_posLimit = _streamPos - _keepSizeAfter;
}
}
void Free() { _bufferBase = null; }
public void Create(int keepSizeBefore, int keepSizeAfter, int keepSizeReserv)
{
_keepSizeBefore = keepSizeBefore;
_keepSizeAfter = keepSizeAfter;
int blockSize = keepSizeBefore + keepSizeAfter + keepSizeReserv;
if (_bufferBase == null || _blockSize != blockSize)
{
Free();
_blockSize = blockSize;
_bufferBase = new byte[_blockSize];
}
_pointerToLastSafePosition = _blockSize - keepSizeAfter;
}
public void SetStream(java.io.InputStream stream) { _stream = stream; }
public void ReleaseStream() { _stream = null; }
public void Init() throws IOException
{
_bufferOffset = 0;
_pos = 0;
_streamPos = 0;
_streamEndWasReached = false;
ReadBlock();
}
public void MovePos() throws IOException
{
_pos++;
if (_pos > _posLimit)
{
int pointerToPostion = _bufferOffset + _pos;
if (pointerToPostion > _pointerToLastSafePosition)
MoveBlock();
ReadBlock();
}
}
public byte GetIndexByte(int index) { return _bufferBase[_bufferOffset + _pos + index]; }
// index + limit have not to exceed _keepSizeAfter;
public int GetMatchLen(int index, int distance, int limit)
{
if (_streamEndWasReached)
if ((_pos + index) + limit > _streamPos)
limit = _streamPos - (_pos + index);
distance++;
// Byte *pby = _buffer + (size_t)_pos + index;
int pby = _bufferOffset + _pos + index;
int i;
for (i = 0; i < limit && _bufferBase[pby + i] == _bufferBase[pby + i - distance]; i++);
return i;
}
public int GetNumAvailableBytes() { return _streamPos - _pos; }
public void ReduceOffsets(int subValue)
{
_bufferOffset += subValue;
_posLimit -= subValue;
_pos -= subValue;
_streamPos -= subValue;
}
}

85
3rdparty/lzma/Java/SevenZip/Compression/LZ/OutWindow.java vendored Normal file
View File

@@ -0,0 +1,85 @@
// LZ.OutWindow
package SevenZip.Compression.LZ;
import java.io.IOException;
public class OutWindow
{
byte[] _buffer;
int _pos;
int _windowSize = 0;
int _streamPos;
java.io.OutputStream _stream;
public void Create(int windowSize)
{
if (_buffer == null || _windowSize != windowSize)
_buffer = new byte[windowSize];
_windowSize = windowSize;
_pos = 0;
_streamPos = 0;
}
public void SetStream(java.io.OutputStream stream) throws IOException
{
ReleaseStream();
_stream = stream;
}
public void ReleaseStream() throws IOException
{
Flush();
_stream = null;
}
public void Init(boolean solid)
{
if (!solid)
{
_streamPos = 0;
_pos = 0;
}
}
public void Flush() throws IOException
{
int size = _pos - _streamPos;
if (size == 0)
return;
_stream.write(_buffer, _streamPos, size);
if (_pos >= _windowSize)
_pos = 0;
_streamPos = _pos;
}
public void CopyBlock(int distance, int len) throws IOException
{
int pos = _pos - distance - 1;
if (pos < 0)
pos += _windowSize;
for (; len != 0; len--)
{
if (pos >= _windowSize)
pos = 0;
_buffer[_pos++] = _buffer[pos++];
if (_pos >= _windowSize)
Flush();
}
}
public void PutByte(byte b) throws IOException
{
_buffer[_pos++] = b;
if (_pos >= _windowSize)
Flush();
}
public byte GetByte(int distance)
{
int pos = _pos - distance - 1;
if (pos < 0)
pos += _windowSize;
return _buffer[pos];
}
}

88
3rdparty/lzma/Java/SevenZip/Compression/LZMA/Base.java vendored Normal file
View File

@@ -0,0 +1,88 @@
// Base.java
package SevenZip.Compression.LZMA;
public class Base
{
public static final int kNumRepDistances = 4;
public static final int kNumStates = 12;
public static final int StateInit()
{
return 0;
}
public static final int StateUpdateChar(int index)
{
if (index < 4)
return 0;
if (index < 10)
return index - 3;
return index - 6;
}
public static final int StateUpdateMatch(int index)
{
return (index < 7 ? 7 : 10);
}
public static final int StateUpdateRep(int index)
{
return (index < 7 ? 8 : 11);
}
public static final int StateUpdateShortRep(int index)
{
return (index < 7 ? 9 : 11);
}
public static final boolean StateIsCharState(int index)
{
return index < 7;
}
public static final int kNumPosSlotBits = 6;
public static final int kDicLogSizeMin = 0;
// public static final int kDicLogSizeMax = 28;
// public static final int kDistTableSizeMax = kDicLogSizeMax * 2;
public static final int kNumLenToPosStatesBits = 2; // it's for speed optimization
public static final int kNumLenToPosStates = 1 << kNumLenToPosStatesBits;
public static final int kMatchMinLen = 2;
public static final int GetLenToPosState(int len)
{
len -= kMatchMinLen;
if (len < kNumLenToPosStates)
return len;
return (int)(kNumLenToPosStates - 1);
}
public static final int kNumAlignBits = 4;
public static final int kAlignTableSize = 1 << kNumAlignBits;
public static final int kAlignMask = (kAlignTableSize - 1);
public static final int kStartPosModelIndex = 4;
public static final int kEndPosModelIndex = 14;
public static final int kNumPosModels = kEndPosModelIndex - kStartPosModelIndex;
public static final int kNumFullDistances = 1 << (kEndPosModelIndex / 2);
public static final int kNumLitPosStatesBitsEncodingMax = 4;
public static final int kNumLitContextBitsMax = 8;
public static final int kNumPosStatesBitsMax = 4;
public static final int kNumPosStatesMax = (1 << kNumPosStatesBitsMax);
public static final int kNumPosStatesBitsEncodingMax = 4;
public static final int kNumPosStatesEncodingMax = (1 << kNumPosStatesBitsEncodingMax);
public static final int kNumLowLenBits = 3;
public static final int kNumMidLenBits = 3;
public static final int kNumHighLenBits = 8;
public static final int kNumLowLenSymbols = 1 << kNumLowLenBits;
public static final int kNumMidLenSymbols = 1 << kNumMidLenBits;
public static final int kNumLenSymbols = kNumLowLenSymbols + kNumMidLenSymbols +
(1 << kNumHighLenBits);
public static final int kMatchMaxLen = kMatchMinLen + kNumLenSymbols - 1;
}

329
3rdparty/lzma/Java/SevenZip/Compression/LZMA/Decoder.java vendored Normal file
View 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);
}
}

1416
3rdparty/lzma/Java/SevenZip/Compression/LZMA/Encoder.java vendored Normal file
View File

File diff suppressed because it is too large Load Diff

55
3rdparty/lzma/Java/SevenZip/Compression/RangeCoder/BitTreeDecoder.java vendored Normal file
View File

@@ -0,0 +1,55 @@
package SevenZip.Compression.RangeCoder;
public class BitTreeDecoder
{
short[] Models;
int NumBitLevels;
public BitTreeDecoder(int numBitLevels)
{
NumBitLevels = numBitLevels;
Models = new short[1 << numBitLevels];
}
public void Init()
{
Decoder.InitBitModels(Models);
}
public int Decode(Decoder rangeDecoder) throws java.io.IOException
{
int m = 1;
for (int bitIndex = NumBitLevels; bitIndex != 0; bitIndex--)
m = (m << 1) + rangeDecoder.DecodeBit(Models, m);
return m - (1 << NumBitLevels);
}
public int ReverseDecode(Decoder rangeDecoder) throws java.io.IOException
{
int m = 1;
int symbol = 0;
for (int bitIndex = 0; bitIndex < NumBitLevels; bitIndex++)
{
int bit = rangeDecoder.DecodeBit(Models, m);
m <<= 1;
m += bit;
symbol |= (bit << bitIndex);
}
return symbol;
}
public static int ReverseDecode(short[] Models, int startIndex,
Decoder rangeDecoder, int NumBitLevels) throws java.io.IOException
{
int m = 1;
int symbol = 0;
for (int bitIndex = 0; bitIndex < NumBitLevels; bitIndex++)
{
int bit = rangeDecoder.DecodeBit(Models, startIndex + m);
m <<= 1;
m += bit;
symbol |= (bit << bitIndex);
}
return symbol;
}
}

99
3rdparty/lzma/Java/SevenZip/Compression/RangeCoder/BitTreeEncoder.java vendored Normal file
View File

@@ -0,0 +1,99 @@
package SevenZip.Compression.RangeCoder;
import java.io.IOException;
public class BitTreeEncoder
{
short[] Models;
int NumBitLevels;
public BitTreeEncoder(int numBitLevels)
{
NumBitLevels = numBitLevels;
Models = new short[1 << numBitLevels];
}
public void Init()
{
Decoder.InitBitModels(Models);
}
public void Encode(Encoder rangeEncoder, int symbol) throws IOException
{
int m = 1;
for (int bitIndex = NumBitLevels; bitIndex != 0; )
{
bitIndex--;
int bit = (symbol >>> bitIndex) & 1;
rangeEncoder.Encode(Models, m, bit);
m = (m << 1) | bit;
}
}
public void ReverseEncode(Encoder rangeEncoder, int symbol) throws IOException
{
int m = 1;
for (int i = 0; i < NumBitLevels; i++)
{
int bit = symbol & 1;
rangeEncoder.Encode(Models, m, bit);
m = (m << 1) | bit;
symbol >>= 1;
}
}
public int GetPrice(int symbol)
{
int price = 0;
int m = 1;
for (int bitIndex = NumBitLevels; bitIndex != 0; )
{
bitIndex--;
int bit = (symbol >>> bitIndex) & 1;
price += Encoder.GetPrice(Models[m], bit);
m = (m << 1) + bit;
}
return price;
}
public int ReverseGetPrice(int symbol)
{
int price = 0;
int m = 1;
for (int i = NumBitLevels; i != 0; i--)
{
int bit = symbol & 1;
symbol >>>= 1;
price += Encoder.GetPrice(Models[m], bit);
m = (m << 1) | bit;
}
return price;
}
public static int ReverseGetPrice(short[] Models, int startIndex,
int NumBitLevels, int symbol)
{
int price = 0;
int m = 1;
for (int i = NumBitLevels; i != 0; i--)
{
int bit = symbol & 1;
symbol >>>= 1;
price += Encoder.GetPrice(Models[startIndex + m], bit);
m = (m << 1) | bit;
}
return price;
}
public static void ReverseEncode(short[] Models, int startIndex,
Encoder rangeEncoder, int NumBitLevels, int symbol) throws IOException
{
int m = 1;
for (int i = 0; i < NumBitLevels; i++)
{
int bit = symbol & 1;
rangeEncoder.Encode(Models, startIndex + m, bit);
m = (m << 1) | bit;
symbol >>= 1;
}
}
}

88
3rdparty/lzma/Java/SevenZip/Compression/RangeCoder/Decoder.java vendored Normal file
View File

@@ -0,0 +1,88 @@
package SevenZip.Compression.RangeCoder;
import java.io.IOException;
public class Decoder
{
static final int kTopMask = ~((1 << 24) - 1);
static final int kNumBitModelTotalBits = 11;
static final int kBitModelTotal = (1 << kNumBitModelTotalBits);
static final int kNumMoveBits = 5;
int Range;
int Code;
java.io.InputStream Stream;
public final void SetStream(java.io.InputStream stream)
{
Stream = stream;
}
public final void ReleaseStream()
{
Stream = null;
}
public final void Init() throws IOException
{
Code = 0;
Range = -1;
for (int i = 0; i < 5; i++)
Code = (Code << 8) | Stream.read();
}
public final int DecodeDirectBits(int numTotalBits) throws IOException
{
int result = 0;
for (int i = numTotalBits; i != 0; i--)
{
Range >>>= 1;
int t = ((Code - Range) >>> 31);
Code -= Range & (t - 1);
result = (result << 1) | (1 - t);
if ((Range & kTopMask) == 0)
{
Code = (Code << 8) | Stream.read();
Range <<= 8;
}
}
return result;
}
public int DecodeBit(short []probs, int index) throws IOException
{
int prob = probs[index];
int newBound = (Range >>> kNumBitModelTotalBits) * prob;
if ((Code ^ 0x80000000) < (newBound ^ 0x80000000))
{
Range = newBound;
probs[index] = (short)(prob + ((kBitModelTotal - prob) >>> kNumMoveBits));
if ((Range & kTopMask) == 0)
{
Code = (Code << 8) | Stream.read();
Range <<= 8;
}
return 0;
}
else
{
Range -= newBound;
Code -= newBound;
probs[index] = (short)(prob - ((prob) >>> kNumMoveBits));
if ((Range & kTopMask) == 0)
{
Code = (Code << 8) | Stream.read();
Range <<= 8;
}
return 1;
}
}
public static void InitBitModels(short []probs)
{
for (int i = 0; i < probs.length; i++)
probs[i] = (kBitModelTotal >>> 1);
}
}

151
3rdparty/lzma/Java/SevenZip/Compression/RangeCoder/Encoder.java vendored Normal file
View File

@@ -0,0 +1,151 @@
package SevenZip.Compression.RangeCoder;
import java.io.IOException;
public class Encoder
{
static final int kTopMask = ~((1 << 24) - 1);
static final int kNumBitModelTotalBits = 11;
static final int kBitModelTotal = (1 << kNumBitModelTotalBits);
static final int kNumMoveBits = 5;
java.io.OutputStream Stream;
long Low;
int Range;
int _cacheSize;
int _cache;
long _position;
public void SetStream(java.io.OutputStream stream)
{
Stream = stream;
}
public void ReleaseStream()
{
Stream = null;
}
public void Init()
{
_position = 0;
Low = 0;
Range = -1;
_cacheSize = 1;
_cache = 0;
}
public void FlushData() throws IOException
{
for (int i = 0; i < 5; i++)
ShiftLow();
}
public void FlushStream() throws IOException
{
Stream.flush();
}
public void ShiftLow() throws IOException
{
int LowHi = (int)(Low >>> 32);
if (LowHi != 0 || Low < 0xFF000000L)
{
_position += _cacheSize;
int temp = _cache;
do
{
Stream.write(temp + LowHi);
temp = 0xFF;
}
while(--_cacheSize != 0);
_cache = (((int)Low) >>> 24);
}
_cacheSize++;
Low = (Low & 0xFFFFFF) << 8;
}
public void EncodeDirectBits(int v, int numTotalBits) throws IOException
{
for (int i = numTotalBits - 1; i >= 0; i--)
{
Range >>>= 1;
if (((v >>> i) & 1) == 1)
Low += Range;
if ((Range & Encoder.kTopMask) == 0)
{
Range <<= 8;
ShiftLow();
}
}
}
public long GetProcessedSizeAdd()
{
return _cacheSize + _position + 4;
}
static final int kNumMoveReducingBits = 2;
public static final int kNumBitPriceShiftBits = 6;
public static void InitBitModels(short []probs)
{
for (int i = 0; i < probs.length; i++)
probs[i] = (kBitModelTotal >>> 1);
}
public void Encode(short []probs, int index, int symbol) throws IOException
{
int prob = probs[index];
int newBound = (Range >>> kNumBitModelTotalBits) * prob;
if (symbol == 0)
{
Range = newBound;
probs[index] = (short)(prob + ((kBitModelTotal - prob) >>> kNumMoveBits));
}
else
{
Low += (newBound & 0xFFFFFFFFL);
Range -= newBound;
probs[index] = (short)(prob - ((prob) >>> kNumMoveBits));
}
if ((Range & kTopMask) == 0)
{
Range <<= 8;
ShiftLow();
}
}
private static int[] ProbPrices = new int[kBitModelTotal >>> kNumMoveReducingBits];
static
{
int kNumBits = (kNumBitModelTotalBits - kNumMoveReducingBits);
for (int i = kNumBits - 1; i >= 0; i--)
{
int start = 1 << (kNumBits - i - 1);
int end = 1 << (kNumBits - i);
for (int j = start; j < end; j++)
ProbPrices[j] = (i << kNumBitPriceShiftBits) +
(((end - j) << kNumBitPriceShiftBits) >>> (kNumBits - i - 1));
}
}
static public int GetPrice(int Prob, int symbol)
{
return ProbPrices[(((Prob - symbol) ^ ((-symbol))) & (kBitModelTotal - 1)) >>> kNumMoveReducingBits];
}
static public int GetPrice0(int Prob)
{
return ProbPrices[Prob >>> kNumMoveReducingBits];
}
static public int GetPrice1(int Prob)
{
return ProbPrices[(kBitModelTotal - Prob) >>> kNumMoveReducingBits];
}
}

6
3rdparty/lzma/Java/SevenZip/ICodeProgress.java vendored Normal file
View File

@@ -0,0 +1,6 @@
package SevenZip;
public interface ICodeProgress
{
public void SetProgress(long inSize, long outSize);
}

253
3rdparty/lzma/Java/SevenZip/LzmaAlone.java vendored Normal file
View File

@@ -0,0 +1,253 @@
package SevenZip;
public class LzmaAlone
{
static public class CommandLine
{
public static final int kEncode = 0;
public static final int kDecode = 1;
public static final int kBenchmak = 2;
public int Command = -1;
public int NumBenchmarkPasses = 10;
public int DictionarySize = 1 << 23;
public boolean DictionarySizeIsDefined = false;
public int Lc = 3;
public int Lp = 0;
public int Pb = 2;
public int Fb = 128;
public boolean FbIsDefined = false;
public boolean Eos = false;
public int Algorithm = 2;
public int MatchFinder = 1;
public String InFile;
public String OutFile;
boolean ParseSwitch(String s)
{
if (s.startsWith("d"))
{
DictionarySize = 1 << Integer.parseInt(s.substring(1));
DictionarySizeIsDefined = true;
}
else if (s.startsWith("fb"))
{
Fb = Integer.parseInt(s.substring(2));
FbIsDefined = true;
}
else if (s.startsWith("a"))
Algorithm = Integer.parseInt(s.substring(1));
else if (s.startsWith("lc"))
Lc = Integer.parseInt(s.substring(2));
else if (s.startsWith("lp"))
Lp = Integer.parseInt(s.substring(2));
else if (s.startsWith("pb"))
Pb = Integer.parseInt(s.substring(2));
else if (s.startsWith("eos"))
Eos = true;
else if (s.startsWith("mf"))
{
String mfs = s.substring(2);
if (mfs.equals("bt2"))
MatchFinder = 0;
else if (mfs.equals("bt4"))
MatchFinder = 1;
else if (mfs.equals("bt4b"))
MatchFinder = 2;
else
return false;
}
else
return false;
return true;
}
public boolean Parse(String[] args) throws Exception
{
int pos = 0;
boolean switchMode = true;
for (int i = 0; i < args.length; i++)
{
String s = args[i];
if (s.length() == 0)
return false;
if (switchMode)
{
if (s.compareTo("--") == 0)
{
switchMode = false;
continue;
}
if (s.charAt(0) == '-')
{
String sw = s.substring(1).toLowerCase();
if (sw.length() == 0)
return false;
try
{
if (!ParseSwitch(sw))
return false;
}
catch (NumberFormatException e)
{
return false;
}
continue;
}
}
if (pos == 0)
{
if (s.equalsIgnoreCase("e"))
Command = kEncode;
else if (s.equalsIgnoreCase("d"))
Command = kDecode;
else if (s.equalsIgnoreCase("b"))
Command = kBenchmak;
else
return false;
}
else if(pos == 1)
{
if (Command == kBenchmak)
{
try
{
NumBenchmarkPasses = Integer.parseInt(s);
if (NumBenchmarkPasses < 1)
return false;
}
catch (NumberFormatException e)
{
return false;
}
}
else
InFile = s;
}
else if(pos == 2)
OutFile = s;
else
return false;
pos++;
continue;
}
return true;
}
}
static void PrintHelp()
{
System.out.println(
"\nUsage: LZMA <e|d> [<switches>...] inputFile outputFile\n" +
" e: encode file\n" +
" d: decode file\n" +
" b: Benchmark\n" +
"<Switches>\n" +
// " -a{N}: set compression mode - [0, 1], default: 1 (max)\n" +
" -d{N}: set dictionary - [0,28], default: 23 (8MB)\n" +
" -fb{N}: set number of fast bytes - [5, 273], default: 128\n" +
" -lc{N}: set number of literal context bits - [0, 8], default: 3\n" +
" -lp{N}: set number of literal pos bits - [0, 4], default: 0\n" +
" -pb{N}: set number of pos bits - [0, 4], default: 2\n" +
" -mf{MF_ID}: set Match Finder: [bt2, bt4], default: bt4\n" +
" -eos: write End Of Stream marker\n"
);
}
public static void main(String[] args) throws Exception
{
System.out.println("\nLZMA (Java) 4.61 2008-11-23\n");
if (args.length < 1)
{
PrintHelp();
return;
}
CommandLine params = new CommandLine();
if (!params.Parse(args))
{
System.out.println("\nIncorrect command");
return;
}
if (params.Command == CommandLine.kBenchmak)
{
int dictionary = (1 << 21);
if (params.DictionarySizeIsDefined)
dictionary = params.DictionarySize;
if (params.MatchFinder > 1)
throw new Exception("Unsupported match finder");
SevenZip.LzmaBench.LzmaBenchmark(params.NumBenchmarkPasses, dictionary);
}
else if (params.Command == CommandLine.kEncode || params.Command == CommandLine.kDecode)
{
java.io.File inFile = new java.io.File(params.InFile);
java.io.File outFile = new java.io.File(params.OutFile);
java.io.BufferedInputStream inStream = new java.io.BufferedInputStream(new java.io.FileInputStream(inFile));
java.io.BufferedOutputStream outStream = new java.io.BufferedOutputStream(new java.io.FileOutputStream(outFile));
boolean eos = false;
if (params.Eos)
eos = true;
if (params.Command == CommandLine.kEncode)
{
SevenZip.Compression.LZMA.Encoder encoder = new SevenZip.Compression.LZMA.Encoder();
if (!encoder.SetAlgorithm(params.Algorithm))
throw new Exception("Incorrect compression mode");
if (!encoder.SetDictionarySize(params.DictionarySize))
throw new Exception("Incorrect dictionary size");
if (!encoder.SetNumFastBytes(params.Fb))
throw new Exception("Incorrect -fb value");
if (!encoder.SetMatchFinder(params.MatchFinder))
throw new Exception("Incorrect -mf value");
if (!encoder.SetLcLpPb(params.Lc, params.Lp, params.Pb))
throw new Exception("Incorrect -lc or -lp or -pb value");
encoder.SetEndMarkerMode(eos);
encoder.WriteCoderProperties(outStream);
long fileSize;
if (eos)
fileSize = -1;
else
fileSize = inFile.length();
for (int i = 0; i < 8; i++)
outStream.write((int)(fileSize >>> (8 * i)) & 0xFF);
encoder.Code(inStream, outStream, -1, -1, null);
}
else
{
int propertiesSize = 5;
byte[] properties = new byte[propertiesSize];
if (inStream.read(properties, 0, propertiesSize) != propertiesSize)
throw new Exception("input .lzma file is too short");
SevenZip.Compression.LZMA.Decoder decoder = new SevenZip.Compression.LZMA.Decoder();
if (!decoder.SetDecoderProperties(properties))
throw new Exception("Incorrect stream properties");
long outSize = 0;
for (int i = 0; i < 8; i++)
{
int v = inStream.read();
if (v < 0)
throw new Exception("Can't read stream size");
outSize |= ((long)v) << (8 * i);
}
if (!decoder.Code(inStream, outStream, outSize))
throw new Exception("Error in data stream");
}
outStream.flush();
outStream.close();
inStream.close();
}
else
throw new Exception("Incorrect command");
return;
}
}

392
3rdparty/lzma/Java/SevenZip/LzmaBench.java vendored Normal file
View File

@@ -0,0 +1,392 @@
package SevenZip;
import java.io.ByteArrayOutputStream;
import java.io.ByteArrayInputStream;
import java.io.IOException;
public class LzmaBench
{
static final int kAdditionalSize = (1 << 21);
static final int kCompressedAdditionalSize = (1 << 10);
static class CRandomGenerator
{
int A1;
int A2;
public CRandomGenerator() { Init(); }
public void Init() { A1 = 362436069; A2 = 521288629; }
public int GetRnd()
{
return
((A1 = 36969 * (A1 & 0xffff) + (A1 >>> 16)) << 16) ^
((A2 = 18000 * (A2 & 0xffff) + (A2 >>> 16)));
}
};
static class CBitRandomGenerator
{
CRandomGenerator RG = new CRandomGenerator();
int Value;
int NumBits;
public void Init()
{
Value = 0;
NumBits = 0;
}
public int GetRnd(int numBits)
{
int result;
if (NumBits > numBits)
{
result = Value & ((1 << numBits) - 1);
Value >>>= numBits;
NumBits -= numBits;
return result;
}
numBits -= NumBits;
result = (Value << numBits);
Value = RG.GetRnd();
result |= Value & (((int)1 << numBits) - 1);
Value >>>= numBits;
NumBits = 32 - numBits;
return result;
}
};
static class CBenchRandomGenerator
{
CBitRandomGenerator RG = new CBitRandomGenerator();
int Pos;
int Rep0;
public int BufferSize;
public byte[] Buffer = null;
public CBenchRandomGenerator() { }
public void Set(int bufferSize)
{
Buffer = new byte[bufferSize];
Pos = 0;
BufferSize = bufferSize;
}
int GetRndBit() { return RG.GetRnd(1); }
int GetLogRandBits(int numBits)
{
int len = RG.GetRnd(numBits);
return RG.GetRnd((int)len);
}
int GetOffset()
{
if (GetRndBit() == 0)
return GetLogRandBits(4);
return (GetLogRandBits(4) << 10) | RG.GetRnd(10);
}
int GetLen1() { return RG.GetRnd(1 + (int)RG.GetRnd(2)); }
int GetLen2() { return RG.GetRnd(2 + (int)RG.GetRnd(2)); }
public void Generate()
{
RG.Init();
Rep0 = 1;
while (Pos < BufferSize)
{
if (GetRndBit() == 0 || Pos < 1)
Buffer[Pos++] = (byte)(RG.GetRnd(8));
else
{
int len;
if (RG.GetRnd(3) == 0)
len = 1 + GetLen1();
else
{
do
Rep0 = GetOffset();
while (Rep0 >= Pos);
Rep0++;
len = 2 + GetLen2();
}
for (int i = 0; i < len && Pos < BufferSize; i++, Pos++)
Buffer[Pos] = Buffer[Pos - Rep0];
}
}
}
};
static class CrcOutStream extends java.io.OutputStream
{
public CRC CRC = new CRC();
public void Init()
{
CRC.Init();
}
public int GetDigest()
{
return CRC.GetDigest();
}
public void write(byte[] b)
{
CRC.Update(b);
}
public void write(byte[] b, int off, int len)
{
CRC.Update(b, off, len);
}
public void write(int b)
{
CRC.UpdateByte(b);
}
};
static class MyOutputStream extends java.io.OutputStream
{
byte[] _buffer;
int _size;
int _pos;
public MyOutputStream(byte[] buffer)
{
_buffer = buffer;
_size = _buffer.length;
}
public void reset()
{
_pos = 0;
}
public void write(int b) throws IOException
{
if (_pos >= _size)
throw new IOException("Error");
_buffer[_pos++] = (byte)b;
}
public int size()
{
return _pos;
}
};
static class MyInputStream extends java.io.InputStream
{
byte[] _buffer;
int _size;
int _pos;
public MyInputStream(byte[] buffer, int size)
{
_buffer = buffer;
_size = size;
}
public void reset()
{
_pos = 0;
}
public int read()
{
if (_pos >= _size)
return -1;
return _buffer[_pos++] & 0xFF;
}
};
static class CProgressInfo implements ICodeProgress
{
public long ApprovedStart;
public long InSize;
public long Time;
public void Init()
{ InSize = 0; }
public void SetProgress(long inSize, long outSize)
{
if (inSize >= ApprovedStart && InSize == 0)
{
Time = System.currentTimeMillis();
InSize = inSize;
}
}
}
static final int kSubBits = 8;
static int GetLogSize(int size)
{
for (int i = kSubBits; i < 32; i++)
for (int j = 0; j < (1 << kSubBits); j++)
if (size <= ((1) << i) + (j << (i - kSubBits)))
return (i << kSubBits) + j;
return (32 << kSubBits);
}
static long MyMultDiv64(long value, long elapsedTime)
{
long freq = 1000; // ms
long elTime = elapsedTime;
while (freq > 1000000)
{
freq >>>= 1;
elTime >>>= 1;
}
if (elTime == 0)
elTime = 1;
return value * freq / elTime;
}
static long GetCompressRating(int dictionarySize, long elapsedTime, long size)
{
long t = GetLogSize(dictionarySize) - (18 << kSubBits);
long numCommandsForOne = 1060 + ((t * t * 10) >> (2 * kSubBits));
long numCommands = (long)(size) * numCommandsForOne;
return MyMultDiv64(numCommands, elapsedTime);
}
static long GetDecompressRating(long elapsedTime, long outSize, long inSize)
{
long numCommands = inSize * 220 + outSize * 20;
return MyMultDiv64(numCommands, elapsedTime);
}
static long GetTotalRating(
int dictionarySize,
long elapsedTimeEn, long sizeEn,
long elapsedTimeDe,
long inSizeDe, long outSizeDe)
{
return (GetCompressRating(dictionarySize, elapsedTimeEn, sizeEn) +
GetDecompressRating(elapsedTimeDe, inSizeDe, outSizeDe)) / 2;
}
static void PrintValue(long v)
{
String s = "";
s += v;
for (int i = 0; i + s.length() < 6; i++)
System.out.print(" ");
System.out.print(s);
}
static void PrintRating(long rating)
{
PrintValue(rating / 1000000);
System.out.print(" MIPS");
}
static void PrintResults(
int dictionarySize,
long elapsedTime,
long size,
boolean decompressMode, long secondSize)
{
long speed = MyMultDiv64(size, elapsedTime);
PrintValue(speed / 1024);
System.out.print(" KB/s ");
long rating;
if (decompressMode)
rating = GetDecompressRating(elapsedTime, size, secondSize);
else
rating = GetCompressRating(dictionarySize, elapsedTime, size);
PrintRating(rating);
}
static public int LzmaBenchmark(int numIterations, int dictionarySize) throws Exception
{
if (numIterations <= 0)
return 0;
if (dictionarySize < (1 << 18))
{
System.out.println("\nError: dictionary size for benchmark must be >= 18 (256 KB)");
return 1;
}
System.out.print("\n Compressing Decompressing\n\n");
SevenZip.Compression.LZMA.Encoder encoder = new SevenZip.Compression.LZMA.Encoder();
SevenZip.Compression.LZMA.Decoder decoder = new SevenZip.Compression.LZMA.Decoder();
if (!encoder.SetDictionarySize(dictionarySize))
throw new Exception("Incorrect dictionary size");
int kBufferSize = dictionarySize + kAdditionalSize;
int kCompressedBufferSize = (kBufferSize / 2) + kCompressedAdditionalSize;
ByteArrayOutputStream propStream = new ByteArrayOutputStream();
encoder.WriteCoderProperties(propStream);
byte[] propArray = propStream.toByteArray();
decoder.SetDecoderProperties(propArray);
CBenchRandomGenerator rg = new CBenchRandomGenerator();
rg.Set(kBufferSize);
rg.Generate();
CRC crc = new CRC();
crc.Init();
crc.Update(rg.Buffer, 0, rg.BufferSize);
CProgressInfo progressInfo = new CProgressInfo();
progressInfo.ApprovedStart = dictionarySize;
long totalBenchSize = 0;
long totalEncodeTime = 0;
long totalDecodeTime = 0;
long totalCompressedSize = 0;
MyInputStream inStream = new MyInputStream(rg.Buffer, rg.BufferSize);
byte[] compressedBuffer = new byte[kCompressedBufferSize];
MyOutputStream compressedStream = new MyOutputStream(compressedBuffer);
CrcOutStream crcOutStream = new CrcOutStream();
MyInputStream inputCompressedStream = null;
int compressedSize = 0;
for (int i = 0; i < numIterations; i++)
{
progressInfo.Init();
inStream.reset();
compressedStream.reset();
encoder.Code(inStream, compressedStream, -1, -1, progressInfo);
long encodeTime = System.currentTimeMillis() - progressInfo.Time;
if (i == 0)
{
compressedSize = compressedStream.size();
inputCompressedStream = new MyInputStream(compressedBuffer, compressedSize);
}
else if (compressedSize != compressedStream.size())
throw (new Exception("Encoding error"));
if (progressInfo.InSize == 0)
throw (new Exception("Internal ERROR 1282"));
long decodeTime = 0;
for (int j = 0; j < 2; j++)
{
inputCompressedStream.reset();
crcOutStream.Init();
long outSize = kBufferSize;
long startTime = System.currentTimeMillis();
if (!decoder.Code(inputCompressedStream, crcOutStream, outSize))
throw (new Exception("Decoding Error"));;
decodeTime = System.currentTimeMillis() - startTime;
if (crcOutStream.GetDigest() != crc.GetDigest())
throw (new Exception("CRC Error"));
}
long benchSize = kBufferSize - (long)progressInfo.InSize;
PrintResults(dictionarySize, encodeTime, benchSize, false, 0);
System.out.print(" ");
PrintResults(dictionarySize, decodeTime, kBufferSize, true, compressedSize);
System.out.println();
totalBenchSize += benchSize;
totalEncodeTime += encodeTime;
totalDecodeTime += decodeTime;
totalCompressedSize += compressedSize;
}
System.out.println("---------------------------------------------------");
PrintResults(dictionarySize, totalEncodeTime, totalBenchSize, false, 0);
System.out.print(" ");
PrintResults(dictionarySize, totalDecodeTime,
kBufferSize * (long)numIterations, true, totalCompressedSize);
System.out.println(" Average");
return 0;
}
}