PowerSpectrumGetter.h

Go to the documentation of this file.

/*  SPDX-License-Identifier: GPL-2.0-or-later */
/*!********************************************************************
 
  Audacity: A Digital Audio Editor
 
  PowerSpectrumGetter.h
 
  Matthieu Hodgkinson
 
**********************************************************************/
#pragma once
 
struct PFFFT_Setup;
 
#include <memory>
#include <type_traits>
#include <vector>
#include "pffft.h"
 
struct FFT_API PffftSetupDeleter {
   void operator ()(PFFFT_Setup *p){ if (p) Pffft_destroy_setup(p); }
private:
  void Pffft_destroy_setup(PFFFT_Setup *);
};
using PffftSetupHolder = std::unique_ptr<PFFFT_Setup, PffftSetupDeleter>;
 
struct FFT_API PffftAllocatorBase {
   static void *Pffft_aligned_malloc(size_t nb_bytes);
   static void Pffft_aligned_free(void *);
};
 
template<typename T> struct PffftAllocator
   : std::allocator<T>, protected PffftAllocatorBase
{
   PffftAllocator() {}
   PffftAllocator(const PffftAllocator&) {}
   template<typename U> PffftAllocator(const PffftAllocator<U>&) {}
 
   template<typename U> struct rebind { using other = PffftAllocator<U>; };
   T* allocate(std::size_t n, const void *) {
      return allocate(n);
   }
   T* allocate(std::size_t n) {
      return static_cast<T*>(Pffft_aligned_malloc(n * sizeof(T)));
   }
   void deallocate(T *p, std::size_t n) {
      if (p) Pffft_aligned_free(p);
   }
};
 
struct PffftAlignedCount
{
   // see source for pffft_aligned_malloc
   static constexpr size_t ByteAlignment = 64;
   static constexpr auto FloatAlignment = ByteAlignment / sizeof(float);
 
   PffftAlignedCount() = default;
 
   explicit PffftAlignedCount(size_t nFloats)
      : value{
         ((nFloats + (FloatAlignment) - 1) / FloatAlignment) * FloatAlignment }
   {}
 
   PffftAlignedCount(const PffftAlignedCount &) = default;
   PffftAlignedCount &operator =(const PffftAlignedCount &) = default;
 
   operator size_t() const { return value; }
 
private:
   size_t value{};
};
 
template<typename Integral>
inline auto operator * (PffftAlignedCount x, Integral y)
   -> std::enable_if_t<
      std::is_unsigned_v<Integral> && sizeof(Integral) <= sizeof(size_t),
      PffftAlignedCount>
{
   return PffftAlignedCount(static_cast<size_t>(x) * y);
}
 
template<typename Integral>
inline auto operator * (Integral x, PffftAlignedCount y)
   -> std::enable_if_t<
      std::is_unsigned_v<Integral> && sizeof(Integral) <= sizeof(size_t),
      PffftAlignedCount>
{
   return PffftAlignedCount(x * static_cast<size_t>(y));
}
 
struct PffftFloatVector;
 
 
struct PffftFloats {
   PffftFloats() = default;
   PffftFloats(const PffftFloats&) = default;
   PffftFloats &operator=(const PffftFloats&) = default;
 
   float *get() const noexcept { return p; }
 
   PffftFloats operator +=(PffftAlignedCount c) {
      p += c; return *this;
   }
   friend PffftFloats operator + (PffftFloats p, PffftAlignedCount c)
   {
      PffftFloats result(p);
      return result += c;
   }
   friend PffftFloats operator + (PffftAlignedCount c, PffftFloats p)
   {
      PffftFloats result(p);
      return result += c;
   }
 
   explicit operator bool() const noexcept { return p != nullptr; }
 
private:
   explicit PffftFloats(float *p) : p{ p } {}
   friend PffftFloatVector;
   float *p{};
};
 
 
struct PffftConstFloats {
   PffftConstFloats() = default;
   PffftConstFloats(const PffftConstFloats&) = default;
   PffftConstFloats &operator=(const PffftConstFloats&) = default;
   PffftConstFloats(PffftFloats p) : PffftConstFloats{ p.get() } {}
 
   const float *get() const noexcept { return p; }
 
   PffftConstFloats operator +=(PffftAlignedCount c) {
      p += c; return *this;
   }
   friend PffftConstFloats operator + (PffftConstFloats p, PffftAlignedCount c)
   {
      PffftConstFloats result(p);
      return result += c;
   }
   friend PffftConstFloats operator + (PffftAlignedCount c, PffftConstFloats p)
   {
      PffftConstFloats result(p);
      return result += c;
   }
 
   explicit operator bool() const noexcept { return p != nullptr; }
 
private:
   explicit PffftConstFloats(const float *p) : p{ p } {}
   friend PffftFloatVector;
   const float *p{};
};
 
 
struct FFT_API PffftFloatVector : std::vector<float, PffftAllocator<float>> {
   using std::vector<float, PffftAllocator<float>>::vector;
   PffftFloats aligned(PffftAlignedCount c = {});
   PffftConstFloats aligned(PffftAlignedCount c = {}) const;
 
   PffftFloats aligned(PffftAlignedCount rowSize, size_t nRow)
   { return aligned(rowSize * nRow); }
 
   PffftConstFloats aligned(PffftAlignedCount rowSize, size_t nRow) const
   { return aligned(rowSize * nRow); }
};
 
class FFT_API PowerSpectrumGetter
{
public:
   explicit PowerSpectrumGetter(int fftSize);
   ~PowerSpectrumGetter();
 
   void operator()(PffftFloats alignedBuffer, PffftFloats alignedOutput);
 
private:
   const int mFftSize;
   PffftSetupHolder mSetup;
   PffftFloatVector mWork;
};