SpecCache Class Reference

#include <SpectrumCache.h>

Collaboration diagram for SpecCache:

Public Member Functions
	SpecCache ()
	~SpecCache ()
bool	Matches (int dirty_, double pixelsPerSecond, const SpectrogramSettings &settings, double rate) const
bool	CalculateOneSpectrum (const SpectrogramSettings &settings, SampleTrackCache &waveTrackCache, const int xx, sampleCount numSamples, double offset, double rate, double pixelsPerSecond, int lowerBoundX, int upperBoundX, const std::vector< float > &gainFactors, float *__restrict scratch, float *__restrict out) const
void	Grow (size_t len_, SpectrogramSettings &settings, double pixelsPerSecond, double start_)
void	Populate (const SpectrogramSettings &settings, SampleTrackCache &waveTrackCache, int copyBegin, int copyEnd, size_t numPixels, sampleCount numSamples, double offset, double rate, double pixelsPerSecond)

Public Attributes
size_t	len { 0 }
int	algorithm
double	pps
double	leftTrim { .0 }
double	rightTrim { .0 }
double	start
int	windowType
size_t	windowSize { 0 }
unsigned	zeroPaddingFactor { 0 }
int	frequencyGain
std::vector< float >	freq
std::vector< sampleCount >	where
int	dirty

Detailed Description

Definition at line 24 of file SpectrumCache.h.

Constructor & Destructor Documentation

SpecCache()

SpecCache::SpecCache ( )

inline

Definition at line 28 of file SpectrumCache.h.

      : algorithm(-1)
      , pps(-1.0)
      , start(-1.0)
      , windowType(-1)
      , frequencyGain(-1)
      , dirty(-1)
   {
   }

~SpecCache()

SpecCache::~SpecCache ( )

inline

Definition at line 38 of file SpectrumCache.h.

   {
   }

Member Function Documentation

CalculateOneSpectrum()

bool SpecCache::CalculateOneSpectrum	(	const SpectrogramSettings &	settings,
		SampleTrackCache &	waveTrackCache,
		const int	xx,
		sampleCount	numSamples,
		double	offset,
		double	rate,
		double	pixelsPerSecond,
		int	lowerBoundX,
		int	upperBoundX,
		const std::vector< float > &	gainFactors,
		float *__restrict	scratch,
		float *__restrict	out
	)		const

Definition at line 97 of file SpectrumCache.cpp.

{
   bool result = false;
   const bool reassignment =
      (settings.algorithm == SpectrogramSettings::algReassignment);
   const size_t windowSizeSetting = settings.WindowSize();
 
   sampleCount from;
 
   // xx may be for a column that is out of the visible bounds, but only
   // when we are calculating reassignment contributions that may cross into
   // the visible area.
 
   if (xx < 0)
      from = sampleCount(
         where[0].as_double() + xx * (rate / pixelsPerSecond)
      );
   else if (xx > (int)len)
      from = sampleCount(
         where[len].as_double() + (xx - len) * (rate / pixelsPerSecond)
      );
   else
      from = where[xx];
 
   const bool autocorrelation =
      settings.algorithm == SpectrogramSettings::algPitchEAC;
   const size_t zeroPaddingFactorSetting = settings.ZeroPaddingFactor();
   const size_t padding = (windowSizeSetting * (zeroPaddingFactorSetting - 1)) / 2;
   const size_t fftLen = windowSizeSetting * zeroPaddingFactorSetting;
   auto nBins = settings.NBins();
 
   if (from < 0 || from >= numSamples) {
      if (xx >= 0 && xx < (int)len) {
         // Pixel column is out of bounds of the clip!  Should not happen.
         float *const results = &out[nBins * xx];
         std::fill(results, results + nBins, 0.0f);
      }
   }
   else {
 
 
      // We can avoid copying memory when ComputeSpectrum is used below
      bool copy = !autocorrelation || (padding > 0) || reassignment;
      float *useBuffer = 0;
      float *adj = scratch + padding;
 
      {
         auto myLen = windowSizeSetting;
         // Take a window of the track centered at this sample.
         from -= windowSizeSetting >> 1;
         if (from < 0) {
            // Near the start of the clip, pad left with zeroes as needed.
            // from is at least -windowSize / 2
            for (auto ii = from; ii < 0; ++ii)
               *adj++ = 0;
            myLen += from.as_long_long(); // add a negative
            from = 0;
            copy = true;
         }
 
         if (from + myLen >= numSamples) {
            // Near the end of the clip, pad right with zeroes as needed.
            // newlen is bounded by myLen:
            auto newlen = ( numSamples - from ).as_size_t();
            for (decltype(myLen) ii = newlen; ii < myLen; ++ii)
               adj[ii] = 0;
            myLen = newlen;
            copy = true;
         }
 
         if (myLen > 0) {
            useBuffer = (float*)(waveTrackCache.GetFloats(
               sampleCount(
                  floor(0.5 + from.as_double() + offset * rate)
               ),
               myLen,
               // Don't throw in this drawing operation
               false)
            );
 
            if (copy) {
               if (useBuffer)
                  memcpy(adj, useBuffer, myLen * sizeof(float));
               else
                  memset(adj, 0, myLen * sizeof(float));
            }
         }
      }
 
      if (copy || !useBuffer)
         useBuffer = scratch;
 
      if (autocorrelation) {
         // not reassignment, xx is surely within bounds.
         wxASSERT(xx >= 0);
         float *const results = &out[nBins * xx];
         // This function does not mutate useBuffer
         ComputeSpectrum(useBuffer, windowSizeSetting, windowSizeSetting,
            rate, results,
            autocorrelation, settings.windowType);
      }
      else if (reassignment) {
         static const double epsilon = 1e-16;
         const auto hFFT = settings.hFFT.get();
 
         float *const scratch2 = scratch + fftLen;
         std::copy(scratch, scratch2, scratch2);
 
         float *const scratch3 = scratch + 2 * fftLen;
         std::copy(scratch, scratch2, scratch3);
 
         {
            const float *const window = settings.window.get();
            for (size_t ii = 0; ii < fftLen; ++ii)
               scratch[ii] *= window[ii];
            RealFFTf(scratch, hFFT);
         }
 
         {
            const float *const dWindow = settings.dWindow.get();
            for (size_t ii = 0; ii < fftLen; ++ii)
               scratch2[ii] *= dWindow[ii];
            RealFFTf(scratch2, hFFT);
         }
 
         {
            const float *const tWindow = settings.tWindow.get();
            for (size_t ii = 0; ii < fftLen; ++ii)
               scratch3[ii] *= tWindow[ii];
            RealFFTf(scratch3, hFFT);
         }
 
         for (size_t ii = 0; ii < hFFT->Points; ++ii) {
            const int index = hFFT->BitReversed[ii];
            const float
               denomRe = scratch[index],
               denomIm = ii == 0 ? 0 : scratch[index + 1];
            const double power = denomRe * denomRe + denomIm * denomIm;
            if (power < epsilon)
               // Avoid dividing by near-zero below
               continue;
 
            double freqCorrection;
            {
               const double multiplier = -(fftLen / (2.0f * M_PI));
               const float
                  numRe = scratch2[index],
                  numIm = ii == 0 ? 0 : scratch2[index + 1];
               // Find complex quotient --
               // Which means, multiply numerator by conjugate of denominator,
               // then divide by norm squared of denominator --
               // Then just take its imaginary part.
               const double
                  quotIm = (-numRe * denomIm + numIm * denomRe) / power;
               // With appropriate multiplier, that becomes the correction of
               // the frequency bin.
               freqCorrection = multiplier * quotIm;
            }
 
            const int bin = (int)((int)ii + freqCorrection + 0.5f);
            // Must check if correction takes bin out of bounds, above or below!
            // bin is signed!
            if (bin >= 0 && bin < (int)hFFT->Points) {
               double timeCorrection;
               {
                  const float
                     numRe = scratch3[index],
                     numIm = ii == 0 ? 0 : scratch3[index + 1];
                  // Find another complex quotient --
                  // Then just take its real part.
                  // The result has sample interval as unit.
                  timeCorrection =
                     (numRe * denomRe + numIm * denomIm) / power;
               }
 
               int correctedX = (floor(0.5 + xx + timeCorrection * pixelsPerSecond / rate));
               if (correctedX >= lowerBoundX && correctedX < upperBoundX)
               {
                  result = true;
 
                  // This is non-negative, because bin and correctedX are
                  auto ind = (int)nBins * correctedX + bin;
#ifdef _OPENMP
                  // This assignment can race if index reaches into another thread's bins.
                  // The probability of a race very low, so this carries little overhead,
                  // about 5% slower vs allowing it to race.
                  #pragma omp atomic update
#endif
                  out[ind] += power;
               }
            }
         }
      }
      else {
         // not reassignment, xx is surely within bounds.
         wxASSERT(xx >= 0);
         float *const results = &out[nBins * xx];
 
         // Do the FFT.  Note that useBuffer is multiplied by the window,
         // and the window is initialized with leading and trailing zeroes
         // when there is padding.  Therefore we did not need to reinitialize
         // the part of useBuffer in the padding zones.
 
         // This function mutates useBuffer
         ComputeSpectrumUsingRealFFTf
            (useBuffer, settings.hFFT.get(), settings.window.get(), fftLen, results);
         if (!gainFactors.empty()) {
            // Apply a frequency-dependent gain factor
            for (size_t ii = 0; ii < nBins; ++ii)
               results[ii] += gainFactors[ii];
         }
      }
   }
 
   return result;
}

References SpectrogramSettings::algPitchEAC, SpectrogramSettings::algReassignment, sampleCount::as_double(), sampleCount::as_long_long(), ComputeSpectrum(), anonymous_namespace{SpectrumCache.cpp}::ComputeSpectrumUsingRealFFTf(), SampleTrackCache::GetFloats(), len, M_PI, fast_float::detail::power(), RealFFTf(), settings(), and where.

Referenced by Populate().

Here is the call graph for this function:

Here is the caller graph for this function:

Grow()

void SpecCache::Grow	(	size_t	len_,
		SpectrogramSettings &	settings,
		double	pixelsPerSecond,
		double	start_
	)

Definition at line 321 of file SpectrumCache.cpp.

{
   settings.CacheWindows();
 
   // len columns, and so many rows, column-major.
   // Don't take column literally -- this isn't pixel data yet, it's the
   // raw data to be mapped onto the display.
   freq.resize(len_ * settings.NBins());
 
   // Sample counts corresponding to the columns, and to one past the end.
   where.resize(len_ + 1);
 
   len = len_;
   algorithm = settings.algorithm;
   pps = pixelsPerSecond;
   start = start_;
   windowType = settings.windowType;
   windowSize = settings.WindowSize();
   zeroPaddingFactor = settings.ZeroPaddingFactor();
   frequencyGain = settings.frequencyGain;
}

References algorithm, freq, frequencyGain, len, pps, settings(), start, where, windowSize, windowType, and zeroPaddingFactor.

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

Here is the call graph for this function:

Here is the caller graph for this function:

Matches()

bool SpecCache::Matches	(	int	dirty_,
		double	pixelsPerSecond,
		const SpectrogramSettings &	settings,
		double	rate
	)		const

Definition at line 76 of file SpectrumCache.cpp.

{
   // 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 double tstep = 1.0 / pixelsPerSecond;
   const bool ppsMatch =
      (fabs(tstep - 1.0 / pps) * len < (1.0 / rate));
 
   return
      ppsMatch &&
      dirty == dirty_ &&
      windowType == settings.windowType &&
      windowSize == settings.WindowSize() &&
      zeroPaddingFactor == settings.ZeroPaddingFactor() &&
      frequencyGain == settings.frequencyGain &&
      algorithm == settings.algorithm;
}

References algorithm, dirty, frequencyGain, len, pps, settings(), windowSize, windowType, and zeroPaddingFactor.

Here is the call graph for this function:

Populate()

void SpecCache::Populate	(	const SpectrogramSettings &	settings,
		SampleTrackCache &	waveTrackCache,
		int	copyBegin,
		int	copyEnd,
		size_t	numPixels,
		sampleCount	numSamples,
		double	offset,
		double	rate,
		double	pixelsPerSecond
	)

Definition at line 344 of file SpectrumCache.cpp.

{
   const int &frequencyGainSetting = settings.frequencyGain;
   const size_t windowSizeSetting = settings.WindowSize();
   const bool autocorrelation =
      settings.algorithm == SpectrogramSettings::algPitchEAC;
   const bool reassignment =
      settings.algorithm == SpectrogramSettings::algReassignment;
   const size_t zeroPaddingFactorSetting = settings.ZeroPaddingFactor();
 
   // FFT length may be longer than the window of samples that affect results
   // because of zero padding done for increased frequency resolution
   const size_t fftLen = windowSizeSetting * zeroPaddingFactorSetting;
   const auto nBins = settings.NBins();
 
   const size_t bufferSize = fftLen;
   const size_t scratchSize = reassignment ? 3 * bufferSize : bufferSize;
   std::vector<float> scratch(scratchSize);
 
   std::vector<float> gainFactors;
   if (!autocorrelation)
      ComputeSpectrogramGainFactors(fftLen, rate, frequencyGainSetting, gainFactors);
 
   // Loop over the ranges before and after the copied portion and compute anew.
   // One of the ranges may be empty.
   for (int jj = 0; jj < 2; ++jj) {
      const int lowerBoundX = jj == 0 ? 0 : copyEnd;
      const int upperBoundX = jj == 0 ? copyBegin : numPixels;
 
#ifdef _OPENMP
      // Storage for mutable per-thread data.
      // private clause ensures one copy per thread
      struct ThreadLocalStorage {
         ThreadLocalStorage()  { }
         ~ThreadLocalStorage() { }
 
         void init(SampleTrackCache &waveTrackCache, size_t scratchSize) {
            if (!cache) {
               cache = std::make_unique<SampleTrackCache>(waveTrackCache.GetTrack());
               scratch.resize(scratchSize);
            }
         }
         std::unique_ptr<SampleTrackCache> cache;
         std::vector<float> scratch;
      } tls;
 
      #pragma omp parallel for private(tls)
#endif
      for (auto xx = lowerBoundX; xx < upperBoundX; ++xx)
      {
#ifdef _OPENMP
         tls.init(waveTrackCache, scratchSize);
         SampleTrackCache& cache = *tls.cache;
         float* buffer = &tls.scratch[0];
#else
         SampleTrackCache& cache = waveTrackCache;
         float* buffer = &scratch[0];
#endif
         CalculateOneSpectrum(
            settings, cache, xx, numSamples,
            offset, rate, pixelsPerSecond,
            lowerBoundX, upperBoundX,
            gainFactors, buffer, &freq[0]);
      }
 
      if (reassignment) {
         // Need to look beyond the edges of the range to accumulate more
         // time reassignments.
         // I'm not sure what's a good stopping criterion?
         auto xx = lowerBoundX;
         const double pixelsPerSample = pixelsPerSecond / rate;
         const int limit = std::min((int)(0.5 + fftLen * pixelsPerSample), 100);
         for (int ii = 0; ii < limit; ++ii)
         {
            const bool result =
               CalculateOneSpectrum(
                  settings, waveTrackCache, --xx, numSamples,
                  offset, rate, pixelsPerSecond,
                  lowerBoundX, upperBoundX,
                  gainFactors, &scratch[0], &freq[0]);
            if (!result)
               break;
         }
 
         xx = upperBoundX;
         for (int ii = 0; ii < limit; ++ii)
         {
            const bool result =
               CalculateOneSpectrum(
                  settings, waveTrackCache, xx++, numSamples,
                  offset, rate, pixelsPerSecond,
                  lowerBoundX, upperBoundX,
                  gainFactors, &scratch[0], &freq[0]);
            if (!result)
               break;
         }
 
         // Now Convert to dB terms.  Do this only after accumulating
         // power values, which may cross columns with the time correction.
#ifdef _OPENMP
         #pragma omp parallel for
#endif
         for (xx = lowerBoundX; xx < upperBoundX; ++xx) {
            float *const results = &freq[nBins * xx];
            for (size_t ii = 0; ii < nBins; ++ii) {
               float &power = results[ii];
               if (power <= 0)
                  power = -160.0;
               else
                  power = 10.0*log10f(power);
            }
            if (!gainFactors.empty()) {
               // Apply a frequency-dependent gain factor
               for (size_t ii = 0; ii < nBins; ++ii)
                  results[ii] += gainFactors[ii];
            }
         }
      }
   }
}

References SpectrogramSettings::algPitchEAC, SpectrogramSettings::algReassignment, CalculateOneSpectrum(), anonymous_namespace{SpectrumCache.cpp}::ComputeSpectrogramGainFactors(), freq, SampleTrackCache::GetTrack(), min(), fast_float::detail::power(), 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:

Member Data Documentation

algorithm

int SpecCache::algorithm

Definition at line 68 of file SpectrumCache.h.

Referenced by Grow(), and Matches().

dirty

int SpecCache::dirty

Definition at line 80 of file SpectrumCache.h.

Referenced by Matches().

freq

std::vector<float> SpecCache::freq

Definition at line 77 of file SpectrumCache.h.

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

frequencyGain

int SpecCache::frequencyGain

Definition at line 76 of file SpectrumCache.h.

Referenced by Grow(), and Matches().

leftTrim

double SpecCache::leftTrim { .0 }

Definition at line 70 of file SpectrumCache.h.

len

size_t SpecCache::len { 0 }

Definition at line 67 of file SpectrumCache.h.

Referenced by CalculateOneSpectrum(), Grow(), and Matches().

pps

double SpecCache::pps

Definition at line 69 of file SpectrumCache.h.

Referenced by Grow(), and Matches().

rightTrim

double SpecCache::rightTrim { .0 }

Definition at line 71 of file SpectrumCache.h.

start

double SpecCache::start

Definition at line 72 of file SpectrumCache.h.

Referenced by Grow().

where

std::vector<sampleCount> SpecCache::where

Definition at line 78 of file SpectrumCache.h.

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

windowSize

size_t SpecCache::windowSize { 0 }

Definition at line 74 of file SpectrumCache.h.

Referenced by Grow(), and Matches().

windowType

int SpecCache::windowType

Definition at line 73 of file SpectrumCache.h.

Referenced by Grow(), and Matches().

zeroPaddingFactor

unsigned SpecCache::zeroPaddingFactor { 0 }

Definition at line 75 of file SpectrumCache.h.

Referenced by Grow(), and Matches().

---

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

• SpectrumCache.h
• SpectrumCache.cpp