comparison src/vamp-hostsdk/PluginSummarisingAdapter.cpp @ 418:a13635e9c440

Tweak debug output

 #include <map>
 #include <algorithm>
 #include <cmath>
 #include <climits>
 
+using namespace std;
+
 //#define DEBUG_PLUGIN_SUMMARISING_ADAPTER 1
 //#define DEBUG_PLUGIN_SUMMARISING_ADAPTER_SEGMENT 1
 
 _VAMP_SDK_HOSTSPACE_BEGIN(PluginSummarisingAdapter.cpp)
 

     size_t m_stepSize;
     size_t m_blockSize;
 
     SegmentBoundaries m_boundaries;
 
-    typedef std::vector<float> ValueList;
+    typedef vector<float> ValueList;
 
     struct Result { // smaller than Feature
         RealTime time;
         RealTime duration;
         ValueList values; // bin number -> value
     };
 
-    typedef std::vector<Result> ResultList;
+    typedef vector<Result> ResultList;
 
     struct OutputAccumulator {
         int bins;
         ResultList results;
         OutputAccumulator() : bins(0) { }
     };
 
-    typedef std::map<int, OutputAccumulator> OutputAccumulatorMap;
+    typedef map<int, OutputAccumulator> OutputAccumulatorMap;
     OutputAccumulatorMap m_accumulators; // output number -> accumulator
 
-    typedef std::map<RealTime, OutputAccumulator> SegmentAccumulatorMap;
-    typedef std::map<int, SegmentAccumulatorMap> OutputSegmentAccumulatorMap;
+    typedef map<RealTime, OutputAccumulator> SegmentAccumulatorMap;
+    typedef map<int, SegmentAccumulatorMap> OutputSegmentAccumulatorMap;
     OutputSegmentAccumulatorMap m_segmentedAccumulators; // output -> segmented
 
-    typedef std::map<int, RealTime> OutputTimestampMap;
+    typedef map<int, RealTime> OutputTimestampMap;
     OutputTimestampMap m_prevTimestamps; // output number -> timestamp
     OutputTimestampMap m_prevDurations; // output number -> durations
 
     struct OutputBinSummary {
 

         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;
+    typedef map<int, OutputBinSummary> OutputSummary;
+    typedef map<RealTime, OutputSummary> SummarySegmentMap;
+    typedef map<int, SummarySegmentMap> OutputSummarySegmentMap;
 
     OutputSummarySegmentMap m_summaries;
 
     bool m_reduced;
     RealTime m_endTime;

     void accumulateFinalDurations();
     void findSegmentBounds(RealTime t, RealTime &start, RealTime &end);
     void segment();
     void reduce();
 
-    std::string getSummaryLabel(SummaryType type, AveragingMethod avg);
+    string getSummaryLabel(SummaryType type, AveragingMethod avg);
 };
 
 static RealTime INVALID_DURATION(INT_MIN, INT_MIN);
     
 PluginSummarisingAdapter::PluginSummarisingAdapter(Plugin *plugin) :

 Plugin::FeatureSet
 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;
+        cerr << "WARNING: Cannot call PluginSummarisingAdapter::process() or getRemainingFeatures() after one of the getSummary methods" << endl;
     }
     FeatureSet fs = m_plugin->process(inputBuffers, timestamp);
     accumulate(fs, timestamp, false);
     m_endTime = timestamp + 
         RealTime::frame2RealTime(m_stepSize, int(m_inputSampleRate + 0.5));
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
+    cerr << "timestamp = " << timestamp << ", end time becomes " << m_endTime
+         << endl;
+#endif
     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;
+        cerr << "WARNING: Cannot call PluginSummarisingAdapter::process() or getRemainingFeatures() after one of the getSummary methods" << endl;
     }
     FeatureSet fs = m_plugin->getRemainingFeatures();
     accumulate(fs, m_endTime, true);
     return fs;
 }

 void
 PluginSummarisingAdapter::Impl::setSummarySegmentBoundaries(const SegmentBoundaries &b)
 {
     m_boundaries = b;
 #ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
-    std::cerr << "PluginSummarisingAdapter::setSummarySegmentBoundaries: boundaries are:" << std::endl;
+    cerr << "PluginSummarisingAdapter::setSummarySegmentBoundaries: boundaries are:" << endl;
     for (SegmentBoundaries::const_iterator i = m_boundaries.begin();
          i != m_boundaries.end(); ++i) {
-        std::cerr << *i << "  ";
-    }
-    std::cerr << std::endl;
+        cerr << *i << "  ";
+    }
+    cerr << endl;
 #endif
 }
 
 Plugin::FeatureList
 PluginSummarisingAdapter::Impl::getSummaryForOutput(int output,

             }
         }
     }
 }
 
-std::string
+string
 PluginSummarisingAdapter::Impl::getSummaryLabel(SummaryType type,
                                                 AveragingMethod avg)
 {
-    std::string label;
-    std::string avglabel;
+    string label;
+    string avglabel;
 
     if (avg == SampleAverage) avglabel = ", sample average";
     else avglabel = ", continuous-time average";
 
     switch (type) {

 
 void
 PluginSummarisingAdapter::Impl::accumulate(int output,
                                            const Feature &f,
                                            RealTime timestamp,
-                                           bool /* final */)
+                                           bool
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
+                                           final
+#endif
+    )
 {
     // What should happen if a feature's duration spans a segment
     // boundary?  I think we probably want to chop it, and pretend
     // that it appears in both.  A very long feature (e.g. key, if the
     // whole audio is in a single key) might span many or all

     // to have per-segment accumulators (and the feature value goes
     // into both -- with a separate phase to split the accumulator up
     // into segments).
 
 #ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
-    std::cerr << "output " << output << ": timestamp " << timestamp << ", prev timestamp " << m_prevTimestamps[output] << ", final " << final << std::endl;
+    cerr << "output " << output << ": timestamp " << timestamp << ", prev timestamp " << m_prevTimestamps[output] << ", final " << final << endl;
 #endif
 
     // At each process step, accumulate() is called once for each
     // feature on each output within that process's returned feature
     // list, and with the timestamp passed in being that of the start

         // current timestamps.
 
         if (m_prevDurations[output] != INVALID_DURATION) {
             prevDuration = m_prevDurations[output];
 #ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
-            std::cerr << "Previous duration from previous feature: " << prevDuration << std::endl;
+            cerr << "Previous duration from previous feature: " << prevDuration << endl;
 #endif
         } else {
             prevDuration = timestamp - m_prevTimestamps[output];
 #ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
-            std::cerr << "Previous duration from diff: " << timestamp << " - "
-                      << m_prevTimestamps[output] << std::endl;
+            cerr << "Previous duration from diff: " << timestamp << " - "
+                      << m_prevTimestamps[output] << endl;
 #endif
         }
 
 #ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
-        std::cerr << "output " << output << ": ";
-        std::cerr << "Pushing previous duration as " << prevDuration << std::endl;
+        cerr << "output " << output << ": ";
+        cerr << "Pushing previous duration as " << prevDuration << endl;
 #endif
         
         m_accumulators[output].results
             [m_accumulators[output].results.size() - 1]
             .duration = prevDuration;

 
     if (f.hasDuration) {
         RealTime et = timestamp;
         et = et + f.duration;
         if (et > m_endTime) m_endTime = et;
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
+        cerr << "feature has duration, updating end time to " << m_endTime << endl;
+#endif
     }
 
     Result result;
     result.time = timestamp;
     result.duration = INVALID_DURATION;

         int acount = m_accumulators[output].results.size();
 
         if (acount == 0) continue;
 
 #ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
-        std::cerr << "output " << output << ": ";
+        cerr << "output " << output << ": ";
 #endif
 
         if (m_prevDurations.find(output) != m_prevDurations.end() &&
             m_prevDurations[output] != INVALID_DURATION) {
 
 #ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
-            std::cerr << "Pushing final duration from feature as " << m_prevDurations[output] << std::endl;
+            cerr << "Pushing final duration from feature as " << m_prevDurations[output] << endl;
 #endif
 
             m_accumulators[output].results[acount - 1].duration =
                 m_prevDurations[output];
 
         } else {
 
 #ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
-            std::cerr << "Pushing final duration from diff as " << m_endTime << " - " << m_prevTimestamps[output] << std::endl;
+            cerr << "Pushing final duration from diff as " << m_endTime << " - " << m_prevTimestamps[output] << endl;
 #endif
 
             m_accumulators[output].results[acount - 1].duration =
                 m_endTime - m_prevTimestamps[output];
         }
         
 #ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
-        std::cerr << "so duration for result no " << acount-1 << " is "
+        cerr << "so duration for result no " << acount-1 << " is "
                   << m_accumulators[output].results[acount-1].duration
-                  << std::endl;
+                  << endl;
 #endif
     }
 }
 
 void
 PluginSummarisingAdapter::Impl::findSegmentBounds(RealTime t,
                                                   RealTime &start,
                                                   RealTime &end)
 {
 #ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER_SEGMENT
-    std::cerr << "findSegmentBounds: t = " << t <<  std::endl;
-#endif
-
-    SegmentBoundaries::const_iterator i = std::upper_bound
+    cerr << "findSegmentBounds: t = " << t <<  endl;
+#endif
+
+    SegmentBoundaries::const_iterator i = upper_bound
         (m_boundaries.begin(), m_boundaries.end(), t);
 
     start = RealTime::zeroTime;
     end = m_endTime;
 

     if (i != m_boundaries.begin()) {
         start = *--i;
     }
 
 #ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER_SEGMENT
-    std::cerr << "findSegmentBounds: " << t << " is in segment " << start << " -> " << end << std::endl;
+    cerr << "findSegmentBounds: " << t << " is in segment " << start << " -> " << end << endl;
 #endif
 }
 
 void
 PluginSummarisingAdapter::Impl::segment()
 {
     SegmentBoundaries::iterator boundaryitr = m_boundaries.begin();
     
 #ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER_SEGMENT
-    std::cerr << "segment: starting" << std::endl;
+    cerr << "segment: starting" << endl;
 #endif
 
     for (OutputAccumulatorMap::iterator i = m_accumulators.begin();
          i != m_accumulators.end(); ++i) {
 
         int output = i->first;
         OutputAccumulator &source = i->second;
 
 #ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER_SEGMENT
-        std::cerr << "segment: total results for output " << output << " = "
-                  << source.results.size() << std::endl;
+        cerr << "segment: total results for output " << output << " = "
+                  << source.results.size() << endl;
 #endif
 
         // This is basically nonsense if the results have no values
         // (i.e. their times and counts are the only things of
         // interest)... but perhaps it's the user's problem if they

 
             RealTime resultStart = source.results[n].time;
             RealTime resultEnd = resultStart + source.results[n].duration;
 
 #ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER_SEGMENT
-            std::cerr << "output: " << output << ", result start = " << resultStart << ", end = " << resultEnd << std::endl;
+            cerr << "output: " << output << ", result start = " << resultStart << ", end = " << resultEnd << endl;
 #endif
 
             RealTime segmentStart = RealTime::zeroTime;
             RealTime segmentEnd = resultEnd - RealTime(1, 0);
             
             RealTime prevSegmentStart = segmentStart - RealTime(1, 0);
 
             while (segmentEnd < resultEnd) {
 
 #ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER_SEGMENT
-                std::cerr << "segment end " << segmentEnd << " < result end "
-                          << resultEnd << " (with result start " << resultStart << ")" <<  std::endl;
+                cerr << "segment end " << segmentEnd << " < result end "
+                          << resultEnd << " (with result start " << resultStart << ")" <<  endl;
 #endif
 
                 findSegmentBounds(resultStart, segmentStart, segmentEnd);
 
                 if (segmentStart == prevSegmentStart) {

                 chunk.time = chunkStart;
                 chunk.duration = chunkEnd - chunkStart;
                 chunk.values = source.results[n].values;
 
 #ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER_SEGMENT
-                std::cerr << "chunk for segment " << segmentStart << ": from " << chunk.time << ", duration " << chunk.duration << std::endl;
+                cerr << "chunk for segment " << segmentStart << ": from " << chunk.time << ", duration " << chunk.duration << endl;
 #endif
 
                 m_segmentedAccumulators[output][segmentStart].results
                     .push_back(chunk);
 

             OutputAccumulator &accumulator = j->second;
 
             int sz = accumulator.results.size();
 
 #ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
-            std::cerr << "reduce: segment starting at " << segmentStart
-                      << " on output " << output << " has " << sz << " result(s)" << std::endl;
+            cerr << "reduce: segment starting at " << segmentStart
+                      << " on output " << output << " has " << sz << " result(s)" << endl;
 #endif
 
             double totalDuration = 0.0;
             //!!! is this right?
             if (sz > 0) {
 #ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
-                std::cerr << "last time = " << accumulator.results[sz-1].time 
+                cerr << "last time = " << accumulator.results[sz-1].time 
                           << ", duration = " << accumulator.results[sz-1].duration
                           << " (step = " << m_stepSize << ", block = " << m_blockSize << ")"
-                          << std::endl;
+                          << endl;
 #endif
                 totalDuration = toSec((accumulator.results[sz-1].time +
                                        accumulator.results[sz-1].duration) -
                                       segmentStart);
             }
 
             for (int bin = 0; bin < accumulator.bins; ++bin) {
 
                 // work on all values over time for a single bin
 
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
+                cerr << "bin " << bin << ":" << endl;
+#endif
+                
                 OutputBinSummary summary;
 
                 summary.count = sz;
 
                 summary.minimum = 0.f;

                 summary.mean_c = 0.f;
                 summary.variance_c = 0.f;
 
                 if (sz == 0) continue;
 
-                std::vector<ValueDurationFloatPair> valvec;
+                vector<ValueDurationFloatPair> valvec;
 
                 for (int k = 0; k < sz; ++k) {
                     while (int(accumulator.results[k].values.size()) <
                            accumulator.bins) {
                         accumulator.results[k].values.push_back(0.f);

                     valvec.push_back(ValueDurationFloatPair
                                      (value,
                                       toSec(accumulator.results[k].duration)));
                 }
 
-                std::sort(valvec.begin(), valvec.end());
+                sort(valvec.begin(), valvec.end());
 
                 summary.minimum = valvec[0].value;
                 summary.maximum = valvec[sz-1].value;
 
 #ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
-                std::cerr << "total duration = " << totalDuration << std::endl;
+                cerr << "total duration = " << totalDuration << endl;
 #endif
 
 #ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
 /*
-                std::cerr << "value vector for medians:" << std::endl;
+                cerr << "value vector for medians:" << endl;
                 for (int k = 0; k < sz; ++k) {
-                    std::cerr << "(" << valvec[k].value << "," << valvec[k].duration << ") ";
-                }
-                std::cerr << std::endl;
+                    cerr << "(" << valvec[k].value << "," << valvec[k].duration << ") ";
+                }
+                cerr << endl;
 */
 #endif
 
                 if (sz % 2 == 1) {
                     summary.median = valvec[sz/2].value;

                         break;
                     }
                 }
 
 #ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
-                std::cerr << "median_c = " << summary.median_c << std::endl;
-                std::cerr << "median = " << summary.median << std::endl;
+                cerr << "median_c = " << summary.median_c << endl;
+                cerr << "median = " << summary.median << endl;
 #endif
                 
-                std::map<float, int> distribution;
+                map<float, int> distribution;
 
                 for (int k = 0; k < sz; ++k) {
                     summary.sum += accumulator.results[k].values[bin];
                     distribution[accumulator.results[k].values[bin]] += 1;
                 }
 
                 int md = 0;
 
-                for (std::map<float, int>::iterator di = distribution.begin();
+                for (map<float, int>::iterator di = distribution.begin();
                      di != distribution.end(); ++di) {
                     if (di->second > md) {
                         md = di->second;
                         summary.mode = di->first;
                     }
                 }
 
                 distribution.clear();
 
-                std::map<float, double> distribution_c;
+                map<float, double> distribution_c;
 
                 for (int k = 0; k < sz; ++k) {
                     distribution_c[accumulator.results[k].values[bin]]
                         += toSec(accumulator.results[k].duration);
                 }
 
                 double mrd = 0.0;
 
-                for (std::map<float, double>::iterator di = distribution_c.begin();
+                for (map<float, double>::iterator di = distribution_c.begin();
                      di != distribution_c.end(); ++di) {
                     if (di->second > mrd) {
                         mrd = di->second;
                         summary.mode_c = di->first;
                     }

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

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