PlaybackSchedule::TimeQueue Class Reference

#include <PlaybackSchedule.h>

Collaboration diagram for PlaybackSchedule::TimeQueue:

Classes
struct	Node

Public Member Functions
	TimeQueue ()
	TimeQueue (const TimeQueue &)=delete
TimeQueue &	operator= (const TimeQueue &)=delete
void	Clear ()
void	Init (size_t size)
void	Producer (PlaybackSchedule &schedule, PlaybackSlice slice)
	Enqueue track time value advanced by the slice according to schedule's PlaybackPolicy. More...
double	GetLastTime () const
	Return the last time saved by Producer. More...
void	SetLastTime (double time)
double	Consumer (size_t nSamples, double rate)
	Find the track time value nSamples after the last consumed sample. More...
void	Prime (double time)
	Empty the queue and reassign the last produced time. More...

Private Attributes
double	mLastTime {}
Node *	mConsumerNode {}
Node *	mProducerNode {}
std::vector< std::unique_ptr< Node > >	mNodePool

Detailed Description

Holds track time values corresponding to every nth sample in the playback buffers, for the large n == TimeQueueGrainSize.

The "producer" is the Audio thread that fetches samples from tracks and fills the playback RingBuffers. The "consumer" is the high-latency PortAudio thread that drains the RingBuffers. The atomics in the RingBuffer implement lock-free synchronization.

This other structure adds other information to the stream of samples: which track times they correspond to.

The consumer thread uses that information, and also makes known to the main thread, what the last consumed track time is. The main thread can use that for other purposes such as refreshing the display of the play head position.

Definition at line 207 of file PlaybackSchedule.h.

Constructor & Destructor Documentation

TimeQueue() [1/2]

PlaybackSchedule::TimeQueue::TimeQueue ( )

default

TimeQueue() [2/2]

PlaybackSchedule::TimeQueue::TimeQueue ( const TimeQueue &  )

delete

Member Function Documentation

Clear()

void PlaybackSchedule::TimeQueue::Clear

(

)

by main thread

Definition at line 270 of file PlaybackSchedule.cpp.

{
   mNodePool.clear();
   mProducerNode = nullptr;
   mConsumerNode = nullptr;
}

References mConsumerNode, mNodePool, and mProducerNode.

Referenced by AudioIO::StartStream(), AudioIO::StartStreamCleanup(), and AudioIO::StopStream().

Here is the caller graph for this function:

Consumer()

double PlaybackSchedule::TimeQueue::Consumer	(	size_t	nSamples,
		double	rate
	)

Find the track time value nSamples after the last consumed sample.

by main thread

Definition at line 403 of file PlaybackSchedule.cpp.

{
   auto node = mConsumerNode;
 
   if ( node == nullptr ) {
      // Recording only.  No scrub or playback time warp.  Don't use the queue.
      return ( mLastTime += nSamples / rate );
   }
 
   auto head = node->head.load(std::memory_order_acquire);
   auto tail = node->tail.load(std::memory_order_relaxed);
 
   auto offset = node->offset;
   auto available = TimeQueueGrainSize - offset;
 
   if(nSamples >= available)
   {
      do
      {
         offset = 0;
         nSamples -= available;
         if ( head == tail )
         {
            //Check if circular buffer was reallocated
            if(const auto next = node->next.load())
            {
               node->offset = 0;
               node->active.clear();
 
               mConsumerNode = node = next;
               head = 0;
               tail = node->tail.load(std::memory_order_relaxed);
               available = TimeQueueGrainSize;
            }
            else
            {
               //consumer is ahead of producer...
               return node->records[head].timeValue;
            }
         }
         else
         {
            head = (head + 1) % static_cast<int>(node->records.size());
            available = TimeQueueGrainSize;
         }
      } while (nSamples >= available);
      node->head.store(head, std::memory_order_release);
   }
   node->offset = offset + nSamples;
   return node->records[head].timeValue;
}

References TimeQueueGrainSize.

Referenced by AudioIoCallback::UpdateTimePosition().

Here is the caller graph for this function:

GetLastTime()

double PlaybackSchedule::TimeQueue::GetLastTime

(

)

const

Return the last time saved by Producer.

Definition at line 393 of file PlaybackSchedule.cpp.

{
   return mLastTime;
}

Referenced by DefaultPlaybackPolicy::RepositionPlayback(), and DefaultPlaybackPolicy::RevertToOldDefault().

Here is the caller graph for this function:

Init()

void PlaybackSchedule::TimeQueue::Init

(

size_t

size

)

Definition at line 277 of file PlaybackSchedule.cpp.

{
   auto node = std::make_unique<Node>();
   mProducerNode = mConsumerNode = node.get();
   mProducerNode->active.test_and_set();
   mProducerNode->records.resize(size);
   mNodePool.clear();
   mNodePool.emplace_back( std::move(node) );
}

References size.

Referenced by AudioIO::AllocateBuffers().

Here is the caller graph for this function:

operator=()

TimeQueue & PlaybackSchedule::TimeQueue::operator= ( const TimeQueue &  )

delete

Prime()

void PlaybackSchedule::TimeQueue::Prime

(

double

time

)

Empty the queue and reassign the last produced time.

by main thread

Assumes producer and consumer are suspended

Definition at line 455 of file PlaybackSchedule.cpp.

{
   //TODO: check that consumer and producer indeed suspended when called from AudioIoCallback
   mLastTime = time;
   if(mProducerNode != nullptr)
   {
      mConsumerNode = mProducerNode;
      mConsumerNode->next.store(nullptr);
      mConsumerNode->head.store(0);
      mConsumerNode->tail.store(0);
      mConsumerNode->written = 0;
      mConsumerNode->offset = 0;
      mConsumerNode->records[0].timeValue = time;
   }
}

Referenced by AudioIoCallback::CallbackDoSeek(), and AudioIO::StartStream().

Here is the caller graph for this function:

Producer()

void PlaybackSchedule::TimeQueue::Producer	(	PlaybackSchedule &	schedule,
		PlaybackSlice	slice
	)

Enqueue track time value advanced by the slice according to schedule's PlaybackPolicy.

by the main thread

Definition at line 287 of file PlaybackSchedule.cpp.

{
   auto &policy = schedule.GetPolicy();
 
   auto node = mProducerNode;
 
   if ( node == nullptr )
      // Recording only.  Don't fill the queue.
      return;
 
 
   auto written = node->written;
   auto tail = node->tail.load(std::memory_order_acquire);
   auto head = node->head.load(std::memory_order_relaxed);
   auto time = mLastTime;
 
   auto frames = slice.toProduce;
 
   auto advanceTail = [&](double time)
   {
      auto newTail = (tail + 1) % static_cast<int>(node->records.size());
      if((newTail > head && static_cast<size_t>(newTail - head) == node->records.size() - 1) ||
         (newTail < head && static_cast<size_t>(head - newTail) == node->records.size() - 1))
      {
         try
         {
            Node* next = nullptr;
            for(auto& p : mNodePool)
            {
               if(p.get() == node || p->active.test_and_set())
                  continue;
 
               next = p.get();
               //next->offset = 0; set on consumer thread
               next->next.store(nullptr);
               next->head.store(0);
               next->tail.store(0);
               break;
            }
            if(next == nullptr)
            {
               mNodePool.emplace_back(std::make_unique<Node>());
               next = mNodePool.back().get();
            }
            //previous node had too low capacity to fit all slices,
            //try enlarge capacity to avoid more reallocaitons
            next->records.resize(node->records.size() * 2);
            next->records[0].timeValue = time;
 
            node->next.store(next);//make it visible to the consumer
            mProducerNode = node = next;
            head = 0;
            newTail = 0;
         }
         catch(...)
         {
            //overwrite last grain...
            newTail = tail;
         }
      }
      else
         node->records[newTail].timeValue = time;
      tail = newTail;
      node->written = 0;
   };
 
   //inv: space > 0
   auto space = TimeQueueGrainSize - written;
   while ( frames >= space )
   {
      const auto times = policy.AdvancedTrackTime( schedule, time, space);
      time = times.second;
      if (!std::isfinite(time))
         time = times.first;
      advanceTail(time);
      written = 0;
      frames -= space;
      space = TimeQueueGrainSize;
   }
   // Last odd lot
   if ( frames > 0 )
   {
      const auto times = policy.AdvancedTrackTime( schedule, time, frames );
      time = times.second;
      if (!std::isfinite(time))
         time = times.first;
      written += frames;
      space -= frames;
   }
   // Produce constant times if there is also some silence in the slice
   frames = slice.frames - slice.toProduce;
   while (frames > 0 && frames >= space )
   {
      advanceTail(time);
      
      frames -= space;
      written = 0;
      space = TimeQueueGrainSize;
   }
 
   mLastTime = time;
   node->written = written + frames;
   node->tail.store(tail, std::memory_order_release);
}

References PlaybackSlice::frames, PlaybackSchedule::GetPolicy(), PlaybackSchedule::TimeQueue::Node::head, PlaybackSchedule::TimeQueue::Node::next, PlaybackSchedule::TimeQueue::Node::records, PlaybackSchedule::TimeQueue::Node::tail, TimeQueueGrainSize, and PlaybackSlice::toProduce.

Referenced by AudioIO::ProcessPlaybackSlices().

Here is the call graph for this function:

Here is the caller graph for this function:

SetLastTime()

void PlaybackSchedule::TimeQueue::SetLastTime

(

double

time

)

Definition at line 398 of file PlaybackSchedule.cpp.

{
   mLastTime = time;
}

Referenced by DefaultPlaybackPolicy::RepositionPlayback().

Here is the caller graph for this function:

Member Data Documentation

mConsumerNode

Node* PlaybackSchedule::TimeQueue::mConsumerNode {}

private

Definition at line 275 of file PlaybackSchedule.h.

Referenced by Clear().

mLastTime

double PlaybackSchedule::TimeQueue::mLastTime {}

private

Definition at line 242 of file PlaybackSchedule.h.

mNodePool

std::vector<std::unique_ptr<Node> > PlaybackSchedule::TimeQueue::mNodePool

private

When node's buffer becomes full consumer will pick up a new one from the pool, which also will be linked to the previous node, so that producer could pick it up too.

Definition at line 281 of file PlaybackSchedule.h.

Referenced by Clear().

mProducerNode

Node* PlaybackSchedule::TimeQueue::mProducerNode {}

private

Definition at line 276 of file PlaybackSchedule.h.

Referenced by Clear().

---

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

• PlaybackSchedule.h
• PlaybackSchedule.cpp