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