A Track that contains audio waveform data. More...

#include <WaveTrack.h>

Inheritance diagram for WaveTrack:

Collaboration diagram for WaveTrack:

Classes
class	AllClipsConstIterator

class	AllClipsIterator

class	Interval

struct	Region
	Structure to hold region of a wavetrack and a comparison function for sortability. More...

Public Types
using	Regions = std::vector< Region >

using	Holder = std::shared_ptr< WaveTrack >

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

using	IntervalHolder = std::shared_ptr< Interval >

using	IntervalConstHolder = std::shared_ptr< const Interval >

Public Types inherited from Track
using	AttachedObjects = ::AttachedTrackObjects
	Alias for my base type. More...

using	Holder = std::shared_ptr< Track >

Public Types inherited from ClientData::Site< Host, ClientData, ObjectCopyingPolicy, Pointer, ObjectLockingPolicy, RegistryLockingPolicy >
using	DataType = ClientData

using	DataPointer = Pointer< ClientData >

using	DataFactory = std::function< DataPointer(Host &) >
	Type of function from which RegisteredFactory is constructed; it builds attachments. More...

Public Types inherited from ChannelGroup
enum class	LinkType : int { None = 0 , Group = 2 , Aligned }
	For two tracks describes the type of the linkage. More...

using	Attachments = ClientData::Site< ChannelGroupData, ClientData::Cloneable<>, ClientData::DeepCopying >

using	Interval = WideChannelGroupInterval

Public Types inherited from Channel
using	Interval = ChannelInterval

Public Member Functions
	WaveTrack (const SampleBlockFactoryPtr &pFactory, sampleFormat format, double rate)

	WaveTrack (const WaveTrack &orig, ProtectedCreationArg &&)
	Copied only in WaveTrack::Clone() ! More...

size_t	GetWidth () const
	The width of every WaveClip in this track; for now always 1. More...

size_t	NChannels () const override
	May report more than one only when this is a leader track. More...

auto	GetChannel (size_t iChannel)

auto	GetChannel (size_t iChannel) const

auto	Channels ()

auto	Channels () const

AudioGraph::ChannelType	GetChannelType () const override
	Classify this channel. More...

void	Reinit (const WaveTrack &orig)

virtual	~WaveTrack ()

void	MoveTo (double o) override

bool	LinkConsistencyFix (bool doFix) override
	Check consistency of channel groups, and maybe fix it. More...

double	GetStartTime () const override
	Implement WideSampleSequence. More...

double	GetEndTime () const override
	Implement WideSampleSequence. More...

double	GetRate () const override

void	SetRate (double newRate)

float	GetGain () const

void	SetGain (float newGain)

float	GetPan () const

void	SetPan (float newPan)

float	GetChannelGain (int channel) const override
	Takes gain and pan into account. More...

int	GetWaveColorIndex () const

void	SetWaveColorIndex (int colorIndex)

sampleCount	GetVisibleSampleCount () const

sampleCount	GetSequenceSamplesCount () const

size_t	CountBlocks () const

sampleFormat	GetSampleFormat () const override

void	ConvertToSampleFormat (sampleFormat format, const std::function< void(size_t)> &progressReport={})

TrackListHolder	Cut (double t0, double t1) override
	Create tracks and modify this track. More...

Holder	EmptyCopy (const SampleBlockFactoryPtr &pFactory={}, bool keepLink=true) const

TrackListHolder	WideEmptyCopy (const SampleBlockFactoryPtr &pFactory={}, bool keepLink=true) const

TrackListHolder	MonoToStereo ()

TrackListHolder	Copy (double t0, double t1, bool forClipboard=true) const override
	Create new tracks and don't modify this track. More...

void	Clear (double t0, double t1) override

void	Paste (double t0, const Track &src) override

void	ClearAndPaste (double t0, double t1, const WaveTrack &src, bool preserve=true, bool merge=true, const TimeWarper *effectWarper=nullptr, bool clearByTrimming=false)

void	ClearAndPaste (double t0, double t1, const TrackList &src, bool preserve=true, bool merge=true, const TimeWarper *effectWarper=nullptr)

void	Silence (double t0, double t1, ProgressReporter reportProgress) override

void	InsertSilence (double t, double len) override

void	Split (double t0, double t1)

void	ClearAndAddCutLine (double t0, double t1)

TrackListHolder	SplitCut (double t0, double t1)

void	SplitDelete (double t0, double t1)

void	Join (double t0, double t1, const ProgressReporter &reportProgress)

void	Disjoin (double t0, double t1)

void	Trim (double t0, double t1)

void	ApplyStretchRatio (std::optional< TimeInterval > interval, ProgressReporter reportProgress)

void	SyncLockAdjust (double oldT1, double newT1) override

bool	IsEmpty (double t0, double t1) const
	Returns true if there are no WaveClips in the specified region. More...

bool	Append (constSamplePtr buffer, sampleFormat format, size_t len, unsigned int stride=1, sampleFormat effectiveFormat=widestSampleFormat, size_t iChannel=0) override

void	Flush () override

bool	IsLeader () const override

bool	DoGet (size_t iChannel, size_t nBuffers, const samplePtr buffers[], sampleFormat format, sampleCount start, size_t len, bool backwards, fillFormat fill=FillFormat::fillZero, bool mayThrow=true, sampleCount *pNumWithinClips=nullptr) const override
	This fails if any clip overlapping the range has non-unit stretch ratio! More...

std::pair< size_t, size_t >	GetFloatsCenteredAroundTime (double t, size_t iChannel, float *buffer, size_t numSideSamples, bool mayThrow) const
	Gets as many samples as it can, but no more than `2 * numSideSamples + 1`, centered around `t`. Reads nothing if `GetClipAtTime(t) == nullptr`. Useful to access samples across clip boundaries, as it spreads the read to adjacent clips, i.e., not separated by silence from clip at `t`. More...

bool	GetFloatAtTime (double t, size_t iChannel, float &value, bool mayThrow) const

void	SetFloatsCenteredAroundTime (double t, size_t iChannel, const float *buffer, size_t numSideSamples, sampleFormat effectiveFormat)
	Similar to GetFloatsCenteredAroundTime, but for writing. Sets as many samples as it can according to the same rules as GetFloatsCenteredAroundTime. Leaves the other samples untouched. More...

void	SetFloatAtTime (double t, size_t iChannel, float value, sampleFormat effectiveFormat)
	Sets sample nearest to `t` to `value`. Silently fails if `GetClipAtTime(t) == nullptr`. More...

void	SetFloatsWithinTimeRange (double t0, double t1, size_t iChannel, const std::function< float(double sampleTime)> &producer, sampleFormat effectiveFormat)
	Provides a means of setting clip values as a function of time. Included are closest sample to t0 up to closest sample to t1, exclusively. If the given interval is empty, i.e., `t0 >= t1`, no action is taken. More...

ChannelGroupSampleView	GetSampleView (double t0, double t1, bool mayThrow=true) const
	Request samples within [t0, t1), not knowing in advance how many this will be. More...

sampleFormat	WidestEffectiveFormat () const override

bool	HasTrivialEnvelope () const override

void	GetEnvelopeValues (double *buffer, size_t bufferLen, double t0, bool backwards) const override

Envelope *	GetEnvelopeAtTime (double time)

const WaveClip *	GetClipAtTime (double time) const

WaveClip *	GetClipAtTime (double time)

WaveClipConstHolders	GetClipsIntersecting (double t0, double t1) const

const WaveClip *	GetNextClip (const WaveClip &clip, PlaybackDirection searchDirection) const
	Returns clips next to `clip` in the given direction, or `nullptr` if there is none. More...

WaveClip *	GetNextClip (const WaveClip &clip, PlaybackDirection searchDirection)
	Returns clips next to `clip` in the given direction, or `nullptr` if there is none. More...

const WaveClip *	GetAdjacentClip (const WaveClip &clip, PlaybackDirection searchDirection) const
	Similar to GetNextClip, but returns `nullptr` if the neighbour clip is not adjacent. More...

WaveClip *	GetAdjacentClip (const WaveClip &clip, PlaybackDirection searchDirection)
	Similar to GetNextClip, but returns `nullptr` if the neighbour clip is not adjacent. More...

size_t	GetBestBlockSize (sampleCount t) const

size_t	GetMaxBlockSize () const

size_t	GetIdealBlockSize ()

bool	HandleXMLTag (const std::string_view &tag, const AttributesList &attrs) override

void	HandleXMLEndTag (const std::string_view &tag) override

XMLTagHandler *	HandleXMLChild (const std::string_view &tag) override

void	WriteXML (XMLWriter &xmlFile) const override

std::optional< TranslatableString >	GetErrorOpening () const override

bool	CloseLock () noexcept
	Should be called upon project close. Not balanced by unlocking calls. More...

WaveClipHolders &	GetClips ()

const WaveClipConstHolders &	GetClips () const

const WaveClip *	GetLeftmostClip () const

const WaveClip *	GetRightmostClip () const

ClipConstHolders	GetClipInterfaces () const
	Get access to the (visible) clips in the tracks, in unspecified order. More...

IteratorRange< AllClipsIterator >	GetAllClips ()

IteratorRange< AllClipsConstIterator >	GetAllClips () const

void	CreateWideClip (double offset=.0, const wxString &name=wxEmptyString)

WaveClip *	CreateClip (double offset=.0, const wxString &name=wxEmptyString)
	Create new clip and add it to this track. More...

WaveClip *	NewestOrNewClip ()
	Get access to the most recently added clip, or create a clip, if there is not already one. THIS IS NOT NECESSARILY RIGHTMOST. More...

WaveClip *	RightmostOrNewClip ()
	Get access to the last (rightmost) clip, or create a clip, if there is not already one. More...

int	GetClipIndex (const WaveClip *clip) const

WaveClip *	GetClipByIndex (int index)
	Get the nth clip in this WaveTrack (will return nullptr if not found). More...

const WaveClip *	GetClipByIndex (int index) const
	Get the nth clip in this WaveTrack (will return nullptr if not found). More...

int	GetNumClips () const

int	GetNumClips (double t0, double t1) const

WaveClipPointers	SortedClipArray ()

WaveClipConstPointers	SortedClipArray () const

bool	HasHiddenData () const
	Whether any clips have hidden audio. More...

void	DiscardTrimmed ()
	Remove hidden audio from all clips. More...

bool	CanOffsetClips (const std::vector< WaveClip * > &clips, double amount, double *allowedAmount=nullptr)
	Decide whether the clips could be offset (and inserted) together without overlapping other clips. More...

bool	CanInsertClip (const WaveClip &clip, double &slideBy, double tolerance) const

std::shared_ptr< WaveClip >	RemoveAndReturnClip (WaveClip *clip)

bool	AddClip (const std::shared_ptr< WaveClip > &clip)

bool	MergeClips (int clipidx1, int clipidx2)

void	ExpandCutLine (double cutLinePosition, double cutlineStart=nullptr, double cutlineEnd=nullptr)

bool	RemoveCutLine (double cutLinePosition)
	Remove cut line, without expanding the audio in it. More...

void	Resample (int rate, BasicUI::ProgressDialog *progress=NULL)

bool	Reverse (sampleCount start, sampleCount len, const ProgressReport &report={})

const TypeInfo &	GetTypeInfo () const override

IntervalConstHolder	GetNextInterval (const Interval &interval, PlaybackDirection searchDirection) const

IntervalHolder	GetNextInterval (const Interval &interval, PlaybackDirection searchDirection)

IntervalHolder	GetIntervalAtTime (double t)

auto	Intervals ()

auto	Intervals () const

Track::Holder	PasteInto (AudacityProject &project, TrackList &list) const override

const WaveClip *	FindClipByName (const wxString &name) const
	Returns nullptr if clip with such name was not found. More...

size_t	NIntervals () const override
	used only during deserialization More...

void	SetLegacyFormat (sampleFormat format)

void	CopyClipEnvelopes ()

bool	GetFloats (float buffer, sampleCount start, size_t len, fillFormat fill=FillFormat::fillZero, bool mayThrow=true, sampleCount pNumWithinClips=nullptr) const
	"narrow" overload fetches first channel only More...

bool	GetFloats (size_t iChannel, size_t nBuffers, float const buffers[], sampleCount start, size_t len, bool backwards=false, fillFormat fill=FillFormat::fillZero, bool mayThrow=true, sampleCount pNumWithinClips=nullptr) const

virtual void	Paste (double t, const Track &src)=0
	Weak precondition allows overrides to replicate one channel into many. More...

void	Paste (double t, const TrackList &src)

PlayableSequence implementation
const ChannelGroup *	FindChannelGroup () const override
	Find associated ChannelGroup if any. More...

bool	GetMute () const override
	May vary asynchronously. More...

bool	GetSolo () const override
	May vary asynchronously. More...

Public Member Functions inherited from WritableSampleTrack
	WritableSampleTrack ()

	WritableSampleTrack (const WritableSampleTrack &other, ProtectedCreationArg &&)

	~WritableSampleTrack () override

const TypeInfo &	GetTypeInfo () const override

bool	IsLeader () const override

virtual size_t	NChannels () const=0
	Report the number of channels. More...

virtual double	GetRate () const=0

Public Member Functions inherited from SampleTrack
	SampleTrack ()

	SampleTrack (const SampleTrack &other, ProtectedCreationArg &&)

	~SampleTrack () override

const TypeInfo &	GetTypeInfo () const override

virtual sampleFormat	GetSampleFormat () const =0

bool	GetFloats (float buffer, sampleCount start, size_t len, fillFormat fill=FillFormat::fillZero, bool mayThrow=true, sampleCount pNumWithinClips=nullptr) const
	"narrow" overload fetches first channel only More...

double	GetStartTime () const
	Get the minimum of Start() values of intervals, or 0 when none. More...

double	GetEndTime () const
	Get the maximum of End() values of intervals, or 0 when none. More...

bool	IsLeader () const override

bool	GetFloats (size_t iChannel, size_t nBuffers, float const buffers[], sampleCount start, size_t len, bool backwards=false, fillFormat fill=FillFormat::fillZero, bool mayThrow=true, sampleCount pNumWithinClips=nullptr) const

Public Member Functions inherited from PlayableTrack
	PlayableTrack ()

	PlayableTrack (const PlayableTrack &orig, ProtectedCreationArg &&)

bool	GetMute () const

bool	GetSolo () const

bool	GetNotMute () const

bool	GetNotSolo () const

void	SetMute (bool m)

void	SetSolo (bool s)

void	WriteXMLAttributes (XMLWriter &xmlFile) const

bool	HandleXMLAttribute (const std::string_view &attr, const XMLAttributeValueView &value)

Public Member Functions inherited from AudioTrack
	AudioTrack ()

	AudioTrack (const Track &orig, ProtectedCreationArg &&a)

void	WriteXMLAttributes (XMLWriter &WXUNUSED(xmlFile)) const

bool	HandleXMLAttribute (const std::string_view &, const XMLAttributeValueView &)

Public Member Functions inherited from Track
TrackId	GetId () const

template<typename Subclass = Track>
std::shared_ptr< Subclass >	SharedPointer ()

template<typename Subclass = const Track>
auto	SharedPointer () const -> std::enable_if_t< std::is_const_v< Subclass >, std::shared_ptr< Subclass > >

std::shared_ptr< Track >	SubstitutePendingChangedTrack ()

std::shared_ptr< const Track >	SubstitutePendingChangedTrack () const

std::shared_ptr< const Track >	SubstituteOriginalTrack () const

virtual const TypeInfo &	GetTypeInfo () const =0

virtual const TypeNames &	GetTypeNames () const

virtual bool	SupportsBasicEditing () const
	Whether this track type implements cut-copy-paste; by default, true. More...

virtual Holder	PasteInto (AudacityProject &project, TrackList &list) const =0

virtual bool	LinkConsistencyFix (bool doFix=true)
	Check consistency of channel groups, and maybe fix it. More...

bool	LinkConsistencyCheck ()
	Do the non-mutating part of consistency fix only and return status. More...

bool	HasOwner () const

std::shared_ptr< TrackList >	GetOwner () const

TrackList *	GetHolder () const

LinkType	GetLinkType () const noexcept

ChannelGroupData &	GetGroupData ()

const ChannelGroupData &	GetGroupData () const
	May make group data on demand, but consider that logically const. More...

	Track ()

	Track (const Track &orig, ProtectedCreationArg &&)

Track &	operator= (const Track &orig)=delete

virtual	~Track ()

void	Init (const Track &orig)

virtual TrackListHolder	Duplicate () const
	public nonvirtual duplication function that invokes Clone() More...

const wxString &	GetName () const
	Name is always the same for all channels of a group. More...

void	SetName (const wxString &n)

bool	GetSelected () const
	Selectedness is always the same for all channels of a group. More...

virtual void	SetSelected (bool s)

void	OnProjectTempoChange (double newTempo)
	method to set project tempo on track More...

virtual TrackListHolder	Cut (double t0, double t1)=0
	Create tracks and modify this track. More...

virtual TrackListHolder	Copy (double t0, double t1, bool forClipboard=true) const =0
	Create new tracks and don't modify this track. More...

virtual void	Clear (double t0, double t1)=0

virtual void	Paste (double t, const Track &src)=0
	Weak precondition allows overrides to replicate one channel into many. More...

void	Paste (double t, const TrackList &src)

virtual void	SyncLockAdjust (double oldT1, double newT1)

virtual void	Silence (double t0, double t1, ProgressReporter reportProgress={})=0

virtual void	InsertSilence (double t, double len)=0

bool	SameKindAs (const Track &track) const

template<typename R = void, typename ... Functions>
R	TypeSwitch (const Functions &...functions)

template<typename R = void, typename ... Functions>
R	TypeSwitch (const Functions &...functions) const

virtual void	WriteXML (XMLWriter &xmlFile) const =0

virtual std::optional< TranslatableString >	GetErrorOpening () const

void	Notify (bool allChannels, int code=-1)

bool	Any () const

bool	IsSelected () const

bool	IsLeader () const override

bool	IsSelectedLeader () const

void	AdjustPositions ()

void	WriteCommonXMLAttributes (XMLWriter &xmlFile, bool includeNameAndSelected=true) const

bool	HandleCommonXMLAttribute (const std::string_view &attr, const XMLAttributeValueView &valueView)

const std::optional< double > &	GetProjectTempo () const

Public Member Functions inherited from XMLTagHandler
	XMLTagHandler ()

virtual	~XMLTagHandler ()

virtual bool	HandleXMLTag (const std::string_view &tag, const AttributesList &attrs)=0

virtual void	HandleXMLEndTag (const std::string_view &WXUNUSED(tag))

virtual void	HandleXMLContent (const std::string_view &WXUNUSED(content))

virtual XMLTagHandler *	HandleXMLChild (const std::string_view &tag)=0

void	ReadXMLEndTag (const char *tag)

void	ReadXMLContent (const char *s, int len)

XMLTagHandler *	ReadXMLChild (const char *tag)

Public Member Functions inherited from ClientData::Site< Host, ClientData, ObjectCopyingPolicy, Pointer, ObjectLockingPolicy, RegistryLockingPolicy >
	~Site ()

	Site ()

	Site (const Site &other)

Site &	operator= (const Site &other)

	Site (Site &&other)

Site &	operator= (Site &&other)

size_t	size () const
	How many attachment pointers are in the Site. More...

template<typename Subclass = ClientData>
Subclass &	Get (const RegisteredFactory &key)
	Get reference to an attachment, creating on demand if not present, down-cast it to Subclass. More...

template<typename Subclass = const ClientData>
auto	Get (const RegisteredFactory &key) const -> std::enable_if_t< std::is_const< Subclass >::value, Subclass & >
	Get reference to an attachment, creating on demand if not present, down-cast it to Subclass. More...

template<typename Subclass = ClientData>
Subclass *	Find (const RegisteredFactory &key)
	Get a (bare) pointer to an attachment, or null, down-cast it to Subclass *; will not create on demand. More...

template<typename Subclass = const ClientData>
auto	Find (const RegisteredFactory &key) const -> std::enable_if_t< std::is_const< Subclass >::value, Subclass * >
	Get a (bare) pointer to an attachment, or null, down-cast it to Subclass *; will not create on demand. More...

template<typename ReplacementPointer >
void	Assign (const RegisteredFactory &key, ReplacementPointer &&replacement)
	Reassign Site's pointer to ClientData. More...

Public Member Functions inherited from ChannelGroup
virtual	~ChannelGroup ()

double	GetStartTime () const
	Get the minimum of Start() values of intervals, or 0 when none. More...

double	GetEndTime () const
	Get the maximum of End() values of intervals, or 0 when none. More...

void	ShiftBy (double t)
	Change start time by given duration. More...

virtual void	MoveTo (double o)=0
	Change start time to given time point. More...

virtual bool	IsLeader () const =0

ChannelGroupData &	GetGroupData ()
	Make attachment site on demand as needed. More...

const ChannelGroupData &	GetGroupData () const

ChannelGroupData *	FindGroupData ()
	Do not make attachment site on demand if absent. More...

const ChannelGroupData *	FindGroupData () const
	Do not make attachment site on demand if absent. More...

void	Init (const ChannelGroup &other)
	Copy, including cloning of attached objects. More...

void	DestroyGroupData ()
	Leave all attachments null. More...

std::unique_ptr< ChannelGroupData >	DetachGroupData ()
	Move attachments out. More...

void	AssignGroupData (std::unique_ptr< ChannelGroupData > pGroupData)
	Replace any previous attachments. More...

template<typename ChannelType = Channel>
std::shared_ptr< ChannelType >	GetChannel (size_t iChannel)
	Retrieve a channel, cast to the given type. More...

template<typename ChannelType = const Channel>
auto	GetChannel (size_t iChannel) const -> std::enable_if_t< std::is_const_v< ChannelType >, std::shared_ptr< ChannelType > >

template<typename ChannelType = Channel>
IteratorRange< ChannelIterator< ChannelType > >	Channels ()
	Get range of channels with mutative access. More...

template<typename ChannelType = const Channel>
auto	Channels () const -> std::enable_if_t< std::is_const_v< ChannelType >, IteratorRange< ChannelIterator< ChannelType > > >
	Get range of channels with read-only access. More...

template<typename IntervalType = Interval>
std::shared_ptr< IntervalType >	GetInterval (size_t iInterval)
	Retrieve an interval, cast to the given type. More...

template<typename IntervalType = const Interval>
auto	GetInterval (size_t iInterval) const -> std::enable_if_t< std::is_const_v< IntervalType >, std::shared_ptr< IntervalType > >

template<typename IntervalType = Interval>
IteratorRange< IntervalIterator< IntervalType > >	Intervals ()
	Get range of intervals with mutative access. More...

template<typename IntervalType = const Interval>
auto	Intervals () const -> std::enable_if_t< std::is_const_v< IntervalType >, IteratorRange< IntervalIterator< IntervalType > > >
	Get range of intervals with read-only access. More...

Public Member Functions inherited from PlayableSequence
	~PlayableSequence () override

virtual const ChannelGroup *	FindChannelGroup () const =0
	Find associated ChannelGroup if any. More...

virtual bool	GetSolo () const =0
	May vary asynchronously. More...

virtual bool	GetMute () const =0
	May vary asynchronously. More...

Public Member Functions inherited from WideSampleSequence
virtual	~WideSampleSequence ()

virtual size_t	NChannels () const =0
	A constant property. More...

virtual float	GetChannelGain (int channel) const =0

bool	GetFloats (size_t iChannel, size_t nBuffers, float const buffers[], sampleCount start, size_t len, bool backwards=false, fillFormat fill=FillFormat::fillZero, bool mayThrow=true, sampleCount pNumWithinClips=nullptr) const

virtual bool	DoGet (size_t iChannel, size_t nBuffers, const samplePtr buffers[], sampleFormat format, sampleCount start, size_t len, bool backward, fillFormat fill=FillFormat::fillZero, bool mayThrow=true, sampleCount *pNumWithinClips=nullptr) const =0

virtual double	GetStartTime () const =0

virtual double	GetEndTime () const =0

virtual double	GetRate () const =0

sampleCount	TimeToLongSamples (double t0) const

double	LongSamplesToTime (sampleCount pos) const

double	SnapToSample (double t) const

virtual sampleFormat	WidestEffectiveFormat () const =0

virtual bool	HasTrivialEnvelope () const =0

virtual void	GetEnvelopeValues (double *buffer, size_t bufferLen, double t0, bool backwards) const =0

Public Member Functions inherited from AudioGraph::Channel
virtual	~Channel ()

virtual ChannelType	GetChannelType () const =0
	Classify this channel. More...

Public Member Functions inherited from RecordableSequence
virtual	~RecordableSequence ()

virtual sampleFormat	GetSampleFormat () const =0

virtual double	GetRate () const =0

virtual size_t	NChannels () const =0
	A constant property. More...

virtual bool	Append (constSamplePtr buffer, sampleFormat format, size_t len, unsigned int stride, sampleFormat effectiveFormat, size_t iChannel=0)=0
	Append the sample data to the track. You must call Flush() after the last Append. More...

bool	Append (constSamplePtr buffer, sampleFormat format, size_t len, size_t iChannel=0)

virtual bool	IsLeader () const =0

virtual void	Flush ()=0
	Flush of related leader must be called after last Append. More...

virtual void	InsertSilence (double t, double len)=0

Public Member Functions inherited from WaveChannel
	~WaveChannel () override

WaveTrack &	GetTrack ()

const WaveTrack &	GetTrack () const

auto	GetInterval (size_t iInterval)

auto	GetInterval (size_t iInterval) const

auto	Intervals ()

auto	Intervals () const

bool	GetFloats (float buffer, sampleCount start, size_t len, fillFormat fill=FillFormat::fillZero, bool mayThrow=true, sampleCount pNumWithinClips=nullptr) const
	"narrow" overload fetches from the unique channel More...

ChannelSampleView	GetSampleView (double t0, double t1, bool mayThrow) const
	Request channel samples within [t0, t1), not knowing in advance how many this will be. More...

bool	Set (constSamplePtr buffer, sampleFormat format, sampleCount start, size_t len, sampleFormat effectiveFormat=widestSampleFormat)
	Random-access assignment of a range of samples. More...

bool	AppendBuffer (constSamplePtr buffer, sampleFormat format, size_t len, unsigned stride, sampleFormat effectiveFormat)

bool	Append (constSamplePtr buffer, sampleFormat format, size_t len)

std::pair< float, float >	GetMinMax (double t0, double t1, bool mayThrow=true) const

float	GetRMS (double t0, double t1, bool mayThrow=true) const
	Get root-mean-square. More...

size_t	GetBestBlockSize (sampleCount t) const
	A hint for sizing of well aligned fetches. More...

size_t	GetIdealBlockSize ()
	A hint for sizing of well aligned fetches. More...

size_t	GetMaxBlockSize () const

bool	GetFloats (size_t iChannel, size_t nBuffers, float const buffers[], sampleCount start, size_t len, bool backwards=false, fillFormat fill=FillFormat::fillZero, bool mayThrow=true, sampleCount pNumWithinClips=nullptr) const

Public Member Functions inherited from Channel
virtual	~Channel ()

ChannelGroup &	GetChannelGroup ()
	Channel object's lifetime is assumed to be nested in its Track's. More...

const ChannelGroup &	GetChannelGroup () const
	Channel object's lifetime is assumed to be nested in its Track's. More...

size_t	GetChannelIndex () const

size_t	ReallyGetChannelIndex () const

size_t	NIntervals () const
	Report the number of intervals. More...

template<typename IntervalType = Interval>
std::shared_ptr< IntervalType >	GetInterval (size_t iInterval)
	Retrieve an interval, cast to the given type. More...

template<typename IntervalType = const Interval>
auto	GetInterval (size_t iInterval) const -> std::enable_if_t< std::is_const_v< IntervalType >, std::shared_ptr< IntervalType > >

template<typename IntervalType = Interval>
IteratorRange< IntervalIterator< IntervalType > >	Intervals ()
	Get range of intervals with mutative access. More...

template<typename IntervalType = const Interval>
auto	Intervals () const -> std::enable_if_t< std::is_const_v< IntervalType >, IteratorRange< IntervalIterator< IntervalType > > >
	Get range of intervals with read-only access. More...

Static Public Member Functions
static wxString	GetDefaultAudioTrackNamePreference ()

static double	ProjectNyquistFrequency (const AudacityProject &project)

static WaveTrack *	New (AudacityProject &project)

static const TypeInfo &	ClassTypeInfo ()

Static Public Member Functions inherited from WritableSampleTrack
static const TypeInfo &	ClassTypeInfo ()

Static Public Member Functions inherited from SampleTrack
static const TypeInfo &	ClassTypeInfo ()

Static Public Member Functions inherited from PlayableTrack
static const TypeInfo &	ClassTypeInfo ()

Static Public Member Functions inherited from AudioTrack
static const TypeInfo &	ClassTypeInfo ()

Static Public Member Functions inherited from Track
template<typename Subclass = Track>
static std::shared_ptr< Subclass >	SharedPointer (Track *pTrack)

template<typename Subclass = const Track>
static std::shared_ptr< Subclass >	SharedPointer (const Track *pTrack)

static const TypeInfo &	ClassTypeInfo ()

Static Public Member Functions inherited from ClientData::Site< Host, ClientData, ObjectCopyingPolicy, Pointer, ObjectLockingPolicy, RegistryLockingPolicy >
static size_t	numFactories ()
	How many static factories have been registered with this specialization of Site. More...

Private Member Functions
void	Init (const WaveTrack &orig)

TrackListHolder	Clone () const override

wxString	MakeClipCopyName (const wxString &originalName) const

wxString	MakeNewClipName () const

void	FlushOne ()

void	HandleClear (double t0, double t1, bool addCutLines, bool split, bool clearByTrimming=false)

void	ClearAndPasteAtSameTempo (double t0, double t1, const WaveTrack &src, bool preserve, bool merge, const TimeWarper *effectWarper, bool clearByTrimming)

void	SplitAt (double t)

void	ExpandOneCutLine (double cutLinePosition, double cutlineStart, double cutlineEnd)

bool	MergeOneClipPair (int clipidx1, int clipidx2)

void	ApplyStretchRatioOnIntervals (const std::vector< IntervalHolder > &intervals, const ProgressReporter &reportProgress)

void	InsertInterval (const IntervalHolder &interval)

void	RemoveInterval (const IntervalHolder &interval)

void	ReplaceInterval (const IntervalHolder &oldOne, const IntervalHolder &newOne)

std::shared_ptr< WideChannelGroupInterval >	DoGetInterval (size_t iInterval) override
	Retrieve an interval. More...

std::shared_ptr<::Channel >	DoGetChannel (size_t iChannel) override
	Retrieve a channel. More...

ChannelGroup &	DoGetChannelGroup () const override
	Subclass must override. More...

ChannelGroup &	ReallyDoGetChannelGroup () const override
	This is temporary! It defaults to call the above. More...

void	DoSetRate (double newRate)

void	SetClipRates (double newRate)

void	DoOnProjectTempoChange (const std::optional< double > &oldTempo, double newTempo) override

TrackListHolder	DuplicateWithOtherTempo (double newTempo, WaveTrack *&leader) const

bool	GetOne (samplePtr buffer, sampleFormat format, sampleCount start, size_t len, bool backwards, fillFormat fill, bool mayThrow, sampleCount *pNumWithinClips) const

size_t	GetFloatsFromTime (double t, size_t iChannel, float *buffer, size_t numSamples, bool mayThrow, PlaybackDirection direction) const
	Helper for GetFloatsCenteredAroundTime. If `direction == PlaybackDirection::Backward`, fetches samples to the left of `t`, excluding `t`, without reversing. More...

void	SetFloatsFromTime (double t, size_t iChannel, const float *buffer, size_t numSamples, sampleFormat effectiveFormat, PlaybackDirection direction)
	Similar to GetFloatsFromTime, but for writing. Sets as many samples as it can according to the same rules as GetFloatsFromTime. Leaves the other samples untouched. More...

void	DoSetPan (float value)

void	DoSetGain (float value)

void	PasteWaveTrack (double t0, const WaveTrack &other, bool merge)

void	PasteWaveTrackAtSameTempo (double t0, const WaveTrack &other, bool merge)

bool	RateConsistencyCheck () const
	Whether all clips of a leader track have a common rate. More...

bool	FormatConsistencyCheck () const
	Whether all tracks in group and all clips have a common sample format. More...

bool	InsertClip (WaveClipHolder clip)

void	ApplyStretchRatioOne (double t0, double t1, const ProgressReporter &reportProgress)

Static Private Member Functions
static void	ClearAndPasteOne (WaveTrack &track, double t0, double t1, double startTime, double endTime, const WaveTrack &src, bool preserve, bool merge, const TimeWarper *effectWarper, bool clearByTrimming)

static void	JoinOne (WaveTrack &track, double t0, double t1)

static Holder	CopyOne (const WaveTrack &track, double t0, double t1, bool forClipboard)

static void	WriteOneXML (const WaveTrack &track, XMLWriter &xmlFile, size_t iChannel, size_t nChannels)

static bool	ReverseOne (WaveTrack &track, sampleCount start, sampleCount len, const ProgressReport &report={})

static bool	ReverseOneClip (WaveTrack &track, sampleCount start, sampleCount len, sampleCount originalStart, sampleCount originalEnd, const ProgressReport &report={})

static void	PasteOne (WaveTrack &track, double t0, const WaveTrack &other, double startTime, double insertDuration, bool merge=true)

Private Attributes
WaveClipHolders	mClips

int	mLegacyRate { 0 }
	used only during deserialization More...

sampleFormat	mLegacyFormat { undefinedSample }
	used only during deserialization More...

SampleBlockFactoryPtr	mpFactory

wxCriticalSection	mFlushCriticalSection

wxCriticalSection	mAppendCriticalSection

double	mLegacyProjectFileOffset

friend	WaveChannel

Friends
class	WaveTrackFactory

Additional Inherited Members
Protected Member Functions inherited from PlayableTrack
bool	DoGetMute () const

void	DoSetMute (bool value)

bool	DoGetSolo () const

void	DoSetSolo (bool value)

Protected Member Functions inherited from Track
void	SetLinkType (LinkType linkType, bool completeList=true)

virtual void	DoOnProjectTempoChange (const std::optional< double > &oldTempo, double newTempo)=0

Protected Member Functions inherited from ClientData::Site< Host, ClientData, ObjectCopyingPolicy, Pointer, ObjectLockingPolicy, RegistryLockingPolicy >
template<typename Function >
void	ForEach (const Function &function)
	Invoke function on each ClientData object that has been created in `this`. More...

template<typename Function >
void	ForEach (const Function &function) const
	Invoke function on each ClientData object that has been created in `this`. More...

template<typename Function >
ClientData *	FindIf (const Function &function)
	Return pointer to first attachment in `this` that is not null and satisfies a predicate, or nullptr. More...

template<typename Function >
const ClientData *	FindIf (const Function &function) const
	Return pointer to first attachment in `this` that is not null and satisfies a predicate, or nullptr. More...

void	BuildAll ()
	For each RegisteredFactory, if the corresponding attachment is absent in `this`, build and store it. More...

virtual std::shared_ptr< Channel >	DoGetChannel (size_t iChannel)=0
	Retrieve a channel. More...

virtual std::shared_ptr< Interval >	DoGetInterval (size_t iInterval)=0
	Retrieve an interval. More...

virtual ChannelGroup &	DoGetChannelGroup () const =0
	Subclass must override. More...

virtual ChannelGroup &	ReallyDoGetChannelGroup () const
	This is temporary! It defaults to call the above. More...

Protected Attributes inherited from Track
std::weak_ptr< TrackList >	mList

TrackNodePointer	mNode {}
	Holds iterator to self, so that TrackList::Find can be constant-time. More...

int	mIndex
	0-based position of this track in its TrackList More...

Detailed Description

A Track that contains audio waveform data.

Definition at line 218 of file WaveTrack.h.

Member Typedef Documentation

◆ Holder

using WaveTrack::Holder = std::shared_ptr<WaveTrack>

Definition at line 298 of file WaveTrack.h.

◆ IntervalConstHolder

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

Definition at line 1012 of file WaveTrack.h.

◆ IntervalHolder

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

Definition at line 1011 of file WaveTrack.h.

◆ ProgressReport

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

Argument is in (0, 1)

Returns: true if processing should continue

Definition at line 915 of file WaveTrack.h.

◆ Regions

using WaveTrack::Regions = std::vector < Region >

Definition at line 243 of file WaveTrack.h.

Constructor & Destructor Documentation

◆ WaveTrack() [1/2]

WaveTrack::WaveTrack	(	const SampleBlockFactoryPtr &	pFactory,
		sampleFormat	format,
		double	rate
	)

Definition at line 776 of file WaveTrack.cpp.

   : mpFactory(pFactory)
{
   mLegacyProjectFileOffset = 0;
 
   WaveTrackData::Get(*this).SetSampleFormat(format);
   DoSetRate(static_cast<int>(rate));
}

References DoSetRate(), anonymous_namespace{ExportPCM.cpp}::format, BasicUI::Get(), and mLegacyProjectFileOffset.

Here is the call graph for this function:

◆ WaveTrack() [2/2]

WaveTrack::WaveTrack	(	const WaveTrack &	orig,
		ProtectedCreationArg &&	a
	)

Copied only in WaveTrack::Clone() !

Definition at line 786 of file WaveTrack.cpp.

   : WritableSampleTrack(orig, std::move(a))
   , mpFactory( orig.mpFactory )
{
   mLegacyProjectFileOffset = 0;
   for (const auto &clip : orig.mClips)
      InsertClip(std::make_shared<WaveClip>(*clip, mpFactory, true));
}

References InsertClip(), mClips, mLegacyProjectFileOffset, and mpFactory.

Here is the call graph for this function:

◆ ~WaveTrack()

WaveTrack::~WaveTrack ( )

virtual

Definition at line 840 of file WaveTrack.cpp.

841{

842}

Member Function Documentation

◆ AddClip()

bool WaveTrack::AddClip ( const std::shared_ptr< WaveClip > & clip )

Append a clip to the track; to succeed, must have the same block factory as this track, and this->GetWidth() == clip->GetWidth(); return success

Precondition: clip != nullptr; this->GetWidth() == clip->GetWidth()

Definition at line 1892 of file WaveTrack.cpp.

{
   assert(clip);
   if (clip->GetSequence(0)->GetFactory() != this->mpFactory)
      return false;
 
   if (clip->GetWidth() != GetWidth())
      return false;
 
   // Uncomment the following line after we correct the problem of zero-length clips
   //if (CanInsertClip(clip))
   InsertClip(clip); // transfer ownership
 
   return true;
}

References GetWidth(), and InsertClip().

Referenced by ClearAndPasteOne(), and ReverseOne().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Append()

bool WaveTrack::Append	(	constSamplePtr	buffer,
		sampleFormat	format,
		size_t	len,
		unsigned int	stride = `1`,
		sampleFormat	effectiveFormat = `widestSampleFormat`,
		size_t	iChannel = `0`
	)

overridevirtual

If there is an existing WaveClip in the WaveTrack, then the data are appended to that clip. If there are no WaveClips in the track, then a new one is created.

Returns: true if at least one complete block was created

Exception safety guarantee:: Partial – Some prefix (maybe none) of the buffer is appended, and no content already flushed to disk is lost.

Implements RecordableSequence.

Definition at line 2665 of file WaveTrack.cpp.

{
   // TODO wide wave tracks -- there will be only one clip, and its `Append`
   // (or an overload) must take iChannel
   auto pTrack = this;
   if (GetOwner() && iChannel == 1)
      pTrack = *TrackList::Channels(this).rbegin();
   constSamplePtr buffers[]{ buffer };
   return pTrack->RightmostOrNewClip()
      ->Append(buffers, format, len, stride, effectiveFormat);
}

References TrackList::Channels(), anonymous_namespace{ExportPCM.cpp}::format, Track::GetOwner(), and anonymous_namespace{StretchingSequenceIntegrationTest.cpp}::iChannel.

Referenced by WaveChannel::Append(), and WaveChannel::AppendBuffer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ApplyStretchRatio()

void WaveTrack::ApplyStretchRatio	(	std::optional< TimeInterval >	interval,
		ProgressReporter	reportProgress
	)

Definition at line 2351 of file WaveTrack.cpp.

{
   assert(IsLeader());
   // Assert that the interval is reasonable, but this function will be no-op
   // anyway if not
   assert(!interval.has_value() ||
          interval->first <= interval->second);
   if (GetNumClips() == 0)
      return;
   const auto startTime =
      interval ? std::max(SnapToSample(interval->first), GetStartTime()) :
                 GetStartTime();
   const auto endTime =
      interval ? std::min(SnapToSample(interval->second), GetEndTime()) :
                 GetEndTime();
   if (startTime >= endTime)
      return;
 
   // Here we assume that left- and right clips are aligned.
   if (auto clipAtT0 = GetClipAtTime(startTime);
       clipAtT0 && clipAtT0->SplitsPlayRegion(startTime) &&
       !clipAtT0->StretchRatioEquals(1))
      Split(startTime, startTime);
   if (auto clipAtT1 = GetClipAtTime(endTime);
       clipAtT1 && clipAtT1->SplitsPlayRegion(endTime) &&
       !clipAtT1->StretchRatioEquals(1))
      Split(endTime, endTime);
 
   std::vector<IntervalHolder> srcIntervals;
   auto clip = GetIntervalAtTime(startTime);
   while (clip && clip->GetPlayStartTime() < endTime)
   {
      if (clip->GetStretchRatio() != 1)
         srcIntervals.push_back(clip);
      clip = GetNextInterval(*clip, PlaybackDirection::forward);
   }
 
   ApplyStretchRatioOnIntervals(srcIntervals, reportProgress);
}

References ApplyStretchRatioOnIntervals(), forward, GetClipAtTime(), GetEndTime(), GetIntervalAtTime(), GetNextInterval(), GetNumClips(), GetStartTime(), IsLeader(), min(), WideSampleSequence::SnapToSample(), Split(), and WaveClip::SplitsPlayRegion().

Referenced by Silence().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ApplyStretchRatioOne()

void WaveTrack::ApplyStretchRatioOne	(	double	t0,
		double	t1,
		const ProgressReporter &	reportProgress
	)

private

◆ ApplyStretchRatioOnIntervals()

void WaveTrack::ApplyStretchRatioOnIntervals	(	const std::vector< IntervalHolder > &	intervals,
		const ProgressReporter &	reportProgress
	)

private

Definition at line 4099 of file WaveTrack.cpp.

{
   std::vector<IntervalHolder> dstIntervals;
   dstIntervals.reserve(srcIntervals.size());
   std::transform(
      srcIntervals.begin(), srcIntervals.end(),
      std::back_inserter(dstIntervals), [&](const IntervalHolder& interval) {
         return interval->GetStretchRenderedCopy(
            reportProgress, *this, mpFactory, GetSampleFormat());
      });
 
   // If we reach this point it means that no error was thrown - we can replace
   // the source with the destination intervals.
   for (auto i = 0; i < srcIntervals.size(); ++i)
      ReplaceInterval(srcIntervals[i], dstIntervals[i]);
}

References ReplaceInterval().

Referenced by ApplyStretchRatio(), and Join().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CanInsertClip()

bool WaveTrack::CanInsertClip	(	const WaveClip &	clip,
		double &	slideBy,
		double	tolerance
	)		const

Definition at line 3910 of file WaveTrack.cpp.

{
   if (mClips.empty())
      return true;
   // Find clip in this that overlaps most with `clip`:
   const auto candidateClipStartTime = candidateClip.GetPlayStartTime();
   const auto candidateClipEndTime = candidateClip.GetPlayEndTime();
   const auto t0 = SnapToSample(candidateClipStartTime + slideBy);
   const auto t1 = SnapToSample(candidateClipEndTime + slideBy);
   std::vector<double> overlaps;
   std::transform(
      mClips.begin(), mClips.end(), std::back_inserter(overlaps),
      [&](const auto& pClip) {
         return pClip->IntersectsPlayRegion(t0, t1) ?
                   std::min(pClip->GetPlayEndTime(), t1) -
                      std::max(pClip->GetPlayStartTime(), t0) :
                   0.0;
      });
   const auto maxOverlap = std::max_element(overlaps.begin(), overlaps.end());
   if (*maxOverlap > tolerance)
      return false;
   const auto overlappedClip =
      mClips[std::distance(overlaps.begin(), maxOverlap)];
   const auto requiredOffset =  slideBy +
             *maxOverlap * (overlappedClip->GetPlayStartTime() < t0 ? 1 : -1);
   // Brute-force check to see if there's another clip that'd be in the way.
   if (std::any_of(
          mClips.begin(), mClips.end(),
          [&](const auto& pClip)
          {
             const auto result = pClip->IntersectsPlayRegion(
                SnapToSample(candidateClipStartTime + requiredOffset),
                SnapToSample(candidateClipEndTime + requiredOffset));
             return result;
          }))
      return false;
   slideBy = requiredOffset;
   return true;
}

References WaveClip::GetPlayEndTime(), WaveClip::GetPlayStartTime(), mClips, and WideSampleSequence::SnapToSample().

Here is the call graph for this function:

◆ CanOffsetClips()

bool WaveTrack::CanOffsetClips	(	const std::vector< WaveClip * > &	clips,
		double	amount,
		double *	allowedAmount = `nullptr`
	)

Decide whether the clips could be offset (and inserted) together without overlapping other clips.

Returns: true if possible to offset by (allowedAmount ? *allowedAmount : amount)

Parameters

	clips	not necessarily in this track
	amount	signed
[out]	allowedAmount	if null, test exact amount only; else, largest (in magnitude) possible offset with same sign

Definition at line 3852 of file WaveTrack.cpp.

{
   if (allowedAmount)
      *allowedAmount = amount;
 
   const auto &moving = [&](WaveClip *clip){
      // linear search might be improved, but expecting few moving clips
      // compared with the fixed clips
      return clips.end() != std::find( clips.begin(), clips.end(), clip );
   };
 
   for (const auto &c: mClips) {
      if ( moving( c.get() ) )
         continue;
      for (const auto clip : clips) {
         if (c->GetPlayStartTime() < clip->GetPlayEndTime() + amount &&
            c->GetPlayEndTime() > clip->GetPlayStartTime() + amount)
         {
            if (!allowedAmount)
               return false; // clips overlap
 
            if (amount > 0)
            {
               if (c->GetPlayStartTime() - clip->GetPlayEndTime() < *allowedAmount)
                  *allowedAmount = c->GetPlayStartTime() - clip->GetPlayEndTime();
               if (*allowedAmount < 0)
                  *allowedAmount = 0;
            } else
            {
               if (c->GetPlayEndTime() - clip->GetPlayStartTime() > *allowedAmount)
                  *allowedAmount = c->GetPlayEndTime() - clip->GetPlayStartTime();
               if (*allowedAmount > 0)
                  *allowedAmount = 0;
            }
         }
      }
   }
 
   if (allowedAmount)
   {
      if (*allowedAmount == amount)
         return true;
 
      // Check if the NEW calculated amount would not violate
      // any other constraint
      if (!CanOffsetClips(clips, *allowedAmount, nullptr)) {
         *allowedAmount = 0; // play safe and don't allow anything
         return false;
      }
      else
         return true;
   } else
      return true;
}

References CanOffsetClips(), and mClips.

Referenced by CanOffsetClips().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Channels() [1/2]

auto WaveTrack::Channels ( )

inline

Definition at line 272 of file WaveTrack.h.

272 {

273 return this->ChannelGroup::Channels<WaveChannel>(); }

Referenced by EffectTruncSilence::Analyze(), CompareAudioCommand::Apply(), EffectTruncSilence::DoRemoval(), GetSampleView(), EffectLoudness::LoadBufferBlock(), PerTrackEffect::ProcessPass(), SetRate(), and EffectLoudness::StoreBufferBlock().

Here is the caller graph for this function:

◆ Channels() [2/2]

auto WaveTrack::Channels ( ) const

inline

Definition at line 274 of file WaveTrack.h.

274 {

275 return this->ChannelGroup::Channels<const WaveChannel>(); }

◆ ClassTypeInfo()

auto WaveTrack::ClassTypeInfo ( )

static

Definition at line 956 of file WaveTrack.cpp.

{
   return typeInfo();
}

References typeInfo().

Here is the call graph for this function:

◆ Clear()

void WaveTrack::Clear	(	double	t0,
		double	t1
	)

overridevirtual

Exception safety guarantee:: Strong

Implements Track.

Definition at line 1436 of file WaveTrack.cpp.

{
   assert(IsLeader());
   for (const auto pChannel : TrackList::Channels(this))
      pChannel->HandleClear(t0, t1, false, false);
}

References TrackList::Channels(), and IsLeader().

Referenced by Cut(), EffectTruncSilence::DoRemoval(), anonymous_namespace{LabelMenus.cpp}::OnCutLabels(), TrackSpectrumTransformer::PostProcess(), EffectStereoToMono::ProcessOne(), SyncLockAdjust(), and Trim().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ClearAndAddCutLine()

void WaveTrack::ClearAndAddCutLine	(	double	t0,
		double	t1
	)

May assume precondition: t0 <= t1

Precondition: IsLeader()

Exception safety guarantee:: Strong

Definition at line 1444 of file WaveTrack.cpp.

{
   assert(IsLeader());
   for (const auto pChannel : TrackList::Channels(this))
      pChannel->HandleClear(t0, t1, true, false);
}

References TrackList::Channels(), and IsLeader().

Referenced by anonymous_namespace{LabelMenus.cpp}::OnCutLabels().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ClearAndPaste() [1/2]

void WaveTrack::ClearAndPaste	(	double	t0,
		double	t1,
		const TrackList &	src,
		bool	preserve = `true`,
		bool	merge = `true`,
		const TimeWarper *	effectWarper = `nullptr`
	)

inline

Overload that takes a TrackList and passes its first wave track

Precondition: **src.Any<const WaveTrack>().begin() satisfies preconditions of the other overload for src

Definition at line 434 of file WaveTrack.h.

   {
      ClearAndPaste(t0, t1, **src.Any<const WaveTrack>().begin(),
         preserve, merge, effectWarper);
   }

References TrackList::Any().

Here is the call graph for this function:

◆ ClearAndPaste() [2/2]

void WaveTrack::ClearAndPaste	(	double	t0,
		double	t1,
		const WaveTrack &	src,
		bool	preserve = `true`,
		bool	merge = `true`,
		const TimeWarper *	effectWarper = `nullptr`,
		bool	clearByTrimming = `false`
	)

May assume precondition: t0 <= t1 If the source has one channel and this has more, then replicate source

Precondition: IsLeader(); src.IsLeader(); src.NChannels() == 1 || src.NChannels() == NChannels()

Exception safety guarantee:: Weak – This WaveTrack remains destructible in case of AudacityException. But some of its cutline clips may have been destroyed.

Definition at line 1498 of file WaveTrack.cpp.

{
   // Get a modifiable copy of `src` because it may come from another project
   // with different tempo, making boundary queries incorrect.
   const auto& tempo = GetProjectTempo();
   if (!tempo.has_value())
      THROW_INCONSISTENCY_EXCEPTION;
   WaveTrack* copy;
   const auto copyHolder = src.DuplicateWithOtherTempo(*tempo, copy);
   ClearAndPasteAtSameTempo(
      t0, t1, *copy, preserve, merge, effectWarper, clearByTrimming);
}

References ClearAndPasteAtSameTempo(), staffpad::vo::copy(), DuplicateWithOtherTempo(), Track::GetProjectTempo(), and THROW_INCONSISTENCY_EXCEPTION.

Referenced by EffectSBSMS::Finalize(), anonymous_namespace{EditMenus.cpp}::OnPaste(), and EffectNoiseRemoval::ProcessOne().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ClearAndPasteAtSameTempo()

void WaveTrack::ClearAndPasteAtSameTempo	(	double	t0,
		double	t1,
		const WaveTrack &	src,
		bool	preserve,
		bool	merge,
		const TimeWarper *	effectWarper,
		bool	clearByTrimming
	)

private

Definition at line 1518 of file WaveTrack.cpp.

{
   const auto srcNChannels = src.NChannels();
   assert(IsLeader());
   assert(src.IsLeader());
   assert(srcNChannels == 1 || srcNChannels == NChannels());
   assert(
      GetProjectTempo().has_value() &&
      GetProjectTempo() == src.GetProjectTempo());
 
   t0 = SnapToSample(t0);
   t1 = SnapToSample(t1);
 
   const auto startTime = src.GetStartTime();
   const auto endTime = src.GetEndTime();
   double dur = std::min(t1 - t0, endTime);
 
   // If duration is 0, then it's just a plain paste
   if (dur == 0.0) {
      // use Weak-guarantee
      PasteWaveTrack(t0, src, merge);
      return;
   }
 
   auto iter = TrackList::Channels(&src).begin();
   const auto myChannels = TrackList::Channels(this);
   for (const auto pChannel : myChannels) {
      ClearAndPasteOne(
         *pChannel, t0, t1, startTime, endTime, **iter, preserve, merge,
         effectWarper, clearByTrimming);
      if (srcNChannels > 1)
         ++iter;
   }
}

References TrackList::Channels(), ClearAndPasteOne(), GetEndTime(), Track::GetProjectTempo(), GetStartTime(), IsLeader(), min(), NChannels(), PasteWaveTrack(), and WideSampleSequence::SnapToSample().

Referenced by ClearAndPaste().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ClearAndPasteOne()

void WaveTrack::ClearAndPasteOne	(	WaveTrack &	track,
		double	t0,
		double	t1,
		double	startTime,
		double	endTime,
		const WaveTrack &	src,
		bool	preserve,
		bool	merge,
		const TimeWarper *	effectWarper,
		bool	clearByTrimming
	)

staticprivate

Definition at line 1555 of file WaveTrack.cpp.

{
   const auto pFactory = track.mpFactory;
 
   std::vector<SplitInfo> splits;
   WaveClipHolders cuts;
 
   //helper routine, that finds SplitInfo by time value,
   //or creates a new one if no one exists yet
   auto get_split = [&](double time) {
      auto it = std::find_if(splits.begin(), splits.end(),
         [time](const SplitInfo& split) { return split.time == time; });
      if(it == splits.end())
         it = splits.insert(
            splits.end(),
            { time, nullptr, nullptr, std::nullopt, std::nullopt }
         );
      return it;
   };
 
   // If provided time warper was NULL, use a default one that does nothing
   IdentityTimeWarper localWarper;
   const TimeWarper *warper = (effectWarper ? effectWarper : &localWarper);
 
   const auto roundTime = [&track](double t){
      return track.SnapToSample(t);
   };
 
   // Align to a sample
   t0 = roundTime(t0);
   t1 = roundTime(t1);
 
   // Save the cut/split lines whether preserving or not since merging
   // needs to know if a clip boundary is being crossed since Paste()
   // will add split lines around the pasted clip if so.
   for (const auto &clip : track.mClips) {
      double st;
 
      // Remember clip boundaries as locations to split
      // we need to copy clips, trims and names, because the original ones
      // could be changed later during Clear/Paste routines
      st = roundTime(clip->GetPlayStartTime());
      if (st >= t0 && st <= t1) {
         auto it = get_split(st);
         if (clip->GetTrimLeft() != 0) {
            //keep only hidden left part
            it->right = std::make_shared<WaveClip>(*clip, pFactory, false);
            it->right->SetTrimLeft(.0);
            it->right->ClearRight(clip->GetPlayStartTime());
         }
         it->rightClipName = clip->GetName();
      }
 
      st = roundTime(clip->GetPlayEndTime());
      if (st >= t0 && st <= t1) {
         auto it = get_split(st);
         if (clip->GetTrimRight() != 0) {
            //keep only hidden right part
            it->left = std::make_shared<WaveClip>(*clip, pFactory, false);
            it->left->SetTrimRight(.0);
            it->left->ClearLeft(clip->GetPlayEndTime());
         }
         it->leftClipName = clip->GetName();
      }
 
      // Search for cut lines
      auto &cutlines = clip->GetCutLines();
      // May erase from cutlines, so don't use range-for
      for (auto it = cutlines.begin(); it != cutlines.end(); ) {
         WaveClip *cut = it->get();
         const double cs = roundTime(
            clip->GetSequenceStartTime() + cut->GetSequenceStartTime());
 
         // Remember cut point
         if (cs >= t0 && cs <= t1) {
            // Remember the absolute offset and add to our cuts array.
            cut->SetSequenceStartTime(cs);
            cuts.push_back(std::move(*it)); // transfer ownership!
            it = cutlines.erase(it);
         }
         else
            ++it;
      }
   }
 
   const auto tolerance = 2.0 / track.GetRate();
 
   // This is not a split-cut operation.
   constexpr auto split = false;
 
   // Now, clear the selection
   track.HandleClear(t0, t1, false, split, clearByTrimming);
 
   // And paste in the new data
   PasteOne(track, t0, src, startTime, endTime, merge);
 
   // First, merge the new clip(s) in with the existing clips
   if (merge && splits.size() > 0) {
      {
         // Now t1 represents the absolute end of the pasted data.
         t1 = t0 + endTime;
 
         // Get a sorted array of the clips
         auto clips = track.SortedClipArray();
 
         // Scan the sorted clips for the first clip whose start time
         // exceeds the pasted regions end time.
         {
            WaveClip *prev = nullptr;
            for (const auto clip : clips) {
               // Merge this clip and the previous clip if the end time
               // falls within it and this isn't the first clip in the track.
               if (fabs(t1 - clip->GetPlayStartTime()) < tolerance) {
                  if (prev && clip->HasEqualStretchRatio(*prev))
                     track.MergeOneClipPair(track.GetClipIndex(prev),
                        track.GetClipIndex(clip));
                  break;
               }
               prev = clip;
            }
         }
      }
 
      {
         // Refill the array since clips have changed.
         auto clips = track.SortedClipArray();
 
         // Scan the sorted clips to look for the start of the pasted
         // region.
         WaveClip *prev = nullptr;
         for (const auto clip : clips) {
            if (prev) {
               // It must be that clip is what was pasted and it begins where
               // prev ends.
               // use Weak-guarantee
               if (clip->HasEqualStretchRatio(*prev))
                  track.MergeOneClipPair(
                     track.GetClipIndex(prev), track.GetClipIndex(clip));
               break;
            }
            if (fabs(t0 - clip->GetPlayEndTime()) < tolerance)
               // Merge this clip and the next clip if the start time
               // falls within it and this isn't the last clip in the track.
               prev = clip;
            else
               prev = nullptr;
         }
      }
   }
 
   // Restore cut/split lines
   if (preserve) {
      auto attachLeft = [](WaveClip& target, WaveClip& src) {
         // What this lambda does is restoring the left hidden data of `target`
         // that was cleared by `HandleClear`. Hence, `target` has no left
         // hidden data at this stage.
         assert(target.GetTrimLeft() == 0);
         if (target.GetTrimLeft() != 0)
            return;
 
         // `src` was created by copy from `target`, so they have equal width
         // and stretch ratio.
         assert(target.GetWidth() == src.GetWidth());
         assert(target.GetStretchRatio() == src.GetStretchRatio());
 
         auto trim = src.GetPlayEndTime() - src.GetPlayStartTime();
         auto success = target.Paste(target.GetPlayStartTime(), src);
         assert(success); // because of precondition above
         target.SetTrimLeft(trim);
         //Play start time needs to be adjusted after
         //prepending data to the sequence
         target.ShiftBy(-trim);
      };
 
      auto attachRight = [](WaveClip &target, WaveClip &src)
      {
         // See `attachLeft` for rationale behind these asserts.
         assert(target.GetTrimRight() == 0);
         if (target.GetTrimRight() != 0)
            return;
         assert(target.GetWidth() == src.GetWidth());
         assert(target.GetStretchRatio() == src.GetStretchRatio());
 
         auto trim = src.GetPlayEndTime() - src.GetPlayStartTime();
         auto success = target.Paste(target.GetPlayEndTime(), src);
         assert(success); // because of precondition above
         target.SetTrimRight(trim);
      };
 
      // Restore the split lines and trims, transforming the position appropriately
      for (const auto& split: splits) {
         auto at = roundTime(warper->Warp(split.time));
         for (const auto& clip : track.GetClips()) {
            // Clips in split began as copies of a clip in the track,
            // therefore have the same width, satisfying preconditions to
            // attach
            if (clip->SplitsPlayRegion(at))//strictly inside
            {
               auto newClip =
                  std::make_shared<WaveClip>(*clip, pFactory, true);
 
               clip->ClearRight(at);
               newClip->ClearLeft(at);
               if (split.left)
                  // clip was cleared right
                  attachRight(*clip, *split.left);
               if (split.right)
                  // new clip was cleared left
                  attachLeft(*newClip, *split.right);
               bool success = track.AddClip(std::move(newClip));
               assert(success); // copied clip has same width and factory
               break;
            }
            else if (clip->GetPlayStartSample() ==
               track.TimeToLongSamples(at) && split.right) {
               // Satisfy the precondition of attachLeft first!
               const auto trim = clip->GetTrimLeft();
               const auto seqStartTime = clip->GetSequenceStartTime();
               clip->Clear(seqStartTime, seqStartTime + trim);
               // This clearing, although only removing the hidden part, moved
               // the clip leftwards. We don't want this in this case.
               clip->ShiftBy(trim);
               attachLeft(*clip, *split.right);
               break;
            }
            else if (clip->GetPlayEndSample() ==
               track.TimeToLongSamples(at) && split.left) {
               // Satisfy the precondition of attachRight first!
               clip->Clear(
                  clip->GetPlayEndTime(), clip->GetSequenceEndTime());
               attachRight(*clip, *split.left);
               break;
            }
         }
      }
 
      //Restore clip names
      for (const auto& split : splits)
      {
         auto s = track.TimeToLongSamples(warper->Warp(split.time));
         for (auto& clip : track.GetClips()) {
            if (split.rightClipName.has_value() && clip->GetPlayStartSample() == s)
               clip->SetName(*split.rightClipName);
            else if (split.leftClipName.has_value() && clip->GetPlayEndSample() == s)
               clip->SetName(*split.leftClipName);
         }
      }
 
      // Restore the saved cut lines, also transforming if time altered
      for (const auto &clip : track.mClips) {
         double st;
         double et;
 
         st = clip->GetPlayStartTime();
         et = clip->GetPlayEndTime();
 
         // Scan the cuts for any that live within this clip
         for (auto it = cuts.begin(); it != cuts.end();) {
            WaveClip *cut = it->get();
            //cutlines in this array were orphaned previously
            double cs = cut->GetSequenceStartTime();
 
            // Offset the cut from the start of the clip and add it to
            // this clips cutlines.
            if (cs >= st && cs <= et) {
               cut->SetSequenceStartTime(warper->Warp(cs) - st);
               clip->GetCutLines().push_back( std::move(*it) ); // transfer ownership!
               it = cuts.erase(it);
            }
            else
               ++it;
         }
      }
   }
}

References AddClip(), GetClipIndex(), GetClips(), WaveClip::GetPlayEndTime(), WaveClip::GetPlayStartTime(), GetRate(), WaveClip::GetSequenceStartTime(), WaveClip::GetStretchRatio(), WaveClip::GetTrimLeft(), WaveClip::GetTrimRight(), GetWidth(), WaveClip::GetWidth(), HandleClear(), WaveClip::HasEqualStretchRatio(), mClips, MergeOneClipPair(), mpFactory, WaveClip::Paste(), PasteOne(), WaveClip::SetSequenceStartTime(), WaveClip::SetTrimLeft(), WaveClip::SetTrimRight(), WaveClip::ShiftBy(), WideSampleSequence::SnapToSample(), SortedClipArray(), WideSampleSequence::TimeToLongSamples(), and TimeWarper::Warp().

Referenced by ClearAndPasteAtSameTempo().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Clone()

TrackListHolder WaveTrack::Clone ( ) const

overrideprivatevirtual

Subclass responsibility implements only a part of Duplicate(), copying the track data proper (not associated data such as for groups and views)

Parameters

unstretchInterval If set, this time interval's stretching must be applied.

Precondition: !unstretchInterval.has_value() || unstretchInterval->first < unstretchInterval->second; IsLeader()

Postcondition: result: NChannels() == result->NChannels()

Implements Track.

Definition at line 1043 of file WaveTrack.cpp.

{
   assert(IsLeader());
   auto result = TrackList::Temporary(nullptr);
   const auto cloneOne = [&](const WaveTrack *pChannel){
      const auto pTrack =
         std::make_shared<WaveTrack>(*pChannel, ProtectedCreationArg{});
      pTrack->Init(*pChannel);
      result->Add(pTrack);
   };
   if (GetOwner())
      for (const auto pChannel : TrackList::Channels(this))
         cloneOne(pChannel);
   else
      cloneOne(this);
   return result;
}

References TrackList::Channels(), Track::GetOwner(), IsLeader(), and TrackList::Temporary().

Here is the call graph for this function:

◆ CloseLock()

bool WaveTrack::CloseLock ( )

noexcept

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

Precondition: IsLeader()

Exception safety guarantee:: No-fail

Definition at line 2982 of file WaveTrack.cpp.

{
   assert(IsLeader());
   for (const auto pChannel : TrackList::Channels(this))
      for (const auto &clip : pChannel->mClips)
         clip->CloseLock();
 
   return true;
}

References TrackList::Channels(), and IsLeader().

Here is the call graph for this function:

◆ ConvertToSampleFormat()

void WaveTrack::ConvertToSampleFormat	(	sampleFormat	format,
		const std::function< void(size_t)> &	progressReport = `{}`
	)

Precondition: IsLeader()

Exception safety guarantee:: Weak – Might complete on only some clips

Definition at line 1226 of file WaveTrack.cpp.

{
   assert(IsLeader());
   for (const auto pChannel : TrackList::Channels(this)) {
      for (const auto& clip : pChannel->mClips)
         clip->ConvertToSampleFormat(format, progressReport);
   }
   WaveTrackData::Get(*this).SetSampleFormat(format);
}

References TrackList::Channels(), anonymous_namespace{ExportPCM.cpp}::format, BasicUI::Get(), and IsLeader().

Here is the call graph for this function:

◆ Copy()

TrackListHolder WaveTrack::Copy	(	double	t0,
		double	t1,
		bool	forClipboard = `true`
	)		const

overridevirtual

Create new tracks and don't modify this track.

Returns: non-NULL or else throw Note that subclasses may want to distinguish tracks stored in a clipboard from those stored in a project May assume precondition: t0 <= t1 Should invoke Track::Init

Precondition: IsLeader

Postcondition: result: result->NChannels() == NChannels()

Implements Track.

Definition at line 1365 of file WaveTrack.cpp.

{
   if (t1 < t0)
      THROW_INCONSISTENCY_EXCEPTION;
 
   auto list = TrackList::Create(nullptr);
   for (const auto pChannel : TrackList::Channels(this))
      list->Add(CopyOne(*pChannel, t0, t1, forClipboard));
   return list;
}

References TrackList::Channels(), CopyOne(), TrackList::Create(), and THROW_INCONSISTENCY_EXCEPTION.

Referenced by Cut(), anonymous_namespace{LabelMenus.cpp}::OnCopyLabels(), anonymous_namespace{LabelMenus.cpp}::OnCutLabels(), anonymous_namespace{EditMenus.cpp}::OnSplitCut(), anonymous_namespace{EditMenus.cpp}::OnSplitNew(), and SplitCut().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CopyClipEnvelopes()

void WaveTrack::CopyClipEnvelopes ( )

Definition at line 2746 of file WaveTrack.cpp.

{
   const auto channels = TrackList::Channels(this);
   if (channels.size() != 2)
      return;
   // Assume correspondence of clips
   const auto left = *channels.begin();
   auto it = begin(left->mClips),
      last = end(left->mClips);
   const auto right = *channels.rbegin();
   auto it2 = begin(right->mClips),
      last2 = end(right->mClips);
   for (; it != last; ++it, ++it2) {
      if (it2 == last2) {
         assert(false);
         break;
      }
      (*it2)->SetEnvelope(std::make_unique<Envelope>(*(*it)->GetEnvelope()));
   }
}

References PackedArray::begin(), TrackList::Channels(), and PackedArray::end().

Here is the call graph for this function:

◆ CopyOne()

auto WaveTrack::CopyOne	(	const WaveTrack &	track,
		double	t0,
		double	t1,
		bool	forClipboard
	)

staticprivate

Definition at line 1376 of file WaveTrack.cpp.

{
   const auto &pFactory = track.mpFactory;
   auto result = track.EmptyCopy();
   WaveTrack *newTrack = result.get();
 
   // PRL:  Why shouldn't cutlines be copied and pasted too?  I don't know,
   // but that was the old behavior.  But this function is also used by the
   // Duplicate command and I changed its behavior in that case.
 
   for (const auto &clip : track.mClips) {
      if(clip->IsEmpty())
         continue;
 
      if (t0 <= clip->GetPlayStartTime() && t1 >= clip->GetPlayEndTime()) {
         // Whole clip is in copy region
         //wxPrintf("copy: clip %i is in copy region\n", (int)clip);
 
         newTrack->InsertClip(
            std::make_shared<WaveClip>(*clip, pFactory, !forClipboard));
         WaveClip *const newClip = newTrack->mClips.back().get();
         newClip->ShiftBy(-t0);
      }
      else if (clip->CountSamples(t0, t1) >= 1) {
         // Clip is affected by command
         //wxPrintf("copy: clip %i is affected by command\n", (int)clip);
 
         auto newClip = std::make_shared<WaveClip>(
            *clip, pFactory, !forClipboard, t0, t1);
         newClip->SetName(clip->GetName());
 
         newClip->ShiftBy(-t0);
         if (newClip->GetPlayStartTime() < 0)
            newClip->SetPlayStartTime(0);
 
         newTrack->InsertClip(std::move(newClip)); // transfer ownership
      }
   }
 
   // AWD, Oct 2009: If the selection ends in whitespace, create a
   // placeholder clip representing that whitespace
   // PRL:  Only if we want the track for pasting into other tracks.  Not if
   // it goes directly into a project as in the Duplicate command.
   if (forClipboard &&
       newTrack->GetEndTime() + 1.0 / newTrack->GetRate() < t1 - t0) {
      // TODO wide wave tracks -- match clip width of newTrack
      auto placeholder = std::make_shared<WaveClip>(1, pFactory,
         newTrack->GetSampleFormat(),
         static_cast<int>(newTrack->GetRate()),
         0 /*colourindex*/);
      placeholder->SetIsPlaceholder(true);
      placeholder->InsertSilence(0, (t1 - t0) - newTrack->GetEndTime());
      placeholder->ShiftBy(newTrack->GetEndTime());
      newTrack->InsertClip(std::move(placeholder)); // transfer ownership
   }
   return newTrack->SharedPointer<WaveTrack>();
}

References GetEndTime(), GetRate(), GetSampleFormat(), InsertClip(), mClips, Track::SharedPointer(), and WaveClip::ShiftBy().

Referenced by Copy().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CountBlocks()

size_t WaveTrack::CountBlocks ( ) const

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

Precondition: IsLeader()

Definition at line 1209 of file WaveTrack.cpp.

{
   assert(IsLeader());
   size_t result{};
   for (const auto pChannel : TrackList::Channels(this)) {
      for (auto& clip : pChannel->GetClips())
         result += clip->GetWidth() * clip->GetSequenceBlockArray(0)->size();
   }
   return result;
}

References TrackList::Channels(), and IsLeader().

Here is the call graph for this function:

◆ CreateClip()

WaveClip * WaveTrack::CreateClip	(	double	offset = `.0`,
		const wxString &	name = `wxEmptyString`
	)

Create new clip and add it to this track.

Returns a pointer to the newly created clip. Optionally initial offset and clip name may be provided

Postcondition: result: result->GetWidth() == GetWidth()

Definition at line 3760 of file WaveTrack.cpp.

{
   // TODO wide wave tracks -- choose clip width correctly for the track
   auto clip = std::make_shared<WaveClip>(1,
      mpFactory, GetSampleFormat(), GetRate(), GetWaveColorIndex());
   clip->SetName(name);
   clip->SetSequenceStartTime(offset);
 
   const auto& tempo = GetProjectTempo();
   if (tempo.has_value())
      clip->OnProjectTempoChange(std::nullopt, *tempo);
   mClips.push_back(std::move(clip));
 
   auto result = mClips.back().get();
   // TODO wide wave tracks -- for now assertion is correct because widths are
   // always 1
   assert(result->GetWidth() == GetWidth());
   return result;
}

References Track::GetProjectTempo(), GetRate(), GetSampleFormat(), GetWaveColorIndex(), GetWidth(), mClips, mpFactory, and name.

Referenced by AUPImportFileHandle::HandleWaveClip(), JoinOne(), NewestOrNewClip(), and RightmostOrNewClip().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CreateWideClip()

void WaveTrack::CreateWideClip	(	double	offset = `.0`,
		const wxString &	name = `wxEmptyString`
	)

Precondition: IsLeader()

Definition at line 3753 of file WaveTrack.cpp.

{
   assert(IsLeader());
   for(auto channel : TrackList::Channels(this))
      channel->CreateClip(offset, name);
}

References TrackList::Channels(), IsLeader(), and name.

Here is the call graph for this function:

◆ Cut()

TrackListHolder WaveTrack::Cut	(	double	t0,
		double	t1
	)

overridevirtual

Create tracks and modify this track.

Returns: non-NULL or else throw May assume precondition: t0 <= t1

Precondition: IsLeader()

Postcondition: result: result->NChannels() == NChannels()

Implements Track.

Definition at line 1260 of file WaveTrack.cpp.

{
   assert(IsLeader());
   if (t1 < t0)
      THROW_INCONSISTENCY_EXCEPTION;
 
   auto result = Copy(t0, t1);
   Clear(t0, t1);
   return result;
}

References Clear(), Copy(), IsLeader(), and THROW_INCONSISTENCY_EXCEPTION.

Here is the call graph for this function:

◆ DiscardTrimmed()

void WaveTrack::DiscardTrimmed ( )

Remove hidden audio from all clips.

Precondition: IsLeader()

Definition at line 4392 of file WaveTrack.cpp.

{
   assert(IsLeader());
   for (const auto pChannel : TrackList::Channels(this)) {
      for (auto clip : pChannel->GetClips()) {
         if (clip->GetTrimLeft() != 0) {
            auto t0 = clip->GetPlayStartTime();
            clip->SetTrimLeft(0);
            clip->ClearLeft(t0);
         }
         if (clip->GetTrimRight() != 0) {
            auto t1 = clip->GetPlayEndTime();
            clip->SetTrimRight(0);
            clip->ClearRight(t1);
         }
      }
   }
}

References TrackList::Channels(), and IsLeader().

Here is the call graph for this function:

◆ Disjoin()

void WaveTrack::Disjoin	(	double	t0,
		double	t1
	)

Precondition: IsLeader()

Exception safety guarantee:: Weak

Definition at line 2477 of file WaveTrack.cpp.

{
   assert(IsLeader());
   auto minSamples = TimeToLongSamples(WAVETRACK_MERGE_POINT_TOLERANCE);
   const size_t maxAtOnce = 1048576;
   std::vector<float> buffer;
   std::vector<samplePtr> buffers;
   Regions regions;
 
   const size_t width = NChannels();
 
   for (const auto &interval : Intervals()) {
      double startTime = interval->Start();
      double endTime = interval->End();
 
      if (endTime < t0 || startTime > t1)
         continue;
 
      // Assume all clips will have the same width
      if (buffer.empty()) {
         buffer.resize(maxAtOnce * width);
         buffers.resize(width);
         auto pBuffer = buffer.data();
         for (size_t ii = 0; ii < width; ++ii, pBuffer += maxAtOnce)
            buffers[ii] = reinterpret_cast<samplePtr>(pBuffer);
      }
 
      const auto allZeroesAt = [&](size_t i) {
         auto pData = buffer.data() + i;
         for (size_t ii = 0; ii < width; ++ii, pData += maxAtOnce) {
            if (*pData != 0.0)
               return false;
         }
         return true;
      };
 
      // simply look for a sequence of zeroes (across all channels) and if the
      // sequence is longer than the minimum number, split-delete the region
 
      sampleCount seqStart = -1;
      auto start = interval->TimeToSamples(std::max(.0, t0 - startTime));
      auto end = interval->TimeToSamples(std::min(endTime, t1) - startTime);
 
      auto len = (end - start);
      for (decltype(len) done = 0; done < len; done += maxAtOnce) {
         auto numSamples = limitSampleBufferSize(maxAtOnce, len - done);
 
         auto bufferIt = buffers.begin();
 
         for (auto channel : interval->Channels())
            channel->GetSamples(
               *bufferIt++, floatSample, start + done, numSamples);
 
         for (decltype(numSamples) i = 0; i < numSamples; ++i) {
            auto curSamplePos = start + done + i;
 
            //start a NEW sequence
            if (seqStart == -1 && allZeroesAt(i))
               seqStart = curSamplePos;
            else if (curSamplePos == end - 1 || !allZeroesAt(i)) {
               if (seqStart != -1) {
                  decltype(end) seqEnd;
 
                  //consider the end case, where selection ends in zeroes
                  if (curSamplePos == end - 1 && allZeroesAt(i))
                     seqEnd = end;
                  else
                     seqEnd = curSamplePos;
                  if (seqEnd - seqStart + 1 > minSamples) {
                     regions.push_back(
                        Region(
                           startTime + interval->SamplesToTime(seqStart),
                           startTime + interval->SamplesToTime(seqEnd)
                        )
                     );
                  }
                  seqStart = -1;
               }
            }
         } // samples
      } // blocks
   } // finding regions
 
   for (const auto &region : regions)
      SplitDelete(region.start, region.end);
}

References PackedArray::end(), floatSample, Intervals(), IsLeader(), limitSampleBufferSize(), min(), NChannels(), SplitDelete(), WideSampleSequence::TimeToLongSamples(), and WAVETRACK_MERGE_POINT_TOLERANCE.

Referenced by anonymous_namespace{LabelMenus.cpp}::OnDisjoinLabels().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DoGet()

bool WaveTrack::DoGet	(	size_t	iChannel,
		size_t	nBuffers,
		const samplePtr	buffers[],
		sampleFormat	format,
		sampleCount	start,
		size_t	len,
		bool	backwards,
		fillFormat	fill = `FillFormat::fillZero`,
		bool	mayThrow = `true`,
		sampleCount *	pNumWithinClips = `nullptr`
	)		const

overridevirtual

This fails if any clip overlapping the range has non-unit stretch ratio!

MM: Now that each wave track can contain multiple clips, we don't have a continuous space of samples anymore, but we simulate it, because there are a lot of places (e.g. effects) using this interface. This interface makes much sense for modifying samples, but note that it is not time-accurate, because the "offset" is a double value and therefore can lie inbetween samples. But as long as you use the same value for "start" in both calls to "Set" and "Get" it is guaranteed that the same samples are affected.

an un-owned track should have reported one channel only

Implements WideSampleSequence.

Definition at line 3134 of file WaveTrack.cpp.

{
   const auto nChannels = NChannels();
   assert(iChannel + nBuffers <= nChannels); // precondition
   const auto pOwner = GetOwner();
   if (!pOwner) {
      assert(nChannels == 1);
      nBuffers = std::min<size_t>(nBuffers, 1);
   }
   std::optional<TrackIter<const WaveTrack>> iter;
   auto pTrack = this;
   if (pOwner) {
      const auto ppLeader = TrackList::Channels(this).first;
      iter.emplace(ppLeader.advance(IsLeader() ? iChannel : 1));
      pTrack = **iter;
   }
   return std::all_of(buffers, buffers + nBuffers, [&](samplePtr buffer) {
      const auto result = pTrack->GetOne(
         buffer, format, start, len, backwards, fill, mayThrow,
         pNumWithinClips);
      if (iter)
         pTrack = *(++ *iter);
      return result;
   });
}

References TrackList::Channels(), anonymous_namespace{ExportPCM.cpp}::format, Track::GetOwner(), anonymous_namespace{StretchingSequenceIntegrationTest.cpp}::iChannel, IsLeader(), and NChannels().

Here is the call graph for this function:

◆ DoGetChannel()

std::shared_ptr<::Channel > WaveTrack::DoGetChannel ( size_t iChannel )

overrideprivatevirtual

Retrieve a channel.

Postcondition: result: !(iChannel < NChannels()) || result

Implements ChannelGroup.

Definition at line 1014 of file WaveTrack.cpp.

{
   auto nChannels = NChannels();
   if (iChannel >= nChannels)
      return {};
   auto pTrack = (iChannel == 0)
      ? this
      // TODO: more-than-two-channels
      : *TrackList::Channels(this).rbegin();
   // Use aliasing constructor of std::shared_ptr
   ::Channel *alias = pTrack;
   return { pTrack->shared_from_this(), alias };
}

References TrackList::Channels(), anonymous_namespace{StretchingSequenceIntegrationTest.cpp}::iChannel, and NChannels().

Here is the call graph for this function:

◆ DoGetChannelGroup()

ChannelGroup & WaveTrack::DoGetChannelGroup ( ) const

overrideprivatevirtual

Subclass must override.

Postcondition: result: for some ii less than result.NChannels(), this == result.GetChannel(ii).get()

Implements Channel.

Definition at line 1028 of file WaveTrack.cpp.

{
   const ChannelGroup &group = *this;
   return const_cast<ChannelGroup&>(group);
}

◆ DoGetInterval()

std::shared_ptr< WideChannelGroupInterval > WaveTrack::DoGetInterval ( size_t iInterval )

overrideprivatevirtual

Retrieve an interval.

Postcondition: result: !(iInterval < NIntervals()) || result

Implements ChannelGroup.

Definition at line 988 of file WaveTrack.cpp.

{
   if (iInterval < NIntervals()) {
      WaveClipHolder pClip = mClips[iInterval],
         pClip1;
      // TODO wide wave tracks
      // This assumed correspondence of clips may be wrong if they misalign
      if (auto right = ChannelGroup::GetChannel<WaveTrack>(1)
         ; right && iInterval < right->mClips.size()
      )
         pClip1 = right->mClips[iInterval];
      return std::make_shared<Interval>(*this, pClip, pClip1);
   }
   return {};
}

References mClips, and NIntervals().

Here is the call graph for this function:

◆ DoOnProjectTempoChange()

void WaveTrack::DoOnProjectTempoChange	(	const std::optional< double > &	oldTempo,
		double	newTempo
	)

overrideprivatevirtual

Precondition: IsLeader()

Implements Track.

Definition at line 857 of file WaveTrack.cpp.

{
   assert(IsLeader());
   for (const auto pChannel : TrackList::Channels(this))
      for (const auto& clip : pChannel->mClips)
         clip->OnProjectTempoChange(oldTempo, newTempo);
}

References TrackList::Channels(), and IsLeader().

Here is the call graph for this function:

◆ DoSetGain()

void WaveTrack::DoSetGain ( float value )

private

Definition at line 1117 of file WaveTrack.cpp.

{
   WaveTrackData::Get(*this).SetGain(value);
}

References BasicUI::Get().

Referenced by HandleXMLTag(), and SetGain().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DoSetPan()

void WaveTrack::DoSetPan ( float value )

private

Definition at line 1135 of file WaveTrack.cpp.

{
   WaveTrackData::Get(*this).SetPan(value);
}

References BasicUI::Get().

Referenced by HandleXMLTag(), and SetPan().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DoSetRate()

void WaveTrack::DoSetRate ( double newRate )

private

Definition at line 1100 of file WaveTrack.cpp.

{
   auto &data = WaveTrackData::Get(*this);
   data.SetRate(static_cast<int>(newRate));
}

References BasicUI::Get().

Referenced by Resample(), SetRate(), and WaveTrack().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DuplicateWithOtherTempo()

TrackListHolder WaveTrack::DuplicateWithOtherTempo	(	double	newTempo,
		WaveTrack *&	leader
	)		const

private

Precondition: IsLeader()

Parameters

[out] leader

pre IsLeader()

Definition at line 867 of file WaveTrack.cpp.

{
   const auto srcCopyList = Duplicate();
   leader = *srcCopyList->Any<WaveTrack>().begin();
   leader->OnProjectTempoChange(newTempo);
   return srcCopyList;
}

References Track::Any(), PackedArray::begin(), Track::Duplicate(), and Track::OnProjectTempoChange().

Referenced by ClearAndPaste(), and PasteWaveTrack().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EmptyCopy()

WaveTrack::Holder WaveTrack::EmptyCopy	(	const SampleBlockFactoryPtr &	pFactory = `{}`,
		bool	keepLink = `true`
	)		const

Make another track copying format, rate, color, etc. but containing no clips; and always with a unique channel

It is important to pass the correct factory (that for the project which will own the copy) in the unusual case that a track is copied from another project or the clipboard. For copies within one project, the default will do.

Parameters

keepLink if false, make the new track mono. But always preserve any other track group data.

Definition at line 1323 of file WaveTrack.cpp.

{
   const auto rate = GetRate();
   auto result = std::make_shared<WaveTrack>(pFactory, GetSampleFormat(), rate);
   result->Init(*this);
   // The previous line might have destroyed the rate information stored in
   // channel group data.  The copy is not yet in a TrackList.  Reassign rate
   // in case the track needs to make WaveClips before it is properly joined
   // with the opposite channel in a TrackList.
   // TODO wide wave tracks -- all of the comment above will be irrelevant!
   result->DoSetRate(rate);
   result->mpFactory = pFactory ? pFactory : mpFactory;
   if (!keepLink)
      result->SetLinkType(LinkType::None);
   WaveTrackData::Get(*result).SetOrigin(0);
   return result;
}

References BasicUI::Get(), GetRate(), GetSampleFormat(), mpFactory, and ChannelGroup::None.

Referenced by WaveTrackFactory::Create(), PasteInto(), EffectNoiseRemoval::ProcessOne(), and EffectStereoToMono::ProcessOne().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExpandCutLine()

void WaveTrack::ExpandCutLine	(	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 3984 of file WaveTrack.cpp.

{
   assert(IsLeader());
   for (const auto pChannel : TrackList::Channels(this)) {
      pChannel->ExpandOneCutLine(cutLinePosition, cutlineStart, cutlineEnd);
      // Assign the out parameters at most once
      cutlineStart = cutlineEnd = nullptr;
   }
}

References TrackList::Channels(), and IsLeader().

Here is the call graph for this function:

◆ ExpandOneCutLine()

void WaveTrack::ExpandOneCutLine	(	double	cutLinePosition,
		double *	cutlineStart,
		double *	cutlineEnd
	)

private

Exception safety guarantee:: Strong

Definition at line 3996 of file WaveTrack.cpp.

{
   bool editClipCanMove = GetEditClipsCanMove();
 
   // Find clip which contains this cut line
   double start = 0, end = 0;
   auto pEnd = mClips.end();
   auto pClip = std::find_if( mClips.begin(), pEnd,
      [&](const WaveClipHolder &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: mClips)
         {
            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 : mClips)
         {
            if (clip2->GetPlayStartTime() > clip->GetPlayStartTime())
               clip2->ShiftBy(end - start);
         }
      }
   }
}

References BadUserAction, PackedArray::end(), GetEditClipsCanMove(), mClips, and XO().

Here is the call graph for this function:

◆ FindChannelGroup()

const ChannelGroup * WaveTrack::FindChannelGroup ( ) const

overridevirtual

Find associated ChannelGroup if any.

Implements PlayableSequence.

Definition at line 2783 of file WaveTrack.cpp.

{
   return this;
}

◆ FindClipByName()

const WaveClip * WaveTrack::FindClipByName ( const wxString & name ) const

Returns nullptr if clip with such name was not found.

Definition at line 1004 of file WaveTrack.cpp.

{
   for (const auto& clip : mClips)
   {
      if (clip->GetName() == name)
         return clip.get();
   }
   return nullptr;
}

References mClips, and name.

Referenced by MakeClipCopyName(), and MakeNewClipName().

Here is the caller graph for this function:

◆ Flush()

void WaveTrack::Flush ( )

overridevirtual

Exception safety guarantee:: Mixed

Exception safety guarantee:: No-fail – The rightmost clip will be in a flushed state.

Exception safety guarantee:: Partial – Some initial portion (maybe none) of the append buffer of the rightmost clip gets appended; no previously saved contents are lost.

Implements RecordableSequence.

Definition at line 2734 of file WaveTrack.cpp.

{
   assert(IsLeader());
   for (const auto pChannel : TrackList::Channels(this))
      pChannel->FlushOne();
}

References TrackList::Channels(), and IsLeader().

Referenced by WaveTrackSink::Flush(), TrackSpectrumTransformer::PostProcess(), and EffectSBSMS::Process().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FlushOne()

void WaveTrack::FlushOne ( )

private

Exception safety guarantee:: Mixed

Exception safety guarantee:: No-fail – The rightmost clip will be in a flushed state.

Exception safety guarantee:: Partial – Some initial portion (maybe none) of the append buffer of the rightmost clip gets appended; no previously saved contents are lost.

Definition at line 2772 of file WaveTrack.cpp.

{
   // After appending, presumably.  Do this to the clip that gets appended.
   RightmostOrNewClip()->Flush();
}

References WaveClip::Flush(), and RightmostOrNewClip().

Here is the call graph for this function:

◆ FormatConsistencyCheck()

bool WaveTrack::FormatConsistencyCheck ( ) const

private

Whether all tracks in group and all clips have a common sample format.

Precondition: IsLeader()

Definition at line 2327 of file WaveTrack.cpp.

{
   assert(IsLeader());
 
   const auto channels = TrackList::Channels(this);
   return std::all_of(channels.begin(), channels.end(),
      [&](const WaveTrack *pTrack){
         return pTrack && pTrack->mLegacyFormat == mLegacyFormat;
      });
}

References TrackList::Channels(), and IsLeader().

Referenced by LinkConsistencyFix().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetAdjacentClip() [1/2]

WaveClip * WaveTrack::GetAdjacentClip	(	const WaveClip &	clip,
		PlaybackDirection	searchDirection
	)

Similar to GetNextClip, but returns nullptr if the neighbour clip is not adjacent.

Definition at line 3675 of file WaveTrack.cpp.

{
   return const_cast<WaveClip*>(
      std::as_const(*this).GetAdjacentClip(clip, direction));
}

◆ GetAdjacentClip() [2/2]

const WaveClip * WaveTrack::GetAdjacentClip	(	const WaveClip &	clip,
		PlaybackDirection	searchDirection
	)		const

Similar to GetNextClip, but returns nullptr if the neighbour clip is not adjacent.

Definition at line 3656 of file WaveTrack.cpp.

{
   const auto neighbour = GetNextClip(clip, direction);
   if (!neighbour)
      return nullptr;
   else if (direction == PlaybackDirection::forward)
      return std::abs(clip.GetPlayEndTime() - neighbour->GetPlayStartTime()) <
                   1e-9 ?
                neighbour :
                nullptr;
   else
      return std::abs(clip.GetPlayStartTime() - neighbour->GetPlayEndTime()) <
                   1e-9 ?
                neighbour :
                nullptr;
}

References forward, GetNextClip(), WaveClip::GetPlayEndTime(), and WaveClip::GetPlayStartTime().

Referenced by GetFloatsFromTime(), and SetFloatsFromTime().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetAllClips() [1/2]

IteratorRange< AllClipsIterator > WaveTrack::GetAllClips ( )

inline

Definition at line 789 of file WaveTrack.h.

   {
      return { AllClipsIterator{ *this }, AllClipsIterator{ } };
   }

◆ GetAllClips() [2/2]

IteratorRange< AllClipsConstIterator > WaveTrack::GetAllClips ( ) const

inline

Definition at line 794 of file WaveTrack.h.

   {
      return { AllClipsConstIterator{ *this }, AllClipsConstIterator{ } };
   }

◆ GetBestBlockSize()

size_t WaveTrack::GetBestBlockSize ( sampleCount t ) const

Definition at line 2679 of file WaveTrack.cpp.

{
   auto bestBlockSize = GetMaxBlockSize();
 
   for (const auto &clip : mClips)
   {
      auto startSample = clip->GetPlayStartSample();
      auto endSample = clip->GetPlayEndSample();
      if (s >= startSample && s < endSample)
      {
         // ignore extra channels (this function will soon be removed)
         bestBlockSize = clip->GetSequence(0)
            ->GetBestBlockSize(s - clip->GetSequenceStartSample());
         break;
      }
   }
 
   return bestBlockSize;
}

References GetMaxBlockSize(), and mClips.

Referenced by WaveChannel::GetBestBlockSize(), EffectNoiseRemoval::ProcessOne(), ReverseOneClip(), VoiceKey::TestDirectionChanges(), VoiceKey::TestEnergy(), and VoiceKey::TestSignChanges().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetChannel() [1/2]

auto WaveTrack::GetChannel ( size_t iChannel )

inline

Definition at line 267 of file WaveTrack.h.

267 {

268 return this->ChannelGroup::GetChannel<WaveChannel>(iChannel); }

References anonymous_namespace{StretchingSequenceIntegrationTest.cpp}::iChannel.

Referenced by WaveTrackMenuTable::SplitStereo().

Here is the caller graph for this function:

◆ GetChannel() [2/2]

auto WaveTrack::GetChannel ( size_t iChannel ) const

inline

Definition at line 269 of file WaveTrack.h.

269 {

270 return this->ChannelGroup::GetChannel<const WaveChannel>(iChannel); }

References anonymous_namespace{StretchingSequenceIntegrationTest.cpp}::iChannel.

◆ GetChannelGain()

float WaveTrack::GetChannelGain ( int channel ) const

overridevirtual

Takes gain and pan into account.

Implements WideSampleSequence.

Definition at line 1153 of file WaveTrack.cpp.

{
   float left = 1.0;
   float right = 1.0;
 
   const auto pan = GetPan();
   if (pan < 0)
      right = (pan + 1.0);
   else if (pan > 0)
      left = 1.0 - pan;
 
   const auto gain = GetGain();
   if ((channel%2) == 0)
      return left * gain;
   else
      return right * gain;
}

References GetGain(), and GetPan().

Referenced by EffectStereoToMono::ProcessOne().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetChannelType()

AudioGraph::ChannelType WaveTrack::GetChannelType ( ) const

overridevirtual

Classify this channel.

Implements AudioGraph::Channel.

Definition at line 811 of file WaveTrack.cpp.

{
   if (TrackList::NChannels(*this) == 1)
      return AudioGraph::MonoChannel;
   else if (IsLeader())
      return AudioGraph::LeftChannel;
   else
      // TODO: more-than-two-channels
      return AudioGraph::RightChannel;
}

References IsLeader(), AudioGraph::LeftChannel, AudioGraph::MonoChannel, TrackList::NChannels(), and AudioGraph::RightChannel.

Here is the call graph for this function:

◆ GetClipAtTime() [1/2]

WaveClip * WaveTrack::GetClipAtTime ( double time )

Definition at line 3683 of file WaveTrack.cpp.

{
   return const_cast<WaveClip*>(std::as_const(*this).GetClipAtTime(time));
}

◆ GetClipAtTime() [2/2]

const WaveClip * WaveTrack::GetClipAtTime ( double time ) const

Definition at line 3718 of file WaveTrack.cpp.

{
   const auto clips = SortedClipArray();
   auto p = std::find_if(
      clips.rbegin(), clips.rend(), [&](const WaveClip* const& clip) {
         return clip->WithinPlayRegion(time);
      });
 
   // When two clips are immediately next to each other, the GetPlayEndTime() of the first clip
   // and the GetPlayStartTime() of the second clip may not be exactly equal due to rounding errors.
   // If "time" is the end time of the first of two such clips, and the end time is slightly
   // less than the start time of the second clip, then the first rather than the
   // second clip is found by the above code. So correct this.
   if (p != clips.rend() && p != clips.rbegin() &&
      time == (*p)->GetPlayEndTime() &&
      (*p)->SharesBoundaryWithNextClip(*(p-1))) {
      p--;
   }
 
   return p != clips.rend() ? *p : nullptr;
}

References SortedClipArray().

Referenced by anonymous_namespace{SampleHandle.cpp}::adjustTime(), ApplyStretchRatio(), SelectHandle::Click(), GetFloatAtTime(), GetFloatsFromTime(), PasteOne(), anonymous_namespace{WaveTrack.cpp}::RoundToNearestClipSample(), SetFloatsFromTime(), and SetFloatsWithinTimeRange().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetClipByIndex() [1/2]

WaveClip * WaveTrack::GetClipByIndex ( int index )

Get the nth clip in this WaveTrack (will return nullptr if not found).

Use this only in special cases (like getting the linked clip), because it is much slower than GetClipIterator().

Definition at line 3818 of file WaveTrack.cpp.

{
   if(index < (int)mClips.size())
      return mClips[index].get();
   else
      return nullptr;
}

References mClips.

Referenced by GetClipByIndex(), MergeOneClipPair(), and PasteOne().

Here is the caller graph for this function:

◆ GetClipByIndex() [2/2]

const WaveClip * WaveTrack::GetClipByIndex ( int index ) const

Get the nth clip in this WaveTrack (will return nullptr if not found).

Use this only in special cases (like getting the linked clip), because it is much slower than GetClipIterator().

Definition at line 3826 of file WaveTrack.cpp.

{
   return const_cast<WaveTrack&>(*this).GetClipByIndex(index);
}

References GetClipByIndex().

Here is the call graph for this function:

◆ GetClipIndex()

int WaveTrack::GetClipIndex ( const WaveClip * clip ) const

Definition at line 3811 of file WaveTrack.cpp.

{
   int result;
   FindClip(mClips, clip, &result);
   return result;
}

References anonymous_namespace{WaveTrack.cpp}::FindClip(), and mClips.

Referenced by ClearAndPasteOne().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetClipInterfaces()

ClipConstHolders WaveTrack::GetClipInterfaces ( ) const

Get access to the (visible) clips in the tracks, in unspecified order.

Precondition: IsLeader()

Definition at line 3014 of file WaveTrack.cpp.

{
  // We're constructing possibly wide clips here, and for this we need to have
  // access to the other channel-tracks.
  assert(IsLeader());
  const auto pOwner = GetOwner();
  ClipConstHolders wideClips;
  wideClips.reserve(mClips.size());
  for (auto clipIndex = 0u; clipIndex < mClips.size(); ++clipIndex)
  {
     const auto leftClip = mClips[clipIndex];
     WaveClipHolder rightClip;
     if (NChannels() == 2u && pOwner)
     {
        const auto& rightClips =
           (*TrackList::Channels(this).rbegin())->mClips;
        // This is known to have potential for failure for stereo tracks with
        // misaligned left/right clips - see
        // https://github.com/audacity/audacity/issues/4791.
        // If what you are trying to do is something else and this fails,
        // please report.
        assert(clipIndex < rightClips.size());
        if (clipIndex < rightClips.size())
           rightClip = rightClips[clipIndex];
     }
     wideClips.emplace_back(
        std::make_shared<WideClip>(leftClip, std::move(rightClip)));
  }
   return wideClips;
}

References TrackList::Channels(), Track::GetOwner(), IsLeader(), mClips, and NChannels().

Here is the call graph for this function:

◆ GetClips() [1/2]

WaveClipHolders & WaveTrack::GetClips ( )

inline

Get access to the (visible) clips in the tracks, in unspecified order (not necessarily sequenced in time).

Postcondition: all pointers are non-null

Definition at line 694 of file WaveTrack.h.

694{ return mClips; }

Referenced by ClearAndPasteOne(), WaveTrackUtilities::HasStretch(), EffectAutoDuck::Process(), and ReverseOne().

Here is the caller graph for this function:

◆ GetClips() [2/2]

const WaveClipConstHolders & WaveTrack::GetClips ( ) const

inline

Get access to the (visible) clips in the tracks, in unspecified order (not necessarily sequenced in time).

Postcondition: all pointers are non-null

Definition at line 698 of file WaveTrack.h.

699 { return reinterpret_cast< const WaveClipConstHolders& >( mClips ); }

WaveClipConstHolders

std::vector< std::shared_ptr< const WaveClip > > WaveClipConstHolders

Definition: WaveClip.h:47

◆ GetClipsIntersecting()

WaveClipConstHolders WaveTrack::GetClipsIntersecting	(	double	t0,
		double	t1
	)		const

Definition at line 3701 of file WaveTrack.cpp.

{
   assert(t0 <= t1);
   WaveClipConstHolders intersectingClips;
   for (const auto& clip : mClips)
      if (clip->IntersectsPlayRegion(t0, t1))
         intersectingClips.push_back(clip);
   return intersectingClips;
}

References mClips.

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

Here is the caller graph for this function:

◆ GetDefaultAudioTrackNamePreference()

wxString WaveTrack::GetDefaultAudioTrackNamePreference ( )

static

Definition at line 708 of file WaveTrack.cpp.

{
   const auto name = AudioTrackNameSetting.ReadWithDefault(L"");
 
   if (name.empty() || ( name == DefaultName.MSGID() ))
      // When nothing was specified,
      // the default-default is whatever translation of...
      /* i18n-hint: The default name for an audio track. */
      return DefaultName.Translation();
   else
      return name;
}

References AudioTrackNameSetting, DefaultName, TranslatableString::empty(), name, and Setting< T >::ReadWithDefault().

Referenced by TracksPrefs::Commit(), EffectBase::DoEffect(), ProjectAudioManager::DoRecord(), anonymous_namespace{WaveTrackMenuItems.cpp}::OnNewStereoTrack(), and anonymous_namespace{WaveTrackMenuItems.cpp}::OnNewWaveTrack().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetEndTime()

double WaveTrack::GetEndTime ( ) const

overridevirtual

Implement WideSampleSequence.

Implements WideSampleSequence.

Definition at line 3050 of file WaveTrack.cpp.

{
   return ChannelGroup::GetEndTime();
}

References ChannelGroup::GetEndTime().

Referenced by AUPImportFileHandle::AddSilence(), EffectTruncSilence::Analyze(), ApplyStretchRatio(), ClearAndPasteAtSameTempo(), CopyOne(), Effect::GetBounds(), PasteWaveTrackAtSameTempo(), TrackSpectrumTransformer::PostProcess(), EffectStereoToMono::ProcessOne(), GetInfoCommand::SendTracks(), RateMenuTable::SetRate(), SyncLockAdjust(), and Trim().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetEnvelopeAtTime()

Envelope * WaveTrack::GetEnvelopeAtTime ( double time )

Definition at line 3740 of file WaveTrack.cpp.

{
   auto pTrack = this;
   if (GetOwner())
      // Substitute the leader track
      pTrack = *TrackList::Channels(this).begin();
   WaveClip* clip = pTrack->GetClipAtTime(time);
   if (clip)
      return clip->GetEnvelope();
   else
      return NULL;
}

References TrackList::Channels(), WaveClip::GetEnvelope(), and Track::GetOwner().

Here is the call graph for this function:

◆ GetEnvelopeValues()

void WaveTrack::GetEnvelopeValues	(	double *	buffer,
		size_t	bufferLen,
		double	t0,
		bool	backwards
	)		const

overridevirtual

Fetch envelope values corresponding to uniformly separated sample times starting at the given time

Parameters

backwards if true, fetch values in reverse order, from t0 to t0 - bufferLen / rate

Implements WideSampleSequence.

Definition at line 3580 of file WaveTrack.cpp.

{
   auto pTrack = this;
   if (GetOwner())
      // Substitute the leader track
      pTrack = *TrackList::Channels(this).begin();
 
   if (backwards)
      t0 -= bufferLen / GetRate();
   // The output buffer corresponds to an unbroken span of time which the callers expect
   // to be fully valid.  As clips are processed below, the output buffer is updated with
   // envelope values from any portion of a clip, start, end, middle, or none at all.
   // Since this does not guarantee that the entire buffer is filled with values we need
   // to initialize the entire buffer to a default value.
   //
   // This does mean that, in the cases where a usable clip is located, the buffer value will
   // be set twice.  Unfortunately, there is no easy way around this since the clips are not
   // stored in increasing time order.  If they were, we could just track the time as the
   // buffer is filled.
   for (decltype(bufferLen) i = 0; i < bufferLen; i++)
   {
      buffer[i] = 1.0;
   }
 
   double startTime = t0;
   const auto rate = GetRate();
   auto tstep = 1.0 / rate;
   double endTime = t0 + tstep * bufferLen;
   for (const auto &clip: pTrack->mClips)
   {
      // IF clip intersects startTime..endTime THEN...
      auto dClipStartTime = clip->GetPlayStartTime();
      auto dClipEndTime = clip->GetPlayEndTime();
      if ((dClipStartTime < endTime) && (dClipEndTime > startTime))
      {
         auto rbuf = buffer;
         auto rlen = bufferLen;
         auto rt0 = t0;
 
         if (rt0 < dClipStartTime)
         {
            // This is not more than the number of samples in
            // (endTime - startTime) which is bufferLen:
            auto nDiff = (sampleCount)floor((dClipStartTime - rt0) * rate + 0.5);
            auto snDiff = nDiff.as_size_t();
            rbuf += snDiff;
            wxASSERT(snDiff <= rlen);
            rlen -= snDiff;
            rt0 = dClipStartTime;
         }
 
         if (rt0 + rlen*tstep > dClipEndTime)
         {
            auto nClipLen = clip->GetPlayEndSample() - clip->GetPlayStartSample();
 
            if (nClipLen <= 0) // Testing for bug 641, this problem is consistently '== 0', but doesn't hurt to check <.
               return;
 
            // This check prevents problem cited in http://bugzilla.audacityteam.org/show_bug.cgi?id=528#c11,
            // Gale's cross_fade_out project, which was already corrupted by bug 528.
            // This conditional prevents the previous write past the buffer end, in clip->GetEnvelope() call.
            // Never increase rlen here.
            // PRL bug 827:  rewrote it again
            rlen = limitSampleBufferSize( rlen, nClipLen );
            rlen = std::min(rlen, size_t(floor(0.5 + (dClipEndTime - rt0) / tstep)));
         }
         // Samples are obtained for the purpose of rendering a wave track,
         // so quantize time
         clip->GetEnvelope()->GetValues(rbuf, rlen, rt0, tstep);
      }
   }
   if (backwards)
      std::reverse(buffer, buffer + bufferLen);
}

References TrackList::Channels(), Track::GetOwner(), GetRate(), limitSampleBufferSize(), and min().

Here is the call graph for this function:

◆ GetErrorOpening()

std::optional< TranslatableString > WaveTrack::GetErrorOpening ( ) const

overridevirtual

Returns nonempty if an error was encountered while trying to open the track from XML

May assume consistency of stereo channel grouping and examine other channels

Precondition: IsLeader()

Reimplemented from Track.

Definition at line 2970 of file WaveTrack.cpp.

{
   assert(IsLeader());
   for (const auto pChannel : TrackList::Channels(this))
      for (const auto &clip : pChannel->mClips)
         for (size_t ii = 0, width = clip->GetWidth(); ii < width; ++ii)
            if (clip->GetSequence(ii)->GetErrorOpening())
               return XO("A track has a corrupted sample sequence.");
 
   return {};
}

References TrackList::Channels(), IsLeader(), and XO().

Here is the call graph for this function:

◆ GetFloatAtTime()

bool WaveTrack::GetFloatAtTime	(	double	t,
		size_t	iChannel,
		float &	value,
		bool	mayThrow
	)		const

Returns: true if GetClipAtTime(t) != nullptr, false otherwise.

Definition at line 3267 of file WaveTrack.cpp.

{
   const auto clip = GetClipAtTime(t);
   if (!clip)
      return false;
   clip->GetFloatAtTime(
      t - clip->GetPlayStartTime(), iChannel, value, mayThrow);
   return true;
}

References GetClipAtTime(), and anonymous_namespace{StretchingSequenceIntegrationTest.cpp}::iChannel.

Here is the call graph for this function:

◆ GetFloats() [1/2]

bool SampleTrack::GetFloats	(	float *	buffer,
		sampleCount	start,
		size_t	len,
		fillFormat	fill = `FillFormat::fillZero`,
		bool	mayThrow = `true`,
		sampleCount *	pNumWithinClips = `nullptr`
	)		const

inline

"narrow" overload fetches first channel only

Definition at line 46 of file SampleTrack.h.

   {
      constexpr auto backwards = false;
      return GetFloats(
         0, 1, &buffer, start, len, backwards, fill, mayThrow, pNumWithinClips);
   }

Referenced by VoiceKey::OffBackward(), VoiceKey::OffForward(), VoiceKey::OnBackward(), VoiceKey::OnForward(), ReverseOneClip(), SelectHandle::StartSnappingFreqSelection(), VoiceKey::TestDirectionChanges(), VoiceKey::TestEnergy(), and VoiceKey::TestSignChanges().

Here is the caller graph for this function:

◆ GetFloats() [2/2]

bool WideSampleSequence::GetFloats	(	size_t	iChannel,
		size_t	nBuffers,
		float *const	buffers[],
		sampleCount	start,
		size_t	len,
		bool	backwards = `false`,
		fillFormat	fill = `FillFormat::fillZero`,
		bool	mayThrow = `true`,
		sampleCount *	pNumWithinClips = `nullptr`
	)		const

Retrieve samples from a sequence in floating-point format, regardless of the storage format

Parameters

	iChannel	index of first channel to fetch
	nBuffers	counts buffers
	buffers	receive the samples
	start	starting sample, relative to absolute time zero
	len	how many samples to get. buffers are assumed sufficiently large
	fill	how to assign values for sample positions between clips
	mayThrow	if false, fill buffer with zeros when there is failure to retrieve samples; else throw
[out]	pNumWithinClips	Report how many samples were copied from within clips, rather than filled according to fillFormat; but these were not necessarily one contiguous range.

Precondition: iChannel + nBuffers <= NChannels()

Returns: false when mayThrow is false and not all samples could be retrieved

Postcondition: if return value is false, buffers are zero-filled

Definition at line 43 of file WideSampleSequence.cpp.

{
   // Cast the pointers to pass them to DoGet() which handles multiple
   // destination formats
   const auto castBuffers = reinterpret_cast<const samplePtr*>(buffers);
   const auto result = DoGet(
      iChannel, nBuffers, castBuffers,
      floatSample, start, len, backwards, fill, mayThrow, pNumWithinClips);
   if (!result)
      while (nBuffers--)
         ClearSamples(castBuffers[nBuffers], floatSample, 0, len);
   return result;
}

◆ GetFloatsCenteredAroundTime()

std::pair< size_t, size_t > WaveTrack::GetFloatsCenteredAroundTime	(	double	t,
		size_t	iChannel,
		float *	buffer,
		size_t	numSideSamples,
		bool	mayThrow
	)		const

Gets as many samples as it can, but no more than 2 * numSideSamples + 1, centered around t. Reads nothing if GetClipAtTime(t) == nullptr. Useful to access samples across clip boundaries, as it spreads the read to adjacent clips, i.e., not separated by silence from clip at t.

Returns: The begin and end indices of the samples in the buffer where samples could actually be copied.

Definition at line 3175 of file WaveTrack.cpp.

{
   const auto numSamplesReadLeft = GetFloatsFromTime(
      t, iChannel, buffer, numSideSamples, mayThrow, PlaybackDirection::backward);
   const auto numSamplesReadRight = GetFloatsFromTime(
      t, iChannel, buffer + numSideSamples, numSideSamples + 1, mayThrow,
      PlaybackDirection::forward);
   return { numSideSamples - numSamplesReadLeft,
            numSideSamples + numSamplesReadRight };
}

References backward, forward, GetFloatsFromTime(), and anonymous_namespace{StretchingSequenceIntegrationTest.cpp}::iChannel.

Here is the call graph for this function:

◆ GetFloatsFromTime()

size_t WaveTrack::GetFloatsFromTime	(	double	t,
		size_t	iChannel,
		float *	buffer,
		size_t	numSamples,
		bool	mayThrow,
		PlaybackDirection	direction
	)		const

private

Helper for GetFloatsCenteredAroundTime. If direction == PlaybackDirection::Backward, fetches samples to the left of t, excluding t, without reversing.

See also: GetFloatsCenteredAroundTime

Returns: The number of samples actually copied.

Definition at line 3243 of file WaveTrack.cpp.

{
   RoundToNearestClipSample(*this, t);
   auto clip = GetClipAtTime(t);
   auto numSamplesRead = 0u;
   const auto forward = direction == PlaybackDirection::forward;
   while (clip)
   {
      const auto args = GetSampleAccessArgs(
         *clip, t, buffer, numSamples, numSamplesRead, forward);
      if (!clip->GetSamples(
             iChannel, args.offsetBuffer, floatSample, args.start, args.len,
             mayThrow))
         return 0u;
      numSamplesRead += args.len;
      if (numSamplesRead >= numSamples)
         break;
      clip = GetAdjacentClip(*clip, direction);
   }
   return numSamplesRead;
}

References floatSample, forward, GetAdjacentClip(), GetClipAtTime(), anonymous_namespace{WaveTrack.cpp}::GetSampleAccessArgs(), anonymous_namespace{StretchingSequenceIntegrationTest.cpp}::iChannel, and anonymous_namespace{WaveTrack.cpp}::RoundToNearestClipSample().

Referenced by GetFloatsCenteredAroundTime().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetGain()

float WaveTrack::GetGain ( ) const

Definition at line 1112 of file WaveTrack.cpp.

{
   return WaveTrackData::Get(*this).GetGain();
}

References BasicUI::Get().

Referenced by WaveTrackControls::GainSlider(), GetChannelGain(), GetInfoCommand::SendTracks(), SetGain(), and WriteOneXML().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetIdealBlockSize()

size_t WaveTrack::GetIdealBlockSize ( )

Definition at line 2721 of file WaveTrack.cpp.

{
   // ignore extra channels (this function will soon be removed)
   return NewestOrNewClip()->GetSequence(0)->GetIdealBlockSize();
}

References Sequence::GetIdealBlockSize(), WaveClip::GetSequence(), and NewestOrNewClip().

Referenced by WaveChannel::GetIdealBlockSize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetIntervalAtTime()

WaveTrack::IntervalHolder WaveTrack::GetIntervalAtTime ( double t )

Definition at line 528 of file WaveTrack.cpp.

{
   IntervalHolder result;
   for (const auto& interval : Intervals())
      if (interval->WithinPlayRegion(t))
         return interval;
   return nullptr;
}

References Intervals().

Referenced by ApplyStretchRatio().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetLeftmostClip()

const WaveClip * WaveTrack::GetLeftmostClip ( ) const

Definition at line 2992 of file WaveTrack.cpp.

                                                 {
   if (mClips.empty())
      return nullptr;
   return std::min_element(
             mClips.begin(), mClips.end(),
             [](const auto& a, const auto b) {
                return a->GetPlayStartTime() < b->GetPlayStartTime();
             })
      ->get();
}

References mClips.

Referenced by PasteOne().

Here is the caller graph for this function:

◆ GetMaxBlockSize()

size_t WaveTrack::GetMaxBlockSize ( ) const

Definition at line 2699 of file WaveTrack.cpp.

{
   decltype(GetMaxBlockSize()) maxblocksize = 0;
   for (const auto &clip : mClips)
      for (size_t ii = 0, width = clip->GetWidth(); ii < width; ++ii)
         maxblocksize = std::max(maxblocksize,
            clip->GetSequence(ii)->GetMaxBlockSize());
 
   if (maxblocksize == 0)
   {
      // We really need the maximum block size, so create a
      // temporary sequence to get it.
      maxblocksize =
         Sequence{ mpFactory, SampleFormats{GetSampleFormat(), GetSampleFormat()} }
            .GetMaxBlockSize();
   }
 
   wxASSERT(maxblocksize > 0);
 
   return maxblocksize;
}

References GetMaxBlockSize(), GetSampleFormat(), mClips, and mpFactory.

Referenced by EffectTruncSilence::Analyze(), CompareAudioCommand::Apply(), GetBestBlockSize(), WaveChannel::GetMaxBlockSize(), GetMaxBlockSize(), EffectCompressor::InitPass1(), EffectNoiseRemoval::ProcessOne(), EffectStereoToMono::ProcessOne(), PerTrackEffect::ProcessPass(), ReverseOneClip(), VoiceKey::TestDirectionChanges(), VoiceKey::TestEnergy(), and VoiceKey::TestSignChanges().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetMute()

bool WaveTrack::GetMute ( ) const

overridevirtual

May vary asynchronously.

Implements PlayableSequence.

Definition at line 2788 of file WaveTrack.cpp.

{
   return PlayableTrack::GetMute();
}

References PlayableTrack::GetMute().

Referenced by ExportAudioDialog::DoExportSplitByTracks(), ExportUtils::FindExportWaveTracks(), anonymous_namespace{ExportAudioDialog.cpp}::GetNumExportChannels(), GetInfoCommand::SendTracks(), and ExportAudioDialog::UpdateTrackExportSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetNextClip() [1/2]

WaveClip * WaveTrack::GetNextClip	(	const WaveClip &	clip,
		PlaybackDirection	searchDirection
	)

Returns clips next to clip in the given direction, or nullptr if there is none.

Definition at line 3712 of file WaveTrack.cpp.

{
   return const_cast<WaveClip*>(
      std::as_const(*this).GetNextClip(clip, direction));
}

◆ GetNextClip() [2/2]

const WaveClip * WaveTrack::GetNextClip	(	const WaveClip &	clip,
		PlaybackDirection	searchDirection
	)		const

Returns clips next to clip in the given direction, or nullptr if there is none.

Definition at line 3688 of file WaveTrack.cpp.

{
   const auto clips = SortedClipArray();
   const auto p = std::find(clips.begin(), clips.end(), &clip);
   if (p == clips.end())
      return nullptr;
   else if (direction == PlaybackDirection::forward)
      return p == clips.end() - 1 ? nullptr : *(p + 1);
   else
      return p == clips.begin() ? nullptr : *(p - 1);
}

References forward, and SortedClipArray().

Referenced by GetAdjacentClip(), and SetFloatsWithinTimeRange().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetNextInterval() [1/2]

WaveTrack::IntervalHolder WaveTrack::GetNextInterval	(	const Interval &	interval,
		PlaybackDirection	searchDirection
	)

Returns: Interval that starts after(before) the beginning of the passed interval

Definition at line 521 of file WaveTrack.cpp.

{
   return std::const_pointer_cast<Interval>(
      std::as_const(*this).GetNextInterval(interval, searchDirection));
}

◆ GetNextInterval() [2/2]

std::shared_ptr< const WaveTrack::Interval > WaveTrack::GetNextInterval	(	const Interval &	interval,
		PlaybackDirection	searchDirection
	)		const

Returns: Interval that starts after(before) the beginning of the passed interval

Definition at line 499 of file WaveTrack.cpp.

{
   std::shared_ptr<const Interval> result;
   auto bestMatchTime = searchDirection == PlaybackDirection::forward
      ? std::numeric_limits<double>::max()
      : std::numeric_limits<double>::lowest();
 
   for(const auto& other : Intervals())
   {
      if((searchDirection == PlaybackDirection::forward &&
         (other->Start() > interval.Start() && other->Start() < bestMatchTime))
         ||
         (searchDirection == PlaybackDirection::backward &&
         (other->Start() < interval.Start() && other->Start() > bestMatchTime)))
      {
         result = other;
         bestMatchTime = other->Start();
      }
   }
   return result;
}

References backward, forward, Intervals(), and ChannelGroupInterval::Start().

Referenced by ApplyStretchRatio(), anonymous_namespace{WaveClipAdjustBorderHandle.cpp}::GetLeftAdjustLimit(), anonymous_namespace{WaveClipAdjustBorderHandle.cpp}::GetRightAdjustLimit(), and ChangeClipSpeedDialog::SetClipSpeedFromDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetNumClips() [1/2]

int WaveTrack::GetNumClips ( ) const

Definition at line 3831 of file WaveTrack.cpp.

{
   return mClips.size();
}

References mClips.

Referenced by ApplyStretchRatio(), and PasteOne().

Here is the caller graph for this function:

◆ GetNumClips() [2/2]

int WaveTrack::GetNumClips	(	double	t0,
		double	t1
	)		const

Definition at line 3836 of file WaveTrack.cpp.

{
   const auto clips = SortedClipArray();
   // Find first position where the comparison is false
   const auto firstIn = std::lower_bound(clips.begin(), clips.end(), t0,
      [](const auto& clip, double t0) {
         return clip->GetPlayEndTime() <= t0;
      });
   // Find first position where the comparison is false
   const auto firstOut = std::lower_bound(firstIn, clips.end(), t1,
      [](const auto& clip, double t1) {
         return clip->GetPlayStartTime() < t1;
      });
   return std::distance(firstIn, firstOut);
}

References SortedClipArray().

Here is the call graph for this function:

◆ GetOne()

bool WaveTrack::GetOne	(	samplePtr	buffer,
		sampleFormat	format,
		sampleCount	start,
		size_t	len,
		bool	backwards,
		fillFormat	fill,
		bool	mayThrow,
		sampleCount *	pNumWithinClips
	)		const

private

Definition at line 3359 of file WaveTrack.cpp.

{
   if (backwards)
      start -= len;
   // Simple optimization: When this buffer is completely contained within one clip,
   // don't clear anything (because we won't have to). Otherwise, just clear
   // everything to be on the safe side.
   bool doClear = true;
   bool result = true;
   sampleCount samplesCopied = 0;
   for (const auto &clip: mClips)
   {
      if (start >= clip->GetPlayStartSample() && start+len <= clip->GetPlayEndSample())
      {
         doClear = false;
         break;
      }
   }
   if (doClear)
   {
      // Usually we fill in empty space with zero
      if (fill == FillFormat::fillZero)
         ClearSamples(buffer, format, 0, len);
      // but we don't have to.
      else if (fill == FillFormat::fillTwo)
      {
         wxASSERT( format==floatSample );
         float * pBuffer = (float*)buffer;
         for(size_t i=0;i<len;i++)
            pBuffer[i]=2.0f;
      }
      else
      {
         wxFAIL_MSG(wxT("Invalid fill format"));
      }
   }
 
   // Iterate the clips.  They are not necessarily sorted by time.
   for (const auto &clip: mClips)
   {
      auto clipStart = clip->GetPlayStartSample();
      auto clipEnd = clip->GetPlayEndSample();
 
      if (clipEnd > start && clipStart < start+len)
      {
         // Yes, exact comparison
         if (clip->GetStretchRatio() != 1.0)
            return false;
 
         // Clip sample region and Get/Put sample region overlap
         auto samplesToCopy =
            std::min( start+len - clipStart, clip->GetVisibleSampleCount() );
         auto startDelta = clipStart - start;
         decltype(startDelta) inclipDelta = 0;
         if (startDelta < 0)
         {
            inclipDelta = -startDelta; // make positive value
            samplesToCopy -= inclipDelta;
            // samplesToCopy is now either len or
            //    (clipEnd - clipStart) - (start - clipStart)
            //    == clipEnd - start > 0
            // samplesToCopy is not more than len
            //
            startDelta = 0;
            // startDelta is zero
         }
         else {
            // startDelta is nonnegative and less than len
            // samplesToCopy is positive and not more than len
         }
 
         if (!clip->GetSamples(0,
               (samplePtr)(((char*)buffer) +
                           startDelta.as_size_t() *
                           SAMPLE_SIZE(format)),
               format, inclipDelta, samplesToCopy.as_size_t(), mayThrow ))
            result = false;
         else
            samplesCopied += samplesToCopy;
      }
   }
   if( pNumWithinClips )
      *pNumWithinClips = samplesCopied;
   if (result == true && backwards)
      ReverseSamples(buffer, format, 0, len);
   return result;
}

References ClearSamples(), fillTwo, fillZero, floatSample, anonymous_namespace{ExportPCM.cpp}::format, mClips, min(), ReverseSamples(), SAMPLE_SIZE, and wxT().

Here is the call graph for this function:

◆ GetPan()

float WaveTrack::GetPan ( ) const

Definition at line 1130 of file WaveTrack.cpp.

{
   return WaveTrackData::Get(*this).GetPan();
}

References BasicUI::Get().

Referenced by GetChannelGain(), WaveTrackControls::PanSlider(), GetInfoCommand::SendTracks(), SetPan(), and WriteOneXML().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetRate()

double WaveTrack::GetRate ( ) const

overridevirtual

Implements RecordableSequence.

Definition at line 1085 of file WaveTrack.cpp.

{
   return WaveTrackData::Get(*this).GetRate();
}

References BasicUI::Get().

Referenced by ProjectFileManager::AddImportedTracks(), SelectHandle::AdjustFreqSelection(), EffectTruncSilence::Analyze(), VoiceKey::CalibrateNoise(), ClearAndPasteOne(), CopyOne(), CreateClip(), SpectrumVRulerControls::DoHandleWheelRotation(), SpectrumVZoomHandle::DoZoom(), WaveformVZoomHandle::DoZoom(), EmptyCopy(), SpectrogramBounds::GetBounds(), GetEnvelopeValues(), anonymous_namespace{WaveClipAdjustBorderHandle.cpp}::GetLeftAdjustLimit(), anonymous_namespace{WaveClipAdjustBorderHandle.cpp}::GetRightAdjustLimit(), TranscriptionToolBar::GetSamples(), InsertSilence(), JoinOne(), SelectHandle::MoveSnappingFreqSelection(), VoiceKey::OffBackward(), VoiceKey::OffForward(), VoiceKey::OnBackward(), VoiceKey::OnForward(), PasteOne(), anonymous_namespace{BrushHandle.cpp}::PositionToFrequency(), anonymous_namespace{SelectHandle.cpp}::PositionToFrequency(), EffectPaulstretch::ProcessOne(), EffectStereoToMono::ProcessOne(), SpectralDataManager::Worker::ProcessOvertones(), PerTrackEffect::ProcessPass(), SpectralDataManager::Worker::ProcessSnapping(), ProjectNyquistFrequency(), SelectHandle::SnapCenterOnce(), SelectHandle::StartSnappingFreqSelection(), anonymous_namespace{WaveTrackControls.cpp}::Status1DrawFunction(), SyncLockAdjust(), and WriteOneXML().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetRightmostClip()

const WaveClip * WaveTrack::GetRightmostClip ( ) const

Definition at line 3003 of file WaveTrack.cpp.

                                                  {
   if (mClips.empty())
      return nullptr;
   return std::max_element(
             mClips.begin(), mClips.end(),
             [](const auto& a, const auto b) {
                return a->GetPlayEndTime() < b->GetPlayEndTime();
             })
      ->get();
}

References mClips.

Referenced by ProjectAudioManager::DoRecord(), and PasteOne().

Here is the caller graph for this function:

◆ GetSampleFormat()

sampleFormat WaveTrack::GetSampleFormat ( ) const

overridevirtual

Implements RecordableSequence.

Definition at line 1220 of file WaveTrack.cpp.

{
   return WaveTrackData::Get(*this).GetSampleFormat();
}

References BasicUI::Get().

Referenced by CopyOne(), CreateClip(), EmptyCopy(), GetMaxBlockSize(), InsertSilence(), SyncLockAdjust(), and WriteOneXML().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetSampleView()

ChannelGroupSampleView WaveTrack::GetSampleView	(	double	t0,
		double	t1,
		bool	mayThrow = `true`
	)		const

Request samples within [t0, t1), not knowing in advance how many this will be.

The stretching of intersecting intervals influences the number of samples fitting into [t0, t1), i.e., half as many for twice as large a stretch ratio, due to a larger spacing of the raw samples.

Precondition: IsLeader()

Postcondition: result: result.size() == NChannels()

Precondition: samples in [t0, t1) can be counted with size_t

Definition at line 3451 of file WaveTrack.cpp.

{
   assert(IsLeader());
   ChannelGroupSampleView result;
   for (const auto& channel : Channels()) {
      result.push_back(channel->GetSampleView(t0, t1, mayThrow));
   }
   return result;
}

References Channels(), and IsLeader().

Here is the call graph for this function:

◆ GetSequenceSamplesCount()

sampleCount WaveTrack::GetSequenceSamplesCount ( ) const

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

Precondition: IsLeader()

Definition at line 1197 of file WaveTrack.cpp.

{
   assert(IsLeader());
   sampleCount result{ 0 };
 
   for (const auto pChannel : TrackList::Channels(this))
      for (const auto& clip : pChannel->mClips)
         result += clip->GetSequenceSamplesCount();
 
   return result;
}

References TrackList::Channels(), and IsLeader().

Here is the call graph for this function:

◆ GetSolo()

bool WaveTrack::GetSolo ( ) const

overridevirtual

May vary asynchronously.

Implements PlayableSequence.

Definition at line 2793 of file WaveTrack.cpp.

{
   return PlayableTrack::GetSolo();
}

References PlayableTrack::GetSolo().

Referenced by ExportAudioDialog::DoExportSplitByTracks(), ExportUtils::FindExportWaveTracks(), anonymous_namespace{ExportAudioDialog.cpp}::GetNumExportChannels(), GetInfoCommand::SendTracks(), and ExportAudioDialog::UpdateTrackExportSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetStartTime()

double WaveTrack::GetStartTime ( ) const

overridevirtual

Implement WideSampleSequence.

Implements WideSampleSequence.

Definition at line 3045 of file WaveTrack.cpp.

{
   return ChannelGroup::GetStartTime();
}

References ChannelGroup::GetStartTime().

Referenced by ApplyStretchRatio(), ClearAndPasteAtSameTempo(), Effect::GetBounds(), TranscriptionToolBar::GetSamples(), MoveTo(), PasteWaveTrackAtSameTempo(), EffectStereoToMono::ProcessOne(), GetInfoCommand::SendTracks(), and Trim().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetTypeInfo()

auto WaveTrack::GetTypeInfo ( ) const

overridevirtual

Reimplemented from WritableSampleTrack.

Definition at line 951 of file WaveTrack.cpp.

{
   return typeInfo();
}

References typeInfo().

Here is the call graph for this function:

◆ GetVisibleSampleCount()

sampleCount WaveTrack::GetVisibleSampleCount ( ) const

Definition at line 1187 of file WaveTrack.cpp.

{
    sampleCount result{ 0 };
 
    for (const auto& clip : mClips)
        result += clip->GetVisibleSampleCount();
 
    return result;
}

References mClips.

◆ GetWaveColorIndex()

int WaveTrack::GetWaveColorIndex ( ) const

Definition at line 1171 of file WaveTrack.cpp.

{
   return WaveTrackData::Get(*this).GetWaveColorIndex();
}

References BasicUI::Get().

Referenced by CreateClip(), HandleXMLChild(), InsertSilence(), and WriteOneXML().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetWidth()

size_t WaveTrack::GetWidth ( ) const

The width of every WaveClip in this track; for now always 1.

Definition at line 795 of file WaveTrack.cpp.

{
   return 1;
}

Referenced by AddClip(), ClearAndPasteOne(), and CreateClip().

Here is the caller graph for this function:

◆ HandleClear()

void WaveTrack::HandleClear	(	double	t0,
		double	t1,
		bool	addCutLines,
		bool	split,
		bool	clearByTrimming = `false`
	)

private

Exception safety guarantee:: Strong

Definition at line 1909 of file WaveTrack.cpp.

{
   // For debugging, use an ASSERT so that we stop
   // closer to the problem.
   wxASSERT( t1 >= t0 );
   if (t1 < t0)
      THROW_INCONSISTENCY_EXCEPTION;
 
   t0 = SnapToSample(t0);
   t1 = SnapToSample(t1);
 
   WaveClipPointers clipsToDelete;
   WaveClipHolders clipsToAdd;
 
   // We only add cut lines when deleting in the middle of a single clip
   // The cut line code is not really prepared to handle other situations
   if (addCutLines)
   {
      for (const auto &clip : mClips)
      {
         if (clip->PartlyWithinPlayRegion(t0, t1))
         {
            addCutLines = false;
            break;
         }
      }
   }
 
   for (const auto &clip : mClips)
   {
      if (clip->CoversEntirePlayRegion(t0, t1))
      {
         // Whole clip must be deleted - remember this
         clipsToDelete.push_back(clip.get());
      }
      else if (clip->IntersectsPlayRegion(t0, t1))
      {
         // Clip data is affected by command
         if (addCutLines)
         {
            // Don't modify this clip in place, because we want a strong
            // guarantee, and might modify another clip
            clipsToDelete.push_back( clip.get() );
            auto newClip =
               std::make_shared<WaveClip>(*clip, mpFactory, true);
            newClip->ClearAndAddCutLine( t0, t1 );
            clipsToAdd.push_back( std::move( newClip ) );
         }
         else
         {
            if (split || clearByTrimming) {
               // Three cases:
 
               if (clip->BeforePlayRegion(t0)) {
                  // Delete from the left edge
 
                  // Don't modify this clip in place, because we want a strong
                  // guarantee, and might modify another clip
                  clipsToDelete.push_back( clip.get() );
                  auto newClip =
                     std::make_shared<WaveClip>(*clip, mpFactory, true);
                  newClip->TrimLeft(t1 - clip->GetPlayStartTime());
                  if (!split)
                     // If this is not a split-cut, where things are left in
                     // place, we need to reposition the clip.
                     newClip->ShiftBy(t0 - t1);
                  clipsToAdd.push_back( std::move( newClip ) );
               }
               else if (clip->AfterPlayRegion(t1)) {
                  // Delete to right edge
 
                  // Don't modify this clip in place, because we want a strong
                  // guarantee, and might modify another clip
                  clipsToDelete.push_back( clip.get() );
                  auto newClip =
                     std::make_shared<WaveClip>(*clip, mpFactory, true);
                  newClip->TrimRight(clip->GetPlayEndTime() - t0);
 
                  clipsToAdd.push_back( std::move( newClip ) );
               }
               else {
                  // Delete in the middle of the clip...we actually create two
                  // NEW clips out of the left and right halves...
 
                  auto leftClip =
                     std::make_shared<WaveClip>(*clip, mpFactory, true);
                  leftClip->TrimRight(clip->GetPlayEndTime() - t0);
                  clipsToAdd.push_back(std::move(leftClip));
 
                  auto rightClip =
                     std::make_shared<WaveClip>(*clip, mpFactory, true);
                  rightClip->TrimLeft(t1 - clip->GetPlayStartTime());
                  if (!split)
                     // If this is not a split-cut, where things are left in
                     // place, we need to reposition the clip.
                     rightClip->ShiftBy(t0 - t1);
                  clipsToAdd.push_back(std::move(rightClip));
 
                  clipsToDelete.push_back(clip.get());
               }
            }
            else {
               // (We are not doing a split cut)
 
               // Don't modify this clip in place, because we want a strong
               // guarantee, and might modify another clip
               clipsToDelete.push_back( clip.get() );
               auto newClip =
                  std::make_shared<WaveClip>(*clip, mpFactory, true);
 
               // clip->Clear keeps points < t0 and >= t1 via Envelope::CollapseRegion
               newClip->Clear(t0,t1);
 
               clipsToAdd.push_back( std::move( newClip ) );
            }
         }
      }
   }
 
   // Only now, change the contents of this track
   // use No-fail-guarantee for the rest
 
   const auto moveClipsLeft = !split && GetEditClipsCanMove();
   if (moveClipsLeft)
      // Clip is "behind" the region -- offset it unless we're splitting
      // or we're using the "don't move other clips" mode
      for (const auto& clip : mClips)
         if (clip->AtOrBeforePlayRegion(t1))
            clip->ShiftBy(-(t1 - t0));
 
   for (const auto &clip: clipsToDelete)
   {
      auto myIt = FindClip(mClips, clip);
      if (myIt != mClips.end())
         mClips.erase(myIt); // deletes the clip!
      else
         wxASSERT(false);
   }
 
   for (auto &clip: clipsToAdd)
      InsertClip(std::move(clip)); // transfer ownership
}

References anonymous_namespace{WaveTrack.cpp}::FindClip(), GetEditClipsCanMove(), InsertClip(), mClips, mpFactory, WideSampleSequence::SnapToSample(), and THROW_INCONSISTENCY_EXCEPTION.

Referenced by ClearAndPasteOne().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HandleXMLChild()

XMLTagHandler * WaveTrack::HandleXMLChild ( const std::string_view & tag )

overridevirtual

Implements XMLTagHandler.

Definition at line 2865 of file WaveTrack.cpp.

{
   if ( auto pChild = WaveTrackIORegistry::Get()
          .CallObjectAccessor(tag, *this) )
      return pChild;
 
   //
   // This is legacy code (1.2 and previous) and is not called for NEW projects!
   //
   if (tag == "sequence" || tag == "envelope")
   {
      // This is a legacy project, so set the cached offset
      NewestOrNewClip()->SetSequenceStartTime(mLegacyProjectFileOffset);
 
      // Legacy project file tracks are imported as one single wave clip
      if (tag == "sequence")
         return NewestOrNewClip()->GetSequence(0);
      else if (tag == "envelope")
         return NewestOrNewClip()->GetEnvelope();
   }
 
   // JKC... for 1.1.0, one step better than what we had, but still badly broken.
   // If we see a waveblock at this level, we'd better generate a sequence.
   if (tag == "waveblock")
   {
      // This is a legacy project, so set the cached offset
      NewestOrNewClip()->SetSequenceStartTime(mLegacyProjectFileOffset);
      Sequence *pSeq = NewestOrNewClip()->GetSequence(0);
      return pSeq;
   }
 
   //
   // This is for the NEW file format (post-1.2)
   //
   if (tag == "waveclip")
   {
      // Make clips (which don't serialize the rate) consistent with channel rate,
      // though the consistency check of channels with each other remains to do.
      // Not all `WaveTrackData` fields are properly initialized by now,
      // use deserialization helpers.
      auto clip = std::make_shared<WaveClip>(1,
         mpFactory, mLegacyFormat, mLegacyRate, GetWaveColorIndex());
      const auto xmlHandler = clip.get();
      mClips.push_back(std::move(clip));
      return xmlHandler;
   }
 
   return nullptr;
}

References XMLMethodRegistry< Host >::Get(), WaveClip::GetEnvelope(), WaveClip::GetSequence(), GetWaveColorIndex(), mClips, mLegacyFormat, mLegacyProjectFileOffset, mLegacyRate, mpFactory, NewestOrNewClip(), and WaveClip::SetSequenceStartTime().

Here is the call graph for this function:

◆ HandleXMLEndTag()

void WaveTrack::HandleXMLEndTag ( const std::string_view & tag )

override

Definition at line 2853 of file WaveTrack.cpp.

{
#if 0
   // In case we opened a pre-multiclip project, we need to
   // simulate closing the waveclip tag.
   NewestOrNewClip()->HandleXMLEndTag("waveclip");
#else
   // File compatibility breaks have intervened long since, and the line above
   // would now have undesirable side effects
#endif
}

References WaveClip::HandleXMLEndTag(), and NewestOrNewClip().

Here is the call graph for this function:

◆ HandleXMLTag()

bool WaveTrack::HandleXMLTag	(	const std::string_view &	tag,
		const AttributesList &	attrs
	)

overridevirtual

Implements XMLTagHandler.

Definition at line 2798 of file WaveTrack.cpp.

{
   if (tag == "wavetrack") {
      double dblValue;
      long nValue;
 
      for (const auto& pair : attrs)
      {
         const auto& attr = pair.first;
         const auto& value = pair.second;
 
         if (attr == "rate")
         {
            // mRate is an int, but "rate" in the project file is a float.
            if (!value.TryGet(dblValue) ||
                  (dblValue < 1.0) || (dblValue > 1000000.0)) // allow a large range to be read
               return false;
 
            // Defer the setting of rate until LinkConsistencyFix
            mLegacyRate = lrint(dblValue);
         }
         else if (attr == "offset" && value.TryGet(dblValue))
         {
            // Offset is only relevant for legacy project files. The value
            // is cached until the actual WaveClip containing the legacy
            // track is created.
            mLegacyProjectFileOffset = dblValue;
         }
         else if (this->WritableSampleTrack::HandleXMLAttribute(attr, value))
         {}
         else if (this->Track::HandleCommonXMLAttribute(attr, value))
            ;
         else if (attr == "gain" && value.TryGet(dblValue))
            DoSetGain(dblValue);
         else if (attr == "pan" && value.TryGet(dblValue) &&
                  (dblValue >= -1.0) && (dblValue <= 1.0))
            DoSetPan(dblValue);
         else if (attr == "linked" && value.TryGet(nValue))
            SetLinkType(ToLinkType(nValue), false);
         else if (attr == "colorindex" && value.TryGet(nValue))
            // Don't use SetWaveColorIndex as it sets the clips too.
            WaveTrackData::Get(*this).SetWaveColorIndex(nValue);
         else if (attr == "sampleformat" && value.TryGet(nValue) &&
                  Sequence::IsValidSampleFormat(nValue))
         {
            //Remember sample format until consistency check is performed.
            SetLegacyFormat(static_cast<sampleFormat>(nValue));
         }
      } // while
      return true;
   }
 
   return false;
}

References DoSetGain(), DoSetPan(), BasicUI::Get(), Track::HandleCommonXMLAttribute(), PlayableTrack::HandleXMLAttribute(), Sequence::IsValidSampleFormat(), lrint, mLegacyProjectFileOffset, mLegacyRate, SetLegacyFormat(), Track::SetLinkType(), and anonymous_namespace{WaveTrack.cpp}::ToLinkType().

Here is the call graph for this function:

◆ HasHiddenData()

bool WaveTrack::HasHiddenData ( ) const

Whether any clips have hidden audio.

Precondition: IsLeader()

Definition at line 4382 of file WaveTrack.cpp.

{
   assert(IsLeader());
   for (const auto pChannel : TrackList::Channels(this))
      for (const auto& clip : pChannel->GetClips())
         if (clip->GetTrimLeft() != 0 || clip->GetTrimRight() != 0)
            return true;
   return false;
}

References TrackList::Channels(), and IsLeader().

Here is the call graph for this function:

◆ HasTrivialEnvelope()

bool WaveTrack::HasTrivialEnvelope ( ) const

overridevirtual

Returns: whether envelope values are all unit

Implements WideSampleSequence.

Definition at line 3569 of file WaveTrack.cpp.

{
   auto pTrack = this;
   if (GetOwner())
      // Substitute the leader track
      pTrack = *TrackList::Channels(this).begin();
   auto &clips = pTrack->GetClips();
   return std::all_of(clips.begin(), clips.end(),
      [](const auto &pClip){ return pClip->GetEnvelope()->IsTrivial(); });
}

References TrackList::Channels(), and Track::GetOwner().

Here is the call graph for this function:

◆ Init()

void WaveTrack::Init ( const WaveTrack & orig )

private

Definition at line 823 of file WaveTrack.cpp.

{
   WritableSampleTrack::Init(orig);
   mpFactory = orig.mpFactory;
}

References Track::Init(), and mpFactory.

Here is the call graph for this function:

◆ InsertClip()

bool WaveTrack::InsertClip ( WaveClipHolder clip )

private

Adds clip to the track. Clip should be not empty or to be a placeholder. Sets project tempo on clip upon push. Use this instead of mClips.push_back.

Returns: true on success

Definition at line 2338 of file WaveTrack.cpp.

{
   if(!clip->GetIsPlaceholder() && clip->IsEmpty())
      return false;
 
   const auto& tempo = GetProjectTempo();
   if (tempo.has_value())
      clip->OnProjectTempoChange(std::nullopt, *tempo);
   mClips.push_back(std::move(clip));
 
   return true;
}

References Track::GetProjectTempo(), and mClips.

Referenced by AddClip(), CopyOne(), HandleClear(), PasteOne(), SplitAt(), and WaveTrack().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InsertInterval()

void WaveTrack::InsertInterval ( const IntervalHolder & interval )

private

Precondition: IsLeader()

Definition at line 4118 of file WaveTrack.cpp.

{
   assert(IsLeader());
   auto channel = 0;
   for (const auto pChannel : TrackList::Channels(this))
   {
      const auto clip = interval->GetClip(channel++);
      if (clip)
         pChannel->InsertClip(clip);
   }
}

References TrackList::Channels(), and IsLeader().

Referenced by ReplaceInterval().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InsertSilence()

void WaveTrack::InsertSilence	(	double	t,
		double	len
	)

overridevirtual

Exception safety guarantee:: Strong

Implements RecordableSequence.

Definition at line 2434 of file WaveTrack.cpp.

{
   assert(IsLeader());
   // Nothing to do, if length is zero.
   // Fixes Bug 1626
   if (len == 0)
      return;
   if (len <= 0)
      THROW_INCONSISTENCY_EXCEPTION;
 
   for (const auto pChannel : TrackList::Channels(this)) {
      auto &clips = pChannel->mClips;
      if (clips.empty()) {
         // Special case if there is no clip yet
         // TODO wide wave tracks -- match clip width
         auto clip = std::make_shared<WaveClip>(1,
            mpFactory, GetSampleFormat(), GetRate(), this->GetWaveColorIndex());
         clip->InsertSilence(0, len);
         // use No-fail-guarantee
         pChannel->InsertClip(move(clip));
      }
      else
      {
         // Assume at most one clip contains t
         const auto end = clips.end();
         const auto it = std::find_if(clips.begin(), end,
            [&](const WaveClipHolder &clip) { return clip->SplitsPlayRegion(t); } );
 
         // use Strong-guarantee
         if (it != end)
            it->get()->InsertSilence(t, len);
 
         // use No-fail-guarantee
         for (const auto &clip : clips)
            if (clip->BeforePlayRegion(t))
               clip->ShiftBy(len);
      }
   }
}

References TrackList::Channels(), PackedArray::end(), GetRate(), GetSampleFormat(), GetWaveColorIndex(), IsLeader(), mpFactory, and THROW_INCONSISTENCY_EXCEPTION.

Referenced by AUPImportFileHandle::AddSilence().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Intervals() [1/2]

auto WaveTrack::Intervals ( )

inline

Definition at line 1026 of file WaveTrack.h.

1026{ return ChannelGroup::Intervals<Interval>(); }

Referenced by ProjectFileManager::AddImportedTracks(), SetClipCommand::Apply(), Disjoin(), GetIntervalAtTime(), GetNextInterval(), and Join().

Here is the caller graph for this function:

◆ Intervals() [2/2]

auto WaveTrack::Intervals ( ) const

inline

Definition at line 1027 of file WaveTrack.h.

1027{ return ChannelGroup::Intervals<const Interval>(); }

◆ IsEmpty()

bool WaveTrack::IsEmpty	(	double	t0,
		double	t1
	)		const

Returns true if there are no WaveClips in the specified region.

Returns: true if no clips in the track overlap the specified time range, false otherwise.

Definition at line 1238 of file WaveTrack.cpp.

{
   if (t0 > t1)
      return true;
 
   //wxPrintf("Searching for overlap in %.6f...%.6f\n", t0, t1);
   for (const auto &clip : mClips)
   {
      if (clip->IntersectsPlayRegion(t0, t1)) {
         //wxPrintf("Overlapping clip: %.6f...%.6f\n",
         //       clip->GetStartTime(),
         //       clip->GetEndTime());
         // We found a clip that overlaps this region
         return false;
      }
   }
   //wxPrintf("No overlap found\n");
 
   // Otherwise, no clips overlap this region
   return true;
}

References mClips.

Referenced by PasteOne(), and SyncLockAdjust().

Here is the caller graph for this function:

◆ IsLeader()

bool WaveTrack::IsLeader ( ) const

overridevirtual

Implements RecordableSequence.

Definition at line 2778 of file WaveTrack.cpp.

{
   return Track::IsLeader();
}

References Track::IsLeader().

Referenced by AUPImportFileHandle::AddSilence(), EffectTruncSilence::Analyze(), ApplyStretchRatio(), Clear(), ClearAndAddCutLine(), ClearAndPasteAtSameTempo(), Clone(), CloseLock(), ConvertToSampleFormat(), CountBlocks(), CreateWideClip(), Cut(), DEFINE_ATTACHED_VIRTUAL_OVERRIDE(), DiscardTrimmed(), Disjoin(), SpectrumView::DoDraw(), WaveformView::DoDraw(), DoGet(), DoOnProjectTempoChange(), EffectTruncSilence::DoRemoval(), ExpandCutLine(), EffectSBSMS::Finalize(), Flush(), FormatConsistencyCheck(), Effect::GetBounds(), GetChannelType(), GetClipInterfaces(), GetErrorOpening(), GetSampleView(), GetSequenceSamplesCount(), HasHiddenData(), InsertInterval(), InsertSilence(), Join(), LinkConsistencyFix(), MoveTo(), NChannels(), Paste(), PasteInto(), PasteWaveTrackAtSameTempo(), TrackSpectrumTransformer::PostProcess(), RateConsistencyCheck(), Reinit(), RemoveCutLine(), RemoveInterval(), ReplaceInterval(), SetWaveColorIndex(), Silence(), Split(), SplitCut(), SplitDelete(), SyncLockAdjust(), Trim(), and WideEmptyCopy().

Here is the call graph for this function:

◆ Join()

void WaveTrack::Join	(	double	t0,
		double	t1,
		const ProgressReporter &	reportProgress
	)

Precondition: IsLeader()

Exception safety guarantee:: Weak

Definition at line 2565 of file WaveTrack.cpp.

{
   assert(IsLeader());
   // Merge all WaveClips overlapping selection into one
   const auto intervals = Intervals();
   std::vector<IntervalHolder> intervalsToJoin;
   for (auto interval : intervals)
      if (interval->IntersectsPlayRegion(t0, t1))
         intervalsToJoin.push_back(interval);
   if (intervalsToJoin.size() < 2u)
      return;
   if (std::any_of(
          intervalsToJoin.begin() + 1, intervalsToJoin.end(),
          [first =
              intervalsToJoin[0]->GetStretchRatio()](const auto& interval) {
             return first != interval->GetStretchRatio();
          }))
      ApplyStretchRatioOnIntervals(intervalsToJoin, reportProgress);
 
   for (const auto pChannel : TrackList::Channels(this))
      JoinOne(*pChannel, t0, t1);
}

References ApplyStretchRatioOnIntervals(), TrackList::Channels(), Intervals(), IsLeader(), and JoinOne().

Referenced by anonymous_namespace{LabelMenus.cpp}::OnJoinLabels().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ JoinOne()

void WaveTrack::JoinOne	(	WaveTrack &	track,
		double	t0,
		double	t1
	)

staticprivate

Precondition: All clips intersecting [t0, t1) have unit stretch ratio

Definition at line 2589 of file WaveTrack.cpp.

{
   WaveClipPointers clipsToDelete;
   WaveClip* newClip{};
 
   const auto rate = track.GetRate();
   auto &clips = track.mClips;
   for (const auto &clip: clips) {
      if (clip->IntersectsPlayRegion(t0, t1)) {
         // Put in sorted order
         auto it = clipsToDelete.begin(), end = clipsToDelete.end();
         for (; it != end; ++it)
            if ((*it)->GetPlayStartTime() > clip->GetPlayStartTime())
               break;
         //wxPrintf("Insert clip %.6f at position %d\n", clip->GetStartTime(), i);
         clipsToDelete.insert(it, clip.get());
      }
   }
 
   //if there are no clips to DELETE, nothing to do
   if (clipsToDelete.empty())
      return;
 
   auto t = clipsToDelete[0]->GetPlayStartTime();
   //preserve left trim data if any
   newClip = track.CreateClip(clipsToDelete[0]->GetSequenceStartTime(),
      clipsToDelete[0]->GetName());
 
   for (auto clip : clipsToDelete) {
      // wxPrintf("t=%.6f adding clip (offset %.6f, %.6f ... %.6f)\n",
      //       t, clip->GetOffset(), clip->GetStartTime(),
      //       clip->GetEndTime());
 
      if (clip->GetPlayStartTime() - t > (1.0 / rate))
      {
         double addedSilence = (clip->GetPlayStartTime() - t);
         // wxPrintf("Adding %.6f seconds of silence\n");
         auto offset = clip->GetPlayStartTime();
         auto value = clip->GetEnvelope()->GetValue(offset);
         newClip->AppendSilence(addedSilence, value);
         t += addedSilence;
      }
 
      // wxPrintf("Pasting at %.6f\n", t);
      bool success = newClip->Paste(t, *clip);
      assert(success); // promise of CreateClip
 
      t = newClip->GetPlayEndTime();
 
      auto it = FindClip(clips, clip);
      clips.erase(it); // deletes the clip
   }
}

References CreateClip(), PackedArray::end(), anonymous_namespace{WaveTrack.cpp}::FindClip(), Track::GetName(), WaveClip::GetPlayStartTime(), GetRate(), and mClips.

Referenced by Join().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LinkConsistencyFix()

bool WaveTrack::LinkConsistencyFix ( bool doFix )

overridevirtual

Check consistency of channel groups, and maybe fix it.

Parameters

doFix whether to make any changes to correct inconsistencies

Precondition: !doFix || IsLeader()

Returns: true if no inconsistencies were found

Reimplemented from Track.

Definition at line 875 of file WaveTrack.cpp.

{
   assert(!doFix || IsLeader());
 
 
   const auto removeZeroClips = [](WaveClipHolders& clips) {
      // Check for zero-length clips and remove them
      for (auto it = clips.begin(); it != clips.end();)
      {
         if ((*it)->IsEmpty())
            it = clips.erase(it);
         else
            ++it;
      }
   };
 
   auto err = !WritableSampleTrack::LinkConsistencyFix(doFix);
 
   const auto linkType = GetLinkType();
   if (linkType != LinkType::None) {
      auto next = *TrackList::Channels(this).first.advance(1);
      if (next == nullptr) {
         //next track is absent or not a wave track, fix and report error
         if (doFix) {
            wxLogWarning(L"Right track %s is expected to be a WaveTrack."
               "\n Removing link from left wave track %s.",
               next->GetName(), GetName());
            SetLinkType(LinkType::None);
         }
         err = true;
      }
      else if (doFix) {
         // non-error upgrades happen here
         if (!AreAligned(SortedClipArray(), next->SortedClipArray()) ||
             !RateConsistencyCheck() || !FormatConsistencyCheck())
         {
            SetLinkType(LinkType::None);
         }
         else
         {
            SetLinkType(LinkType::Aligned);
            // Be sure to lose any right channel group data that might
            // have been made during during deserialization of the channel
            // before joining it
            next->DestroyGroupData();
            //clean up zero clips only after alignment check has completed
            //this can't break alignment as there should be a "twin"
            //in the right channel which will also be removed, otherwise
            //track will be unlinked
            removeZeroClips(next->mClips);
         }
      }
   }
   if (doFix) {
      // More non-error upgrading
      // Set the common channel group rate from the leader's rate
      if (mLegacyRate > 0)
      {
         SetRate(mLegacyRate);
         mLegacyRate = 0;
         if (mLegacyFormat != undefinedSample)
            WaveTrackData::Get(*this).SetSampleFormat(mLegacyFormat);
      }
      removeZeroClips(mClips);
   }
   return !err;
}

References ChannelGroup::Aligned, anonymous_namespace{WaveTrack.cpp}::AreAligned(), TrackList::Channels(), FormatConsistencyCheck(), BasicUI::Get(), Track::GetLinkType(), Track::GetName(), IsLeader(), Track::LinkConsistencyFix(), mClips, mLegacyFormat, mLegacyRate, ChannelGroup::None, RateConsistencyCheck(), Track::SetLinkType(), SetRate(), SortedClipArray(), and undefinedSample.

Here is the call graph for this function:

◆ MakeClipCopyName()

wxString WaveTrack::MakeClipCopyName ( const wxString & originalName ) const

private

Definition at line 1061 of file WaveTrack.cpp.

{
   auto name = originalName;
   for (auto i = 1;; ++i)
   {
      if (FindClipByName(name) == nullptr)
         return name;
      //i18n-hint Template for clip name generation on copy-paste
      name = XC("%s.%i", "clip name template").Format(originalName, i).Translation();
   }
}

References FindClipByName(), name, and XC.

Referenced by PasteOne().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MakeNewClipName()

wxString WaveTrack::MakeNewClipName ( ) const

private

Definition at line 1073 of file WaveTrack.cpp.

{
   auto name = GetName();
   for (auto i = 1;; ++i)
   {
      if (FindClipByName(name) == nullptr)
         return name;
      //i18n-hint Template for clip name generation on inserting new empty clip
      name = XC("%s %i", "clip name template").Format(GetName(), i).Translation();
   }
}

References FindClipByName(), Track::GetName(), name, and XC.

Referenced by NewestOrNewClip(), PasteOne(), and RightmostOrNewClip().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MergeClips()

bool WaveTrack::MergeClips	(	int	clipidx1,
		int	clipidx2
	)

Definition at line 4065 of file WaveTrack.cpp.

{
   const auto channels = TrackList::Channels(this);
   return std::all_of(channels.begin(), channels.end(),
      [&](const auto pChannel){
         return pChannel->MergeOneClipPair(clipidx1, clipidx2); });
}

References TrackList::Channels().

Here is the call graph for this function:

◆ MergeOneClipPair()

bool WaveTrack::MergeOneClipPair	(	int	clipidx1,
		int	clipidx2
	)

private

Exception safety guarantee:: Strong

Definition at line 4074 of file WaveTrack.cpp.

{
   WaveClip* clip1 = GetClipByIndex(clipidx1);
   WaveClip* clip2 = GetClipByIndex(clipidx2);
 
   if (!clip1 || !clip2) // Could happen if one track of a linked pair had a split and the other didn't.
      return false; // Don't throw, just do nothing.
 
   const auto stretchRatiosEqual = clip1->HasEqualStretchRatio(*clip2);
   if (!stretchRatiosEqual)
      return false;
 
   // Append data from second clip to first clip
   // use Strong-guarantee
   bool success = clip1->Paste(clip1->GetPlayEndTime(), *clip2);
   assert(success);  // assuming clips of the same track must have same width
 
   // use No-fail-guarantee for the rest
   // Delete second clip
   auto it = FindClip(mClips, clip2);
   mClips.erase(it);
 
   return true;
}

References anonymous_namespace{WaveTrack.cpp}::FindClip(), GetClipByIndex(), WaveClip::GetPlayEndTime(), WaveClip::HasEqualStretchRatio(), mClips, and WaveClip::Paste().

Referenced by ClearAndPasteOne().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MonoToStereo()

TrackListHolder WaveTrack::MonoToStereo ( )

Precondition: !GetOwner()

Definition at line 1355 of file WaveTrack.cpp.

{
   assert(!GetOwner());
 
   auto result = Duplicate();
   result->MakeMultiChannelTrack(**result->begin(), 2);
 
   return result;
}

References Track::Duplicate(), and Track::GetOwner().

Here is the call graph for this function:

◆ MoveTo()

void WaveTrack::MoveTo ( double origin )

overridevirtual

Exception safety guarantee:: No-fail

Implements ChannelGroup.

Definition at line 845 of file WaveTrack.cpp.

{
   double delta = origin - GetStartTime();
   assert(IsLeader());
   for (const auto pChannel : TrackList::Channels(this)) {
      for (const auto &clip : pChannel->mClips)
         // assume No-fail-guarantee
         clip->ShiftBy(delta);
   }
   WaveTrackData::Get(*this).SetOrigin(origin);
}

References TrackList::Channels(), BasicUI::Get(), GetStartTime(), and IsLeader().

Here is the call graph for this function:

◆ NChannels()

size_t WaveTrack::NChannels ( ) const

overridevirtual

May report more than one only when this is a leader track.

Implements RecordableSequence.

Definition at line 800 of file WaveTrack.cpp.

{
   if (IsLeader() && GetOwner()) {
      auto result = TrackList::NChannels(*this);
      assert(result > 0);
      return result;
   }
   else
      return 1;
}

References Track::GetOwner(), IsLeader(), and TrackList::NChannels().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ New()

WaveTrack * WaveTrack::New ( AudacityProject & project )

static

Definition at line 767 of file WaveTrack.cpp.

{
   auto &trackFactory = WaveTrackFactory::Get( project );
   auto &tracks = TrackList::Get( project );
   auto result = tracks.Add(trackFactory.Create());
   result->AttachedTrackObjects::BuildAll();
   return result;
}

References TrackList::Get(), WaveTrackFactory::Get(), project, and tracks.

Here is the call graph for this function:

◆ NewestOrNewClip()

WaveClip * WaveTrack::NewestOrNewClip ( )

Get access to the most recently added clip, or create a clip, if there is not already one. THIS IS NOT NECESSARILY RIGHTMOST.

Returns: a pointer to the most recently added WaveClip

Definition at line 3780 of file WaveTrack.cpp.

{
   if (mClips.empty()) {
      return CreateClip(WaveTrackData::Get(*this).GetOrigin(), MakeNewClipName());
   }
   else
      return mClips.back().get();
}

References CreateClip(), BasicUI::Get(), MakeNewClipName(), and mClips.

Referenced by GetIdealBlockSize(), HandleXMLChild(), and HandleXMLEndTag().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NIntervals()

size_t WaveTrack::NIntervals ( ) const

overridevirtual

used only during deserialization

Implements ChannelGroup.

Definition at line 982 of file WaveTrack.cpp.

{
   return mClips.size();
}

References mClips.

Referenced by DoGetInterval().

Here is the caller graph for this function:

◆ Paste() [1/3]

virtual void Track::Paste	(	double	t,
		const Track &	src
	)

virtual

Weak precondition allows overrides to replicate one channel into many.

Precondition: IsLeader(); SameKindAs(src); src.NChannels() == 1 || src.NChannels() == NChannels()

Implements Track.

◆ Paste() [2/3]

void Track::Paste	(	double	t,
		const TrackList &	src
	)

Non-virtual overload that passes the first track of a given list

Precondition: IsLeader(); SameKindAs(**src.begin()).NChannels(); NChannels == (**src.begin()).NChannels()

Definition at line 364 of file Track.cpp.

{
   Paste(t, **src.begin());
}

◆ Paste() [3/3]

void WaveTrack::Paste	(	double	t0,
		const Track &	src
	)

overridevirtual

Exception safety guarantee:: Weak

Implements Track.

Definition at line 2393 of file WaveTrack.cpp.

{
   assert(IsLeader()); // pre of Track::Paste
   if (const auto other = dynamic_cast<const WaveTrack*>(&src))
   {
      // Currently `Paste` isn't used by code that wants the newer "don't merge
      // when copy/pasting" behaviour ...
      constexpr auto merge = true;
      PasteWaveTrack(t0, *other, merge);
   }
   else
      // THROW_INCONSISTENCY_EXCEPTION; // ?
      (void)0;// Empty if intentional.
}

References IsLeader(), and PasteWaveTrack().

Referenced by EffectStereoToMono::ProcessOne().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PasteInto()

Track::Holder WaveTrack::PasteInto	(	AudacityProject &	project,
		TrackList &	list
	)		const

overridevirtual

Find or create the destination track for a paste, maybe in a different project

Precondition: IsLeader()

Parameters

list	to which any newly created tracks are added; but left unchanged if an existing track is found in the project instead

Returns: A smart pointer to a leader track

Implements Track.

Definition at line 961 of file WaveTrack.cpp.

{
   assert(IsLeader());
   auto &trackFactory = WaveTrackFactory::Get(project);
   auto &pSampleBlockFactory = trackFactory.GetSampleBlockFactory();
   Track::Holder pFirstTrack;
   const WaveTrack *pFirstChannel{};
   for (const auto pChannel : TrackList::Channels(this)) {
      auto pNewTrack = pChannel->EmptyCopy(pSampleBlockFactory);
      list.Add(pNewTrack);
      assert(pNewTrack->IsLeader() == pChannel->IsLeader());
      if (!pFirstTrack) {
         pFirstTrack = pNewTrack;
         pFirstChannel = pChannel;
      }
   }
   pFirstTrack->Paste(0.0, *pFirstChannel);
   return pFirstTrack;
}

References TrackList::Add(), TrackList::Channels(), EmptyCopy(), WaveTrackFactory::Get(), IsLeader(), and project.

Here is the call graph for this function:

◆ PasteOne()

void WaveTrack::PasteOne	(	WaveTrack &	track,
		double	t0,
		const WaveTrack &	other,
		double	startTime,
		double	insertDuration,
		bool	merge = `true`
	)

staticprivate

Definition at line 2131 of file WaveTrack.cpp.

{
    //
    // Pasting is a bit complicated, because with the existence of multiclip mode,
    // we must guess the behaviour the user wants.
    //
    // Currently, two modes are implemented:
    //
    // - If a single clip should be pasted, and it should be pasted inside another
    //   clip, no NEW clips are generated. The audio is simply inserted.
    //   This resembles the old (pre-multiclip support) behaviour. However, if
    //   the clip is pasted outside of any clip, a NEW clip is generated. This is
    //   the only behaviour which is different to what was done before, but it
    //   shouldn't confuse users too much.
    //
    // - If multiple clips should be pasted, or a single clip that does not fill
    // the duration of the pasted track, these are always pasted as single
    // clips, and the current clip is split, when necessary. This may seem
    // strange at first, but it probably is better than trying to auto-merge
    // anything. The user can still merge the clips by hand (which should be a
    // simple command reachable by a hotkey or single mouse click).
    //
 
    if (other.GetNumClips() == 0)
        return;
 
    t0 = track.SnapToSample(t0);
 
    //wxPrintf("paste: we have at least one clip\n");
 
    const auto clipAtT0 = track.GetClipAtTime(t0);
    const auto otherFirstClip = other.GetLeftmostClip();
    const auto otherLastClip = other.GetRightmostClip();
    const auto stretchRatiosMatch =
       !clipAtT0 || (clipAtT0->HasEqualStretchRatio(*otherFirstClip) &&
                     clipAtT0->HasEqualStretchRatio(*otherLastClip));
 
    // `singleClipMode` will try to merge. Only allow this if clips on both ends
    // of the selection have equal stretch ratio.
    const bool singleClipMode =
       other.GetNumClips() == 1 &&
       std::abs(startTime) < track.LongSamplesToTime(1) * 0.5 &&
       stretchRatiosMatch && merge;
 
    const auto rate = track.GetRate();
    if (insertDuration != 0 && insertDuration < 1.0 / rate)
        // PRL:  I added this check to avoid violations of preconditions in other WaveClip and Sequence
        // methods, but allow the value 0 so I don't subvert the purpose of commit
        // 739422ba70ceb4be0bb1829b6feb0c5401de641e which causes append-recording always to make
        // a new clip.
        return;
 
    //wxPrintf("Check if we need to make room for the pasted data\n");
 
    auto pastingFromTempTrack = !other.GetOwner();
    bool editClipCanMove = GetEditClipsCanMove();
 
    const SimpleMessageBoxException notEnoughSpaceException {
       ExceptionType::BadUserAction,
       XO("There is not enough room available to paste the selection"),
       XO("Warning"), "Error:_Insufficient_space_in_track"
    };
 
    // Make room for the pasted data
    if (editClipCanMove) {
        if (!singleClipMode) {
            // We need to insert multiple clips, so split the current clip and ...
            track.SplitAt(t0);
        }
        //else if there is a clip at t0 insert new clip inside it and ...
 
        // ... move everything to the right
        for (const auto& clip : track.mClips)
            if (clip->GetPlayStartTime() > t0 - (1.0 / rate))
                clip->ShiftBy(insertDuration);
    }
    else
    {
       if (!merge)
          track.SplitAt(t0);
       const auto clipAtT0 = track.GetClipAtTime(t0);
       const auto t = clipAtT0 ? clipAtT0->GetPlayEndTime() : t0;
       if (!track.IsEmpty(t, t + insertDuration))
          throw notEnoughSpaceException;
    }
 
    // See if the clipboard data is one clip only and if it should be merged. If
    // edit-clip-can-move mode is checked, merging happens only if the pasting
    // point splits a clip. If it isn't, merging also happens when the pasting
    // point is at the exact beginning of a clip.
    if (singleClipMode && merge) {
        // Single clip mode
        // wxPrintf("paste: checking for single clip mode!\n");
 
        WaveClip* insideClip = nullptr;
        for (const auto& clip : track.mClips) {
            if (editClipCanMove) {
                if (clip->SplitsPlayRegion(t0)) {
                    //wxPrintf("t0=%.6f: inside clip is %.6f ... %.6f\n",
                    //       t0, clip->GetStartTime(), clip->GetEndTime());
                    insideClip = clip.get();
                    break;
                }
            }
            else {
                // If clips are immovable we also allow prepending to clips
                if (clip->WithinPlayRegion(t0))
                {
                    insideClip = clip.get();
                    break;
                }
            }
        }
 
        if (insideClip) {
            // Exhibit traditional behaviour
            //wxPrintf("paste: traditional behaviour\n");
            if (!editClipCanMove) {
                // We did not move other clips out of the way already, so
                // check if we can paste without having to move other clips
                for (const auto& clip : track.mClips) {
                    if (clip->GetPlayStartTime() > insideClip->GetPlayStartTime() &&
                        insideClip->GetPlayEndTime() + insertDuration >
                        clip->GetPlayStartTime())
                        // Strong-guarantee in case of this path
                        // not that it matters.
                        throw notEnoughSpaceException;
                }
            }
            if (auto *pClip = other.GetClipByIndex(0)) {
               // This branch only gets executed in `singleClipMode` - we've
               // already made sure that stretch ratios are equal, satisfying
               // `WaveClip::Paste`'s precondition.
               bool success = insideClip->Paste(t0, *pClip);
               // TODO wide wave tracks -- prove success, or propagate failure,
               // or we might throw a MessageBoxException
               // (which would require a change in base class Track)
               // for now it would be quiet failure if clip widths mismatched
               // Can't yet assert(success);
            }
            return;
        }
        // Just fall through and exhibit NEW behaviour
    }
 
    // Insert NEW clips
    //wxPrintf("paste: multi clip mode!\n");
 
    if (!editClipCanMove &&
        !track.IsEmpty(t0, t0 + insertDuration - 1.0 / rate))
        // Strong-guarantee in case of this path
        // not that it matters.
        throw notEnoughSpaceException;
 
    for (const auto& clip : other.mClips) {
        // AWD Oct. 2009: Don't actually paste in placeholder clips
        if (!clip->GetIsPlaceholder()) {
            auto newClip =
                std::make_shared<WaveClip>(*clip, track.mpFactory, true);
            newClip->Resample(rate);
            newClip->ShiftBy(t0);
            newClip->MarkChanged();
            if (pastingFromTempTrack)
                //Clips from the tracks which aren't bound to any TrackList are
                //considered to be new entities, thus named using "new" name template
                newClip->SetName(track.MakeNewClipName());
            else
                newClip->SetName(track.MakeClipCopyName(clip->GetName()));
            track.InsertClip(std::move(newClip)); // transfer ownership
        }
    }
}

References BadUserAction, GetClipAtTime(), GetClipByIndex(), GetEditClipsCanMove(), GetLeftmostClip(), GetNumClips(), Track::GetOwner(), WaveClip::GetPlayEndTime(), WaveClip::GetPlayStartTime(), GetRate(), GetRightmostClip(), InsertClip(), IsEmpty(), WideSampleSequence::LongSamplesToTime(), MakeClipCopyName(), MakeNewClipName(), mClips, mpFactory, WaveClip::Paste(), WideSampleSequence::SnapToSample(), SplitAt(), and XO().

Referenced by ClearAndPasteOne(), PasteWaveTrackAtSameTempo(), and SyncLockAdjust().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PasteWaveTrack()

void WaveTrack::PasteWaveTrack	(	double	t0,
		const WaveTrack &	other,
		bool	merge
	)

private

Definition at line 2100 of file WaveTrack.cpp.

{
   // Get a modifiable copy of `src` because it may come from another project
   // with different tempo, making boundary queries incorrect.
   const auto& tempo = GetProjectTempo();
   if (!tempo.has_value())
      THROW_INCONSISTENCY_EXCEPTION;
   WaveTrack* copy;
   const auto copyHolder = other.DuplicateWithOtherTempo(*tempo, copy);
   PasteWaveTrackAtSameTempo(t0, *copy, merge);
}

References staffpad::vo::copy(), DuplicateWithOtherTempo(), Track::GetProjectTempo(), PasteWaveTrackAtSameTempo(), and THROW_INCONSISTENCY_EXCEPTION.

Referenced by ClearAndPasteAtSameTempo(), and Paste().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PasteWaveTrackAtSameTempo()

void WaveTrack::PasteWaveTrackAtSameTempo	(	double	t0,
		const WaveTrack &	other,
		bool	merge
	)

private

Definition at line 2112 of file WaveTrack.cpp.

{
   assert(IsLeader());
   const auto otherNChannels = other.NChannels();
   assert(otherNChannels == 1 || otherNChannels == NChannels());
   assert(
      GetProjectTempo().has_value() &&
      GetProjectTempo() == other.GetProjectTempo());
   const auto startTime = other.GetStartTime();
   const auto endTime = other.GetEndTime();
   auto iter = TrackList::Channels(&other).begin();
   for (const auto pChannel : TrackList::Channels(this)) {
      PasteOne(*pChannel, t0, **iter, startTime, endTime, merge);
      if (otherNChannels > 1)
         ++iter;
   }
}

References TrackList::Channels(), GetEndTime(), Track::GetProjectTempo(), GetStartTime(), IsLeader(), NChannels(), and PasteOne().

Referenced by PasteWaveTrack().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ProjectNyquistFrequency()

double WaveTrack::ProjectNyquistFrequency ( const AudacityProject & project )

static

Definition at line 696 of file WaveTrack.cpp.

{
   auto &tracks = TrackList::Get(project);
   return std::max(ProjectRate::Get(project).GetRate(),
      tracks.Any<const WaveTrack>().max(&WaveTrack::GetRate))
      / 2.0;
}

References ProjectRate::Get(), TrackList::Get(), GetRate(), project, and tracks.

Referenced by SelectFrequenciesCommand::Apply().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RateConsistencyCheck()

bool WaveTrack::RateConsistencyCheck ( ) const

private

Whether all clips of a leader track have a common rate.

Precondition: IsLeader()

Definition at line 2306 of file WaveTrack.cpp.

{
   assert(IsLeader());
 
   // The channels and all clips in them should have the same sample rate.
   std::optional<double> oRate;
   auto channels = TrackList::Channels(this);
   return std::all_of(channels.begin(), channels.end(),
      [&](const WaveTrack *pTrack){
         if (!pTrack)
            return false;
 
         const auto rate = pTrack->mLegacyRate;
         if (!oRate)
            oRate = rate;
         else if (*oRate != rate)
            return false;
         return true;
      });
}

References TrackList::Channels(), and IsLeader().

Referenced by LinkConsistencyFix().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ReallyDoGetChannelGroup()

ChannelGroup & WaveTrack::ReallyDoGetChannelGroup ( ) const

overrideprivatevirtual

This is temporary! It defaults to call the above.

Reimplemented from Channel.

Definition at line 1034 of file WaveTrack.cpp.

{
   const Track *pTrack = this;
   if (const auto pOwner = GetHolder())
      pTrack = *pOwner->Find(this);
   const ChannelGroup &group = *pTrack;
   return const_cast<ChannelGroup&>(group);
}

References ClientData::Site< Host, ClientData, ObjectCopyingPolicy, Pointer, ObjectLockingPolicy, RegistryLockingPolicy >::Find(), and Track::GetHolder().

Here is the call graph for this function:

◆ Reinit()

void WaveTrack::Reinit ( const WaveTrack & orig )

Overwrite data excluding the sample sequence but including display settings

Precondition: IsLeader(); orig.IsLeader(); NChannels() == orig.NChannels()

Definition at line 829 of file WaveTrack.cpp.

{
   assert(IsLeader());
   assert(orig.IsLeader());
   assert(NChannels() == orig.NChannels());
   const auto channels = TrackList::Channels(this);
   auto iter = TrackList::Channels(&orig).begin();
   for (const auto pChannel : channels)
      pChannel->Init(**iter++);
}

References TrackList::Channels(), IsLeader(), and NChannels().

Referenced by ProjectAudioManager::DoRecord().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RemoveAndReturnClip()

std::shared_ptr< WaveClip > WaveTrack::RemoveAndReturnClip ( WaveClip * clip )

Definition at line 1879 of file WaveTrack.cpp.

{
   // Be clear about who owns the clip!!
   auto it = FindClip(mClips, clip);
   if (it != mClips.end()) {
      auto result = std::move(*it); // Array stops owning the clip, before we shrink it
      mClips.erase(it);
      return result;
   }
   else
      return {};
}

References anonymous_namespace{WaveTrack.cpp}::FindClip(), and mClips.

Referenced by ReverseOne().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RemoveCutLine()

bool WaveTrack::RemoveCutLine ( double cutLinePosition )

Remove cut line, without expanding the audio in it.

Definition at line 4049 of file WaveTrack.cpp.

{
   assert(IsLeader());
 
   bool removed = false;
   for (const auto pChannel : TrackList::Channels(this))
      for (const auto &clip : pChannel->mClips)
         if (clip->RemoveCutLine(cutLinePosition)) {
            removed = true;
            break;
         }
 
   return removed;
}

References TrackList::Channels(), and IsLeader().

Here is the call graph for this function:

◆ RemoveInterval()

void WaveTrack::RemoveInterval ( const IntervalHolder & interval )

private

Precondition: IsLeader()

Definition at line 4130 of file WaveTrack.cpp.

{
   assert(IsLeader());
   auto channel = 0;
   for (const auto pChannel : TrackList::Channels(this))
   {
      const auto clip = interval->GetClip(channel);
      if (clip)
         pChannel->RemoveAndReturnClip(clip.get());
      ++channel;
   }
}

References TrackList::Channels(), and IsLeader().

Referenced by ReplaceInterval().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ReplaceInterval()

void WaveTrack::ReplaceInterval	(	const IntervalHolder &	oldOne,
		const IntervalHolder &	newOne
	)

private

Precondition: IsLeader(); oldOne->NChannels() == newOne->NChannels()

Definition at line

Classes

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ Holder

◆ IntervalConstHolder

◆ IntervalHolder

◆ ProgressReport

◆ Regions

Constructor & Destructor Documentation

◆ WaveTrack() [1/2]

◆ WaveTrack() [2/2]

◆ ~WaveTrack()

Member Function Documentation

◆ AddClip()

◆ Append()

◆ ApplyStretchRatio()

◆ ApplyStretchRatioOne()

◆ ApplyStretchRatioOnIntervals()

◆ CanInsertClip()

◆ CanOffsetClips()

◆ Channels() [1/2]

◆ Channels() [2/2]

◆ ClassTypeInfo()

◆ Clear()

◆ ClearAndAddCutLine()

◆ ClearAndPaste() [1/2]

◆ ClearAndPaste() [2/2]

◆ ClearAndPasteAtSameTempo()

◆ ClearAndPasteOne()

◆ Clone()

◆ CloseLock()

◆ ConvertToSampleFormat()

◆ Copy()

◆ CopyClipEnvelopes()

◆ CopyOne()

◆ CountBlocks()

◆ CreateClip()

◆ CreateWideClip()

◆ Cut()

◆ DiscardTrimmed()

◆ Disjoin()

◆ DoGet()

◆ DoGetChannel()

◆ DoGetChannelGroup()

◆ DoGetInterval()

◆ DoOnProjectTempoChange()

◆ DoSetGain()

◆ DoSetPan()

◆ DoSetRate()

◆ DuplicateWithOtherTempo()

◆ EmptyCopy()

◆ ExpandCutLine()

◆ ExpandOneCutLine()

◆ FindChannelGroup()

◆ FindClipByName()

◆ Flush()

◆ FlushOne()

◆ FormatConsistencyCheck()

◆ GetAdjacentClip() [1/2]

◆ GetAdjacentClip() [2/2]

◆ GetAllClips() [1/2]

◆ GetAllClips() [2/2]

◆ GetBestBlockSize()

◆ GetChannel() [1/2]

◆ GetChannel() [2/2]

◆ GetChannelGain()

◆ GetChannelType()

◆ GetClipAtTime() [1/2]

◆ GetClipAtTime() [2/2]

◆ GetClipByIndex() [1/2]

◆ GetClipByIndex() [2/2]

◆ GetClipIndex()