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

void	CheckSoundActivatedRecordingLevel (float *inputSamples, unsigned long framesPerBuffer)

bool	FillOutputBuffers (float outputFloats, 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

std::vector< std::vector< float > >	mProcessingBuffers

std::vector< std::vector< float > >	mMasterBuffers

RingBuffers	mPlaybackBuffers

ConstPlayableSequences	mPlaybackSequences

float	mOldPlaybackVolume

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 std::map< int, std::vector< long > >	mCachedPlaybackRates

static std::map< int, std::vector< long > >	mCachedCaptureRates

static std::map< std::pair< int, int >, std::vector< long > >	mCachedSampleRates

static int	mCurrentPlaybackIndex { -1 }

static int	mCurrentCaptureIndex { -1 }

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)
	Get a list of sample rates the output (playback) device supports. More...

static long	GetClosestSupportedPlaybackRate (int devIndex, long rate)
	Find the closest supported sample rate for given playback device. More...

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

static long	GetClosestSupportedCaptureRate (int devIndex, long rate)
	Find the closest supported sample rate for given recording device. More...

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

static long	GetClosestSupportedSampleRate (int playDevice, int recDevice, long rate)
	Find the closest supported sample rate for given playback and recording devices. More...

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

static bool	IsPlaybackRateSupported (int devIndex, long rate)
	Check if the specified playback rate is supported by a device. More...

static bool	IsCaptureRateSupported (int devIndex, long rate)
	Check if the specified sample rate is supported by a device. 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 111 of file AudioIO.h.

Member Typedef Documentation

◆ RingBuffers

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

Definition at line 257 of file AudioIO.h.

Constructor & Destructor Documentation

◆ AudioIoCallback()

AudioIoCallback::AudioIoCallback ( )

Definition at line 3107 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 3116 of file AudioIO.cpp.

3117{

3118}

Member Function Documentation

◆ AudioCallback()

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

Definition at line 3121 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 ) || mOldPlaybackVolume == 0.0f ))
      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 CheckSoundActivatedRecordingLevel(), CountSoloingSequences(), DoPlaythrough(), DrainInputBuffers(), Extensions(), FillOutputBuffers(), floatSample, GetMixerOutputVol(), AudioIOBase::IsPaused(), mbHasSoloSequences, mbMicroFades, mCallbackReturn, mCaptureFormat, mNumCaptureChannels, mNumPauseFrames, mNumPlaybackChannels, mOldPlaybackVolume, 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 3292 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 3232 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 2636 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 375 of file AudioIO.h.

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

AudioIoCallback::mRecordingException

wxAtomicInt mRecordingException

Definition: AudioIO.h:372

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

Here is the caller graph for this function:

◆ CountSoloingSequences()

unsigned AudioIoCallback::CountSoloingSequences ( )

Definition at line 3076 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 2996 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 2838 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 163 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 *	outputFloats,
		unsigned long	framesPerBuffer,
		float *	outputMeterFloats
	)

Definition at line 2674 of file AudioIO.cpp.

{
   const auto numPlaybackSequences = mPlaybackSequences.size();
   const auto numPlaybackChannels = mNumPlaybackChannels;
 
   mMaxFramesOutput = 0;
 
   // Quick returns if next to nothing to do.
   if (mStreamToken <= 0 ||
       !outputFloats ||
       numPlaybackChannels <= 0) {
      // So that UpdateTimePosition() will be correct, in case of MIDI play with
      // no audio output channels
      mMaxFramesOutput = framesPerBuffer;
      return false;
   }
 
   if (mSeek && !mPlaybackSchedule.GetPolicy().AllowSeek(mPlaybackSchedule))
      mSeek = 0.0;
 
   if (mSeek){
      mCallbackReturn = CallbackDoSeek();
      return true;
   }
 
   // Choose a common size to take from all ring buffers
   const auto toGet =
      std::min<size_t>(framesPerBuffer, GetCommonlyReadyPlayback());
 
   // Poke: If there are no playback sequences, then check playback
   // completion condition and do early return
   // PRL:  Also consume frbom the single playback ring buffer
   if (numPlaybackSequences == 0) {
      mMaxFramesOutput = mPlaybackBuffers[0]->Discard(toGet);
      CallbackCheckCompletion(mCallbackReturn, 0);
      mLastPlaybackTimeMillis = ::wxGetUTCTimeMillis();
      return false;
   }
 
   // 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 volume of 0.0 for silent audio and go on through to the stage of
   // applying that 0.0 volume to the data mixed into the buffer.
   // Then (and only then) we would have if needed fast paths for:
   // - Applying a uniform volume of 0.0.
   // - Applying a uniform volume of 1.0.
   // - Applying some other uniform volume.
   // - Applying a linearly interpolated volume.
   // I would expect us not to need the fast paths, since linearly interpolated volume
   // is very cheap to process.
 
   // ------ 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 ---------------
 
   auto playbackVolume = ExpGain(GetMixerOutputVol());
   if (mForceFadeOut.load(std::memory_order_relaxed) || IsPaused())
      playbackVolume = 0.0;
 
   for(unsigned n = 0; n < numPlaybackChannels; ++n)
   {
      decltype(framesPerBuffer) len = mPlaybackBuffers[n]->Get(
         reinterpret_cast<samplePtr>(tempBufs[n]),
         floatSample,
         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[n][len], 0,
            (framesPerBuffer - len) * sizeof(float));
      }
 
      // 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)
      {
         // 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+n] +=
                  playbackVolume*tempBufs[n][i];
         }
 
         auto oldVolume = mOldPlaybackVolume;
         // if no microfades, jump in volume.
         if (!mbMicroFades)
            oldVolume = playbackVolume;
 
         // Linear interpolate.
         // PRL todo:  choose denominator differently, so it doesn't depend on
         // framesPerBuffer, which is influenced by the portAudio implementation in
         // opaque ways
         const float deltaVolume = (playbackVolume - oldVolume) / len;
         for (unsigned i = 0; i < len; i++)
         {
            outputFloats[numPlaybackChannels * i + n] +=
               (oldVolume + deltaVolume * i) * tempBufs[n][i];
         }
      }
      CallbackCheckCompletion(mCallbackReturn, len);
   }
 
   mOldPlaybackVolume = playbackVolume;
 
   // wxASSERT( maxLen == toGet );
 
   mLastPlaybackTimeMillis = ::wxGetUTCTimeMillis();
 
   ClampBuffer( outputFloats, framesPerBuffer*numPlaybackChannels );
   if (outputMeterFloats != outputFloats)
      ClampBuffer( outputMeterFloats, framesPerBuffer*numPlaybackChannels );
 
   return false;
}

References PlaybackPolicy::AllowSeek(), CallbackCheckCompletion(), CallbackDoSeek(), ClampBuffer(), ExpGain(), floatSample, AudioIOBase::Get(), GetCommonlyReadyPlayback(), GetMixerOutputVol(), PlaybackSchedule::GetPolicy(), AudioIOBase::IsPaused(), mbMicroFades, mCallbackReturn, mForceFadeOut, mLastPlaybackTimeMillis, mMaxFramesOutput, mNumPlaybackChannels, mOldPlaybackVolume, mPlaybackBuffers, mPlaybackSchedule, mPlaybackSequences, mSeek, AudioIOBase::mStreamToken, 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 1854 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 1859 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 171 of file AudioIO.h.

172 { return mListener.lock(); }

AudioIoCallback::mListener

std::weak_ptr< AudioIOListener > mListener

Definition: AudioIO.h:348

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

340 {

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

AudioIoCallback::mMixerOutputVol

std::atomic< float > mMixerOutputVol

Definition: AudioIO.h:278

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

Here is the caller graph for this function:

◆ HasRecordingException()

bool AudioIoCallback::HasRecordingException ( ) const

inline

Definition at line 366 of file AudioIO.h.

367 { 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 384 of file AudioIO.h.

385 { return mLostCaptureIntervals; }

◆ MinValue()

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

staticprotected

Definition at line 1837 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 3346 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 3032 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 3048 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:

◆ SequenceShouldBeSilent()

bool AudioIoCallback::SequenceShouldBeSilent ( const PlayableSequence & ps )

Definition at line 3097 of file AudioIO.cpp.

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

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

Referenced by AudioIO::ProcessPlaybackSlices().

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

342 {

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

374 { wxAtomicInc( mRecordingException ); }

Referenced by AudioIO::DrainRecordBuffers().

Here is the caller graph for this function:

◆ StartAudioThread()

void AudioIoCallback::StartAudioThread ( )

Definition at line 3316 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 3331 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 2823 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 3321 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 3336 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 381 of file AudioIOBase.h.

Referenced by AudioIoCallback().

◆ mAudioThread

std::thread AudioIoCallback::mAudioThread

Definition at line 252 of file AudioIO.h.

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

◆ mAudioThreadAcknowledge

std::atomic<Acknowledge> AudioIoCallback::mAudioThreadAcknowledge

Definition at line 314 of file AudioIO.h.

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

◆ mAudioThreadSequenceBufferExchangeLoopActive

std::atomic<bool> AudioIoCallback::mAudioThreadSequenceBufferExchangeLoopActive

Definition at line 312 of file AudioIO.h.

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

◆ mAudioThreadSequenceBufferExchangeLoopRunning

std::atomic<bool> AudioIoCallback::mAudioThreadSequenceBufferExchangeLoopRunning

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

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

◆ mbHasSoloSequences

int AudioIoCallback::mbHasSoloSequences

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

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

◆ mCachedBestRateCapturing

bool AudioIoCallback::mCachedBestRateCapturing

staticprotected

Definition at line 356 of file AudioIO.h.

Referenced by AudioIO::GetBestRate().

◆ mCachedBestRateOut

double AudioIoCallback::mCachedBestRateOut

staticprotected

Definition at line 354 of file AudioIO.h.

Referenced by AudioIO::GetBestRate().

◆ mCachedBestRatePlaying

bool AudioIoCallback::mCachedBestRatePlaying

staticprotected

Definition at line 355 of file AudioIO.h.

Referenced by AudioIO::GetBestRate().

◆ mCallbackReturn

int AudioIoCallback::mCallbackReturn

Definition at line 183 of file AudioIO.h.

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

◆ mCaptureBuffers

RingBuffers AudioIoCallback::mCaptureBuffers

Definition at line 258 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 307 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 308 of file AudioIO.h.

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

◆ mCaptureRingBufferSecs

double AudioIoCallback::mCaptureRingBufferSecs

Definition at line 287 of file AudioIO.h.

Referenced by AudioIO::AllocateBuffers().

◆ mCaptureSequences

RecordableSequences AudioIoCallback::mCaptureSequences

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

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

◆ mDetectUpstreamDropouts

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

Definition at line 392 of file AudioIO.h.

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

◆ mFactor

double AudioIoCallback::mFactor

Definition at line 280 of file AudioIO.h.

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

◆ mFinishAudioThread

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

Definition at line 253 of file AudioIO.h.

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

◆ mForceFadeOut

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

Definition at line 328 of file AudioIO.h.

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

◆ mHardwarePlaybackLatencyFrames

size_t AudioIoCallback::mHardwarePlaybackLatencyFrames {}

Hardware output latency in frames.

Definition at line 292 of file AudioIO.h.

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

◆ mLastPaError

PaError AudioIoCallback::mLastPaError

Definition at line 334 of file AudioIO.h.

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

◆ mLastPlaybackTimeMillis

wxLongLong AudioIoCallback::mLastPlaybackTimeMillis

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

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

◆ mLostCaptureIntervals

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

protected

Definition at line 378 of file AudioIO.h.

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

◆ mLostSamples

unsigned long long AudioIoCallback::mLostSamples { 0 }

Definition at line 309 of file AudioIO.h.

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

◆ mMasterBuffers

std::vector<std::vector<float> > AudioIoCallback::mMasterBuffers

These buffers are used to mix and process the result of processed source channels. Number of buffers equals to number of output channels.

Definition at line 265 of file AudioIO.h.

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

◆ mMaxFramesOutput

unsigned long AudioIoCallback::mMaxFramesOutput

Definition at line 281 of file AudioIO.h.

Referenced by FillOutputBuffers(), and UpdateTimePosition().

◆ mMinCaptureSecsToCopy

double AudioIoCallback::mMinCaptureSecsToCopy

Definition at line 296 of file AudioIO.h.

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

◆ mMixerOutputVol

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

Definition at line 278 of file AudioIO.h.

◆ mNextStreamToken

int AudioIoCallback::mNextStreamToken = 0

static

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

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

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

◆ mOldPlaybackVolume

float AudioIoCallback::mOldPlaybackVolume

Definition at line 271 of file AudioIO.h.

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

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

◆ mPlaybackMixers

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

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

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

◆ mPlaybackRingBufferSecs

PlaybackPolicy::Duration AudioIoCallback::mPlaybackRingBufferSecs

Definition at line 286 of file AudioIO.h.

Referenced by AudioIO::AllocateBuffers().

◆ mPlaybackSamplesToCopy

size_t AudioIoCallback::mPlaybackSamplesToCopy

Preferred batch size for replenishing the playback RingBuffer.

Definition at line 290 of file AudioIO.h.

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

◆ mPlaybackSchedule

PlaybackSchedule AudioIoCallback::mPlaybackSchedule

protected

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

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

◆ mProcessingBuffers

std::vector<std::vector<float> > AudioIoCallback::mProcessingBuffers

Buffers that hold outcome of transformations applied to each individual sample source. Number of buffers equals to the sum of number all source channels.

Definition at line 262 of file AudioIO.h.

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

◆ mpTransportState

std::unique_ptr<TransportState> AudioIoCallback::mpTransportState

protected

Holds some state for duration of playback or recording.

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

Referenced by AudioIO::DrainRecordBuffers().

◆ mRecordingSchedule

RecordingSchedule AudioIoCallback::mRecordingSchedule {}

protected

Definition at line 395 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 255 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 273 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 274 of file AudioIO.h.

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

◆ mSeek

double AudioIoCallback::mSeek

Definition at line 285 of file AudioIO.h.

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

◆ mSilenceLevel

float AudioIoCallback::mSilenceLevel

Definition at line 302 of file AudioIO.h.

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

◆ mSimulateRecordingErrors

bool AudioIoCallback::mSimulateRecordingErrors { false }

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

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

◆ mSuspendAudioThread

wxMutex AudioIoCallback::mSuspendAudioThread

protected

Definition at line 360 of file AudioIO.h.

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

◆ mUsingAlsa

bool AudioIoCallback::mUsingAlsa { false }

protected

Definition at line 350 of file AudioIO.h.

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

◆ mUsingJack

bool AudioIoCallback::mUsingJack { false }

protected

Definition at line 351 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

◆ RingBuffers

Constructor & Destructor Documentation

◆ AudioIoCallback()

◆ ~AudioIoCallback()

Member Function Documentation

◆ AudioCallback()

◆ CallbackCheckCompletion()

◆ CallbackDoSeek()

◆ CheckSoundActivatedRecordingLevel()

◆ ClearRecordingException()

◆ CountSoloingSequences()

◆ DoPlaythrough()

◆ DrainInputBuffers()

◆ Extensions()

◆ FillOutputBuffers()

◆ GetCommonlyReadyPlayback()

◆ GetCommonlyWrittenForPlayback()

◆ GetListener()

◆ GetMixerOutputVol()

◆ HasRecordingException()

◆ LostCaptureIntervals()

◆ MinValue()

◆ ProcessOnceAndWait()

◆ SendVuInputMeterData()

◆ SendVuOutputMeterData()

◆ 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

◆ mLostSamples

◆ mMasterBuffers

◆ mMaxFramesOutput

◆ mMinCaptureSecsToCopy