bitbuffer.cpp

// #################################################################################################
//  ALib C++ Library
//
//  Copyright 2013-2025 A-Worx GmbH, Germany
//  Published under 'Boost Software License' (a free software license, see LICENSE.txt)
// #################################################################################################
#include "alib_precompile.hpp"
#if !defined(ALIB_C20_MODULES) || ((ALIB_C20_MODULES != 0) && (ALIB_C20_MODULES != 1))
#   error "Symbol ALIB_C20_MODULES has to be given to the compiler as either 0 or 1"
#endif
#if ALIB_C20_MODULES
    module;
#endif
// ======================================   Global Fragment   ======================================
#include "alib/bitbuffer/bitbuffer.prepro.hpp"
 
// ===========================================   Module   ==========================================
#if ALIB_C20_MODULES
    module ALib.BitBuffer;
#else
#   include "ALib.BitBuffer.H"
#endif
// ======================================   Implementation   =======================================
namespace alib {
 
//==================================================================================================
/// This \alibmod implements a buffer that is write- and readable bit by bit.
/// Conversion for standard numerical types is provided. Furthermore several array compression
/// algorithms are given, which allow the bit buffers to be compressed before transported or
/// stored.
///
/// Please consult the little quick
/// \ref alib_mod_bitbuffer "ALib Module BitBuffer - Programmer's Manual" for further information.
//==================================================================================================
namespace bitbuffer {
 
BitBufferBase::Index BitBufferBase::Terminate( Index idx )
{
    // write termination bit
    {
        BitWriter bw(*this, idx);
        bw.Write<1>(1);
        idx= bw.GetIndex();
    }// <bw.Flush
 
    // fast forward to next word
    if(idx.bit)
    {
        idx.pos++;
        idx.bit= 0;
    }
    return idx;
}
 
BitBufferBase::Index BitBufferBase::Unterminate(Index terminationIndex )
{
    ALIB_ASSERT_ERROR(   terminationIndex.pos > 0
                      && terminationIndex.bit == 0
                      && data[terminationIndex.pos - 1] != 0,
                      "BITBUFFER", "Given index is no termination index" )
 
    // go back to previous word...
    terminationIndex.pos--;
    TStorage word= GetWord(terminationIndex);
 
    //...search and delete MSB
    terminationIndex.bit= lang::MSB(word );
    terminationIndex.bit--;
    word^= BitBuffer::TStorage(1) << terminationIndex.bit;
 
    // store word and return new reduced index
    SetWord(terminationIndex, word );
    return terminationIndex;
}
 
#if !DOXYGEN
// anonymous check if this platform has little endian encoding
// already (done once). If so, this method does nothing.
namespace
{
    static int                      isLittleEndianEncoding= 0;
    static BitBufferBase::TStorage  testWord;
    bool IsLittleEndianEncoding()
    {
        if( isLittleEndianEncoding == 0 )
        {
            ALIB_STATIC_ASSERT( Sizeof_int_must_be_16_32_or_64,
                                   bitsof(BitBufferBase::TStorage) == 16
                                || bitsof(BitBufferBase::TStorage) == 32
                                || bitsof(BitBufferBase::TStorage) == 64,
                               "Platform not supported")
 
            isLittleEndianEncoding= 2;
            if constexpr ( bitsof(BitBufferBase::TStorage) == 16 )
            {
                testWord= 0x2211;
                uint8_t* bytes= reinterpret_cast<uint8_t*>( &testWord );
                if( *bytes == 0x11 && *(bytes+1) == 0x22)
                    isLittleEndianEncoding= 1;
            }
 
            else if constexpr ( bitsof(BitBufferBase::TStorage) == 32 )
            {
                testWord= 0x44332211;
                uint8_t* bytes= reinterpret_cast<uint8_t*>( &testWord );
                if(    * bytes    == 0x11 && *(bytes+1) == 0x22
                    && *(bytes+2) == 0x33 && *(bytes+3) == 0x44 )
                    isLittleEndianEncoding= 1;
            }
 
            else if constexpr ( bitsof(BitBufferBase::TStorage) == 64 )
            {
                ALIB_WARNINGS_IGNORE_INTEGRAL_CONSTANT_OVERFLOW
                testWord= 0x8877665544332211u;
                uint8_t* bytes= reinterpret_cast<uint8_t*>( &testWord );
                if(    * bytes    == 0x11 && *(bytes+1) == 0x22
                    && *(bytes+2) == 0x33 && *(bytes+3) == 0x44
                    && *(bytes+4) == 0x55 && *(bytes+5) == 0x66
                    && *(bytes+6) == 0x77 && *(bytes+7) == 0x88 )
                    isLittleEndianEncoding= 1;
                ALIB_WARNINGS_RESTORE
 
            }
        }
 
        return (isLittleEndianEncoding == 1);
    }
}
#endif
 
void  BitBufferBase::ToLittleEndianEncoding( const Index& startIndex, const Index& endIndex )
{
    ALIB_ASSERT_ERROR( startIndex.IsAligned(), "BITBUFFER",
        "Given start index is not algined. The easiest way to get an aligned "
        "index is to terminate the buffer." )
 
    if( IsLittleEndianEncoding())
        return;
 
    const size_t end=   endIndex.pos + (endIndex.bit != 0 );
    for (size_t  pos= startIndex.pos; pos < end; ++pos)
    {
        TStorage   word = data[pos];
        uint8_t*   bytes= reinterpret_cast<uint8_t*>( &data[pos] );
                   bytes[0]= word & 0xFF;
        word>>= 8; bytes[1]= word & 0xFF;
 
        if constexpr ( bitsof(TStorage) > 16 )
        {
            word>>= 8; bytes[2]= word & 0xFF;
            word>>= 8; bytes[3]= word & 0xFF;
        }
 
        if constexpr ( bitsof(TStorage) > 32 )
        {
            word>>= 8; bytes[4]= word & 0xFF;
            word>>= 8; bytes[5]= word & 0xFF;
            word>>= 8; bytes[6]= word & 0xFF;
            word>>= 8; bytes[7]= word & 0xFF;
        }
    }
}
 
void  BitBufferBase::FromLittleEndianEncoding( const Index& startIndex, const Index& endIndex )
{
    if( IsLittleEndianEncoding())
        return;
 
    size_t end= endIndex.pos + (endIndex.bit != 0 );
    for (size_t pos= startIndex.pos; pos < end; ++pos)
    {
        TStorage word = 0;
        uint8_t* bytes= reinterpret_cast<uint8_t*>( &data[pos] );
        word|=  TStorage(bytes[0]);
        word|=  TStorage(bytes[1]) << 8;
 
        if constexpr ( bitsof(TStorage) > 16 )
        {
            word|=  TStorage(bytes[2]) << 16;
            word|=  TStorage(bytes[3]) << 24;
        }
 
        if constexpr ( bitsof(TStorage) > 32 )
        {
            ALIB_WARNINGS_IGNORE_INTEGER_OVERFLOW
            word|=  TStorage(bytes[4]) << 32;
            word|=  TStorage(bytes[5]) << 40;
            word|=  TStorage(bytes[6]) << 48;
            word|=  TStorage(bytes[7]) << 56;
            ALIB_WARNINGS_RESTORE
        }
 
        data[pos]= word;
    }
}
 
 
 
// write 8-bit values
void BitWriter::writeUIntegral(uint8_t val)
{
    if( val < (1<<3) )
    {
        Write<4>( val << 1); // | 0
        return;
    }
 
    Write<9>( (val << 1) |1 ) ;
}
 
// write  16-bit values
void BitWriter::writeUIntegral(uint16_t val)
{
    if( val < (1<<8) )
    {
        Write<9>( val << 1);
        return;
    }
 
    Write<17>( ( val << 1 ) | 1 ) ;
}
 
// write  32-bit byte values
void BitWriter::writeUIntegral(uint32_t val)
{
         if( val < (1<< 8) )       { Write<10>(  val << 2       );  }
    else if( val < (1<<16) )       { Write<18>(( val << 2) | 1u );  }
    else if( val < (1<<24) )       { Write<26>(( val << 2) | 2u );  }
    else                           { Write< 2>(  3 );
                                     Write<32>( val );  }
}
 
// write  64-bit byte values
void BitWriter::writeUIntegral(uint64_t val)
{
         if( val < uint64_t(1) <<  8 )    { Write<11>(   int16_t  (val) << 3        );  }
    else if( val < uint64_t(1) << 16 )    { Write<19>( ( uint32_t (val) << 3 )  | 1u);  }
    else if( val < uint64_t(1) << 24 )    { Write<27>( ( uint32_t (val) << 3 )  | 2u);  }
    else if( val < uint64_t(1) << 32 )    { Write<35>( (           val  << 3 )  | 3u);  }
    else if( val < uint64_t(1) << 40 )    { Write<43>( (           val  << 3 )  | 4u);  }
    else if( val < uint64_t(1) << 48 )    { Write<51>( (           val  << 3 )  | 5u);  }
    else if( val < uint64_t(1) << 56 )    { Write<59>( (           val  << 3 )  | 6u);  }
    else                                  { Write< 3>(             7                );
                                            Write<64>(             val              );  }
}
 
 
// read 8-bit values
uint8_t BitReader::readUIntegral8()
{
    auto result= Read<4>();
    if( !(result & 1))
        return uint8_t(result >> 1);
 
    return    uint8_t(    result >> 1
                        | Read<5>() << 3  );
}
 
uint16_t BitReader::readUIntegral16()
{
    auto result= Read< 9>();
    if( !(result & 1))
        return uint16_t(result >> 1);
 
    return    uint16_t(   result    >> 1
                        | Read<8>() << 8 );
}
 
uint32_t BitReader::readUIntegral32()
{
    uint32_t result= Read< 10, uint32_t>();
    switch (result & 3)
    {
        case 0: return uint32_t(result >> 2);
        case 1: return uint32_t(result >> 2  | (Read<  8, uint32_t>() << 8 ) );
        case 2: return uint32_t(result >> 2  | (Read< 16, uint32_t>() << 8 ) );
       default: return uint32_t(result >> 2  | (Read< 24, uint32_t>() << 8 ) );
    }
}
 
uint64_t BitReader::readUIntegral64()
{
    uint64_t result= Read< 11, uint64_t>();
    switch (result & 7)
    {
        case 0: return uint64_t(result >> 3);
        case 1: return uint64_t(result >> 3 |  (Read<  8, uint64_t>() << 8 ));
        case 2: return uint64_t(result >> 3 |  (Read< 16, uint64_t>() << 8 ));
        case 3: return uint64_t(result >> 3 |  (Read< 24, uint64_t>() << 8 ));
        case 4: return uint64_t(result >> 3 |  (Read< 32, uint64_t>() << 8 ));
        case 5: return uint64_t(result >> 3 |  (Read< 40, uint64_t>() << 8 ));
        case 6: return uint64_t(result >> 3 |  (Read< 48, uint64_t>() << 8 ));
       default: return uint64_t(result >> 3 |  (Read< 56, uint64_t>() << 8 ));
    }
}
 
}} // namespace [alib::bitbuffer]