comparison PYinVamp.cpp @ 146:8404827a4b02 memory

Avoid calculating a temporary obsprob matrix for note tracking; + some tidying

     d.identifier = "f0candidates";
     d.name = "F0 Candidates";
     d.description = "Estimated fundamental frequency candidates.";
     d.unit = "Hz";
     d.hasFixedBinCount = false;
-    // d.binCount = 1;
     d.hasKnownExtents = true;
     d.minValue = m_fmin;
     d.maxValue = 500;
     d.isQuantized = false;
     d.sampleType = OutputDescriptor::FixedSampleRate;

     outputs.push_back(d);
     m_oF0Candidates = outputNumber++;
 
     d.identifier = "f0probs";
     d.name = "Candidate Probabilities";
-    d.description = "Probabilities  of estimated fundamental frequency candidates.";
+    d.description = "Probabilities of estimated fundamental frequency candidates.";
     d.unit = "";
     d.hasFixedBinCount = false;
-    // d.binCount = 1;
     d.hasKnownExtents = true;
     d.minValue = 0;
     d.maxValue = 1;
     d.isQuantized = false;
     d.sampleType = OutputDescriptor::FixedSampleRate;

     outputs.push_back(d);
     m_oCandidateSalience = outputNumber++;
     
     d.identifier = "smoothedpitchtrack";
     d.name = "Smoothed Pitch Track";
-    d.description = ".";
+    d.description = "Frame-by-frame pitch estimate after smoothing";
     d.unit = "Hz";
     d.hasFixedBinCount = true;
     d.binCount = 1;
     d.hasKnownExtents = false;
-    // d.minValue = 0;
-    // d.maxValue = 1;
     d.isQuantized = false;
     d.sampleType = OutputDescriptor::FixedSampleRate;
     d.sampleRate = (m_inputSampleRate / m_stepSize);
     d.hasDuration = false;
     outputs.push_back(d);
     m_oSmoothedPitchTrack = outputNumber++;
 
     d.identifier = "notes";
     d.name = "Notes";
     d.description = "Derived fixed-pitch note frequencies";
-    // d.unit = "MIDI unit";
     d.unit = "Hz";
     d.hasFixedBinCount = true;
     d.binCount = 1;
     d.hasKnownExtents = false;
     d.isQuantized = false;

 PYinVamp::initialise(size_t channels, size_t stepSize, size_t blockSize)
 {
     if (channels < getMinChannelCount() ||
 	channels > getMaxChannelCount()) return false;
 
-/*
-    std::cerr << "PYinVamp::initialise: channels = " << channels
-          << ", stepSize = " << stepSize << ", blockSize = " << blockSize
-          << std::endl;
-*/
     m_channels = channels;
     m_stepSize = stepSize;
     m_blockSize = blockSize;
     
     reset();

     
     m_pitchProb.clear();
     m_timestamp.clear();
     m_level.clear();
     m_pitchTrack.clear();
-/*    
-    std::cerr << "PYinVamp::reset"
-          << ", blockSize = " << m_blockSize
-          << std::endl;
-*/
 }
 
 PYinVamp::FeatureSet
 PYinVamp::process(const float *const *inputBuffers, RealTime timestamp)
 {
-//    std::cerr << timestamp << std::endl;
     int offset = m_preciseTime == 1.0 ? m_blockSize/2 : m_blockSize/4;
     timestamp = timestamp + Vamp::RealTime::frame2RealTime(offset, 
         lrintf(m_inputSampleRate));
 
     FeatureSet fs;

                 fs[m_oSmoothedPitchTrack].push_back(f);
             }
         }
     }
 
-
     // F0 CANDIDATES
     Feature f;
     f.hasTimestamp = true;
     f.timestamp = timestamp;
     for (size_t i = 0; i < yo.freqProb.size(); ++i)

 
 PYinVamp::FeatureSet
 PYinVamp::getRemainingFeatures()
 {
     FeatureSet fs;
+
+    if (m_pitchProb.empty()) {
+        return fs;
+    }
+
     Feature f;
     f.hasTimestamp = true;
     f.hasDuration = false;
-    
-    if (m_pitchProb.empty()) {
-        return fs;
-    }
 
     // ================== P I T C H  T R A C K =================================
 
+    // NB we do this even in fixed-lag mode, as we still have the last
+    // lag's-worth of pitch probs to consume
+    
     vector<int> rawPitchPath = m_pitchHmm.track();
     
     for (size_t iFrame = 0; iFrame < rawPitchPath.size(); ++iFrame)
     {
         float freq = m_pitchHmm.nearestFreq(rawPitchPath[iFrame], 
                                             m_pitchProb[iFrame]);
         m_pitchTrack.push_back(freq); // for note processing below
-
+        
         f.timestamp = m_timestamp[iFrame];
         f.values.clear();
-
+        
         // different output modes
         if (freq < 0 && (m_outputUnvoiced==0)) continue;
         if (m_outputUnvoiced == 1)
         {
             f.values.push_back(fabs(freq));
         } else {
             f.values.push_back(freq);
         }
         fs[m_oSmoothedPitchTrack].push_back(f);
     }
-    
-    // ======================== N O T E S ======================================
-    MonoNote mn;
+
+    addNoteFeatures(fs);
+
+    return fs;
+}
+
+void
+PYinVamp::addNoteFeatures(FeatureSet &fs)
+{
     std::vector<std::vector<std::pair<double, double> > > smoothedPitch;
     for (size_t iFrame = 0; iFrame < m_pitchTrack.size(); ++iFrame) {
         std::vector<std::pair<double, double> > temp;
         if (m_pitchTrack[iFrame] > 0)
         {
             double tempPitch = 12 * 
                 std::log(m_pitchTrack[iFrame]/440)/std::log(2.) + 69;
             temp.push_back(std::pair<double,double>(tempPitch, .9));
-            // std::cerr << "tempPitch: " << tempPitch << std::endl;
         }
-        // std::cerr << "temp size: " << temp.size() << std::endl;
         smoothedPitch.push_back(temp);
     }
 
+    MonoNote mn;
     vector<MonoNote::FrameOutput> mnOut = mn.process(smoothedPitch);
+
     std::cerr << "mnOut size: " << mnOut.size() << std::endl;
     std::cerr << "m_pitchTrack size: " << m_pitchTrack.size() << std::endl;
     
     // turning feature into a note feature
+    Feature f;
     f.hasTimestamp = true;
     f.hasDuration = true;
     f.values.clear();
         
     int onsetFrame = 0;

                 notePitchTrack.clear();
             }
         }
         oldIsVoiced = isVoiced;
     }
-    return fs;
-}
+}