This allows multiple clips to be a part of one WaveTrack. More...

#include <WaveClip.h>

Inheritance diagram for WaveClip:

Collaboration diagram for WaveClip:

Public Member Functions
	WaveClip (const SampleBlockFactoryPtr &factory, sampleFormat format, int rate, int colourIndex)

	WaveClip (const WaveClip &orig, const SampleBlockFactoryPtr &factory, bool copyCutlines)

	WaveClip (const WaveClip &orig, const SampleBlockFactoryPtr &factory, bool copyCutlines, double t0, double t1)

virtual	~WaveClip ()

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

void	TimeToSamplesClip (double t0, sampleCount *s0) const

int	GetRate () const

void	SetRate (int rate)

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

void	SetColourIndex (int index)

int	GetColourIndex () const

void	SetOffset (double offset)

double	GetOffset () const

void	Offset (double delta)

double	GetStartTime () const

double	GetEndTime () const

sampleCount	GetStartSample () const

sampleCount	GetEndSample () const

sampleCount	GetNumSamples () const

bool	WithinClip (double t) const

bool	BeforeClip (double t) const

bool	AfterClip (double t) const

bool	IsClipStartAfterClip (double t) const

bool	GetSamples (samplePtr buffer, sampleFormat format, sampleCount start, size_t len, bool mayThrow=true) const

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

Envelope *	GetEnvelope ()

const Envelope *	GetEnvelope () const

BlockArray *	GetSequenceBlockArray ()

const BlockArray *	GetSequenceBlockArray () const

Sequence *	GetSequence ()

const Sequence *	GetSequence () const

void	MarkChanged ()

bool	GetWaveDisplay (WaveDisplay &display, double t0, double pixelsPerSecond) const

bool	GetSpectrogram (WaveTrackCache &cache, const float &spectrogram, const sampleCount &where, size_t numPixels, double t0, double pixelsPerSecond) const

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

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

void	UpdateEnvelopeTrackLen ()

std::shared_ptr< SampleBlock >	AppendNewBlock (samplePtr buffer, sampleFormat format, size_t len)
	For use in importing pre-version-3 projects to preserve sharing of blocks. More...

void	AppendSharedBlock (const std::shared_ptr< SampleBlock > &pBlock)
	For use in importing pre-version-3 projects to preserve sharing of blocks. More...

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

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

void	Clear (double t0, double t1)

void	ClearAndAddCutLine (double t0, double t1)
	Clear, and add cut line that starts at t0 and contains everything until t1. More...

void	Paste (double t0, const WaveClip *other)
	Paste data from other clip, resampling it if not equal rate. More...

void	InsertSilence (double t, double len, double *pEnvelopeValue=nullptr)

void	AppendSilence (double len, double envelopeValue)

WaveClipHolders &	GetCutLines ()
	Get access to cut lines list. More...

const WaveClipConstHolders &	GetCutLines () const

size_t	NumCutLines () const

bool	FindCutLine (double cutLinePosition, double cutLineStart=NULL, double cutLineEnd=NULL) const

void	ExpandCutLine (double cutLinePosition)

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

void	OffsetCutLines (double t0, double len)
	Offset cutlines right to time 't0' by time amount 'len'. More...

void	CloseLock ()

void	ClearWaveCache ()
	Delete the wave cache - force redraw. Thread-safe. More...

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

bool	GetIsPlaceholder () const

void	SetIsPlaceholder (bool val)

bool	SharesBoundaryWithNextClip (const WaveClip *next) const

void	SetName (const wxString &name)

const wxString &	GetName () const

Public Member Functions inherited from XMLTagHandler
	XMLTagHandler ()

virtual	~XMLTagHandler ()

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

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

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

void	ReadXMLEndTag (const char *tag)

void	ReadXMLContent (const char *s, int len)

XMLTagHandler *	ReadXMLChild (const char *tag)

Public Attributes
std::unique_ptr< SpecPxCache >	mSpecPxCache

Protected Attributes
double	mOffset { 0 }

int	mRate

int	mDirty { 0 }

int	mColourIndex

std::unique_ptr< Sequence >	mSequence

std::unique_ptr< Envelope >	mEnvelope

std::unique_ptr< WaveCache >	mWaveCache

std::unique_ptr< SpecCache >	mSpecCache

SampleBuffer	mAppendBuffer {}

size_t	mAppendBufferLen { 0 }

WaveClipHolders	mCutLines {}

bool	mIsPlaceholder { false }

Private Member Functions
	WaveClip (const WaveClip &) PROHIBITED

WaveClip &	operator= (const WaveClip &) PROHIBITED

Private Attributes
wxString	mName

Detailed Description

This allows multiple clips to be a part of one WaveTrack.

Definition at line 172 of file WaveClip.h.

Constructor & Destructor Documentation

◆ WaveClip() [1/4]

WaveClip::WaveClip ( const WaveClip & )

private

◆ WaveClip() [2/4]

WaveClip::WaveClip	(	const SampleBlockFactoryPtr &	factory,
		sampleFormat	format,
		int	rate,
		int	colourIndex
	)

Definition at line 121 of file WaveClip.cpp.

 {
    mRate = rate;
    mColourIndex = colourIndex;
    mSequence = std::make_unique<Sequence>(factory, format);
  
    mEnvelope = std::make_unique<Envelope>(true, 1e-7, 2.0, 1.0);
  
    mWaveCache = std::make_unique<WaveCache>();
    mSpecCache = std::make_unique<SpecCache>();
    mSpecPxCache = std::make_unique<SpecPxCache>(1);
 }

References factory, format, mColourIndex, mEnvelope, mRate, mSequence, mSpecCache, mSpecPxCache, and mWaveCache.

◆ WaveClip() [3/4]

WaveClip::WaveClip	(	const WaveClip &	orig,
		const SampleBlockFactoryPtr &	factory,
		bool	copyCutlines
	)

Definition at line 135 of file WaveClip.cpp.

 {
    // essentially a copy constructor - but you must pass in the
    // current sample block factory, because we might be copying
    // from one project to another
  
    mOffset = orig.mOffset;
    mRate = orig.mRate;
    mColourIndex = orig.mColourIndex;
    mSequence = std::make_unique<Sequence>(*orig.mSequence, factory);
  
    mEnvelope = std::make_unique<Envelope>(*orig.mEnvelope);
  
    mWaveCache = std::make_unique<WaveCache>();
    mSpecCache = std::make_unique<SpecCache>();
    mSpecPxCache = std::make_unique<SpecPxCache>(1);
  
    mName = orig.mName;
  
    if ( copyCutlines )
       for (const auto &clip: orig.mCutLines)
          mCutLines.push_back
             ( std::make_unique<WaveClip>( *clip, factory, true ) );
  
    mIsPlaceholder = orig.GetIsPlaceholder();
 }

References factory, GetIsPlaceholder(), mColourIndex, mCutLines, mEnvelope, mIsPlaceholder, mName, mOffset, mRate, mSequence, mSpecCache, mSpecPxCache, and mWaveCache.

Here is the call graph for this function:

◆ WaveClip() [4/4]

WaveClip::WaveClip	(	const WaveClip &	orig,
		const SampleBlockFactoryPtr &	factory,
		bool	copyCutlines,
		double	t0,
		double	t1
	)

Definition at line 164 of file WaveClip.cpp.

 {
    // Copy only a range of the other WaveClip
  
    mOffset = orig.mOffset;
    mRate = orig.mRate;
    mColourIndex = orig.mColourIndex;
  
    mWaveCache = std::make_unique<WaveCache>();
    mSpecCache = std::make_unique<SpecCache>();
    mSpecPxCache = std::make_unique<SpecPxCache>(1);
  
    mIsPlaceholder = orig.GetIsPlaceholder();
  
    sampleCount s0, s1;
  
    orig.TimeToSamplesClip(t0, &s0);
    orig.TimeToSamplesClip(t1, &s1);
  
    mSequence = orig.mSequence->Copy(factory, s0, s1);
  
    mEnvelope = std::make_unique<Envelope>(
       *orig.mEnvelope,
       mOffset + s0.as_double()/mRate,
       mOffset + s1.as_double()/mRate
    );
  
    if ( copyCutlines )
       // Copy cutline clips that fall in the range
       for (const auto &ppClip : orig.mCutLines)
       {
          const WaveClip* clip = ppClip.get();
          double cutlinePosition = orig.mOffset + clip->GetOffset();
          if (cutlinePosition >= t0 && cutlinePosition <= t1)
          {
             auto newCutLine =
                std::make_unique< WaveClip >( *clip, factory, true );
             newCutLine->SetOffset( cutlinePosition - t0 );
             mCutLines.push_back(std::move(newCutLine));
          }
       }
 }

References sampleCount::as_double(), factory, GetIsPlaceholder(), GetOffset(), mColourIndex, mCutLines, mEnvelope, mIsPlaceholder, mOffset, mRate, mSequence, mSpecCache, mSpecPxCache, mWaveCache, and TimeToSamplesClip().

Here is the call graph for this function:

◆ ~WaveClip()

WaveClip::~WaveClip ( )

virtual

Definition at line 211 of file WaveClip.cpp.

212 {

213 }

Member Function Documentation

◆ AfterClip()

bool WaveClip::AfterClip ( double t ) const

Definition at line 298 of file WaveClip.cpp.

 {
    auto ts = (sampleCount)floor(t * mRate + 0.5);
    return ts >= GetEndSample() + mAppendBufferLen;
 }

References GetEndSample(), mAppendBufferLen, and mRate.

Here is the call graph for this function:

◆ Append()

bool WaveClip::Append	(	constSamplePtr	buffer,
		sampleFormat	format,
		size_t	len,
		unsigned int	stride
	)

You must call Flush after the last Append

Returns: true if at least one complete block was created

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

Definition at line 1208 of file WaveClip.cpp.

 {
    //wxLogDebug(wxT("Append: len=%lli"), (long long) len);
    bool result = false;
  
    auto maxBlockSize = mSequence->GetMaxBlockSize();
    auto blockSize = mSequence->GetIdealAppendLen();
    sampleFormat seqFormat = mSequence->GetSampleFormat();
  
    if (!mAppendBuffer.ptr())
       mAppendBuffer.Allocate(maxBlockSize, seqFormat);
  
    auto cleanup = finally( [&] {
       // use No-fail-guarantee
       UpdateEnvelopeTrackLen();
       MarkChanged();
    } );
  
    for(;;) {
       if (mAppendBufferLen >= blockSize) {
          // flush some previously appended contents
          // use Strong-guarantee
          mSequence->Append(mAppendBuffer.ptr(), seqFormat, blockSize);
          result = true;
  
          // use No-fail-guarantee for rest of this "if"
          memmove(mAppendBuffer.ptr(),
                  mAppendBuffer.ptr() + blockSize * SAMPLE_SIZE(seqFormat),
                  (mAppendBufferLen - blockSize) * SAMPLE_SIZE(seqFormat));
          mAppendBufferLen -= blockSize;
          blockSize = mSequence->GetIdealAppendLen();
       }
  
       if (len == 0)
          break;
  
       // use No-fail-guarantee for rest of this "for"
       wxASSERT(mAppendBufferLen <= maxBlockSize);
       auto toCopy = std::min(len, maxBlockSize - mAppendBufferLen);
  
       CopySamples(buffer, format,
                   mAppendBuffer.ptr() + mAppendBufferLen * SAMPLE_SIZE(seqFormat),
                   seqFormat,
                   toCopy,
                   gHighQualityDither,
                   stride);
  
       mAppendBufferLen += toCopy;
       buffer += toCopy * SAMPLE_SIZE(format) * stride;
       len -= toCopy;
    }
  
    return result;
 }

References SampleBuffer::Allocate(), CopySamples(), format, gHighQualityDither, mAppendBuffer, mAppendBufferLen, MarkChanged(), min(), mSequence, SampleBuffer::ptr(), SAMPLE_SIZE, and UpdateEnvelopeTrackLen().

Referenced by WaveTrack::Append().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AppendNewBlock()

std::shared_ptr< SampleBlock > WaveClip::AppendNewBlock	(	samplePtr	buffer,
		sampleFormat	format,
		size_t	len
	)

For use in importing pre-version-3 projects to preserve sharing of blocks.

Exception safety guarantee:: Strong

Definition at line 1193 of file WaveClip.cpp.

 {
    return mSequence->AppendNewBlock( buffer, format, len );
 }

References format, and mSequence.

◆ AppendSharedBlock()

void WaveClip::AppendSharedBlock ( const std::shared_ptr< SampleBlock > & pBlock )

For use in importing pre-version-3 projects to preserve sharing of blocks.

Exception safety guarantee:: Strong

Definition at line 1200 of file WaveClip.cpp.

 {
    mSequence->AppendSharedBlock( pBlock );
 }

References mSequence.

◆ AppendSilence()

void WaveClip::AppendSilence	(	double	len,
		double	envelopeValue
	)

Insert silence at the end, and causes the envelope to ramp linearly to the given value

Exception safety guarantee:: Strong

Definition at line 1467 of file WaveClip.cpp.

 {
    auto t = GetEndTime();
    InsertSilence( t, len, &envelopeValue );
 }

References GetEndTime(), and InsertSilence().

Here is the call graph for this function:

◆ BeforeClip()

bool WaveClip::BeforeClip ( double t ) const

Definition at line 292 of file WaveClip.cpp.

 {
    auto ts = (sampleCount)floor(t * mRate + 0.5);
    return ts <= GetStartSample();
 }

References GetStartSample(), and mRate.

Here is the call graph for this function:

◆ Clear()

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

This name is consistent with WaveTrack::Clear. It performs a "Cut" operation (but without putting the cut audio to the clipboard)

Exception safety guarantee:: Strong

Definition at line 1474 of file WaveClip.cpp.

 {
    sampleCount s0, s1;
  
    TimeToSamplesClip(t0, &s0);
    TimeToSamplesClip(t1, &s1);
  
    // use Strong-guarantee
    GetSequence()->Delete(s0, s1-s0);
  
    // use No-fail-guarantee in the remaining
  
    // msmeyer
    //
    // Delete all cutlines that are within the given area, if any.
    //
    // Note that when cutlines are active, two functions are used:
    // Clear() and ClearAndAddCutLine(). ClearAndAddCutLine() is called
    // whenever the user directly calls a command that removes some audio, e.g.
    // "Cut" or "Clear" from the menu. This command takes care about recursive
    // preserving of cutlines within clips. Clear() is called when internal
    // operations want to remove audio. In the latter case, it is the right
    // thing to just remove all cutlines within the area.
    //
    double clip_t0 = t0;
    double clip_t1 = t1;
    if (clip_t0 < GetStartTime())
       clip_t0 = GetStartTime();
    if (clip_t1 > GetEndTime())
       clip_t1 = GetEndTime();
  
    // May DELETE as we iterate, so don't use range-for
    for (auto it = mCutLines.begin(); it != mCutLines.end();)
    {
       WaveClip* clip = it->get();
       double cutlinePosition = mOffset + clip->GetOffset();
       if (cutlinePosition >= t0 && cutlinePosition <= t1)
       {
          // This cutline is within the area, DELETE it
          it = mCutLines.erase(it);
       }
       else
       {
          if (cutlinePosition >= t1)
          {
             clip->Offset(clip_t0 - clip_t1);
          }
          ++it;
       }
    }
  
    // Collapse envelope
    auto sampleTime = 1.0 / GetRate();
    GetEnvelope()->CollapseRegion( t0, t1, sampleTime );
    if (t0 < GetStartTime())
       Offset(-(GetStartTime() - t0));
  
    MarkChanged();
 }

References Envelope::CollapseRegion(), Sequence::Delete(), GetEndTime(), GetEnvelope(), GetOffset(), GetRate(), GetSequence(), GetStartTime(), MarkChanged(), mCutLines, mOffset, Offset(), and TimeToSamplesClip().

Here is the call graph for this function:

◆ ClearAndAddCutLine()

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

Clear, and add cut line that starts at t0 and contains everything until t1.

Exception safety guarantee:: Weak – This WaveClip remains destructible in case of AudacityException. But some cutlines may be deleted

Definition at line 1537 of file WaveClip.cpp.

 {
    if (t0 > GetEndTime() || t1 < GetStartTime())
       return; // time out of bounds
  
    const double clip_t0 = std::max( t0, GetStartTime() );
    const double clip_t1 = std::min( t1, GetEndTime() );
  
    auto newClip = std::make_unique< WaveClip >
       (*this, mSequence->GetFactory(), true, clip_t0, clip_t1);
  
    newClip->SetOffset( clip_t0 - mOffset );
  
    // Remove cutlines from this clip that were in the selection, shift
    // left those that were after the selection
    // May DELETE as we iterate, so don't use range-for
    for (auto it = mCutLines.begin(); it != mCutLines.end();)
    {
       WaveClip* clip = it->get();
       double cutlinePosition = mOffset + clip->GetOffset();
       if (cutlinePosition >= t0 && cutlinePosition <= t1)
          it = mCutLines.erase(it);
       else
       {
          if (cutlinePosition >= t1)
          {
             clip->Offset(clip_t0 - clip_t1);
          }
          ++it;
       }
    }
  
    // Clear actual audio data
    sampleCount s0, s1;
  
    TimeToSamplesClip(t0, &s0);
    TimeToSamplesClip(t1, &s1);
  
    // use Weak-guarantee
    GetSequence()->Delete(s0, s1-s0);
  
    // Collapse envelope
    auto sampleTime = 1.0 / GetRate();
    GetEnvelope()->CollapseRegion( t0, t1, sampleTime );
    if (t0 < GetStartTime())
       Offset(-(GetStartTime() - t0));
  
    MarkChanged();
  
    mCutLines.push_back(std::move(newClip));
 }

References Envelope::CollapseRegion(), Sequence::Delete(), GetEndTime(), GetEnvelope(), GetOffset(), GetRate(), GetSequence(), GetStartTime(), MarkChanged(), mCutLines, min(), mOffset, mSequence, Offset(), and TimeToSamplesClip().

Here is the call graph for this function:

◆ ClearWaveCache()

void WaveClip::ClearWaveCache ( )

Delete the wave cache - force redraw. Thread-safe.

Definition at line 315 of file WaveClip.cpp.

 {
    mWaveCache = std::make_unique<WaveCache>();
 }

References mWaveCache.

◆ CloseLock()

void WaveClip::CloseLock ( )

Definition at line 1666 of file WaveClip.cpp.

 {
    GetSequence()->CloseLock();
    for (const auto &cutline: mCutLines)
       cutline->CloseLock();
 }

References Sequence::CloseLock(), GetSequence(), and mCutLines.

Here is the call graph for this function:

◆ ConvertToSampleFormat()

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

Definition at line 1163 of file WaveClip.cpp.

 {
    // Note:  it is not necessary to do this recursively to cutlines.
    // They get converted as needed when they are expanded.
  
    auto bChanged = mSequence->ConvertToSampleFormat(format, progressReport);
    if (bChanged)
       MarkChanged();
 }

References format, MarkChanged(), and mSequence.

Referenced by Paste().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExpandCutLine()

void WaveClip::ExpandCutLine ( double cutLinePosition )

Expand cut line (that is, re-insert audio, then DELETE audio saved in cut line). Returns true if a cut line could be found and successfully expanded, false otherwise

Exception safety guarantee:: Strong

Definition at line 1609 of file WaveClip.cpp.

 {
    auto end = mCutLines.end();
    auto it = std::find_if( mCutLines.begin(), end,
       [&](const WaveClipHolder &cutline) {
          return fabs(mOffset + cutline->GetOffset() - cutLinePosition) < 0.0001;
       } );
  
    if ( it != end ) {
       auto cutline = it->get();
       // assume Strong-guarantee from Paste
  
       // Envelope::Paste takes offset into account, WaveClip::Paste doesn't!
       // Do this to get the right result:
       cutline->mEnvelope->SetOffset(0);
  
       Paste(mOffset+cutline->GetOffset(), cutline);
       // Now erase the cutline,
       // but be careful to find it again, because Paste above may
       // have modified the array of cutlines (if our cutline contained
       // another cutline!), invalidating the iterator we had.
       end = mCutLines.end();
       it = std::find_if(mCutLines.begin(), end,
          [=](const WaveClipHolder &p) { return p.get() == cutline; });
       if (it != end)
          mCutLines.erase(it); // deletes cutline!
       else {
          wxASSERT(false);
       }
    }
 }

References mCutLines, mOffset, and Paste().

Here is the call graph for this function:

◆ FindCutLine()

bool WaveClip::FindCutLine	(	double	cutLinePosition,
		double *	cutLineStart = `NULL`,
		double *	cutLineEnd = `NULL`
	)		const

Find cut line at (approximately) this position. Returns true and fills in cutLineStart and cutLineEnd (if specified) if a cut line at this position could be found. Return false otherwise.

Definition at line 1589 of file WaveClip.cpp.

 {
    for (const auto &cutline: mCutLines)
    {
       if (fabs(mOffset + cutline->GetOffset() - cutLinePosition) < 0.0001)
       {
          if (cutlineStart)
             *cutlineStart = mOffset+cutline->GetStartTime();
          if (cutlineEnd)
             *cutlineEnd = mOffset+cutline->GetEndTime();
          return true;
       }
    }
  
    return false;
 }

References mCutLines, and mOffset.

◆ Flush()

void WaveClip::Flush ( )

Flush must be called after last Append.

Exception safety guarantee:: Mixed

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

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

Definition at line 1269 of file WaveClip.cpp.

 {
    //wxLogDebug(wxT("WaveClip::Flush"));
    //wxLogDebug(wxT("   mAppendBufferLen=%lli"), (long long) mAppendBufferLen);
    //wxLogDebug(wxT("   previous sample count %lli"), (long long) mSequence->GetNumSamples());
  
    if (mAppendBufferLen > 0) {
  
       auto cleanup = finally( [&] {
          // Blow away the append buffer even in case of failure.  May lose some
          // data but don't leave the track in an un-flushed state.
  
          // Use No-fail-guarantee of these steps.
          mAppendBufferLen = 0;
          UpdateEnvelopeTrackLen();
          MarkChanged();
       } );
  
       mSequence->Append(mAppendBuffer.ptr(), mSequence->GetSampleFormat(),
          mAppendBufferLen);
    }
  
    //wxLogDebug(wxT("now sample count %lli"), (long long) mSequence->GetNumSamples());
 }

References mAppendBuffer, mAppendBufferLen, MarkChanged(), mSequence, SampleBuffer::ptr(), and UpdateEnvelopeTrackLen().

Referenced by WaveTrack::Flush().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetColourIndex()

int WaveClip::GetColourIndex ( ) const

inline

Definition at line 218 of file WaveClip.h.

218 { return mColourIndex;};

Referenced by anonymous_namespace{WaveformView.cpp}::DrawClipWaveform().

Here is the caller graph for this function:

◆ GetCutLines() [1/2]

WaveClipHolders& WaveClip::GetCutLines ( )

inline

Get access to cut lines list.

Definition at line 312 of file WaveClip.h.

312 { return mCutLines; }

◆ GetCutLines() [2/2]

const WaveClipConstHolders& WaveClip::GetCutLines ( ) const

inline

Definition at line 313 of file WaveClip.h.

314 { return reinterpret_cast< const WaveClipConstHolders& >( mCutLines ); }

◆ GetEndSample()

sampleCount WaveClip::GetEndSample ( ) const

Definition at line 271 of file WaveClip.cpp.

 {
    return GetStartSample() + mSequence->GetNumSamples();
 }

References GetStartSample(), and mSequence.

Referenced by AfterClip(), IsClipStartAfterClip(), EffectReverse::ProcessOneWave(), and WithinClip().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetEndTime()

double WaveClip::GetEndTime ( ) const

Definition at line 255 of file WaveClip.cpp.

 {
    auto numSamples = mSequence->GetNumSamples();
  
    double maxLen = mOffset + (numSamples+mAppendBufferLen).as_double()/mRate;
    // JS: calculated value is not the length;
    // it is a maximum value and can be negative; no clipping to 0
  
    return maxLen;
 }

References mAppendBufferLen, mOffset, mRate, and mSequence.

Referenced by AUPImportFileHandle::AddSilence(), AppendSilence(), SetClipCommand::ApplyInner(), SetEnvelopeCommand::ApplyInner(), WaveTrack::CanInsertClip(), Clear(), ClearAndAddCutLine(), ClipParameters::ClipParameters(), ClipParameters::GetClipRect(), WaveTrack::MergeClips(), anonymous_namespace{WaveTrackAffordanceControls.cpp}::NextClipLooped(), WaveTrack::Paste(), Paste(), and WaveTrack::UpdateLocationsCache().

Here is the caller graph for this function:

◆ GetEnvelope() [1/2]

Envelope* WaveClip::GetEnvelope ( )

inline

Definition at line 243 of file WaveClip.h.

243 { return mEnvelope.get(); }

Referenced by SetEnvelopeCommand::ApplyInner(), Clear(), ClearAndAddCutLine(), anonymous_namespace{WaveformView.cpp}::DrawClipWaveform(), anonymous_namespace{WaveformView.cpp}::DrawIndividualSamples(), WaveTrack::GetEnvelopeAtTime(), AUPImportFileHandle::HandleEnvelope(), WaveTrack::HandleXMLChild(), and InsertSilence().

Here is the caller graph for this function:

◆ GetEnvelope() [2/2]

const Envelope* WaveClip::GetEnvelope ( ) const

inline

Definition at line 244 of file WaveClip.h.

244 { return mEnvelope.get(); }

◆ GetIsPlaceholder()

bool WaveClip::GetIsPlaceholder ( ) const

inline

Definition at line 351 of file WaveClip.h.

351 { return mIsPlaceholder; }

Referenced by WaveClip().

Here is the caller graph for this function:

◆ GetMinMax()

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

Definition at line 1121 of file WaveClip.cpp.

 {
    if (t0 > t1) {
       if (mayThrow)
          THROW_INCONSISTENCY_EXCEPTION;
       return {
          0.f,  // harmless, but unused since Sequence::GetMinMax does not use these values
          0.f   // harmless, but unused since Sequence::GetMinMax does not use these values
       };
    }
  
    if (t0 == t1)
       return{ 0.f, 0.f };
  
    sampleCount s0, s1;
  
    TimeToSamplesClip(t0, &s0);
    TimeToSamplesClip(t1, &s1);
  
    return mSequence->GetMinMax(s0, s1-s0, mayThrow);
 }

References mSequence, THROW_INCONSISTENCY_EXCEPTION, and TimeToSamplesClip().

Here is the call graph for this function:

◆ GetName()

const wxString & WaveClip::GetName ( ) const

Definition at line 1788 of file WaveClip.cpp.

 {
    return mName;
 }

References mName.

◆ GetNumSamples()

sampleCount WaveClip::GetNumSamples ( ) const

Definition at line 276 of file WaveClip.cpp.

 {
    return mSequence->GetNumSamples();
 }

References mSequence.

Referenced by anonymous_namespace{WaveTrack.cpp}::AreAligned(), anonymous_namespace{SpectrumView.cpp}::DrawClipSpectrum(), anonymous_namespace{WaveformView.cpp}::DrawClipWaveform(), anonymous_namespace{WaveformView.cpp}::DrawIndividualSamples(), and SharesBoundaryWithNextClip().

Here is the caller graph for this function:

◆ GetOffset()

double WaveClip::GetOffset ( ) const

inline

Definition at line 220 of file WaveClip.h.

220 { return mOffset; }

Referenced by Clear(), ClearAndAddCutLine(), WaveTrack::ClearAndPaste(), ClipParameters::ClipParameters(), anonymous_namespace{WaveformView.cpp}::DrawIndividualSamples(), ClipParameters::GetClipRect(), WaveTrack::Join(), WaveTrack::RightmostOrNewClip(), SharesBoundaryWithNextClip(), and WaveClip().

Here is the caller graph for this function:

◆ GetRate()

int WaveClip::GetRate ( ) const

inline

Definition at line 208 of file WaveClip.h.

208 { return mRate; }

Referenced by Clear(), ClearAndAddCutLine(), ClipParameters::ClipParameters(), anonymous_namespace{WaveformView.cpp}::DrawIndividualSamples(), ClipParameters::GetClipRect(), InsertSilence(), Paste(), SharesBoundaryWithNextClip(), and UpdateEnvelopeTrackLen().

Here is the caller graph for this function:

◆ GetRMS()

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

Definition at line 1144 of file WaveClip.cpp.

 {
    if (t0 > t1) {
       if (mayThrow)
          THROW_INCONSISTENCY_EXCEPTION;
       return 0.f;
    }
  
    if (t0 == t1)
       return 0.f;
  
    sampleCount s0, s1;
  
    TimeToSamplesClip(t0, &s0);
    TimeToSamplesClip(t1, &s1);
  
    return mSequence->GetRMS(s0, s1-s0, mayThrow);
 }

References mSequence, THROW_INCONSISTENCY_EXCEPTION, and TimeToSamplesClip().

Here is the call graph for this function:

◆ GetSamples()

bool WaveClip::GetSamples	(	samplePtr	buffer,
		sampleFormat	format,
		sampleCount	start,
		size_t	len,
		bool	mayThrow = `true`
	)		const

Definition at line 222 of file WaveClip.cpp.

 {
    return mSequence->Get(buffer, format, start, len, mayThrow);
 }

References format, and mSequence.

Referenced by anonymous_namespace{WaveformView.cpp}::DrawIndividualSamples().

Here is the caller graph for this function:

◆ GetSequence() [1/2]

Sequence* WaveClip::GetSequence ( )

inline

Definition at line 251 of file WaveClip.h.

251 { return mSequence.get(); }

Referenced by WaveTrack::AddClip(), Clear(), ClearAndAddCutLine(), CloseLock(), WaveTrack::GetIdealBlockSize(), WaveTrack::GetSequenceAtTime(), AUPImportFileHandle::HandleSequence(), WaveTrack::HandleXMLChild(), and InsertSilence().

Here is the caller graph for this function:

◆ GetSequence() [2/2]

const Sequence* WaveClip::GetSequence ( ) const

inline

Definition at line 252 of file WaveClip.h.

252 { return mSequence.get(); }

◆ GetSequenceBlockArray() [1/2]

BlockArray * WaveClip::GetSequenceBlockArray ( )

Definition at line 239 of file WaveClip.cpp.

 {
    return &mSequence->GetBlockArray();
 }

References mSequence.

◆ GetSequenceBlockArray() [2/2]

const BlockArray * WaveClip::GetSequenceBlockArray ( ) const

Definition at line 244 of file WaveClip.cpp.

 {
    return &mSequence->GetBlockArray();
 }

References mSequence.

◆ GetSpectrogram()

bool WaveClip::GetSpectrogram	(	WaveTrackCache &	cache,
		const float *&	spectrogram,
		const sampleCount *&	where,
		size_t	numPixels,
		double	t0,
		double	pixelsPerSecond
	)		const

Definition at line 1010 of file WaveClip.cpp.

 {
    const WaveTrack *const track = waveTrackCache.GetTrack().get();
    const SpectrogramSettings &settings = track->GetSpectrogramSettings();
  
    bool match =
       mSpecCache &&
       mSpecCache->len > 0 &&
       mSpecCache->Matches
       (mDirty, pixelsPerSecond, settings, mRate);
  
    if (match &&
        mSpecCache->start == t0 &&
        mSpecCache->len >= numPixels) {
       spectrogram = &mSpecCache->freq[0];
       where = &mSpecCache->where[0];
  
       return false;  //hit cache completely
    }
  
    // Caching is not implemented for reassignment, unless for
    // a complete hit, because of the complications of time reassignment
    if (settings.algorithm == SpectrogramSettings::algReassignment)
       match = false;
  
    // Free the cache when it won't cause a major stutter.
    // If the window size changed, we know there is nothing to be copied
    // If we zoomed out, or resized, we can give up memory. But not too much -
    // up to 2x extra is needed at the end of the clip to prevent stutter.
    if (mSpecCache->freq.capacity() > 2.1 * mSpecCache->freq.size() ||
        mSpecCache->windowSize*mSpecCache->zeroPaddingFactor <
        settings.WindowSize()*settings.ZeroPaddingFactor())
    {
       match = false;
       mSpecCache = std::make_unique<SpecCache>();
    }
  
    const double tstep = 1.0 / pixelsPerSecond;
    const double samplesPerPixel = mRate * tstep;
  
    int oldX0 = 0;
    double correction = 0.0;
  
    int copyBegin = 0, copyEnd = 0;
    if (match) {
       findCorrection(mSpecCache->where, mSpecCache->len, numPixels,
          t0, mRate, samplesPerPixel,
          oldX0, correction);
       // Remember our first pixel maps to oldX0 in the old cache,
       // possibly out of bounds.
       // For what range of pixels can data be copied?
       copyBegin = std::min((int)numPixels, std::max(0, -oldX0));
       copyEnd = std::min((int)numPixels, std::max(0,
          (int)mSpecCache->len - oldX0
       ));
    }
  
    // Resize the cache, keep the contents unchanged.
    mSpecCache->Grow(numPixels, settings, pixelsPerSecond, t0);
    auto nBins = settings.NBins();
  
    // Optimization: if the old cache is good and overlaps
    // with the current one, re-use as much of the cache as
    // possible
    if (copyEnd > copyBegin)
    {
       // memmove is required since dst/src overlap
       memmove(&mSpecCache->freq[nBins * copyBegin],
                &mSpecCache->freq[nBins * (copyBegin + oldX0)],
                nBins * (copyEnd - copyBegin) * sizeof(float));
    }
  
    // Reassignment accumulates, so it needs a zeroed buffer
    if (settings.algorithm == SpectrogramSettings::algReassignment)
    {
       // The cache could theoretically copy from the middle, resulting
       // in two regions to update. This won't happen in zoom, since
       // old cache doesn't match. It won't happen in resize, since the
       // spectrum view is pinned to left side of window.
       wxASSERT(
          (copyBegin >= 0 && copyEnd == (int)numPixels) || // copied the end
          (copyBegin == 0 && copyEnd <= (int)numPixels)    // copied the beginning
       );
  
       int zeroBegin = copyBegin > 0 ? 0 : copyEnd-copyBegin;
       int zeroEnd = copyBegin > 0 ? copyBegin : numPixels;
  
       memset(&mSpecCache->freq[nBins*zeroBegin], 0, nBins*(zeroEnd-zeroBegin)*sizeof(float));
    }
  
    // purposely offset the display 1/2 sample to the left (as compared
    // to waveform display) to properly center response of the FFT
    fillWhere(mSpecCache->where, numPixels, 0.5, correction,
       t0, mRate, samplesPerPixel);
  
    mSpecCache->Populate
       (settings, waveTrackCache, copyBegin, copyEnd, numPixels,
        mSequence->GetNumSamples(),
        mOffset, mRate, pixelsPerSecond);
  
    mSpecCache->dirty = mDirty;
    spectrogram = &mSpecCache->freq[0];
    where = &mSpecCache->where[0];
  
    return true;
 }

References SpectrogramSettings::algReassignment, anonymous_namespace{WaveClip.cpp}::fillWhere(), anonymous_namespace{WaveClip.cpp}::findCorrection(), WaveTrack::GetSpectrogramSettings(), WaveTrackCache::GetTrack(), mDirty, min(), mOffset, mRate, mSequence, mSpecCache, and settings().

Referenced by anonymous_namespace{SpectrumView.cpp}::DrawClipSpectrum().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetStartSample()

sampleCount WaveClip::GetStartSample ( ) const

Definition at line 266 of file WaveClip.cpp.

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

References mOffset, and mRate.

Referenced by BeforeClip(), WaveTrack::GetClipAtSample(), GetEndSample(), EffectReverse::ProcessOneWave(), and WithinClip().

Here is the caller graph for this function:

◆ GetStartTime()

double WaveClip::GetStartTime ( ) const

Definition at line 249 of file WaveClip.cpp.

 {
    // JS: mOffset is the minimum value and it is returned; no clipping to 0
    return mOffset;
 }

References mOffset.

Referenced by SetClipCommand::ApplyInner(), SetEnvelopeCommand::ApplyInner(), anonymous_namespace{WaveTrack.cpp}::AreAligned(), WaveTrack::CanInsertClip(), Clear(), ClearAndAddCutLine(), ClipParameters::ClipParameters(), anonymous_namespace{WaveTrackAffordanceControls.cpp}::NextClipLooped(), WaveTrack::Paste(), and Paste().

Here is the caller graph for this function:

◆ GetWaveDisplay()

bool WaveClip::GetWaveDisplay	(	WaveDisplay &	display,
		double	t0,
		double	pixelsPerSecond
	)		const

Getting high-level data for screen display and clipping calculations and Contrast

Definition at line 384 of file WaveClip.cpp.

 {
    const bool allocated = (display.where != 0);
  
    const size_t numPixels = (int)display.width;
  
    size_t p0 = 0;         // least column requiring computation
    size_t p1 = numPixels; // greatest column requiring computation, plus one
  
    float *min;
    float *max;
    float *rms;
    int *bl;
    std::vector<sampleCount> *pWhere;
  
    if (allocated) {
       // assume ownWhere is filled.
       min = &display.min[0];
       max = &display.max[0];
       rms = &display.rms[0];
       bl = &display.bl[0];
       pWhere = &display.ownWhere;
    }
    else {
       const double tstep = 1.0 / pixelsPerSecond;
       const double samplesPerPixel = mRate * tstep;
  
       // Make a tolerant comparison of the pps values in this wise:
       // accumulated difference of times over the number of pixels is less than
       // a sample period.
       const bool ppsMatch = mWaveCache &&
          (fabs(tstep - 1.0 / mWaveCache->pps) * numPixels < (1.0 / mRate));
  
       const bool match =
          mWaveCache &&
          ppsMatch &&
          mWaveCache->len > 0 &&
          mWaveCache->dirty == mDirty;
  
       if (match &&
          mWaveCache->start == t0 &&
          mWaveCache->len >= numPixels) {
  
          // Satisfy the request completely from the cache
          display.min = &mWaveCache->min[0];
          display.max = &mWaveCache->max[0];
          display.rms = &mWaveCache->rms[0];
          display.bl = &mWaveCache->bl[0];
          display.where = &mWaveCache->where[0];
          return true;
       }
  
       std::unique_ptr<WaveCache> oldCache(std::move(mWaveCache));
  
       int oldX0 = 0;
       double correction = 0.0;
       size_t copyBegin = 0, copyEnd = 0;
       if (match) {
          findCorrection(oldCache->where, oldCache->len, numPixels,
             t0, mRate, samplesPerPixel,
             oldX0, correction);
          // Remember our first pixel maps to oldX0 in the old cache,
          // possibly out of bounds.
          // For what range of pixels can data be copied?
          copyBegin = std::min<size_t>(numPixels, std::max(0, -oldX0));
          copyEnd = std::min<size_t>(numPixels, std::max(0,
             (int)oldCache->len - oldX0
          ));
       }
       if (!(copyEnd > copyBegin))
          oldCache.reset(0);
  
       mWaveCache = std::make_unique<WaveCache>(numPixels, pixelsPerSecond, mRate, t0, mDirty);
       min = &mWaveCache->min[0];
       max = &mWaveCache->max[0];
       rms = &mWaveCache->rms[0];
       bl = &mWaveCache->bl[0];
       pWhere = &mWaveCache->where;
  
       fillWhere(*pWhere, numPixels, 0.0, correction,
          t0, mRate, samplesPerPixel);
  
       // The range of pixels we must fetch from the Sequence:
       p0 = (copyBegin > 0) ? 0 : copyEnd;
       p1 = (copyEnd >= numPixels) ? copyBegin : numPixels;
  
       // Optimization: if the old cache is good and overlaps
       // with the current one, re-use as much of the cache as
       // possible
  
       if (oldCache) {
  
          // Copy what we can from the old cache.
          const int length = copyEnd - copyBegin;
          const size_t sizeFloats = length * sizeof(float);
          const int srcIdx = (int)copyBegin + oldX0;
          memcpy(&min[copyBegin], &oldCache->min[srcIdx], sizeFloats);
          memcpy(&max[copyBegin], &oldCache->max[srcIdx], sizeFloats);
          memcpy(&rms[copyBegin], &oldCache->rms[srcIdx], sizeFloats);
          memcpy(&bl[copyBegin], &oldCache->bl[srcIdx], length * sizeof(int));
       }
    }
  
    if (p1 > p0) {
       // Cache was not used or did not satisfy the whole request
       std::vector<sampleCount> &where = *pWhere;
  
       /* handle values in the append buffer */
  
       auto numSamples = mSequence->GetNumSamples();
       auto a = p0;
  
       // Not all of the required columns might be in the sequence.
       // Some might be in the append buffer.
       for (; a < p1; ++a) {
          if (where[a + 1] > numSamples)
             break;
       }
  
       // Handle the columns that land in the append buffer.
       //compute the values that are outside the overlap from scratch.
       if (a < p1) {
          sampleFormat seqFormat = mSequence->GetSampleFormat();
          bool didUpdate = false;
          for(auto i = a; i < p1; i++) {
             auto left = std::max(sampleCount{ 0 },
                                  where[i] - numSamples);
             auto right = std::min(sampleCount{ mAppendBufferLen },
                                   where[i + 1] - numSamples);
  
             //wxCriticalSectionLocker locker(mAppendCriticalSection);
  
             if (right > left) {
                Floats b;
                float *pb{};
                // left is nonnegative and at most mAppendBufferLen:
                auto sLeft = left.as_size_t();
                // The difference is at most mAppendBufferLen:
                size_t len = ( right - left ).as_size_t();
  
                if (seqFormat == floatSample)
                   pb = &((float *)mAppendBuffer.ptr())[sLeft];
                else {
                   b.reinit(len);
                   pb = b.get();
                   SamplesToFloats(
                      mAppendBuffer.ptr() + sLeft * SAMPLE_SIZE(seqFormat),
                      seqFormat, pb, len);
                }
  
                float theMax, theMin, sumsq;
                {
                   const float val = pb[0];
                   theMax = theMin = val;
                   sumsq = val * val;
                }
                for(decltype(len) j = 1; j < len; j++) {
                   const float val = pb[j];
                   theMax = std::max(theMax, val);
                   theMin = std::min(theMin, val);
                   sumsq += val * val;
                }
  
                min[i] = theMin;
                max[i] = theMax;
                rms[i] = (float)sqrt(sumsq / len);
                bl[i] = 1; //for now just fake it.
  
                didUpdate=true;
             }
          }
  
          // Shrink the right end of the range to fetch from Sequence
          if(didUpdate)
             p1 = a;
       }
  
       // Done with append buffer, now fetch the rest of the cache miss
       // from the sequence
       if (p1 > p0) {
          if (!mSequence->GetWaveDisplay(&min[p0],
                                         &max[p0],
                                         &rms[p0],
                                         &bl[p0],
                                         p1-p0,
                                         &where[p0]))
          {
             return false;
          }
       }
    }
  
    if (!allocated) {
       // Now report the results
       display.min = min;
       display.max = max;
       display.rms = rms;
       display.bl = bl;
       display.where = &(*pWhere)[0];
    }
  
    return true;
 }

References WaveCache::bl, WaveDisplay::bl, anonymous_namespace{WaveClip.cpp}::fillWhere(), anonymous_namespace{WaveClip.cpp}::findCorrection(), floatSample, WaveCache::len, mAppendBuffer, mAppendBufferLen, WaveCache::max, WaveDisplay::max, mDirty, min(), WaveCache::min, WaveDisplay::min, mRate, mSequence, mWaveCache, WaveDisplay::ownWhere, SampleBuffer::ptr(), ArrayOf< X >::reinit(), WaveCache::rms, WaveDisplay::rms, SAMPLE_SIZE, SamplesToFloats(), WaveCache::where, WaveDisplay::where, and WaveDisplay::width.

Referenced by anonymous_namespace{WaveformView.cpp}::DrawClipWaveform().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HandleXMLChild()

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

overridevirtual

Implements XMLTagHandler.

Definition at line 1341 of file WaveClip.cpp.

 {
    if (!wxStrcmp(tag, wxT("sequence")))
       return mSequence.get();
    else if (!wxStrcmp(tag, wxT("envelope")))
       return mEnvelope.get();
    else if (!wxStrcmp(tag, wxT("waveclip")))
    {
       // Nested wave clips are cut lines
       mCutLines.push_back(
          std::make_unique<WaveClip>(mSequence->GetFactory(),
             mSequence->GetSampleFormat(), mRate, 0 /*colourindex*/));
       return mCutLines.back().get();
    }
    else
       return NULL;
 }

References mCutLines, mEnvelope, mRate, and mSequence.

Referenced by AUPImportFileHandle::HandleWaveClip().

Here is the caller graph for this function:

◆ HandleXMLEndTag()

void WaveClip::HandleXMLEndTag ( const wxChar * tag )

override

Definition at line 1335 of file WaveClip.cpp.

 {
    if (!wxStrcmp(tag, wxT("waveclip")))
       UpdateEnvelopeTrackLen();
 }

References UpdateEnvelopeTrackLen().

Referenced by WaveTrack::HandleXMLEndTag().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HandleXMLTag()

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

overridevirtual

Implements XMLTagHandler.

Definition at line 1294 of file WaveClip.cpp.

 {
    if (!wxStrcmp(tag, wxT("waveclip")))
    {
       double dblValue;
       long longValue;
       while (*attrs)
       {
          const wxChar *attr = *attrs++;
          const wxChar *value = *attrs++;
  
          if (!value)
             break;
  
          const wxString strValue = value;
          if (!wxStrcmp(attr, wxT("offset")))
          {
             if (!XMLValueChecker::IsGoodString(strValue) ||
                   !Internat::CompatibleToDouble(strValue, &dblValue))
                return false;
             SetOffset(dblValue);
          }
          else if (!wxStrcmp(attr, wxT("name")))
          {
             if(XMLValueChecker::IsGoodLongString(strValue))
                SetName(strValue);
          }
          else if (!wxStrcmp(attr, wxT("colorindex")))
          {
             if (!XMLValueChecker::IsGoodString(strValue) ||
                   !strValue.ToLong( &longValue))
                return false;
             SetColourIndex(longValue);
          }
       }
       return true;
    }
  
    return false;
 }

References Internat::CompatibleToDouble(), XMLValueChecker::IsGoodLongString(), XMLValueChecker::IsGoodString(), SetColourIndex(), SetName(), and SetOffset().

Here is the call graph for this function:

◆ InsertSilence()

void WaveClip::InsertSilence	(	double	t,
		double	len,
		double *	pEnvelopeValue = `nullptr`
	)

Insert silence - note that this is an efficient operation for large amounts of silence

Exception safety guarantee:: Strong

Definition at line 1434 of file WaveClip.cpp.

 {
    sampleCount s0;
    TimeToSamplesClip(t, &s0);
    auto slen = (sampleCount)floor(len * mRate + 0.5);
  
    // use Strong-guarantee
    GetSequence()->InsertSilence(s0, slen);
  
    // use No-fail-guarantee
    OffsetCutLines(t, len);
  
    const auto sampleTime = 1.0 / GetRate();
    auto pEnvelope = GetEnvelope();
    if ( pEnvelopeValue ) {
  
       // Preserve limit value at the end
       auto oldLen = pEnvelope->GetTrackLen();
       auto newLen = oldLen + len;
       pEnvelope->Cap( sampleTime );
  
       // Ramp across the silence to the given value
       pEnvelope->SetTrackLen( newLen, sampleTime );
       pEnvelope->InsertOrReplace
          ( pEnvelope->GetOffset() + newLen, *pEnvelopeValue );
    }
    else
       pEnvelope->InsertSpace( t, len );
  
    MarkChanged();
 }

References GetEnvelope(), GetRate(), GetSequence(), Sequence::InsertSilence(), MarkChanged(), mRate, OffsetCutLines(), and TimeToSamplesClip().

Referenced by AUPImportFileHandle::AddSilence(), and AppendSilence().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsClipStartAfterClip()

bool WaveClip::IsClipStartAfterClip ( double t ) const

Definition at line 307 of file WaveClip.cpp.

 {
    auto ts = (sampleCount)floor(t * mRate + 0.5);
    return ts >= GetEndSample() + mAppendBufferLen;
 }

References GetEndSample(), mAppendBufferLen, and mRate.

Here is the call graph for this function:

◆ MarkChanged()

void WaveClip::MarkChanged ( )

inline

WaveTrack calls this whenever data in the wave clip changes. It is called automatically when WaveClip has a chance to know that something has changed, like when member functions SetSamples() etc. are called.

Exception safety guarantee:: No-fail

Definition at line 258 of file WaveClip.h.

259 { mDirty++; }

Referenced by Append(), Clear(), ClearAndAddCutLine(), ConvertToSampleFormat(), Flush(), InsertSilence(), Paste(), SetRate(), and SetSamples().

Here is the caller graph for this function:

◆ NumCutLines()

size_t WaveClip::NumCutLines ( ) const

inline

Definition at line 315 of file WaveClip.h.

315 { return mCutLines.size(); }

Referenced by WaveTrack::UpdateLocationsCache().

Here is the caller graph for this function:

◆ Offset()

void WaveClip::Offset ( double delta )

inline

Exception safety guarantee:: No-fail

Definition at line 222 of file WaveClip.h.

223 { SetOffset(GetOffset() + delta); }

Referenced by Clear(), ClearAndAddCutLine(), WaveTrack::Copy(), and Paste().

Here is the caller graph for this function:

◆ OffsetCutLines()

void WaveClip::OffsetCutLines	(	double	t0,
		double	len
	)

Offset cutlines right to time 't0' by time amount 'len'.

Exception safety guarantee:: No-fail

Definition at line 1657 of file WaveClip.cpp.

 {
    for (const auto &cutLine : mCutLines)
    {
       if (mOffset + cutLine->GetOffset() >= t0)
          cutLine->Offset(len);
    }
 }

References mCutLines, and mOffset.

Referenced by InsertSilence(), and Paste().

Here is the caller graph for this function:

◆ operator=()

WaveClip& WaveClip::operator= ( const WaveClip & )

private

◆ Paste()

void WaveClip::Paste	(	double	t0,
		const WaveClip *	other
	)

Paste data from other clip, resampling it if not equal rate.

Exception safety guarantee:: Strong

Definition at line 1377 of file WaveClip.cpp.

 {
    const bool clipNeedsResampling = other->mRate != mRate;
    const bool clipNeedsNewFormat =
       other->mSequence->GetSampleFormat() != mSequence->GetSampleFormat();
    std::unique_ptr<WaveClip> newClip;
    const WaveClip* pastedClip;
  
    if (clipNeedsResampling || clipNeedsNewFormat)
    {
       newClip =
          std::make_unique<WaveClip>(*other, mSequence->GetFactory(), true);
       if (clipNeedsResampling)
          // The other clip's rate is different from ours, so resample
          newClip->Resample(mRate);
       if (clipNeedsNewFormat)
          // Force sample formats to match.
          newClip->ConvertToSampleFormat(mSequence->GetSampleFormat());
       pastedClip = newClip.get();
    }
    else
    {
       // No resampling or format change needed, just use original clip without making a copy
       pastedClip = other;
    }
  
    // Paste cut lines contained in pasted clip
    WaveClipHolders newCutlines;
    for (const auto &cutline: pastedClip->mCutLines)
    {
       newCutlines.push_back(
          std::make_unique<WaveClip>
             ( *cutline, mSequence->GetFactory(),
               // Recursively copy cutlines of cutlines.  They don't need
               // their offsets adjusted.
               true));
       newCutlines.back()->Offset(t0 - mOffset);
    }
  
    sampleCount s0;
    TimeToSamplesClip(t0, &s0);
  
    // Assume Strong-guarantee from Sequence::Paste
    mSequence->Paste(s0, pastedClip->mSequence.get());
  
    // Assume No-fail-guarantee in the remaining
    MarkChanged();
    auto sampleTime = 1.0 / GetRate();
    mEnvelope->PasteEnvelope
       (s0.as_double()/mRate + mOffset, pastedClip->mEnvelope.get(), sampleTime);
    OffsetCutLines(t0, pastedClip->GetEndTime() - pastedClip->GetStartTime());
  
    for (auto &holder : newCutlines)
       mCutLines.push_back(std::move(holder));
 }

References sampleCount::as_double(), ConvertToSampleFormat(), GetEndTime(), GetRate(), GetStartTime(), MarkChanged(), mCutLines, mEnvelope, mOffset, mRate, mSequence, Offset(), OffsetCutLines(), Resample(), and TimeToSamplesClip().

Referenced by ExpandCutLine(), WaveTrack::MergeClips(), and WaveTrack::Paste().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RemoveCutLine()

bool WaveClip::RemoveCutLine ( double cutLinePosition )

Remove cut line, without expanding the audio in it.

Definition at line 1641 of file WaveClip.cpp.

 {
    for (auto it = mCutLines.begin(); it != mCutLines.end(); ++it)
    {
       const auto &cutline = *it;
       if (fabs(mOffset + cutline->GetOffset() - cutLinePosition) < 0.0001)
       {
          mCutLines.erase(it); // deletes cutline!
          return true;
       }
    }
  
    return false;
 }

References mCutLines, and mOffset.

◆ Resample()

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

Exception safety guarantee:: Strong

We want to keep going as long as we have something to feed the resampler with OR as long as the resampler spews out samples (which could continue for a few iterations after we stop feeding it)

Definition at line 1682 of file WaveClip.cpp.

 {
    // Note:  it is not necessary to do this recursively to cutlines.
    // They get resampled as needed when they are expanded.
  
    if (rate == mRate)
       return; // Nothing to do
  
    double factor = (double)rate / (double)mRate;
    ::Resample resample(true, factor, factor); // constant rate resampling
  
    const size_t bufsize = 65536;
    Floats inBuffer{ bufsize };
    Floats outBuffer{ bufsize };
    sampleCount pos = 0;
    bool error = false;
    int outGenerated = 0;
    auto numSamples = mSequence->GetNumSamples();
  
    auto newSequence =
       std::make_unique<Sequence>(mSequence->GetFactory(), mSequence->GetSampleFormat());
  
    while (pos < numSamples || outGenerated > 0)
    {
       const auto inLen = limitSampleBufferSize( bufsize, numSamples - pos );
  
       bool isLast = ((pos + inLen) == numSamples);
  
       if (!mSequence->Get((samplePtr)inBuffer.get(), floatSample, pos, inLen, true))
       {
          error = true;
          break;
       }
  
       const auto results = resample.Process(factor, inBuffer.get(), inLen, isLast,
                                             outBuffer.get(), bufsize);
       outGenerated = results.second;
  
       pos += results.first;
  
       if (outGenerated < 0)
       {
          error = true;
          break;
       }
  
       newSequence->Append((samplePtr)outBuffer.get(), floatSample,
                           outGenerated);
  
       if (progress)
       {
          auto updateResult = progress->Update(
             pos.as_long_long(),
             numSamples.as_long_long()
          );
          error = (updateResult != ProgressResult::Success);
          if (error)
             throw UserException{};
       }
    }
  
    if (error)
       throw SimpleMessageBoxException{
          ExceptionType::Internal,
          XO("Resampling failed."),
          XO("Warning"),
          "Error:_Resampling"
       };
    else
    {
       // Use No-fail-guarantee in these steps
  
       // Invalidate wave display cache
       mWaveCache = std::make_unique<WaveCache>();
       // Invalidate the spectrum display cache
       mSpecCache = std::make_unique<SpecCache>();
  
       mSequence = std::move(newSequence);
       mRate = rate;
    }
 }

References floatSample, Internal, limitSampleBufferSize(), mRate, mSequence, mSpecCache, mWaveCache, Resample::Process(), BasicUI::Success, ProgressDialog::Update(), and XO.

Referenced by Paste().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetColourIndex()

void WaveClip::SetColourIndex ( int index )

inline

Definition at line 217 of file WaveClip.h.

217 { mColourIndex = index;};

Referenced by SetClipCommand::ApplyInner(), and HandleXMLTag().

Here is the caller graph for this function:

◆ SetIsPlaceholder()

void WaveClip::SetIsPlaceholder ( bool val )

inline

Definition at line 352 of file WaveClip.h.

352 { mIsPlaceholder = val; }

◆ SetName()

void WaveClip::SetName ( const wxString & name )

Definition at line 1783 of file WaveClip.cpp.

 {
    mName = name;
 }

References mName, and name.

Referenced by SetClipCommand::ApplyInner(), and HandleXMLTag().

Here is the caller graph for this function:

◆ SetOffset()

void WaveClip::SetOffset ( double offset )

Exception safety guarantee:: No-fail

Definition at line 216 of file WaveClip.cpp.

 {
     mOffset = offset;
     mEnvelope->SetOffset(mOffset);
 }

References mEnvelope, and mOffset.

Referenced by SetClipCommand::ApplyInner(), WaveTrack::ClearAndPaste(), WaveTrack::HandleXMLChild(), and HandleXMLTag().

Here is the caller graph for this function:

◆ SetRate()

void WaveClip::SetRate ( int rate )

Definition at line 1673 of file WaveClip.cpp.

 {
    mRate = rate;
    auto newLength = mSequence->GetNumSamples().as_double() / mRate;
    mEnvelope->RescaleTimes( newLength );
    MarkChanged();
 }

References MarkChanged(), mEnvelope, mRate, and mSequence.

Here is the call graph for this function:

◆ SetSamples()

void WaveClip::SetSamples	(	constSamplePtr	buffer,
		sampleFormat	format,
		sampleCount	start,
		size_t	len
	)

Exception safety guarantee:: Strong

Definition at line 229 of file WaveClip.cpp.

 {
    // use Strong-guarantee
    mSequence->SetSamples(buffer, format, start, len);
  
    // use No-fail-guarantee
    MarkChanged();
 }

References format, MarkChanged(), and mSequence.

Here is the call graph for this function:

◆ SharesBoundaryWithNextClip()

bool WaveClip::SharesBoundaryWithNextClip ( const WaveClip * next ) const

Definition at line 1773 of file WaveClip.cpp.

 {
    double endThis = GetRate() * GetOffset() + GetNumSamples().as_double();
    double startNext = next->GetRate() * next->GetOffset();
  
    // given that a double has about 15 significant digits, using a criterion
    // of half a sample should be safe in all normal usage.
    return fabs(startNext - endThis) < 0.5;
 }

References sampleCount::as_double(), GetNumSamples(), GetOffset(), and GetRate().

Here is the call graph for this function:

◆ TimeToSamplesClip()

void WaveClip::TimeToSamplesClip	(	double	t0,
		sampleCount *	s0
	)		const

Definition at line 1182 of file WaveClip.cpp.

 {
    if (t0 < mOffset)
       *s0 = 0;
    else if (t0 > mOffset + mSequence->GetNumSamples().as_double()/mRate)
       *s0 = mSequence->GetNumSamples();
    else
       *s0 = sampleCount( floor(((t0 - mOffset) * mRate) + 0.5) );
 }

References mOffset, mRate, and mSequence.

Referenced by Clear(), ClearAndAddCutLine(), GetMinMax(), GetRMS(), InsertSilence(), Paste(), and WaveClip().

Here is the caller graph for this function:

◆ UpdateEnvelopeTrackLen()

void WaveClip::UpdateEnvelopeTrackLen ( )

Whenever you do an operation to the sequence that will change the number of samples (that is, the length of the clip), you will want to call this function to tell the envelope about it.

Exception safety guarantee:: No-fail

Definition at line 1175 of file WaveClip.cpp.

 {
    auto len = (mSequence->GetNumSamples().as_double()) / mRate;
    if (len != mEnvelope->GetTrackLen())
       mEnvelope->SetTrackLen(len, 1.0 / GetRate());
 }

References GetRate(), mEnvelope, mRate, and mSequence.

Referenced by Append(), Flush(), and HandleXMLEndTag().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ WithinClip()

bool WaveClip::WithinClip ( double t ) const

Definition at line 286 of file WaveClip.cpp.

 {
    auto ts = (sampleCount)floor(t * mRate + 0.5);
    return ts > GetStartSample() && ts < GetEndSample() + mAppendBufferLen;
 }

References GetEndSample(), GetStartSample(), mAppendBufferLen, and mRate.

Here is the call graph for this function:

◆ WriteXML()

void WaveClip::WriteXML ( XMLWriter & xmlFile ) const

Definition at line 1359 of file WaveClip.cpp.

 {
    xmlFile.StartTag(wxT("waveclip"));
    xmlFile.WriteAttr(wxT("offset"), mOffset, 8);
    xmlFile.WriteAttr(wxT("name"), mName);
    xmlFile.WriteAttr(wxT("colorindex"), mColourIndex );
  
    mSequence->WriteXML(xmlFile);
    mEnvelope->WriteXML(xmlFile);
  
    for (const auto &clip: mCutLines)
       clip->WriteXML(xmlFile);
  
    xmlFile.EndTag(wxT("waveclip"));
 }

Member Data Documentation

◆ mAppendBuffer

SampleBuffer WaveClip::mAppendBuffer {}

protected

Definition at line 375 of file WaveClip.h.

Referenced by Append(), Flush(), and GetWaveDisplay().

◆ mAppendBufferLen

size_t WaveClip::mAppendBufferLen { 0 }

protected

Definition at line 376 of file WaveClip.h.

Referenced by AfterClip(), Append(), Flush(), GetEndTime(), GetWaveDisplay(), IsClipStartAfterClip(), and WithinClip().

◆ mColourIndex

int WaveClip::mColourIndex

protected

Definition at line 368 of file WaveClip.h.

Referenced by WaveClip().

◆ mCutLines

WaveClipHolders WaveClip::mCutLines {}

protected

Definition at line 380 of file WaveClip.h.

Referenced by Clear(), ClearAndAddCutLine(), CloseLock(), ExpandCutLine(), FindCutLine(), HandleXMLChild(), OffsetCutLines(), Paste(), RemoveCutLine(), and WaveClip().

◆ mDirty

int WaveClip::mDirty { 0 }

protected

Definition at line 367 of file WaveClip.h.

Referenced by GetSpectrogram(), and GetWaveDisplay().

◆ mEnvelope

std::unique_ptr<Envelope> WaveClip::mEnvelope

protected

Definition at line 371 of file WaveClip.h.

Referenced by HandleXMLChild(), Paste(), SetOffset(), SetRate(), UpdateEnvelopeTrackLen(), and WaveClip().

◆ mIsPlaceholder

bool WaveClip::mIsPlaceholder { false }

protected

Definition at line 383 of file WaveClip.h.

Referenced by WaveClip().

◆ mName

wxString WaveClip::mName

private

Definition at line 386 of file WaveClip.h.

Referenced by GetName(), SetName(), and WaveClip().

◆ mOffset

double WaveClip::mOffset { 0 }

protected

Definition at line 365 of file WaveClip.h.

Referenced by Clear(), ClearAndAddCutLine(), ExpandCutLine(), FindCutLine(), GetEndTime(), GetSpectrogram(), GetStartSample(), GetStartTime(), OffsetCutLines(), Paste(), RemoveCutLine(), SetOffset(), TimeToSamplesClip(), and WaveClip().

◆ mRate

int WaveClip::mRate

protected

Definition at line 366 of file WaveClip.h.

Referenced by AfterClip(), BeforeClip(), GetEndTime(), GetSpectrogram(), GetStartSample(), GetWaveDisplay(), HandleXMLChild(), InsertSilence(), IsClipStartAfterClip(), Paste(), Resample(), SetRate(), TimeToSamplesClip(), UpdateEnvelopeTrackLen(), WaveClip(), and WithinClip().

◆ mSequence

std::unique_ptr<Sequence> WaveClip::mSequence

protected

Definition at line 370 of file WaveClip.h.

Referenced by Append(), AppendNewBlock(), AppendSharedBlock(), ClearAndAddCutLine(), ConvertToSampleFormat(), Flush(), GetEndSample(), GetEndTime(), GetMinMax(), GetNumSamples(), GetRMS(), GetSamples(), GetSequenceBlockArray(), GetSpectrogram(), GetWaveDisplay(), HandleXMLChild(), Paste(), Resample(), SetRate(), SetSamples(), TimeToSamplesClip(), UpdateEnvelopeTrackLen(), and WaveClip().

◆ mSpecCache

std::unique_ptr<SpecCache> WaveClip::mSpecCache

mutableprotected

Definition at line 374 of file WaveClip.h.

Referenced by GetSpectrogram(), Resample(), and WaveClip().

◆ mSpecPxCache

std::unique_ptr<SpecPxCache> WaveClip::mSpecPxCache

mutable

Definition at line 362 of file WaveClip.h.

Referenced by anonymous_namespace{SpectrumView.cpp}::DrawClipSpectrum(), and WaveClip().

◆ mWaveCache

std::unique_ptr<WaveCache> WaveClip::mWaveCache

mutableprotected

Definition at line 373 of file WaveClip.h.

Referenced by ClearWaveCache(), GetWaveDisplay(), Resample(), and WaveClip().

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

Public Member Functions

Public Attributes

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ WaveClip() [1/4]

◆ WaveClip() [2/4]

◆ WaveClip() [3/4]

◆ WaveClip() [4/4]

◆ ~WaveClip()

Member Function Documentation

◆ AfterClip()

◆ Append()

◆ AppendNewBlock()

◆ AppendSharedBlock()

◆ AppendSilence()

◆ BeforeClip()

◆ Clear()

◆ ClearAndAddCutLine()

◆ ClearWaveCache()

◆ CloseLock()

◆ ConvertToSampleFormat()

◆ ExpandCutLine()

◆ FindCutLine()

◆ Flush()

◆ GetColourIndex()

◆ GetCutLines() [1/2]

◆ GetCutLines() [2/2]

◆ GetEndSample()

◆ GetEndTime()

◆ GetEnvelope() [1/2]

◆ GetEnvelope() [2/2]

◆ GetIsPlaceholder()

◆ GetMinMax()

◆ GetName()

◆ GetNumSamples()

◆ GetOffset()

◆ GetRate()

◆ GetRMS()

◆ GetSamples()

◆ GetSequence() [1/2]

◆ GetSequence() [2/2]

◆ GetSequenceBlockArray() [1/2]

◆ GetSequenceBlockArray() [2/2]

◆ GetSpectrogram()

◆ GetStartSample()

◆ GetStartTime()

◆ GetWaveDisplay()

◆ HandleXMLChild()

◆ HandleXMLEndTag()

◆ HandleXMLTag()

◆ InsertSilence()

◆ IsClipStartAfterClip()

◆ MarkChanged()

◆ NumCutLines()

◆ Offset()

◆ OffsetCutLines()

◆ operator=()

◆ Paste()

◆ RemoveCutLine()

◆ Resample()

◆ SetColourIndex()

◆ SetIsPlaceholder()

◆ SetName()

◆ SetOffset()

◆ SetRate()

◆ SetSamples()

◆ SharesBoundaryWithNextClip()

◆ TimeToSamplesClip()

◆ UpdateEnvelopeTrackLen()

◆ WithinClip()

◆ WriteXML()

Member Data Documentation

◆ mAppendBuffer

◆ mAppendBufferLen

◆ mColourIndex

◆ mCutLines

◆ mDirty