Be less messy with PFFFT

Remove a 1-element array for an over-allocated struct array. Also add a wrapper
struct for C++.

1 files changed, 8 insertions, 15 deletions

diff --git a/core/uhjfilter.cpp b/core/uhjfilter.cpp
index 28999e09..e507d705 100644
--- a/core/uhjfilter.cpp
+++ b/core/uhjfilter.cpp
@@ -20,11 +20,6 @@ UhjQualityType UhjEncodeQuality{UhjQualityType::Default};
 
 namespace {
 
-struct PFFFTSetupDeleter {
-    void operator()(PFFFT_Setup *ptr) { pffft_destroy_setup(ptr); }
-};
-using PFFFTSetupPtr = std::unique_ptr<PFFFT_Setup,PFFFTSetupDeleter>;
-
 /* Convolution is implemented using a segmented overlap-add method. The filter
  * response is broken up into multiple segments of 128 samples, and each
  * segment has an FFT applied with a 256-sample buffer (the latter half left
@@ -57,13 +52,11 @@ struct SegmentedFilter {
     static_assert(N >= sFftLength);
     static_assert((N % sSampleLength) == 0);
 
-    PFFFTSetupPtr mFft;
+    PFFFTSetup mFft;
     alignas(16) std::array<float,sFftLength*sNumSegments> mFilterData;
 
-    SegmentedFilter()
+    SegmentedFilter() : mFft{sFftLength, PFFFT_REAL}
     {
-        mFft = PFFFTSetupPtr{pffft_new_setup(sFftLength, PFFFT_REAL)};
-
         using complex_d = std::complex<double>;
         constexpr size_t fft_size{N};
         constexpr size_t half_size{fft_size / 2};
@@ -113,7 +106,7 @@ struct SegmentedFilter {
                 fftTmp[i*2 + 1] = static_cast<float>((i == 0) ? fftBuffer2[sSampleLength].real()
                     : fftBuffer2[i].imag()) / float{sFftLength};
             }
-            pffft_zreorder(mFft.get(), fftTmp.data(), filter, PFFFT_BACKWARD);
+            mFft.zreorder(fftTmp.data(), filter, PFFFT_BACKWARD);
             filter += sFftLength;
         }
     }
@@ -246,7 +239,7 @@ void UhjEncoder<N>::encode(float *LeftOut, float *RightOut,
         std::copy_n(mWXInOut.begin(), sSegmentSize, input);
         std::fill_n(input+sSegmentSize, sSegmentSize, 0.0f);
 
-        pffft_transform(Filter.mFft.get(), input, input, mWorkData.data(), PFFFT_FORWARD);
+        Filter.mFft.transform(input, input, mWorkData.data(), PFFFT_FORWARD);
 
         /* Convolve each input segment with its IR filter counterpart (aligned
          * in time, from newest to oldest).
@@ -255,14 +248,14 @@ void UhjEncoder<N>::encode(float *LeftOut, float *RightOut,
         const float *filter{Filter.mFilterData.data()};
         for(size_t s{curseg};s < sNumSegments;++s)
         {
-            pffft_zconvolve_accumulate(Filter.mFft.get(), input, filter, mFftBuffer.data());
+            Filter.mFft.zconvolve_accumulate(input, filter, mFftBuffer.data());
             input += sFftLength;
             filter += sFftLength;
         }
         input = mWXHistory.data();
         for(size_t s{0};s < curseg;++s)
         {
-            pffft_zconvolve_accumulate(Filter.mFft.get(), input, filter, mFftBuffer.data());
+            Filter.mFft.zconvolve_accumulate(input, filter, mFftBuffer.data());
             input += sFftLength;
             filter += sFftLength;
         }
@@ -270,8 +263,8 @@ void UhjEncoder<N>::encode(float *LeftOut, float *RightOut,
         /* Convert back to samples, writing to the output and storing the extra
          * for next time.
          */
-        pffft_transform(Filter.mFft.get(), mFftBuffer.data(), mFftBuffer.data(),
-            mWorkData.data(), PFFFT_BACKWARD);
+        Filter.mFft.transform(mFftBuffer.data(), mFftBuffer.data(), mWorkData.data(),
+            PFFFT_BACKWARD);
 
         for(size_t i{0};i < sSegmentSize;++i)
             mWXInOut[i] = mFftBuffer[i] + mWXInOut[sSegmentSize+i];