Audacity  3.0.3
AudioIO.h
Go to the documentation of this file.
1 /**********************************************************************
2 
3  Audacity: A Digital Audio Editor
4 
5  AudioIO.h
6 
7  Dominic Mazzoni
8 
9  Use the PortAudio library to play and record sound
10 
11 **********************************************************************/
12 
13 #ifndef __AUDACITY_AUDIO_IO__
14 #define __AUDACITY_AUDIO_IO__
15 
16 
17 
18 #include "AudioIOBase.h" // to inherit
19 #include "PlaybackSchedule.h" // member variable
20 
21 #include <functional>
22 #include <memory>
23 #include <mutex>
24 #include <utility>
25 #include <wx/atomic.h> // member variable
26 
27 #include <wx/event.h> // to declare custom event types
28 
29 #include "SampleCount.h"
30 #include "SampleFormat.h"
31 
32 class wxArrayString;
33 class AudioIOBase;
34 class AudioIO;
35 class RingBuffer;
36 class Mixer;
37 class Resample;
38 class AudioThread;
39 class PlayRegionEvent;
40 
41 class AudacityProject;
42 
43 class PlayableTrack;
45  std::vector < std::shared_ptr < const PlayableTrack > >;
46 
47 class WaveTrack;
48 using WaveTrackArray = std::vector < std::shared_ptr < WaveTrack > >;
49 using WaveTrackConstArray = std::vector < std::shared_ptr < const WaveTrack > >;
50 
51 struct PaStreamCallbackTimeInfo;
52 typedef unsigned long PaStreamCallbackFlags;
53 typedef int PaError;
54 
56 
57 wxDECLARE_EXPORTED_EVENT(AUDACITY_DLL_API,
58  EVT_AUDIOIO_PLAYBACK, wxCommandEvent);
59 wxDECLARE_EXPORTED_EVENT(AUDACITY_DLL_API,
60  EVT_AUDIOIO_CAPTURE, wxCommandEvent);
61 wxDECLARE_EXPORTED_EVENT(AUDACITY_DLL_API,
62  EVT_AUDIOIO_MONITOR, wxCommandEvent);
63 
68 
69  // This is a subset of playbackTracks
71 };
72 
96  const void *inputBuffer, void *outputBuffer,
97  unsigned long framesPerBuffer,
98  const PaStreamCallbackTimeInfo *timeInfo,
99  PaStreamCallbackFlags statusFlags, void *userData );
100 
101 class AudioIOExt;
102 
103 class AUDACITY_DLL_API AudioIoCallback /* not final */
104  : public AudioIOBase
105 {
106 public:
107  AudioIoCallback();
108  ~AudioIoCallback();
109 
110 public:
111  // This function executes in a thread spawned by the PortAudio library
112  int AudioCallback(
113  constSamplePtr inputBuffer, float *outputBuffer,
114  unsigned long framesPerBuffer,
115  const PaStreamCallbackTimeInfo *timeInfo,
116  const PaStreamCallbackFlags statusFlags, void *userData);
117 
120  class AUDACITY_DLL_API AudioIOExtIterator {
121  public:
122  using difference_type = ptrdiff_t;
124  using pointer = AudioIOExt *;
126  using iterator_category = std::forward_iterator_tag;
127 
128  explicit AudioIOExtIterator( AudioIoCallback &audioIO, bool end )
129  : mIterator{ end
130  ? audioIO.mAudioIOExt.end()
131  : audioIO.mAudioIOExt.begin() }
132  {}
133  AudioIOExtIterator &operator ++ () { ++mIterator; return *this; }
134  auto operator *() const -> AudioIOExt &;
135  friend inline bool operator == (
136  const AudioIOExtIterator &xx, const AudioIOExtIterator &yy)
137  {
138  return xx.mIterator == yy.mIterator;
139  }
140  friend inline bool operator != (
141  const AudioIOExtIterator &xx, const AudioIOExtIterator &yy)
142  {
143  return !(xx == yy);
144  }
145  private:
146  std::vector<std::unique_ptr<AudioIOExtBase>>::const_iterator mIterator;
147  };
151  AudioIOExtIterator begin() const { return first; }
152  AudioIOExtIterator end() const { return second; }
153  };
154 
156  return {
157  AudioIOExtIterator{ *this, false },
158  AudioIOExtIterator{ *this, true }
159  };
160  }
162 
163  std::shared_ptr< AudioIOListener > GetListener() const
164  { return mListener.lock(); }
165  void SetListener( const std::shared_ptr< AudioIOListener > &listener);
166 
167  // Part of the callback
168  int CallbackDoSeek();
169 
170  // Part of the callback
171  void CallbackCheckCompletion(
172  int &callbackReturn, unsigned long len);
173 
176  // Helpers to determine if tracks have already been faded out.
177  unsigned CountSoloingTracks();
178  bool TrackShouldBeSilent( const WaveTrack &wt );
179  bool TrackHasBeenFadedOut( const WaveTrack &wt );
180  bool AllTracksAlreadySilent();
181 
182  void CheckSoundActivatedRecordingLevel(
183  float *inputSamples,
184  unsigned long framesPerBuffer
185  );
186  void AddToOutputChannel( unsigned int chan,
187  float * outputMeterFloats,
188  float * outputFloats,
189  const float * tempBuf,
190  bool drop,
191  unsigned long len,
192  WaveTrack *vt
193  );
194  bool FillOutputBuffers(
195  float *outputBuffer,
196  unsigned long framesPerBuffer,
197  float *outputMeterFloats
198  );
199  void DrainInputBuffers(
200  constSamplePtr inputBuffer,
201  unsigned long framesPerBuffer,
202  const PaStreamCallbackFlags statusFlags,
203  float * tempFloats
204  );
205  void UpdateTimePosition(
206  unsigned long framesPerBuffer
207  );
208  void DoPlaythrough(
209  constSamplePtr inputBuffer,
210  float *outputBuffer,
211  unsigned long framesPerBuffer,
212  float *outputMeterFloats
213  );
214  void SendVuInputMeterData(
215  const float *inputSamples,
216  unsigned long framesPerBuffer
217  );
218  void SendVuOutputMeterData(
219  const float *outputMeterFloats,
220  unsigned long framesPerBuffer
221  );
222 
228  size_t GetCommonlyReadyPlayback();
229 
232 
233 #ifdef EXPERIMENTAL_AUTOMATED_INPUT_LEVEL_ADJUSTMENT
234  bool mAILAActive;
235  bool mAILAClipped;
236  int mAILATotalAnalysis;
237  int mAILAAnalysisCounter;
238  double mAILAMax;
239  double mAILAGoalPoint;
240  double mAILAGoalDelta;
241  double mAILAAnalysisTime;
242  double mAILALastStartTime;
243  double mAILAChangeFactor;
244  double mAILATopLevel;
245  double mAILAAnalysisEndTime;
246  double mAILAAbsolutStartTime;
247  unsigned short mAILALastChangeType; //0 - no change, 1 - increase change, 2 - decrease change
248 #endif
249 
250  std::unique_ptr<AudioThread> mThread;
251 
257 
258  std::vector<std::unique_ptr<Mixer>> mPlaybackMixers;
259 
260  float mMixerOutputVol { 1.0 };
261  static int mNextStreamToken;
262  double mFactor;
263  unsigned long mMaxFramesOutput; // The actual number of frames output.
265 
266  double mSeek;
269 
274 
278  bool mPauseRec;
280  unsigned int mNumCaptureChannels;
281  unsigned int mNumPlaybackChannels;
283  unsigned long long mLostSamples{ 0 };
287 
288  std::atomic<bool> mForceFadeOut{ false };
289 
291 
292  volatile double mLastRecordingOffset;
294 
295 protected:
296 
298  volatile bool mUpdatingMeters;
299 
300  std::weak_ptr< AudioIOListener > mListener;
301 
302  friend class AudioThread;
303 
304  bool mUsingAlsa { false };
305 
306  // For cacheing supported sample rates
307  static double mCachedBestRateOut;
310 
311  // Serialize main thread and PortAudio thread's attempts to pause and change
312  // the state used by the third, Audio thread.
314 
315 protected:
316  // A flag tested and set in one thread, cleared in another. Perhaps
317  // this guarantee of atomicity is more cautious than necessary.
318  wxAtomicInt mRecordingException {};
320  { wxAtomicInc( mRecordingException ); }
322  { if (mRecordingException) wxAtomicDec( mRecordingException ); }
323 
324  std::vector< std::pair<double, double> > mLostCaptureIntervals;
325  bool mDetectDropouts{ true };
326 
327 public:
328  // Pairs of starting time and duration
329  const std::vector< std::pair<double, double> > &LostCaptureIntervals()
330  { return mLostCaptureIntervals; }
331 
332  // Used only for testing purposes in alpha builds
333  bool mSimulateRecordingErrors{ false };
334 
335  // Whether to check the error code passed to audacityAudioCallback to
336  // detect more dropouts
337  bool mDetectUpstreamDropouts{ true };
338 
339 protected:
340  RecordingSchedule mRecordingSchedule{};
342 
343 private:
350 };
351 
352 struct PaStreamInfo;
353 
354 class AUDACITY_DLL_API AudioIO final
355  : public AudioIoCallback
356 {
357 
358  AudioIO();
359  ~AudioIO();
360 
361 public:
362  // This might return null during application startup or shutdown
363  static AudioIO *Get();
364 
372  void StartMonitoring( const AudioIOStartStreamOptions &options );
373 
381  int StartStream(const TransportTracks &tracks,
382  double t0, double t1,
383  const AudioIOStartStreamOptions &options);
384 
390  void StopStream() override;
393  void SeekStream(double seconds) { mSeek = seconds; }
394 
395  using PostRecordingAction = std::function<void()>;
396 
398 
399  void CallAfterRecording(PostRecordingAction action);
400 
401 public:
402  wxString LastPaErrorString();
403 
404  wxLongLong GetLastPlaybackTime() const { return mLastPlaybackTimeMillis; }
405  std::shared_ptr<AudacityProject> GetOwningProject() const
406  { return mOwningProject.lock(); }
407 
409  void SetPaused(bool state);
410 
411  /* Mixer services are always available. If no stream is running, these
412  * methods use whatever device is specified by the preferences. If a
413  * stream *is* running, naturally they manipulate the mixer associated
414  * with that stream. If no mixer is available, output is emulated and
415  * input is stuck at 1.0f (a gain is applied to output samples).
416  */
417  void SetMixer(int inputSource, float inputVolume,
418  float playbackVolume);
419  void GetMixer(int *inputSource, float *inputVolume,
420  float *playbackVolume);
427  bool InputMixerWorks();
428 
433  wxArrayString GetInputSourceNames();
434 
436  unsigned GetNumPlaybackChannels() const { return mNumPlaybackChannels; }
437  unsigned GetNumCaptureChannels() const { return mNumCaptureChannels; }
438 
439  // Meaning really capturing, not just pre-rolling
440  bool IsCapturing() const;
441 
445  static bool ValidateDeviceNames(const wxString &play, const wxString &rec);
446 
450  #ifdef EXPERIMENTAL_AUTOMATED_INPUT_LEVEL_ADJUSTMENT
451  void AILAInitialize();
452  void AILADisable();
453  bool AILAIsActive();
454  void AILAProcess(double maxPeak);
455  void AILASetStartTime();
456  double AILAGetLastDecisionTime();
457  #endif
458 
459  bool IsAvailable(AudacityProject &project) const;
460 
471  double GetBestRate(bool capturing, bool playing, double sampleRate);
472 
479  double GetStreamTime();
480 
481  friend class AudioThread;
482 
483  static void Init();
484  static void Deinit();
485 
488  void DelayActions(bool recording);
489 
490 private:
491 
492  bool DelayingActions() const;
493 
496  void SetMeters();
497 
508  bool StartPortAudioStream(const AudioIOStartStreamOptions &options,
509  unsigned int numPlaybackChannels,
510  unsigned int numCaptureChannels,
511  sampleFormat captureFormat);
512 
513  void SetOwningProject( const std::shared_ptr<AudacityProject> &pProject );
514  void ResetOwningProject();
515  static void LoopPlayUpdate( PlayRegionEvent &evt );
516 
523  void TrackBufferExchange();
524 
526  void FillPlayBuffers();
527 
529  void DrainRecordBuffers();
530 
536  size_t GetCommonlyFreePlayback();
537 
544  size_t GetCommonlyAvailCapture();
545 
551  bool AllocateBuffers(
552  const AudioIOStartStreamOptions &options,
553  const TransportTracks &tracks, double t0, double t1, double sampleRate );
554 
558  void StartStreamCleanup(bool bOnlyBuffers = false);
559 
562 
563  bool mDelayingActions{ false };
564 };
565 
566 #endif
AudioIoCallback::mPlaybackQueueMinimum
size_t mPlaybackQueueMinimum
Occupancy of the queue we try to maintain, with bigger batches if needed.
Definition: AudioIO.h:273
Init
Definition: ModuleManager.h:152
WaveTrackArray
std::vector< std::shared_ptr< WaveTrack > > WaveTrackArray
Definition: AudioIO.h:48
AudioIoCallback::mCaptureFormat
sampleFormat mCaptureFormat
Definition: AudioIO.h:282
AudioIOBase.h
WaveTrackConstArray
std::vector< std::shared_ptr< const WaveTrack > > WaveTrackConstArray
Definition: AudioIO.h:49
TransportTracks::playbackTracks
WaveTrackArray playbackTracks
Definition: AudioIO.h:65
AudioIoCallback::AudioIOExtIterator::mIterator
std::vector< std::unique_ptr< AudioIOExtBase > >::const_iterator mIterator
Definition: AudioIO.h:146
AudioIoCallback::mPlaybackTracks
WaveTrackArray mPlaybackTracks
Definition: AudioIO.h:256
AudioIoCallback::mbMicroFades
bool mbMicroFades
Definition: AudioIO.h:264
WaveTrack
A Track that contains audio waveform data.
Definition: WaveTrack.h:69
AudioIO::PostRecordingAction
std::function< void()> PostRecordingAction
Definition: AudioIO.h:395
AudioIoCallback::LostCaptureIntervals
const std::vector< std::pair< double, double > > & LostCaptureIntervals()
Definition: AudioIO.h:329
operator*
Vector operator*(const Vector &left, const Vector &right)
Definition: Matrix.cpp:153
AudioIoCallback::mThread
std::unique_ptr< AudioThread > mThread
Definition: AudioIO.h:250
AudioIoCallback::AudioIOExtIterator::difference_type
ptrdiff_t difference_type
Definition: AudioIO.h:122
TransportTracks::captureTracks
WaveTrackArray captureTracks
Definition: AudioIO.h:66
AudioIO::GetNumPlaybackChannels
unsigned GetNumPlaybackChannels() const
Definition: AudioIO.h:436
AudioIoCallback::mNumPlaybackChannels
unsigned int mNumPlaybackChannels
Definition: AudioIO.h:281
AudioIoCallback::mPlaybackMixers
std::vector< std::unique_ptr< Mixer > > mPlaybackMixers
Definition: AudioIO.h:258
AudioIO::GetCaptureFormat
sampleFormat GetCaptureFormat()
Definition: AudioIO.h:435
AudioIoCallback::mNumCaptureChannels
unsigned int mNumCaptureChannels
Definition: AudioIO.h:280
operator!=
bool operator!=(const Tags &lhs, const Tags &rhs)
Definition: Tags.h:140
AudioIoCallback::AudioIOExtRange::begin
AudioIOExtIterator begin() const
Definition: AudioIO.h:151
AudioIoCallback::mUpdatingMeters
volatile bool mUpdatingMeters
Definition: AudioIO.h:298
AudioIoCallback::mMaxFramesOutput
unsigned long mMaxFramesOutput
Definition: AudioIO.h:263
AudioIoCallback::mPlaybackSamplesToCopy
size_t mPlaybackSamplesToCopy
Preferred batch size for replenishing the playback RingBuffer.
Definition: AudioIO.h:271
AudioIOExt
Definition: AudioIOExt.h:29
AudioIoCallback
AudioIoCallback is a class that implements the callback required by PortAudio. The callback needs to ...
Definition: AudioIO.h:105
AudioIoCallback::mPlaybackBuffers
ArrayOf< std::unique_ptr< RingBuffer > > mPlaybackBuffers
Definition: AudioIO.h:255
AudioIoCallback::AudioIOExtRange::end
AudioIOExtIterator end() const
Definition: AudioIO.h:152
AudioIoCallback::mUpdateMeters
bool mUpdateMeters
Definition: AudioIO.h:297
AudioIO::GetNumCaptureChannels
unsigned GetNumCaptureChannels() const
Definition: AudioIO.h:437
TransportTracks::otherPlayableTracks
PlayableTrackConstArray otherPlayableTracks
Definition: AudioIO.h:67
PlayableTrackConstArray
std::vector< std::shared_ptr< const PlayableTrack > > PlayableTrackConstArray
Definition: AudioIO.h:45
PlayRegionEvent
Definition: ViewInfo.h:118
AudioIOBase::mAudioIOExt
std::vector< std::unique_ptr< AudioIOExtBase > > mAudioIOExt
Definition: AudioIOBase.h:318
AudioIoCallback::AudioIOExtRange::second
AudioIOExtIterator second
Definition: AudioIO.h:150
AudioIoCallback::mAudioThreadShouldCallTrackBufferExchangeOnce
volatile bool mAudioThreadShouldCallTrackBufferExchangeOnce
Definition: AudioIO.h:284
SampleCount.h
PlaybackSchedule.h
AudioIoCallback::Extensions
AudioIOExtRange Extensions()
Definition: AudioIO.h:155
AudioIO::mPostRecordingAction
PostRecordingAction mPostRecordingAction
Definition: AudioIO.h:561
AudioIoCallback::mSoftwarePlaythrough
bool mSoftwarePlaythrough
Definition: AudioIO.h:276
AudioIoCallback::AudioIOExtIterator::iterator_category
std::forward_iterator_tag iterator_category
Definition: AudioIO.h:126
AudioIoCallback::mPauseRec
bool mPauseRec
True if Sound Activated Recording is enabled.
Definition: AudioIO.h:278
AudioIO::GetOwningProject
std::shared_ptr< AudacityProject > GetOwningProject() const
Definition: AudioIO.h:405
wxDECLARE_EXPORTED_EVENT
wxDECLARE_EXPORTED_EVENT(AUDACITY_DLL_API, EVT_AUDIOIO_PLAYBACK, wxCommandEvent)
AudioIO::SeekStream
void SeekStream(double seconds)
Move the playback / recording position of the current stream by the specified amount from where it is...
Definition: AudioIO.h:393
AudioIoCallback::mCaptureBuffers
ArrayOf< std::unique_ptr< RingBuffer > > mCaptureBuffers
Definition: AudioIO.h:253
AudioIoCallback::mAudioThreadTrackBufferExchangeLoopRunning
volatile bool mAudioThreadTrackBufferExchangeLoopRunning
Definition: AudioIO.h:285
AudioIoCallback::mLastPlaybackTimeMillis
wxLongLong mLastPlaybackTimeMillis
Definition: AudioIO.h:290
PaError
int PaError
Definition: AudioIO.h:53
constSamplePtr
const char * constSamplePtr
Definition: SampleFormat.h:50
PlaybackSchedule
Definition: PlaybackSchedule.h:268
AudioIoCallback::mCallbackReturn
int mCallbackReturn
Definition: AudioIO.h:175
AudioIoCallback::mAudioIOExt
std::vector< std::unique_ptr< AudioIOExtBase > > mAudioIOExt
Definition: AudioIOBase.h:318
AudioIOBase::Get
static AudioIOBase * Get()
Definition: AudioIOBase.cpp:89
AudioIoCallback::mSuspendAudioThread
wxMutex mSuspendAudioThread
Definition: AudioIO.h:313
AudioIoCallback::mLastRecordingOffset
volatile double mLastRecordingOffset
Definition: AudioIO.h:292
AudioIOBase::SetMixer
void SetMixer(int inputSource)
Definition: AudioIOBase.cpp:98
AudioIOStartStreamOptions
struct holding stream options, including a pointer to the time warp info and AudioIOListener and whet...
Definition: AudioIOBase.h:44
AudioIoCallback::mNextStreamToken
static int mNextStreamToken
Definition: AudioIO.h:261
AudioIoCallback::mCachedBestRateCapturing
static bool mCachedBestRateCapturing
Definition: AudioIO.h:309
Resample
Interface to libsoxr.
Definition: Resample.h:27
PlayableTrack
AudioTrack subclass that can also be audibly replayed by the program.
Definition: Track.h:854
TransportTracks
Definition: AudioIO.h:64
AudioIoCallback::ClearRecordingException
void ClearRecordingException()
Definition: AudioIO.h:321
sampleFormat
sampleFormat
Definition: SampleFormat.h:29
AudioIoCallback::mCaptureRingBufferSecs
double mCaptureRingBufferSecs
Definition: AudioIO.h:268
AudioIoCallback::AudioIOExtIterator::AudioIOExtIterator
AudioIOExtIterator(AudioIoCallback &audioIO, bool end)
Definition: AudioIO.h:128
AudioIO::mPostRecordingActionMutex
std::mutex mPostRecordingActionMutex
Definition: AudioIO.h:560
PaStreamCallbackFlags
unsigned long PaStreamCallbackFlags
Definition: AudioIO.h:51
AudioIoCallback::mbHasSoloTracks
int mbHasSoloTracks
Definition: AudioIO.h:174
AudioIoCallback::mSilenceLevel
float mSilenceLevel
Definition: AudioIO.h:279
AudioIoCallback::mSeek
double mSeek
Definition: AudioIO.h:266
AudacityProject
The top-level handle to an Audacity project. It serves as a source of events that other objects can b...
Definition: Project.h:92
AudioIoCallback::AudioIOExtIterator
Definition: AudioIO.h:120
AudioIoCallback::mAudioThreadTrackBufferExchangeLoopActive
volatile bool mAudioThreadTrackBufferExchangeLoopActive
Definition: AudioIO.h:286
AudioIoCallback::mLostCaptureIntervals
std::vector< std::pair< double, double > > mLostCaptureIntervals
Definition: AudioIO.h:324
AudioIoCallback::AudioIOExtRange::first
AudioIOExtIterator first
Definition: AudioIO.h:149
AudioIoCallback::mCachedBestRatePlaying
static bool mCachedBestRatePlaying
Definition: AudioIO.h:308
AudioIO::GetLastPlaybackTime
wxLongLong GetLastPlaybackTime() const
Definition: AudioIO.h:404
AudioIoCallback::mLastPaError
PaError mLastPaError
Definition: AudioIO.h:293
AudioIOBase::StopStream
virtual void StopStream()=0
AudioIoCallback::GetListener
std::shared_ptr< AudioIOListener > GetListener() const
Definition: AudioIO.h:163
AudioIoCallback::mResample
ArrayOf< std::unique_ptr< Resample > > mResample
Definition: AudioIO.h:252
AudioIoCallback::mPlaybackSchedule
PlaybackSchedule mPlaybackSchedule
Definition: AudioIO.h:341
AudioIoCallback::mListener
std::weak_ptr< AudioIOListener > mListener
Definition: AudioIO.h:300
RingBuffer
Holds streamed audio samples.
Definition: RingBuffer.h:17
RecordingSchedule
Definition: PlaybackSchedule.h:131
ValidateDeviceNames
bool ValidateDeviceNames()
AudioIoCallback::mNumPauseFrames
long mNumPauseFrames
How many frames of zeros were output due to pauses?
Definition: AudioIO.h:231
AudioIO
AudioIO uses the PortAudio library to play and record sound.
Definition: AudioIO.h:356
AudioThread
Defined different on Mac and other platforms (on Mac it does not use wxWidgets wxThread),...
Definition: AudioIO.cpp:223
AudioIOBase
A singleton object supporting queries of the state of any active audio streams, and audio device capa...
Definition: AudioIOBase.h:100
AudioIoCallback::mMinCaptureSecsToCopy
double mMinCaptureSecsToCopy
Definition: AudioIO.h:275
AudioIoCallback::AudioIOExtRange
Definition: AudioIO.h:148
TransportTracks::prerollTracks
WaveTrackConstArray prerollTracks
Definition: AudioIO.h:70
Mixer
Functions for doing the mixdown of the tracks.
Definition: Mix.h:76
SampleFormat.h
ArrayOf
Memory.h template class for making an array of float, bool, etc.
Definition: MemoryX.h:27
AudioIoCallback::SetRecordingException
void SetRecordingException()
Definition: AudioIO.h:319
AudioIoCallback::mCaptureTracks
WaveTrackArray mCaptureTracks
Definition: AudioIO.h:254
audacityAudioCallback
int audacityAudioCallback(const void *inputBuffer, void *outputBuffer, unsigned long framesPerBuffer, const PaStreamCallbackTimeInfo *timeInfo, PaStreamCallbackFlags statusFlags, void *userData)
Definition: AudioIO.cpp:2277
AudioIoCallback::mFactor
double mFactor
Definition: AudioIO.h:262
AudioIoCallback::mCachedBestRateOut
static double mCachedBestRateOut
Definition: AudioIO.h:307
AudioIoCallback::mPlaybackRingBufferSecs
double mPlaybackRingBufferSecs
Definition: AudioIO.h:267