#include <SpectrumCache.h>

Inheritance diagram for WaveClipSpectrumCache:

Collaboration diagram for WaveClipSpectrumCache:

Public Member Functions
	WaveClipSpectrumCache (size_t nChannels)

	~WaveClipSpectrumCache () override

void	MarkChanged () override

void	Invalidate () override

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

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

virtual void	MarkChanged ()=0

virtual void	Invalidate ()=0

Static Public Member Functions
static WaveClipSpectrumCache &	Get (const WaveClip &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 104 of file SpectrumCache.h.

Constructor & Destructor Documentation

◆ WaveClipSpectrumCache()

WaveClipSpectrumCache::WaveClipSpectrumCache ( size_t nChannels )

explicit

Definition at line 575 of file SpectrumCache.cpp.

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

References mSpecCaches.

◆ ~WaveClipSpectrumCache()

WaveClipSpectrumCache::~WaveClipSpectrumCache ( )

override

Definition at line 584 of file SpectrumCache.cpp.

585{

586}

Member Function Documentation

◆ Get()

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

static

Definition at line 592 of file SpectrumCache.cpp.

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

References sKeyS.

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

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) {
      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;
   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, fillWhere(), findCorrection(), WaveChannelInterval::GetChannelIndex(), WaveChannelInterval::GetRate(), WaveChannelInterval::GetStretchRatio(), WaveChannelInterval::GetTrimLeft(), WaveChannelInterval::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 603 of file SpectrumCache.cpp.

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

References mSpecCaches.

◆ MarkChanged()

void WaveClipSpectrumCache::MarkChanged ( )

overridevirtual

Implements WaveClipListener.

Definition at line 598 of file SpectrumCache.cpp.

{
   ++mDirty;
}

References mDirty.

Member Data Documentation

◆ mDirty

int WaveClipSpectrumCache::mDirty { 0 }

Definition at line 112 of file SpectrumCache.h.

Referenced by GetSpectrogram(), and MarkChanged().

◆ mSpecCaches

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

Definition at line 111 of file SpectrumCache.h.

Referenced by GetSpectrogram(), Invalidate(), and WaveClipSpectrumCache().

◆ mSpecPxCaches

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

Definition at line 110 of file SpectrumCache.h.

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

Public Member Functions

Static Public Member Functions

Public Attributes