From 36f9bf0161de90f8d6c446e5100f788b95a5bee5 Mon Sep 17 00:00:00 2001
From: weefuzzy <gungwho@gmail.com>
Date: Thu, 28 Apr 2022 11:26:18 +0100
Subject: [PATCH 1/6] CMake: Centralise C++ version and set to 17

---
 CMakeLists.txt | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 00e37b8f7..68029db94 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -8,6 +8,10 @@
 
 cmake_minimum_required (VERSION 3.11)
 
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
 get_directory_property(hasParent PARENT_DIRECTORY)
 
 #set module path at top level so wrapper projects can easily include fluid_version script
@@ -127,9 +131,6 @@ target_link_libraries(
 target_include_directories(HISSTools_FFT PUBLIC "${hisstools_SOURCE_DIR}")
 
 set_target_properties(HISSTools_FFT PROPERTIES
-    CXX_STANDARD 14
-    CXX_STANDARD_REQUIRED ON
-    CXX_EXTENSIONS OFF
     POSITION_INDEPENDENT_CODE ON
 )
 
@@ -152,11 +153,6 @@ add_library(
   "${hisstools_SOURCE_DIR}/AudioFile/OAudioFile.cpp"
 )
 
-set_target_properties(HISSTools_AudioFile PROPERTIES
-    CXX_STANDARD 14
-    CXX_STANDARD_REQUIRED ON
-    CXX_EXTENSIONS OFF
-)
 
 #Fluid Decomposition header-only target
 add_library(FLUID_DECOMPOSITION INTERFACE)

From c1a92fc7c14929361a57f18d90a76aabc4fe7efd Mon Sep 17 00:00:00 2001
From: weefuzzy <gungwho@gmail.com>
Date: Thu, 28 Apr 2022 11:28:56 +0100
Subject: [PATCH 2/6] =?UTF-8?q?Introduce=20long=20param=20type=20with=20a?=
 =?UTF-8?q?=20user-defined=20maximum=20+=20'primary'=20params=20=20?=
 =?UTF-8?q?=E2=80=93=C2=A0e.g.=20max=20coeffs=20for=20MFCC)=20=20-=20decou?=
 =?UTF-8?q?pling=20Max/PD=20arguments=20from=20'fixed'=20params=20?=
 =?UTF-8?q?=E2=80=93?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 include/clients/common/FluidBaseClient.hpp    |  12 +-
 .../clients/common/FluidNRTClientWrapper.hpp  |   8 +-
 .../clients/common/ParameterConstraints.hpp   |  25 +++-
 include/clients/common/ParameterSet.hpp       |  69 +++++++++-
 include/clients/common/ParameterTypes.hpp     | 125 ++++++++++++++++--
 include/clients/common/Result.hpp             |   6 +-
 .../nrt/FluidSharedInstanceAdaptor.hpp        |   6 +
 7 files changed, 215 insertions(+), 36 deletions(-)

diff --git a/include/clients/common/FluidBaseClient.hpp b/include/clients/common/FluidBaseClient.hpp
index 5a839b821..76490e323 100644
--- a/include/clients/common/FluidBaseClient.hpp
+++ b/include/clients/common/FluidBaseClient.hpp
@@ -33,7 +33,8 @@ enum ProcessState { kNoProcess, kProcessing, kDone, kDoneStillProcessing };
 
 struct ControlChannel {
   index count{0}; 
-  index size{-1}; 
+  index size{-1};
+  index max{-1}; 
 }; 
 
 class FluidBaseClient
@@ -47,7 +48,7 @@ class FluidBaseClient
   ControlChannel controlChannelsOut() const noexcept { return mControlChannelsOut; }
   index maxControlChannelsOut() const noexcept
   {
-    return mMaxControlChannelsOut;
+    return mControlChannelsOut.max > -1 ? mControlChannelsOut.max : mControlChannelsOut.size;
   }
   bool   controlTrigger() const noexcept { return mControlTrigger; }
   index  audioBuffersIn() const noexcept { return mBuffersIn; }
@@ -71,10 +72,6 @@ class FluidBaseClient
   void audioChannelsOut(const index x) noexcept { mAudioChannelsOut = x; }
   void controlChannelsIn(const index x) noexcept { mControlChannelsIn = x; }
   void controlChannelsOut(const ControlChannel x) noexcept { mControlChannelsOut = x; }
-  void maxControlChannelsOut(const index x) noexcept
-  {
-    mMaxControlChannelsOut = x;
-  }
   void controlTrigger(const bool x) noexcept { mControlTrigger = x; }
   void audioBuffersIn(const index x) noexcept { mBuffersIn = x; }
   void audioBuffersOut(const index x) noexcept { mBuffersOut = x; }
@@ -97,8 +94,7 @@ class FluidBaseClient
   index  mAudioChannelsIn = 0;
   index  mAudioChannelsOut = 0;
   index  mControlChannelsIn = 0;
-  ControlChannel  mControlChannelsOut {0,0};
-  index  mMaxControlChannelsOut = 0;
+  ControlChannel  mControlChannelsOut {0,0,-1};
   bool   mControlTrigger{false};
   index  mBuffersIn = 0;
   index  mBuffersOut = 0;
diff --git a/include/clients/common/FluidNRTClientWrapper.hpp b/include/clients/common/FluidNRTClientWrapper.hpp
index b87f75c63..8b298392b 100644
--- a/include/clients/common/FluidNRTClientWrapper.hpp
+++ b/include/clients/common/FluidNRTClientWrapper.hpp
@@ -528,7 +528,7 @@ struct StreamingControl
   {
     // To account for process latency we need to copy the buffers with padding
     std::vector<HostMatrix> inputData;
-    index                   nFeatures = client.controlChannelsOut().size;
+    index                   maxFeatures = client.maxControlChannelsOut();
     //      outputData.reserve(nFeatures);
     inputData.reserve(inputBuffers.size());
 
@@ -557,7 +557,7 @@ struct StreamingControl
     std::fill_n(std::back_inserter(inputData), inputBuffers.size(),
                 HostMatrix(nChans, nFrames + totalPadding));
 
-    HostMatrix outputData(nChans * nFeatures, nHops);
+    HostMatrix outputData(nChans * maxFeatures, nHops);
     double     sampleRate{0};
     // Copy input data
     for (index i = 0; i < nChans; ++i)
@@ -591,7 +591,7 @@ struct StreamingControl
 
         // for (index k = 0; k < nFeatures; ++k)
         //   outputs.emplace_back(outputData.row(k + i * nFeatures)(Slice(j, 1)));
-        outputs.push_back(outputData.col(j)(Slice(i * nFeatures, nFeatures)));
+        outputs.push_back(outputData.col(j)(Slice(i * maxFeatures, maxFeatures)));
 
         client.process(inputs, outputs, dummyContext);
 
@@ -603,7 +603,7 @@ struct StreamingControl
     }
 
     BufferAdaptor::Access thisOutput(outputBuffers[0]);
-
+    index nFeatures = client.controlChannelsOut().size;
     index latencyHops = client.latency() / controlRate;
     index keepHops = nHops - latencyHops;
 
diff --git a/include/clients/common/ParameterConstraints.hpp b/include/clients/common/ParameterConstraints.hpp
index 38bc0d6d9..0991ed729 100644
--- a/include/clients/common/ParameterConstraints.hpp
+++ b/include/clients/common/ParameterConstraints.hpp
@@ -35,7 +35,22 @@ struct MinImpl
   constexpr void clamp(U& x, Tuple& /*params*/, Descriptor& d, Result* r) const
   {
     U oldX = x;
-    x = std::max<U>(x, value);
+    x = std::max<U>(x, static_cast<U>(value));
+    if (r && oldX != x)
+    {
+      r->set(Result::Status::kWarning);
+      r->addMessage(d.template get<N>().name, " value, ", oldX,
+                    ", below absolute minimum ", x);
+    }
+  }
+  
+  template <size_t Offset, size_t N, typename Tuple,
+            typename Descriptor>
+  constexpr void clamp(LongRuntimeMaxParam& x, Tuple& /*params*/, Descriptor& d, Result* r) const
+  {
+    index oldX = x();
+    index newx = std::max<index>(x(), value);
+    x.set(newx); 
     if (r && oldX != x)
     {
       r->set(Result::Status::kWarning);
@@ -75,17 +90,17 @@ struct LowerLimitImpl : public Relational
   {
     T oldV = v;
 
-    v = std::max<T>({v, std::get<Is + Offset>(params)...});
+    v = std::max<T>({v, std::get<Is + Offset>(params).get()...});
 
     if (r && oldV != v)
     {
       r->set(Result::Status::kWarning);
       std::array<T, sizeof...(Is)> constraintValues{
-          {std::get<Is + Offset>(params)...}};
+          {std::get<Is + Offset>(params).get()...}};
       index minPos = std::distance(
           constraintValues.begin(),
           std::min_element(constraintValues.begin(), constraintValues.end()));
-      std::array<const char*, sizeof...(Is)> constraintNames{
+      std::array<std::string_view, sizeof...(Is)> constraintNames{
           {d.template get<Is + Offset>().name...}};
       r->addMessage(d.template get<N>().name, " value (", oldV,
                     ") below parameter ", constraintNames[asUnsigned(minPos)],
@@ -113,7 +128,7 @@ struct UpperLimitImpl : public Relational
       index maxPos = std::distance(
           constraintValues.begin(),
           std::max_element(constraintValues.begin(), constraintValues.end()));
-      std::array<const char*, sizeof...(Is)> constraintNames{
+      std::array<std::string_view, sizeof...(Is)> constraintNames{
           {d.template get<Is + Offset>().name...}};
       r->addMessage(d.template get<N>().name, " value, ", oldV,
                     ", above parameter ", constraintNames[asUnsigned(maxPos)],
diff --git a/include/clients/common/ParameterSet.hpp b/include/clients/common/ParameterSet.hpp
index d57b2d7ee..4df01e835 100644
--- a/include/clients/common/ParameterSet.hpp
+++ b/include/clients/common/ParameterSet.hpp
@@ -16,6 +16,9 @@ under the European Union’s Horizon 2020 research and innovation programme
 #include "../../data/FluidIndex.hpp"
 #include <functional>
 #include <tuple>
+#include <type_traits>
+		
+
 
 namespace fluid {
 namespace client {
@@ -29,16 +32,41 @@ class ParameterDescriptorSet;
 template <size_t... Os, typename... Ts>
 class ParameterDescriptorSet<std::index_sequence<Os...>, std::tuple<Ts...>>
 {
+  
+  
+  template<size_t N, typename Tuple>
+  using tuple_element_t = typename std::tuple_element<N,Tuple>::type;
+  
+  struct IsPrimary
+  {
+    template <typename T>
+    using apply = std::is_same<Primary,tuple_element_t<2,T>>;
+  };
+  
   template <bool B>
   struct FixedParam
   {
     template <typename T>
-    using apply =
-        std::is_same<Fixed<B>, typename std::tuple_element<2, T>::type>;
+    using apply = std::is_same<Fixed<B>, tuple_element_t<2,T>>;
   };
-
-  using IsFixed = FixedParam<true>;
-  using IsMutable = FixedParam<false>;
+  
+  struct IsFixed
+  {
+    template <typename T>
+    using apply = std::is_same<Fixed<true>, tuple_element_t<2,T>>;
+  };
+  
+  struct IsMutable
+  {
+    template <typename T>
+    using apply = std::disjunction<
+      std::is_same<Fixed<false>, tuple_element_t<2,T>>,
+      std::is_same<Primary, tuple_element_t<2,T>>>;  
+  };
+  
+    
+//  using IsFixed = FixedParam<true>;
+//  using IsMutable = FixedParam<false>;
 
   struct IsRelational
   {
@@ -79,6 +107,9 @@ class ParameterDescriptorSet<std::index_sequence<Os...>, std::tuple<Ts...>>
 
   // clang < 3.7: index_sequence_for doesn't work here
   using IndexList = std::make_index_sequence<sizeof...(Ts)>;
+  
+  using PrimaryIndexList = typename impl::FilterTupleIndices<IsPrimary, DescriptorType,IndexList>::type;
+  
   using FixedIndexList =
       typename impl::FilterTupleIndices<IsFixed, DescriptorType,
                                         IndexList>::type;
@@ -105,6 +136,7 @@ class ParameterDescriptorSet<std::index_sequence<Os...>, std::tuple<Ts...>>
         typename impl::FilterTupleIndices<T, DescriptorType, IndexList>::type::size();
   }
 
+  static constexpr index NumPrimaryParams = PrimaryIndexList::size();
   static constexpr index NumFixedParams = FixedIndexList::size();
   static constexpr index NumMutableParams = MutableIndexList::size();
 
@@ -124,6 +156,14 @@ class ParameterDescriptorSet<std::index_sequence<Os...>, std::tuple<Ts...>>
     iterateImpl<Func>(IndexList(), std::forward<Args>(args)...);
   }
 
+  template<class Func>
+  void iteratePrimary(Func&& func) const
+  {
+    ForThese(mDescriptors,
+            [](auto& d, auto idx, auto&& f){ f(std::get<0>(d),idx); },
+            PrimaryIndexList(), std::forward<Func>(func));
+  }
+  
   template <template <size_t N, typename T> class Func>
   void iterateFixed() const
   {
@@ -208,6 +248,7 @@ class ParameterSetView<
   
   using ValueRefTuple = typename DescriptorSetType::ValueRefTuple;
   using IndexList = typename DescriptorSetType::IndexList;
+  using PrimaryIndexList = typename DescriptorSetType::PrimaryIndexList;
   using FixedIndexList = typename DescriptorSetType::FixedIndexList;
   using MutableIndexList = typename DescriptorSetType::MutableIndexList;
 
@@ -281,6 +322,24 @@ class ParameterSetView<
                                         std::forward<Args>(args)...);
   }
 
+
+  template<typename Func,typename... Args>
+  std::array<Result, PrimaryIndexList::size()>
+  setPrimaryParameterValues(bool reportage, Func&& func, Args&&... args)
+  {
+    static std::array<Result, PrimaryIndexList::size()> results;
+    results.fill(Result(Result::Status::kOk)); 
+    
+    ForThese(mParams,[this,reportage,n=0u](auto&, auto idx, auto& res, Func&& f, auto&&... As) mutable
+    {
+        this->template set<idx()>(f(idx,std::forward<Args>(As)...),reportage ? &res[n++] : nullptr);
+    }, PrimaryIndexList(), results, std::forward<Func>(func), std::forward<Args>(args)...);
+    
+    
+    return constrainParameterValuesImpl(std::make_index_sequence<PrimaryIndexList::size()>(),
+                                 PrimaryIndexList());  
+  }
+
   template <template <size_t N, typename T> class Func, typename... Args>
   std::array<Result, FixedIndexList::size()>
   setFixedParameterValues(bool reportage, Args&&... args)
diff --git a/include/clients/common/ParameterTypes.hpp b/include/clients/common/ParameterTypes.hpp
index 378ceaedb..b7ebdad05 100644
--- a/include/clients/common/ParameterTypes.hpp
+++ b/include/clients/common/ParameterTypes.hpp
@@ -41,6 +41,8 @@ struct Fixed
   static bool constexpr value{b};
 };
 
+struct Primary {};
+
 struct ParamTypeBase
 {
   constexpr ParamTypeBase(const char* n, const char* display)
@@ -72,6 +74,7 @@ struct LongT : ParamTypeBase
   const type  defaultValue;
 };
 
+
 struct BufferT : ParamTypeBase
 {
   using type = BufferUnderlyingType;
@@ -249,12 +252,11 @@ struct ConstrainMaxFFTSize<true>
 class FFTParams
 {
 public:
-  constexpr FFTParams(intptr_t win, intptr_t hop, intptr_t fft)
-      : mWindowSize{win}, mHopSize{hop}, mFFTSize{fft}, trackWin{win},
-        trackHop{hop}, trackFFT{fft}
+  constexpr FFTParams(intptr_t win, intptr_t hop, intptr_t fft, intptr_t max = -1)
+      : mWindowSize{win}, mHopSize{hop}, mFFTSize{fft}, mMaxFFTSize{max},
+        trackWin{win}, trackHop{hop}, trackFFT{fft}
   {}
-
-
+  
   constexpr FFTParams(const FFTParams& p) noexcept = default;
   constexpr FFTParams(FFTParams&& p) noexcept = default;
 
@@ -264,7 +266,7 @@ class FFTParams
     mWindowSize = p.mWindowSize;
     mHopSize = p.mHopSize;
     mFFTSize = p.mFFTSize;
-
+    mMaxFFTSize = p.mMaxFFTSize;
     return *this;
   }
 
@@ -273,10 +275,15 @@ class FFTParams
     mWindowSize = p.mWindowSize;
     mHopSize = p.mHopSize;
     mFFTSize = p.mFFTSize;
-
+    mMaxFFTSize = p.mMaxFFTSize;
     return *this;
   }
 
+  index maxSize() const noexcept
+  {
+    return mMaxFFTSize;
+  }
+
   index fftSize() const noexcept
   {
     assert(mWindowSize >= 0 &&
@@ -424,9 +431,10 @@ class FFTParams
   };
 
 private:
-  intptr_t mWindowSize{0};
-  intptr_t mHopSize{0};
-  intptr_t mFFTSize{0};
+  intptr_t mWindowSize;
+  intptr_t mHopSize;
+  intptr_t mFFTSize;
+  intptr_t mMaxFFTSize;
 
   ParameterTrackChanges<intptr_t> trackWin;
   ParameterTrackChanges<intptr_t> trackHop;
@@ -440,13 +448,88 @@ struct FFTParamsT : ParamTypeBase
   constexpr FFTParamsT(const char* name, const char* displayName,
                        index winDefault, index hopDefault, index fftDefault)
       : ParamTypeBase(name, displayName), defaultValue{winDefault, hopDefault,
-                                                       fftDefault}
+                                                       fftDefault,-1}
   {}
 
   const index fixedSize = 3;
   const type  defaultValue;
 };
 
+class LongRuntimeMaxParam {
+public:
+  
+  constexpr LongRuntimeMaxParam(index val, index max)
+    : mValue(max < 0 ? val: std::min(val,max)), mMax(max < 0 ? val : max)
+  {}
+
+  constexpr LongRuntimeMaxParam(index val): LongRuntimeMaxParam(val,-1){}
+  //todo do I need this?
+  LongRuntimeMaxParam(std::reference_wrapper<index> val): LongRuntimeMaxParam(val.get(),-1){}
+
+  index operator()() const  { return mValue; }
+  operator fluid::index() const {return mValue; }
+  index max() const { return mMax; }
+  
+  void set(index val)
+  {
+    mValue = val;
+  }
+  
+  void clamp() { mValue = std::min(mValue,mMax);   }
+  
+  struct RuntimeMaxConstraint
+  {
+    template <index Offset, size_t N, typename Tuple, typename Descriptor>
+    constexpr void clamp(LongRuntimeMaxParam& v, Tuple&, Descriptor& d,
+                         Result* r) const
+    {
+       index oldValue = v;
+       v.clamp();
+       if(r && oldValue != v)
+       {
+          r->set(Result::Status::kWarning);
+          r->addMessage(d.template get<N>().name, " value, ", oldValue,
+                    ", above user defined maximum ", v.max());
+       }
+    }
+  };
+  
+  friend bool operator<(const LongRuntimeMaxParam& l, const LongRuntimeMaxParam& r)
+  {
+    return l() < r();
+  }
+  
+  friend bool operator>(const LongRuntimeMaxParam& l, const LongRuntimeMaxParam& r)
+  {
+    return r() < l();
+  }
+  
+  friend bool operator<=(const LongRuntimeMaxParam& l, const LongRuntimeMaxParam& r)
+  {
+    return !(l() > r());
+  }
+  
+  friend bool operator>=(const LongRuntimeMaxParam& l, const LongRuntimeMaxParam& r)
+  {
+    return !(l() < r());
+  }
+    
+private:
+  index mValue;
+  index mMax;
+};
+
+struct LongRuntimeMaxT: ParamTypeBase
+{
+  using type = LongRuntimeMaxParam;
+  constexpr LongRuntimeMaxT(const char* name, const char* displayName,
+                           index defaultValue)
+       : ParamTypeBase(name, displayName), defaultValue(defaultValue,-1)
+  {}
+  const index fixedSize = 2;
+  const type  defaultValue;
+};
+
 template <typename T, typename Fixed, typename... Constraints>
 using ParamSpec = std::tuple<T, std::tuple<Constraints...>, Fixed>;
 
@@ -543,6 +626,14 @@ FFTParam(const char* name, const char* displayName, index winDefault,
           Fixed<false>{}};
 }
 
+template<typename IsPrimary = Fixed<false>, typename...Constraints>
+constexpr ParamSpec<LongRuntimeMaxT,IsPrimary,LongRuntimeMaxParam::RuntimeMaxConstraint,Constraints...>
+LongParamRuntimeMax(const char* name, const char* displayName, index defaultValue,  const Constraints&&...c)
+{
+  return { LongRuntimeMaxT(name, displayName,defaultValue),
+            std::make_tuple(LongRuntimeMaxParam::RuntimeMaxConstraint(), std::forward<const Constraints>(c)...),
+            IsPrimary()};
+}
 
 template <typename IsFixed = Fixed<false>, typename... Constraints>
 constexpr ParamSpec<StringT, IsFixed, Constraints...>
@@ -581,6 +672,18 @@ struct ParamLiterals<FFTParamsT>
     return {{p.winSize(), p.hopRaw(), p.fftRaw()}};
   }
 };
+
+template <>
+struct ParamLiterals<LongRuntimeMaxT>
+{
+   using type = index;
+   
+   static std::array<index,2> getLiteral(const LongRuntimeMaxParam& p)
+   {
+      return {{p(),p.max()}};
+   }
+};
+
 } // namespace impl
 
 template <typename T, size_t N>
diff --git a/include/clients/common/Result.hpp b/include/clients/common/Result.hpp
index e652c36d2..52ba9d636 100644
--- a/include/clients/common/Result.hpp
+++ b/include/clients/common/Result.hpp
@@ -39,7 +39,7 @@ class Result
     if (&r == this) return *this;
 
     mStatus = r.mStatus;
-    mMsg = std::stringstream(r.mMsg.str());
+    mMsg = std::ostringstream(r.mMsg.str());
     return *this;
   };
 
@@ -71,13 +71,13 @@ class Result
 
   void reset()
   {
-    mMsg = std::stringstream();
+    mMsg = std::ostringstream();
     mStatus = Status::kOk;
   }
 
 private:
   Status            mStatus = Status::kOk;
-  std::stringstream mMsg;
+  std::ostringstream mMsg;
 };
 
 
diff --git a/include/clients/nrt/FluidSharedInstanceAdaptor.hpp b/include/clients/nrt/FluidSharedInstanceAdaptor.hpp
index 7d0895cd3..9d803855c 100644
--- a/include/clients/nrt/FluidSharedInstanceAdaptor.hpp
+++ b/include/clients/nrt/FluidSharedInstanceAdaptor.hpp
@@ -126,6 +126,12 @@ class ParamAliasAdaptor<NRTClient, std::tuple<Ts...>>
       return {Result::Status::kWarning, name, " not found"};
   }
 
+  template<typename Func,typename... Args>
+  auto setPrimaryParameterValues(bool reportage,Func&& f, Args&&...args)
+  {
+     return mParams->params.setPrimaryParameterValues(reportage, std::forward<Func>(f),std::forward<Args>(args)...);
+  }
+  
   template <template <size_t N, typename T> class Func, typename... Args>
   auto setFixedParameterValues(bool reportage, Args&&... args)
   {

From df20671244b902022c82a7aceea1052df2e8e42f Mon Sep 17 00:00:00 2001
From: weefuzzy <gungwho@gmail.com>
Date: Thu, 28 Apr 2022 11:29:25 +0100
Subject: [PATCH 3/6] MFCC: Proof of concept for new way of expressing runtime
 max for certain params

---
 include/clients/rt/MFCCClient.hpp | 26 ++++++++++++++------------
 1 file changed, 14 insertions(+), 12 deletions(-)

diff --git a/include/clients/rt/MFCCClient.hpp b/include/clients/rt/MFCCClient.hpp
index b80ff43a9..b731f11e5 100644
--- a/include/clients/rt/MFCCClient.hpp
+++ b/include/clients/rt/MFCCClient.hpp
@@ -31,23 +31,21 @@ enum MFCCParamIndex {
   kDrop0,
   kMinFreq,
   kMaxFreq,
-  kMaxNCoefs,
   kFFT,
   kMaxFFTSize
 };
 
 constexpr auto MFCCParams = defineParameters(
-    LongParam("numCoeffs", "Number of Cepstral Coefficients", 13, Min(2),
-              UpperLimit<kNBands, kMaxNCoefs>()),
-    LongParam("numBands", "Number of Bands", 40, Min(2),
+    LongParamRuntimeMax<Primary>("numCoeffs", "Number of Cepstral Coefficients", 13,
+              Min(2),
+              UpperLimit<kNBands>()),
+    LongParam<Primary>("numBands", "Number of Bands", 40, Min(2),
               FrameSizeUpperLimit<kFFT>(), LowerLimit<kNCoefs>()),
     LongParam("startCoeff", "Output Coefficient Offset", 0, Min(0),
               Max(1)), // this needs to be programmatically changed to start+num
                        // coeffs <= numBands as discussed
     FloatParam("minFreq", "Low Frequency Bound", 20, Min(0)),
     FloatParam("maxFreq", "High Frequency Bound", 20000, Min(0)),
-    LongParam<Fixed<true>>("maxNumCoeffs", "Maximum Number of Coefficients", 40,
-                           MaxFrameSizeUpperLimit<kMaxFFTSize>(), Min(2)),
     FFTParam<kMaxFFTSize>("fftSettings", "FFT Settings", 1024, -1, -1),
     LongParam<Fixed<true>>("maxFFTSize", "Maxiumm FFT Size", 16384));
 
@@ -59,10 +57,14 @@ class MFCCClient : public FluidBaseClient, public AudioIn, public ControlOut
   using ParamSetViewType = ParameterSetView<ParamDescType>;
   std::reference_wrapper<ParamSetViewType> mParams;
 
-  void setParams(ParamSetViewType& p) { mParams = p; }
+  void setParams(ParamSetViewType& p)
+  {
+    mParams = p;
+    controlChannelsOut({1, get<kNCoefs>(), get<kNCoefs>().max()});
+  }
 
   template <size_t N>
-  auto& get() const
+  auto get() const -> decltype(mParams.get().template get<N>())
   {
     return mParams.get().template get<N>();
   }
@@ -72,13 +74,12 @@ class MFCCClient : public FluidBaseClient, public AudioIn, public ControlOut
   MFCCClient(ParamSetViewType& p)
       : mParams{p}, mSTFTBufferedProcess(get<kMaxFFTSize>(), 1, 0),
         mMelBands(get<kMaxFFTSize>(), get<kMaxFFTSize>()),
-        mDCT(get<kMaxFFTSize>(),
-             get<kMaxNCoefs>() + 1) // + 1 for possibility of dropping 0th
+        mDCT(get<kMaxFFTSize>(), get<kNCoefs>().max() + 1)
   {
     mBands = FluidTensor<double, 1>(get<kNBands>());
     mCoefficients = FluidTensor<double, 1>(get<kNCoefs>() + get<kDrop0>());
     audioChannelsIn(1);
-    controlChannelsOut({1, get<kMaxNCoefs>()});
+    controlChannelsOut({1, get<kNCoefs>(), get<kNCoefs>().max()});
     setInputLabels({"audio input"});
     setOutputLabels({"MFCCs"});
   }
@@ -107,6 +108,7 @@ class MFCCClient : public FluidBaseClient, public AudioIn, public ControlOut
                      get<kFFT>().frameSize(), sampleRate(),
                      get<kFFT>().winSize());
       mDCT.init(get<kNBands>(), get<kNCoefs>() + !has0);
+      controlChannelsOut({1, get<kNCoefs>()});
     }
 
     mSTFTBufferedProcess.processInput(
@@ -118,7 +120,7 @@ class MFCCClient : public FluidBaseClient, public AudioIn, public ControlOut
   
       output[0](Slice(0, get<kNCoefs>())) <<=
         mCoefficients(Slice(get<kDrop0>(), get<kNCoefs>()));
-      output[0](Slice(get<kNCoefs>(), get<kMaxNCoefs>() - get<kNCoefs>())).fill(0); 
+      output[0](Slice(get<kNCoefs>(), get<kNCoefs>().max() - get<kNCoefs>())).fill(0);
   }
 
   index latency() { return get<kFFT>().winSize(); }

From e6f3384fae4648fbba3b43310792e9d73bfdd3ce Mon Sep 17 00:00:00 2001
From: weefuzzy <gungwho@gmail.com>
Date: Thu, 28 Apr 2022 13:08:22 +0100
Subject: [PATCH 4/6] CMake: Missing C++ version adjustments

---
 examples/CMakeLists.txt |  7 -------
 tests/CMakeLists.txt    | 13 -------------
 2 files changed, 20 deletions(-)

diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index 7466c904a..9712c6290 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -9,12 +9,5 @@ foreach (EXAMPLE  describe)
 	)
 
 	target_compile_options(${EXAMPLE} PRIVATE ${FLUID_ARCH})
-
-	set_target_properties(${EXAMPLE}
-	    PROPERTIES
-	    CXX_STANDARD 14
-	    CXX_STANDARD_REQUIRED ON
-	    CXX_EXTENSIONS OFF
-	)
 	
 endforeach (EXAMPLE)
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index f1b4c7954..3e903f48e 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -7,11 +7,6 @@ add_subdirectory(test_signals)
 
 # a handler to catch sigabrt for us on death tests
 add_library(AbortHandler OBJECT AbortHandler.cpp)
-set_target_properties(AbortHandler PROPERTIES 
-  CXX_STANDARD 14
-  CXX_STANDARD_REQUIRED ON
-  CXX_EXTENSIONS  OFF
-)
 
 # function (add_assert_fail_test testname sourcedir)
 #   try_compile(
@@ -60,9 +55,6 @@ function (_add_one_compile_test testname sourcefile should_fail)
   set_target_properties(${testname} PROPERTIES 
       EXCLUDE_FROM_ALL true
       EXCLUDE_FROM_DEFAULT_BUILD true
-      CXX_STANDARD 14
-      CXX_STANDARD_REQUIRED ON
-      CXX_EXTENSIONS OFF
       POSITION_INDEPENDENT_CODE ON
   )                                               
   target_compile_definitions(${testname} PRIVATE ${testname})
@@ -112,11 +104,6 @@ target_compile_features(TestUtils INTERFACE cxx_std_14)
 function(add_test_executable target_name source_file)
   add_executable(${target_name} ${source_file})
   target_link_libraries(${target_name} PUBLIC TestUtils)
-  set_target_properties(${target_name} PROPERTIES 
-    CXX_STANDARD 14
-    CXX_STANDARD_REQUIRED ON
-    CXX_EXTENSIONS  OFF
-  )
 endfunction()
 
 add_test_executable(TestFluidTensor data/TestFluidTensor.cpp)

From 41ec2e4ab4ede21f73592b807590f808f3efebda Mon Sep 17 00:00:00 2001
From: weefuzzy <gungwho@gmail.com>
Date: Thu, 28 Apr 2022 15:04:55 +0100
Subject: [PATCH 5/6] CMake: Another rogue C++ version flag

---
 tests/CMakeLists.txt | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 3e903f48e..887e05ced 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -99,7 +99,6 @@ target_link_libraries(TestUtils INTERFACE
 target_compile_definitions(TestUtils INTERFACE 
   APPROVAL_TESTS_HIDE_DEPRECATED_CODE=1
 )
-target_compile_features(TestUtils INTERFACE cxx_std_14)
 
 function(add_test_executable target_name source_file)
   add_executable(${target_name} ${source_file})

From e8f590a2530b638c9ce9706c61c479a6c1e6d22a Mon Sep 17 00:00:00 2001
From: weefuzzy <gungwho@gmail.com>
Date: Thu, 28 Apr 2022 15:30:41 +0100
Subject: [PATCH 6/6] Try to get catch to build on OS 12 whilst targetting 10.8

---
 tests/CMakeLists.txt | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 887e05ced..1e57de951 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -100,6 +100,12 @@ target_compile_definitions(TestUtils INTERFACE
   APPROVAL_TESTS_HIDE_DEPRECATED_CODE=1
 )
 
+if(APPLE)
+  target_compile_definitions(TestUtils INTERFACE   
+    CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS
+  )
+endif()
+
 function(add_test_executable target_name source_file)
   add_executable(${target_name} ${source_file})
   target_link_libraries(${target_name} PUBLIC TestUtils)