vcs.maemo.org Git - physicsfs/blob - lzma/CS/7zip/Compress/LZ/LzInWindow.cs

   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 }