fluid.voiceallocator community testing build

FlucomaClients.cmake

@@ -118,6 +118,7 @@ add_client(BufThreadDemo clients/nrt/FluidThreadTestClient.hpp CLASS NRTThreaded
 add_client(BufThresh clients/nrt/BufThreshClient.hpp CLASS NRTThreadedBufferThreshClient )
 add_client(BufTransientSlice clients/rt/TransientSliceClient.hpp CLASS NRTThreadedTransientSliceClient )
 add_client(BufTransients clients/rt/TransientClient.hpp CLASS NRTThreadedTransientsClient )
+add_kr_in_client(BufVoiceAllocator clients/rt/VoiceAllocatorClient.hpp CLASS NRTThreadedVoiceAllocatorClient )
 add_client(Chroma clients/rt/ChromaClient.hpp CLASS RTChromaClient )
 add_client(Gain clients/rt/GainClient.hpp CLASS RTGainClient NOINSTALL)
 add_client(HPSS clients/rt/HPSSClient.hpp CLASS RTHPSSClient )
@@ -139,6 +140,7 @@ add_client(SpectralShape clients/rt/SpectralShapeClient.hpp CLASS RTSpectralShap
 add_kr_in_client(Stats clients/rt/RunningStatsClient.hpp CLASS RunningStatsClient )
 add_client(TransientSlice clients/rt/TransientSliceClient.hpp CLASS RTTransientSliceClient )
 add_client(Transients clients/rt/TransientClient.hpp CLASS RTTransientClient )
+add_kr_in_client(VoiceAllocator clients/rt/VoiceAllocatorClient.hpp CLASS VoiceAllocatorClient )
 
 #lib manipulation client group 
 add_client(DataSet clients/nrt/DataSetClient.hpp CLASS NRTThreadedDataSetClient GROUP MANIPULATION)

include/algorithms/public/VoiceAllocator.hpp

@@ -0,0 +1,163 @@
+/*
+Part of the Fluid Corpus Manipulation Project (http://www.flucoma.org/)
+Copyright University of Huddersfield.
+Licensed under the BSD-3 License.
+See license.md file in the project root for full license information.
+This project has received funding from the European Research Council (ERC)
+under the European Union’s Horizon 2020 research and innovation programme
+(grant agreement No 725899).
+*/
+
+#pragma once
+
+#include "../util/PartialTracking.hpp"
+
+namespace fluid {
+namespace algorithm {
+
+class VoiceAllocator
+{
+  template <typename T>
+  using vector = rt::vector<T>;
+
+public:
+  VoiceAllocator(index nVoices, Allocator& alloc)
+      : mTracking(alloc), mVoices{nVoices}, mFreeVoices(alloc),
+        mActiveVoices(alloc), mActiveVoiceData(0, alloc)
+  {}
+
+  void init(index nVoices, Allocator& alloc)
+  {
+    mVoices = nVoices;
+    while (!mActiveVoices.empty()) { mActiveVoices.pop_back(); }
+    while (!mFreeVoices.empty()) { mFreeVoices.pop(); }
+    for (index i = 0; i < nVoices; ++i) { mFreeVoices.push(i); }
+    mActiveVoiceData.resize(nVoices);
+    for (VoicePeak each : mActiveVoiceData) { each = {0, 0, 0}; }
+    mTracking.init();
+    mInitialized = true;
+  }
+
+  void processFrame(vector<SinePeak>   incomingVoices,
+                    vector<VoicePeak>& outgoingVoices, index minTrackLen,
+                    double birthLowTreshold, double birthHighTreshold,
+                    index trackMethod, double trackMagRange,
+                    double trackFreqRange, double trackProb, index sortMethod,
+                    Allocator& alloc)
+  {
+    assert(mInitialized);
+
+    double maxAmp = -144;
+    for (const SinePeak& voice : incomingVoices)
+    {
+      if (voice.logMag > maxAmp) { maxAmp = voice.logMag; }
+    }
+
+    mTracking.processFrame(incomingVoices, maxAmp, minTrackLen,
+                           birthLowTreshold, birthHighTreshold, trackMethod,
+                           trackMagRange, trackFreqRange, trackProb, alloc);
+
+    outgoingVoices = mTracking.getActiveVoices(alloc);
+    outgoingVoices = sortVoices(outgoingVoices, sortMethod);
+    if (outgoingVoices.size() > mVoices) outgoingVoices.resize(mVoices);
+    outgoingVoices = assignVoices(outgoingVoices, alloc);
+
+    mTracking.prune();
+  }
+
+  void reset() { mInitialized = false; }
+
+  bool initialized() const { return mInitialized; }
+
+private:
+  vector<VoicePeak> sortVoices(vector<VoicePeak>& incomingVoices,
+                               index              sortingMethod)
+  {
+    switch (sortingMethod)
+    {
+    case 0: // lowest
+      std::sort(incomingVoices.begin(), incomingVoices.end(),
+                [](const VoicePeak& voice1, const VoicePeak& voice2) {
+                  return voice1.freq < voice2.freq;
+                });
+      break;
+    case 1: // loudest
+      std::sort(incomingVoices.begin(), incomingVoices.end(),
+                [](const VoicePeak& voice1, const VoicePeak& voice2) {
+                  return voice1.logMag > voice2.logMag;
+                });
+      break;
+    }
+    return incomingVoices;
+  }
+
+  vector<VoicePeak> assignVoices(vector<VoicePeak>& incomingVoices,
+                                 Allocator&         alloc)
+  {
+    // move released to free
+    for (index existing = 0; existing < mActiveVoiceData.size(); ++existing)
+    {
+      if (mActiveVoiceData[existing].state ==
+          algorithm::VoiceState::kReleaseState)
+        mActiveVoiceData[existing].state = algorithm::VoiceState::kFreeState;
+    }
+
+    // handle existing voices - killing or sustaining
+    for (index existing = 0; existing < mActiveVoices.size(); ++existing)
+    {
+      bool killVoice = true;
+      for (index incoming = 0; incoming < incomingVoices.size(); ++incoming)
+      {
+        // remove incoming voice events & allows corresponding voice to live if
+        // it already exists
+        if (mActiveVoiceData[mActiveVoices[existing]].voiceID ==
+            incomingVoices[incoming].voiceID)
+        {
+          killVoice = false;
+          mActiveVoiceData[mActiveVoices[existing]] =
+              incomingVoices[incoming]; // update freq/mag
+          mActiveVoiceData[mActiveVoices[existing]].state =
+              algorithm::VoiceState::kSustainState;
+          incomingVoices.erase(incomingVoices.begin() + incoming);
+          break;
+        }
+      }
+      if (killVoice) // voice off
+      {
+        mActiveVoiceData[mActiveVoices[existing]].state =
+            algorithm::VoiceState::kReleaseState;
+        mFreeVoices.push(mActiveVoices[existing]);
+        mActiveVoices.erase(mActiveVoices.begin() + existing);
+        --existing;
+      }
+    }
+
+    // handle new voice allocation
+    for (index incoming = 0; incoming < incomingVoices.size(); ++incoming)
+    {
+      if (!mFreeVoices.empty()) // voice on
+      {
+        index newVoiceIndex = mFreeVoices.front();
+        mFreeVoices.pop();
+        mActiveVoices.push_back(newVoiceIndex);
+        algorithm::VoiceState prevState = mActiveVoiceData[newVoiceIndex].state;
+        mActiveVoiceData[newVoiceIndex] = incomingVoices[incoming];
+        if (prevState == algorithm::VoiceState::kReleaseState) // mark as stolen
+          mActiveVoiceData[newVoiceIndex].state =
+              algorithm::VoiceState::kStolenState;
+      }
+    }
+
+    return mActiveVoiceData;
+  }
+
+  PartialTracking   mTracking;
+  index             mVoices;
+  rt::queue<index>  mFreeVoices;
+  rt::deque<index>  mActiveVoices;
+  vector<VoicePeak> mActiveVoiceData;
+
+  bool mInitialized{false};
+};
+} // namespace algorithm
+} // namespace fluid

include/algorithms/util/PartialTracking.hpp

@@ -25,22 +25,38 @@ Capability through Linear Programming". Proceedings of DAFx-2018.
 namespace fluid {
 namespace algorithm {
 
+enum class VoiceState {
+  kFreeState,
+  kAttackState,
+  kSustainState,
+  kReleaseState,
+  kStolenState
+};
+
 struct SinePeak
 {
   double freq;
   double logMag;
   bool   assigned;
 };
 
+struct VoicePeak
+{
+  double     freq;
+  double     logMag;
+  index      voiceID;
+  VoiceState state;
+};
+
 struct SineTrack
 {
 
   SineTrack(Allocator& alloc) : peaks(alloc) {}
 
   SineTrack(rt::vector<SinePeak>&& p, index s, index e, bool a, bool ass,
             index t)
-      : peaks{p}, startFrame{s}, endFrame{e}, active{a}, assigned{ass}, trackId{
-                                                                            t}
+      : peaks{p}, startFrame{s}, endFrame{e}, active{a}, assigned{ass},
+        trackId{t}
   {}
 
   rt::vector<SinePeak> peaks;
@@ -134,6 +150,29 @@ class PartialTracking
     return sinePeaks;
   }
 
+  // todo - refactor this function with the one above
+  vector<VoicePeak> getActiveVoices(Allocator& alloc)
+  {
+    vector<VoicePeak> voicePeaks(0, alloc);
+    index             latencyFrame = mCurrentFrame - mMinTrackLength;
+    if (latencyFrame < 0) return voicePeaks;
+    for (auto&& track : mTracks)
+    {
+      if (track.startFrame > latencyFrame) continue;
+      if (track.endFrame >= 0 && track.endFrame <= latencyFrame) continue;
+      if (track.endFrame >= 0 &&
+          track.endFrame - track.startFrame < mMinTrackLength)
+        continue;
+      voicePeaks.push_back(
+          {track.peaks[asUnsigned(latencyFrame - track.startFrame)].freq,
+           pow(10,
+               track.peaks[asUnsigned(latencyFrame - track.startFrame)].logMag /
+                   20),
+           track.trackId, VoiceState::kAttackState});
+    }
+    return voicePeaks;
+  }
+
 private:
   void updateVariances()
   {