circularbuffer.h

Go to the documentation of this file.

/* SPDX-License-Identifier: MIT */
#ifndef AJA_CIRCULAR_BUFFER_H
#define AJA_CIRCULAR_BUFFER_H
 
#include "ajabase/common/public.h"
#include "ajabase/system/lock.h"
#include "ajabase/system/event.h"
 
 
 
template <typename FrameDataPtr>
class AJACircularBuffer
{
public:
    AJACircularBuffer ();
 
 
    virtual ~AJACircularBuffer ();
    
 
    inline void SetAbortFlag (const bool * pAbortFlag)
    {
        mAbortFlag = pAbortFlag;
    }
 
 
    inline unsigned int GetCircBufferCount (void) const
    {
        return mCircBufferCount;
    }
 
 
    inline bool IsEmpty (void) const
    {
        return GetCircBufferCount () == 0;
    }
 
    inline unsigned int GetNumFrames (void) const
    {
        return (unsigned int) mFrames.size ();
    }
 
    
    AJAStatus Add (FrameDataPtr pInFrameData)
    {
        mFrames.push_back(pInFrameData);
        AJALock* lock = new AJALock;
        mLocks.push_back(lock);
        
        return (mFrames.size() == mLocks.size() && lock) ? AJA_STATUS_SUCCESS
            : AJA_STATUS_FAIL;
    }
 
    
    FrameDataPtr StartProduceNextBuffer (void)
    {
        while (1)
        {
            if( !WaitForLockOrAbort(&mDataBufferLock) )
                return NULL;
            
            if ( mCircBufferCount == mFrames.size() )
            {
                mDataBufferLock.Unlock();
                if( !WaitForEventOrAbort(&mNotFullEvent) )
                    return NULL;
                
                continue;
            }
            break;
        }
        if( !WaitForLockOrAbort(mLocks[mHead]) ) return NULL;
        mFillIndex = mHead;
        mHead = (mHead+1)%((unsigned int)(mFrames.size()));
        mCircBufferCount++;
        if( mCircBufferCount == mFrames.size() )
            mNotFullEvent.SetState(false);
        
        mDataBufferLock.Unlock();
        
        return mFrames[mFillIndex];
    }
 
 
    void EndProduceNextBuffer (void);
 
 
    FrameDataPtr StartConsumeNextBuffer (void)
    {
        while (1)
        {
            if( !WaitForLockOrAbort(&mDataBufferLock) )
                return NULL;
            
            if ( mCircBufferCount == 0 )
            {
                mDataBufferLock.Unlock();
                if( !WaitForEventOrAbort(&mNotEmptyEvent) )
                    return NULL;
 
                continue;
            }
            break;
        }
        
        if( !WaitForLockOrAbort(mLocks[mTail]) )
            return NULL;
        
        mEmptyIndex = mTail;
        mTail = (mTail+1)%((unsigned int)mFrames.size());
        mCircBufferCount--;
        if( mCircBufferCount == 0 )
            mNotEmptyEvent.SetState(false);
        mDataBufferLock.Unlock();
        
        return mFrames[mEmptyIndex];
    }
 
 
    void EndConsumeNextBuffer (void);
 
 
    void Clear (void);
 
 
private:
    typedef std::vector <AJALock *> AJALockVector;
 
    std::vector <FrameDataPtr>  mFrames;            
    AJALockVector               mLocks;             
    
    unsigned int                mHead;              
    unsigned int                mTail;              
    unsigned int                mCircBufferCount;   
    AJAEvent                    mNotFullEvent;      
    AJAEvent                    mNotEmptyEvent;     
    AJALock                     mDataBufferLock;    
 
    unsigned int                mFillIndex;         
    unsigned int                mEmptyIndex;        
 
    const bool *                mAbortFlag;         
    
    bool WaitForEventOrAbort (AJAEvent * ajaEvent);
 
 
    bool WaitForLockOrAbort (AJALock * ajaEvent);
 
};  //  AJACircularBuffer
 
 
 
template <typename FrameDataPtr>
AJACircularBuffer <FrameDataPtr>::AJACircularBuffer ()
    :   mHead (0),
        mTail (0),
        mCircBufferCount (0),
        mFillIndex (0),
        mEmptyIndex (0),
        mAbortFlag (NULL)
{
}
 
template <typename FrameDataPtr>
AJACircularBuffer <FrameDataPtr>::~AJACircularBuffer ()
{
    Clear ();
}
 
 
 
 
template<typename FrameDataPtr>
void AJACircularBuffer<FrameDataPtr>::EndProduceNextBuffer()
{
    mLocks[mFillIndex]->Unlock();
    mNotEmptyEvent.SetState(true);
}
 
template<typename FrameDataPtr>
void AJACircularBuffer<FrameDataPtr>::EndConsumeNextBuffer()
{
    mLocks[mEmptyIndex]->Unlock();
    mNotFullEvent.SetState(true);
}
 
template<typename FrameDataPtr>
bool AJACircularBuffer<FrameDataPtr>::WaitForEventOrAbort(AJAEvent* ajaEvent)
{
    const unsigned int timeout = 100;
    
    do {
        AJAStatus status = ajaEvent->WaitForSignal(timeout);
        if (status == AJA_STATUS_TIMEOUT)
            if ( mAbortFlag )
                if ( *mAbortFlag )
                    return false;
        if (status == AJA_STATUS_FAIL)
            return false;
        if (status == AJA_STATUS_SUCCESS )
            break;
    } while(1);
    
    return true;
}
 
template<typename FrameDataPtr>
bool AJACircularBuffer<FrameDataPtr>::WaitForLockOrAbort(AJALock* ajaLock)
{
    const unsigned int timeout = 100;
    
    do {
        AJAStatus status = ajaLock->Lock(timeout);
        if (status == AJA_STATUS_TIMEOUT)
            if ( mAbortFlag )
                if ( *mAbortFlag)
                    return false;
        if (status == AJA_STATUS_FAIL)
            return false;
        if (status == AJA_STATUS_SUCCESS )
            break;
    } while(1);
    
    return true;
}
 
 
template<typename FrameDataPtr>
void AJACircularBuffer<FrameDataPtr>::Clear (void)
{
    for (AJALockVector::iterator iter (mLocks.begin());  iter != mLocks.end();  ++iter)
        delete *iter;
 
    mLocks.clear();
    mFrames.clear();
 
    mHead = mTail = mFillIndex = mEmptyIndex = mCircBufferCount = 0;
    mAbortFlag = NULL;
}
 
 
#endif  //  AJA_CIRCULAR_BUFFER_H