sbgStreamBufferCommon.h

Go to the documentation of this file.

 
#ifndef SBG_STREAM_BUFFER_COMMON_H
#define SBG_STREAM_BUFFER_COMMON_H
 
#include <sbgCommon.h>
 
//----------------------------------------------------------------------//
//- General definitions                                                -//
//----------------------------------------------------------------------//
 
#if SBG_CONFIG_BIG_ENDIAN == 1
    #define sbgStreamBufferReadUint16       sbgStreamBufferReadUint16BE
    #define sbgStreamBufferReadInt16        sbgStreamBufferReadInt16BE
 
    #define sbgStreamBufferReadUint24       sbgStreamBufferReadUint24BE
    #define sbgStreamBufferReadInt24        sbgStreamBufferReadInt24BE
 
    #define sbgStreamBufferReadUint32       sbgStreamBufferReadUint32BE
    #define sbgStreamBufferReadInt32        sbgStreamBufferReadInt32BE
 
    #define sbgStreamBufferReadUint40       sbgStreamBufferReadUint40BE
    #define sbgStreamBufferReadInt40        sbgStreamBufferReadInt40BE
 
    #define sbgStreamBufferReadUint48       sbgStreamBufferReadUint48BE
    #define sbgStreamBufferReadInt48        sbgStreamBufferReadInt48BE
 
    #define sbgStreamBufferReadUint56       sbgStreamBufferReadUint56BE
    #define sbgStreamBufferReadInt56        sbgStreamBufferReadInt56BE
 
    #define sbgStreamBufferReadUint64       sbgStreamBufferReadUint64BE
    #define sbgStreamBufferReadInt64        sbgStreamBufferReadInt64BE
 
    #define sbgStreamBufferReadSizeT32      sbgStreamBufferReadSizeT32BE
    #define sbgStreamBufferReadSizeT64      sbgStreamBufferReadSizeT64BE
 
    #define sbgStreamBufferReadFloat        sbgStreamBufferReadFloatBE
    #define sbgStreamBufferReadDouble       sbgStreamBufferReadDoubleBE
 
    #define sbgStreamBufferWriteUint16      sbgStreamBufferWriteUint16BE
    #define sbgStreamBufferWriteInt16       sbgStreamBufferWriteInt16BE
 
    #define sbgStreamBufferWriteUint24      sbgStreamBufferWriteUint24BE
    #define sbgStreamBufferWriteInt24       sbgStreamBufferWriteInt24BE
 
    #define sbgStreamBufferWriteUint32      sbgStreamBufferWriteUint32BE
    #define sbgStreamBufferWriteInt32       sbgStreamBufferWriteInt32BE
 
    #define sbgStreamBufferWriteUint64      sbgStreamBufferWriteUint64BE
    #define sbgStreamBufferWriteInt64       sbgStreamBufferWriteInt64BE
 
    #define sbgStreamBufferWriteSizeT32     sbgStreamBufferWriteSizeT32BE
    #define sbgStreamBufferWriteSizeT64     sbgStreamBufferWriteSizeT64BE
 
    #define sbgStreamBufferWriteFloat       sbgStreamBufferWriteFloatBE
    #define sbgStreamBufferWriteDouble      sbgStreamBufferWriteDoubleBE
 
    #define sbgStreamBufferReadString       sbgStreamBufferReadStringBE
    #define sbgStreamBufferWriteString      sbgStreamBufferWriteStringBE
#else
    #define sbgStreamBufferReadUint16       sbgStreamBufferReadUint16LE
    #define sbgStreamBufferReadInt16        sbgStreamBufferReadInt16LE
 
    #define sbgStreamBufferReadUint24       sbgStreamBufferReadUint24LE
    #define sbgStreamBufferReadInt24        sbgStreamBufferReadInt24LE
 
    #define sbgStreamBufferReadUint32       sbgStreamBufferReadUint32LE
    #define sbgStreamBufferReadInt32        sbgStreamBufferReadInt32LE
 
    #define sbgStreamBufferReadUint40       sbgStreamBufferReadUint40LE
    #define sbgStreamBufferReadInt40        sbgStreamBufferReadInt40LE
 
    #define sbgStreamBufferReadUint48       sbgStreamBufferReadUint48LE
    #define sbgStreamBufferReadInt48        sbgStreamBufferReadInt48LE
 
    #define sbgStreamBufferReadUint56       sbgStreamBufferReadUint56LE
    #define sbgStreamBufferReadInt56        sbgStreamBufferReadInt56LE
 
    #define sbgStreamBufferReadUint64       sbgStreamBufferReadUint64LE
    #define sbgStreamBufferReadInt64        sbgStreamBufferReadInt64LE
 
    #define sbgStreamBufferReadSizeT32      sbgStreamBufferReadSizeT32LE
    #define sbgStreamBufferReadSizeT64      sbgStreamBufferReadSizeT64LE
 
    #define sbgStreamBufferReadFloat        sbgStreamBufferReadFloatLE
    #define sbgStreamBufferReadDouble       sbgStreamBufferReadDoubleLE
 
    #define sbgStreamBufferWriteUint16      sbgStreamBufferWriteUint16LE
    #define sbgStreamBufferWriteInt16       sbgStreamBufferWriteInt16LE
 
    #define sbgStreamBufferWriteUint24      sbgStreamBufferWriteUint24LE
    #define sbgStreamBufferWriteInt24       sbgStreamBufferWriteInt24LE
 
    #define sbgStreamBufferWriteUint32      sbgStreamBufferWriteUint32LE
    #define sbgStreamBufferWriteInt32       sbgStreamBufferWriteInt32LE
 
    #define sbgStreamBufferWriteUint64      sbgStreamBufferWriteUint64LE
    #define sbgStreamBufferWriteInt64       sbgStreamBufferWriteInt64LE
 
    #define sbgStreamBufferWriteSizeT32     sbgStreamBufferWriteSizeT32LE
    #define sbgStreamBufferWriteSizeT64     sbgStreamBufferWriteSizeT64LE
 
    #define sbgStreamBufferWriteFloat       sbgStreamBufferWriteFloatLE
    #define sbgStreamBufferWriteDouble      sbgStreamBufferWriteDoubleLE
 
    #define sbgStreamBufferReadString       sbgStreamBufferReadStringLE
    #define sbgStreamBufferWriteString      sbgStreamBufferWriteStringLE
#endif
 
#define sbgStreamBufferReadUint8LE      sbgStreamBufferReadUint8
#define sbgStreamBufferReadInt8LE       sbgStreamBufferReadInt8
#define sbgStreamBufferReadBooleanLE    sbgStreamBufferReadBoolean
#define sbgStreamBufferReadBufferLE     sbgStreamBufferReadBuffer
 
#define sbgStreamBufferWriteUint8LE     sbgStreamBufferWriteUint8
#define sbgStreamBufferWriteInt8LE      sbgStreamBufferWriteInt8
#define sbgStreamBufferWriteBooleanLE   sbgStreamBufferWriteBoolean
#define sbgStreamBufferWriteBufferLE    sbgStreamBufferWriteBuffer
 
#define sbgStreamBufferReadUint8BE      sbgStreamBufferReadUint8
#define sbgStreamBufferReadInt8BE       sbgStreamBufferReadInt8
#define sbgStreamBufferReadBooleanBE    sbgStreamBufferReadBoolean
#define sbgStreamBufferReadBufferBE     sbgStreamBufferReadBuffer
 
#define sbgStreamBufferWriteUint8BE     sbgStreamBufferWriteUint8
#define sbgStreamBufferWriteInt8BE      sbgStreamBufferWriteInt8
#define sbgStreamBufferWriteBooleanBE   sbgStreamBufferWriteBoolean
#define sbgStreamBufferWriteBufferBE    sbgStreamBufferWriteBuffer
 
//----------------------------------------------------------------------//
//- Structure definitions                                              -//
//----------------------------------------------------------------------//
 
typedef enum _SbgSBMode
{
    SB_MODE_READ,                       
    SB_MODE_WRITE                       
} SbgSBMode;
 
typedef enum _SbgSBSeekOrigin
{
    SB_SEEK_SET,                            
    SB_SEEK_CUR_INC,                        
    SB_SEEK_CUR_DEC,                        
    SB_SEEK_END                             
} SbgSBSeekOrigin;
 
typedef struct _SbgStreamBuffer
{
    SbgSBMode            modes;             
    size_t               bufferSize;        
    uint8_t             *pBufferPtr;        
    uint8_t             *pCurrentPtr;       
    SbgErrorCode         errorCode;         
} SbgStreamBuffer;
 
//----------------------------------------------------------------------//
//- Common operations methods                                          -//
//----------------------------------------------------------------------//
 
SBG_INLINE SbgErrorCode sbgStreamBufferInitForWrite(SbgStreamBuffer *pHandle, void *pLinkedBuffer, size_t bufferSize)
{
    assert(pHandle);
    assert(pLinkedBuffer);
 
    //
    // Initialize stream parameters
    //
    pHandle->modes = SB_MODE_WRITE;
    pHandle->bufferSize = bufferSize;
    pHandle->errorCode = SBG_NO_ERROR;
 
    //
    // Initialize the buffer
    //
    pHandle->pBufferPtr = (uint8_t*)pLinkedBuffer;
    pHandle->pCurrentPtr = (uint8_t*)pLinkedBuffer;
 
    //
    // For now, we don't handle any error, maybe we could add checks in debug mode only
    //
    return SBG_NO_ERROR;
}
 
SBG_INLINE SbgErrorCode sbgStreamBufferInitForRead(SbgStreamBuffer *pHandle, const void *pLinkedBuffer, size_t bufferSize)
{
    assert(pHandle);
    assert(pLinkedBuffer);
 
    //
    // Initialize stream parameters
    //
    pHandle->modes = SB_MODE_READ;
    pHandle->bufferSize = bufferSize;
    pHandle->errorCode = SBG_NO_ERROR;
 
    //
    // Initialize the buffer
    //
    pHandle->pBufferPtr = (uint8_t*)pLinkedBuffer;
    pHandle->pCurrentPtr = (uint8_t*)pLinkedBuffer;
 
    //
    // For now, we don't handle any error, maybe we could add checks in debug mode only
    //
    return SBG_NO_ERROR;
}
 
SBG_INLINE SbgErrorCode sbgStreamBufferGetLastError(const SbgStreamBuffer *pHandle)
{
    assert(pHandle);
 
    //
    // Return error code
    //
    return pHandle->errorCode;
}
 
SBG_INLINE void sbgStreamBufferClearLastError(SbgStreamBuffer *pHandle)
{
    assert(pHandle);
 
    //
    // Return error code
    //
    pHandle->errorCode = SBG_NO_ERROR;
}
 
SBG_INLINE size_t sbgStreamBufferGetSize(const SbgStreamBuffer *pHandle)
{
    assert(pHandle);
 
    //
    // Return the linked buffer size
    //
    return pHandle->bufferSize;
}
 
SBG_INLINE size_t sbgStreamBufferGetLength(const SbgStreamBuffer *pHandle)
{
    assert(pHandle);
 
    //
    // Return the number of bytes between the begin of the stream and the current pointer
    //
    return ((size_t)pHandle->pCurrentPtr - (size_t)pHandle->pBufferPtr);
}
 
SBG_INLINE size_t sbgStreamBufferGetSpace(const SbgStreamBuffer *pHandle)
{
    assert(pHandle);
 
    //
    // Return the space left in bytes
    //
    return sbgStreamBufferGetSize(pHandle) - sbgStreamBufferGetLength(pHandle);
}
 
SBG_INLINE SbgErrorCode sbgStreamBufferSeek(SbgStreamBuffer *pHandle, size_t offset, SbgSBSeekOrigin origin)
{
    assert(pHandle);
 
    //
    // Test if we haven't already an error
    //
    if (pHandle->errorCode == SBG_NO_ERROR)
    {
        //
        // According to the origin reference point
        //
        switch (origin)
        {
        case SB_SEEK_SET:
            pHandle->pCurrentPtr = pHandle->pBufferPtr + offset;
            break;
        case SB_SEEK_CUR_INC:
            pHandle->pCurrentPtr += offset;
            break;
        case SB_SEEK_CUR_DEC:
            pHandle->pCurrentPtr -= offset;
            break;
        case SB_SEEK_END:
            pHandle->pCurrentPtr = pHandle->pBufferPtr + (pHandle->bufferSize - offset);
            break;
        default:
            pHandle->errorCode = SBG_INVALID_PARAMETER;
            SBG_LOG_ERROR(pHandle->errorCode, "Invalid origin parameter");
        }
 
        //
        // Make sure that no error has occurred
        //
        if (pHandle->errorCode == SBG_NO_ERROR)
        {
            //
            // Test if the current ptr is still within the buffer bounds
            //
            if (pHandle->pCurrentPtr < pHandle->pBufferPtr)
            {
                //
                // We are before the buffer so clamp to the begining of the buffer and raise an error
                //
                pHandle->pCurrentPtr = pHandle->pBufferPtr;
                pHandle->errorCode = SBG_BUFFER_OVERFLOW;
 
                //
                // Stream buffer underflow
                //
                SBG_LOG_ERROR(pHandle->errorCode, "Trying to seek before the buffer");
            }
            else if (pHandle->pCurrentPtr > pHandle->pBufferPtr + pHandle->bufferSize)
            {
                //
                // We are after the buffer so clamp to the end of the buffer and raise an error
                //
                pHandle->pCurrentPtr = pHandle->pBufferPtr + pHandle->bufferSize;
                pHandle->errorCode = SBG_BUFFER_OVERFLOW;
 
                //
                // Stream buffer overflow
                //
                SBG_LOG_ERROR(pHandle->errorCode, "Trying to seek after the buffer");
            }
        }
    }
 
    return pHandle->errorCode;
}
 
SBG_INLINE size_t sbgStreamBufferTell(const SbgStreamBuffer *pHandle)
{
    assert(pHandle);
 
    return (size_t)pHandle->pCurrentPtr - (size_t)pHandle->pBufferPtr;
}
 
SBG_INLINE void *sbgStreamBufferGetLinkedBuffer(const SbgStreamBuffer *pHandle)
{
    assert(pHandle);
 
    return pHandle->pBufferPtr;
}
 
SBG_INLINE void *sbgStreamBufferGetCursor(const SbgStreamBuffer *pHandle)
{
    assert(pHandle);
 
    return pHandle->pCurrentPtr;
}
 
//----------------------------------------------------------------------//
//- Read operations methods                                            -//
//----------------------------------------------------------------------//
 
SBG_INLINE int8_t sbgStreamBufferReadInt8(SbgStreamBuffer *pHandle)
{
    assert(pHandle);
 
    //
    // Test if we haven't already an error
    //
    if (pHandle->errorCode == SBG_NO_ERROR)
    {
        //
        // Test if we can access this item
        //
        if (sbgStreamBufferGetSpace(pHandle) >= sizeof(int8_t))
        {
            //
            // Read the byte
            //
            return *((int8_t*)(pHandle->pCurrentPtr++));
        }
        else
        {
            //
            // We have a buffer overflow
            //
            pHandle->errorCode = SBG_BUFFER_OVERFLOW;
        }
    }
 
    //
    // If we are here, it means we have an error so return 0
    //
    return 0;
}
 
SBG_INLINE uint8_t sbgStreamBufferReadUint8(SbgStreamBuffer *pHandle)
{
    assert(pHandle);
 
    //
    // Test if we haven't already an error
    //
    if (pHandle->errorCode == SBG_NO_ERROR)
    {
        //
        // Test if we can access this item
        //
        if (sbgStreamBufferGetSpace(pHandle) >= sizeof(uint8_t))
        {
            //
            // Read the byte
            //
            return *((uint8_t*)(pHandle->pCurrentPtr++));
        }
        else
        {
            //
            // We have a buffer overflow
            //
            pHandle->errorCode = SBG_BUFFER_OVERFLOW;
        }
    }
 
    //
    // If we are here, it means we have an error so return 0
    //
    return 0;
}
 
SBG_INLINE bool sbgStreamBufferReadBoolean(SbgStreamBuffer *pHandle)
{
    assert(pHandle);
 
    //
    // Test if we haven't already an error
    //
    if (pHandle->errorCode == SBG_NO_ERROR)
    {
        //
        // Test if we can access this item
        //
        if (sbgStreamBufferGetSpace(pHandle) >= sizeof(uint8_t))
        {
            //
            // Read the byte and check if the value is different than zero or not
            //
            if (*((uint8_t*)(pHandle->pCurrentPtr++)))
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        else
        {
            //
            // We have a buffer overflow
            //
            pHandle->errorCode = SBG_BUFFER_OVERFLOW;
        }
    }
 
    //
    // If we are here, it means we have an error so return false
    //
    return false;
}
 
SBG_INLINE SbgErrorCode sbgStreamBufferReadBuffer(SbgStreamBuffer *pHandle, void *pBuffer, size_t numBytesToRead)
{
    assert(pHandle);
    assert((pBuffer) || (numBytesToRead == 0));
 
    //
    // Test if we haven't already an error
    //
    if (pHandle->errorCode == SBG_NO_ERROR)
    {
        //
        // Test if enough bytes in stream
        //
        if (sbgStreamBufferGetSpace(pHandle) >= numBytesToRead)
        {
            //
            // Copy from the stream buffer to the output buffer
            //
            memcpy(pBuffer, pHandle->pCurrentPtr, numBytesToRead);
 
            //
            // Update the current pointer
            //
            pHandle->pCurrentPtr += numBytesToRead;
        }
        else
        {
            //
            // Not enough data in stream
            //
            pHandle->errorCode = SBG_BUFFER_OVERFLOW;
        }
    }
 
    return pHandle->errorCode;
}
 
//----------------------------------------------------------------------//
//- Write operations methods                                           -//
//----------------------------------------------------------------------//
 
SBG_INLINE SbgErrorCode sbgStreamBufferWriteInt8(SbgStreamBuffer *pHandle, int8_t value)
{
    assert(pHandle);
 
    //
    // Test if we haven't already an error
    //
    if (pHandle->errorCode == SBG_NO_ERROR)
    {
        //
        // Test if we can access this item
        //
        if (sbgStreamBufferGetSpace(pHandle) >= sizeof(int8_t))
        {
            //
            // Write each byte
            //
            *(pHandle->pCurrentPtr++) = (int8_t)(value);
        }
        else
        {
            //
            // We are accessing a data that is outside the stream buffer
            //
            pHandle->errorCode = SBG_BUFFER_OVERFLOW;
        }
    }
 
    return pHandle->errorCode;
}
 
SBG_INLINE SbgErrorCode sbgStreamBufferWriteUint8(SbgStreamBuffer *pHandle, uint8_t value)
{
    assert(pHandle);
 
    //
    // Test if we haven't already an error
    //
    if (pHandle->errorCode == SBG_NO_ERROR)
    {
        //
        // Test if we can access this item
        //
        if (sbgStreamBufferGetSpace(pHandle) >= sizeof(uint8_t))
        {
            //
            // Write each byte
            //
            *(pHandle->pCurrentPtr++) = (uint8_t)(value);
        }
        else
        {
            //
            // We are accessing a data that is outside the stream buffer
            //
            pHandle->errorCode = SBG_BUFFER_OVERFLOW;
        }
    }
 
    return pHandle->errorCode;
}
 
SBG_INLINE SbgErrorCode sbgStreamBufferWriteBoolean(SbgStreamBuffer *pHandle, bool value)
{
    assert(pHandle);
 
    //
    // Test if we haven't already an error
    //
    if (pHandle->errorCode == SBG_NO_ERROR)
    {
        //
        // Test if we can access this item
        //
        if (sbgStreamBufferGetSpace(pHandle) >= sizeof(uint8_t))
        {
            //
            // Write the boolean as an uint8_t value (1 byte)
            //
            if (value)
            {
                *(pHandle->pCurrentPtr++) = 1;
            }
            else
            {
                *(pHandle->pCurrentPtr++) = 0;
            }
        }
        else
        {
            //
            // We are accessing a data that is outside the stream buffer
            //
            pHandle->errorCode = SBG_BUFFER_OVERFLOW;
        }
    }
 
    return pHandle->errorCode;
}
 
SBG_INLINE SbgErrorCode sbgStreamBufferWriteBuffer(SbgStreamBuffer *pHandle, const void *pBuffer, size_t numBytesToWrite)
{
    assert(pHandle);
    assert((pBuffer) || (numBytesToWrite == 0));
 
    //
    // Test if we haven't already an error
    //
    if (pHandle->errorCode == SBG_NO_ERROR)
    {
        //
        // Test if we can access this item
        //
        if (sbgStreamBufferGetSpace(pHandle) >= numBytesToWrite)
        {
            //
            // Copy from the stream buffer to the output buffer
            //
            memcpy(pHandle->pCurrentPtr, pBuffer, numBytesToWrite);
 
            //
            // Update the current pointer
            //
            pHandle->pCurrentPtr += numBytesToWrite;
        }
        else
        {
            //
            // We are accessing a data that is outside the stream buffer
            //
            pHandle->errorCode = SBG_BUFFER_OVERFLOW;
        }
    }
 
    return pHandle->errorCode;
}
 
#endif // SBG_STREAM_BUFFER_COMMON_H