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

#include <WaveTrack.h>

Inheritance diagram for WaveTrack:

Collaboration diagram for WaveTrack:

Classes
struct	CreateToken

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

Public Types
using	Interval = WaveClip

using	IntervalHolder = std::shared_ptr< Interval >

using	IntervalHolders = std::vector< IntervalHolder >

using	IntervalConstHolder = std::shared_ptr< const Interval >

using	IntervalConstHolders = std::vector< IntervalConstHolder >

using	Regions = std::vector< Region >

using	Holder = std::shared_ptr< WaveTrack >

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 = ChannelGroupAttachments

using	Interval = WideChannelGroupInterval

Public Types inherited from Observer::Publisher< WaveTrackMessage >
using	message_type = WaveTrackMessage

using	CallbackReturn = std::conditional_t< true, void, bool >

using	Callback = std::function< CallbackReturn(const WaveTrackMessage &) >
	Type of functions that can be connected to the Publisher. More...

Public Member Functions
	WaveTrack (CreateToken &&, const SampleBlockFactoryPtr &pFactory, sampleFormat format, double rate)
	Don't call directly, but use Create. More...

const SampleBlockFactoryPtr &	GetSampleBlockFactory () const

size_t	NChannels () const override
	A constant property. 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	Init (const WaveTrack &orig)

virtual	~WaveTrack ()

void	MoveTo (double o) override

void	ShiftBy (double t0, double delta) 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)
	!brief Sets the new rate for the track without resampling it More...

float	GetVolume () const

void	SetVolume (float newVolume)

float	GetPan () const

void	SetPan (float newPan)

float	GetChannelVolume (int channel) const override
	Takes volume and pan into account. More...

sampleCount	GetVisibleSampleCount () const

sampleFormat	GetSampleFormat () const override

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

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

Holder	EmptyCopy (size_t nChannels, const SampleBlockFactoryPtr &pFactory={}) const

Holder	EmptyCopy (const SampleBlockFactoryPtr &pFactory={}) const

void	MakeMono ()
	Simply discard any right channel. More...

Holder	MonoToStereo ()

std::vector< Holder >	SplitChannels ()

void	SwapChannels ()

Track::Holder	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	Silence (double t0, double t1, ProgressReporter reportProgress) override

void	InsertSilence (double t, double len) override

void	Split (double t0, double t1)

std::pair< IntervalHolder, IntervalHolder >	SplitAt (double t)

void	ClearAndAddCutLine (double t0, double t1)

Holder	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	ApplyPitchAndSpeed (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 (size_t iChannel, constSamplePtr buffer, sampleFormat format, size_t len, unsigned int stride=1, sampleFormat effectiveFormat=widestSampleFormat) override

void	Flush () override

void	RepairChannels () 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...

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

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

IntervalHolder	GetLeftmostClip ()

IntervalConstHolder	GetLeftmostClip () const

IntervalHolder	GetRightmostClip ()

IntervalConstHolder	GetRightmostClip () const

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

IntervalHolder	CreateClip (double offset=.0, const wxString &name=wxEmptyString, const Interval *pToCopy=nullptr, bool copyCutlines=true)

IntervalHolder	CopyClip (const Interval &toCopy, bool copyCutlines)
	Create new clip and add it to this track. More...

IntervalHolder	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...

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

int	GetNumClips () const

IntervalHolders	SortedIntervalArray ()
	Return all WaveClips sorted by clip play start time. More...

IntervalConstHolders	SortedIntervalArray () const
	Return all WaveClips sorted by clip play start time. More...

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

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

bool	MergeClips (int clipidx1, int clipidx2)

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

bool	SetFloats (const float const buffers, sampleCount start, size_t len, sampleFormat effectiveFormat=widestSampleFormat)
	Random-access assignment of a range of samples. More...

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

void	InsertInterval (const IntervalHolder &interval, bool newClip, bool allowEmpty=false)

void	RemoveInterval (const IntervalHolder &interval)

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

bool	HasClipNamed (const wxString &name) const

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

IntervalHolder	GetClip (size_t iInterval)

IntervalConstHolder	GetClip (size_t iInterval) const
	used only during deserialization More...

void	SetLegacyFormat (sampleFormat format)

int	GetClipIndex (const Interval &clip) const
	Get the linear index of a given clip (== number of clips if not found) More...

void	ZipClips (bool mustAlign=true)

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

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

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

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	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 > >

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

LinkType	GetLinkType () const noexcept

	Track ()

	Track (const Track &orig, ProtectedCreationArg &&)

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

virtual	~Track ()

void	Init (const Track &orig)

virtual Holder	Duplicate (DuplicateOptions={}) const
	public nonvirtual duplication function that invokes Clone() More...

void	ReparentAllAttachments ()

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)

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

virtual Holder	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...

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

void	AdjustPositions ()

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

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

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	ShiftBy (double t0, double delta)=0
	Shift all intervals that starts after `t0` by `delta` seconds. More...

virtual void	MoveTo (double o)=0
	Change start time to given time point. 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...

std::shared_ptr< Channel >	NthChannel (size_t nChannel)

std::shared_ptr< const Channel >	NthChannel (size_t nChannel) const

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	GetChannelVolume (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 (size_t iChannel, constSamplePtr buffer, sampleFormat format, size_t len, unsigned int stride, sampleFormat effectiveFormat)=0
	Append the sample data to the track. You must call Flush() after the last Append. More...

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

virtual void	RepairChannels ()=0

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

Public Member Functions inherited from Observer::Publisher< WaveTrackMessage >
	Publisher (ExceptionPolicy *pPolicy=nullptr, Alloc a={})
	Constructor supporting type-erased custom allocation/deletion. More...

	Publisher (Publisher &&)=default

Publisher &	operator= (Publisher &&)=default

Subscription	Subscribe (Callback callback)
	Connect a callback to the Publisher; later-connected are called earlier. More...

Subscription	Subscribe (Object &obj, Return(Object::*callback)(Args...))
	Overload of Subscribe takes an object and pointer-to-member-function. More...

Static Public Member Functions
static wxString	GetDefaultAudioTrackNamePreference ()

static double	ProjectNyquistFrequency (const AudacityProject &project)

static WaveTrack *	New (AudacityProject &project)

static Holder	Create (const SampleBlockFactoryPtr &pFactory, sampleFormat format, double rate)
	Factory builds all AttachedTrackObjects. More...

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 void	CopyAttachments (Track &dst, const Track &src, bool deep)
	Copy (deep) or just share (!deep) AttachedTrackObjects. More...

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...

Static Public Attributes
static const char *	WaveTrack_tag = "wavetrack"

Static Public Attributes inherited from Observer::Publisher< WaveTrackMessage >
static constexpr bool	notifies_all

Private Member Functions
std::ptrdiff_t	FindClip (const Interval &clip)

void	RemoveClip (std::ptrdiff_t distance)

Track::Holder	Clone (bool backup) const override

wxString	MakeClipCopyName (const wxString &originalName) const

wxString	MakeNewClipName () const

void	CopyWholeClip (const Interval &clip, double t0, bool forClipboard)

void	CopyPartOfClip (const Interval &clip, double t0, double t1, bool forClipboard)

void	FinishCopy (double t0, double t1, bool forClipboard)

IntervalConstHolders	SortedClipArray () const
	Return all WaveClips sorted by clip play start time. More...

IntervalConstHolder	GetClipAtTime (double time) const

void	CreateRight ()

WaveClipHolder	DoCreateClip (double offset=.0, const wxString &name=wxEmptyString) const
	Create a new clip that can be inserted later into the track. More...

bool	InsertClip (WaveClipHolders &clips, WaveClipHolder clip, bool newClip, bool backup, bool allowEmpty)

void	CopyClips (WaveClipHolders &clips, SampleBlockFactoryPtr pFactory, const WaveClipHolders &orig, bool backup)

void	MergeChannelAttachments (WaveTrack &&other)

void	EraseChannelAttachments (size_t index)
	Erase all attachments for a given index. More...

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	ExpandOneCutLine (double cutLinePosition, double cutlineStart, double cutlineEnd)

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

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

WaveClipHolders &	NarrowClips ()

const WaveClipHolders &	NarrowClips () const

void	DoSetRate (double newRate)

Holder	DuplicateWithOtherTempo (double newTempo) const

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

void	DoSetPan (float value)

void	DoSetVolume (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 an unzipped leader track have a common rate. More...

bool	FormatConsistencyCheck () const

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

Static Private Member Functions
static void	JoinOne (WaveTrack &track, double t0, double t1)

static void	WriteOneXML (const WaveChannel &channel, XMLWriter &xmlFile, size_t iChannel, size_t nChannels)

Private Attributes
WaveChannel	mChannel

std::optional< WaveChannel >	mRightChannel
	may be null More...

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 { 0 }

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)

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 >
void	ForCorresponding (Site &other, const Function &function, bool create=true)

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...

template<typename Function >
void	EraseIf (const Function &function)
	Erase attached objects satisfying a predicate. 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

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

Protected Member Functions inherited from Observer::Publisher< WaveTrackMessage >
CallbackReturn	Publish (const WaveTrackMessage &message)
	Send a message to connected callbacks. 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...

Detailed Description

A Track that contains audio waveform data.

Definition at line 200 of file WaveTrack.h.

Member Typedef Documentation

◆ Holder

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

Definition at line 247 of file WaveTrack.h.

◆ Interval

using WaveTrack::Interval = WaveClip

Definition at line 208 of file WaveTrack.h.

◆ IntervalConstHolder

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

Definition at line 211 of file WaveTrack.h.

◆ IntervalConstHolders

using WaveTrack::IntervalConstHolders = std::vector<IntervalConstHolder>

Definition at line 212 of file WaveTrack.h.

◆ IntervalHolder

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

Definition at line 209 of file WaveTrack.h.

◆ IntervalHolders

using WaveTrack::IntervalHolders = std::vector<IntervalHolder>

Definition at line 210 of file WaveTrack.h.

◆ Regions

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

Definition at line 230 of file WaveTrack.h.

Constructor & Destructor Documentation

◆ WaveTrack()

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

Don't call directly, but use Create.

Definition at line 494 of file WaveTrack.cpp.

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

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

Here is the call graph for this function:

◆ ~WaveTrack()

WaveTrack::~WaveTrack ( )

virtual

Definition at line 559 of file WaveTrack.cpp.

560{

561}

Member Function Documentation

◆ Append()

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

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.

Precondition: iChannel < NChannels()

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 2248 of file WaveTrack.cpp.

{
   assert(iChannel < NChannels());
   auto pTrack = this;
   constSamplePtr buffers[]{ buffer };
   auto pClip = RightmostOrNewClip();
   return pClip->Append(iChannel, 1,
      buffers, format, len, stride, effectiveFormat);
}

References anonymous_namespace{ExportPCM.cpp}::format, anonymous_namespace{StretchingSequenceIntegrationTest.cpp}::iChannel, NChannels(), and RightmostOrNewClip().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ApplyPitchAndSpeed()

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

Definition at line 1945 of file WaveTrack.cpp.

{
   // 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->HasPitchOrSpeed())
      Split(startTime, startTime);
   if (auto clipAtT1 = GetClipAtTime(endTime);
       clipAtT1 && clipAtT1->SplitsPlayRegion(endTime) &&
       clipAtT1->HasPitchOrSpeed())
      Split(endTime, endTime);
 
   IntervalHolders srcIntervals;
   auto clip = GetIntervalAtTime(startTime);
   while (clip && clip->GetPlayStartTime() < endTime)
   {
      if (clip->HasPitchOrSpeed())
         srcIntervals.push_back(clip);
      clip = GetNextInterval(*clip, PlaybackDirection::forward);
   }
 
   ApplyPitchAndSpeedOnIntervals(srcIntervals, reportProgress);
}

References ApplyPitchAndSpeedOnIntervals(), forward, GetClipAtTime(), GetEndTime(), GetIntervalAtTime(), GetNextInterval(), GetNumClips(), GetStartTime(), min(), WideSampleSequence::SnapToSample(), and Split().

Referenced by Silence().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ApplyPitchAndSpeedOne()

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

private

◆ ApplyPitchAndSpeedOnIntervals()

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

private

Definition at line 3207 of file WaveTrack.cpp.

{
   IntervalHolders dstIntervals;
   dstIntervals.reserve(srcIntervals.size());
   std::transform(
      srcIntervals.begin(), srcIntervals.end(),
      std::back_inserter(dstIntervals), [&](const IntervalHolder& interval) {
         return GetRenderedCopy(interval,
            reportProgress, 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 ApplyPitchAndSpeed(), and Join().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CanInsertClip()

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

Definition at line 3113 of file WaveTrack.cpp.

{
   const auto &clips = Intervals();
   if (clips.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(
      clips.begin(), clips.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;
   auto iter = clips.begin();
   std::advance(iter, std::distance(overlaps.begin(), maxOverlap));
   const auto overlappedClip = *iter;
   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(
          clips.begin(), clips.end(),
          [&](const auto& pClip)
          {
             const auto result = pClip->IntersectsPlayRegion(
                SnapToSample(candidateClipStartTime + requiredOffset),
                SnapToSample(candidateClipEndTime + requiredOffset));
             return result;
          }))
      return false;
   slideBy = requiredOffset;
   return true;
}

References Intervals(), and WideSampleSequence::SnapToSample().

Here is the call graph for this function:

◆ CanOffsetClips()

bool WaveTrack::CanOffsetClips	(	const std::vector< Interval * > &	movingClips,
		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

	movingClips	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 3054 of file WaveTrack.cpp.

{
   if (allowedAmount)
      *allowedAmount = amount;
 
   const auto &moving = [&](Interval *clip){
      // linear search might be improved, but expecting few moving clips
      // compared with the fixed clips
      return movingClips.end() !=
         std::find(movingClips.begin(), movingClips.end(), clip);
   };
 
   for (const auto &c: Intervals()) {
      if ( moving( c.get() ) )
         continue;
      for (const auto clip : movingClips) {
         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(movingClips, *allowedAmount, nullptr)) {
         *allowedAmount = 0; // play safe and don't allow anything
         return false;
      }
      else
         return true;
   } else
      return true;
}

References CanOffsetClips(), and Intervals().

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 263 of file WaveTrack.h.

263 {

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

Referenced by TruncSilenceBase::Analyze(), CompareAudioCommand::Apply(), SetTrackVisualsCommand::ApplyInner(), DEFINE_ATTACHED_VIRTUAL_OVERRIDE(), WaveChannelSubView::DoDetailedHitTest(), TruncSilenceBase::DoRemoval(), ImportUtils::ForEachChannel(), GetChannelType(), WaveChannelUtilities::GetEnvelopeAtTime(), WaveChannelView::GetFirst(), GetIdealBlockSize(), GetSampleView(), LoudnessBase::LoadBufferBlock(), PerTrackEffect::ProcessPass(), SetFloats(), and LoudnessBase::StoreBufferBlock().

Here is the caller graph for this function:

◆ Channels() [2/2]

auto WaveTrack::Channels ( ) const

inline

Definition at line 265 of file WaveTrack.h.

265 {

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

◆ ClassTypeInfo()

auto WaveTrack::ClassTypeInfo ( )

static

Definition at line 689 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 1161 of file WaveTrack.cpp.

{
   HandleClear(t0, t1, false, false);
}

References HandleClear().

Referenced by Cut(), TruncSilenceBase::DoRemoval(), anonymous_namespace{LabelMenus.cpp}::OnCutLabels(), TrackSpectrumTransformer::PostProcess(), StereoToMono::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

Exception safety guarantee:: Strong

Definition at line 1167 of file WaveTrack.cpp.

{
   HandleClear(t0, t1, true, false);
}

References HandleClear().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ClearAndPaste()

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: 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 1219 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(*this);
   if (!tempo.has_value())
      THROW_INCONSISTENCY_EXCEPTION;
   const auto copyHolder = src.DuplicateWithOtherTempo(*tempo);
   ClearAndPasteAtSameTempo(
      t0, t1, *copyHolder, preserve, merge, effectWarper, clearByTrimming);
}

References ClearAndPasteAtSameTempo(), DuplicateWithOtherTempo(), GetProjectTempo(), and THROW_INCONSISTENCY_EXCEPTION.

Referenced by SBSMSBase::Finalize(), anonymous_namespace{EditMenus.cpp}::OnPaste(), and PerTrackEffect::ProcessPass().

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 1238 of file WaveTrack.cpp.

{
   const auto srcNChannels = src.NChannels();
   assert(srcNChannels == NChannels());
   assert(
      GetProjectTempo(*this).has_value() &&
      GetProjectTempo(*this) == GetProjectTempo(src));
 
   t0 = SnapToSample(t0);
   t1 = SnapToSample(t1);
 
   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 &track = *this;
 
   std::vector<SplitInfo> splits;
   IntervalHolders 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.Intervals()) {
      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 = track.CopyClip(*clip, 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 = track.CopyClip(*clip, false);
            it->left->SetTrimRight(.0);
            it->left->ClearLeft(clip->GetPlayEndTime());
         }
         it->leftClipName = clip->GetName();
      }
 
      // Search for cut lines
      auto cutlines = clip->GetCutLines();
      for (auto &cut : cutlines) {
         const auto unrounded =
            clip->GetSequenceStartTime() + cut->GetSequenceStartTime();
         const double cs = roundTime(unrounded);
 
         // Remember cut point
         if (cs >= t0 && cs <= t1) {
            // Remember the absolute offset and add to our cuts array.
            cut->SetSequenceStartTime(cs);
            bool removed = clip->RemoveCutLine(unrounded);
            assert(removed);
            cuts.push_back(move(cut));
         }
      }
   }
 
   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
   track.PasteWaveTrackAtSameTempo(t0, src, 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.SortedIntervalArray();
 
         // Scan the sorted clips for the first clip whose start time
         // exceeds the pasted regions end time.
         IntervalHolder prev;
         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->HasEqualPitchAndSpeed(*prev))
                  track.MergeClips(
                     track.GetClipIndex(*prev), track.GetClipIndex(*clip));
               break;
            }
            prev = clip;
         }
      }
 
      {
         // Refill the array since clips have changed.
         auto clips = track.SortedIntervalArray();
 
         // Scan the sorted clips to look for the start of the pasted
         // region.
         IntervalHolder prev;
         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->HasEqualPitchAndSpeed(*prev))
                  track.MergeClips(
                     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 = [](Interval& target, Interval& 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,
         // pitch and speed.
         assert(target.NChannels() == src.NChannels());
         assert(target.HasEqualPitchAndSpeed(src));
 
         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 = [](Interval &target, Interval &src)
      {
         // See `attachLeft` for rationale behind these asserts.
         assert(target.GetTrimRight() == 0);
         if (target.GetTrimRight() != 0)
            return;
         assert(target.NChannels() == src.NChannels());
         assert(target.HasEqualPitchAndSpeed(src));
 
         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.Intervals()) {
            // 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 = CopyClip(*clip, 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);
               track.InsertInterval(move(newClip), false);
               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.Intervals()) {
            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.Intervals()) {
         const double st = clip->GetPlayStartTime();
         const double et = clip->GetPlayEndTime();
 
         // Scan the cuts for any that live within this clip
         for (auto &cut : cuts) {
            if (!cut)
               continue;
 
            //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->AddCutLine(cut);
               cut = {};
            }
         }
      }
   }
}

References CopyClip(), GetEndTime(), GetProjectTempo(), min(), WideChannelGroupInterval::NChannels(), NChannels(), PasteWaveTrack(), WideSampleSequence::SnapToSample(), and TimeWarper::Warp().

Referenced by ClearAndPaste().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Clone()

Track::Holder WaveTrack::Clone ( bool backup ) const

overrideprivatevirtual

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

Parameters

backup whether the duplication is for backup purposes while opening a project, instead of other editing operations

Postcondition: result tracks have same TrackIds as the channels of this

Implements Track.

Definition at line 778 of file WaveTrack.cpp.

{
   auto newTrack = EmptyCopy(NChannels());
   if(backup)
   {
      //Init-time rate and format should be preserved as initialization
      //phase is not yet completed for that track.
      newTrack->mLegacyFormat = mLegacyFormat;
      newTrack->mLegacyRate = mLegacyRate;
   }
   newTrack->CopyClips(newTrack->mClips,
      newTrack->mpFactory, this->mClips, backup);
   return newTrack;
}

References EmptyCopy(), mLegacyFormat, mLegacyRate, and NChannels().

Here is the call graph for this function:

◆ ConvertToSampleFormat()

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

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

Definition at line 924 of file WaveTrack.cpp.

{
   for (const auto &pClip : Intervals())
      pClip->ConvertToSampleFormat(format, progressReport);
   WaveTrackData::Get(*this).SetSampleFormat(format);
}

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

Here is the call graph for this function:

◆ Copy()

Track::Holder 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

Implements Track.

Definition at line 1097 of file WaveTrack.cpp.

{
   if (t1 < t0)
      THROW_INCONSISTENCY_EXCEPTION;
 
   auto newTrack = EmptyCopy(NChannels());
   for (const auto pClip : Intervals()) {
      // 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.
      if (pClip->IsEmpty())
         continue;
      else if (t0 <= pClip->GetPlayStartTime() && t1 >= pClip->GetPlayEndTime())
      {
         newTrack->CopyWholeClip(*pClip, t0, forClipboard);
      }
      else if (pClip->CountSamples(t0, t1) >= 1) {
         newTrack->CopyPartOfClip(*pClip, t0, t1, forClipboard);
      }
   }
   newTrack->FinishCopy(t0, t1, forClipboard);
   return newTrack;
}

References EmptyCopy(), Intervals(), NChannels(), and THROW_INCONSISTENCY_EXCEPTION.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CopyClip()

auto WaveTrack::CopyClip	(	const Interval &	toCopy,
		bool	copyCutlines
	)

Create new clip and add it to this track.

Returns a pointer to the newly created clip, using this track's block factory but copying all else from the given clip, except possibly the cutlines.

Definition at line 2975 of file WaveTrack.cpp.

{
   return CreateClip(toCopy.GetSequenceStartTime(),
      toCopy.GetName(), &toCopy, copyCutlines);
}

Referenced by ClearAndPasteAtSameTempo(), and HandleClear().

Here is the caller graph for this function:

◆ CopyClips()

void WaveTrack::CopyClips	(	WaveClipHolders &	clips,
		SampleBlockFactoryPtr	pFactory,
		const WaveClipHolders &	orig,
		bool	backup
	)

private

Definition at line 516 of file WaveTrack.cpp.

{
   for (const auto &clip : orig)
      InsertClip(clips,
         std::make_shared<WaveClip>(*clip, pFactory, true),
         false, backup, false);
}

References InsertClip().

Here is the call graph for this function:

◆ CopyPartOfClip()

void WaveTrack::CopyPartOfClip	(	const Interval &	clip,
		double	t0,
		double	t1,
		bool	forClipboard
	)

private

Definition at line 1131 of file WaveTrack.cpp.

{
   const auto &pFactory = GetSampleBlockFactory();
   auto newClip = std::make_shared<Interval>(
      clip, pFactory, !forClipboard, t0, t1);
   newClip->SetName(clip.GetName());
   newClip->ShiftBy(-t0);
   if (newClip->GetPlayStartTime() < 0)
      newClip->SetPlayStartTime(0);
   InsertInterval(std::move(newClip), false, false);
}

References GetSampleBlockFactory(), and InsertInterval().

Here is the call graph for this function:

◆ CopyWholeClip()

void WaveTrack::CopyWholeClip	(	const Interval &	clip,
		double	t0,
		bool	forClipboard
	)

private

Definition at line 1121 of file WaveTrack.cpp.

{
   const auto &pFactory = GetSampleBlockFactory();
   const auto newClip =
      std::make_shared<Interval>(clip, pFactory, !forClipboard);
   InsertInterval(newClip, false, false);
   newClip->ShiftBy(-t0);
}

References GetSampleBlockFactory(), and InsertInterval().

Here is the call graph for this function:

◆ Create()

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

static

Factory builds all AttachedTrackObjects.

Definition at line 503 of file WaveTrack.cpp.

{
   auto result =
      std::make_shared<WaveTrack>(CreateToken{}, pFactory, format, rate);
   // Only after make_shared returns, can weak_from_this be used, which
   // attached object factories may need
   // (but this is anyway just the factory for unit test purposes)
   result->AttachedTrackObjects::BuildAll();
   return result;
}

References anonymous_namespace{ExportPCM.cpp}::format.

Referenced by TestWaveTrackMaker::Track().

Here is the caller graph for this function:

◆ CreateClip()

auto WaveTrack::CreateClip	(	double	offset = `.0`,
		const wxString &	name = `wxEmptyString`,
		const Interval *	pToCopy = `nullptr`,
		bool	copyCutlines = `true`
	)

Create new clip that uses this track's factory but do not add it to the track

Returns a pointer to the newly created clip. Optionally initial offset and clip name may be provided, and a clip from which to copy all sample data. The clip is not owned by the track. Use InsertInterval to make it so.

Parameters

offset desired sequence (not play) start time

Definition at line 2961 of file WaveTrack.cpp.

{
   if (pToCopy) {
      auto pNewClip =
         std::make_shared<WaveClip>(*pToCopy, mpFactory, copyCutlines);
      pNewClip->SetName(name);
      pNewClip->SetSequenceStartTime(offset);
      return pNewClip;
   }
   else
      return DoCreateClip(offset, name);
}

References name.

Referenced by ProjectAudioManager::DoRecord(), FinishCopy(), AUPImportFileHandle::HandleWaveClip(), InsertSilence(), Join(), and PasteWaveTrackAtSameTempo().

Here is the caller graph for this function:

◆ CreateRight()

void WaveTrack::CreateRight ( )

private

Definition at line 2982 of file WaveTrack.cpp.

{
   mRightChannel.emplace(*this);
}

References mRightChannel.

Referenced by ZipClips().

Here is the caller graph for this function:

◆ Cut()

Track::Holder WaveTrack::Cut	(	double	t0,
		double	t1
	)

overridevirtual

Create tracks and modify this track.

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

Implements Track.

Definition at line 955 of file WaveTrack.cpp.

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

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

Here is the call graph for this function:

◆ Disjoin()

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

Exception safety guarantee:: Weak

Definition at line 2061 of file WaveTrack.cpp.

{
   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 details::end(), floatSample, Intervals(), 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:

◆ DoCreateClip()

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

private

Create a new clip that can be inserted later into the track.

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

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

Definition at line 2987 of file WaveTrack.cpp.

{
   auto clip = std::make_shared<WaveClip>(NChannels(),
      mpFactory, GetSampleFormat(), GetRate());
   clip->SetName(name);
   clip->SetSequenceStartTime(offset);
 
   const auto& tempo = GetProjectTempo(*this);
   if (tempo.has_value())
      clip->OnProjectTempoChange(std::nullopt, *tempo);
   assert(clip->NChannels() == NChannels());
   return clip;
}

References GetProjectTempo(), anonymous_namespace{TimeTrack.cpp}::GetRate(), and name.

Here is the call 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.

Implements WideSampleSequence.

Definition at line 2636 of file WaveTrack.cpp.

{
   const auto nChannels = NChannels();
   assert(iChannel + nBuffers <= nChannels); // precondition
   return std::all_of(buffers, buffers + nBuffers, [&](samplePtr buffer) {
      const auto result = GetOne(mClips, iChannel++,
         buffer, format, start, len, backwards, fill, mayThrow,
         pNumWithinClips);
      return result;
   });
}

References anonymous_namespace{ExportPCM.cpp}::format, GetOne(), anonymous_namespace{StretchingSequenceIntegrationTest.cpp}::iChannel, mClips, and NChannels().

Referenced by WaveChannel::DoGet().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DoGetChannel()

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

overrideprivatevirtual

Retrieve a channel For fixed iChannel, resulting address must be unchanging, if there has been no other mutation of this ChannelGroup

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

Implements ChannelGroup.

Definition at line 735 of file WaveTrack.cpp.

{
   auto nChannels = NChannels();
   if (iChannel >= nChannels)
      return {};
   // TODO: more-than-two-channels
   ::Channel &aliased = (iChannel == 0)
      ? mChannel
      : *mRightChannel;
   // Use aliasing constructor of std::shared_ptr
   return { shared_from_this(), &aliased };
}

References anonymous_namespace{StretchingSequenceIntegrationTest.cpp}::iChannel, mChannel, mRightChannel, and NChannels().

Here is the call graph for this function:

◆ DoGetInterval()

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

overrideprivatevirtual

Retrieve an interval.

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

Implements ChannelGroup.

Definition at line 721 of file WaveTrack.cpp.

{
   if (iInterval < NIntervals())
      return mClips[iInterval];
   return {};
}

References mClips, and NIntervals().

Here is the call graph for this function:

◆ DoSetPan()

void WaveTrack::DoSetPan ( float value )

private

Definition at line 865 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 836 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:

◆ DoSetVolume()

void WaveTrack::DoSetVolume ( float value )

private

Definition at line 847 of file WaveTrack.cpp.

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

References BasicUI::Get().

Referenced by HandleXMLTag(), and SetVolume().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DuplicateWithOtherTempo()

auto WaveTrack::DuplicateWithOtherTempo ( double newTempo ) const

private

Definition at line 589 of file WaveTrack.cpp.

{
   const auto srcCopy = Duplicate();
   ::DoProjectTempoChange(*srcCopy, newTempo);
   return std::static_pointer_cast<WaveTrack>(srcCopy);
}

References DoProjectTempoChange(), and anonymous_namespace{FloatVectorClip.cpp}::Duplicate().

Referenced by ClearAndPaste(), and PasteWaveTrack().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EmptyCopy() [1/2]

auto WaveTrack::EmptyCopy ( const SampleBlockFactoryPtr & pFactory = {} ) const

Make another channel group copying format, rate, etc. but containing no clips; with as many channels as in this

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.

Definition at line 1033 of file WaveTrack.cpp.

{
   return EmptyCopy(NChannels(), pFactory);
}

◆ EmptyCopy() [2/2]

WaveTrack::Holder WaveTrack::EmptyCopy	(	size_t	nChannels,
		const SampleBlockFactoryPtr &	pFactory = `{}`
	)		const

Make another track copying format, rate, etc. but containing no clips; with the specified number of channels.

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.

Definition at line 1012 of file WaveTrack.cpp.

{
   const auto rate = GetRate();
   auto result = std::make_shared<WaveTrack>(CreateToken{},
      pFactory, GetSampleFormat(), rate);
   if (nChannels > 1)
      result->CreateRight();
   result->Init(*this);
   // Copy state rather than BuildAll()
   Track::CopyAttachments(*result, *this, true /* deep copy */);
   // 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.
   result->DoSetRate(rate);
   result->mpFactory = pFactory ? pFactory : mpFactory;
   WaveTrackData::Get(*result).SetOrigin(0);
   return result;
}

References Track::CopyAttachments(), BasicUI::Get(), GetRate(), GetSampleFormat(), and mpFactory.

Referenced by Clone(), Copy(), WaveTrackFactory::Create(), PasteInto(), StereoToMono::ProcessOne(), and SyncLockAdjust().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EraseChannelAttachments()

void WaveTrack::EraseChannelAttachments ( size_t index )

private

Erase all attachments for a given index.

Definition at line 452 of file WaveTrack.cpp.

{
   this->AttachedTrackObjects::ForEach(
   [this, ii](TrackAttachment &attachment){
      if (const auto pAttachments =
         dynamic_cast<ChannelAttachmentsBase *>(&attachment))
         pAttachments->Erase(shared_from_this(), ii);
   });
}

References ClientData::Site< Host, ClientData, ObjectCopyingPolicy, Pointer, ObjectLockingPolicy, RegistryLockingPolicy >::ForEach().

Referenced by MakeMono().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExpandOneCutLine()

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

private

◆ FindChannelGroup()

const ChannelGroup * WaveTrack::FindChannelGroup ( ) const

overridevirtual

Find associated ChannelGroup if any.

Implements PlayableSequence.

Definition at line 2334 of file WaveTrack.cpp.

{
   return this;
}

◆ FindClip()

std::ptrdiff_t WaveTrack::FindClip ( const Interval & clip )

private

Definition at line 1533 of file WaveTrack.cpp.

{
   auto clips = Intervals();
   const auto begin = clips.begin();
   const auto pred = [&](auto pClip){ return pClip.get() == &clip; };
   auto iter = std::find_if(begin, clips.end(), pred);
   return std::distance(begin, iter);
}

References details::begin(), and Intervals().

Referenced by Join(), and ReplaceInterval().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FinishCopy()

void WaveTrack::FinishCopy	(	double	t0,
		double	t1,
		bool	forClipboard
	)

private

Definition at line 1144 of file WaveTrack.cpp.

{
   // 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 && GetEndTime() + 1.0 / GetRate() < t1 - t0) {
      auto placeholder = CreateClip();
      placeholder->SetIsPlaceholder(true);
      placeholder->InsertSilence(0, (t1 - t0) - GetEndTime());
      placeholder->ShiftBy(GetEndTime());
      InsertInterval(move(placeholder), true, false);
   }
}

References CreateClip(), GetEndTime(), GetRate(), and InsertInterval().

Here is the call 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 2315 of file WaveTrack.cpp.

{
   if (NIntervals() == 0)
      return;
   // After appending, presumably.  Do this to the clip that gets appended.
   GetRightmostClip()->Flush();
}

References GetRightmostClip(), and NIntervals().

Referenced by ImportUtils::FinalizeImport(), WaveTrackSink::Flush(), TrackSpectrumTransformer::PostProcess(), and SBSMSBase::Process().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FormatConsistencyCheck()

bool WaveTrack::FormatConsistencyCheck ( ) const

private

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

Definition at line 1920 of file WaveTrack.cpp.

{
   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().

Referenced by LinkConsistencyFix().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetBestBlockSize()

size_t WaveTrack::GetBestBlockSize ( sampleCount t ) const

Definition at line 2260 of file WaveTrack.cpp.

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

References GetMaxBlockSize(), and Intervals().

Referenced by WaveChannel::GetBestBlockSize(), and anonymous_namespace{WaveTrackUtilities.cpp}::ReverseOneClip().

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 258 of file WaveTrack.h.

258 {

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

References anonymous_namespace{StretchingSequenceIntegrationTest.cpp}::iChannel.

Referenced by WaveTrackMenuTable::OnMergeStereo(), and WaveTrackMenuTable::SplitStereo().

Here is the caller graph for this function:

◆ GetChannel() [2/2]

auto WaveTrack::GetChannel ( size_t iChannel ) const

inline

Definition at line 260 of file WaveTrack.h.

260 {

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

References anonymous_namespace{StretchingSequenceIntegrationTest.cpp}::iChannel.

◆ GetChannelType()

AudioGraph::ChannelType WaveTrack::GetChannelType ( ) const

overridevirtual

Classify this channel.

Implements AudioGraph::Channel.

Definition at line 546 of file WaveTrack.cpp.

{
   // Not quite meaningful but preserving old behavior
   return (*Channels().begin())->WaveChannel::GetChannelType();
}

References details::begin(), and Channels().

Here is the call graph for this function:

◆ GetChannelVolume()

float WaveTrack::GetChannelVolume ( int channel ) const

overridevirtual

Takes volume and pan into account.

Implements WideSampleSequence.

Definition at line 888 of file WaveTrack.cpp.

{
   // channel is not necessarily less than the channel group width but
   // a mono track might pan differently according to that
   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 volume = GetVolume();
   if ((channel % 2) == 0)
      return left * volume;
   else
      return right * volume;
}

References GetPan(), and GetVolume().

Referenced by WaveChannel::GetChannelVolume(), and StereoToMono::ProcessOne().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetClip() [1/2]

auto WaveTrack::GetClip ( size_t iInterval )

Definition at line 710 of file WaveTrack.cpp.

{
   return std::static_pointer_cast<Interval>(DoGetInterval(iInterval));
}

Referenced by GetClip(), HandleXMLChild(), MergeClips(), and PasteWaveTrackAtSameTempo().

Here is the caller graph for this function:

◆ GetClip() [2/2]

auto WaveTrack::GetClip ( size_t iInterval ) const

used only during deserialization

Definition at line 715 of file WaveTrack.cpp.

{
   return const_cast<WaveTrack&>(*this).GetClip(iInterval);
}

References GetClip().

Here is the call graph for this function:

◆ GetClipAtTime()

auto WaveTrack::GetClipAtTime ( double time ) const

private

Definition at line 2951 of file WaveTrack.cpp.

{
   const auto clips = SortedClipArray();
   auto p = std::find_if(
      clips.rbegin(), clips.rend(), [&](const auto &pClip) {
         return pClip->WithinPlayRegion(time);
      });
   return p != clips.rend() ? *p : nullptr;
}

References WaveChannelUtilities::SortedClipArray().

Referenced by ApplyPitchAndSpeed().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetClipIndex()

int WaveTrack::GetClipIndex ( const Interval & clip ) const

Get the linear index of a given clip (== number of clips if not found)

Definition at line 3037 of file WaveTrack.cpp.

{
   int result = 0;
   const auto &clips = Intervals();
   const auto test =
      [&](const auto &pOtherClip){ return &clip == pOtherClip.get(); };
   auto begin = clips.begin(),
      end = clips.end(),
      iter = std::find_if(begin, end, test);
   return std::distance(begin, iter);
}

References details::begin(), details::end(), and Intervals().

Here is the call graph for this function:

◆ GetClipInterfaces()

ClipConstHolders WaveTrack::GetClipInterfaces ( ) const

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

Definition at line 2592 of file WaveTrack.cpp.

{
   auto clips = Intervals();
   return { clips.begin(), clips.end() };
}

References Intervals().

Here is the call graph for this function:

◆ GetDefaultAudioTrackNamePreference()

wxString WaveTrack::GetDefaultAudioTrackNamePreference ( )

static

Definition at line 373 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, 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 2613 of file WaveTrack.cpp.

{
   return ChannelGroup::GetEndTime();
}

References ChannelGroup::GetEndTime().

Referenced by AUPImportFileHandle::AddSilence(), TruncSilenceBase::Analyze(), ApplyPitchAndSpeed(), ClearAndPasteAtSameTempo(), FinishCopy(), Effect::GetBounds(), WaveChannel::GetEndTime(), PasteWaveTrackAtSameTempo(), TrackSpectrumTransformer::PostProcess(), StereoToMono::ProcessOne(), GetInfoCommand::SendTracks(), RateMenuTable::SetRate(), SyncLockAdjust(), and Trim().

Here is the call graph for this function:

Here is the caller 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 2874 of file WaveTrack.cpp.

{
   auto pTrack = this;
   if (!pTrack)
      return;
 
   if (backwards)
      t0 -= bufferLen / pTrack->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 = pTrack->GetRate();
   auto tstep = 1.0 / rate;
   double endTime = t0 + tstep * bufferLen;
   for (const auto &clip: pTrack->Intervals())
   {
      // 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 limitSampleBufferSize(), min(), and anonymous_namespace{RegisterBuiltinEffects.cpp}::reverse.

Referenced by WaveChannel::GetEnvelopeValues().

Here is the call graph for this function:

Here is the caller 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

Reimplemented from Track.

Definition at line 2548 of file WaveTrack.cpp.

{
   for (const auto &pClip : Intervals()) {
      const auto width = pClip->NChannels();
      for (size_t ii = 0; ii < width; ++ii)
         if (pClip->GetSequence(ii)->GetErrorOpening())
            return XO("A track has a corrupted sample sequence.");
   }
 
   return {};
}

References Intervals(), and XO().

Here is the call graph for this function:

◆ GetIdealBlockSize()

size_t WaveTrack::GetIdealBlockSize ( )

Definition at line 2300 of file WaveTrack.cpp.

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

References details::begin(), Channels(), 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 201 of file WaveTrack.cpp.

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

References Intervals().

Referenced by ApplyPitchAndSpeed().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetLeftmostClip() [1/2]

auto WaveTrack::GetLeftmostClip ( )

Definition at line 2560 of file WaveTrack.cpp.

                                                  {
   auto clips = Intervals();
   if (clips.empty())
      return nullptr;
   const auto begin = clips.begin(),
      iter = std::min_element(begin, clips.end(),
          [](const auto& a, const auto b) {
             return a->GetPlayStartTime() < b->GetPlayStartTime();
          });
   return GetClip(std::distance(begin, iter));
}

References details::begin().

Referenced by GetLeftmostClip(), and PasteWaveTrackAtSameTempo().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetLeftmostClip() [2/2]

auto WaveTrack::GetLeftmostClip ( ) const

Definition at line 2572 of file WaveTrack.cpp.

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

References GetLeftmostClip().

Here is the call graph for this function:

◆ GetMaxBlockSize()

size_t WaveTrack::GetMaxBlockSize ( ) const

Definition at line 2279 of file WaveTrack.cpp.

{
   const auto clips = Intervals();
   auto maxblocksize = std::accumulate(clips.begin(), clips.end(), size_t{},
   [](size_t acc, auto pClip){
      return std::max(acc, pClip->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 GetSampleFormat(), Intervals(), and mpFactory.

Referenced by TruncSilenceBase::Analyze(), CompareAudioCommand::Apply(), GetBestBlockSize(), WaveChannel::GetMaxBlockSize(), LegacyCompressorBase::InitPass1(), StereoToMono::ProcessOne(), PerTrackEffect::ProcessPass(), and anonymous_namespace{WaveTrackUtilities.cpp}::ReverseOneClip().

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 2339 of file WaveTrack.cpp.

{
   return PlayableTrack::GetMute();
}

References PlayableTrack::GetMute().

Referenced by ExportAudioDialog::DoExportSplitByTracks(), ExportUtils::FindExportWaveTracks(), GetInfoCommand::SendTracks(), and ExportAudioDialog::UpdateTrackExportSettings().

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 194 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 173 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 ApplyPitchAndSpeed(), WaveTrackUtilities::ExpandClipTillNextOne(), anonymous_namespace{WaveClipAdjustBorderHandle.cpp}::GetLeftAdjustLimit(), anonymous_namespace{WaveClipAdjustBorderHandle.cpp}::GetRightAdjustLimit(), and TimeStretching::SetClipStretchRatio().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetNumClips()

int WaveTrack::GetNumClips ( ) const

Definition at line 3049 of file WaveTrack.cpp.

{
   return NarrowClips().size();
}

References NarrowClips().

Referenced by ApplyPitchAndSpeed(), and PasteWaveTrackAtSameTempo().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetOne()

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

private

Definition at line 2651 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: clips)
   {
      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: clips)
   {
      auto clipStart = clip->GetPlayStartSample();
      auto clipEnd = clip->GetPlayEndSample();
 
      if (clipEnd > start && clipStart < start+len)
      {
         if (clip->HasPitchOrSpeed())
            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(iChannel,
               (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, anonymous_namespace{StretchingSequenceIntegrationTest.cpp}::iChannel, min(), ReverseSamples(), SAMPLE_SIZE, and wxT().

Referenced by DoGet().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetPan()

float WaveTrack::GetPan ( ) const

Definition at line 860 of file WaveTrack.cpp.

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

References BasicUI::Get().

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

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 821 of file WaveTrack.cpp.

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

References BasicUI::Get().

Referenced by ProjectFileManager::AddImportedTracks(), TruncSilenceBase::Analyze(), EmptyCopy(), FinishCopy(), SpectrogramBounds::GetBounds(), anonymous_namespace{WaveClipAdjustBorderHandle.cpp}::GetLeftAdjustLimit(), WaveChannel::GetRate(), anonymous_namespace{WaveClipAdjustBorderHandle.cpp}::GetRightAdjustLimit(), TranscriptionToolBar::GetSamples(), EqualizationBase::Init(), Join(), anonymous_namespace{LabelMenus.cpp}::OnJoinLabels(), WaveTrackMenuTable::OnMergeStereo(), RateMenuTable::OnRateOther(), PaulstretchBase::ProcessOne(), StereoToMono::ProcessOne(), SpectralDataManager::Worker::ProcessOvertones(), PerTrackEffect::ProcessPass(), SpectralDataManager::Worker::ProcessSnapping(), ProjectNyquistFrequency(), and SyncLockAdjust().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetRightmostClip() [1/2]

auto WaveTrack::GetRightmostClip ( )

Definition at line 2576 of file WaveTrack.cpp.

                                                   {
   auto clips = Intervals();
   if (clips.empty())
      return nullptr;
   const auto begin = clips.begin(),
      iter = std::max_element(begin, clips.end(),
          [](const auto& a, const auto b) {
             return a->GetPlayEndTime() < b->GetPlayEndTime();
          });
   return GetClip(std::distance(begin, iter));
}

References details::begin().

Referenced by Flush(), GetRightmostClip(), and PasteWaveTrackAtSameTempo().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetRightmostClip() [2/2]

auto WaveTrack::GetRightmostClip ( ) const

Definition at line 2588 of file WaveTrack.cpp.

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

References GetRightmostClip().

Here is the call graph for this function:

◆ GetSampleBlockFactory()

const SampleBlockFactoryPtr & WaveTrack::GetSampleBlockFactory ( ) const

inline

Definition at line 253 of file WaveTrack.h.

254 { return mpFactory; }

Referenced by CopyPartOfClip(), and CopyWholeClip().

Here is the caller graph for this function:

◆ GetSampleFormat()

sampleFormat WaveTrack::GetSampleFormat ( ) const

overridevirtual

Implements RecordableSequence.

Definition at line 918 of file WaveTrack.cpp.

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

References BasicUI::Get().

Referenced by EmptyCopy(), GetMaxBlockSize(), WaveChannel::GetSampleFormat(), and WaveTrackMenuTable::OnMergeStereo().

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.

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

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

Definition at line 2742 of file WaveTrack.cpp.

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

References Channels().

Here is the call graph for this function:

◆ GetSolo()

bool WaveTrack::GetSolo ( ) const

overridevirtual

May vary asynchronously.

Implements PlayableSequence.

Definition at line 2344 of file WaveTrack.cpp.

{
   return PlayableTrack::GetSolo();
}

References PlayableTrack::GetSolo().

Referenced by ExportAudioDialog::DoExportSplitByTracks(), WaveformView::Draw(), ExportUtils::FindExportWaveTracks(), 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 2603 of file WaveTrack.cpp.

{
   return ChannelGroup::GetStartTime();
}

References ChannelGroup::GetStartTime().

Referenced by ApplyPitchAndSpeed(), Effect::GetBounds(), TranscriptionToolBar::GetSamples(), WaveChannel::GetStartTime(), MoveTo(), PasteWaveTrackAtSameTempo(), StereoToMono::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 684 of file WaveTrack.cpp.

{
   return typeInfo();
}

References typeInfo().

Here is the call graph for this function:

◆ GetVisibleSampleCount()

sampleCount WaveTrack::GetVisibleSampleCount ( ) const

Definition at line 908 of file WaveTrack.cpp.

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

References Intervals().

Here is the call graph for this function:

◆ GetVolume()

float WaveTrack::GetVolume ( ) const

Definition at line 842 of file WaveTrack.cpp.

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

References BasicUI::Get().

Referenced by GetChannelVolume(), GetInfoCommand::SendTracks(), SetVolume(), and WaveTrackControls::VolumeSlider().

Here is the call graph for this function:

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 1550 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);
 
   IntervalHolders clipsToDelete;
   IntervalHolders 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 : Intervals())
         if (clip->PartlyWithinPlayRegion(t0, t1)) {
            addCutLines = false;
            break;
         }
 
   for (const auto &clip : Intervals()) {
      if (clip->CoversEntirePlayRegion(t0, t1))
         // Whole clip must be deleted - remember this
         clipsToDelete.push_back(clip);
      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);
            auto newClip = CopyClip(*clip, true);
            newClip->ClearAndAddCutLine(t0, t1);
            clipsToAdd.push_back(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);
                  auto newClip = CopyClip(*clip, 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(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);
                  auto newClip = CopyClip(*clip, true);
                  newClip->TrimRight(clip->GetPlayEndTime() - t0);
 
                  clipsToAdd.push_back(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 = CopyClip(*clip, true);
                  leftClip->TrimRight(clip->GetPlayEndTime() - t0);
                  clipsToAdd.push_back(move(leftClip));
 
                  auto rightClip = CopyClip(*clip, 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(move(rightClip));
 
                  clipsToDelete.push_back(clip);
               }
            }
            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);
               auto newClip = CopyClip(*clip, true);
 
               // clip->Clear keeps points < t0 and >= t1 via Envelope::CollapseRegion
               newClip->Clear(t0,t1);
 
               clipsToAdd.push_back(move(newClip));
            }
         }
      }
   }
 
   // Only now, change the contents of this track
   // use No-fail-guarantee for the rest
 
   for (const auto &clip: clipsToDelete)
      RemoveInterval(clip);
 
   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 : Intervals())
         if (clip->AtOrBeforePlayRegion(t1))
            clip->ShiftBy(-(t1 - t0));
 
   for (auto &clip: clipsToAdd)
      InsertInterval(move(clip), false);
}

References CopyClip(), GetEditClipsCanMove(), InsertInterval(), Intervals(), RemoveInterval(), WideSampleSequence::SnapToSample(), and THROW_INCONSISTENCY_EXCEPTION.

Referenced by Clear(), ClearAndAddCutLine(), and SplitDelete().

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 2425 of file WaveTrack.cpp.

{
   if (auto pChild = WaveTrackIORegistry::Get().CallObjectAccessor(tag, *this))
      // Deserialize any extra attached structures
      return pChild;
 
   const auto getClip = [this]() -> WaveClip & {
      return (*NewestOrNewClip()->Channels().begin())->GetClip();
   };
 
   //
   // This is legacy code (1.2 and previous) and is not called for new projects!
   if (tag == Sequence::Sequence_tag || 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::Sequence_tag)
         return getClip().GetSequence(0);
      else if (tag == "envelope")
         return &getClip().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 == Sequence::WaveBlock_tag) {
      // This is a legacy project, so set the cached offset
      NewestOrNewClip()->SetSequenceStartTime(mLegacyProjectFileOffset);
      auto pSeq = getClip().GetSequence(0);
      return pSeq;
   }
 
   // This is for the new file format (post-1.2)
   if (tag == WaveClip::WaveClip_tag) {
      // 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);
      const auto xmlHandler = clip.get();
      auto &clips = NarrowClips();
      clips.push_back(std::move(clip));
      Publish({ clips.back(), WaveTrackMessage::Deserialized });
      return xmlHandler;
   }
 
   return nullptr;
}

References WaveTrackMessage::Deserialized, XMLMethodRegistry< Host >::Get(), GetClip(), mLegacyFormat, mLegacyProjectFileOffset, mLegacyRate, mpFactory, NarrowClips(), NewestOrNewClip(), Observer::Publisher< WaveTrackMessage >::Publish(), Sequence::Sequence_tag, Sequence::WaveBlock_tag, and WaveClip::WaveClip_tag.

Here is the call graph for this function:

◆ HandleXMLEndTag()

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

override

Definition at line 2413 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::WaveClip_tag);
#else
   // File compatibility breaks have intervened long since, and the line above
   // would now have undesirable side effects
#endif
}

References NewestOrNewClip(), and WaveClip::WaveClip_tag.

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 2361 of file WaveTrack.cpp.

{
   if (tag == WaveTrack_tag) {
      double dblValue;
      long nValue;
 
      for (const auto& pair : attrs)
      {
         const auto& attr = pair.first;
         const auto& value = pair.second;
 
         if (attr == Rate_attr)
         {
            // 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_attr && 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 == Volume_attr && value.TryGet(dblValue))
            DoSetVolume(dblValue);
         else if (attr == Pan_attr && value.TryGet(dblValue) &&
                  (dblValue >= -1.0) && (dblValue <= 1.0))
            DoSetPan(dblValue);
         else if (attr == Linked_attr && value.TryGet(nValue))
            SetLinkType(ToLinkType(nValue), false);
         else if (attr == SampleFormat_attr && 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 DoSetPan(), DoSetVolume(), Track::HandleCommonXMLAttribute(), PlayableTrack::HandleXMLAttribute(), Sequence::IsValidSampleFormat(), Linked_attr, lrint, mLegacyProjectFileOffset, mLegacyRate, Offset_attr, Pan_attr, Rate_attr, SampleFormat_attr, SetLegacyFormat(), Track::SetLinkType(), anonymous_namespace{WaveTrack.cpp}::ToLinkType(), Volume_attr, and WaveTrack_tag.

Here is the call graph for this function:

◆ HasClipNamed()

bool WaveTrack::HasClipNamed ( const wxString & name ) const

Definition at line 728 of file WaveTrack.cpp.

{
   auto clips = Intervals();
   return std::any_of(clips.begin(), clips.end(),
      [&](const auto &pClip){ return pClip->GetName() == name; });
}

References Intervals().

Referenced by ProjectAudioManager::DoRecord(), MakeClipCopyName(), and MakeNewClipName().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HasTrivialEnvelope()

bool WaveTrack::HasTrivialEnvelope ( ) const

overridevirtual

Returns: whether envelope values are all unit

Implements WideSampleSequence.

Definition at line 2858 of file WaveTrack.cpp.

{
   auto pTrack = this;
   if (!pTrack)
      return false;
   auto clips = pTrack->Intervals();
   return std::all_of(clips.begin(), clips.end(),
      [](const auto &pClip){ return pClip->GetEnvelope().IsTrivial(); });
}

Referenced by WaveChannel::HasTrivialEnvelope().

Here is the caller graph for this function:

◆ Init()

void WaveTrack::Init ( const WaveTrack & orig )

Overwrite data excluding the sample sequence but including display settings

Definition at line 553 of file WaveTrack.cpp.

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

References Track::Init(), and mpFactory.

Referenced by ProjectAudioManager::DoRecord().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InsertClip()

bool WaveTrack::InsertClip	(	WaveClipHolders &	clips,
		WaveClipHolder	clip,
		bool	newClip,
		bool	backup,
		bool	allowEmpty
	)

private

Sets project tempo on clip upon push. Use this instead of NarrowClips().push_back

Returns: true on success

Parameters

backup whether the duplication is for backup purposes while opening a project, instead of other editing operations

Definition at line 1929 of file WaveTrack.cpp.

{
   if (!backup && !clip->GetIsPlaceholder() && !allowEmpty && clip->IsEmpty())
      return false;
 
   const auto& tempo = GetProjectTempo(*this);
   if (tempo.has_value())
      clip->OnProjectTempoChange(std::nullopt, *tempo);
   clips.push_back(std::move(clip));
   Publish({ clips.back(),
      newClip ? WaveTrackMessage::New : WaveTrackMessage::Inserted });
 
   return true;
}

References GetProjectTempo(), WaveTrackMessage::Inserted, WaveTrackMessage::New, and Observer::Publisher< WaveTrackMessage >::Publish().

Referenced by CopyClips(), and InsertInterval().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InsertInterval()

void WaveTrack::InsertInterval	(	const IntervalHolder &	interval,
		bool	newClip,
		bool	allowEmpty = `false`
	)

Definition at line 3235 of file WaveTrack.cpp.

{
   if (clip) {
      constexpr bool backup = false;
      InsertClip(mClips, clip, newClip, backup, allowEmpty);
      // Detect errors resulting in duplicate shared pointers to clips
      assert(ClipsAreUnique(mClips));
   }
}

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

Referenced by CopyPartOfClip(), CopyWholeClip(), ProjectAudioManager::DoRecord(), FinishCopy(), HandleClear(), AUPImportFileHandle::HandleWaveClip(), InsertSilence(), Join(), ReplaceInterval(), and WaveTrackUtilities::Reverse().

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 2023 of file WaveTrack.cpp.

{
   // Nothing to do, if length is zero.
   // Fixes Bug 1626
   if (len == 0)
      return;
   if (len <= 0)
      THROW_INCONSISTENCY_EXCEPTION;
 
   auto &&clips = Intervals();
   if (clips.empty()) {
      // Special case if there is no clip yet
      auto clip = CreateClip(0);
      clip->InsertSilence(0, len);
      // use No-fail-guarantee
      InsertInterval(move(clip), true);
   }
   else
   {
      // Assume at most one clip contains t
      const auto end = clips.end();
      const auto it = std::find_if(clips.begin(), end,
         [&](const IntervalHolder &clip) { return clip->SplitsPlayRegion(t); } );
 
      // use Strong-guarantee
      if (it != end)
         (*it)->InsertSilence(t, len);
 
      // use No-fail-guarantee
      for (const auto &&clip : clips)
         if (clip->BeforePlayRegion(t))
            clip->ShiftBy(len);
   }
}

References CreateClip(), details::end(), InsertInterval(), Intervals(), and THROW_INCONSISTENCY_EXCEPTION.

Referenced by AUPImportFileHandle::AddSilence(), and SilenceBase::GenerateTrack().

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 671 of file WaveTrack.h.

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

Here is the caller graph for this function:

◆ Intervals() [2/2]

auto WaveTrack::Intervals ( ) const

inline

Definition at line 672 of file WaveTrack.h.

672{ 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 933 of file WaveTrack.cpp.

{
   if (t0 > t1)
      return true;
 
   //wxPrintf("Searching for overlap in %.6f...%.6f\n", t0, t1);
   for (const auto &clip : Intervals())
   {
      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 Intervals().

Referenced by SyncLockAdjust().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Join()

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

Exception safety guarantee:: Weak

Definition at line 2148 of file WaveTrack.cpp.

{
   // Merge all WaveClips overlapping selection into one
   const auto &intervals = Intervals();
 
   {
      IntervalHolders intervalsToJoin;
      for (const 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]](const auto& interval) {
                return !first->HasEqualPitchAndSpeed(*interval);
             }))
         ApplyPitchAndSpeedOnIntervals(intervalsToJoin, reportProgress);
   }
 
   IntervalHolders clipsToDelete;
   IntervalHolder newClip{};
 
   const auto rate = GetRate();
   for (const auto &clip: intervals) {
      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);
      }
   }
 
   //if there are no clips to delete, nothing to do
   if (clipsToDelete.empty())
      return;
 
   const auto firstToDelete = clipsToDelete[0].get();
   auto t = firstToDelete->GetPlayStartTime();
   //preserve left trim data if any
   newClip = CreateClip(
      firstToDelete->GetSequenceStartTime(),
      firstToDelete->GetName());
 
   for (const 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 DoCreateClip
 
      t = newClip->GetPlayEndTime();
 
      RemoveClip(FindClip(*clip));
   }
 
   InsertInterval(move(newClip), false);
}

References ApplyPitchAndSpeedOnIntervals(), CreateClip(), details::end(), FindClip(), GetRate(), InsertInterval(), Intervals(), and RemoveClip().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ JoinOne()

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

staticprivate

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

◆ 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 596 of file WaveTrack.cpp.

{
   // This implies satisfaction of the precondition of SetRate()
   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);
 
   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 = LinkType::None);
         }
         else
         {
            SetLinkType(linkType = LinkType::Aligned);
            //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 because AreAligned returned false
            removeZeroClips(NarrowClips());
            removeZeroClips(next->NarrowClips());
         }
      }
   }
   if (doFix) {
      // More non-error upgrading
      // Set the common channel group rate from the unzipped leader's rate
      if (mLegacyRate > 0)
      {
         WaveTrack *next{};
         if (linkType != LinkType::None)
            next = *TrackList::Channels(this).first.advance(1);
         SetRate(mLegacyRate);
         mLegacyRate = 0;
         if (next && next->mLegacyRate > 0)
         {
            next->SetRate(next->mLegacyRate);
            next->mLegacyRate = 0;
         }
         if (mLegacyFormat != undefinedSample)
            WaveTrackData::Get(*this).SetSampleFormat(mLegacyFormat);
         if (next && next->mLegacyFormat != undefinedSample)
            WaveTrackData::Get(*next).SetSampleFormat(mLegacyFormat);
      }
      if (linkType == LinkType::None)
         // Did not visit the other call to removeZeroClips, do it now
         removeZeroClips(NarrowClips());
      else
         // Make a real wide wave track from two deserialized narrow tracks
         ZipClips();
   }
   return !err;
}

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

Here is the call graph for this function:

◆ MakeClipCopyName()

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

private

Definition at line 793 of file WaveTrack.cpp.

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

References HasClipNamed(), name, and XC.

Here is the call graph for this function:

◆ MakeMono()

void WaveTrack::MakeMono ( )

Simply discard any right channel.

Definition at line 1039 of file WaveTrack.cpp.

{
   mRightChannel.reset();
   for (auto &pClip : mClips)
      pClip->DiscardRightChannel();
   EraseChannelAttachments(1);
}

References EraseChannelAttachments(), mClips, and mRightChannel.

Referenced by StereoToMono::ProcessOne().

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 805 of file WaveTrack.cpp.

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

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

Here is the call graph for this function:

◆ MergeChannelAttachments()

void WaveTrack::MergeChannelAttachments ( WaveTrack && other )

private

Steal channel attachments from other, then destroy the track attachment slot

Definition at line 429 of file WaveTrack.cpp.

{
   this->AttachedTrackObjects::ForCorresponding(other,
   [this](TrackAttachment *pLeft, TrackAttachment *pRight){
      // Precondition of callback from ClientData::Site
      assert(pLeft && pRight);
      const auto pLeftAttachments =
         dynamic_cast<ChannelAttachmentsBase *>(pLeft);
      const auto pRightAttachments =
         dynamic_cast<ChannelAttachmentsBase *>(pRight);
      // They should have come from the same factory of channel attachments
      assert((pLeftAttachments == nullptr) == (pRightAttachments == nullptr));
      if (pLeftAttachments) {
         // First fixup the back-pointers from channel views to their track
         pRightAttachments->Reparent(shared_from_this());
         // Then "steal" them
         pLeftAttachments->MakeStereo(shared_from_this(),
            std::move(*pRightAttachments));
      }
   });
}

References ClientData::Site< Host, ClientData, ObjectCopyingPolicy, Pointer, ObjectLockingPolicy, RegistryLockingPolicy >::ForCorresponding().

Referenced by ZipClips().

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 3185 of file WaveTrack.cpp.

{
   const auto clip1 = GetClip(clipidx1);
   const auto clip2 = GetClip(clipidx2);
 
   if (!clip1 || !clip2)
      return false; // Don't throw, just do nothing.
 
   if (!clip1->HasEqualPitchAndSpeed(*clip2))
      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
   RemoveInterval(clip2);
   return true;
}

References GetClip(), and RemoveInterval().

Here is the call graph for this function:

◆ MonoToStereo()

auto WaveTrack::MonoToStereo ( )

Precondition: !GetOwner()

Definition at line 1047 of file WaveTrack.cpp.

{
   assert(!GetOwner());
   MakeMono();
 
   // Make temporary new mono track
   auto newTrack = Duplicate();
 
   // Make a list
   auto result = TrackList::Temporary(nullptr, shared_from_this());
   result->Add(newTrack);
   // Destroy the temporary track, widening this track to stereo
   ZipClips();
 
   return std::static_pointer_cast<WaveTrack>(result->DetachFirst());
}

References anonymous_namespace{FloatVectorClip.cpp}::Duplicate(), and TrackList::Temporary().

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 564 of file WaveTrack.cpp.

{
   double delta = origin - GetStartTime();
   for (const auto &pInterval : Intervals())
      // assume No-fail-guarantee
      pInterval->ShiftBy(delta);
   WaveTrackData::Get(*this).SetOrigin(origin);
}

References BasicUI::Get(), GetStartTime(), and Intervals().

Here is the call graph for this function:

◆ NarrowClips() [1/2]

WaveClipHolders & WaveTrack::NarrowClips ( )

private

Definition at line 768 of file WaveTrack.cpp.

{
   return mClips;
}

References mClips.

Referenced by GetNumClips(), HandleXMLChild(), LinkConsistencyFix(), NIntervals(), and RemoveClip().

Here is the caller graph for this function:

◆ NarrowClips() [2/2]

const WaveClipHolders & WaveTrack::NarrowClips ( ) const

private

Definition at line 773 of file WaveTrack.cpp.

{
   return mClips;
}

References mClips.

◆ NChannels()

size_t WaveTrack::NChannels ( ) const

overridevirtual

A constant property.

Postcondition: result: result > 0

Implements RecordableSequence.

Definition at line 530 of file WaveTrack.cpp.

{
   return mRightChannel.has_value() ? 2 : 1;
}

References mRightChannel.

Referenced by Append(), AppendItem(), ProjectAudioManager::ChooseExistingRecordingTracks(), ClearAndPasteAtSameTempo(), Clone(), Copy(), EffectBase::CountWaveTracks(), Disjoin(), DoGet(), DoGetChannel(), anonymous_namespace{TrackMenus.cpp}::DoMixAndRender(), SBSMSBase::Finalize(), CompareAudioCommand::GetSelection(), anonymous_namespace{EditMenus.cpp}::OnPaste(), PasteWaveTrackAtSameTempo(), Reverse::Process(), NyquistBase::Process(), PerTrackEffect::ProcessPass(), anonymous_namespace{WaveTrackUtilities.cpp}::ReverseOneClip(), GetInfoCommand::SendTracks(), SwapChannels(), and ZipClips().

Here is the caller graph for this function:

◆ New()

WaveTrack * WaveTrack::New ( AudacityProject & project )

static

Definition at line 486 of file WaveTrack.cpp.

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

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

Here is the call graph for this function:

◆ NewestOrNewClip()

auto 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 3002 of file WaveTrack.cpp.

{
   const auto &intervals = Intervals();
   if (intervals.empty()) {
      const auto origin = WaveTrackData::Get(*this).GetOrigin();
      const auto name = MakeNewClipName();
      auto pInterval = CreateClip(origin, name);
      InsertInterval(pInterval, true, true);
      return pInterval;
   }
   else
      return mClips.back();
}

References BasicUI::Get(), and name.

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

Report the number of intervals.

Implements ChannelGroup.

Definition at line 705 of file WaveTrack.cpp.

{
   return NarrowClips().size();
}

References NarrowClips().

Referenced by DoGetInterval(), and Flush().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Paste() [1/2]

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

virtual

Weak precondition allows overrides to replicate one channel into many.

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

Implements Track.

◆ Paste() [2/2]

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

overridevirtual

Exception safety guarantee:: Weak

Implements Track.

Definition at line 1986 of file WaveTrack.cpp.

{
   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 PasteWaveTrack().

Referenced by StereoToMono::ProcessOne(), and SyncLockAdjust().

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

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 track

Implements Track.

Definition at line 694 of file WaveTrack.cpp.

{
   auto &trackFactory = WaveTrackFactory::Get(project);
   auto &pSampleBlockFactory = trackFactory.GetSampleBlockFactory();
   auto pFirstTrack = EmptyCopy(pSampleBlockFactory);
   list.Add(pFirstTrack->SharedPointer());
   pFirstTrack->Paste(0.0, *this);
   return pFirstTrack->SharedPointer();
}

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

Here is the call graph for this function:

◆ PasteWaveTrack()

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

private

Definition at line 1709 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(*this);
   if (!tempo.has_value())
      THROW_INCONSISTENCY_EXCEPTION;
   const auto copyHolder = other.DuplicateWithOtherTempo(*tempo);
   PasteWaveTrackAtSameTempo(t0, *copyHolder, merge);
}

References DuplicateWithOtherTempo(), 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 1720 of file WaveTrack.cpp.

{
   const auto otherNChannels = other.NChannels();
   assert(otherNChannels == NChannels());
   assert(
      GetProjectTempo(*this).has_value() &&
      GetProjectTempo(*this) == GetProjectTempo(other));
   const auto startTime = other.GetStartTime();
   const auto endTime = other.GetEndTime();
 
   const auto insertDuration = endTime;
   auto &track = *this;
    //
    // 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.GetIntervalAtTime(t0);
    const auto otherFirstClip = other.GetLeftmostClip();
    const auto otherLastClip = other.GetRightmostClip();
    const auto pitchAndSpeedMatch =
       !clipAtT0 || (clipAtT0->HasEqualPitchAndSpeed(*otherFirstClip) &&
                     clipAtT0->HasEqualPitchAndSpeed(*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 &&
       pitchAndSpeedMatch && 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");
 
    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.Intervals())
            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");
 
        IntervalHolder insideClip{};
        for (const auto& clip : track.Intervals()) {
            if (editClipCanMove) {
                if (clip->SplitsPlayRegion(t0)) {
                    //wxPrintf("t0=%.6f: inside clip is %.6f ... %.6f\n",
                    //       t0, clip->GetStartTime(), clip->GetEndTime());
                    insideClip = clip;
                    break;
                }
            }
            else {
                // If clips are immovable we also allow prepending to clips
                if (clip->WithinPlayRegion(t0))
                {
                    insideClip = clip;
                    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.Intervals()) {
                    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.GetClip(0)) {
               // This branch only gets executed in `singleClipMode` - we've
               // already made sure that stretch ratios are equal, satisfying
               // `WaveClip::Paste`'s precondition.
               assert(insideClip->GetStretchRatio() == pClip->GetStretchRatio());
               // This too should follow from the assertion of the same number
               // of channels in the tracks, near the top
               assert(insideClip->NChannels() == pClip->NChannels());
               bool success = insideClip->Paste(t0, *pClip);
               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.Intervals()) {
        // AWD Oct. 2009: Don't actually paste in placeholder clips
        if (!clip->GetIsPlaceholder()) {
            // If clip has no name (i.e. generated), assigning a new name
            const auto name = clip->GetName().IsEmpty()
                ? track.MakeNewClipName()
                : clip->GetName();
            const auto oldPlayStart = clip->GetPlayStartTime();
            const auto newSequenceStart =
               (oldPlayStart + t0) - clip->GetTrimLeft();
            const auto newClip = CreateClip(newSequenceStart, name, clip.get());
            newClip->Resample(rate);
            track.InsertInterval(move(newClip), false);
        }
    }
}

References BadUserAction, CreateClip(), GetClip(), GetEditClipsCanMove(), GetEndTime(), GetLeftmostClip(), GetNumClips(), GetProjectTempo(), GetRightmostClip(), GetStartTime(), Intervals(), name, NChannels(), and XO().

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 356 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(), and SpectralSelectionBar::ModifySpectralSelection().

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 an unzipped leader track have a common rate.

Definition at line 1901 of file WaveTrack.cpp.

{
   // 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().

Referenced by LinkConsistencyFix().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RemoveClip()

void WaveTrack::RemoveClip ( std::ptrdiff_t distance )

private

Definition at line 1542 of file WaveTrack.cpp.

{
   auto &clips = NarrowClips();
   if (distance < clips.size())
      clips.erase(clips.begin() + distance);
}

References NarrowClips().

Referenced by Join().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RemoveInterval()

void WaveTrack::RemoveInterval ( const IntervalHolder & interval )

Definition at line 3246 of file WaveTrack.cpp.

{
   const auto end = mClips.end(),
      iter = find(mClips.begin(), end, interval);
   if (iter != end)
      mClips.erase(iter);
}

References details::end(), and mClips.

Referenced by HandleClear(), MergeClips(), ReplaceInterval(), and WaveTrackUtilities::Reverse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RepairChannels()

void WaveTrack::RepairChannels ( )

overridevirtual

Called in exception handling after possibly unbalanced calls to Append in different channels. Allows the sequence to repair consistency.

Implements RecordableSequence.

Definition at line 2323 of file WaveTrack.cpp.

{
   for (auto pInterval : Intervals())
      pInterval->RepairChannels();
}

References Intervals().

Here is the call graph for this function:

◆ ReplaceInterval()

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

private

Precondition: oldOne->NChannels() == newOne->NChannels(); newOne and oldOne are the same, or else newOne is not already owned by this or any other track

Definition at line 3254 of file WaveTrack.cpp.

{
   assert(newOne == oldOne || FindClip(*newOne) == Intervals().size());
   assert(oldOne->NChannels() == newOne->NChannels());
   RemoveInterval(oldOne);
   InsertInterval(newOne, false);
   newOne->SetName(oldOne->GetName());
}

References FindClip(), InsertInterval(), Intervals(), RemoveInterval(), and ClientData::Site< Host, ClientData, ObjectCopyingPolicy, Pointer, ObjectLockingPolicy, RegistryLockingPolicy >::size().

Referenced by ApplyPitchAndSpeedOnIntervals().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Resample()

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

Exception safety guarantee:: Weak – Partial completion may leave clips at differing sample rates!

Definition at line 3266 of file WaveTrack.cpp.

{
   for (const auto &pClip : Intervals())
      pClip->Resample(rate, progress);
   DoSetRate(rate);
}

References DoSetRate(), and Intervals().

Here is the call graph for this function:

◆ RightmostOrNewClip()

auto WaveTrack::RightmostOrNewClip ( )

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

Returns: a pointer to a WaveClip at the end of the track

Exception safety guarantee:: No-fail

Definition at line 3017 of file WaveTrack.cpp.

{
   if (mClips.empty()) {
      auto pInterval = CreateClip(
         WaveTrackData::Get(*this).GetOrigin());
      InsertInterval(pInterval, true, true);
      return pInterval;
   }
   else {
      auto end = mClips.end(),
         it = max_element(mClips.begin(), end,
            [](const auto &pClip1, const auto &pClip2){
               return pClip1->GetPlayStartTime() < pClip2->GetPlayStartTime();
         });
      assert(it != end);
      return *it;
   }
}

References details::end(), and BasicUI::Get().

Referenced by AUPImportFileHandle::AddSamples(), Append(), and AUPImportFileHandle::HandleEnvelope().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetFloats()

bool WaveTrack::SetFloats	(	const float const	buffers,
		sampleCount	start,
		size_t	len,
		sampleFormat	effectiveFormat = `widestSampleFormat`
	)

Random-access assignment of a range of samples.

Parameters

buffers a span of pointers of size NChannels()

Precondition: each of buffers is non-null

Parameters

effectiveFormat Make the effective format of the data at least the minumum of this value and `format`. (Maybe wider, if merging with preexistent data.) If the data are later narrowed from stored format, but not narrower than the effective, then no dithering will occur.

Definition at line 3273 of file WaveTrack.cpp.

{
   bool result = true;
   size_t ii = 0;
   for (const auto &pChannel : Channels()) {
      const auto buffer = buffers[ii++];
      assert(buffer); // precondition
      result = pChannel->SetFloats(buffer, start, len, effectiveFormat)
         && result;
   }
   return result;
}

References Channels().

Referenced by anonymous_namespace{WaveTrackUtilities.cpp}::ReverseOneClip().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetLegacyFormat()

void WaveTrack::SetLegacyFormat ( sampleFormat format )

Definition at line 2329 of file WaveTrack.cpp.

{
   mLegacyFormat = format;
}

References anonymous_namespace{ExportPCM.cpp}::format, and mLegacyFormat.

Referenced by AUPImportFileHandle::HandleXMLEndTag(), and HandleXMLTag().

Here is the caller graph for this function:

◆ SetPan()

void WaveTrack::SetPan ( float newPan )

Definition at line 870 of file WaveTrack.cpp.

{
   if (newPan > 1.0)
      newPan = 1.0;
   else if (newPan < -1.0)
      newPan = -1.0;
 
   if ( GetPan() != newPan ) {
      DoSetPan(newPan);
      Notify(true);
   }
}

References DoSetPan(), GetPan(), and Track::Notify().

Referenced by MixerTrackCluster::HandleSliderPan(), WaveTrackMenuTable::OnMergeStereo(), and anonymous_namespace{TrackMenus.cpp}::SetTrackPan().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetRate()

void WaveTrack::SetRate ( double newRate )

!brief Sets the new rate for the track without resampling it

Precondition: newRate > 0

Definition at line 826 of file WaveTrack.cpp.

{
   assert(newRate > 0);
   newRate = std::max( 1.0, newRate );
   DoSetRate(newRate);
 
   for (const auto &clip : Intervals())
      clip->SetRate(newRate);
}

References DoSetRate(), and Intervals().

Referenced by LinkConsistencyFix(), and RateMenuTable::SetRate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetVolume()

void WaveTrack::SetVolume ( float newVolume )

Definition at line 852 of file WaveTrack.cpp.

{
   if (GetVolume() != newVolume) {
      DoSetVolume(newVolume);
      Notify(true);
   }
}

References DoSetVolume(), GetVolume(), and Track::Notify().

Referenced by MixerTrackCluster::HandleSliderGain(), and anonymous_namespace{TrackMenus.cpp}::SetTrackGain().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ShiftBy()

void WaveTrack::ShiftBy	(	double	t0,
		double	delta
	)

overridevirtual

Exception safety guarantee:: No-fail

Implements ChannelGroup.

Definition at line 574 of file WaveTrack.cpp.

{
   for (const auto &pInterval : Intervals())
   {   // assume No-fail-guarantee
      if(pInterval->Start() >= t0)
         pInterval->ShiftBy(delta);
   }
   const auto origin = WaveTrackData::Get(*this).GetOrigin();
   if(t0 <= origin)
   {
      const auto offset = t0 >= 0 ? delta : t0 + delta;
      WaveTrackData::Get(*this).SetOrigin(origin + offset);
   }
}

References BasicUI::Get(), and Intervals().

Here is the call graph for this function:

◆ Silence()

void WaveTrack::Silence	(	double	t0,
		double	t1,
		ProgressReporter	reportProgress
	)

overridevirtual

Implements Track.

Definition at line 2000 of file WaveTrack.cpp.

{
   if (t1 < t0)
      THROW_INCONSISTENCY_EXCEPTION;
 
   ApplyPitchAndSpeed({ { t0, t1 } }, std::move(reportProgress));
 
   auto start = TimeToLongSamples(t0);
   auto end = TimeToLongSamples(t1);
 
   for (const auto &pClip : Intervals()) {
      auto clipStart = pClip->GetPlayStartSample();
      auto clipEnd = pClip->GetPlayEndSample();
      if (clipEnd > start && clipStart < end) {
         auto offset = std::max(start - clipStart, sampleCount(0));
         // Clip sample region and Get/Put sample region overlap
         auto length = std::min(end, clipEnd) - (clipStart + offset);
         pClip->SetSilence(offset, length);
      }
   }
}

References ApplyPitchAndSpeed(), details::end(), Intervals(), min(), THROW_INCONSISTENCY_EXCEPTION, and WideSampleSequence::TimeToLongSamples().

Referenced by anonymous_namespace{LabelMenus.cpp}::OnSilenceLabels(), anonymous_namespace{EditMenus.cpp}::OnSplitCut(), and anonymous_namespace{LabelMenus.cpp}::OnSplitDeleteLabels().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SortedClipArray()

auto WaveTrack::SortedClipArray ( ) const

private

Return all WaveClips sorted by clip play start time.

Definition at line 3287 of file WaveTrack.cpp.

{
   const auto &intervals = Intervals();
   IntervalConstHolders clips{ intervals.begin(), intervals.end() };
   const auto comp = [](const auto &a, const auto &b) {
      return a->GetPlayStartTime() < b->GetPlayStartTime(); };
   std::sort(clips.begin(), clips.end(), comp);
   return clips;
}

References Intervals().

Referenced by LinkConsistencyFix(), and ZipClips().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SortedIntervalArray() [1/2]

auto WaveTrack::SortedIntervalArray ( )

Return all WaveClips sorted by clip play start time.

Definition at line 3297 of file WaveTrack.cpp.

{
   const auto &intervals = Intervals();
   IntervalHolders result;
   copy(intervals.begin(), intervals.end(), back_inserter(result));
   sort(result.begin(), result.end(), [](const auto &pA, const auto &pB){
      return pA->GetPlayStartTime() < pB->GetPlayStartTime(); });
   return result;
}

References staffpad::vo::copy().

Referenced by SetEnvelopeCommand::ApplyInner(), SBSMSBase::Finalize(), anonymous_namespace{ClipMenus.cpp}::FindNextClip(), anonymous_namespace{ClipMenus.cpp}::FindNextClipBoundary(), anonymous_namespace{ClipMenus.cpp}::FindPrevClip(), anonymous_namespace{ClipMenus.cpp}::FindPrevClipBoundary(), FindWaveTrackLocations(), anonymous_namespace{NyquistBase.cpp}::GetClipBoundaries(), WaveTrackUtilities::Reverse(), and GetInfoCommand::SendEnvelopes().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SortedIntervalArray() [2/2]

auto WaveTrack::SortedIntervalArray ( ) const

Return all WaveClips sorted by clip play start time.

Definition at line 3307 of file WaveTrack.cpp.

{
   const auto &intervals = Intervals();
   IntervalConstHolders result;
   copy(intervals.begin(), intervals.end(), back_inserter(result));
   sort(result.begin(), result.end(), [](const auto &pA, const auto &pB){
      return pA->GetPlayStartTime() < pB->GetPlayStartTime(); });
   return result;
}

References staffpad::vo::copy(), and Intervals().

Here is the call graph for this function:

◆ Split()

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

Exception safety guarantee:: Weak

Definition at line 3157 of file WaveTrack.cpp.

{
   SplitAt(t0);
   if (t0 != t1)
      SplitAt(t1);
}

References SplitAt().

Referenced by ApplyPitchAndSpeed(), and anonymous_namespace{LabelMenus.cpp}::OnSplitLabels().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SplitAt()

auto WaveTrack::SplitAt ( double t )

Exception safety guarantee:: Weak

Definition at line 3165 of file WaveTrack.cpp.

{
   for (const auto &&c : Intervals()) {
      if (c->SplitsPlayRegion(t)) {
         t = SnapToSample(t);
         auto newClip = CopyClip(*c, true);
         c->TrimRightTo(t);// put t on a sample
         newClip->TrimLeftTo(t);
         auto result = std::pair{ c, newClip };
 
         // This could invalidate the iterators for the loop!  But we return
         // at once so it's okay
         InsertInterval(move(newClip), false); // transfer ownership
         return result;
      }
   }
   return {};
}

Referenced by WaveTrackUtilities::Reverse(), and Split().

Here is the caller graph for this function:

◆ SplitChannels()

auto WaveTrack::SplitChannels ( )

Definition at line 1064 of file WaveTrack.cpp.

{
   std::vector<Holder> result{ SharedPointer<WaveTrack>() };
   if (NChannels() == 2) {
      auto pOwner = GetOwner();
      assert(pOwner); // pre
      auto pNewTrack = result.emplace_back(EmptyCopy(1));
      for (auto &pClip : mClips)
         pNewTrack->mClips.emplace_back(pClip->SplitChannels());
      this->mRightChannel.reset();
      TrackList::AssignUniqueId(pNewTrack);
      auto iter = pOwner->Find(this);
      pOwner->Insert(*++iter, pNewTrack);
      // Fix up the channel attachments to avoid waste of space
      result[0]->EraseChannelAttachments(1);
      result[1]->EraseChannelAttachments(0);
   }
   return result;
}

References TrackList::AssignUniqueId().

Referenced by WaveTrackMenuTable::SplitStereo().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SplitCut()

auto WaveTrack::SplitCut	(	double	t0,
		double	t1
	)

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

Exception safety guarantee:: Strong

Definition at line 966 of file WaveTrack.cpp.

{
   if (t1 < t0)
      THROW_INCONSISTENCY_EXCEPTION;
 
   // SplitCut is the same as 'Copy', then 'SplitDelete'
   auto result = Copy(t0, t1);
   SplitDelete(t0, t1);
   return std::static_pointer_cast<WaveTrack>(result);
}

References THROW_INCONSISTENCY_EXCEPTION.

Referenced by anonymous_namespace{EditMenus.cpp}::OnSplitCut(), and anonymous_namespace{LabelMenus.cpp}::OnSplitCutLabels().

Here is the caller graph for this function:

◆ SplitDelete()

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

Exception safety guarantee:: Strong

Definition at line 1526 of file WaveTrack.cpp.

{
   constexpr bool addCutLines = false;
   constexpr bool split = true;
   HandleClear(t0, t1, addCutLines, split);
}

References HandleClear().

Referenced by Disjoin(), SBSMSBase::Finalize(), anonymous_namespace{EditMenus.cpp}::OnSplitDelete(), anonymous_namespace{LabelMenus.cpp}::OnSplitDeleteLabels(), anonymous_namespace{EditMenus.cpp}::OnSplitNew(), and Trim().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SwapChannels()

void WaveTrack::SwapChannels ( )

Precondition: NChannels() == 2

Definition at line 1084 of file WaveTrack.cpp.

{
   assert(NChannels() == 2);
   for (const auto &pClip: mClips)
      pClip->SwapChannels();
   this->AttachedTrackObjects::ForEach([this](TrackAttachment &attachment){
      if (const auto pAttachments =
         dynamic_cast<ChannelAttachmentsBase *>(&attachment)) {
         pAttachments->SwapChannels(shared_from_this());
      }
   });
}

References ClientData::Site< Host, ClientData, ObjectCopyingPolicy, Pointer, ObjectLockingPolicy, RegistryLockingPolicy >::ForEach(), mClips, and NChannels().

Referenced by WaveTrackMenuTable::OnSwapChannels().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SyncLockAdjust()

void WaveTrack::SyncLockAdjust	(	double	oldT1,
		double	newT1
	)

overridevirtual

This can be used to adjust a sync-lock selected track when the selection is replaced by one of a different length.

Reimplemented from Track.

Definition at line 1671 of file WaveTrack.cpp.

{
   const auto endTime = GetEndTime();
   if (newT1 > oldT1 &&
      // JKC: This is a rare case where using >= rather than > on a float matters.
      // GetEndTime() looks through the clips and may give us EXACTLY the same
      // value as T1, when T1 was set to be at the end of one of those clips.
      oldT1 >= endTime)
         return;
   if (newT1 > oldT1) {
      // Insert space within the track
 
      // If track is empty at oldT1 insert whitespace; otherwise, silence
      if (IsEmpty(oldT1, oldT1)) {
         // Check if clips can move
         if (EditClipsCanMove.Read()) {
            const auto offset = newT1 - oldT1;
            const auto rate = GetRate();
            for (const auto &clip : Intervals())
               if (clip->GetPlayStartTime() > oldT1 - (1.0 / rate))
                  clip->ShiftBy(offset);
         }
         return;
      }
      else {
         // AWD: Could just use InsertSilence() on its own here, but it doesn't
         // follow EditClipCanMove rules (Paste() does it right)
         const auto duration = newT1 - oldT1;
         auto tmp = EmptyCopy(mpFactory);
         tmp->InsertSilence(0.0, duration);
         tmp->Flush();
         Paste(oldT1, *tmp);
      }
   }
   else if (newT1 < oldT1)
      Clear(newT1, oldT1);
}

References Clear(), EditClipsCanMove, EmptyCopy(), GetEndTime(), GetRate(), Intervals(), IsEmpty(), mpFactory, Paste(), and Setting< T >::Read().

Here is the call graph for this function:

◆ Trim()

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

Exception safety guarantee:: Weak

Definition at line 980 of file WaveTrack.cpp.

{
   bool inside0 = false;
   bool inside1 = false;
 
   for (const auto &clip : Intervals()) {
      if (t1 > clip->GetPlayStartTime() && t1 < clip->GetPlayEndTime()) {
         clip->SetTrimRight(
            clip->GetTrimRight() + clip->GetPlayEndTime() - t1);
         inside1 = true;
      }
 
      if (t0 > clip->GetPlayStartTime() && t0 < clip->GetPlayEndTime()) {
         clip->SetTrimLeft(
            clip->GetTrimLeft() + t0 - clip->GetPlayStartTime());
         inside0 = true;
      }
   }
 
   //if inside0 is false, then the left selector was between
   //clips, so DELETE everything to its left.
   if (const auto endTime = GetEndTime()
      ; !inside1 && t1 < endTime
   )
      Clear(t1, endTime);
 
   if (const auto startTime = GetStartTime()
      ; !inside0 && t0 > startTime
   )
      SplitDelete(startTime, t0);
}

References Clear(), GetEndTime(), GetStartTime(), Intervals(), and SplitDelete().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ WidestEffectiveFormat()

sampleFormat WaveTrack::WidestEffectiveFormat ( ) const

overridevirtual

Returns: widest effective SampleFormat in any part of the track

Implements WideSampleSequence.

Definition at line 2845 of file WaveTrack.cpp.

{
   auto result = narrowestSampleFormat;
   for (const auto &pClip : Intervals())
      result = std::max(result, pClip->GetSampleFormats().Effective());
   return result;
}

References Intervals(), and narrowestSampleFormat.

Referenced by WaveChannel::WidestEffectiveFormat().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ WriteOneXML()

void WaveTrack::WriteOneXML	(	const WaveChannel &	channel,
		XMLWriter &	xmlFile,
		size_t	iChannel,
		size_t	nChannels
	)

staticprivate

Definition at line 2485 of file WaveTrack.cpp.

{
   // Track data has always been written using channel-major iteration.
   // Do it still this way for compatibility.
 
   // Some values don't vary independently in channels but have been written
   // redundantly for each channel.  Keep doing this in 3.4 and later in case
   // a project is opened in an earlier version.
 
   xmlFile.StartTag(WaveTrack_tag);
   auto &track = channel.GetTrack();
 
   // Name, selectedness, etc. are channel group properties
   track.Track::WriteCommonXMLAttributes(xmlFile);
 
   // Write the "channel" attribute so earlier versions can interpret stereo
   // tracks, but this version doesn't read it
   {
      enum ChannelType {
         LeftChannel = 0,
         RightChannel = 1,
         MonoChannel = 2
      };
      const auto channelType = (nChannels == 0)
         ? MonoChannel
         : (iChannel == 0)
            ? LeftChannel
            : RightChannel;
      xmlFile.WriteAttr(Channel_attr, channelType);
   }
 
   // The "linked" flag is used to define the beginning of a channel group
   // that isn't mono
   const auto linkType = static_cast<int>(
      (iChannel == 0) && (nChannels == 2)
         ? LinkType::Aligned
         : LinkType::None);
   xmlFile.WriteAttr(Linked_attr, linkType);
 
   // VS: trying to save tracks that didn't pass all necessary
   // initializations on project read from the disk.
   const auto useLegacy = track.mLegacyRate != 0;
 
   // More channel group properties written redundantly
   track.WritableSampleTrack::WriteXMLAttributes(xmlFile);
   xmlFile.WriteAttr(Rate_attr, useLegacy ? track.mLegacyRate : track.GetRate());
   xmlFile.WriteAttr(Volume_attr, static_cast<double>(track.GetVolume()));
   xmlFile.WriteAttr(Pan_attr, static_cast<double>(track.GetPan()));
   xmlFile.WriteAttr(SampleFormat_attr, static_cast<long>(useLegacy ? track.mLegacyFormat : track.GetSampleFormat()));
 
   // Other persistent data specified elsewhere;
   // NOT written redundantly any more
   if (iChannel == 0)
      WaveTrackIORegistry::Get().CallWriters(track, xmlFile);
 
   for (const auto &clip : channel.Intervals())
      clip->WriteXML(xmlFile);
 
   xmlFile.EndTag(WaveTrack_tag);
}

References ChannelGroup::Aligned, XMLMethodRegistry< Host >::CallWriters(), Channel_attr, XMLWriter::EndTag(), XMLMethodRegistry< Host >::Get(), WaveChannel::GetTrack(), anonymous_namespace{StretchingSequenceIntegrationTest.cpp}::iChannel, WaveChannel::Intervals(), AudioGraph::LeftChannel, Linked_attr, AudioGraph::MonoChannel, ChannelGroup::None, Pan_attr, Rate_attr, AudioGraph::RightChannel, SampleFormat_attr, XMLWriter::StartTag(), Volume_attr, WaveTrack_tag, and XMLWriter::WriteAttr().

Here is the call graph for this function:

◆ WriteXML()

void WaveTrack::WriteXML ( XMLWriter & xmlFile ) const

overridevirtual

Implements Track.

Definition at line 2475 of file WaveTrack.cpp.

{
   const auto channels = Channels();
   size_t iChannel = 0,
      nChannels = channels.size();
   for (const auto pChannel : channels)
      WriteOneXML(*pChannel, xmlFile, iChannel++, nChannels);
}

References anonymous_namespace{StretchingSequenceIntegrationTest.cpp}::iChannel.

◆ ZipClips()

void WaveTrack::ZipClips ( bool mustAlign = true )

Convert channel-major storage to interval-major, replacing two tracks with one in the owning TrackList

Precondition: GetOwner(); next track in the list exists, is a WaveTrack, has one channel only; NChannels() == 1; if mustAlign, then clips are aligned across the tracks

Parameters

mustAlign if false, clips may be of different number or not aligned. Do not use the resulting track normally!

Refuse if clips are not well aligned.

Definition at line 3317 of file WaveTrack.cpp.

{
   const auto pOwner = GetOwner();
   assert(GetOwner()); // pre
   assert(NChannels() == 1); // pre
 
   // If deserializing, first un-link the track, so iterator finds the partner.
   SetLinkType(LinkType::None);
 
   auto iter = pOwner->Find(this);
   assert(this == *iter);
   ++iter;
   assert(iter != pOwner->end()); // pre
   auto pRight = dynamic_cast<WaveTrack*>(*iter);
   assert(pRight && pRight->NChannels() == 1); // pre
 
   if (mustAlign &&
      !AreAligned(this->SortedClipArray(), pRight->SortedClipArray()))
      return;
 
   CreateRight();
 
   // Now steal right side sample data info.  When not requiring alignment,
   // because this is a track that just keeps the sample counts of blocks
   // above 0 for later purposes -- then there is laxity about consistent
   // width of the clips.
   auto iterMe = mClips.begin(),
      endMe = mClips.end();
   auto iterRight = pRight->mClips.begin(),
      endRight = pRight->mClips.end();
   while (iterMe != endMe && iterRight != endRight) {
      (*iterMe)->MakeStereo(std::move(**iterRight), mustAlign);
      ++iterMe;
      ++iterRight;
   }
   assert(!mustAlign || (iterMe == endMe && iterRight == endRight));
 
   while (iterRight != endRight) {
      // Leftover misaligned mono clips
      mClips.emplace_back(move(*iterRight));
      ++iterRight;
   }
 
   this->MergeChannelAttachments(std::move(*pRight));
 
   pOwner->Remove(*pRight);
}

References anonymous_namespace{WaveTrack.cpp}::anonymous_namespace{WaveTrack.cpp}::AreAligned(), CreateRight(), Track::GetOwner(), mClips, MergeChannelAttachments(), NChannels(), ChannelGroup::None, Track::SetLinkType(), and SortedClipArray().

Referenced by LinkConsistencyFix(), PerTrackEffect::ProcessPass(), and ProjectFileManager::ReadProjectFile().

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

◆ WaveTrackFactory

friend class WaveTrackFactory

friend

Definition at line 280 of file WaveTrack.h.

Member Data Documentation

◆ mAppendCriticalSection

wxCriticalSection WaveTrack::mAppendCriticalSection

private

Definition at line 833 of file WaveTrack.h.

◆ mChannel

WaveChannel WaveTrack::mChannel

private

Invariant: non-null

Definition at line 768 of file WaveTrack.h.

Referenced by DoGetChannel().

◆ mClips

WaveClipHolders WaveTrack::mClips

private

Do not call mClips.push_back directly. Use InsertClip instead.

Invariant: all are non-null

Definition at line 776 of file WaveTrack.h.

Referenced by DoGet(), DoGetInterval(), InsertInterval(), MakeMono(), NarrowClips(), RemoveInterval(), SwapChannels(), and ZipClips().

◆ mFlushCriticalSection

wxCriticalSection WaveTrack::mFlushCriticalSection

private

Definition at line 832 of file WaveTrack.h.

◆ mLegacyFormat

sampleFormat WaveTrack::mLegacyFormat { undefinedSample }

private

used only during deserialization

Definition at line 779 of file WaveTrack.h.

Referenced by Clone(), HandleXMLChild(), LinkConsistencyFix(), and SetLegacyFormat().

◆ mLegacyProjectFileOffset

double WaveTrack::mLegacyProjectFileOffset { 0 }

private

Definition at line 834 of file WaveTrack.h.

Referenced by HandleXMLChild(), and HandleXMLTag().

◆ mLegacyRate

int WaveTrack::mLegacyRate { 0 }

mutableprivate

used only during deserialization

Definition at line 778 of file WaveTrack.h.

Referenced by Clone(), HandleXMLChild(), HandleXMLTag(), and LinkConsistencyFix().

◆ mpFactory

SampleBlockFactoryPtr WaveTrack::mpFactory

private

Definition at line 830 of file WaveTrack.h.

Referenced by EmptyCopy(), GetMaxBlockSize(), HandleXMLChild(), Init(), and SyncLockAdjust().

◆ mRightChannel

std::optional<WaveChannel> WaveTrack::mRightChannel

private

may be null

Definition at line 770 of file WaveTrack.h.

Referenced by CreateRight(), DoGetChannel(), MakeMono(), and NChannels().

◆ WaveChannel

friend WaveTrack::WaveChannel

private

Definition at line 836 of file WaveTrack.h.

◆ WaveTrack_tag

const char * WaveTrack::WaveTrack_tag = "wavetrack"

static

Definition at line 206 of file WaveTrack.h.

Referenced by AUPImportFileHandle::HandleEnvelope(), AUPImportFileHandle::HandleImport(), AUPImportFileHandle::HandleSequence(), AUPImportFileHandle::HandleWaveClip(), AUPImportFileHandle::HandleXMLEndTag(), HandleXMLTag(), AUPImportFileHandle::HandleXMLTag(), and WriteOneXML().

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

Classes

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ Holder

◆ Interval

◆ IntervalConstHolder

◆ IntervalConstHolders

◆ IntervalHolder

◆ IntervalHolders

◆ Regions

Constructor & Destructor Documentation

◆ WaveTrack()

◆ ~WaveTrack()

Member Function Documentation

◆ Append()

◆ ApplyPitchAndSpeed()

◆ ApplyPitchAndSpeedOne()

◆ ApplyPitchAndSpeedOnIntervals()

◆ CanInsertClip()

◆ CanOffsetClips()

◆ Channels() [1/2]

◆ Channels() [2/2]

◆ ClassTypeInfo()

◆ Clear()

◆ ClearAndAddCutLine()

◆ ClearAndPaste()

◆ ClearAndPasteAtSameTempo()

◆ Clone()

◆ ConvertToSampleFormat()

◆ Copy()

◆ CopyClip()

◆ CopyClips()

◆ CopyPartOfClip()

◆ CopyWholeClip()

◆ Create()

◆ CreateClip()

◆ CreateRight()

◆ Cut()

◆ Disjoin()

◆ DoCreateClip()

◆ DoGet()

◆ DoGetChannel()

◆ DoGetInterval()

◆ DoSetPan()

◆ DoSetRate()

◆ DoSetVolume()

◆ DuplicateWithOtherTempo()

◆ EmptyCopy() [1/2]

◆ EmptyCopy() [2/2]

◆ EraseChannelAttachments()

◆ ExpandOneCutLine()

◆ FindChannelGroup()

◆ FindClip()

◆ FinishCopy()

◆ Flush()

◆ FormatConsistencyCheck()

◆ GetBestBlockSize()

◆ GetChannel() [1/2]

◆ GetChannel() [2/2]

◆ GetChannelType()

◆ GetChannelVolume()

◆ GetClip() [1/2]

◆ GetClip() [2/2]

◆ GetClipAtTime()

◆ GetClipIndex()

◆ GetClipInterfaces()

◆ GetDefaultAudioTrackNamePreference()

◆ GetEndTime()

◆ GetEnvelopeValues()

◆ GetErrorOpening()

◆ GetIdealBlockSize()