filter: moved dc_blocker to gr-filter with QA and GRC blocks.

13 files changed, 761 insertions, 0 deletions

diff --git a/gr-filter/grc/CMakeLists.txt b/gr-filter/grc/CMakeLists.txt
index 00171e6ff..5241680e8 100644
--- a/gr-filter/grc/CMakeLists.txt
+++ b/gr-filter/grc/CMakeLists.txt
@@ -19,6 +19,7 @@
 
 install(FILES
     filter_block_tree.xml
+    dc_blocker_xx.xml
     fft_filter_xxx.xml
     hilbert_fc.xml
     DESTINATION ${GRC_BLOCKS_DIR}
diff --git a/gr-filter/grc/dc_blocker_xx.xml b/gr-filter/grc/dc_blocker_xx.xml
new file mode 100644
index 000000000..9bce5e980
--- /dev/null
+++ b/gr-filter/grc/dc_blocker_xx.xml
@@ -0,0 +1,51 @@
+<?xml version="1.0"?>
+<!--
+###################################################
+## DC Blocker
+###################################################
+ -->
+<block>
+	<name>DC Blocker</name>
+	<key>dc_blocker_xx</key>
+	<import>from gnuradio import filter</import>
+	<make>filter.dc_blocker_$(type)($length, $long_form)</make>
+	<!-- <callback>set_length($length)</callback> -->
+	<param>
+		<name>Type</name>
+		<key>type</key>
+		<type>enum</type>
+		<option>
+			<name>Complex->Complex</name>
+			<key>cc</key>
+			<opt>input:complex</opt>
+			<opt>output:complex</opt>
+		</option>
+		<option>
+			<name>Float->Float</name>
+			<key>ff</key>
+			<opt>input:float</opt>
+			<opt>output:float</opt>
+		</option>
+	</param>
+	<param>
+		<name>Length</name>
+		<key>length</key>
+		<value>32</value>
+		<type>int</type>
+	</param>
+	<param>
+		<name>Long Form</name>
+		<key>long_form</key>
+		<value>True</value>
+		<type>bool</type>
+	</param>
+
+	<sink>
+		<name>in</name>
+		<type>$type.input</type>
+	</sink>
+	<source>
+		<name>out</name>
+		<type>$type.output</type>
+	</source>
+</block>
diff --git a/gr-filter/grc/filter_block_tree.xml b/gr-filter/grc/filter_block_tree.xml
index c0c2e96e2..709aa89aa 100644
--- a/gr-filter/grc/filter_block_tree.xml
+++ b/gr-filter/grc/filter_block_tree.xml
@@ -30,6 +30,7 @@
 	<name></name> <!-- Blank for Root Name -->
 	<cat>
 		<name>Filters</name>
+		<block>dc_blocker_xx</block>
 		<block>fft_filter_xxx</block>
 		<block>hilbert_fc</block>
 	</cat>
diff --git a/gr-filter/include/filter/CMakeLists.txt b/gr-filter/include/filter/CMakeLists.txt
index b0b2a7e91..402dd599a 100644
--- a/gr-filter/include/filter/CMakeLists.txt
+++ b/gr-filter/include/filter/CMakeLists.txt
@@ -80,7 +80,10 @@ install(FILES
     fir_filter.h
     fft_filter.h
     ${generated_includes}
+    dc_blocker_cc.h
+    dc_blocker_ff.h
     fft_filter_ccc.h
+    fft_filter_fff.h
     hilbert_fc.h
     DESTINATION ${GR_INCLUDE_DIR}/gnuradio/filter
     COMPONENT "fft_devel"
diff --git a/gr-filter/include/filter/dc_blocker_cc.h b/gr-filter/include/filter/dc_blocker_cc.h
new file mode 100644
index 000000000..64d7ebffc
--- /dev/null
+++ b/gr-filter/include/filter/dc_blocker_cc.h
@@ -0,0 +1,75 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2011,2012 Free Software Foundation, Inc.
+ *
+ * This file is part of GNU Radio
+ *
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ *
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU Radio; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef INCLUDED_FILTER_DC_BLOCKER_CC_H
+#define	INCLUDED_FILTER_DC_BLOCKER_CC_H
+
+#include <filter/api.h>
+#include <gr_sync_block.h>
+#include <deque>
+
+namespace gr {
+  namespace filter {
+    
+    class FILTER_API dc_blocker_cc : virtual public gr_sync_block
+    {
+    public:
+
+      // gr::filter::dc_blocker_cc::sptr
+      typedef boost::shared_ptr<dc_blocker_cc> sptr;
+
+      /*!
+       * \class gr_dc_blocker_cc
+       * \brief a computationally efficient controllable DC blocker
+       *
+       * \ingroup filter_blk
+       *
+       * This block implements a computationally efficient DC blocker that produces
+       * a tighter notch filter around DC for a smaller group delay than an
+       * equivalent FIR filter or using a single pole IIR filter (though the IIR
+       * filter is computationally cheaper).
+       *
+       * The block defaults to using a delay line of length 32 and the long form
+       * of the filter. Optionally, the delay line length can be changed to alter
+       * the width of the DC notch (longer lines will decrease the width).
+       *
+       * The long form of the filter produces a nearly flat response outside of
+       * the notch but at the cost of a group delay of 2D-2.
+       *
+       * The short form of the filter does not have as flat a response in the
+       * passband but has a group delay of only D-1 and is cheaper to compute.
+       *
+       * The theory behind this block can be found in the paper:
+       *
+       *    <B><EM>R. Yates, "DC Blocker Algorithms," IEEE Signal Processing Magazine,
+       *        Mar. 2008, pp 132-134.</EM></B>
+       *
+       * \param D          (int) the length of the delay line
+       * \param long_form  (bool) whether to use long (true, default) or short form
+       */
+      static FILTER_API sptr make(int D, bool long_form);
+    };
+
+  } /* namespace filter */
+} /* namespace gr */
+
+#endif /* INCLUDED_FILTER_DC_BLOCKER_CC_H */
diff --git a/gr-filter/include/filter/dc_blocker_ff.h b/gr-filter/include/filter/dc_blocker_ff.h
new file mode 100644
index 000000000..d1c7e7819
--- /dev/null
+++ b/gr-filter/include/filter/dc_blocker_ff.h
@@ -0,0 +1,75 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2011,2012 Free Software Foundation, Inc.
+ *
+ * This file is part of GNU Radio
+ *
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ *
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU Radio; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef INCLUDED_FILTER_DC_BLOCKER_FF_H
+#define	INCLUDED_FILTER_DC_BLOCKER_FF_H
+
+#include <filter/api.h>
+#include <gr_sync_block.h>
+#include <deque>
+
+namespace gr {
+  namespace filter {
+    
+    class FILTER_API dc_blocker_ff : virtual public gr_sync_block
+    {
+    public:
+
+      // gr::filter::dc_blocker_ff::sptr
+      typedef boost::shared_ptr<dc_blocker_ff> sptr;
+
+      /*!
+       * \class gr_dc_blocker_ff
+       * \brief a computationally efficient controllable DC blocker
+       *
+       * \ingroup filter_blk
+       *
+       * This block implements a computationally efficient DC blocker that produces
+       * a tighter notch filter around DC for a smaller group delay than an
+       * equivalent FIR filter or using a single pole IIR filter (though the IIR
+       * filter is computationally cheaper).
+       *
+       * The block defaults to using a delay line of length 32 and the long form
+       * of the filter. Optionally, the delay line length can be changed to alter
+       * the width of the DC notch (longer lines will decrease the width).
+       *
+       * The long form of the filter produces a nearly flat response outside of
+       * the notch but at the cost of a group delay of 2D-2.
+       *
+       * The short form of the filter does not have as flat a response in the
+       * passband but has a group delay of only D-1 and is cheaper to compute.
+       *
+       * The theory behind this block can be found in the paper:
+       *
+       *    <B><EM>R. Yates, "DC Blocker Algorithms," IEEE Signal Processing Magazine,
+       *        Mar. 2008, pp 132-134.</EM></B>
+       *
+       * \param D          (int) the length of the delay line
+       * \param long_form  (bool) whether to use long (true, default) or short form
+       */
+      static FILTER_API sptr make(int D, bool long_form=true);
+    };
+
+  } /* namespace filter */
+} /* namespace gr */
+
+#endif /* INCLUDED_FILTER_DC_BLOCKER_FF_H */
diff --git a/gr-filter/lib/CMakeLists.txt b/gr-filter/lib/CMakeLists.txt
index 6b33d547b..ab49cf7ae 100644
--- a/gr-filter/lib/CMakeLists.txt
+++ b/gr-filter/lib/CMakeLists.txt
@@ -110,6 +110,8 @@ list(APPEND filter_sources
   firdes.cc
   pm_remez.cc
   ${generated_sources}
+  dc_blocker_cc_impl.cc
+  dc_blocker_ff_impl.cc
   fft_filter_ccc_impl.cc
   fft_filter_fff_impl.cc
   hilbert_fc_impl.cc
diff --git a/gr-filter/lib/dc_blocker_cc_impl.cc b/gr-filter/lib/dc_blocker_cc_impl.cc
new file mode 100644
index 000000000..11974e5ae
--- /dev/null
+++ b/gr-filter/lib/dc_blocker_cc_impl.cc
@@ -0,0 +1,144 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2011,2012 Free Software Foundation, Inc.
+ *
+ * This file is part of GNU Radio
+ *
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ *
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU Radio; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "dc_blocker_cc_impl.h"
+#include <gr_io_signature.h>
+#include <cstdio>
+
+namespace gr {
+  namespace filter {
+    
+    moving_averager_c::moving_averager_c(int D)
+      : d_length(D), d_out(0), d_out_d1(0), d_out_d2(0)
+    {
+      d_delay_line = std::deque<gr_complex>(d_length-1, gr_complex(0,0));
+    }
+
+    moving_averager_c::~moving_averager_c()
+    {
+    }
+
+    gr_complex
+    moving_averager_c::filter(gr_complex x)
+    {
+      d_out_d1 = d_out;
+      d_delay_line.push_back(x);
+      d_out = d_delay_line[0];
+      d_delay_line.pop_front();
+      
+      gr_complex y = x - d_out_d1 + d_out_d2;
+      d_out_d2 = y;
+      
+      return (y / (float)(d_length));
+    }
+
+
+
+    dc_blocker_cc::sptr dc_blocker_cc::make(int D, bool long_form)
+    {
+      return gnuradio::get_initial_sptr(new dc_blocker_cc_impl(D, long_form));
+    }
+
+
+    dc_blocker_cc_impl::dc_blocker_cc_impl(int D, bool long_form)
+      : gr_sync_block ("dc_blocker_cc",
+		       gr_make_io_signature (1, 1, sizeof(gr_complex)),
+		       gr_make_io_signature (1, 1, sizeof(gr_complex))),
+	d_length(D), d_long_form(long_form)
+    {
+      if(d_long_form) {
+	d_ma_0 = new moving_averager_c(D);
+	d_ma_1 = new moving_averager_c(D);
+	d_ma_2 = new moving_averager_c(D);
+	d_ma_3 = new moving_averager_c(D);
+	d_delay_line = std::deque<gr_complex>(d_length-1, gr_complex(0,0));
+      }
+      else {
+	d_ma_0 = new moving_averager_c(D);
+	d_ma_1 = new moving_averager_c(D);
+      }
+    }
+
+    dc_blocker_cc_impl::~dc_blocker_cc_impl()
+    {
+      if(d_long_form) {
+	delete d_ma_0;
+	delete d_ma_1;
+	delete d_ma_2;
+	delete d_ma_3;
+      }
+      else {
+	delete d_ma_0;
+	delete d_ma_1;
+      }
+    }
+
+    int
+    dc_blocker_cc_impl::get_group_delay()
+    {
+      if(d_long_form)
+	return (2*d_length-2);
+      else
+	return d_length - 1;
+    }
+
+    int
+    dc_blocker_cc_impl::work(int noutput_items,
+			     gr_vector_const_void_star &input_items,
+			     gr_vector_void_star &output_items)
+    {
+      const gr_complex *in = (const gr_complex*)input_items[0];
+      gr_complex *out = (gr_complex*)output_items[0];
+      
+      if(d_long_form) {
+	gr_complex y1, y2, y3, y4, d;
+	for(int i = 0; i < noutput_items; i++) {
+	  y1 = d_ma_0->filter(in[i]);
+	  y2 = d_ma_1->filter(y1);
+	  y3 = d_ma_2->filter(y2);
+	  y4 = d_ma_3->filter(y3);
+	  
+	  d_delay_line.push_back(d_ma_0->delayed_sig());
+	  d = d_delay_line[0];
+	  d_delay_line.pop_front();
+	  
+	  out[i] = d - y4;
+	}
+      }
+      else {
+	gr_complex y1, y2;
+	for(int i = 0; i < noutput_items; i++) {
+	  y1 = d_ma_0->filter(in[i]);
+	  y2 = d_ma_1->filter(y1);
+	  out[i] = d_ma_0->delayed_sig() - y2;
+	}
+      }
+      
+      return noutput_items;
+    }
+
+  } /* namespace filter */
+} /* namespace gr */
diff --git a/gr-filter/lib/dc_blocker_cc_impl.h b/gr-filter/lib/dc_blocker_cc_impl.h
new file mode 100644
index 000000000..7c8d1d93d
--- /dev/null
+++ b/gr-filter/lib/dc_blocker_cc_impl.h
@@ -0,0 +1,76 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2011,2012 Free Software Foundation, Inc.
+ *
+ * This file is part of GNU Radio
+ *
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ *
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU Radio; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+
+#ifndef INCLUDED_FILTER_DC_BLOCKER_CC_IMPL_H
+#define	INCLUDED_FILTER_DC_BLOCKER_CC_IMPL_H
+
+#include <filter/dc_blocker_cc.h>
+#include <deque>
+
+namespace gr {
+  namespace filter {
+    
+    class moving_averager_c
+    {
+    public:
+      moving_averager_c(int D);
+      ~moving_averager_c();
+      
+      gr_complex filter(gr_complex x);
+      gr_complex delayed_sig() { return d_out; }
+      
+    private:
+      int d_length;
+      gr_complex d_out, d_out_d1, d_out_d2;
+      std::deque<gr_complex> d_delay_line;
+    };
+    
+    class FILTER_API dc_blocker_cc_impl : public dc_blocker_cc
+    {
+    private:
+      int d_length;
+      bool d_long_form;
+      moving_averager_c *d_ma_0;
+      moving_averager_c *d_ma_1;
+      moving_averager_c *d_ma_2;
+      moving_averager_c *d_ma_3;
+      std::deque<gr_complex> d_delay_line;
+
+    public:
+      dc_blocker_cc_impl(int D, bool long_form);
+
+      ~dc_blocker_cc_impl();
+
+      int get_group_delay();
+      
+      //int set_length(int D);
+      
+      int work(int noutput_items,
+	       gr_vector_const_void_star &input_items,
+	       gr_vector_void_star &output_items);
+    };
+
+  } /* namespace filter */
+} /* namespace gr */
+
+#endif /* INCLUDED_FILTER_DC_BLOCKER_CC_IMPL_H */
diff --git a/gr-filter/lib/dc_blocker_ff_impl.cc b/gr-filter/lib/dc_blocker_ff_impl.cc
new file mode 100644
index 000000000..86d2f2f7a
--- /dev/null
+++ b/gr-filter/lib/dc_blocker_ff_impl.cc
@@ -0,0 +1,142 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2011,2012 Free Software Foundation, Inc.
+ *
+ * This file is part of GNU Radio
+ *
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ *
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU Radio; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "dc_blocker_ff_impl.h"
+#include <gr_io_signature.h>
+#include <cstdio>
+
+namespace gr {
+  namespace filter {
+    
+    moving_averager_f::moving_averager_f(int D)
+      : d_length(D), d_out(0), d_out_d1(0), d_out_d2(0)
+    {
+      d_delay_line = std::deque<float>(d_length-1, 0);
+    }
+    
+    moving_averager_f::~moving_averager_f()
+    {
+    }
+
+    float
+    moving_averager_f::filter(float x)
+    {
+      d_out_d1 = d_out;
+      d_delay_line.push_back(x);
+      d_out = d_delay_line[0];
+      d_delay_line.pop_front();
+      
+      float y = x - d_out_d1 + d_out_d2;
+      d_out_d2 = y;
+      
+      return (y / (float)(d_length));
+    }
+    
+
+    dc_blocker_ff::sptr dc_blocker_ff::make(int D, bool long_form)
+    {
+      return gnuradio::get_initial_sptr(new dc_blocker_ff_impl(D, long_form));
+    }
+
+    dc_blocker_ff_impl::dc_blocker_ff_impl (int D, bool long_form)
+      : gr_sync_block ("dc_blocker_ff",
+		       gr_make_io_signature (1, 1, sizeof(float)),
+		       gr_make_io_signature (1, 1, sizeof(float))),
+	d_length(D), d_long_form(long_form)
+    {
+      if(d_long_form) {
+	d_ma_0 = new moving_averager_f(D);
+	d_ma_1 = new moving_averager_f(D);
+	d_ma_2 = new moving_averager_f(D);
+	d_ma_3 = new moving_averager_f(D);
+	d_delay_line = std::deque<float>(d_length-1, 0);
+      }
+      else {
+	d_ma_0 = new moving_averager_f(D);
+	d_ma_1 = new moving_averager_f(D);
+      }
+    }
+
+    dc_blocker_ff_impl::~dc_blocker_ff_impl()
+    {
+      if(d_long_form) {
+	delete d_ma_0;
+	delete d_ma_1;
+	delete d_ma_2;
+	delete d_ma_3;
+      }
+      else {
+	delete d_ma_0;
+	delete d_ma_1;
+      }
+    }
+
+    int
+    dc_blocker_ff_impl::get_group_delay()
+    {
+      if(d_long_form)
+	return (2*d_length-2);
+      else
+	return d_length - 1;
+    }
+
+    int
+    dc_blocker_ff_impl::work(int noutput_items,
+			     gr_vector_const_void_star &input_items,
+			     gr_vector_void_star &output_items)
+    {
+      const float *in = (const float*)input_items[0];
+      float *out = (float*)output_items[0];
+
+      if(d_long_form) {
+	float y1, y2, y3, y4, d;
+	for(int i = 0; i < noutput_items; i++) {
+	  y1 = d_ma_0->filter(in[i]);
+	  y2 = d_ma_1->filter(y1);
+	  y3 = d_ma_2->filter(y2);
+	  y4 = d_ma_3->filter(y3);
+
+	  d_delay_line.push_back(d_ma_0->delayed_sig());
+	  d = d_delay_line[0];
+	  d_delay_line.pop_front();
+
+	  out[i] = d - y4;
+	}
+      }
+      else {
+	float y1, y2;
+	for(int i = 0; i < noutput_items; i++) {
+	  y1 = d_ma_0->filter(in[i]);
+	  y2 = d_ma_1->filter(y1);
+	  out[i] = d_ma_0->delayed_sig() - y2;
+	}
+      }
+
+      return noutput_items;
+    }
+
+  } /* namespace filter */
+} /* namespace gr */
diff --git a/gr-filter/lib/dc_blocker_ff_impl.h b/gr-filter/lib/dc_blocker_ff_impl.h
new file mode 100644
index 000000000..868e1d433
--- /dev/null
+++ b/gr-filter/lib/dc_blocker_ff_impl.h
@@ -0,0 +1,76 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2011,2012 Free Software Foundation, Inc.
+ *
+ * This file is part of GNU Radio
+ *
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ *
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU Radio; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+
+#ifndef INCLUDED_FILTER_DC_BLOCKER_FF_IMPL_H
+#define	INCLUDED_FILTER_DC_BLOCKER_FF_IMPL_H
+
+#include <filter/dc_blocker_ff.h>
+#include <deque>
+
+namespace gr {
+  namespace filter {
+    
+    class moving_averager_f
+    {
+    public:
+      moving_averager_f(int D);
+      ~moving_averager_f();
+      
+      float filter(float x);
+      float delayed_sig() { return d_out; }
+      
+    private:
+      int d_length;
+      float d_out, d_out_d1, d_out_d2;
+      std::deque<float> d_delay_line;
+    };
+    
+    class FILTER_API dc_blocker_ff_impl : public dc_blocker_ff
+    {
+    private:
+      int d_length;
+      bool d_long_form;
+      moving_averager_f *d_ma_0;
+      moving_averager_f *d_ma_1;
+      moving_averager_f *d_ma_2;
+      moving_averager_f *d_ma_3;
+      std::deque<float>  d_delay_line;
+
+    public:
+      dc_blocker_ff_impl(int D, bool long_form);
+
+      ~dc_blocker_ff_impl();
+
+      int get_group_delay();
+      
+      //int set_length(int D);
+      
+      int work(int noutput_items,
+	       gr_vector_const_void_star &input_items,
+	       gr_vector_void_star &output_items);
+    };
+
+  } /* namespace filter */
+} /* namespace gr */
+
+#endif /* INCLUDED_FILTER_DC_BLOCKER_FF_IMPL_H */
diff --git a/gr-filter/python/qa_dc_blocker.py b/gr-filter/python/qa_dc_blocker.py
new file mode 100755
index 000000000..b9df06b45
--- /dev/null
+++ b/gr-filter/python/qa_dc_blocker.py
@@ -0,0 +1,109 @@
+#!/usr/bin/env python
+#
+# Copyright 2011,2012 Free Software Foundation, Inc.
+#
+# This file is part of GNU Radio
+#
+# GNU Radio is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3, or (at your option)
+# any later version.
+#
+# GNU Radio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with GNU Radio; see the file COPYING.  If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+#
+
+from gnuradio import gr, gr_unittest
+import filter_swig as filter
+
+class test_dc_blocker(gr_unittest.TestCase):
+
+    def setUp (self):
+        self.tb = gr.top_block ()
+
+    def tearDown (self):
+        self.tb = None
+
+    def test_001(self):
+        ''' Test impulse response - long form, cc '''
+        src_data = [1,] + 100*[0,]
+        expected_result = ((-0.02072429656982422+0j), (-0.02081298828125+0j),
+                           (0.979156494140625+0j), (-0.02081298828125+0j),
+                           (-0.02072429656982422+0j))
+
+        src = gr.vector_source_c(src_data)
+        op = filter.dc_blocker_cc(32, True)
+        dst = gr.vector_sink_c()
+
+        self.tb.connect (src, op, dst)
+        self.tb.run()
+
+        # only test samples around 2D-2
+        result_data = dst.data()[60:65]
+        self.assertComplexTuplesAlmostEqual (expected_result, result_data)
+
+    def test_002(self):
+        ''' Test impulse response - short form, cc '''
+        src_data = [1,] + 100*[0,]
+        expected_result = ((-0.029296875+0j), (-0.0302734375+0j),
+                           (0.96875+0j), (-0.0302734375+0j),
+                           (-0.029296875+0j))
+
+        src = gr.vector_source_c(src_data)
+        op = filter.dc_blocker_cc(32, False)
+        dst = gr.vector_sink_c()
+
+        self.tb.connect (src, op, dst)
+        self.tb.run()
+
+        # only test samples around D-1
+        result_data = dst.data()[29:34]
+        self.assertComplexTuplesAlmostEqual (expected_result, result_data)
+
+
+    def test_003(self):
+        ''' Test impulse response - long form, ff '''
+        src_data = [1,] + 100*[0,]
+        expected_result = ((-0.02072429656982422), (-0.02081298828125),
+                           (0.979156494140625), (-0.02081298828125),
+                           (-0.02072429656982422))
+
+        src = gr.vector_source_f(src_data)
+        op = filter.dc_blocker_ff(32, True)
+        dst = gr.vector_sink_f()
+
+        self.tb.connect (src, op, dst)
+        self.tb.run()
+
+        # only test samples around 2D-2
+        result_data = dst.data()[60:65]
+        self.assertFloatTuplesAlmostEqual (expected_result, result_data)
+
+    def test_004(self):
+        ''' Test impulse response - short form, ff '''
+        src_data = [1,] + 100*[0,]
+        expected_result = ((-0.029296875), (-0.0302734375),
+                           (0.96875), (-0.0302734375),
+                           (-0.029296875))
+
+        src = gr.vector_source_f(src_data)
+        op = filter.dc_blocker_ff(32, False)
+        dst = gr.vector_sink_f()
+
+        self.tb.connect (src, op, dst)
+        self.tb.run()
+
+        # only test samples around D-1
+        result_data = dst.data()[29:34]
+        self.assertFloatTuplesAlmostEqual (expected_result, result_data)
+
+if __name__ == '__main__':
+    gr_unittest.run(test_dc_blocker, "test_dc_blocker.xml")
+
diff --git a/gr-filter/swig/filter_swig.i b/gr-filter/swig/filter_swig.i
index 558565fc4..3eba5f4c8 100644
--- a/gr-filter/swig/filter_swig.i
+++ b/gr-filter/swig/filter_swig.i
@@ -30,6 +30,8 @@
 %{
 #include "filter/firdes.h"
 #include "filter/pm_remez.h"
+#include "filter/dc_blocker_cc.h"
+#include "filter/dc_blocker_ff.h"
 #include "filter/fir_filter_fff.h"
 #include "filter/fir_filter_ccf.h"
 #include "filter/fir_filter_ccc.h"
@@ -40,6 +42,8 @@
 
 %include "filter/firdes.h"
 %include "filter/pm_remez.h"
+%include "filter/dc_blocker_cc.h"
+%include "filter/dc_blocker_ff.h"
 %include "filter/fir_filter_fff.h"
 %include "filter/fir_filter_ccf.h"
 %include "filter/fir_filter_ccc.h"
@@ -47,6 +51,8 @@
 %include "filter/fft_filter_fff.h"
 %include "filter/hilbert_fc.h"
 
+GR_SWIG_BLOCK_MAGIC2(filter, dc_blocker_cc);
+GR_SWIG_BLOCK_MAGIC2(filter, dc_blocker_ff);
 GR_SWIG_BLOCK_MAGIC2(filter, fir_filter_fff);
 GR_SWIG_BLOCK_MAGIC2(filter, fir_filter_ccf);
 GR_SWIG_BLOCK_MAGIC2(filter, fir_filter_ccc);