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

#include <WaveTrack.h>

Inheritance diagram for WaveTrack:

Collaboration diagram for WaveTrack:

Classes
class	AllClipsConstIterator

class	AllClipsIterator

class	IntervalData

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

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

typedef WaveTrackLocation	Location

using	Holder = std::shared_ptr< WaveTrack >

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

enum	ChannelType { LeftChannel = 0 , RightChannel = 1 , MonoChannel = 2 }

using	ChannelGroupAttachments = ClientData::Site< ChannelGroupData, ClientData::Cloneable<>, ClientData::DeepCopying >
	Hosting of objects attached by higher level code. More...

using	AttachedObjects = ::AttachedTrackObjects
	Alias for my base type. More...

using	IntervalData = TrackIntervalData

using	Interval = TrackInterval

using	Intervals = std::vector< Interval >

using	ConstInterval = ConstTrackInterval

using	ConstIntervals = std::vector< ConstInterval >

using	Holder = std::shared_ptr< Track >

template<typename R = void>
using	Continuation = std::function< R() >
	Type of arguments passed as optional second parameter to TypeSwitch() cases. More...

using	Fallthrough = Continuation<>
	Type of arguments passed as optional second parameter to TypeSwitch<void>() cases. More...

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 Member Functions
	WaveTrack (const SampleBlockFactoryPtr &pFactory, sampleFormat format, double rate)

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

void	Reinit (const WaveTrack &orig)

virtual	~WaveTrack ()

double	GetOffset () const override

void	SetOffset (double o) override

ChannelType	GetChannelIgnoringPan () const override

ChannelType	GetChannel () const override

virtual void	SetPanFromChannelType () override

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

double	GetStartTime () const override
	Get the time at which the first clip in the track starts. More...

double	GetEndTime () const override
	Get the time at which the last clip in the track ends, plus recorded stuff. More...

double	GetRate () const override

void	SetRate (double newRate)

float	GetGain () const

void	SetGain (float newGain)

float	GetPan () const

void	SetPan (float newPan) override

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

float	GetOldChannelGain (int channel) const override

void	SetOldChannelGain (int channel, float gain) override

int	GetWaveColorIndex () const

void	SetWaveColorIndex (int colorIndex)

sampleCount	GetPlaySamplesCount () const

sampleCount	GetSequenceSamplesCount () const

sampleFormat	GetSampleFormat () const override

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

const SpectrogramSettings &	GetSpectrogramSettings () const

SpectrogramSettings &	GetSpectrogramSettings ()

SpectrogramSettings &	GetIndependentSpectrogramSettings ()

void	SetSpectrogramSettings (std::unique_ptr< SpectrogramSettings > &&pSettings)

const WaveformSettings &	GetWaveformSettings () const

WaveformSettings &	GetWaveformSettings ()

void	SetWaveformSettings (std::unique_ptr< WaveformSettings > &&pSettings)

void	UseSpectralPrefs (bool bUse=true)

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

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

Track::Holder	Copy (double t0, double t1, bool forClipboard=true) const override

Track::Holder	CopyNonconst (double t0, double t1)

void	Clear (double t0, double t1) override

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

void	ClearAndPaste (double t0, double t1, const Track src, bool preserve=true, bool merge=true, const TimeWarper effectWarper=NULL)

void	Silence (double t0, double t1) override

void	InsertSilence (double t, double len) override

void	SplitAt (double t)

void	Split (double t0, double t1)

void	ClearAndAddCutLine (double t0, double t1)

Track::Holder	SplitCut (double t0, double t1)

void	SplitDelete (double t0, double t1)

void	Join (double t0, double t1)

void	Disjoin (double t0, double t1)

void	Trim (double t0, double t1)

void	HandleClear (double t0, double t1, bool addCutLines, bool split)

void	SyncLockAdjust (double oldT1, double newT1) override

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

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

void	Flush () override

bool	Get (samplePtr buffer, sampleFormat format, sampleCount start, size_t len, fillFormat fill=fillZero, bool mayThrow=true, sampleCount *pNumWithinClips=nullptr) const override

void	Set (constSamplePtr buffer, sampleFormat format, sampleCount start, size_t len)

void	GetEnvelopeValues (double *buffer, size_t bufferLen, double t0) const override
	Fetch envelope values corresponding to uniformly separated sample times starting at the given time. More...

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

float	GetRMS (double t0, double t1, bool mayThrow=true) const

Sequence *	GetSequenceAtTime (double time)

Envelope *	GetEnvelopeAtTime (double time)

WaveClip *	GetClipAtSample (sampleCount sample)

WaveClip *	GetClipAtTime (double time)

sampleCount	GetBlockStart (sampleCount t) const override
	This returns a possibly large or negative value. More...

size_t	GetBestBlockSize (sampleCount t) const override
	This returns a nonnegative number of samples meant to size a memory buffer. More...

size_t	GetMaxBlockSize () const override
	This returns a nonnegative number of samples meant to size a memory buffer. More...

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

bool	GetErrorOpening () override

bool	CloseLock ()

WaveClipHolders &	GetClips ()

const WaveClipConstHolders &	GetClips () const

IteratorRange< AllClipsIterator >	GetAllClips ()

IteratorRange< AllClipsConstIterator >	GetAllClips () const

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

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

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

int	GetClipIndex (const WaveClip *clip) const

WaveClip *	GetClipByIndex (int index)

const WaveClip *	GetClipByIndex (int index) const

int	GetNumClips () const

WaveClipPointers	SortedClipArray ()

WaveClipConstPointers	SortedClipArray () const

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

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

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

bool	AddClip (const std::shared_ptr< WaveClip > &clip)
	Append a clip to the track; which must have the same block factory as this track; return success. More...

void	MergeClips (int clipidx1, int clipidx2)

void	UpdateLocationsCache () const

const std::vector< Location > &	GetCachedLocations () const

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

bool	RemoveCutLine (double cutLinePosition)

void	Merge (const Track &orig) override

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

const TypeInfo &	GetTypeInfo () const override

int	GetLastScaleType () const

void	SetLastScaleType () const

int	GetLastdBRange () const

void	SetLastdBRange () const

void	GetDisplayBounds (float min, float max) const

void	SetDisplayBounds (float min, float max) const

void	GetSpectrumBounds (float min, float max) const

void	SetSpectrumBounds (float min, float max) const

int	ZeroLevelYCoordinate (wxRect rect) const

Track::Holder	PasteInto (AudacityProject &) const override
	Find or create the destination track for a paste, maybe in a different project. More...

ConstIntervals	GetIntervals () const override
	Report times on the track where important intervals begin and end, for UI to snap to. More...

Intervals	GetIntervals () override

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

Public Member Functions inherited from WritableSampleTrack
	WritableSampleTrack ()

	WritableSampleTrack (const WritableSampleTrack &other, ProtectedCreationArg &&)

	~WritableSampleTrack () override

const TypeInfo &	GetTypeInfo () const override

virtual void	SetOldChannelGain (int channel, float gain)=0

virtual bool	Append (constSamplePtr buffer, sampleFormat format, size_t len, unsigned int stride=1)=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...

Public Member Functions inherited from SampleTrack
	SampleTrack ()

	SampleTrack (const SampleTrack &other, ProtectedCreationArg &&)

	~SampleTrack () override

const TypeInfo &	GetTypeInfo () const override

virtual sampleFormat	GetSampleFormat () const =0

virtual ChannelType	GetChannelIgnoringPan () const =0

virtual float	GetOldChannelGain (int channel) const =0

virtual double	GetRate () const =0

virtual void	GetEnvelopeValues (double *buffer, size_t bufferLen, double t0) const =0
	Fetch envelope values corresponding to uniformly separated sample times starting at the given time. More...

virtual float	GetChannelGain (int channel) const =0
	Takes gain and pan into account. More...

virtual size_t	GetBestBlockSize (sampleCount t) const =0
	This returns a nonnegative number of samples meant to size a memory buffer. More...

virtual size_t	GetMaxBlockSize () const =0
	This returns a nonnegative number of samples meant to size a memory buffer. More...

virtual sampleCount	GetBlockStart (sampleCount t) const =0
	This returns a possibly large or negative value. More...

bool	GetFloats (float buffer, sampleCount start, size_t len, fillFormat fill=fillZero, bool mayThrow=true, sampleCount pNumWithinClips=nullptr) const
	Retrieve samples from a track in floating-point format, regardless of the storage format. More...

virtual bool	Get (samplePtr buffer, sampleFormat format, sampleCount start, size_t len, fillFormat fill=fillZero, bool mayThrow=true, sampleCount *pNumWithinClips=nullptr) const =0
	Retrieve samples from a track in a specified format. More...

sampleCount	TimeToLongSamples (double t0) const
	Convert correctly between an (absolute) time in seconds and a number of samples. More...

double	LongSamplesToTime (sampleCount pos) const
	Convert correctly between a number of samples and an (absolute) time in seconds. More...

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	Init (const PlayableTrack &init)

void	Merge (const Track &init) override

void	WriteXMLAttributes (XMLWriter &xmlFile) const

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

Public Member Functions inherited from AudioTrack
	AudioTrack ()

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

void	WriteXMLAttributes (XMLWriter &WXUNUSED(xmlFile)) const

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

Public Member Functions inherited from Track
TrackId	GetId () const

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

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

std::shared_ptr< Track >	SubstitutePendingChangedTrack ()

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

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

virtual const TypeInfo &	GetTypeInfo () const =0

virtual const TypeNames &	GetTypeNames () const

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

virtual Holder	PasteInto (AudacityProject &) const =0
	Find or create the destination track for a paste, maybe in a different project. More...

virtual ConstIntervals	GetIntervals () const
	Report times on the track where important intervals begin and end, for UI to snap to. More...

virtual Intervals	GetIntervals ()

int	GetIndex () const

void	SetIndex (int index)

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

bool	LinkConsistencyCheck (bool completeList)
	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

bool	IsAlignedWithLeader () const
	Returns true if the leader track has link type LinkType::Aligned. More...

ChannelGroupData &	GetGroupData ()

const ChannelGroupData &	GetGroupData () const

	Track ()

	Track (const Track &orig, ProtectedCreationArg &&)

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

virtual	~Track ()

void	Init (const Track &orig)

virtual Holder	Duplicate () const

virtual void	Merge (const Track &orig)

wxString	GetName () const

void	SetName (const wxString &n)

bool	GetSelected () const

virtual void	SetSelected (bool s)

void	EnsureVisible (bool modifyState=false)

virtual ChannelType	GetChannel () const

virtual double	GetOffset () const =0

void	Offset (double t)

virtual void	SetOffset (double o)

virtual void	SetPan (float)

virtual void	SetPanFromChannelType ()

virtual Holder	Cut (double WXUNUSED(t0), double WXUNUSED(t1))=0

virtual Holder	Copy (double WXUNUSED(t0), double WXUNUSED(t1), bool forClipboard=true) const =0

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

virtual void	Paste (double WXUNUSED(t), const Track *WXUNUSED(src))=0

virtual void	SyncLockAdjust (double oldT1, double newT1)

virtual void	Silence (double WXUNUSED(t0), double WXUNUSED(t1))=0

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

bool	SameKindAs (const Track &track) const

template<typename R = void, typename ... Functions>
R	TypeSwitch (const Functions &...functions)
	Use this function rather than testing track type explicitly and making down-casts. More...

template<typename R = void, typename ... Functions>
R	TypeSwitch (const Functions &...functions) const
	Use this function rather than testing track type explicitly and making down-casts. More...

virtual void	WriteXML (XMLWriter &xmlFile) const =0

virtual bool	GetErrorOpening ()

virtual double	GetStartTime () const =0

virtual double	GetEndTime () const =0

void	Notify (int code=-1)

bool	Any () const

bool	IsSelected () const

bool	IsLeader () const

bool	IsSelectedLeader () 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...

Static Public Member Functions
static wxString	GetDefaultAudioTrackNamePreference ()

static WaveTrack *	New (AudacityProject &project)

static const TypeInfo &	ClassTypeInfo ()

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

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

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

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

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

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

static const TypeInfo &	ClassTypeInfo ()

static void	FinishCopy (const Track n, Track dest)

template<typename TrackType >
static void	checkTrackType ()

template<typename R , typename TrackType , typename... Functions>
static R	CallExecutor (R , std::tuple<> , TrackType &, const Functions &...)

template<typename R , typename TrackType , typename... Functions, typename Executor , typename... Executors>
static R	CallExecutor (R , std::tuple< Executor, Executors... > , TrackType &track, const Functions &...functions)

template<typename ... Executors>
static constexpr unsigned	UsedCases (std::tuple< Executors... > *)

template<typename Tag , bool IsConst, typename R , typename ... TrackTypes, typename ... Functions>
static R	DoTypeSwitch (std::conditional_t< IsConst, const Track, Track > &track, std::tuple< TrackTypes... > *, const Functions &...functions)

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

Protected Attributes
WaveClipHolders	mClips

sampleFormat	mFormat

int	mRate

std::atomic< float >	mGain { 1.0f }
	Atomic because it may be read by worker threads in playback. More...

std::atomic< float >	mPan { 0.0f }
	Atomic because it may be read by worker threads in playback. More...

int	mWaveColorIndex

float	mOldGain [2]
	A memo used by PortAudio thread, doesn't need atomics: More...

float	mDisplayMin

float	mDisplayMax

float	mSpectrumMin

float	mSpectrumMax

int	mLastScaleType

int	mLastdBRange

std::vector< Location >	mDisplayLocationsCache

Protected Attributes inherited from PlayableTrack
std::atomic< bool >	mMute { false }
	Atomic because it may be read by worker threads in playback. More...

std::atomic< bool >	mSolo { false }
	Atomic because it may be read by worker threads in playback. More...

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

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

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

wxString	mName

ChannelType	mChannel

double	mOffset

Private Member Functions
void	Init (const WaveTrack &orig)

Track::Holder	Clone () const override

wxString	MakeClipCopyName (const wxString &originalName) const

wxString	MakeNewClipName () const

void	DoSetPan (float value)

void	DoSetGain (float value)

void	PasteWaveTrack (double t0, const WaveTrack *other)

Private Attributes
SampleBlockFactoryPtr	mpFactory

wxCriticalSection	mFlushCriticalSection

wxCriticalSection	mAppendCriticalSection

double	mLegacyProjectFileOffset

std::unique_ptr< SpectrogramSettings >	mpSpectrumSettings

std::unique_ptr< WaveformSettings >	mpWaveformSettings

Friends
class	WaveTrackFactory

Additional Inherited Members
Public Attributes inherited from Track
std::pair< int, int >	vrulerSize

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)

void	SetChannel (ChannelType c) noexcept

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

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

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

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

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

Detailed Description

A Track that contains audio waveform data.

Definition at line 56 of file WaveTrack.h.

Member Typedef Documentation

◆ Holder

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

Definition at line 106 of file WaveTrack.h.

◆ Location

typedef WaveTrackLocation WaveTrack::Location

Definition at line 105 of file WaveTrack.h.

◆ Regions

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

Definition at line 75 of file WaveTrack.h.

Constructor & Destructor Documentation

◆ WaveTrack() [1/2]

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

Definition at line 137 of file WaveTrack.cpp.

   : WritableSampleTrack()
   , mpFactory(pFactory)
{
   mLegacyProjectFileOffset = 0;
 
   mFormat = format;
   mRate = (int) rate;
   mOldGain[0] = 0.0;
   mOldGain[1] = 0.0;
   mWaveColorIndex = 0;
   mDisplayMin = -1.0;
   mDisplayMax = 1.0;
   mSpectrumMin = mSpectrumMax = -1; // so values will default to settings
   mLastScaleType = -1;
   mLastdBRange = -1;
}

References format, mDisplayMax, mDisplayMin, mFormat, mLastdBRange, mLastScaleType, mLegacyProjectFileOffset, mOldGain, mRate, mSpectrumMax, mSpectrumMin, and mWaveColorIndex.

◆ WaveTrack() [2/2]

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

Copied only in WaveTrack::Clone() !

Definition at line 156 of file WaveTrack.cpp.

   : WritableSampleTrack(orig, std::move(a))
   , mpFactory( orig.mpFactory )
   , mpSpectrumSettings(orig.mpSpectrumSettings
      ? std::make_unique<SpectrogramSettings>(*orig.mpSpectrumSettings)
      : nullptr
   )
   , mpWaveformSettings(orig.mpWaveformSettings 
      ? std::make_unique<WaveformSettings>(*orig.mpWaveformSettings)
      : nullptr
   )
{
   mLastScaleType = -1;
   mLastdBRange = -1;
   mLegacyProjectFileOffset = 0;
   for (const auto &clip : orig.mClips)
      mClips.push_back
         ( std::make_unique<WaveClip>( *clip, mpFactory, true ) );
}

References mClips, mLastdBRange, mLastScaleType, mLegacyProjectFileOffset, and mpFactory.

◆ ~WaveTrack()

WaveTrack::~WaveTrack ( )

virtual

Definition at line 233 of file WaveTrack.cpp.

234{

235}

Member Function Documentation

◆ AddClip()

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

Append a clip to the track; which must have the same block factory as this track; return success.

Definition at line 1230 of file WaveTrack.cpp.

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

References mClips.

Referenced by ClearAndPaste(), and EffectReverse::ProcessOneWave().

Here is the caller graph for this function:

◆ Append()

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

overridevirtual

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

Implements WritableSampleTrack.

Definition at line 1776 of file WaveTrack.cpp.

{
   return RightmostOrNewClip()->Append(buffer, format, len, stride);
}

References WaveClip::Append(), format, and RightmostOrNewClip().

Referenced by BlockGenerator::GenerateTrack(), EffectTwoPassSimpleMono::ProcessOne(), and NyquistEffect::PutCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CanInsertClip()

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

Definition at line 2492 of file WaveTrack.cpp.

{
   for (const auto &c : mClips)
   {
      double d1 = c->GetPlayStartTime() - (clip->GetPlayEndTime()+slideBy);
      double d2 = (clip->GetPlayStartTime()+slideBy) - c->GetPlayEndTime();
      if ( (d1<0) &&  (d2<0) )
      {
         // clips overlap.
         // Try to rescue it.
         // The rescue logic is not perfect, and will typically
         // move the clip at most once.  
         // We divide by 1000 rather than set to 0, to allow for 
         // a second 'micro move' that is really about rounding error.
         if( -d1 < tolerance ){
            // right edge of clip overlaps slightly.
            // slide clip left a small amount.
            slideBy +=d1;
            tolerance /=1000;
         } else if( -d2 < tolerance ){
            // left edge of clip overlaps slightly.
            // slide clip right a small amount.
            slideBy -= d2;
            tolerance /=1000;
         }
         else
            return false; // clips overlap  No tolerance left.
      }
   }
 
   return true;
}

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

Here is the call graph for this function:

◆ CanOffsetClips()

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

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

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

Parameters

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

Definition at line 2434 of file WaveTrack.cpp.

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

References CanOffsetClips(), and mClips.

Referenced by CanOffsetClips().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ClassTypeInfo()

auto WaveTrack::ClassTypeInfo ( )

static

Definition at line 325 of file WaveTrack.cpp.

{
   return typeInfo();
}

References typeInfo().

Here is the call graph for this function:

◆ Clear()

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

override

Exception safety guarantee:: Strong

Definition at line 788 of file WaveTrack.cpp.

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

References HandleClear().

Referenced by Cut(), EffectTruncSilence::DoRemoval(), LabelEditActions::Handler::OnCutLabels(), Generator::Process(), EffectEqualization::ProcessOne(), EffectStereoToMono::ProcessOne(), EffectPaulstretch::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
	)

Exception safety guarantee:: Strong

Definition at line 794 of file WaveTrack.cpp.

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

References HandleClear().

Referenced by EditActions::Handler::OnCut(), and LabelEditActions::Handler::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 Track *	src,
		bool	preserve = `true`,
		bool	merge = `true`,
		const TimeWarper *	effectWarper = `NULL`
	)

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

{
   double dur = std::min(t1 - t0, src->GetEndTime());
 
   // If duration is 0, then it's just a plain paste
   if (dur == 0.0) {
      // use Weak-guarantee
      Paste(t0, src);
      return;
   }
 
   std::vector<SplitInfo> splits;
   WaveClipHolders cuts;
 
   //helper routine, that finds SplitInfo by time value,
   //or creates a new one if no one exists yet
   auto get_split = [&](double time) {
      auto it = std::find_if(splits.begin(), splits.end(), [time](const SplitInfo& split) {
         return split.time == time;
      });
      if(it == splits.end())
         it = splits.insert(
            splits.end(),
            { time, nullptr, nullptr, std::nullopt, std::nullopt }
         );
      return it;
   };
 
   // If provided time warper was NULL, use a default one that does nothing
   IdentityTimeWarper localWarper;
   const TimeWarper *warper = (effectWarper ? effectWarper : &localWarper);
 
   // Align to a sample
   t0 = LongSamplesToTime(TimeToLongSamples(t0));
   t1 = LongSamplesToTime(TimeToLongSamples(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 : mClips) {
      double st;
 
      // Remember clip boundaries as locations to split
      // we need to copy clips, trims and names, because the original ones
      // could be changed later during Clear/Paste routines
      st = LongSamplesToTime(TimeToLongSamples(clip->GetPlayStartTime()));
      if (st >= t0 && st <= t1) {
         auto it = get_split(st);
         if (clip->GetTrimLeft() != 0)
         {
            //keep only hidden left part
            it->right = std::make_shared<WaveClip>(*clip, mpFactory, false);
            it->right->SetTrimLeft(.0);
            it->right->ClearRight(clip->GetPlayStartTime());
         }
         it->rightClipName = clip->GetName();
      }
 
      st = LongSamplesToTime(TimeToLongSamples(clip->GetPlayEndTime()));
      if (st >= t0 && st <= t1) {
         auto it = get_split(st);
         if (clip->GetTrimRight() != 0)
         {
            //keep only hidden right part
            it->left = std::make_shared<WaveClip>(*clip, mpFactory, false);
            it->left->SetTrimRight(.0);
            it->left->ClearLeft(clip->GetPlayEndTime());
         }
         it->leftClipName = clip->GetName();
      }
 
      // Search for cut lines
      auto &cutlines = clip->GetCutLines();
      // May erase from cutlines, so don't use range-for
      for (auto it = cutlines.begin(); it != cutlines.end(); ) {
         WaveClip *cut = it->get();
         double cs = LongSamplesToTime(TimeToLongSamples(clip->GetSequenceStartTime() +
                                                         cut->GetSequenceStartTime()));
 
         // Remember cut point
         if (cs >= t0 && cs <= t1) {
 
            // Remember the absolute offset and add to our cuts array.
            cut->SetSequenceStartTime(cs);
            cuts.push_back(std::move(*it)); // transfer ownership!
            it = cutlines.erase(it);
         }
         else
            ++it;
      }
   }
 
   const auto tolerance = 2.0 / GetRate();
 
   // Now, clear the selection
   HandleClear(t0, t1, false, false);
   {
 
      // And paste in the NEW data
      Paste(t0, src);
      {
         // 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 + src->GetEndTime();
 
            // Get a sorted array of the clips
            auto clips = SortedClipArray();
 
            // Scan the sorted clips for the first clip whose start time
            // exceeds the pasted regions end time.
            {
               WaveClip *prev = nullptr;
               for (const auto clip : clips) {
                  // Merge this clip and the previous clip if the end time
                  // falls within it and this isn't the first clip in the track.
                  if (fabs(t1 - clip->GetPlayStartTime()) < tolerance) {
                     if (prev)
                        MergeClips(GetClipIndex(prev), GetClipIndex(clip));
                     break;
                  }
                  prev = clip;
               }
            }
         }
 
         // Refill the array since clips have changed.
         auto clips = SortedClipArray();
 
         {
            // Scan the sorted clips to look for the start of the pasted
            // region.
            WaveClip *prev = nullptr;
            for (const auto clip : clips) {
               if (prev) {
                  // It must be that clip is what was pasted and it begins where
                  // prev ends.
                  // use Weak-guarantee
                  MergeClips(GetClipIndex(prev), GetClipIndex(clip));
                  break;
               }
               if (fabs(t0 - clip->GetPlayEndTime()) < tolerance)
                  // Merge this clip and the next clip if the start time
                  // falls within it and this isn't the last clip in the track.
                  prev = clip;
               else
                  prev = nullptr;
            }
         }
      }
 
      // Restore cut/split lines
      if (preserve) {
 
         auto attachLeft = [](WaveClip* target, WaveClip* src) 
         {
            wxASSERT(target->GetTrimLeft() == 0);
            if (target->GetTrimLeft() != 0)
               return;
 
            auto trim = src->GetPlayEndTime() - src->GetPlayStartTime();
            target->Paste(target->GetPlayStartTime(), src);
            target->SetTrimLeft(trim);
            //Play start time needs to be adjusted after 
            //prepending data to the sequence
            target->Offset(-trim);
         };
 
         auto attachRight = [](WaveClip* target, WaveClip* src)
         {
            wxASSERT(target->GetTrimRight() == 0);
            if (target->GetTrimRight() != 0)
               return;
            
            auto trim = src->GetPlayEndTime() - src->GetPlayStartTime();
            target->Paste(target->GetPlayEndTime(), src);
            target->SetTrimRight(trim);
         };
 
         // Restore the split lines and trims, transforming the position appropriately
         for (const auto& split: splits) {
            auto at = LongSamplesToTime(TimeToLongSamples(warper->Warp(split.time)));
            for (const auto& clip : GetClips())
            {
               if (clip->WithinPlayRegion(at))//strictly inside
               {
                  auto newClip = std::make_unique<WaveClip>(*clip, mpFactory, true);
 
                  clip->ClearRight(at);
                  newClip->ClearLeft(at);
                  if (split.left)
                     attachRight(clip.get(), split.left.get());
                  if (split.right)
                     attachLeft(newClip.get(), split.right.get());
                  AddClip(std::move(newClip));
                  break;
               }
               else if (clip->GetPlayStartSample() == TimeToLongSamples(at) && split.right)
               {
                  attachLeft(clip.get(), split.right.get());
                  break;
               }
               else if (clip->GetPlayEndSample() == TimeToLongSamples(at) && split.left)
               {
                  attachRight(clip.get(), split.left.get());
                  break;
               }
            }
         }
 
         //Restore clip names
         for (const auto& split : splits)
         {
            auto s = TimeToLongSamples(warper->Warp(split.time));
            for (auto& clip : GetClips())
            {
               if (split.rightClipName.has_value() && clip->GetPlayStartSample() == s)
                  clip->SetName(*split.rightClipName);
               else if (split.leftClipName.has_value() && clip->GetPlayEndSample() == s)
                  clip->SetName(*split.leftClipName);
            }
         }
 
         // Restore the saved cut lines, also transforming if time altered
         for (const auto &clip : mClips) {
            double st;
            double et;
 
            st = clip->GetPlayStartTime();
            et = clip->GetPlayEndTime();
 
            // Scan the cuts for any that live within this clip
            for (auto it = cuts.begin(); it != cuts.end();) {
               WaveClip *cut = it->get();
               //cutlines in this array were orphaned previously
               double cs = cut->GetSequenceStartTime();
 
               // Offset the cut from the start of the clip and add it to
               // this clips cutlines.
               if (cs >= st && cs <= et) {
                  cut->SetSequenceStartTime(warper->Warp(cs) - st);
                  clip->GetCutLines().push_back( std::move(*it) ); // transfer ownership!
                  it = cuts.erase(it);
               }
               else
                  ++it;
            }
         }
      }
   }
}

References AddClip(), GetClipIndex(), GetClips(), Track::GetEndTime(), WaveClip::GetPlayEndTime(), WaveClip::GetPlayStartTime(), GetRate(), WaveClip::GetSequenceStartTime(), WaveClip::GetTrimLeft(), WaveClip::GetTrimRight(), HandleClear(), SampleTrack::LongSamplesToTime(), mClips, MergeClips(), min(), mpFactory, WaveClip::Offset(), Paste(), WaveClip::Paste(), WaveClip::SetSequenceStartTime(), WaveClip::SetTrimLeft(), WaveClip::SetTrimRight(), SortedClipArray(), SampleTrack::TimeToLongSamples(), and TimeWarper::Warp().

Referenced by TrackSpectrumTransformer::DoFinish(), EffectSBSMS::Finalize(), WaveTrackSink::Flush(), EditActions::Handler::OnPaste(), Generator::Process(), NyquistEffect::ProcessOne(), EffectNoiseRemoval::ProcessOne(), and EffectChangeSpeed::ProcessOne().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Clone()

Track::Holder WaveTrack::Clone ( ) const

overrideprivatevirtual

Implements Track.

Definition at line 448 of file WaveTrack.cpp.

{
   auto result = std::make_shared<WaveTrack>(*this, ProtectedCreationArg{});
   result->Init(*this);
   return result;
}

◆ CloseLock()

bool WaveTrack::CloseLock ( )

Definition at line 1997 of file WaveTrack.cpp.

{
   for (const auto &clip : mClips)
      clip->CloseLock();
 
   return true;
}

References mClips.

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

{
   for (const auto& clip : mClips)
      clip->ConvertToSampleFormat(format, progressReport);
   mFormat = format;
}

References format, mClips, and mFormat.

Referenced by EffectEqualization::ProcessOne().

Here is the caller graph for this function:

◆ Copy()

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

override

Definition at line 716 of file WaveTrack.cpp.

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

References EmptyCopy(), GetEndTime(), GetRate(), GetSampleFormat(), mClips, min(), mpFactory, WaveClip::Offset(), and THROW_INCONSISTENCY_EXCEPTION.

Referenced by CopyNonconst(), Cut(), EditActions::Handler::OnSplitCut(), LabelEditActions::Handler::OnSplitCutLabels(), and SplitCut().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CopyNonconst()

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

Definition at line 782 of file WaveTrack.cpp.

{
   return Copy(t0, t1);
}

References Copy().

Referenced by LabelEditActions::Handler::OnCopyLabels(), and LabelEditActions::Handler::OnCutLabels().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CreateClip()

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

Definition at line 2368 of file WaveTrack.cpp.

{
   auto clip = std::make_unique<WaveClip>(mpFactory, mFormat, mRate, GetWaveColorIndex());
   clip->SetName(name);
   clip->SetSequenceStartTime(offset);
   mClips.push_back(std::move(clip));
 
   return mClips.back().get();
}

References GetWaveColorIndex(), mClips, mFormat, mpFactory, mRate, and name.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Cut()

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

override

Definition at line 627 of file WaveTrack.cpp.

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

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

Referenced by PasteWaveTrack(), and SyncLockAdjust().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Disjoin()

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

Exception safety guarantee:: Weak

Definition at line 1647 of file WaveTrack.cpp.

{
   auto minSamples = TimeToLongSamples( WAVETRACK_MERGE_POINT_TOLERANCE );
   const size_t maxAtOnce = 1048576;
   Floats buffer{ maxAtOnce };
   Regions regions;
 
   for (const auto &clip : mClips)
   {
      double startTime = clip->GetPlayStartTime();
      double endTime = clip->GetPlayEndTime();
 
      if( endTime < t0 || startTime > t1 )
         continue;
 
      //simply look for a sequence of zeroes and if the sequence
      //is greater than minimum number, split-DELETE the region
 
      sampleCount seqStart = -1;
      auto start = clip->TimeToSamples(std::max(.0, t0 - startTime));
      auto end = clip->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 );
 
         clip->GetSamples( ( samplePtr )buffer.get(), floatSample, start + done,
               numSamples );
         for( decltype(numSamples) i = 0; i < numSamples; i++ )
         {
            auto curSamplePos = start + done + i;
 
            //start a NEW sequence
            if( buffer[ i ] == 0.0 && seqStart == -1 )
               seqStart = curSamplePos;
            else if( buffer[ i ] != 0.0 || curSamplePos == end - 1 )
            {
               if( seqStart != -1 )
               {
                  decltype(end) seqEnd;
 
                  //consider the end case, where selection ends in zeroes
                  if( curSamplePos == end - 1 && buffer[ i ] == 0.0 )
                     seqEnd = end;
                  else
                     seqEnd = curSamplePos;
                  if( seqEnd - seqStart + 1 > minSamples )
                  {
                     regions.push_back(
                        Region(
                           startTime + clip->SamplesToTime(seqStart),
                           startTime + clip->SamplesToTime(seqEnd)
                        )
                     );
                  }
                  seqStart = -1;
               }
            }
         }
      }
   }
 
   for( unsigned int i = 0; i < regions.size(); i++ )
   {
      const Region &region = regions.at(i);
      SplitDelete(region.start, region.end );
   }
}

References PackedArray::end(), WaveTrack::Region::end, floatSample, limitSampleBufferSize(), mClips, min(), SplitDelete(), WaveTrack::Region::start, SampleTrack::TimeToLongSamples(), and WAVETRACK_MERGE_POINT_TOLERANCE.

Referenced by LabelEditActions::Handler::OnDisjoinLabels().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DoSetGain()

void WaveTrack::DoSetGain ( float value )

private

Definition at line 501 of file WaveTrack.cpp.

{
   mGain.store(value, std::memory_order_relaxed);
}

References mGain.

Referenced by HandleXMLTag(), Init(), Merge(), and SetGain().

Here is the caller graph for this function:

◆ DoSetPan()

void WaveTrack::DoSetPan ( float value )

private

Definition at line 519 of file WaveTrack.cpp.

{
   mPan.store(value, std::memory_order_relaxed);
}

References mPan.

Referenced by HandleXMLTag(), Init(), Merge(), and SetPan().

Here is the caller graph for this function:

◆ EmptyCopy()

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

Make another track copying format, rate, color, etc. but containing no clips

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

Parameters

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

Definition at line 705 of file WaveTrack.cpp.

{
   auto result = std::make_shared<WaveTrack>( pFactory, mFormat, mRate );
   result->Init(*this);
   result->mpFactory = pFactory ? pFactory : mpFactory;
   if (!keepLink)
      result->SetLinkType(LinkType::None);
   return result;
}

References mFormat, mpFactory, mRate, and Track::None.

Referenced by Copy(), TrackSpectrumTransformer::DoStart(), PasteInto(), Generator::Process(), EffectSBSMS::Process(), NyquistEffect::ProcessOne(), EffectEqualization::ProcessOne(), EffectNoiseRemoval::ProcessOne(), EffectStereoToMono::ProcessOne(), EffectChangeSpeed::ProcessOne(), and EffectPaulstretch::ProcessOne().

Here is the caller graph for this function:

◆ ExpandCutLine()

void WaveTrack::ExpandCutLine	(	double	cutLinePosition,
		double *	cutlineStart = `NULL`,
		double *	cutlineEnd = `NULL`
	)

Exception safety guarantee:: Strong

Definition at line 2628 of file WaveTrack.cpp.

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

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

Here is the call graph for this function:

◆ FindClipByName()

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

Returns nullptr if clip with such name was not found.

Definition at line 438 of file WaveTrack.cpp.

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

References mClips, and name.

Referenced by MakeClipCopyName(), and MakeNewClipName().

Here is the caller graph for this function:

◆ Flush()

void WaveTrack::Flush ( )

overridevirtual

Exception safety guarantee:: Mixed

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

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

Implements WritableSampleTrack.

Definition at line 1846 of file WaveTrack.cpp.

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

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

Referenced by EffectTwoPassSimpleMono::ProcessOne(), and AudioIO::StopStream().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Get()

bool WaveTrack::Get	(	samplePtr	buffer,
		sampleFormat	format,
		sampleCount	start,
		size_t	len,
		fillFormat	fill = `fillZero`,
		bool	mayThrow = `true`,
		sampleCount *	pNumWithinClips = `nullptr`
	)		const

overridevirtual

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

Definition at line 2122 of file WaveTrack.cpp.

{
   // Simple optimization: When this buffer is completely contained within one clip,
   // don't clear anything (because we won't have to). Otherwise, just clear
   // everything to be on the safe side.
   bool doClear = true;
   bool result = true;
   sampleCount samplesCopied = 0;
   for (const auto &clip: mClips)
   {
      if (start >= clip->GetPlayStartSample() && start+len <= clip->GetPlayEndSample())
      {
         doClear = false;
         break;
      }
   }
   if (doClear)
   {
      // Usually we fill in empty space with zero
      if( fill == fillZero )
         ClearSamples(buffer, format, 0, len);
      // but we don't have to.
      else if( fill==fillTwo )
      {
         wxASSERT( format==floatSample );
         float * pBuffer = (float*)buffer;
         for(size_t i=0;i<len;i++)
            pBuffer[i]=2.0f;
      }
      else
      {
         wxFAIL_MSG(wxT("Invalid fill format"));
      }
   }
 
   // Iterate the clips.  They are not necessarily sorted by time.
   for (const auto &clip: mClips)
   {
      auto clipStart = clip->GetPlayStartSample();
      auto clipEnd = clip->GetPlayEndSample();
 
      if (clipEnd > start && clipStart < start+len)
      {
         // Clip sample region and Get/Put sample region overlap
         auto samplesToCopy =
            std::min( start+len - clipStart, clip->GetPlaySamplesCount() );
         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(
               (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;
   return result;
}

References ClearSamples(), fillTwo, fillZero, floatSample, format, mClips, min(), SAMPLE_SIZE, and wxT().

Referenced by WaveTrackFactory::Get(), and EffectNoiseRemoval::ProcessOne().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetAllClips() [1/2]

IteratorRange< AllClipsIterator > WaveTrack::GetAllClips ( )

inline

Definition at line 411 of file WaveTrack.h.

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

◆ GetAllClips() [2/2]

IteratorRange< AllClipsConstIterator > WaveTrack::GetAllClips ( ) const

inline

Definition at line 416 of file WaveTrack.h.

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

◆ GetBestBlockSize()

size_t WaveTrack::GetBestBlockSize ( sampleCount t ) const

overridevirtual

This returns a nonnegative number of samples meant to size a memory buffer.

Implements SampleTrack.

Definition at line 1798 of file WaveTrack.cpp.

{
   auto bestBlockSize = GetMaxBlockSize();
 
   for (const auto &clip : mClips)
   {
      auto startSample = clip->GetPlayStartSample();
      auto endSample = clip->GetPlayEndSample();
      if (s >= startSample && s < endSample)
      {
         bestBlockSize = clip->GetSequence()->GetBestBlockSize(s - clip->GetSequenceStartSample());
         break;
      }
   }
 
   return bestBlockSize;
}

References GetMaxBlockSize(), and mClips.

Referenced by EffectNormalize::AnalyseTrackData(), CompareAudioCommand::Apply(), BlockGenerator::GenerateTrack(), NyquistEffect::GetCallback(), TrackSpectrumTransformer::Process(), EffectNoiseRemoval::ProcessOne(), EffectLoudness::ProcessOne(), EffectNormalize::ProcessOne(), EffectChangeSpeed::ProcessOne(), EffectSimpleMono::ProcessOne(), EffectTwoPassSimpleMono::ProcessOne(), EffectReverse::ProcessOneClip(), resampleCB(), VoiceKey::TestDirectionChanges(), VoiceKey::TestEnergy(), and VoiceKey::TestSignChanges().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetBlockStart()

sampleCount WaveTrack::GetBlockStart ( sampleCount t ) const

overridevirtual

This returns a possibly large or negative value.

Implements SampleTrack.

Definition at line 1782 of file WaveTrack.cpp.

{
   for (const auto &clip : mClips)
   {
      const auto startSample = clip->GetPlayStartSample();
      const auto endSample = clip->GetPlayEndSample();
      if (s >= startSample && s < endSample)
      {
          auto blockStartOffset = clip->GetSequence()->GetBlockStart(clip->ToSequenceSamples(s));
          return std::max(startSample, clip->GetSequenceStartSample() + blockStartOffset);
      }
   }
 
   return -1;
}

References mClips.

◆ GetCachedLocations()

const std::vector< Location > & WaveTrack::GetCachedLocations ( ) const

inline

Definition at line 489 of file WaveTrack.h.

489{ return mDisplayLocationsCache; }

WaveTrack::mDisplayLocationsCache

std::vector< Location > mDisplayLocationsCache

Definition: WaveTrack.h:570

Referenced by WaveTrackSubView::DrawBoldBoundaries(), anonymous_namespace{CutlineHandle.cpp}::FindMergeLine(), and anonymous_namespace{CutlineHandle.cpp}::IsOverCutline().

Here is the caller graph for this function:

◆ GetChannel()

auto WaveTrack::GetChannel ( ) const

overridevirtual

Reimplemented from Track.

Definition at line 258 of file WaveTrack.cpp.

{
   if( mChannel != Track::MonoChannel )
      return mChannel; 
   auto pan = GetPan();
   if( pan < -0.99 )
      return Track::LeftChannel;
   if( pan >  0.99 )
      return Track::RightChannel;
   return mChannel;
}

References GetPan(), Track::LeftChannel, Track::mChannel, Track::MonoChannel, and Track::RightChannel.

Here is the call graph for this function:

◆ GetChannelGain()

float WaveTrack::GetChannelGain ( int channel ) const

overridevirtual

Takes gain and pan into account.

Implements SampleTrack.

Definition at line 537 of file WaveTrack.cpp.

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

References GetGain(), and GetPan().

Referenced by AudioIoCallback::AddToOutputChannel(), and MixerTrackCluster::UpdateMeter().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetChannelIgnoringPan()

auto WaveTrack::GetChannelIgnoringPan ( ) const

overridevirtual

May be called from a worker thread

Implements SampleTrack.

Definition at line 254 of file WaveTrack.cpp.

                                                           {
   return mChannel;
}

References Track::mChannel.

Referenced by AudioIoCallback::FillOutputBuffers(), and AudioIoCallback::TrackHasBeenFadedOut().

Here is the caller graph for this function:

◆ GetClipAtSample()

WaveClip * WaveTrack::GetClipAtSample ( sampleCount sample )

Definition at line 2313 of file WaveTrack.cpp.

{
   for (const auto &clip: mClips)
   {
      auto start = clip->GetPlayStartSample();
      auto len   = clip->GetPlaySamplesCount();
 
      if (sample >= start && sample < start + len)
         return clip.get();
   }
 
   return NULL;
}

References WaveClip::GetPlayStartSample(), and mClips.

Here is the call graph for this function:

◆ GetClipAtTime()

WaveClip * WaveTrack::GetClipAtTime ( double time )

Definition at line 2329 of file WaveTrack.cpp.

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

References SortedClipArray().

Referenced by SelectHandle::Click(), GetEnvelopeAtTime(), and GetSequenceAtTime().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetClipByIndex() [1/2]

WaveClip * WaveTrack::GetClipByIndex ( int index )

Definition at line 2416 of file WaveTrack.cpp.

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

References mClips.

Referenced by GetClipByIndex(), MergeClips(), and PasteWaveTrack().

Here is the caller graph for this function:

◆ GetClipByIndex() [2/2]

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

Definition at line 2424 of file WaveTrack.cpp.

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

References GetClipByIndex().

Here is the call graph for this function:

◆ GetClipIndex()

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

Definition at line 2409 of file WaveTrack.cpp.

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

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

Referenced by ClearAndPaste(), and UpdateLocationsCache().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetClips() [1/2]

WaveClipHolders & WaveTrack::GetClips ( )

inline

Definition at line 329 of file WaveTrack.h.

329{ return mClips; }

Referenced by ProjectFileManager::AddImportedTracks(), WaveClipTrimHandle::AdjustBetweenBorders::AdjustBetweenBorders(), ClearAndPaste(), SpectrumView::DoDraw(), WaveformView::DoDraw(), EffectEqualization::ProcessOne(), EffectReverse::ProcessOneWave(), and anonymous_namespace{ClipMenus.cpp}::TwoChannelsHaveSameBoundaries().

Here is the caller graph for this function:

◆ GetClips() [2/2]

const WaveClipConstHolders & WaveTrack::GetClips ( ) const

inline

Definition at line 330 of file WaveTrack.h.

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

WaveClipConstHolders

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

Definition: WaveClip.h:43

◆ GetDefaultAudioTrackNamePreference()

wxString WaveTrack::GetDefaultAudioTrackNamePreference ( )

static

Definition at line 100 of file WaveTrack.cpp.

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetDisplayBounds()

void WaveTrack::GetDisplayBounds	(	float *	min,
		float *	max
	)		const

Definition at line 340 of file WaveTrack.cpp.

{
   *min = mDisplayMin;
   *max = mDisplayMax;
}

References mDisplayMax, mDisplayMin, and min().

Referenced by EnvelopeHandle::Click(), WaveformVRulerControls::DoHandleWheelRotation(), WaveformVRulerControls::DoUpdateVRuler(), WaveformVZoomHandle::DoZoom(), anonymous_namespace{WaveformView.cpp}::DrawClipWaveform(), and GetInfoCommand::SendTracks().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetEndTime()

double WaveTrack::GetEndTime ( ) const

overridevirtual

Get the time at which the last clip in the track ends, plus recorded stuff.

Returns: time in seconds, or zero if there are no clips in the track.

Implements Track.

Definition at line 2025 of file WaveTrack.cpp.

{
   bool found = false;
   double best = 0.0;
 
   if (mClips.empty())
      return 0;
 
   for (const auto &clip : mClips)
      if (!found)
      {
         found = true;
         best = clip->GetPlayEndTime();
      }
      else if (clip->GetPlayEndTime() > best)
         best = clip->GetPlayEndTime();
 
   return best;
}

References mClips.

Referenced by AUPImportFileHandle::AddSilence(), EffectTruncSilence::Analyze(), Copy(), Effect::GetBounds(), PasteWaveTrack(), EffectChangeSpeed::Process(), EffectSBSMS::Process(), NyquistEffect::ProcessOne(), EffectStereoToMono::ProcessOne(), GetInfoCommand::SendTracks(), SyncLockAdjust(), and Trim().

Here is the caller graph for this function:

◆ GetEnvelopeAtTime()

Envelope * WaveTrack::GetEnvelopeAtTime ( double time )

Definition at line 2350 of file WaveTrack.cpp.

{
   WaveClip* clip = GetClipAtTime(time);
   if (clip)
      return clip->GetEnvelope();
   else
      return NULL;
}

References GetClipAtTime(), and WaveClip::GetEnvelope().

Here is the call graph for this function:

◆ GetEnvelopeValues()

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

overridevirtual

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

Implements SampleTrack.

Definition at line 2247 of file WaveTrack.cpp.

{
   // 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;
   auto tstep = 1.0 / mRate;
   double endTime = t0 + tstep * bufferLen;
   for (const auto &clip: mClips)
   {
      // IF clip intersects startTime..endTime THEN...
      auto dClipStartTime = clip->GetPlayStartTime();
      auto dClipEndTime = clip->GetPlayEndTime();
      if ((dClipStartTime < endTime) && (dClipEndTime > startTime))
      {
         auto rbuf = buffer;
         auto rlen = bufferLen;
         auto rt0 = t0;
 
         if (rt0 < dClipStartTime)
         {
            // This is not more than the number of samples in
            // (endTime - startTime) which is bufferLen:
            auto nDiff = (sampleCount)floor((dClipStartTime - rt0) * mRate + 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);
      }
   }
}

References limitSampleBufferSize(), mClips, min(), and mRate.

Here is the call graph for this function:

◆ GetErrorOpening()

bool WaveTrack::GetErrorOpening ( )

overridevirtual

Reimplemented from Track.

Definition at line 1988 of file WaveTrack.cpp.

{
   for (const auto &clip : mClips)
      if (clip->GetSequence()->GetErrorOpening())
         return true;
 
   return false;
}

References mClips.

◆ GetGain()

float WaveTrack::GetGain ( ) const

Definition at line 496 of file WaveTrack.cpp.

{
   return mGain.load(std::memory_order_relaxed);
}

References mGain.

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

Here is the caller graph for this function:

◆ GetIdealBlockSize()

size_t WaveTrack::GetIdealBlockSize ( )

Definition at line 1836 of file WaveTrack.cpp.

{
   return NewestOrNewClip()->GetSequence()->GetIdealBlockSize();
}

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

Referenced by NyquistEffect::GetCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetIndependentSpectrogramSettings()

SpectrogramSettings & WaveTrack::GetIndependentSpectrogramSettings ( )

Definition at line 815 of file WaveTrack.cpp.

{
   if (!mpSpectrumSettings)
      mpSpectrumSettings =
      std::make_unique<SpectrogramSettings>(SpectrogramSettings::defaults());
   return *mpSpectrumSettings;
}

References SpectrogramSettings::defaults(), and mpSpectrumSettings.

Referenced by SpectrumVRulerControls::DoHandleWheelRotation(), and UseSpectralPrefs().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetIntervals() [1/2]

auto WaveTrack::GetIntervals ( ) const

overridevirtual

Report times on the track where important intervals begin and end, for UI to snap to.

Some intervals may be empty, and no ordering of the intervals is assumed.

Reimplemented from Track.

Definition at line 428 of file WaveTrack.cpp.

{
   return MakeIntervals<ConstIntervals>( mClips );
}

References mClips.

◆ GetIntervals() [2/2]

auto WaveTrack::GetIntervals ( )

overridevirtual

This overload exposes the extra data of the intervals as non-const This overload exposes the extra data of the intervals as non-const

Reimplemented from Track.

Definition at line 433 of file WaveTrack.cpp.

{
   return MakeIntervals<Intervals>( mClips );
}

◆ GetLastdBRange()

int WaveTrack::GetLastdBRange ( ) const

inline

Definition at line 510 of file WaveTrack.h.

510{ return mLastdBRange; }

Referenced by WaveformVRulerControls::DoUpdateVRuler().

Here is the caller graph for this function:

◆ GetLastScaleType()

int WaveTrack::GetLastScaleType ( ) const

inline

Definition at line 507 of file WaveTrack.h.

507{ return mLastScaleType; }

Referenced by WaveformVRulerControls::DoUpdateVRuler().

Here is the caller graph for this function:

◆ GetMaxBlockSize()

size_t WaveTrack::GetMaxBlockSize ( ) const

overridevirtual

This returns a nonnegative number of samples meant to size a memory buffer.

Implements SampleTrack.

Definition at line 1816 of file WaveTrack.cpp.

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

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

Referenced by EffectNormalize::AnalyseTrackData(), EffectTruncSilence::Analyze(), CompareAudioCommand::Apply(), BlockGenerator::GenerateTrack(), GetBestBlockSize(), GetMaxBlockSize(), EffectCompressor::InitPass1(), TrackSpectrumTransformer::Process(), EffectSBSMS::Process(), EffectEqualization::ProcessOne(), EffectClickRemoval::ProcessOne(), EffectNoiseRemoval::ProcessOne(), EffectStereoToMono::ProcessOne(), EffectNormalize::ProcessOne(), EffectChangeSpeed::ProcessOne(), EffectSimpleMono::ProcessOne(), EffectTwoPassSimpleMono::ProcessOne(), EffectReverse::ProcessOneClip(), VoiceKey::TestDirectionChanges(), VoiceKey::TestEnergy(), and VoiceKey::TestSignChanges().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetMinMax()

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

Definition at line 2050 of file WaveTrack.cpp.

{
   std::pair<float, float> results {
      // we need these at extremes to make sure we find true min and max
      FLT_MAX, -FLT_MAX
   };
   bool clipFound = false;
 
   if (t0 > t1) {
      if (mayThrow)
         THROW_INCONSISTENCY_EXCEPTION;
      return results;
   }
 
   if (t0 == t1)
      return results;
 
   for (const auto &clip: mClips)
   {
      if (t1 >= clip->GetPlayStartTime() && t0 <= clip->GetPlayEndTime())
      {
         clipFound = true;
         auto clipResults = clip->GetMinMax(t0, t1, mayThrow);
         if (clipResults.first < results.first)
            results.first = clipResults.first;
         if (clipResults.second > results.second)
            results.second = clipResults.second;
      }
   }
 
   if(!clipFound)
   {
      results = { 0.f, 0.f }; // sensible defaults if no clips found
   }
 
   return results;
}

References mClips, and THROW_INCONSISTENCY_EXCEPTION.

Referenced by EffectNormalize::AnalyseTrack(), and NyquistEffect::ProcessOne().

Here is the caller graph for this function:

◆ GetNumClips()

int WaveTrack::GetNumClips ( ) const

Definition at line 2429 of file WaveTrack.cpp.

{
   return mClips.size();
}

References mClips.

Referenced by PasteWaveTrack().

Here is the caller graph for this function:

◆ GetOffset()

double WaveTrack::GetOffset ( ) const

overridevirtual

Implements Track.

Definition at line 237 of file WaveTrack.cpp.

{
   return GetStartTime();
}

References GetStartTime().

Referenced by TranscriptionToolBar::GetSamples(), EditActions::Handler::OnSplitNew(), and SetOffset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetOldChannelGain()

float WaveTrack::GetOldChannelGain ( int channel ) const

overridevirtual

Implements SampleTrack.

Definition at line 555 of file WaveTrack.cpp.

{
   return mOldGain[channel%2];
}

References mOldGain.

Referenced by AudioIoCallback::AddToOutputChannel(), and AudioIoCallback::TrackHasBeenFadedOut().

Here is the caller graph for this function:

◆ GetPan()

float WaveTrack::GetPan ( ) const

Definition at line 514 of file WaveTrack.cpp.

{
   return mPan.load(std::memory_order_relaxed);
}

References mPan.

Referenced by GetChannel(), GetChannelGain(), Init(), Merge(), WaveTrackControls::PanSlider(), GetInfoCommand::SendTracks(), and SetPan().

Here is the caller graph for this function:

◆ GetPlaySamplesCount()

sampleCount WaveTrack::GetPlaySamplesCount ( ) const

Definition at line 575 of file WaveTrack.cpp.

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

References mClips.

◆ GetRate()

double WaveTrack::GetRate ( ) const

overridevirtual

Implements SampleTrack.

Definition at line 479 of file WaveTrack.cpp.

{
   return mRate;
}

References mRate.

Referenced by ProjectFileManager::AddImportedTracks(), SelectHandle::AdjustFreqSelection(), EffectTruncSilence::Analyze(), VoiceKey::CalibrateNoise(), ClearAndPaste(), Copy(), SpectrumVRulerControls::DoHandleWheelRotation(), SpectrumVZoomHandle::DoZoom(), WaveformVZoomHandle::DoZoom(), anonymous_namespace{CutlineHandle.cpp}::FindMergeLine(), TranscriptionToolBar::GetSamples(), GetSpectrumBounds(), SelectHandle::MoveSnappingFreqSelection(), VoiceKey::OffBackward(), VoiceKey::OffForward(), VoiceKey::OnBackward(), VoiceKey::OnForward(), anonymous_namespace{BrushHandle.cpp}::PositionToFrequency(), anonymous_namespace{SelectHandle.cpp}::PositionToFrequency(), Generator::Process(), EffectSBSMS::Process(), NyquistEffect::ProcessOne(), EffectStereoToMono::ProcessOne(), EffectPaulstretch::ProcessOne(), SpectralDataManager::Worker::ProcessOvertones(), SpectralDataManager::Worker::ProcessSnapping(), anonymous_namespace{SampleHandle.cpp}::SampleResolutionTest(), SelectHandle::SnapCenterOnce(), ProjectSelectionManager::SSBL_GetRate(), SelectHandle::StartSnappingFreqSelection(), anonymous_namespace{WaveTrackControls.cpp}::Status1DrawFunction(), and SyncLockAdjust().

Here is the caller graph for this function:

◆ GetRMS()

float WaveTrack::GetRMS	(	double	t0,
		double	t1,
		bool	mayThrow = `true`
	)		const

Definition at line 2089 of file WaveTrack.cpp.

{
   if (t0 > t1) {
      if (mayThrow)
         THROW_INCONSISTENCY_EXCEPTION;
      return 0.f;
   }
 
   if (t0 == t1)
      return 0.f;
 
   double sumsq = 0.0;
   sampleCount length = 0;
 
   for (const auto &clip: mClips)
   {
      // If t1 == clip->GetStartTime() or t0 == clip->GetEndTime(), then the clip
      // is not inside the selection, so we don't want it.
      // if (t1 >= clip->GetStartTime() && t0 <= clip->GetEndTime())
      if (t1 >= clip->GetPlayStartTime() && t0 <= clip->GetPlayEndTime())
      {
         auto clipStart = clip->TimeToSequenceSamples(wxMax(t0, clip->GetPlayStartTime()));
         auto clipEnd = clip->TimeToSequenceSamples(wxMin(t1, clip->GetPlayEndTime()));
 
         float cliprms = clip->GetRMS(t0, t1, mayThrow);
 
         sumsq += cliprms * cliprms * (clipEnd - clipStart).as_float();
         length += (clipEnd - clipStart);
      }
   }
   return length > 0 ? sqrt(sumsq / length.as_double()) : 0.0;
}

References sampleCount::as_double(), mClips, and THROW_INCONSISTENCY_EXCEPTION.

Referenced by EffectLoudness::GetTrackRMS(), and NyquistEffect::ProcessOne().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetSampleFormat()

sampleFormat WaveTrack::GetSampleFormat ( ) const

inlineoverridevirtual

Implements SampleTrack.

Definition at line 161 of file WaveTrack.h.

161{ return mFormat; }

Referenced by Copy(), and SyncLockAdjust().

Here is the caller graph for this function:

◆ GetSequenceAtTime()

Sequence * WaveTrack::GetSequenceAtTime ( double time )

Definition at line 2359 of file WaveTrack.cpp.

{
   WaveClip* clip = GetClipAtTime(time);
   if (clip)
      return clip->GetSequence();
   else
      return NULL;
}

References GetClipAtTime(), and WaveClip::GetSequence().

Here is the call graph for this function:

◆ GetSequenceSamplesCount()

sampleCount WaveTrack::GetSequenceSamplesCount ( ) const

Definition at line 585 of file WaveTrack.cpp.

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

References mClips.

◆ GetSpectrogramSettings() [1/2]

SpectrogramSettings & WaveTrack::GetSpectrogramSettings ( )

Definition at line 807 of file WaveTrack.cpp.

{
   if (mpSpectrumSettings)
      return *mpSpectrumSettings;
   else
      return SpectrogramSettings::defaults();
}

References SpectrogramSettings::defaults(), and mpSpectrumSettings.

Here is the call graph for this function:

◆ GetSpectrogramSettings() [2/2]

const SpectrogramSettings & WaveTrack::GetSpectrogramSettings ( ) const

Definition at line 799 of file WaveTrack.cpp.

{
   if (mpSpectrumSettings)
      return *mpSpectrumSettings;
   else
      return SpectrogramSettings::defaults();
}

References SpectrogramSettings::defaults(), and mpSpectrumSettings.

Referenced by SpectrumVRulerControls::DoUpdateVRuler(), SpectrumVZoomHandle::DoZoom(), for(), anonymous_namespace{BrushHandle.cpp}::FrequencyToPosition(), anonymous_namespace{SelectHandle.cpp}::FrequencyToPosition(), GetSpectrumBounds(), SpectrumVRulerMenuTable::OnSpectrumScaleType(), anonymous_namespace{BrushHandle.cpp}::PositionToFrequency(), anonymous_namespace{SelectHandle.cpp}::PositionToFrequency(), NyquistEffect::ProcessOne(), SelectHandle::SnapCenterOnce(), SpectrumPrefs::SpectrumPrefs(), and SelectHandle::StartSnappingFreqSelection().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetSpectrumBounds()

void WaveTrack::GetSpectrumBounds	(	float *	min,
		float *	max
	)		const

Definition at line 352 of file WaveTrack.cpp.

{
   const double rate = GetRate();
 
   const SpectrogramSettings &settings = GetSpectrogramSettings();
   const SpectrogramSettings::ScaleType type = settings.scaleType;
 
   const float top = (rate / 2.);
 
   float bottom;
   if (type == SpectrogramSettings::stLinear)
      bottom = 0.0f;
   else if (type == SpectrogramSettings::stPeriod) {
      // special case
      const auto half = settings.GetFFTLength() / 2;
      // EAC returns no data for below this frequency:
      const float bin2 = rate / half;
      bottom = bin2;
   }
   else
      // logarithmic, etc.
      bottom = 1.0f;
 
   {
      float spectrumMax = mSpectrumMax;
      if (spectrumMax < 0)
         spectrumMax = settings.maxFreq;
      if (spectrumMax < 0)
         *max = top;
      else
         *max = std::max(bottom, std::min(top, spectrumMax));
   }
 
   {
      float spectrumMin = mSpectrumMin;
      if (spectrumMin < 0)
         spectrumMin = settings.minFreq;
      if (spectrumMin < 0)
         *min = std::max(bottom, top / 1000.0f);
      else
         *min = std::max(bottom, std::min(top, spectrumMin));
   }
}

References GetRate(), GetSpectrogramSettings(), min(), mSpectrumMax, mSpectrumMin, settings(), SpectrogramSettings::stLinear, and SpectrogramSettings::stPeriod.

Referenced by SpectrumVRulerControls::DoHandleWheelRotation(), SpectrumVRulerControls::DoUpdateVRuler(), SpectrumVZoomHandle::DoZoom(), anonymous_namespace{BrushHandle.cpp}::FrequencyToPosition(), anonymous_namespace{SelectHandle.cpp}::FrequencyToPosition(), anonymous_namespace{BrushHandle.cpp}::PositionToFrequency(), anonymous_namespace{SelectHandle.cpp}::PositionToFrequency(), and SpectrumPrefs::SpectrumPrefs().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetStartTime()

double WaveTrack::GetStartTime ( ) const

overridevirtual

Get the time at which the first clip in the track starts.

Returns: time in seconds, or zero if there are no clips in the track

Implements Track.

Definition at line 2005 of file WaveTrack.cpp.

{
   bool found = false;
   double best = 0.0;
 
   if (mClips.empty())
      return 0;
 
   for (const auto &clip : mClips)
      if (!found)
      {
         found = true;
         best = clip->GetPlayStartTime();
      }
      else if (clip->GetPlayStartTime() < best)
         best = clip->GetPlayStartTime();
 
   return best;
}

References mClips.

Referenced by Effect::GetBounds(), GetOffset(), PasteWaveTrack(), EffectChangeSpeed::Process(), EffectSBSMS::Process(), EffectStereoToMono::ProcessOne(), GetInfoCommand::SendTracks(), and Trim().

Here is the caller graph for this function:

◆ GetTypeInfo()

auto WaveTrack::GetTypeInfo ( ) const

overridevirtual

Implements Track.

Definition at line 320 of file WaveTrack.cpp.

{
   return typeInfo();
}

References typeInfo().

Here is the call graph for this function:

◆ GetWaveColorIndex()

int WaveTrack::GetWaveColorIndex ( ) const

inline

Definition at line 155 of file WaveTrack.h.

155{ return mWaveColorIndex; };

Referenced by CreateClip(), and InsertSilence().

Here is the caller graph for this function:

◆ GetWaveformSettings() [1/2]

WaveformSettings & WaveTrack::GetWaveformSettings ( )

Definition at line 853 of file WaveTrack.cpp.

{
   // Create on demand
   if (!mpWaveformSettings)
      mpWaveformSettings = std::make_unique<WaveformSettings>(WaveformSettings::defaults());
   return *mpWaveformSettings;
}

References WaveformSettings::defaults(), and mpWaveformSettings.

Here is the call graph for this function:

◆ GetWaveformSettings() [2/2]

const WaveformSettings & WaveTrack::GetWaveformSettings ( ) const

Definition at line 847 of file WaveTrack.cpp.

{
   // Create on demand
   return const_cast<WaveTrack*>(this)->GetWaveformSettings();
}

References GetWaveformSettings().

Referenced by EnvelopeHandle::Click(), WaveformView::DoDraw(), WaveformVRulerControls::DoHandleWheelRotation(), WaveformVRulerControls::DoUpdateVRuler(), WaveformVZoomHandle::DoZoom(), anonymous_namespace{WaveformView.cpp}::DrawClipWaveform(), for(), GetWaveformSettings(), WaveformVRulerMenuTable::OnWaveformScaleType(), SetLastdBRange(), SetLastScaleType(), and WaveformPrefs::WaveformPrefs().

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
	)

Exception safety guarantee:: Strong

Definition at line 1243 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;
 
   bool editClipCanMove = GetEditClipsCanMove();
 
   WaveClipPointers clipsToDelete;
   WaveClipHolders clipsToAdd;
 
   // We only add cut lines when deleting in the middle of a single clip
   // The cut line code is not really prepared to handle other situations
   if (addCutLines)
   {
      for (const auto &clip : mClips)
      {
         if (!clip->BeforePlayStartTime(t1) && !clip->AfterPlayEndTime(t0) &&
               (clip->BeforePlayStartTime(t0) || clip->AfterPlayEndTime(t1)))
         {
            addCutLines = false;
            break;
         }
      }
   }
 
   for (const auto &clip : mClips)
   {
      if (clip->BeforePlayStartTime(t0) && clip->AfterPlayEndTime(t1))
      {
         // Whole clip must be deleted - remember this
         clipsToDelete.push_back(clip.get());
      }
      else if (!clip->BeforePlayStartTime(t1) && !clip->AfterPlayEndTime(t0))
      {
         // Clip data is affected by command
         if (addCutLines)
         {
            // Don't modify this clip in place, because we want a strong
            // guarantee, and might modify another clip
            clipsToDelete.push_back( clip.get() );
            auto newClip = std::make_unique<WaveClip>( *clip, mpFactory, true );
            newClip->ClearAndAddCutLine( t0, t1 );
            clipsToAdd.push_back( std::move( newClip ) );
         }
         else
         {
            if (split) {
               // Three cases:
 
               if (clip->BeforePlayStartTime(t0)) {
                  // Delete from the left edge
 
                  // Don't modify this clip in place, because we want a strong
                  // guarantee, and might modify another clip
                  clipsToDelete.push_back( clip.get() );
                  auto newClip = std::make_unique<WaveClip>( *clip, mpFactory, true );
                  newClip->TrimLeft(t1 - clip->GetPlayStartTime());
                  clipsToAdd.push_back( std::move( newClip ) );
               }
               else if (clip->AfterPlayEndTime(t1)) {
                  // Delete to right edge
 
                  // Don't modify this clip in place, because we want a strong
                  // guarantee, and might modify another clip
                  clipsToDelete.push_back( clip.get() );
                  auto newClip = std::make_unique<WaveClip>( *clip, mpFactory, true );
                  newClip->TrimRight(clip->GetPlayEndTime() - t0);
 
                  clipsToAdd.push_back( std::move( newClip ) );
               }
               else {
                  // Delete in the middle of the clip...we actually create two
                  // NEW clips out of the left and right halves...
 
                  auto leftClip = std::make_unique<WaveClip>(*clip, mpFactory, true);
                  leftClip->TrimRight(clip->GetPlayEndTime() - t0);
                  clipsToAdd.push_back(std::move(leftClip));
 
                  auto rightClip = std::make_unique<WaveClip>(*clip, mpFactory, true);
                  rightClip->TrimLeft(t1 - rightClip->GetPlayStartTime());
                  clipsToAdd.push_back(std::move(rightClip));
 
                  clipsToDelete.push_back(clip.get());
               }
            }
            else {
               // (We are not doing a split cut)
 
               // Don't modify this clip in place, because we want a strong
               // guarantee, and might modify another clip
               clipsToDelete.push_back( clip.get() );
               auto newClip = std::make_unique<WaveClip>( *clip, mpFactory, true );
 
               // clip->Clear keeps points < t0 and >= t1 via Envelope::CollapseRegion
               newClip->Clear(t0,t1);
 
               clipsToAdd.push_back( std::move( newClip ) );
            }
         }
      }
   }
 
   // Only now, change the contents of this track
   // use No-fail-guarantee for the rest
 
   if (!split && editClipCanMove)
   {
      // Clip is "behind" the region -- offset it unless we're splitting
      // or we're using the "don't move other clips" mode
      for (const auto& clip : mClips)
      {
         if (clip->BeforePlayStartTime(t1))
            clip->Offset(-(t1 - t0));
      }
   }
 
   for (const auto &clip: clipsToDelete)
   {
      auto myIt = FindClip(mClips, clip);
      if (myIt != mClips.end())
         mClips.erase(myIt); // deletes the clip!
      else
         wxASSERT(false);
   }
 
   for (auto &clip: clipsToAdd)
      mClips.push_back(std::move(clip)); // transfer ownership
}

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

Referenced by Clear(), ClearAndAddCutLine(), ClearAndPaste(), 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 1924 of file WaveTrack.cpp.

{
   if ( auto pChild = WaveTrackIORegistry::Get()
          .CallObjectAccessor(tag, *this) )
      return pChild;
 
   //
   // This is legacy code (1.2 and previous) and is not called for NEW projects!
   //
   if (tag == "sequence" || tag == "envelope")
   {
      // This is a legacy project, so set the cached offset
      NewestOrNewClip()->SetSequenceStartTime(mLegacyProjectFileOffset);
 
      // Legacy project file tracks are imported as one single wave clip
      if (tag == "sequence")
         return NewestOrNewClip()->GetSequence();
      else if (tag == "envelope")
         return NewestOrNewClip()->GetEnvelope();
   }
 
   // JKC... for 1.1.0, one step better than what we had, but still badly broken.
   // If we see a waveblock at this level, we'd better generate a sequence.
   if (tag == "waveblock")
   {
      // This is a legacy project, so set the cached offset
      NewestOrNewClip()->SetSequenceStartTime(mLegacyProjectFileOffset);
      Sequence *pSeq = NewestOrNewClip()->GetSequence();
      return pSeq;
   }
 
   //
   // This is for the NEW file format (post-1.2)
   //
   if (tag == "waveclip")
      return CreateClip();
 
   return nullptr;
}

References CreateClip(), XMLMethodRegistry< Host >::Get(), WaveClip::GetEnvelope(), WaveClip::GetSequence(), mLegacyProjectFileOffset, NewestOrNewClip(), and WaveClip::SetSequenceStartTime().

Here is the call graph for this function:

◆ HandleXMLEndTag()

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

override

Definition at line 1917 of file WaveTrack.cpp.

{
   // In case we opened a pre-multiclip project, we need to
   // simulate closing the waveclip tag.
   NewestOrNewClip()->HandleXMLEndTag("waveclip");
}

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

Here is the call graph for this function:

◆ HandleXMLTag()

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

overridevirtual

Implements XMLTagHandler.

Definition at line 1859 of file WaveTrack.cpp.

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

References DoSetGain(), DoSetPan(), Track::HandleCommonXMLAttribute(), PlayableTrack::HandleXMLAttribute(), anonymous_namespace{WaveTrack.cpp}::IsValidChannel(), Sequence::IsValidSampleFormat(), lrint, Track::mChannel, mFormat, mLegacyProjectFileOffset, mRate, mWaveColorIndex, Track::SetLinkType(), and anonymous_namespace{WaveTrack.cpp}::ToLinkType().

Here is the call graph for this function:

◆ Init()

void WaveTrack::Init ( const WaveTrack & orig )

private

Definition at line 177 of file WaveTrack.cpp.

{
   WritableSampleTrack::Init(orig);
   mpFactory = orig.mpFactory;
   
   mFormat = orig.mFormat;
   mWaveColorIndex = orig.mWaveColorIndex;
   mRate = orig.mRate;
   DoSetGain(orig.GetGain());
   DoSetPan(orig.GetPan());
   mOldGain[0] = 0.0;
   mOldGain[1] = 0.0;
   mDisplayMin = orig.mDisplayMin;
   mDisplayMax = orig.mDisplayMax;
   mSpectrumMin = orig.mSpectrumMin;
   mSpectrumMax = orig.mSpectrumMax;
   mDisplayLocationsCache.clear();
}

References DoSetGain(), DoSetPan(), GetGain(), GetPan(), PlayableTrack::Init(), mDisplayLocationsCache, mDisplayMax, mDisplayMin, mFormat, mOldGain, mpFactory, mRate, mSpectrumMax, mSpectrumMin, and mWaveColorIndex.

Referenced by Reinit().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InsertSilence()

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

override

Exception safety guarantee:: Strong

Definition at line 1607 of file WaveTrack.cpp.

{
   // Nothing to do, if length is zero.
   // Fixes Bug 1626
   if( len == 0 )
      return;
   if (len <= 0)
      THROW_INCONSISTENCY_EXCEPTION;
 
   if (mClips.empty())
   {
      // Special case if there is no clip yet
      auto clip = std::make_unique<WaveClip>(mpFactory, mFormat, mRate, this->GetWaveColorIndex());
      clip->InsertSilence(0, len);
      // use No-fail-guarantee
      mClips.push_back( std::move( clip ) );
      return;
   }
   else {
      // Assume at most one clip contains t
      const auto end = mClips.end();
      const auto it = std::find_if( mClips.begin(), end,
         [&](const WaveClipHolder &clip) { return clip->WithinPlayRegion(t); } );
 
      // use Strong-guarantee
      if (it != end)
         it->get()->InsertSilence(t, len);
 
      // use No-fail-guarantee
      for (const auto &clip : mClips)
      {
         if (clip->BeforePlayStartTime(t))
            clip->Offset(len);
      }
   }
}

References PackedArray::end(), GetWaveColorIndex(), mClips, mFormat, mpFactory, mRate, and THROW_INCONSISTENCY_EXCEPTION.

Referenced by AUPImportFileHandle::AddSilence(), EffectSilence::GenerateTrack(), and FFmpegImportFileHandle::Import().

Here is the call graph for this function:

Here is the caller graph for this function:

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

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

References mClips.

Referenced by PasteWaveTrack(), Generator::Process(), and SyncLockAdjust().

Here is the caller graph for this function:

◆ Join()

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

Exception safety guarantee:: Weak

Definition at line 1718 of file WaveTrack.cpp.

{
   // Merge all WaveClips overlapping selection into one
 
   WaveClipPointers clipsToDelete;
   WaveClip* newClip{};
 
   for (const auto &clip: mClips)
   {
      if (clip->GetPlayStartTime() < t1-(1.0/mRate) &&
          clip->GetPlayEndTime()-(1.0/mRate) > t0) {
 
         // Put in sorted order
         auto it = clipsToDelete.begin(), end = clipsToDelete.end();
         for (; it != end; ++it)
            if ((*it)->GetPlayStartTime() > clip->GetPlayStartTime())
               break;
         //wxPrintf("Insert clip %.6f at position %d\n", clip->GetStartTime(), i);
         clipsToDelete.insert(it, clip.get());
      }
   }
 
   //if there are no clips to DELETE, nothing to do
   if( clipsToDelete.size() == 0 )
      return;
 
   auto t = clipsToDelete[0]->GetPlayStartTime();
   //preserve left trim data if any
   newClip = CreateClip(clipsToDelete[0]->GetSequenceStartTime(),
      clipsToDelete[0]->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 / mRate)) {
         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);
      newClip->Paste(t, clip);
 
      t = newClip->GetPlayEndTime();
 
      auto it = FindClip(mClips, clip);
      mClips.erase(it); // deletes the clip
   }
}

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

Referenced by LabelEditActions::Handler::OnJoinLabels(), and EffectEqualization::ProcessOne().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LinkConsistencyFix()

bool WaveTrack::LinkConsistencyFix	(	bool	doFix,
		bool	completeList
	)

overridevirtual

Check consistency of channel groups, and maybe fix it.

Parameters

doFix	whether to make any changes to correct inconsistencies
completeList	whether to assume that the TrackList containing this is completely loaded; if false, skip some of the checks

Returns: true if no inconsistencies were found

Reimplemented from Track.

Definition at line 278 of file WaveTrack.cpp.

{
   auto err = !WritableSampleTrack::LinkConsistencyFix(doFix, completeList);
   if (completeList) {
      auto linkType = GetLinkType();
      if (static_cast<int>(linkType) == 1 || //Comes from old audacity version
          linkType == LinkType::Aligned) {
         auto next =
            dynamic_cast<WaveTrack*>(*std::next(GetOwner()->Find(this)));
         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);
               SetChannel(MonoChannel);
            }
            err = true;
         }
         else if (doFix) {
            auto newLinkType =
               AreAligned(SortedClipArray(), next->SortedClipArray())
               ? LinkType::Aligned : LinkType::Group;
            //not an error
            if (newLinkType != linkType)
               SetLinkType(newLinkType);
         }
      }
   }
   return !err;
}

References Track::Aligned, anonymous_namespace{WaveTrack.cpp}::AreAligned(), ClientData::Site< Host, ClientData, ObjectCopyingPolicy, Pointer, ObjectLockingPolicy, RegistryLockingPolicy >::Find(), Track::GetLinkType(), Track::GetName(), Track::GetOwner(), Track::Group, Track::LinkConsistencyFix(), Track::MonoChannel, Track::None, Track::SetChannel(), Track::SetLinkType(), and SortedClipArray().

Here is the call graph for this function:

◆ MakeClipCopyName()

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

private

Definition at line 455 of file WaveTrack.cpp.

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

References FindClipByName(), name, and XC.

Referenced by PasteWaveTrack().

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

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Merge()

void WaveTrack::Merge ( const Track & orig )

overridevirtual

Reimplemented from Track.

Definition at line 217 of file WaveTrack.cpp.

{
   orig.TypeSwitch( [&](const WaveTrack *pwt) {
      const WaveTrack &wt = *pwt;
      DoSetGain(wt.GetGain());
      DoSetPan(wt.GetPan());
      mDisplayMin = wt.mDisplayMin;
      mDisplayMax = wt.mDisplayMax;
      SetSpectrogramSettings(wt.mpSpectrumSettings
         ? std::make_unique<SpectrogramSettings>(*wt.mpSpectrumSettings) : nullptr);
      SetWaveformSettings
         (wt.mpWaveformSettings ? std::make_unique<WaveformSettings>(*wt.mpWaveformSettings) : nullptr);
   });
   WritableSampleTrack::Merge(orig);
}

References DoSetGain(), DoSetPan(), GetGain(), GetPan(), mDisplayMax, mDisplayMin, PlayableTrack::Merge(), mpSpectrumSettings, mpWaveformSettings, SetSpectrogramSettings(), SetWaveformSettings(), and Track::TypeSwitch().

Referenced by WaveTrackMenuTable::OnMergeStereo().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MergeClips()

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

Exception safety guarantee:: Strong

Definition at line 2691 of file WaveTrack.cpp.

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

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

Referenced by ClearAndPaste().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ New()

WaveTrack * WaveTrack::New ( AudacityProject & project )

static

Definition at line 128 of file WaveTrack.cpp.

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

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

Here is the call graph for this function:

◆ NewestOrNewClip()

WaveClip * WaveTrack::NewestOrNewClip ( )

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

Returns: a pointer to the most recently added WaveClip

Definition at line 2378 of file WaveTrack.cpp.

{
   if (mClips.empty()) {
      return CreateClip(mOffset, MakeNewClipName());
   }
   else
      return mClips.back().get();
}

References CreateClip(), MakeNewClipName(), mClips, and Track::mOffset.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Paste()

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

override

Exception safety guarantee:: Weak

Definition at line 1573 of file WaveTrack.cpp.

{
   if (auto other = dynamic_cast<const WaveTrack*>(src))
      PasteWaveTrack(t0, other);
   else
      // THROW_INCONSISTENCY_EXCEPTION; // ?
      (void)0;// Empty if intentional.   
}

References PasteWaveTrack().

Referenced by ClearAndPaste(), PasteWaveTrack(), EffectEqualization::ProcessOne(), EffectStereoToMono::ProcessOne(), EffectPaulstretch::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 & ) const

overridevirtual

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

Returns: A smart pointer to the track; its use_count() can tell whether it is new

Implements Track.

Definition at line 419 of file WaveTrack.cpp.

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

References EmptyCopy(), and WaveTrackFactory::Get().

Here is the call graph for this function:

◆ PasteWaveTrack()

void WaveTrack::PasteWaveTrack	(	double	t0,
		const WaveTrack *	other
	)

private

Definition at line 1413 of file WaveTrack.cpp.

{
    //
    // Pasting is a bit complicated, because with the existence of multiclip mode,
    // we must guess the behaviour the user wants.
    //
    // Currently, two modes are implemented:
    //
    // - If a single clip should be pasted, and it should be pasted inside another
    //   clip, no NEW clips are generated. The audio is simply inserted.
    //   This resembles the old (pre-multiclip support) behaviour. However, if
    //   the clip is pasted outside of any clip, a NEW clip is generated. This is
    //   the only behaviour which is different to what was done before, but it
    //   shouldn't confuse users too much.
    //
    // - If multiple clips should be pasted, or a single clip that does not fill
    // the duration of the pasted track, these are always pasted as single
    // clips, and the current clip is split, when necessary. This may seem
    // strange at first, but it probably is better than trying to auto-merge
    // anything. The user can still merge the clips by hand (which should be a
    // simple command reachable by a hotkey or single mouse click).
    //
 
    if (other->GetNumClips() == 0)
        return;
 
    //wxPrintf("paste: we have at least one clip\n");
 
    bool singleClipMode = other->GetNumClips() == 1 &&
        std::abs(other->GetStartTime()) < LongSamplesToTime(1) * 0.5;
 
    const double insertDuration = other->GetEndTime();
    if (insertDuration != 0 && insertDuration < 1.0 / mRate)
        // PRL:  I added this check to avoid violations of preconditions in other WaveClip and Sequence
        // methods, but allow the value 0 so I don't subvert the purpose of commit
        // 739422ba70ceb4be0bb1829b6feb0c5401de641e which causes append-recording always to make
        // a new clip.
        return;
 
    //wxPrintf("Check if we need to make room for the pasted data\n");
 
    auto pastingFromTempTrack = !other->GetOwner();
    bool editClipCanMove = GetEditClipsCanMove();
 
    // Make room for the pasted data
    if (editClipCanMove) {
        if (!singleClipMode) {
            // We need to insert multiple clips, so split the current clip and
            // move everything to the right, then try to paste again
            if (!IsEmpty(t0, GetEndTime())) {
                auto tmp = Cut(t0, GetEndTime() + 1.0 / mRate);
                Paste(t0 + insertDuration, tmp.get());
            }
        }
        else {
            // We only need to insert one single clip, so just move all clips
            // to the right of the paste point out of the way
            for (const auto& clip : mClips)
            {
                if (clip->GetPlayStartTime() > t0 - (1.0 / mRate))
                    clip->Offset(insertDuration);
            }
        }
    }
 
    if (singleClipMode)
    {
        // Single clip mode
        // wxPrintf("paste: checking for single clip mode!\n");
 
        WaveClip* insideClip = nullptr;
 
        for (const auto& clip : mClips)
        {
            if (editClipCanMove)
            {
                if (clip->WithinPlayRegion(t0))
                {
                    //wxPrintf("t0=%.6f: inside clip is %.6f ... %.6f\n",
                    //       t0, clip->GetStartTime(), clip->GetEndTime());
                    insideClip = clip.get();
                    break;
                }
            }
            else
            {
                // If clips are immovable we also allow prepending to clips
                if (clip->WithinPlayRegion(t0) ||
                    TimeToLongSamples(t0) == clip->GetPlayStartSample())
                {
                    insideClip = clip.get();
                    break;
                }
            }
        }
 
        if (insideClip)
        {
            // Exhibit traditional behaviour
            //wxPrintf("paste: traditional behaviour\n");
            if (!editClipCanMove)
            {
                // We did not move other clips out of the way already, so
                // check if we can paste without having to move other clips
                for (const auto& clip : mClips)
                {
                    if (clip->GetPlayStartTime() > insideClip->GetPlayStartTime() &&
                        insideClip->GetPlayEndTime() + insertDuration >
                        clip->GetPlayStartTime())
                        // Strong-guarantee in case of this path
                        // not that it matters.
                        throw SimpleMessageBoxException{
                           ExceptionType::BadUserAction,
                              XO("There is not enough room available to paste the selection"),
                              XO("Warning"),
                              "Error:_Insufficient_space_in_track"
                    };
                }
            }
            insideClip->Paste(t0, other->GetClipByIndex(0));
            return;
        }
        // Just fall through and exhibit NEW behaviour
    }
 
    // Insert NEW clips
    //wxPrintf("paste: multi clip mode!\n");
 
    if (!editClipCanMove && !IsEmpty(t0, t0 + insertDuration - 1.0 / mRate))
        // Strong-guarantee in case of this path
        // not that it matters.
        throw SimpleMessageBoxException{
           ExceptionType::BadUserAction,
           XO("There is not enough room available to paste the selection"),
           XO("Warning"),
           "Error:_Insufficient_space_in_track"
    };
 
    for (const auto& clip : other->mClips)
    {
        // AWD Oct. 2009: Don't actually paste in placeholder clips
        if (!clip->GetIsPlaceholder())
        {
            auto newClip =
                std::make_unique<WaveClip>(*clip, mpFactory, true);
            newClip->Resample(mRate);
            newClip->Offset(t0);
            newClip->MarkChanged();
            if (pastingFromTempTrack)
                //Clips from the tracks which aren't bound to any TrackList are 
                //considered to be new entities, thus named using "new" name template
                newClip->SetName(MakeNewClipName());
            else
                newClip->SetName(MakeClipCopyName(clip->GetName()));
            mClips.push_back(std::move(newClip)); // transfer ownership
        }
    }
}

References BadUserAction, Cut(), GetClipByIndex(), GetEditClipsCanMove(), GetEndTime(), GetNumClips(), Track::GetOwner(), WaveClip::GetPlayEndTime(), WaveClip::GetPlayStartTime(), GetStartTime(), IsEmpty(), SampleTrack::LongSamplesToTime(), MakeClipCopyName(), MakeNewClipName(), mClips, mpFactory, mRate, Paste(), WaveClip::Paste(), SampleTrack::TimeToLongSamples(), and XO.

Referenced by Paste().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Reinit()

void WaveTrack::Reinit ( const WaveTrack & orig )

Definition at line 196 of file WaveTrack.cpp.

{
   Init(orig);
 
   {
      auto &settings = orig.mpSpectrumSettings;
      if (settings)
         mpSpectrumSettings = std::make_unique<SpectrogramSettings>(*settings);
      else
         mpSpectrumSettings.reset();
   }
 
   {
      auto &settings = orig.mpWaveformSettings;
      if (settings)
         mpWaveformSettings = std::make_unique<WaveformSettings>(*settings);
      else
         mpWaveformSettings.reset();
   }
}

References Init(), mpSpectrumSettings, mpWaveformSettings, and settings().

Referenced by ProjectAudioManager::DoRecord().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RemoveAndReturnClip()

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

Definition at line 1217 of file WaveTrack.cpp.

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

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

Referenced by EffectReverse::ProcessOneWave().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RemoveCutLine()

bool WaveTrack::RemoveCutLine ( double cutLinePosition )

Definition at line 2681 of file WaveTrack.cpp.

{
   for (const auto &clip : mClips)
      if (clip->RemoveCutLine(cutLinePosition))
         return true;
 
   return false;
}

References mClips.

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

{
   for (const auto &clip : mClips)
      clip->Resample(rate, progress);
 
   mRate = rate;
}

References mClips, and mRate.

◆ RightmostOrNewClip()

WaveClip * 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 2388 of file WaveTrack.cpp.

{
   if (mClips.empty()) {
      return CreateClip(mOffset, MakeNewClipName());
   }
   else
   {
      auto it = mClips.begin();
      WaveClip *rightmost = (*it++).get();
      double maxOffset = rightmost->GetPlayStartTime();
      for (auto end = mClips.end(); it != end; ++it)
      {
         WaveClip *clip = it->get();
         double offset = clip->GetPlayStartTime();
         if (maxOffset < offset)
            maxOffset = offset, rightmost = clip;
      }
      return rightmost;
   }
}

References CreateClip(), PackedArray::end(), WaveClip::GetPlayStartTime(), MakeNewClipName(), mClips, and Track::mOffset.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Set()

void WaveTrack::Set	(	constSamplePtr	buffer,
		sampleFormat	format,
		sampleCount	start,
		size_t	len
	)

Exception safety guarantee:: Weak

Definition at line 2205 of file WaveTrack.cpp.

{
   for (const auto &clip: mClips)
   {
      auto clipStart = clip->GetPlayStartSample();
      auto clipEnd = clip->GetPlayEndSample();
 
      if (clipEnd > start && clipStart < start+len)
      {
         // Clip sample region and Get/Put sample region overlap
         auto samplesToCopy =
            std::min( start+len - clipStart, clip->GetPlaySamplesCount() );
         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
         }
 
         clip->SetSamples(
               (constSamplePtr)(((const char*)buffer) +
                           startDelta.as_size_t() *
                           SAMPLE_SIZE(format)),
                          format, inclipDelta, samplesToCopy.as_size_t() );
         clip->MarkChanged();
      }
   }
}

References format, mClips, min(), and SAMPLE_SIZE.

Referenced by EffectAutoDuck::ApplyDuckFade(), WaveTrackSink::DoConsume(), EffectTruncSilence::DoRemoval(), EffectClickRemoval::ProcessOne(), EffectRepair::ProcessOne(), EffectNormalize::ProcessOne(), EffectSimpleMono::ProcessOne(), EffectTwoPassSimpleMono::ProcessOne(), and EffectReverse::ProcessOneClip().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetDisplayBounds()

void WaveTrack::SetDisplayBounds	(	float	min,
		float	max
	)		const

Definition at line 346 of file WaveTrack.cpp.

{
   mDisplayMin = min;
   mDisplayMax = max;
}

References mDisplayMax, mDisplayMin, and min().

Referenced by WaveformVRulerControls::DoUpdateVRuler().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetGain()

void WaveTrack::SetGain ( float newGain )

Definition at line 506 of file WaveTrack.cpp.

{
   if (GetGain() != newGain) {
      DoSetGain(newGain);
      Notify();
   }
}

References DoSetGain(), GetGain(), and Track::Notify().

Referenced by MixerTrackCluster::HandleSliderGain().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetLastdBRange()

void WaveTrack::SetLastdBRange ( ) const

Definition at line 335 of file WaveTrack.cpp.

{
   mLastdBRange = GetWaveformSettings().dBRange;
}

References WaveformSettings::dBRange, GetWaveformSettings(), and mLastdBRange.

Referenced by WaveformVRulerControls::DoUpdateVRuler().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetLastScaleType()

void WaveTrack::SetLastScaleType ( ) const

Definition at line 330 of file WaveTrack.cpp.

{
   mLastScaleType = GetWaveformSettings().scaleType;
}

References GetWaveformSettings(), mLastScaleType, and WaveformSettings::scaleType.

Referenced by WaveformVRulerControls::DoUpdateVRuler().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetOffset()

void WaveTrack::SetOffset ( double o )

overridevirtual

Exception safety guarantee:: No-fail

Reimplemented from Track.

Definition at line 243 of file WaveTrack.cpp.

{
   double delta = o - GetOffset();
 
   for (const auto &clip : mClips)
      // assume No-fail-guarantee
      clip->Offset(delta);
 
   mOffset = o;
}

References GetOffset(), mClips, and Track::mOffset.

Here is the call graph for this function:

◆ SetOldChannelGain()

void WaveTrack::SetOldChannelGain	(	int	channel,
		float	gain
	)

overridevirtual

Implements WritableSampleTrack.

Definition at line 560 of file WaveTrack.cpp.

{
   mOldGain[channel % 2] = gain;
}

References mOldGain.

Referenced by AudioIoCallback::AddToOutputChannel().

Here is the caller graph for this function:

◆ SetPan()

void WaveTrack::SetPan ( float newPan )

overridevirtual

Reimplemented from Track.

Definition at line 524 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();
   }
}

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

Referenced by MixerTrackCluster::HandleSliderPan(), WaveTrackMenuTable::OnMergeStereo(), and SetPanFromChannelType().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetPanFromChannelType()

void WaveTrack::SetPanFromChannelType ( )

overridevirtual

Reimplemented from Track.

Definition at line 270 of file WaveTrack.cpp.

{ 
   if( mChannel == Track::LeftChannel )
      SetPan( -1.0f );
   else if( mChannel == Track::RightChannel )
      SetPan( 1.0f );
}

References Track::LeftChannel, Track::mChannel, Track::RightChannel, and SetPan().

Here is the call graph for this function:

◆ SetRate()

void WaveTrack::SetRate ( double newRate )

Definition at line 484 of file WaveTrack.cpp.

{
   wxASSERT( newRate > 0 );
   newRate = std::max( 1.0, newRate );
   auto ratio = mRate / newRate;
   mRate = (int) newRate;
   for (const auto &clip : mClips) {
      clip->SetRate((int)newRate);
      clip->SetSequenceStartTime( clip->GetSequenceStartTime() * ratio );
   }
}

References mClips, and mRate.

◆ SetSpectrogramSettings()

void WaveTrack::SetSpectrogramSettings ( std::unique_ptr< SpectrogramSettings > && pSettings )

Definition at line 823 of file WaveTrack.cpp.

{
   if (mpSpectrumSettings != pSettings) {
      mpSpectrumSettings = std::move(pSettings);
   }
}

References mpSpectrumSettings.

Referenced by Merge().

Here is the caller graph for this function:

◆ SetSpectrumBounds()

void WaveTrack::SetSpectrumBounds	(	float	min,
		float	max
	)		const

Definition at line 396 of file WaveTrack.cpp.

{
   mSpectrumMin = min;
   mSpectrumMax = max;
}

References min(), mSpectrumMax, and mSpectrumMin.

Here is the call graph for this function:

◆ SetWaveColorIndex()

void WaveTrack::SetWaveColorIndex ( int colorIndex )

Exception safety guarantee:: Strong

Definition at line 568 of file WaveTrack.cpp.

{
   for (const auto &clip : mClips)
      clip->SetColourIndex( colorIndex );
   mWaveColorIndex = colorIndex;
}

References mClips, and mWaveColorIndex.

Referenced by SetTrackVisualsCommand::ApplyInner().

Here is the caller graph for this function:

◆ SetWaveformSettings()

void WaveTrack::SetWaveformSettings ( std::unique_ptr< WaveformSettings > && pSettings )

Definition at line 861 of file WaveTrack.cpp.

{
   if (mpWaveformSettings != pSettings) {
      mpWaveformSettings = std::move(pSettings);
   }
}

References mpWaveformSettings.

Referenced by Merge().

Here is the caller graph for this function:

◆ Silence()

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

override

Definition at line 1582 of file WaveTrack.cpp.

{
   if (t1 < t0)
      THROW_INCONSISTENCY_EXCEPTION;
 
   auto start = TimeToLongSamples(t0);
   auto end = TimeToLongSamples(t1);
 
   for (const auto &clip : mClips)
   {
      auto clipStart = clip->GetPlayStartSample();
      auto clipEnd = clip->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);
 
         clip->SetSilence(offset, length);
      }
   }
}

References PackedArray::end(), mClips, min(), THROW_INCONSISTENCY_EXCEPTION, and SampleTrack::TimeToLongSamples().

Referenced by LabelEditActions::Handler::OnSilenceLabels(), EditActions::Handler::OnSplitCut(), LabelEditActions::Handler::OnSplitCutLabels(), and LabelEditActions::Handler::OnSplitDeleteLabels().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SortedClipArray() [1/2]

WaveClipPointers WaveTrack::SortedClipArray ( )

Definition at line 2733 of file WaveTrack.cpp.

{
   return FillSortedClipArray<WaveClipPointers>(mClips);
}

References mClips.

Referenced by SetClipCommand::ApplyInner(), SetEnvelopeCommand::ApplyInner(), ClearAndPaste(), EffectSBSMS::Finalize(), anonymous_namespace{ClipMenus.cpp}::FindNextClip(), anonymous_namespace{ClipMenus.cpp}::FindNextClipBoundary(), anonymous_namespace{ClipMenus.cpp}::FindPrevClip(), anonymous_namespace{ClipMenus.cpp}::FindPrevClipBoundary(), GetClipAtTime(), LinkConsistencyFix(), NyquistEffect::ProcessOne(), EffectChangeSpeed::ProcessOne(), EffectReverse::ProcessOneWave(), GetInfoCommand::SendClips(), GetInfoCommand::SendEnvelopes(), and UpdateLocationsCache().

Here is the caller graph for this function:

◆ SortedClipArray() [2/2]

WaveClipConstPointers WaveTrack::SortedClipArray ( ) const

Definition at line 2738 of file WaveTrack.cpp.

{
   return FillSortedClipArray<WaveClipConstPointers>(mClips);
}

References mClips.

◆ Split()

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

Exception safety guarantee:: Weak

Definition at line 2527 of file WaveTrack.cpp.

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

References SplitAt().

Referenced by LabelEditActions::Handler::OnSplitLabels().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SplitAt()

void WaveTrack::SplitAt ( double t )

Exception safety guarantee:: Weak

Definition at line 2535 of file WaveTrack.cpp.

{
   for (const auto &c : mClips)
   {
      if (c->WithinPlayRegion(t))
      {
         t = LongSamplesToTime(TimeToLongSamples(t));
         auto newClip = std::make_unique<WaveClip>( *c, mpFactory, true );
         c->TrimRightTo(t);// put t on a sample
         newClip->TrimLeftTo(t);
         
         // This could invalidate the iterators for the loop!  But we return
         // at once so it's okay
         mClips.push_back(std::move(newClip)); // transfer ownership
         return;
      }
   }
}

References SampleTrack::LongSamplesToTime(), mClips, mpFactory, and SampleTrack::TimeToLongSamples().

Referenced by EffectReverse::ProcessOneWave(), and Split().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SplitCut()

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

Exception safety guarantee:: Strong

Definition at line 640 of file WaveTrack.cpp.

{
   if (t1 < t0)
      THROW_INCONSISTENCY_EXCEPTION;
 
   // SplitCut is the same as 'Copy', then 'SplitDelete'
   auto tmp = Copy(t0, t1);
 
   SplitDelete(t0, t1);
 
   return tmp;
}

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

Referenced by EditActions::Handler::OnSplitCut(), LabelEditActions::Handler::OnSplitCutLabels(), and EditActions::Handler::OnSplitNew().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SplitDelete()

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

Exception safety guarantee:: Strong

Definition at line 1175 of file WaveTrack.cpp.

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

References HandleClear().

Referenced by Disjoin(), EffectSBSMS::Finalize(), EditActions::Handler::OnSplitDelete(), LabelEditActions::Handler::OnSplitDeleteLabels(), EffectChangeSpeed::ProcessOne(), SplitCut(), and Trim().

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

Reimplemented from Track.

Definition at line 1376 of file WaveTrack.cpp.

{
   if (newT1 > oldT1) {
      // Insert space within the track
 
      // 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.
      if (oldT1 >= GetEndTime())
         return;
 
      // If track is empty at oldT1 insert whitespace; otherwise, silence
      if (IsEmpty(oldT1, oldT1))
      {
         // Check if clips can move
         if (EditClipsCanMove.Read()) {
            auto tmp = Cut (oldT1, GetEndTime() + 1.0/GetRate());
            Paste(newT1, tmp.get());
         }
         return;
      }
      else {
         // AWD: Could just use InsertSilence() on its own here, but it doesn't
         // follow EditClipCanMove rules (Paste() does it right)
         auto tmp = std::make_shared<WaveTrack>(
            mpFactory, GetSampleFormat(), GetRate() );
 
         tmp->InsertSilence(0.0, newT1 - oldT1);
         tmp->Flush();
         Paste(oldT1, tmp.get());
      }
   }
   else if (newT1 < oldT1) {
      Clear(newT1, oldT1);
   }
}

References Clear(), Cut(), EditClipsCanMove, GetEndTime(), GetRate(), GetSampleFormat(), 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 673 of file WaveTrack.cpp.

{
   bool inside0 = false;
   bool inside1 = false;
 
   for (const auto &clip : mClips)
   {
      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(!inside1 && t1 < GetEndTime())
      Clear(t1,GetEndTime());
 
   if(!inside0 && t0 > GetStartTime())
      SplitDelete(GetStartTime(), t0);
}

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

Referenced by EditActions::Handler::OnTrim().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateLocationsCache()

void WaveTrack::UpdateLocationsCache ( ) const

Definition at line 2554 of file WaveTrack.cpp.

{
   auto clips = SortedClipArray();
 
   mDisplayLocationsCache.clear();
 
   // Count number of display locations
   int num = 0;
   {
      const WaveClip *prev = nullptr;
      for (const auto clip : clips)
      {
         //enough for estimation
         num += clip->NumCutLines();
 
         if (prev && fabs(prev->GetPlayEndTime() -
                          clip->GetPlayStartTime()) < WAVETRACK_MERGE_POINT_TOLERANCE)
            ++num;
         prev = clip;
      }
   }
 
   if (num == 0)
      return;
 
   // Alloc necessary number of display locations
   mDisplayLocationsCache.reserve(num);
 
   // Add all display locations to cache
   int curpos = 0;
 
   const WaveClip *previousClip = nullptr;
   for (const auto clip: clips)
   {
      for (const auto &cc : clip->GetCutLines())
      {
         auto cutlinePosition = clip->GetSequenceStartTime() + cc->GetSequenceStartTime();
         if (clip->WithinPlayRegion(cutlinePosition))
         {
             // Add cut line expander point
             mDisplayLocationsCache.push_back(WaveTrackLocation{
                cutlinePosition,
                WaveTrackLocation::locationCutLine
             });
         }
         // If cutline is skipped, we still need to count it
         // so that curpos match num at the end
         curpos++;
      }
 
      if (previousClip)
      {
         if (fabs(previousClip->GetPlayEndTime() - clip->GetPlayStartTime())
                                          < WAVETRACK_MERGE_POINT_TOLERANCE)
         {
            // Add merge point
            mDisplayLocationsCache.push_back(WaveTrackLocation{
               previousClip->GetPlayEndTime(),
               WaveTrackLocation::locationMergePoint,
               GetClipIndex(previousClip),
               GetClipIndex(clip)
            });
            curpos++;
         }
      }
 
      previousClip = clip;
   }
 
   wxASSERT(curpos == num);
}

References GetClipIndex(), WaveClip::GetPlayEndTime(), WaveClip::GetSequenceStartTime(), WaveTrackLocation::locationCutLine, WaveTrackLocation::locationMergePoint, mDisplayLocationsCache, WaveClip::NumCutLines(), SortedClipArray(), and WAVETRACK_MERGE_POINT_TOLERANCE.

Here is the call graph for this function:

◆ UseSpectralPrefs()

void WaveTrack::UseSpectralPrefs ( bool bUse = true )

Definition at line 830 of file WaveTrack.cpp.

{  
   if( bUse ){
      if( !mpSpectrumSettings )
         return;
      // reset it, and next we will be getting the defaults.
      mpSpectrumSettings.reset();
   }
   else {
      if( mpSpectrumSettings )
         return;
      GetIndependentSpectrogramSettings();
   }
}

References GetIndependentSpectrogramSettings(), and mpSpectrumSettings.

Here is the call graph for this function:

◆ WriteXML()

void WaveTrack::WriteXML ( XMLWriter & xmlFile ) const

overridevirtual

Implements Track.

Definition at line 1964 of file WaveTrack.cpp.

{
   xmlFile.StartTag(wxT("wavetrack"));
   this->Track::WriteCommonXMLAttributes( xmlFile );
   xmlFile.WriteAttr(wxT("channel"), mChannel);
   xmlFile.WriteAttr(wxT("linked"), static_cast<int>(GetLinkType()));
   this->WritableSampleTrack::WriteXMLAttributes(xmlFile);
   xmlFile.WriteAttr(wxT("rate"), mRate);
   xmlFile.WriteAttr(wxT("gain"), static_cast<double>(GetGain()));
   xmlFile.WriteAttr(wxT("pan"), static_cast<double>(GetPan()));
   xmlFile.WriteAttr(wxT("colorindex"), mWaveColorIndex );
   xmlFile.WriteAttr(wxT("sampleformat"), static_cast<long>(mFormat) );
 
   WaveTrackIORegistry::Get().CallWriters(*this, xmlFile);
 
   for (const auto &clip : mClips)
   {
      clip->WriteXML(xmlFile);
   }
 
   xmlFile.EndTag(wxT("wavetrack"));
}

References XMLMethodRegistry< Host >::CallWriters(), XMLMethodRegistry< Host >::Get(), Track::WriteCommonXMLAttributes(), PlayableTrack::WriteXMLAttributes(), and wxT().

Here is the call graph for this function:

◆ ZeroLevelYCoordinate()

int WaveTrack::ZeroLevelYCoordinate ( wxRect rect ) const

Definition at line 402 of file WaveTrack.cpp.

{
   return rect.GetTop() +
      (int)((mDisplayMax / (mDisplayMax - mDisplayMin)) * rect.height);
}

References mDisplayMax, and mDisplayMin.

Referenced by WaveformVRulerControls::DoHandleWheelRotation(), and anonymous_namespace{WaveformView.cpp}::DrawClipWaveform().

Here is the caller graph for this function:

Friends And Related Function Documentation

◆ WaveTrackFactory

friend class WaveTrackFactory

friend

Definition at line 99 of file WaveTrack.h.

Member Data Documentation

◆ mAppendCriticalSection

wxCriticalSection WaveTrack::mAppendCriticalSection

private

Definition at line 581 of file WaveTrack.h.

◆ mClips

WaveClipHolders WaveTrack::mClips

protected

Definition at line 546 of file WaveTrack.h.

Referenced by AddClip(), WaveTrack::AllClipsIterator::AllClipsIterator(), CanInsertClip(), CanOffsetClips(), ClearAndPaste(), CloseLock(), ConvertToSampleFormat(), Copy(), CreateClip(), Disjoin(), ExpandCutLine(), FindClipByName(), Get(), GetBestBlockSize(), GetBlockStart(), GetClipAtSample(), GetClipByIndex(), GetClipIndex(), GetEndTime(), GetEnvelopeValues(), GetErrorOpening(), GetIntervals(), GetMaxBlockSize(), GetMinMax(), GetNumClips(), GetPlaySamplesCount(), GetRMS(), GetSequenceSamplesCount(), GetStartTime(), HandleClear(), InsertSilence(), IsEmpty(), Join(), MergeClips(), NewestOrNewClip(), PasteWaveTrack(), RemoveAndReturnClip(), RemoveCutLine(), Resample(), RightmostOrNewClip(), Set(), SetOffset(), SetRate(), SetWaveColorIndex(), Silence(), SortedClipArray(), SplitAt(), Trim(), and WaveTrack().

◆ mDisplayLocationsCache

std::vector<Location> WaveTrack::mDisplayLocationsCache

mutableprotected

Definition at line 570 of file WaveTrack.h.

Referenced by Init(), and UpdateLocationsCache().

◆ mDisplayMax

float WaveTrack::mDisplayMax

mutableprotected

Definition at line 564 of file WaveTrack.h.

Referenced by GetDisplayBounds(), Init(), Merge(), SetDisplayBounds(), WaveTrack(), and ZeroLevelYCoordinate().

◆ mDisplayMin

float WaveTrack::mDisplayMin

mutableprotected

Definition at line 563 of file WaveTrack.h.

Referenced by GetDisplayBounds(), Init(), Merge(), SetDisplayBounds(), WaveTrack(), and ZeroLevelYCoordinate().

◆ mFlushCriticalSection

wxCriticalSection WaveTrack::mFlushCriticalSection

private

Definition at line 580 of file WaveTrack.h.

◆ mFormat

sampleFormat WaveTrack::mFormat

protected

Definition at line 548 of file WaveTrack.h.

Referenced by ConvertToSampleFormat(), CreateClip(), EmptyCopy(), GetMaxBlockSize(), HandleXMLTag(), Init(), InsertSilence(), and WaveTrack().

◆ mGain

std::atomic<float> WaveTrack::mGain { 1.0f }

protected

Atomic because it may be read by worker threads in playback.

Definition at line 551 of file WaveTrack.h.

Referenced by DoSetGain(), and GetGain().

◆ mLastdBRange

int WaveTrack::mLastdBRange

mutableprotected

Definition at line 569 of file WaveTrack.h.

Referenced by SetLastdBRange(), and WaveTrack().

◆ mLastScaleType

int WaveTrack::mLastScaleType

mutableprotected

Definition at line 568 of file WaveTrack.h.

Referenced by SetLastScaleType(), and WaveTrack().

◆ mLegacyProjectFileOffset

double WaveTrack::mLegacyProjectFileOffset

private

Definition at line 582 of file WaveTrack.h.

Referenced by HandleXMLChild(), HandleXMLTag(), and WaveTrack().

◆ mOldGain

float WaveTrack::mOldGain[2]

protected

A memo used by PortAudio thread, doesn't need atomics:

Definition at line 556 of file WaveTrack.h.

Referenced by GetOldChannelGain(), Init(), SetOldChannelGain(), and WaveTrack().

◆ mPan

std::atomic<float> WaveTrack::mPan { 0.0f }

protected

Atomic because it may be read by worker threads in playback.

Definition at line 553 of file WaveTrack.h.

Referenced by DoSetPan(), and GetPan().

◆ mpFactory

SampleBlockFactoryPtr WaveTrack::mpFactory

private

Definition at line 578 of file WaveTrack.h.

Referenced by ClearAndPaste(), Copy(), CreateClip(), EmptyCopy(), GetMaxBlockSize(), HandleClear(), Init(), InsertSilence(), PasteWaveTrack(), SplitAt(), SyncLockAdjust(), and WaveTrack().

◆ mpSpectrumSettings

std::unique_ptr<SpectrogramSettings> WaveTrack::mpSpectrumSettings

private

Definition at line 584 of file WaveTrack.h.

Referenced by GetIndependentSpectrogramSettings(), GetSpectrogramSettings(), Merge(), Reinit(), SetSpectrogramSettings(), and UseSpectralPrefs().

◆ mpWaveformSettings

std::unique_ptr<WaveformSettings> WaveTrack::mpWaveformSettings

private

Definition at line 585 of file WaveTrack.h.

Referenced by GetWaveformSettings(), Merge(), Reinit(), and SetWaveformSettings().

◆ mRate

int WaveTrack::mRate

protected

Definition at line 549 of file WaveTrack.h.

Referenced by CreateClip(), EmptyCopy(), GetEnvelopeValues(), GetRate(), HandleXMLTag(), Init(), InsertSilence(), Join(), PasteWaveTrack(), Resample(), SetRate(), and WaveTrack().

◆ mSpectrumMax

float WaveTrack::mSpectrumMax

mutableprotected

Definition at line 566 of file WaveTrack.h.

Referenced by GetSpectrumBounds(), Init(), SetSpectrumBounds(), and WaveTrack().

◆ mSpectrumMin

float WaveTrack::mSpectrumMin

mutableprotected

Definition at line 565 of file WaveTrack.h.

Referenced by GetSpectrumBounds(), Init(), SetSpectrumBounds(), and WaveTrack().

◆ mWaveColorIndex

int WaveTrack::mWaveColorIndex

protected

Definition at line 554 of file WaveTrack.h.

Referenced by HandleXMLTag(), Init(), SetWaveColorIndex(), and WaveTrack().

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

Classes

Public Types

Public Member Functions

Static Public Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ Holder

◆ Location

◆ Regions

Constructor & Destructor Documentation

◆ WaveTrack() [1/2]

◆ WaveTrack() [2/2]

◆ ~WaveTrack()

Member Function Documentation

◆ AddClip()

◆ Append()

◆ CanInsertClip()

◆ CanOffsetClips()

◆ ClassTypeInfo()

◆ Clear()

◆ ClearAndAddCutLine()

◆ ClearAndPaste()

◆ Clone()

◆ CloseLock()

◆ ConvertToSampleFormat()

◆ Copy()

◆ CopyNonconst()

◆ CreateClip()

◆ Cut()

◆ Disjoin()

◆ DoSetGain()

◆ DoSetPan()

◆ EmptyCopy()

◆ ExpandCutLine()

◆ FindClipByName()

◆ Flush()

◆ Get()

◆ GetAllClips() [1/2]

◆ GetAllClips() [2/2]

◆ GetBestBlockSize()

◆ GetBlockStart()

◆ GetCachedLocations()

◆ GetChannel()

◆ GetChannelGain()

◆ GetChannelIgnoringPan()

◆ GetClipAtSample()

◆ GetClipAtTime()

◆ GetClipByIndex() [1/2]

◆ GetClipByIndex() [2/2]

◆ GetClipIndex()

◆ GetClips() [1/2]

◆ GetClips() [2/2]

◆ GetDefaultAudioTrackNamePreference()

◆ GetDisplayBounds()

◆ GetEndTime()

◆ GetEnvelopeAtTime()

◆ GetEnvelopeValues()

◆ GetErrorOpening()

◆ GetGain()

◆ GetIdealBlockSize()

◆ GetIndependentSpectrogramSettings()

◆ GetIntervals() [1/2]

◆ GetIntervals() [2/2]

◆ GetLastdBRange()

◆ GetLastScaleType()

◆ GetMaxBlockSize()

◆ GetMinMax()

◆ GetNumClips()

◆ GetOffset()

◆ GetOldChannelGain()

◆ GetPan()

◆ GetPlaySamplesCount()

◆ GetRate()

◆ GetRMS()

◆ GetSampleFormat()