comparison src/Silvet.cpp @ 336:d25e4aee73d7 livemode

Add onset+offset output; look up shift counts rather than passing them around

     d.isQuantized = false;
     d.sampleType = OutputDescriptor::VariableSampleRate;
     d.sampleRate = processingSampleRate / (m_cq ? m_cq->getColumnHop() : 62);
     d.hasDuration = false;
     m_onsetsOutputNo = list.size();
+    list.push_back(d);
+
+    d.identifier = "onoffsets";
+    d.name = "Note onsets and offsets";
+    d.description = "Note onsets and offsets as separate events. Each onset event has time, estimated fundamental frequency in Hz, and a synthetic MIDI velocity (1-127) estimated from the strength of the pitch in the mixture. Offsets are represented in the same way but with a velocity of 0.";
+    d.unit = "Hz";
+    d.hasFixedBinCount = true;
+    d.binCount = 2;
+    d.binNames.push_back("Frequency");
+    d.binNames.push_back("Velocity");
+    d.hasKnownExtents = false;
+    d.isQuantized = false;
+    d.sampleType = OutputDescriptor::VariableSampleRate;
+    d.sampleRate = processingSampleRate / (m_cq ? m_cq->getColumnHop() : 62);
+    d.hasDuration = false;
+    m_onOffsetsOutputNo = list.size();
     list.push_back(d);
 
     d.identifier = "timefreq";
     d.name = "Time-frequency distribution";
     d.description = "Filtered constant-Q time-frequency distribution as used as input to the expectation-maximisation algorithm.";

     d.hasFixedBinCount = true;
     d.binCount = getPack(0).templateNoteCount;
     d.binNames.clear();
     if (m_cq) {
         for (int i = 0; i < getPack(0).templateNoteCount; ++i) {
-            d.binNames.push_back(getNoteName(i, 0, 1));
+            d.binNames.push_back(getNoteName(i, 0));
         }
     }
     d.hasKnownExtents = false;
     d.isQuantized = false;
     d.sampleType = OutputDescriptor::FixedSampleRate;

 
     return names[pitch];
 }
     
 std::string
-Silvet::getNoteName(int note, int shift, int shiftCount) const
+Silvet::getNoteName(int note, int shift) const
 {
     string n = getChromaName(note % 12);
 
     int oct = (note + 9) / 12; 
     
     char buf[30];
 
     float pshift = 0.f;
+    int shiftCount = getShiftCount();
     if (shiftCount > 1) {
         // see getNoteFrequency below
         pshift = 
             float((shiftCount - shift) - int(shiftCount / 2) - 1) / shiftCount;
     }

 
     return buf;
 }
 
 float
-Silvet::getNoteFrequency(int note, int shift, int shiftCount) const
+Silvet::getNoteFrequency(int note, int shift) const
 {
     // Convert shift number to a pitch shift. The given shift number
     // is an offset into the template array, which starts with some
     // zeros, followed by the template, then some trailing zeros.
     // 

     // zeros at the start, which is the low-frequency end), for a
     // positive pitch shift; and higher values represent moving it
     // down in pitch, for a negative pitch shift.
 
     float pshift = 0.f;
+    int shiftCount = getShiftCount();
     if (shiftCount > 1) {
         pshift = 
             float((shiftCount - shift) - int(shiftCount / 2) - 1) / shiftCount;
     }
 

 Silvet::FeatureSet
 Silvet::getRemainingFeatures()
 {
     Grid cqout = m_cq->getRemainingOutput();
     FeatureSet fs;
+
     if (m_columnCount == 0) {
         // process() was never called, but we still want these
         insertTemplateFeatures(fs);
     } else {
+
+        // Complete the transcription
+
         transcribe(cqout, fs);
-    }
+
+        // And make sure any extant playing notes are finished and returned
+
+        m_pianoRoll.push_back({});
+
+        auto events = noteTrack();
+    
+        for (const auto &f : events.notes) {
+            fs[m_notesOutputNo].push_back(f);
+        }
+    
+        for (const auto &f : events.onsets) {
+            fs[m_onsetsOutputNo].push_back(f);
+        }
+    
+        for (const auto &f : events.onOffsets) {
+            fs[m_onOffsetsOutputNo].push_back(f);
+        }
+    }
+
     return fs;
 }
 
 void
 Silvet::insertTemplateFeatures(FeatureSet &fs)

             .data[i % pack.templateNoteCount];
         fs[m_templateOutputNo].push_back(f);
     }
 }        
 
+int
+Silvet::getShiftCount() const
+{
+    bool wantShifts = (m_mode == HighQualityMode) && m_fineTuning;
+    int shiftCount = 1;
+    if (wantShifts) {
+        const InstrumentPack &pack(getPack(m_instrument));
+        shiftCount = pack.templateMaxShift * 2 + 1;
+    }
+    return shiftCount;
+}
+
 void
 Silvet::transcribe(const Grid &cqout, Silvet::FeatureSet &fs)
 {
     Grid filtered = preProcess(cqout);
 

         fs[m_fcqOutputNo].push_back(f);
     }
     
     Grid localPitches(width);
 
-    bool wantShifts = (m_mode == HighQualityMode) && m_fineTuning;
-    int shiftCount = 1;
-    if (wantShifts) {
-        shiftCount = pack.templateMaxShift * 2 + 1;
-    }
+    int shiftCount = getShiftCount();
+    bool wantShifts = (shiftCount > 1);
 
     vector<vector<int> > localBestShifts;
     if (wantShifts) {
         localBestShifts = vector<vector<int> >(width);
     }

             vector<EMFuture> results;
             for (int j = 0; j < emThreadCount && i + j < width; ++j) {
                 results.push_back
                     (async(std::launch::async,
                            [&](int index) {
-                               return applyEM
-                                   (pack, filtered.at(index), wantShifts);
+                               return applyEM(pack, filtered.at(index));
                            }, i + j));
             }
             for (int j = 0; j < emThreadCount && i + j < width; ++j) {
                 auto out = results[j].get();
                 localPitches[i+j] = out.first;

     }
 #endif
 
     if (emThreadCount == 1) {
         for (int i = 0; i < width; ++i) {
-            auto out = applyEM(pack, filtered.at(i), wantShifts);
+            auto out = applyEM(pack, filtered.at(i));
             localPitches[i] = out.first;
             if (wantShifts) localBestShifts[i] = out.second;
         }
     }
         

         }
         fs[m_chromaOutputNo].push_back(f);
 
         // This pushes the up-to-max-polyphony activation column to
         // m_pianoRoll
-        postProcess(filtered, localBestShifts[i], wantShifts);
-
-        auto events = noteTrack(shiftCount);
-
-        FeatureList noteFeatures = events.first;
-        for (FeatureList::const_iterator fi = noteFeatures.begin();
-             fi != noteFeatures.end(); ++fi) {
-            fs[m_notesOutputNo].push_back(*fi);
-        }
-
-        FeatureList onsetFeatures = events.second;
-        for (FeatureList::const_iterator fi = onsetFeatures.begin();
-             fi != onsetFeatures.end(); ++fi) {
-            fs[m_onsetsOutputNo].push_back(*fi);
+        postProcess(filtered, localBestShifts[i]);
+
+        auto events = noteTrack();
+
+        for (const auto &f : events.notes) {
+            fs[m_notesOutputNo].push_back(f);
+        }
+
+        for (const auto &f : events.onsets) {
+            fs[m_onsetsOutputNo].push_back(f);
+        }
+
+        for (const auto &f : events.onOffsets) {
+            fs[m_onOffsetsOutputNo].push_back(f);
         }
     }
 }
 
 pair<vector<double>, vector<int> >
 Silvet::applyEM(const InstrumentPack &pack,
-                const vector<double> &column,
-                bool wantShifts)
+                const vector<double> &column)
 {
     double columnThreshold = 1e-5;
     
     if (m_mode == LiveMode) {
         columnThreshold /= 15;

     }
 
     const float *pitchDist = em.getPitchDistribution();
     const float *const *shiftDist = em.getShifts();
 
-    int shiftCount = 1;
-    if (wantShifts) {
-        shiftCount = pack.templateMaxShift * 2 + 1;
-    }
+    int shiftCount = getShiftCount();
     
     for (int j = 0; j < pack.templateNoteCount; ++j) {
 
         pitches[j] = pitchDist[j] * sum;
 
         int bestShift = 0;
         float bestShiftValue = 0.0;
-        if (wantShifts) {
+        if (shiftCount > 1) {
             for (int k = 0; k < shiftCount; ++k) {
                 float value = shiftDist[k][j];
                 if (k == 0 || value > bestShiftValue) {
                     bestShiftValue = value;
                     bestShift = k;

     return out;
 }
     
 void
 Silvet::postProcess(const vector<double> &pitches,
-                    const vector<int> &bestShifts,
-                    bool wantShifts)
+                    const vector<int> &bestShifts)
 {
     const InstrumentPack &pack(getPack(m_instrument));
 
     // Threshold for level and reduce number of candidate pitches
 

     ValueIndexMap::const_iterator si = strengths.end();
 
     map<int, double> active;
     map<int, int> activeShifts;
 
+    int shiftCount = getShiftCount();
+    
     while (int(active.size()) < pack.maxPolyphony && si != strengths.begin()) {
 
         --si;
 
         double strength = si->first;
         int j = si->second;
 
         active[j] = strength;
 
-        if (wantShifts) {
+        if (shiftCount > 1) {
             activeShifts[j] = bestShifts[j];
         }
     }
 
     m_pianoRoll.push_back(active);
 
-    if (wantShifts) {
+    if (shiftCount > 1) {
         m_pianoRollShifts.push_back(activeShifts);
     }
 
     return;
 }
 
-pair<Vamp::Plugin::FeatureList, Vamp::Plugin::FeatureList>
-Silvet::noteTrack(int shiftCount)
+Silvet::FeatureChunk
+Silvet::noteTrack()
 {        
     // Minimum duration pruning, and conversion to notes. We can only
     // report notes that have just ended (i.e. that are absent in the
     // latest active set but present in the prior set in the piano
     // roll) -- any notes that ended earlier will have been reported

     // only keep notes >= 100ms or thereabouts
     double durationThrSec = 0.1;
     int durationThreshold = floor(durationThrSec / columnDuration); // in cols
     if (durationThreshold < 1) durationThreshold = 1;
 
-    FeatureList noteFeatures, onsetFeatures;
+    FeatureList noteFeatures, onsetFeatures, onOffsetFeatures;
 
     if (width < durationThreshold + 1) {
-        return { noteFeatures, onsetFeatures };
+        return { noteFeatures, onsetFeatures, onOffsetFeatures };
     }
     
     for (map<int, double>::const_iterator ni = m_pianoRoll[width-1].begin();
          ni != m_pianoRoll[width-1].end(); ++ni) {
 

             continue;
         }
 
         if (duration == durationThreshold) {
             m_current.insert(note);
-            emitOnset(start, note, shiftCount, onsetFeatures);
+            emitOnset(start, note, onsetFeatures);
+            emitOnset(start, note, onOffsetFeatures);
         }            
         
         if (active.find(note) == active.end()) {
             // the note was playing but just ended
             m_current.erase(note);
-            emitNote(start, end, note, shiftCount, noteFeatures);
+            emitNote(start, end, note, noteFeatures);
+            emitOffset(start, end, note, onOffsetFeatures);
         } else { // still playing
             // repeated note detection: if level is greater than this
             // multiple of its previous value, then we end the note and
             // restart it with the same pitch
             double restartFactor = 1.5;
             if (duration >= durationThreshold * 2 &&
                 (active.find(note)->second >
                  restartFactor * m_pianoRoll[width-1][note])) {
                 m_current.erase(note);
-                emitNote(start, end-1, note, shiftCount, noteFeatures);
+                emitNote(start, end-1, note, noteFeatures);
+                emitOffset(start, end-1, note, onOffsetFeatures);
                 // and remove this so that we start counting the new
                 // note's duration from the current position
                 m_pianoRoll[width-1].erase(note);
             }
         }
     }
 
 //    cerr << "returning " << noteFeatures.size() << " complete note(s) " << endl;
 
-    return { noteFeatures, onsetFeatures };
+    return { noteFeatures, onsetFeatures, onOffsetFeatures };
 }
 
 void
-Silvet::emitNote(int start, int end, int note, int shiftCount,
-                 FeatureList &noteFeatures)
+Silvet::emitNote(int start, int end, int note, FeatureList &noteFeatures)
 {
     int partStart = start;
     int partShift = 0;
     double partStrength = 0;
 

         
         double strength = m_pianoRoll[i][note];
 
         int shift = 0;
 
-        if (shiftCount > 1) {
+        if (getShiftCount() > 1) {
 
             shift = m_pianoRollShifts[i][note];
 
             if (i == partStart) {
                 partShift = shift;

                 // pitch has changed, emit an intermediate note
                 noteFeatures.push_back(makeNoteFeature(partStart,
                                                        i,
                                                        note,
                                                        partShift,
-                                                       shiftCount,
                                                        partStrength));
                 partStart = i;
                 partShift = shift;
                 partStrength = 0;
             }

     if (end >= partStart + partThreshold) {
         noteFeatures.push_back(makeNoteFeature(partStart,
                                                end,
                                                note,
                                                partShift,
-                                               shiftCount,
                                                partStrength));
     }
 }
 
 void
-Silvet::emitOnset(int start, int note, int shiftCount,
-                  FeatureList &onsetFeatures)
+Silvet::emitOnset(int start, int note, FeatureList &onOffsetFeatures)
 {
     int len = int(m_pianoRoll.size());
 
     double onsetStrength = 0;
 
     int shift = 0;
-    if (shiftCount > 1) {
+    if (getShiftCount() > 1) {
         shift = m_pianoRollShifts[start][note];
     }
     
     for (int i = start; i < len; ++i) {
         double strength = m_pianoRoll[i][note];
         if (strength > onsetStrength) {
             onsetStrength = strength;
         }
     }
 
-    onsetFeatures.push_back(makeOnsetFeature(start,
-                                             note,
-                                             shift,
-                                             shiftCount,
-                                             onsetStrength));
+    if (onsetStrength == 0) return;
+    
+    onOffsetFeatures.push_back(makeOnsetFeature(start,
+                                                note,
+                                                shift,
+                                                onsetStrength));
+}
+
+void
+Silvet::emitOffset(int start, int end, int note, FeatureList &onOffsetFeatures)
+{
+    int shift = 0;
+    if (getShiftCount() > 1) {
+        shift = m_pianoRollShifts[start][note];
+    }
+    
+    onOffsetFeatures.push_back(makeOffsetFeature(end,
+                                                 note,
+                                                 shift));
 }
 
 RealTime
 Silvet::getColumnTimestamp(int column)
 {

 Silvet::Feature
 Silvet::makeNoteFeature(int start,
                         int end,
                         int note,
                         int shift,
-                        int shiftCount,
                         double strength)
 {
     Feature f;
 
     f.hasTimestamp = true;

 
     f.hasDuration = true;
     f.duration = getColumnTimestamp(end) - f.timestamp;
 
     f.values.clear();
-    f.values.push_back(getNoteFrequency(note, shift, shiftCount));
+    f.values.push_back(getNoteFrequency(note, shift));
     f.values.push_back(getVelocityFor(strength, start));
 
-    f.label = getNoteName(note, shift, shiftCount);
+    f.label = getNoteName(note, shift);
 
     return f;
 }
 
 Silvet::Feature
 Silvet::makeOnsetFeature(int start,
                          int note,
                          int shift,
-                         int shiftCount,
                          double strength)
 {
     Feature f;
 
     f.hasTimestamp = true;
     f.timestamp = getColumnTimestamp(start);
 
     f.hasDuration = false;
 
     f.values.clear();
-    f.values.push_back(getNoteFrequency(note, shift, shiftCount));
+    f.values.push_back(getNoteFrequency(note, shift));
     f.values.push_back(getVelocityFor(strength, start));
 
-    f.label = getNoteName(note, shift, shiftCount);
+    f.label = getNoteName(note, shift);
+
+    return f;
+}
+
+Silvet::Feature
+Silvet::makeOffsetFeature(int col,
+                          int note,
+                          int shift)
+{
+    Feature f;
+    
+    f.hasTimestamp = true;
+    f.timestamp = getColumnTimestamp(col);
+
+    f.hasDuration = false;
+
+    f.values.clear();
+    f.values.push_back(getNoteFrequency(note, shift));
+    f.values.push_back(0); // velocity 0 for offset
+
+    f.label = getNoteName(note, shift) + " off";
 
     return f;
 }
 
 int