seven-zip 1.4.2 → 1.7.0.rc1

data/ext/p7zip/CPP/7zip/Compress/Bcj2Coder.h

@@ -3,60 +3,57 @@
 #ifndef __COMPRESS_BCJ2_CODER_H
 #define __COMPRESS_BCJ2_CODER_H
 
+#include "../../../C/Bcj2.h"
+
 #include "../../Common/MyCom.h"
 
 #include "../ICoder.h"
 
-#include "RangeCoderBit.h"
-
 namespace NCompress {
 namespace NBcj2 {
 
-const int kNumMoveBits = 5;
+class CBaseCoder
+{
+protected:
+  Byte *_bufs[BCJ2_NUM_STREAMS + 1];
+  UInt32 _bufsCurSizes[BCJ2_NUM_STREAMS + 1];
+  UInt32 _bufsNewSizes[BCJ2_NUM_STREAMS + 1];
+
+  HRESULT Alloc(bool allocForOrig = true);
+public:
+  CBaseCoder();
+  ~CBaseCoder();
+};
+
 
 #ifndef EXTRACT_ONLY
 
 class CEncoder:
   public ICompressCoder2,
-  public CMyUnknownImp
+  public ICompressSetCoderProperties,
+  public ICompressSetBufSize,
+  public CMyUnknownImp,
+  public CBaseCoder
 {
-  Byte *_buffer;
-  bool Create();
-
-  COutBuffer _mainStream;
-  COutBuffer _callStream;
-  COutBuffer _jumpStream;
-  NCompress::NRangeCoder::CEncoder _rangeEncoder;
-  NCompress::NRangeCoder::CBitEncoder<kNumMoveBits> _statusEncoder[256 + 2];
+  UInt32 _relatLim;
 
-  HRESULT Flush();
-public:
-  void ReleaseStreams()
-  {
-    _mainStream.ReleaseStream();
-    _callStream.ReleaseStream();
-    _jumpStream.ReleaseStream();
-    _rangeEncoder.ReleaseStream();
-  }
-
-  class CCoderReleaser
-  {
-    CEncoder *_coder;
-  public:
-    CCoderReleaser(CEncoder *coder): _coder(coder) {}
-    ~CCoderReleaser() {  _coder->ReleaseStreams(); }
-  };
+  HRESULT CodeReal(ISequentialInStream * const *inStreams, const UInt64 * const *inSizes, UInt32 numInStreams,
+      ISequentialOutStream * const *outStreams, const UInt64 * const *outSizes, UInt32 numOutStreams,
+      ICompressProgressInfo *progress);
 
 public:
-  MY_UNKNOWN_IMP
+  MY_UNKNOWN_IMP3(ICompressCoder2, ICompressSetCoderProperties, ICompressSetBufSize)
 
-  HRESULT CodeReal(ISequentialInStream **inStreams, const UInt64 **inSizes, UInt32 numInStreams,
-      ISequentialOutStream **outStreams, const UInt64 **outSizes, UInt32 numOutStreams,
-      ICompressProgressInfo *progress);
-  STDMETHOD(Code)(ISequentialInStream **inStreams, const UInt64 **inSizes, UInt32 numInStreams,
-      ISequentialOutStream **outStreams, const UInt64 **outSizes, UInt32 numOutStreams,
+  STDMETHOD(Code)(ISequentialInStream * const *inStreams, const UInt64 * const *inSizes, UInt32 numInStreams,
+      ISequentialOutStream * const *outStreams, const UInt64 * const *outSizes, UInt32 numOutStreams,
       ICompressProgressInfo *progress);
-  CEncoder(): _buffer(0) {};
+
+  STDMETHOD(SetCoderProperties)(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps);
+  
+  STDMETHOD(SetInBufSize)(UInt32 streamIndex, UInt32 size);
+  STDMETHOD(SetOutBufSize)(UInt32 streamIndex, UInt32 size);
+  
+  CEncoder();
   ~CEncoder();
 };
 
@@ -64,49 +61,54 @@ public:
 
 class CDecoder:
   public ICompressCoder2,
+  public ICompressSetFinishMode,
+  public ICompressSetInStream2,
+  public ISequentialInStream,
+  public ICompressSetOutStreamSize,
   public ICompressSetBufSize,
-  public CMyUnknownImp
+  public CMyUnknownImp,
+  public CBaseCoder
 {
-  CInBuffer _mainInStream;
-  CInBuffer _callStream;
-  CInBuffer _jumpStream;
-  NCompress::NRangeCoder::CDecoder _rangeDecoder;
-  NCompress::NRangeCoder::CBitDecoder<kNumMoveBits> _statusDecoder[256 + 2];
+  unsigned _extraReadSizes[BCJ2_NUM_STREAMS];
+  UInt64 _inStreamsProcessed[BCJ2_NUM_STREAMS];
+  HRESULT _readRes[BCJ2_NUM_STREAMS];
+  CMyComPtr<ISequentialInStream> _inStreams[BCJ2_NUM_STREAMS];
+
+  bool _finishMode;
+  bool _outSizeDefined;
+  UInt64 _outSize;
+  UInt64 _outSize_Processed;
+  CBcj2Dec dec;
+
+  void InitCommon();
+  // HRESULT ReadSpec();
+  
+public:
+  MY_UNKNOWN_IMP6(
+    ICompressCoder2,
+    ICompressSetFinishMode,
+    ICompressSetInStream2,
+    ISequentialInStream,
+    ICompressSetOutStreamSize,
+    ICompressSetBufSize
+    );
+  
+  STDMETHOD(Code)(ISequentialInStream * const *inStreams, const UInt64 * const *inSizes, UInt32 numInStreams,
+      ISequentialOutStream * const *outStreams, const UInt64 * const *outSizes, UInt32 numOutStreams,
+      ICompressProgressInfo *progress);
 
-  COutBuffer _outStream;
-  UInt32 _inBufSizes[4];
-  UInt32 _outBufSize;
+  STDMETHOD(SetFinishMode)(UInt32 finishMode);
 
-public:
-  void ReleaseStreams()
-  {
-    _mainInStream.ReleaseStream();
-    _callStream.ReleaseStream();
-    _jumpStream.ReleaseStream();
-    _rangeDecoder.ReleaseStream();
-    _outStream.ReleaseStream();
-  }
-
-  HRESULT Flush() { return _outStream.Flush(); }
-  class CCoderReleaser
-  {
-    CDecoder *_coder;
-  public:
-    CCoderReleaser(CDecoder *coder): _coder(coder) {}
-    ~CCoderReleaser()  { _coder->ReleaseStreams(); }
-  };
+  STDMETHOD(SetInStream2)(UInt32 streamIndex, ISequentialInStream *inStream);
+  STDMETHOD(ReleaseInStream2)(UInt32 streamIndex);
 
-public:
-  MY_UNKNOWN_IMP1(ICompressSetBufSize);
-  HRESULT CodeReal(ISequentialInStream **inStreams, const UInt64 **inSizes, UInt32 numInStreams,
-      ISequentialOutStream **outStreams, const UInt64 **outSizes, UInt32 numOutStreams,
-      ICompressProgressInfo *progress);
-  STDMETHOD(Code)(ISequentialInStream **inStreams, const UInt64 **inSizes, UInt32 numInStreams,
-      ISequentialOutStream **outStreams, const UInt64 **outSizes, UInt32 numOutStreams,
-      ICompressProgressInfo *progress);
+  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
+
+  STDMETHOD(SetOutStreamSize)(const UInt64 *outSize);
 
   STDMETHOD(SetInBufSize)(UInt32 streamIndex, UInt32 size);
   STDMETHOD(SetOutBufSize)(UInt32 streamIndex, UInt32 size);
+
   CDecoder();
 };
 

data/ext/p7zip/CPP/7zip/Compress/Bcj2Register.cpp

@@ -6,14 +6,19 @@
 
 #include "Bcj2Coder.h"
 
-static void *CreateCodec() { return (void *)(ICompressCoder2 *)(new NCompress::NBcj2::CDecoder()); }
+namespace NCompress {
+namespace NBcj2 {
+
+REGISTER_CODEC_CREATE_2(CreateCodec, CDecoder(), ICompressCoder2)
 #ifndef EXTRACT_ONLY
-static void *CreateCodecOut() { return (void *)(ICompressCoder2 *)(new NCompress::NBcj2::CEncoder());  }
+REGISTER_CODEC_CREATE_2(CreateCodecOut, CEncoder(), ICompressCoder2)
 #else
-#define CreateCodecOut 0
+#define CreateCodecOut NULL
 #endif
 
-static CCodecInfo g_CodecInfo =
-  { CreateCodec, CreateCodecOut, 0x0303011B, L"BCJ2", 4, false };
+REGISTER_CODEC_VAR
+  { CreateCodec, CreateCodecOut, 0x303011B, "BCJ2", 4, false };
 
 REGISTER_CODEC(BCJ2)
+
+}}

data/ext/p7zip/CPP/7zip/Compress/BcjCoder.cpp

@@ -4,12 +4,21 @@
 
 #include "BcjCoder.h"
 
-UInt32 CBCJ_x86_Encoder::SubFilter(Byte *data, UInt32 size)
+namespace NCompress {
+namespace NBcj {
+
+STDMETHODIMP CCoder::Init()
 {
-  return (UInt32)::x86_Convert(data, size, _bufferPos, &_prevMask, 1);
+  _bufferPos = 0;
+  x86_Convert_Init(_prevMask);
+  return S_OK;
 }
 
-UInt32 CBCJ_x86_Decoder::SubFilter(Byte *data, UInt32 size)
+STDMETHODIMP_(UInt32) CCoder::Filter(Byte *data, UInt32 size)
 {
-  return (UInt32)::x86_Convert(data, size, _bufferPos, &_prevMask, 0);
+  UInt32 processed = (UInt32)::x86_Convert(data, size, _bufferPos, &_prevMask, _encode);
+  _bufferPos += processed;
+  return processed;
 }
+
+}}

data/ext/p7zip/CPP/7zip/Compress/BcjCoder.h

@@ -5,15 +5,27 @@
 
 #include "../../../C/Bra.h"
 
-#include "BranchCoder.h"
+#include "../../Common/MyCom.h"
 
-struct CBranch86
+#include "../ICoder.h"
+
+namespace NCompress {
+namespace NBcj {
+
+class CCoder:
+  public ICompressFilter,
+  public CMyUnknownImp
 {
+  UInt32 _bufferPos;
   UInt32 _prevMask;
-  void x86Init() { x86_Convert_Init(_prevMask); }
+  int _encode;
+public:
+  MY_UNKNOWN_IMP1(ICompressFilter);
+  INTERFACE_ICompressFilter(;)
+
+  CCoder(int encode): _bufferPos(0), _encode(encode) { x86_Convert_Init(_prevMask); }
 };
 
-MyClassB(BCJ_x86, 0x01, 3, CBranch86 ,
-    virtual void SubInit() { x86Init(); })
+}}
 
 #endif

data/ext/p7zip/CPP/7zip/Compress/BcjRegister.cpp

@@ -6,14 +6,12 @@
 
 #include "BcjCoder.h"
 
-static void *CreateCodec() { return (void *)(ICompressFilter *)(new CBCJ_x86_Decoder()); }
-#ifndef EXTRACT_ONLY
-static void *CreateCodecOut() { return (void *)(ICompressFilter *)(new CBCJ_x86_Encoder());  }
-#else
-#define CreateCodecOut 0
-#endif
+namespace NCompress {
+namespace NBcj {
 
-static CCodecInfo g_CodecInfo =
-  { CreateCodec, CreateCodecOut, 0x03030103, L"BCJ", 1, true };
+REGISTER_FILTER_E(BCJ,
+    CCoder(false),
+    CCoder(true),
+    0x3030103, "BCJ")
 
-REGISTER_CODEC(BCJ)
+}}

data/ext/p7zip/CPP/7zip/Compress/BitlDecoder.cpp

@@ -12,9 +12,9 @@ struct CInverterTableInitializer
 {
   CInverterTableInitializer()
   {
-    for (int i = 0; i < 256; i++)
+    for (unsigned i = 0; i < 256; i++)
     {
-      int x = ((i & 0x55) << 1) | ((i & 0xAA) >> 1);
+      unsigned x = ((i & 0x55) << 1) | ((i & 0xAA) >> 1);
       x = ((x & 0x33) << 2) | ((x & 0xCC) >> 2);
       kInvertTable[i] = (Byte)(((x & 0x0F) << 4) | ((x & 0xF0) >> 4));
     }

data/ext/p7zip/CPP/7zip/Compress/BitlDecoder.h

@@ -9,130 +9,127 @@ namespace NBitl {
 
 const unsigned kNumBigValueBits = 8 * 4;
 const unsigned kNumValueBytes = 3;
-const unsigned kNumValueBits = 8  * kNumValueBytes;
+const unsigned kNumValueBits = 8 * kNumValueBytes;
 
 const UInt32 kMask = (1 << kNumValueBits) - 1;
 
 extern Byte kInvertTable[256];
 
+/* TInByte must support "Extra Bytes" (bytes that can be read after the end of stream
+   TInByte::ReadByte() returns 0xFF after the end of stream
+   TInByte::NumExtraBytes contains the number "Extra Bytes"
+       
+   Bitl decoder can read up to 4 bytes ahead to internal buffer. */
+
 template<class TInByte>
 class CBaseDecoder
 {
 protected:
-  unsigned m_BitPos;
-  UInt32 m_Value;
-  TInByte m_Stream;
+  unsigned _bitPos;
+  UInt32 _value;
+  TInByte _stream;
 public:
-  UInt32 NumExtraBytes;
-  bool Create(UInt32 bufferSize) { return m_Stream.Create(bufferSize); }
-  void SetStream(ISequentialInStream *inStream) { m_Stream.SetStream(inStream); }
-  void ReleaseStream() { m_Stream.ReleaseStream(); }
+  bool Create(UInt32 bufSize) { return _stream.Create(bufSize); }
+  void SetStream(ISequentialInStream *inStream) { _stream.SetStream(inStream); }
   void Init()
   {
-    m_Stream.Init();
-    m_BitPos = kNumBigValueBits;
-    m_Value = 0;
-    NumExtraBytes = 0;
+    _stream.Init();
+    _bitPos = kNumBigValueBits;
+    _value = 0;
   }
-  UInt64 GetProcessedSize() const { return m_Stream.GetProcessedSize() + NumExtraBytes - (kNumBigValueBits - m_BitPos) / 8; }
+
+  UInt64 GetStreamSize() const { return _stream.GetStreamSize(); }
+  UInt64 GetProcessedSize() const { return _stream.GetProcessedSize() - ((kNumBigValueBits - _bitPos) >> 3); }
+
+  bool ThereAreDataInBitsBuffer() const { return this->_bitPos != kNumBigValueBits; }
 
   void Normalize()
   {
-    for (; m_BitPos >= 8; m_BitPos -= 8)
-    {
-      Byte b = 0;
-      if (!m_Stream.ReadByte(b))
-      {
-        b = 0xFF; // check it
-        NumExtraBytes++;
-      }
-      m_Value = (b << (kNumBigValueBits - m_BitPos)) | m_Value;
-    }
+    for (; _bitPos >= 8; _bitPos -= 8)
+      _value = ((UInt32)_stream.ReadByte() << (kNumBigValueBits - _bitPos)) | _value;
   }
   
   UInt32 ReadBits(unsigned numBits)
   {
     Normalize();
-    UInt32 res = m_Value & ((1 << numBits) - 1);
-    m_BitPos += numBits;
-    m_Value >>= numBits;
+    UInt32 res = _value & ((1 << numBits) - 1);
+    _bitPos += numBits;
+    _value >>= numBits;
     return res;
   }
 
   bool ExtraBitsWereRead() const
   {
-    if (NumExtraBytes == 0)
-      return false;
-    return ((UInt32)(kNumBigValueBits - m_BitPos) < (NumExtraBytes << 3));
+    return (_stream.NumExtraBytes > 4 || kNumBigValueBits - _bitPos < (_stream.NumExtraBytes << 3));
+  }
+  
+  bool ExtraBitsWereRead_Fast() const
+  {
+    // full version is not inlined in vc6.
+    // return _stream.NumExtraBytes != 0 && (_stream.NumExtraBytes > 4 || kNumBigValueBits - _bitPos < (_stream.NumExtraBytes << 3));
+    
+    // (_stream.NumExtraBytes > 4) is fast overread detection. It's possible that
+    // it doesn't return true, if small number of extra bits were read.
+    return (_stream.NumExtraBytes > 4);
   }
+
+  // it must be fixed !!! with extra bits
+  // UInt32 GetNumExtraBytes() const { return _stream.NumExtraBytes; }
 };
 
 template<class TInByte>
 class CDecoder: public CBaseDecoder<TInByte>
 {
-  UInt32 m_NormalValue;
+  UInt32 _normalValue;
 
 public:
   void Init()
   {
     CBaseDecoder<TInByte>::Init();
-    m_NormalValue = 0;
+    _normalValue = 0;
   }
 
   void Normalize()
   {
-    for (; this->m_BitPos >= 8; this->m_BitPos -= 8)
+    for (; this->_bitPos >= 8; this->_bitPos -= 8)
     {
-      Byte b = 0;
-      if (!this->m_Stream.ReadByte(b))
-      {
-        b = 0xFF; // check it
-        this->NumExtraBytes++;
-      }
-      m_NormalValue = (b << (kNumBigValueBits - this->m_BitPos)) | m_NormalValue;
-      this->m_Value = (this->m_Value << 8) | kInvertTable[b];
+      Byte b = this->_stream.ReadByte();
+      _normalValue = ((UInt32)b << (kNumBigValueBits - this->_bitPos)) | _normalValue;
+      this->_value = (this->_value << 8) | kInvertTable[b];
     }
   }
   
   UInt32 GetValue(unsigned numBits)
   {
     Normalize();
-    return ((this->m_Value >> (8 - this->m_BitPos)) & kMask) >> (kNumValueBits - numBits);
+    return ((this->_value >> (8 - this->_bitPos)) & kMask) >> (kNumValueBits - numBits);
   }
 
   void MovePos(unsigned numBits)
   {
-    this->m_BitPos += numBits;
-    m_NormalValue >>= numBits;
+    this->_bitPos += numBits;
+    _normalValue >>= numBits;
   }
   
   UInt32 ReadBits(unsigned numBits)
   {
     Normalize();
-    UInt32 res = m_NormalValue & ((1 << numBits) - 1);
+    UInt32 res = _normalValue & ((1 << numBits) - 1);
     MovePos(numBits);
     return res;
   }
 
-  void AlignToByte() { MovePos((32 - this->m_BitPos) & 7); }
+  void AlignToByte() { MovePos((32 - this->_bitPos) & 7); }
 
-  Byte ReadByte()
+  Byte ReadDirectByte() { return this->_stream.ReadByte(); }
+
+  Byte ReadAlignedByte()
   {
-    if (this->m_BitPos == kNumBigValueBits)
-    {
-      Byte b = 0;
-      if (!this->m_Stream.ReadByte(b))
-      {
-        b = 0xFF;
-        this->NumExtraBytes++;
-      }
-      return b;
-    }
-    {
-      Byte b = (Byte)(m_NormalValue & 0xFF);
-      MovePos(8);
-      return b;
-    }
+    if (this->_bitPos == kNumBigValueBits)
+      return this->_stream.ReadByte();
+    Byte b = (Byte)(_normalValue & 0xFF);
+    MovePos(8);
+    return b;
   }
 };
 

data/ext/p7zip/CPP/7zip/Compress/BitlEncoder.h

@@ -7,51 +7,50 @@
 
 class CBitlEncoder
 {
-  COutBuffer m_Stream;
-  unsigned m_BitPos;
-  Byte m_CurByte;
+  COutBuffer _stream;
+  unsigned _bitPos;
+  Byte _curByte;
 public:
-  bool Create(UInt32 bufferSize) { return m_Stream.Create(bufferSize); }
-  void SetStream(ISequentialOutStream *outStream) { m_Stream.SetStream(outStream); }
-  void ReleaseStream() { m_Stream.ReleaseStream(); }
-  UInt32 GetBitPosition() const { return (8 - m_BitPos); }
-  UInt64 GetProcessedSize() const { return m_Stream.GetProcessedSize() + (8 - m_BitPos + 7) /8; }
+  bool Create(UInt32 bufSize) { return _stream.Create(bufSize); }
+  void SetStream(ISequentialOutStream *outStream) { _stream.SetStream(outStream); }
+  // unsigned GetBitPosition() const { return (8 - _bitPos); }
+  UInt64 GetProcessedSize() const { return _stream.GetProcessedSize() + ((8 - _bitPos + 7) >> 3); }
   void Init()
   {
-    m_Stream.Init();
-    m_BitPos = 8;
-    m_CurByte = 0;
+    _stream.Init();
+    _bitPos = 8;
+    _curByte = 0;
   }
   HRESULT Flush()
   {
     FlushByte();
-    return m_Stream.Flush();
+    return _stream.Flush();
   }
   void FlushByte()
   {
-    if (m_BitPos < 8)
-      m_Stream.WriteByte(m_CurByte);
-    m_BitPos = 8;
-    m_CurByte = 0;
+    if (_bitPos < 8)
+      _stream.WriteByte(_curByte);
+    _bitPos = 8;
+    _curByte = 0;
   }
   void WriteBits(UInt32 value, unsigned numBits)
   {
     while (numBits > 0)
     {
-      if (numBits < m_BitPos)
+      if (numBits < _bitPos)
       {
-        m_CurByte |= (value & ((1 << numBits) - 1)) << (8 - m_BitPos);
-        m_BitPos -= numBits;
+        _curByte |= (value & ((1 << numBits) - 1)) << (8 - _bitPos);
+        _bitPos -= numBits;
         return;
       }
-      numBits -= m_BitPos;
-      m_Stream.WriteByte((Byte)(m_CurByte | (value << (8 - m_BitPos))));
-      value >>= m_BitPos;
-      m_BitPos = 8;
-      m_CurByte = 0;
+      numBits -= _bitPos;
+      _stream.WriteByte((Byte)(_curByte | (value << (8 - _bitPos))));
+      value >>= _bitPos;
+      _bitPos = 8;
+      _curByte = 0;
     }
   }
-  void WriteByte(Byte b) { m_Stream.WriteByte(b);}
+  void WriteByte(Byte b) { _stream.WriteByte(b);}
 };
 
 #endif

data/ext/p7zip/CPP/7zip/Compress/BitmDecoder.h

@@ -9,45 +9,59 @@ namespace NBitm {
 
 const unsigned kNumBigValueBits = 8 * 4;
 const unsigned kNumValueBytes = 3;
-const unsigned kNumValueBits = 8  * kNumValueBytes;
+const unsigned kNumValueBits = 8 * kNumValueBytes;
 
 const UInt32 kMask = (1 << kNumValueBits) - 1;
 
+// _bitPos - the number of free bits (high bits in _value)
+// (kNumBigValueBits - _bitPos) = (32 - _bitPos) == the number of ready to read bits (low bits of _value)
+
 template<class TInByte>
 class CDecoder
 {
-  unsigned m_BitPos;
-  UInt32 m_Value;
+  unsigned _bitPos;
+  UInt32 _value;
+  TInByte _stream;
 public:
-  TInByte m_Stream;
-  bool Create(UInt32 bufferSize) { return m_Stream.Create(bufferSize); }
-  void SetStream(ISequentialInStream *inStream) { m_Stream.SetStream(inStream);}
-  void ReleaseStream() { m_Stream.ReleaseStream();}
+  bool Create(UInt32 bufSize) { return _stream.Create(bufSize); }
+  void SetStream(ISequentialInStream *inStream) { _stream.SetStream(inStream);}
 
   void Init()
   {
-    m_Stream.Init();
-    m_BitPos = kNumBigValueBits;
+    _stream.Init();
+    _bitPos = kNumBigValueBits;
+    _value = 0;
     Normalize();
   }
   
-  UInt64 GetProcessedSize() const { return m_Stream.GetProcessedSize() - (kNumBigValueBits - m_BitPos) / 8; }
-  
+  UInt64 GetStreamSize() const { return _stream.GetStreamSize(); }
+  UInt64 GetProcessedSize() const { return _stream.GetProcessedSize() - ((kNumBigValueBits - _bitPos) >> 3); }
+
+  bool ExtraBitsWereRead() const
+  {
+    return (_stream.NumExtraBytes > 4 || kNumBigValueBits - _bitPos < (_stream.NumExtraBytes << 3));
+  }
+
+  bool ExtraBitsWereRead_Fast() const
+  {
+    return (_stream.NumExtraBytes > 4);
+  }
+
   void Normalize()
   {
-    for (;m_BitPos >= 8; m_BitPos -= 8)
-      m_Value = (m_Value << 8) | m_Stream.ReadByte();
+    for (; _bitPos >= 8; _bitPos -= 8)
+      _value = (_value << 8) | _stream.ReadByte();
   }
 
   UInt32 GetValue(unsigned numBits) const
   {
-    // return (m_Value << m_BitPos) >> (kNumBigValueBits - numBits);
-    return ((m_Value >> (8 - m_BitPos)) & kMask) >> (kNumValueBits - numBits);
+    // return (_value << _bitPos) >> (kNumBigValueBits - numBits);
+    return ((_value >> (8 - _bitPos)) & kMask) >> (kNumValueBits - numBits);
   }
   
   void MovePos(unsigned numBits)
   {
-    m_BitPos += numBits;
+    _bitPos += numBits;
     Normalize();
   }
   
@@ -58,7 +72,22 @@ public:
     return res;
   }
 
-  void AlignToByte() { MovePos((32 - m_BitPos) & 7); }
+  /*
+  unsigned ReadBit()
+  {
+    UInt32 res = ((_value >> (8 - _bitPos)) & kMask) >> (kNumValueBits - 1);
+    if (++_bitPos >= 8)
+    {
+      _value = (_value << 8) | _stream.ReadByte();
+      _bitPos -= 8;
+    }
+    return (unsigned)res;
+  }
+  */
+
+  void AlignToByte() { MovePos((kNumBigValueBits - _bitPos) & 7); }
+
+  UInt32 ReadAlignBits() { return ReadBits((kNumBigValueBits - _bitPos) & 7); }
 };
 
 }