WaveTrackUtilities.h

Go to the documentation of this file.

/*  SPDX-License-Identifier: GPL-2.0-or-later */
/*!********************************************************************
 
  Audacity: A Digital Audio Editor
 
  WaveTrackUtilities.h
 
  Paul Licameli
 
  @brief Various operations on WaveTrack, needing only its public interface
 
**********************************************************************/
#ifndef __AUDACITY_WAVE_TRACK_UTILITIES__
#define __AUDACITY_WAVE_TRACK_UTILITIES__
 
#include "IteratorX.h"
#include "WaveTrack.h"
#include <unordered_set>
 
class SampleBlock;
class sampleCount;
class TrackList;
class WaveTrack;
 
#include <functional>
using ProgressReporter = std::function<void(double)>;
 
class SampleBlock;
class TrackList;
 
namespace WaveTrackUtilities {
 
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>;
 
 
class WAVE_TRACK_API AllClipsIterator : public ValueIterator<IntervalHolder>
{
public:
   // Constructs an "end" iterator
   AllClipsIterator() {}
 
   // Construct a "begin" iterator
   explicit AllClipsIterator(WaveTrack &track);
 
   value_type operator *() const;
 
   AllClipsIterator &operator ++();
 
   friend bool operator ==(
      const AllClipsIterator &a, const AllClipsIterator &b)
   { return a.mStack.empty() == b.mStack.empty(); }
 
   friend bool operator !=(
      const AllClipsIterator &a, const AllClipsIterator &b)
   { return !(a == b); }
 
private:
   using Stack = std::vector<std::pair<IntervalHolders, size_t>>;
   void Push(IntervalHolders clips);
 
   WaveTrack *mpTrack{};
   Stack mStack;
};
 
 
class WAVE_TRACK_API AllClipsConstIterator
   : public ValueIterator<IntervalConstHolder>
{
public:
   // Constructs an "end" iterator
   AllClipsConstIterator() {}
 
   // Construct a "begin" iterator
   explicit AllClipsConstIterator(const WaveTrack &track)
      : mIter{ const_cast<WaveTrack&>(track) }
   {}
 
   value_type operator *() const { return *mIter; }
 
   AllClipsConstIterator &operator ++()
   { ++mIter; return *this; }
 
   friend bool operator ==(
      const AllClipsConstIterator &a, const AllClipsConstIterator &b)
   { return a.mIter == b.mIter; }
 
   friend bool operator !=(
      const AllClipsConstIterator &a, const AllClipsConstIterator &b)
   { return !(a == b); }
 
private:
   AllClipsIterator mIter;
};
 
inline IteratorRange<AllClipsIterator> GetAllClips(WaveTrack &track)
{
   return { AllClipsIterator{ track }, AllClipsIterator{} };
}
 
inline IteratorRange<AllClipsConstIterator> GetAllClips(const WaveTrack &track)
{
   return { AllClipsConstIterator{ track }, AllClipsConstIterator{} };
}
 
using ProgressReport = std::function<bool(double)>;
 
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;
 
/*
 @return whether any cutline existed at the position and was removed
 */
WAVE_TRACK_API bool RemoveCutLine(WaveTrack &track, double cutLinePosition);
 
/*
 @param[out] cutlineStart start time of the insertion
 @param[out] cutlineEnd end time of the insertion
 */
WAVE_TRACK_API void ExpandCutLine(WaveTrack &track, double cutLinePosition,
   double* cutlineStart = nullptr, double* cutlineEnd = nullptr);
 
WAVE_TRACK_API bool HasHiddenData(const WaveTrack &track);
 
WAVE_TRACK_API void DiscardTrimmed(WaveTrack &track);
 
// Function to visit all sample blocks from a list of tracks.
// If a set is supplied, then only visit once each unique block ID not already
// in that set, and accumulate those into the set as a side-effect.
// The visitor function may be null.
WAVE_TRACK_API void VisitBlocks(TrackList &tracks, BlockVisitor visitor,
   SampleBlockIDSet *pIDs = nullptr);
 
// Non-mutating version of the above
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);
} // namespace WaveTrackUtilities
 
#endif