comparison src/Silvet.cpp @ 246:70773820e719 norm eval-norm-u4

Use flattendynamics code within Silvet

 
 #include <cq/CQSpectrogram.h>
 
 #include "MedianFilter.h"
 #include "constant-q-cpp/src/dsp/Resampler.h"
+#include "flattendynamics-ladspa.h"
 
 #include <vector>
 
 #include <cstdio>
 

 
 Silvet::Silvet(float inputSampleRate) :
     Plugin(inputSampleRate),
     m_instruments(InstrumentPack::listInstrumentPacks()),
     m_resampler(0),
+    m_flattener(0),
     m_cq(0),
     m_hqMode(true),
     m_fineTuning(false),
     m_instrument(0),
     m_colsPerSec(50)

 }
 
 Silvet::~Silvet()
 {
     delete m_resampler;
+    delete m_flattener;
     delete m_cq;
     for (int i = 0; i < (int)m_postFilter.size(); ++i) {
         delete m_postFilter[i];
     }
 }

     d.binNames.push_back("Frequency");
     d.binNames.push_back("Velocity");
     d.hasKnownExtents = false;
     d.isQuantized = false;
     d.sampleType = OutputDescriptor::VariableSampleRate;
-    d.sampleRate = m_inputSampleRate / (m_cq ? m_cq->getColumnHop() : 62);
+    d.sampleRate = processingSampleRate / (m_cq ? m_cq->getColumnHop() : 62);
     d.hasDuration = true;
     m_notesOutputNo = list.size();
     list.push_back(d);
 
     d.identifier = "timefreq";

 
 void
 Silvet::reset()
 {
     delete m_resampler;
+    delete m_flattener;
     delete m_cq;
 
     if (m_inputSampleRate != processingSampleRate) {
 	m_resampler = new Resampler(m_inputSampleRate, processingSampleRate);
     } else {
 	m_resampler = 0;
     }
+
+    m_flattener = new FlattenDynamics(m_inputSampleRate); // before resampling
+    m_flattener->reset();
 
     double minFreq = 27.5;
 
     if (!m_hqMode) {
         // We don't actually return any notes from the bottom octave,

     m_postFilter.clear();
     for (int i = 0; i < m_instruments[0].templateNoteCount; ++i) {
         m_postFilter.push_back(new MedianFilter<double>(3));
     }
     m_pianoRoll.clear();
+    m_inputGains.clear();
     m_columnCount = 0;
     m_startTime = RealTime::zeroTime;
 }
 
 Silvet::FeatureSet
 Silvet::process(const float *const *inputBuffers, Vamp::RealTime timestamp)
 {
     if (m_columnCount == 0) {
         m_startTime = timestamp;
     }
+
+    vector<float> flattened(m_blockSize);
+    float gain = 1.f;
+    m_flattener->connectInputPort
+        (FlattenDynamics::AudioInputPort, inputBuffers[0]);
+    m_flattener->connectOutputPort
+        (FlattenDynamics::AudioOutputPort, &flattened[0]);
+    m_flattener->connectOutputPort
+        (FlattenDynamics::GainOutputPort, &gain);
+    m_flattener->process(m_blockSize);
+
+    m_inputGains.push_back(gain);
     
     vector<double> data;
     for (int i = 0; i < m_blockSize; ++i) {
-        double d = inputBuffers[0][i];
+        double d = flattened[i];
         data.push_back(d);
     }
 
     if (m_resampler) {
 	data = m_resampler->process(data.data(), data.size());
     }
-
+ 
     Grid cqout = m_cq->process(data);
     FeatureSet fs = transcribe(cqout);
     return fs;
 }
 

                 partShift = shift;
                 partVelocity = 0;
             }
         }
 
-        int v = strength * 2;
+        //!!! todo: do something with input gain. Presumably we need
+        //!!! to index it by something close to, but not actually, i
+        //!!! (depending on cq latency)
+
+        cerr << "i = " << i << ", gain length = " << m_inputGains.size()
+             << ", cq latency = " << m_cq->getLatency() << " (as columns = "
+             << m_cq->getLatency() / m_cq->getColumnHop() << ", as input blocks = " 
+             << m_cq->getLatency() / m_blockSize << ")" << endl;
+
+        int v = round(strength * 2);
         if (v > 127) v = 127;
 
         if (v > partVelocity) {
             partVelocity = v;
         }