filter: fixing having the delay of the resampler as a negative number, which I think I backed into from making the other computations work.

Author: trondeau

gr-filter/lib/pfb_arb_resampler.cc

@@ -69,19 +69,19 @@ namespace gr {
 
         // Delay is based on number of taps per filter arm. Round to
         // the nearest integer.
-        float delay = -rate * (taps_per_filter() - 1.0) / 2.0;
+        float delay = rate * (taps_per_filter() - 1.0) / 2.0;
         d_delay = static_cast<int>(boost::math::iround(delay));
 
         // This calculation finds the phase offset induced by the
         // arbitrary resampling. It's based on which filter arm we are
         // at the filter's group delay plus the fractional offset
         // between the samples. Calculated here based on the rotation
         // around nfilts starting at start_filter.
-        float accum = -d_delay * d_flt_rate;
+        float accum = d_delay * d_flt_rate;
         int   accum_int = static_cast<int>(accum);
         float accum_frac = accum - accum_int;
         int end_filter = static_cast<int>
-          (boost::math::iround(fmodf(d_last_filter - d_delay * d_dec_rate + accum_int, \
+          (boost::math::iround(fmodf(d_last_filter + d_delay * d_dec_rate + accum_int, \
                                      static_cast<float>(d_int_rate))));
 
         d_est_phase_change = d_last_filter - (end_filter + accum_frac);
@@ -280,19 +280,19 @@ namespace gr {
 
         // Delay is based on number of taps per filter arm. Round to
         // the nearest integer.
-        float delay = -rate * (taps_per_filter() - 1.0) / 2.0;
+        float delay = rate * (taps_per_filter() - 1.0) / 2.0;
         d_delay = static_cast<int>(boost::math::iround(delay));
 
         // This calculation finds the phase offset induced by the
         // arbitrary resampling. It's based on which filter arm we are
         // at the filter's group delay plus the fractional offset
         // between the samples. Calculated here based on the rotation
         // around nfilts starting at start_filter.
-        float accum = -d_delay * d_flt_rate;
+        float accum = d_delay * d_flt_rate;
         int   accum_int = static_cast<int>(accum);
         float accum_frac = accum - accum_int;
         int end_filter = static_cast<int>
-          (boost::math::iround(fmodf(d_last_filter - d_delay * d_dec_rate + accum_int, \
+          (boost::math::iround(fmodf(d_last_filter + d_delay * d_dec_rate + accum_int, \
                                      static_cast<float>(d_int_rate))));
 
         d_est_phase_change = d_last_filter - (end_filter + accum_frac);
@@ -491,19 +491,19 @@ namespace gr {
 
         // Delay is based on number of taps per filter arm. Round to
         // the nearest integer.
-        float delay = -rate * (taps_per_filter() - 1.0) / 2.0;
+        float delay = rate * (taps_per_filter() - 1.0) / 2.0;
         d_delay = static_cast<int>(boost::math::iround(delay));
 
         // This calculation finds the phase offset induced by the
         // arbitrary resampling. It's based on which filter arm we are
         // at the filter's group delay plus the fractional offset
         // between the samples. Calculated here based on the rotation
         // around nfilts starting at start_filter.
-        float accum = -d_delay * d_flt_rate;
+        float accum = d_delay * d_flt_rate;
         int   accum_int = static_cast<int>(accum);
         float accum_frac = accum - accum_int;
         int end_filter = static_cast<int>
-          (boost::math::iround(fmodf(d_last_filter - d_delay * d_dec_rate + accum_int, \
+          (boost::math::iround(fmodf(d_last_filter + d_delay * d_dec_rate + accum_int, \
                                      static_cast<float>(d_int_rate))));
 
         d_est_phase_change = d_last_filter - (end_filter + accum_frac);

gr-filter/python/filter/qa_pfb_arb_resampler.py

@@ -69,7 +69,7 @@ def test_fff_000(self):
         phase = pfb.phase_offset(freq, fs)
 
         # Create a timeline offset by the filter's group delay
-        t = map(lambda x: float(x)/(fs*rrate), xrange(delay, L+delay))
+        t = map(lambda x: float(x)/(fs*rrate), xrange(-delay, L-delay))
 
         # Data of the sinusoid at frequency freq with the delay and phase offset.
         expected_data = map(lambda x: math.sin(2.*math.pi*freq*x+phase), t)
@@ -105,7 +105,7 @@ def test_ccf_000(self):
         phase = pfb.phase_offset(freq, fs)
 
         # Create a timeline offset by the filter's group delay
-        t = map(lambda x: float(x)/(fs*rrate), xrange(delay, L+delay))
+        t = map(lambda x: float(x)/(fs*rrate), xrange(-delay, L-delay))
 
         # Data of the sinusoid at frequency freq with the delay and phase offset.
         expected_data = map(lambda x: math.cos(2.*math.pi*freq*x+phase) + \
@@ -142,7 +142,7 @@ def test_ccf_001(self):
         phase = pfb.phase_offset(freq, fs)
 
         # Create a timeline offset by the filter's group delay
-        t = map(lambda x: float(x)/(fs*rrate), xrange(delay, L+delay))
+        t = map(lambda x: float(x)/(fs*rrate), xrange(-delay, L-delay))
 
         # Data of the sinusoid at frequency freq with the delay and phase offset.
         expected_data = map(lambda x: math.cos(2.*math.pi*freq*x+phase) + \
@@ -179,7 +179,7 @@ def test_ccc_000(self):
         phase = pfb.phase_offset(freq, fs)
 
         # Create a timeline offset by the filter's group delay
-        t = map(lambda x: float(x)/(fs*rrate), xrange(delay, L+delay))
+        t = map(lambda x: float(x)/(fs*rrate), xrange(-delay, L-delay))
 
         # Data of the sinusoid at frequency freq with the delay and phase offset.
         expected_data = map(lambda x: math.cos(2.*math.pi*freq*x+phase) + \
@@ -216,7 +216,7 @@ def test_ccc_001(self):
         phase = pfb.phase_offset(freq, fs)
 
         # Create a timeline offset by the filter's group delay
-        t = map(lambda x: float(x)/(fs*rrate), xrange(delay, L+delay))
+        t = map(lambda x: float(x)/(fs*rrate), xrange(-delay, L-delay))
 
         # Data of the sinusoid at frequency freq with the delay and phase offset.
         expected_data = map(lambda x: math.cos(2.*math.pi*freq*x+phase) + \