AudioIoCallback is a class that implements the callback required by PortAudio. The callback needs to be responsive, has no GUI, and copies data into and out of the sound card buffers. It also sends data to the meters. More...

#include <AudioIO.h>

Inheritance diagram for AudioIoCallback:

[legend]

Collaboration diagram for AudioIoCallback:

[legend]

Classes
class	AudioIOExtIterator

struct	AudioIOExtRange

struct	TransportState

Public Types
using	OldChannelGains = std::array< float, 2 >

using	RingBuffers = std::vector< std::unique_ptr< RingBuffer > >

Public Member Functions
	AudioIoCallback ()

	~AudioIoCallback ()

int	AudioCallback (constSamplePtr inputBuffer, float outputBuffer, unsigned long framesPerBuffer, const PaStreamCallbackTimeInfo timeInfo, const PaStreamCallbackFlags statusFlags, void *userData)

std::shared_ptr< AudioIOListener >	GetListener () const

void	SetListener (const std::shared_ptr< AudioIOListener > &listener)

int	CallbackDoSeek ()

void	CallbackCheckCompletion (int &callbackReturn, unsigned long len)

unsigned	CountSoloingSequences ()

bool	SequenceShouldBeSilent (const PlayableSequence &ps)

bool	SequenceHasBeenFadedOut (const OldChannelGains &gains)
	Returns true when playback buffer data from both channels is discardable. More...

bool	AllSequencesAlreadySilent ()

void	CheckSoundActivatedRecordingLevel (float *inputSamples, unsigned long framesPerBuffer)

void	AddToOutputChannel (unsigned int chan, float outputMeterFloats, float outputFloats, const float *tempBuf, bool drop, unsigned long len, const PlayableSequence &ps, float &channelGain)

bool	FillOutputBuffers (float outputBuffer, unsigned long framesPerBuffer, float outputMeterFloats)

void	DrainInputBuffers (constSamplePtr inputBuffer, unsigned long framesPerBuffer, const PaStreamCallbackFlags statusFlags, float *tempFloats)

void	UpdateTimePosition (unsigned long framesPerBuffer)

void	DoPlaythrough (constSamplePtr inputBuffer, float outputBuffer, unsigned long framesPerBuffer, float outputMeterFloats)

void	SendVuInputMeterData (const float *inputSamples, unsigned long framesPerBuffer)

void	SendVuOutputMeterData (const float *outputMeterFloats, unsigned long framesPerBuffer)

size_t	GetCommonlyReadyPlayback ()
	Get the number of audio samples ready in all of the playback buffers. More...

size_t	GetCommonlyWrittenForPlayback ()

void	StartAudioThread ()

void	WaitForAudioThreadStarted ()

void	StopAudioThread ()

void	WaitForAudioThreadStopped ()

void	ProcessOnceAndWait (std::chrono::milliseconds sleepTime=std::chrono::milliseconds(50))

bool	HasRecordingException () const

const std::vector< std::pair< double, double > > &	LostCaptureIntervals ()

iteration over extensions, supporting range-for syntax
AudioIOExtRange	Extensions ()

Public Member Functions inherited from AudioIOBase
	AudioIOBase ()

virtual	~AudioIOBase ()

	AudioIOBase (const AudioIOBase &)=delete

AudioIOBase &	operator= (const AudioIOBase &)=delete

void	SetCaptureMeter (const std::shared_ptr< AudacityProject > &project, const std::weak_ptr< Meter > &meter)

void	SetPlaybackMeter (const std::shared_ptr< AudacityProject > &project, const std::weak_ptr< Meter > &meter)

void	HandleDeviceChange ()
	update state after changing what audio devices are selected More...

wxString	GetDeviceInfo () const
	Get diagnostic information on all the available audio I/O devices. More...

std::vector< AudioIODiagnostics >	GetAllDeviceInfo ()
	Get diagnostic information for audio devices and also for extensions. More...

bool	IsPaused () const
	Find out if playback / recording is currently paused. More...

virtual void	StopStream ()=0

bool	IsBusy () const
	Returns true if audio i/o is busy starting, stopping, playing, or recording. More...

bool	IsStreamActive () const
	Returns true if the audio i/o is running at all, but not during cleanup. More...

bool	IsStreamActive (int token) const

bool	IsAudioTokenActive (int token) const
	Returns true if the stream is active, or even if audio I/O is busy cleaning up its data or writing to disk. More...

bool	IsMonitoring () const
	Returns true if we're monitoring input (but not recording or playing actual audio) More...

void	SetMixer (int inputSource)

Public Attributes
int	mbHasSoloSequences

int	mCallbackReturn

long	mNumPauseFrames
	How many frames of zeros were output due to pauses? More...

std::thread	mAudioThread

std::atomic< bool >	mFinishAudioThread { false }

std::vector< std::unique_ptr< Resample > >	mResample

RingBuffers	mCaptureBuffers

RecordableSequences	mCaptureSequences

RingBuffers	mPlaybackBuffers

ConstPlayableSequences	mPlaybackSequences

std::vector< OldChannelGains >	mOldChannelGains

std::vector< SampleBuffer >	mScratchBuffers

std::vector< float * >	mScratchPointers
	pointing into mScratchBuffers More...

std::vector< std::unique_ptr< Mixer > >	mPlaybackMixers

std::atomic< float >	mMixerOutputVol { 1.0 }

double	mFactor

unsigned long	mMaxFramesOutput

bool	mbMicroFades

double	mSeek

PlaybackPolicy::Duration	mPlaybackRingBufferSecs

double	mCaptureRingBufferSecs

size_t	mPlaybackSamplesToCopy
	Preferred batch size for replenishing the playback RingBuffer. More...

size_t	mHardwarePlaybackLatencyFrames {}
	Hardware output latency in frames. More...

size_t	mPlaybackQueueMinimum
	Occupancy of the queue we try to maintain, with bigger batches if needed. More...

double	mMinCaptureSecsToCopy

bool	mSoftwarePlaythrough

bool	mPauseRec
	True if Sound Activated Recording is enabled. More...

float	mSilenceLevel

size_t	mNumCaptureChannels

size_t	mNumPlaybackChannels

sampleFormat	mCaptureFormat

double	mCaptureRate {}

unsigned long long	mLostSamples { 0 }

std::atomic< bool >	mAudioThreadShouldCallSequenceBufferExchangeOnce

std::atomic< bool >	mAudioThreadSequenceBufferExchangeLoopRunning

std::atomic< bool >	mAudioThreadSequenceBufferExchangeLoopActive

std::atomic< Acknowledge >	mAudioThreadAcknowledge

std::atomic< bool >	mForceFadeOut { false }

wxLongLong	mLastPlaybackTimeMillis

double	mLastRecordingOffset
	Not (yet) used; should perhaps be atomic when it is. More...

PaError	mLastPaError

bool	mSimulateRecordingErrors { false }

std::atomic< bool >	mDetectUpstreamDropouts { true }

Static Public Attributes
static int	mNextStreamToken = 0

Static Public Attributes inherited from AudioIOBase
static const int	StandardRates []
	Array of common audio sample rates. More...

static const int	NumStandardRates = WXSIZEOF(AudioIOBase::StandardRates)
	How many standard sample rates there are. More...

Protected Member Functions
float	GetMixerOutputVol ()

void	SetMixerOutputVol (float value)

void	SetRecordingException ()

void	ClearRecordingException ()

Static Protected Member Functions
static size_t	MinValue (const RingBuffers &buffers, size_t(RingBuffer::*pmf)() const)

Static Protected Member Functions inherited from AudioIOBase
static wxString	DeviceName (const PaDeviceInfo *info)

static wxString	HostName (const PaDeviceInfo *info)

static int	getRecordDevIndex (const wxString &devName={})
	get the index of the supplied (named) recording device, or the device selected in the preferences if none given. More...

static int	getPlayDevIndex (const wxString &devName={})
	get the index of the device selected in the preferences. More...

Protected Attributes
std::weak_ptr< AudioIOListener >	mListener

bool	mUsingAlsa { false }

bool	mUsingJack { false }

wxMutex	mSuspendAudioThread

wxAtomicInt	mRecordingException {}

std::vector< std::pair< double, double > >	mLostCaptureIntervals

bool	mDetectDropouts { true }

RecordingSchedule	mRecordingSchedule {}

PlaybackSchedule	mPlaybackSchedule

std::unique_ptr< TransportState >	mpTransportState
	Holds some state for duration of playback or recording. More...

Protected Attributes inherited from AudioIOBase
std::weak_ptr< AudacityProject >	mOwningProject

std::atomic< bool >	mPaused { false }
	True if audio playback is paused. More...

int	mStreamToken { 0 }

double	mRate
	Audio playback rate in samples per second. More...

PaStream *	mPortStreamV19

std::weak_ptr< Meter >	mInputMeter {}

std::weak_ptr< Meter >	mOutputMeter {}

bool	mInputMixerWorks
	Can we control the hardware input level? More...

std::vector< std::unique_ptr< AudioIOExtBase > >	mAudioIOExt

Static Protected Attributes
static double	mCachedBestRateOut

static bool	mCachedBestRatePlaying

static bool	mCachedBestRateCapturing

Static Protected Attributes inherited from AudioIOBase
static std::unique_ptr< AudioIOBase >	ugAudioIO

static int	mCachedPlaybackIndex = -1

static std::vector< long >	mCachedPlaybackRates

static int	mCachedCaptureIndex = -1

static std::vector< long >	mCachedCaptureRates

static std::vector< long >	mCachedSampleRates

static double	mCachedBestRateIn = 0.0

static const int	RatesToTry []
	Array of audio sample rates to try to use. More...

static const int	NumRatesToTry = WXSIZEOF(AudioIOBase::RatesToTry)
	How many sample rates to try. More...

Private Attributes
std::vector< std::unique_ptr< AudioIOExtBase > >	mAudioIOExt

Additional Inherited Members
Static Public Member Functions inherited from AudioIOBase
static AudioIOBase *	Get ()

static std::vector< long >	GetSupportedPlaybackRates (int DevIndex=-1, double rate=0.0)
	Get a list of sample rates the output (playback) device supports. More...

static std::vector< long >	GetSupportedCaptureRates (int devIndex=-1, double rate=0.0)
	Get a list of sample rates the input (recording) device supports. More...

static std::vector< long >	GetSupportedSampleRates (int playDevice=-1, int recDevice=-1, double rate=0.0)
	Get a list of sample rates the current input/output device combination supports. More...

static int	GetOptimalSupportedSampleRate ()
	Get a supported sample rate which can be used a an optimal default. More...

Detailed Description

AudioIoCallback is a class that implements the callback required by PortAudio. The callback needs to be responsive, has no GUI, and copies data into and out of the sound card buffers. It also sends data to the meters.

Definition at line 109 of file AudioIO.h.

Member Typedef Documentation

◆ OldChannelGains

using AudioIoCallback::OldChannelGains = std::array<float, 2>

Definition at line 185 of file AudioIO.h.

◆ RingBuffers

using AudioIoCallback::RingBuffers = std::vector<std::unique_ptr<RingBuffer> >

Definition at line 271 of file AudioIO.h.

Constructor & Destructor Documentation

◆ AudioIoCallback()

AudioIoCallback::AudioIoCallback ( )

Definition at line 3087 of file AudioIO.cpp.

{
   auto &factories = AudioIOExt::GetFactories();
   for (auto &factory: factories)
      if (auto pExt = factory(mPlaybackSchedule))
         mAudioIOExt.push_back( move(pExt) );
}

References factory, AudioIOExt::GetFactories(), mAudioIOExt, and mPlaybackSchedule.

Here is the call graph for this function:

◆ ~AudioIoCallback()

AudioIoCallback::~AudioIoCallback ( )

Definition at line 3096 of file AudioIO.cpp.

3097{

3098}

Member Function Documentation

◆ AddToOutputChannel()

void AudioIoCallback::AddToOutputChannel	(	unsigned int	chan,
		float *	outputMeterFloats,
		float *	outputFloats,
		const float *	tempBuf,
		bool	drop,
		unsigned long	len,
		const PlayableSequence &	ps,
		float &	channelGain
	)

Parameters

[in,out] channelGain

Definition at line 2569 of file AudioIO.cpp.

{
   const auto numPlaybackChannels = mNumPlaybackChannels;
 
   float gain = ps.GetChannelGain(chan);
   if (drop || mForceFadeOut.load(std::memory_order_relaxed) || IsPaused())
      gain = 0.0;
 
   // Output volume emulation: possibly copy meter samples, then
   // apply volume, then copy to the output buffer
   if (outputMeterFloats != outputFloats)
      for ( unsigned i = 0; i < len; ++i)
         outputMeterFloats[numPlaybackChannels*i+chan] +=
            gain*tempBuf[i];
 
   // DV: We use gain to emulate panning.
   // Let's keep the old behavior for panning.
   gain *= ExpGain(GetMixerOutputVol());
 
   float oldGain = channelGain;
   channelGain = gain;
   // if no microfades, jump in volume.
   if (!mbMicroFades)
      oldGain = gain;
   wxASSERT(len > 0);
 
   // Linear interpolate.
   // PRL todo:  choose denominator differently, so it doesn't depend on
   // framesPerBuffer, which is influenced by the portAudio implementation in
   // opaque ways
   float deltaGain = (gain - oldGain) / len;
   for (unsigned i = 0; i < len; i++)
      outputFloats[numPlaybackChannels*i+chan] += (oldGain + deltaGain * i) *tempBuf[i];
};

References ExpGain(), WideSampleSequence::GetChannelGain(), GetMixerOutputVol(), AudioIOBase::IsPaused(), mbMicroFades, mForceFadeOut, and mNumPlaybackChannels.

Referenced by FillOutputBuffers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AllSequencesAlreadySilent()

bool AudioIoCallback::AllSequencesAlreadySilent ( )

Definition at line 3076 of file AudioIO.cpp.

{
   for (size_t ii = 0, nn = mPlaybackSequences.size(); ii < nn; ++ii) {
      auto vt = mPlaybackSequences[ii];
      const auto &oldGains = mOldChannelGains[ii];
      if (!(SequenceShouldBeSilent(*vt) && SequenceHasBeenFadedOut(oldGains)))
         return false;
   }
   return true;
}

References mOldChannelGains, mPlaybackSequences, SequenceHasBeenFadedOut(), and SequenceShouldBeSilent().

Referenced by AudioCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AudioCallback()

int AudioIoCallback::AudioCallback	(	constSamplePtr	inputBuffer,
		float *	outputBuffer,
		unsigned long	framesPerBuffer,
		const PaStreamCallbackTimeInfo *	timeInfo,
		const PaStreamCallbackFlags	statusFlags,
		void *	userData
	)

Definition at line 3101 of file AudioIO.cpp.

{
   // Poll sequences for change of state.
   // (User might click mute and solo buttons.)
   mbHasSoloSequences = CountSoloingSequences() > 0 ;
   mCallbackReturn = paContinue;
 
   if (IsPaused()
       // PRL:  Why was this added?  Was it only because of the mysterious
       // initial leading zeroes, now solved by setting mStreamToken early?
       // JKC: I think it's used for the MIDI time cursor.  See comments
       // at head of file about AudioTime().
       || mStreamToken <= 0
       )
      mNumPauseFrames += framesPerBuffer;
 
   for( auto &ext : Extensions() ) {
      ext.ComputeOtherTimings(mRate, IsPaused(),
         timeInfo,
         framesPerBuffer);
      ext.FillOtherBuffers(
         mRate, mNumPauseFrames, IsPaused(), mbHasSoloSequences);
   }
 
   // ------ MEMORY ALLOCATIONS -----------------------------------------------
   // tempFloats will be a reusable scratch pad for (possibly format converted)
   // audio data.  One temporary use is for the InputMeter data.
   const auto numPlaybackChannels = mNumPlaybackChannels;
   const auto numCaptureChannels = mNumCaptureChannels;
   const auto tempFloats = stackAllocate(float,
      framesPerBuffer * std::max(numCaptureChannels, numPlaybackChannels));
 
   bool bVolEmulationActive =
      (outputBuffer && GetMixerOutputVol() != 1.0);
   // outputMeterFloats is the scratch pad for the output meter.
   // we can often reuse the existing outputBuffer and save on allocating
   // something new.
   const auto outputMeterFloats = bVolEmulationActive
      ? stackAllocate(float, framesPerBuffer * numPlaybackChannels)
      : outputBuffer;
   // ----- END of MEMORY ALLOCATIONS ------------------------------------------
 
   if (inputBuffer && numCaptureChannels) {
      float *inputSamples;
 
      if (mCaptureFormat == floatSample) {
         inputSamples = (float *) inputBuffer;
      }
      else {
         SamplesToFloats(reinterpret_cast<constSamplePtr>(inputBuffer),
            mCaptureFormat, tempFloats, framesPerBuffer * numCaptureChannels);
         inputSamples = tempFloats;
      }
 
      SendVuInputMeterData(
         inputSamples,
         framesPerBuffer);
 
      // This function may queue up a pause or resume.
      // TODO this is a bit dodgy as it toggles the Pause, and
      // relies on an idle event to have handled that, so could
      // queue up multiple toggle requests and so do nothing.
      // Eventually it will sort itself out by random luck, but
      // the net effect is a delay in starting/stopping sound activated
      // recording.
      CheckSoundActivatedRecordingLevel(
         inputSamples,
         framesPerBuffer);
   }
 
   // Even when paused, we do playthrough.
   // Initialise output buffer to zero or to playthrough data.
   // Initialise output meter values.
   DoPlaythrough(
      inputBuffer,
      outputBuffer,
      framesPerBuffer,
      outputMeterFloats);
 
   // Test for no sequence audio to play (because we are paused and have faded
   // out)
   if( IsPaused() &&  (( !mbMicroFades ) || AllSequencesAlreadySilent() ))
      return mCallbackReturn;
 
   // To add sequence output to output (to play sound on speaker)
   // possible exit, if we were seeking.
   if( FillOutputBuffers(
         outputBuffer,
         framesPerBuffer,
         outputMeterFloats))
      return mCallbackReturn;
 
   // To move the cursor onwards.  (uses mMaxFramesOutput)
   UpdateTimePosition(framesPerBuffer);
 
   // To capture input into sequence (sound from microphone)
   DrainInputBuffers(
      inputBuffer,
      framesPerBuffer,
      statusFlags,
      tempFloats);
 
   SendVuOutputMeterData( outputMeterFloats, framesPerBuffer);
 
   return mCallbackReturn;
}

References AllSequencesAlreadySilent(), CheckSoundActivatedRecordingLevel(), CountSoloingSequences(), DoPlaythrough(), DrainInputBuffers(), Extensions(), FillOutputBuffers(), floatSample, GetMixerOutputVol(), AudioIOBase::IsPaused(), mbHasSoloSequences, mbMicroFades, mCallbackReturn, mCaptureFormat, mNumCaptureChannels, mNumPauseFrames, mNumPlaybackChannels, AudioIOBase::mRate, AudioIOBase::mStreamToken, SamplesToFloats(), SendVuInputMeterData(), SendVuOutputMeterData(), stackAllocate, and UpdateTimePosition().

Here is the call graph for this function:

◆ CallbackCheckCompletion()

void AudioIoCallback::CallbackCheckCompletion	(	int &	callbackReturn,
		unsigned long	len
	)

Definition at line 3276 of file AudioIO.cpp.

{
   if (IsPaused())
      return;
 
   bool done =
      mPlaybackSchedule.GetPolicy().Done(mPlaybackSchedule, len);
   if (!done)
      return;
 
   for( auto &ext : Extensions() )
      ext.SignalOtherCompletion();
   callbackReturn = paComplete;
}

References PlaybackPolicy::Done(), Extensions(), PlaybackSchedule::GetPolicy(), AudioIOBase::IsPaused(), and mPlaybackSchedule.

Referenced by FillOutputBuffers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CallbackDoSeek()

int AudioIoCallback::CallbackDoSeek ( )

Definition at line 3216 of file AudioIO.cpp.

{
   const int token = mStreamToken;
   wxMutexLocker locker(mSuspendAudioThread);
   if (token != mStreamToken)
      // This stream got destroyed while we waited for it
      return paAbort;
 
   // Pause audio thread and wait for it to finish
   //
   // [PM] the following 8 lines of code could be probably replaced by
   // a single call to StopAudioThreadAndWait()
   //
   // CAUTION: when trying the above, you must also replace the setting of the
   // atomic before the return, with a call to StartAudioThread()
   //
   // If that works, then we can remove mAudioThreadSequenceBufferExchangeLoopActive,
   // as it will become unused; consequently, the AudioThread loop would get simpler too.
   //
   mAudioThreadSequenceBufferExchangeLoopRunning
      .store(false, std::memory_order_relaxed);
 
   while( mAudioThreadSequenceBufferExchangeLoopActive
      .load(std::memory_order_relaxed ) )
   {
      using namespace std::chrono;
      std::this_thread::sleep_for(50ms);
   }
 
   // Calculate the NEW time position, in the PortAudio callback
   const auto time =
      mPlaybackSchedule.GetPolicy().OffsetSequenceTime( mPlaybackSchedule, mSeek );
 
   mPlaybackSchedule.SetSequenceTime( time );
   mSeek = 0.0;
 
 
   // Reset mixer positions and flush buffers for all sequences
   for (auto &mixer : mPlaybackMixers)
      mixer->Reposition( time, true );
   for (auto &buffer : mPlaybackBuffers) {
      const auto toDiscard = buffer->AvailForGet();
      const auto discarded = buffer->Discard( toDiscard );
      // wxASSERT( discarded == toDiscard );
      // but we can't assert in this thread
      wxUnusedVar(discarded);
   }
 
   mPlaybackSchedule.mTimeQueue.Prime(time);
 
   // Reload the ring buffers
   ProcessOnceAndWait();
 
   // Reenable the audio thread
   mAudioThreadSequenceBufferExchangeLoopRunning
      .store(true, std::memory_order_relaxed);
 
   return paContinue;
}

References PlaybackSchedule::GetPolicy(), mAudioThreadSequenceBufferExchangeLoopActive, mAudioThreadSequenceBufferExchangeLoopRunning, mPlaybackBuffers, mPlaybackMixers, mPlaybackSchedule, mSeek, AudioIOBase::mStreamToken, mSuspendAudioThread, PlaybackSchedule::mTimeQueue, PlaybackPolicy::OffsetSequenceTime(), PlaybackSchedule::TimeQueue::Prime(), ProcessOnceAndWait(), and PlaybackSchedule::SetSequenceTime().

Referenced by FillOutputBuffers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CheckSoundActivatedRecordingLevel()

void AudioIoCallback::CheckSoundActivatedRecordingLevel	(	float *	inputSamples,
		unsigned long	framesPerBuffer
	)

Definition at line 2541 of file AudioIO.cpp.

{
   // Quick returns if next to nothing to do.
   if( !mPauseRec )
      return;
 
   float maxPeak = 0.;
   for( unsigned long i = 0, cnt = framesPerBuffer * mNumCaptureChannels; i < cnt; ++i ) {
      float sample = fabs(*(inputSamples++));
      if (sample > maxPeak) {
         maxPeak = sample;
      }
   }
 
   bool bShouldBePaused = maxPeak < mSilenceLevel;
   if( bShouldBePaused != IsPaused() )
   {
      auto pListener = GetListener();
      if ( pListener )
         pListener->OnSoundActivationThreshold();
   }
}

References GetListener(), AudioIOBase::IsPaused(), mNumCaptureChannels, mPauseRec, and mSilenceLevel.

Referenced by AudioCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ClearRecordingException()

void AudioIoCallback::ClearRecordingException ( )

inlineprotected

Definition at line 383 of file AudioIO.h.

384 { if (mRecordingException) wxAtomicDec( mRecordingException ); }

AudioIoCallback::mRecordingException

wxAtomicInt mRecordingException

Definition: AudioIO.h:380

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

Here is the caller graph for this function:

◆ CountSoloingSequences()

unsigned AudioIoCallback::CountSoloingSequences ( )

Definition at line 3039 of file AudioIO.cpp.

                                               {
   const auto numPlaybackSequences = mPlaybackSequences.size();
 
   // MOVE_TO: CountSoloingSequences() function
   unsigned numSolo = 0;
   for (unsigned t = 0; t < numPlaybackSequences; t++ )
      if (mPlaybackSequences[t]->GetSolo())
         numSolo++;
   auto range = Extensions();
   numSolo += std::accumulate(range.begin(), range.end(), 0,
      [](unsigned sum, auto &ext){
         return sum + ext.CountOtherSolo(); });
   return numSolo;
}

References Extensions(), and mPlaybackSequences.

Referenced by AudioCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DoPlaythrough()

void AudioIoCallback::DoPlaythrough	(	constSamplePtr	inputBuffer,
		float *	outputBuffer,
		unsigned long	framesPerBuffer,
		float *	outputMeterFloats
	)

Definition at line 2959 of file AudioIO.cpp.

{
   const auto numCaptureChannels = mNumCaptureChannels;
   const auto numPlaybackChannels = mNumPlaybackChannels;
 
   // Quick returns if next to nothing to do.
   if( !outputBuffer )
      return;
   if( numPlaybackChannels <= 0 )
      return;
 
   float *outputFloats = outputBuffer;
   for(unsigned i = 0; i < framesPerBuffer*numPlaybackChannels; i++)
      outputFloats[i] = 0.0;
 
   if (inputBuffer && mSoftwarePlaythrough) {
      DoSoftwarePlaythrough(inputBuffer, mCaptureFormat,
                              numCaptureChannels,
                              outputBuffer, framesPerBuffer);
   }
 
   // Copy the results to outputMeterFloats if necessary
   if (outputMeterFloats != outputFloats) {
      for (unsigned i = 0; i < framesPerBuffer*numPlaybackChannels; ++i) {
         outputMeterFloats[i] = outputFloats[i];
      }
   }
}

References DoSoftwarePlaythrough(), mCaptureFormat, mNumCaptureChannels, mNumPlaybackChannels, and mSoftwarePlaythrough.

Referenced by AudioCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DrainInputBuffers()

void AudioIoCallback::DrainInputBuffers	(	constSamplePtr	inputBuffer,
		unsigned long	framesPerBuffer,
		const PaStreamCallbackFlags	statusFlags,
		float *	tempFloats
	)

Definition at line 2801 of file AudioIO.cpp.

{
   const auto numPlaybackChannels = mNumPlaybackChannels;
   const auto numCaptureChannels = mNumCaptureChannels;
 
   // Quick returns if next to nothing to do.
   if (mStreamToken <= 0)
      return;
   if( !inputBuffer )
      return;
   if( numCaptureChannels <= 0 )
      return;
 
   // If there are no playback sequences, and we are recording, then the
   // earlier checks for being past the end won't happen, so do it here.
   if (mPlaybackSchedule.GetPolicy().Done(mPlaybackSchedule, 0)) {
      mCallbackReturn = paComplete;
   }
 
   // The error likely from a too-busy CPU falling behind real-time data
   // is paInputOverflow
   bool inputError =
      (statusFlags & (paInputOverflow))
      && !(statusFlags & paPrimingOutput);
 
   // But it seems it's easy to get false positives, at least on Mac
   // So we have not decided to enable this extra detection yet in
   // production
 
   size_t len = framesPerBuffer;
   for(unsigned t = 0; t < numCaptureChannels; t++)
      len = std::min( len, mCaptureBuffers[t]->AvailForPut() );
 
   if (mSimulateRecordingErrors && 100LL * rand() < RAND_MAX)
      // Make spurious errors for purposes of testing the error
      // reporting
      len = 0;
 
   // A different symptom is that len < framesPerBuffer because
   // the other thread, executing SequenceBufferExchange, isn't consuming fast
   // enough from mCaptureBuffers; maybe it's CPU-bound, or maybe the
   // storage device it writes is too slow
   if (mDetectDropouts &&
         ((mDetectUpstreamDropouts.load(std::memory_order_relaxed)
           && inputError) ||
         len < framesPerBuffer) ) {
      // Assume that any good partial buffer should be written leftmost
      // and zeroes will be padded after; label the zeroes.
      auto start = mPlaybackSchedule.GetSequenceTime() +
            len / mRate + mRecordingSchedule.mLatencyCorrection;
      auto duration = (framesPerBuffer - len) / mRate;
      auto pLast = mLostCaptureIntervals.empty()
         ? nullptr : &mLostCaptureIntervals.back();
      if (pLast &&
          fabs(pLast->first + pLast->second - start) < 0.5/mRate)
         // Make one bigger interval, not two butting intervals
         pLast->second = start + duration - pLast->first;
      else
         mLostCaptureIntervals.emplace_back( start, duration );
   }
 
   if (len < framesPerBuffer)
   {
      mLostSamples += (framesPerBuffer - len);
      wxPrintf(wxT("lost %d samples\n"), (int)(framesPerBuffer - len));
   }
 
   if (len <= 0)
      return;
 
   // We have an ASSERT in the AudioIO constructor to alert us to
   // possible issues with the (short*) cast.  We'd have a problem if
   // sizeof(short) > sizeof(float) since our buffers are sized for floats.
   for(unsigned t = 0; t < numCaptureChannels; t++) {
 
      // dmazzoni:
      // Un-interleave.  Ugly special-case code required because the
      // capture channels could be in three different sample formats;
      // it'd be nice to be able to call CopySamples, but it can't
      // handle multiplying by the gain and then clipping.  Bummer.
 
      switch(mCaptureFormat) {
         case floatSample: {
            auto inputFloats = (const float *)inputBuffer;
            for(unsigned i = 0; i < len; i++)
               tempFloats[i] =
                  inputFloats[numCaptureChannels*i+t];
         } break;
         case int24Sample:
            // We should never get here. Audacity's int24Sample format
            // is different from PortAudio's sample format and so we
            // make PortAudio return float samples when recording in
            // 24-bit samples.
            wxASSERT(false);
            break;
         case int16Sample: {
            auto inputShorts = (const short *)inputBuffer;
            short *tempShorts = (short *)tempFloats;
            for( unsigned i = 0; i < len; i++) {
               float tmp = inputShorts[numCaptureChannels*i+t];
               tmp = std::clamp(tmp, -32768.0f, 32767.0f);
               tempShorts[i] = (short)(tmp);
            }
         } break;
      } // switch
 
      // JKC: mCaptureFormat must be for samples with sizeof(float) or
      // fewer bytes (because tempFloats is sized for floats).  All
      // formats are 2 or 4 bytes, so we are OK.
      const auto put =
         mCaptureBuffers[t]->Put(
            (samplePtr)tempFloats, mCaptureFormat, len);
      // wxASSERT(put == len);
      // but we can't assert in this thread
      wxUnusedVar(put);
      mCaptureBuffers[t]->Flush();
   }
}

References PlaybackPolicy::Done(), floatSample, PlaybackSchedule::GetPolicy(), PlaybackSchedule::GetSequenceTime(), int16Sample, int24Sample, mCallbackReturn, mCaptureBuffers, mCaptureFormat, mDetectDropouts, mDetectUpstreamDropouts, min(), RecordingSchedule::mLatencyCorrection, mLostCaptureIntervals, mLostSamples, mNumCaptureChannels, mNumPlaybackChannels, mPlaybackSchedule, AudioIOBase::mRate, mRecordingSchedule, mSimulateRecordingErrors, AudioIOBase::mStreamToken, and wxT().

Referenced by AudioCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Extensions()

AudioIOExtRange AudioIoCallback::Extensions ( )

inline

Definition at line 161 of file AudioIO.h.

                                {
      return {
         AudioIOExtIterator{ *this, false },
         AudioIOExtIterator{ *this, true }
      };
   }

Referenced by AudioCallback(), CallbackCheckCompletion(), CountSoloingSequences(), AudioIO::StartStream(), and AudioIO::StopStream().

Here is the caller graph for this function:

◆ FillOutputBuffers()

bool AudioIoCallback::FillOutputBuffers	(	float *	outputBuffer,
		unsigned long	framesPerBuffer,
		float *	outputMeterFloats
	)

Definition at line 2623 of file AudioIO.cpp.

{
   const auto numPlaybackSequences = mPlaybackSequences.size();
   const auto numPlaybackChannels = mNumPlaybackChannels;
   const auto numCaptureChannels = mNumCaptureChannels;
 
   mMaxFramesOutput = 0;
 
   // Quick returns if next to nothing to do.
   if (mStreamToken <= 0 ||
       !outputBuffer ||
       numPlaybackChannels <= 0) {
      // So that UpdateTimePosition() will be correct, in case of MIDI play with
      // no audio output channels
      mMaxFramesOutput = framesPerBuffer;
      return false;
   }
 
   float *outputFloats = outputBuffer;
 
   if (mSeek && !mPlaybackSchedule.GetPolicy().AllowSeek(mPlaybackSchedule))
      mSeek = 0.0;
 
   if (mSeek){
      mCallbackReturn = CallbackDoSeek();
      return true;
   }
 
   // ------ MEMORY ALLOCATION ----------------------
   // These are small structures.
   const auto tempBufs = stackAllocate(float *, numPlaybackChannels);
 
   // And these are larger structures....
   for (unsigned int c = 0; c < numPlaybackChannels; c++)
      tempBufs[c] = stackAllocate(float, framesPerBuffer);
   // ------ End of MEMORY ALLOCATION ---------------
 
   // Choose a common size to take from all ring buffers
   const auto toGet =
      std::min<size_t>(framesPerBuffer, GetCommonlyReadyPlayback());
 
   // The drop and dropQuickly booleans are so named for historical reasons.
   // JKC: The original code attempted to be faster by doing nothing on silenced audio.
   // This, IMHO, is 'premature optimisation'.  Instead clearer and cleaner code would
   // simply use a gain of 0.0 for silent audio and go on through to the stage of
   // applying that 0.0 gain to the data mixed into the buffer.
   // Then (and only then) we would have if needed fast paths for:
   // - Applying a uniform gain of 0.0.
   // - Applying a uniform gain of 1.0.
   // - Applying some other uniform gain.
   // - Applying a linearly interpolated gain.
   // I would expect us not to need the fast paths, since linearly interpolated gain
   // is very cheap to process.
 
   bool drop = false;        // Sequence should become silent.
   bool discardable = false; // Sequence has already been faded to silence.
   // mPlaybackBuffers buffers correspond many-to-one with mPlaybackSequences
   size_t iBuffer = 0;
   for (unsigned tt = 0; tt < numPlaybackSequences; ++tt) {
      auto vt = mPlaybackSequences[tt].get();
      const auto width = vt->NChannels();
 
      // IF mono THEN clear 'the other' channel.
      if (width < numPlaybackChannels)
         // TODO: more-than-two-channels
         memset(tempBufs[1], 0, framesPerBuffer * sizeof(float));
 
      // Check for asynchronous user changes in mute, solo, pause status
      discardable = drop = SequenceShouldBeSilent(*vt);
 
      if (mbMicroFades)
         // If micro fading, don't silence tracks instantaneously
         discardable = discardable &&
            SequenceHasBeenFadedOut(mOldChannelGains[tt]);
 
      decltype(framesPerBuffer) len = 0;
 
      for (size_t c = 0; c < width; ++c) {
         if (discardable) {
            len = mPlaybackBuffers[iBuffer]->Discard(toGet);
            // keep going here.
            // we may still need to issue a paComplete.
 
            // Keep tempBufs initialized to avoid NaNs and Infs
            memset(tempBufs[c], 0, framesPerBuffer * sizeof(float));
         }
         else {
            len = mPlaybackBuffers[iBuffer]
               ->Get((samplePtr)tempBufs[c], floatSample, toGet);
            // wxASSERT( len == toGet );
            if (len < framesPerBuffer)
               // This used to happen normally at the end of non-looping
               // plays, but it can also be an anomalous case where the
               // supply from SequenceBufferExchange fails to keep up with the
               // real-time demand in this thread (see bug 1932).  We
               // must supply something to the sound card, so pad it with
               // zeroes and not random garbage.
               memset((void*)&tempBufs[c][len], 0,
                  (framesPerBuffer - len) * sizeof(float));
         }
         ++iBuffer;
      }
 
      // PRL:  More recent rewrites of SequenceBufferExchange should guarantee a
      // padding out of the ring buffers so that equal lengths are
      // available, so maxLen ought to increase from 0 only once
      mMaxFramesOutput = std::max(mMaxFramesOutput, len);
 
      len = mMaxFramesOutput;
 
      // Realtime effect transformation of the sound used to happen here
      // but it is now done already on the producer side of the RingBuffer
 
      // Mix the results with the existing output (software playthrough) and
      // apply panning.  If post panning effects are desired, the panning would
      // need to be be split out from the mixing and applied in a separate step.
 
      // Our channels aren't silent.  We need to pass their data on.
      //
      // Each channel in the sequences can output to more than one channel on
      // the device. For example mono channels output to both left and right
      // output channels.
      if (len > 0) {
         auto &gains = mOldChannelGains[tt];
         AddToOutputChannel(0, outputMeterFloats, outputFloats,
            tempBufs[0], drop, len, *vt, gains[0]);
 
         // If one of mPlaybackSequences is mono, this replicates it in both
         // device channels
         const auto iBuffer = std::min<size_t>(1, width - 1);
         AddToOutputChannel(1, outputMeterFloats, outputFloats,
            tempBufs[iBuffer], drop, len, *vt, gains[1]);
      }
 
      CallbackCheckCompletion(mCallbackReturn, len);
      if (discardable) // no samples to process, they've been discarded
         continue;
   }
 
   // Poke: If there are no playback sequences, then the earlier check
   // about the time indicator being past the end won't happen;
   // do it here instead (but not if looping or scrubbing)
   // PRL:  Also consume from the single playback ring buffer
   if (numPlaybackSequences == 0) {
      mMaxFramesOutput = mPlaybackBuffers[0]->Discard(toGet);
      CallbackCheckCompletion(mCallbackReturn, 0);
   }
 
   // wxASSERT( maxLen == toGet );
 
   mLastPlaybackTimeMillis = ::wxGetUTCTimeMillis();
 
   ClampBuffer( outputFloats, framesPerBuffer*numPlaybackChannels );
   if (outputMeterFloats != outputFloats)
      ClampBuffer( outputMeterFloats, framesPerBuffer*numPlaybackChannels );
 
   return false;
}

References AddToOutputChannel(), PlaybackPolicy::AllowSeek(), CallbackCheckCompletion(), CallbackDoSeek(), ClampBuffer(), floatSample, GetCommonlyReadyPlayback(), PlaybackSchedule::GetPolicy(), mbMicroFades, mCallbackReturn, mLastPlaybackTimeMillis, mMaxFramesOutput, mNumCaptureChannels, mNumPlaybackChannels, mOldChannelGains, mPlaybackBuffers, mPlaybackSchedule, mPlaybackSequences, mSeek, AudioIOBase::mStreamToken, SequenceHasBeenFadedOut(), SequenceShouldBeSilent(), and stackAllocate.

Referenced by AudioCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetCommonlyReadyPlayback()

size_t AudioIoCallback::GetCommonlyReadyPlayback ( )

Get the number of audio samples ready in all of the playback buffers.

Returns the smallest of the buffer ready space values in the event that they are different.

Definition at line 1880 of file AudioIO.cpp.

{
   return MinValue(mPlaybackBuffers, &RingBuffer::AvailForGet);
}

References RingBuffer::AvailForGet(), MinValue(), and mPlaybackBuffers.

Referenced by FillOutputBuffers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetCommonlyWrittenForPlayback()

size_t AudioIoCallback::GetCommonlyWrittenForPlayback ( )

Definition at line 1885 of file AudioIO.cpp.

{
   return MinValue(mPlaybackBuffers, &RingBuffer::WrittenForGet);
}

References MinValue(), mPlaybackBuffers, and RingBuffer::WrittenForGet().

Referenced by AudioIO::FillPlayBuffers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetListener()

std::shared_ptr< AudioIOListener > AudioIoCallback::GetListener ( ) const

inline

Definition at line 169 of file AudioIO.h.

170 { return mListener.lock(); }

AudioIoCallback::mListener

std::weak_ptr< AudioIOListener > mListener

Definition: AudioIO.h:356

Referenced by CheckSoundActivatedRecordingLevel(), AudioIO::DrainRecordBuffers(), AudioIO::StartMonitoring(), AudioIO::StartStream(), and AudioIO::StopStream().

Here is the caller graph for this function:

◆ GetMixerOutputVol()

float AudioIoCallback::GetMixerOutputVol ( )

inlineprotected

Definition at line 348 of file AudioIO.h.

348 {

349 return mMixerOutputVol.load(std::memory_order_relaxed); }

AudioIoCallback::mMixerOutputVol

std::atomic< float > mMixerOutputVol

Definition: AudioIO.h:286

Referenced by AddToOutputChannel(), AudioCallback(), and AudioIO::GetMixer().

Here is the caller graph for this function:

◆ HasRecordingException()

bool AudioIoCallback::HasRecordingException ( ) const

inline

Definition at line 374 of file AudioIO.h.

375 { return mRecordingException; }

Referenced by ProjectAudioManager::OnAudioIOStopRecording().

Here is the caller graph for this function:

◆ LostCaptureIntervals()

const std::vector< std::pair< double, double > > & AudioIoCallback::LostCaptureIntervals ( )

inline

Definition at line 392 of file AudioIO.h.

393 { return mLostCaptureIntervals; }

◆ MinValue()

size_t AudioIoCallback::MinValue	(	const RingBuffers &	buffers,
		size_t(RingBuffer::*)() const	pmf
	)

staticprotected

Definition at line 1863 of file AudioIO.cpp.

{
   return std::accumulate(buffers.begin(), buffers.end(),
      std::numeric_limits<size_t>::max(),
      [pmf](auto value, auto &pBuffer){
         return std::min(value, (pBuffer.get()->*pmf)()); });
}

Referenced by AudioIO::GetCommonlyAvailCapture(), AudioIO::GetCommonlyFreePlayback(), GetCommonlyReadyPlayback(), and GetCommonlyWrittenForPlayback().

Here is the caller graph for this function:

◆ ProcessOnceAndWait()

void AudioIoCallback::ProcessOnceAndWait ( std::chrono::milliseconds sleepTime = std::chrono::milliseconds(50) )

Definition at line 3330 of file AudioIO.cpp.

{
   mAudioThreadShouldCallSequenceBufferExchangeOnce
      .store(true, std::memory_order_release);
 
   while (mAudioThreadShouldCallSequenceBufferExchangeOnce
      .load(std::memory_order_acquire))
   {
      using namespace std::chrono;
      std::this_thread::sleep_for(sleepTime);
   }
}

References mAudioThreadShouldCallSequenceBufferExchangeOnce.

Referenced by CallbackDoSeek(), and AudioIO::StopStream().

Here is the caller graph for this function:

◆ SendVuInputMeterData()

void AudioIoCallback::SendVuInputMeterData	(	const float *	inputSamples,
		unsigned long	framesPerBuffer
	)

Definition at line 2995 of file AudioIO.cpp.

{
   const auto numCaptureChannels = mNumCaptureChannels;
   auto pInputMeter = mInputMeter.lock();
   if ( !pInputMeter )
      return;
   if( pInputMeter->IsMeterDisabled())
      return;
   pInputMeter->UpdateDisplay(
      numCaptureChannels, framesPerBuffer, inputSamples);
}

References AudioIOBase::mInputMeter, and mNumCaptureChannels.

Referenced by AudioCallback().

Here is the caller graph for this function:

◆ SendVuOutputMeterData()

void AudioIoCallback::SendVuOutputMeterData	(	const float *	outputMeterFloats,
		unsigned long	framesPerBuffer
	)

Definition at line 3011 of file AudioIO.cpp.

{
   const auto numPlaybackChannels = mNumPlaybackChannels;
 
   auto pOutputMeter = mOutputMeter.lock();
   if (!pOutputMeter)
      return;
   if( pOutputMeter->IsMeterDisabled() )
      return;
   if( !outputMeterFloats)
      return;
   pOutputMeter->UpdateDisplay(
      numPlaybackChannels, framesPerBuffer, outputMeterFloats);
 
      //v Vaughan, 2011-02-25: Moved this update back to TrackPanel::OnTimer()
      //    as it helps with playback issues reported by Bill and noted on Bug 258.
      //    The problem there occurs if Software Playthrough is on.
      //    Could conditionally do the update here if Software Playthrough is off,
      //    and in TrackPanel::OnTimer() if Software Playthrough is on, but not now.
      // PRL 12 Jul 2015: and what was in TrackPanel::OnTimer is now handled by means of track panel timer events
      //MixerBoard* pMixerBoard = mOwningProject->GetMixerBoard();
      //if (pMixerBoard)
      //   pMixerBoard->UpdateMeters(GetStreamTime(),
      //                              (pProj->GetControlToolBar()->GetLastPlayMode() == loopedPlay));
}

References mNumPlaybackChannels, and AudioIOBase::mOutputMeter.

Referenced by AudioCallback().

Here is the caller graph for this function:

◆ SequenceHasBeenFadedOut()

bool AudioIoCallback::SequenceHasBeenFadedOut ( const OldChannelGains & gains )

Returns true when playback buffer data from both channels is discardable.

Definition at line 3071 of file AudioIO.cpp.

{
   return gains[0] == 0.0 && gains[1] == 0.0;
}

Referenced by AllSequencesAlreadySilent(), and FillOutputBuffers().

Here is the caller graph for this function:

◆ SequenceShouldBeSilent()

bool AudioIoCallback::SequenceShouldBeSilent ( const PlayableSequence & ps )

Definition at line 3060 of file AudioIO.cpp.

{
   return IsPaused() || (!ps.GetSolo() && (
      // Cut if somebody else is soloing
      mbHasSoloSequences ||
      // Cut if we're muted (and not soloing)
      ps.GetMute()
   ));
}

References PlayableSequence::GetMute(), PlayableSequence::GetSolo(), AudioIOBase::IsPaused(), and mbHasSoloSequences.

Referenced by AllSequencesAlreadySilent(), and FillOutputBuffers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetListener()

void AudioIoCallback::SetListener ( const std::shared_ptr< AudioIOListener > & listener )

Definition at line 2324 of file AudioIO.cpp.

{
   if (IsBusy())
      return;
 
   mListener = listener;
}

References AudioIOBase::IsBusy(), and mListener.

Here is the call graph for this function:

◆ SetMixerOutputVol()

void AudioIoCallback::SetMixerOutputVol ( float value )

inlineprotected

Definition at line 350 of file AudioIO.h.

350 {

351 mMixerOutputVol.store(value, std::memory_order_relaxed); }

Referenced by AudioIO::AudioIO(), and AudioIO::SetMixer().

Here is the caller graph for this function:

◆ SetRecordingException()

void AudioIoCallback::SetRecordingException ( )

inlineprotected

Definition at line 381 of file AudioIO.h.

382 { wxAtomicInc( mRecordingException ); }

Referenced by AudioIO::DrainRecordBuffers().

Here is the caller graph for this function:

◆ StartAudioThread()

void AudioIoCallback::StartAudioThread ( )

Definition at line 3300 of file AudioIO.cpp.

{
   mAudioThreadSequenceBufferExchangeLoopRunning.store(true, std::memory_order_release);
}

References mAudioThreadSequenceBufferExchangeLoopRunning.

Referenced by AudioIO::StartStream().

Here is the caller graph for this function:

◆ StopAudioThread()

void AudioIoCallback::StopAudioThread ( )

Definition at line 3315 of file AudioIO.cpp.

{
   mAudioThreadSequenceBufferExchangeLoopRunning.store(false, std::memory_order_release);
}

References mAudioThreadSequenceBufferExchangeLoopRunning.

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

Here is the caller graph for this function:

◆ UpdateTimePosition()

void AudioIoCallback::UpdateTimePosition ( unsigned long framesPerBuffer )

Definition at line 2786 of file AudioIO.cpp.

{
   // Quick returns if next to nothing to do.
   if (mStreamToken <= 0)
      return;
 
   // Update the position seen by drawing code
   mPlaybackSchedule.SetSequenceTime(
      mPlaybackSchedule.mTimeQueue.Consumer( mMaxFramesOutput, mRate ) );
}

References PlaybackSchedule::TimeQueue::Consumer(), mMaxFramesOutput, mPlaybackSchedule, AudioIOBase::mRate, AudioIOBase::mStreamToken, PlaybackSchedule::mTimeQueue, and PlaybackSchedule::SetSequenceTime().

Referenced by AudioCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ WaitForAudioThreadStarted()

void AudioIoCallback::WaitForAudioThreadStarted ( )

Definition at line 3305 of file AudioIO.cpp.

{
   while (mAudioThreadAcknowledge.load(std::memory_order_acquire) != Acknowledge::eStart)
   {
      using namespace std::chrono;
      std::this_thread::sleep_for(50ms);
   }
   mAudioThreadAcknowledge.store(Acknowledge::eNone, std::memory_order_release);
}

References eNone, eStart, and mAudioThreadAcknowledge.

Referenced by AudioIO::StartStream().

Here is the caller graph for this function:

◆ WaitForAudioThreadStopped()

void AudioIoCallback::WaitForAudioThreadStopped ( )

Definition at line 3320 of file AudioIO.cpp.

{
   while (mAudioThreadAcknowledge.load(std::memory_order_acquire) != Acknowledge::eStop)
   {
      using namespace std::chrono;
      std::this_thread::sleep_for(50ms);
   }
   mAudioThreadAcknowledge.store(Acknowledge::eNone, std::memory_order_release);
}

References eNone, eStop, and mAudioThreadAcknowledge.

Referenced by AudioIO::StopStream().

Here is the caller graph for this function:

Member Data Documentation

◆ mAudioIOExt

std::vector<std::unique_ptr<AudioIOExtBase> > AudioIOBase::mAudioIOExt

private

Privatize the inherited array but give access by Extensions(). This class guarantees that this array is populated only with non-null pointers to the subtype AudioIOExt

Definition at line 322 of file AudioIOBase.h.

Referenced by AudioIoCallback().

◆ mAudioThread

std::thread AudioIoCallback::mAudioThread

Definition at line 266 of file AudioIO.h.

Referenced by AudioIO::StartThread(), and AudioIO::~AudioIO().

◆ mAudioThreadAcknowledge

std::atomic<Acknowledge> AudioIoCallback::mAudioThreadAcknowledge

Definition at line 322 of file AudioIO.h.

Referenced by AudioIO::AudioIO(), AudioIO::AudioThread(), WaitForAudioThreadStarted(), and WaitForAudioThreadStopped().

◆ mAudioThreadSequenceBufferExchangeLoopActive

std::atomic<bool> AudioIoCallback::mAudioThreadSequenceBufferExchangeLoopActive

Definition at line 320 of file AudioIO.h.

Referenced by AudioIO::AudioIO(), AudioIO::AudioThread(), and CallbackDoSeek().

◆ mAudioThreadSequenceBufferExchangeLoopRunning

std::atomic<bool> AudioIoCallback::mAudioThreadSequenceBufferExchangeLoopRunning

Definition at line 319 of file AudioIO.h.

Referenced by AudioIO::AudioIO(), AudioIO::AudioThread(), CallbackDoSeek(), StartAudioThread(), StopAudioThread(), and AudioIO::StopStream().

◆ mAudioThreadShouldCallSequenceBufferExchangeOnce

std::atomic<bool> AudioIoCallback::mAudioThreadShouldCallSequenceBufferExchangeOnce

Definition at line 318 of file AudioIO.h.

Referenced by AudioIO::AudioIO(), AudioIO::AudioThread(), AudioIO::DrainRecordBuffers(), ProcessOnceAndWait(), and AudioIO::StartStream().

◆ mbHasSoloSequences

int AudioIoCallback::mbHasSoloSequences

Definition at line 180 of file AudioIO.h.

Referenced by AudioCallback(), and SequenceShouldBeSilent().

◆ mbMicroFades

bool AudioIoCallback::mbMicroFades

Read by a worker thread but unchanging during playback

Definition at line 291 of file AudioIO.h.

Referenced by AddToOutputChannel(), AudioCallback(), FillOutputBuffers(), AudioIO::StartStream(), and AudioIO::StopStream().

◆ mCachedBestRateCapturing

bool AudioIoCallback::mCachedBestRateCapturing

staticprotected

Definition at line 364 of file AudioIO.h.

Referenced by AudioIO::GetBestRate().

◆ mCachedBestRateOut

double AudioIoCallback::mCachedBestRateOut

staticprotected

Definition at line 362 of file AudioIO.h.

Referenced by AudioIO::GetBestRate().

◆ mCachedBestRatePlaying

bool AudioIoCallback::mCachedBestRatePlaying

staticprotected

Definition at line 363 of file AudioIO.h.

Referenced by AudioIO::GetBestRate().

◆ mCallbackReturn

int AudioIoCallback::mCallbackReturn

Definition at line 181 of file AudioIO.h.

Referenced by AudioCallback(), DrainInputBuffers(), and FillOutputBuffers().

◆ mCaptureBuffers

RingBuffers AudioIoCallback::mCaptureBuffers

Definition at line 272 of file AudioIO.h.

Referenced by AudioIO::AllocateBuffers(), DrainInputBuffers(), AudioIO::DrainRecordBuffers(), AudioIO::GetCommonlyAvailCapture(), AudioIO::StartStream(), AudioIO::StartStreamCleanup(), and AudioIO::StopStream().

◆ mCaptureFormat

sampleFormat AudioIoCallback::mCaptureFormat

Definition at line 315 of file AudioIO.h.

Referenced by AudioIO::AllocateBuffers(), AudioCallback(), DoPlaythrough(), DrainInputBuffers(), AudioIO::DrainRecordBuffers(), AudioIO::StartMonitoring(), AudioIO::StartPortAudioStream(), and AudioIO::StartStream().

◆ mCaptureRate

double AudioIoCallback::mCaptureRate {}

Definition at line 316 of file AudioIO.h.

Referenced by AudioIO::DrainRecordBuffers(), AudioIO::StartMonitoring(), and AudioIO::StartStream().

◆ mCaptureRingBufferSecs

double AudioIoCallback::mCaptureRingBufferSecs

Definition at line 295 of file AudioIO.h.

Referenced by AudioIO::AllocateBuffers().

◆ mCaptureSequences

RecordableSequences AudioIoCallback::mCaptureSequences

Definition at line 273 of file AudioIO.h.

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

◆ mDetectDropouts

bool AudioIoCallback::mDetectDropouts { true }

protected

Read by a worker thread but unchanging during playback

Definition at line 388 of file AudioIO.h.

Referenced by DrainInputBuffers(), and AudioIO::StartStream().

◆ mDetectUpstreamDropouts

std::atomic<bool> AudioIoCallback::mDetectUpstreamDropouts { true }

Definition at line 400 of file AudioIO.h.

Referenced by DrainInputBuffers(), and anonymous_namespace{PluginMenus.cpp}::ToolsMenu().

◆ mFactor

double AudioIoCallback::mFactor

Definition at line 288 of file AudioIO.h.

Referenced by AudioIO::AllocateBuffers(), and AudioIO::DrainRecordBuffers().

◆ mFinishAudioThread

std::atomic<bool> AudioIoCallback::mFinishAudioThread { false }

Definition at line 267 of file AudioIO.h.

Referenced by AudioIO::StartThread(), and AudioIO::~AudioIO().

◆ mForceFadeOut

std::atomic<bool> AudioIoCallback::mForceFadeOut { false }

Definition at line 336 of file AudioIO.h.

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

◆ mHardwarePlaybackLatencyFrames

size_t AudioIoCallback::mHardwarePlaybackLatencyFrames {}

Hardware output latency in frames.

Definition at line 300 of file AudioIO.h.

Referenced by AudioIO::AllocateBuffers(), and AudioIO::StartPortAudioStream().

◆ mLastPaError

PaError AudioIoCallback::mLastPaError

Definition at line 342 of file AudioIO.h.

Referenced by AudioIO::AudioIO(), AudioIO::LastPaErrorString(), AudioIO::StartMonitoring(), and AudioIO::StartPortAudioStream().

◆ mLastPlaybackTimeMillis

wxLongLong AudioIoCallback::mLastPlaybackTimeMillis

Definition at line 338 of file AudioIO.h.

Referenced by AudioIO::AudioIO(), and FillOutputBuffers().

◆ mLastRecordingOffset

double AudioIoCallback::mLastRecordingOffset

Not (yet) used; should perhaps be atomic when it is.

Definition at line 341 of file AudioIO.h.

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

◆ mListener

std::weak_ptr< AudioIOListener > AudioIoCallback::mListener

protected

Pointer is read by a worker thread but unchanging during playback. (Whether its overriding methods are race-free is not for AudioIO to ensure.)

Definition at line 356 of file AudioIO.h.

Referenced by SetListener(), and AudioIO::StartStream().

◆ mLostCaptureIntervals

std::vector< std::pair<double, double> > AudioIoCallback::mLostCaptureIntervals

protected

Definition at line 386 of file AudioIO.h.

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

◆ mLostSamples

unsigned long long AudioIoCallback::mLostSamples { 0 }

Definition at line 317 of file AudioIO.h.

Referenced by DrainInputBuffers(), and AudioIO::StartStream().

◆ mMaxFramesOutput

unsigned long AudioIoCallback::mMaxFramesOutput

Definition at line 289 of file AudioIO.h.

Referenced by FillOutputBuffers(), and UpdateTimePosition().

◆ mMinCaptureSecsToCopy

double AudioIoCallback::mMinCaptureSecsToCopy

Definition at line 304 of file AudioIO.h.

Referenced by AudioIO::AllocateBuffers(), and AudioIO::DrainRecordBuffers().

◆ mMixerOutputVol

std::atomic<float> AudioIoCallback::mMixerOutputVol { 1.0 }

Definition at line 286 of file AudioIO.h.

◆ mNextStreamToken

int AudioIoCallback::mNextStreamToken = 0

static

Definition at line 287 of file AudioIO.h.

Referenced by AudioIO::StartStream().

◆ mNumCaptureChannels

size_t AudioIoCallback::mNumCaptureChannels

Read by a worker thread but unchanging during playback

Definition at line 312 of file AudioIO.h.

Referenced by AudioIO::AllocateBuffers(), AudioCallback(), AudioIO::AudioIO(), CheckSoundActivatedRecordingLevel(), AudioIO::DelayingActions(), DoPlaythrough(), DrainInputBuffers(), AudioIO::DrainRecordBuffers(), FillOutputBuffers(), SendVuInputMeterData(), AudioIO::StartPortAudioStream(), AudioIO::StartStream(), and AudioIO::StopStream().

◆ mNumPauseFrames

long AudioIoCallback::mNumPauseFrames

How many frames of zeros were output due to pauses?

Definition at line 247 of file AudioIO.h.

Referenced by AudioCallback(), AudioIO::AudioIO(), and AudioIO::StartPortAudioStream().

◆ mNumPlaybackChannels

size_t AudioIoCallback::mNumPlaybackChannels

Read by a worker thread but unchanging during playback

Definition at line 314 of file AudioIO.h.

Referenced by AddToOutputChannel(), AudioIO::AllocateBuffers(), AudioCallback(), DoPlaythrough(), DrainInputBuffers(), FillOutputBuffers(), AudioIO::FillPlayBuffers(), SendVuOutputMeterData(), AudioIO::StartPortAudioStream(), AudioIO::StartStream(), AudioIO::StopStream(), and AudioIO::TransformPlayBuffers().

◆ mOldChannelGains

std::vector<OldChannelGains> AudioIoCallback::mOldChannelGains

Definition at line 279 of file AudioIO.h.

Referenced by AudioIO::AllocateBuffers(), AllSequencesAlreadySilent(), and FillOutputBuffers().

◆ mPauseRec

bool AudioIoCallback::mPauseRec

True if Sound Activated Recording is enabled.

Read by a worker thread but unchanging during playback

Definition at line 309 of file AudioIO.h.

Referenced by CheckSoundActivatedRecordingLevel(), and AudioIO::StartStream().

◆ mPlaybackBuffers

RingBuffers AudioIoCallback::mPlaybackBuffers

Read by worker threads but unchanging during playback

Definition at line 275 of file AudioIO.h.

Referenced by AudioIO::AllocateBuffers(), CallbackDoSeek(), FillOutputBuffers(), AudioIO::FillPlayBuffers(), AudioIO::GetCommonlyFreePlayback(), GetCommonlyReadyPlayback(), GetCommonlyWrittenForPlayback(), AudioIO::ProcessPlaybackSlices(), AudioIO::StartStream(), AudioIO::StartStreamCleanup(), AudioIO::StopStream(), and AudioIO::TransformPlayBuffers().

◆ mPlaybackMixers

std::vector<std::unique_ptr<Mixer> > AudioIoCallback::mPlaybackMixers

Definition at line 284 of file AudioIO.h.

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

◆ mPlaybackQueueMinimum

size_t AudioIoCallback::mPlaybackQueueMinimum

Occupancy of the queue we try to maintain, with bigger batches if needed.

Definition at line 302 of file AudioIO.h.

Referenced by AudioIO::AllocateBuffers(), and AudioIO::FillPlayBuffers().

◆ mPlaybackRingBufferSecs

PlaybackPolicy::Duration AudioIoCallback::mPlaybackRingBufferSecs

Definition at line 294 of file AudioIO.h.

Referenced by AudioIO::AllocateBuffers().

◆ mPlaybackSamplesToCopy

size_t AudioIoCallback::mPlaybackSamplesToCopy

Preferred batch size for replenishing the playback RingBuffer.

Definition at line 298 of file AudioIO.h.

Referenced by AudioIO::AllocateBuffers(), and AudioIO::FillPlayBuffers().

◆ mPlaybackSchedule

PlaybackSchedule AudioIoCallback::mPlaybackSchedule

protected

Definition at line 404 of file AudioIO.h.

Referenced by AudioIO::AllocateBuffers(), AudioIoCallback(), AudioIO::AudioThread(), CallbackCheckCompletion(), CallbackDoSeek(), DrainInputBuffers(), FillOutputBuffers(), AudioIO::GetStreamTime(), AudioIO::IsCapturing(), AudioIO::ProcessPlaybackSlices(), AudioIO::StartStream(), AudioIO::StartStreamCleanup(), AudioIO::StopStream(), and UpdateTimePosition().

◆ mPlaybackSequences

ConstPlayableSequences AudioIoCallback::mPlaybackSequences

Definition at line 276 of file AudioIO.h.

Referenced by AudioIO::AllocateBuffers(), AllSequencesAlreadySilent(), CountSoloingSequences(), FillOutputBuffers(), AudioIO::ProcessPlaybackSlices(), AudioIO::StartStream(), AudioIO::StopStream(), and AudioIO::TransformPlayBuffers().

◆ mpTransportState

std::unique_ptr<TransportState> AudioIoCallback::mpTransportState

protected

Holds some state for duration of playback or recording.

Definition at line 408 of file AudioIO.h.

Referenced by AudioIO::AddState(), AudioIO::FillPlayBuffers(), AudioIO::RemoveState(), AudioIO::ReplaceState(), AudioIO::StartStream(), AudioIO::StartStreamCleanup(), and AudioIO::StopStream().

◆ mRecordingException

wxAtomicInt AudioIoCallback::mRecordingException {}

protected

Definition at line 380 of file AudioIO.h.

Referenced by AudioIO::DrainRecordBuffers().

◆ mRecordingSchedule

RecordingSchedule AudioIoCallback::mRecordingSchedule {}

protected

Definition at line 403 of file AudioIO.h.

Referenced by DrainInputBuffers(), AudioIO::DrainRecordBuffers(), AudioIO::IsCapturing(), AudioIO::StartStream(), and AudioIO::StopStream().

◆ mResample

std::vector<std::unique_ptr<Resample> > AudioIoCallback::mResample

Definition at line 269 of file AudioIO.h.

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

◆ mScratchBuffers

std::vector<SampleBuffer> AudioIoCallback::mScratchBuffers

Definition at line 281 of file AudioIO.h.

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

◆ mScratchPointers

std::vector<float *> AudioIoCallback::mScratchPointers

pointing into mScratchBuffers

Definition at line 282 of file AudioIO.h.

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

◆ mSeek

double AudioIoCallback::mSeek

Definition at line 293 of file AudioIO.h.

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

◆ mSilenceLevel

float AudioIoCallback::mSilenceLevel

Definition at line 310 of file AudioIO.h.

Referenced by AudioIO::AudioIO(), CheckSoundActivatedRecordingLevel(), and AudioIO::StartStream().

◆ mSimulateRecordingErrors

bool AudioIoCallback::mSimulateRecordingErrors { false }

Definition at line 396 of file AudioIO.h.

Referenced by DrainInputBuffers(), and anonymous_namespace{PluginMenus.cpp}::ToolsMenu().

◆ mSoftwarePlaythrough

bool AudioIoCallback::mSoftwarePlaythrough

Read by a worker thread but unchanging during playback

Definition at line 306 of file AudioIO.h.

Referenced by DoPlaythrough(), AudioIO::StartMonitoring(), AudioIO::StartPortAudioStream(), and AudioIO::StartStream().

◆ mSuspendAudioThread

wxMutex AudioIoCallback::mSuspendAudioThread

protected

Definition at line 368 of file AudioIO.h.

Referenced by CallbackDoSeek(), and AudioIO::StopStream().

◆ mUsingAlsa

bool AudioIoCallback::mUsingAlsa { false }

protected

Definition at line 358 of file AudioIO.h.

Referenced by AudioIO::StartMonitoring(), AudioIO::StartPortAudioStream(), and AudioIO::StartStream().

◆ mUsingJack

bool AudioIoCallback::mUsingJack { false }

protected

Definition at line 359 of file AudioIO.h.

Referenced by AudioIO::StartPortAudioStream().

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

Classes

Public Types

Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ OldChannelGains

◆ RingBuffers

Constructor & Destructor Documentation

◆ AudioIoCallback()

◆ ~AudioIoCallback()

Member Function Documentation

◆ AddToOutputChannel()

◆ AllSequencesAlreadySilent()

◆ AudioCallback()

◆ CallbackCheckCompletion()

◆ CallbackDoSeek()

◆ CheckSoundActivatedRecordingLevel()

◆ ClearRecordingException()

◆ CountSoloingSequences()

◆ DoPlaythrough()

◆ DrainInputBuffers()

◆ Extensions()

◆ FillOutputBuffers()

◆ GetCommonlyReadyPlayback()

◆ GetCommonlyWrittenForPlayback()

◆ GetListener()

◆ GetMixerOutputVol()

◆ HasRecordingException()

◆ LostCaptureIntervals()

◆ MinValue()

◆ ProcessOnceAndWait()

◆ SendVuInputMeterData()

◆ SendVuOutputMeterData()

◆ SequenceHasBeenFadedOut()

◆ SequenceShouldBeSilent()

◆ SetListener()

◆ SetMixerOutputVol()

◆ SetRecordingException()

◆ StartAudioThread()

◆ StopAudioThread()

◆ UpdateTimePosition()

◆ WaitForAudioThreadStarted()

◆ WaitForAudioThreadStopped()

Member Data Documentation

◆ mAudioIOExt

◆ mAudioThread

◆ mAudioThreadAcknowledge

◆ mAudioThreadSequenceBufferExchangeLoopActive

◆ mAudioThreadSequenceBufferExchangeLoopRunning

◆ mAudioThreadShouldCallSequenceBufferExchangeOnce

◆ mbHasSoloSequences

◆ mbMicroFades

◆ mCachedBestRateCapturing

◆ mCachedBestRateOut

◆ mCachedBestRatePlaying

◆ mCallbackReturn

◆ mCaptureBuffers

◆ mCaptureFormat

◆ mCaptureRate

◆ mCaptureRingBufferSecs

◆ mCaptureSequences

◆ mDetectDropouts

◆ mDetectUpstreamDropouts

◆ mFactor

◆ mFinishAudioThread

◆ mForceFadeOut

◆ mHardwarePlaybackLatencyFrames

◆ mLastPaError

◆ mLastPlaybackTimeMillis

◆ mLastRecordingOffset

◆ mListener

◆ mLostCaptureIntervals