#include <SpectrumCache.h>

Inheritance diagram for WaveClipSpectrumCache:

Collaboration diagram for WaveClipSpectrumCache:

Public Member Functions
	WaveClipSpectrumCache ()

	~WaveClipSpectrumCache () override

void	MarkChanged () override

void	Invalidate () override

bool	GetSpectrogram (const WaveClip &clip, SampleTrackCache &cache, const float &spectrogram, 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::unique_ptr< SpecPxCache >	mSpecPxCache

std::unique_ptr< SpecCache >	mSpecCache

int	mDirty { 0 }

Detailed Description

Definition at line 106 of file SpectrumCache.h.

Constructor & Destructor Documentation

◆ WaveClipSpectrumCache()

WaveClipSpectrumCache::WaveClipSpectrumCache ( )

Definition at line 591 of file SpectrumCache.cpp.

: mSpecCache{ std::make_unique<SpecCache>() }
, mSpecPxCache{ std::make_unique<SpecPxCache>(1) }
{
}

◆ ~WaveClipSpectrumCache()

WaveClipSpectrumCache::~WaveClipSpectrumCache ( )

override

Definition at line 597 of file SpectrumCache.cpp.

598{

599}

Member Function Documentation

◆ Get()

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

static

Definition at line 605 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 WaveClip &	clip,
		SampleTrackCache &	cache,
		const float *&	spectrogram,
		const sampleCount *&	where,
		size_t	numPixels,
		double	t0,
		double	pixelsPerSecond
	)

Getting high-level data for screen display

Definition at line 469 of file SpectrumCache.cpp.

{
   t0 += clip.GetTrimLeft();
 
   const auto track =
      static_cast<const WaveTrack*>(waveTrackCache.GetTrack().get());
   auto &settings = SpectrogramSettings::Get(*track);
   const auto rate = clip.GetRate();
 
   //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, pixelsPerSecond, settings, rate);
 
   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 = rate * tstep;
 
   int oldX0 = 0;
   double correction = 0.0;
 
   int copyBegin = 0, copyEnd = 0;
   if (match) {
      findCorrection(mSpecCache->where, mSpecCache->len, numPixels,
         t0, rate, 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);
   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
   fillWhere(mSpecCache->where, numPixels, 0.5, correction,
      t0, rate, samplesPerPixel);
 
   mSpecCache->Populate
      (settings, waveTrackCache, copyBegin, copyEnd, numPixels,
       clip.GetSequenceSamplesCount(),
       clip.GetSequenceStartTime(), rate, pixelsPerSecond);
 
   mSpecCache->dirty = mDirty;
   spectrogram = &mSpecCache->freq[0];
   where = &mSpecCache->where[0];
 
   return true;
}

References SpectrogramSettings::algReassignment, fillWhere(), findCorrection(), SpectrogramSettings::Get(), WaveClip::GetRate(), WaveClip::GetSequenceSamplesCount(), WaveClip::GetSequenceStartTime(), SampleTrackCache::GetTrack(), WaveClip::GetTrimLeft(), WaveClip::GetTrimRight(), mDirty, min(), 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:

◆ Invalidate()

void WaveClipSpectrumCache::Invalidate ( )

overridevirtual

Implements WaveClipListener.

Definition at line 616 of file SpectrumCache.cpp.

{
   // Invalidate the spectrum display cache
   mSpecCache = std::make_unique<SpecCache>();
}

References mSpecCache.

◆ MarkChanged()

void WaveClipSpectrumCache::MarkChanged ( )

overridevirtual

Implements WaveClipListener.

Definition at line 611 of file SpectrumCache.cpp.

{
   ++mDirty;
}

References mDirty.

Member Data Documentation

◆ mDirty

int WaveClipSpectrumCache::mDirty { 0 }

Definition at line 114 of file SpectrumCache.h.

Referenced by GetSpectrogram(), and MarkChanged().

◆ mSpecCache

std::unique_ptr<SpecCache> WaveClipSpectrumCache::mSpecCache

Definition at line 113 of file SpectrumCache.h.

Referenced by GetSpectrogram(), and Invalidate().

◆ mSpecPxCache

std::unique_ptr<SpecPxCache> WaveClipSpectrumCache::mSpecPxCache

Definition at line 112 of file SpectrumCache.h.

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

Public Member Functions

Static Public Member Functions

Public Attributes