comparison audioio/IntegerTimeStretcher.cpp @ 13:00ed645f4175

* various fixes in the time stretcher

 
     m_time = (fftwf_complex *)fftwf_malloc(sizeof(fftwf_complex) * m_wlen);
     m_freq = (fftwf_complex *)fftwf_malloc(sizeof(fftwf_complex) * m_wlen);
     m_dbuf = (float *)fftwf_malloc(sizeof(float) * m_wlen);
     m_mashbuf = (float *)fftwf_malloc(sizeof(float) * m_wlen);
+    m_modulationbuf = (float *)fftwf_malloc(sizeof(float) * m_wlen);
     m_prevPhase = (float *)fftwf_malloc(sizeof(float) * m_wlen);
     m_prevAdjustedPhase = (float *)fftwf_malloc(sizeof(float) * m_wlen);
 
     m_plan = fftwf_plan_dft_1d(m_wlen, m_time, m_freq, FFTW_FORWARD, FFTW_ESTIMATE);
     m_iplan = fftwf_plan_dft_c2r_1d(m_wlen, m_freq, m_dbuf, FFTW_ESTIMATE);
 
     for (int i = 0; i < m_wlen; ++i) {
 	m_mashbuf[i] = 0.0;
+	m_modulationbuf[i] = 0.0;
         m_prevPhase[i] = 0.0;
         m_prevAdjustedPhase[i] = 0.0;
     }
 }
 

 
     fftwf_free(m_time);
     fftwf_free(m_freq);
     fftwf_free(m_dbuf);
     fftwf_free(m_mashbuf);
+    fftwf_free(m_modulationbuf);
     fftwf_free(m_prevPhase);
     fftwf_free(m_prevAdjustedPhase);
 
     delete m_window;
 }	

 	    // pointer.
 
 	    size_t got = m_inbuf.peek(m_dbuf, m_wlen);
 	    assert(got == m_wlen);
 		
-	    processBlock(m_dbuf, m_mashbuf);
+	    processBlock(m_dbuf, m_mashbuf, m_modulationbuf);
 
 #ifdef DEBUG_INTEGER_TIME_STRETCHER
 	    std::cerr << "writing first " << m_n2 << " from mashbuf, skipping " << m_n1 << " on inbuf " << std::endl;
 #endif
 	    m_inbuf.skip(m_n1);
+
+            for (size_t i = 0; i < m_n2; ++i) {
+                if (m_modulationbuf[i] > 0.f) {
+                    m_mashbuf[i] /= m_modulationbuf[i];
+                }
+            }
+
 	    m_outbuf.write(m_mashbuf, m_n2);
 
 	    for (size_t i = 0; i < m_wlen - m_n2; ++i) {
 		m_mashbuf[i] = m_mashbuf[i + m_n2];
+                m_modulationbuf[i] = m_modulationbuf[i + m_n2];
 	    }
+
 	    for (size_t i = m_wlen - m_n2; i < m_wlen; ++i) {
 		m_mashbuf[i] = 0.0f;
+                m_modulationbuf[i] = 0.0f;
 	    }
 	}
 
 //	std::cerr << "WARNING: IntegerTimeStretcher::process: writespace not enough for output increment (" << m_outbuf.getWriteSpace() << " < " << m_n2 << ")" << std::endl;
 //	}

     std::cerr << "IntegerTimeStretcher::process returning" << std::endl;
 #endif
 }
 
 void
-IntegerTimeStretcher::processBlock(float *buf, float *out)
+IntegerTimeStretcher::processBlock(float *buf, float *out, float *modulation)
 {
     size_t i;
 
     // buf contains m_wlen samples; out contains enough space for
     // m_wlen * ratio samples (we mix into out, rather than replacing)

 	buf[i] = buf[i + m_wlen/2] / m_wlen;
 	buf[i + m_wlen/2] = temp;
     }
     
     m_window->cut(buf);
-    
+/*    
     int div = m_wlen / m_n2;
     if (div > 1) div /= 2;
     for (i = 0; i < m_wlen; ++i) {
 	buf[i] /= div;
     }
-
+*/
     for (i = 0; i < m_wlen; ++i) {
 	out[i] += buf[i];
-    }
-}
+        modulation[i] += m_window->getValue(i);
+    }
+}