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 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
#else

        #define sbgStreamBufferReadUint16               sbgStreamBufferReadUint16LE
        #define sbgStreamBufferReadInt16                sbgStreamBufferReadInt16LE
        #define sbgStreamBufferReadUint24               sbgStreamBufferReadUint24LE
        #define sbgStreamBufferReadInt24                sbgStreamBufferReadInt24LE
        #define sbgStreamBufferReadUint32               sbgStreamBufferReadUint32LE
        #define sbgStreamBufferReadInt32                sbgStreamBufferReadInt32LE
        #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
#endif

#define sbgStreamBufferReadUint8LE              sbgStreamBufferReadUint8
#define sbgStreamBufferReadInt8LE               sbgStreamBufferReadInt8
#define sbgStreamBufferReadBufferLE             sbgStreamBufferReadBuffer

#define sbgStreamBufferWriteUint8LE             sbgStreamBufferWriteUint8
#define sbgStreamBufferWriteInt8LE              sbgStreamBufferWriteInt8
#define sbgStreamBufferWriteBufferLE    sbgStreamBufferWriteBuffer

#define sbgStreamBufferReadUint8BE              sbgStreamBufferReadUint8
#define sbgStreamBufferReadInt8BE               sbgStreamBufferReadInt8
#define sbgStreamBufferReadBufferBE             sbgStreamBufferReadBuffer

#define sbgStreamBufferWriteUint8BE             sbgStreamBufferWriteUint8
#define sbgStreamBufferWriteInt8BE              sbgStreamBufferWriteInt8
#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                           *pBufferPtr;            
        uint8                           *pCurrentPtr;           
        SbgErrorCode             errorCode;                     
} SbgStreamBuffer;

//----------------------------------------------------------------------//
//- Common operations methods                                          -//
//----------------------------------------------------------------------//

SBG_INLINE SbgErrorCode sbgStreamBufferInitForWrite(SbgStreamBuffer *pHandle, void *pLinkedBuffer, size_t bufferSize)
{
        //
        // Check input parameters
        //
        SBG_ASSERT(pHandle);
        SBG_ASSERT(pLinkedBuffer);
        SBG_ASSERT(bufferSize > 0);
        
        //
        // Initialize stream parameters
        //
        pHandle->modes = SB_MODE_WRITE;
        pHandle->bufferSize = bufferSize;
        pHandle->errorCode = SBG_NO_ERROR;

        //
        // Initialize the buffer
        //
        pHandle->pBufferPtr = (uint8*)pLinkedBuffer;
        pHandle->pCurrentPtr = (uint8*)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)
{
        //
        // Check input parameters
        //
        SBG_ASSERT(pHandle);
        SBG_ASSERT(pLinkedBuffer);
        SBG_ASSERT(bufferSize > 0);

        //
        // Initialize stream parameters
        //
        pHandle->modes = SB_MODE_READ;
        pHandle->bufferSize = bufferSize;
        pHandle->errorCode = SBG_NO_ERROR;

        //
        // Initialize the buffer
        //
        pHandle->pBufferPtr = (uint8*)pLinkedBuffer;
        pHandle->pCurrentPtr = (uint8*)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(SbgStreamBuffer *pHandle)
{
        //
        // Check input parameters
        //
        SBG_ASSERT(pHandle);

        //
        // Return error code
        //
        return pHandle->errorCode;
}

SBG_INLINE void sbgStreamBufferClearLastError(SbgStreamBuffer *pHandle)
{
        //
        // Check input parameters
        //
        SBG_ASSERT(pHandle);

        //
        // Return error code
        //
        pHandle->errorCode = SBG_NO_ERROR;
}

SBG_INLINE size_t sbgStreamBufferGetSize(SbgStreamBuffer *pHandle)
{
        //
        // Check input parameters
        //
        SBG_ASSERT(pHandle);

        //
        // Return the linked buffer size
        //
        return pHandle->bufferSize;
}

SBG_INLINE size_t sbgStreamBufferGetLength(SbgStreamBuffer *pHandle)
{
        //
        // Check input parameters
        //
        SBG_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(SbgStreamBuffer *pHandle)
{
        //
        // Check input parameters
        //
        SBG_ASSERT(pHandle);

        //
        // Return the space left in bytes
        //
        return sbgStreamBufferGetSize(pHandle) - sbgStreamBufferGetLength(pHandle);
}

SBG_INLINE SbgErrorCode sbgStreamBufferSeek(SbgStreamBuffer *pHandle, size_t offset, SbgSBSeekOrigin origin)
{
        //
        // Check input parameters
        //
        SBG_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(SbgStreamBuffer *pHandle)
{
        //
        // Check input parameters
        //
        SBG_ASSERT(pHandle);

        return (size_t)pHandle->pCurrentPtr - (size_t)pHandle->pBufferPtr;
}

SBG_INLINE void *sbgStreamBufferGetLinkedBuffer(SbgStreamBuffer *pHandle)
{
        //
        // Check input parameters
        //
        SBG_ASSERT(pHandle);

        return pHandle->pBufferPtr;
}

SBG_INLINE void *sbgStreamBufferGetCursor(SbgStreamBuffer *pHandle)
{
        //
        // Check input parameters
        //
        SBG_ASSERT(pHandle);

        return pHandle->pCurrentPtr;
}

//----------------------------------------------------------------------//
//- Read operations methods                                            -//
//----------------------------------------------------------------------//

SBG_INLINE int8 sbgStreamBufferReadInt8(SbgStreamBuffer *pHandle)
{
        //
        // Check input parameters
        //
        SBG_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))
                {
                        //
                        // Read the byte
                        //
                        return *((int8*)(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 sbgStreamBufferReadUint8(SbgStreamBuffer *pHandle)
{
        //
        // Check input parameters
        //
        SBG_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))
                {
                        //
                        // Read the byte
                        //
                        return *((uint8*)(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 SbgErrorCode sbgStreamBufferReadBuffer(SbgStreamBuffer *pHandle, void *pBuffer, size_t numBytesToRead)
{
        //
        // Check input parameters
        //
        SBG_ASSERT(pHandle);
        SBG_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 value)
{
        //
        // Check input parameters
        //
        SBG_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))
                {
                        //
                        // Write each byte
                        //
                        *(pHandle->pCurrentPtr++) = (int8)(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 value)
{
        //
        // Check input parameters
        //
        SBG_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))
                {
                        //
                        // Write each byte
                        //
                        *(pHandle->pCurrentPtr++) = (uint8)(value);
                }
                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)
{
        //
        // Check input parameters
        //
        SBG_ASSERT(pHandle);
        SBG_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__ */