Mercurial > hg > constant-q-cpp

changeset 36:cb072f01435b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Get remaining blocks from end of processing; fix some compile warnings, etc
author Chris Cannam <c.cannam@qmul.ac.uk>
date Wed, 06 Nov 2013 16:21:28 +0000
parents 75d528478feb
children 7f0133234f00
files cpp-qm-dsp/CQKernel.cpp cpp-qm-dsp/ConstantQ.cpp cpp-qm-dsp/ConstantQ.h vamp/CQVamp.cpp vamp/CQVamp.h
diffstat 5 files changed, 64 insertions(+), 27 deletions(-) [+]
line wrap: on
line diff
--- a/cpp-qm-dsp/CQKernel.cpp	Wed Nov 06 14:30:42 2013 +0000
+++ b/cpp-qm-dsp/CQKernel.cpp	Wed Nov 06 16:21:28 2013 +0000
@@ -135,8 +135,8 @@
     // print density as diagnostic
 
     int nnz = 0;
-    for (int i = 0; i < m_kernel.data.size(); ++i) {
-        for (int j = 0; j < m_kernel.data[i].size(); ++j) {
+    for (int i = 0; i < (int)m_kernel.data.size(); ++i) {
+        for (int j = 0; j < (int)m_kernel.data[i].size(); ++j) {
             if (m_kernel.data[i][j] != C(0, 0)) {
                 ++nnz;
             }
@@ -145,8 +145,8 @@
 
     cerr << "size = " << m_kernel.data.size() << "*" << m_kernel.data[0].size() << " (fft size = " << m_p.fftSize << ")" << endl;
 
-    assert(m_kernel.data.size() == m_p.binsPerOctave * m_p.atomsPerFrame);
-    assert(m_kernel.data[0].size() == m_p.fftSize);
+    assert((int)m_kernel.data.size() == m_p.binsPerOctave * m_p.atomsPerFrame);
+    assert((int)m_kernel.data[0].size() == m_p.fftSize);
 
     cerr << "density = " << double(nnz) / double(m_p.binsPerOctave * m_p.atomsPerFrame * m_p.fftSize) << " (" << nnz << " of " << m_p.binsPerOctave * m_p.atomsPerFrame * m_p.fftSize << ")" << endl;
 
@@ -173,7 +173,7 @@
 
     vector<vector<C> > subset(m_kernel.data.size());
     for (int j = wx1; j <= wx2; ++j) {
-        for (int i = 0; i < m_kernel.data.size(); ++i) {
+        for (int i = 0; i < (int)m_kernel.data.size(); ++i) {
             subset[i].push_back(m_kernel.data[i][j]);
         }
     }
@@ -183,7 +183,7 @@
     vector<vector<C> > square(ncols); // conjugate transpose of subset * subset
 
     for (int i = 0; i < nrows; ++i) {
-        assert(subset[i].size() == ncols);
+        assert((int)subset[i].size() == ncols);
     }
 
     for (int j = 0; j < ncols; ++j) {
@@ -214,13 +214,13 @@
 
     KernelMatrix sk;
 
-    for (int i = 0; i < m_kernel.data.size(); ++i) {
+    for (int i = 0; i < (int)m_kernel.data.size(); ++i) {
 
         sk.origin.push_back(0);
         sk.data.push_back(vector<C>());
 
         int lastNZ = 0;
-        for (int j = m_kernel.data[i].size()-1; j >= 0; --j) {
+        for (int j = (int)m_kernel.data[i].size()-1; j >= 0; --j) {
             if (abs(m_kernel.data[i][j]) != 0.0) {
                 lastNZ = j;
                 break;
@@ -246,13 +246,12 @@
     // matrix multiply m_kernel.data by in, converting in to complex
     // as we go
 
-    int ncols = m_p.fftSize;
     int nrows = m_p.binsPerOctave * m_p.atomsPerFrame;
 
     vector<C> rv(nrows, C(0, 0));
 
     for (int i = 0; i < nrows; ++i) {
-        for (int j = 0; j < m_kernel.data[i].size(); ++j) {
+        for (int j = 0; j < (int)m_kernel.data[i].size(); ++j) {
             rv[i] += cv[j + m_kernel.origin[i]] * m_kernel.data[i][j];
         }
     }
--- a/cpp-qm-dsp/ConstantQ.cpp	Wed Nov 06 14:30:42 2013 +0000
+++ b/cpp-qm-dsp/ConstantQ.cpp	Wed Nov 06 16:21:28 2013 +0000
@@ -39,7 +39,7 @@
 ConstantQ::~ConstantQ()
 {
     delete m_fft;
-    for (int i = 0; i < m_decimators.size(); ++i) {
+    for (int i = 0; i < (int)m_decimators.size(); ++i) {
 	delete m_decimators[i];
     }
     delete m_kernel;
@@ -79,10 +79,21 @@
     int maxLatency = *std::max_element(latencies.begin(), latencies.end());
     m_totalLatency = MathUtilities::nextPowerOfTwo(maxLatency);
     cerr << "total latency = " << m_totalLatency << endl;
-    for (int i = 0; i < latencies.size(); ++i) {
-	m_extraLatencies.push_back(m_totalLatency - latencies[i]);
-	cerr << "extra latency " << i << " = " << m_extraLatencies[i] << endl;
-	m_buffers.push_back(vector<double>(m_extraLatencies[i], 0.0));
+
+    for (int i = 0; i < m_octaves; ++i) {
+
+	int extraLatency = m_totalLatency - latencies[i];
+
+	int pad = 0;
+ //!!! quite wrong
+	for (int j = 0; j < i; ++j) {
+	    pad += m_p.fftSize/2;
+	}
+	cerr << "for octave " << i << ", pad = " << pad << endl;
+	pad = 0;
+
+	m_buffers.push_back
+	    (vector<double>(extraLatency + pad, 0.0));
     }
 
     m_fft = new FFTReal(m_p.fftSize);
@@ -92,7 +103,7 @@
 }
 
 vector<vector<double> > 
-ConstantQ::process(vector<double> td)
+ConstantQ::process(const vector<double> &td)
 {
     m_buffers[0].insert(m_buffers[0].end(), td.begin(), td.end());
 
@@ -105,7 +116,7 @@
 
     //!!!! need some mechanism for handling remaining samples at the end
 
-    while (m_buffers[0].size() >= m_bigBlockSize) {
+    while ((int)m_buffers[0].size() >= m_bigBlockSize) {
 
 	int base = out.size();
 	int totalColumns = pow(2, m_octaves - 1) * m_p.atomsPerFrame;
@@ -139,6 +150,14 @@
 }
 
 vector<vector<double> >
+ConstantQ::getRemainingBlocks()
+{
+    int n = m_bigBlockSize + m_bigBlockSize - m_buffers[0].size();
+    vector<double> pad(n, 0.0);
+    return process(pad);
+}
+
+vector<vector<double> >
 ConstantQ::processOctaveBlock(int octave)
 {
     vector<double> ro(m_p.fftSize, 0.0);
--- a/cpp-qm-dsp/ConstantQ.h	Wed Nov 06 14:30:42 2013 +0000
+++ b/cpp-qm-dsp/ConstantQ.h	Wed Nov 06 16:21:28 2013 +0000
@@ -26,7 +26,8 @@
     int getTotalBins() const { return m_octaves * m_binsPerOctave; }
     int getColumnHop() const { return m_p.fftHop / m_p.atomsPerFrame; }
 
-    std::vector<std::vector<double> > process(std::vector<double>);
+    std::vector<std::vector<double> > process(const std::vector<double> &);
+    std::vector<std::vector<double> > getRemainingBlocks();
 
 private:
     double m_sampleRate;
@@ -43,7 +44,6 @@
     std::vector<std::vector<double> > m_buffers;
 
     int m_totalLatency;
-    std::vector<int> m_extraLatencies; // per resampler, to make up to total
 
     FFTReal *m_fft;
 
--- a/vamp/CQVamp.cpp	Wed Nov 06 14:30:42 2013 +0000
+++ b/vamp/CQVamp.cpp	Wed Nov 06 16:21:28 2013 +0000
@@ -159,6 +159,7 @@
 	m_cq = new ConstantQ
 	    (m_inputSampleRate, m_minFrequency, m_maxFrequency, m_bpo);
     }
+    m_prevFeature.clear();
 }
 
 size_t
@@ -209,15 +210,36 @@
     for (int i = 0; i < m_blockSize; ++i) data.push_back(inputBuffers[0][i]);
     
     vector<vector<double> > cqout = m_cq->process(data);
+    return convertToFeatures(cqout);
+}
 
+CQVamp::FeatureSet
+CQVamp::getRemainingFeatures()
+{
+    vector<vector<double> > cqout = m_cq->getRemainingBlocks();
+    return convertToFeatures(cqout);
+}
+
+CQVamp::FeatureSet
+CQVamp::convertToFeatures(const vector<vector<double> > &cqout)
+{
+    
     FeatureSet returnFeatures;
 
-    for (int i = 0; i < cqout.size(); ++i) {
+    for (int i = 0; i < (int)cqout.size(); ++i) {
 
 	vector<float> column(m_cq->getTotalBins(), 0.f);
-	for (int j = 0; j < cqout[i].size(); ++j) {
+
+	for (int j = 0; j < (int)cqout[i].size(); ++j) {
 	    column[j] = cqout[i][j];
 	}
+	for (int j = cqout[i].size(); j < m_cq->getTotalBins(); ++j) {
+	    if (j < (int)m_prevFeature.size()) {
+		column[j] = m_prevFeature[j];
+	    }
+	}
+
+	m_prevFeature = column;
 
 	Feature feature;
 	feature.hasTimestamp = false;
@@ -229,9 +251,3 @@
     return returnFeatures;
 }
 
-CQVamp::FeatureSet
-CQVamp::getRemainingFeatures()
-{
-    return FeatureSet();
-}
-
--- a/vamp/CQVamp.h	Wed Nov 06 14:30:42 2013 +0000
+++ b/vamp/CQVamp.h	Wed Nov 06 16:21:28 2013 +0000
@@ -46,6 +46,9 @@
     int m_bpo;
     int m_stepSize;
     int m_blockSize;
+
+    std::vector<float> m_prevFeature;
+    FeatureSet convertToFeatures(const std::vector<std::vector<double> > &);
 };