AudioIOBase.h

Go to the documentation of this file.

/**********************************************************************
 
Audacity: A Digital Audio Editor
 
AudioIOBase.h
 
Paul Licameli split from AudioIO.h
 
**********************************************************************/
 
#ifndef __AUDACITY_AUDIO_IO_BASE__
#define __AUDACITY_AUDIO_IO_BASE__
 
#include <atomic>
#include <cfloat>
#include <chrono>
#include <functional>
#include <map>
#include <optional>
#include <vector>
#include <utility>
#include <wx/string.h>
#include "MemoryX.h"
 
struct PaDeviceInfo;
typedef void PaStream;
 
#if USE_PORTMIXER
typedef void PxMixer;
#endif
 
class AudioIOBase;
 
class AudacityProject;
class AudioIOListener;
class BoundedEnvelope;
class Meter;
using PRCrossfadeData = std::vector< std::vector < float > >;
 
#define BAD_STREAM_TIME (-DBL_MAX)
 
class PlaybackPolicy;
 
// To avoid growing the argument list of StartStream, add fields here
struct AudioIOStartStreamOptions
{
   explicit
   AudioIOStartStreamOptions(
      const std::shared_ptr<AudacityProject> &pProject = {},
      double rate_ = 44100.0
   )  : pProject{ pProject }
      , rate(rate_)
   {}
 
   std::shared_ptr<AudacityProject> pProject;
   std::weak_ptr<Meter> captureMeter, playbackMeter;
   const BoundedEnvelope *envelope{}; // for time warping
   std::shared_ptr< AudioIOListener > listener;
   double rate;
   mutable std::optional<double> pStartTime;
   double preRoll{ 0.0 };
 
   bool playNonWaveTracks{ true };
 
   // contents may get swapped with empty vector
   PRCrossfadeData      *pCrossfadeData{};
 
   // An unfortunate thing needed just to make scrubbing work on Linux when
   // we can't use a separate polling thread.
   // The return value is duration to sleep before calling again
   std::function< std::chrono::milliseconds() > playbackStreamPrimer;
 
   using PolicyFactory = std::function<
      std::unique_ptr<PlaybackPolicy>(const AudioIOStartStreamOptions&) >;
   PolicyFactory policyFactory;
 
   bool loopEnabled{ false };
   bool variableSpeed{ false };
};
 
struct AudioIODiagnostics{
   wxString filename;    // For crash report bundle
   wxString text;        // One big string, may be localized
   wxString description; // Non-localized short description
};
 
class AUDIO_DEVICES_API AudioIOExtBase
{
public:
   virtual ~AudioIOExtBase();
 
   // Formerly in AudioIOBase
   virtual bool IsOtherStreamActive() const = 0;
 
   virtual AudioIODiagnostics Dump() const = 0;
};
 
class AUDIO_DEVICES_API AudioIOBase /* not final */
   : public NonInterferingBase
{
public:
   static AudioIOBase *Get();
 
   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();
 
   static std::vector<long> GetSupportedPlaybackRates(int DevIndex = -1);
 
   static long GetClosestSupportedPlaybackRate(int devIndex, long rate);
 
   static std::vector<long> GetSupportedCaptureRates(int devIndex = -1);
 
   static long GetClosestSupportedCaptureRate(int devIndex, long rate);
 
   static std::vector<long> GetSupportedSampleRates(int playDevice = -1,
                                                    int recDevice = -1);
 
   static long GetClosestSupportedSampleRate(int playDevice,
                                             int recDevice, long rate);
 
   static int GetOptimalSupportedSampleRate();
 
   static bool IsPlaybackRateSupported(int devIndex, long rate);
 
   static bool IsCaptureRateSupported(int devIndex, long rate);
 
   static const int StandardRates[];
   static const int NumStandardRates;
 
   wxString GetDeviceInfo() const;
 
   std::vector<AudioIODiagnostics> GetAllDeviceInfo();
 
   bool IsPaused() const;
 
   virtual void StopStream() = 0;
 
   bool IsBusy() const;
 
   bool IsStreamActive() const;
   bool IsStreamActive(int token) const;
 
   bool IsAudioTokenActive(int token) const;
 
   bool IsMonitoring() const;
 
   /* Mixer services are always available.  If no stream is running, these
    * methods use whatever device is specified by the preferences.  If a
    * stream *is* running, naturally they manipulate the mixer associated
    * with that stream.  If no mixer is available, output is emulated and
    * input is stuck at 1.0f (a volume gain is applied to output samples).
    */
   void SetMixer(int inputSource);
 
protected:
   static std::unique_ptr<AudioIOBase> ugAudioIO;
   static wxString DeviceName(const PaDeviceInfo* info);
   static wxString HostName(const PaDeviceInfo* info);
 
   std::weak_ptr<AudacityProject> mOwningProject;
 
   std::atomic<bool>   mPaused{ false };
 
   int                 mStreamToken{ 0 };
 
 
   double              mRate;
 
   PaStream           *mPortStreamV19;
 
   std::weak_ptr<Meter> mInputMeter{};
   std::weak_ptr<Meter> mOutputMeter{};
 
   #if USE_PORTMIXER
   PxMixer            *mPortMixer;
   float               mPreviousHWPlaythrough;
   #endif /* USE_PORTMIXER */
 
   bool                mInputMixerWorks;
 
   // For cacheing supported sample rates
   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;
   static int mCurrentCaptureIndex;
   static double mCachedBestRateIn;
 
protected:
   static int getRecordDevIndex(const wxString &devName = {});
 
#if USE_PORTMIXER
   static int getRecordSourceIndex(PxMixer *portMixer);
#endif
 
   static int getPlayDevIndex(const wxString &devName = {});
 
   static const int RatesToTry[];
   static const int NumRatesToTry;
 
   std::vector<std::unique_ptr<AudioIOExtBase>> mAudioIOExt;
};
 
#include "Prefs.h"
 
extern AUDIO_DEVICES_API StringSetting AudioIOHost;
extern AUDIO_DEVICES_API DoubleSetting AudioIOLatencyCorrection;
extern AUDIO_DEVICES_API DoubleSetting AudioIOLatencyDuration;
extern AUDIO_DEVICES_API StringSetting AudioIOPlaybackDevice;
extern AUDIO_DEVICES_API StringSetting AudioIOPlaybackSource;
extern AUDIO_DEVICES_API DoubleSetting AudioIOPlaybackVolume;
extern AUDIO_DEVICES_API IntSetting    AudioIORecordChannels;
extern AUDIO_DEVICES_API StringSetting AudioIORecordingDevice;
extern AUDIO_DEVICES_API StringSetting AudioIORecordingSource;
extern AUDIO_DEVICES_API IntSetting    AudioIORecordingSourceIndex;
 
#endif