WaveTrackUtilities Namespace Reference

Classes
class	AllClipsConstIterator
class	AllClipsIterator

Typedefs
using	SampleBlockID = long long
using	SampleBlockIDSet = std::unordered_set< SampleBlockID >
using	BlockVisitor = std::function< void(const std::shared_ptr< SampleBlock > &)>
using	BlockInspector = std::function< void(std::shared_ptr< const SampleBlock >)>
using	IntervalHolder = std::shared_ptr< WaveTrack::Interval >
using	IntervalHolders = std::vector< IntervalHolder >
using	IntervalConstHolder = std::shared_ptr< const WaveTrack::Interval >
using	ProgressReport = std::function< bool(double)>

Functions
IteratorRange< AllClipsIterator >	GetAllClips (WaveTrack &track)
IteratorRange< AllClipsConstIterator >	GetAllClips (const WaveTrack &track)
WAVE_TRACK_API bool	Reverse (WaveTrack &track, sampleCount start, sampleCount len, const ProgressReport &report={})
WAVE_TRACK_API sampleCount	GetSequenceSamplesCount (const WaveTrack &track)
WAVE_TRACK_API size_t	CountBlocks (const WaveTrack &track)
WAVE_TRACK_API void	CloseLock (WaveTrack &track) noexcept
	Should be called upon project close. Not balanced by unlocking calls. More...
WAVE_TRACK_API bool	RemoveCutLine (WaveTrack &track, double cutLinePosition)
	Remove cut line, without expanding the audio in it. More...
WAVE_TRACK_API void	ExpandCutLine (WaveTrack &track, double cutLinePosition, double *cutlineStart=nullptr, double *cutlineEnd=nullptr)
WAVE_TRACK_API bool	HasHiddenData (const WaveTrack &track)
	Whether any clips have hidden audio. More...
WAVE_TRACK_API void	DiscardTrimmed (WaveTrack &track)
	Remove hidden audio from all clips. More...
WAVE_TRACK_API void	VisitBlocks (TrackList &tracks, BlockVisitor visitor, SampleBlockIDSet *pIDs=nullptr)
WAVE_TRACK_API void	InspectBlocks (const TrackList &tracks, BlockInspector inspector, SampleBlockIDSet *pIDs=nullptr)
WAVE_TRACK_API WaveTrack::IntervalConstHolders	GetClipsIntersecting (const WaveTrack &track, double t0, double t1)
WAVE_TRACK_API void	ExpandClipTillNextOne (const WaveTrack &track, WaveTrack::Interval &interval)

Typedef Documentation

BlockInspector

using WaveTrackUtilities::BlockInspector = typedef std::function<void(std::shared_ptr<const SampleBlock>)>

Definition at line 37 of file WaveTrackUtilities.h.

BlockVisitor

using WaveTrackUtilities::BlockVisitor = typedef std::function<void(const std::shared_ptr<SampleBlock> &)>

Definition at line 35 of file WaveTrackUtilities.h.

IntervalConstHolder

using WaveTrackUtilities::IntervalConstHolder = typedef std::shared_ptr<const WaveTrack::Interval>

Definition at line 42 of file WaveTrackUtilities.h.

IntervalHolder

using WaveTrackUtilities::IntervalHolder = typedef std::shared_ptr<WaveTrack::Interval>

Definition at line 40 of file WaveTrackUtilities.h.

IntervalHolders

using WaveTrackUtilities::IntervalHolders = typedef std::vector<IntervalHolder>

Definition at line 41 of file WaveTrackUtilities.h.

ProgressReport

using WaveTrackUtilities::ProgressReport = typedef std::function<bool(double)>

Argument is in (0, 1)

Returns

true if processing should continue

Definition at line 128 of file WaveTrackUtilities.h.

SampleBlockID

using WaveTrackUtilities::SampleBlockID = typedef long long

Definition at line 33 of file WaveTrackUtilities.h.

SampleBlockIDSet

using WaveTrackUtilities::SampleBlockIDSet = typedef std::unordered_set<SampleBlockID>

Definition at line 34 of file WaveTrackUtilities.h.

Function Documentation

CloseLock()

void WaveTrackUtilities::CloseLock ( WaveTrack &  track )

noexcept

Should be called upon project close. Not balanced by unlocking calls.

Exception safety guarantee:

No-fail

Definition at line 286 of file WaveTrackUtilities.cpp.

{
   for (const auto &pClip : track.Intervals())
      pClip->CloseLock();
}

Referenced by ProjectFileManager::CompactProjectOnClose(), ProjectFileManager::DiscardAutosave(), and ProjectFileManager::OpenProjectFile().

Here is the caller graph for this function:

CountBlocks()

size_t WaveTrackUtilities::CountBlocks

(

const WaveTrack &

track

)

Returns

the total number of blocks in all underlying sequences of all clips, across all channels (including hidden audio but not counting the cutlines)

Definition at line 278 of file WaveTrackUtilities.cpp.

{
   size_t result{};
   for (const auto &pInterval : track.Intervals())
      result += pInterval->CountBlocks();
   return result;
}

References WaveTrack::Intervals().

Referenced by anonymous_namespace{EditMenus.cpp}::EstimateCopiedBlocks().

Here is the call graph for this function:

Here is the caller graph for this function:

DiscardTrimmed()

void WaveTrackUtilities::DiscardTrimmed

(

WaveTrack &

track

)

Remove hidden audio from all clips.

Definition at line 360 of file WaveTrackUtilities.cpp.

{
   for (const auto &pClip : track.Intervals()) {
      if (pClip->GetTrimLeft() != 0) {
         auto t0 = pClip->GetPlayStartTime();
         pClip->SetTrimLeft(0);
         pClip->ClearLeft(t0);
      }
      if (pClip->GetTrimRight() != 0) {
         auto t1 = pClip->GetPlayEndTime();
         pClip->SetTrimRight(0);
         pClip->ClearRight(t1);
      }
   }
}

References WaveTrack::Intervals().

Referenced by anonymous_namespace{EditMenus.cpp}::DuplicateDiscardTrimmed().

Here is the call graph for this function:

Here is the caller graph for this function:

ExpandClipTillNextOne()

void WaveTrackUtilities::ExpandClipTillNextOne	(	const WaveTrack &	track,
		WaveTrack::Interval &	interval
	)

Definition at line 416 of file WaveTrackUtilities.cpp.

{
   if (
      const auto nextClip =
         track.GetNextInterval(interval, PlaybackDirection::forward))
   {
      interval.StretchRightTo(nextClip->GetPlayStartTime());
   }
}

References forward, WaveTrack::GetNextInterval(), and WaveClip::StretchRightTo().

Referenced by PitchAndSpeedDialog::PopulateOrExchange().

Here is the call graph for this function:

Here is the caller graph for this function:

ExpandCutLine()

void WaveTrackUtilities::ExpandCutLine	(	WaveTrack &	track,
		double	cutLinePosition,
		double *	cutlineStart = nullptr,
		double *	cutlineEnd = nullptr
	)

Expand cut line (that is, re-insert audio, then delete audio saved in cut line)

Definition at line 305 of file WaveTrackUtilities.cpp.

{
   const bool editClipCanMove = GetEditClipsCanMove();
 
   // Find clip which contains this cut line
   double start = 0, end = 0;
   const auto &clips = track.Intervals();
   const auto pEnd = clips.end();
   const auto pClip = std::find_if(clips.begin(), pEnd,
      [&](const auto &clip) {
         return clip->FindCutLine(cutLinePosition, &start, &end); });
   if (pClip != pEnd) {
      auto &&clip = *pClip;
      if (!editClipCanMove) {
         // We are not allowed to move the other clips, so see if there
         // is enough room to expand the cut line
         for (const auto &clip2: clips)
            if (clip2->GetPlayStartTime() > clip->GetPlayStartTime() &&
                clip->GetPlayEndTime() + end - start > clip2->GetPlayStartTime())
               // Strong-guarantee in case of this path
               throw SimpleMessageBoxException{
                  ExceptionType::BadUserAction,
                  XO("There is not enough room available to expand the cut line"),
                  XO("Warning"),
                  "Error:_Insufficient_space_in_track"
               };
      }
 
      clip->ExpandCutLine(cutLinePosition);
 
      // Strong-guarantee provided that the following gives No-fail-guarantee
 
      if (cutlineStart)
         *cutlineStart = start;
      if (cutlineEnd)
         *cutlineEnd = end;
 
      // Move clips which are to the right of the cut line
      if (editClipCanMove)
         for (const auto &clip2 : clips)
            if (clip2->GetPlayStartTime() > clip->GetPlayStartTime())
               clip2->ShiftBy(end - start);
   }
}

References BadUserAction, details::end(), GetEditClipsCanMove(), WaveTrack::Intervals(), and XO().

Referenced by CutlineHandle::Click().

Here is the call graph for this function:

Here is the caller graph for this function:

GetAllClips() [1/2]

IteratorRange< AllClipsConstIterator > WaveTrackUtilities::GetAllClips ( const WaveTrack &  track )

inline

Definition at line 121 of file WaveTrackUtilities.h.

{
   return { AllClipsConstIterator{ track }, AllClipsConstIterator{} };
}

GetAllClips() [2/2]

IteratorRange< AllClipsIterator > WaveTrackUtilities::GetAllClips ( WaveTrack &  track )

inline

Definition at line 116 of file WaveTrackUtilities.h.

{
   return { AllClipsIterator{ track }, AllClipsIterator{} };
}

Referenced by VisitBlocks().

Here is the caller graph for this function:

GetClipsIntersecting()

WaveTrack::IntervalConstHolders WaveTrackUtilities::GetClipsIntersecting	(	const WaveTrack &	track,
		double	t0,
		double	t1
	)

Precondition

t0 <= t1

Definition at line 404 of file WaveTrackUtilities.cpp.

{
   assert(t0 <= t1);
   WaveTrack::IntervalConstHolders result;
   const auto &intervals = track.Intervals();
   copy_if(intervals.begin(), intervals.end(), back_inserter(result),
      [&](const auto &pClip){
         return pClip->IntersectsPlayRegion(t0, t1); });
   return result;
}

References WaveTrack::Intervals().

Referenced by WaveChannelSubView::GetMenuItems(), anonymous_namespace{EditMenus.cpp}::JoinClipsAvailableFlag(), and SelectActions::Handler::OnZeroCrossing().

Here is the call graph for this function:

Here is the caller graph for this function:

GetSequenceSamplesCount()

sampleCount WaveTrackUtilities::GetSequenceSamplesCount

(

const WaveTrack &

track

)

Returns

the total number of samples in all underlying sequences of all clips, across all channels (including hidden audio but not counting the cutlines)

Definition at line 270 of file WaveTrackUtilities.cpp.

{
   sampleCount result{ 0 };
   for (const auto &pInterval : track.Intervals())
      result += pInterval->GetSequenceSamplesCount();
   return result;
}

References WaveTrack::Intervals().

Referenced by anonymous_namespace{EditMenus.cpp}::EstimateCopyBytesCount(), FormatMenuTable::OnFormatChange(), and WaveClip::WriteXML().

Here is the call graph for this function:

Here is the caller graph for this function:

HasHiddenData()

bool WaveTrackUtilities::HasHiddenData

(

const WaveTrack &

track

)

Whether any clips have hidden audio.

Definition at line 352 of file WaveTrackUtilities.cpp.

{
   const auto &clips = track.Intervals();
   return std::any_of(clips.begin(), clips.end(), [](const auto &pClip){
      return pClip->GetTrimLeft() != 0 || pClip->GetTrimRight() != 0;
   });
}

References WaveTrack::Intervals().

Here is the call graph for this function:

InspectBlocks()

void WaveTrackUtilities::InspectBlocks	(	const TrackList &	tracks,
		BlockInspector	inspector,
		SampleBlockIDSet *	pIDs = nullptr
	)

Definition at line 397 of file WaveTrackUtilities.cpp.

{
   VisitBlocks(const_cast<TrackList &>(tracks), move(inspector), pIDs);
}

References tracks, and VisitBlocks().

Referenced by anonymous_namespace{HistoryWindow.cpp}::SpaceUsageCalculator::CalculateUsage(), ProjectFileIO::CopyTo(), EstimateRemovedBlocks(), ProjectFileIO::GetCurrentUsage(), ProjectFileIO::SaveProject(), and ProjectFileIO::ShouldCompact().

Here is the call graph for this function:

Here is the caller graph for this function:

RemoveCutLine()

bool WaveTrackUtilities::RemoveCutLine	(	WaveTrack &	track,
		double	cutLinePosition
	)

Remove cut line, without expanding the audio in it.

Definition at line 292 of file WaveTrackUtilities.cpp.

{
   bool removed = false;
   for (const auto &pClip : track.Intervals())
      if (pClip->RemoveCutLine(cutLinePosition)) {
         removed = true;
         break;
      }
   return removed;
}

References WaveTrack::Intervals().

Referenced by CutlineHandle::Click().

Here is the call graph for this function:

Here is the caller graph for this function:

Reverse()

bool WaveTrackUtilities::Reverse	(	WaveTrack &	track,
		sampleCount	start,
		sampleCount	len,
		const ProgressReport &	report = {}
	)

Definition at line 126 of file WaveTrackUtilities.cpp.

{
   bool rValue = true; // return value
 
   // start, end, len refer to the selected reverse region
   auto end = start + len;
 
   auto clipArray = track.SortedIntervalArray();
   const auto invariant = [&]{
      return std::is_sorted(clipArray.begin(), clipArray.end(),
         [](const auto &pA, const auto &pB){
            return pA->GetPlayStartTime() < pB->GetPlayEndTime();
         });
   };
   assert(invariant());
 
   // STEP 1:
   // If a reverse selection begins and/or ends at the inside of a clip
   // perform a split at the start and/or end of the reverse selection
   // Beware, the array grows as we loop over it, so don't use range-for
   for (size_t ii = 0; ii < clipArray.size(); ++ii) {
      const auto &clip = *clipArray[ii];
      auto clipStart = clip.GetPlayStartSample();
      auto clipEnd = clip.GetPlayEndSample();
      const auto splitAt = [&](double splitTime){
         auto [_, second] = track.SplitAt(splitTime);
         if (second)
            clipArray.insert(clipArray.begin() + ii + 1, second);
      };
      if (clipStart < start && clipEnd > start && clipEnd <= end) {
         // the reverse selection begins at the inside of a clip
         double splitTime = track.LongSamplesToTime(start);
         splitAt(splitTime);
      }
      else if (clipStart >= start && clipStart < end && clipEnd > end) {
         // the reverse selection ends at the inside of a clip
         double splitTime = track.LongSamplesToTime(end);
         splitAt(splitTime);
      }
      else if (clipStart < start && clipEnd > end) {
         // the selection begins AND ends at the inside of a clip
         double splitTime = track.LongSamplesToTime(end);
         splitAt(splitTime);
         splitTime = track.LongSamplesToTime(start);
         splitAt(splitTime);
      }
      assert(invariant());
   }
 
   //STEP 2:
   // Individually reverse each clip inside the selected region
   // and apply the appropriate offset after detaching them from the track
 
   bool checkedFirstClip = false;
 
   // used in calculating the offset of clips to rearrange
   // holds the new end position of the current clip
   auto currentEnd = end;
 
   // holds the reversed clips
   using IntervalHolders = WaveTrack::IntervalHolders;
   IntervalHolders revClips;
   // holds the clips that appear after the reverse selection region
   IntervalHolders otherClips;
   // Unlike in the previous iteration, clipArray is not inserted or
   // erased
   size_t i = 0;
   for (const auto &clip : clipArray) {
      Finally Do([&]{ ++i; });
      auto clipStart = clip->GetPlayStartSample();
      auto clipEnd = clip->GetPlayEndSample();
 
      if (clipStart >= start && clipEnd <= end) {
         // if the clip is inside the selected region
         // this is used to check if the selected region begins with a
         // whitespace.  If yes then clipStart (of the first clip) and start are
         // not the same.  Adjust currentEnd accordingly and set endMerge to
         // false
         if (!checkedFirstClip && clipStart > start) {
            checkedFirstClip = true;
            if (i > 0) {
               if (clipArray[i - 1]->GetPlayEndSample() <= start)
                  currentEnd -= (clipStart - start);
            }
            else
               currentEnd -= (clipStart - start);
         }
 
         auto revStart = std::max(clipStart, start);
         auto revEnd = std::min(end, clipEnd);
         auto revLen = revEnd - revStart;
         if (revEnd >= revStart) {
            // reverse the clip
            if (!ReverseOneClip(track, revStart, revLen, start, end, progress))
            {
               rValue = false;
               break;
            }
 
            // calculate the offset required
            auto clipOffsetStart = currentEnd - (clipEnd - clipStart);
            double offsetStartTime = track.LongSamplesToTime(clipOffsetStart);
            if (i + 1 < clipArray.size()) {
               // update currentEnd if there is a clip to process next
               auto nextClipStart = clipArray[i + 1]->GetPlayStartSample();
               currentEnd = currentEnd -
                  (clipEnd - clipStart) - (nextClipStart - clipEnd);
            }
 
            // detach the clip from track
            revClips.push_back(clip);
            track.RemoveInterval(clip);
            // align time to a sample and set offset
            revClips.back()->SetPlayStartTime(
               track.SnapToSample(offsetStartTime));
         }
      }
      else if (clipStart >= end) {
         // clip is after the selection region
         // simply remove and append to otherClips
         otherClips.push_back(clip);
         track.RemoveInterval(clip);
      }
   }
 
   // STEP 3: Append the clips from
   // revClips and otherClips back to the track
   // the last clip of revClips is appended to the track first
   // PRL:  I don't think that matters, the sequence of storage of clips in the
   // track is not elsewhere assumed to be by time
   for (auto it = revClips.rbegin(), revEnd = revClips.rend();
         it != revEnd; ++it)
      track.InsertInterval(*it, false);
 
   if (!rValue)
      return false;
 
   for (auto &clip : otherClips)
      track.InsertInterval(clip, false);
 
   return rValue;
}

References _, details::end(), WaveTrack::InsertInterval(), WideSampleSequence::LongSamplesToTime(), min(), WaveTrack::RemoveInterval(), anonymous_namespace{WaveTrackUtilities.cpp}::ReverseOneClip(), WideSampleSequence::SnapToSample(), WaveTrack::SortedIntervalArray(), and WaveTrack::SplitAt().

Referenced by Reverse::Process().

Here is the call graph for this function:

Here is the caller graph for this function:

VisitBlocks()

void WaveTrackUtilities::VisitBlocks	(	TrackList &	tracks,
		BlockVisitor	visitor,
		SampleBlockIDSet *	pIDs = nullptr
	)

Definition at line 376 of file WaveTrackUtilities.cpp.

{
   for (auto wt : tracks.Any<WaveTrack>())
      // Scan all clips within current track
      for (const auto &pClip : GetAllClips(*wt))
         // Scan all sample blocks within current clip
         for (const auto &pChannel : pClip->Channels()) {
            auto blocks = pChannel->GetSequenceBlockArray();
            for (const auto &block : *blocks) {
               auto &pBlock = block.sb;
               if (pBlock) {
                  if (pIDs && !pIDs->insert(pBlock->GetBlockID()).second)
                     continue;
                  if (visitor)
                     visitor(pBlock);
               }
            }
         }
}

References GetAllClips(), and tracks.

Referenced by InspectBlocks(), and audacity::cloud::audiocom::sync::LocalProjectSnapshot::ProjectBlocksLock::VisitBlocks().

Here is the call graph for this function:

Here is the caller graph for this function: