misc/libphysfs/lzma/CS/7zip/Compress/LZ/LzOutWindow.cs
changeset 13904 99b265e0d1d0
parent 13903 5f819b90d479
child 13905 b172a5d40eee
equal deleted inserted replaced
13903:5f819b90d479 13904:99b265e0d1d0
     1 // LzOutWindow.cs
       
     2 
       
     3 namespace SevenZip.Compression.LZ
       
     4 {
       
     5 	public class OutWindow
       
     6 	{
       
     7 		byte[] _buffer = null;
       
     8 		uint _pos;
       
     9 		uint _windowSize = 0;
       
    10 		uint _streamPos;
       
    11 		System.IO.Stream _stream;
       
    12 
       
    13 		public uint TrainSize = 0;
       
    14 
       
    15 		public void Create(uint windowSize)
       
    16 		{
       
    17 			if (_windowSize != windowSize)
       
    18 			{
       
    19 				// System.GC.Collect();
       
    20 				_buffer = new byte[windowSize];
       
    21 			}
       
    22 			_windowSize = windowSize;
       
    23 			_pos = 0;
       
    24 			_streamPos = 0;
       
    25 		}
       
    26 
       
    27 		public void Init(System.IO.Stream stream, bool solid)
       
    28 		{
       
    29 			ReleaseStream();
       
    30 			_stream = stream;
       
    31 			if (!solid)
       
    32 			{
       
    33 				_streamPos = 0;
       
    34 				_pos = 0;
       
    35 				TrainSize = 0;
       
    36 			}
       
    37 		}
       
    38 	
       
    39 		public bool Train(System.IO.Stream stream)
       
    40 		{
       
    41 			long len = stream.Length;
       
    42 			uint size = (len < _windowSize) ? (uint)len : _windowSize;
       
    43 			TrainSize = size;
       
    44 			stream.Position = len - size;
       
    45 			_streamPos = _pos = 0;
       
    46 			while (size > 0)
       
    47 			{
       
    48 				uint curSize = _windowSize - _pos;
       
    49 				if (size < curSize)
       
    50 					curSize = size;
       
    51 				int numReadBytes = stream.Read(_buffer, (int)_pos, (int)curSize);
       
    52 				if (numReadBytes == 0)
       
    53 					return false;
       
    54 				size -= (uint)numReadBytes;
       
    55 				_pos += (uint)numReadBytes;
       
    56 				_streamPos += (uint)numReadBytes;
       
    57 				if (_pos == _windowSize)
       
    58 					_streamPos = _pos = 0;
       
    59 			}
       
    60 			return true;
       
    61 		}
       
    62 
       
    63 		public void ReleaseStream()
       
    64 		{
       
    65 			Flush();
       
    66 			_stream = null;
       
    67 		}
       
    68 
       
    69 		public void Flush()
       
    70 		{
       
    71 			uint size = _pos - _streamPos;
       
    72 			if (size == 0)
       
    73 				return;
       
    74 			_stream.Write(_buffer, (int)_streamPos, (int)size);
       
    75 			if (_pos >= _windowSize)
       
    76 				_pos = 0;
       
    77 			_streamPos = _pos;
       
    78 		}
       
    79 
       
    80 		public void CopyBlock(uint distance, uint len)
       
    81 		{
       
    82 			uint pos = _pos - distance - 1;
       
    83 			if (pos >= _windowSize)
       
    84 				pos += _windowSize;
       
    85 			for (; len > 0; len--)
       
    86 			{
       
    87 				if (pos >= _windowSize)
       
    88 					pos = 0;
       
    89 				_buffer[_pos++] = _buffer[pos++];
       
    90 				if (_pos >= _windowSize)
       
    91 					Flush();
       
    92 			}
       
    93 		}
       
    94 
       
    95 		public void PutByte(byte b)
       
    96 		{
       
    97 			_buffer[_pos++] = b;
       
    98 			if (_pos >= _windowSize)
       
    99 				Flush();
       
   100 		}
       
   101 
       
   102 		public byte GetByte(uint distance)
       
   103 		{
       
   104 			uint pos = _pos - distance - 1;
       
   105 			if (pos >= _windowSize)
       
   106 				pos += _windowSize;
       
   107 			return _buffer[pos];
       
   108 		}
       
   109 	}
       
   110 }