SpectrumTransformer Class Reference

A class that transforms a portion of a wave track (preserving duration) by applying Fourier transform, then modifying coefficients, then inverse Fourier transform and overlap-add to reconstruct. More...

#include <SpectrumTransformer.h>

Inheritance diagram for SpectrumTransformer:

Collaboration diagram for SpectrumTransformer:

Classes
struct	Window
	Derive this class to add information to the queue. More...

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

Public Member Functions
	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 Attributes
const size_t	mWindowSize
const size_t	mSpectrumSize
const unsigned	mStepsPerWindow
const size_t	mStepSize
const bool	mLeadingPadding
const bool	mTrailingPadding

Private Member Functions
void	ResizeQueue (size_t queueLength)
void	FillFirstWindow ()
void	RotateWindows ()
void	OutputStep ()

Private Attributes
std::vector< std::unique_ptr< Window > >	mQueue
HFFT	hFFT
sampleCount	mInSampleCount = 0
sampleCount	mOutStepCount = 0
	sometimes negative More...
size_t	mInWavePos = 0
FloatVector	mFFTBuffer
	These have size mWindowSize: More...
FloatVector	mInWaveBuffer
FloatVector	mOutOverlapBuffer
FloatVector	mInWindow
	These have size mWindowSize, or 0 for rectangular window: More...
FloatVector	mOutWindow
const bool	mNeedsOutput

Detailed Description

A class that transforms a portion of a wave track (preserving duration) by applying Fourier transform, then modifying coefficients, then inverse Fourier transform and overlap-add to reconstruct.

The procedure that modifies coefficients can be varied, and can employ lookahead

and -behind to nearby windows. May also be used just to gather information without producing output.

Definition at line 33 of file SpectrumTransformer.h.

Member Typedef Documentation

FloatVector

using SpectrumTransformer::FloatVector = std::vector<float>

Definition at line 37 of file SpectrumTransformer.h.

WindowProcessor

using SpectrumTransformer::WindowProcessor = std::function< bool(SpectrumTransformer&) >

Type of function that transforms windows in the queue.

Called repeatedly, with the newest window in the queue taken from input, and the last window of the queue about to be inverse-transformed for output.

Returns

false to abort processing.

Definition at line 43 of file SpectrumTransformer.h.

Constructor & Destructor Documentation

SpectrumTransformer()

SpectrumTransformer::SpectrumTransformer	(	bool	needsOutput,
		eWindowFunctions	inWindowType,
		eWindowFunctions	outWindowType,
		size_t	windowSize,
		unsigned	stepsPerWindow,
		bool	leadingPadding,
		bool	trailingPadding
	)

Precondition

!(inWindowType == eWinFuncRectangular && outWindowType eWinFuncRectangular)

windowSize % stepsPerWindow == 0

windowSize is a power of 2

Parameters

needsOutput	Whether to do the inverse FFT
inWindowType	Used in FFT transform
outWindowType	Used in inverse FFT transform
windowSize	must be a power of 2
stepsPerWindow	determines the overlap
leadingPadding	Whether to start the queue with windows that partially overlap the first full window of input samples
trailingPadding	Whether to stop the procedure after the last complete window of input is added to the queue

Definition at line 16 of file SpectrumTransformer.cpp.

: mWindowSize{ windowSize }
, mSpectrumSize{ 1 + mWindowSize / 2 }
, mStepsPerWindow{ stepsPerWindow }
, mStepSize{ mWindowSize / mStepsPerWindow }
, mLeadingPadding{ leadingPadding }
, mTrailingPadding{ trailingPadding }
, hFFT{ GetFFT(mWindowSize) }
, mFFTBuffer( mWindowSize )
, mInWaveBuffer( mWindowSize )
, mOutOverlapBuffer( mWindowSize )
, mNeedsOutput{ needsOutput }
{
   // Check preconditions
 
   // Powers of 2 only!
   wxASSERT(mWindowSize > 0 &&
      0 == (mWindowSize & (mWindowSize - 1)));
 
   wxASSERT(mWindowSize % mStepsPerWindow == 0);
 
   wxASSERT(!(inWindowType == eWinFuncRectangular && outWindowType == eWinFuncRectangular));
 
   // To do:  check that inWindowType, outWindowType, and mStepsPerWindow
   // are compatible for correct overlap-add reconstruction.
 
   // Create windows as needed
   if (inWindowType != eWinFuncRectangular) {
      mInWindow.resize(mWindowSize);
      std::fill(mInWindow.begin(), mInWindow.end(), 1.0f);
      NewWindowFunc(inWindowType, mWindowSize, false, mInWindow.data());
   }
   if (outWindowType != eWinFuncRectangular) {
      mOutWindow.resize(mWindowSize);
      std::fill(mOutWindow.begin(), mOutWindow.end(), 1.0f);
      NewWindowFunc(outWindowType, mWindowSize, false, mOutWindow.data());
   }
 
   // Must scale one or the other window so overlap-add
   // comes out right
   double denom = 0;
   for (size_t ii = 0; ii < mWindowSize; ii += mStepSize) {
      denom +=
         (mInWindow.empty() ? 1.0 : mInWindow[ii])
         *
         (mOutWindow.empty() ? 1.0 : mOutWindow[ii]);
   }
   // It is ASSUMED that you have chosen window types and
   // steps per window, so that this sum denom would be the
   // same, starting the march anywhere from 0 to mStepSize - 1.
   // Else, your overlap-add won't be right, and the transformer
   // might not be an identity even when you do nothing to the
   // spectra.
 
   float *pWindow = 0;
   if (!mInWindow.empty())
      pWindow = mInWindow.data();
   else if (!mOutWindow.empty())
      pWindow = mOutWindow.data();
   else
      // Can only happen if both window types were rectangular
      wxASSERT(false);
   for (size_t ii = 0; ii < mWindowSize; ++ii)
      *pWindow++ /= denom;
}

References eWinFuncRectangular, mInWindow, mOutWindow, mStepSize, mStepsPerWindow, mWindowSize, and NewWindowFunc().

Here is the call graph for this function:

~SpectrumTransformer()

SpectrumTransformer::~SpectrumTransformer ( )

virtualdefault

Member Function Documentation

CurrentQueueSize()

size_t SpectrumTransformer::CurrentQueueSize

(

)

const

How many windows in the queue have been filled?

(Not always the allocated size of the queue)

Definition at line 258 of file SpectrumTransformer.cpp.

{
   auto allocSize = mQueue.size();
   auto size = mOutStepCount + allocSize;
   if (mLeadingPadding)
      size += mStepsPerWindow - 1;
 
   if (size < allocSize)
      return size.as_size_t();
   else
      return allocSize;
}

References mLeadingPadding, mOutStepCount, mQueue, mStepsPerWindow, and size.

Referenced by NoiseReductionBase::Worker::ReduceNoise().

Here is the caller graph for this function:

DoFinish()

bool SpectrumTransformer::DoFinish ( )

virtual

Called after the last call to ProcessWindow().

Returns

false to abort processing. Default implementation just returns true.

Reimplemented in MyTransformer, TrackSpectrumTransformer, and SpectralDataManager::Worker.

Definition at line 97 of file SpectrumTransformer.cpp.

{
   return true;
}

Referenced by TrackSpectrumTransformer::DoFinish(), and Finish().

Here is the caller graph for this function:

DoOutput()

virtual void SpectrumTransformer::DoOutput ( const float *  outBuffer, size_t  mStepSize  )

pure virtual

Called within ProcessSamples if output was requested.

Implemented in TrackSpectrumTransformer.

Referenced by OutputStep().

Here is the caller graph for this function:

DoStart()

bool SpectrumTransformer::DoStart ( )

virtual

Called before any calls to ProcessWindow.

More queue initializations can be done here.

Returns

false to abort processing. Default implementation just returns true.

Reimplemented in MyTransformer, TrackSpectrumTransformer, and SpectralDataManager::Worker.

Definition at line 92 of file SpectrumTransformer.cpp.

{
   return true;
}

Referenced by TrackSpectrumTransformer::DoStart(), and Start().

Here is the caller graph for this function:

FillFirstWindow()

void SpectrumTransformer::FillFirstWindow ( )

private

Definition at line 194 of file SpectrumTransformer.cpp.

{
   // Transform samples to frequency domain, windowed as needed
   {
      auto pFFTBuffer = mFFTBuffer.data(), pInWaveBuffer = mInWaveBuffer.data();
      if (mInWindow.size() > 0) {
         auto pInWindow = mInWindow.data();
         for (size_t ii = 0; ii < mWindowSize; ++ii)
            *pFFTBuffer++ = *pInWaveBuffer++ * *pInWindow++;
      }
      else
         memmove(pFFTBuffer, pInWaveBuffer, mWindowSize * sizeof(float));
   }
   RealFFTf(mFFTBuffer.data(), hFFT.get());
 
   auto &record = Nth(0);
 
   // Store real and imaginary parts for later inverse FFT
   {
      float *pReal = &record.mRealFFTs[1];
      float *pImag = &record.mImagFFTs[1];
      int *pBitReversed = &hFFT->BitReversed[1];
      const auto last = mSpectrumSize - 1;
      for (size_t ii = 1; ii < last; ++ii) {
         const int kk = *pBitReversed++;
         *pReal++ = mFFTBuffer[kk];
         *pImag++ = mFFTBuffer[kk + 1];
      }
      // DC and Fs/2 bins need to be handled specially
      const float dc = mFFTBuffer[0];
      record.mRealFFTs[0] = dc;
 
      const float nyquist = mFFTBuffer[1];
      record.mImagFFTs[0] = nyquist; // For Fs/2, not really imaginary
   }
}

References hFFT, mFFTBuffer, mInWaveBuffer, mInWindow, mSpectrumSize, mWindowSize, Nth(), and RealFFTf().

Referenced by ProcessSamples().

Here is the call graph for this function:

Here is the caller graph for this function:

Finish()

bool SpectrumTransformer::Finish

(

const WindowProcessor &

processor

)

Call once after a sequence of calls to ProcessSamples; flushes the queue and Invokes DoFinish

Returns

success

Definition at line 236 of file SpectrumTransformer.cpp.

{
   bool bLoopSuccess = true;
   if (mTrailingPadding) {
      // Keep flushing empty input buffers through the history
      // windows until we've output exactly as many samples as
      // were input.
      // Well, not exactly, but not more than one step-size of extra samples
      // at the end.
 
      while (bLoopSuccess &&
            mOutStepCount * static_cast<int>(mStepSize) < mInSampleCount)
         bLoopSuccess = ProcessSamples(processor, nullptr, mStepSize);
   }
 
   if (bLoopSuccess)
      // invoke derived method
      bLoopSuccess = DoFinish();
 
   return bLoopSuccess;
}

References DoFinish(), mInSampleCount, mOutStepCount, mStepSize, mTrailingPadding, and ProcessSamples().

Referenced by TrackSpectrumTransformer::Process().

Here is the call graph for this function:

Here is the caller graph for this function:

Latest()

Window & SpectrumTransformer::Latest ( )

inline

Definition at line 144 of file SpectrumTransformer.h.

{ return **mQueue.rbegin(); }

NeedsOutput()

bool SpectrumTransformer::NeedsOutput ( ) const

inline

Definition at line 65 of file SpectrumTransformer.h.

{ return mNeedsOutput; }

Newest()

Window & SpectrumTransformer::Newest ( )

inline

Definition at line 143 of file SpectrumTransformer.h.

{ return **mQueue.begin(); }

NewWindow()

auto SpectrumTransformer::NewWindow ( size_t  windowSize )

virtual

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 in MyTransformer, and SpectralDataManager::Worker.

Definition at line 86 of file SpectrumTransformer.cpp.

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

Referenced by ResizeQueue().

Here is the caller graph for this function:

Nth()

Window & SpectrumTransformer::Nth ( int  n )

inline

Access the queue, so you can inspect and modify any window in it.

Newer windows are at earlier indices. You can't modify the length of it

Definition at line 141 of file SpectrumTransformer.h.

{ return *mQueue[n]; }

Referenced by FillFirstWindow(), and SpectralDataManager::Worker::NthWindow().

Here is the caller graph for this function:

OutputStep()

void SpectrumTransformer::OutputStep ( )

private

Definition at line 272 of file SpectrumTransformer.cpp.

{
   if (!mNeedsOutput)
      return;
   if (QueueIsFull()) {
      const auto last = mSpectrumSize - 1;
      Window &record = **mQueue.rbegin();
 
      const float *pReal = &record.mRealFFTs[1];
      const float *pImag = &record.mImagFFTs[1];
      float *pBuffer = &mFFTBuffer[2];
      auto nn = mSpectrumSize - 2;
      for (; nn--;) {
         *pBuffer++ = *pReal++;
         *pBuffer++ = *pImag++;
      }
      mFFTBuffer[0] = record.mRealFFTs[0];
      // The Fs/2 component is stored as the imaginary part of the DC component
      mFFTBuffer[1] = record.mImagFFTs[0];
 
      // Invert the FFT into the output buffer
      InverseRealFFTf(mFFTBuffer.data(), hFFT.get());
 
      // Overlap-add
      if (mOutWindow.size() > 0) {
         auto pOut = mOutOverlapBuffer.data();
         auto pWindow = mOutWindow.data();
         auto pBitReversed = &hFFT->BitReversed[0];
         for (size_t jj = 0; jj < last; ++jj) {
            auto kk = *pBitReversed++;
            *pOut++ += mFFTBuffer[kk] * (*pWindow++);
            *pOut++ += mFFTBuffer[kk + 1] * (*pWindow++);
         }
      }
      else {
         auto pOut = mOutOverlapBuffer.data();
         auto pBitReversed = &hFFT->BitReversed[0];
         for (size_t jj = 0; jj < last; ++jj) {
            auto kk = *pBitReversed++;
            *pOut++ += mFFTBuffer[kk];
            *pOut++ += mFFTBuffer[kk + 1];
         }
      }
      auto buffer = mOutOverlapBuffer.data();
      if (mOutStepCount >= 0) {
         // Output the first portion of the overlap buffer, they're done
         DoOutput(buffer, mStepSize);
      }
      // Shift the remainder over.
      memmove(buffer, buffer + mStepSize, sizeof(float)*(mWindowSize - mStepSize));
      std::fill(buffer + mWindowSize - mStepSize, buffer + mWindowSize, 0.0f);
   }
}

References DoOutput(), hFFT, InverseRealFFTf(), mFFTBuffer, SpectrumTransformer::Window::mImagFFTs, mNeedsOutput, mOutOverlapBuffer, mOutStepCount, mOutWindow, mQueue, SpectrumTransformer::Window::mRealFFTs, mSpectrumSize, mStepSize, mWindowSize, and QueueIsFull().

Referenced by ProcessSamples().

Here is the call graph for this function:

Here is the caller graph for this function:

ProcessSamples()

bool SpectrumTransformer::ProcessSamples	(	const WindowProcessor &	processor,
		const float *	buffer,
		size_t	len
	)

Call multiple times.

Parameters

buffer

null if flushing the end

Returns

success

Definition at line 146 of file SpectrumTransformer.cpp.

{
   if (buffer)
      mInSampleCount += len;
   bool success = true;
   while (success && len &&
          mOutStepCount * static_cast<int>(mStepSize) < mInSampleCount) {
      auto avail = std::min(len, mWindowSize - mInWavePos);
      if (buffer)
         memmove(&mInWaveBuffer[mInWavePos], buffer, avail * sizeof(float));
      else
         memset(&mInWaveBuffer[mInWavePos], 0, avail * sizeof(float));
      if (buffer)
         buffer += avail;
      len -= avail;
      mInWavePos += avail;
 
      if (mInWavePos == mWindowSize) {
         FillFirstWindow();
 
         // invoke derived method
         if ( (success = processor(*this)), success )
            OutputStep();
 
         ++mOutStepCount;
         RotateWindows();
 
         // Shift input.
         memmove(mInWaveBuffer.data(), &mInWaveBuffer[mStepSize],
            (mWindowSize - mStepSize) * sizeof(float));
         mInWavePos -= mStepSize;
      }
   }
 
   return success;
}

References FillFirstWindow(), min(), mInSampleCount, mInWaveBuffer, mInWavePos, mOutStepCount, mStepSize, mWindowSize, OutputStep(), and RotateWindows().

Referenced by Finish(), and TrackSpectrumTransformer::Process().

Here is the call graph for this function:

Here is the caller graph for this function:

QueueIsFull()

bool SpectrumTransformer::QueueIsFull

(

)

const

Whether the last window in the queue overlapped the input at least partially and its coefficients will affect output.

Definition at line 326 of file SpectrumTransformer.cpp.

{
   if (mLeadingPadding)
      return (mOutStepCount >= -static_cast<int>(mStepsPerWindow - 1));
   else
      return (mOutStepCount >= 0);
}

References mLeadingPadding, mOutStepCount, and mStepsPerWindow.

Referenced by OutputStep(), and NoiseReductionBase::Worker::ReduceNoise().

Here is the caller graph for this function:

ResizeQueue()

void SpectrumTransformer::ResizeQueue ( size_t  queueLength )

private

Definition at line 184 of file SpectrumTransformer.cpp.

{
   int oldLen = mQueue.size();
   mQueue.resize(queueLength);
   for (size_t ii = oldLen; ii < queueLength; ++ii)
      // invoke derived method to get a queue element
      // with appropriate extra fields
      mQueue[ii] = NewWindow(mWindowSize);
}

References mQueue, mWindowSize, and NewWindow().

Referenced by Start().

Here is the call graph for this function:

Here is the caller graph for this function:

RotateWindows()

void SpectrumTransformer::RotateWindows ( )

private

Definition at line 231 of file SpectrumTransformer.cpp.

{
   std::rotate(mQueue.begin(), mQueue.end() - 1, mQueue.end());
}

References mQueue, and staffpad::vo::rotate().

Referenced by ProcessSamples().

Here is the call graph for this function:

Here is the caller graph for this function:

Start()

bool SpectrumTransformer::Start

(

size_t

queueLength

)

Call once before a sequence of calls to ProcessSamples; Invokes DoStart.

Returns

success

Definition at line 102 of file SpectrumTransformer.cpp.

{
   // Prepare clean queue
   ResizeQueue(queueLength);
   for (auto &pWindow : mQueue)
      pWindow->Zero();
 
   // invoke derived method
   if (!DoStart())
      return false;
 
   // Clean input and output buffers
   {
      float *pFill;
      pFill = mInWaveBuffer.data();
      std::fill(pFill, pFill + mWindowSize, 0.0f);
      pFill = mOutOverlapBuffer.data();
      std::fill(pFill, pFill + mWindowSize, 0.0f);
   }
 
   if (!mLeadingPadding)
   {
      // We do not want leading zero padded windows
      mInWavePos = 0;
      mOutStepCount = -static_cast<int>(queueLength - 1);
   }
   else
   {
      // So that the queue gets primed with some windows,
      // zero-padded in front, the first having mStepSize
      // samples of wave data:
      mInWavePos = mWindowSize - mStepSize;
      // This starts negative, to count up until the queue fills:
      mOutStepCount = -static_cast<int>(queueLength - 1)
         // ... and then must pass over the padded windows,
         // before the first full window:
         - static_cast<int>(mStepsPerWindow - 1);
   }
 
   mInSampleCount = 0;
 
   return true;
}

References DoStart(), mInSampleCount, mInWaveBuffer, mInWavePos, mLeadingPadding, mOutOverlapBuffer, mOutStepCount, mQueue, mStepSize, mStepsPerWindow, mWindowSize, and ResizeQueue().

Referenced by TrackSpectrumTransformer::Process().

Here is the call graph for this function:

Here is the caller graph for this function:

TotalQueueSize()

size_t SpectrumTransformer::TotalQueueSize ( ) const

inline

Useful functions to implement WindowProcesser:

How many windows in the queue have been allocated?

Definition at line 129 of file SpectrumTransformer.h.

{ return mQueue.size(); }

Member Data Documentation

hFFT

HFFT SpectrumTransformer::hFFT

private

Definition at line 165 of file SpectrumTransformer.h.

Referenced by FillFirstWindow(), and OutputStep().

mFFTBuffer

FloatVector SpectrumTransformer::mFFTBuffer

private

These have size mWindowSize:

Definition at line 171 of file SpectrumTransformer.h.

Referenced by FillFirstWindow(), and OutputStep().

mInSampleCount

sampleCount SpectrumTransformer::mInSampleCount = 0

private

Definition at line 166 of file SpectrumTransformer.h.

Referenced by Finish(), ProcessSamples(), and Start().

mInWaveBuffer

FloatVector SpectrumTransformer::mInWaveBuffer

private

Definition at line 172 of file SpectrumTransformer.h.

Referenced by FillFirstWindow(), ProcessSamples(), and Start().

mInWavePos

size_t SpectrumTransformer::mInWavePos = 0

private

Definition at line 168 of file SpectrumTransformer.h.

Referenced by ProcessSamples(), and Start().

mInWindow

FloatVector SpectrumTransformer::mInWindow

private

These have size mWindowSize, or 0 for rectangular window:

Definition at line 175 of file SpectrumTransformer.h.

Referenced by FillFirstWindow(), and SpectrumTransformer().

mLeadingPadding

const bool SpectrumTransformer::mLeadingPadding

protected

Definition at line 159 of file SpectrumTransformer.h.

Referenced by CurrentQueueSize(), QueueIsFull(), and Start().

mNeedsOutput

const bool SpectrumTransformer::mNeedsOutput

private

Definition at line 178 of file SpectrumTransformer.h.

Referenced by OutputStep().

mOutOverlapBuffer

FloatVector SpectrumTransformer::mOutOverlapBuffer

private

Definition at line 173 of file SpectrumTransformer.h.

Referenced by OutputStep(), and Start().

mOutStepCount

sampleCount SpectrumTransformer::mOutStepCount = 0

private

sometimes negative

Definition at line 167 of file SpectrumTransformer.h.

Referenced by CurrentQueueSize(), Finish(), OutputStep(), ProcessSamples(), QueueIsFull(), and Start().

mOutWindow

FloatVector SpectrumTransformer::mOutWindow

private

Definition at line 176 of file SpectrumTransformer.h.

Referenced by OutputStep(), and SpectrumTransformer().

mQueue

std::vector<std::unique_ptr<Window> > SpectrumTransformer::mQueue

private

Definition at line 164 of file SpectrumTransformer.h.

Referenced by CurrentQueueSize(), OutputStep(), ResizeQueue(), RotateWindows(), and Start().

mSpectrumSize

const size_t SpectrumTransformer::mSpectrumSize

protected

Definition at line 154 of file SpectrumTransformer.h.

Referenced by FillFirstWindow(), and OutputStep().

mStepSize

const size_t SpectrumTransformer::mStepSize

protected

Definition at line 157 of file SpectrumTransformer.h.

Referenced by TrackSpectrumTransformer::DoOutput(), Finish(), OutputStep(), ProcessSamples(), SpectrumTransformer(), and Start().

mStepsPerWindow

const unsigned SpectrumTransformer::mStepsPerWindow

protected

Definition at line 156 of file SpectrumTransformer.h.

Referenced by CurrentQueueSize(), QueueIsFull(), SpectrumTransformer(), and Start().

mTrailingPadding

const bool SpectrumTransformer::mTrailingPadding

protected

Definition at line 161 of file SpectrumTransformer.h.

Referenced by Finish().

mWindowSize

const size_t SpectrumTransformer::mWindowSize

protected

Definition at line 153 of file SpectrumTransformer.h.

Referenced by FillFirstWindow(), OutputStep(), ProcessSamples(), ResizeQueue(), SpectrumTransformer(), and Start().

---

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

• SpectrumTransformer.h
• SpectrumTransformer.cpp