comparison dsp/rateconversion/Resampler.cpp @ 505:930b5b0f707d

Merge branch 'codestyle-and-tidy'

 #include "Resampler.h"
 
 #include "maths/MathUtilities.h"
 #include "base/KaiserWindow.h"
 #include "base/SincWindow.h"
+#include "base/Restrict.h"
 
 #include <iostream>
 #include <vector>
 #include <map>
 #include <cassert>

         // antialiasing filter, should be slightly below nyquist
         m_peakToPole = m_peakToPole / (1.0 - bandwidth/2.0);
     }
 
     KaiserWindow::Parameters params =
-	KaiserWindow::parametersForBandwidth(snr, bandwidth, higher / m_gcd);
+        KaiserWindow::parametersForBandwidth(snr, bandwidth, higher / m_gcd);
 
     params.length =
-	(params.length % 2 == 0 ? params.length + 1 : params.length);
+        (params.length % 2 == 0 ? params.length + 1 : params.length);
     
     params.length =
         (params.length > 200001 ? 200001 : params.length);
 
     m_filterLength = params.length;

 
     m_phaseData = new Phase[inputSpacing];
 
     for (int phase = 0; phase < inputSpacing; ++phase) {
 
-	Phase p;
-
-	p.nextPhase = phase - outputSpacing;
-	while (p.nextPhase < 0) p.nextPhase += inputSpacing;
-	p.nextPhase %= inputSpacing;
-	
-	p.drop = int(ceil(std::max(0.0, double(outputSpacing - phase))
-			  / inputSpacing));
-
-	int filtZipLength = int(ceil(double(m_filterLength - phase)
-				     / inputSpacing));
-
-	for (int i = 0; i < filtZipLength; ++i) {
-	    p.filter.push_back(filter[i * inputSpacing + phase]);
-	}
-
-	m_phaseData[phase] = p;
+        Phase p;
+
+        p.nextPhase = phase - outputSpacing;
+        while (p.nextPhase < 0) p.nextPhase += inputSpacing;
+        p.nextPhase %= inputSpacing;
+        
+        p.drop = int(ceil(std::max(0.0, double(outputSpacing - phase))
+                          / inputSpacing));
+
+        int filtZipLength = int(ceil(double(m_filterLength - phase)
+                                     / inputSpacing));
+
+        for (int i = 0; i < filtZipLength; ++i) {
+            p.filter.push_back(filter[i * inputSpacing + phase]);
+        }
+
+        m_phaseData[phase] = p;
     }
 
 #ifdef DEBUG_RESAMPLER
     int cp = 0;
     int totDrop = 0;

     m_buffer = vector<double>(fill, 0);
     m_bufferOrigin = 0;
 
 #ifdef DEBUG_RESAMPLER
     cerr << "initial phase " << m_phase << " (as " << (m_filterLength/2) << " % " << inputSpacing << ")"
-	      << ", latency " << m_latency << endl;
+              << ", latency " << m_latency << endl;
 #endif
 }
 
 double
 Resampler::reconstructOne()

         cerr << "ERROR: n + m_bufferOrigin > m_buffer.size() [" << n << " + "
              << m_bufferOrigin << " > " << m_buffer.size() << "]" << endl;
         throw std::logic_error("n + m_bufferOrigin > m_buffer.size()");
     }
 
-#if defined(__MSVC__)
-#define R__ __restrict
-#elif defined(__GNUC__)
-#define R__ __restrict__
-#else
-#define R__
-#endif
-
-    const double *const R__ buf(m_buffer.data() + m_bufferOrigin);
-    const double *const R__ filt(pd.filter.data());
+    const double *const QM_R__ buf(m_buffer.data() + m_bufferOrigin);
+    const double *const QM_R__ filt(pd.filter.data());
 
     for (int i = 0; i < n; ++i) {
-	// NB gcc can only vectorize this with -ffast-math
-	v += buf[i] * filt[i];
+        // NB gcc can only vectorize this with -ffast-math
+        v += buf[i] * filt[i];
     }
 
     m_bufferOrigin += pd.drop;
     m_phase = pd.nextPhase;
     return v;

 #endif
 
     double scaleFactor = (double(m_targetRate) / m_gcd) / m_peakToPole;
 
     while (outidx < maxout &&
-	   m_buffer.size() >= m_phaseData[m_phase].filter.size() + m_bufferOrigin) {
-	dst[outidx] = scaleFactor * reconstructOne();
-	outidx++;
+           m_buffer.size() >= m_phaseData[m_phase].filter.size() + m_bufferOrigin) {
+        dst[outidx] = scaleFactor * reconstructOne();
+        outidx++;
     }
 
     if (m_bufferOrigin > (int)m_buffer.size()) {
         cerr << "ERROR: m_bufferOrigin > m_buffer.size() [" 
              << m_bufferOrigin << " > " << m_buffer.size() << "]" << endl;

 #endif
 #ifdef DEBUG_RESAMPLER_VERBOSE
     int printN = 50;
     cerr << "first " << printN << " in:" << endl;
     for (int i = 0; i < printN && i < n; ++i) {
-	if (i % 5 == 0) cerr << endl << i << "... ";
+        if (i % 5 == 0) cerr << endl << i << "... ";
         cerr << data[i] << " ";
     }
     cerr << endl;
 #endif
 
     int toReturn = got - latency;
     if (toReturn > m) toReturn = m;
 
     vector<double> sliced(out.begin() + latency, 
-			  out.begin() + latency + toReturn);
+                          out.begin() + latency + toReturn);
 
 #ifdef DEBUG_RESAMPLER_VERBOSE
     cerr << "first " << printN << " out (after latency compensation), length " << sliced.size() << ":";
     for (int i = 0; i < printN && i < sliced.size(); ++i) {
-	if (i % 5 == 0) cerr << endl << i << "... ";
-	cerr << sliced[i] << " ";
+        if (i % 5 == 0) cerr << endl << i << "... ";
+        cerr << sliced[i] << " ";
     }
     cerr << endl;
 #endif
 
     return sliced;