comparison src/Silvet.cpp @ 176:8af9b6cd7451

Add some ensemble instrument packs

 using std::endl;
 using Vamp::RealTime;
 
 static int processingSampleRate = 44100;
 static int processingBPO = 60;
-
-//!!! todo: replace these two with values from instrument pack
-static int processingHeight = 545;
-static int processingNotes = 88;
 
 Silvet::Silvet(float inputSampleRate) :
     Plugin(inputSampleRate),
     m_instruments(InstrumentPack::listInstrumentPacks()),
     m_resampler(0),

     desc.quantizeStep = 1;
     desc.valueNames.push_back("Draft (faster)"); 
     desc.valueNames.push_back("Intensive (higher quality)");
     list.push_back(desc);
 
-    desc.identifier = "soloinstrument";
-    desc.name = "Solo instrument";
+    desc.identifier = "instrument";
+    desc.name = "Instrument";
     desc.unit = "";
     desc.description = "The instrument known to be present in the recording, if there is only one";
     desc.minValue = 0;
     desc.maxValue = m_instruments.size()-1;
     desc.defaultValue = 0;

 {
     if (identifier == "mode") {
         return m_hqMode ? 1.f : 0.f;
     } else if (identifier == "finetune") {
         return m_fineTuning ? 1.f : 0.f;
-    } else if (identifier == "soloinstrument") {
+    } else if (identifier == "instrument") {
         return m_instrument;
     }
     return 0;
 }
 

 {
     if (identifier == "mode") {
         m_hqMode = (value > 0.5);
     } else if (identifier == "finetune") {
         m_fineTuning = (value > 0.5);
-    } else if (identifier == "soloinstrument") {
+    } else if (identifier == "instrument") {
         m_instrument = lrintf(value);
     }
 }
 
 Silvet::ProgramList

 
     for (int i = 0; i < (int)m_postFilter.size(); ++i) {
         delete m_postFilter[i];
     }
     m_postFilter.clear();
-    for (int i = 0; i < processingNotes; ++i) {
+    for (int i = 0; i < m_instruments[0].templateNoteCount; ++i) {
         m_postFilter.push_back(new MedianFilter<double>(3));
     }
     m_pianoRoll.clear();
     m_columnCount = 0;
     m_startTime = RealTime::zeroTime;

     int width = filtered.size();
 
     int iterations = m_hqMode ? 20 : 10;
 
     //!!! pitches or notes? [terminology]
-    Grid localPitches(width, vector<double>(processingNotes, 0.0));
+    Grid localPitches(width, vector<double>(pack.templateNoteCount, 0.0));
 
     bool wantShifts = m_hqMode && m_fineTuning;
     int shiftCount = 1;
     if (wantShifts) {
         shiftCount = pack.templateMaxShift * 2 + 1;
     }
 
     vector<vector<int> > localBestShifts;
     if (wantShifts) {
         localBestShifts = 
-            vector<vector<int> >(width, vector<int>(processingNotes, 0));
+            vector<vector<int> >(width, vector<int>(pack.templateNoteCount, 0));
     }
 
     vector<bool> present(width, false);
 
 #pragma omp parallel for
     for (int i = 0; i < width; ++i) {
 
         double sum = 0.0;
-        for (int j = 0; j < processingHeight; ++j) {
+        for (int j = 0; j < pack.templateHeight; ++j) {
             sum += filtered.at(i).at(j);
         }
         if (sum < 1e-5) continue;
 
         present[i] = true;

         }
 
         const float *pitchDist = em.getPitchDistribution();
         const float *const *shiftDist = em.getShifts();
 
-        for (int j = 0; j < processingNotes; ++j) {
+        for (int j = 0; j < pack.templateNoteCount; ++j) {
 
             localPitches[i][j] = pitchDist[j] * sum;
 
             int bestShift = 0;
             int bestShiftValue = 0.0;

         
     for (int i = 0; i < width; ++i) {
 
         if (!present[i]) {
             // silent column
-            for (int j = 0; j < processingNotes; ++j) {
+            for (int j = 0; j < pack.templateNoteCount; ++j) {
                 m_postFilter[j]->push(0.0);
             }
             m_pianoRoll.push_back(map<int, double>());
             if (wantShifts) {
                 m_pianoRollShifts.push_back(map<int, int>());

     // isn't quite accurate. But the small constant offset is
     // practically irrelevant compared to the jitter from the frame
     // size we reduce to in a moment
     int latentColumns = m_cq->getLatency() / m_cq->getColumnHop();
 
+    const InstrumentPack &pack = m_instruments[m_instrument];
+
     for (int i = 0; i < width; ++i) {
 
         if (m_columnCount < latentColumns) {
             ++m_columnCount;
             continue;

 
         bool select = (sampleNo / spacing != prevSampleNo / spacing);
 
         if (select) {
             vector<double> inCol = in[i];
-            vector<double> outCol(processingHeight);
+            vector<double> outCol(pack.templateHeight);
 
             // we reverse the column as we go (the CQ output is
             // "upside-down", with high frequencies at the start of
             // each column, and we want it the other way around) and
             // then ignore the first 55 (lowest-frequency) bins,
             // giving us 545 bins instead of 600
 
-            for (int j = 0; j < processingHeight; ++j) {
+            for (int j = 0; j < pack.templateHeight; ++j) {
                 int ix = inCol.size() - j - 55;
                 outCol[j] = inCol[ix];
             }
 
             vector<double> noiseLevel1 = 
                 MedianFilter<double>::filter(40, outCol);
-            for (int j = 0; j < processingHeight; ++j) {
+            for (int j = 0; j < pack.templateHeight; ++j) {
                 noiseLevel1[j] = std::min(outCol[j], noiseLevel1[j]);
             }
 
             vector<double> noiseLevel2 = 
                 MedianFilter<double>::filter(40, noiseLevel1);
-            for (int j = 0; j < processingHeight; ++j) {
+            for (int j = 0; j < pack.templateHeight; ++j) {
                 outCol[j] = std::max(outCol[j] - noiseLevel2[j], 0.0);
             }
 
             out.push_back(outCol);
         }

 void
 Silvet::postProcess(const vector<double> &pitches,
                     const vector<int> &bestShifts,
                     bool wantShifts)
 {
+    const InstrumentPack &pack = m_instruments[m_instrument];
+
     vector<double> filtered;
 
-    for (int j = 0; j < processingNotes; ++j) {
+    for (int j = 0; j < pack.templateNoteCount; ++j) {
         m_postFilter[j]->push(pitches[j]);
         filtered.push_back(m_postFilter[j]->get());
     }
 
     // Threshold for level and reduce number of candidate pitches

 
     typedef std::multimap<double, int> ValueIndexMap;
 
     ValueIndexMap strengths;
 
-    for (int j = 0; j < processingNotes; ++j) {
+    for (int j = 0; j < pack.templateNoteCount; ++j) {
         double strength = filtered[j];
         if (strength < threshold) continue;
         strengths.insert(ValueIndexMap::value_type(strength, j));
     }