8 files changed, 68 insertions, 44 deletions
diff --git a/gr-fec/lib/async_decoder_impl.cc b/gr-fec/lib/async_decoder_impl.cc
index 955aaa51e8..8d20a43142 100644
--- a/gr-fec/lib/async_decoder_impl.cc
+++ b/gr-fec/lib/async_decoder_impl.cc
@@ -34,14 +34,16 @@ namespace gr {
 
     async_decoder::sptr
     async_decoder::make(generic_decoder::sptr my_decoder,
-                        bool packed, bool rev_pack)
+                        bool packed, bool rev_pack,
+                        int mtu)
     {
       return gnuradio::get_initial_sptr
-        (new async_decoder_impl(my_decoder, packed, rev_pack));
+        (new async_decoder_impl(my_decoder, packed, rev_pack, mtu));
     }
 
     async_decoder_impl::async_decoder_impl(generic_decoder::sptr my_decoder,
-                                           bool packed, bool rev_pack)
+                                           bool packed, bool rev_pack,
+                                           int mtu)
       : block("async_decoder",
               io_signature::make(0,0,0),
               io_signature::make(0,0,0)),
@@ -58,6 +60,7 @@ namespace gr {
 
       d_packed = packed;
       d_rev_pack = rev_pack;
+      d_mtu = mtu;
 
       message_port_register_in(d_in_port);
       message_port_register_out(d_out_port);
@@ -71,7 +74,7 @@ namespace gr {
       }
 
       // The maximum frame size is set by the initial frame size of the decoder.
-      d_max_bits_in = d_decoder->get_input_size();
+      d_max_bits_in = d_mtu*8 * 1.0/d_decoder->rate();
       d_tmp_f32 = (float*)volk_malloc(d_max_bits_in*sizeof(float),
                                       volk_get_alignment());
 
@@ -81,7 +84,7 @@ namespace gr {
       }
 
       if(d_packed) {
-        int max_bits_out = d_decoder->get_output_size();
+        int max_bits_out = d_mtu*8;
         d_bits_out = (uint8_t*)volk_malloc(max_bits_out*sizeof(uint8_t),
                                            volk_get_alignment());
       }
@@ -127,14 +130,14 @@ namespace gr {
       // set up nbits_out
       if(variable_frame_size){
         nbits_out = nbits_in*d_decoder->rate() - diff;
-        } else {
-            nblocks = nbits_in / d_decoder->get_input_size();
-            nbits_out = nblocks * d_decoder->get_output_size();
-            if(nblocks * d_decoder->get_input_size() != nbits_in){
-                throw std::runtime_error("bad block multiple in!");
-            }
+      }
+      else {
+        nblocks = nbits_in / d_decoder->get_input_size();
+        nbits_out = nblocks * d_decoder->get_output_size();
+        if(nblocks * d_decoder->get_input_size() != nbits_in){
+          throw std::runtime_error("bad block multiple in!");
         }
-
+      }
 
       size_t o0(0);
       const float* f32in = pmt::f32vector_elements(bits, o0);
@@ -145,13 +148,6 @@ namespace gr {
         volk_32f_s32f_multiply_32f(d_tmp_f32, f32in, 48.0f, nbits_in);
       }
       else {
-        // grow d_tmp_f32 if needed
-        if(nbits_in > d_max_bits_in){
-            d_max_bits_in = nbits_in;
-            volk_free(d_tmp_f32);
-            d_tmp_f32 = (float*)volk_malloc(d_max_bits_in*sizeof(float),
-                        volk_get_alignment());
-            }
         memcpy(d_tmp_f32, f32in, nbits_in*sizeof(float));
       }
 
diff --git a/gr-fec/lib/async_decoder_impl.h b/gr-fec/lib/async_decoder_impl.h
index 53dc84fbe3..abbe55e105 100644
--- a/gr-fec/lib/async_decoder_impl.h
+++ b/gr-fec/lib/async_decoder_impl.h
@@ -43,6 +43,7 @@ namespace gr {
 
       bool d_packed;
       bool d_rev_pack;
+      int d_mtu;
 
       size_t d_max_bits_in;
       float *d_tmp_f32;
@@ -54,7 +55,8 @@ namespace gr {
 
     public:
       async_decoder_impl(generic_decoder::sptr my_decoder,
-                         bool packed=false, bool rev_pack=true);
+                         bool packed=false, bool rev_pack=true,
+                         int mtu=1500);
       ~async_decoder_impl();
 
       int general_work(int noutput_items,
diff --git a/gr-fec/lib/async_encoder_impl.cc b/gr-fec/lib/async_encoder_impl.cc
index b3396e7b21..346160b26c 100644
--- a/gr-fec/lib/async_encoder_impl.cc
+++ b/gr-fec/lib/async_encoder_impl.cc
@@ -34,14 +34,16 @@ namespace gr {
 
     async_encoder::sptr
     async_encoder::make(generic_encoder::sptr my_encoder,
-                        bool packed, bool rev_unpack, bool rev_pack)
+                        bool packed, bool rev_unpack, bool rev_pack,
+                        int mtu)
     {
       return gnuradio::get_initial_sptr
-        (new async_encoder_impl(my_encoder, packed, rev_unpack, rev_pack));
+        (new async_encoder_impl(my_encoder, packed, rev_unpack, rev_pack, mtu));
     }
 
     async_encoder_impl::async_encoder_impl(generic_encoder::sptr my_encoder,
-                                           bool packed, bool rev_unpack, bool rev_pack)
+                                           bool packed, bool rev_unpack, bool rev_pack,
+                                           int mtu)
       : block("async_encoder",
               io_signature::make(0,0,0),
               io_signature::make(0,0,0)),
@@ -55,6 +57,7 @@ namespace gr {
       d_packed = packed;
       d_rev_unpack = rev_unpack;
       d_rev_pack = rev_pack;
+      d_mtu = mtu;
 
       message_port_register_in(d_in_port);
       message_port_register_out(d_out_port);
@@ -64,7 +67,7 @@ namespace gr {
 
         d_unpack = new blocks::kernel::unpack_k_bits(8);
 
-        int max_bits_out = d_encoder->get_output_size();
+        int max_bits_out = d_encoder->rate() * d_mtu * 8;
         d_bits_out = (uint8_t*)volk_malloc(max_bits_out*sizeof(uint8_t),
                                            volk_get_alignment());
 
@@ -80,7 +83,7 @@ namespace gr {
 
         // encode_unpacked: Holds packed bits in when input conversion is packed
         // encode_packed: holds the output bits of the encoder to be packed
-        int max_bits_in = d_encoder->get_input_size();
+        int max_bits_in = d_mtu*8;
         d_bits_in = (uint8_t*)volk_malloc(max_bits_in*sizeof(uint8_t),
                                           volk_get_alignment());
       }
@@ -108,6 +111,10 @@ namespace gr {
 
       size_t o0 = 0;
       int nbits_in = pmt::length(bits);
+      if(nbits_in > (d_mtu*8)) {
+        throw std::runtime_error("async_encoder: received message larger than the MTU.");
+      }
+
       const uint8_t* bits_in = pmt::u8vector_elements(bits, o0);
 
       bool variable_framesize = d_encoder->set_frame_size(nbits_in);
@@ -153,6 +160,10 @@ namespace gr {
 
       size_t o0 = 0;
       int nbytes_in = pmt::length(bytes);
+      if(nbytes_in > d_mtu) {
+        throw std::runtime_error("async_encoder: received message larger than the MTU.");
+      }
+
       int nbits_in = 8*nbytes_in;
       const uint8_t* bytes_in = pmt::u8vector_elements(bytes, o0);
 
diff --git a/gr-fec/lib/async_encoder_impl.h b/gr-fec/lib/async_encoder_impl.h
index fe48177b95..265054370d 100644
--- a/gr-fec/lib/async_encoder_impl.h
+++ b/gr-fec/lib/async_encoder_impl.h
@@ -46,6 +46,7 @@ namespace gr {
       bool d_packed;
       bool d_rev_unpack;
       bool d_rev_pack;
+      int d_mtu;
 
       uint8_t* d_bits_in;
       uint8_t* d_bits_out;
@@ -56,7 +57,8 @@ namespace gr {
     public:
       async_encoder_impl(generic_encoder::sptr my_encoder,
                          bool packed=false,
-                         bool rev_unpack=true, bool rev_pack=true);
+                         bool rev_unpack=true, bool rev_pack=true,
+                         int mtu=1500);
       ~async_encoder_impl();
 
       int general_work(int noutput_items,
diff --git a/gr-fec/lib/tagged_decoder_impl.cc b/gr-fec/lib/tagged_decoder_impl.cc
index 2841b5f57f..989a7a726b 100644
--- a/gr-fec/lib/tagged_decoder_impl.cc
+++ b/gr-fec/lib/tagged_decoder_impl.cc
@@ -35,24 +35,29 @@ namespace gr {
     tagged_decoder::make(generic_decoder::sptr my_decoder,
                          size_t input_item_size,
                          size_t output_item_size,
-                         const std::string &lengthtagname)
+                         const std::string &lengthtagname,
+                         int mtu)
     {
       return gnuradio::get_initial_sptr
         ( new tagged_decoder_impl(my_decoder, input_item_size,
-                                  output_item_size, lengthtagname));
+                                  output_item_size, lengthtagname,
+                                  mtu));
     }
 
     tagged_decoder_impl::tagged_decoder_impl(generic_decoder::sptr my_decoder,
                                              size_t input_item_size,
                                              size_t output_item_size,
-                                             const std::string &lengthtagname)
+                                             const std::string &lengthtagname,
+                                             int mtu)
       : tagged_stream_block("fec_tagged_decoder",
                             io_signature::make(1, 1, input_item_size),
                             io_signature::make(1, 1, output_item_size),
                             lengthtagname),
-        d_input_item_size(input_item_size), d_output_item_size(output_item_size)
+      d_input_item_size(input_item_size), d_output_item_size(output_item_size),
+      d_mtu(mtu)
     {
       d_decoder = my_decoder;
+      d_decoder->set_frame_size(d_mtu*8);
 
       set_relative_rate(d_decoder->rate());
     }
@@ -60,6 +65,10 @@ namespace gr {
     int
     tagged_decoder_impl::calculate_output_stream_length(const gr_vector_int &ninput_items)
     {
+      if((ninput_items[0]*d_decoder->rate()) > (d_mtu*8)) {
+        throw std::runtime_error("tagged_encoder: received frame is larger than MTU.");
+      }
+      d_decoder->set_frame_size(round(ninput_items[0]*d_decoder->rate()));
       return d_decoder->get_output_size();
     }
 
@@ -76,10 +85,6 @@ namespace gr {
       const unsigned char *in = (unsigned char*)input_items[0];
       unsigned char *out = (unsigned char *)output_items[0];
 
-      d_decoder->set_frame_size(ninput_items[0]*d_decoder->rate());
-      if(noutput_items < d_decoder->get_output_size())
-        return 0;
-
       GR_LOG_DEBUG(d_debug_logger, boost::format("%1%, %2%, %3%")      \
                    % noutput_items % ninput_items[0] % d_decoder->get_output_size());
 
diff --git a/gr-fec/lib/tagged_decoder_impl.h b/gr-fec/lib/tagged_decoder_impl.h
index ec81a4fa76..08af956334 100644
--- a/gr-fec/lib/tagged_decoder_impl.h
+++ b/gr-fec/lib/tagged_decoder_impl.h
@@ -34,12 +34,14 @@ namespace gr {
       generic_decoder::sptr d_decoder;
       size_t d_input_item_size;
       size_t d_output_item_size;
+      int d_mtu;
 
     public:
       tagged_decoder_impl(generic_decoder::sptr my_decoder,
                           size_t input_item_size,
                           size_t output_item_size,
-                          const std::string &lengthtagname="packet_len");
+                          const std::string &lengthtagname="packet_len",
+                          int mtu=1500);
       ~tagged_decoder_impl();
 
       int work(int noutput_items,
diff --git a/gr-fec/lib/tagged_encoder_impl.cc b/gr-fec/lib/tagged_encoder_impl.cc
index 8461a56ef7..3870fc51aa 100644
--- a/gr-fec/lib/tagged_encoder_impl.cc
+++ b/gr-fec/lib/tagged_encoder_impl.cc
@@ -35,26 +35,30 @@ namespace gr {
     tagged_encoder::make(generic_encoder::sptr my_encoder,
                          size_t input_item_size,
                          size_t output_item_size,
-                         const std::string& lengthtagname)
+                         const std::string& lengthtagname,
+                         int mtu)
     {
       return gnuradio::get_initial_sptr
         (new tagged_encoder_impl(my_encoder, input_item_size,
                                  output_item_size,
-                                 lengthtagname));
+                                 lengthtagname, mtu));
     }
 
     tagged_encoder_impl::tagged_encoder_impl(generic_encoder::sptr my_encoder,
                                              size_t input_item_size,
                                              size_t output_item_size,
-                                             const std::string& lengthtagname)
+                                             const std::string& lengthtagname,
+                                             int mtu)
       : tagged_stream_block("fec_tagged_encoder",
                             io_signature::make(1, 1, input_item_size),
                             io_signature::make(1, 1, output_item_size),
                             lengthtagname),
-        d_input_item_size(input_item_size), d_output_item_size(output_item_size)
+      d_input_item_size(input_item_size), d_output_item_size(output_item_size),
+      d_mtu(mtu)
     {
       d_encoder = my_encoder;
 
+      d_encoder->set_frame_size(d_mtu*8);
       set_relative_rate(d_encoder->rate());
     }
 
@@ -65,6 +69,10 @@ namespace gr {
     int
     tagged_encoder_impl::calculate_output_stream_length(const gr_vector_int &ninput_items)
     {
+      if(ninput_items[0] > (d_mtu*8)) {
+        throw std::runtime_error("tagged_encoder: received frame is larger than MTU.");
+      }
+      d_encoder->set_frame_size(ninput_items[0]);
       return d_encoder->get_output_size();
     }
 
@@ -77,10 +85,6 @@ namespace gr {
       char *inbuffer  = (char*)input_items[0];
       char *outbuffer = (char*)output_items[0];
 
-      d_encoder->set_frame_size(ninput_items[0]);
-      if(noutput_items < d_encoder->get_output_size())
-        return 0;
-
       GR_LOG_DEBUG(d_debug_logger, boost::format("nout: %1%   nin: %2%   ret: %3%") \
                    % noutput_items % ninput_items[0] % d_encoder->get_output_size());
 
diff --git a/gr-fec/lib/tagged_encoder_impl.h b/gr-fec/lib/tagged_encoder_impl.h
index 55b355342c..a119607789 100644
--- a/gr-fec/lib/tagged_encoder_impl.h
+++ b/gr-fec/lib/tagged_encoder_impl.h
@@ -34,12 +34,14 @@ namespace gr {
       generic_encoder::sptr d_encoder;
       size_t d_input_item_size;
       size_t d_output_item_size;
+      int d_mtu;
 
     public:
       tagged_encoder_impl(generic_encoder::sptr my_encoder,
                           size_t input_item_size,
                           size_t output_item_size,
-                          const std::string &lengthtagname="packet_len");
+                          const std::string &lengthtagname="packet_len",
+                          int mtu=1500);
       ~tagged_encoder_impl();
 
       int work(int noutput_items,