comparison vamp-sdk/hostext/PluginSummarisingAdapter.cpp @ 195:1e4c6f25ded6

* More accurate calculation of summaries in continuous-time mode
* Labels
* Make some debug output optional

 
 #include <map>
 #include <cmath>
 #include <climits>
 
-//#define DEBUG_PLUGIN_SUMMARISING_ADAPTER 1
+#define DEBUG_PLUGIN_SUMMARISING_ADAPTER 1
+//#define DEBUG_PLUGIN_SUMMARISING_ADAPTER_SEGMENT 1
 
 namespace Vamp {
 
 namespace HostExt {
 

 {
 public:
     Impl(Plugin *plugin, float inputSampleRate);
     ~Impl();
 
+    bool initialise(size_t channels, size_t stepSize, size_t blockSize);
+
     FeatureSet process(const float *const *inputBuffers, RealTime timestamp);
     FeatureSet getRemainingFeatures();
 
     void setSummarySegmentBoundaries(const SegmentBoundaries &);
 

                                        AveragingMethod avg);
 
 protected:
     Plugin *m_plugin;
     float m_inputSampleRate;
+    size_t m_stepSize;
+    size_t m_blockSize;
 
     SegmentBoundaries m_boundaries;
 
     typedef std::vector<float> ValueList;
 

     struct OutputBinSummary {
 
         int count;
 
         // extents
-        float minimum;
-        float maximum;
-        float sum;
+        double minimum;
+        double maximum;
+        double sum;
 
         // sample-average results
-        float median;
-        float mode;
-        float variance;
+        double median;
+        double mode;
+        double variance;
 
         // continuous-time average results
-        float median_c;
-        float mode_c;
-        float mean_c;
-        float variance_c;
+        double median_c;
+        double mode_c;
+        double mean_c;
+        double variance_c;
     };
 
     typedef std::map<int, OutputBinSummary> OutputSummary;
     typedef std::map<RealTime, OutputSummary> SummarySegmentMap;
     typedef std::map<int, SummarySegmentMap> OutputSummarySegmentMap;
 
     OutputSummarySegmentMap m_summaries;
 
     bool m_reduced;
-    RealTime m_lastTimestamp;
+    RealTime m_endTime;
 
     void accumulate(const FeatureSet &fs, RealTime, bool final);
     void accumulate(int output, const Feature &f, RealTime, bool final);
     void accumulateFinalDurations();
     void findSegmentBounds(RealTime t, RealTime &start, RealTime &end);
     void segment();
     void reduce();
+
+    std::string getSummaryLabel(SummaryType type, AveragingMethod avg);
 };
 
 static RealTime INVALID_DURATION(INT_MIN, INT_MIN);
     
 PluginSummarisingAdapter::PluginSummarisingAdapter(Plugin *plugin) :

 PluginSummarisingAdapter::~PluginSummarisingAdapter()
 {
     delete m_impl;
 }
 
+bool
+PluginSummarisingAdapter::initialise(size_t channels,
+                                     size_t stepSize, size_t blockSize)
+{
+    return
+        PluginWrapper::initialise(channels, stepSize, blockSize) &&
+        m_impl->initialise(channels, stepSize, blockSize);
+}
+
 Plugin::FeatureSet
 PluginSummarisingAdapter::process(const float *const *inputBuffers, RealTime timestamp)
 {
     return m_impl->process(inputBuffers, timestamp);
 }

 
 PluginSummarisingAdapter::Impl::~Impl()
 {
 }
 
+bool
+PluginSummarisingAdapter::Impl::initialise(size_t channels,
+                                           size_t stepSize, size_t blockSize)
+{
+    m_stepSize = stepSize;
+    m_blockSize = blockSize;
+    return true;
+}
+
 Plugin::FeatureSet
-PluginSummarisingAdapter::Impl::process(const float *const *inputBuffers, RealTime timestamp)
+PluginSummarisingAdapter::Impl::process(const float *const *inputBuffers,
+                                        RealTime timestamp)
 {
     if (m_reduced) {
         std::cerr << "WARNING: Cannot call PluginSummarisingAdapter::process() or getRemainingFeatures() after one of the getSummary methods" << std::endl;
     }
     FeatureSet fs = m_plugin->process(inputBuffers, timestamp);
     accumulate(fs, timestamp, false);
-    //!!! should really be "timestamp plus step size"
-    m_lastTimestamp = timestamp;
+    m_endTime = timestamp + 
+        RealTime::frame2RealTime(m_stepSize, m_inputSampleRate);
     return fs;
 }
 
 Plugin::FeatureSet
 PluginSummarisingAdapter::Impl::getRemainingFeatures()
 {
     if (m_reduced) {
         std::cerr << "WARNING: Cannot call PluginSummarisingAdapter::process() or getRemainingFeatures() after one of the getSummary methods" << std::endl;
     }
     FeatureSet fs = m_plugin->getRemainingFeatures();
-    accumulate(fs, m_lastTimestamp, true);
+    accumulate(fs, m_endTime, true);
     return fs;
 }
 
 void
 PluginSummarisingAdapter::Impl::setSummarySegmentBoundaries(const SegmentBoundaries &b)

     FeatureList fl;
     for (SummarySegmentMap::const_iterator i = m_summaries[output].begin();
          i != m_summaries[output].end(); ++i) {
 
         Feature f;
+
         f.hasTimestamp = true;
         f.timestamp = i->first;
-        f.hasDuration = false;
+
+        f.hasDuration = true;
+        SummarySegmentMap::const_iterator ii = i;
+        if (++ii == m_summaries[output].end()) {
+            f.duration = m_endTime - f.timestamp;
+        } else {
+            f.duration = ii->first - f.timestamp;
+        }
+
+        f.label = getSummaryLabel(type, avg);
 
         for (OutputSummary::const_iterator j = i->second.begin();
              j != i->second.end(); ++j) {
 
             // these will be ordered by bin number, and no bin numbers
             // will be missing except at the end (because of the way
             // the accumulators were initially filled in accumulate())
 
             const OutputBinSummary &summary = j->second;
-            float result = 0.f;
+            double result = 0.f;
 
             switch (type) {
 
             case Minimum:
                 result = summary.minimum;

             }
         }
     }
 }
 
+std::string
+PluginSummarisingAdapter::Impl::getSummaryLabel(SummaryType type,
+                                                AveragingMethod avg)
+{
+    std::string label;
+    std::string avglabel;
+
+    if (avg == SampleAverage) avglabel = ", sample average";
+    else avglabel = ", continuous-time average";
+
+    switch (type) {
+    case Minimum:  label = "(minimum value)"; break;
+    case Maximum:  label = "(maximum value)"; break;
+    case Mean:     label = "(mean value" + avglabel + ")"; break;
+    case Median:   label = "(median value" + avglabel + ")"; break;
+    case Mode:     label = "(modal value" + avglabel + ")"; break;
+    case Sum:      label = "(sum)"; break;
+    case Variance: label = "(variance" + avglabel + ")"; break;
+    case StandardDeviation: label = "(standard deviation" + avglabel + ")"; break;
+    case Count:    label = "(count)"; break;
+    case UnknownSummaryType: label = "(unknown summary)"; break;
+    }
+    
+    return label;
+}
+
 void
 PluginSummarisingAdapter::Impl::accumulate(int output,
                                            const Feature &f,
                                            RealTime timestamp,
                                            bool final)

     if (f.hasDuration) m_prevDurations[output] = f.duration;
     else m_prevDurations[output] = INVALID_DURATION;
 
     m_prevTimestamps[output] = timestamp;
 
-    //!!! should really be "timestamp plus duration" or "timestamp plus output resolution"
-    if (timestamp > m_lastTimestamp) m_lastTimestamp = timestamp;
+    if (f.hasDuration) {
+        RealTime et = timestamp;
+        et = et + f.duration;
+        if (et > m_endTime) m_endTime = et;
+    }
 
     Result result;
     result.time = timestamp;
     result.duration = INVALID_DURATION;
 

                 m_prevDurations[output];
 
         } else {
 
 #ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
-            std::cerr << "Pushing final duration from diff as " << m_lastTimestamp << " - " << m_prevTimestamps[output] << std::endl;
+            std::cerr << "Pushing final duration from diff as " << m_endTime << " - " << m_prevTimestamps[output] << std::endl;
 #endif
 
             m_accumulators[output].results[acount - 1].duration =
-                m_lastTimestamp - m_prevTimestamps[output];
+                m_endTime - m_prevTimestamps[output];
         }
         
 #ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
         std::cerr << "so duration for result no " << acount-1 << " is "
                   << m_accumulators[output].results[acount-1].duration

 void
 PluginSummarisingAdapter::Impl::findSegmentBounds(RealTime t,
                                                   RealTime &start,
                                                   RealTime &end)
 {
-#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER_SEGMENT
     std::cerr << "findSegmentBounds: t = " << t <<  std::endl;
 #endif
 
     SegmentBoundaries::const_iterator i = std::upper_bound
         (m_boundaries.begin(), m_boundaries.end(), t);
 
     start = RealTime::zeroTime;
-    end = m_lastTimestamp;
+    end = m_endTime;
 
     if (i != m_boundaries.end()) {
         end = *i;
     }
 
     if (i != m_boundaries.begin()) {
         start = *--i;
     }
 
-#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER    
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER_SEGMENT
     std::cerr << "findSegmentBounds: " << t << " is in segment " << start << " -> " << end << std::endl;
 #endif
 }
 
 void

          i != m_accumulators.end(); ++i) {
 
         int output = i->first;
         OutputAccumulator &source = i->second;
 
-#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER_SEGMENT
         std::cerr << "segment: total results for output " << output << " = "
                   << source.results.size() << std::endl;
 #endif
 
         //!!! This is basically nonsense if the results have no values

             // We need to dispose it into segments appropriately
 
             RealTime resultStart = source.results[n].time;
             RealTime resultEnd = resultStart + source.results[n].duration;
 
-#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER_SEGMENT
             std::cerr << "output: " << output << ", result start = " << resultStart << ", end = " << resultEnd << std::endl;
 #endif
 
             RealTime segmentStart = RealTime::zeroTime;
             RealTime segmentEnd = resultEnd - RealTime(1, 0);

                 Result chunk;
                 chunk.time = chunkStart;
                 chunk.duration = chunkEnd - chunkStart;
                 chunk.values = source.results[n].values;
 
-#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER_SEGMENT
                 std::cerr << "chunk for segment " << segmentStart << ": from " << chunk.time << ", duration " << chunk.duration << std::endl;
 #endif
 
                 m_segmentedAccumulators[output][segmentStart].results
                     .push_back(chunk);
 
                 resultStart = chunkEnd;
             }
         }
     }
-            
-            
-
-/*
-        if (boundaryitr == m_boundaries.end()) {
-            m_segmentedAccumulators[output][segmentStart] = source;
-            source.clear();
-            continue;
-        }
-*/
-        
-            
-
-        
 }
 
 struct ValueDurationFloatPair
 {
     float value;

             //!!! is this right?
             if (sz > 0) {
 #ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
                 std::cerr << "last time = " << accumulator.results[sz-1].time 
                           << ", duration = " << accumulator.results[sz-1].duration
+                          << " (step = " << m_stepSize << ", block = " << m_blockSize << ")"
                           << std::endl;
 #endif
                 totalDuration = toSec((accumulator.results[sz-1].time +
                                        accumulator.results[sz-1].duration) -
                                       segmentStart);

 #ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
                 std::cerr << "total duration = " << totalDuration << std::endl;
 #endif
 
 #ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
+/*
                 std::cerr << "value vector for medians:" << std::endl;
                 for (int k = 0; k < sz; ++k) {
                     std::cerr << "(" << valvec[k].value << "," << valvec[k].duration << ") ";
                 }
                 std::cerr << std::endl;
+*/
 #endif
 
                 if (sz % 2 == 1) {
                     summary.median = valvec[sz/2].value;
                 } else {

 #endif
                 
                     summary.mean_c = sum_c / totalDuration;
 
                     for (int k = 0; k < sz; ++k) {
-                        double value = accumulator.results[k].values[bin]
+                        double value = accumulator.results[k].values[bin];
+//                            * toSec(accumulator.results[k].duration);
+                        summary.variance_c +=
+                            (value - summary.mean_c) * (value - summary.mean_c)
                             * toSec(accumulator.results[k].duration);
-                        summary.variance_c +=
-                            (value - summary.mean_c) * (value - summary.mean_c);
                     }
 
-                    summary.variance_c /= summary.count;
-                }
-
-                float mean = summary.sum / summary.count;
+//                    summary.variance_c /= summary.count;
+                    summary.variance_c /= totalDuration;
+                }
+
+                double mean = summary.sum / summary.count;
 
 #ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
                 std::cerr << "mean = " << summary.sum << " / " << summary.count << " = "
                           << summary.sum / summary.count << std::endl;
 #endif