Merge branch 'master' into file_meta_data

Conflicts:
	gr-utils/src/python/CMakeLists.txt

19 files changed, 419 insertions, 33 deletions

diff --git a/gr-blocks/gnuradio-blocks.pc.in b/gr-blocks/gnuradio-blocks.pc.in
index abcfe017b..c24564157 100644
--- a/gr-blocks/gnuradio-blocks.pc.in
+++ b/gr-blocks/gnuradio-blocks.pc.in
@@ -5,7 +5,7 @@ includedir=@includedir@
 
 Name: gnuradio-blocks
 Description: GNU Radio basic block library
-Requires: gnuradio-core gnuradio-audio
+Requires: gnuradio-core
 Version: @LIBVER@
 Libs: -L${libdir} -lgnuradio-blocks
 Cflags: -I${includedir}
diff --git a/gr-blocks/grc/blocks_file_source.xml b/gr-blocks/grc/blocks_file_source.xml
index 753465bb3..7ac573f2d 100644
--- a/gr-blocks/grc/blocks_file_source.xml
+++ b/gr-blocks/grc/blocks_file_source.xml
@@ -9,6 +9,7 @@
 	<key>blocks_file_source</key>
 	<import>from gnuradio import blocks</import>
 	<make>blocks.file_source($type.size*$vlen, $file, $repeat)</make>
+	<callback>open($file, $repeat)</callback>
 	<param>
 		<name>File</name>
 		<key>file</key>
diff --git a/gr-blocks/grc/blocks_patterned_interleaver.xml b/gr-blocks/grc/blocks_patterned_interleaver.xml
new file mode 100644
index 000000000..8dd0fac41
--- /dev/null
+++ b/gr-blocks/grc/blocks_patterned_interleaver.xml
@@ -0,0 +1,66 @@
+<?xml version="1.0"?>
+<!--
+###################################################
+##Vector to Stream
+###################################################
+ -->
+<block>
+	<name>Patterned Interleaver</name>
+	<key>blocks_patterned_interleaver</key>
+	<import>from gnuradio import blocks</import>
+	<make>blocks.patterned_interleaver($type.size*$vlen, $pattern)</make>
+	<param>
+		<name>IO Type</name>
+		<key>type</key>
+		<type>enum</type>
+		<option>
+			<name>Complex</name>
+			<key>complex</key>
+			<opt>size:gr.sizeof_gr_complex</opt>
+		</option>
+		<option>
+			<name>Float</name>
+			<key>float</key>
+			<opt>size:gr.sizeof_float</opt>
+		</option>
+		<option>
+			<name>Int</name>
+			<key>int</key>
+			<opt>size:gr.sizeof_int</opt>
+		</option>
+		<option>
+			<name>Short</name>
+			<key>short</key>
+			<opt>size:gr.sizeof_short</opt>
+		</option>
+		<option>
+			<name>Byte</name>
+			<key>byte</key>
+			<opt>size:gr.sizeof_char</opt>
+		</option>
+	</param>
+	<param>
+		<name>Pattern</name>
+		<key>pattern</key>
+		<value>[0,0,1,2]</value>
+		<type>int_vector</type>
+	</param>
+	<param>
+		<name>Vec Length</name>
+		<key>vlen</key>
+		<value>1</value>
+		<type>int</type>
+	</param>
+	<check>$vlen &gt;= 1</check>
+	<sink>
+		<name>in</name>
+		<type>$type</type>
+		<vlen>$vlen</vlen>
+        <nports>1+max($pattern)</nports>
+	</sink>
+	<source>
+		<name>out</name>
+		<type>$type</type>
+		<vlen>$vlen</vlen>
+	</source>
+</block>
diff --git a/gr-blocks/include/blocks/CMakeLists.txt b/gr-blocks/include/blocks/CMakeLists.txt
index ac674528f..787fddba3 100644
--- a/gr-blocks/include/blocks/CMakeLists.txt
+++ b/gr-blocks/include/blocks/CMakeLists.txt
@@ -118,6 +118,7 @@ install(FILES
     multiply_const_cc.h
     multiply_const_ff.h
     nlog10_ff.h
+    patterned_interleaver.h
     repeat.h
     short_to_char.h
     short_to_float.h
diff --git a/gr-blocks/include/blocks/file_source.h b/gr-blocks/include/blocks/file_source.h
index 6207cdf70..1a12aa905 100644
--- a/gr-blocks/include/blocks/file_source.h
+++ b/gr-blocks/include/blocks/file_source.h
@@ -40,6 +40,21 @@ namespace gr {
       // gr::blocks::file_source::sptr
       typedef boost::shared_ptr<file_source> sptr;
 
+      /*!
+       * \brief Create a file source.
+       *
+       * Opens \p filename as a source of items into a flowgraph. The
+       * data is expected to be in binary format, item after item. The
+       * \p itemsize of the block determines the conversion from bits
+       * to items.
+       *
+       * If \p repeat is turned on, the file will repeat the file after
+       * it's reached the end.
+       *
+       * \param itemsize	the size of each item in the file, in bytes
+       * \param filename	name of the file to source from
+       * \param repeat	repeat file from start
+       */
       static sptr make(size_t itemsize, const char *filename, bool repeat = false);
 
       /*!
@@ -49,6 +64,19 @@ namespace gr {
        * \param whence	one of SEEK_SET, SEEK_CUR, SEEK_END (man fseek)
        */
       virtual bool seek(long seek_point, int whence) = 0;
+
+      /*!
+       * \brief Opens a new file.
+       *
+       * \param filename	name of the file to source from
+       * \param repeat	repeat file from start
+       */
+      virtual void open(const char *filename, bool repeat) = 0;
+
+      /*!
+       * \brief Close the file handle.
+       */
+      virtual void close() = 0;
     };
 
   } /* namespace blocks */
diff --git a/gr-blocks/include/blocks/multiply_const_cc.h b/gr-blocks/include/blocks/multiply_const_cc.h
index 032a765a4..9572eaec7 100644
--- a/gr-blocks/include/blocks/multiply_const_cc.h
+++ b/gr-blocks/include/blocks/multiply_const_cc.h
@@ -46,6 +46,7 @@ namespace gr {
       /*!
        * \brief Create an instance of multiply_const_cc
        * \param k complex multiplicative constant
+       * \param vlen Vector length of incoming stream
        */
       static sptr make(gr_complex k, size_t vlen=1);
       
diff --git a/gr-blocks/include/blocks/multiply_const_ff.h b/gr-blocks/include/blocks/multiply_const_ff.h
index e755f59bf..d2d5e805c 100644
--- a/gr-blocks/include/blocks/multiply_const_ff.h
+++ b/gr-blocks/include/blocks/multiply_const_ff.h
@@ -46,6 +46,7 @@ namespace gr {
       /*!
        * \brief Create an instance of multiply_const_ff
        * \param k real multiplicative constant
+       * \param vlen Vector length of incoming stream
        */
       static sptr make(float k, size_t vlen=1);
       
diff --git a/gr-blocks/include/blocks/patterned_interleaver.h b/gr-blocks/include/blocks/patterned_interleaver.h
new file mode 100644
index 000000000..cfcdac6e7
--- /dev/null
+++ b/gr-blocks/include/blocks/patterned_interleaver.h
@@ -0,0 +1,23 @@
+#ifndef INCLUDED_BLOCKS_PATTERNED_INTERLEAVER_H
+#define INCLUDED_BLOCKS_PATTERNED_INTERLEAVER_H
+
+#include <blocks/api.h>
+#include <gr_block.h>
+
+namespace gr {
+  namespace blocks {
+
+    class BLOCKS_API patterned_interleaver : virtual public gr_block
+    {
+    public:
+      
+      typedef boost::shared_ptr<patterned_interleaver> sptr;
+
+      static sptr make(size_t itemsize, std::vector<int> pattern);
+    };
+
+  }
+}
+
+#endif
+
diff --git a/gr-blocks/include/blocks/stream_mux.h b/gr-blocks/include/blocks/stream_mux.h
index 905ea3c9f..58d564f9f 100644
--- a/gr-blocks/include/blocks/stream_mux.h
+++ b/gr-blocks/include/blocks/stream_mux.h
@@ -53,7 +53,7 @@ namespace gr {
        * \ingroup converter_blk
        *
        * \param itemsize the item size of the stream
-       * \param length   a vector (list/tuple) specifying the number of
+       * \param lengths  a vector (list/tuple) specifying the number of
        *                 items from each stream the mux together.
        *                 Warning: this requires that at least as many items
        *                 per stream are available or the system will wait
diff --git a/gr-blocks/lib/CMakeLists.txt b/gr-blocks/lib/CMakeLists.txt
index 0b6c89298..3a8ffac75 100644
--- a/gr-blocks/lib/CMakeLists.txt
+++ b/gr-blocks/lib/CMakeLists.txt
@@ -160,6 +160,7 @@ list(APPEND gr_blocks_sources
     multiply_const_cc_impl.cc
     multiply_const_ff_impl.cc
     nlog10_ff_impl.cc
+    patterned_interleaver_impl.cc
     repeat_impl.cc
     short_to_char_impl.cc
     short_to_float_impl.cc
diff --git a/gr-blocks/lib/file_source_impl.cc b/gr-blocks/lib/file_source_impl.cc
index 0d20827b7..ed1f50c43 100644
--- a/gr-blocks/lib/file_source_impl.cc
+++ b/gr-blocks/lib/file_source_impl.cc
@@ -54,39 +54,87 @@ namespace gr {
 
     file_source::sptr file_source::make(size_t itemsize, const char *filename, bool repeat)
     {
-      return gnuradio::get_initial_sptr(new file_source_impl(itemsize, filename, repeat));
+      return gnuradio::get_initial_sptr
+	(new file_source_impl(itemsize, filename, repeat));
     }
 
     file_source_impl::file_source_impl(size_t itemsize, const char *filename, bool repeat)
       : gr_sync_block("file_source",
 		      gr_make_io_signature(0, 0, 0),
 		      gr_make_io_signature(1, 1, itemsize)),
-	d_itemsize(itemsize), d_fp (0), d_repeat(repeat)
+	d_itemsize(itemsize), d_fp(0), d_new_fp(0), d_repeat(repeat),
+	d_updated(false)
     {
-      // we use "open" to use to the O_LARGEFILE flag
+      open(filename, repeat);
+    }
+
+    file_source_impl::~file_source_impl()
+    {
+      fclose ((FILE*)d_fp);
+    }
+    
+    bool
+    file_source_impl::seek(long seek_point, int whence)
+    {
+      return fseek((FILE*)d_fp, seek_point *d_itemsize, whence) == 0;
+    }
+
+
+    void
+    file_source_impl::open(const char *filename, bool repeat)
+    {
+      // obtain exclusive access for duration of this function
+      boost::mutex::scoped_lock lock(fp_mutex);
 
       int fd;
 
-      if ((fd = open (filename, O_RDONLY | OUR_O_LARGEFILE | OUR_O_BINARY)) < 0){
-	perror (filename);
-	throw std::runtime_error ("can't open file");
+      // we use "open" to use to the O_LARGEFILE flag
+      if((fd = ::open(filename, O_RDONLY | OUR_O_LARGEFILE | OUR_O_BINARY)) < 0) {
+	perror(filename);
+	throw std::runtime_error("can't open file");
+      }
+
+      if(d_new_fp) {
+	fclose(d_new_fp);
+	d_new_fp = 0;
       }
 
-      if ((d_fp = fdopen (fd, "rb")) == NULL) {
+      if((d_new_fp = fdopen (fd, "rb")) == NULL) {
 	perror(filename);
+	::close(fd);	// don't leak file descriptor if fdopen fails
 	throw std::runtime_error("can't open file");
       }
+
+      d_updated = true;
+      d_repeat = repeat;
     }
 
-    file_source_impl::~file_source_impl()
+    void
+    file_source_impl::close()
     {
-      fclose ((FILE *) d_fp);
+      // obtain exclusive access for duration of this function
+      boost::mutex::scoped_lock lock(fp_mutex);
+
+      if(d_new_fp != NULL) {
+	fclose(d_new_fp);
+	d_new_fp = NULL;
+      }
+      d_updated = true;
     }
-    
-    bool
-    file_source_impl::seek(long seek_point, int whence)
+
+    void
+    file_source_impl::do_update()
     {
-      return fseek ((FILE *) d_fp, seek_point *d_itemsize, whence) == 0;
+      if(d_updated) {
+	boost::mutex::scoped_lock lock(fp_mutex); // hold while in scope
+
+	if(d_fp)
+	  fclose(d_fp);
+
+	d_fp = d_new_fp;    // install new file pointer
+	d_new_fp = 0;
+	d_updated = false;
+      }
     }
 
     int
@@ -94,37 +142,41 @@ namespace gr {
 			   gr_vector_const_void_star &input_items,
 			   gr_vector_void_star &output_items)
     {
-      char *o = (char *) output_items[0];
+      char *o = (char*)output_items[0];
       int i;
       int size = noutput_items;
 
-      while (size) {
-	i = fread(o, d_itemsize, size, (FILE *) d_fp);
+      do_update();       // update d_fp is reqd
+      if(d_fp == NULL)
+	throw std::runtime_error("work with file not open");
+
+      boost::mutex::scoped_lock lock(fp_mutex); // hold for the rest of this function
+      while(size) {
+	i = fread(o, d_itemsize, size, (FILE*)d_fp);
 
 	size -= i;
 	o += i * d_itemsize;
 
-	if (size == 0)		// done
+	if(size == 0)		// done
 	  break;
 
-	if (i > 0)			// short read, try again
+	if(i > 0)			// short read, try again
 	  continue;
 
 	// We got a zero from fread.  This is either EOF or error.  In
 	// any event, if we're in repeat mode, seek back to the beginning
 	// of the file and try again, else break
-	
-	if (!d_repeat)
+	if(!d_repeat)
 	  break;
 
-	if (fseek ((FILE *) d_fp, 0, SEEK_SET) == -1) {
+	if(fseek ((FILE *) d_fp, 0, SEEK_SET) == -1) {
 	  fprintf(stderr, "[%s] fseek failed\n", __FILE__);
 	  exit(-1);
 	}
       }
 
-      if (size > 0) {	     		// EOF or error
-	if (size == noutput_items)      // we didn't read anything; say we're done
+      if(size > 0) {	     		// EOF or error
+	if(size == noutput_items)       // we didn't read anything; say we're done
 	  return -1;
 	return noutput_items - size;	// else return partial result
       }
diff --git a/gr-blocks/lib/file_source_impl.h b/gr-blocks/lib/file_source_impl.h
index c35d563d1..600fe80ab 100644
--- a/gr-blocks/lib/file_source_impl.h
+++ b/gr-blocks/lib/file_source_impl.h
@@ -31,15 +31,22 @@ namespace gr {
     class BLOCKS_API file_source_impl : public file_source
     {
     private:
-      size_t  d_itemsize;
-      void   *d_fp;
-      bool    d_repeat;
+      size_t d_itemsize;
+      FILE *d_fp;
+      FILE *d_new_fp;
+      bool d_repeat;
+      bool d_updated;
+      boost::mutex fp_mutex;
       
+      void do_update();
+
     public:
       file_source_impl(size_t itemsize, const char *filename, bool repeat);
       ~file_source_impl();
 
       bool seek(long seek_point, int whence);
+      void open(const char *filename, bool repeat);
+      void close();
 
       int work(int noutput_items,
 	       gr_vector_const_void_star &input_items,
diff --git a/gr-blocks/lib/keep_m_in_n_impl.cc b/gr-blocks/lib/keep_m_in_n_impl.cc
index b3efdd962..312b09c25 100644
--- a/gr-blocks/lib/keep_m_in_n_impl.cc
+++ b/gr-blocks/lib/keep_m_in_n_impl.cc
@@ -39,10 +39,10 @@ namespace gr {
       : gr_block("keep_m_in_n",
 		 gr_make_io_signature (1, 1, itemsize),
 		 gr_make_io_signature (1, 1, itemsize)),
-	d_itemsize(itemsize),
 	d_m(m),
 	d_n(n),
-	d_offset(offset)
+	d_offset(offset),
+	d_itemsize(itemsize)
     {
       // sanity checking
       assert(d_m > 0);
diff --git a/gr-blocks/lib/keep_m_in_n_impl.h b/gr-blocks/lib/keep_m_in_n_impl.h
index 5e264dba0..0b8819489 100644
--- a/gr-blocks/lib/keep_m_in_n_impl.h
+++ b/gr-blocks/lib/keep_m_in_n_impl.h
@@ -30,8 +30,8 @@ namespace gr {
 
     class BLOCKS_API keep_m_in_n_impl : public keep_m_in_n
     {
-      int d_n;
       int d_m;
+      int d_n;
       int d_count;
       int d_offset;
       int d_itemsize;
diff --git a/gr-blocks/lib/patterned_interleaver_impl.cc b/gr-blocks/lib/patterned_interleaver_impl.cc
new file mode 100644
index 000000000..437c733a1
--- /dev/null
+++ b/gr-blocks/lib/patterned_interleaver_impl.cc
@@ -0,0 +1,87 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 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 "patterned_interleaver_impl.h"
+#include <gr_io_signature.h>
+
+namespace gr {
+  namespace blocks {
+
+    patterned_interleaver::sptr patterned_interleaver::make(size_t itemsize, std::vector<int> pattern)
+    {
+      return gnuradio::get_initial_sptr(new patterned_interleaver_impl(itemsize, pattern));
+    }
+
+    patterned_interleaver_impl::patterned_interleaver_impl(size_t itemsize, std::vector<int> pattern)
+      : gr_block ("patterned_interleaver",
+			      gr_make_io_signature (pattern_max(pattern)+1, pattern_max(pattern)+1, itemsize),
+			      gr_make_io_signature (1, 1, itemsize)),
+        d_pattern(pattern), d_counts( pattern_max(pattern)+1, 0), d_itemsize(itemsize)
+    {
+        BOOST_FOREACH( int i, d_pattern)
+        { d_counts[i]++; }
+        set_output_multiple(d_pattern.size());
+    }
+
+    int
+    patterned_interleaver_impl::general_work(int noutput_items,
+                gr_vector_int &ninput_items,
+				gr_vector_const_void_star &input_items,
+				gr_vector_void_star &output_items)
+    {
+      size_t nblks = noutput_items/d_pattern.size();
+      
+      std::vector<const char*> ii;
+      for(size_t i=0; i<input_items.size(); i++){
+        ii.push_back((const char*)input_items[i]);
+        }
+
+      char *oo = (char *) output_items[0];
+      
+      for(size_t i=0; i<nblks; i++){
+        for(size_t j=0; j<d_pattern.size(); j++){
+          memcpy(oo, ii[d_pattern[j]], d_itemsize);
+          oo += d_itemsize;
+          ii[d_pattern[j]] += d_itemsize;
+          }
+        }
+            
+      for(size_t i=0; i<d_counts.size(); i++){
+        consume(i, d_counts[i]*nblks );
+      }
+      return nblks*d_pattern.size();
+    }
+
+    void patterned_interleaver_impl::forecast (int noutput_items,
+        gr_vector_int &ninput_items_required){
+            int nblks = noutput_items / d_pattern.size();
+            for(size_t i=0; i<ninput_items_required.size(); i++){
+                ninput_items_required[i] = d_counts[i] * nblks;
+            }
+        }
+
+  } /* namespace blocks */
+} /* namespace gr */
diff --git a/gr-blocks/lib/patterned_interleaver_impl.h b/gr-blocks/lib/patterned_interleaver_impl.h
new file mode 100644
index 000000000..4266c9636
--- /dev/null
+++ b/gr-blocks/lib/patterned_interleaver_impl.h
@@ -0,0 +1,61 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 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_PATTERNED_INTERLEAVER_IMPL_H
+#define INCLUDED_PATTERNED_INTERLEAVER_IMPL_H
+
+#include <blocks/patterned_interleaver.h>
+#include <boost/foreach.hpp>
+
+namespace gr {
+  namespace blocks {
+
+    class BLOCKS_API patterned_interleaver_impl : public patterned_interleaver
+    {
+    public:
+      patterned_interleaver_impl(size_t itemsize, std::vector<int> pattern);
+
+      int general_work(int noutput_items,
+	       gr_vector_int &ninput_items,
+	       gr_vector_const_void_star &input_items,
+	       gr_vector_void_star &output_items);
+
+      int pattern_max(std::vector<int> pattern){
+        int mval(0);
+        BOOST_FOREACH( int i, pattern)
+            { mval = std::max(mval, i); }
+        return mval;
+        }
+
+      void forecast (int noutput_items,
+             gr_vector_int &ninput_items_required);
+
+      std::vector<int> d_pattern;
+      std::vector<int> d_counts;
+      size_t d_itemsize;
+
+    };
+
+  } /* namespace blocks */
+} /* namespace gr */
+
+#endif 
diff --git a/gr-blocks/python/qa_patterned_interleaver.py b/gr-blocks/python/qa_patterned_interleaver.py
new file mode 100755
index 000000000..3cf29c917
--- /dev/null
+++ b/gr-blocks/python/qa_patterned_interleaver.py
@@ -0,0 +1,56 @@
+#!/usr/bin/env python
+#
+# Copyright 2008,2010 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
+try:
+    import blocks_swig as blocks
+except:
+    from gnuradio import blocks
+import math
+
+class test_patterned_interleaver (gr_unittest.TestCase):
+
+    def setUp (self):
+        self.tb = gr.top_block ()
+
+    def tearDown (self):
+        self.tb = None
+
+    def test_000(self):
+        dst_data = [0,0,1,2,0,2,1,0];
+        src0 = gr.vector_source_f(200*[0])
+        src1 = gr.vector_source_f(200*[1])
+        src2 = gr.vector_source_f(200*[2])
+        itg = blocks.patterned_interleaver(gr.sizeof_float, dst_data)
+        dst = gr.vector_sink_f()
+        head = gr.head(gr.sizeof_float, 8);
+        
+        self.tb.connect( src0, (itg,0) );
+        self.tb.connect( src1, (itg,1) );
+        self.tb.connect( src2, (itg,2) );
+        self.tb.connect( itg, head, dst );
+    
+        self.tb.run()
+        self.assertEqual(list(dst_data), list(dst.data()))
+    
+if __name__ == '__main__':
+    gr_unittest.run(test_patterned_interleaver, "test_patterned_interleaver.xml")
diff --git a/gr-blocks/swig/CMakeLists.txt b/gr-blocks/swig/CMakeLists.txt
index cd2748547..fb29789f0 100644
--- a/gr-blocks/swig/CMakeLists.txt
+++ b/gr-blocks/swig/CMakeLists.txt
@@ -23,8 +23,6 @@
 include(GrPython)
 include(GrSwig)
 
-set(GR_SWIG_TARGET_DEPS core_swig)
-
 set(GR_SWIG_INCLUDE_DIRS
     ${GR_BLOCKS_INCLUDE_DIRS}
     ${GNURADIO_CORE_SWIG_INCLUDE_DIRS}
diff --git a/gr-blocks/swig/blocks_swig.i b/gr-blocks/swig/blocks_swig.i
index 45b259498..7ec6bb423 100644
--- a/gr-blocks/swig/blocks_swig.i
+++ b/gr-blocks/swig/blocks_swig.i
@@ -93,6 +93,7 @@
 #include "blocks/not_bb.h"
 #include "blocks/not_ss.h"
 #include "blocks/not_ii.h"
+#include "blocks/patterned_interleaver.h"
 #include "blocks/or_bb.h"
 #include "blocks/or_ss.h"
 #include "blocks/or_ii.h"
@@ -181,6 +182,7 @@
 %include "blocks/not_bb.h"
 %include "blocks/not_ss.h"
 %include "blocks/not_ii.h"
+%include "blocks/patterned_interleaver.h"
 %include "blocks/or_bb.h"
 %include "blocks/or_ss.h"
 %include "blocks/or_ii.h"
@@ -268,6 +270,7 @@ GR_SWIG_BLOCK_MAGIC2(blocks, nlog10_ff);
 GR_SWIG_BLOCK_MAGIC2(blocks, not_bb);
 GR_SWIG_BLOCK_MAGIC2(blocks, not_ss);
 GR_SWIG_BLOCK_MAGIC2(blocks, not_ii);
+GR_SWIG_BLOCK_MAGIC2(blocks, patterned_interleaver);
 GR_SWIG_BLOCK_MAGIC2(blocks, or_bb);
 GR_SWIG_BLOCK_MAGIC2(blocks, or_ss);
 GR_SWIG_BLOCK_MAGIC2(blocks, or_ii);