FixedTermLoudnessMeter now uses DoubleBuffering for Realtime safety

Author: maxwalley

include/ChannelProcessor.h

@@ -27,7 +27,7 @@ class ChannelProcessor
 
 private:
     void initialiseFilters();
-    
+
     float weighting;
 
     Filter filt1;

include/DoubleBuffer.h

@@ -12,7 +12,7 @@ template<typename T>
 class DoubleBuffer
 {
 public:
-    DoubleBuffer(const T& initialVal)  : buffers{{initialVal}, {initialVal}}, realtimeCopy{initialVal} {}
+    DoubleBuffer(const T& initialVal)  : buffers{initialVal, initialVal}, realtimeCopy{initialVal} {}
 
     ~DoubleBuffer()
     {
@@ -35,27 +35,27 @@ class DoubleBuffer
         control.store((writeIndex & IndexBit) | NewDataBit);
     }
 
-    T& nonRealtimeRead()
+    const T& nonRealtimeRead() const
     {
         int current = control.load();
 
-        if(!current & NewDataBit)
+        if(current & NewDataBit)
         {
-            return;
-        }
+            int newValue;
 
-        int newValue;
+            //CAS loop to spin while busy bit is set, then set the new buffer to write to
+            do
+            {
+                current &= ~BusyBit;
+                newValue = (current ^ IndexBit) & IndexBit;
+            }
+            while(!control.compare_exchange_weak(current, newValue));
 
-        //CAS loop to spin while busy bit is set, then set the new buffer to write to
-        do
-        {
-            current &= ~BusyBit;
-            newValue = (comp ^ IndexBit) & IndexBit;
+            current = newValue;
         }
-        while(!control.compare_exchange_weak(current, newValue));
 
         //Return the last buffer that was written to
-        return buffers[(newValue & IndexBit) & 0x1]
+        return buffers[(current & IndexBit) ^ 0x1];
     }
 
     //This is not realtime safe with the other calls
@@ -74,9 +74,9 @@ class DoubleBuffer
         IndexBit = (1 << 0), 
         NewDataBit = (1 << 1), 
         BusyBit = (1 << 2)
-    }
+    };
 
-    std::atomic<int> control;
+    mutable std::atomic<int> control;
 
     std::array<T, 2> buffers;
     T realtimeCopy;

include/FixedTermLoudnessMeter.h

@@ -5,6 +5,7 @@
 #include <span>
 
 #include "LiblufsAPI.h"
+#include "DoubleBuffer.h"
 #include "ChannelProcessor.h"
 
 namespace LUFS
@@ -13,7 +14,7 @@ namespace LUFS
 class LIBLUFS_API FixedTermLoudnessMeter
 {
 public:
-    FixedTermLoudnessMeter(const std::vector<Channel>& channels, const std::chrono::milliseconds& windowLength);
+    FixedTermLoudnessMeter(const std::vector<Channel>& channelSet, const std::chrono::milliseconds& windowLength);
     ~FixedTermLoudnessMeter();
 
     //Deinterleaved and interleaved
@@ -23,15 +24,18 @@ class LIBLUFS_API FixedTermLoudnessMeter
     //This is not threadsafe with process calls
     void reset();
 
-    //This is threadsafe with process calls
+    //This is threadsafe with process calls, but must only be called from a single thread at a time
     float getLoudness() const;
 
 private:
     int getBlockLengthSamples(const std::chrono::milliseconds& windowLength) const;
 
+    std::vector<ChannelProcessor> generateChannelProcessors() const;
+
+    const std::vector<Channel> channels;
     const int blockLengthSamples;
 
-    std::vector<ChannelProcessor> channelProcessors;
+    DoubleBuffer<std::vector<ChannelProcessor>> channelProcessors;
 
     size_t blockWritePos = 0;
 

src/ChannelProcessor.cpp

@@ -3,7 +3,7 @@
 namespace LUFS
 {
 
-ChannelProcessor::ChannelProcessor(float channelWeighting, size_t blockSizeSamples)  : weighting(channelWeighting), currentBlockData(blockSizeSamples, 0.0f)
+ChannelProcessor::ChannelProcessor(float channelWeighting, size_t blockSizeSamples)  : weighting{channelWeighting}, currentBlockData(blockSizeSamples, 0.0f)
 {
     initialiseFilters();
 

src/FixedTermLoudnessMeter.cpp

@@ -3,12 +3,9 @@
 namespace LUFS
 {
 
-FixedTermLoudnessMeter::FixedTermLoudnessMeter(const std::vector<Channel>& channels, const std::chrono::milliseconds& windowLength)  : blockLengthSamples{getBlockLengthSamples(windowLength)}
+FixedTermLoudnessMeter::FixedTermLoudnessMeter(const std::vector<Channel>& channelSet, const std::chrono::milliseconds& windowLength)  : channels{channelSet}, blockLengthSamples{getBlockLengthSamples(windowLength)}, channelProcessors{generateChannelProcessors()}
 {
-    std::transform(channels.begin(), channels.end(), std::back_insert_iterator(channelProcessors), [this](const Channel& channel)
-    {
-        return ChannelProcessor(channel.getWeighting(), blockLengthSamples);
-    });
+    
 }
 
 FixedTermLoudnessMeter::~FixedTermLoudnessMeter()
@@ -18,59 +15,66 @@ FixedTermLoudnessMeter::~FixedTermLoudnessMeter()
 
 void FixedTermLoudnessMeter::process(std::span<const float* const> audio, int numSamplesPerChannel)
 {
-    assert(audio.size() == channelProcessors.size());
+    std::vector<ChannelProcessor>& processors = channelProcessors.realtimeAquire();
+
+    assert(audio.size() == processors.size());
 
     for(size_t sampleIndex = 0; sampleIndex < numSamplesPerChannel; ++sampleIndex)
     {
-        for(int channelIndex = 0; channelIndex < channelProcessors.size(); ++channelIndex)
+        for(int channelIndex = 0; channelIndex < processors.size(); ++channelIndex)
         {
-            channelProcessors[channelIndex].currentBlockData[blockWritePos] =  channelProcessors[channelIndex].filterSample(audio[channelIndex][sampleIndex]);
+            processors[channelIndex].currentBlockData[blockWritePos] =  processors[channelIndex].filterSample(audio[channelIndex][sampleIndex]);
         }
 
         if(++blockWritePos >= blockLengthSamples)
         {
             blockWritePos = 0;
         }
     }
+
+    channelProcessors.realtimeRelease();
 }
 
 void FixedTermLoudnessMeter::process(std::span<const float> audio)
 {
-    assert(audio.size() % channelProcessors.size() == 0);
+    std::vector<ChannelProcessor>& processors = channelProcessors.realtimeAquire();
+
+    assert(audio.size() % processors.size() == 0);
 
-    const size_t numSamplesPerChannel = audio.size() / channelProcessors.size();
+    const size_t numSamplesPerChannel = audio.size() / processors.size();
 
     const float* inputData = audio.data();
 
     for(size_t sampleIndex = 0; sampleIndex < numSamplesPerChannel; ++sampleIndex)
     {
-        for(int channelIndex = 0; channelIndex < channelProcessors.size(); ++channelIndex)
+        for(int channelIndex = 0; channelIndex < processors.size(); ++channelIndex)
         {
-            channelProcessors[channelIndex].currentBlockData[blockWritePos] =  channelProcessors[channelIndex].filterSample(*inputData++);
+            processors[channelIndex].currentBlockData[blockWritePos] = processors[channelIndex].filterSample(*inputData++);
         }
 
         if(++blockWritePos >= blockLengthSamples)
         {
             blockWritePos = 0;
         }
     }
+
+    channelProcessors.realtimeRelease();
 }
 
 void FixedTermLoudnessMeter::reset()
 {
-    std::for_each(channelProcessors.begin(), channelProcessors.end(), [](ChannelProcessor& processor)
-    {
-        processor.reset();
-    });
+    channelProcessors.reset(generateChannelProcessors());
 
     blockWritePos = 0;
 }
 
 float FixedTermLoudnessMeter::getLoudness() const
 {
+    const std::vector<ChannelProcessor>& processors = channelProcessors.nonRealtimeRead();
+
     float accumulatedChannels = 0.0f;
 
-    std::for_each(channelProcessors.begin(), channelProcessors.end(), [&accumulatedChannels](const ChannelProcessor& processor)
+    std::for_each(processors.begin(), processors.end(), [&accumulatedChannels](const ChannelProcessor& processor)
     {
         accumulatedChannels += processor.getCurrentBlockMeanSquares() * processor.getWeighting();
     });
@@ -83,4 +87,16 @@ int FixedTermLoudnessMeter::getBlockLengthSamples(const std::chrono::millisecond
     return (windowLength.count() / 1000.0f) * sampleRate;
 }
 
+std::vector<ChannelProcessor> FixedTermLoudnessMeter::generateChannelProcessors() const
+{
+    std::vector<ChannelProcessor> tempChannelProcessors;
+
+    std::transform(channels.begin(), channels.end(), std::back_insert_iterator(tempChannelProcessors), [this](const Channel& channel)
+    {
+        return ChannelProcessor(channel.getWeighting(), blockLengthSamples);
+    });
+
+    return tempChannelProcessors;
+}
+
 }