changeset 139:7fe0da91e9c3

Save extra samples from one process to next (+ other fixes and debug out)

--- a/dsp/rateconversion/Resampler.cpp	Sun Oct 13 12:47:50 2013 +0100
+++ b/dsp/rateconversion/Resampler.cpp	Mon Oct 14 08:15:51 2013 +0100
@@ -20,7 +20,6 @@
 
 Resampler::~Resampler()
 {
-    delete[] m_buffer;
     delete[] m_phaseData;
 }
 
@@ -55,7 +54,7 @@
 
     m_latency = int((m_filterLength / 2) / outputSpacing);
 
-    m_bufferLength = 0;
+    int bufferLength = 0;
 
     m_phaseData = new Phase[inputSpacing];
 
@@ -73,8 +72,8 @@
 		     / outputSpacing);
 
 	int filtZipLength = int(ceil((m_filterLength - phase) / inputSpacing));
-	if (filtZipLength > m_bufferLength) {
-	    m_bufferLength = filtZipLength;
+	if (filtZipLength > bufferLength) {
+	    bufferLength = filtZipLength;
 	}
 	
 	for (int i = 0; i < filtZipLength; ++i) {
@@ -104,12 +103,11 @@
     // latter. (What do other implementations do?)
 
     m_phase = m_filterLength % inputSpacing;
-    m_buffer = new double[m_bufferLength];
-    for (int i = 0; i < m_bufferLength; ++i) m_buffer[i] = 0.0;
+    m_buffer = vector<double>(bufferLength, 0);
 }
 
 double
-Resampler::reconstructOne(const double **srcptr)
+Resampler::reconstructOne(const double *src)
 {
     Phase &pd = m_phaseData[m_phase];
     double *filt = pd.filter.data();
@@ -118,32 +116,37 @@
     for (int i = 0; i < n; ++i) {
 	v += m_buffer[i] * filt[i];
     }
-    for (int i = pd.drop; i < n; ++i) {
-	m_buffer[i - pd.drop] = m_buffer[i];
+    m_buffer = vector<double>(m_buffer.begin() + pd.drop, m_buffer.end());
+    for (int i = 0; i < pd.take; ++i) {
+	m_buffer.push_back(src[i]);
     }
-    for (int i = 0; i < pd.take; ++i) {
-	m_buffer[n - pd.drop + i] = **srcptr;
-	++ *srcptr;
-    }
-    m_phase = pd.nextPhase;
     return v;
 }
 
 int
-Resampler::process(const double *src, double *dst, int n)
+Resampler::process(const double *src, double *dst, int remaining)
 {
     int m = 0;
-    const double *srcptr = src;
+    int offset = 0;
 
-    while (n > m_phaseData[m_phase].take) {
-	std::cerr << "n = " << n << ", m = " << m << ", take = " << m_phaseData[m_phase].take << std::endl;
-	n -= m_phaseData[m_phase].take;
-	dst[m] = reconstructOne(&srcptr);
-	std::cerr << "n -> " << n << std::endl;
+    while (remaining >= m_phaseData[m_phase].take) {
+	std::cerr << "remaining = " << remaining << ", m = " << m << ", take = " << m_phaseData[m_phase].take << std::endl;
+	int advance = m_phaseData[m_phase].take;
+	dst[m] = reconstructOne(src + offset);
+	offset += advance;
+	remaining -= advance;
+	m_phase = m_phaseData[m_phase].nextPhase;
+	std::cerr << "remaining -> " << remaining << ", new phase has advance " << m_phaseData[m_phase].take << std::endl;
 	++m;
     }
 
-    //!!! save any excess 
+    if (remaining > 0) {
+	std::cerr << "have " << remaining << " spare, pushing to buffer" << std::endl;
+    }	
+
+    for (int i = 0; i < remaining; ++i) {
+	m_buffer.push_back(src[offset + i]);
+    }
 
     return m;
 }

--- a/dsp/rateconversion/Resampler.h	Sun Oct 13 12:47:50 2013 +0100
+++ b/dsp/rateconversion/Resampler.h	Mon Oct 14 08:15:51 2013 +0100
@@ -55,10 +55,10 @@
 
     Phase *m_phaseData;
     int m_phase;
-    double *m_buffer;
+    std::vector<double> m_buffer;
 
     void initialise();
-    double reconstructOne(const double **);
+    double reconstructOne(const double *);
 };
 
 #endif

--- a/dsp/rateconversion/TestResampler.cpp	Sun Oct 13 12:47:50 2013 +0100
+++ b/dsp/rateconversion/TestResampler.cpp	Mon Oct 14 08:15:51 2013 +0100
@@ -41,7 +41,7 @@
 	      int m,
 	      double *expected)
 {
-//!!! to be useful, this should provide the input in varying-size chunks
+    // Here we provide the input in chunks (of varying size)
 
     Resampler r(sourceRate, targetRate);
     int latency = r.getLatency();
@@ -62,19 +62,34 @@
 	outPadded[i] = -999.0;
     }
 
-    int got = r.process(inPadded, outPadded, n1);
+    int chunkSize = 1;
+    int got = 0;
+    int i = 0;
 
-    std::cerr << n1 << " in, " << got << " out" << std::endl;
+    while (true) {
+	std::cerr << "i = " << i << ", n1 = " << n1 << ", chunkSize = " << chunkSize << std::endl;
+	got += r.process(inPadded + i, outPadded + got, chunkSize);
+	i = i + chunkSize;
+	chunkSize = chunkSize + 1;
+	if (i + 1 >= n1) {
+	    break;
+	} else if (i + chunkSize >= n1) {
+	    chunkSize = n1 - i;
+	}
+    }
+
+//    int got = r.process(inPadded, outPadded, n1);
+    std::cerr << i << " in, " << got << " out" << std::endl;
 
     BOOST_CHECK_EQUAL(got, m1);
-
+/*
     std::cerr << "results including latency padding:" << std::endl;
     for (int i = 0; i < m1; ++i) {
 	std::cerr << outPadded[i] << " ";
 	if (i % 6 == 5) std::cerr << "\n";
     }
     std::cerr << "\n";
-
+*/
     for (int i = latency; i < m1; ++i) {
 	BOOST_CHECK_SMALL(outPadded[i] - expected[i-latency], 1e-8);
     }