tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

InWindow.java (3726B)

      1 // LZ.InWindow
      2 
      3 package SevenZip.Compression.LZ;
      4 
      5 import java.io.IOException;
      6 
      7 public class InWindow
      8 {
      9 public byte[] _bufferBase; // pointer to buffer with data
     10 java.io.InputStream _stream;
     11 int _posLimit;  // offset (from _buffer) of first byte when new block reading must be done
     12 boolean _streamEndWasReached; // if (true) then _streamPos shows real end of stream
     13 
     14 int _pointerToLastSafePosition;
     15 
     16 public int _bufferOffset;
     17 
     18 public int _blockSize;  // Size of Allocated memory block
     19 public int _pos;             // offset (from _buffer) of curent byte
     20 int _keepSizeBefore;  // how many BYTEs must be kept in buffer before _pos
     21 int _keepSizeAfter;   // how many BYTEs must be kept buffer after _pos
     22 public int _streamPos;   // offset (from _buffer) of first not read byte from Stream
     23 
     24 public void MoveBlock()
     25 {
     26 	int offset = _bufferOffset + _pos - _keepSizeBefore;
     27 	// we need one additional byte, since MovePos moves on 1 byte.
     28 	if (offset > 0)
     29 		offset--;
     30 
     31 	int numBytes = _bufferOffset + _streamPos - offset;
     32 	
     33 	// check negative offset ????
     34 	for (int i = 0; i < numBytes; i++)
     35 		_bufferBase[i] = _bufferBase[offset + i];
     36 	_bufferOffset -= offset;
     37 }
     38 
     39 public void ReadBlock() throws IOException
     40 {
     41 	if (_streamEndWasReached)
     42 		return;
     43 	while (true)
     44 	{
     45 		int size = (0 - _bufferOffset) + _blockSize - _streamPos;
     46 		if (size == 0)
     47 			return;
     48 		int numReadBytes = _stream.read(_bufferBase, _bufferOffset + _streamPos, size);
     49 		if (numReadBytes == -1)
     50 		{
     51 			_posLimit = _streamPos;
     52 			int pointerToPostion = _bufferOffset + _posLimit;
     53 			if (pointerToPostion > _pointerToLastSafePosition)
     54 				_posLimit = _pointerToLastSafePosition - _bufferOffset;
     55 			
     56 			_streamEndWasReached = true;
     57 			return;
     58 		}
     59 		_streamPos += numReadBytes;
     60 		if (_streamPos >= _pos + _keepSizeAfter)
     61 			_posLimit = _streamPos - _keepSizeAfter;
     62 	}
     63 }
     64 
     65 void Free() { _bufferBase = null; }
     66 
     67 public void Create(int keepSizeBefore, int keepSizeAfter, int keepSizeReserv)
     68 {
     69 	_keepSizeBefore = keepSizeBefore;
     70 	_keepSizeAfter = keepSizeAfter;
     71 	int blockSize = keepSizeBefore + keepSizeAfter + keepSizeReserv;
     72 	if (_bufferBase == null || _blockSize != blockSize)
     73 	{
     74 		Free();
     75 		_blockSize = blockSize;
     76 		_bufferBase = new byte[_blockSize];
     77 	}
     78 	_pointerToLastSafePosition = _blockSize - keepSizeAfter;
     79 }
     80 
     81 public void SetStream(java.io.InputStream stream) { _stream = stream; 	}
     82 public void ReleaseStream() { _stream = null; }
     83 
     84 public void Init() throws IOException
     85 {
     86 	_bufferOffset = 0;
     87 	_pos = 0;
     88 	_streamPos = 0;
     89 	_streamEndWasReached = false;
     90 	ReadBlock();
     91 }
     92 
     93 public void MovePos() throws IOException
     94 {
     95 	_pos++;
     96 	if (_pos > _posLimit)
     97 	{
     98 		int pointerToPostion = _bufferOffset + _pos;
     99 		if (pointerToPostion > _pointerToLastSafePosition)
    100 			MoveBlock();
    101 		ReadBlock();
    102 	}
    103 }
    104 
    105 public byte GetIndexByte(int index)	{ return _bufferBase[_bufferOffset + _pos + index]; }
    106 
    107 // index + limit have not to exceed _keepSizeAfter;
    108 public int GetMatchLen(int index, int distance, int limit)
    109 {
    110 	if (_streamEndWasReached)
    111 		if ((_pos + index) + limit > _streamPos)
    112 			limit = _streamPos - (_pos + index);
    113 	distance++;
    114 	// Byte *pby = _buffer + (size_t)_pos + index;
    115 	int pby = _bufferOffset + _pos + index;
    116 	
    117 	int i;
    118 	for (i = 0; i < limit && _bufferBase[pby + i] == _bufferBase[pby + i - distance]; i++);
    119 	return i;
    120 }
    121 
    122 public int GetNumAvailableBytes()	{ return _streamPos - _pos; }
    123 
    124 public void ReduceOffsets(int subValue)
    125 {
    126 	_bufferOffset += subValue;
    127 	_posLimit -= subValue;
    128 	_pos -= subValue;
    129 	_streamPos -= subValue;
    130 }
    131 }