#include <SpectralDataManager.h>

Inheritance diagram for SpectralDataManager::Worker:

Collaboration diagram for SpectralDataManager::Worker:

Classes
struct	MyWindow

Public Member Functions
	Worker (WaveChannel *pChannel, const Setting &setting)

	~Worker ()

bool	Process (const WaveChannel &channel, const std::shared_ptr< SpectralData > &sDataPtr)

int	ProcessSnapping (const WaveChannel &channel, long long int startSC, int hopSize, size_t winSize, double threshold, int targetFreqBin)

std::vector< int >	ProcessOvertones (const WaveChannel &channel, long long int startSC, int hopSize, size_t winSize, double threshold, int targetFreqBin)

Public Member Functions inherited from TrackSpectrumTransformer
	TrackSpectrumTransformer (WaveChannel *pOutputTrack, bool needsOutput, eWindowFunctions inWindowType, eWindowFunctions outWindowType, size_t windowSize, unsigned stepsPerWindow, bool leadingPadding, bool trailingPadding)

	~TrackSpectrumTransformer () override

bool	Process (const WindowProcessor &processor, const WaveChannel &channel, size_t queueLength, sampleCount start, sampleCount len)
	Invokes Start(), ProcessSamples(), and Finish() More...

Public Member Functions inherited from SpectrumTransformer
	SpectrumTransformer (bool needsOutput, eWindowFunctions inWindowType, eWindowFunctions outWindowType, size_t windowSize, unsigned stepsPerWindow, bool leadingPadding, bool trailingPadding)

virtual	~SpectrumTransformer ()

bool	NeedsOutput () const

bool	Start (size_t queueLength)
	Call once before a sequence of calls to ProcessSamples; Invokes DoStart. More...

bool	ProcessSamples (const WindowProcessor &processor, const float *buffer, size_t len)
	Call multiple times. More...

bool	Finish (const WindowProcessor &processor)

virtual std::unique_ptr< Window >	NewWindow (size_t windowSize)
	Allocates a window to place in the queue. More...

virtual bool	DoStart ()
	Called before any calls to ProcessWindow. More...

virtual void	DoOutput (const float *outBuffer, size_t mStepSize)=0
	Called within ProcessSamples if output was requested. More...

virtual bool	DoFinish ()
	Called after the last call to ProcessWindow(). More...

size_t	TotalQueueSize () const
	Useful functions to implement WindowProcesser: More...

size_t	CurrentQueueSize () const
	How many windows in the queue have been filled? More...

bool	QueueIsFull () const

Window &	Nth (int n)
	Access the queue, so you can inspect and modify any window in it. More...

Window &	Newest ()

Window &	Latest ()

Protected Member Functions
MyWindow &	NthWindow (int nn)

std::unique_ptr< Window >	NewWindow (size_t windowSize) override
	Allocates a window to place in the queue. More...

bool	DoStart () override
	Called before any calls to ProcessWindow. More...

bool	DoFinish () override
	Called after the last call to ProcessWindow(). More...

Protected Member Functions inherited from TrackSpectrumTransformer
bool	DoStart () override
	Called before any calls to ProcessWindow. More...

void	DoOutput (const float *outBuffer, size_t mStepSize) override

bool	DoFinish () override
	Called after the last call to ProcessWindow(). More...

Static Protected Member Functions
static bool	Processor (SpectrumTransformer &transformer)

static bool	OvertonesProcessor (SpectrumTransformer &transformer)

static bool	SnappingProcessor (SpectrumTransformer &transformer)

Private Member Functions
bool	ApplyEffectToSelection ()

Private Attributes
std::shared_ptr< SpectralData >	mpSpectralData

int	mWindowCount { 0 }

double	mSnapSamplingRate

double	mSnapThreshold

double	mOvertonesThreshold

std::vector< int >	mOvertonesTargetFreqBin

int	mSnapTargetFreqBin

int	mSnapReturnFreqBin { -1 }

long long	mStartHopNum { 0 }

Additional Inherited Members
Public Types inherited from SpectrumTransformer
using	FloatVector = std::vector< float >

using	WindowProcessor = std::function< bool(SpectrumTransformer &) >
	Type of function that transforms windows in the queue. More...

Static Public Member Functions inherited from TrackSpectrumTransformer
static bool	PostProcess (WaveTrack &outputTrack, sampleCount len)
	Final flush and trimming of tail samples. More...

Protected Attributes inherited from SpectrumTransformer
const size_t	mWindowSize

const size_t	mSpectrumSize

const unsigned	mStepsPerWindow

const size_t	mStepSize

const bool	mLeadingPadding

const bool	mTrailingPadding

Detailed Description

Definition at line 40 of file SpectralDataManager.h.

Constructor & Destructor Documentation

◆ Worker()

SpectralDataManager::Worker::Worker	(	WaveChannel *	pChannel,
		const Setting &	setting
	)

Definition at line 150 of file SpectralDataManager.cpp.

   : TrackSpectrumTransformer{ pChannel,
      setting.mNeedOutput, setting.mInWindowType, setting.mOutWindowType,
      setting.mWindowSize, setting.mStepsPerWindow,
      setting.mLeadingPadding, setting.mTrailingPadding
   }
// Work members
{
}

◆ ~Worker()

SpectralDataManager::Worker::~Worker ( )

default

Member Function Documentation

◆ ApplyEffectToSelection()

bool SpectralDataManager::Worker::ApplyEffectToSelection ( )

private

Definition at line 323 of file SpectralDataManager.cpp.

                                                       {
   auto &record = NthWindow(0);
 
   for(auto &spectralDataMap: mpSpectralData->dataHistory){
      // For all added frequency
      for(const int &freqBin: spectralDataMap[mStartHopNum]){
         record.mRealFFTs[freqBin] = 0;
         record.mImagFFTs[freqBin] = 0;
      }
   }
 
   mWindowCount++;
   mStartHopNum ++;
   return true;
}

◆ DoFinish()

bool SpectralDataManager::Worker::DoFinish ( )

overrideprotectedvirtual

Called after the last call to ProcessWindow().

Returns: false to abort processing. Default implementation just returns true.

Reimplemented from SpectrumTransformer.

Definition at line 166 of file SpectralDataManager.cpp.

                                         {
   return TrackSpectrumTransformer::DoFinish();
}

References TrackSpectrumTransformer::DoFinish().

Here is the call graph for this function:

◆ DoStart()

bool SpectralDataManager::Worker::DoStart ( )

overrideprotectedvirtual

Called before any calls to ProcessWindow.

More queue initializations can be done here.

Returns: false to abort processing. Default implementation just returns true.

Reimplemented from SpectrumTransformer.

Definition at line 163 of file SpectralDataManager.cpp.

                                        {
   return TrackSpectrumTransformer::DoStart();
}

References TrackSpectrumTransformer::DoStart().

Here is the call graph for this function:

◆ NewWindow()

auto SpectralDataManager::Worker::NewWindow ( size_t windowSize )

overrideprotectedvirtual

Allocates a window to place in the queue.

Only when initializing – windows are recycled thereafter. You can derive from Window to add fields, and then override this factory function.

Reimplemented from SpectrumTransformer.

Definition at line 339 of file SpectralDataManager.cpp.

{
   return std::make_unique<MyWindow>(windowSize);
}

◆ NthWindow()

MyWindow & SpectralDataManager::Worker::NthWindow ( int nn )

inlineprotected

Definition at line 71 of file SpectralDataManager.h.

                               {
      return static_cast<MyWindow&>(Nth(nn));
   }

References SpectrumTransformer::Nth().

Here is the call graph for this function:

◆ OvertonesProcessor()

bool SpectralDataManager::Worker::OvertonesProcessor ( SpectrumTransformer & transformer )

staticprotected

Definition at line 255 of file SpectralDataManager.cpp.

                                                                                   {
   auto &worker = static_cast<Worker &>(transformer);
   // Compute power spectrum in the newest window
   {
      MyWindow &record = worker.NthWindow(0);
      float *pSpectrum = &record.mSpectrums[0];
      const double dc = record.mRealFFTs[0];
      *pSpectrum++ = dc * dc;
      float *pReal = &record.mRealFFTs[1], *pImag = &record.mImagFFTs[1];
      for (size_t nn = worker.mSpectrumSize - 2; nn--;) {
         const double re = *pReal++, im = *pImag++;
         *pSpectrum++ = re * re + im * im;
      }
      const double nyquist = record.mImagFFTs[0];
      *pSpectrum = nyquist * nyquist;
 
      const double &spectrumSize = worker.mSpectrumSize;
      const int &targetBin = worker.mSnapTargetFreqBin;
 
      float targetValue = record.mSpectrums[targetBin];
 
      double fundamental = targetBin;
      int overtone = 2, binNum = 0;
      pSpectrum = &record.mSpectrums[0];
      while ( fundamental >= 1 &&
         ( binNum = lrint( fundamental * overtone )  ) < spectrumSize) {
         // Examine a few bins each way up and down
         constexpr int tolerance = 3;
         auto begin = pSpectrum + std::max( 0, binNum - (tolerance + 1) );
         auto end = pSpectrum +
            std::min<size_t>( spectrumSize, binNum + (tolerance + 1) + 1 );
         auto peak = std::max_element( begin, end );
 
         // Abandon if the peak is too far up or down
         if ( peak == begin || peak == end - 1 )
            break;
 
         int newBin = peak - pSpectrum;
         worker.mOvertonesTargetFreqBin.push_back(newBin);
         // Correct the estimate of the fundamental
         fundamental = double(newBin) / overtone++;
      }
   }
   return true;
}

References details::begin(), details::end(), lrint, and SpectralDataManager::Worker::MyWindow::mSpectrums.

Here is the call graph for this function:

◆ Process()

bool SpectralDataManager::Worker::Process	(	const WaveChannel &	channel,
		const std::shared_ptr< SpectralData > &	sDataPtr
	)

Definition at line 170 of file SpectralDataManager.cpp.

{
   mpSpectralData = pSpectralData;
   const auto hopSize = mpSpectralData->GetHopSize();
   const auto startSample = mpSpectralData->GetStartSample();
   // Correct the first hop num, because SpectrumTransformer will send
   // a few initial windows that overlay the range only partially
   mStartHopNum = startSample / hopSize - (mStepsPerWindow - 1);
   mWindowCount = 0;
   return TrackSpectrumTransformer::Process(Processor, channel, 1,
      mpSpectralData->GetCorrectedStartSample(), mpSpectralData->GetLength());
}

References TrackSpectrumTransformer::Process().

Here is the call graph for this function:

◆ Processor()

bool SpectralDataManager::Worker::Processor ( SpectrumTransformer & transformer )

staticprotected

Definition at line 301 of file SpectralDataManager.cpp.

{
   auto &worker = static_cast<Worker &>(transformer);
   // Compute power spectrum in the newest window
   {
      MyWindow &record = worker.NthWindow(0);
      float *pSpectrum = &record.mSpectrums[0];
      const double dc = record.mRealFFTs[0];
      *pSpectrum++ = dc * dc;
      float *pReal = &record.mRealFFTs[1], *pImag = &record.mImagFFTs[1];
      for (size_t nn = worker.mSpectrumSize - 2; nn--;) {
         const double re = *pReal++, im = *pImag++;
         *pSpectrum++ = re * re + im * im;
      }
      const double nyquist = record.mImagFFTs[0];
      *pSpectrum = nyquist * nyquist;
   }
 
   worker.ApplyEffectToSelection();
   return true;
}

References SpectralDataManager::Worker::MyWindow::mSpectrums.

◆ ProcessOvertones()

std::vector< int > SpectralDataManager::Worker::ProcessOvertones	(	const WaveChannel &	channel,
		long long int	startSC,
		int	hopSize,
		size_t	winSize,
		double	threshold,
		int	targetFreqBin
	)

Definition at line 201 of file SpectralDataManager.cpp.

{
   mOvertonesThreshold = threshold;
   mSnapTargetFreqBin = targetFreqBin;
   mSnapSamplingRate = channel.GetTrack().GetRate();
 
   startSC = std::max(static_cast<long long>(0), startSC - 2 * hopSize);
   // The calculated multiple frequency peaks will be stored in mOvertonesTargetFreqBin
   TrackSpectrumTransformer::Process(
      OvertonesProcessor, channel, 1, startSC, winSize);
   return move( mOvertonesTargetFreqBin );
 }

References WaveTrack::GetRate(), WaveChannel::GetTrack(), and TrackSpectrumTransformer::Process().

Here is the call graph for this function:

◆ ProcessSnapping()

int SpectralDataManager::Worker::ProcessSnapping	(	const WaveChannel &	channel,
		long long int	startSC,
		int	hopSize,
		size_t	winSize,
		double	threshold,
		int	targetFreqBin
	)

Definition at line 184 of file SpectralDataManager.cpp.

{
   mSnapThreshold = threshold;
   mSnapTargetFreqBin = targetFreqBin;
   mSnapSamplingRate = channel.GetTrack().GetRate();
 
   startSC = std::max(static_cast<long long>(0), startSC - 2 * hopSize);
   // The calculated frequency peak will be stored in mReturnFreq
   if (!TrackSpectrumTransformer::Process(SnappingProcessor, channel,
      1, startSC, winSize))
      return 0;
 
   return mSnapReturnFreqBin;
}

References WaveTrack::GetRate(), WaveChannel::GetTrack(), and TrackSpectrumTransformer::Process().

Here is the call graph for this function:

◆ SnappingProcessor()

bool SpectralDataManager::Worker::SnappingProcessor ( SpectrumTransformer & transformer )

staticprotected

Definition at line 216 of file SpectralDataManager.cpp.

                                                                                  {
   auto &worker = static_cast<Worker &>(transformer);
   // Compute power spectrum in the newest window
   {
      MyWindow &record = worker.NthWindow(0);
      float *pSpectrum = &record.mSpectrums[0];
      const double dc = record.mRealFFTs[0];
      *pSpectrum++ = dc * dc;
      float *pReal = &record.mRealFFTs[1], *pImag = &record.mImagFFTs[1];
      for (size_t nn = worker.mSpectrumSize - 2; nn--;) {
         const double re = *pReal++, im = *pImag++;
         *pSpectrum++ = re * re + im * im;
      }
      const double nyquist = record.mImagFFTs[0];
      *pSpectrum = nyquist * nyquist;
 
      const double &sr = worker.mSnapSamplingRate;
      const double nyquistRate = sr / 2;
      const double &threshold = worker.mSnapThreshold;
      const double &spectrumSize = worker.mSpectrumSize;
      const int &targetBin = worker.mSnapTargetFreqBin;
 
      int binBound = spectrumSize * threshold;
      float maxValue = std::numeric_limits<float>::min();
 
      // Skip the first and last bin
      for(int i = -binBound; i < binBound; i++){
         int idx = std::clamp(targetBin + i, 0, static_cast<int>(spectrumSize - 1));
         if(record.mSpectrums[idx] > maxValue){
            maxValue = record.mSpectrums[idx];
            // Update the return frequency
            worker.mSnapReturnFreqBin = idx;
         }
      }
   }
 
   return true;
}

References min(), and SpectralDataManager::Worker::MyWindow::mSpectrums.

Here is the call graph for this function:

Member Data Documentation

◆ mOvertonesTargetFreqBin

std::vector<int> SpectralDataManager::Worker::mOvertonesTargetFreqBin

private

Definition at line 88 of file SpectralDataManager.h.

◆ mOvertonesThreshold

double SpectralDataManager::Worker::mOvertonesThreshold

private

Definition at line 87 of file SpectralDataManager.h.

◆ mpSpectralData

std::shared_ptr<SpectralData> SpectralDataManager::Worker::mpSpectralData

private

Definition at line 83 of file SpectralDataManager.h.

◆ mSnapReturnFreqBin

int SpectralDataManager::Worker::mSnapReturnFreqBin { -1 }

private

Definition at line 90 of file SpectralDataManager.h.

◆ mSnapSamplingRate

double SpectralDataManager::Worker::mSnapSamplingRate

private

Definition at line 85 of file SpectralDataManager.h.

◆ mSnapTargetFreqBin

int SpectralDataManager::Worker::mSnapTargetFreqBin

private

Definition at line 89 of file SpectralDataManager.h.

◆ mSnapThreshold

double SpectralDataManager::Worker::mSnapThreshold

private

Definition at line 86 of file SpectralDataManager.h.

◆ mStartHopNum

long long SpectralDataManager::Worker::mStartHopNum { 0 }

private

Definition at line 91 of file SpectralDataManager.h.

◆ mWindowCount

int SpectralDataManager::Worker::mWindowCount { 0 }

private

Definition at line 84 of file SpectralDataManager.h.

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

Classes

Public Member Functions

Protected Member Functions

Static Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ Worker()

◆ ~Worker()

Member Function Documentation

◆ ApplyEffectToSelection()

◆ DoFinish()

◆ DoStart()

◆ NewWindow()

◆ NthWindow()

◆ OvertonesProcessor()

◆ Process()

◆ Processor()

◆ ProcessOvertones()

◆ ProcessSnapping()

◆ SnappingProcessor()

Member Data Documentation

◆ mOvertonesTargetFreqBin

◆ mOvertonesThreshold

◆ mpSpectralData

◆ mSnapReturnFreqBin

◆ mSnapSamplingRate

◆ mSnapTargetFreqBin

◆ mSnapThreshold

◆ mStartHopNum

◆ mWindowCount