WaveClip Class Reference

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

#include <WaveClip.h>

Inheritance diagram for WaveClip:

Public Member Functions
	WaveClip (const std::shared_ptr< DirManager > &projDirManager, sampleFormat format, int rate, int colourIndex)
	WaveClip (const WaveClip &orig, const std::shared_ptr< DirManager > &projDirManager, bool copyCutlines)
	WaveClip (const WaveClip &orig, const std::shared_ptr< DirManager > &projDirManager, bool copyCutlines, double t0, double t1)
virtual	~WaveClip ()
void	ConvertToSampleFormat (sampleFormat format)
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	GetSamples (samplePtr buffer, sampleFormat format, sampleCount start, size_t len, bool mayThrow=true) const
void	SetSamples (samplePtr buffer, sampleFormat format, sampleCount start, size_t len)
Envelope *	GetEnvelope ()
const Envelope *	GetEnvelope () const
BlockArray *	GetSequenceBlockArray ()
Sequence *	GetSequence ()
void	MarkChanged ()
bool	GetWaveDisplay (WaveDisplay &display, double t0, double pixelsPerSecond, bool &isLoadingOD) 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	ClearDisplayRect () const
void	SetDisplayRect (const wxRect &r) const
void	GetDisplayRect (wxRect *r)
void	UpdateEnvelopeTrackLen ()
void	Append (samplePtr buffer, sampleFormat format, size_t len, unsigned int stride=1, XMLWriter *blockFileLog=NULL)
	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)
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	Lock ()
	Lock all blockfiles. More...
void	Unlock ()
	Unlock all blockfiles. More...
void	CloseLock ()
void	ClearWaveCache ()
	Delete the wave cache - force redraw. Thread-safe. More...
void	AddInvalidRegion (sampleCount startSample, sampleCount endSample)
	Adds an invalid region to the wavecache so it redraws that portion only. 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
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
wxRect	mDisplayRect {}
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
ODLock	mWaveCacheMutex {}
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

Detailed Description

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

Definition at line 176 of file WaveClip.h.

Constructor & Destructor Documentation

WaveClip::WaveClip ( const WaveClip &  )

private

WaveClip::WaveClip	(	const std::shared_ptr< DirManager > &	projDirManager,
		sampleFormat	format,
		int	rate,
		int	colourIndex
	)

Definition at line 300 of file WaveClip.cpp.

References format, and WaveCache::rate.

{
   mRate = rate;
   mColourIndex = colourIndex;
   mSequence = std::make_unique<Sequence>(projDirManager, 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);
}

WaveClip::WaveClip	(	const WaveClip &	orig,
		const std::shared_ptr< DirManager > &	projDirManager,
		bool	copyCutlines
	)

Definition at line 314 of file WaveClip.cpp.

References GetIsPlaceholder(), mColourIndex, mCutLines, mEnvelope, mOffset, mRate, and mSequence.

{
   // essentially a copy constructor - but you must pass in the
   // current project's DirManager, 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, projDirManager);

   mEnvelope = std::make_unique<Envelope>(*orig.mEnvelope);

   mWaveCache = std::make_unique<WaveCache>();
   mSpecCache = std::make_unique<SpecCache>();
   mSpecPxCache = std::make_unique<SpecPxCache>(1);

   if ( copyCutlines )
      for (const auto &clip: orig.mCutLines)
         mCutLines.push_back
            ( std::make_unique<WaveClip>( *clip, projDirManager, true ) );

   mIsPlaceholder = orig.GetIsPlaceholder();
}

WaveClip::WaveClip	(	const WaveClip &	orig,
		const std::shared_ptr< DirManager > &	projDirManager,
		bool	copyCutlines,
		double	t0,
		double	t1
	)

Definition at line 341 of file WaveClip.cpp.

References sampleCount::as_double(), GetIsPlaceholder(), GetOffset(), mColourIndex, mCutLines, mEnvelope, mOffset, mRate, mSequence, and TimeToSamplesClip().

{
   // 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(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, projDirManager, true );
            newCutLine->SetOffset( cutlinePosition - t0 );
            mCutLines.push_back(std::move(newCutLine));
         }
      }
}

WaveClip::~WaveClip ( )

virtual

Definition at line 388 of file WaveClip.cpp.

{
}

Member Function Documentation

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

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

Definition at line 479 of file WaveClip.cpp.

Referenced by WaveTrack::AddInvalidRegion().

{
   ODLocker locker(&mWaveCacheMutex);
   if(mWaveCache!=NULL)
      mWaveCache->AddInvalidRegion(startSample,endSample);
}

bool WaveClip::AfterClip

(

double

t

)

const

Definition at line 465 of file WaveClip.cpp.

Referenced by WaveTrack::HandleClear().

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

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

You must call Flush after the last Append.

Definition at line 1393 of file WaveClip.cpp.

References CopySamples(), min(), and SAMPLE_SIZE.

Referenced by WaveTrack::Append().

{
   //wxLogDebug(wxT("Append: len=%lli"), (long long) len);

   auto maxBlockSize = mSequence->GetMaxBlockSize();
   auto blockSize = mSequence->GetIdealAppendLen();
   sampleFormat seqFormat = mSequence->GetSampleFormat();

   if (!mAppendBuffer.ptr())
      mAppendBuffer.Allocate(maxBlockSize, seqFormat);

   auto cleanup = finally( [&] {
      // use NOFAIL-GUARANTEE
      UpdateEnvelopeTrackLen();
      MarkChanged();
   } );

   for(;;) {
      if (mAppendBufferLen >= blockSize) {
         // flush some previously appended contents
         // use STRONG-GUARANTEE
         mSequence->Append(mAppendBuffer.ptr(), seqFormat, blockSize,
                           blockFileLog);

         // use NOFAIL-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 NOFAIL-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,
                  true, // high quality
                  stride);

      mAppendBufferLen += toCopy;
      buffer += toCopy * SAMPLE_SIZE(format) * stride;
      len -= toCopy;
   }
}

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

Definition at line 1450 of file WaveClip.cpp.

Referenced by WaveTrack::AppendAlias().

{
   // use STRONG-GUARANTEE
   mSequence->AppendAlias(fName, start, len, channel,useOD);

   // use NOFAIL-GUARANTEE
   UpdateEnvelopeTrackLen();
   MarkChanged();
}

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

Definition at line 1462 of file WaveClip.cpp.

Referenced by WaveTrack::AppendCoded().

{
   // use STRONG-GUARANTEE
   mSequence->AppendCoded(fName, start, len, channel, decodeType);

   // use NOFAIL-GUARANTEE
   UpdateEnvelopeTrackLen();
   MarkChanged();
}

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

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

Definition at line 1669 of file WaveClip.cpp.

Referenced by WaveTrack::Join().

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

bool WaveClip::BeforeClip

(

double

t

)

const

Definition at line 459 of file WaveClip.cpp.

Referenced by WaveTrack::HandleClear(), and WaveTrack::InsertSilence().

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

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

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

Definition at line 1676 of file WaveClip.cpp.

References GetOffset(), and Offset().

Referenced by WaveTrack::HandleClear().

{
   sampleCount s0, s1;

   TimeToSamplesClip(t0, &s0);
   TimeToSamplesClip(t1, &s1);

   // use STRONG-GUARANTEE
   GetSequence()->Delete(s0, s1-s0);

   // use NOFAIL-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();
}

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

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

Definition at line 1737 of file WaveClip.cpp.

References GetOffset(), min(), and Offset().

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

void WaveClip::ClearDisplayRect

(

)

const

Definition at line 1377 of file WaveClip.cpp.

{
   mDisplayRect.x = mDisplayRect.y = -1;
   mDisplayRect.width = mDisplayRect.height = -1;
}

void WaveClip::ClearWaveCache

(

)

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

Definition at line 472 of file WaveClip.cpp.

Referenced by WaveTrack::ClearWaveCaches().

{
   ODLocker locker(&mWaveCacheMutex);
   mWaveCache = std::make_unique<WaveCache>();
}

void WaveClip::CloseLock

(

)

Definition at line 1876 of file WaveClip.cpp.

Referenced by WaveTrack::CloseLock().

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

void WaveClip::ConvertToSampleFormat

(

sampleFormat

format

)

Definition at line 1350 of file WaveClip.cpp.

Referenced by Paste().

{
   // 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);
   if (bChanged)
      MarkChanged();
}

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 sucessfully expanded, false otherwise

Definition at line 1811 of file WaveClip.cpp.

Referenced by WaveTrack::ExpandCutLine().

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

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 1792 of file WaveClip.cpp.

Referenced by WaveTrack::ExpandCutLine().

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

void WaveClip::Flush

(

)

Flush must be called after last Append.

Definition at line 1474 of file WaveClip.cpp.

Referenced by WaveTrack::Flush().

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

int WaveClip::GetColourIndex ( ) const

inline

Definition at line 220 of file WaveClip.h.

Referenced by TrackArtist::DrawClipWaveform().

{ return mColourIndex;};

WaveClipHolders& WaveClip::GetCutLines ( )

inline

Get access to cut lines list.

Definition at line 314 of file WaveClip.h.

Referenced by WaveTrack::UpdateLocationsCache().

{ return mCutLines; }

const WaveClipConstHolders& WaveClip::GetCutLines ( ) const

inline

Definition at line 315 of file WaveClip.h.

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

void WaveClip::GetDisplayRect

(

wxRect *

r

)

Definition at line 1388 of file WaveClip.cpp.

Referenced by WaveTrack::GetClipAtX().

{
   *r = mDisplayRect;
}

sampleCount WaveClip::GetEndSample

(

)

const

Definition at line 443 of file WaveClip.cpp.

Referenced by WaveTrack::Get(), WaveTrack::GetEnvelopeValues(), EffectReverse::ProcessOneWave(), WaveTrack::Set(), and WaveTrack::Silence().

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

double WaveClip::GetEndTime

(

)

const

Definition at line 427 of file WaveClip.cpp.

Referenced by SetClipCommand::ApplyInner(), SetEnvelopeCommand::ApplyInner(), WaveTrack::CanInsertClip(), WaveTrack::CanOffsetClip(), SelectHandle::Click(), WaveTrack::Disjoin(), WaveTrack::ExpandCutLine(), WaveTrack::GetClipAtTime(), WaveTrack::GetEndTime(), WaveTrack::GetEnvelopeValues(), WaveTrack::GetMinMax(), WaveTrack::GetRMS(), WaveTrack::HandleClear(), WaveTrack::Join(), WaveTrack::MergeClips(), AudacityProject::OnClipMove(), WaveTrack::Paste(), Paste(), and WaveTrack::UpdateLocationsCache().

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

Envelope* WaveClip::GetEnvelope ( )

inline

Definition at line 243 of file WaveClip.h.

Referenced by SetEnvelopeCommand::ApplyInner(), TrackArtist::DrawClipWaveform(), TrackArtist::DrawIndividualSamples(), WaveTrack::GetEnvelopeAtX(), WaveTrack::GetEnvelopeValues(), WaveTrack::HandleXMLChild(), and WaveTrack::Join().

{ return mEnvelope.get(); }

const Envelope* WaveClip::GetEnvelope ( ) const

inline

Definition at line 244 of file WaveClip.h.

{ return mEnvelope.get(); }

bool WaveClip::GetIsPlaceholder ( ) const

inline

Definition at line 361 of file WaveClip.h.

Referenced by WaveTrack::Paste(), and WaveClip().

{ return mIsPlaceholder; }

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

Definition at line 1308 of file WaveClip.cpp.

References THROW_INCONSISTENCY_EXCEPTION.

Referenced by WaveTrack::GetMinMax().

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

sampleCount WaveClip::GetNumSamples

(

)

const

Definition at line 448 of file WaveClip.cpp.

Referenced by TrackArtist::DrawClipSpectrum(), TrackArtist::DrawClipWaveform(), TrackArtist::DrawIndividualSamples(), WaveTrack::Get(), WaveTrack::GetBestBlockSize(), WaveTrack::GetBlockStart(), WaveTrack::GetClipAtSample(), AudacityProject::GetTime(), WaveTrack::Set(), and WaveTrack::Silence().

{
   return mSequence->GetNumSamples();
}

double WaveClip::GetOffset ( ) const

inline

Definition at line 222 of file WaveClip.h.

Referenced by Clear(), ClearAndAddCutLine(), WaveTrack::ClearAndPaste(), SelectHandle::Click(), TrackArtist::DrawIndividualSamples(), WaveTrack::Join(), WaveTrack::RightmostOrNewClip(), SharesBoundaryWithNextClip(), WaveTrack::UpdateLocationsCache(), and WaveClip().

{ return mOffset; }

int WaveClip::GetRate ( ) const

inline

Definition at line 210 of file WaveClip.h.

Referenced by TrackArtist::DrawIndividualSamples(), and SharesBoundaryWithNextClip().

{ return mRate; }

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

Definition at line 1331 of file WaveClip.cpp.

References THROW_INCONSISTENCY_EXCEPTION.

Referenced by WaveTrack::GetRMS().

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

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

Definition at line 399 of file WaveClip.cpp.

Referenced by WaveTrack::Disjoin(), TrackArtist::DrawIndividualSamples(), and WaveTrack::Get().

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

Sequence* WaveClip::GetSequence ( )

inline

Definition at line 250 of file WaveClip.h.

Referenced by WaveTrack::GetBestBlockSize(), WaveTrack::GetBlockStart(), WaveTrack::GetErrorOpening(), WaveTrack::GetIdealBlockSize(), WaveTrack::GetMaxBlockSize(), WaveTrack::GetODFlags(), WaveTrack::GetSequenceAtX(), WaveTrack::HandleXMLChild(), RecordingRecoveryHandler::HandleXMLEndTag(), RecordingRecoveryHandler::HandleXMLTag(), and WaveTrack::Silence().

{ return mSequence.get(); }

BlockArray * WaveClip::GetSequenceBlockArray

(

)

Definition at line 416 of file WaveClip.cpp.

{
   return &mSequence->GetBlockArray();
}

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

Definition at line 1197 of file WaveClip.cpp.

References SpectrogramSettings::algorithm, SpectrogramSettings::algReassignment, WaveTrack::GetSpectrogramSettings(), WaveTrackCache::GetTrack(), min(), SpectrogramSettings::NBins(), SpectrogramSettings::WindowSize(), and SpectrogramSettings::ZeroPaddingFactor().

Referenced by TrackArtist::DrawClipSpectrum().

{
   const WaveTrack *const track = waveTrackCache.GetTrack();
   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;
}

sampleCount WaveClip::GetStartSample

(

)

const

Definition at line 438 of file WaveClip.cpp.

Referenced by WaveTrack::Get(), WaveTrack::GetClipAtSample(), WaveTrack::GetEnvelopeValues(), WaveTrack::Paste(), EffectReverse::ProcessOneWave(), WaveTrack::Set(), and WaveTrack::Silence().

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

double WaveClip::GetStartTime

(

)

const

Definition at line 421 of file WaveClip.cpp.

Referenced by SetClipCommand::ApplyInner(), SetEnvelopeCommand::ApplyInner(), WaveTrack::CanInsertClip(), WaveTrack::CanOffsetClip(), WaveTrack::Disjoin(), WaveTrack::ExpandCutLine(), WaveTrack::GetBestBlockSize(), WaveTrack::GetBlockStart(), WaveTrack::GetClipAtTime(), WaveTrack::GetEnvelopeValues(), WaveTrack::GetMinMax(), WaveTrack::GetRMS(), WaveTrack::GetStartTime(), AudacityProject::GetTime(), WaveTrack::HandleClear(), WaveTrack::Join(), AudacityProject::OnClipMove(), WaveTrack::Paste(), Paste(), and WaveTrack::UpdateLocationsCache().

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

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

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

Definition at line 550 of file WaveClip.cpp.

References WaveCache::bl, WaveDisplay::bl, WaveCache::ClearInvalidRegions(), CopySamples(), floatSample, if(), WaveCache::len, WaveCache::LoadInvalidRegions(), WaveCache::max, WaveDisplay::max, WaveCache::min, min(), WaveDisplay::min, WaveDisplay::ownBl, WaveDisplay::ownWhere, ArrayOf< X >::reinit(), WaveCache::rms, WaveDisplay::rms, SAMPLE_SIZE, WaveCache::where, WaveDisplay::where, and WaveDisplay::width.

Referenced by TrackArtist::DrawClipWaveform().

{
   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 {
      // Lock the list of invalid regions
      ODLocker locker(&mWaveCacheMutex);

      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) {
         mWaveCache->LoadInvalidRegions(mSequence.get(), true);
         mWaveCache->ClearInvalidRegions();

         // 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];
         isLoadingOD = mWaveCache->numODPixels > 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) {

         //TODO: only load inval regions if
         //necessary.  (usually is the case, so no rush.)
         //also, we should be updating the NEW cache, but here we are patching the old one up.
         oldCache->LoadInvalidRegions(mSequence.get(), false);
         oldCache->ClearInvalidRegions();

         // 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();
                  CopySamples(mAppendBuffer.ptr() + sLeft * SAMPLE_SIZE(seqFormat),
                              seqFormat,
                              (samplePtr)pb, floatSample, 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]))
         {
            isLoadingOD=false;
            return false;
         }
      }
   }

   //find the number of OD pixels - the only way to do this is by recounting
   if (!allocated) {
      // Now report the results
      display.min = min;
      display.max = max;
      display.rms = rms;
      display.bl = bl;
      display.where = &(*pWhere)[0];
      isLoadingOD = mWaveCache->numODPixels > 0;
   }
   else {
      using namespace std;
      isLoadingOD =
         count_if(display.ownBl.begin(), display.ownBl.end(),
                  bind2nd(less<int>(), 0)) > 0;
   }

   return true;
}

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

overridevirtual

Implements XMLTagHandler.

Definition at line 1545 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->GetDirManager(),
            mSequence->GetSampleFormat(), mRate, 0 /*colourindex*/));
      return mCutLines.back().get();
   }
   else
      return NULL;
}

void WaveClip::HandleXMLEndTag ( const wxChar *  tag )

override

Definition at line 1539 of file WaveClip.cpp.

Referenced by WaveTrack::HandleXMLEndTag().

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

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

overridevirtual

Implements XMLTagHandler.

Definition at line 1503 of file WaveClip.cpp.

References Internat::CompatibleToDouble(), and XMLValueChecker::IsGoodString().

{
   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);
         }
         if (!wxStrcmp(attr, wxT("colorindex")))
         {
            if (!XMLValueChecker::IsGoodString(strValue) ||
                  !strValue.ToLong( &longValue))
               return false;
            SetColourIndex(longValue);
         }
      }
      return true;
   }

   return false;
}

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

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

Definition at line 1636 of file WaveClip.cpp.

References WaveCache::len.

Referenced by WaveTrack::InsertSilence().

{
   sampleCount s0;
   TimeToSamplesClip(t, &s0);
   auto slen = (sampleCount)floor(len * mRate + 0.5);

   // use STRONG-GUARANTEE
   GetSequence()->InsertSilence(s0, slen);

   // use NOFAIL-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();
}

void WaveClip::Lock

(

)

Lock all blockfiles.

Definition at line 1869 of file WaveClip.cpp.

Referenced by WaveTrack::Lock().

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

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.

Definition at line 255 of file WaveClip.h.

Referenced by TimeShiftHandle::Release(), WaveTrack::Set(), and WaveTrack::Silence().

      { mDirty++; }

size_t WaveClip::NumCutLines ( ) const

inline

Definition at line 317 of file WaveClip.h.

Referenced by WaveTrack::UpdateLocationsCache().

{ return mCutLines.size(); }

void WaveClip::Offset ( double  delta )

inline

Definition at line 223 of file WaveClip.h.

Referenced by Clear(), ClearAndAddCutLine(), WaveTrack::Copy(), TimeShiftHandle::DoSlideHorizontal(), WaveTrack::HandleClear(), WaveTrack::InsertSilence(), WaveTrack::Paste(), and Paste().

      { SetOffset(GetOffset() + delta); }

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

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

Definition at line 1859 of file WaveClip.cpp.

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

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

private

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

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

Definition at line 1579 of file WaveClip.cpp.

References sampleCount::as_double(), ConvertToSampleFormat(), GetEndTime(), GetStartTime(), mCutLines, mEnvelope, mRate, mSequence, Offset(), and Resample().

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

{
   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->GetDirManager(), 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->GetDirManager(),
              // 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 NOFAIL-GUARANTEE in the remaining
   MarkChanged();
   auto sampleTime = 1.0 / GetRate();
   mEnvelope->Paste
      (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));
}

bool WaveClip::RemoveCutLine

(

double

cutLinePosition

)

Remove cut line, without expanding the audio in it.

Definition at line 1844 of file WaveClip.cpp.

Referenced by WaveTrack::RemoveCutLine().

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

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

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 1898 of file WaveClip.cpp.

References _(), sampleCount::as_long_long(), floatSample, limitSampleBufferSize(), Resample::Process(), WaveCache::rate, Success, and ProgressDialog::Update().

Referenced by Paste(), TimeShiftHandle::Release(), and WaveTrack::Resample().

{
   // 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->GetDirManager(), 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{
         _("Resampling failed.")
      };
   else
   {
      // Use NOFAIL-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;
   }
}

void WaveClip::SetColourIndex ( int  index )

inline

Definition at line 219 of file WaveClip.h.

Referenced by SetClipCommand::ApplyInner().

{ mColourIndex = index;};

void WaveClip::SetDisplayRect

(

const wxRect &

r

)

const

Definition at line 1383 of file WaveClip.cpp.

Referenced by TrackArtist::DrawClipSpectrum(), and TrackArtist::DrawClipWaveform().

{
   mDisplayRect = r;
}

void WaveClip::SetIsPlaceholder ( bool  val )

inline

Definition at line 362 of file WaveClip.h.

{ mIsPlaceholder = val; }

void WaveClip::SetOffset

(

double

offset

)

Definition at line 392 of file WaveClip.cpp.

Referenced by SetClipCommand::ApplyInner(), WaveTrack::ClearAndPaste(), WaveTrack::HandleXMLChild(), WaveTrack::Join(), WaveTrack::NewestOrNewClip(), and WaveTrack::RightmostOrNewClip().

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

void WaveClip::SetRate

(

int

rate

)

Definition at line 1890 of file WaveClip.cpp.

References WaveCache::rate.

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

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

Definition at line 405 of file WaveClip.cpp.

Referenced by WaveTrack::Set().

{
   // use STRONG-GUARANTEE
   mSequence->SetSamples(buffer, format, start, len);

   // use NOFAIL-GUARANTEE
   MarkChanged();
}

bool WaveClip::SharesBoundaryWithNextClip

(

const WaveClip *

next

)

const

Definition at line 1987 of file WaveClip.cpp.

References GetOffset(), and GetRate().

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

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

Definition at line 1367 of file WaveClip.cpp.

Referenced by WaveTrack::Disjoin(), WaveTrack::GetRMS(), and WaveClip().

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

void WaveClip::Unlock

(

)

Unlock all blockfiles.

Definition at line 1883 of file WaveClip.cpp.

Referenced by WaveTrack::Unlock().

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

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.

Definition at line 1360 of file WaveClip.cpp.

Referenced by RecordingRecoveryHandler::HandleXMLTag().

{
   mEnvelope->SetTrackLen
      ((mSequence->GetNumSamples().as_double()) / mRate, 1.0 / GetRate());
}

bool WaveClip::WithinClip

(

double

t

)

const

Definition at line 453 of file WaveClip.cpp.

Referenced by WaveTrack::InsertSilence(), and WaveTrack::Paste().

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

void WaveClip::WriteXML

(

XMLWriter &

xmlFile

)

const

Definition at line 1563 of file WaveClip.cpp.

Referenced by WaveTrack::WriteXML().

{
   xmlFile.StartTag(wxT("waveclip"));
   xmlFile.WriteAttr(wxT("offset"), mOffset, 8);
   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

SampleBuffer WaveClip::mAppendBuffer {}

protected

Definition at line 385 of file WaveClip.h.

size_t WaveClip::mAppendBufferLen { 0 }

protected

Definition at line 386 of file WaveClip.h.

int WaveClip::mColourIndex

protected

Definition at line 377 of file WaveClip.h.

Referenced by WaveClip().

WaveClipHolders WaveClip::mCutLines {}

protected

Definition at line 390 of file WaveClip.h.

Referenced by Paste(), and WaveClip().

int WaveClip::mDirty { 0 }

protected

Definition at line 376 of file WaveClip.h.

wxRect WaveClip::mDisplayRect {}

mutableprotected

Definition at line 372 of file WaveClip.h.

std::unique_ptr<Envelope> WaveClip::mEnvelope

protected

Definition at line 380 of file WaveClip.h.

Referenced by Paste(), and WaveClip().

bool WaveClip::mIsPlaceholder { false }

protected

Definition at line 393 of file WaveClip.h.

double WaveClip::mOffset { 0 }

protected

Definition at line 374 of file WaveClip.h.

Referenced by WaveClip().

int WaveClip::mRate

protected

Definition at line 375 of file WaveClip.h.

Referenced by Paste(), and WaveClip().

std::unique_ptr<Sequence> WaveClip::mSequence

protected

Definition at line 379 of file WaveClip.h.

Referenced by Paste(), and WaveClip().

std::unique_ptr<SpecCache> WaveClip::mSpecCache

mutableprotected

Definition at line 384 of file WaveClip.h.

std::unique_ptr<SpecPxCache> WaveClip::mSpecPxCache

mutable

Definition at line 369 of file WaveClip.h.

Referenced by TrackArtist::DrawClipSpectrum().

std::unique_ptr<WaveCache> WaveClip::mWaveCache

mutableprotected

Definition at line 382 of file WaveClip.h.

ODLock WaveClip::mWaveCacheMutex {}

mutableprotected

Definition at line 383 of file WaveClip.h.

---

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

• WaveClip.h
• WaveClip.cpp