ProjectAudioManager Class Reference

#include <ProjectAudioManager.h>

Inheritance diagram for ProjectAudioManager:

Collaboration diagram for ProjectAudioManager:

Public Member Functions
	ProjectAudioManager (AudacityProject &project)
	ProjectAudioManager (const ProjectAudioManager &) PROHIBITED
ProjectAudioManager &	operator= (const ProjectAudioManager &) PROHIBITED
	~ProjectAudioManager () override
bool	IsTimerRecordCancelled ()
void	SetTimerRecordCancelled ()
void	ResetTimerRecordCancelled ()
bool	Paused () const
bool	Playing () const
bool	Recording () const
bool	Stopping () const
bool	Appending () const
bool	Looping () const
bool	Cutting () const
bool	CanStopAudioStream () const
void	OnRecord (bool altAppearance)
bool	DoRecord (AudacityProject &project, const TransportTracks &transportTracks, double t0, double t1, bool altAppearance, const AudioIOStartStreamOptions &options)
int	PlayPlayRegion (const SelectedRegion &selectedRegion, const AudioIOStartStreamOptions &options, PlayMode playMode, bool backwards=false)
void	PlayCurrentRegion (bool newDefault=false, bool cutpreview=false)
void	OnPause ()
void	Stop (bool stopStream=true)
void	StopIfPaused ()
bool	DoPlayStopSelect (bool click, bool shift)
void	DoPlayStopSelect ()
PlayMode	GetLastPlayMode () const
Public Member Functions inherited from ClientData::Base
virtual	~Base ()
Public Member Functions inherited from AudioIOListener
	AudioIOListener ()
virtual	~AudioIOListener ()
virtual void	OnAudioIORate (int rate)=0
virtual void	OnAudioIOStartRecording ()=0
virtual void	OnAudioIOStopRecording ()=0
virtual void	OnAudioIONewBlocks (const WritableSampleTrackArray *tracks)=0
virtual void	OnCommitRecording ()=0
virtual void	OnSoundActivationThreshold ()=0
Public Member Functions inherited from Observer::Publisher< RecordingDropoutEvent >
	Publisher (ExceptionPolicy *pPolicy=nullptr, Alloc a={})
	Constructor supporting type-erased custom allocation/deletion. More...
	Publisher (Publisher &&)=default
Publisher &	operator= (Publisher &&)=default
Subscription	Subscribe (Callback callback)
	Connect a callback to the Publisher; later-connected are called earlier. More...
Subscription	Subscribe (Object &obj, Return(Object::*callback)(Args...))
	Overload of Subscribe takes an object and pointer-to-member-function. More...

Static Public Member Functions
static ProjectAudioManager &	Get (AudacityProject &project)
static const ProjectAudioManager &	Get (const AudacityProject &project)
static WritableSampleTrackArray	ChooseExistingRecordingTracks (AudacityProject &proj, bool selectedOnly, double targetRate=RATE_NOT_SELECTED)
static bool	UseDuplex ()

Private Member Functions
void	TogglePaused ()
void	SetPausedOff ()
void	SetAppending (bool value)
void	SetLooping (bool value)
void	SetCutting (bool value)
void	SetStopping (bool value)
void	CancelRecording ()
void	OnAudioIORate (int rate) override
void	OnAudioIOStartRecording () override
void	OnAudioIOStopRecording () override
void	OnAudioIONewBlocks (const WritableSampleTrackArray *tracks) override
void	OnCommitRecording () override
void	OnSoundActivationThreshold () override
void	OnCheckpointFailure (ProjectFileIOMessage)

Static Private Member Functions
static std::pair< TranslatableStrings, unsigned >	StatusWidthFunction (const AudacityProject &project, StatusBarField field)

Private Attributes
Observer::Subscription	mCheckpointFailureSubcription
AudacityProject &	mProject
PlayMode	mLastPlayMode { PlayMode::normalPlay }
bool	mTimerRecordCanceled { false }
std::atomic< int >	mPaused { 0 }
bool	mAppending { false }
bool	mLooping { false }
bool	mCutting { false }
bool	mStopping { false }
int	mDisplayedRate { 0 }

Additional Inherited Members
Public Types inherited from Observer::Publisher< RecordingDropoutEvent >
using	message_type = RecordingDropoutEvent
using	CallbackReturn = std::conditional_t< true, void, bool >
using	Callback = std::function< CallbackReturn(const RecordingDropoutEvent &) >
	Type of functions that can be connected to the Publisher. More...
Static Public Attributes inherited from Observer::Publisher< RecordingDropoutEvent >
static constexpr bool	notifies_all
Protected Member Functions inherited from Observer::Publisher< RecordingDropoutEvent >
CallbackReturn	Publish (const RecordingDropoutEvent &message)
	Send a message to connected callbacks. More...

Detailed Description

Definition at line 60 of file ProjectAudioManager.h.

Constructor & Destructor Documentation

ProjectAudioManager() [1/2]

ProjectAudioManager::ProjectAudioManager ( AudacityProject &  project )

explicit

Definition at line 65 of file ProjectAudioManager.cpp.

   : mProject{ project }
{
   static ProjectStatus::RegisteredStatusWidthFunction
      registerStatusWidthFunction{ StatusWidthFunction };
   mCheckpointFailureSubcription = ProjectFileIO::Get(project)
      .Subscribe(*this, &ProjectAudioManager::OnCheckpointFailure);
}

References ProjectFileIO::Get(), mCheckpointFailureSubcription, OnCheckpointFailure(), StatusWidthFunction(), and Observer::Publisher< Message, NotifyAll >::Subscribe().

Here is the call graph for this function:

ProjectAudioManager() [2/2]

ProjectAudioManager::ProjectAudioManager

(

const ProjectAudioManager &

)

~ProjectAudioManager()

ProjectAudioManager::~ProjectAudioManager ( )

overridedefault

Member Function Documentation

Appending()

bool ProjectAudioManager::Appending ( ) const

inline

Definition at line 97 of file ProjectAudioManager.h.

{ return mAppending; }

CancelRecording()

void ProjectAudioManager::CancelRecording ( )

private

Definition at line 1019 of file ProjectAudioManager.cpp.

{
   const auto project = &mProject;
   TrackList::Get( *project ).ClearPendingTracks();
}

References TrackList::ClearPendingTracks(), and TrackList::Get().

Here is the call graph for this function:

CanStopAudioStream()

bool ProjectAudioManager::CanStopAudioStream

(

)

const

Definition at line 1141 of file ProjectAudioManager.cpp.

{
   auto gAudioIO = AudioIO::Get();
   return (!gAudioIO->IsStreamActive() ||
           gAudioIO->IsMonitoring() ||
           gAudioIO->GetOwningProject().get() == &mProject );
}

References AudioIO::Get().

Here is the call graph for this function:

ChooseExistingRecordingTracks()

WritableSampleTrackArray ProjectAudioManager::ChooseExistingRecordingTracks ( AudacityProject &  proj, bool  selectedOnly, double  targetRate = RATE_NOT_SELECTED  )

static

Definition at line 562 of file ProjectAudioManager.cpp.

{
   auto p = &proj;
   size_t recordingChannels = std::max(0, AudioIORecordChannels.Read());
   bool strictRules = (recordingChannels <= 2);
 
   // Iterate over all wave tracks, or over selected wave tracks only.
   // If target rate was specified, ignore all tracks with other rates.
   //
   // In the usual cases of one or two recording channels, seek a first-fit
   // unbroken sub-sequence for which the total number of channels matches the
   // required number exactly.  Never drop inputs or fill only some channels
   // of a track.
   //
   // In case of more than two recording channels, choose tracks only among the
   // selected.  Simply take the earliest wave tracks, until the number of
   // channels is enough.  If there are fewer channels than inputs, but at least
   // one channel, then some of the input channels will be dropped.
   //
   // Resulting tracks may be non-consecutive within the list of all tracks
   // (there may be non-wave tracks between, or non-selected tracks when
   // considering selected tracks only.)
 
   if (!strictRules && !selectedOnly)
      return {};
 
   auto &trackList = TrackList::Get( *p );
   std::vector<unsigned> channelCounts;
   WritableSampleTrackArray candidates;
   const auto range = trackList.Leaders<WaveTrack>();
   for ( auto candidate : selectedOnly ? range + &Track::IsSelected : range ) {
      if (targetRate != RATE_NOT_SELECTED && candidate->GetRate() != targetRate)
         continue;
 
      // count channels in this track
      const auto channels = TrackList::Channels( candidate );
      unsigned nChannels = channels.size();
 
      if (strictRules && nChannels > recordingChannels) {
         // The recording would under-fill this track's channels
         // Can't use any partial accumulated results
         // either.  Keep looking.
         candidates.clear();
         channelCounts.clear();
         continue;
      }
      else {
         // Might use this but may have to discard some of the accumulated
         while(strictRules &&
               nChannels + candidates.size() > recordingChannels) {
            auto nOldChannels = channelCounts[0];
            wxASSERT(nOldChannels > 0);
            channelCounts.erase(channelCounts.begin());
            candidates.erase(candidates.begin(),
                             candidates.begin() + nOldChannels);
         }
         channelCounts.push_back(nChannels);
         for ( auto channel : channels ) {
            candidates.push_back(channel->SharedPointer<WaveTrack>());
            if(candidates.size() == recordingChannels)
               // Done!
               return candidates;
         }
      }
   }
 
   if (!strictRules && !candidates.empty())
      // good enough
      return candidates;
 
   // If the loop didn't exit early, we could not find enough channels
   return {};
}

References AudioIORecordChannels, TrackList::Channels(), TrackList::Get(), Track::IsSelected(), RATE_NOT_SELECTED, and Setting< T >::Read().

Referenced by anonymous_namespace{TimerRecordDialog.cpp}::OnTimerRecord().

Here is the call graph for this function:

Here is the caller graph for this function:

Cutting()

bool ProjectAudioManager::Cutting ( ) const

inline

Definition at line 100 of file ProjectAudioManager.h.

{ return mCutting; }

DoPlayStopSelect() [1/2]

void ProjectAudioManager::DoPlayStopSelect

(

)

Definition at line 1266 of file ProjectAudioManager.cpp.

{
   auto gAudioIO = AudioIO::Get();
   if (DoPlayStopSelect(false, false))
      Stop();
   else if (!gAudioIO->IsBusy()) {
      //Otherwise, start playing (assuming audio I/O isn't busy)
 
      // Will automatically set mLastPlayMode
      PlayCurrentRegion(false);
   }
}

References AudioIO::Get().

Here is the call graph for this function:

DoPlayStopSelect() [2/2]

bool ProjectAudioManager::DoPlayStopSelect	(	bool	click,
		bool	shift
	)

Definition at line 1210 of file ProjectAudioManager.cpp.

{
   auto &project = mProject;
   auto &scrubber = Scrubber::Get( project );
   auto token = ProjectAudioIO::Get( project ).GetAudioIOToken();
   auto &viewInfo = ViewInfo::Get( project );
   auto &selection = viewInfo.selectedRegion;
   auto gAudioIO = AudioIO::Get();
 
   //If busy, stop playing, make sure everything is unpaused.
   if (scrubber.HasMark() ||
       gAudioIO->IsStreamActive(token)) {
      // change the selection
      auto time = gAudioIO->GetStreamTime();
      // Test WasSpeedPlaying(), not IsSpeedPlaying()
      // as we could be stopped now. Similarly WasKeyboardScrubbing().
      if (click && (scrubber.WasSpeedPlaying() || scrubber.WasKeyboardScrubbing()))
      {
         ;// don't change the selection.
      }
      else if (shift && click) {
         // Change the region selection, as if by shift-click at the play head
         auto t0 = selection.t0(), t1 = selection.t1();
         if (time < t0)
            // Grow selection
            t0 = time;
         else if (time > t1)
            // Grow selection
            t1 = time;
         else {
            // Shrink selection, changing the nearer boundary
            if (fabs(t0 - time) < fabs(t1 - time))
               t0 = time;
            else
               t1 = time;
         }
         selection.setTimes(t0, t1);
      }
      else if (click){
         // avoid a point at negative time.
         time = wxMax( time, 0 );
         // Set a point selection, as if by a click at the play head
         selection.setTimes(time, time);
      } else
         // How stop and set cursor always worked
         // -- change t0, collapsing to point only if t1 was greater
         selection.setT0(time, false);
 
      ProjectHistory::Get( project ).ModifyState(false);           // without bWantsAutoSave
      return true;
   }
   return false;
}

References AudioIO::Get(), ProjectAudioIO::Get(), ProjectHistory::Get(), ViewInfo::Get(), Scrubber::Get(), ProjectAudioIO::GetAudioIOToken(), and ProjectHistory::ModifyState().

Referenced by anonymous_namespace{TransportMenus.cpp}::OnPlayStopSelect().

Here is the call graph for this function:

Here is the caller graph for this function:

DoRecord()

bool ProjectAudioManager::DoRecord	(	AudacityProject &	project,
		const TransportTracks &	transportTracks,
		double	t0,
		double	t1,
		bool	altAppearance,
		const AudioIOStartStreamOptions &	options
	)

Definition at line 761 of file ProjectAudioManager.cpp.

{
   auto &projectAudioManager = *this;
 
   CommandFlag flags = AlwaysEnabledFlag; // 0 means recalc flags.
 
   // NB: The call may have the side effect of changing flags.
   bool allowed = MenuManager::Get(project).TryToMakeActionAllowed(
      flags,
      AudioIONotBusyFlag() | CanStopAudioStreamFlag());
 
   if (!allowed)
      return false;
   // ...end of code from CommandHandler.
 
   auto gAudioIO = AudioIO::Get();
   if (gAudioIO->IsBusy())
      return false;
 
   projectAudioManager.SetAppending( !altAppearance );
 
   bool success = false;
 
   auto transportTracks = tracks;
 
   // Will replace any given capture tracks with temporaries
   transportTracks.captureTracks.clear();
 
   const auto p = &project;
 
   bool appendRecord = !tracks.captureTracks.empty();
 
   auto makeNewClipName = [&](WaveTrack* track) {
       for (auto i = 1;; ++i)
       {
           //i18n-hint a numerical suffix added to distinguish otherwise like-named clips when new record started
           auto name = XC("%s #%d", "clip name template").Format(track->GetName(), i).Translation();
           if (track->FindClipByName(name) == nullptr)
               return name;
       }
   };
 
   {
      if (appendRecord) {
         // Append recording:
         // Pad selected/all wave tracks to make them all the same length
         for (const auto &wt : tracks.captureTracks)
         {
            auto endTime = wt->GetEndTime();
 
            // If the track was chosen for recording and playback both,
            // remember the original in preroll tracks, before making the
            // pending replacement.
            bool prerollTrack = make_iterator_range(transportTracks.playbackTracks).contains(wt);
            if (prerollTrack)
                  transportTracks.prerollTracks.push_back(wt);
 
            // A function that copies all the non-sample data between
            // wave tracks; in case the track recorded to changes scale
            // type (for instance), during the recording.
            auto updater = [](Track &d, const Track &s){
               auto &dst = static_cast<WaveTrack&>(d);
               auto &src = static_cast<const WaveTrack&>(s);
               dst.Reinit(src);
            };
 
            // Get a copy of the track to be appended, to be pushed into
            // undo history only later.
            auto pending = std::static_pointer_cast<WaveTrack>(
               TrackList::Get( *p ).RegisterPendingChangedTrack(
                  updater, wt.get() ) );
 
            // End of current track is before or at recording start time.
            // Less than or equal, not just less than, to ensure a clip boundary.
            // when append recording.
            if (endTime <= t0) {
               pending->CreateClip(t0, makeNewClipName(pending.get()));
            }
            transportTracks.captureTracks.push_back(pending);
         }
         TrackList::Get( *p ).UpdatePendingTracks();
      }
 
      if( transportTracks.captureTracks.empty() )
      {   // recording to NEW track(s).
         bool recordingNameCustom, useTrackNumber, useDateStamp, useTimeStamp;
         wxString defaultTrackName, defaultRecordingTrackName;
 
         // Count the tracks.
         auto &trackList = TrackList::Get( *p );
         auto numTracks = trackList.Leaders< const WaveTrack >().size();
 
         auto recordingChannels = std::max(1, AudioIORecordChannels.Read());
 
         gPrefs->Read(wxT("/GUI/TrackNames/RecordingNameCustom"), &recordingNameCustom, false);
         gPrefs->Read(wxT("/GUI/TrackNames/TrackNumber"), &useTrackNumber, false);
         gPrefs->Read(wxT("/GUI/TrackNames/DateStamp"), &useDateStamp, false);
         gPrefs->Read(wxT("/GUI/TrackNames/TimeStamp"), &useTimeStamp, false);
         defaultTrackName = trackList.MakeUniqueTrackName(WaveTrack::GetDefaultAudioTrackNamePreference());
         gPrefs->Read(wxT("/GUI/TrackNames/RecodingTrackName"), &defaultRecordingTrackName, defaultTrackName);
 
         wxString baseTrackName = recordingNameCustom? defaultRecordingTrackName : defaultTrackName;
 
         Track *first {};
         for (int c = 0; c < recordingChannels; c++) {
            auto newTrack = WaveTrackFactory::Get( *p ).Create();
            if (!first)
               first = newTrack.get();
 
            // Quantize bounds to the rate of the new track.
            if (c == 0) {
               if (t0 < DBL_MAX)
                  t0 = newTrack->LongSamplesToTime(newTrack->TimeToLongSamples(t0));
               if (t1 < DBL_MAX)
                  t1 = newTrack->LongSamplesToTime(newTrack->TimeToLongSamples(t1));
            }
 
            newTrack->SetOffset(t0);
            wxString nameSuffix = wxString(wxT(""));
 
            if (useTrackNumber) {
               nameSuffix += wxString::Format(wxT("%d"), 1 + (int) numTracks + c);
            }
 
            if (useDateStamp) {
               if (!nameSuffix.empty()) {
                  nameSuffix += wxT("_");
               }
               nameSuffix += wxDateTime::Now().FormatISODate();
            }
 
            if (useTimeStamp) {
               if (!nameSuffix.empty()) {
                  nameSuffix += wxT("_");
               }
               nameSuffix += wxDateTime::Now().FormatISOTime();
            }
 
            // ISO standard would be nice, but ":" is unsafe for file name.
            nameSuffix.Replace(wxT(":"), wxT("-"));
 
            if (baseTrackName.empty()) {
               newTrack->SetName(nameSuffix);
            }
            else if (nameSuffix.empty()) {
               newTrack->SetName(baseTrackName);
            }
            else {
               newTrack->SetName(baseTrackName + wxT("_") + nameSuffix);
            }
            //create a new clip with a proper name before recording is started
            newTrack->CreateClip(t0, makeNewClipName(newTrack.get()));
 
            TrackList::Get( *p ).RegisterPendingNewTrack( newTrack );
 
            if ((recordingChannels > 2) &&
                !(ProjectSettings::Get(*p).GetTracksFitVerticallyZoomed())) {
               TrackView::Get( *newTrack ).SetMinimized(true);
            }
 
            transportTracks.captureTracks.push_back(newTrack);
         }
         TrackList::Get( *p ).MakeMultiChannelTrack(*first, recordingChannels, true);
         // Bug 1548.  First of new tracks needs the focus.
         TrackFocus::Get(*p).Set(first);
         if (TrackList::Get(*p).back())
            TrackList::Get(*p).back()->EnsureVisible();
      }
 
      //Automated Input Level Adjustment Initialization
      #ifdef EXPERIMENTAL_AUTOMATED_INPUT_LEVEL_ADJUSTMENT
         gAudioIO->AILAInitialize();
      #endif
 
      int token = gAudioIO->StartStream(transportTracks, t0, t1, t1, options);
 
      success = (token != 0);
 
      if (success) {
         ProjectAudioIO::Get( *p ).SetAudioIOToken(token);
      }
      else {
         CancelRecording();
 
         // Show error message if stream could not be opened
         auto msg = XO("Error opening recording device.\nError code: %s")
            .Format( gAudioIO->LastPaErrorString() );
         using namespace BasicUI;
         ShowErrorDialog( *ProjectFramePlacement(&mProject),
            XO("Error"), msg, wxT("Error_opening_sound_device"),
            ErrorDialogOptions{ ErrorDialogType::ModalErrorReport } );
      }
   }
 
   return success;
}

References AlwaysEnabledFlag, AudioIONotBusyFlag(), AudioIORecordChannels, CanStopAudioStreamFlag(), TransportTracks::captureTracks, WaveTrackFactory::Create(), AudioIO::Get(), TrackFocus::Get(), ProjectAudioIO::Get(), TrackList::Get(), WaveTrackFactory::Get(), MenuManager::Get(), ProjectSettings::Get(), TrackView::Get(), WaveTrack::GetDefaultAudioTrackNamePreference(), ProjectSettings::GetTracksFitVerticallyZoomed(), gPrefs, make_iterator_range(), TrackList::MakeMultiChannelTrack(), name, ProjectFramePlacement(), Setting< T >::Read(), TrackList::RegisterPendingChangedTrack(), TrackList::RegisterPendingNewTrack(), WaveTrack::Reinit(), ProjectAudioIO::SetAudioIOToken(), TrackView::SetMinimized(), BasicUI::ShowErrorDialog(), size, MenuManager::TryToMakeActionAllowed(), TrackList::UpdatePendingTracks(), updater, wxT(), XC, and XO().

Here is the call graph for this function:

Get() [1/2]

ProjectAudioManager & ProjectAudioManager::Get ( AudacityProject &  project )

static

Definition at line 53 of file ProjectAudioManager.cpp.

{
   return project.AttachedObjects::Get< ProjectAudioManager >(
      sProjectAudioManagerKey );
}

References sProjectAudioManagerKey.

Referenced by AdornedRulerPanel::ScrubbingHandle::Cancel(), CanStopAudioStreamFlag(), AdornedRulerPanel::ClearPlayRegion(), CloseButtonHandle::CommitChanges(), CommandDispatch::DoAudacityCommand(), EffectUI::DoEffect(), anonymous_namespace{TransportMenus.cpp}::DoMoveToLabel(), TransportUtilities::DoStopPlaying(), anonymous_namespace{DropoutDetector.cpp}::DropoutSubscription::DropoutSubscription(), ControlToolBar::EnableDisableButtons(), Get(), Scrubber::MarkScrubStart(), ProjectManager::New(), ProjectManager::OnCloseWindow(), ControlToolBar::OnFF(), ControlToolBar::OnIdle(), AudacityApp::OnKeyDown(), ControlToolBar::OnKeyEvent(), anonymous_namespace{TransportMenus.cpp}::OnPause(), ControlToolBar::OnPause(), EffectUIHost::OnPlay(), ControlToolBar::OnPlay(), anonymous_namespace{TransportMenus.cpp}::OnPlayStopSelect(), ControlToolBar::OnRecord(), ControlToolBar::OnRewind(), anonymous_namespace{TransportMenus.cpp}::OnStop(), ControlToolBar::OnStop(), MixerBoard::OnTimer(), PlayIndicatorOverlay::OnTimer(), TrackPanel::OnTimer(), anonymous_namespace{TimerRecordDialog.cpp}::OnTimerRecord(), TranscriptionToolBar::PlayAtSpeed(), TransportUtilities::PlayCurrentRegionAndWait(), ControlToolBar::PlayDefault(), TransportUtilities::PlayPlayRegionAndWait(), TransportUtilities::RecordAndWait(), TimerRecordDialog::RunWaitDialog(), AdornedRulerPanel::StartQPPlay(), ControlToolBar::StateForStatusBar(), StatusWidthFunction(), and EffectUIHost::StopPlayback().

Here is the caller graph for this function:

Get() [2/2]

const ProjectAudioManager & ProjectAudioManager::Get ( const AudacityProject &  project )

static

Definition at line 59 of file ProjectAudioManager.cpp.

{
   return Get( const_cast< AudacityProject & >( project ) );
}

References Get().

Here is the call graph for this function:

GetLastPlayMode()

PlayMode ProjectAudioManager::GetLastPlayMode ( ) const

inline

Definition at line 135 of file ProjectAudioManager.h.

{ return mLastPlayMode; }

Referenced by MixerBoard::OnTimer(), and PlayIndicatorOverlay::OnTimer().

Here is the caller graph for this function:

IsTimerRecordCancelled()

bool ProjectAudioManager::IsTimerRecordCancelled ( )

inline

Definition at line 82 of file ProjectAudioManager.h.

{ return mTimerRecordCanceled; }

Looping()

bool ProjectAudioManager::Looping ( ) const

inline

Definition at line 99 of file ProjectAudioManager.h.

{ return mLooping; }

OnAudioIONewBlocks()

void ProjectAudioManager::OnAudioIONewBlocks ( const WritableSampleTrackArray *  tracks )

overrideprivatevirtual

Implements AudioIOListener.

Definition at line 1080 of file ProjectAudioManager.cpp.

{
   auto &project = mProject;
   auto &projectFileIO = ProjectFileIO::Get( project );
 
   wxTheApp->CallAfter( [&]{ projectFileIO.AutoSave(true); });
}

References ProjectFileIO::Get().

Here is the call graph for this function:

OnAudioIORate()

void ProjectAudioManager::OnAudioIORate ( int  rate )

overrideprivatevirtual

Implements AudioIOListener.

Definition at line 1025 of file ProjectAudioManager.cpp.

{
   auto &project = mProject;
 
   mDisplayedRate = rate;
 
   auto display = FormatRate( rate );
 
   ProjectStatus::Get( project ).Set( display, rateStatusBarField );
}

References FormatRate(), ProjectStatus::Get(), rateStatusBarField, and ProjectStatus::Set().

Here is the call graph for this function:

OnAudioIOStartRecording()

void ProjectAudioManager::OnAudioIOStartRecording ( )

overrideprivatevirtual

Implements AudioIOListener.

Definition at line 1036 of file ProjectAudioManager.cpp.

{
   // Auto-save was done here before, but it is unnecessary, provided there
   // are sufficient autosaves when pushing or modifying undo states.
}

OnAudioIOStopRecording()

void ProjectAudioManager::OnAudioIOStopRecording ( )

overrideprivatevirtual

Implements AudioIOListener.

Definition at line 1043 of file ProjectAudioManager.cpp.

{
   auto &project = mProject;
   auto &projectAudioIO = ProjectAudioIO::Get( project );
   auto &projectFileIO = ProjectFileIO::Get( project );
 
   // Only push state if we were capturing and not monitoring
   if (projectAudioIO.GetAudioIOToken() > 0)
   {
      auto &history = ProjectHistory::Get( project );
 
      if (IsTimerRecordCancelled()) {
         // discard recording
         history.RollbackState();
         // Reset timer record
         ResetTimerRecordCancelled();
      }
      else {
         // Add to history
         // We want this to have No-fail-guarantee if we get here from exception
         // handling of recording, and that means we rely on the last autosave
         // successfully committed to the database, not risking a failure
         auto flags = AudioIO::Get()->HasRecordingException()
            ? UndoPush::NOAUTOSAVE
            : UndoPush::NONE;
         history.PushState(XO("Recorded Audio"), XO("Record"), flags);
 
         // Now, we may add a label track to give information about
         // dropouts.  We allow failure of this.
         auto gAudioIO = AudioIO::Get();
         auto &intervals = gAudioIO->LostCaptureIntervals();
         if (intervals.size())
            Publish( RecordingDropoutEvent{ intervals } );
      }
   }
}

References AudioIO::Get(), ProjectAudioIO::Get(), ProjectFileIO::Get(), ProjectHistory::Get(), AudioIoCallback::HasRecordingException(), NOAUTOSAVE, NONE, and XO().

Here is the call graph for this function:

OnCheckpointFailure()

void ProjectAudioManager::OnCheckpointFailure ( ProjectFileIOMessage  message )

private

Definition at line 1114 of file ProjectAudioManager.cpp.

{
   if (message == ProjectFileIOMessage::CheckpointFailure)
      Stop();
}

References CheckpointFailure.

Referenced by ProjectAudioManager().

Here is the caller graph for this function:

OnCommitRecording()

void ProjectAudioManager::OnCommitRecording ( )

overrideprivatevirtual

Implements AudioIOListener.

Definition at line 1089 of file ProjectAudioManager.cpp.

{
   const auto project = &mProject;
   TrackList::Get( *project ).ApplyPendingTracks();
}

References TrackList::ApplyPendingTracks(), and TrackList::Get().

Here is the call graph for this function:

OnPause()

void ProjectAudioManager::OnPause

(

)

Definition at line 962 of file ProjectAudioManager.cpp.

{
   auto &projectAudioManager = *this;
   bool canStop = projectAudioManager.CanStopAudioStream();
 
   if ( !canStop ) {
      return;
   }
 
   bool paused = !projectAudioManager.Paused();
   TogglePaused();
 
   auto gAudioIO = AudioIO::Get();
 
#ifdef EXPERIMENTAL_SCRUBBING_SUPPORT
 
   auto project = &mProject;
   auto &scrubber = Scrubber::Get( *project );
 
   // Bug 1494 - Pausing a seek or scrub should just STOP as
   // it is confusing to be in a paused scrub state.
   bool bStopInstead = paused &&
      ScrubState::IsScrubbing() &&
      !scrubber.IsSpeedPlaying() &&
      !scrubber.IsKeyboardScrubbing();
 
   if (bStopInstead) {
      Stop();
      return;
   }
 
   if (ScrubState::IsScrubbing())
      scrubber.Pause(paused);
   else
#endif
   {
      gAudioIO->SetPaused(paused);
   }
}

References AudioIO::Get(), Scrubber::Get(), and ScrubState::IsScrubbing().

Referenced by anonymous_namespace{TransportMenus.cpp}::OnPause(), and ControlToolBar::OnPause().

Here is the call graph for this function:

Here is the caller graph for this function:

OnRecord()

void ProjectAudioManager::OnRecord

(

bool

altAppearance

)

Exception safety guarantee:

Strong – For state of current project's tracks

Definition at line 638 of file ProjectAudioManager.cpp.

{
   bool bPreferNewTrack;
   gPrefs->Read("/GUI/PreferNewTrackRecord", &bPreferNewTrack, false);
   const bool appendRecord = (altAppearance == bPreferNewTrack);
 
   // Code from CommandHandler start...
   AudacityProject *p = &mProject;
 
   if (p) {
      const auto &selectedRegion = ViewInfo::Get( *p ).selectedRegion;
      double t0 = selectedRegion.t0();
      double t1 = selectedRegion.t1();
      // When no time selection, recording duration is 'unlimited'.
      if (t1 == t0)
         t1 = DBL_MAX;
 
      auto options = ProjectAudioIO::GetDefaultOptions(*p);
      WritableSampleTrackArray existingTracks;
 
      // Checking the selected tracks: counting them and
      // making sure they all have the same rate
      const auto selectedTracks{ GetPropertiesOfSelected(*p) };
      const int rateOfSelected{ selectedTracks.rateOfSelected };
      const int numberOfSelected{ selectedTracks.numberOfSelected };
      const bool allSameRate{ selectedTracks.allSameRate };
 
      if (!allSameRate) {
         AudacityMessageBox(XO("The tracks selected "
            "for recording must all have the same sampling rate"),
            XO("Mismatched Sampling Rates"),
            wxICON_ERROR | wxCENTRE);
 
         return;
      }
 
      if (appendRecord) {
         const auto trackRange = TrackList::Get( *p ).Any< const WaveTrack >();
 
         // Try to find wave tracks to record into.  (If any are selected,
         // try to choose only from them; else if wave tracks exist, may record into any.)
         existingTracks = ChooseExistingRecordingTracks(*p, true, rateOfSelected);
         if (!existingTracks.empty()) {
            t0 = std::max(t0,
               (trackRange + &Track::IsSelected).max(&Track::GetEndTime));
         }
         else {
            if (numberOfSelected > 0 && rateOfSelected != options.rate) {
               AudacityMessageBox(XO(
                  "Too few tracks are selected for recording at this sample rate.\n"
                  "(Audacity requires two channels at the same sample rate for\n"
                  "each stereo track)"),
                  XO("Too Few Compatible Tracks Selected"),
                  wxICON_ERROR | wxCENTRE);
 
               return;
            }
 
            existingTracks = ChooseExistingRecordingTracks(*p, false, options.rate);
            if (!existingTracks.empty())
            {
               auto endTime = std::max_element(
                  existingTracks.begin(),
                  existingTracks.end(),
                  [](const auto& a, const auto& b) {
                     return a->GetEndTime() < b->GetEndTime();
                  }
               )->get()->GetEndTime();
 
               //If there is a suitable track, then adjust t0 so
               //that recording not starts before the end of that track
               t0 = std::max(t0, endTime);
            }
            // If suitable tracks still not found, will record into NEW ones,
            // starting with t0
         }
         
         // Whether we decided on NEW tracks or not:
         if (t1 <= selectedRegion.t0() && selectedRegion.t1() > selectedRegion.t0()) {
            t1 = selectedRegion.t1();   // record within the selection
         }
         else {
            t1 = DBL_MAX;        // record for a long, long time
         }
      }
 
      TransportTracks transportTracks;
      if (UseDuplex()) {
         // Remove recording tracks from the list of tracks for duplex ("overdub")
         // playback.
         /* TODO: set up stereo tracks if that is how the user has set up
          * their preferences, and choose sample format based on prefs */
         transportTracks = TransportTracks{ TrackList::Get( *p ), false, true };
         for (const auto &wt : existingTracks) {
            auto end = transportTracks.playbackTracks.end();
            auto it = std::find(transportTracks.playbackTracks.begin(), end, wt);
            if (it != end)
               transportTracks.playbackTracks.erase(it);
         }
      }
 
      transportTracks.captureTracks = existingTracks;
 
      if (rateOfSelected != RATE_NOT_SELECTED)
         options.rate = rateOfSelected;
 
      DoRecord(*p, transportTracks, t0, t1, altAppearance, options);
   }
}

References TrackList::Any(), AudacityMessageBox(), TransportTracks::captureTracks, PackedArray::end(), ViewInfo::Get(), TrackList::Get(), ProjectAudioIO::GetDefaultOptions(), Track::GetEndTime(), GetPropertiesOfSelected(), gPrefs, Track::IsSelected(), TransportTracks::playbackTracks, RATE_NOT_SELECTED, PropertiesOfSelected::rateOfSelected, ViewInfo::selectedRegion, NotifyingSelectedRegion::t0(), and XO().

Referenced by ControlToolBar::OnRecord(), and TimerRecordDialog::RunWaitDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

OnSoundActivationThreshold()

void ProjectAudioManager::OnSoundActivationThreshold ( )

overrideprivatevirtual

Implements AudioIOListener.

Definition at line 1095 of file ProjectAudioManager.cpp.

{
   auto& project = mProject;
   auto gAudioIO = AudioIO::Get();
   if (gAudioIO && &project == gAudioIO->GetOwningProject().get())
   {
      bool canStop =  CanStopAudioStream();
 
      gAudioIO->SetPaused(!gAudioIO->IsPaused());
 
      if (canStop)
      {
         // Instead of calling ::OnPause here, we can simply do the only thing it does (i.e. toggling the pause state),
         // because scrubbing can not happen while recording
         TogglePaused();
      }
   }
}

References AudioIO::Get().

Here is the call graph for this function:

operator=()

ProjectAudioManager & ProjectAudioManager::operator=

(

const ProjectAudioManager &

)

Paused()

bool ProjectAudioManager::Paused

(

)

const

Definition at line 1013 of file ProjectAudioManager.cpp.

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

PlayCurrentRegion()

void ProjectAudioManager::PlayCurrentRegion	(	bool	newDefault = false,
		bool	cutpreview = false
	)

Parameters

newDefault

See ProjectAudioIO::GetDefaultOptions

Definition at line 467 of file ProjectAudioManager.cpp.

{
   auto &projectAudioManager = *this;
   bool canStop = projectAudioManager.CanStopAudioStream();
 
   if ( !canStop )
      return;
 
   AudacityProject *p = &mProject;
 
   {
 
      const auto &playRegion = ViewInfo::Get( *p ).playRegion;
 
      if (newDefault)
         cutpreview = false;
      auto options = ProjectAudioIO::GetDefaultOptions(*p, newDefault);
      if (cutpreview)
         options.envelope = nullptr;
      auto mode =
         cutpreview ? PlayMode::cutPreviewPlay
         : newDefault ? PlayMode::loopedPlay
         : PlayMode::normalPlay;
      PlayPlayRegion(SelectedRegion(playRegion.GetStart(), playRegion.GetEnd()),
                     options,
                     mode);
   }
}

References cutPreviewPlay, ViewInfo::Get(), ProjectAudioIO::GetDefaultOptions(), loopedPlay, normalPlay, and ViewInfo::playRegion.

Referenced by ControlToolBar::PlayDefault().

Here is the call graph for this function:

Here is the caller graph for this function:

Playing()

bool ProjectAudioManager::Playing

(

)

const

Definition at line 1120 of file ProjectAudioManager.cpp.

{
   auto gAudioIO = AudioIO::Get();
   return
      gAudioIO->IsBusy() &&
      CanStopAudioStream() &&
      // ... and not merely monitoring
      !gAudioIO->IsMonitoring() &&
      // ... and not punch-and-roll recording
      gAudioIO->GetNumCaptureChannels() == 0;
}

References AudioIO::Get().

Here is the call graph for this function:

PlayPlayRegion()

int ProjectAudioManager::PlayPlayRegion	(	const SelectedRegion &	selectedRegion,
		const AudioIOStartStreamOptions &	options,
		PlayMode	playMode,
		bool	backwards = false
	)

Definition at line 289 of file ProjectAudioManager.cpp.

{
   auto &projectAudioManager = *this;
   bool canStop = projectAudioManager.CanStopAudioStream();
 
   if ( !canStop )
      return -1;
 
   auto &pStartTime = options.pStartTime;
 
   bool nonWaveToo = options.playNonWaveTracks;
 
   // Uncomment this for laughs!
   // backwards = true;
 
   double t0 = selectedRegion.t0();
   double t1 = selectedRegion.t1();
   // SelectedRegion guarantees t0 <= t1, so we need another boolean argument
   // to indicate backwards play.
   const bool newDefault = (mode == PlayMode::loopedPlay);
 
   if (backwards)
      std::swap(t0, t1);
 
   projectAudioManager.SetLooping( mode == PlayMode::loopedPlay );
   projectAudioManager.SetCutting( mode == PlayMode::cutPreviewPlay );
 
   bool success = false;
 
   auto gAudioIO = AudioIO::Get();
   if (gAudioIO->IsBusy())
      return -1;
 
   const bool cutpreview = mode == PlayMode::cutPreviewPlay;
   if (cutpreview && t0==t1)
      return -1; /* msmeyer: makes no sense */
 
   AudacityProject *p = &mProject;
 
   auto &tracks = TrackList::Get( *p );
 
   mLastPlayMode = mode;
 
   bool hasaudio;
   if (nonWaveToo)
      hasaudio = ! tracks.Any<PlayableTrack>().empty();
   else
      hasaudio = ! tracks.Any<WaveTrack>().empty();
 
   double latestEnd = tracks.GetEndTime();
 
   if (!hasaudio)
      return -1;  // No need to continue without audio tracks
 
#if defined(EXPERIMENTAL_SEEK_BEHIND_CURSOR)
   double initSeek = 0.0;
#endif
   double loopOffset = 0.0;
 
   if (t1 == t0) {
      if (newDefault) {
         const auto &selectedRegion = ViewInfo::Get( *p ).selectedRegion;
         // play selection if there is one, otherwise
         // set start of play region to project start,
         // and loop the project from current play position.
 
         if ((t0 > selectedRegion.t0()) && (t0 < selectedRegion.t1())) {
            t0 = selectedRegion.t0();
            t1 = selectedRegion.t1();
         }
         else {
            // loop the entire project
            // Bug2347, loop playback from cursor position instead of project start
            loopOffset = t0 - tracks.GetStartTime();
            if (!pStartTime)
               // TODO move this reassignment elsewhere so we don't need an
               // ugly mutable member
               pStartTime.emplace(loopOffset);
            t0 = tracks.GetStartTime();
            t1 = tracks.GetEndTime();
         }
      } else {
         // move t0 to valid range
         if (t0 < 0) {
            t0 = tracks.GetStartTime();
         }
         else if (t0 > tracks.GetEndTime()) {
            t0 = tracks.GetEndTime();
         }
#if defined(EXPERIMENTAL_SEEK_BEHIND_CURSOR)
         else {
            initSeek = t0;         //AC: initSeek is where playback will 'start'
            if (!pStartTime)
               pStartTime.emplace(initSeek);
            t0 = tracks.GetStartTime();
         }
#endif
      }
      t1 = tracks.GetEndTime();
   }
   else {
      // maybe t1 < t0, with backwards scrubbing for instance
      if (backwards)
         std::swap(t0, t1);
 
      t0 = std::max(0.0, std::min(t0, latestEnd));
      t1 = std::max(0.0, std::min(t1, latestEnd));
 
      if (backwards)
         std::swap(t0, t1);
   }
 
   int token = -1;
 
   if (t1 != t0) {
      if (cutpreview) {
         const double tless = std::min(t0, t1);
         const double tgreater = std::max(t0, t1);
         double beforeLen, afterLen;
         gPrefs->Read(wxT("/AudioIO/CutPreviewBeforeLen"), &beforeLen, 2.0);
         gPrefs->Read(wxT("/AudioIO/CutPreviewAfterLen"), &afterLen, 1.0);
         double tcp0 = tless-beforeLen;
         const double diff = tgreater - tless;
         double tcp1 = tgreater+afterLen;
         if (backwards)
            std::swap(tcp0, tcp1);
         AudioIOStartStreamOptions myOptions = options;
         myOptions.policyFactory =
            [tless, diff](auto&) -> std::unique_ptr<PlaybackPolicy> {
               return std::make_unique<CutPreviewPlaybackPolicy>(tless, diff);
            };
         token = gAudioIO->StartStream(
            TransportTracks{ TrackList::Get(*p), false, nonWaveToo },
            tcp0, tcp1, tcp1, myOptions);
      }
      else {
         double mixerLimit = t1;
         if (newDefault) {
            mixerLimit = latestEnd;
            if (pStartTime && *pStartTime >= t1)
               t1 = latestEnd;
         }
         token = gAudioIO->StartStream(
            TransportTracks{ tracks, false, nonWaveToo },
            t0, t1, mixerLimit, options);
      }
      if (token != 0) {
         success = true;
         ProjectAudioIO::Get(*p).SetAudioIOToken(token);
      }
      else {
         // Bug1627 (part of it):
         // infinite error spew when trying to start scrub:
         // Problem was that the error dialog yields to events,
         // causing recursion to this function in the scrub timer
         // handler!  Easy fix, just delay the user alert instead.
         auto &window = GetProjectFrame( mProject );
         window.CallAfter( [&]{
            using namespace BasicUI;
            // Show error message if stream could not be opened
            ShowErrorDialog( *ProjectFramePlacement(&mProject),
               XO("Error"),
               XO("Error opening sound device.\nTry changing the audio host, playback device and the project sample rate."),
               wxT("Error_opening_sound_device"),
               ErrorDialogOptions{ ErrorDialogType::ModalErrorReport } );
         });
      }
   }
 
   if (!success)
      return -1;
 
   return token;
}

References cutPreviewPlay, AudioIO::Get(), ProjectAudioIO::Get(), ViewInfo::Get(), TrackList::Get(), GetProjectFrame(), gPrefs, loopedPlay, min(), AudioIOStartStreamOptions::playNonWaveTracks, AudioIOStartStreamOptions::policyFactory, ProjectFramePlacement(), AudioIOStartStreamOptions::pStartTime, ViewInfo::selectedRegion, ProjectAudioIO::SetAudioIOToken(), BasicUI::ShowErrorDialog(), anonymous_namespace{NoteTrack.cpp}::swap(), SelectedRegion::t0(), SelectedRegion::t1(), wxT(), and XO().

Here is the call graph for this function:

Recording()

bool ProjectAudioManager::Recording

(

)

const

Definition at line 1132 of file ProjectAudioManager.cpp.

{
   auto gAudioIO = AudioIO::Get();
   return
      gAudioIO->IsBusy() &&
      CanStopAudioStream() &&
      gAudioIO->GetNumCaptureChannels() > 0;
}

References AudioIO::Get().

Here is the call graph for this function:

ResetTimerRecordCancelled()

void ProjectAudioManager::ResetTimerRecordCancelled ( )

inline

Definition at line 84 of file ProjectAudioManager.h.

{ mTimerRecordCanceled = false; }

SetAppending()

void ProjectAudioManager::SetAppending ( bool  value )

inlineprivate

Definition at line 142 of file ProjectAudioManager.h.

{ mAppending = value; }

SetCutting()

void ProjectAudioManager::SetCutting ( bool  value )

inlineprivate

Definition at line 144 of file ProjectAudioManager.h.

{ mCutting = value; }

SetLooping()

void ProjectAudioManager::SetLooping ( bool  value )

inlineprivate

Definition at line 143 of file ProjectAudioManager.h.

{ mLooping = value; }

SetPausedOff()

void ProjectAudioManager::SetPausedOff ( )

private

Definition at line 1008 of file ProjectAudioManager.cpp.

{
   mPaused.store(0, std::memory_order::memory_order_relaxed);
}

SetStopping()

void ProjectAudioManager::SetStopping ( bool  value )

inlineprivate

Definition at line 145 of file ProjectAudioManager.h.

{ mStopping = value; }

SetTimerRecordCancelled()

void ProjectAudioManager::SetTimerRecordCancelled ( )

inline

Definition at line 83 of file ProjectAudioManager.h.

{ mTimerRecordCanceled = true; }

Referenced by anonymous_namespace{TimerRecordDialog.cpp}::OnTimerRecord().

Here is the caller graph for this function:

StatusWidthFunction()

auto ProjectAudioManager::StatusWidthFunction ( const AudacityProject &  project, StatusBarField  field  )

staticprivate

Definition at line 86 of file ProjectAudioManager.cpp.

{
   if ( field == rateStatusBarField ) {
      auto &audioManager = ProjectAudioManager::Get( project );
      int rate = audioManager.mDisplayedRate;
      return {
         { { FormatRate( rate ) } },
         50
      };
   }
   return {};
}

References field, FormatRate(), Get(), and rateStatusBarField.

Referenced by ProjectAudioManager().

Here is the call graph for this function:

Here is the caller graph for this function:

Stop()

void ProjectAudioManager::Stop

(

bool

stopStream = true

)

Definition at line 497 of file ProjectAudioManager.cpp.

{
   AudacityProject *project = &mProject;
   auto &projectAudioManager = *this;
   bool canStop = projectAudioManager.CanStopAudioStream();
 
   if ( !canStop )
      return;
 
   if(project) {
      // Let scrubbing code do some appearance change
      auto &scrubber = Scrubber::Get( *project );
      scrubber.StopScrubbing();
   }
 
   auto gAudioIO = AudioIO::Get();
 
   auto cleanup = finally( [&]{
      projectAudioManager.SetStopping( false );
   } );
 
   if (stopStream && gAudioIO->IsBusy()) {
      // flag that we are stopping
      projectAudioManager.SetStopping( true );
      // Allow UI to update for that
      while( wxTheApp->ProcessIdle() )
         ;
   }
 
   if(stopStream)
      gAudioIO->StopStream();
 
   projectAudioManager.SetLooping( false );
   projectAudioManager.SetCutting( false );
 
   #ifdef EXPERIMENTAL_AUTOMATED_INPUT_LEVEL_ADJUSTMENT
      gAudioIO->AILADisable();
   #endif
 
   projectAudioManager.SetPausedOff();
   //Make sure you tell gAudioIO to unpause
   gAudioIO->SetPaused( false );
 
   // So that we continue monitoring after playing or recording.
   // also clean the MeterQueues
   if( project ) {
      auto &projectAudioIO = ProjectAudioIO::Get( *project );
      auto meter = projectAudioIO.GetPlaybackMeter();
      if( meter ) {
         meter->Clear();
      }
 
      meter = projectAudioIO.GetCaptureMeter();
      if( meter ) {
         meter->Clear();
      }
   }
 
   // To do: eliminate this, use an event instead
   const auto toolbar = ToolManager::Get( *project ).GetToolBar(wxT("Scrub"));
   if (toolbar)
      toolbar->EnableDisableButtons();
}

References ToolBar::EnableDisableButtons(), AudioIO::Get(), ProjectAudioIO::Get(), ToolManager::Get(), Scrubber::Get(), ToolManager::GetToolBar(), and wxT().

Referenced by AdornedRulerPanel::ScrubbingHandle::Cancel(), AdornedRulerPanel::ClearPlayRegion(), CommandDispatch::DoAudacityCommand(), EffectUI::DoEffect(), ProjectManager::OnCloseWindow(), AudacityApp::OnKeyDown(), anonymous_namespace{TransportMenus.cpp}::OnStop(), and TimerRecordDialog::RunWaitDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

StopIfPaused()

void ProjectAudioManager::StopIfPaused

(

)

Definition at line 1204 of file ProjectAudioManager.cpp.

{
   if( AudioIOBase::Get()->IsPaused() )
      Stop();
}

References AudioIOBase::Get().

Referenced by CloseButtonHandle::CommitChanges(), ControlToolBar::OnFF(), and ControlToolBar::OnRewind().

Here is the call graph for this function:

Here is the caller graph for this function:

Stopping()

bool ProjectAudioManager::Stopping ( ) const

inline

Definition at line 94 of file ProjectAudioManager.h.

{ return mStopping; }

TogglePaused()

void ProjectAudioManager::TogglePaused ( )

private

Definition at line 1003 of file ProjectAudioManager.cpp.

{
   mPaused.fetch_xor(1, std::memory_order::memory_order_relaxed);
}

UseDuplex()

bool ProjectAudioManager::UseDuplex ( )

static

Definition at line 748 of file ProjectAudioManager.cpp.

{
   bool duplex;
   gPrefs->Read(wxT("/AudioIO/Duplex"), &duplex,
#ifdef EXPERIMENTAL_DA
      false
#else
      true
#endif
      );
   return duplex;
}

References gPrefs, and wxT().

Here is the call graph for this function:

Member Data Documentation

mAppending

bool ProjectAudioManager::mAppending { false }

private

Definition at line 172 of file ProjectAudioManager.h.

mCheckpointFailureSubcription

Observer::Subscription ProjectAudioManager::mCheckpointFailureSubcription

private

Definition at line 160 of file ProjectAudioManager.h.

Referenced by ProjectAudioManager().

mCutting

bool ProjectAudioManager::mCutting { false }

private

Definition at line 174 of file ProjectAudioManager.h.

mDisplayedRate

int ProjectAudioManager::mDisplayedRate { 0 }

private

Definition at line 177 of file ProjectAudioManager.h.

mLastPlayMode

PlayMode ProjectAudioManager::mLastPlayMode { PlayMode::normalPlay }

private

Definition at line 163 of file ProjectAudioManager.h.

mLooping

bool ProjectAudioManager::mLooping { false }

private

Definition at line 173 of file ProjectAudioManager.h.

mPaused

std::atomic<int> ProjectAudioManager::mPaused { 0 }

private

Definition at line 170 of file ProjectAudioManager.h.

mProject

AudacityProject& ProjectAudioManager::mProject

private

Definition at line 161 of file ProjectAudioManager.h.

mStopping

bool ProjectAudioManager::mStopping { false }

private

Definition at line 175 of file ProjectAudioManager.h.

mTimerRecordCanceled

bool ProjectAudioManager::mTimerRecordCanceled { false }

private

Definition at line 166 of file ProjectAudioManager.h.

---

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

• ProjectAudioManager.h
• ProjectAudioManager.cpp