EffectOutputTracks Class Reference

Use this object to copy the input tracks to tentative outputTracks. More...

#include <EffectOutputTracks.h>

Collaboration diagram for EffectOutputTracks:

Public Types
using	TimeInterval = std::pair< double, double >

Public Member Functions
	EffectOutputTracks (TrackList &tracks, EffectType effectType, std::optional< TimeInterval > effectTimeInterval, bool allSyncLockSelected=false, bool stretchSyncLocked=false)
	EffectOutputTracks (const EffectOutputTracks &)=delete
	~EffectOutputTracks ()
Track *	AddToOutputTracks (const std::shared_ptr< Track > &t)
	Use this to add an output track, not corresponding to an input. More...
const Track *	GetMatchingInput (const Track &outTrack) const
	Gets the matching input track for the given output track if it finds its match, else nullptr. More...
void	Commit ()
	Replace input tracks with temporaries only on commit. More...
TrackList &	Get ()
	Expose the output track list for iterations or even erasures. More...

Static Public Member Functions
static void	IncEffectCounter ()

Static Public Attributes
static int	nEffectsDone = 0

Private Attributes
TrackList &	mTracks
const EffectType	mEffectType
std::vector< Track * >	mIMap
std::vector< Track * >	mOMap
std::shared_ptr< TrackList >	mOutputTracks

Detailed Description

Use this object to copy the input tracks to tentative outputTracks.

Definition at line 28 of file EffectOutputTracks.h.

Member Typedef Documentation

TimeInterval

using EffectOutputTracks::TimeInterval = std::pair<double, double>

Definition at line 35 of file EffectOutputTracks.h.

Constructor & Destructor Documentation

EffectOutputTracks() [1/2]

EffectOutputTracks::EffectOutputTracks	(	TrackList &	tracks,
		EffectType	effectType,
		std::optional< TimeInterval >	effectTimeInterval,
		bool	allSyncLockSelected = false,
		bool	stretchSyncLocked = false
	)

Parameters

effectTimeInterval	if given, and any copied tracks have clips with non-unit stretch intersecting that interval, then in the copies those clips are split, and new clips bounded by the interval, with the stretches applied, are inserted.
allSyncLockSelected	if true, unselected tracks that are sync-locked with a selected track are copied too
stretchSyncLocked	if false, do not apply the stretch interval to any unselected WaveTrack that is copied

Precondition

!effectTimeInterval.has_value() || effectTimeInterval->first <= effectTimeInterval->second

Definition at line 20 of file EffectOutputTracks.cpp.

    : mTracks { tracks }
    , mEffectType { effectType }
{
   assert(
      !effectTimeInterval.has_value() ||
      effectTimeInterval->first <= effectTimeInterval->second);
   // Reset map
   mIMap.clear();
   mOMap.clear();
   mOutputTracks = TrackList::Create(mTracks.GetOwner());
 
   auto trackRange = mTracks.Any() +
      [&] (const Track *pTrack) {
         return allSyncLockSelected
         ? SyncLock::IsSelectedOrSyncLockSelected(*pTrack)
         : dynamic_cast<const WaveTrack*>(pTrack) && pTrack->GetSelected();
      };
 
   for (auto aTrack : trackRange) {
      auto pTrack = aTrack->Duplicate();
      mIMap.push_back(aTrack);
      mOMap.push_back(pTrack.get());
      mOutputTracks->Add(pTrack);
   }
 
   if (
      effectTimeInterval.has_value() &&
      effectTimeInterval->second > effectTimeInterval->first)
   {
      TimeStretching::WithClipRenderingProgress(
         [&](const ProgressReporter& parent)
         {
            const auto tracksToUnstretch =
               (stretchSyncLocked ? mOutputTracks->Any<WaveTrack>() :
                                    mOutputTracks->Selected<WaveTrack>()) +
               [&](const WaveTrack* pTrack)
            {
               return TimeStretching::HasPitchOrSpeed(
                  *pTrack, effectTimeInterval->first,
                  effectTimeInterval->second);
            };
            BasicUI::SplitProgress(
               tracksToUnstretch.begin(), tracksToUnstretch.end(),
               [&](WaveTrack* aTrack, const ProgressReporter& child) {
                  aTrack->ApplyPitchAndSpeed(effectTimeInterval, child);
               },
               parent);
         });
   }
 
   // Invariant is established
   assert(mIMap.size() == mOutputTracks->Size());
   assert(mIMap.size() == mOMap.size());
}

References TrackList::Any(), TrackList::Create(), TrackList::GetOwner(), Track::GetSelected(), TimeStretching::HasPitchOrSpeed(), SyncLock::IsSelectedOrSyncLockSelected(), mIMap, mOMap, mOutputTracks, mTracks, BasicUI::SplitProgress(), and TimeStretching::WithClipRenderingProgress().

Here is the call graph for this function:

EffectOutputTracks() [2/2]

EffectOutputTracks::EffectOutputTracks ( const EffectOutputTracks &  )

delete

~EffectOutputTracks()

EffectOutputTracks::~EffectOutputTracks ( )

default

Member Function Documentation

AddToOutputTracks()

Track * EffectOutputTracks::AddToOutputTracks

(

const std::shared_ptr< Track > &

t

)

Use this to add an output track, not corresponding to an input.

Returns

a pointer to the given track

Definition at line 81 of file EffectOutputTracks.cpp.

{
   mIMap.push_back(nullptr);
   mOMap.push_back(t.get());
   auto result = mOutputTracks->Add(t);
   // Invariant is maintained
   assert(mIMap.size() == mOutputTracks->Size());
   assert(mIMap.size() == mOMap.size());
   return result;
}

References mIMap, mOMap, and mOutputTracks.

Referenced by NyquistEffect::ProcessOne().

Here is the caller graph for this function:

Commit()

void EffectOutputTracks::Commit

(

)

Replace input tracks with temporaries only on commit.

Definition at line 103 of file EffectOutputTracks.cpp.

{
   if (!mOutputTracks) {
      // Already committed, violating precondition.  Maybe wrong intent...
      assert(false);
      // ... but harmless
      return;
   }
 
   size_t cnt = mOMap.size();
   size_t i = 0;
 
   while (!mOutputTracks->empty()) {
      const auto pOutputTrack = *mOutputTracks->begin();
 
      // If tracks were removed from mOutputTracks, then there will be
      // tracks in the map that must be removed from mTracks.
      while (i < cnt && mOMap[i] != pOutputTrack) {
         const auto t = mIMap[i];
         // Class invariant justifies the assertion
         assert(t);
         ++i;
         mTracks.Remove(*t);
      }
 
      // The output track, still in the list, must also have been placed in
      // the map
      assert(i < cnt);
 
      // Find the input track it corresponds to
      if (!mIMap[i])
         // This track was an addition to output tracks; add it to mTracks
         mTracks.AppendOne(std::move(*mOutputTracks));
      else if (
         mEffectType != EffectTypeNone && mEffectType != EffectTypeAnalyze)
         // Replace mTracks entry with the new track
         mTracks.ReplaceOne(*mIMap[i], std::move(*mOutputTracks));
      else
         // This output track was just a placeholder for pre-processing. Discard
         // it.
         mOutputTracks->Remove(*pOutputTrack);
      ++i;
   }
 
   // If tracks were removed from mOutputTracks, then there may be tracks
   // left at the end of the map that must be removed from mTracks.
   while (i < cnt) {
      const auto t = mIMap[i];
      // Class invariant justifies the assertion
      assert(t);
      ++i;
      mTracks.Remove(*t);
   }
 
   // Reset map
   mIMap.clear();
   mOMap.clear();
 
   // Make sure we processed everything
   assert(mOutputTracks->empty());
 
   // The output list is no longer needed
   mOutputTracks.reset();
   ++nEffectsDone;
}

References TrackList::AppendOne(), EffectTypeAnalyze, EffectTypeNone, mEffectType, mIMap, mOMap, mOutputTracks, mTracks, nEffectsDone, TrackList::Remove(), and TrackList::ReplaceOne().

Here is the call graph for this function:

Get()

TrackList & EffectOutputTracks::Get ( )

inline

Expose the output track list for iterations or even erasures.

Definition at line 80 of file EffectOutputTracks.h.

{ return *mOutputTracks; }

Referenced by NyquistEffect::ProcessOne().

Here is the caller graph for this function:

GetMatchingInput()

const Track * EffectOutputTracks::GetMatchingInput

(

const Track &

outTrack

)

const

Gets the matching input track for the given output track if it finds its match, else nullptr.

Definition at line 92 of file EffectOutputTracks.cpp.

{
   const auto it = std::find(mOMap.begin(), mOMap.end(), &outTrack);
   if (it == mOMap.end())
      return nullptr;
   const auto index = it - mOMap.begin();
   return mIMap[index];
}

References mIMap, and mOMap.

Referenced by NyquistEffect::ProcessOne().

Here is the caller graph for this function:

IncEffectCounter()

static void EffectOutputTracks::IncEffectCounter ( )

inlinestatic

Definition at line 33 of file EffectOutputTracks.h.

{ ++nEffectsDone; }

Referenced by SelectTracksCommand::Apply().

Here is the caller graph for this function:

Member Data Documentation

mEffectType

const EffectType EffectOutputTracks::mEffectType

private

Definition at line 84 of file EffectOutputTracks.h.

Referenced by Commit().

mIMap

std::vector<Track*> EffectOutputTracks::mIMap

private

Invariant

mIMap.size() == mOutputTracks->Size()

mIMap.size() == mOMap.size()

Definition at line 89 of file EffectOutputTracks.h.

Referenced by AddToOutputTracks(), Commit(), EffectOutputTracks(), and GetMatchingInput().

mOMap

std::vector<Track*> EffectOutputTracks::mOMap

private

Definition at line 90 of file EffectOutputTracks.h.

Referenced by AddToOutputTracks(), Commit(), EffectOutputTracks(), and GetMatchingInput().

mOutputTracks

std::shared_ptr<TrackList> EffectOutputTracks::mOutputTracks

private

Definition at line 91 of file EffectOutputTracks.h.

Referenced by AddToOutputTracks(), Commit(), and EffectOutputTracks().

mTracks

TrackList& EffectOutputTracks::mTracks

private

Definition at line 83 of file EffectOutputTracks.h.

Referenced by Commit(), and EffectOutputTracks().

nEffectsDone

int EffectOutputTracks::nEffectsDone = 0

static

Definition at line 32 of file EffectOutputTracks.h.

Referenced by Commit(), and NyquistEffect::Process().

---

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

• EffectOutputTracks.h
• EffectOutputTracks.cpp