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, double rate=0.0)
	Get a list of sample rates the output (playback) device supports. More...
static std::vector< long >	GetSupportedCaptureRates (int devIndex=-1, double rate=0.0)
	Get a list of sample rates the input (recording) device supports. More...
static std::vector< long >	GetSupportedSampleRates (int playDevice=-1, int recDevice=-1, double rate=0.0)
	Get a list of sample rates the current input/output device combination supports. More...
static int	GetOptimalSupportedSampleRate ()
	Get a supported sample rate which can be used a an optimal default. More...

Static 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 int	mCachedPlaybackIndex = -1
static std::vector< long >	mCachedPlaybackRates
static int	mCachedCaptureIndex = -1
static std::vector< long >	mCachedCaptureRates
static std::vector< long >	mCachedSampleRates
static double	mCachedBestRateIn = 0.0
static const int	RatesToTry []
	Array of audio sample rates to try to use. More...
static const int	NumRatesToTry = WXSIZEOF(AudioIOBase::RatesToTry)
	How many sample rates to try. More...

Detailed Description

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

Definition at line 100 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 75 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 93 of file AudioIOBase.cpp.

{
   return ugAudioIO.get();
}

References ugAudioIO.

Referenced by AudioIOBusyPred(), AudioSetupToolBar::CommonMenuItemSteps(), LabelTrackView::DoCaptureKey(), AdornedRulerPanel::DoSelectionChange(), TransportUtilities::DoStartPlaying(), TransportUtilities::DoStopPlaying(), LyricsPanel::DoUpdateLyrics(), cloud::ShareAudioToolbar::EnableDisableButtons(), AudioSetupToolBar::EnableDisableButtons(), DeviceToolBar::EnableDisableButtons(), AudioIO::Get(), GetMIDIDeviceInfo(), ProjectAudioIO::IsAudioActive(), ScrubState::IsScrubbing(), anonymous_namespace{TransportMenus.cpp}::MakeReadyToPlay(), anonymous_namespace{HelpMenus.cpp}::OnAudioDeviceInfo(), DeviceToolBar::OnChoice(), ControlToolBar::OnKeyEvent(), TranscriptionToolBar::OnKeyEvent(), 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 926 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:

GetDeviceInfo()

wxString AudioIOBase::GetDeviceInfo

(

)

const

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

Definition at line 697 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 );
 
      auto rates = GetSupportedPlaybackRates(j, 0.0);
 
      /* i18n-hint: Supported, meaning made available by the system */
      s << XO("Supported 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(), GetSupportedPlaybackRates(), GetSupportedSampleRates(), HostName(), IsStreamActive(), name, Setting< T >::Read(), 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 551 of file AudioIOBase.cpp.

{
   auto rates = GetSupportedSampleRates();
 
   if (make_iterator_range(rates).contains(44100))
      return 44100;
 
   if (make_iterator_range(rates).contains(48000))
      return 48000;
 
   // 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 (rates.empty()) return 44100;
 
   return rates.back();
}

References GetSupportedSampleRates(), and make_iterator_range().

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 585 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 GetSupportedPlaybackRates(), GetSupportedSampleRates(), HandleDeviceChange(), AudioIO::Init(), 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 640 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 ASSERT 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.
      assert(false);
      deviceNum = 0;
   }
 
   return deviceNum;
}

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

Referenced by GetSupportedCaptureRates(), GetSupportedSampleRates(), HandleDeviceChange(), AudioIO::Init(), 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, double  rate = 0.0  )

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.

You may also specify a rate for which to check in addition to the standard rates.

Definition at line 437 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 rates
   if (mCachedCaptureIndex != -1 && devIndex == mCachedCaptureIndex
         && (rate == 0.0 || make_iterator_range(mCachedCaptureRates).contains(rate)))
   {
      return mCachedCaptureRates;
   }
 
   std::vector<long> supported;
   int irate = (int)rate;
   const PaDeviceInfo* devInfo = NULL;
   int i;
 
   devInfo = Pa_GetDeviceInfo(devIndex);
 
   if (!devInfo)
   {
      wxLogDebug(wxT("GetSupportedCaptureRates() Could not get device info!"));
      return supported;
   }
 
   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;
 
   for (i = 0; i < NumRatesToTry; i++)
   {
      // LLL: Remove when a proper method of determining actual supported
      //      DirectSound rate is devised.
      if (!(isDirectSound && RatesToTry[i] > 200000))
      {
         if (Pa_IsFormatSupported(&pars, NULL, RatesToTry[i]) == 0)
            supported.push_back(RatesToTry[i]);
         Pa_Sleep( 10 );// There are ALSA drivers that don't like being probed
         // too quickly.
      }
   }
 
   if (irate != 0 && !make_iterator_range(supported).contains(irate))
   {
      // LLL: Remove when a proper method of determining actual supported
      //      DirectSound rate is devised.
      if (!(isDirectSound && RatesToTry[i] > 200000))
         if (Pa_IsFormatSupported(&pars, NULL, irate) == 0)
            supported.push_back(irate);
   }
 
   return supported;
}

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

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

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, double  rate = 0.0  )

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.

You may also specify a rate for which to check in addition to the standard rates.

Definition at line 372 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 rates
   if (mCachedPlaybackIndex != -1 && devIndex == mCachedPlaybackIndex
         && (rate == 0.0 || make_iterator_range(mCachedPlaybackRates).contains(rate)))
   {
      return mCachedPlaybackRates;
   }
 
   std::vector<long> supported;
   int irate = (int)rate;
   const PaDeviceInfo* devInfo = NULL;
   int i;
 
   devInfo = Pa_GetDeviceInfo(devIndex);
 
   if (!devInfo)
   {
      wxLogDebug(wxT("GetSupportedPlaybackRates() Could not get device info!"));
      return supported;
   }
 
   // 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
   for (i = 0; i < NumRatesToTry; i++)
   {
      // LLL: Remove when a proper method of determining actual supported
      //      DirectSound rate is devised.
      if (!(isDirectSound && RatesToTry[i] > 200000)){
         if (Pa_IsFormatSupported(NULL, &pars, RatesToTry[i]) == 0)
            supported.push_back(RatesToTry[i]);
         Pa_Sleep( 10 );// There are ALSA drivers that don't like being probed
         // too quickly.
      }
   }
 
   if (irate != 0 && !make_iterator_range(supported).contains(irate))
   {
      // LLL: Remove when a proper method of determining actual supported
      //      DirectSound rate is devised.
      if (!(isDirectSound && RatesToTry[i] > 200000))
         if (Pa_IsFormatSupported(NULL, &pars, irate) == 0)
            supported.push_back(irate);
   }
 
   return supported;
}

References getPlayDevIndex(), make_iterator_range(), mCachedPlaybackIndex, mCachedPlaybackRates, NumRatesToTry, RatesToTry, and wxT().

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

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, double  rate = 0.0  )

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. You may also specify a rate for which to check in addition to the standard rates.

Definition at line 506 of file AudioIOBase.cpp.

{
   // 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
   if (mCachedPlaybackIndex != -1 && mCachedCaptureIndex != -1 &&
         playDevice == mCachedPlaybackIndex &&
         recDevice == mCachedCaptureIndex &&
         (rate == 0.0 || make_iterator_range(mCachedSampleRates).contains(rate)))
   {
      return mCachedSampleRates;
   }
 
   auto playback = GetSupportedPlaybackRates(playDevice, rate);
   auto capture = GetSupportedCaptureRates(recDevice, rate);
   int i;
 
   // Return only sample rates which are in both arrays
   std::vector<long> result;
 
   for (i = 0; i < (int)playback.size(); i++)
      if (make_iterator_range(capture).contains(playback[i]))
         result.push_back(playback[i]);
 
   // If this yields no results, use the default sample rates nevertheless
/*   if (result.empty())
   {
      for (i = 0; i < NumStandardRates; i++)
         result.push_back(StandardRates[i]);
   }*/
 
   return result;
}

References getPlayDevIndex(), getRecordDevIndex(), GetSupportedCaptureRates(), GetSupportedPlaybackRates(), make_iterator_range(), mCachedCaptureIndex, mCachedPlaybackIndex, and mCachedSampleRates.

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

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 111 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 (mCachedPlaybackIndex == playDeviceNum &&
       mCachedCaptureIndex == recDeviceNum)
       return;
 
   // cache playback/capture rates
   mCachedPlaybackRates = GetSupportedPlaybackRates(playDeviceNum);
   mCachedCaptureRates = GetSupportedCaptureRates(recDeviceNum);
   mCachedSampleRates = GetSupportedSampleRates(playDeviceNum, recDeviceNum);
   mCachedPlaybackIndex = playDeviceNum;
   mCachedCaptureIndex = 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;
   }
 
   // that might have given us no rates whatsoever, so we have to guess an
   // answer to do the next bit
   int numrates = mCachedSampleRates.size();
   int highestSampleRate;
   if (numrates > 0)
   {
      highestSampleRate = mCachedSampleRates[numrates - 1];
   }
   else
   {  // 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;
      // mCachedSampleRates is still empty, but it's not used again, so
      // can ignore
   }
 
   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, Setting< T >::GetDefault(), getPlayDevIndex(), getRecordDevIndex(), GetSupportedCaptureRates(), GetSupportedPlaybackRates(), GetSupportedSampleRates(), IsStreamActive(), mCachedBestRateIn, mCachedCaptureIndex, mCachedCaptureRates, mCachedPlaybackIndex, mCachedPlaybackRates, mCachedSampleRates, 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 82 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 362 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 336 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:

IsMonitoring()

bool AudioIOBase::IsMonitoring

(

)

const

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

Definition at line 367 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 331 of file AudioIOBase.cpp.

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

References mPaused.

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

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 344 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 357 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 297 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, and mRate.

Referenced by AudioIO::StartPortAudioStream().

Here is the caller graph for this function:

SetMixer()

void AudioIOBase::SetMixer

(

int

inputSource

)

Definition at line 102 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 314 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, and mRate.

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 322 of file AudioIOBase.h.

Referenced by IsStreamActive().

mCachedBestRateIn

double AudioIOBase::mCachedBestRateIn = 0.0

staticprotected

Definition at line 282 of file AudioIOBase.h.

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

mCachedCaptureIndex

int AudioIOBase::mCachedCaptureIndex = -1

staticprotected

Definition at line 279 of file AudioIOBase.h.

Referenced by GetSupportedCaptureRates(), GetSupportedSampleRates(), and HandleDeviceChange().

mCachedCaptureRates

std::vector< long > AudioIOBase::mCachedCaptureRates

staticprotected

Definition at line 280 of file AudioIOBase.h.

Referenced by GetSupportedCaptureRates(), and HandleDeviceChange().

mCachedPlaybackIndex

int AudioIOBase::mCachedPlaybackIndex = -1

staticprotected

Definition at line 277 of file AudioIOBase.h.

Referenced by GetSupportedPlaybackRates(), GetSupportedSampleRates(), and HandleDeviceChange().

mCachedPlaybackRates

std::vector< long > AudioIOBase::mCachedPlaybackRates

staticprotected

Definition at line 278 of file AudioIOBase.h.

Referenced by GetSupportedPlaybackRates(), and HandleDeviceChange().

mCachedSampleRates

std::vector< long > AudioIOBase::mCachedSampleRates

staticprotected

Definition at line 281 of file AudioIOBase.h.

Referenced by GetSupportedSampleRates(), and HandleDeviceChange().

mInputMeter

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

protected

Definition at line 259 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 274 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 260 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 245 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 248 of file AudioIOBase.h.

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

mPortStreamV19

PaStream* AudioIOBase::mPortStreamV19

protected

Definition at line 257 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 255 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 251 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 317 of file AudioIOBase.h.

Referenced by GetSupportedCaptureRates(), and GetSupportedPlaybackRates().

NumStandardRates

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

static

How many standard sample rates there are.

Definition at line 191 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 315 of file AudioIOBase.h.

Referenced by 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 189 of file AudioIOBase.h.

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

ugAudioIO

std::unique_ptr< AudioIOBase > AudioIOBase::ugAudioIO

staticprotected

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