SpectrumTransformer.h

Go to the documentation of this file.

/*!********************************************************************
 
Audacity: A Digital Audio Editor
 
SpectrumTransformer.h
@brief Transformer of sample sequences by FFT, coefficient changes, inverse FFT, overlap-add
 
Paul Licameli
 
**********************************************************************/
 
#ifndef __AUDACITY_SPECTRUM_TRANSFORMER__
#define __AUDACITY_SPECTRUM_TRANSFORMER__
 
#include <functional>
#include <memory>
#include <vector>
#include "audacity/Types.h"
#include "RealFFTf.h"
#include "SampleCount.h"
 
enum eWindowFunctions : int;
 
class SpectrumTransformer /* not final */
{
public:
   // Public interface
   using FloatVector = std::vector<float>;
 
 
   using WindowProcessor = std::function< bool(SpectrumTransformer&) >;
 
   SpectrumTransformer(
      bool needsOutput, 
      eWindowFunctions inWindowType, 
      eWindowFunctions outWindowType, 
      size_t windowSize,     
      unsigned stepsPerWindow, 
      bool leadingPadding, 
      bool trailingPadding 
   );
   virtual ~SpectrumTransformer();
 
   bool NeedsOutput() const { return mNeedsOutput; }
 
 
   bool Start(size_t queueLength);
 
 
   bool ProcessSamples(const WindowProcessor &processor,
      const float *buffer, size_t len);
 
 
   bool Finish(const WindowProcessor &processor);
 
   struct Window
   {
      explicit Window(size_t windowSize)
         : mRealFFTs( windowSize / 2 )
         , mImagFFTs( windowSize / 2 )
      {
      }
 
      virtual ~Window();
 
      void Zero()
      {
         const auto size = mRealFFTs.size();
         auto pFill = mRealFFTs.data();
         std::fill(pFill, pFill + size, 0.0f);
         pFill = mImagFFTs.data();
         std::fill(pFill, pFill + size, 0.0f);
      }
 
      FloatVector mRealFFTs;
      FloatVector mImagFFTs;
   };
 
 
   virtual std::unique_ptr<Window> NewWindow(size_t windowSize);
 
 
   virtual bool DoStart();
 
   virtual void DoOutput(const float *outBuffer, size_t mStepSize) = 0;
 
 
   virtual bool DoFinish();
 
 
   size_t TotalQueueSize() const { return mQueue.size(); }
 
 
   size_t CurrentQueueSize() const;
 
   bool QueueIsFull() const;
 
 
   Window &Nth(int n) { return *mQueue[n]; }
 
   Window &Newest() { return **mQueue.begin(); }
   Window &Latest() { return **mQueue.rbegin(); }
 
private:
   void ResizeQueue(size_t queueLength);
   void FillFirstWindow();
   void RotateWindows();
   void OutputStep();
 
protected:
   const size_t mWindowSize;
   const size_t mSpectrumSize;
 
   const unsigned mStepsPerWindow;
   const size_t mStepSize;
   
   const bool mLeadingPadding;
 
   const bool mTrailingPadding;
 
private:
   std::vector<std::unique_ptr<Window>> mQueue;
   HFFT     hFFT;
   sampleCount mInSampleCount = 0;
   sampleCount mOutStepCount = 0; 
   size_t mInWavePos = 0;
 
   FloatVector mFFTBuffer;
   FloatVector mInWaveBuffer;
   FloatVector mOutOverlapBuffer;
   FloatVector mInWindow;
   FloatVector mOutWindow;
 
   const bool mNeedsOutput;
};
 
class WaveTrack;
 
class TrackSpectrumTransformer /* not final */ : public SpectrumTransformer {
public:
   using SpectrumTransformer::SpectrumTransformer;
   ~TrackSpectrumTransformer() override;
 
   bool Process( const WindowProcessor &processor, WaveTrack *track,
      size_t queueLength, sampleCount start, sampleCount len);
 
protected:
   bool DoStart() override;
   void DoOutput(const float *outBuffer, size_t mStepSize) override;
   bool DoFinish() override;
 
private:
   WaveTrack *mpTrack = nullptr;
   std::shared_ptr<WaveTrack> mOutputTrack;
   sampleCount mStart = 0, mLen = 0;
};
 
#endif