comparison dsp/rateconversion/Resampler.cpp @ 139:7fe0da91e9c3

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

     initialise();
 }
 
 Resampler::~Resampler()
 {
-    delete[] m_buffer;
     delete[] m_phaseData;
 }
 
 void
 Resampler::initialise()

     int inputSpacing = m_targetRate / m_gcd;
     int outputSpacing = m_sourceRate / m_gcd;
 
     m_latency = int((m_filterLength / 2) / outputSpacing);
 
-    m_bufferLength = 0;
+    int bufferLength = 0;
 
     m_phaseData = new Phase[inputSpacing];
 
     for (int phase = 0; phase < inputSpacing; ++phase) {
 

 	p.take = int((outputSpacing +
 		      ((m_filterLength - 1 - phase) % inputSpacing))
 		     / 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) {
 	    p.filter.push_back(filter[i * inputSpacing + phase]);
 	}

     // until the filter fills, then half the filter length at once) or
     // else have a lengthy declared latency on the output. We do the
     // 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();
     int n = pd.filter.size();
     double v = 0.0;
     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;
 }
 
 std::vector<double>