WaveClipSpectrumCache Struct Reference

#include <SpectrumCache.h>

Inheritance diagram for WaveClipSpectrumCache:

Collaboration diagram for WaveClipSpectrumCache:

Public Member Functions
	WaveClipSpectrumCache (size_t nChannels)
	~WaveClipSpectrumCache () override
std::unique_ptr< WaveClipListener >	Clone () const override
void	MarkChanged () noexcept override
void	Invalidate () override
bool	GetSpectrogram (const WaveChannelInterval &clip, const float *&spectrogram, SpectrogramSettings &spectrogramSettings, const sampleCount *&where, size_t numPixels, double t0, double pixelsPerSecond)
void	MakeStereo (WaveClipListener &&other, bool aligned) override
void	SwapChannels () override
	Default implementation does nothing. More...
void	Erase (size_t index) override
Public Member Functions inherited from WaveClipListener
virtual	~WaveClipListener ()=0
virtual void	MarkChanged () noexcept=0
virtual void	Invalidate ()=0
virtual void	WriteXMLAttributes (XMLWriter &writer) const
virtual bool	HandleXMLAttribute (const std::string_view &attr, const XMLAttributeValueView &valueView)
virtual void	MakeStereo (WaveClipListener &&other, bool aligned)
virtual void	SwapChannels ()
	Default implementation does nothing. More...
virtual void	Erase (size_t index)

Static Public Member Functions
static WaveClipSpectrumCache &	Get (const WaveChannelInterval &clip)

Public Attributes
std::vector< std::unique_ptr< SpecPxCache > >	mSpecPxCaches
std::vector< std::unique_ptr< SpecCache > >	mSpecCaches
int	mDirty { 0 }

Detailed Description

Definition at line 105 of file SpectrumCache.h.

Constructor & Destructor Documentation

WaveClipSpectrumCache()

WaveClipSpectrumCache::WaveClipSpectrumCache ( size_t  nChannels )

explicit

Definition at line 575 of file SpectrumCache.cpp.

   : mSpecCaches(nChannels)
   , mSpecPxCaches(nChannels)
{
   for (auto &pCache : mSpecCaches)
      pCache = std::make_unique<SpecCache>();
}

References mSpecCaches.

~WaveClipSpectrumCache()

WaveClipSpectrumCache::~WaveClipSpectrumCache ( )

override

Definition at line 583 of file SpectrumCache.cpp.

{
}

Member Function Documentation

Clone()

std::unique_ptr< WaveClipListener > WaveClipSpectrumCache::Clone ( ) const

override

Definition at line 587 of file SpectrumCache.cpp.

{
   // Don't need to copy contents
   return std::make_unique<WaveClipSpectrumCache>(mSpecCaches.size());
}

References mSpecCaches.

Erase()

void WaveClipSpectrumCache::Erase ( size_t  index )

overridevirtual

Erase attachment at a given index, if it existed, moving later-indexed attachments to earlier indices

Default implementation does nothing

Reimplemented from WaveClipListener.

Definition at line 632 of file SpectrumCache.cpp.

{
   if (index < mSpecCaches.size())
      mSpecCaches.erase(mSpecCaches.begin() + index);
   if (index < mSpecPxCaches.size())
      mSpecPxCaches.erase(mSpecPxCaches.begin() + index);
}

References mSpecCaches, and mSpecPxCaches.

Get()

WaveClipSpectrumCache & WaveClipSpectrumCache::Get ( const WaveChannelInterval &  clip )

static

Definition at line 598 of file SpectrumCache.cpp.

{
   return const_cast<WaveClip&>(clip.GetClip()) // Consider it mutable data
      .Attachments::Get< WaveClipSpectrumCache >( sKeyS );
}

References WaveClipChannel::GetClip(), and sKeyS.

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

Here is the call graph for this function:

Here is the caller graph for this function:

GetSpectrogram()

bool WaveClipSpectrumCache::GetSpectrogram	(	const WaveChannelInterval &	clip,
		const float *&	spectrogram,
		SpectrogramSettings &	spectrogramSettings,
		const sampleCount *&	where,
		size_t	numPixels,
		double	t0,
		double	pixelsPerSecond
	)

Getting high-level data for screen display

Definition at line 461 of file SpectrumCache.cpp.

{
   auto &mSpecCache = mSpecCaches[clip.GetChannelIndex()];
 
   const auto sampleRate = clip.GetRate();
   const auto stretchRatio = clip.GetStretchRatio();
   const auto samplesPerPixel = sampleRate / pixelsPerSecond / stretchRatio;
 
   //Trim offset comparison failure forces spectrogram cache rebuild
   //and skip copying "unchanged" data after clip border was trimmed.
   bool match = mSpecCache && mSpecCache->leftTrim == clip.GetTrimLeft() &&
                mSpecCache->rightTrim == clip.GetTrimRight() &&
                mSpecCache->len > 0 &&
                mSpecCache->Matches(mDirty, samplesPerPixel, settings);
 
   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>();
   }
 
   int oldX0 = 0;
   double correction = 0.0;
 
   int copyBegin = 0, copyEnd = 0;
   if (match) {
      WaveClipUIUtilities::findCorrection(
         mSpecCache->where, mSpecCache->len, numPixels, t0, sampleRate,
         stretchRatio, 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, samplesPerPixel, t0);
   mSpecCache->leftTrim = clip.GetTrimLeft();
   mSpecCache->rightTrim = clip.GetTrimRight();
   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
   constexpr auto addBias = true;
   WaveClipUIUtilities::fillWhere(
      mSpecCache->where, numPixels, addBias, correction, t0, sampleRate,
      stretchRatio, samplesPerPixel);
 
   mSpecCache->Populate(
      settings, clip, copyBegin, copyEnd, numPixels, pixelsPerSecond);
 
   mSpecCache->dirty = mDirty;
   spectrogram = &mSpecCache->freq[0];
   where = &mSpecCache->where[0];
 
   return true;
}

References SpectrogramSettings::algReassignment, WaveClipUIUtilities::fillWhere(), WaveClipUIUtilities::findCorrection(), WaveClipChannel::GetChannelIndex(), WaveClipChannel::GetRate(), WaveClipChannel::GetStretchRatio(), WaveClipChannel::GetTrimLeft(), WaveClipChannel::GetTrimRight(), mDirty, min(), mSpecCaches, anonymous_namespace{ClipSegmentTest.cpp}::sampleRate, 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:

Invalidate()

void WaveClipSpectrumCache::Invalidate ( )

overridevirtual

Implements WaveClipListener.

Definition at line 609 of file SpectrumCache.cpp.

{
   // Invalidate the spectrum display cache
   for (auto &pCache : mSpecCaches)
      pCache = std::make_unique<SpecCache>();
}

References mSpecCaches.

MakeStereo()

void WaveClipSpectrumCache::MakeStereo ( WaveClipListener &&  other, bool  aligned  )

overridevirtual

Append the other's attachments to this, assuming concrete subclasses are the same

Default implementation does nothing

Parameters

aligned

whether the strong invariant condition on the clip may be assumed

Precondition

typeid(*this) == typeid(other)

Reimplemented from WaveClipListener.

Definition at line 616 of file SpectrumCache.cpp.

{
   auto pOther = dynamic_cast<WaveClipSpectrumCache *>(&other);
   assert(pOther); // precondition
   mSpecCaches.push_back(move(pOther->mSpecCaches[0]));
   mSpecPxCaches.push_back(move(pOther->mSpecPxCaches[0]));
}

References mSpecCaches, and mSpecPxCaches.

MarkChanged()

void WaveClipSpectrumCache::MarkChanged ( )

overridevirtualnoexcept

Implements WaveClipListener.

Definition at line 604 of file SpectrumCache.cpp.

{
   ++mDirty;
}

References mDirty.

SwapChannels()

void WaveClipSpectrumCache::SwapChannels ( )

overridevirtual

Default implementation does nothing.

Reimplemented from WaveClipListener.

Definition at line 624 of file SpectrumCache.cpp.

{
   mSpecCaches.resize(2);
   std::swap(mSpecCaches[0], mSpecCaches[1]);
   mSpecPxCaches.resize(2);
   std::swap(mSpecPxCaches[0], mSpecPxCaches[1]);
}

References mSpecCaches, mSpecPxCaches, and anonymous_namespace{NoteTrack.cpp}::swap().

Here is the call graph for this function:

Member Data Documentation

mDirty

int WaveClipSpectrumCache::mDirty { 0 }

Definition at line 115 of file SpectrumCache.h.

Referenced by GetSpectrogram(), and MarkChanged().

mSpecCaches

std::vector<std::unique_ptr<SpecCache> > WaveClipSpectrumCache::mSpecCaches

Definition at line 114 of file SpectrumCache.h.

Referenced by Clone(), Erase(), GetSpectrogram(), Invalidate(), MakeStereo(), SwapChannels(), and WaveClipSpectrumCache().

mSpecPxCaches

std::vector<std::unique_ptr<SpecPxCache> > WaveClipSpectrumCache::mSpecPxCaches

Definition at line 113 of file SpectrumCache.h.

Referenced by Erase(), MakeStereo(), and SwapChannels().

---

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

• SpectrumCache.h
• SpectrumCache.cpp