AudioThread Class Reference

Defined different on Mac and other platforms (on Mac it does not use wxWidgets wxThread), this class sits in a thread loop reading and writing audio. More...

Public Types
typedef int	ExitCode

Public Member Functions
	AudioThread ()
virtual ExitCode	Entry ()
void	Create ()
void	Delete ()
bool	TestDestroy ()
void	Sleep (int ms)
void	Run ()

Static Public Member Functions
static void *	callback (void *p)

Private Attributes
bool	mDestroy
pthread_t	mThread

Detailed Description

Defined different on Mac and other platforms (on Mac it does not use wxWidgets wxThread), this class sits in a thread loop reading and writing audio.

Definition at line 214 of file AudioIO.cpp.

Member Typedef Documentation

ExitCode

typedef int AudioThread::ExitCode

Definition at line 216 of file AudioIO.cpp.

Constructor & Destructor Documentation

AudioThread()

AudioThread::AudioThread ( )

inline

Definition at line 217 of file AudioIO.cpp.

{ mDestroy = false; mThread = NULL; }

References mDestroy, and mThread.

Member Function Documentation

callback()

static void * AudioThread::callback ( void *  p )

inlinestatic

Definition at line 231 of file AudioIO.cpp.

                                  {
      AudioThread *th = (AudioThread *)p;
      return reinterpret_cast<void *>( th->Entry() );
   }

References Entry().

Referenced by Run().

Here is the call graph for this function:

Here is the caller graph for this function:

Create()

void AudioThread::Create ( )

inline

Definition at line 219 of file AudioIO.cpp.

{}

Delete()

void AudioThread::Delete ( )

inline

Definition at line 220 of file AudioIO.cpp.

                 {
      mDestroy = true;
      pthread_join(mThread, NULL);
   }

References mDestroy, and mThread.

Entry()

AudioThread::ExitCode AudioThread::Entry ( )

virtual

Definition at line 1739 of file AudioIO.cpp.

{
   enum class State { eUndefined, eOnce, eLoopRunning, eDoNothing, eMonitoring } lastState = State::eUndefined;
 
   AudioIO *gAudioIO;
   while( !TestDestroy() &&
      nullptr != ( gAudioIO = AudioIO::Get() ) )
   {
      using Clock = std::chrono::steady_clock;
      auto loopPassStart = Clock::now();
      auto &schedule = gAudioIO->mPlaybackSchedule;
      const auto interval = schedule.GetPolicy().SleepInterval(schedule);
 
      // Set LoopActive outside the tests to avoid race condition
      gAudioIO->mAudioThreadTrackBufferExchangeLoopActive
         .store(true, std::memory_order_relaxed);
      if( gAudioIO->mAudioThreadShouldCallTrackBufferExchangeOnce
         .load(std::memory_order_acquire) )
      {
         gAudioIO->TrackBufferExchange();
         gAudioIO->mAudioThreadShouldCallTrackBufferExchangeOnce
            .store(false, std::memory_order_release);
 
         lastState = State::eOnce;
      }
      else if( gAudioIO->mAudioThreadTrackBufferExchangeLoopRunning
         .load(std::memory_order_relaxed))
      {
         if (lastState != State::eLoopRunning)
         {
            // Main thread has told us to start - acknowledge that we do
            gAudioIO->mAudioThreadAcknowledge.store(Acknowledge::eStart,
                                                    std::memory_order::memory_order_release);
         }
         lastState = State::eLoopRunning;
 
         // We call the processing after raising the acknowledge flag, because the main thread
         // only needs to know that the message was seen.
         // 
         // This is unlike the case with mAudioThreadShouldCallTrackBufferExchangeOnce where the
         // store really means that the one-time exchange was done. 
 
         gAudioIO->TrackBufferExchange();         
      }
      else
      {
         if (    (lastState == State::eLoopRunning)
              || (lastState == State::eMonitoring ) )
         {
            // Main thread has told us to stop; (actually: to neither process "once" nor "loop running")
            // acknowledge that we received the order and that no more processing will be done.
            gAudioIO->mAudioThreadAcknowledge.store(Acknowledge::eStop,
                                                    std::memory_order::memory_order_release);
         }
         lastState = State::eDoNothing;
 
         if (gAudioIO->IsMonitoring())
         {
            lastState = State::eMonitoring;
         }
      }
 
      gAudioIO->mAudioThreadTrackBufferExchangeLoopActive
         .store(false, std::memory_order_relaxed);
 
      std::this_thread::sleep_until( loopPassStart + interval );
   }
 
   return 0;
}

References eStart, eStop, AudioIO::Get(), PlaybackSchedule::GetPolicy(), AudioIOBase::IsMonitoring(), AudioIoCallback::mAudioThreadAcknowledge, AudioIoCallback::mAudioThreadShouldCallTrackBufferExchangeOnce, AudioIoCallback::mAudioThreadTrackBufferExchangeLoopActive, AudioIoCallback::mAudioThreadTrackBufferExchangeLoopRunning, AudioIoCallback::mPlaybackSchedule, PlaybackPolicy::SleepInterval(), TestDestroy(), and AudioIO::TrackBufferExchange().

Referenced by callback().

Here is the call graph for this function:

Here is the caller graph for this function:

Run()

void AudioThread::Run ( )

inline

Definition at line 235 of file AudioIO.cpp.

              {
      pthread_create(&mThread, NULL, callback, this);
   }

References callback(), and mThread.

Here is the call graph for this function:

Sleep()

void AudioThread::Sleep ( int  ms )

inline

Definition at line 225 of file AudioIO.cpp.

                      {
      struct timespec spec;
      spec.tv_sec = 0;
      spec.tv_nsec = ms * 1000 * 1000;
      nanosleep(&spec, NULL);
   }

TestDestroy()

bool AudioThread::TestDestroy ( )

inline

Definition at line 224 of file AudioIO.cpp.

{ return mDestroy; }

References mDestroy.

Referenced by Entry().

Here is the caller graph for this function:

Member Data Documentation

mDestroy

bool AudioThread::mDestroy

private

Definition at line 239 of file AudioIO.cpp.

Referenced by AudioThread(), Delete(), and TestDestroy().

mThread

pthread_t AudioThread::mThread

private

Definition at line 240 of file AudioIO.cpp.

Referenced by AudioThread(), Delete(), and Run().

---

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

• AudioIO.cpp