#include <ProjectAudioManager.h>

Inheritance diagram for ProjectAudioManager:

Collaboration diagram for ProjectAudioManager:

Public Member Functions
	ProjectAudioManager (AudacityProject &project)

	ProjectAudioManager (const ProjectAudioManager &)=delete

ProjectAudioManager &	operator= (const ProjectAudioManager &)=delete

	~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 TransportSequences &transportSequences, 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 ()=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)
	Find suitable tracks to record into, or return an empty array. More...

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 () 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	mCheckpointFailureSubscription

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 69 of file ProjectAudioManager.cpp.

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

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

Here is the call graph for this function:

◆ ProjectAudioManager() [2/2]

ProjectAudioManager::ProjectAudioManager ( const ProjectAudioManager & )

delete

◆ ~ProjectAudioManager()

ProjectAudioManager::~ProjectAudioManager ( )

overridedefault

Member Function Documentation

◆ Appending()

bool ProjectAudioManager::Appending ( ) const

inline

Definition at line 97 of file ProjectAudioManager.h.

97{ return mAppending; }

ProjectAudioManager::mAppending

bool mAppending

Definition: ProjectAudioManager.h:173

◆ CancelRecording()

void ProjectAudioManager::CancelRecording ( )

private

Definition at line 1065 of file ProjectAudioManager.cpp.

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

References PendingTracks::ClearPendingTracks(), PendingTracks::Get(), and project.

Here is the call graph for this function:

◆ CanStopAudioStream()

bool ProjectAudioManager::CanStopAudioStream ( ) const

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

Find suitable tracks to record into, or return an empty array.

Definition at line 561 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);
   WritableSampleTrackArray candidates;
   std::vector<unsigned> channelCounts;
   size_t totalChannels = 0;
   const auto range = trackList.Any<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 nChannels = candidate->NChannels();
      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();
         totalChannels = 0;
         continue;
      }
      else {
         // Might use this but may have to discard some of the accumulated
         while(strictRules &&
               nChannels + totalChannels > recordingChannels) {
            candidates.erase(candidates.begin());
            auto nOldChannels = channelCounts[0];
            assert(nOldChannels > 0);
            channelCounts.erase(channelCounts.begin());
            totalChannels -= nOldChannels;
         }
         candidates.push_back(candidate->SharedPointer<WaveTrack>());
         channelCounts.push_back(nChannels);
         totalChannels += nChannels;
         if (totalChannels >= 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::Get(), Track::IsSelected(), WaveTrack::NChannels(), RATE_NOT_SELECTED, and Setting< T >::Read().

Referenced by anonymous_namespace{TransportMenus.cpp}::OnPunchAndRoll(), and 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.

100{ return mCutting; }

ProjectAudioManager::mCutting

bool mCutting

Definition: ProjectAudioManager.h:175

◆ DoPlayStopSelect() [1/2]

void ProjectAudioManager::DoPlayStopSelect ( )

Definition at line 1311 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 1255 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(), ProjectHistory::ModifyState(), and project.

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 TransportSequences &	transportSequences,
		double	t0,
		double	t1,
		bool	altAppearance,
		const AudioIOStartStreamOptions &	options
	)

Parameters

transportSequences If captureSequences is empty, then tracks are created

Definition at line 757 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 = CommandManager::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 transportSequences = sequences;
 
   // Will replace any given capture tracks with temporaries
   transportSequences.captureSequences.clear();
 
   const auto p = &project;
   auto &trackList = TrackList::Get(project);
 
   bool appendRecord = !sequences.captureSequences.empty();
 
   auto insertEmptyInterval =
   [&](WaveTrack &track, double t0, bool placeholder) {
      wxString name;
      for (auto i = 1; ; ++i) {
         //i18n-hint a numerical suffix added to distinguish otherwise like-named clips when new record started
         name = XC("%s.%d", "clip name template")
            .Format(track.GetName(), i).Translation();
         if (!track.HasClipNamed(name))
            break;
      }
 
      auto clip = track.CreateClip(t0, name);
      // So that the empty clip is not skipped for insertion:
      clip->SetIsPlaceholder(true);
      track.InsertInterval(clip, true);
      if (!placeholder)
         clip->SetIsPlaceholder(false);
      return clip;
   };
 
   auto &pendingTracks = PendingTracks::Get(project);
 
   {
      if (appendRecord) {
         // Append recording:
         // Pad selected/all wave tracks to make them all the same length
         for (const auto &sequence : sequences.captureSequences) {
            WaveTrack *wt{};
            if (!(wt = dynamic_cast<WaveTrack *>(sequence.get()))) {
               assert(false);
               continue;
            }
            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.
            const auto shared = wt->SharedPointer<WaveTrack>();
            // prerollSequences should be a subset of playbackSequences.
            const auto &range = transportSequences.playbackSequences;
            bool prerollTrack = any_of(range.begin(), range.end(),
               [&](const auto &pSequence){
                  return shared.get() == pSequence->FindChannelGroup(); });
            if (prerollTrack)
               transportSequences.prerollSequences.push_back(shared);
 
            // 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){
               assert(d.NChannels() == s.NChannels());
               auto &dst = static_cast<WaveTrack&>(d);
               auto &src = static_cast<const WaveTrack&>(s);
               dst.Init(src);
            };
 
            // 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.
            //const auto pending = static_cast<WaveTrack*>(newTrack);
            const auto lastClip = wt->GetRightmostClip();
            // RoundedT0 to have a new clip created when punch-and-roll
            // recording with the cursor in the second half of the space
            // between two samples
            // (https://github.com/audacity/audacity/issues/5113#issuecomment-1705154108)
            const auto recordingStart =
               std::round(t0 * wt->GetRate()) / wt->GetRate();
            const auto recordingStartsBeforeTrackEnd =
               lastClip && recordingStart < lastClip->GetPlayEndTime();
            // Recording doesn't start before the beginning of the last clip
            // - or the check for creating a new clip or not should be more
            // general than that ...
            assert(
               !recordingStartsBeforeTrackEnd ||
               lastClip->WithinPlayRegion(recordingStart));
            WaveTrack::IntervalHolder newClip{};
            if (!recordingStartsBeforeTrackEnd ||
               lastClip->HasPitchOrSpeed())
               newClip = insertEmptyInterval(*wt, t0, true);
            // Get a copy of the track to be appended, to be pushed into
            // undo history only later.
            const auto pending = static_cast<WaveTrack*>(
               pendingTracks.RegisterPendingChangedTrack(updater, wt)
            );
            // Source clip was marked as placeholder so that it would not be
            // skipped in clip copying.  Un-mark it and its copy now
            if (newClip)
               newClip->SetIsPlaceholder(false);
            if (auto copiedClip = pending->NewestOrNewClip())
               copiedClip->SetIsPlaceholder(false);
            transportSequences.captureSequences
               .push_back(pending->SharedPointer<WaveTrack>());
         }
         pendingTracks.UpdatePendingTracks();
      }
 
      if (transportSequences.captureSequences.empty()) {
         // recording to NEW track(s).
         bool recordingNameCustom, useTrackNumber, useDateStamp, useTimeStamp;
         wxString defaultTrackName, defaultRecordingTrackName;
 
         // Count the tracks.
         auto numTracks = trackList.Any<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;
 
         auto newTracks =
            WaveTrackFactory::Get(*p).CreateMany(recordingChannels);
         const auto first = *newTracks->begin();
         int trackCounter = 0;
         const auto minimizeChannelView = recordingChannels > 2
            && !TracksPrefs::TracksFitVerticallyZoomed.Read();
         for (auto newTrack : newTracks->Any<WaveTrack>()) {
            // Quantize bounds to the rate of the new track.
            if (newTrack == first) {
               if (t0 < DBL_MAX)
                  t0 = newTrack->SnapToSample(t0);
               if (t1 < DBL_MAX)
                  t1 = newTrack->SnapToSample(t1);
            }
 
            newTrack->MoveTo(t0);
            wxString nameSuffix = wxString(wxT(""));
 
            if (useTrackNumber) {
               nameSuffix += wxString::Format(wxT("%d"), 1 + (int) numTracks + trackCounter++);
            }
 
            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
            insertEmptyInterval(*newTrack, t0, false);
 
            transportSequences.captureSequences.push_back(
               std::static_pointer_cast<WaveTrack>(newTrack->shared_from_this())
            );
 
            for(auto channel : newTrack->Channels())
            {
               ChannelView::Get(*channel).SetMinimized(minimizeChannelView);
            }
         }
         pendingTracks.RegisterPendingNewTracks(std::move(*newTracks));
         // Bug 1548.  First of new tracks needs the focus.
         TrackFocus::Get(project).Set(first);
         if (!trackList.empty()) {
            BasicUI::CallAfter([pProject = project.weak_from_this()]{
               if (!pProject.expired()) {
                  auto &project = *pProject.lock();
                  auto &trackList = TrackList::Get(project);
                  Viewport::Get(project).ShowTrack(**trackList.rbegin());
               }
            });
         }
      }
 
      //Automated Input Level Adjustment Initialization
      #ifdef EXPERIMENTAL_AUTOMATED_INPUT_LEVEL_ADJUSTMENT
         gAudioIO->AILAInitialize();
      #endif
 
      int token =
         gAudioIO->StartStream(transportSequences, 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, Track::Any(), AudioIONotBusyFlag(), AudioIORecordChannels, BasicUI::CallAfter(), CanStopAudioStreamFlag(), TransportSequences::captureSequences, WaveTrack::CreateClip(), WaveTrackFactory::CreateMany(), AudioIO::Get(), TrackFocus::Get(), ProjectAudioIO::Get(), CommandManager::Get(), PendingTracks::Get(), TrackList::Get(), WaveTrackFactory::Get(), ChannelView::Get(), WaveTrack::GetDefaultAudioTrackNamePreference(), Track::GetName(), gPrefs, WaveTrack::HasClipNamed(), WaveTrack::Init(), WaveTrack::InsertInterval(), name, ChannelGroup::NChannels(), project, ProjectFramePlacement(), audacity::BasicSettings::Read(), Setting< T >::Read(), fast_float::round(), ProjectAudioIO::SetAudioIOToken(), ChannelView::SetMinimized(), BasicUI::ShowErrorDialog(), size, TracksPrefs::TracksFitVerticallyZoomed, CommandManager::TryToMakeActionAllowed(), updater, wxT(), XC, and XO().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Get() [1/2]

ProjectAudioManager & ProjectAudioManager::Get ( AudacityProject & project )

static

Definition at line 57 of file ProjectAudioManager.cpp.

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

References project, and sProjectAudioManagerKey.

Here is the caller graph for this function:

◆ Get() [2/2]

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

static

Definition at line 63 of file ProjectAudioManager.cpp.

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

References Get(), and project.

Here is the call graph for this function:

◆ GetLastPlayMode()

PlayMode ProjectAudioManager::GetLastPlayMode ( ) const

inline

Definition at line 136 of file ProjectAudioManager.h.

136{ return mLastPlayMode; }

ProjectAudioManager::mLastPlayMode

PlayMode mLastPlayMode

Definition: ProjectAudioManager.h:164

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.

82{ return mTimerRecordCanceled; }

ProjectAudioManager::mTimerRecordCanceled

bool mTimerRecordCanceled

Definition: ProjectAudioManager.h:167

◆ Looping()

bool ProjectAudioManager::Looping ( ) const

inline

Definition at line 99 of file ProjectAudioManager.h.

99{ return mLooping; }

ProjectAudioManager::mLooping

bool mLooping

Definition: ProjectAudioManager.h:174

◆ OnAudioIONewBlocks()

void ProjectAudioManager::OnAudioIONewBlocks ( )

overrideprivatevirtual

Implements AudioIOListener.

Definition at line 1126 of file ProjectAudioManager.cpp.

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

References ProjectFileIO::Get(), and project.

Here is the call graph for this function:

◆ OnAudioIORate()

void ProjectAudioManager::OnAudioIORate ( int rate )

overrideprivatevirtual

Implements AudioIOListener.

Definition at line 1071 of file ProjectAudioManager.cpp.

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

References FormatRate(), ProjectStatus::Get(), project, RateStatusBarField(), and ProjectStatus::Set().

Here is the call graph for this function:

◆ OnAudioIOStartRecording()

void ProjectAudioManager::OnAudioIOStartRecording ( )

overrideprivatevirtual

Implements AudioIOListener.

Definition at line 1082 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 1089 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, project, and XO().

Here is the call graph for this function:

◆ OnCheckpointFailure()

void ProjectAudioManager::OnCheckpointFailure ( ProjectFileIOMessage message )

private

Definition at line 1159 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 1134 of file ProjectAudioManager.cpp.

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

References PendingTracks::ApplyPendingTracks(), PendingTracks::Get(), and project.

Here is the call graph for this function:

◆ OnPause()

void ProjectAudioManager::OnPause ( )

Definition at line 1010 of file ProjectAudioManager.cpp.

{
   auto &projectAudioManager = *this;
   bool canStop = projectAudioManager.CanStopAudioStream();
 
   if ( !canStop ) {
      return;
   }
 
   bool paused = !projectAudioManager.Paused();
   TogglePaused();
 
   auto gAudioIO = AudioIO::Get();
 
   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
   {
      constexpr auto publish = true;
      gAudioIO->SetPaused(paused, publish);
   }
}

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

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 636 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 bool anySelected{ selectedTracks.anySelected };
      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) {
         // 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,
               TrackList::Get(*p).Selected<const WaveTrack>()
               .max(&Track::GetEndTime));
            options.rate = rateOfSelected;
         }
         else {
            if (anySelected && 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())
            {
               const auto endTime = accumulate(
                  existingTracks.begin(), existingTracks.end(),
                  std::numeric_limits<double>::lowest(),
                  [](double acc, auto &pTrack) {
                     return std::max(acc, pTrack->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
         }
      }
 
      TransportSequences 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 =
            MakeTransportTracks(TrackList::Get( *p ), false, true);
         for (const auto &wt : existingTracks) {
            auto end = transportTracks.playbackSequences.end();
            auto it = std::find_if(
               transportTracks.playbackSequences.begin(), end,
               [&wt](const auto& playbackSequence) {
                  return playbackSequence->FindChannelGroup() ==
                         wt->FindChannelGroup();
               });
            if (it != end)
               transportTracks.playbackSequences.erase(it);
         }
      }
 
      std::copy(existingTracks.begin(), existingTracks.end(),
         back_inserter(transportTracks.captureSequences));
 
      DoRecord(*p, transportTracks, t0, t1, altAppearance, options);
   }
}

References AudacityMessageBox(), TransportSequences::captureSequences, staffpad::vo::copy(), details::end(), ViewInfo::Get(), TrackList::Get(), ProjectAudioIO::GetDefaultOptions(), ChannelGroup::GetEndTime(), GetPropertiesOfSelected(), gPrefs, MakeTransportTracks(), TransportSequences::playbackSequences, PropertiesOfSelected::rateOfSelected, audacity::BasicSettings::Read(), TrackList::Selected(), 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 1140 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(), and project.

Here is the call graph for this function:

◆ operator=()

ProjectAudioManager & ProjectAudioManager::operator= ( const ProjectAudioManager & )

delete

◆ Paused()

bool ProjectAudioManager::Paused ( ) const

Definition at line 1059 of file ProjectAudioManager.cpp.

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

Referenced by Scrubber::OnActivateOrDeactivateApp().

Here is the caller graph for this function:

◆ PlayCurrentRegion()

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

Parameters

newDefault See ProjectAudioIO::GetDefaultOptions

Definition at line 471 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 1165 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 293 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(
            MakeTransportTracks(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(
            MakeTransportTracks(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, MakeTransportTracks(), min(), AudioIOStartStreamOptions::playNonWaveTracks, AudioIOStartStreamOptions::policyFactory, ProjectFramePlacement(), AudioIOStartStreamOptions::pStartTime, audacity::BasicSettings::Read(), ViewInfo::selectedRegion, ProjectAudioIO::SetAudioIOToken(), BasicUI::ShowErrorDialog(), anonymous_namespace{NoteTrack.cpp}::swap(), SelectedRegion::t0(), SelectedRegion::t1(), tracks, wxT(), and XO().

Referenced by Scrubber::StartKeyboardScrubbing().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Recording()

bool ProjectAudioManager::Recording ( ) const

Definition at line 1177 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.

84{ mTimerRecordCanceled = false; }

◆ SetAppending()

void ProjectAudioManager::SetAppending ( bool value )

inlineprivate

Definition at line 143 of file ProjectAudioManager.h.

143{ mAppending = value; }

◆ SetCutting()

void ProjectAudioManager::SetCutting ( bool value )

inlineprivate

Definition at line 145 of file ProjectAudioManager.h.

145{ mCutting = value; }

◆ SetLooping()

void ProjectAudioManager::SetLooping ( bool value )

inlineprivate

Definition at line 144 of file ProjectAudioManager.h.

144{ mLooping = value; }

◆ SetPausedOff()

void ProjectAudioManager::SetPausedOff ( )

private

Definition at line 1054 of file ProjectAudioManager.cpp.

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

◆ SetStopping()

void ProjectAudioManager::SetStopping ( bool value )

inlineprivate

Definition at line 146 of file ProjectAudioManager.h.

146{ mStopping = value; }

ProjectAudioManager::mStopping

bool mStopping

Definition: ProjectAudioManager.h:176

◆ SetTimerRecordCancelled()

void ProjectAudioManager::SetTimerRecordCancelled ( )

inline

Definition at line 83 of file ProjectAudioManager.h.

83{ 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 90 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(), project, 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 501 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();
      }
   }
}

References AudioIO::Get(), ProjectAudioIO::Get(), Scrubber::Get(), and project.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ StopIfPaused()

void ProjectAudioManager::StopIfPaused ( )

Definition at line 1249 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.

94{ return mStopping; }

◆ TogglePaused()

void ProjectAudioManager::TogglePaused ( )

private

Definition at line 1049 of file ProjectAudioManager.cpp.

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

◆ UseDuplex()

bool ProjectAudioManager::UseDuplex ( )

static

Definition at line 750 of file ProjectAudioManager.cpp.

{
   bool duplex;
   gPrefs->Read(wxT("/AudioIO/Duplex"), &duplex, true);
   return duplex;
}

References gPrefs, audacity::BasicSettings::Read(), and wxT().

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

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ mAppending

bool ProjectAudioManager::mAppending { false }

private

Definition at line 173 of file ProjectAudioManager.h.

◆ mCheckpointFailureSubscription

Observer::Subscription ProjectAudioManager::mCheckpointFailureSubscription

private

Definition at line 161 of file ProjectAudioManager.h.

Referenced by ProjectAudioManager().

◆ mCutting

bool ProjectAudioManager::mCutting { false }

private

Definition at line 175 of file ProjectAudioManager.h.

◆ mDisplayedRate

int ProjectAudioManager::mDisplayedRate { 0 }

private

Definition at line 178 of file ProjectAudioManager.h.

◆ mLastPlayMode

PlayMode ProjectAudioManager::mLastPlayMode { PlayMode::normalPlay }

private

Definition at line 164 of file ProjectAudioManager.h.

◆ mLooping

bool ProjectAudioManager::mLooping { false }

private

Definition at line 174 of file ProjectAudioManager.h.

◆ mPaused

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

private

Definition at line 171 of file ProjectAudioManager.h.

◆ mProject

AudacityProject& ProjectAudioManager::mProject

private

Definition at line 162 of file ProjectAudioManager.h.

◆ mStopping

bool ProjectAudioManager::mStopping { false }

private

Definition at line 176 of file ProjectAudioManager.h.

◆ mTimerRecordCanceled

bool ProjectAudioManager::mTimerRecordCanceled { false }

private

Definition at line 167 of file ProjectAudioManager.h.

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

Public Member Functions

Static Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ProjectAudioManager() [1/2]

◆ ProjectAudioManager() [2/2]

◆ ~ProjectAudioManager()

Member Function Documentation

◆ Appending()

◆ CancelRecording()

◆ CanStopAudioStream()

◆ ChooseExistingRecordingTracks()

◆ Cutting()

◆ DoPlayStopSelect() [1/2]

◆ DoPlayStopSelect() [2/2]

◆ DoRecord()

◆ Get() [1/2]

◆ Get() [2/2]

◆ GetLastPlayMode()

◆ IsTimerRecordCancelled()

◆ Looping()

◆ OnAudioIONewBlocks()

◆ OnAudioIORate()

◆ OnAudioIOStartRecording()

◆ OnAudioIOStopRecording()

◆ OnCheckpointFailure()

◆ OnCommitRecording()

◆ OnPause()

◆ OnRecord()

◆ OnSoundActivationThreshold()

◆ operator=()

◆ Paused()

◆ PlayCurrentRegion()

◆ Playing()

◆ PlayPlayRegion()

◆ Recording()

◆ ResetTimerRecordCancelled()

◆ SetAppending()

◆ SetCutting()

◆ SetLooping()

◆ SetPausedOff()

◆ SetStopping()

◆ SetTimerRecordCancelled()

◆ StatusWidthFunction()

◆ Stop()

◆ StopIfPaused()

◆ Stopping()

◆ TogglePaused()

◆ UseDuplex()

Member Data Documentation

◆ mAppending

◆ mCheckpointFailureSubscription

◆ mCutting

◆ mDisplayedRate

◆ mLastPlayMode

◆ mLooping

◆ mPaused

◆ mProject

◆ mStopping

◆ mTimerRecordCanceled