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

#include <WaveTrack.h>

Inheritance diagram for WaveTrack:

Classes
class	AllClipsIterator

class	Location
	Used only by WaveTrack, a special way to hold location that can accommodate merged regions. More...

struct	Locker

struct	WaveTrackLockDeleter

Public Types
enum	WaveTrackDisplayValues : int { Waveform = 0, MinDisplay = Waveform, obsoleteWaveformDBDisplay, Spectrum, obsolete1, obsolete2, obsolete3, obsolete4, MaxDisplay = Spectrum, NoDisplay }

enum	SampleDisplay { LinearInterpolate = 0, StemPlot }

enum	ZoomPresets { kZoomToFit = 0, kZoomToSelection, kZoomDefault, kZoomMinutes, kZoomSeconds, kZoom5ths, kZoom10ths, kZoom20ths, kZoom50ths, kZoom100ths, kZoom500ths, kZoomMilliSeconds, kZoomSamples, kZoom4To1, kMaxZoom }

typedef WaveTrackLocation	Location

using	Holder = std::unique_ptr< WaveTrack >

using	LockerBase = std::unique_ptr< const WaveTrack, WaveTrackLockDeleter >

typedef int	WaveTrackDisplay

Public Types inherited from Track
enum	{ LeftChannel = 0, RightChannel = 1, MonoChannel = 2 }

enum	TrackKindEnum { None, Wave, Label, Time, All }

enum	: unsigned { DefaultHeight = 150 }

using	Holder = std::unique_ptr< Track >

Public Member Functions
void	Reinit (const WaveTrack &orig)

virtual	~WaveTrack ()

std::vector< UIHandlePtr >	DetailedHitTest (const TrackPanelMouseState &state, const AudacityProject *pProject, int currentTool, bool bMultiTool) override

double	GetOffset () const override

void	SetOffset (double o) override

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

int	GetKind () const override

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

void	DoSetMinimized (bool isMinimized) override

int	GetWaveColorIndex () const

void	SetWaveColorIndex (int colorIndex)

sampleFormat	GetSampleFormat () const

void	ConvertToSampleFormat (sampleFormat format)

const SpectrogramSettings &	GetSpectrogramSettings () const

SpectrogramSettings &	GetSpectrogramSettings ()

SpectrogramSettings &	GetIndependentSpectrogramSettings ()

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

const WaveformSettings &	GetWaveformSettings () const

WaveformSettings &	GetWaveformSettings ()

WaveformSettings &	GetIndependentWaveformSettings ()

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

void	UseSpectralPrefs (bool bUse=true)

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

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

void	Append (samplePtr buffer, sampleFormat format, size_t len, unsigned int stride=1, XMLWriter *blockFileLog=NULL)
	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	AppendAlias (const wxString &fName, sampleCount start, size_t len, int channel, bool useOD)

void	AppendCoded (const wxString &fName, sampleCount start, size_t len, int channel, int decodeType)

unsigned int	GetODFlags () const
	gets an int with OD flags so that we can determine which ODTasks should be run on this track after save/open, etc. More...

void	ClearWaveCaches ()
	Invalidates all clips' wavecaches. Careful, This may not be threadsafe. More...

void	AddInvalidRegion (sampleCount startSample, sampleCount endSample)
	Adds an invalid region to the wavecache so it redraws that portion only. More...

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

void	Set (samplePtr 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

WaveClip *	GetClipAtX (int xcoord)

Sequence *	GetSequenceAtX (int xcoord)

Envelope *	GetEnvelopeAtX (int xcoord)

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	Lock () const

bool	Unlock () const

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 an number of samples and an (absolute) time in seconds. More...

WaveClipHolders &	GetClips ()

const WaveClipConstHolders &	GetClips () const

IteratorRange< AllClipsIterator >	GetAllClips ()

WaveClip *	CreateClip ()

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	CanOffsetClip (WaveClip clip, double amount, double allowedAmount=NULL)

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

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

void	AddClip (std::shared_ptr< WaveClip > &&clip)

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	GetAutoSaveIdent ()

void	SetAutoSaveIdent (int id)

int	GetLastScaleType () const

void	SetLastScaleType () const

int	GetLastdBRange () const

void	SetLastdBRange () const

WaveTrackDisplay	GetDisplay () const

void	SetDisplay (WaveTrackDisplay display)

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

Public Member Functions inherited from PlayableTrack
	PlayableTrack (const std::shared_ptr< DirManager > &projDirManager)

	PlayableTrack (const Track &orig)

bool	GetMute () const

bool	GetSolo () 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 (const std::shared_ptr< DirManager > &projDirManager)

	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

std::vector< UIHandlePtr >	HitTest (const TrackPanelMouseState &, const AudacityProject *pProject) finaloverride

std::shared_ptr< TrackPanelCell >	ContextMenuDelegate () override

std::shared_ptr< TrackPanelCell >	GetTrackControl ()

std::shared_ptr< TrackPanelCell >	GetVRulerControl ()

std::shared_ptr< TrackPanelCell >	GetResizer ()

virtual int	GetMinimizedHeight () const

int	GetActualHeight () const

int	GetIndex () const

void	SetIndex (int index)

int	GetY () const

int	GetHeight () const

void	SetHeight (int h)

bool	GetMinimized () const

void	SetMinimized (bool isMinimized)

Track *	GetLink () const

	Track (const std::shared_ptr< DirManager > &projDirManager)

	Track (const Track &orig)

virtual	~Track ()

void	Init (const Track &orig)

wxString	GetName () const

void	SetName (const wxString &n)

wxString	GetDefaultName () const

void	SetDefaultName (const wxString &n)

bool	GetSelected () const

virtual void	SetSelected (bool s)

bool	GetLinked () const

void	SetLinked (bool l)

void	Offset (double t)

void	SetChannel (int c)

const std::shared_ptr < DirManager > &	GetDirManager () const

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	IsSyncLockSelected () const

Public Member Functions inherited from CommonTrackPanelCell
	CommonTrackPanelCell ()

virtual	~CommonTrackPanelCell ()=0

HitTestPreview	DefaultPreview (const TrackPanelMouseState &, const AudacityProject *) override

Public Member Functions inherited from TrackPanelCell
virtual	~TrackPanelCell ()=0

virtual unsigned	DoContextMenu (const wxRect &rect, wxWindow pParent, wxPoint pPosition)

virtual unsigned	CaptureKey (wxKeyEvent &event, ViewInfo &viewInfo, wxWindow *pParent)

virtual unsigned	KeyDown (wxKeyEvent &event, ViewInfo &viewInfo, wxWindow *pParent)

virtual unsigned	KeyUp (wxKeyEvent &event, ViewInfo &viewInfo, wxWindow *pParent)

virtual unsigned	Char (wxKeyEvent &event, ViewInfo &viewInfo, wxWindow *pParent)

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)

Static Public Member Functions
static WaveTrackDisplay	ConvertLegacyDisplayValue (int oldValue)

static WaveTrackDisplay	ValidateWaveTrackDisplay (WaveTrackDisplay display)

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

template<typename Subclass = const Track>
static std::shared_ptr< Subclass >	Pointer (const Track *t)

Protected Member Functions
std::shared_ptr< TrackControls >	GetControls () override

std::shared_ptr < TrackVRulerControls >	GetVRulerControls () override

Protected Member Functions inherited from Track
virtual void	DoSetHeight (int h)

std::shared_ptr< Track >	FindTrack () override

Protected Member Functions inherited from CommonTrackPanelCell
unsigned	HandleWheelRotation (const TrackPanelMouseEvent &event, AudacityProject *pProject) override

Protected Attributes
WaveClipHolders	mClips

sampleFormat	mFormat

int	mRate

float	mGain

float	mPan

int	mWaveColorIndex

float	mDisplayMin

float	mDisplayMax

float	mSpectrumMin

float	mSpectrumMax

WaveTrackDisplay	mDisplay

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

int	mIndex

int	mY

int	mHeight

wxString	mName

wxString	mDefaultName

bool	mSelected

bool	mLinked

bool	mMinimized

int	mChannel

double	mOffset

std::shared_ptr< DirManager >	mDirManager

std::shared_ptr< TrackControls >	mpControls

std::shared_ptr < TrackVRulerControls >	mpVRulerContols

std::shared_ptr < TrackPanelResizerCell >	mpResizer

std::weak_ptr< SelectHandle >	mSelectHandle

std::weak_ptr< TimeShiftHandle >	mTimeShiftHandle

Private Member Functions
	WaveTrack (const std::shared_ptr< DirManager > &projDirManager, sampleFormat format=(sampleFormat) 0, double rate=0)

	WaveTrack (const WaveTrack &orig)

void	Init (const WaveTrack &orig)

Track::Holder	Duplicate () const override

Private Attributes
wxCriticalSection	mFlushCriticalSection

wxCriticalSection	mAppendCriticalSection

double	mLegacyProjectFileOffset

int	mAutoSaveIdent

std::unique_ptr < SpectrogramSettings >	mpSpectrumSettings

std::unique_ptr< WaveformSettings >	mpWaveformSettings

std::weak_ptr< CutlineHandle >	mCutlineHandle

std::weak_ptr< SampleHandle >	mSampleHandle

std::weak_ptr< EnvelopeHandle >	mEnvelopeHandle

Friends
class	TrackFactory

Additional Inherited Members
Public Attributes inherited from Track
wxSize	vrulerSize

Detailed Description

A Track that contains audio waveform data.

Definition at line 60 of file WaveTrack.h.

Member Typedef Documentation

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

Definition at line 90 of file WaveTrack.h.

typedef WaveTrackLocation WaveTrack::Location

Definition at line 89 of file WaveTrack.h.

using WaveTrack::LockerBase = std::unique_ptr< const WaveTrack, WaveTrackLockDeleter >

Definition at line 322 of file WaveTrack.h.

typedef int WaveTrack::WaveTrackDisplay

Definition at line 531 of file WaveTrack.h.

Member Enumeration Documentation

enum WaveTrack::SampleDisplay

Enumerator
LinearInterpolate
StemPlot

Definition at line 557 of file WaveTrack.h.

                       {
       LinearInterpolate = 0,
       StemPlot
    };

enum WaveTrack::WaveTrackDisplayValues : int

Enumerator
Waveform
MinDisplay
obsoleteWaveformDBDisplay
Spectrum
obsolete1
obsolete2
obsolete3
obsolete4
MaxDisplay
NoDisplay

Definition at line 532 of file WaveTrack.h.

                                : int {
 
       // DO NOT REORDER OLD VALUES!  Replace obsoletes with placeholders.
 
       Waveform = 0,
       MinDisplay = Waveform,
 
       obsoleteWaveformDBDisplay,
 
       Spectrum,
 
       obsolete1, // was SpectrumLogDisplay
       obsolete2, // was SpectralSelectionDisplay
       obsolete3, // was SpectralSelectionLogDisplay
       obsolete4, // was PitchDisplay
 
       // Add values here, and update MaxDisplay.
 
       MaxDisplay = Spectrum,
 
       NoDisplay,            // Preview track has no display
    };

enum WaveTrack::ZoomPresets

Enumerator
kZoomToFit
kZoomToSelection
kZoomDefault
kZoomMinutes
kZoomSeconds
kZoom5ths
kZoom10ths
kZoom20ths
kZoom50ths
kZoom100ths
kZoom500ths
kZoomMilliSeconds
kZoomSamples
kZoom4To1
kMaxZoom

Definition at line 563 of file WaveTrack.h.

                     {
       kZoomToFit = 0,
       kZoomToSelection,
       kZoomDefault,
       kZoomMinutes,
       kZoomSeconds,
       kZoom5ths,
       kZoom10ths,
       kZoom20ths,
       kZoom50ths,
       kZoom100ths,
       kZoom500ths,
       kZoomMilliSeconds,
       kZoomSamples,
       kZoom4To1,
       kMaxZoom,
    };

Constructor & Destructor Documentation

WaveTrack::WaveTrack	(	const std::shared_ptr< DirManager > &	projDirManager,
		sampleFormat	format = `(sampleFormat)0`,
		double	rate = `0`
	)

private

Definition at line 84 of file WaveTrack.cpp.

References TrackInfo::DefaultWaveTrackHeight(), format, GetActiveProject(), TracksPrefs::GetDefaultAudioTrackNamePreference(), AudacityProject::GetDefaultFormat(), Track::GetDefaultName(), GetIndependentWaveformSettings(), AudacityProject::GetRate(), mAutoSaveIdent, mDisplay, mDisplayMax, mDisplayMin, mFormat, mGain, mLastdBRange, mLastScaleType, mLegacyProjectFileOffset, mPan, mRate, mSpectrumMax, mSpectrumMin, mWaveColorIndex, obsoleteWaveformDBDisplay, WaveformSettings::scaleType, Track::SetDefaultName(), Track::SetHeight(), Track::SetName(), WaveformSettings::stLogarithmic, TracksPrefs::ViewModeChoice(), and Waveform.

                                                                                                       :
    PlayableTrack(projDirManager)
 {
    if (format == (sampleFormat)0)
    {
       format = GetActiveProject()->GetDefaultFormat();
    }
    if (rate == 0)
    {
       rate = GetActiveProject()->GetRate();
    }
 
    // Force creation always:
    WaveformSettings &settings = GetIndependentWaveformSettings();
 
    mDisplay = TracksPrefs::ViewModeChoice();
    if (mDisplay == obsoleteWaveformDBDisplay) {
       mDisplay = Waveform;
       settings.scaleType = WaveformSettings::stLogarithmic;
    }
 
    mLegacyProjectFileOffset = 0;
 
    mFormat = format;
    mRate = (int) rate;
    mGain = 1.0;
    mPan = 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;
    mAutoSaveIdent = 0;
 
    SetHeight( TrackInfo::DefaultWaveTrackHeight() );
 }

WaveTrack::WaveTrack ( const WaveTrack & orig )

private

Definition at line 124 of file WaveTrack.cpp.

References Init(), mClips, Track::mDirManager, mLastdBRange, mLastScaleType, and mLegacyProjectFileOffset.

                                          :
    PlayableTrack(orig)
    , 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, mDirManager, true ) );
 }

WaveTrack::~WaveTrack ( )

virtual

Definition at line 211 of file WaveTrack.cpp.

References ODManager::Instance, ODManager::IsInstanceCreated(), and ODManager::RemoveWaveTrack().

 {
    //Let the ODManager know this WaveTrack is disappearing.
    //Deschedules tasks associated with this track.
    if(ODManager::IsInstanceCreated())
       ODManager::Instance()->RemoveWaveTrack(this);
 }

Member Function Documentation

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

Definition at line 1003 of file WaveTrack.cpp.

References mClips.

Referenced by TimeShiftHandle::Drag(), and EffectReverse::ProcessOneWave().

 {
    // Uncomment the following line after we correct the problem of zero-length clips
    //if (CanInsertClip(clip))
       mClips.push_back(std::move(clip)); // transfer ownership
 }

void WaveTrack::AddInvalidRegion	(	sampleCount	startSample,
		sampleCount	endSample
	)

Adds an invalid region to the wavecache so it redraws that portion only.

Definition at line 2594 of file WaveTrack.cpp.

References WaveClip::AddInvalidRegion().

 {
    for (const auto &clip : mClips)
       clip->AddInvalidRegion(startSample, endSample);
 }

void WaveTrack::Append	(	samplePtr	buffer,
		sampleFormat	format,
		size_t	len,
		unsigned int	stride = `1`,
		XMLWriter *	blockFileLog = `NULL`
	)

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.

Definition at line 1557 of file WaveTrack.cpp.

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

Referenced by BlockGenerator::GenerateTrack(), NyquistEffect::PutCallback(), and EffectNoiseReduction::Worker::ReduceNoise().

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

void WaveTrack::AppendAlias	(	const wxString &	fName,
		sampleCount	start,
		size_t	len,
		int	channel,
		bool	useOD
	)

Definition at line 1568 of file WaveTrack.cpp.

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

 {
    RightmostOrNewClip()->AppendAlias(fName, start, len, channel, useOD);
 }

void WaveTrack::AppendCoded	(	const wxString &	fName,
		sampleCount	start,
		size_t	len,
		int	channel,
		int	decodeType
	)

for use with On-Demand decoding of compressed files. decodeType should be an enum from ODDecodeTask that specifies what Type of encoded file this is, such as eODFLAC

Definition at line 1575 of file WaveTrack.cpp.

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

 {
    RightmostOrNewClip()->AppendCoded(fName, start, len, channel, decodeType);
 }

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

Definition at line 2342 of file WaveTrack.cpp.

References WaveClip::GetEndTime(), WaveClip::GetStartTime(), and mClips.

Referenced by TimeShiftHandle::Drag().

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

bool WaveTrack::CanOffsetClip	(	WaveClip *	clip,
		double	amount,
		double *	allowedAmount = `NULL`
	)

Definition at line 2295 of file WaveTrack.cpp.

References WaveClip::GetEndTime(), WaveClip::GetStartTime(), and mClips.

Referenced by TimeShiftHandle::DoSlideHorizontal().

 {
    if (allowedAmount)
       *allowedAmount = amount;
 
    for (const auto &c: mClips)
    {
       if (c.get() != clip && 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 (!CanOffsetClip(clip, *allowedAmount, NULL)) {
          *allowedAmount = 0; // play safe and don't allow anything
          return false;
       }
       else
          return true;
    } else
       return true;
 }

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

override

Definition at line 678 of file WaveTrack.cpp.

References HandleClear().

Referenced by Cut(), EffectTruncSilence::DoRemoval(), AudacityProject::OnCutLabels(), AudacityProject::OnDeleteLabels(), AudacityProject::OnPunchAndRoll(), Generator::Process(), EffectStereoToMono::ProcessOne(), EffectPaulstretch::ProcessOne(), EffectEqualization::ProcessOne(), SyncLockAdjust(), and Trim().

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

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

Definition at line 684 of file WaveTrack.cpp.

References HandleClear().

Referenced by AudacityProject::OnCutLabels().

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

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

Definition at line 782 of file WaveTrack.cpp.

References 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 Generator::Process(), EffectChangeSpeed::ProcessOne(), NyquistEffect::ProcessOne(), EffectNoiseReduction::Worker::ProcessOne(), and Effect::ProcessTrack().

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

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

References WaveClip::ClearWaveCache().

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

bool WaveTrack::CloseLock ( )

Definition at line 1826 of file WaveTrack.cpp.

References WaveClip::CloseLock(), and mClips.

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

WaveTrack::WaveTrackDisplay WaveTrack::ConvertLegacyDisplayValue ( int oldValue )

static

Definition at line 259 of file WaveTrack.cpp.

References obsoleteWaveformDBDisplay, Spectrum, and Waveform.

Referenced by TracksViewModeSetting::Migrate().

 {
    // Remap old values.
    enum OldValues {
       Waveform,
       WaveformDB,
       Spectrogram,
       SpectrogramLogF,
       Pitch,
    };
 
    WaveTrackDisplay newValue;
    switch (oldValue) {
    default:
    case Waveform:
       newValue = WaveTrack::Waveform; break;
    case WaveformDB:
       newValue = WaveTrack::obsoleteWaveformDBDisplay; break;
    case Spectrogram:
    case SpectrogramLogF:
    case Pitch:
       newValue = WaveTrack::Spectrum; break;
       /*
    case SpectrogramLogF:
       newValue = WaveTrack::SpectrumLogDisplay; break;
    case Pitch:
       newValue = WaveTrack::PitchDisplay; break;
       */
    }
    return newValue;
 }

void WaveTrack::ConvertToSampleFormat ( sampleFormat format )

Definition at line 486 of file WaveTrack.cpp.

References format, mClips, and mFormat.

Referenced by FormatMenuTable::OnFormatChange().

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

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

override

Definition at line 605 of file WaveTrack.cpp.

References GetEndTime(), GetRate(), GetSampleFormat(), GetStartTime(), Init(), mClips, Track::mDirManager, min(), WaveClip::Offset(), safenew, and THROW_INCONSISTENCY_EXCEPTION.

Referenced by CopyNonconst(), Cut(), Effect::Preview(), EffectRepeat::Process(), and SplitCut().

 {
    if (t1 < t0)
       THROW_INCONSISTENCY_EXCEPTION;
 
    WaveTrack *newTrack;
    Track::Holder result
    { newTrack = safenew WaveTrack{ mDirManager } };
 
    newTrack->Init(*this);
 
    // 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, mDirManager, ! 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, mDirManager, ! 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>(mDirManager,
             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;
 }

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

Definition at line 673 of file WaveTrack.cpp.

References Copy().

Referenced by AudacityProject::OnCopyLabels(), and AudacityProject::OnCutLabels().

 {
    return Copy(t0, t1);
 }

WaveClip * WaveTrack::CreateClip ( )

Definition at line 2229 of file WaveTrack.cpp.

References GetWaveColorIndex(), mClips, Track::mDirManager, mFormat, and mRate.

Referenced by HandleXMLChild(), Join(), NewestOrNewClip(), and RightmostOrNewClip().

 {
    mClips.push_back(std::make_unique<WaveClip>(mDirManager, mFormat, mRate, GetWaveColorIndex()));
    return mClips.back().get();
 }

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

override

Definition at line 517 of file WaveTrack.cpp.

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

Referenced by Paste(), and SyncLockAdjust().

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

std::vector< UIHandlePtr > WaveTrack::DetailedHitTest	(	const TrackPanelMouseState &	state,
		const AudacityProject *	pProject,
		int	currentTool,
		bool	bMultiTool
	)

overridevirtual

Implements Track.

Definition at line 27 of file WaveTrackUI.cpp.

References drawTool, envelopeTool, SampleHandle::HitAnywhere(), EnvelopeHandle::HitAnywhere(), TimeShiftHandle::HitAnywhere(), CutlineHandle::HitTest(), SampleHandle::HitTest(), TimeShiftHandle::HitTest(), TrackPanelMouseState::rect, TrackPanelMouseState::state, Waveform, and EnvelopeHandle::WaveTrackHitTest().

 {
    // This is the only override of Track::DetailedHitTest that still
    // depends on the state of the Tools toolbar.
    // If that toolbar were eliminated, this could simplify to a sequence of
    // hit test routines describable by a table.
 
    UIHandlePtr result;
    std::vector<UIHandlePtr> results;
    bool isWaveform = (GetDisplay() == WaveTrack::Waveform);
 
    if (bMultiTool && st.state.CmdDown()) {
       // Ctrl modifier key in multi-tool overrides everything else
       // (But this does not do the time shift constrained to the vertical only,
       //  which is what happens when you hold Ctrl in the Time Shift tool mode)
       result = TimeShiftHandle::HitAnywhere(
          mTimeShiftHandle, Pointer(this), false);
       if (result)
          results.push_back(result);
       return results;
    }
 
    // Some special targets are not drawn in spectrogram,
    // so don't hit them in such views.
    else if (isWaveform) {
       UIHandlePtr result;
       if (NULL != (result = CutlineHandle::HitTest(
          mCutlineHandle, st.state, st.rect,
          pProject, Pointer<WaveTrack>(this))))
          // This overriding test applies in all tools
          results.push_back(result);
       if (bMultiTool) {
          // Conditional hit tests
          // If Tools toolbar were eliminated, we would keep these
          // The priority of these, in case more than one might apply at one
          // point, seems arbitrary
          if (NULL != (result = EnvelopeHandle::WaveTrackHitTest(
             mEnvelopeHandle, st.state, st.rect,
             pProject, Pointer<WaveTrack>(this))))
             results.push_back(result);
          if (NULL != (result = TimeShiftHandle::HitTest(
             mTimeShiftHandle, st.state, st.rect, Pointer(this))))
             // This is the hit test on the "grips" drawn left and
             // right in Multi only
             results.push_back(result);
          if (NULL != (result = SampleHandle::HitTest(
             mSampleHandle, st.state, st.rect,
             pProject, Pointer<WaveTrack>(this))))
             results.push_back(result);
       }
       else {
          switch ( currentTool ) {
                // Unconditional hits appropriate to the tool
                // If tools toolbar were eliminated, we would eliminate these
             case envelopeTool: {
                auto envelope = GetEnvelopeAtX( st.state.m_x );
                result = EnvelopeHandle::HitAnywhere(
                   mEnvelopeHandle, envelope, false);
                break;
             }
             case drawTool:
                result = SampleHandle::HitAnywhere(
                   mSampleHandle, st.state, Pointer<WaveTrack>(this));
                break;
             default:
                result = {};
                break;
          }
          if (result)
             results.push_back(result);
       }
    }
 
    return results;
 }

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

Definition at line 1425 of file WaveTrack.cpp.

References sampleCount::as_double(), Region::end, floatSample, WaveClip::GetEndTime(), GetRate(), WaveClip::GetSamples(), WaveClip::GetStartTime(), limitSampleBufferSize(), mClips, Region, SplitDelete(), Region::start, TimeToLongSamples(), WaveClip::TimeToSamplesClip(), and WAVETRACK_MERGE_POINT_TOLERANCE.

Referenced by AudacityProject::OnDisjoinLabels().

 {
    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 );
    }
 }

void WaveTrack::DoSetMinimized ( bool isMinimized )

overridevirtual

Reimplemented from Track.

Definition at line 456 of file WaveTrack.cpp.

References Track::DoSetMinimized(), WaveTrackVRulerControls::DoZoomPreset(), GetVRulerControls(), and gPrefs.

                                               {
 
 #ifdef EXPERIMENTAL_HALF_WAVE
    bool bHalfWave;
    gPrefs->Read(wxT("/GUI/CollapseToHalfWave"), &bHalfWave, false);
    if( bHalfWave )
    {
       // Show half wave on collapse, full on restore.
       std::shared_ptr<TrackVRulerControls> pTvc = GetVRulerControls();
 
       // An awkward workaround for a function that lives 'in the wrong place'.
       // We use magic numbers, 0 and 1, to tell it to zoom reset or zoom half-wave.
       WaveTrackVRulerControls * pWtvc = reinterpret_cast<WaveTrackVRulerControls*>(pTvc.get());
       if( pWtvc )
          pWtvc->DoZoomPreset( isMinimized ? 1:0);
    }
 #endif
 
    PlayableTrack::DoSetMinimized( isMinimized );
 }

Track::Holder WaveTrack::Duplicate ( ) const

overrideprivatevirtual

Implements Track.

Definition at line 393 of file WaveTrack.cpp.

References safenew.

Referenced by TrackFactory::DuplicateWaveTrack().

 {
    return Track::Holder{ safenew WaveTrack{ *this } };
 }

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

Definition at line 2473 of file WaveTrack.cpp.

References _(), WaveClip::ExpandCutLine(), WaveClip::FindCutLine(), AudacityPrefs::GetEditClipsCanMove(), WaveClip::GetEndTime(), WaveClip::GetStartTime(), gPrefs, and mClips.

 {
    bool editClipCanMove = gPrefs->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{
                   _("There is not enough room available to expand the cut line")
                };
           }
       }
 
       clip->ExpandCutLine(cutLinePosition);
 
       // STRONG-GUARANTEE provided that the following gives NOFAIL-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);
          }
       }
    }
 }

void WaveTrack::Flush ( )

Flush must be called after last Append.

Definition at line 1650 of file WaveTrack.cpp.

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

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

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

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

MM: Now that each wave track can contain multiple clips, we don't have a continous space of samples anymore, but we simulate it, because there are alot 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.

Definition at line 1971 of file WaveTrack.cpp.

References ClearSamples(), fillTwo, fillZero, floatSample, WaveClip::GetEndSample(), WaveClip::GetNumSamples(), WaveClip::GetSamples(), WaveClip::GetStartSample(), mClips, min(), and SAMPLE_SIZE.

 {
    // 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"));
       }
    }
 
    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 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( pNumCopied )
       *pNumCopied = samplesCopied;
    return result;
 }

IteratorRange< AllClipsIterator > WaveTrack::GetAllClips ( )

inline

Definition at line 435 of file WaveTrack.h.

Referenced by GetAllSeqBlocks().

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

int WaveTrack::GetAutoSaveIdent ( )

Definition at line 2600 of file WaveTrack.cpp.

References mAutoSaveIdent.

 {
    return mAutoSaveIdent;
 }

size_t WaveTrack::GetBestBlockSize ( sampleCount t ) const

Definition at line 1607 of file WaveTrack.cpp.

References Sequence::GetBestBlockSize(), GetMaxBlockSize(), WaveClip::GetNumSamples(), WaveClip::GetSequence(), WaveClip::GetStartTime(), mClips, and mRate.

Referenced by EffectNormalize::AnalyseTrackData(), CompareAudioCommand::Apply(), BlockGenerator::GenerateTrack(), NyquistEffect::GetCallback(), EffectSimpleMono::ProcessOne(), EffectChangeSpeed::ProcessOne(), EffectNormalize::ProcessOne(), EffectTwoPassSimpleMono::ProcessOne(), EffectNoiseReduction::Worker::ProcessOne(), EffectReverse::ProcessOneClip(), VoiceKey::TestDirectionChanges(), VoiceKey::TestEnergy(), and VoiceKey::TestSignChanges().

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

sampleCount WaveTrack::GetBlockStart ( sampleCount t ) const

Definition at line 1594 of file WaveTrack.cpp.

References Sequence::GetBlockStart(), WaveClip::GetNumSamples(), WaveClip::GetSequence(), WaveClip::GetStartTime(), mClips, and mRate.

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

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

inline

Definition at line 502 of file WaveTrack.h.

Referenced by TrackArtist::DrawWaveform().

502 { return mDisplayLocationsCache; }

WaveTrack::mDisplayLocationsCache

std::vector< Location > mDisplayLocationsCache

Definition: WaveTrack.h:632

int WaveTrack::GetChannel ( ) const

overridevirtual

Reimplemented from Track.

Definition at line 236 of file WaveTrack.cpp.

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

Referenced by AudioIO::AudioCallback(), WaveTrackMenuTable::InitMenu(), Mixer::Process(), and Effect::ProcessPass().

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

float WaveTrack::GetChannelGain ( int channel ) const

Definition at line 440 of file WaveTrack.cpp.

References mGain, and mPan.

Referenced by AudioIO::AudioCallback(), Mixer::MixSameRate(), Mixer::MixVariableRates(), and MixerTrackCluster::UpdateMeter().

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

WaveClip * WaveTrack::GetClipAtSample ( sampleCount sample )

Definition at line 2174 of file WaveTrack.cpp.

References WaveClip::GetNumSamples(), WaveClip::GetStartSample(), and mClips.

Referenced by AudacityProject::OnPunchAndRoll().

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

WaveClip * WaveTrack::GetClipAtTime ( double time )

Definition at line 2190 of file WaveTrack.cpp.

References WaveClip::GetEndTime(), WaveClip::GetStartTime(), and SortedClipArray().

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

WaveClip * WaveTrack::GetClipAtX ( int xcoord )

Definition at line 2161 of file WaveTrack.cpp.

References WaveClip::GetDisplayRect(), and mClips.

Referenced by SelectHandle::Click(), TimeShiftHandle::Click(), GetEnvelopeAtX(), and GetSequenceAtX().

 {
    for (const auto &clip: mClips)
    {
       wxRect r;
       clip->GetDisplayRect(&r);
       if (xcoord >= r.x && xcoord < r.x+r.width)
          return clip.get();
    }
 
    return NULL;
 }

WaveClip * WaveTrack::GetClipByIndex ( int index )

Definition at line 2277 of file WaveTrack.cpp.

References mClips.

Referenced by GetClipByIndex(), AudacityProject::GetTime(), MergeClips(), and Paste().

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

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

Definition at line 2285 of file WaveTrack.cpp.

References GetClipByIndex().

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

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

Definition at line 2270 of file WaveTrack.cpp.

References mClips.

Referenced by ClearAndPaste(), and UpdateLocationsCache().

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

WaveClipHolders& WaveTrack::GetClips ( )

inline

Definition at line 364 of file WaveTrack.h.

Referenced by AudacityProject::ChannelsHaveSameClipBoundaries(), TrackArtist::DrawSpectrum(), TrackArtist::DrawTrack(), TrackArtist::DrawWaveform(), EffectEqualization::ProcessOne(), EffectReverse::ProcessOneWave(), and AudacityProject::RedrawProject().

364 { return mClips; }

WaveTrack::mClips

WaveClipHolders mClips

Definition: WaveTrack.h:611

const WaveClipConstHolders& WaveTrack::GetClips ( ) const

inline

Definition at line 365 of file WaveTrack.h.

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

WaveTrack::mClips

WaveClipHolders mClips

Definition: WaveTrack.h:611

WaveClipConstHolders

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

Definition: WaveClip.h:123

std::shared_ptr< TrackControls > WaveTrack::GetControls ( )

overrideprotectedvirtual

Implements Track.

Definition at line 104 of file WaveTrackUI.cpp.

References Track::Pointer().

 {
    return std::make_shared<WaveTrackControls>( Pointer( this ) );
 }

WaveTrackDisplay WaveTrack::GetDisplay ( ) const

inline

Definition at line 593 of file WaveTrack.h.

Referenced by EnvelopeHandle::Click(), AudacityProject::DoNextPeakFrequency(), WaveTrackVZoomHandle::DoZoom(), TrackArtist::DrawTrack(), WaveTrackVRulerControls::HandleWheelRotation(), SampleHandle::HitTest(), WaveTrackMenuTable::InitMenu(), WaveTrackMenuTable::OnSetDisplay(), WaveTrackVZoomHandle::Release(), SpectrumPrefs::SpectrumPrefs(), and TrackArtist::UpdateVRuler().

593 { return mDisplay; }

WaveTrack::mDisplay

WaveTrackDisplay mDisplay

Definition: WaveTrack.h:629

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

Definition at line 325 of file WaveTrack.cpp.

References mDisplayMax, and mDisplayMin.

Referenced by EnvelopeHandle::Click(), WaveTrackVZoomHandle::DoZoom(), TrackArtist::DrawClipWaveform(), SampleHandle::HitTest(), and TrackArtist::UpdateVRuler().

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

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

References WaveClip::GetEndTime(), and mClips.

Referenced by EffectTruncSilence::Analyze(), Copy(), Effect::GetSamples(), AudacityProject::GetTime(), Mixer::MixSameRate(), Mixer::MixVariableRates(), AudacityProject::OnPunchAndRoll(), ControlToolBar::OnRecord(), Paste(), EffectStereoToMono::Process(), EffectFindClipping::Process(), EffectChangeSpeed::Process(), EffectNoiseReduction::Worker::Process(), EffectStereoToMono::ProcessOne(), NyquistEffect::ProcessOne(), SyncLockAdjust(), and Trim().

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

Envelope * WaveTrack::GetEnvelopeAtX ( int xcoord )

Definition at line 2211 of file WaveTrack.cpp.

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

Referenced by EnvelopeHandle::Click(), and SampleHandle::HitTest().

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

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

Definition at line 2095 of file WaveTrack.cpp.

References WaveClip::GetEndSample(), WaveClip::GetEndTime(), WaveClip::GetEnvelope(), WaveClip::GetStartSample(), WaveClip::GetStartTime(), Envelope::GetValues(), limitSampleBufferSize(), mClips, min(), and mRate.

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

 {
    // 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);
       }
    }
 }

bool WaveTrack::GetErrorOpening ( )

overridevirtual

Reimplemented from Track.

Definition at line 1809 of file WaveTrack.cpp.

References Sequence::GetErrorOpening(), WaveClip::GetSequence(), and mClips.

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

float WaveTrack::GetGain ( ) const

Definition at line 415 of file WaveTrack.cpp.

References mGain.

Referenced by TrackInfo::GainSlider(), and AudacityProject::WriteXML().

 {
    return mGain;
 }

size_t WaveTrack::GetIdealBlockSize ( )

Definition at line 1645 of file WaveTrack.cpp.

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

Referenced by NyquistEffect::GetCallback().

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

SpectrogramSettings & WaveTrack::GetIndependentSpectrogramSettings ( )

Definition at line 706 of file WaveTrack.cpp.

References SpectrogramSettings::defaults(), and mpSpectrumSettings.

Referenced by SpectrumVRulerMenuTable::OnSpectrumScaleType(), SpectrumPrefs::Preview(), SpectrumPrefs::Rollback(), and UseSpectralPrefs().

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

WaveformSettings & WaveTrack::GetIndependentWaveformSettings ( )

Definition at line 754 of file WaveTrack.cpp.

References WaveformSettings::defaults(), and mpWaveformSettings.

Referenced by WaveformPrefs::Commit(), WaveTrackMenuTable::OnSetDisplay(), WaveformVRulerMenuTable::OnWaveformScaleType(), and WaveTrack().

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

int WaveTrack::GetKind ( ) const

inlineoverridevirtual

Reimplemented from Track.

Definition at line 121 of file WaveTrack.h.

References Track::Wave.

Referenced by TimeShiftHandle::Click(), TimeShiftHandle::Drag(), WaveTrackMenuTable::InitMenu(), FormatMenuTable::OnFormatChange(), RateMenuTable::OnRateChange(), RateMenuTable::OnRateOther(), WaveTrackMenuTable::OnSetDisplay(), and WaveColorMenuTable::OnWaveColorChange().

121 { return Wave; }

Track::Wave

Definition: Track.h:250

int WaveTrack::GetLastdBRange ( ) const

inline

Definition at line 590 of file WaveTrack.h.

Referenced by TrackArtist::UpdateVRuler().

590 { return mLastdBRange; }

WaveTrack::mLastdBRange

int mLastdBRange

Definition: WaveTrack.h:631

int WaveTrack::GetLastScaleType ( ) const

inline

Definition at line 587 of file WaveTrack.h.

Referenced by TrackArtist::UpdateVRuler().

587 { return mLastScaleType; }

WaveTrack::mLastScaleType

int mLastScaleType

Definition: WaveTrack.h:630

size_t WaveTrack::GetMaxBlockSize ( ) const

Definition at line 1625 of file WaveTrack.cpp.

References Sequence::GetMaxBlockSize(), WaveClip::GetSequence(), mClips, Track::mDirManager, and mFormat.

 {
    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{ mDirManager, mFormat }.GetMaxBlockSize();
    }
 
    wxASSERT(maxblocksize > 0);
 
    return maxblocksize;
 }

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

Definition at line 1898 of file WaveTrack.cpp.

References WaveClip::GetEndTime(), WaveClip::GetMinMax(), WaveClip::GetStartTime(), mClips, and THROW_INCONSISTENCY_EXCEPTION.

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

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

int WaveTrack::GetNumClips ( ) const

Definition at line 2290 of file WaveTrack.cpp.

References mClips.

Referenced by AudacityProject::GetTime(), and Paste().

 {
    return mClips.size();
 }

unsigned int WaveTrack::GetODFlags ( ) const

gets an int with OD flags so that we can determine which ODTasks should be run on this track after save/open, etc.

Definition at line 1583 of file WaveTrack.cpp.

References Sequence::GetODFlags(), WaveClip::GetSequence(), and mClips.

Referenced by EffectNormalize::AnalyseTrack().

 {
    unsigned int ret = 0;
    for (const auto &clip : mClips)
    {
       ret = ret | clip->GetSequence()->GetODFlags();
    }
    return ret;
 }

double WaveTrack::GetOffset ( ) const

overridevirtual

Implements Track.

Definition at line 219 of file WaveTrack.cpp.

References GetStartTime().

Referenced by TranscriptionToolBar::GetSamples(), Reinit(), and SetOffset().

 {
    return GetStartTime();
 }

float WaveTrack::GetPan ( ) const

Definition at line 425 of file WaveTrack.cpp.

References mPan.

Referenced by GetChannel(), TrackList::GetNumExportChannels(), TrackInfo::PanSlider(), and AudacityProject::WriteXML().

 {
    return mPan;
 }

double WaveTrack::GetRate ( ) const

Definition at line 398 of file WaveTrack.cpp.

References mRate.

Referenced by SelectHandle::AdjustFreqSelection(), EffectNormalize::AnalyseTrack(), EffectTruncSilence::Analyze(), VoiceKey::CalibrateNoise(), ClearAndPaste(), Copy(), ODTask::DemandTrackUpdate(), Disjoin(), WaveTrackVZoomHandle::DoZoom(), TimeShiftHandle::Drag(), EffectTruncSilence::FindSilences(), FreqWindow::GetAudio(), TranscriptionToolBar::GetSamples(), GetSpectrumBounds(), AudacityProject::HandlePasteNothingSelected(), SampleHandle::HitTest(), EffectScienFilter::Init(), EffectEqualization::Init(), RateMenuTable::InitMenu(), Mixer::MixSameRate(), Mixer::MixVariableRates(), SelectHandle::MoveSnappingFreqSelection(), AudacityProject::NearestZeroCrossing(), VoiceKey::OffBackward(), VoiceKey::OffForward(), VoiceKey::OnBackward(), VoiceKey::OnForward(), AudacityProject::OnPunchAndRoll(), RateMenuTable::OnRateOther(), EffectEqualization::PopulateOrExchange(), EffectStereoToMono::Process(), Generator::Process(), Mixer::Process(), EffectNoiseReduction::Worker::Process(), EffectPaulstretch::ProcessOne(), EffectChangeSpeed::ProcessOne(), NyquistEffect::ProcessOne(), EffectEqualization::ProcessOne(), EffectNoiseReduction::Worker::ProcessOne(), Effect::ProcessPass(), Effect::ProcessTrack(), SelectHandle::SnapCenterOnce(), SelectHandle::StartSnappingFreqSelection(), TrackInfo::Status1DrawFunction(), and SyncLockAdjust().

 {
    return mRate;
 }

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

Definition at line 1937 of file WaveTrack.cpp.

References sampleCount::as_double(), WaveClip::GetEndTime(), WaveClip::GetRMS(), WaveClip::GetStartTime(), mClips, THROW_INCONSISTENCY_EXCEPTION, and WaveClip::TimeToSamplesClip().

Referenced by NyquistEffect::ProcessOne().

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

sampleFormat WaveTrack::GetSampleFormat ( ) const

inline

Definition at line 146 of file WaveTrack.h.

Referenced by Copy(), AudacityProject::HandlePasteNothingSelected(), FormatMenuTable::InitMenu(), FormatMenuTable::OnFormatChange(), Generator::Process(), EffectPaulstretch::ProcessOne(), EffectChangeSpeed::ProcessOne(), NyquistEffect::ProcessOne(), EffectNoiseReduction::Worker::ProcessOne(), Effect::ProcessTrack(), and SyncLockAdjust().

146 { return mFormat; }

WaveTrack::mFormat

sampleFormat mFormat

Definition: WaveTrack.h:613

Sequence * WaveTrack::GetSequenceAtX ( int xcoord )

Definition at line 2220 of file WaveTrack.cpp.

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

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

const SpectrogramSettings & WaveTrack::GetSpectrogramSettings ( ) const

Definition at line 690 of file WaveTrack.cpp.

References SpectrogramSettings::defaults(), and mpSpectrumSettings.

Referenced by WaveTrackVZoomHandle::DoZoom(), TrackArtist::DrawClipSpectrum(), WaveClip::GetSpectrogram(), GetSpectrumBounds(), SpectrumVRulerMenuTable::InitMenu(), SpectrumVRulerMenuTable::OnSpectrumScaleType(), NyquistEffect::ProcessOne(), SelectHandle::SnapCenterOnce(), SpectrumPrefs::SpectrumPrefs(), SelectHandle::StartSnappingFreqSelection(), and TrackArtist::UpdateVRuler().

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

SpectrogramSettings & WaveTrack::GetSpectrogramSettings ( )

Definition at line 698 of file WaveTrack.cpp.

References SpectrogramSettings::defaults(), and mpSpectrumSettings.

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

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

Definition at line 337 of file WaveTrack.cpp.

References SpectrogramSettings::GetFFTLength(), GetRate(), GetSpectrogramSettings(), SpectrogramSettings::maxFreq, min(), SpectrogramSettings::minFreq, mSpectrumMax, mSpectrumMin, SpectrogramSettings::scaleType, SpectrogramSettings::stLinear, and SpectrogramSettings::stPeriod.

Referenced by WaveTrackVZoomHandle::DoZoom(), TrackArtist::DrawClipSpectrum(), SpectrumPrefs::SpectrumPrefs(), and TrackArtist::UpdateVRuler().

 {
    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));
    }
 }

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

References WaveClip::GetStartTime(), and mClips.

Referenced by Copy(), GetOffset(), Effect::GetSamples(), Mixer::MixSameRate(), Mixer::MixVariableRates(), Paste(), EffectRepair::Process(), EffectStereoToMono::Process(), EffectFindClipping::Process(), EffectClickRemoval::Process(), EffectChangeSpeed::Process(), EffectEqualization::Process(), EffectNoiseReduction::Worker::Process(), EffectStereoToMono::ProcessOne(), NyquistEffect::ProcessOne(), and Trim().

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

std::shared_ptr< TrackVRulerControls > WaveTrack::GetVRulerControls ( )

overrideprotectedvirtual

Implements Track.

Definition at line 109 of file WaveTrackUI.cpp.

References Track::Pointer().

Referenced by DoSetMinimized().

 {
    return std::make_shared<WaveTrackVRulerControls>( Pointer( this ) );
 }

int WaveTrack::GetWaveColorIndex ( ) const

inline

Definition at line 143 of file WaveTrack.h.

Referenced by CreateClip(), WaveColorMenuTable::InitMenu(), InsertSilence(), and Effect::ProcessTrack().

143 { return mWaveColorIndex; };

WaveTrack::mWaveColorIndex

int mWaveColorIndex

Definition: WaveTrack.h:617

const WaveformSettings & WaveTrack::GetWaveformSettings ( ) const

Definition at line 738 of file WaveTrack.cpp.

References WaveformSettings::defaults(), and mpWaveformSettings.

Referenced by EnvelopeHandle::Click(), WaveTrackVZoomHandle::DoZoom(), TrackArtist::DrawClipWaveform(), TrackArtist::DrawWaveform(), SampleHandle::HitTest(), WaveformVRulerMenuTable::InitMenu(), WaveTrackMenuTable::InitMenu(), WaveTrackMenuTable::OnSetDisplay(), WaveformVRulerMenuTable::OnWaveformScaleType(), NyquistEffect::ProcessOne(), SetLastdBRange(), SetLastScaleType(), TrackArtist::UpdateVRuler(), and WaveformPrefs::WaveformPrefs().

 {
    if (mpWaveformSettings)
       return *mpWaveformSettings;
    else
       return WaveformSettings::defaults();
 }

WaveformSettings & WaveTrack::GetWaveformSettings ( )

Definition at line 746 of file WaveTrack.cpp.

References WaveformSettings::defaults(), and mpWaveformSettings.

 {
    if (mpWaveformSettings)
       return *mpWaveformSettings;
    else
       return WaveformSettings::defaults();
 }

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

Definition at line 1010 of file WaveTrack.cpp.

References WaveClip::AfterClip(), WaveClip::BeforeClip(), WaveClip::Clear(), AudacityPrefs::GetEditClipsCanMove(), WaveClip::GetEndTime(), WaveClip::GetStartTime(), gPrefs, mClips, Track::mDirManager, WaveClip::Offset(), and THROW_INCONSISTENCY_EXCEPTION.

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

 {
    if (t1 < t0)
       THROW_INCONSISTENCY_EXCEPTION;
 
    bool editClipCanMove = gPrefs->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, mDirManager, 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, mDirManager, 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, mDirManager, 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, mDirManager, true ) );
                   clipsToAdd.back()->Clear(t0, clip->GetEndTime());
 
                   // right
                   clipsToAdd.push_back
                      ( std::make_unique<WaveClip>( *clip, mDirManager, 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, mDirManager, 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 NOFAIL-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
 }

XMLTagHandler * WaveTrack::HandleXMLChild ( const wxChar * tag )

overridevirtual

Implements XMLTagHandler.

Definition at line 1745 of file WaveTrack.cpp.

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

 {
    //
    // 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;
 }

void WaveTrack::HandleXMLEndTag ( const wxChar * tag )

override

Definition at line 1738 of file WaveTrack.cpp.

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

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

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

overridevirtual

Implements XMLTagHandler.

Definition at line 1660 of file WaveTrack.cpp.

References Internat::CompatibleToDouble(), PlayableTrack::HandleXMLAttribute(), XMLValueChecker::IsGoodInt(), XMLValueChecker::IsGoodString(), XMLValueChecker::IsValidChannel(), lrint, mAutoSaveIdent, Track::mChannel, mGain, Track::mHeight, mLegacyProjectFileOffset, Track::mMinimized, Track::mName, mPan, mRate, mWaveColorIndex, Track::SetLinked(), and Track::SetSelected().

 {
    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 (!wxStrcmp(attr, wxT("height")) &&
                   XMLValueChecker::IsGoodInt(strValue) && strValue.ToLong(&nValue))
             mHeight = nValue;
          else if (!wxStrcmp(attr, wxT("minimized")) &&
                   XMLValueChecker::IsGoodInt(strValue) && strValue.ToLong(&nValue))
             mMinimized = (nValue != 0);
          else if (!wxStrcmp(attr, wxT("isSelected")) &&
                   XMLValueChecker::IsGoodInt(strValue) && strValue.ToLong(&nValue))
             this->SetSelected(nValue != 0);
          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("name")) && XMLValueChecker::IsGoodString(strValue))
             mName = strValue;
          else if (!wxStrcmp(attr, wxT("channel")))
          {
             if (!XMLValueChecker::IsGoodInt(strValue) || !strValue.ToLong(&nValue) ||
                   !XMLValueChecker::IsValidChannel(nValue))
                return false;
             mChannel = nValue;
          }
          else if (!wxStrcmp(attr, wxT("linked")) &&
                   XMLValueChecker::IsGoodInt(strValue) && strValue.ToLong(&nValue))
             SetLinked(nValue != 0);
          else if (!wxStrcmp(attr, wxT("autosaveid")) &&
                   XMLValueChecker::IsGoodInt(strValue) && strValue.ToLong(&nValue))
             mAutoSaveIdent = (int) nValue;
          else if (!wxStrcmp(attr, wxT("colorindex")) &&
                   XMLValueChecker::IsGoodString(strValue) &&
                   strValue.ToLong(&nValue))
             // Don't use SetWaveColorIndex as it sets the clips too.
             mWaveColorIndex  = nValue;
       } // while
       return true;
    }
 
    return false;
 }

void WaveTrack::Init ( const WaveTrack & orig )

private

Definition at line 148 of file WaveTrack.cpp.

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

Referenced by Copy(), Reinit(), and WaveTrack().

 {
    PlayableTrack::Init(orig);
    mFormat = orig.mFormat;
    mWaveColorIndex = orig.mWaveColorIndex;
    mRate = orig.mRate;
    mGain = orig.mGain;
    mPan = orig.mPan;
    SetDefaultName(orig.GetDefaultName());
    SetName(orig.GetName());
    mDisplay = orig.mDisplay;
    mDisplayMin = orig.mDisplayMin;
    mDisplayMax = orig.mDisplayMax;
    mSpectrumMin = orig.mSpectrumMin;
    mSpectrumMax = orig.mSpectrumMax;
    mDisplayLocationsCache.clear();
 }

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

override

Definition at line 1385 of file WaveTrack.cpp.

References WaveClip::BeforeClip(), GetWaveColorIndex(), WaveClip::InsertSilence(), mClips, Track::mDirManager, mFormat, mRate, WaveClip::Offset(), THROW_INCONSISTENCY_EXCEPTION, and WaveClip::WithinClip().

Referenced by EffectSilence::GenerateTrack(), and Effect::GetSamples().

 {
    // 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>(mDirManager, mFormat, mRate, this->GetWaveColorIndex());
       clip->InsertSilence(0, len);
       // use NOFAIL-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 NOFAIL-GUARANTEE
       for (const auto &clip : mClips)
       {
          if (clip->BeforeClip(t))
             clip->Offset(len);
       }
    }
 }

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

References mClips.

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

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

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

Definition at line 1503 of file WaveTrack.cpp.

References WaveClip::AppendSilence(), CreateClip(), WaveClip::GetEndTime(), WaveClip::GetEnvelope(), WaveClip::GetOffset(), WaveClip::GetStartTime(), Envelope::GetValue(), mClips, mRate, WaveClip::Paste(), and WaveClip::SetOffset().

Referenced by AudacityProject::OnJoinLabels(), and EffectEqualization::ProcessOne().

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

bool WaveTrack::Lock ( ) const

Definition at line 1818 of file WaveTrack.cpp.

References WaveClip::Lock(), and mClips.

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

double WaveTrack::LongSamplesToTime ( sampleCount pos ) const

Convert correctly between an 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 1848 of file WaveTrack.cpp.

References sampleCount::as_double(), and mRate.

Referenced by EffectTruncSilence::Analyze(), CompareAudioCommand::Apply(), EffectAutoDuck::ApplyDuckFade(), ClearAndPaste(), EffectTruncSilence::DoRemoval(), TrackArtist::DrawClipWaveform(), EffectTruncSilence::FindSilences(), AudacityProject::OnSplitNew(), EffectRepeat::Process(), EffectAutoDuck::Process(), EffectFindClipping::ProcessOne(), EffectEqualization::ProcessOne(), EffectReverse::ProcessOneWave(), and SplitAt().

 {
    return pos.as_double() / mRate;
 }

void WaveTrack::Merge ( const Track & orig )

overridevirtual

Reimplemented from PlayableTrack.

Definition at line 193 of file WaveTrack.cpp.

References Track::GetKind(), mDisplay, mDisplayMax, mDisplayMin, PlayableTrack::Merge(), mGain, mPan, mpSpectrumSettings, mpWaveformSettings, SetSpectrogramSettings(), SetWaveformSettings(), and Track::Wave.

Referenced by WaveTrackMenuTable::OnMergeStereo().

 {
    if (orig.GetKind() == Wave)
    {
       const WaveTrack &wt = static_cast<const WaveTrack&>(orig);
       mDisplay = wt.mDisplay;
       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);
 }

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

Definition at line 2533 of file WaveTrack.cpp.

References GetClipByIndex(), WaveClip::GetEndTime(), mClips, and WaveClip::Paste().

Referenced by ClearAndPaste().

 {
    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 NOFAIL-GUARANTEE for the rest
    // Delete second clip
    auto it = FindClip(mClips, clip2);
    mClips.erase(it);
 }

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

References CreateClip(), mClips, Track::mOffset, and WaveClip::SetOffset().

Referenced by GetIdealBlockSize(), HandleXMLChild(), RecordingRecoveryHandler::HandleXMLEndTag(), HandleXMLEndTag(), and RecordingRecoveryHandler::HandleXMLTag().

 {
    if (mClips.empty()) {
       WaveClip *clip = CreateClip();
       clip->SetOffset(mOffset);
       return clip;
    }
    else
       return mClips.back().get();
 }

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

override

Definition at line 1192 of file WaveTrack.cpp.

References _(), Cut(), GetClipByIndex(), AudacityPrefs::GetEditClipsCanMove(), GetEndTime(), WaveClip::GetEndTime(), WaveClip::GetIsPlaceholder(), Track::GetKind(), GetNumClips(), WaveClip::GetStartSample(), GetStartTime(), WaveClip::GetStartTime(), gPrefs, IsEmpty(), mClips, Track::mDirManager, mRate, WaveClip::Offset(), WaveClip::Paste(), TimeToLongSamples(), Track::Wave, and WaveClip::WithinClip().

Referenced by ClearAndPaste(), EffectRepeat::Process(), EffectStereoToMono::ProcessOne(), EffectPaulstretch::ProcessOne(), EffectEqualization::ProcessOne(), and SyncLockAdjust().

 {
    bool editClipCanMove = gPrefs->GetEditClipsCanMove();
    
    if( src == NULL )
       // THROW_INCONSISTENCY_EXCEPTION; // ?
       return;
 
    if (src->GetKind() != Track::Wave)
       // THROW_INCONSISTENCY_EXCEPTION; // ?
       return;
 
    const WaveTrack* other = static_cast<const WaveTrack*>(src);
 
    //
    // 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 splitted, when necessary. This may seem
    // strange at first, but it probably is better than trying to auto-merge
    // anything. The user can still merge the clips by hand (which should be a
    // simple command reachable by a hotkey or single mouse click).
    //
 
    if (other->GetNumClips() == 0)
       return;
 
    //wxPrintf("paste: we have at least one clip\n");
 
    bool singleClipMode = (other->GetNumClips() == 1 &&
          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;
 
    //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{
                      _("There is not enough room available to paste the selection")
                   };
             }
          }
 
          insideClip->Paste(t0, other->GetClipByIndex(0));
          return;
       }
 
       // Just fall through and exhibit NEW behaviour
    }
 
    // Insert NEW clips
    //wxPrintf("paste: multi clip mode!\n");
 
    if (!editClipCanMove && !IsEmpty(t0, t0+insertDuration-1.0/mRate))
       // STRONG-GUARANTEE in case of this path
       // not that it matters.
       throw SimpleMessageBoxException{
          _("There is not enough room available to paste the selection")
       };
 
    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, mDirManager, true );
          newClip->Resample(mRate);
          newClip->Offset(t0);
          newClip->MarkChanged();
          mClips.push_back(std::move(newClip)); // transfer ownership
       }
    }
 }

void WaveTrack::Reinit ( const WaveTrack & orig )

Definition at line 166 of file WaveTrack.cpp.

References GetOffset(), Init(), mpSpectrumSettings, mpWaveformSettings, and SetOffset().

Referenced by ControlToolBar::DoRecord().

 {
    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();
    }
 
    this->SetOffset(orig.GetOffset());
 
 #ifdef EXPERIMENTAL_OUTPUT_DISPLAY
    // To do:  mYv, mHeightV, mPerY, mVirtualStereo
 #endif
 }

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

Definition at line 990 of file WaveTrack.cpp.

References mClips.

Referenced by EffectReverse::ProcessOneWave().

 {
    // 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 {};
 }

bool WaveTrack::RemoveCutLine ( double cutLinePosition )

Definition at line 2524 of file WaveTrack.cpp.

References mClips, and WaveClip::RemoveCutLine().

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

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

Definition at line 2552 of file WaveTrack.cpp.

References mClips, mRate, and WaveClip::Resample().

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

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

Definition at line 2246 of file WaveTrack.cpp.

References CreateClip(), WaveClip::GetOffset(), mClips, Track::mOffset, and WaveClip::SetOffset().

Referenced by Append(), AppendAlias(), AppendCoded(), and Flush().

 {
    if (mClips.empty()) {
       WaveClip *clip = CreateClip();
       clip->SetOffset(mOffset);
       return clip;
    }
    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;
    }
 }

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

Definition at line 2052 of file WaveTrack.cpp.

References WaveClip::GetEndSample(), WaveClip::GetNumSamples(), WaveClip::GetStartSample(), WaveClip::MarkChanged(), mClips, min(), SAMPLE_SIZE, and WaveClip::SetSamples().

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

 {
    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 than len
             // samplesToCopy is positive and not more than len
          }
 
          clip->SetSamples(
                (samplePtr)(((char*)buffer) +
                            startDelta.as_size_t() *
                            SAMPLE_SIZE(format)),
                           format, inclipDelta, samplesToCopy.as_size_t() );
          clip->MarkChanged();
       }
    }
 }

void WaveTrack::SetAutoSaveIdent ( int id )

Definition at line 2605 of file WaveTrack.cpp.

References ident(), and mAutoSaveIdent.

Referenced by AudacityProject::WriteXML().

 {
    mAutoSaveIdent = ident;
 }

void WaveTrack::SetDisplay ( WaveTrackDisplay display )

inline

Definition at line 594 of file WaveTrack.h.

Referenced by WaveformPrefs::Commit(), WaveTrackMenuTable::OnSetDisplay(), SpectrumPrefs::Preview(), and SpectrumPrefs::Rollback().

594 { mDisplay = display; }

WaveTrack::mDisplay

WaveTrackDisplay mDisplay

Definition: WaveTrack.h:629

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

Definition at line 331 of file WaveTrack.cpp.

References mDisplayMax, mDisplayMin, and min().

Referenced by WaveTrackVZoomHandle::DoZoom(), and TrackArtist::UpdateVRuler().

 {
    mDisplayMin = min;
    mDisplayMax = max;
 }

void WaveTrack::SetGain ( float newGain )

Definition at line 420 of file WaveTrack.cpp.

References mGain.

Referenced by MixerTrackCluster::HandleSliderGain(), AudacityProject::SaveCopyWaveTracks(), AudacityProject::SetTrackGain(), and GainSliderHandle::SetValue().

 {
    mGain = newGain;
 }

void WaveTrack::SetLastdBRange ( ) const

Definition at line 320 of file WaveTrack.cpp.

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

Referenced by TrackArtist::UpdateVRuler().

 {
    mLastdBRange = GetWaveformSettings().dBRange;
 }

void WaveTrack::SetLastScaleType ( ) const

Definition at line 315 of file WaveTrack.cpp.

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

Referenced by WaveTrackMenuTable::OnSetDisplay(), and TrackArtist::UpdateVRuler().

 {
    mLastScaleType = GetWaveformSettings().scaleType;
 }

void WaveTrack::SetOffset ( double o )

overridevirtual

Reimplemented from Track.

Definition at line 224 of file WaveTrack.cpp.

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

Referenced by Reinit().

 {
    double delta = o - GetOffset();
 
    for (const auto &clip : mClips)
       // assume NOFAIL-GUARANTEE
       clip->SetOffset(clip->GetOffset() + delta);
 
    mOffset = o;
 }

void WaveTrack::SetPan ( float newPan )

overridevirtual

Reimplemented from Track.

Definition at line 430 of file WaveTrack.cpp.

References mPan.

Referenced by MixerTrackCluster::HandleSliderPan(), WaveTrackMenuTable::OnMergeStereo(), AudacityProject::OnPanTracks(), AudacityProject::SaveCopyWaveTracks(), SetPanFromChannelType(), AudacityProject::SetTrackPan(), and PanSliderHandle::SetValue().

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

void WaveTrack::SetPanFromChannelType ( )

overridevirtual

Reimplemented from Track.

Definition at line 248 of file WaveTrack.cpp.

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

Referenced by WaveTrackMenuTable::SplitStereo().

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

void WaveTrack::SetRate ( double newRate )

Definition at line 403 of file WaveTrack.cpp.

References mClips, and mRate.

Referenced by RateMenuTable::SetRate().

 {
    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 );
    }
 }

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

Definition at line 714 of file WaveTrack.cpp.

References mpSpectrumSettings.

Referenced by Merge(), SpectrumPrefs::Preview(), and SpectrumPrefs::Rollback().

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

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

Definition at line 381 of file WaveTrack.cpp.

References min(), mSpectrumMax, and mSpectrumMin.

Referenced by WaveTrackVZoomHandle::DoZoom(), SpectrumPrefs::Preview(), and SpectrumPrefs::Rollback().

 {
    mSpectrumMin = min;
    mSpectrumMax = max;
 }

void WaveTrack::SetWaveColorIndex ( int colorIndex )

Definition at line 477 of file WaveTrack.cpp.

References mClips, and mWaveColorIndex.

Referenced by SetTrackVisualsCommand::ApplyInner(), WaveColorMenuTable::OnWaveColorChange(), and NyquistEffect::ProcessOne().

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

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

Definition at line 761 of file WaveTrack.cpp.

References mpWaveformSettings.

Referenced by WaveformPrefs::Commit(), and Merge().

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

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

override

Definition at line 1351 of file WaveTrack.cpp.

References WaveClip::GetEndSample(), WaveClip::GetNumSamples(), WaveClip::GetSequence(), WaveClip::GetStartSample(), WaveClip::MarkChanged(), mClips, mRate, Sequence::SetSilence(), and THROW_INCONSISTENCY_EXCEPTION.

Referenced by AudacityProject::OnSilenceLabels().

 {
    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();
       }
    }
 }

WaveClipPointers WaveTrack::SortedClipArray ( )

Definition at line 2576 of file WaveTrack.cpp.

References mClips.

Referenced by SetClipCommand::ApplyInner(), SetEnvelopeCommand::ApplyInner(), ClearAndPaste(), AudacityProject::FindNextClip(), AudacityProject::FindNextClipBoundary(), AudacityProject::FindPrevClip(), AudacityProject::FindPrevClipBoundary(), GetClipAtTime(), NyquistEffect::ProcessOne(), EffectReverse::ProcessOneWave(), GetInfoCommand::SendClips(), GetInfoCommand::SendEnvelopes(), and UpdateLocationsCache().

 {
    return FillSortedClipArray<WaveClipPointers>(mClips);
 }

WaveClipConstPointers WaveTrack::SortedClipArray ( ) const

Definition at line 2581 of file WaveTrack.cpp.

References mClips.

 {
    return FillSortedClipArray<WaveClipConstPointers>(mClips);
 }

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

Definition at line 2375 of file WaveTrack.cpp.

References SplitAt().

Referenced by AudacityProject::OnSplit(), and AudacityProject::OnSplitLabels().

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

void WaveTrack::SplitAt ( double t )

Definition at line 2383 of file WaveTrack.cpp.

References sampleCount::as_double(), LongSamplesToTime(), mClips, Track::mDirManager, mRate, and TimeToLongSamples().

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

 {
    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, mDirManager, 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;
       }
    }
 }

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

Definition at line 529 of file WaveTrack.cpp.

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

Referenced by AudacityProject::OnSplitCutLabels().

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

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

Definition at line 947 of file WaveTrack.cpp.

References HandleClear().

Referenced by Disjoin(), AudacityProject::OnSplitDeleteLabels(), SplitCut(), and Trim().

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

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

overridevirtual

Reimplemented from Track.

Definition at line 1147 of file WaveTrack.cpp.

References Clear(), Cut(), GetActiveProject(), GetEndTime(), GetRate(), GetSampleFormat(), AudacityProject::GetTrackFactory(), gPrefs, IsEmpty(), TrackFactory::NewWaveTrack(), Paste(), and THROW_INCONSISTENCY_EXCEPTION.

 {
    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)
          AudacityProject *p = GetActiveProject();
          if (!p)
             THROW_INCONSISTENCY_EXCEPTION;
          TrackFactory *f = p->GetTrackFactory();
          if (!f)
             THROW_INCONSISTENCY_EXCEPTION;
          auto tmp = f->NewWaveTrack(GetSampleFormat(), GetRate());
 
          tmp->InsertSilence(0.0, newT1 - oldT1);
          tmp->Flush();
          Paste(oldT1, tmp.get());
       }
    }
    else if (newT1 < oldT1) {
       Clear(newT1, oldT1);
    }
 }

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

References mRate.

Referenced by EffectNormalize::AnalyseTrackData(), EffectTruncSilence::Analyze(), CompareAudioCommand::Apply(), EffectAutoDuck::ApplyDuckFade(), EffectTruncSilence::CalcPreviewInputLength(), ClearAndPaste(), Disjoin(), EffectTruncSilence::DoRemoval(), TrackArtist::DrawClipWaveform(), EffectTruncSilence::FindSilences(), BlockGenerator::GenerateTrack(), FreqWindow::GetAudio(), Effect::GetSamples(), Mixer::MixVariableRates(), AudacityProject::NearestZeroCrossing(), AudacityProject::OnPunchAndRoll(), Paste(), EffectReverse::Process(), EffectStereoToMono::Process(), EffectRepeat::Process(), EffectFindClipping::Process(), EffectAutoDuck::Process(), EffectChangeSpeed::Process(), EffectNoiseReduction::Worker::Process(), EffectPaulstretch::ProcessOne(), EffectNormalize::ProcessOne(), NyquistEffect::ProcessOne(), EffectReverse::ProcessOneWave(), Effect::ProcessPass(), SplitAt(), and SelectHandle::StartSnappingFreqSelection().

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

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

Definition at line 562 of file WaveTrack.cpp.

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

 {
    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);
 }

bool WaveTrack::Unlock ( ) const

Definition at line 1835 of file WaveTrack.cpp.

References mClips, and WaveClip::Unlock().

Referenced by WaveTrack::WaveTrackLockDeleter::operator()().

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

void WaveTrack::UpdateLocationsCache ( ) const

Definition at line 2406 of file WaveTrack.cpp.

References GetClipIndex(), WaveClip::GetCutLines(), WaveClip::GetEndTime(), WaveClip::GetOffset(), WaveClip::GetStartTime(), WaveTrackLocation::locationCutLine, WaveTrackLocation::locationMergePoint, mDisplayLocationsCache, WaveClip::NumCutLines(), SortedClipArray(), and WAVETRACK_MERGE_POINT_TOLERANCE.

Referenced by TrackArtist::DrawWaveform().

 {
    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);
 }

void WaveTrack::UseSpectralPrefs ( bool bUse = true )

Definition at line 721 of file WaveTrack.cpp.

References GetIndependentSpectrogramSettings(), and mpSpectrumSettings.

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

WaveTrack::WaveTrackDisplay WaveTrack::ValidateWaveTrackDisplay ( WaveTrackDisplay display )

static

Definition at line 293 of file WaveTrack.cpp.

References MinDisplay, obsolete1, obsolete2, obsolete3, obsolete4, obsoleteWaveformDBDisplay, Spectrum, and Waveform.

Referenced by TracksViewModeSetting::Migrate().

 {
    switch (display) {
       // non-obsolete codes
    case Waveform:
    case obsoleteWaveformDBDisplay:
    case Spectrum:
       return display;
 
       // obsolete codes
    case obsolete1: // was SpectrumLogDisplay
    case obsolete2: // was SpectralSelectionDisplay
    case obsolete3: // was SpectralSelectionLogDisplay
    case obsolete4: // was PitchDisplay
       return Spectrum;
 
       // codes out of bounds (from future prefs files?)
    default:
       return MinDisplay;
    }
 }

void WaveTrack::WriteXML ( XMLWriter & xmlFile ) const

overridevirtual

Implements Track.

Definition at line 1781 of file WaveTrack.cpp.

References WaveClip::WriteXML(), and PlayableTrack::WriteXMLAttributes().

 {
    xmlFile.StartTag(wxT("wavetrack"));
    if (mAutoSaveIdent)
    {
       xmlFile.WriteAttr(wxT("autosaveid"), mAutoSaveIdent);
    }
    xmlFile.WriteAttr(wxT("name"), mName);
    xmlFile.WriteAttr(wxT("channel"), mChannel);
    xmlFile.WriteAttr(wxT("linked"), mLinked);
    this->PlayableTrack::WriteXMLAttributes(xmlFile);
    xmlFile.WriteAttr(wxT("height"), this->GetActualHeight());
    xmlFile.WriteAttr(wxT("minimized"), this->GetMinimized());
    xmlFile.WriteAttr(wxT("isSelected"), this->GetSelected());
    xmlFile.WriteAttr(wxT("rate"), mRate);
    xmlFile.WriteAttr(wxT("gain"), (double)mGain);
    xmlFile.WriteAttr(wxT("pan"), (double)mPan);
    xmlFile.WriteAttr(wxT("colorindex"), mWaveColorIndex );
 
    for (const auto &clip : mClips)
    {
       clip->WriteXML(xmlFile);
    }
 
    xmlFile.EndTag(wxT("wavetrack"));
 }

int WaveTrack::ZeroLevelYCoordinate ( wxRect rect ) const

Definition at line 387 of file WaveTrack.cpp.

References mDisplayMax, and mDisplayMin.

Referenced by TrackArtist::DrawClipWaveform().

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

Friends And Related Function Documentation

friend class TrackFactory

friend

Definition at line 85 of file WaveTrack.h.

Member Data Documentation

wxCriticalSection WaveTrack::mAppendCriticalSection

private

Definition at line 645 of file WaveTrack.h.

int WaveTrack::mAutoSaveIdent

private

Definition at line 647 of file WaveTrack.h.

Referenced by GetAutoSaveIdent(), HandleXMLTag(), SetAutoSaveIdent(), and WaveTrack().

WaveClipHolders WaveTrack::mClips

protected

std::weak_ptr<CutlineHandle> WaveTrack::mCutlineHandle

private

Definition at line 652 of file WaveTrack.h.

WaveTrackDisplay WaveTrack::mDisplay

protected

Definition at line 629 of file WaveTrack.h.

Referenced by Init(), Merge(), and WaveTrack().

std::vector<Location> WaveTrack::mDisplayLocationsCache

mutableprotected

Definition at line 632 of file WaveTrack.h.

Referenced by Init(), and UpdateLocationsCache().

float WaveTrack::mDisplayMax

mutableprotected

Definition at line 625 of file WaveTrack.h.

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

float WaveTrack::mDisplayMin

mutableprotected

Definition at line 624 of file WaveTrack.h.

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

std::weak_ptr<EnvelopeHandle> WaveTrack::mEnvelopeHandle

private

Definition at line 654 of file WaveTrack.h.

wxCriticalSection WaveTrack::mFlushCriticalSection

private

Definition at line 644 of file WaveTrack.h.

sampleFormat WaveTrack::mFormat

protected

Definition at line 613 of file WaveTrack.h.

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

float WaveTrack::mGain

protected

Definition at line 615 of file WaveTrack.h.

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

int WaveTrack::mLastdBRange

mutableprotected

Definition at line 631 of file WaveTrack.h.

Referenced by SetLastdBRange(), and WaveTrack().

int WaveTrack::mLastScaleType

mutableprotected

Definition at line 630 of file WaveTrack.h.

Referenced by SetLastScaleType(), and WaveTrack().

double WaveTrack::mLegacyProjectFileOffset

private

Definition at line 646 of file WaveTrack.h.

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

float WaveTrack::mPan

protected

Definition at line 616 of file WaveTrack.h.

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

std::unique_ptr<SpectrogramSettings> WaveTrack::mpSpectrumSettings

private

Definition at line 649 of file WaveTrack.h.

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

std::unique_ptr<WaveformSettings> WaveTrack::mpWaveformSettings

private

Definition at line 650 of file WaveTrack.h.

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

int WaveTrack::mRate

protected

Definition at line 614 of file WaveTrack.h.

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

std::weak_ptr<SampleHandle> WaveTrack::mSampleHandle

private

Definition at line 653 of file WaveTrack.h.

float WaveTrack::mSpectrumMax

mutableprotected

Definition at line 627 of file WaveTrack.h.

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

float WaveTrack::mSpectrumMin

mutableprotected

Definition at line 626 of file WaveTrack.h.

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

int WaveTrack::mWaveColorIndex

protected

Definition at line 617 of file WaveTrack.h.

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

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

Classes

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation