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

Public Types
typedef WaveTrackLocation	Location

using	Holder = std::shared_ptr< WaveTrack >

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

using	ChannelType = XMLValueChecker::ChannelType

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)

void	Reinit (const WaveTrack &orig)

virtual	~WaveTrack ()

double	GetOffset () const override

void	SetOffset (double o) override

virtual ChannelType	GetChannelIgnoringPan () const

ChannelType	GetChannel () const override

virtual void	SetPanFromChannelType () override

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

void	SetRate (double newRate)

float	GetGain () const

void	SetGain (float newGain)

float	GetPan () const

void	SetPan (float newPan) override

float	GetChannelGain (int channel) const

float	GetOldChannelGain (int channel) const

void	SetOldChannelGain (int channel, float gain)

int	GetWaveColorIndex () const

void	SetWaveColorIndex (int colorIndex)

sampleCount	GetNumSamples () const

sampleFormat	GetSampleFormat () const

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={}) 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)
	Append the sample data to the WaveTrack. You must call Flush() after the last Append. More...

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

void	ClearWaveCaches ()
	Invalidates all clips' wavecaches. Careful, This may not be threadsafe. 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...

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

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

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

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

size_t	GetBestBlockSize (sampleCount t) const

size_t	GetMaxBlockSize () const

size_t	GetIdealBlockSize ()

bool	HandleXMLTag (const wxChar tag, const wxChar *attrs) override

void	HandleXMLEndTag (const wxChar *tag) override

XMLTagHandler *	HandleXMLChild (const wxChar *tag) override

void	WriteXML (XMLWriter &xmlFile) const override

bool	GetErrorOpening () override

bool	CloseLock ()

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

WaveClipHolders &	GetClips ()

const WaveClipConstHolders &	GetClips () const

IteratorRange< AllClipsIterator >	GetAllClips ()

IteratorRange< AllClipsConstIterator >	GetAllClips () const

WaveClip *	CreateClip (double offset=.0)

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, ProgressDialog *progress=NULL)

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

Public Member Functions inherited from PlayableTrack
	PlayableTrack ()

	PlayableTrack (const Track &orig)

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	WriteXMLAttributes (XMLWriter &xmlFile) const

bool	HandleXMLAttribute (const wxChar attr, const wxChar value)

Public Member Functions inherited from AudioTrack
	AudioTrack ()

	AudioTrack (const Track &orig)

void	WriteXMLAttributes (XMLWriter &WXUNUSED(xmlFile)) const

bool	HandleXMLAttribute (const wxChar , const wxChar )

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 -> typename std::enable_if< std::is_const< Subclass >::value, std::shared_ptr< Subclass > >::type

std::shared_ptr< Track >	SubstitutePendingChangedTrack ()

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

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

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

const std::shared_ptr< CommonTrackCell > &	GetTrackView ()

void	SetTrackView (const std::shared_ptr< CommonTrackCell > &pView)

const std::shared_ptr< CommonTrackCell > &	GetTrackControls ()

void	SetTrackControls (const std::shared_ptr< CommonTrackCell > &pControls)

int	GetIndex () const

void	SetIndex (int index)

bool	LinkConsistencyCheck ()

bool	HasOwner () const

std::shared_ptr< TrackList >	GetOwner () const

	Track ()

	Track (const Track &orig)

virtual	~ Track ()

void	Init (const Track &orig)

virtual Holder	Duplicate () const

wxString	GetName () const

void	SetName (const wxString &n)

wxString	GetDefaultName () const

void	SetDefaultName (const wxString &n)

bool	GetSelected () const

virtual void	SetSelected (bool s)

void	EnsureVisible (bool modifyState=false)

void	Offset (double t)

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

bool	IsSyncLockSelected () const

void	Notify (int code=-1)

bool	Any () const

bool	IsSelected () const

bool	IsSelectedOrSyncLockSelected () const

bool	IsLeader () const

bool	IsSelectedLeader () const

void	AdjustPositions ()

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

bool	HandleCommonXMLAttribute (const wxChar attr, const wxChar value)

Public Member Functions inherited from XMLTagHandler
	XMLTagHandler ()

virtual	~XMLTagHandler ()

virtual void	HandleXMLEndTag (const wxChar *WXUNUSED(tag))

virtual void	HandleXMLContent (const wxString &WXUNUSED(content))

bool	ReadXMLTag (const char tag, const char *attrs)

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 -> typename std::enable_if< std::is_const< Subclass >::value, Subclass & >::type
	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 -> typename std::enable_if< std::is_const< Subclass >::value, Subclass * >::type
	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...

Protected Attributes
WaveClipHolders	mClips

sampleFormat	mFormat

int	mRate

float	mGain

float	mPan

int	mWaveColorIndex

float	mOldGain [2]

float	mDisplayMin

float	mDisplayMax

float	mSpectrumMin

float	mSpectrumMax

int	mLastScaleType

int	mLastdBRange

std::vector< Location >	mDisplayLocationsCache

Protected Attributes inherited from PlayableTrack
bool	mMute { false }

bool	mSolo { false }

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

wxString	mDefaultName

bool	mLinked

ChannelType	mChannel

double	mOffset

std::shared_ptr< CommonTrackCell >	mpView

std::shared_ptr< CommonTrackCell >	mpControls

Private Member Functions
void	Init (const WaveTrack &orig)

Track::Holder	Clone () const override

TrackKind	GetKind () const override

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
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 void	FinishCopy (const Track n, Track dest)

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

Public Attributes inherited from Track
wxSize	vrulerSize

Static Public Attributes inherited from Track
static const auto	LeftChannel = XMLValueChecker::LeftChannel

static const auto	RightChannel = XMLValueChecker::RightChannel

static const auto	MonoChannel = XMLValueChecker::MonoChannel

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

Member Typedef Documentation

◆ Holder

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

Definition at line 94 of file WaveTrack.h.

◆ Location

typedef WaveTrackLocation WaveTrack::Location

Definition at line 93 of file WaveTrack.h.

Constructor & Destructor Documentation

◆ WaveTrack() [1/2]

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

Definition at line 94 of file WaveTrack.cpp.

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

References format, TracksPrefs::GetDefaultAudioTrackNamePreference(), Track::GetDefaultName(), mDisplayMax, mDisplayMin, mFormat, mGain, mLastdBRange, mLastScaleType, mLegacyProjectFileOffset, mOldGain, mPan, mRate, mSpectrumMax, mSpectrumMin, mWaveColorIndex, Track::SetDefaultName(), and Track::SetName().

Here is the call graph for this function:

◆ WaveTrack() [2/2]

WaveTrack::WaveTrack ( const WaveTrack & orig )

Definition at line 117 of file WaveTrack.cpp.

                                          :
    PlayableTrack(orig)
    , 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;
  
    Init(orig);
  
    for (const auto &clip : orig.mClips)
       mClips.push_back
          ( std::make_unique<WaveClip>( *clip, mpFactory, true ) );
 }

References Init(), mClips, mLastdBRange, mLastScaleType, mLegacyProjectFileOffset, and mpFactory.

Here is the call graph for this function:

◆ ~WaveTrack()

WaveTrack::~WaveTrack ( )

virtual

Definition at line 200 of file WaveTrack.cpp.

201 {

202 }

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 979 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 Sequence::GetFactory(), WaveClip::GetSequence(), and mClips.

Referenced by EffectReverse::ProcessOneWave().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Append()

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

Append the sample data to the WaveTrack. You must call Flush() after the last Append.

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

Returns: true if at least one complete block was created

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

Definition at line 1544 of file WaveTrack.cpp.

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

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

Referenced by BlockGenerator::GenerateTrack(), EffectTwoPassSimpleMono::ProcessOne(), Effect::ProcessTrack(), NyquistEffect::PutCallback(), and EffectNoiseReduction::Worker::ReduceNoise().

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

 {
    for (const auto &c : mClips)
    {
       double d1 = c->GetStartTime() - (clip->GetEndTime()+slideBy);
       double d2 = (clip->GetStartTime()+slideBy) - c->GetEndTime();
       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::GetEndTime(), WaveClip::GetStartTime(), 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 2208 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->GetStartTime() < clip->GetEndTime() + amount &&
             c->GetEndTime() > clip->GetStartTime() + amount)
          {
             if (!allowedAmount)
                return false; // clips overlap
  
             if (amount > 0)
             {
                if (c->GetStartTime()-clip->GetEndTime() < *allowedAmount)
                   *allowedAmount = c->GetStartTime()-clip->GetEndTime();
                if (*allowedAmount < 0)
                   *allowedAmount = 0;
             } else
             {
                if (c->GetEndTime()-clip->GetStartTime() > *allowedAmount)
                   *allowedAmount = c->GetEndTime()-clip->GetStartTime();
                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 mClips.

◆ Clear()

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

override

Exception safety guarantee:: Strong

Definition at line 652 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 658 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 748 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<EnvPoint> envPoints;
    std::vector<double> splits;
    WaveClipHolders cuts;
  
    // 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
       st = LongSamplesToTime(TimeToLongSamples(clip->GetStartTime()));
       if (st >= t0 && st <= t1 && !make_iterator_range(splits).contains(st)) {
          splits.push_back(st);
       }
  
       st = LongSamplesToTime(TimeToLongSamples(clip->GetEndTime()));
       if (st >= t0 && st <= t1 && !make_iterator_range(splits).contains(st)) {
          splits.push_back(st);
       }
  
       // 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->GetOffset() +
                                                          cut->GetOffset()));
  
          // Remember cut point
          if (cs >= t0 && cs <= t1) {
  
             // Remember the absolute offset and add to our cuts array.
             cut->SetOffset(cs);
             cuts.push_back(std::move(*it)); // transfer ownership!
             it = cutlines.erase(it);
          }
          else
             ++it;
       }
  
       // Save the envelope points
       const auto &env = *clip->GetEnvelope();
       for (size_t i = 0, numPoints = env.GetNumberOfPoints(); i < numPoints; ++i) {
          envPoints.push_back(env[i]);
       }
    }
  
    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->GetStartTime()) < 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->GetEndTime()) < 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) {
  
          // Restore the split lines, transforming the position appropriately
          for (const auto split: splits) {
             SplitAt(warper->Warp(split));
          }
  
          // Restore the saved cut lines, also transforming if time altered
          for (const auto &clip : mClips) {
             double st;
             double et;
  
             st = clip->GetStartTime();
             et = clip->GetEndTime();
  
             // Scan the cuts for any that live within this clip
             for (auto it = cuts.begin(); it != cuts.end();) {
                WaveClip *cut = it->get();
                double cs = cut->GetOffset();
  
                // Offset the cut from the start of the clip and add it to
                // this clips cutlines.
                if (cs >= st && cs <= et) {
                   cut->SetOffset(warper->Warp(cs) - st);
                   clip->GetCutLines().push_back( std::move(*it) ); // transfer ownership!
                   it = cuts.erase(it);
                }
                else
                   ++it;
             }
          }
       }
  
       // Restore the envelope points
       for (auto point : envPoints) {
          auto t = warper->Warp(point.GetT());
          if (auto clip = GetClipAtTime(t))
             clip->GetEnvelope()->Insert(t, point.GetVal());
       }
    }
 }

References GetClipAtTime(), GetClipIndex(), Track::GetEndTime(), WaveClip::GetOffset(), GetRate(), HandleClear(), LongSamplesToTime(), make_iterator_range(), mClips, MergeClips(), min(), Paste(), WaveClip::SetOffset(), SortedClipArray(), SplitAt(), TimeToLongSamples(), and TimeWarper::Warp().

Referenced by EffectSBSMS::Finalize(), EditActions::Handler::OnPaste(), Generator::Process(), NyquistEffect::ProcessOne(), EffectNoiseReduction::Worker::ProcessOne(), EffectNoiseRemoval::ProcessOne(), EffectChangeSpeed::ProcessOne(), and Effect::ProcessTrack().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ClearWaveCaches()

void WaveTrack::ClearWaveCaches ( )

Invalidates all clips' wavecaches. Careful, This may not be threadsafe.

Deletes all clips' wavecaches. Careful, This may not be threadsafe.

Definition at line 2515 of file WaveTrack.cpp.

 {
    for (const auto &clip : mClips)
       clip->ClearWaveCache();
 }

References mClips.

◆ Clone()

Track::Holder WaveTrack::Clone ( ) const

overrideprivatevirtual

Implements Track.

Definition at line 353 of file WaveTrack.cpp.

 {
    return std::make_shared<WaveTrack>( *this );
 }

◆ CloseLock()

bool WaveTrack::CloseLock ( )

Definition at line 1762 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 453 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 581 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->GetStartTime() && t1 >= clip->GetEndTime())
       {
          // 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->GetStartTime() && t0 < clip->GetEndTime())
       {
          // Clip is affected by command
          //wxPrintf("copy: clip %i is affected by command\n", (int)clip);
  
          const double clip_t0 = std::max(t0, clip->GetStartTime());
          const double clip_t1 = std::min(t1, clip->GetEndTime());
  
          auto newClip = std::make_unique<WaveClip>
             (*clip, mpFactory, ! forClipboard, clip_t0, clip_t1);
  
          //wxPrintf("copy: clip_t0=%f, clip_t1=%f\n", clip_t0, clip_t1);
  
          newClip->Offset(-t0);
          if (newClip->GetOffset() < 0)
             newClip->SetOffset(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(), GetStartTime(), mClips, min(), mpFactory, WaveClip::Offset(), and THROW_INCONSISTENCY_EXCEPTION.

Referenced by CopyNonconst(), Cut(), EditActions::Handler::OnSplitCut(), LabelEditActions::Handler::OnSplitCutLabels(), EffectRepeat::Process(), 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 646 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 )

Definition at line 2144 of file WaveTrack.cpp.

 {
    mClips.emplace_back(std::make_shared<WaveClip>(mpFactory, mFormat, mRate, GetWaveColorIndex()));
    auto clip = mClips.back().get();
    clip->SetOffset(offset);
    return clip;
 }

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

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 484 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 Paste(), 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 1410 of file WaveTrack.cpp.

 {
    auto minSamples = TimeToLongSamples( WAVETRACK_MERGE_POINT_TOLERANCE );
    const size_t maxAtOnce = 1048576;
    Floats buffer{ maxAtOnce };
    Regions regions;
  
    wxBusyCursor busy;
  
    for (const auto &clip : mClips)
    {
       double startTime = clip->GetStartTime();
       double endTime = clip->GetEndTime();
  
       if( endTime < t0 || startTime > t1 )
          continue;
  
       if( t0 > startTime )
          startTime = t0;
       if( t1 < endTime )
          endTime = t1;
  
       //simply look for a sequence of zeroes and if the sequence
       //is greater than minimum number, split-DELETE the region
  
       sampleCount seqStart = -1;
       sampleCount start, end;
       clip->TimeToSamplesClip( startTime, &start );
       clip->TimeToSamplesClip( endTime, &end );
  
       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(
                         seqStart.as_double() / GetRate()
                                               + clip->GetStartTime(),
                         seqEnd.as_double() / GetRate()
                                               + clip->GetStartTime()));
                   }
                   seqStart = -1;
                }
             }
          }
       }
    }
  
    for( unsigned int i = 0; i < regions.size(); i++ )
    {
       const Region &region = regions.at(i);
       SplitDelete(region.start, region.end );
    }
 }

References sampleCount::as_double(), Region::end, floatSample, GetRate(), limitSampleBufferSize(), mClips, Region, SplitDelete(), Region::start, 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:

◆ EmptyCopy()

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

Definition at line 572 of file WaveTrack.cpp.

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

References mFormat, mpFactory, and mRate.

Referenced by Copy(), PasteInto(), Generator::Process(), EffectSBSMS::Process(), NyquistEffect::ProcessOne(), EffectNoiseReduction::Worker::ProcessOne(), EffectEqualization::ProcessOne(), EffectNoiseRemoval::ProcessOne(), EffectStereoToMono::ProcessOne(), EffectChangeSpeed::ProcessOne(), EffectPaulstretch::ProcessOne(), and Effect::ProcessTrack().

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 2399 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->GetStartTime() > clip->GetStartTime() &&
                 clip->GetEndTime() + end - start > clip2->GetStartTime())
                // 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->GetStartTime() > clip->GetStartTime())
                clip2->Offset(end - start);
          }
       }
    }
 }

References BadUserAction, GetEditClipsCanMove(), mClips, and XO.

Here is the call graph for this function:

◆ Flush()

void WaveTrack::Flush ( )

Flush must be called after last Append.

Exception safety guarantee:: Mixed

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

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

Definition at line 1611 of file WaveTrack.cpp.

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

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

Referenced by NyquistEffect::ProcessOne(), EffectTwoPassSimpleMono::ProcessOne(), Effect::ProcessTrack(), 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

Retrieve samples from a track in a specified format.

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.

Parameters

	buffer	receives the samples
	start	starting sample, relative to absolute time zero (not to the track's offset value)
	len	how many samples to get. buffer is assumed sufficiently large
	fill	how to assign values for sample positions between clips
	mayThrow	if false, fill buffer with zeros when there is failure to retrieve samples; else throw
[out]	pNumWithinClips	Report how many samples were copied from within clips, rather than filled according to fillFormat; but these were not necessarily one contiguous range.
	format	sample format of the destination buffer

Definition at line 1898 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->GetStartSample() && start+len <= clip->GetEndSample())
       {
          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->GetStartSample();
       auto clipEnd = clip->GetEndSample();
  
       if (clipEnd > start && clipStart < start+len)
       {
          // Clip sample region and Get/Put sample region overlap
          auto samplesToCopy =
             std::min( start+len - clipStart, clip->GetNumSamples() );
          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(), and SAMPLE_SIZE.

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

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

◆ GetAllClips() [2/2]

IteratorRange< AllClipsConstIterator > WaveTrack::GetAllClips ( ) const

inline

Definition at line 453 of file WaveTrack.h.

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

◆ GetBestBlockSize()

size_t WaveTrack::GetBestBlockSize ( sampleCount t ) const

Definition at line 1563 of file WaveTrack.cpp.

 {
    auto bestBlockSize = GetMaxBlockSize();
  
    for (const auto &clip : mClips)
    {
       auto startSample = (sampleCount)floor(clip->GetStartTime()*mRate + 0.5);
       auto endSample = startSample + clip->GetNumSamples();
       if (s >= startSample && s < endSample)
       {
          bestBlockSize = clip->GetSequence()->GetBestBlockSize(s - startSample);
          break;
       }
    }
  
    return bestBlockSize;
 }

References GetMaxBlockSize(), mClips, and mRate.

Referenced by EffectNormalize::AnalyseTrackData(), CompareAudioCommand::Apply(), BlockGenerator::GenerateTrack(), NyquistEffect::GetCallback(), EffectNoiseReduction::Worker::ProcessOne(), 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

Definition at line 1550 of file WaveTrack.cpp.

 {
    for (const auto &clip : mClips)
    {
       const auto startSample = (sampleCount)floor(0.5 + clip->GetStartTime()*mRate);
       const auto endSample = startSample + clip->GetNumSamples();
       if (s >= startSample && s < endSample)
          return startSample + clip->GetSequence()->GetBlockStart(s - startSample);
    }
  
    return -1;
 }

References mClips, and mRate.

◆ GetCachedLocations()

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

inline

Definition at line 526 of file WaveTrack.h.

526 { return mDisplayLocationsCache; }

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

Referenced by Mixer::Process().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetChannelGain()

float WaveTrack::GetChannelGain ( int channel ) const

Definition at line 406 of file WaveTrack.cpp.

 {
    float left = 1.0;
    float right = 1.0;
  
    if (mPan < 0)
       right = (mPan + 1.0);
    else if (mPan > 0)
       left = 1.0 - mPan;
  
    if ((channel%2) == 0)
       return left*mGain;
    else
       return right*mGain;
 }

References mGain, and mPan.

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

Here is the caller graph for this function:

◆ GetChannelIgnoringPan()

auto WaveTrack::GetChannelIgnoringPan ( ) const

virtual

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

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

References WaveClip::GetStartSample(), and mClips.

Here is the call graph for this function:

◆ GetClipAtTime()

WaveClip * WaveTrack::GetClipAtTime ( double time )

Definition at line 2105 of file WaveTrack.cpp.

 {
    
    const auto clips = SortedClipArray();
    auto p = std::find_if(clips.rbegin(), clips.rend(), [&] (WaveClip* const& clip) {
       return time >= clip->GetStartTime() && time <= clip->GetEndTime(); });
  
    // When two clips are immediately next to each other, the GetEndTime() of the first clip
    // and the GetStartTime() 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)->GetEndTime() &&
       (*p)->SharesBoundaryWithNextClip(*(p-1))) {
       p--;
    }
  
    return p != clips.rend() ? *p : nullptr;
 }

References SortedClipArray().

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

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

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

References mClips.

Referenced by GetClipByIndex(), and MergeClips().

Here is the caller graph for this function:

◆ GetClipByIndex() [2/2]

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

Definition at line 2198 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 2183 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 366 of file WaveTrack.h.

366 { return mClips; }

Referenced by 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 367 of file WaveTrack.h.

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

◆ GetDisplayBounds()

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

Definition at line 255 of file WaveTrack.cpp.

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

References mDisplayMax, mDisplayMin, and min().

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

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 1800 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->GetEndTime();
       }
       else if (clip->GetEndTime() > best)
          best = clip->GetEndTime();
  
    return best;
 }

References mClips.

Referenced by AUPImportFileHandle::AddSilence(), EffectTruncSilence::Analyze(), Copy(), Effect::GetBounds(), GetMinMax(), GetRMS(), Mixer::MixSameRate(), Mixer::MixVariableRates(), Paste(), EffectChangeSpeed::Process(), EffectSBSMS::Process(), NyquistEffect::ProcessOne(), EffectStereoToMono::ProcessOne(), Effect::ProcessTrack(), GetInfoCommand::SendTracks(), SyncLockAdjust(), and Trim().

Here is the caller graph for this function:

◆ GetEnvelopeAtTime()

Envelope * WaveTrack::GetEnvelopeAtTime ( double time )

Definition at line 2126 of file WaveTrack.cpp.

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

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

Referenced by EnvelopeHandle::WaveTrackHitTest().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetEnvelopeValues()

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

Definition at line 2023 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->GetStartTime();
       auto dClipEndTime = clip->GetEndTime();
       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->GetEndSample() - clip->GetStartSample();
  
             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.

Referenced by Mixer::MixSameRate(), and Mixer::MixVariableRates().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetErrorOpening()

bool WaveTrack::GetErrorOpening ( )

overridevirtual

Reimplemented from Track.

Definition at line 1753 of file WaveTrack.cpp.

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

References mClips.

◆ GetFloats()

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

inline

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

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.

Parameters

	buffer	receives the samples
	start	starting sample, relative to absolute time zero (not to the track's offset value)
	len	how many samples to get. buffer is assumed sufficiently large
	fill	how to assign values for sample positions between clips
	mayThrow	if false, fill buffer with zeros when there is failure to retrieve samples; else throw
[out]	pNumWithinClips	Report how many samples were copied from within clips, rather than filled according to fillFormat; but these were not necessarily one contiguous range.

Cast the pointer to pass it to Get() which handles multiple destination formats

Definition at line 261 of file WaveTrack.h.

    {
       return Get(reinterpret_cast<samplePtr>(buffer),
          floatSample, start, len, fill, mayThrow, pNumWithinClips);
    }

References floatSample, and ClientData::Site< Host, ClientData, ObjectCopyingPolicy, Pointer, ObjectLockingPolicy, RegistryLockingPolicy >::Get().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetGain()

float WaveTrack::GetGain ( ) const

Definition at line 375 of file WaveTrack.cpp.

 {
    return mGain;
 }

References mGain.

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

Here is the caller graph for this function:

◆ GetIdealBlockSize()

size_t WaveTrack::GetIdealBlockSize ( )

Definition at line 1601 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 679 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 343 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 348 of file WaveTrack.cpp.

 {
    return MakeIntervals<Intervals>( mClips );
 }

◆ GetKind()

TrackKind WaveTrack::GetKind ( ) const

inlineoverrideprivatevirtual

Reimplemented from Track.

Definition at line 607 of file WaveTrack.h.

607 { return TrackKind::Wave; }

References Wave.

◆ GetLastdBRange()

int WaveTrack::GetLastdBRange ( ) const

inline

Definition at line 544 of file WaveTrack.h.

544 { return mLastdBRange; }

Referenced by WaveformVRulerControls::DoUpdateVRuler().

Here is the caller graph for this function:

◆ GetLastScaleType()

int WaveTrack::GetLastScaleType ( ) const

inline

Definition at line 541 of file WaveTrack.h.

541 { return mLastScaleType; }

Referenced by WaveformVRulerControls::DoUpdateVRuler().

Here is the caller graph for this function:

◆ GetMaxBlockSize()

size_t WaveTrack::GetMaxBlockSize ( ) const

Definition at line 1581 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 mClips, mFormat, and mpFactory.

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 1825 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->GetStartTime() && t0 <= clip->GetEndTime())
       {
          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 GetEndTime(), mClips, and THROW_INCONSISTENCY_EXCEPTION.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetNumClips()

int WaveTrack::GetNumClips ( ) const

Definition at line 2203 of file WaveTrack.cpp.

 {
    return mClips.size();
 }

References mClips.

◆ GetNumSamples()

sampleCount WaveTrack::GetNumSamples ( ) const

Definition at line 442 of file WaveTrack.cpp.

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

References mClips.

Referenced by TranscriptionToolBar::GetSamples().

Here is the caller graph for this function:

◆ GetOffset()

double WaveTrack::GetOffset ( ) const

overridevirtual

Implements Track.

Definition at line 204 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

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

 {
    return mPan;
 }

References mPan.

Referenced by GetChannel(), MixAndRender(), WaveTrackControls::PanSlider(), and GetInfoCommand::SendTracks().

Here is the caller graph for this function:

◆ GetRate()

double WaveTrack::GetRate ( ) const

Definition at line 358 of file WaveTrack.cpp.

 {
    return mRate;
 }

References mRate.

Referenced by ProjectFileManager::AddImportedTracks(), SelectHandle::AdjustFreqSelection(), EffectTruncSilence::Analyze(), VoiceKey::CalibrateNoise(), ClearAndPaste(), Copy(), ODTask::DemandTrackUpdate(), Disjoin(), SpectrumVRulerControls::DoHandleWheelRotation(), SpectrumVZoomHandle::DoZoom(), WaveformVZoomHandle::DoZoom(), anonymous_namespace{CutlineHandle.cpp}::FindMergeLine(), TranscriptionToolBar::GetSamples(), GetSpectrumBounds(), Mixer::MixSameRate(), Mixer::MixVariableRates(), SelectHandle::MoveSnappingFreqSelection(), VoiceKey::OffBackward(), VoiceKey::OffForward(), VoiceKey::OnBackward(), VoiceKey::OnForward(), anonymous_namespace{SelectHandle.cpp}::PositionToFrequency(), Generator::Process(), EffectSBSMS::Process(), Mixer::Process(), NyquistEffect::ProcessOne(), EffectStereoToMono::ProcessOne(), EffectPaulstretch::ProcessOne(), Effect::ProcessPass(), Effect::ProcessTrack(), 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 1864 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->GetStartTime() && t0 <= clip->GetEndTime())
       {
          sampleCount clipStart, clipEnd;
  
          float cliprms = clip->GetRMS(t0, t1, mayThrow);
  
          clip->TimeToSamplesClip(wxMax(t0, clip->GetStartTime()), &clipStart);
          clip->TimeToSamplesClip(wxMin(t1, clip->GetEndTime()), &clipEnd);
          sumsq += cliprms * cliprms * (clipEnd - clipStart).as_float();
          length += (clipEnd - clipStart);
       }
    }
    return length > 0 ? sqrt(sumsq / length.as_double()) : 0.0;
 }

References sampleCount::as_double(), GetEndTime(), 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

inline

Definition at line 149 of file WaveTrack.h.

149 { return mFormat; }

Referenced by Copy(), and SyncLockAdjust().

Here is the caller graph for this function:

◆ GetSequenceAtTime()

Sequence * WaveTrack::GetSequenceAtTime ( double time )

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

◆ GetSpectrogramSettings() [1/2]

SpectrogramSettings & WaveTrack::GetSpectrogramSettings ( )

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

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

References SpectrogramSettings::defaults(), and mpSpectrumSettings.

Referenced by SpectrumVRulerControls::DoUpdateVRuler(), SpectrumVZoomHandle::DoZoom(), anonymous_namespace{SpectrumView.cpp}::DrawClipSpectrum(), for(), anonymous_namespace{SelectHandle.cpp}::FrequencyToPosition(), WaveClip::GetSpectrogram(), GetSpectrumBounds(), SpectrumVRulerMenuTable::OnSpectrumScaleType(), anonymous_namespace{SelectHandle.cpp}::PositionToFrequency(), NyquistEffect::ProcessOne(), SelectHandle::SnapCenterOnce(), 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 267 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{SpectrumView.cpp}::DrawClipSpectrum(), anonymous_namespace{SelectHandle.cpp}::FrequencyToPosition(), and anonymous_namespace{SelectHandle.cpp}::PositionToFrequency().

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 1780 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->GetStartTime();
       }
       else if (clip->GetStartTime() < best)
          best = clip->GetStartTime();
  
    return best;
 }

References mClips.

Referenced by Copy(), Effect::GetBounds(), GetOffset(), Mixer::MixSameRate(), Mixer::MixVariableRates(), EffectChangeSpeed::Process(), EffectSBSMS::Process(), EffectStereoToMono::ProcessOne(), GetInfoCommand::SendTracks(), and Trim().

Here is the caller graph for this function:

◆ GetWaveColorIndex()

int WaveTrack::GetWaveColorIndex ( ) const

inline

Definition at line 144 of file WaveTrack.h.

144 { return mWaveColorIndex; };

Referenced by CreateClip(), and InsertSilence().

Here is the caller graph for this function:

◆ GetWaveformSettings() [1/2]

WaveformSettings & WaveTrack::GetWaveformSettings ( )

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

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

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

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 992 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->BeforeClip(t1) && !clip->AfterClip(t0) &&
                (clip->BeforeClip(t0) || clip->AfterClip(t1)))
          {
             addCutLines = false;
             break;
          }
       }
    }
  
    for (const auto &clip : mClips)
    {
       if (clip->BeforeClip(t0) && clip->AfterClip(t1))
       {
          // Whole clip must be deleted - remember this
          clipsToDelete.push_back(clip.get());
       }
       else if (!clip->BeforeClip(t1) && !clip->AfterClip(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->BeforeClip(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->Clear(clip->GetStartTime(), t1);
                   newClip->Offset(t1-clip->GetStartTime());
  
                   clipsToAdd.push_back( std::move( newClip ) );
                }
                else if (clip->AfterClip(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->Clear(t0, clip->GetEndTime());
  
                   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...
  
                   // left
                   clipsToAdd.push_back
                      ( std::make_unique<WaveClip>( *clip, mpFactory, true ) );
                   clipsToAdd.back()->Clear(t0, clip->GetEndTime());
  
                   // right
                   clipsToAdd.push_back
                      ( std::make_unique<WaveClip>( *clip, mpFactory, true ) );
                   WaveClip *const right = clipsToAdd.back().get();
                   right->Clear(clip->GetStartTime(), t1);
                   right->Offset(t1 - clip->GetStartTime());
  
                   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
  
    for (const auto &clip : mClips)
    {
       if (clip->BeforeClip(t1))
       {
          // Clip is "behind" the region -- offset it unless we're splitting
          // or we're using the "don't move other clips" mode
          if (!split && editClipCanMove)
             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 WaveClip::Clear(), anonymous_namespace{WaveTrack.cpp}::FindClip(), GetEditClipsCanMove(), mClips, mpFactory, WaveClip::Offset(), 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 wxChar * tag )

overridevirtual

Implements XMLTagHandler.

Definition at line 1695 of file WaveTrack.cpp.

 {
    //
    // This is legacy code (1.2 and previous) and is not called for NEW projects!
    //
    if (!wxStrcmp(tag, wxT("sequence")) || !wxStrcmp(tag, wxT("envelope")))
    {
       // This is a legacy project, so set the cached offset
       NewestOrNewClip()->SetOffset(mLegacyProjectFileOffset);
  
       // Legacy project file tracks are imported as one single wave clip
       if (!wxStrcmp(tag, wxT("sequence")))
          return NewestOrNewClip()->GetSequence();
       else if (!wxStrcmp(tag, wxT("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( !wxStrcmp( tag, wxT("waveblock" )))
    {
       // This is a legacy project, so set the cached offset
       NewestOrNewClip()->SetOffset(mLegacyProjectFileOffset);
       Sequence *pSeq = NewestOrNewClip()->GetSequence();
       return pSeq;
    }
  
    //
    // This is for the NEW file format (post-1.2)
    //
    if (!wxStrcmp(tag, wxT("waveclip")))
       return CreateClip();
    else
       return NULL;
 }

References CreateClip(), WaveClip::GetEnvelope(), WaveClip::GetSequence(), mLegacyProjectFileOffset, NewestOrNewClip(), and WaveClip::SetOffset().

Here is the call graph for this function:

◆ HandleXMLEndTag()

void WaveTrack::HandleXMLEndTag ( const wxChar * tag )

override

Definition at line 1688 of file WaveTrack.cpp.

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

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

Here is the call graph for this function:

◆ HandleXMLTag()

bool WaveTrack::HandleXMLTag	(	const wxChar *	tag,
		const wxChar **	attrs
	)

overridevirtual

Implements XMLTagHandler.

Definition at line 1617 of file WaveTrack.cpp.

 {
    if (!wxStrcmp(tag, wxT("wavetrack"))) {
       double dblValue;
       long nValue;
       while(*attrs) {
          const wxChar *attr = *attrs++;
          const wxChar *value = *attrs++;
  
          if (!value)
             break;
  
          const wxString strValue = value;
          if (!wxStrcmp(attr, wxT("rate")))
          {
             // mRate is an int, but "rate" in the project file is a float.
             if (!XMLValueChecker::IsGoodString(strValue) ||
                   !Internat::CompatibleToDouble(strValue, &dblValue) ||
                   (dblValue < 1.0) || (dblValue > 1000000.0)) // allow a large range to be read
                return false;
             mRate = lrint(dblValue);
          }
          else if (!wxStrcmp(attr, wxT("offset")) &&
                   XMLValueChecker::IsGoodString(strValue) &&
                   Internat::CompatibleToDouble(strValue, &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->PlayableTrack::HandleXMLAttribute(attr, value))
          {}
          else if (this->Track::HandleCommonXMLAttribute(attr, strValue))
             ;
          else if (!wxStrcmp(attr, wxT("gain")) &&
                   XMLValueChecker::IsGoodString(strValue) &&
                   Internat::CompatibleToDouble(strValue, &dblValue))
             mGain = dblValue;
          else if (!wxStrcmp(attr, wxT("pan")) &&
                   XMLValueChecker::IsGoodString(strValue) &&
                   Internat::CompatibleToDouble(strValue, &dblValue) &&
                   (dblValue >= -1.0) && (dblValue <= 1.0))
             mPan = dblValue;
          else if (!wxStrcmp(attr, wxT("channel")))
          {
             if (!XMLValueChecker::IsGoodInt(strValue) || !strValue.ToLong(&nValue) ||
                   !XMLValueChecker::IsValidChannel(nValue))
                return false;
             mChannel = static_cast<Track::ChannelType>( nValue );
          }
          else if (!wxStrcmp(attr, wxT("linked")) &&
                   XMLValueChecker::IsGoodInt(strValue) && strValue.ToLong(&nValue))
             SetLinked(nValue != 0);
          else if (!wxStrcmp(attr, wxT("colorindex")) &&
                   XMLValueChecker::IsGoodString(strValue) &&
                   strValue.ToLong(&nValue))
             // Don't use SetWaveColorIndex as it sets the clips too.
             mWaveColorIndex  = nValue;
          else if (!wxStrcmp(attr, wxT("sampleformat")) &&
                   XMLValueChecker::IsGoodInt(strValue) &&
                   strValue.ToLong(&nValue) &&
                   XMLValueChecker::IsValidSampleFormat(nValue))
             mFormat = static_cast<sampleFormat>(nValue);
       } // while
       return true;
    }
  
    return false;
 }

References Internat::CompatibleToDouble(), Track::HandleCommonXMLAttribute(), PlayableTrack::HandleXMLAttribute(), XMLValueChecker::IsGoodInt(), XMLValueChecker::IsGoodString(), XMLValueChecker::IsValidChannel(), XMLValueChecker::IsValidSampleFormat(), lrint, Track::mChannel, mFormat, mGain, mLegacyProjectFileOffset, mPan, mRate, mWaveColorIndex, and Track::SetLinked().

Here is the call graph for this function:

◆ Init()

void WaveTrack::Init ( const WaveTrack & orig )

private

Definition at line 142 of file WaveTrack.cpp.

 {
    PlayableTrack::Init(orig);
    mpFactory = orig.mpFactory;
    
    mFormat = orig.mFormat;
    mWaveColorIndex = orig.mWaveColorIndex;
    mRate = orig.mRate;
    mGain = orig.mGain;
    mPan = orig.mPan;
    mOldGain[0] = 0.0;
    mOldGain[1] = 0.0;
    SetDefaultName(orig.GetDefaultName());
    SetName(orig.GetName());
    mDisplayMin = orig.mDisplayMin;
    mDisplayMax = orig.mDisplayMax;
    mSpectrumMin = orig.mSpectrumMin;
    mSpectrumMax = orig.mSpectrumMax;
    mDisplayLocationsCache.clear();
 }

References Track::GetDefaultName(), Track::GetName(), PlayableTrack::Init(), mDisplayLocationsCache, mDisplayMax, mDisplayMin, mFormat, mGain, mOldGain, mPan, mpFactory, mRate, mSpectrumMax, mSpectrumMin, mWaveColorIndex, Track::SetDefaultName(), and Track::SetName().

Referenced by Reinit(), and WaveTrack().

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 1370 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->WithinClip(t); } );
  
       // use Strong-guarantee
       if (it != end)
          it->get()->InsertSilence(t, len);
  
       // use No-fail-guarantee
       for (const auto &clip : mClips)
       {
          if (clip->BeforeClip(t))
             clip->Offset(len);
       }
    }
 }

References 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 462 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->BeforeClip(t1) && !clip->AfterClip(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 Paste(), 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 1488 of file WaveTrack.cpp.

 {
    // Merge all WaveClips overlapping selection into one
  
    WaveClipPointers clipsToDelete;
    WaveClip *newClip;
  
    for (const auto &clip: mClips)
    {
       if (clip->GetStartTime() < t1-(1.0/mRate) &&
           clip->GetEndTime()-(1.0/mRate) > t0) {
  
          // Put in sorted order
          auto it = clipsToDelete.begin(), end = clipsToDelete.end();
          for (; it != end; ++it)
             if ((*it)->GetStartTime() > clip->GetStartTime())
                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;
  
    newClip = CreateClip();
    double t = clipsToDelete[0]->GetOffset();
    newClip->SetOffset(t);
    for (const auto &clip : clipsToDelete)
    {
       //wxPrintf("t=%.6f adding clip (offset %.6f, %.6f ... %.6f)\n",
       //       t, clip->GetOffset(), clip->GetStartTime(), clip->GetEndTime());
  
       if (clip->GetOffset() - t > (1.0 / mRate)) {
          double addedSilence = (clip->GetOffset() - t);
          //wxPrintf("Adding %.6f seconds of silence\n");
          auto offset = clip->GetOffset();
          auto value = clip->GetEnvelope()->GetValue( offset );
          newClip->AppendSilence( addedSilence, value );
          t += addedSilence;
       }
  
       //wxPrintf("Pasting at %.6f\n", t);
       newClip->Paste(t, clip);
  
       t = newClip->GetEndTime();
  
       auto it = FindClip(mClips, clip);
       mClips.erase(it); // deletes the clip
    }
 }

References WaveClip::AppendSilence(), CreateClip(), anonymous_namespace{WaveTrack.cpp}::FindClip(), WaveClip::GetEndTime(), mClips, mRate, WaveClip::Paste(), and WaveClip::SetOffset().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LongSamplesToTime()

double WaveTrack::LongSamplesToTime ( sampleCount pos ) const

Convert correctly between a number of samples and an (absolute) time in seconds.

Parameters

pos	The time number of samples from the start of the track to convert.

Returns: The time in seconds.

Definition at line 1775 of file WaveTrack.cpp.

 {
    return pos.as_double() / mRate;
 }

References sampleCount::as_double(), and mRate.

Referenced by AUPImportFileHandle::AddSilence(), anonymous_namespace{SampleHandle.cpp}::adjustTime(), EffectTruncSilence::Analyze(), CompareAudioCommand::Apply(), EffectAutoDuck::ApplyDuckFade(), ClearAndPaste(), EffectTruncSilence::DoRemoval(), anonymous_namespace{WaveformView.cpp}::DrawClipWaveform(), EffectSBSMS::Finalize(), EditActions::Handler::OnSplitNew(), EffectAutoDuck::Process(), EffectRepeat::Process(), EffectEqualization::ProcessOne(), EffectFindClipping::ProcessOne(), EffectChangeSpeed::ProcessOne(), EffectReverse::ProcessOneWave(), and SplitAt().

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

Definition at line 184 of file WaveTrack.cpp.

 {
    orig.TypeSwitch( [&](const WaveTrack *pwt) {
       const WaveTrack &wt = *pwt;
       mGain    = wt.mGain;
       mPan     = wt.mPan;
       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);
    });
    PlayableTrack::Merge(orig);
 }

References mDisplayMax, mDisplayMin, PlayableTrack::Merge(), mGain, mPan, 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 2462 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->GetEndTime(), 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::GetEndTime(), mClips, and WaveClip::Paste().

Referenced by ClearAndPaste().

Here is the call graph for this function:

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

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

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

 {
    bool editClipCanMove = GetEditClipsCanMove();
  
    bool bOk = src && src->TypeSwitch< bool >( [&](const WaveTrack *other) {
  
       //
       // 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 true;
  
       //wxPrintf("paste: we have at least one clip\n");
  
       bool singleClipMode = (other->GetNumClips() == 1 &&
             other->GetStartTime() == 0.0);
  
       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 true;
  
       //wxPrintf("Check if we need to make room for the pasted data\n");
  
       // 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->GetStartTime() > t0-(1.0/mRate))
                   clip->Offset(insertDuration);
             }
          }
       }
  
       if (singleClipMode)
       {
          // Single clip mode
          // wxPrintf("paste: checking for single clip mode!\n");
  
          WaveClip *insideClip = NULL;
  
          for (const auto &clip : mClips)
          {
             if (editClipCanMove)
             {
                if (clip->WithinClip(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->WithinClip(t0) ||
                      TimeToLongSamples(t0) == clip->GetStartSample())
                {
                   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->GetStartTime() > insideClip->GetStartTime() &&
                       insideClip->GetEndTime() + insertDuration >
                                                          clip->GetStartTime())
                      // 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 true;
          }
  
          // 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();
             mClips.push_back(std::move(newClip)); // transfer ownership
          }
       }
       return true;
    } );
  
    if( !bOk )
       // THROW_INCONSISTENCY_EXCEPTION; // ?
       (void)0;// Empty if intentional.
 }

References BadUserAction, Cut(), GetEditClipsCanMove(), WaveClip::GetEndTime(), GetEndTime(), WaveClip::GetStartTime(), IsEmpty(), mClips, mpFactory, mRate, WaveClip::Paste(), TimeToLongSamples(), Track::TypeSwitch(), and XO.

Referenced by ClearAndPaste(), EffectRepeat::Process(), 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 334 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:

◆ Reinit()

void WaveTrack::Reinit ( const WaveTrack & orig )

Definition at line 163 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 966 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 2452 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,
		ProgressDialog *	progress = `NULL`
	)

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

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

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

References CreateClip(), WaveClip::GetOffset(), 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 1981 of file WaveTrack.cpp.

 {
    for (const auto &clip: mClips)
    {
       auto clipStart = clip->GetStartSample();
       auto clipEnd = clip->GetEndSample();
  
       if (clipEnd > start && clipStart < start+len)
       {
          // Clip sample region and Get/Put sample region overlap
          auto samplesToCopy =
             std::min( start+len - clipStart, clip->GetNumSamples() );
          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(), EffectTruncSilence::DoRemoval(), EffectClickRemoval::ProcessOne(), EffectRepair::ProcessOne(), EffectNormalize::ProcessOne(), EffectSimpleMono::ProcessOne(), EffectTwoPassSimpleMono::ProcessOne(), EffectReverse::ProcessOneClip(), and Effect::ProcessTrack().

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

 {
    if (mGain != newGain) {
       mGain = newGain;
       Notify();
    }
 }

References mGain, 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 250 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 245 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 210 of file WaveTrack.cpp.

 {
    double delta = o - GetOffset();
  
    for (const auto &clip : mClips)
       // assume No-fail-guarantee
       clip->SetOffset(clip->GetOffset() + 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
	)

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

 {
    if (newPan > 1.0)
       newPan = 1.0;
    else if (newPan < -1.0)
       newPan = -1.0;
  
    if ( mPan != newPan ) {
       mPan = newPan;
       Notify();
    }
 }

References mPan, 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 237 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 363 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->SetOffset( clip->GetOffset() * ratio );
    }
 }

References mClips, and mRate.

Referenced by NyquistEffect::ProcessOne().

Here is the caller graph for this function:

◆ SetSpectrogramSettings()

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

Definition at line 687 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 311 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 435 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 725 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 1335 of file WaveTrack.cpp.

 {
    if (t1 < t0)
       THROW_INCONSISTENCY_EXCEPTION;
  
    auto start = (sampleCount)floor(t0 * mRate + 0.5);
    auto len = (sampleCount)floor(t1 * mRate + 0.5) - start;
  
    for (const auto &clip : mClips)
    {
       auto clipStart = clip->GetStartSample();
       auto clipEnd = clip->GetEndSample();
  
       if (clipEnd > start && clipStart < start+len)
       {
          // Clip sample region and Get/Put sample region overlap
          auto samplesToCopy = start+len - clipStart;
          if (samplesToCopy > clip->GetNumSamples())
             samplesToCopy = clip->GetNumSamples();
          auto startDelta = clipStart - start;
          decltype(startDelta) inclipDelta = 0;
          if (startDelta < 0)
          {
             inclipDelta = -startDelta; // make positive value
             samplesToCopy -= inclipDelta;
             startDelta = 0;
          }
  
          clip->GetSequence()->SetSilence(inclipDelta, samplesToCopy);
          clip->MarkChanged();
       }
    }
 }

References mClips, mRate, and THROW_INCONSISTENCY_EXCEPTION.

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

Here is the caller graph for this function:

◆ SortedClipArray() [1/2]

WaveClipPointers WaveTrack::SortedClipArray ( )

Definition at line 2504 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(), 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 2509 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 2301 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 2309 of file WaveTrack.cpp.

 {
    for (const auto &c : mClips)
    {
       if (c->WithinClip(t))
       {
          t = LongSamplesToTime(TimeToLongSamples(t)); // put t on a sample
          auto newClip = std::make_unique<WaveClip>( *c, mpFactory, true );
          c->Clear(t, c->GetEndTime());
          newClip->Clear(c->GetStartTime(), t);
  
          //offset the NEW clip by the splitpoint (noting that it is already offset to c->GetStartTime())
          sampleCount here = llrint(floor(((t - c->GetStartTime()) * mRate) + 0.5));
          newClip->Offset(here.as_double()/(double)mRate);
          // 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 sampleCount::as_double(), LongSamplesToTime(), mClips, mpFactory, mRate, and TimeToLongSamples().

Referenced by ClearAndPaste(), 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 497 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 924 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 1131 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
          bool clipsCanMove = true;
          gPrefs->Read(wxT("/GUI/EditClipCanMove"), &clipsCanMove);
          if (clipsCanMove) {
             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(), GetEndTime(), GetRate(), GetSampleFormat(), gPrefs, IsEmpty(), mpFactory, and Paste().

Here is the call graph for this function:

◆ TimeToLongSamples()

AUDACITY_DLL_API sampleCount WaveTrack::TimeToLongSamples ( double t0 ) const

Convert correctly between an (absolute) time in seconds and a number of samples.

This method will not give the correct results if used on a relative time (difference of two times). Each absolute time must be converted and the numbers of samples differenced: sampleCount start = track->TimeToLongSamples(t0); sampleCount end = track->TimeToLongSamples(t1); sampleCount len = (sampleCount)(end - start); NOT the likes of: sampleCount len = track->TimeToLongSamples(t1 - t0); See also WaveTrack::TimeToLongSamples().

Parameters

t0	The time (floating point seconds) to convert

Returns: The number of samples from the start of the track which lie before the given time.

Definition at line 1770 of file WaveTrack.cpp.

 {
    return sampleCount( floor(t0 * mRate + 0.5) );
 }

References mRate.

Referenced by anonymous_namespace{SampleHandle.cpp}::adjustTime(), EffectNormalize::AnalyseTrackData(), EffectTruncSilence::Analyze(), CompareAudioCommand::Apply(), EffectAutoDuck::ApplyDuckFade(), ClearAndPaste(), ClipParameters::ClipParameters(), Disjoin(), EffectTruncSilence::DoRemoval(), anonymous_namespace{WaveformView.cpp}::DrawClipWaveform(), EffectSBSMS::Finalize(), BlockGenerator::GenerateTrack(), Effect::GetBounds(), Mixer::MixVariableRates(), EditActions::Handler::OnSplitNew(), Paste(), EffectAutoDuck::Process(), EffectChangeSpeed::Process(), NyquistEffect::Process(), EffectRepeat::Process(), EffectReverse::Process(), EffectSBSMS::Process(), NyquistEffect::ProcessOne(), EffectLoudness::ProcessOne(), EffectNormalize::ProcessOne(), EffectChangeSpeed::ProcessOne(), EffectPaulstretch::ProcessOne(), EffectReverse::ProcessOneWave(), Effect::ProcessPass(), SplitAt(), and SelectHandle::StartSnappingFreqSelection().

Here is the caller graph for this function:

◆ Trim()

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

Exception safety guarantee:: Weak

Definition at line 530 of file WaveTrack.cpp.

 {
    bool inside0 = false;
    bool inside1 = false;
    //Keeps track of the offset of the first clip greater than
    // the left selection t0.
    double firstGreaterOffset = -1;
  
    for (const auto &clip : mClips)
    {
       //Find the first clip greater than the offset.
       //If we end up clipping the entire track, this is useful.
       if(firstGreaterOffset < 0 &&
             clip->GetStartTime() >= t0)
          firstGreaterOffset = clip->GetStartTime();
  
       if(t1 > clip->GetStartTime() && t1 < clip->GetEndTime())
       {
          clip->Clear(t1,clip->GetEndTime());
          inside1 = true;
       }
  
       if(t0 > clip->GetStartTime() && t0 < clip->GetEndTime())
       {
          clip->Clear(clip->GetStartTime(),t0);
          clip->SetOffset(t0);
          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 2331 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)
       {
          num += clip->NumCutLines();
  
          if (prev && fabs(prev->GetEndTime() -
                           clip->GetStartTime()) < 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())
       {
          // Add cut line expander point
          mDisplayLocationsCache.push_back(WaveTrackLocation{
             clip->GetOffset() + cc->GetOffset(),
             WaveTrackLocation::locationCutLine
          });
          curpos++;
       }
  
       if (previousClip)
       {
          if (fabs(previousClip->GetEndTime() - clip->GetStartTime())
                                           < WAVETRACK_MERGE_POINT_TOLERANCE)
          {
             // Add merge point
             mDisplayLocationsCache.push_back(WaveTrackLocation{
                previousClip->GetEndTime(),
                WaveTrackLocation::locationMergePoint,
                GetClipIndex(previousClip),
                GetClipIndex(clip)
             });
             curpos++;
          }
       }
  
       previousClip = clip;
    }
  
    wxASSERT(curpos == num);
 }

References GetClipIndex(), WaveClip::GetEndTime(), 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 694 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 1731 of file WaveTrack.cpp.

 {
    xmlFile.StartTag(wxT("wavetrack"));
    this->Track::WriteCommonXMLAttributes( xmlFile );
    xmlFile.WriteAttr(wxT("channel"), mChannel);
    xmlFile.WriteAttr(wxT("linked"), mLinked);
    this->PlayableTrack::WriteXMLAttributes(xmlFile);
    xmlFile.WriteAttr(wxT("rate"), mRate);
    xmlFile.WriteAttr(wxT("gain"), (double)mGain);
    xmlFile.WriteAttr(wxT("pan"), (double)mPan);
    xmlFile.WriteAttr(wxT("colorindex"), mWaveColorIndex );
    xmlFile.WriteAttr(wxT("sampleformat"), static_cast<long>(mFormat) );
  
    for (const auto &clip : mClips)
    {
       clip->WriteXML(xmlFile);
    }
  
    xmlFile.EndTag(wxT("wavetrack"));
 }

References Track::WriteCommonXMLAttributes(), and PlayableTrack::WriteXMLAttributes().

Here is the call graph for this function:

◆ ZeroLevelYCoordinate()

int WaveTrack::ZeroLevelYCoordinate ( wxRect rect ) const

Definition at line 317 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 89 of file WaveTrack.h.

Member Data Documentation

◆ mAppendCriticalSection

wxCriticalSection WaveTrack::mAppendCriticalSection

private

Definition at line 616 of file WaveTrack.h.

◆ mClips

WaveClipHolders WaveTrack::mClips

protected

◆ mDisplayLocationsCache

std::vector<Location> WaveTrack::mDisplayLocationsCache

mutableprotected

Definition at line 599 of file WaveTrack.h.

Referenced by Init(), and UpdateLocationsCache().

◆ mDisplayMax

float WaveTrack::mDisplayMax

mutableprotected

Definition at line 593 of file WaveTrack.h.

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

◆ mDisplayMin

float WaveTrack::mDisplayMin

mutableprotected

Definition at line 592 of file WaveTrack.h.

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

◆ mFlushCriticalSection

wxCriticalSection WaveTrack::mFlushCriticalSection

private

Definition at line 615 of file WaveTrack.h.

◆ mFormat

sampleFormat WaveTrack::mFormat

protected

Definition at line 580 of file WaveTrack.h.

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

◆ mGain

float WaveTrack::mGain

protected

Definition at line 582 of file WaveTrack.h.

Referenced by GetChannelGain(), GetGain(), HandleXMLTag(), Init(), Merge(), SetGain(), and WaveTrack().

◆ mLastdBRange

int WaveTrack::mLastdBRange

mutableprotected

Definition at line 598 of file WaveTrack.h.

Referenced by SetLastdBRange(), and WaveTrack().

◆ mLastScaleType

int WaveTrack::mLastScaleType

mutableprotected

Definition at line 597 of file WaveTrack.h.

Referenced by SetLastScaleType(), and WaveTrack().

◆ mLegacyProjectFileOffset

double WaveTrack::mLegacyProjectFileOffset

private

Definition at line 617 of file WaveTrack.h.

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

◆ mOldGain

float WaveTrack::mOldGain[2]

protected

Definition at line 585 of file WaveTrack.h.

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

◆ mPan

float WaveTrack::mPan

protected

Definition at line 583 of file WaveTrack.h.

Referenced by GetChannelGain(), GetPan(), HandleXMLTag(), Init(), Merge(), SetPan(), and WaveTrack().

◆ mpFactory

SampleBlockFactoryPtr WaveTrack::mpFactory

private

Definition at line 613 of file WaveTrack.h.

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

◆ mpSpectrumSettings

std::unique_ptr<SpectrogramSettings> WaveTrack::mpSpectrumSettings

private

Definition at line 619 of file WaveTrack.h.

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

◆ mpWaveformSettings

std::unique_ptr<WaveformSettings> WaveTrack::mpWaveformSettings

private

Definition at line 620 of file WaveTrack.h.

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

◆ mRate

int WaveTrack::mRate

protected

Definition at line 581 of file WaveTrack.h.

Referenced by CreateClip(), EmptyCopy(), GetBestBlockSize(), GetBlockStart(), GetEnvelopeValues(), GetRate(), HandleXMLTag(), Init(), InsertSilence(), Join(), LongSamplesToTime(), Paste(), Resample(), SetRate(), Silence(), SplitAt(), TimeToLongSamples(), and WaveTrack().

◆ mSpectrumMax

float WaveTrack::mSpectrumMax

mutableprotected

Definition at line 595 of file WaveTrack.h.

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

◆ mSpectrumMin

float WaveTrack::mSpectrumMin

mutableprotected

Definition at line 594 of file WaveTrack.h.

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

◆ mWaveColorIndex

int WaveTrack::mWaveColorIndex

protected

Definition at line 584 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

Protected Attributes

Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ Holder

◆ Location

Constructor & Destructor Documentation

◆ WaveTrack() [1/2]

◆ WaveTrack() [2/2]

◆ ~WaveTrack()

Member Function Documentation

◆ AddClip()

◆ Append()

◆ CanInsertClip()

◆ CanOffsetClips()

◆ Clear()

◆ ClearAndAddCutLine()

◆ ClearAndPaste()

◆ ClearWaveCaches()

◆ Clone()

◆ CloseLock()

◆ ConvertToSampleFormat()

◆ Copy()

◆ CopyNonconst()

◆ CreateClip()

◆ Cut()

◆ Disjoin()

◆ EmptyCopy()

◆ ExpandCutLine()

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

◆ GetDisplayBounds()

◆ GetEndTime()

◆ GetEnvelopeAtTime()

◆ GetEnvelopeValues()

◆ GetErrorOpening()

◆ GetFloats()

◆ GetGain()

◆ GetIdealBlockSize()

◆ GetIndependentSpectrogramSettings()

◆ GetIntervals() [1/2]

◆ GetIntervals() [2/2]

◆ GetKind()

◆ GetLastdBRange()

◆ GetLastScaleType()

◆ GetMaxBlockSize()

◆ GetMinMax()

◆ GetNumClips()

◆ GetNumSamples()

◆ GetOffset()

◆ GetOldChannelGain()

◆ GetPan()

◆ GetRate()

◆ GetRMS()

◆ GetSampleFormat()

◆ GetSequenceAtTime()

◆ GetSpectrogramSettings() [1/2]

◆ GetSpectrogramSettings() [2/2]

◆ GetSpectrumBounds()