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 >

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	CountSoloingTracks ()

bool	TrackShouldBeSilent (const SampleTrack &wt)

bool	TrackHasBeenFadedOut (const SampleTrack &wt, const OldChannelGains &gains)

bool	AllTracksAlreadySilent ()

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 SampleTrack vt, OldChannelGains &gains)

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	mbHasSoloTracks

int	mCallbackReturn

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

std::thread	mAudioThread

std::atomic< bool >	mFinishAudioThread { false }

ArrayOf< std::unique_ptr< Resample > >	mResample

ArrayOf< std::unique_ptr< RingBuffer > >	mCaptureBuffers

WritableSampleTrackArray	mCaptureTracks

ArrayOf< std::unique_ptr< RingBuffer > >	mPlaybackBuffers

SampleTrackConstArray	mPlaybackTracks

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

unsigned int	mNumCaptureChannels

unsigned int	mNumPlaybackChannels

sampleFormat	mCaptureFormat

unsigned long long	mLostSamples { 0 }

std::atomic< bool >	mAudioThreadShouldCallTrackBufferExchangeOnce

std::atomic< bool >	mAudioThreadTrackBufferExchangeLoopRunning

std::atomic< bool >	mAudioThreadTrackBufferExchangeLoopActive

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 ()

Protected Attributes
std::weak_ptr< AudioIOListener >	mListener

bool	mUsingAlsa { 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...

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...

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 125 of file AudioIO.h.

Member Typedef Documentation

◆ OldChannelGains

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

Definition at line 201 of file AudioIO.h.

Constructor & Destructor Documentation

◆ AudioIoCallback()

AudioIoCallback::AudioIoCallback ( )

Definition at line 3063 of file AudioIO.cpp.

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

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

Here is the call graph for this function:

◆ ~AudioIoCallback()

AudioIoCallback::~AudioIoCallback ( )

Definition at line 3072 of file AudioIO.cpp.

3073{

3074}

Member Function Documentation

◆ AddToOutputChannel()

void AudioIoCallback::AddToOutputChannel	(	unsigned int	chan,
		float *	outputMeterFloats,
		float *	outputFloats,
		const float *	tempBuf,
		bool	drop,
		unsigned long	len,
		const SampleTrack *	vt,
		OldChannelGains &	gains
	)

Definition at line 2502 of file AudioIO.cpp.

{
   const auto numPlaybackChannels = mNumPlaybackChannels;
 
   float gain = vt->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 = gains[chan];
   if( gain != oldGain )
      gains[chan] = gain;
   // if no microfades, jump in volume.
   if( !mbMicroFades )
      oldGain =gain;
   wxASSERT(len > 0);
 
   // Linear interpolate.
   float deltaGain = (gain - oldGain) / len;
   for (unsigned i = 0; i < len; i++)
      outputFloats[numPlaybackChannels*i+chan] += (oldGain + deltaGain * i) *tempBuf[i];
};

References ExpGain(), SampleTrack::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:

◆ AllTracksAlreadySilent()

bool AudioIoCallback::AllTracksAlreadySilent ( )

Definition at line 3052 of file AudioIO.cpp.

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

References mOldChannelGains, mPlaybackTracks, TrackHasBeenFadedOut(), and TrackShouldBeSilent().

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 3077 of file AudioIO.cpp.

{
   // Poll tracks for change of state.  User might click mute and solo buttons.
   mbHasSoloTracks = CountSoloingTracks() > 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(), mbHasSoloTracks);
   }
 
   // ------ 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;
   float *tempFloats = (float *)alloca(framesPerBuffer*sizeof(float)*
                             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.
   float *outputMeterFloats = bVolEmulationActive ?
         (float *)alloca(framesPerBuffer*numPlaybackChannels * sizeof(float)) :
         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 track audio to play (because we are paused and have faded out)
   if( IsPaused() &&  (( !mbMicroFades ) || AllTracksAlreadySilent() ))
      return mCallbackReturn;
 
   // To add track 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 track (sound from microphone)
   DrainInputBuffers(
      inputBuffer,
      framesPerBuffer,
      statusFlags,
      tempFloats);
 
   SendVuOutputMeterData( outputMeterFloats, framesPerBuffer);
 
   return mCallbackReturn;
}

References AllTracksAlreadySilent(), CheckSoundActivatedRecordingLevel(), CountSoloingTracks(), DoPlaythrough(), DrainInputBuffers(), Extensions(), FillOutputBuffers(), floatSample, GetMixerOutputVol(), AudioIOBase::IsPaused(), MAX, mbHasSoloTracks, mbMicroFades, mCallbackReturn, mCaptureFormat, mNumCaptureChannels, mNumPauseFrames, mNumPlaybackChannels, AudioIOBase::mRate, AudioIOBase::mStreamToken, SamplesToFloats(), SendVuInputMeterData(), SendVuOutputMeterData(), and UpdateTimePosition().

Here is the call graph for this function:

◆ CallbackCheckCompletion()

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

Definition at line 3255 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 3190 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;
 
   const auto numPlaybackTracks = mPlaybackTracks.size();
 
   // 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 mAudioThreadTrackBufferExchangeLoopActive,
   // as it will become unused; consequently, the AudioThread loop would get simpler too.
   //
   mAudioThreadTrackBufferExchangeLoopRunning
      .store(false, std::memory_order_relaxed);
 
   while( mAudioThreadTrackBufferExchangeLoopActive
      .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().OffsetTrackTime( mPlaybackSchedule, mSeek );
 
   mPlaybackSchedule.SetTrackTime( time );
   mSeek = 0.0;
 
 
   // Reset mixer positions and flush buffers for all tracks
   for (auto &mixer : mPlaybackMixers)
      mixer->Reposition( time, true );
   for (size_t i = 0; i < numPlaybackTracks; i++)
   {
      const auto toDiscard =
         mPlaybackBuffers[i]->AvailForGet();
      const auto discarded =
         mPlaybackBuffers[i]->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
   mAudioThreadTrackBufferExchangeLoopRunning
      .store(true, std::memory_order_relaxed);
 
   return paContinue;
}

References PlaybackSchedule::GetPolicy(), mAudioThreadTrackBufferExchangeLoopActive, mAudioThreadTrackBufferExchangeLoopRunning, mPlaybackBuffers, mPlaybackMixers, mPlaybackSchedule, mPlaybackTracks, mSeek, AudioIOBase::mStreamToken, mSuspendAudioThread, PlaybackSchedule::mTimeQueue, PlaybackPolicy::OffsetTrackTime(), PlaybackSchedule::TimeQueue::Prime(), ProcessOnceAndWait(), and PlaybackSchedule::SetTrackTime().

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 2474 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 390 of file AudioIO.h.

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

AudioIoCallback::mRecordingException

wxAtomicInt mRecordingException

Definition: AudioIO.h:387

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

Here is the caller graph for this function:

◆ CountSoloingTracks()

unsigned AudioIoCallback::CountSoloingTracks ( )

Definition at line 3007 of file AudioIO.cpp.

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

References Extensions(), and mPlaybackTracks.

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 2927 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 2768 of file AudioIO.cpp.

{
   const auto numPlaybackTracks = mPlaybackTracks.size();
   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 tracks, 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 TrackBufferExchange, 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.GetTrackTime() +
            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::GetTrackTime(), int16Sample, int24Sample, mCallbackReturn, mCaptureBuffers, mCaptureFormat, mDetectDropouts, mDetectUpstreamDropouts, min(), RecordingSchedule::mLatencyCorrection, mLostCaptureIntervals, mLostSamples, mNumCaptureChannels, mNumPlaybackChannels, mPlaybackSchedule, mPlaybackTracks, 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 177 of file AudioIO.h.

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

Referenced by AudioCallback(), CallbackCheckCompletion(), CountSoloingTracks(), 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 2555 of file AudioIO.cpp.

{
   const auto numPlaybackTracks = mPlaybackTracks.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 chans = (const SampleTrack **) alloca(
      numPlaybackChannels * sizeof(const SampleTrack *));
   const auto oldgains = (OldChannelGains **) alloca(
      numPlaybackChannels * sizeof(OldChannelGains *));
   float **tempBufs = (float **) alloca(numPlaybackChannels * sizeof(float *));
 
   // And these are larger structures....
   for (unsigned int c = 0; c < numPlaybackChannels; c++)
      tempBufs[c] = (float *) alloca(framesPerBuffer * sizeof(float));
   // ------ End of MEMORY ALLOCATION ---------------
 
   int chanCnt = 0;
 
   // 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;        // Track should become silent.
   bool dropQuickly = false; // Track has already been faded to silence.
   for (unsigned t = 0; t < numPlaybackTracks; t++)
   {
      auto vt = mPlaybackTracks[t].get();
      chans[chanCnt] = vt;
      oldgains[chanCnt] = &mOldChannelGains[t];
 
      // TODO: more-than-two-channels
      auto nextTrack =
         t + 1 < numPlaybackTracks
            ? mPlaybackTracks[t + 1].get()
            : nullptr;
 
      // First and last channel in this group (for example left and right
      // channels of stereo).
      bool firstChannel = vt->IsLeader();
      bool lastChannel = !nextTrack || nextTrack->IsLeader();
 
      if ( firstChannel )
      {
         // IF mono THEN clear 'the other' channel.
         if ( lastChannel && (numPlaybackChannels>1)) {
            // TODO: more-than-two-channels
            memset(tempBufs[1], 0, framesPerBuffer * sizeof(float));
         }
         drop = TrackShouldBeSilent( *vt );
         dropQuickly = drop;
      }
 
      if( mbMicroFades )
         dropQuickly = dropQuickly &&
            TrackHasBeenFadedOut( *vt, mOldChannelGains[t] );
         
      decltype(framesPerBuffer) len = 0;
 
      if (dropQuickly)
      {
         len = mPlaybackBuffers[t]->Discard(toGet);
         // keep going here.  
         // we may still need to issue a paComplete.
      }
      else
      {
         len = mPlaybackBuffers[t]->Get((samplePtr)tempBufs[chanCnt],
                                                   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 TrackBufferExchange 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[chanCnt][len], 0,
               (framesPerBuffer - len) * sizeof(float));
         chanCnt++;
      }
 
      // PRL:  Bug1104:
      // There can be a difference of len in different loop passes if one channel
      // of a stereo track ends before the other!  Take a max!
 
      // PRL:  More recent rewrites of TrackBufferExchange 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);
 
      if ( !lastChannel )
         continue;
 
      // Last channel of a track seen now
      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.
      //
      // Note that there are two kinds of channel count.
      // c and chanCnt are counting channels in the Tracks.
      // chan (and numPlayBackChannels) is counting output channels on the device.
      // chan = 0 is left channel
      // chan = 1 is right channel.
      //
      // Each channel in the tracks 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) for (int c = 0; c < chanCnt; c++)
      {
         vt = chans[c];
 
         if (vt->GetChannelIgnoringPan() == Track::LeftChannel ||
               vt->GetChannelIgnoringPan() == Track::MonoChannel )
            AddToOutputChannel( 0, outputMeterFloats, outputFloats,
               tempBufs[c], drop, len, vt, *oldgains[c % 2]);
 
         if (vt->GetChannelIgnoringPan() == Track::RightChannel ||
               vt->GetChannelIgnoringPan() == Track::MonoChannel  )
            AddToOutputChannel( 1, outputMeterFloats, outputFloats,
               tempBufs[c], drop, len, vt, *oldgains[c % 2]);
      }
 
      CallbackCheckCompletion(mCallbackReturn, len);
      if (dropQuickly) // no samples to process, they've been discarded
         continue;
 
      chanCnt = 0;
   }
 
   // Poke: If there are no playback tracks, 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 (numPlaybackTracks == 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(), Track::LeftChannel, mbMicroFades, mCallbackReturn, mLastPlaybackTimeMillis, mMaxFramesOutput, mNumCaptureChannels, mNumPlaybackChannels, mOldChannelGains, Track::MonoChannel, mPlaybackBuffers, mPlaybackSchedule, mPlaybackTracks, mSeek, AudioIOBase::mStreamToken, Track::RightChannel, TrackHasBeenFadedOut(), and TrackShouldBeSilent().

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 1814 of file AudioIO.cpp.

{
   auto commonlyAvail = mPlaybackBuffers[0]->AvailForGet();
   for (unsigned i = 1; i < mPlaybackTracks.size(); ++i)
      commonlyAvail = std::min(commonlyAvail,
         mPlaybackBuffers[i]->AvailForGet());
   return commonlyAvail;
}

References min(), mPlaybackBuffers, and mPlaybackTracks.

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 1823 of file AudioIO.cpp.

{
   auto commonlyAvail = mPlaybackBuffers[0]->WrittenForGet();
   for (unsigned i = 1; i < mPlaybackTracks.size(); ++i)
      commonlyAvail = std::min(commonlyAvail,
         mPlaybackBuffers[i]->WrittenForGet());
   return commonlyAvail;
}

References min(), mPlaybackBuffers, and mPlaybackTracks.

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 185 of file AudioIO.h.

186 { return mListener.lock(); }

AudioIoCallback::mListener

std::weak_ptr< AudioIOListener > mListener

Definition: AudioIO.h:364

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 356 of file AudioIO.h.

356 {

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

AudioIoCallback::mMixerOutputVol

std::atomic< float > mMixerOutputVol

Definition: AudioIO.h:297

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

Here is the caller graph for this function:

◆ HasRecordingException()

bool AudioIoCallback::HasRecordingException ( ) const

inline

Definition at line 381 of file AudioIO.h.

382 { 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 399 of file AudioIO.h.

400 { return mLostCaptureIntervals; }

◆ ProcessOnceAndWait()

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

Definition at line 3309 of file AudioIO.cpp.

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

References mAudioThreadShouldCallTrackBufferExchangeOnce.

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 2963 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 2979 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:

◆ SetListener()

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

Definition at line 2255 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 358 of file AudioIO.h.

358 {

359 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 388 of file AudioIO.h.

389 { wxAtomicInc( mRecordingException ); }

Referenced by AudioIO::DrainRecordBuffers().

Here is the caller graph for this function:

◆ StartAudioThread()

void AudioIoCallback::StartAudioThread ( )

Definition at line 3279 of file AudioIO.cpp.

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

References mAudioThreadTrackBufferExchangeLoopRunning.

Referenced by AudioIO::StartStream().

Here is the caller graph for this function:

◆ StopAudioThread()

void AudioIoCallback::StopAudioThread ( )

Definition at line 3294 of file AudioIO.cpp.

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

References mAudioThreadTrackBufferExchangeLoopRunning.

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

Here is the caller graph for this function:

◆ TrackHasBeenFadedOut()

bool AudioIoCallback::TrackHasBeenFadedOut	(	const SampleTrack &	wt,
		const OldChannelGains &	gains
	)

Definition at line 3039 of file AudioIO.cpp.

{
   const auto channel = wt.GetChannelIgnoringPan();
   if ((channel == Track::LeftChannel  || channel == Track::MonoChannel) &&
      gains[0] != 0.0)
      return false;
   if ((channel == Track::RightChannel || channel == Track::MonoChannel) &&
      gains[1] != 0.0)
      return false;
   return true;
}

References SampleTrack::GetChannelIgnoringPan(), Track::LeftChannel, Track::MonoChannel, and Track::RightChannel.

Referenced by AllTracksAlreadySilent(), and FillOutputBuffers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TrackShouldBeSilent()

bool AudioIoCallback::TrackShouldBeSilent ( const SampleTrack & wt )

Definition at line 3028 of file AudioIO.cpp.

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

References PlayableTrack::GetMute(), PlayableTrack::GetSolo(), AudioIOBase::IsPaused(), and mbHasSoloTracks.

Referenced by AllTracksAlreadySilent(), and FillOutputBuffers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateTimePosition()

void AudioIoCallback::UpdateTimePosition ( unsigned long framesPerBuffer )

Definition at line 2753 of file AudioIO.cpp.

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

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

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 3284 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 3299 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 279 of file AudioIO.h.

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

◆ mAudioThreadAcknowledge

std::atomic<Acknowledge> AudioIoCallback::mAudioThreadAcknowledge

Definition at line 332 of file AudioIO.h.

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

◆ mAudioThreadShouldCallTrackBufferExchangeOnce

std::atomic<bool> AudioIoCallback::mAudioThreadShouldCallTrackBufferExchangeOnce

Definition at line 328 of file AudioIO.h.

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

◆ mAudioThreadTrackBufferExchangeLoopActive

std::atomic<bool> AudioIoCallback::mAudioThreadTrackBufferExchangeLoopActive

Definition at line 330 of file AudioIO.h.

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

◆ mAudioThreadTrackBufferExchangeLoopRunning

std::atomic<bool> AudioIoCallback::mAudioThreadTrackBufferExchangeLoopRunning

Definition at line 329 of file AudioIO.h.

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

◆ mbHasSoloTracks

int AudioIoCallback::mbHasSoloTracks

Definition at line 196 of file AudioIO.h.

Referenced by AudioCallback(), and TrackShouldBeSilent().

◆ mbMicroFades

bool AudioIoCallback::mbMicroFades

Read by a worker thread but unchanging during playback

Definition at line 302 of file AudioIO.h.

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

◆ mCachedBestRateCapturing

bool AudioIoCallback::mCachedBestRateCapturing

staticprotected

Definition at line 371 of file AudioIO.h.

Referenced by AudioIO::GetBestRate().

◆ mCachedBestRateOut

double AudioIoCallback::mCachedBestRateOut

staticprotected

Definition at line 369 of file AudioIO.h.

Referenced by AudioIO::GetBestRate().

◆ mCachedBestRatePlaying

bool AudioIoCallback::mCachedBestRatePlaying

staticprotected

Definition at line 370 of file AudioIO.h.

Referenced by AudioIO::GetBestRate().

◆ mCallbackReturn

int AudioIoCallback::mCallbackReturn

Definition at line 197 of file AudioIO.h.

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

◆ mCaptureBuffers

ArrayOf<std::unique_ptr<RingBuffer> > AudioIoCallback::mCaptureBuffers

Definition at line 283 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 326 of file AudioIO.h.

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

◆ mCaptureRingBufferSecs

double AudioIoCallback::mCaptureRingBufferSecs

Definition at line 306 of file AudioIO.h.

Referenced by AudioIO::AllocateBuffers().

◆ mCaptureTracks

WritableSampleTrackArray AudioIoCallback::mCaptureTracks

Definition at line 284 of file AudioIO.h.

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

◆ mDetectDropouts

bool AudioIoCallback::mDetectDropouts { true }

protected

Read by a worker thread but unchanging during playback

Definition at line 395 of file AudioIO.h.

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

◆ mDetectUpstreamDropouts

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

Definition at line 407 of file AudioIO.h.

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

◆ mFactor

double AudioIoCallback::mFactor

Definition at line 299 of file AudioIO.h.

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

◆ mFinishAudioThread

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

Definition at line 280 of file AudioIO.h.

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

◆ mForceFadeOut

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

Definition at line 346 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 311 of file AudioIO.h.

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

◆ mLastPaError

PaError AudioIoCallback::mLastPaError

Definition at line 352 of file AudioIO.h.

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

◆ mLastPlaybackTimeMillis

wxLongLong AudioIoCallback::mLastPlaybackTimeMillis

Definition at line 348 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 351 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 364 of file AudioIO.h.

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

◆ mLostCaptureIntervals

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

protected

Definition at line 393 of file AudioIO.h.

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

◆ mLostSamples

unsigned long long AudioIoCallback::mLostSamples { 0 }

Definition at line 327 of file AudioIO.h.

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

◆ mMaxFramesOutput

unsigned long AudioIoCallback::mMaxFramesOutput

Definition at line 300 of file AudioIO.h.

Referenced by FillOutputBuffers(), and UpdateTimePosition().

◆ mMinCaptureSecsToCopy

double AudioIoCallback::mMinCaptureSecsToCopy

Definition at line 315 of file AudioIO.h.

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

◆ mMixerOutputVol

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

Definition at line 297 of file AudioIO.h.

◆ mNextStreamToken

int AudioIoCallback::mNextStreamToken = 0

static

Definition at line 298 of file AudioIO.h.

Referenced by AudioIO::StartStream().

◆ mNumCaptureChannels

unsigned int AudioIoCallback::mNumCaptureChannels

Read by a worker thread but unchanging during playback

Definition at line 323 of file AudioIO.h.

Referenced by AudioIO::AllocateBuffers(), AudioCallback(), AudioIO::AudioIO(), CheckSoundActivatedRecordingLevel(), AudioIO::DelayingActions(), DoPlaythrough(), DrainInputBuffers(), 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 260 of file AudioIO.h.

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

◆ mNumPlaybackChannels

unsigned int AudioIoCallback::mNumPlaybackChannels

Read by a worker thread but unchanging during playback

Definition at line 325 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 290 of file AudioIO.h.

Referenced by AudioIO::AllocateBuffers(), AllTracksAlreadySilent(), 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 320 of file AudioIO.h.

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

◆ mPlaybackBuffers

ArrayOf<std::unique_ptr<RingBuffer> > AudioIoCallback::mPlaybackBuffers

Read by worker threads but unchanging during playback

Definition at line 286 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 295 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 313 of file AudioIO.h.

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

◆ mPlaybackRingBufferSecs

PlaybackPolicy::Duration AudioIoCallback::mPlaybackRingBufferSecs

Definition at line 305 of file AudioIO.h.

Referenced by AudioIO::AllocateBuffers().

◆ mPlaybackSamplesToCopy

size_t AudioIoCallback::mPlaybackSamplesToCopy

Preferred batch size for replenishing the playback RingBuffer.

Definition at line 309 of file AudioIO.h.

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

◆ mPlaybackSchedule

PlaybackSchedule AudioIoCallback::mPlaybackSchedule

protected

Definition at line 411 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().

◆ mPlaybackTracks

SampleTrackConstArray AudioIoCallback::mPlaybackTracks

Definition at line 287 of file AudioIO.h.

Referenced by AudioIO::AllocateBuffers(), AllTracksAlreadySilent(), CallbackDoSeek(), CountSoloingTracks(), DrainInputBuffers(), FillOutputBuffers(), AudioIO::FillPlayBuffers(), AudioIO::GetCommonlyFreePlayback(), GetCommonlyReadyPlayback(), GetCommonlyWrittenForPlayback(), 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 415 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 387 of file AudioIO.h.

Referenced by AudioIO::DrainRecordBuffers().

◆ mRecordingSchedule

RecordingSchedule AudioIoCallback::mRecordingSchedule {}

protected

Definition at line 410 of file AudioIO.h.

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

◆ mResample

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

Definition at line 282 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 292 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 293 of file AudioIO.h.

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

◆ mSeek

double AudioIoCallback::mSeek

Definition at line 304 of file AudioIO.h.

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

◆ mSilenceLevel

float AudioIoCallback::mSilenceLevel

Definition at line 321 of file AudioIO.h.

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

◆ mSimulateRecordingErrors

bool AudioIoCallback::mSimulateRecordingErrors { false }

Definition at line 403 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 317 of file AudioIO.h.

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

◆ mSuspendAudioThread

wxMutex AudioIoCallback::mSuspendAudioThread

protected

Definition at line 375 of file AudioIO.h.

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

◆ mUsingAlsa

bool AudioIoCallback::mUsingAlsa { false }

protected

Definition at line 366 of file AudioIO.h.

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

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

Protected Attributes

Static Protected Attributes

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ OldChannelGains

Constructor & Destructor Documentation

◆ AudioIoCallback()

◆ ~AudioIoCallback()

Member Function Documentation

◆ AddToOutputChannel()

◆ AllTracksAlreadySilent()

◆ AudioCallback()

◆ CallbackCheckCompletion()

◆ CallbackDoSeek()

◆ CheckSoundActivatedRecordingLevel()

◆ ClearRecordingException()

◆ CountSoloingTracks()

◆ DoPlaythrough()

◆ DrainInputBuffers()

◆ Extensions()

◆ FillOutputBuffers()

◆ GetCommonlyReadyPlayback()

◆ GetCommonlyWrittenForPlayback()

◆ GetListener()

◆ GetMixerOutputVol()

◆ HasRecordingException()

◆ LostCaptureIntervals()

◆ ProcessOnceAndWait()

◆ SendVuInputMeterData()

◆ SendVuOutputMeterData()

◆ SetListener()

◆ SetMixerOutputVol()

◆ SetRecordingException()

◆ StartAudioThread()

◆ StopAudioThread()

◆ TrackHasBeenFadedOut()

◆ TrackShouldBeSilent()

◆ UpdateTimePosition()

◆ WaitForAudioThreadStarted()

◆ WaitForAudioThreadStopped()

Member Data Documentation

◆ mAudioIOExt

◆ mAudioThread

◆ mAudioThreadAcknowledge

◆ mAudioThreadShouldCallTrackBufferExchangeOnce

◆ mAudioThreadTrackBufferExchangeLoopActive

◆ mAudioThreadTrackBufferExchangeLoopRunning

◆ mbHasSoloTracks

◆ mbMicroFades

◆ mCachedBestRateCapturing

◆ mCachedBestRateOut

◆ mCachedBestRatePlaying

◆ mCallbackReturn

◆ mCaptureBuffers

◆ mCaptureFormat

◆ mCaptureRingBufferSecs

◆ mCaptureTracks

◆ mDetectDropouts

◆ mDetectUpstreamDropouts

◆ mFactor

◆ mFinishAudioThread

◆ mForceFadeOut

◆ mHardwarePlaybackLatencyFrames

◆ mLastPaError

◆ mLastPlaybackTimeMillis

◆ mLastRecordingOffset

◆ mListener

◆ mLostCaptureIntervals

◆ mLostSamples

◆ mMaxFramesOutput

◆ mMinCaptureSecsToCopy

◆ mMixerOutputVol