comparison src/Silvet.cpp @ 272:e5f897b2d5e8

Handle resampler latency, impose limits on input sample rate

 using std::endl;
 using Vamp::RealTime;
 
 static int processingSampleRate = 44100;
 static int processingBPO = 60;
+
+static int minInputSampleRate = 100;
+static int maxInputSampleRate = 192000;
 
 Silvet::Silvet(float inputSampleRate) :
     Plugin(inputSampleRate),
     m_instruments(InstrumentPack::listInstrumentPacks()),
     m_resampler(0),

 }
 
 bool
 Silvet::initialise(size_t channels, size_t stepSize, size_t blockSize)
 {
+    if (m_inputSampleRate < minInputSampleRate ||
+        m_inputSampleRate > maxInputSampleRate) {
+	cerr << "Silvet::initialise: Unsupported input sample rate "
+             << m_inputSampleRate << " (supported min " << minInputSampleRate
+             << ", max " << maxInputSampleRate << ")" << endl;
+        return false;
+    }
+
     if (channels < getMinChannelCount() ||
-	channels > getMaxChannelCount()) return false;
+	channels > getMaxChannelCount()) {
+	cerr << "Silvet::initialise: Unsupported channel count " << channels
+             << " (supported min " << getMinChannelCount() << ", max "
+             << getMaxChannelCount() << ")" << endl;
+        return false;
+    }
 
     if (stepSize != blockSize) {
 	cerr << "Silvet::initialise: Step size must be the same as block size ("
 	     << stepSize << " != " << blockSize << ")" << endl;
 	return false;

         m_postFilter.push_back(new MedianFilter<double>(3));
     }
     m_pianoRoll.clear();
     m_inputGains.clear();
     m_columnCount = 0;
+    m_resampledCount = 0;
     m_startTime = RealTime::zeroTime;
 }
 
 Silvet::FeatureSet
 Silvet::process(const float *const *inputBuffers, Vamp::RealTime timestamp)

         double d = flattened[i];
         data.push_back(d);
     }
 
     if (m_resampler) {
+
 	data = m_resampler->process(data.data(), data.size());
-    }
- 
+
+        int hadCount = m_resampledCount;
+        m_resampledCount += data.size();
+
+        int resamplerLatency = m_resampler->getLatency();
+
+        if (hadCount < resamplerLatency) {
+            int stillToDrop = resamplerLatency - hadCount;
+            if (stillToDrop >= int(data.size())) {
+                return FeatureSet();
+            } else {
+                data = vector<double>(data.begin() + stillToDrop, data.end());
+            }
+        }
+    }
+
     Grid cqout = m_cq->process(data);
     FeatureSet fs = transcribe(cqout);
     return fs;
 }
 

 
     int width = filtered.size();
 
     int iterations = m_hqMode ? 20 : 10;
 
-    //!!! pitches or notes? [terminology]
     Grid localPitches(width, vector<double>(pack.templateNoteCount, 0.0));
 
     bool wantShifts = m_hqMode && m_fineTuning;
     int shiftCount = 1;
     if (wantShifts) {