openshot-audio  0.1.2
Public Member Functions | List of all members
juce::AbstractFifo Class Reference

#include <juce_core.h>

Public Member Functions

 AbstractFifo (int capacity) noexcept
 
 ~AbstractFifo ()
 
int getTotalSize () const noexcept
 
int getFreeSpace () const noexcept
 
int getNumReady () const noexcept
 
void reset () noexcept
 
void setTotalSize (int newSize) noexcept
 
void prepareToWrite (int numToWrite, int &startIndex1, int &blockSize1, int &startIndex2, int &blockSize2) const noexcept
 
void finishedWrite (int numWritten) noexcept
 
void prepareToRead (int numWanted, int &startIndex1, int &blockSize1, int &startIndex2, int &blockSize2) const noexcept
 
void finishedRead (int numRead) noexcept
 

Detailed Description

Encapsulates the logic required to implement a lock-free FIFO.

This class handles the logic needed when building a single-reader, single-writer FIFO.

It doesn't actually hold any data itself, but your FIFO class can use one of these to manage its position and status when reading or writing to it.

To use it, you can call prepareToWrite() to determine the position within your own buffer that an incoming block of data should be stored, and prepareToRead() to find out when the next outgoing block should be read from.

e.g.

class MyFifo
{
public:
MyFifo() : abstractFifo (1024)
{
}
void addToFifo (const int* someData, int numItems)
{
int start1, size1, start2, size2;
abstractFifo.prepareToWrite (numItems, start1, size1, start2, size2);
if (size1 > 0)
copySomeData (myBuffer + start1, someData, size1);
if (size2 > 0)
copySomeData (myBuffer + start2, someData + size1, size2);
abstractFifo.finishedWrite (size1 + size2);
}
void readFromFifo (int* someData, int numItems)
{
int start1, size1, start2, size2;
abstractFifo.prepareToRead (numItems, start1, size1, start2, size2);
if (size1 > 0)
copySomeData (someData, myBuffer + start1, size1);
if (size2 > 0)
copySomeData (someData + size1, myBuffer + start2, size2);
abstractFifo.finishedRead (size1 + size2);
}
private:
AbstractFifo abstractFifo;
int myBuffer [1024];
};

Constructor & Destructor Documentation

AbstractFifo::AbstractFifo ( int  capacity)
noexcept

Creates a FIFO to manage a buffer with the specified capacity.

AbstractFifo::~AbstractFifo ( )

Destructor

Member Function Documentation

void AbstractFifo::finishedRead ( int  numRead)
noexcept

Called after reading from the FIFO, to indicate that this many items have now been consumed.

See also
prepareToRead
void AbstractFifo::finishedWrite ( int  numWritten)
noexcept

Called after writing from the FIFO, to indicate that this many items have been added.

See also
prepareToWrite
int AbstractFifo::getFreeSpace ( ) const
noexcept

Returns the number of items that can currently be added to the buffer without it overflowing.

int AbstractFifo::getNumReady ( ) const
noexcept

Returns the number of items that can currently be read from the buffer.

int AbstractFifo::getTotalSize ( ) const
noexcept

Returns the total size of the buffer being managed.

void AbstractFifo::prepareToRead ( int  numWanted,
int startIndex1,
int blockSize1,
int startIndex2,
int blockSize2 
) const
noexcept

Returns the location within the buffer from which the next block of data should be read.

Because the section of data that you want to read from the buffer may overlap the end and wrap around to the start, two blocks within your buffer are returned, and you should read from both of them.

If the number of items you ask for is greater than the amount of data available, then blockSize1 + blockSize2 may add up to a lower value than numWanted. If this happens, you may decide to keep waiting and re-trying the method until there's enough data available.

After calling this method, if you choose to read the data, you must call finishedRead() to tell the FIFO how much data you have consumed.

e.g.

void readFromFifo (int* someData, int numItems)
{
int start1, size1, start2, size2;
prepareToRead (numSamples, start1, size1, start2, size2);
if (size1 > 0)
copySomeData (someData, myBuffer + start1, size1);
if (size2 > 0)
copySomeData (someData + size1, myBuffer + start2, size2);
finishedRead (size1 + size2);
}
Parameters
numWantedindicates how many items you'd like to add to the buffer
startIndex1on exit, this will contain the start index in your buffer at which your data should be written
blockSize1on exit, this indicates how many items can be written to the block starting at startIndex1
startIndex2on exit, this will contain the start index in your buffer at which any data that didn't fit into the first block should be written
blockSize2on exit, this indicates how many items can be written to the block starting at startIndex2
See also
finishedRead
void AbstractFifo::prepareToWrite ( int  numToWrite,
int startIndex1,
int blockSize1,
int startIndex2,
int blockSize2 
) const
noexcept

Returns the location within the buffer at which an incoming block of data should be written.

Because the section of data that you want to add to the buffer may overlap the end and wrap around to the start, two blocks within your buffer are returned, and you should copy your data into the first one, with any remaining data spilling over into the second.

If the number of items you ask for is too large to fit within the buffer's free space, then blockSize1 + blockSize2 may add up to a lower value than numToWrite. If this happens, you may decide to keep waiting and re-trying the method until there's enough space available.

After calling this method, if you choose to write your data into the blocks returned, you must call finishedWrite() to tell the FIFO how much data you actually added.

e.g.

void addToFifo (const int* someData, int numItems)
{
int start1, size1, start2, size2;
prepareToWrite (numItems, start1, size1, start2, size2);
if (size1 > 0)
copySomeData (myBuffer + start1, someData, size1);
if (size2 > 0)
copySomeData (myBuffer + start2, someData + size1, size2);
finishedWrite (size1 + size2);
}
Parameters
numToWriteindicates how many items you'd like to add to the buffer
startIndex1on exit, this will contain the start index in your buffer at which your data should be written
blockSize1on exit, this indicates how many items can be written to the block starting at startIndex1
startIndex2on exit, this will contain the start index in your buffer at which any data that didn't fit into the first block should be written
blockSize2on exit, this indicates how many items can be written to the block starting at startIndex2
See also
finishedWrite
void AbstractFifo::reset ( )
noexcept

Clears the buffer positions, so that it appears empty.

void AbstractFifo::setTotalSize ( int  newSize)
noexcept

Changes the buffer's total size. Note that this isn't thread-safe, so don't call it if there's any danger that it might overlap with a call to any other method in this class!


The documentation for this class was generated from the following files: