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