comparison src/Silvet.cpp @ 167:416b555df3b2 finetune

More on returning fine tuning (but we're treating different shifts of the same pitch as different notes at the moment which is not right)

 
     return buf;
 }
 
 float
-Silvet::noteFrequency(int note) const
-{
-    return float(27.5 * pow(2.0, note / 12.0));
+Silvet::noteFrequency(int note, int shiftCount) const
+{
+    float fineNote = float(note) / float(shiftCount);
+    return float(27.5 * pow(2.0, fineNote / 12.0));
 }
 
 bool
 Silvet::initialise(size_t channels, size_t stepSize, size_t blockSize)
 {

 
         for (int j = 0; j < iterations; ++j) {
             em[i]->iterate(filtered.at(i).data());
         }
     }
+
+    int shiftCount = 1;
+    if (m_hqMode && m_fineTuning) {
+        shiftCount = m_instruments[m_instrument].templateMaxShift * 2 + 1;
+    }
         
     for (int i = 0; i < width; ++i) {
 
         if (!em[i]) {
-            noteTrack(map<int, double>());
+            noteTrack(map<int, double>(), shiftCount);
             continue;
         }
 
         map<int, double> active = postProcess(em[i]->getPitchDistribution(),
                                               em[i]->getShifts(),
-                                              em[i]->getShiftCount(),
+                                              shiftCount,
                                               sums[i]);
         
         delete em[i];
         
-        FeatureList noteFeatures = noteTrack(active);
+        FeatureList noteFeatures = noteTrack(active, shiftCount);
 
         for (FeatureList::const_iterator fi = noteFeatures.begin();
              fi != noteFeatures.end(); ++fi) {
             fs[m_notesOutputNo].push_back(*fi);
         }

     for (int j = 0; j < processingNotes; ++j) {
 
         double strength = filtered[j];
         if (strength < threshold) continue;
 
-        // convert note number j to a pitch value p. If we are not using fine tuning or 
-
-        strengths.insert(ValueIndexMap::value_type(strength, j));
+        // convert note number j to a pitch value p. If we are not
+        // using fine tuning, p is the same as j; otherwise p is j *
+        // shiftCount + preferred shift
+
+        int p = j;
+
+        if (m_hqMode && m_fineTuning && shiftCount > 1) {
+            float bestShiftValue = 0.f;
+            int bestShift = 0;
+            for (int f = 0; f < shiftCount; ++f) {
+                if (f == 0 || shifts[f][j] > bestShiftValue) {
+                    bestShiftValue = shifts[f][j];
+                    bestShift = f;
+                }
+            }
+            //!!! I think our shift array per note is actually upside down, check this
+            p = j * shiftCount + bestShift;
+        }
+
+        strengths.insert(ValueIndexMap::value_type(strength, p));
     }
 
     map<int, double> active;
     ValueIndexMap::const_iterator si = strengths.end();
     while (int(active.size()) < polyphony && si != strengths.begin()) {

 
     return active;
 }
 
 Vamp::Plugin::FeatureList
-Silvet::noteTrack(const map<int, double> &active)
+Silvet::noteTrack(const map<int, double> &active, int shiftCount)
 {        
     // 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 last set in the piano
     // roll) -- any notes that ended earlier will have been reported

         nf.timestamp = RealTime::fromSeconds
             (columnDuration * (start - postFilterLatency) + 0.02);
         nf.hasDuration = true;
         nf.duration = RealTime::fromSeconds
             (columnDuration * duration);
-        nf.values.push_back(noteFrequency(note));
+        nf.values.push_back(noteFrequency(note, shiftCount));
         nf.values.push_back(velocity);
         nf.label = noteName(note);
         noteFeatures.push_back(nf);
     }