AudioIOBase Class Reference

A singleton object supporting queries of the state of any active audio streams, and audio device capabilities. More...

#include <AudioIOBase.h>

Inheritance diagram for AudioIOBase:

Collaboration diagram for AudioIOBase:

Public Member Functions
	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)

Static Public Member Functions
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...

Static Public Attributes
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...

Static Protected Member Functions
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< 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 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...

Detailed Description

A singleton object supporting queries of the state of any active audio streams, and audio device capabilities.

Definition at line 102 of file AudioIOBase.h.

Constructor & Destructor Documentation

AudioIOBase() [1/2]

AudioIOBase::AudioIOBase ( )

default

~AudioIOBase()

AudioIOBase::~AudioIOBase ( )

virtualdefault

AudioIOBase() [2/2]

AudioIOBase::AudioIOBase ( const AudioIOBase &  )

delete

Member Function Documentation

DeviceName()

wxString AudioIOBase::DeviceName ( const PaDeviceInfo *  info )

staticprotected

Definition at line 76 of file AudioIOBase.cpp.

{
   wxString infoName = wxSafeConvertMB2WX(info->name);
 
   return infoName;
}

Referenced by GetDeviceInfo(), getPlayDevIndex(), getRecordDevIndex(), and AudioIO::Init().

Here is the caller graph for this function:

Get()

AudioIOBase * AudioIOBase::Get ( )

static

Definition at line 94 of file AudioIOBase.cpp.

{
   return ugAudioIO.get();
}

References ugAudioIO.

Referenced by AudioIOBusyPred(), AudioSetupToolBar::CommonMenuItemSteps(), LabelTrackView::DoCaptureKey(), Scrubber::DoKeyboardScrub(), AdornedRulerPanel::DoSelectionChange(), TransportUtilities::DoStartPlaying(), TransportUtilities::DoStopPlaying(), audacity::cloud::ShareAudioToolbar::EnableDisableButtons(), AudioSetupToolBar::EnableDisableButtons(), DeviceToolBar::EnableDisableButtons(), AudioIoCallback::FillOutputBuffers(), AudioIO::Get(), GetMIDIDeviceInfo(), ProjectAudioIO::IsAudioActive(), ScrubState::IsScrubbing(), anonymous_namespace{TransportMenus.cpp}::MakeReadyToPlay(), anonymous_namespace{HelpMenus.cpp}::OnAudioDeviceInfo(), DeviceToolBar::OnChoice(), ControlToolBar::OnKeyEvent(), TranscriptionToolBar::OnKeyEvent(), anonymous_namespace{NoteTrackMenuItems.cpp}::OnMidiDeviceInfo(), PrefsDialog::OnOK(), NyqBench::OnRunUpdate(), anonymous_namespace{SpectrumView.cpp}::SpectrogramSettingsHandler::OnSpectrogramSettings(), PausedFlag(), TranscriptionToolBar::PlayAtSpeed(), DeviceManager::Rescan(), ProjectAudioIO::SetCaptureMeter(), ProjectAudioIO::SetPlaybackMeter(), and ProjectAudioManager::StopIfPaused().

Here is the caller graph for this function:

GetAllDeviceInfo()

auto AudioIOBase::GetAllDeviceInfo

(

)

Get diagnostic information for audio devices and also for extensions.

Definition at line 1055 of file AudioIOBase.cpp.

{
   std::vector<AudioIODiagnostics> result;
   result.push_back({
      wxT("audiodev.txt"), GetDeviceInfo(), wxT("Audio Device Info") });
   for( auto &pExt : mAudioIOExt )
      if ( pExt )
         result.emplace_back(pExt->Dump());
   return result;
}

References wxT().

Here is the call graph for this function:

GetClosestSupportedCaptureRate()

long AudioIOBase::GetClosestSupportedCaptureRate ( int  devIndex, long  rate  )

static

Find the closest supported sample rate for given recording device.

Attempts to find the sample rate that is closest to the requested rate, and is supported by the recording device.

If device is not specified the currently selected device will be used.

Sample rate check order:

• the exact requested rate
• higher available rates
• lower available rates

returns 0 if none is found or the input rate is invalid.

Definition at line 542 of file AudioIOBase.cpp.

{
   long supportedRate = 0;
   if (devIndex == -1)
   {  // not given a device, look up in prefs / default
      devIndex = getRecordDevIndex();
   }
 
   if (rate == 0)
   {  // not given a correct rate
      return supportedRate;
   }
 
   // Check if we can use the cached rate
   if (mCachedCaptureRates.count(devIndex)
       && (make_iterator_range(mCachedCaptureRates[devIndex]).contains(rate)))
   {
      supportedRate = rate;
      return supportedRate;
   }
 
 
   // First we will probe the requested state
   std::vector<long> rates = { rate };
 
   // Next default rates higher than requested
   auto higherRatesIt = std::upper_bound(RatesToTry, RatesToTry + NumRatesToTry, rate);
   std::copy(higherRatesIt, RatesToTry + NumRatesToTry, std::back_inserter(rates));
 
   // Last default rates lower than requested in reverse order
   auto lowerRatesIt = std::lower_bound(RatesToTry, RatesToTry + NumRatesToTry, rate);
   std::copy(std::make_reverse_iterator(lowerRatesIt), std::make_reverse_iterator(RatesToTry),
             std::back_inserter(rates));
 
   for (const long rateToTry : rates)
   {
      if (IsCaptureRateSupported(devIndex, rateToTry))
      {
         supportedRate = rateToTry;
         break;
      }
      Pa_Sleep( 10 );   // There are ALSA drivers that don't like being probed
                        // too quickly.
   }
 
   return supportedRate;
}

References staffpad::vo::copy(), getRecordDevIndex(), IsCaptureRateSupported(), make_iterator_range(), mCachedCaptureRates, NumRatesToTry, and RatesToTry.

Referenced by AudioIO::GetBestRate().

Here is the call graph for this function:

Here is the caller graph for this function:

GetClosestSupportedPlaybackRate()

long AudioIOBase::GetClosestSupportedPlaybackRate ( int  devIndex, long  rate  )

static

Find the closest supported sample rate for given playback device.

Attempts to find the sample rate that is closest to the requested rate, and is supported by the playback device.

If device is not specified the currently selected device will be used.

Sample rate check order:

• the exact requested rate
• higher available rates
• lower available rates

returns 0 if none is found or the input rate is invalid.

Definition at line 505 of file AudioIOBase.cpp.

{
   long supportedRate = 0;
   if (devIndex == -1)
   {  // weren't given a device index, get the prefs / default one
      devIndex = getPlayDevIndex();
   }
 
   if (rate == 0.0)
   {  // not given a correct rate
      return 0;
   }
 
   // First we will probe the requested state
   std::vector<long> rates = { rate };
   // Next default rates higher than requested
   auto higherRatesIt = std::upper_bound(RatesToTry, RatesToTry + NumRatesToTry, rate);
   std::copy(higherRatesIt, RatesToTry + NumRatesToTry, std::back_inserter(rates));
   // Last default rates lower than requested in reverse order
   auto lowerRatesIt = std::lower_bound(RatesToTry, RatesToTry + NumRatesToTry, rate);
   std::copy(std::make_reverse_iterator(lowerRatesIt), std::make_reverse_iterator(RatesToTry),
             std::back_inserter(rates));
 
   for (const long rateToTry : rates)
   {
      if (IsPlaybackRateSupported(devIndex, rateToTry))
      {
         supportedRate = rateToTry;
         break;
      }
      Pa_Sleep( 10 );   // There are ALSA drivers that don't like being probed
                        // too quickly.
   }
 
   return supportedRate;
}

References staffpad::vo::copy(), getPlayDevIndex(), IsPlaybackRateSupported(), NumRatesToTry, and RatesToTry.

Referenced by AudioIO::GetBestRate().

Here is the call graph for this function:

Here is the caller graph for this function:

GetClosestSupportedSampleRate()

long AudioIOBase::GetClosestSupportedSampleRate ( int  playDevice, int  recDevice, long  rate  )

static

Find the closest supported sample rate for given playback and recording devices.

Attempts to find the sample rate that is closest to the requested rate, and is supported by both playback and recording devices.

If devices are not specified the currently selected devices will be used.

Sample rate check order:

• the exact requested rate
• higher available rates
• lower available rates

returns 0 if none is found or the input rate is invalid.

Definition at line 590 of file AudioIOBase.cpp.

{
   long supportedRate = 0;
 
   // Not given device indices, look up prefs
   if (playDevice == -1) {
      playDevice = getPlayDevIndex();
   }
   if (recDevice == -1) {
      recDevice = getRecordDevIndex();
   }
 
   // Check if we can use the cached rates
   std::pair<int, int> devicePair { playDevice, recDevice };
   if (mCachedSampleRates.count(devicePair) &&
       make_iterator_range(mCachedSampleRates.at(devicePair)).contains(rate))
   {
      return rate;
   }
 
   // First we will probe the requested state
   std::vector<long> rates { rate };
 
   // Next default rates higher than requested
   auto higherRatesIt = std::upper_bound(RatesToTry, RatesToTry + NumRatesToTry, rate);
   std::copy(higherRatesIt, RatesToTry + NumRatesToTry, std::back_inserter(rates));
 
   // Last default rates lower than requested in reverse order
   auto lowerRatesIt = std::lower_bound(RatesToTry, RatesToTry + NumRatesToTry, rate);
   std::copy(std::make_reverse_iterator(lowerRatesIt), std::make_reverse_iterator(RatesToTry),
             std::back_inserter(rates));
 
   for (const long rateToTry : rates)
   {
      if (IsPlaybackRateSupported(playDevice, rateToTry) &&
          IsCaptureRateSupported(recDevice, rateToTry))
      {
         supportedRate = rateToTry;
         break;
      }
      Pa_Sleep( 10 );   // There are ALSA drivers that don't like being probed
                        // too quickly.
   }
 
   mCachedSampleRates[devicePair].push_back(supportedRate);
 
   return supportedRate;
}

References staffpad::vo::copy(), getPlayDevIndex(), getRecordDevIndex(), IsCaptureRateSupported(), IsPlaybackRateSupported(), make_iterator_range(), mCachedSampleRates, NumRatesToTry, and RatesToTry.

Referenced by AudioIO::GetBestRate(), GetOptimalSupportedSampleRate(), and HandleDeviceChange().

Here is the call graph for this function:

Here is the caller graph for this function:

GetDeviceInfo()

wxString AudioIOBase::GetDeviceInfo

(

)

const

Get diagnostic information on all the available audio I/O devices.

Definition at line 812 of file AudioIOBase.cpp.

{
   wxStringOutputStream o;
   wxTextOutputStream s(o, wxEOL_UNIX);
 
   if (IsStreamActive()) {
      return XO("Stream is active ... unable to gather information.\n")
         .Translation();
   }
 
 
   // FIXME: TRAP_ERR PaErrorCode not handled.  3 instances in GetDeviceInfo().
   int recDeviceNum = Pa_GetDefaultInputDevice();
   int playDeviceNum = Pa_GetDefaultOutputDevice();
   int cnt = Pa_GetDeviceCount();
 
   // PRL:  why only into the log?
   wxLogDebug(wxT("Portaudio reports %d audio devices"),cnt);
   
   s << wxT("==============================\n");
   s << XO("Default recording device number: %d\n").Format( recDeviceNum );
   s << XO("Default playback device number: %d\n").Format( playDeviceNum);
 
   auto recDevice = AudioIORecordingDevice.Read();
   auto playDevice = AudioIOPlaybackDevice.Read();
   int j;
 
   // This gets info on all available audio devices (input and output)
   if (cnt <= 0) {
      s << XO("No devices found\n");
      return o.GetString();
   }
 
   const PaDeviceInfo* info;
 
   for (j = 0; j < cnt; j++) {
      s << wxT("==============================\n");
 
      info = Pa_GetDeviceInfo(j);
      if (!info) {
         s << XO("Device info unavailable for: %d\n").Format( j );
         continue;
      }
 
      wxString name = DeviceName(info);
      s << XO("Device ID: %d\n").Format( j );
      s << XO("Device name: %s\n").Format( name );
      s << XO("Host name: %s\n").Format( HostName(info) );
      s << XO("Recording channels: %d\n").Format( info->maxInputChannels );
      s << XO("Playback channels: %d\n").Format( info->maxOutputChannels );
      s << XO("Low Recording Latency: %g\n").Format( info->defaultLowInputLatency );
      s << XO("Low Playback Latency: %g\n").Format( info->defaultLowOutputLatency );
      s << XO("High Recording Latency: %g\n").Format( info->defaultHighInputLatency );
      s << XO("High Playback Latency: %g\n").Format( info->defaultHighOutputLatency );
 
      if (info->maxOutputChannels)
      {
         auto rates = GetSupportedPlaybackRates(j);
 
         /* i18n-hint: Supported, meaning made available by the system */
         s << XO("Supported Playback Rates:\n");
         for (int k = 0; k < (int) rates.size(); k++) {
            s << wxT("    ") << (int) rates[k] << wxT("\n");
         }
      }
 
      if (info->maxInputChannels)
      {
         auto rates = GetSupportedCaptureRates(j);
 
         /* i18n-hint: Supported, meaning made available by the system */
         s << XO("Supported Capture Rates:\n");
         for (int k = 0; k < (int) rates.size(); k++) {
            s << wxT("    ") << (int) rates[k] << wxT("\n");
         }
      }
 
      if (name == playDevice && info->maxOutputChannels > 0)
         playDeviceNum = j;
 
      if (name == recDevice && info->maxInputChannels > 0)
         recDeviceNum = j;
 
      // Sometimes PortAudio returns -1 if it cannot find a suitable default
      // device, so we just use the first one available
      if (recDeviceNum < 0 && info->maxInputChannels > 0){
         recDeviceNum = j;
      }
      if (playDeviceNum < 0 && info->maxOutputChannels > 0){
         playDeviceNum = j;
      }
   }
 
   bool haveRecDevice = (recDeviceNum >= 0);
   bool havePlayDevice = (playDeviceNum >= 0);
 
   s << wxT("==============================\n");
   if (haveRecDevice)
      s << XO("Selected recording device: %d - %s\n").Format( recDeviceNum, recDevice );
   else
      s << XO("No recording device found for '%s'.\n").Format( recDevice );
 
   if (havePlayDevice)
      s << XO("Selected playback device: %d - %s\n").Format( playDeviceNum, playDevice );
   else
      s << XO("No playback device found for '%s'.\n").Format( playDevice );
 
   std::vector<long> supportedSampleRates;
 
   if (havePlayDevice && haveRecDevice) {
      supportedSampleRates = GetSupportedSampleRates(playDeviceNum, recDeviceNum);
 
      s << XO("Supported Rates:\n");
      for (int k = 0; k < (int) supportedSampleRates.size(); k++) {
         s << wxT("    ") << (int)supportedSampleRates[k] << wxT("\n");
      }
   }
   else {
      s << XO("Cannot check mutual sample rates without both devices.\n");
      return o.GetString();
   }
 
#if defined(USE_PORTMIXER)
   if (supportedSampleRates.size() > 0)
      {
      int highestSampleRate = supportedSampleRates.back();
      bool EmulateMixerInputVol = true;
      float MixerInputVol = 1.0;
      float MixerOutputVol = 1.0;
 
      int error;
 
      PaStream *stream;
 
      PaStreamParameters playbackParameters;
 
      playbackParameters.device = playDeviceNum;
      playbackParameters.sampleFormat = paFloat32;
      playbackParameters.hostApiSpecificStreamInfo = NULL;
      playbackParameters.channelCount = 1;
      if (Pa_GetDeviceInfo(playDeviceNum)){
         playbackParameters.suggestedLatency =
            Pa_GetDeviceInfo(playDeviceNum)->defaultLowOutputLatency;
      }
      else
         playbackParameters.suggestedLatency =
            AudioIOLatencyCorrection.GetDefault()/1000.0;
 
      PaStreamParameters captureParameters;
 
      captureParameters.device = recDeviceNum;
      captureParameters.sampleFormat = paFloat32;;
      captureParameters.hostApiSpecificStreamInfo = NULL;
      captureParameters.channelCount = 1;
      if (Pa_GetDeviceInfo(recDeviceNum)){
         captureParameters.suggestedLatency =
            Pa_GetDeviceInfo(recDeviceNum)->defaultLowInputLatency;
      }
      else
         captureParameters.suggestedLatency =
            AudioIOLatencyCorrection.GetDefault()/1000.0;
 
      // Not really doing I/O so pass nullptr for the callback function
      error = Pa_OpenStream(&stream,
                         &captureParameters, &playbackParameters,
                         highestSampleRate, paFramesPerBufferUnspecified,
                         paClipOff | paDitherOff,
                         nullptr, NULL);
 
      if (error) {
         error = Pa_OpenStream(&stream,
                            &captureParameters, NULL,
                            highestSampleRate, paFramesPerBufferUnspecified,
                            paClipOff | paDitherOff,
                            nullptr, NULL);
      }
 
      if (error) {
         s << XO("Received %d while opening devices\n").Format( error );
         return o.GetString();
      }
 
      PxMixer *PortMixer = Px_OpenMixer(stream, recDeviceNum, playDeviceNum, 0);
 
      if (!PortMixer) {
         s << XO("Unable to open Portmixer\n");
         Pa_CloseStream(stream);
         return o.GetString();
      }
 
      s << wxT("==============================\n");
      s << XO("Available mixers:\n");
 
      // FIXME: ? PortMixer errors on query not reported in GetDeviceInfo
      cnt = Px_GetNumMixers(stream);
      for (int i = 0; i < cnt; i++) {
         wxString name = wxSafeConvertMB2WX(Px_GetMixerName(stream, i));
         s << XO("%d - %s\n").Format( i, name );
      }
 
      s << wxT("==============================\n");
      s << XO("Available recording sources:\n");
      cnt = Px_GetNumInputSources(PortMixer);
      for (int i = 0; i < cnt; i++) {
         wxString name = wxSafeConvertMB2WX(Px_GetInputSourceName(PortMixer, i));
         s << XO("%d - %s\n").Format( i, name );
      }
 
      s << wxT("==============================\n");
      s << XO("Available playback volumes:\n");
      cnt = Px_GetNumOutputVolumes(PortMixer);
      for (int i = 0; i < cnt; i++) {
         wxString name = wxSafeConvertMB2WX(Px_GetOutputVolumeName(PortMixer, i));
         s << XO("%d - %s\n").Format( i, name );
      }
 
     // Check, if PortMixer supports adjusting input levels on the interface
 
      MixerInputVol = Px_GetInputVolume(PortMixer);
      EmulateMixerInputVol = false;
      Px_SetInputVolume(PortMixer, 0.0);
      if (Px_GetInputVolume(PortMixer) > 0.1)
         EmulateMixerInputVol = true;
      Px_SetInputVolume(PortMixer, 0.2f);
      if (Px_GetInputVolume(PortMixer) < 0.1 ||
          Px_GetInputVolume(PortMixer) > 0.3)
         EmulateMixerInputVol = true;
      Px_SetInputVolume(PortMixer, MixerInputVol);
 
      Pa_CloseStream(stream);
 
      s << wxT("==============================\n");
      s << ( EmulateMixerInputVol
         ? XO("Recording volume is emulated\n")
         : XO("Recording volume is native\n") );
 
      Px_CloseMixer(PortMixer);
 
      }  //end of massive if statement if a valid sample rate has been found
#endif
   return o.GetString();
}

References AudioIOLatencyCorrection, AudioIOPlaybackDevice, AudioIORecordingDevice, DeviceName(), Setting< T >::GetDefault(), GetSupportedCaptureRates(), GetSupportedPlaybackRates(), GetSupportedSampleRates(), HostName(), IsStreamActive(), name, Setting< T >::Read(), anonymous_namespace{ExportOpus.cpp}::supportedSampleRates, wxT(), and XO().

Here is the call graph for this function:

GetOptimalSupportedSampleRate()

int AudioIOBase::GetOptimalSupportedSampleRate ( )

static

Get a supported sample rate which can be used a an optimal default.

Currently, this uses the first supported rate in the list [44100, 48000, highest sample rate]. Used in Project as a default value for project rates if one cannot be retrieved from the preferences. So all in all not that useful or important really

Todo:

: should this take into account PortAudio's value for PaDeviceInfo::defaultSampleRate? In principal this should let us work out which rates are "real" and which resampled in the drivers, and so prefer the real rates.

Definition at line 669 of file AudioIOBase.cpp.

{
   auto rate = GetClosestSupportedSampleRate(-1, -1, 44100);
 
   // if there are no supported rates, the next bit crashes. So check first,
   // and give them a "sensible" value if there are no valid values. They
   // will still get an error later, but with any luck may have changed
   // something by then. It's no worse than having an invalid default rate
   // stored in the preferences, which we don't check for
   if (rate == 0)
   {
      return 44100;
   }
 
   return rate;
}

References GetClosestSupportedSampleRate().

Here is the call graph for this function:

getPlayDevIndex()

int AudioIOBase::getPlayDevIndex ( const wxString &  devName = {} )

staticprotected

get the index of the device selected in the preferences.

If the device isn't found, returns -1

get the index of the supplied (named) playback device, or the device selected in the preferences if none given.

Pure utility function, but it comes round a number of times in the code and would be neater done once. If the device isn't found, return the default device index.

Definition at line 700 of file AudioIOBase.cpp.

{
   wxString devName(devNameArg);
   // if we don't get given a device, look up the preferences
   if (devName.empty())
      devName = AudioIOPlaybackDevice.Read();
 
   auto hostName = AudioIOHost.Read();
   PaHostApiIndex hostCnt = Pa_GetHostApiCount();
   PaHostApiIndex hostNum;
   for (hostNum = 0; hostNum < hostCnt; hostNum++)
   {
      const PaHostApiInfo *hinfo = Pa_GetHostApiInfo(hostNum);
      if (hinfo && wxString(wxSafeConvertMB2WX(hinfo->name)) == hostName)
      {
         for (PaDeviceIndex hostDevice = 0; hostDevice < hinfo->deviceCount; hostDevice++)
         {
            PaDeviceIndex deviceNum = Pa_HostApiDeviceIndexToDeviceIndex(hostNum, hostDevice);
 
            const PaDeviceInfo *dinfo = Pa_GetDeviceInfo(deviceNum);
            if (dinfo && DeviceName(dinfo) == devName && dinfo->maxOutputChannels > 0 )
            {
               // this device name matches the stored one, and works.
               // So we say this is the answer and return it
               return deviceNum;
            }
         }
 
         // The device wasn't found so use the default for this host.
         // LL:  At this point, preferences and active no longer match.
         return hinfo->defaultOutputDevice;
      }
   }
 
   // The host wasn't found, so use the default output device.
   // FIXME: TRAP_ERR PaErrorCode not handled well (this code is similar to input code
   // and the input side has more comments.)
 
   PaDeviceIndex deviceNum = Pa_GetDefaultOutputDevice();
 
   // Sometimes PortAudio returns -1 if it cannot find a suitable default
   // device, so we just use the first one available
   //
   // LL:  At this point, preferences and active no longer match
   //
   //      And I can't imagine how far we'll get specifying an "invalid" index later
   //      on...are we certain "0" even exists?
   if (deviceNum < 0) {
      assert(false);
      deviceNum = 0;
   }
 
   return deviceNum;
}

References AudioIOHost, AudioIOPlaybackDevice, DeviceName(), and Setting< T >::Read().

Referenced by GetClosestSupportedPlaybackRate(), GetClosestSupportedSampleRate(), GetSupportedPlaybackRates(), GetSupportedSampleRates(), HandleDeviceChange(), AudioIO::Init(), IsPlaybackRateSupported(), AudioIO::StartPortAudioStream(), and AudioIO::ValidateDeviceNames().

Here is the call graph for this function:

Here is the caller graph for this function:

getRecordDevIndex()

int AudioIOBase::getRecordDevIndex ( const wxString &  devName = {} )

staticprotected

get the index of the supplied (named) recording device, or the device selected in the preferences if none given.

Pure utility function, but it comes round a number of times in the code and would be neater done once. If the device isn't found, return the default device index.

Definition at line 755 of file AudioIOBase.cpp.

{
   wxString devName(devNameArg);
   // if we don't get given a device, look up the preferences
   if (devName.empty())
      devName = AudioIORecordingDevice.Read();
 
   auto hostName = AudioIOHost.Read();
   PaHostApiIndex hostCnt = Pa_GetHostApiCount();
   PaHostApiIndex hostNum;
   for (hostNum = 0; hostNum < hostCnt; hostNum++)
   {
      const PaHostApiInfo *hinfo = Pa_GetHostApiInfo(hostNum);
      if (hinfo && wxString(wxSafeConvertMB2WX(hinfo->name)) == hostName)
      {
         for (PaDeviceIndex hostDevice = 0; hostDevice < hinfo->deviceCount; hostDevice++)
         {
            PaDeviceIndex deviceNum = Pa_HostApiDeviceIndexToDeviceIndex(hostNum, hostDevice);
 
            const PaDeviceInfo *dinfo = Pa_GetDeviceInfo(deviceNum);
            if (dinfo && DeviceName(dinfo) == devName && dinfo->maxInputChannels > 0 )
            {
               // this device name matches the stored one, and works.
               // So we say this is the answer and return it
               return deviceNum;
            }
         }
 
         // The device wasn't found so use the default for this host.
         // LL:  At this point, preferences and active no longer match.
         return hinfo->defaultInputDevice;
      }
   }
 
   // The host wasn't found, so use the default input device.
   // FIXME: TRAP_ERR PaErrorCode not handled well in getRecordDevIndex()
   PaDeviceIndex deviceNum = Pa_GetDefaultInputDevice();
 
   // Sometimes PortAudio returns -1 if it cannot find a suitable default
   // device, so we just use the first one available
   // PortAudio has an error reporting function.  We should log/report the error?
   //
   // LL:  At this point, preferences and active no longer match
   //
   //      And I can't imagine how far we'll get specifying an "invalid" index later
   //      on...are we certain "0" even exists?
   if (deviceNum < 0) {
      // JKC: This will happen if you run with no config file
      // This happens once.  Config file will exist on the next run.
      // TODO: Look into this a bit more.  Could be relevant to blank Device Toolbar.
      wxLogDebug("PortAudio returns -1, cannot find a suitable default device, so we just use the first one available");
      deviceNum = 0;
   }
 
   return deviceNum;
}

References AudioIOHost, AudioIORecordingDevice, DeviceName(), and Setting< T >::Read().

Referenced by GetClosestSupportedCaptureRate(), GetClosestSupportedSampleRate(), GetSupportedCaptureRates(), GetSupportedSampleRates(), HandleDeviceChange(), AudioIO::Init(), IsCaptureRateSupported(), AudioIO::StartPortAudioStream(), and AudioIO::ValidateDeviceNames().

Here is the call graph for this function:

Here is the caller graph for this function:

GetSupportedCaptureRates()

std::vector< long > AudioIOBase::GetSupportedCaptureRates ( int  devIndex = -1 )

static

Get a list of sample rates the input (recording) device supports.

If no information about available sample rates can be fetched, an empty list is returned.

You can explicitly give the index of the device. If you don't give it, the currently selected device from the preferences will be used.

Definition at line 485 of file AudioIOBase.cpp.

{
   if (devIndex == -1)
   {  // weren't given a device index, get the prefs / default one
      devIndex = getRecordDevIndex();
   }
 
   std::vector<long> supportedRates;
 
   for(const long rate : RatesToTry) {
      if (IsCaptureRateSupported(devIndex, rate)) {
         supportedRates.push_back(rate);
      }
      Pa_Sleep( 10 );   // There are ALSA drivers that don't like being probed
                        // too quickly.
   }
 
   return supportedRates;
}

References getRecordDevIndex(), IsCaptureRateSupported(), and RatesToTry.

Referenced by GetDeviceInfo(), and GetSupportedSampleRates().

Here is the call graph for this function:

Here is the caller graph for this function:

GetSupportedPlaybackRates()

std::vector< long > AudioIOBase::GetSupportedPlaybackRates ( int  DevIndex = -1 )

static

Get a list of sample rates the output (playback) device supports.

If no information about available sample rates can be fetched, an empty list is returned.

You can explicitly give the index of the device. If you don't give it, the currently selected device from the preferences will be used.

Definition at line 465 of file AudioIOBase.cpp.

{
   if (devIndex == -1)
   {  // weren't given a device index, get the prefs / default one
      devIndex = getPlayDevIndex();
   }
 
   std::vector<long> supportedRates;
 
   for(const long rate : RatesToTry) {
      if (IsPlaybackRateSupported(devIndex, rate)) {
         supportedRates.push_back(rate);
      }
      Pa_Sleep( 10 );   // There are ALSA drivers that don't like being probed
                        // too quickly.
   }
 
   return supportedRates;
}

References getPlayDevIndex(), IsPlaybackRateSupported(), and RatesToTry.

Referenced by GetDeviceInfo(), and GetSupportedSampleRates().

Here is the call graph for this function:

Here is the caller graph for this function:

GetSupportedSampleRates()

std::vector< long > AudioIOBase::GetSupportedSampleRates ( int  playDevice = -1, int  recDevice = -1  )

static

Get a list of sample rates the current input/output device combination supports.

Since there is no concept (yet) for different input/output sample rates, this currently returns only sample rates that are supported on both the output and input device. If no information about available sample rates can be fetched, it returns a default list. You can explicitly give the indexes of the playDevice/recDevice. If you don't give them, the selected devices from the preferences will be used.

Definition at line 640 of file AudioIOBase.cpp.

{
   // Not given device indices, look up prefs
   if (playDevice == -1)
   {
      playDevice = getPlayDevIndex();
   }
   if (recDevice == -1)
   {
      recDevice = getRecordDevIndex();
   }
 
   auto playback = GetSupportedPlaybackRates(playDevice);
   auto capture = GetSupportedCaptureRates(recDevice);
 
   // Return only sample rates which are in both arrays
   std::vector<long> result;
 
   std::set_intersection(playback.begin(), playback.end(),
                         capture.begin(), capture.end(),
                         std::back_inserter(result));
 
   return result;
}

References getPlayDevIndex(), getRecordDevIndex(), GetSupportedCaptureRates(), and GetSupportedPlaybackRates().

Referenced by GetDeviceInfo().

Here is the call graph for this function:

Here is the caller graph for this function:

HandleDeviceChange()

void AudioIOBase::HandleDeviceChange

(

)

update state after changing what audio devices are selected

Called when the devices stored in the preferences are changed to update the audio mixer capabilities

Todo:

: Make this do a sample rate query and store the result in the AudioIO object to avoid doing it later? Would simplify the GetSupported*Rate functions considerably

Definition at line 112 of file AudioIOBase.cpp.

{
   // This should not happen, but it would screw things up if it did.
   // Vaughan, 2010-10-08: But it *did* happen, due to a bug, and nobody
   // caught it because this method just returned. Added wxASSERT().
   wxASSERT(!IsStreamActive());
   if (IsStreamActive())
      return;
 
   // get the selected record and playback devices
   const int playDeviceNum = getPlayDevIndex();
   const int recDeviceNum = getRecordDevIndex();
 
   // If no change needed, return
   if (mCurrentPlaybackIndex == playDeviceNum &&
       mCurrentCaptureIndex == recDeviceNum)
       return;
 
   // Update playback/capture device indices
   mCurrentPlaybackIndex = playDeviceNum;
   mCurrentCaptureIndex = recDeviceNum;
   mCachedBestRateIn = 0.0;
 
#if defined(USE_PORTMIXER)
 
   // if we have a PortMixer object, close it down
   if (mPortMixer) {
      #if __WXMAC__
      // on the Mac we must make sure that we restore the hardware playthrough
      // state of the sound device to what it was before, because there isn't
      // a UI for this (!)
      if (Px_SupportsPlaythrough(mPortMixer) && mPreviousHWPlaythrough >= 0.0)
         Px_SetPlaythrough(mPortMixer, mPreviousHWPlaythrough);
         mPreviousHWPlaythrough = -1.0;
      #endif
      Px_CloseMixer(mPortMixer);
      mPortMixer = NULL;
   }
 
   // Looking for highest supported sample rate for a given
   // play/rec device pair
   long highestSampleRate = GetClosestSupportedSampleRate(playDeviceNum, recDeviceNum, INT_MAX);
   if (highestSampleRate == 0)
   {
      // we don't actually have any rates that work for Rec and Play. Guess one
      // to use for messing with the mixer, which doesn't actually do either
      highestSampleRate = 44100;
   }
 
   mInputMixerWorks = false;
 
   int error;
   // This tries to open the device with the samplerate worked out above, which
   // will be the highest available for play and record on the device, or
   // 44.1kHz if the info cannot be fetched.
 
   PaStream *stream;
 
   PaStreamParameters playbackParameters;
 
   playbackParameters.device = playDeviceNum;
   playbackParameters.sampleFormat = paFloat32;
   playbackParameters.hostApiSpecificStreamInfo = NULL;
   playbackParameters.channelCount = 1;
   if (Pa_GetDeviceInfo(playDeviceNum))
      playbackParameters.suggestedLatency =
         Pa_GetDeviceInfo(playDeviceNum)->defaultLowOutputLatency;
   else
      playbackParameters.suggestedLatency =
         AudioIOLatencyCorrection.GetDefault()/1000.0;
 
   PaStreamParameters captureParameters;
 
   captureParameters.device = recDeviceNum;
   captureParameters.sampleFormat = paFloat32;;
   captureParameters.hostApiSpecificStreamInfo = NULL;
   captureParameters.channelCount = 1;
   if (Pa_GetDeviceInfo(recDeviceNum))
      captureParameters.suggestedLatency =
         Pa_GetDeviceInfo(recDeviceNum)->defaultLowInputLatency;
   else
      captureParameters.suggestedLatency =
         AudioIOLatencyCorrection.GetDefault()/1000.0;
 
   // try opening for record and playback
   // Not really doing I/O so pass nullptr for the callback function
   error = Pa_OpenStream(&stream,
                         &captureParameters, &playbackParameters,
                         highestSampleRate, paFramesPerBufferUnspecified,
                         paClipOff | paDitherOff,
                         nullptr, NULL);
 
   if (!error) {
      // Try portmixer for this stream
      mPortMixer = Px_OpenMixer(stream, recDeviceNum, playDeviceNum, 0);
      if (!mPortMixer) {
         Pa_CloseStream(stream);
         error = true;
      }
   }
 
   // if that failed, try just for record
   if( error ) {
      error = Pa_OpenStream(&stream,
                            &captureParameters, NULL,
                            highestSampleRate, paFramesPerBufferUnspecified,
                            paClipOff | paDitherOff,
                            nullptr, NULL);
 
      if (!error) {
         mPortMixer = Px_OpenMixer(stream, recDeviceNum, playDeviceNum, 0);
         if (!mPortMixer) {
            Pa_CloseStream(stream);
            error = true;
         }
      }
   }
 
   // finally, try just for playback
   if ( error ) {
      error = Pa_OpenStream(&stream,
                            NULL, &playbackParameters,
                            highestSampleRate, paFramesPerBufferUnspecified,
                            paClipOff | paDitherOff,
                            nullptr, NULL);
 
      if (!error) {
         mPortMixer = Px_OpenMixer(stream, recDeviceNum, playDeviceNum, 0);
         if (!mPortMixer) {
            Pa_CloseStream(stream);
            error = true;
         }
      }
   }
 
   // FIXME: TRAP_ERR errors in HandleDeviceChange not reported.
   // if it's still not working, give up
   if( error )
      return;
 
   // Set input source
#if USE_PORTMIXER
   auto sourceIndex = AudioIORecordingSourceIndex.Read(); // defaults to -1
   if (sourceIndex >= 0) {
      //the current index of our source may be different because the stream
      //is a combination of two devices, so update it.
      sourceIndex = getRecordSourceIndex(mPortMixer);
      if (sourceIndex >= 0)
         SetMixer(sourceIndex);
   }
#endif
 
   // Determine mixer capabilities - if it doesn't support control of output
   // signal level, we emulate it (by multiplying this value by all outgoing
   // samples)
 
   float inputVol = Px_GetInputVolume(mPortMixer);
   mInputMixerWorks = true;   // assume it works unless proved wrong
   Px_SetInputVolume(mPortMixer, 0.0);
   if (Px_GetInputVolume(mPortMixer) > 0.1)
      mInputMixerWorks = false;  // can't set to zero
   Px_SetInputVolume(mPortMixer, 0.2f);
   if (Px_GetInputVolume(mPortMixer) < 0.1 ||
       Px_GetInputVolume(mPortMixer) > 0.3)
      mInputMixerWorks = false;  // can't set level accurately
   Px_SetInputVolume(mPortMixer, inputVol);
 
   Pa_CloseStream(stream);
 
 
   #if 0
   wxPrintf("PortMixer: Recording: %s\n"
          mInputMixerWorks? "hardware": "no control");
   #endif
#endif   // USE_PORTMIXER
}

References AudioIOLatencyCorrection, AudioIORecordingSourceIndex, GetClosestSupportedSampleRate(), Setting< T >::GetDefault(), getPlayDevIndex(), getRecordDevIndex(), IsStreamActive(), mCachedBestRateIn, mCurrentCaptureIndex, mCurrentPlaybackIndex, mInputMixerWorks, Setting< T >::Read(), and SetMixer().

Referenced by AudioIO::AudioIO().

Here is the call graph for this function:

Here is the caller graph for this function:

HostName()

wxString AudioIOBase::HostName ( const PaDeviceInfo *  info )

staticprotected

Definition at line 83 of file AudioIOBase.cpp.

{
   wxString hostapiName = wxSafeConvertMB2WX(Pa_GetHostApiInfo(info->hostApi)->name);
 
   return hostapiName;
}

Referenced by GetDeviceInfo(), and AudioIO::Init().

Here is the caller graph for this function:

IsAudioTokenActive()

bool AudioIOBase::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.

This is used by TrackPanel to determine when a track has been completely recorded, and it's safe to flush to disk.

Definition at line 354 of file AudioIOBase.cpp.

{
   return ( token > 0 && token == mStreamToken );
}

References mStreamToken.

Referenced by AudioIOBusyPred(), and IsStreamActive().

Here is the caller graph for this function:

IsBusy()

bool AudioIOBase::IsBusy

(

)

const

Returns true if audio i/o is busy starting, stopping, playing, or recording.

When this is false, it's safe to start playing or recording

Definition at line 328 of file AudioIOBase.cpp.

{
   if (mStreamToken != 0)
      return true;
 
   return false;
}

References mStreamToken.

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

Here is the caller graph for this function:

IsCaptureRateSupported()

bool AudioIOBase::IsCaptureRateSupported ( int  devIndex, long  rate  )

static

Check if the specified sample rate is supported by a device.

Verifies if a recording device supports a given rate. If no device index is specified (devIndex == -1), the preferred device is used.

Definition at line 413 of file AudioIOBase.cpp.

{
   if (devIndex == -1)
   {  // not given a device, look up in prefs / default
      devIndex = getRecordDevIndex();
   }
 
   // Check if we can use the cached rate
   if (mCachedCaptureRates.count(devIndex) &&
       (make_iterator_range(mCachedCaptureRates.at(devIndex)).contains(rate)))
   {
      return true;
   }
 
   auto devInfo = Pa_GetDeviceInfo(devIndex);
 
   if (!devInfo)
   {
      wxLogDebug(wxT("IsCaptureRateSupported() Could not get device info!"));
      return false;
   }
 
   auto latencyDuration = AudioIOLatencyDuration.Read();
   // Why not defaulting to 2 as elsewhere?
   auto recordChannels = AudioIORecordChannels.ReadWithDefault(1);
 
   // LLL: Remove when a proper method of determining actual supported
   //      DirectSound rate is devised.
   const PaHostApiInfo* hostInfo = Pa_GetHostApiInfo(devInfo->hostApi);
   bool isDirectSound = (hostInfo && hostInfo->type == paDirectSound);
 
   PaStreamParameters pars;
 
   pars.device = devIndex;
   pars.channelCount = recordChannels;
   pars.sampleFormat = paFloat32;
   pars.suggestedLatency = latencyDuration / 1000.0;
   pars.hostApiSpecificStreamInfo = NULL;
 
   // LLL: Remove when a proper method of determining actual supported
   //      DirectSound rate is devised.
   if (!(isDirectSound && rate > 200000))
   {
      if (Pa_IsFormatSupported(&pars, NULL, rate) == 0)
      {
         mCachedCaptureRates[devIndex].push_back(rate);
         return true;
      }
   }
   return false;
}

References AudioIOLatencyDuration, AudioIORecordChannels, getRecordDevIndex(), make_iterator_range(), mCachedCaptureRates, Setting< T >::Read(), Setting< T >::ReadWithDefault(), and wxT().

Referenced by GetClosestSupportedCaptureRate(), GetClosestSupportedSampleRate(), and GetSupportedCaptureRates().

Here is the call graph for this function:

Here is the caller graph for this function:

IsMonitoring()

bool AudioIOBase::IsMonitoring

(

)

const

Returns true if we're monitoring input (but not recording or playing actual audio)

Definition at line 359 of file AudioIOBase.cpp.

{
   return ( mPortStreamV19 && mStreamToken==0 );
}

References mPortStreamV19, and mStreamToken.

Referenced by AudioIO::AudioThread().

Here is the caller graph for this function:

IsPaused()

bool AudioIOBase::IsPaused

(

)

const

Find out if playback / recording is currently paused.

Definition at line 323 of file AudioIOBase.cpp.

{
   return mPaused.load(std::memory_order_relaxed);
}

References mPaused.

Referenced by AudioIoCallback::AudioCallback(), AudioIoCallback::CallbackCheckCompletion(), AudioIoCallback::CheckSoundActivatedRecordingLevel(), AudioIoCallback::FillOutputBuffers(), PausedFlag(), and AudioIO::SetPaused().

Here is the caller graph for this function:

IsPlaybackRateSupported()

bool AudioIOBase::IsPlaybackRateSupported ( int  devIndex, long  rate  )

static

Check if the specified playback rate is supported by a device.

Verifies if a playback device supports a given rate. If no device index is specified (devIndex == -1), the preferred device is used.

Definition at line 364 of file AudioIOBase.cpp.

{
   if (devIndex == -1)
   {  // weren't given a device index, get the prefs / default one
      devIndex = getPlayDevIndex();
   }
 
   // Check if we can use the cached rate
   if (mCachedPlaybackRates.count(devIndex) &&
       (make_iterator_range(mCachedPlaybackRates.at(devIndex)).contains(rate)))
   {
      return true;
   }
 
   auto devInfo = Pa_GetDeviceInfo(devIndex);
 
   if (!devInfo)
   {
      wxLogDebug(wxT("IsPlaybackRateSupported() Could not get device info!"));
      return false;
   }
 
   // LLL: Remove when a proper method of determining actual supported
   //      DirectSound rate is devised.
   const PaHostApiInfo* hostInfo = Pa_GetHostApiInfo(devInfo->hostApi);
   bool isDirectSound = (hostInfo && hostInfo->type == paDirectSound);
 
   PaStreamParameters pars;
 
   pars.device = devIndex;
   pars.channelCount = 1;
   pars.sampleFormat = paFloat32;
   pars.suggestedLatency = devInfo->defaultHighOutputLatency;
   pars.hostApiSpecificStreamInfo = NULL;
 
   // JKC: PortAudio Errors handled OK here.  No need to report them
 
   // LLL: Remove when a proper method of determining actual supported
   //      DirectSound rate is devised.
   if (!(isDirectSound && rate > 200000)){
      if (Pa_IsFormatSupported(NULL, &pars, rate) == 0)
      {
         mCachedPlaybackRates[devIndex].push_back(rate);
         return true;
      }
   }
   return false;
}

References getPlayDevIndex(), make_iterator_range(), mCachedPlaybackRates, and wxT().

Referenced by GetClosestSupportedPlaybackRate(), GetClosestSupportedSampleRate(), and GetSupportedPlaybackRates().

Here is the call graph for this function:

Here is the caller graph for this function:

IsStreamActive() [1/2]

bool AudioIOBase::IsStreamActive

(

)

const

Returns true if the audio i/o is running at all, but not during cleanup.

Doesn't return true if the device has been closed but some disk i/o or cleanup is still going on. If you want to know if it's safe to start a NEW stream, use IsBusy()

Definition at line 336 of file AudioIOBase.cpp.

{
   bool isActive = false;
   // JKC: Not reporting any Pa error, but that looks OK.
   if( mPortStreamV19 )
      isActive = (Pa_IsStreamActive( mPortStreamV19 ) > 0);
 
   isActive = isActive ||
      std::any_of(mAudioIOExt.begin(), mAudioIOExt.end(),
         [](auto &pExt){ return pExt && pExt->IsOtherStreamActive(); });
   return isActive;
}

References mAudioIOExt, and mPortStreamV19.

Referenced by AudioIO::DrainRecordBuffers(), GetDeviceInfo(), AudioIO::GetStreamTime(), HandleDeviceChange(), AudioIO::IsCapturing(), and IsStreamActive().

Here is the caller graph for this function:

IsStreamActive() [2/2]

bool AudioIOBase::IsStreamActive

(

int

token

)

const

Definition at line 349 of file AudioIOBase.cpp.

{
   return (this->IsStreamActive() && this->IsAudioTokenActive(token));
}

References IsAudioTokenActive(), and IsStreamActive().

Here is the call graph for this function:

operator=()

AudioIOBase & AudioIOBase::operator= ( const AudioIOBase &  )

delete

SetCaptureMeter()

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

Definition at line 289 of file AudioIOBase.cpp.

{
   if (auto pOwningProject = mOwningProject.lock();
       ( pOwningProject ) && ( pOwningProject != project))
      return;
 
   auto meter = wMeter.lock();
   if (meter)
   {
      mInputMeter = meter;
      meter->Reset(mRate, true);
   }
   else
      mInputMeter.reset();
}

References mInputMeter, mOwningProject, mRate, and project.

Referenced by AudioIO::StartPortAudioStream().

Here is the caller graph for this function:

SetMixer()

void AudioIOBase::SetMixer

(

int

inputSource

)

Definition at line 103 of file AudioIOBase.cpp.

{
#if defined(USE_PORTMIXER)
   int oldRecordSource = Px_GetCurrentInputSource(mPortMixer);
   if ( inputSource != oldRecordSource )
         Px_SetCurrentInputSource(mPortMixer, inputSource);
#endif
}

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

Here is the caller graph for this function:

SetPlaybackMeter()

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

Definition at line 306 of file AudioIOBase.cpp.

{
   if (auto pOwningProject = mOwningProject.lock();
       ( pOwningProject ) && ( pOwningProject != project))
      return;
 
   auto meter = wMeter.lock();
   if (meter)
   {
      mOutputMeter = meter;
      meter->Reset(mRate, true);
   }
   else
      mOutputMeter.reset();
}

References mOutputMeter, mOwningProject, mRate, and project.

StopStream()

virtual void AudioIOBase::StopStream ( )

pure virtual

Implemented in AudioIO.

Member Data Documentation

mAudioIOExt

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

protected

This class needs to iterate this array for one limited purpose but does not populate it and does not give access to it except to subclasses

Definition at line 381 of file AudioIOBase.h.

Referenced by IsStreamActive().

mCachedBestRateIn

double AudioIOBase::mCachedBestRateIn { 0.0 }

staticprotected

Definition at line 341 of file AudioIOBase.h.

Referenced by AudioIO::GetBestRate(), and HandleDeviceChange().

mCachedCaptureRates

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

staticprotected

Definition at line 337 of file AudioIOBase.h.

Referenced by GetClosestSupportedCaptureRate(), and IsCaptureRateSupported().

mCachedPlaybackRates

std::map< int, std::vector< long > > AudioIOBase::mCachedPlaybackRates

staticprotected

Definition at line 336 of file AudioIOBase.h.

Referenced by IsPlaybackRateSupported().

mCachedSampleRates

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

staticprotected

Definition at line 338 of file AudioIOBase.h.

Referenced by GetClosestSupportedSampleRate().

mCurrentCaptureIndex

int AudioIOBase::mCurrentCaptureIndex { -1 }

staticprotected

Definition at line 340 of file AudioIOBase.h.

Referenced by HandleDeviceChange().

mCurrentPlaybackIndex

int AudioIOBase::mCurrentPlaybackIndex { -1 }

staticprotected

Definition at line 339 of file AudioIOBase.h.

Referenced by HandleDeviceChange().

mInputMeter

std::weak_ptr<Meter> AudioIOBase::mInputMeter {}

protected

Definition at line 318 of file AudioIOBase.h.

Referenced by AudioIoCallback::SendVuInputMeterData(), SetCaptureMeter(), AudioIO::SetMeters(), AudioIO::StartPortAudioStream(), and AudioIO::StopStream().

mInputMixerWorks

bool AudioIOBase::mInputMixerWorks

protected

Can we control the hardware input level?

This flag is set to true if using portmixer to control the input volume seems to be working (and so we offer the user the control), and to false (locking the control out) otherwise. This avoids stupid scaled clipping problems when trying to do software emulated input volume control

Definition at line 333 of file AudioIOBase.h.

Referenced by AudioIO::AudioIO(), AudioIO::GetMixer(), HandleDeviceChange(), and AudioIO::InputMixerWorks().

mOutputMeter

std::weak_ptr<Meter> AudioIOBase::mOutputMeter {}

protected

Definition at line 319 of file AudioIOBase.h.

Referenced by AudioIO::AudioIO(), AudioIoCallback::SendVuOutputMeterData(), AudioIO::SetMeters(), SetPlaybackMeter(), AudioIO::StartPortAudioStream(), and AudioIO::StopStream().

mOwningProject

std::weak_ptr<AudacityProject> AudioIOBase::mOwningProject

protected

Definition at line 304 of file AudioIOBase.h.

Referenced by AudioIO::FillPlayBuffers(), AudioIO::IsAvailable(), AudioIO::ResetOwningProject(), SetCaptureMeter(), AudioIO::SetOwningProject(), AudioIO::SetPaused(), SetPlaybackMeter(), AudioIO::StartMonitoring(), AudioIO::StartPortAudioStream(), AudioIO::StartStream(), AudioIO::StopStream(), and AudioIO::~AudioIO().

mPaused

std::atomic<bool> AudioIOBase::mPaused { false }

protected

True if audio playback is paused.

Definition at line 307 of file AudioIOBase.h.

Referenced by IsPaused(), and AudioIO::SetPaused().

mPortStreamV19

PaStream* AudioIOBase::mPortStreamV19

protected

Definition at line 316 of file AudioIOBase.h.

Referenced by AudioIO::AudioIO(), AudioIO::DelayingActions(), IsMonitoring(), IsStreamActive(), AudioIO::StartMonitoring(), AudioIO::StartPortAudioStream(), AudioIO::StartStream(), AudioIO::StartStreamCleanup(), and AudioIO::StopStream().

mRate

double AudioIOBase::mRate

protected

Audio playback rate in samples per second.

Read by worker threads but unchanging during playback

Definition at line 314 of file AudioIOBase.h.

Referenced by AudioIO::AllocateBuffers(), AudioIoCallback::AudioCallback(), AudioIoCallback::DrainInputBuffers(), AudioIO::DrainRecordBuffers(), SetCaptureMeter(), AudioIO::SetMeters(), SetPlaybackMeter(), AudioIO::StartMonitoring(), AudioIO::StartPortAudioStream(), AudioIO::StartStream(), AudioIO::StopStream(), and AudioIoCallback::UpdateTimePosition().

mStreamToken

int AudioIOBase::mStreamToken { 0 }

protected

Read by worker threads but unchanging during playback

Definition at line 310 of file AudioIOBase.h.

Referenced by AudioIoCallback::AudioCallback(), AudioIoCallback::CallbackDoSeek(), AudioIoCallback::DrainInputBuffers(), AudioIoCallback::FillOutputBuffers(), IsAudioTokenActive(), IsBusy(), IsMonitoring(), AudioIO::StartMonitoring(), AudioIO::StartStream(), AudioIO::StartStreamCleanup(), AudioIO::StopStream(), and AudioIoCallback::UpdateTimePosition().

NumRatesToTry

const int AudioIOBase::NumRatesToTry = WXSIZEOF(AudioIOBase::RatesToTry)

staticprotected

How many sample rates to try.

Definition at line 376 of file AudioIOBase.h.

Referenced by GetClosestSupportedCaptureRate(), GetClosestSupportedPlaybackRate(), and GetClosestSupportedSampleRate().

NumStandardRates

const int AudioIOBase::NumStandardRates = WXSIZEOF(AudioIOBase::StandardRates)

static

How many standard sample rates there are.

Definition at line 250 of file AudioIOBase.h.

Referenced by DevicePrefs::GetNamesAndLabels(), and ImportRawDialog::ImportRawDialog().

RatesToTry

const int AudioIOBase::RatesToTry

staticprotected

Initial value:

= {
   8000,
   9600,
   11025,
   12000,
   15000,
   16000,
   22050,
   24000,
   32000,
   44100,
   48000,
   88200,
   96000,
   176400,
   192000,
   352800,
   384000
}

Array of audio sample rates to try to use.

These are the rates we will check if a device supports, and is as long as I can think of (to try and work out what the card can do)

Definition at line 374 of file AudioIOBase.h.

Referenced by GetClosestSupportedCaptureRate(), GetClosestSupportedPlaybackRate(), GetClosestSupportedSampleRate(), GetSupportedCaptureRates(), and GetSupportedPlaybackRates().

StandardRates

const int AudioIOBase::StandardRates

static

Initial value:

= {
   8000,
   11025,
   16000,
   22050,
   32000,
   44100,
   48000,
   88200,
   96000,
   176400,
   192000,
   352800,
   384000
}

Array of common audio sample rates.

These are the rates we will always support, regardless of hardware support for them (by resampling in audacity if needed)

Definition at line 248 of file AudioIOBase.h.

Referenced by DevicePrefs::GetNamesAndLabels(), and ImportRawDialog::ImportRawDialog().

ugAudioIO

std::unique_ptr< AudioIOBase > AudioIOBase::ugAudioIO

staticprotected

Definition at line 300 of file AudioIOBase.h.

Referenced by AudioIO::Deinit(), Get(), and AudioIO::Init().

---

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

• AudioIOBase.h
• AudioIOBase.cpp