builds/digitalwerk/solutions/adtf_content/adtf_base/adtf_core/src/libraries/a_utils/include/a_utils/core/bitserializer.h

Go to the documentation of this file.

 
#include <type_traits>
#include <limits.h>
 
#ifndef _BIT_SERIALIZER_HEADER_
#define _BIT_SERIALIZER_HEADER_
 
namespace A_UTILS_NS
{
    namespace bithelpers 
    {
        tVoid PrintBits(tUInt64 nValue);
 
        tResult ConvertSignalEndianess(tUInt64 *pSignal, tInt nEndianess, tSize nBitLength);
    } // namespace bithelpers
 
    namespace bitconverters
    {
        template<typename T>
        class ConverterBase {
 
        protected:
 
            static tResult ReadSignal(tUInt8 *pBuffer, tSize nStartBit, tSize nBitLength, T* pValue,
                tInt nEndianess = PLATFORM_BYTEORDER)
            {
                /*
                *   nOffsetEnd         nOffsetStart
                *        _                   ____
                *       | |                 |    |
                *  ....|...abcde|fghijklm|no......|.... Buffer (index 0 on the right end side)
                *          |_______________|
                *              nBitLength  ^
                *                          |
                *                          nStartBit
                */
 
                // 1) COPY relevant bytes of Buffer content to result variable.
                tUInt64 nResult = 0; // Result value
                tUInt64 nNinthByte = 0; // variable to eventually store a ninth byte from buffer
                tSize nBytesToRead = 0;
                CopyBytesFromBuffer(pBuffer, &nResult, nStartBit, nBitLength, &nNinthByte, &nBytesToRead);
 
                // 2) TRIM unrelevant bits and SHIFT to align value.
 
                // Number of bits the start position is offset from 0 (0 for aligned signal)
                tSize nOffsetStart = nStartBit % CHAR_BIT;
                // Number of bits the end position is offset from the end of the last byte (0 for complete bytes)
                tSize nOffsetEnd = (CHAR_BIT - ((nStartBit + nBitLength) % CHAR_BIT)) % CHAR_BIT;
 
                /**********************************************************************************************
                *      Distinguish between LE and BE operating systems to get the shift operations right     *
                **********************************************************************************************/
                // On LE System
                if (PLATFORM_BYTEORDER == PLATFORM_LITTLE_ENDIAN_8)
                {
                    /* Use bit mask to remove bits on the higher end, which do not belong to the value to read.
                    *
                    *   ...|...abcde|fghijklm|no......|  =>  000|000abcde|fghijklm|no......|
                    *
                    */
                    CutLeadingBits(&nResult, nBitLength + nOffsetStart);
 
                    /* Shift right to align start at position 0 (also trims the right end).
                    *
                    *   000|000abcde|fghijklm|no......|  =>  000|00000000|0abcdefg|hijklmno|
                    *
                    */
                    nResult >>= nOffsetStart;
 
                    // Eventually get bits from the copied 9th byte.
                    if (nNinthByte > 0) // nothing to take care of if nothing was copied or all copied bits are 0.
                    {
                        // Delete unwanted bits from ninth byte.
                        CutLeadingBits(&nNinthByte, (CHAR_BIT - nOffsetEnd));
                        tSize nBitSize = sizeof(nResult) * CHAR_BIT;
                        // Shift requested bits from the 9th byte into the right position to be combined with nResult.
                        nNinthByte <<= (nBitSize - nOffsetStart);
                        // Merge value together from all nine bytes.
                        nResult = nResult | nNinthByte;
                    }
 
                    // BE Signal needs byte order swapping.
                    if (nEndianess == PLATFORM_BIG_ENDIAN_8)
                    {
                        // Only for reading partial bytes. Filling the missing bits differs from LE Signal.
                        if (nBitLength % CHAR_BIT != 0)
                        {
                            /* Shift left to align end position.
                            *
                            *   000|0abcdefg|hijklmno|  =>  000|abcdefgh|ijklmno0|
                            *
                            */
                            nResult <<= (nOffsetEnd + nOffsetStart) % CHAR_BIT;
 
                            /* Shift bits within MSByte, filling the gap with 0s.
                            *
                            *   000|abcdefgh|ijklmno0|  =>  000|abcdefgh|0ijklmno|
                            *                ^                        ^
                            *              MSByte                   MSByte
                            */
                            tUInt8 *pMSByte = (tUInt8*)&nResult;
                            pMSByte[0] >>= (nOffsetEnd + nOffsetStart) % CHAR_BIT;
                        }
 
                        /* Swap bytes to LE.
                        *
                        *   000|abcdefgh|0ijklmno|  =>  000|0ijklmno|abcdefgh|
                        *
                        */
                        bithelpers::ConvertSignalEndianess(&nResult, nEndianess, nBitLength);
                    }
                }
                // On BE System
                else
                {
                    /* Swap bytes to simulate LE shifting operations.
                    *
                    *   |...abcde|fghijklm|no......|...  =>  ...|no......|fghijklm|...abcde|
                    *
                    */
                    bithelpers::ConvertSignalEndianess(&nResult, PLATFORM_LITTLE_ENDIAN_8, sizeof(nResult) * CHAR_BIT);
 
                    // LE Signal
                    if (nEndianess == PLATFORM_LITTLE_ENDIAN_8)
                    {
                        /* Use bit mask to remove bits on the higher end, which do not belong to the value to read.
                        *
                        *   ...|no......|fghijklm|...abcde|  =>  ...|no......|fghijklm|000abcde|
                        *
                        */
                        CutLeadingBits(&nResult, (sizeof(nResult) * CHAR_BIT) - nOffsetEnd); // Cut away only nOffsetEnd bits.
 
                        /* Shift right to align bits within LSByte (BE Shifting!).
                        *
                        *   ...|no......|fghijklm|000abcde|  =>  ...|hijklmno|0abcdefg|00000000|
                        *
                        */
                        nResult >>= nOffsetStart;
 
                        /* Shift right to align LSByte on the left side (BE Shifting!).
                        *
                        *   ...|hijklmno|0abcdefg|00000000|  =>  |hijklmno|0abcdefg|000
                        *
                        * Shift over all
                        * empty bytes = (all bits - occupied bits (nBitLength) - already shifted bits) / number of bytes
                        */
                        nResult >>= (((sizeof(nResult) * CHAR_BIT) - nBitLength - nOffsetStart) / sizeof(nResult)) * CHAR_BIT;
 
                        // No further byte swap, because there has been one swap before the shift operations already.
                    }
                    // BE Signal
                    else
                    {
                        /* Shift left to align bits within LSByte (now rightmost byte because of byte swap).
                        * Also deletes bits from end offset.
                        *
                        *   ...|no......|fghijklm|...abcde|  =>  ...|........|ijklmno.|abcdefgh|
                        *
                        */
                        nResult <<= nOffsetEnd;
 
                        // Only for reading partial bytes. Filling the missing bits differs from LE Signal.
                        if (nBitLength % CHAR_BIT != 0)
                        {
                            /* Shift bits within MSByte to move 0s to the highest bits (also deleting all unwanted bits from start offset).
                            *
                            *   ...|........|ijklmno.|abcdefgh|  =>  ...|........|0ijklmno|abcdefgh|
                            *
                            */
                            tUInt8 *pMSByte = (tUInt8*)&nResult + (nBitLength / CHAR_BIT); // position of the value's MSByte
                            pMSByte[0] >>= (nOffsetEnd + nOffsetStart) % CHAR_BIT; // amount of unused bits within MSByte
                        }
 
                        /* Swap bytes back to BE
                        *
                        *   ...|........|0ijklmno|abcdefgh|  =>  |abcdefgh|0ijklmno|...
                        *
                        */
                        bithelpers::ConvertSignalEndianess(&nResult, PLATFORM_LITTLE_ENDIAN_8, sizeof(nResult) * CHAR_BIT); // Change the simulated LE value back
 
                        /* Use bit mask to remove bits on the higher end, which do not belong to the value to read.
                        *
                        *   |abcdefgh|0ijklmno|...  =>  |abcdefgh|0ijklmno|000
                        *
                        * Remove everything behind the value length plus the gap within MSByte.
                        */
                        CutLeadingBits(&nResult, nBitLength + (nOffsetEnd + nOffsetStart) % CHAR_BIT);
                    }
                }
 
                // Copy the resulting value to the target variable. No Casting! Data might be lost otherwise. 
                cMemoryBlock::MemCopy(pValue, &nResult, (tSize)(std::min)(sizeof(*pValue), sizeof(nResult)));
 
                RETURN_NOERROR;
            }
 
            static tResult WriteSignal(tUInt8 *pBuffer, tSize nStartBit, tSize nBitLength, T nValue,
                tInt nEndianess = PLATFORM_BYTEORDER)
            {
                // 1) Copy relevant bytes of Buffer content to be overwritten.
                tUInt64 nBufferCopy = 0;
                tUInt64 nNinthByte = 0; // storage variable for the ninth bit from buffer
                tSize nBytesToRead = 0;
                CopyBytesFromBuffer(pBuffer, &nBufferCopy, nStartBit, nBitLength, &nNinthByte, &nBytesToRead);
 
                // 2) Erase Bits from Buffer copy that will be overwritten TODO: BE LE system difference important here?
                // Number of bits the start position is offset from 0
                tSize nOffsetStart = nStartBit % CHAR_BIT;
                // Number of bits the end position is offset from the end of the last byte
                tSize nOffsetEnd = (CHAR_BIT - ((nStartBit + nBitLength) % CHAR_BIT)) % CHAR_BIT;
                tUInt64 nMaskLeft = ~0ULL;
                if ((nBitLength + nOffsetStart) >= (sizeof(nMaskLeft) * CHAR_BIT))
                {
                    nMaskLeft = 0;
                }
                else
                {
                    nMaskLeft = ~0ULL;
                    nMaskLeft <<= (nBitLength + nOffsetStart);
                }
                tUInt64 nMask = ~0ULL;
                nMask <<= nOffsetStart;
                nMask = ~nMask;
                nMask |= nMaskLeft;
 
                nBufferCopy &= nMask;
 
                // 3) Copy nValue to UInt64 variable to work with.
                tUInt64 nSignal;
                cMemoryBlock::MemCopy(&nSignal, &nValue, (tSize)sizeof(nSignal));
 
                // 4) Keep only nLength bits: Remove bits that should not be written to the Buffer.
                CutLeadingBits(&nSignal, nBitLength);
 
                // 5) Shift to align at start bit position. 
                tInt nShiftAmount = (tInt)nOffsetStart; // Initialized to fit LE Signal shift
 
                // BE Signal
                if (nEndianess == PLATFORM_BIG_ENDIAN_8)
                {
                    // Swap bytes
                    bithelpers::ConvertSignalEndianess(&nSignal, nEndianess, nBitLength);
                    // Remove gap for partial bytes within MSByte
                    tUInt8 *pMSByte = (tUInt8*)&nSignal;
                    tInt nMSBShift = (CHAR_BIT - (nBitLength % CHAR_BIT)) % CHAR_BIT;
                    pMSByte[0] <<= nMSBShift;
                    nShiftAmount -= nMSBShift;
                }
 
                // Copy most significant byte to ninth buffer byte before losing bits with the shift.
                if ((nOffsetStart + nBitLength) > (sizeof(nSignal) * CHAR_BIT))
                {
                    tUInt64 nSignalForNinthByte = nSignal;
                    nSignalForNinthByte >>= (sizeof(nSignal) - 1) * CHAR_BIT;
                    nSignalForNinthByte >>= (CHAR_BIT - nOffsetStart); // Only LE Signal
                    tUInt64 nMask = ~0ULL;
                    nMask <<= (CHAR_BIT - nOffsetEnd);
                    nNinthByte &= nMask;
                    nNinthByte |= nSignalForNinthByte;
                }
 
                if (nShiftAmount < 0)
                {
                    nSignal >>= std::abs(nShiftAmount);
                }
                else
                {
                    nSignal <<= nShiftAmount;
                }
 
                // 7) Write bytes with integrated signal back to the buffer. 
                nBufferCopy |= nSignal;
 
                cMemoryBlock::MemCopy(pBuffer + (nStartBit / CHAR_BIT), &nBufferCopy, (std::min)(nBytesToRead, (tSize)sizeof(nSignal)));
 
                // Eventually copy ninth byte back to buffer
                if (nBytesToRead > sizeof(nSignal))
                {
                    cMemoryBlock::MemCopy(pBuffer + (nStartBit / CHAR_BIT) + sizeof(nSignal), &nNinthByte, 1);
                }
 
                RETURN_NOERROR;
            }
 
            static tResult CutLeadingBits(tUInt64 *pValue, tSize nBitLength)
            {
                tSize nBitSize = (sizeof(pValue) * CHAR_BIT);
                if (nBitLength < nBitSize)
                {
                    tUInt64 mask = ~0ULL;
                    mask >>= (nBitSize - nBitLength);
                    *pValue &= mask;
                }
 
                RETURN_NOERROR;
            }
 
            static tResult CopyBytesFromBuffer(tUInt8 *pBuffer, tUInt64 *pValue, tSize nStartBit, tSize nBitLength, tUInt64 *pNinthByte, tSize *pBytesToRead)
            {
                // Byte within the buffer to start reading at
                tSize nStartByte = nStartBit / CHAR_BIT;
 
                // Number of bits to read: signal length + bits to fill in the offset on both sides for unaligned signals
                tSize nBitsToRead = nBitLength + (nStartBit % CHAR_BIT);
                if ((nBitsToRead % CHAR_BIT) > 0)
                {
                    nBitsToRead += (CHAR_BIT - (nBitsToRead % CHAR_BIT));
                }
                // Number of bytes to read from the buffer
                *pBytesToRead = nBitsToRead / CHAR_BIT;
 
                // Copy up to 8 bytes to nResult
                if (*pBytesToRead > (tSize)sizeof(pValue))
                {
                    cMemoryBlock::MemCopy(pValue, pBuffer + nStartByte, (tSize)sizeof(pValue));
                }
                else
                {
                    cMemoryBlock::MemCopy(pValue, pBuffer + nStartByte, *pBytesToRead);
                }
 
                // The max signal size is 8 byte, but if the signal is not aligned, it might spread over 9 bytes.
 
                if (*pBytesToRead > sizeof(*pValue))
                {
                    // Get a copy of the most significant byte, which could not yet be saved to nResult
                    cMemoryBlock::MemCopy(pNinthByte, pBuffer + nStartByte + sizeof(*pValue), 1);
                }
 
                RETURN_NOERROR;
            }
        };
 
        template<typename T, int IS_SIGNED, int IS_FLOATING_POINT> class Converter;
 
        template<typename T>
        class Converter<T, 0, 0> : public ConverterBase<T>
        {
        public:
 
            static tResult Read(tUInt8 *pBuffer, tSize nStartBit, tSize nBitLength, T* pValue,
                tInt nEndianess)
            {
                return ConverterBase<T>::ReadSignal(pBuffer, nStartBit, nBitLength, pValue, nEndianess);
            }
 
            static tResult Write(tUInt8 *pBuffer, tSize nStartBit, tSize nBitLength, T nValue,
                tInt nEndianess)
            {
                return ConverterBase<T>::WriteSignal(pBuffer, nStartBit, nBitLength, nValue, nEndianess);
            }
        };
 
        template<typename T>
        class Converter<T, 1, 0> : public ConverterBase<T>
        {
        public:
 
            static tResult Read(tUInt8 *pBuffer, tSize nStartBit, tSize nBitLength, T* pValue,
                tInt nEndianess)
            {
                RETURN_IF_FAILED(ConverterBase<T>::ReadSignal(pBuffer, nStartBit, nBitLength, pValue, nEndianess));
                // replicate sign bit
                *pValue <<= (sizeof(T) * CHAR_BIT) - nBitLength;
                *pValue >>= (sizeof(T) * CHAR_BIT) - nBitLength;
                RETURN_NOERROR;
            }
 
            static tResult Write(tUInt8 *pBuffer, tSize nStartBit, tSize nBitLength, T nValue,
                tInt nEndianess)
            {
                // Nothing special to take care of for writing signed integers, compared to writing unsigned integers.
                return ConverterBase<T>::WriteSignal(pBuffer, nStartBit, nBitLength, nValue, nEndianess);
            }
        };
 
        template<typename T>
        class Converter<T, 1, 1> : public ConverterBase<T>
        {
 
        public:
 
            static tResult Read(tUInt8 *pBuffer, tSize nStartBit, tSize nBitLength, T* pValue,
                tInt nEndianess)
            {
                // Read only values of size tFloat
                if (sizeof(T) * CHAR_BIT == nBitLength)
                {
                    return ConverterBase<T>::ReadSignal(pBuffer, nStartBit, nBitLength, pValue, nEndianess);
                }
                else
                {
                    return ERR_INVALID_ARG;
                }
            }
 
            static tResult Write(tUInt8 *pBuffer, tSize nStartBit, tSize nBitLength, T nValue,
                tInt nEndianess)
            {
                // Write only values of size tFloat
                if (sizeof(T) * CHAR_BIT == nBitLength)
                {
                    return ConverterBase<T>::WriteSignal(pBuffer, nStartBit, nBitLength, nValue, nEndianess);
                }
                else
                {
                    return ERR_INVALID_ARG;
                }
            }
        };
 
 
    } // namespace bitconverters
 
class cBitSerializer
{
    public:
 
        cBitSerializer(cMemoryBlock* pMemoryBlock) : cBitSerializer()
        {
            m_pBuffer = reinterpret_cast<tUInt8*>(pMemoryBlock->GetPtr());
            m_nBufferBytes = pMemoryBlock->GetSize();
            m_nBufferBits = m_nBufferBytes * CHAR_BIT;;
        }
 
        cBitSerializer(tVoid* pData, tSize nDataSize) : cBitSerializer()
        {
            m_pBuffer = static_cast<tUInt8*>(pData);
            m_nBufferBytes = nDataSize;
            m_nBufferBits = m_nBufferBytes * CHAR_BIT;
        }
 
        cBitSerializer()
        {
            m_pBuffer = nullptr;
            m_nBufferBytes = 0;
            m_nBufferBits = 0;
        }
 
        virtual ~cBitSerializer()
        {
 
        }
 
        template<typename T>
        tResult Read(tSize nStartBit, tSize nBitLength, T* pValue,
            tInt nEndianess = PLATFORM_BYTEORDER)
        {
            // Check if in range
            tResult resultCode = CheckForInvalidArguments(nStartBit, nBitLength, sizeof(T));
            if (resultCode.IsFailed())
            {
                return resultCode;
            }
 
            // Call template function
            bitconverters::Converter<T, std::is_signed<T>::value,
                                        std::is_floating_point<T>::value>
                                        ::Read(m_pBuffer, nStartBit, nBitLength, pValue, nEndianess);
   
            RETURN_NOERROR;
        }
 
        template<typename T>
        tResult Write(tSize nStartBit, tSize nBitLength, T nValue,
            tInt nEndianess = PLATFORM_BYTEORDER)
        {
            // Check if in range
            tResult resultCode = CheckForInvalidArguments(nStartBit, nBitLength, sizeof(T));
            if (resultCode.IsFailed())
            {
                return resultCode;
            }
 
            // Call template function
            bitconverters::Converter<T, std::is_signed<T>::value,
                                        std::is_floating_point<T>::value>
                                        ::Write(m_pBuffer, nStartBit, nBitLength, nValue, nEndianess);
 
            RETURN_NOERROR;
        }
 
 
    private:
        
            tUInt8 *m_pBuffer;         
            tSize m_nBufferBytes;     
            tSize m_nBufferBits;
 
        tResult CheckForInvalidArguments(tSize nStartBit, tSize nBitLength, tSize nSizeVariable)
        {
            RETURN_IF_POINTER_NULL(m_pBuffer);
 
            // Check invalid starting point
            if (nStartBit >= m_nBufferBits)
            {
                RETURN_ERROR(ERR_INVALID_ARG);
            }
 
            // Check out of buffer bounds or length < 1
            if ((nBitLength < 1)
                || (m_nBufferBits < nStartBit + nBitLength))
            {
                RETURN_ERROR(ERR_INVALID_ARG);
            }
 
            // Check variable size
            if (nSizeVariable * CHAR_BIT < nBitLength)
            {
                RETURN_ERROR(ERR_INVALID_ARG);
            }
 
            RETURN_NOERROR;
        }
 
};
 
} //namespace A_UTILS_NS
 
#endif // __BIT_SERIALIZER_HEADER