//+---------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1991 - 2000.
//
//  File:       BITSTM.cxx
//
//  Contents:   'Bit Stream'
//
//  Classes:    CBitBuffer
//
//  Classes:    CBitStream, CWBitStream, CRBitStream
//
//  History:    03-Jul-91       KyleP           Created
//              24-Aug-92       BartoszM        Rewrote it
//
//----------------------------------------------------------------------------

#include <pch.cxx>
#pragma hdrstop

#pragma optimize( "t", on )

#include "bitstm.hxx"

//+---------------------------------------------------------------------------
//
//  Member:     CSmartBuffer::CSmartBuffer, public
//
//  Synopsis:   Constructor.
//
//  Arguments:  [phStorage] -- Physical index -- source of pages
//              [mode]      -- Access mode for the index
//
//  History:    02-Sep-92       BartoszM        Created
//
//----------------------------------------------------------------------------

CSmartBuffer::CSmartBuffer ( CPhysStorage& phStorage, EAccessMode mode )
        : _phStorage(phStorage),
          _pBuffer(0),
          _fWritable( mode == eWriteExisting )
{
}


//+---------------------------------------------------------------------------
//
//  Member:     CSmartBuffer::CSmartBuffer, public
//
//  Synopsis:   Constructor.
//
//  Arguments:  [phStorage] -- Physical index -- source of pages
//              [fCreate]   -- Indicates if new buffer is needed
//
//  History:    02-Sep-92       BartoszM        Created
//
//----------------------------------------------------------------------------

CSmartBuffer::CSmartBuffer ( CPhysStorage& phStorage, BOOL fCreate )
        : _phStorage(phStorage),
          _numPage(0),
          _fWritable(fCreate)
{
    if (fCreate)
    {
        _pBuffer  = _phStorage.BorrowNewBuffer(0);

        IncrementSig();

        #if CIDBG == 1
        CheckCorruption();
        #endif
    }
    else
    {
        _pBuffer  = _phStorage.BorrowBuffer( 0, _fWritable, _fWritable );

        CheckCorruption();
    }
}

//+---------------------------------------------------------------------------
//
//  Member:     CSmartBuffer::CSmartBuffer, public
//
//  Synopsis:   Constructor.
//
//  Arguments:  [phStorage] -- Physical index -- source of pages
//              [numPage]   -- Page to encapsulate
//              [mode]      -- Access mode for the index
//              [fIncrSig]  -- Indicates if page should be signed
//
//  History:    02-Sep-92       BartoszM        Created
//
//----------------------------------------------------------------------------

CSmartBuffer::CSmartBuffer ( CPhysStorage& phStorage,
                             ULONG numPage,
                             EAccessMode mode,
                             BOOL fIncrSig )
        : _phStorage(phStorage),
          _numPage(numPage),
          _fWritable(mode == eWriteExisting)
{
    _pBuffer = _phStorage.BorrowBuffer( _numPage, _fWritable, _fWritable );

    if ( _fWritable && fIncrSig )
        IncrementSig();

    if (fIncrSig)
        CheckCorruption();
}

//+---------------------------------------------------------------------------
//
//  Member:     CSmartBuffer::CSmartBuffer, public
//
//  Synopsis:   Constructor.
//
//  Arguments:  [buf] -- Source CSmartBuffer
//              [numPage]      -- Page to acquire
//
//  History:    02-Sep-92       BartoszM        Created
//
//----------------------------------------------------------------------------

CSmartBuffer::CSmartBuffer ( CSmartBuffer& buf, ULONG numPage )
        : _phStorage(buf._phStorage),
          _numPage(numPage),
          _fWritable(buf._fWritable)
{
    _pBuffer = _phStorage.BorrowBuffer( _numPage, _fWritable, _fWritable );

    if ( _fWritable )
        IncrementSig();

    CheckCorruption();
}


//+---------------------------------------------------------------------------
//
//  Member:     CSmartBuffer::~CSmartBuffer, public
//
//  Synopsis:   Destructor.
//
//  History:    02-Sep-92       BartoszM        Created
//
//----------------------------------------------------------------------------

CSmartBuffer::~CSmartBuffer ()
{
    if ( 0 != _pBuffer )
    {
        // If a writable buffer still exists in this destructor we're in a
        // failure path that must not THROW.  Anything that really needs to
        // be on disk should already be there by now, so this code path
        // won't throw if it can't flush.
        //
        // If you see this debugout and you're not unwinding an exception,
        // your code is broken.
        // If a merge fails and you get this debugout, it's not a problem
        //

        if ( _fWritable && _phStorage.RequiresFlush( _numPage ) )
        {
            IncrementSig();
            ciDebugOut(( DEB_WARN, "deleting writable buffer in potential "
                         "unwind path -- it may not get flushed\n" ));
        }

        _phStorage.ReturnBuffer( _numPage, _fWritable, FALSE );
    }
}

//+---------------------------------------------------------------------------
//
//  Member:     CSmartBuffer::CheckCorruption, private
//
//  Synopsis:   Attempts to determine if the entire page wasn't written
//              to disk.
//
//  History:    ?       KyleP        Created
//
//----------------------------------------------------------------------------

void CSmartBuffer::CheckCorruption()
{
    if ( 0 == _pBuffer[0] ||
         _pBuffer[0] != _pBuffer[SMARTBUF_PAGE_SIZE_IN_DWORDS + 1] )
    {
        ciDebugOut(( DEB_ERROR, "Buffer at 0x%x corrupt (StartDword = 0x%x, EndDword = 0x%x)\n",
                     _pBuffer, _pBuffer[0], _pBuffer[SMARTBUF_PAGE_SIZE_IN_DWORDS + 1] ));

        Win4Assert( !"Index corruption." );

        _phStorage.GetStorage().ReportCorruptComponent( ( 0 == _pBuffer[0] ) ?
                                                        L"SmartBuffer1" :
                                                        L"SmartBuffer2");
        THROW( CException( CI_CORRUPT_DATABASE ) );
    }
}

//+---------------------------------------------------------------------------
//
//  Member:     CSmartBuffer::IncrementSig, private
//
//  Synopsis:   Increments the signature at the start and end of the page.
//
//  History:    ?       KyleP        Created
//
//----------------------------------------------------------------------------

void CSmartBuffer::IncrementSig()
{
    Win4Assert( _pBuffer[0] == _pBuffer[SMARTBUF_PAGE_SIZE_IN_DWORDS + 1] );

    _pBuffer[0]++;
    _pBuffer[SMARTBUF_PAGE_SIZE_IN_DWORDS + 1]++;
}

//+---------------------------------------------------------------------------
//
//  Member:     CSmartBuffer::InitSignature, public
//
//  Synopsis:   Initializes the signature at the start and end of the page.
//
//  History:    ?       KyleP        Created
//
//----------------------------------------------------------------------------

void CSmartBuffer::InitSignature()
{
    _pBuffer[0] = _pBuffer[SMARTBUF_PAGE_SIZE_IN_DWORDS + 1] = 1;
}


//+---------------------------------------------------------------------------
//
//  Member:     CSmartBuffer::Refill, public
//
//  Synopsis:   Makes sure the given page is borrowed and ready to go
//
//  Arguments:  [numPage]  -- The page requested
//
//  History:    11/6/98   dlee      Added Header
//
//----------------------------------------------------------------------------

void CSmartBuffer::Refill( ULONG numPage )
{
    if ( 0 != _pBuffer &&
         _fWritable &&
         _phStorage.RequiresFlush( _numPage ) )
    {
        IncrementSig();
    }

    // first borrow next, then return previous to avoid reloading

    ULONG * pOld = _pBuffer;
    unsigned numOldPage = _numPage;
    _pBuffer = _phStorage.BorrowBuffer( numPage, _fWritable, _fWritable );
    _numPage = numPage;

    if ( 0 != pOld )
        _phStorage.ReturnBuffer( numOldPage, _fWritable );

    Win4Assert( 0 != _pBuffer );

    // increment signature

    if ( _fWritable )
        IncrementSig();

    CheckCorruption();
}

//+---------------------------------------------------------------------------
//
//  Member:     CSmartBuffer::Next, public
//
//  Synopsis:   Makes sure the next page is borrowed and ready to go
//
//  History:    11/6/98   dlee      Added Header
//
//----------------------------------------------------------------------------

ULONG* CSmartBuffer::Next()
{
    Win4Assert( 0 != _pBuffer );

    if ( 0 != _pBuffer &&
         _fWritable &&
         _phStorage.RequiresFlush( _numPage ) )
        IncrementSig();

    ULONG * pOld = _pBuffer;

    // first borrow next, then return previous to avoid reloading

    _pBuffer = _phStorage.BorrowBuffer( _numPage+1, _fWritable, _fWritable );
    _numPage++;

    if ( 0 != pOld )
        _phStorage.ReturnBuffer( _numPage-1, _fWritable );

    Win4Assert( 0 != _pBuffer );

    if ( _fWritable )
        IncrementSig();

    CheckCorruption();

    return _pBuffer + 1;
}

//+---------------------------------------------------------------------------
//
//  Member:     CSmartBuffer::NextNew, public
//
//  Synopsis:   Makes sure the next page is borrowed and ready to go
//
//  History:    11/6/98   dlee      Added Header
//
//----------------------------------------------------------------------------

ULONG* CSmartBuffer::NextNew()
{
    Win4Assert( 0 != _pBuffer );

    if ( _fWritable && _phStorage.RequiresFlush( _numPage ) )
        IncrementSig();

    // first borrow next, then return previous to avoid reloading

    _pBuffer = _phStorage.BorrowNewBuffer(_numPage+1);
    _numPage++;
    Win4Assert ( _pBuffer != 0 );
    _phStorage.ReturnBuffer( _numPage-1, _fWritable );

    if ( _fWritable )
        IncrementSig();

    #if CIDBG == 1
    CheckCorruption();
    #endif

    return _pBuffer + 1;
}

//+---------------------------------------------------------------------------
//
//  Member:     CSmartBuffer::Free, public
//
//  Synopsis:   Frees the current page if and only if the underlying storage
//              is writable.  Useful for master merges where we want to
//              unmap the old master index so it can be made sparse.
//
//  History:    11/6/98   dlee      Added Header
//
//----------------------------------------------------------------------------

void CSmartBuffer::Free()
{
    //
    // Only free the buffer if the stream (not necessarily the buffer)
    // is writable, so the stream can be shrunk from the front during a
    // master merge.
    //

    Win4Assert( _phStorage.IsWritable() );

    if ( 0 != _pBuffer )
    {
        if ( _fWritable && _phStorage.RequiresFlush( _numPage ) )
            IncrementSig();

        _phStorage.ReturnBuffer( _numPage, _fWritable );
        _pBuffer = 0;
    }
}

//+---------------------------------------------------------------------------
//
//  Member:     CBitStream::CBitStream, public
//
//  Synopsis:   Constructor. Does not load pages.
//
//  Arguments:  [physIndex] -- Physical index -- source of pages
//
//  History:    02-Sep-92       BartoszM        Created
//
//----------------------------------------------------------------------------
CBitStream::CBitStream(CPhysStorage& phStorage, CSmartBuffer::EAccessMode mode )
        : _buffer(phStorage, mode),
          _oBuffer( 0 )
{
}

//+---------------------------------------------------------------------------
//
//  Member:     CPBitStream::CPBitStream, public
//
//  Synopsis:   Constructor. Does not load any pages.
//
//  Arguments:  [physIndex] -- Physical index -- source of pages
//
//  History:    02-Sep-92       BartoszM        Created
//
//----------------------------------------------------------------------------

CPBitStream::CPBitStream(CPhysStorage& phStorage)
: CBitStream ( phStorage, CSmartBuffer::eWriteExisting )

{
    _bitOff.SetPage(0);
    _bitOff.SetOff(0);
    ciDebugOut (( DEB_BITSTM, "CPBitStream::CPBitStream\n" ));
}

//+---------------------------------------------------------------------------
//
//  Member:     CBitStream::CBitStream, public
//
//  Synopsis:   Constructor. Starts at the beginning of index
//
//  Arguments:  [physIndex] -- Physical index -- source of pages
//
//  History:    08-Jul-91   KyleP       Created.
//
//----------------------------------------------------------------------------

CBitStream::CBitStream(CPhysStorage& phStorage, BOOL fCreate)
        : _buffer(phStorage, fCreate),
          _oBuffer( 0 )

{
    ciDebugOut (( DEB_BITSTM, "CBitStream::CBitStream\n" ));

    _pCurPos = _buffer.Get();
    _pEndBuf = _pCurPos + SMARTBUF_PAGE_SIZE_IN_DWORDS;
    _cbitLeftDW = ULONG_BITS;
}

//+---------------------------------------------------------------------------
//
//  Member:     CBitStream::CBitStream, public
//
//  Synopsis:   Constructor.  Seek to a specified position.
//
//  Arguments:  [physIndex] -- Physical index -- source of pages
//              [off]  -- starting bit offset
//              [mode] -- Check access mode
//              [fIncrSig] -- Indicates if signature has to be incremented.
//
//  History:    08-Jul-91   KyleP       Created.
//
//----------------------------------------------------------------------------

CBitStream::CBitStream(CPhysStorage& phStorage,
                       const BitOffset& off,
                       CSmartBuffer::EAccessMode mode,
                       BOOL fIncrSig )
        : _buffer(phStorage, off.Page(), mode, fIncrSig),
          _oBuffer( 0 )

{
    ciDebugOut(( DEB_BITSTM, "CBitStream::CBitStream %d:%d\n",
                 off.Page(), off.Offset() ));
    SetPosition(off.Offset());
}

//+---------------------------------------------------------------------------
//
//  Member:     CBitStream::LoadNextPage, private
//
//  Synopsis:   Loads next page, positions stream at its beginning
//
//  Requires:   Page must already exits
//
//  History:    28-Aug-92   BartoszM    Created.
//
//----------------------------------------------------------------------------

void CBitStream::LoadNextPage()
{
    _pCurPos = _buffer.Next();
    _pEndBuf = _pCurPos + SMARTBUF_PAGE_SIZE_IN_DWORDS;
    _cbitLeftDW = ULONG_BITS;
}

//+---------------------------------------------------------------------------
//
//  Member:     CBitStream::LoadNewPage, private
//
//  Synopsis:   Creates and loads new page following the current one
//              Positions stream at its beginning
//
//  History:    28-Aug-92   BartoszM    Created.
//
//  Notice:     Page should be zero filled
//
//----------------------------------------------------------------------------

void CBitStream::LoadNewPage()
{
    _pCurPos = _buffer.NextNew();
    _pEndBuf = _pCurPos + SMARTBUF_PAGE_SIZE_IN_DWORDS;
    _cbitLeftDW = ULONG_BITS;

#if CIDBG == 1
    ULONG* p = _buffer.Get();
    for (int i=0; i < SMARTBUF_PAGE_SIZE_IN_DWORDS; i++)
        if (p[i] != 0)
            break;
    Win4Assert(i == SMARTBUF_PAGE_SIZE_IN_DWORDS);
#endif
}

//+---------------------------------------------------------------------------
//
//  Function:   Refill
//
//  Synopsis:   Invalidates the currently cached copy and gets a new
//              copy of the buffer. This is needed during master merge
//              because we unmap the buffer before flushing and it is
//              possible that the re-mapped buffer may be in a physically
//              different location.
//
//  History:    4-20-94   srikants   Created
//
//  Notes:
//
//----------------------------------------------------------------------------

void CBitStream::Refill()
{
    BitOffset bitOff;
    GetOffset(bitOff);

    _buffer.Refill(bitOff.Page());
    SetPosition( bitOff.Offset() );
}

//+---------------------------------------------------------------------------
//
//  Member:     CBitStream::SetPosition, private
//
//  Synopsis:   Set bit position within a freshly loaded page
//
//  Arguments:  [off] -- number of bits to skip
//
//  History:    28-Aug-92   BartoszM    Created.
//
//----------------------------------------------------------------------------

void CBitStream::SetPosition(ULONG off)
{
    Win4Assert( off < SMARTBUF_PAGE_SIZE_IN_BITS );

    Win4Assert( !_buffer.isEmpty() );

    //ciDebugOut (( DEB_BITSTM, "SetPosition %d\n", off ));
    _pCurPos = _buffer.Get() + off / ULONG_BITS;
    _pEndBuf = _buffer.Get() + SMARTBUF_PAGE_SIZE_IN_DWORDS;
    _cbitLeftDW = ULONG_BITS - ( off - ULONG_BITS * ( off / ULONG_BITS ) );

    Win4Assert ( Position() == off );
}

//+---------------------------------------------------------------------------
//
//  Member:     CBitStream::CBitStream, public
//
//  Synopsis:   Copy Constructor (with pb as a clone of _pBuffer).
//
//  Arguments:  [pb] -- Pointer to memory for buffer.
//
//              [orig] -- Original CBitStream to be copied.
//
//  History:    13-Jan-92   AmyA        Created.
//
//----------------------------------------------------------------------------

CBitStream::CBitStream(CBitStream & orig)
      : _buffer(orig._buffer, orig._buffer.PageNum()),
        _cbitLeftDW(orig._cbitLeftDW),
        _oBuffer( 0 )

{
    _pCurPos = _buffer.Get() + ( orig._pCurPos - orig._buffer.Get() );
    _pEndBuf = _buffer.Get() + SMARTBUF_PAGE_SIZE_IN_DWORDS;
}

//+---------------------------------------------------------------------------
//
//  Member:     CPBitStream::OverwriteBits, public
//
//  Synopsis:   Store bits in the buffer. This call doesn't affect
//              surrounding bits.
//
//  Effects:    OR the [cb] low bits in [ul] beginning at the 'bit-cursor'
//
//  Arguments:  [ul] -- A DWord containing data to store.
//
//              [cb] -- The number of bits to store.
//
//  History:    18-Jul-91   KyleP       Created.
//              02-Sep-92   BartoszM    Rewrote for lazy paging
//
//  Notes:      Bits are stored 'big-endian'.
//
//----------------------------------------------------------------------------

void CPBitStream::OverwriteBits(ULONG ul, unsigned cb)
{
    ciDebugOut (( DEB_BITSTM , "OverwriteBits %d\n", cb ));
    Win4Assert(cb != 0 && cb <= ULONG_BITS);

    // Fault in the page if necessary
    if ( _buffer.isEmpty() || _buffer.PageNum() != _bitOff.Page())
    {
        _buffer.Refill(_bitOff.Page());
    }

    SetPosition(_bitOff.Offset());

    //
    // The easy case is the one where all the data fits in the current dword
    //

    if (cb <= _cbitLeftDW)
    {
        // this much will be left after current write
        _cbitLeftDW -= cb;

        // zero out a segment within current dword
        // first create a mask of cb bits by (ULONG_BITS - cb) shift right
        // then shift this mask left by the number of bits to be left

        *_pCurPos &= ~((0xFFFFFFFF >> (ULONG_BITS - cb)) << _cbitLeftDW);

        // shift ul left by the number of bits to be left
        *_pCurPos |= (ul << _cbitLeftDW);

        // prepare for the next write
        _bitOff += cb;

        Win4Assert( _bitOff.Offset() < SMARTBUF_PAGE_SIZE_IN_BITS );
    }
    else
    {
        IOverwriteBits( ul, cb );
    }
}

//+---------------------------------------------------------------------------
//
//  Member:     CWBitStream::IPutBits, private
//
//  Synopsis:   Store bits in the buffer. Internal version for multi-dword
//              case.
//
//  Effects:    Store the [cb] low bits in [ul] beginning at the 'bit-cursor'
//
//  Arguments:  [ul] -- A DWord containing data to store.
//
//              [cb] -- The number of bits to store.
//
//  History:    08-Jul-91   KyleP       Created.
//
//  Notes:      Bits are stored 'big-endian'.
//
//----------------------------------------------------------------------------

void CWBitStream::IPutBits(ULONG ul, unsigned cb)
{
    Win4Assert ( cb > _cbitLeftDW );

//    ciDebugOut (( DEB_BITSTM, "IPutBits %d\n", cb ));
    if ( _cbitLeftDW != 0 )
    {
        Win4Assert ( _pCurPos < EndBuf() );
        //
        // Save the high portion in the current dword and save the
        // number of unwritten bits in cb
        //

        cb -= _cbitLeftDW;
        *_pCurPos |= (ul >> cb);
    }

    //
    // Increment to the next dword
    //

    NextDword();

    //
    // Store the remainder
    //

    _cbitLeftDW -= cb;
    *_pCurPos = ul << _cbitLeftDW;
}

//+---------------------------------------------------------------------------
//
//  Member:     CWBitStream::ZeroToEndOfPage, public
//
//  Synopsis:   Writes zeros from the current bit offset to ther end of the
//              page.
//
//  History:    22-Apr-94   DwightKr    Created.
//
//  Notes:      Bits are stored 'big-endian'.
//
//----------------------------------------------------------------------------
void CWBitStream::ZeroToEndOfPage()
{
    ULONG * pCurPos = _pCurPos;

    if ( (_cbitLeftDW != 0) && (_cbitLeftDW != 32) )
    {
        *pCurPos &= (0xFFFFFFFF << _cbitLeftDW);
         pCurPos++;
    }

    RtlZeroMemory( pCurPos, (EndBuf() - pCurPos) * sizeof(ULONG));
}

void CWBitStream::InitSignature()
{
    _buffer.InitSignature();
}

//+---------------------------------------------------------------------------
//
//  Member:     CPBitStream::IOverwriteBits, private
//
//  Synopsis:   Store bits in the buffer. This call doesn't affect
//              surrounding bits.
//
//  Effects:    OR the [cb] low bits in [ul] beginning at the 'bit-cursor'
//
//  Arguments:  [ul] -- A DWord containing data to store.
//
//              [cb] -- The number of bits to store.
//
//  History:    18-Jul-91   KyleP       Created.
//
//  Notes:      Bits are stored 'big-endian'.
//
//----------------------------------------------------------------------------

void CPBitStream::IOverwriteBits(ULONG ul, unsigned cb)
{
    Win4Assert ( cb > _cbitLeftDW );

    // prepare for next write
    _bitOff += cb;

    Win4Assert( _bitOff.Offset() < SMARTBUF_PAGE_SIZE_IN_BITS );

    if ( _cbitLeftDW > 0 )
    {
        Win4Assert ( _pCurPos < EndBuf() );
        // zero the remaining bits in the current dword
        *_pCurPos &= 0xFFFFFFFF << _cbitLeftDW;
        // this much will go to the next dword
        cb -= _cbitLeftDW;
        // shift away the part that goes to the next dword
        // and or in the rest
        *_pCurPos |= (ul >> cb);
    }

    //
    // Increment to the next dword
    //

    NextDword();
    //
    // Store the remainder
    //

    Win4Assert( cb <= ULONG_BITS );

    if ( cb == ULONG_BITS )
    {
        *_pCurPos = ul;
    }
    else
    {
        // zero the cb upper bits of the current dword
        *_pCurPos &= (0xFFFFFFFF >> cb);
        // fill them with cb bits from the bottom of ul
        *_pCurPos |= ul << (ULONG_BITS - cb);
    }
}

const ULONG g_aMasks[33] =
{
    0,
    0x1,
    0x3,
    0x7,
    0xf,
    0x1f,
    0x3f,
    0x7f,
    0xff,
    0x1ff,
    0x3ff,
    0x7ff,
    0xfff,
    0x1fff,
    0x3fff,
    0x7fff,
    0xffff,
    0x1ffff,
    0x3ffff,
    0x7ffff,
    0xfffff,
    0x1fffff,
    0x3fffff,
    0x7fffff,
    0xffffff,
    0x1ffffff,
    0x3ffffff,
    0x7ffffff,
    0xfffffff,
    0x1fffffff,
    0x3fffffff,
    0x7fffffff,
    0xffffffff,
};

//+---------------------------------------------------------------------------
//
//  Member:     CBitStream::IGetBits, public
//
//  Synopsis:   Retrieve bits from the buffer. Internal version for multi-
//              dword case.
//
//  Arguments:  [cb] -- Count of bits to retrieve.
//
//  History:    12-Jul-91   KyleP       Created.
//
//----------------------------------------------------------------------------

ULONG CBitStream::IGetBits(unsigned cb)
{
    Win4Assert ( cb > _cbitLeftDW );

    //ciDebugOut (( DEB_BITSTM, "IGetBits %d\n", cb ));

    //
    // Get the portion from the current DWord
    //

    ULONG ul;

    if ( 0 != _cbitLeftDW )
    {
        const ULONG mask = g_aMasks[ cb ];
        cb -= _cbitLeftDW;
        ul = (*_pCurPos << cb) & mask;
    }
    else
        ul = 0L;

    //
    // And the portion from the next.
    //

    NextDword();

    _cbitLeftDW -= cb;
    return ul | (*_pCurPos >> (ULONG_BITS - cb));
} //IGetBits

//+---------------------------------------------------------------------------
//
//  Member:     CWBitStream::PutBytes, public
//
//  Synopsis:   Store a number of bytes in the buffer.
//
//  Arguments:  [pb] -- Pointer to data to store.
//
//              [cb] -- Number of bytes to store.
//
//  History:    08-Jul-91   KyleP       Created.
//
//----------------------------------------------------------------------------

void CWBitStream::PutBytes(const BYTE * pb, unsigned cb)
{
//    ciDebugOut (( DEB_BITSTM, "IPutBytes %d\n", cb ));

    while (cb > 0)
    {
        PutBits(*pb, 8);
        pb += 1;
        cb--;
    }
}

//+---------------------------------------------------------------------------
//
//  Member:     CBitStream::GetBytes, public
//
//  Synopsis:   Retrieve bytes from the buffer.
//
//  Arguments:  [pb] -- Pointer to area where data is returned.
//
//              [cb] -- Count of bytes to retrieve.
//
//  History:    12-Jul-91   KyleP       Created.
//
//----------------------------------------------------------------------------

void CBitStream::GetBytes(BYTE * pb, unsigned cb)
{
    ciDebugOut (( DEB_BITSTM, "GetBytes %d\n", cb ));

    while (cb > 0)
    {
        *pb = BYTE ( GetBits(8) );
        pb++;
        cb--;
    }
}


//+---------------------------------------------------------------------------
//
//  Member:     CBitStream::Seek, public
//
//  Synopsis:   Seeks to the specified bit offset
//
//  Arguments:  [off] -- bit offset
//
//  History:    28-Aug-92   BartoszM    Created.
//
//----------------------------------------------------------------------------

void CBitStream::Seek ( const BitOffset& off )
{
    ciDebugOut (( DEB_BITSTM , "CBitStream::Seek %d:%d\n",
        off.Page(), off.Offset()  ));

    if (_buffer.PageNum() != off.Page())
    {
        _buffer.Refill(off.Page());
    }

    SetPosition(off.Offset());
}

#if CIDBG == 1

unsigned CBitStream::PeekBit()
{
    if (_cbitLeftDW > 0)
    {
        ULONG ul = *_pCurPos;
        return( ul >> (_cbitLeftDW - 1)) & 1;
    }
    else
    {
        ULONG* pNewPos = _pCurPos + 1;
        if (pNewPos < EndBuf())
        {
            return(*pNewPos >> (ULONG_BITS-1));
        }
        else
        {
            Win4Assert ( 0 && "Untested" );
            CSmartBuffer bufTmp( _buffer, _buffer.PageNum() + 1 );

            ULONG* p = bufTmp.Get();
            unsigned bit = *p >> (ULONG_BITS-1);
            return(bit);
        }
    }
}

unsigned CPBitStream::PeekBit()
{
    // Fault in the page if necessary

    if (_buffer.isEmpty() || _buffer.PageNum() != _bitOff.Page())
        _buffer.Refill(_bitOff.Page());

    SetPosition(_bitOff.Offset());

    return CBitStream::PeekBit();
}

void DumpDword ( ULONG* pul )
{
    ULONG ul = *pul;

    for (int i = ULONG_BITS-1; i >= 0; i--)
    {
        ciDebugOut (( DEB_ITRACE | DEB_NOCOMPNAME,"%0d", (ul >> i) & 1 ));
        if (i %4 == 0)
            ciDebugOut (( DEB_ITRACE | DEB_NOCOMPNAME," " ));
    }
    ciDebugOut (( DEB_ITRACE | DEB_NOCOMPNAME,"\n" ));
}

void CBitStream::Dump()
{
    ciDebugOut (( DEB_ITRACE, "CBitStream:\n"
    "\tpage %d\n"
    "\t_pCurPos 0x%x dwords from beginning\n"
    "\t_cbitLeftDW %d\n",
        _buffer.PageNum(), _pCurPos - _buffer.Get(), _cbitLeftDW ));

    if (_pCurPos > _buffer.Get())
        DumpDword ( _pCurPos - 1 );
    if (_pCurPos < EndBuf())
    {
        DumpDword ( _pCurPos );
        for (unsigned i = 1; i <= ULONG_BITS - _cbitLeftDW; i++ )
        {
            ciDebugOut (( DEB_ITRACE | DEB_NOCOMPNAME," " ));
            if (i %4 == 0)
                ciDebugOut (( DEB_ITRACE | DEB_NOCOMPNAME," " ));
        }
        ciDebugOut (( DEB_ITRACE | DEB_NOCOMPNAME,"^\n" ));
    }
    if (_pCurPos + 1 < EndBuf())
        DumpDword(_pCurPos + 1);
}

void CPBitStream::Dump()
{
    // Fault in the page if necessary
    if (_buffer.isEmpty() || _buffer.PageNum() != _bitOff.Page())
    {
        _buffer.Refill(_bitOff.Page());
    }

    SetPosition(_bitOff.Offset());

    CBitStream::Dump();
}

#endif // CIDBG == 1