7 files changed, 35 insertions, 24 deletions
diff --git a/gr-fec/lib/async_encoder_impl.cc b/gr-fec/lib/async_encoder_impl.cc
index 4856dfd564..ff7480f00a 100644
--- a/gr-fec/lib/async_encoder_impl.cc
+++ b/gr-fec/lib/async_encoder_impl.cc
@@ -92,7 +92,7 @@ namespace gr {
       d_encoder->set_frame_size(nbits);
 
       int nbits_out = d_encoder->get_output_size();
-      int nbytes_out = ceilf(static_cast<float>(nbits_out)/8.0f);
+      int nbytes_out = nbits_out/8;
 
       // buffers for bits/bytes to go to
       uint8_t* bits_out = (uint8_t*)volk_malloc(nbits_out*sizeof(uint8_t),
diff --git a/gr-fec/lib/cc_decoder_impl.cc b/gr-fec/lib/cc_decoder_impl.cc
index 6b7daaf4b2..6739f7bf3d 100644
--- a/gr-fec/lib/cc_decoder_impl.cc
+++ b/gr-fec/lib/cc_decoder_impl.cc
@@ -40,23 +40,24 @@ namespace gr {
       cc_decoder::make(int frame_size, int k,
                        int rate, std::vector<int> polys,
                        int start_state, int end_state,
-                       cc_mode_t mode)
+                       cc_mode_t mode, bool padded)
       {
         return generic_decoder::sptr
           (new cc_decoder_impl(frame_size, k, rate, polys,
-                               start_state, end_state, mode));
+                               start_state, end_state, mode, padded));
       }
 
       cc_decoder_impl::cc_decoder_impl(int frame_size, int k,
                                        int rate, std::vector<int> polys,
                                        int start_state, int end_state,
-                                       cc_mode_t mode)
+                                       cc_mode_t mode, bool padded)
         : generic_decoder("cc_decoder"),
           d_k(k),
           d_rate(rate),
           d_partial_rate(rate),
           d_polys(polys),
           d_mode(mode),
+          d_padding(0),
           d_start_state_chaining(start_state),
           d_start_state_nonchaining(start_state),
           d_end_state_nonchaining(end_state)
@@ -65,7 +66,12 @@ namespace gr {
         // based on this value.
         d_max_frame_size = frame_size;
         d_frame_size = frame_size;
-        //set_frame_size(frame_size);
+
+        // set up a padding factor. If padding, the encoded frame was exteded
+        // by this many bits to fit into a full byte.
+        if(padded && (mode == CC_TERMINATED)) {
+          d_padding = static_cast<int>(8.0f*ceilf(d_rate*(d_k-1)/8.0f) - (d_rate*(d_k-1)));
+        }
 
         d_vp = new struct v;
 
@@ -170,7 +176,7 @@ namespace gr {
       cc_decoder_impl::get_input_size()
       {
         if(d_mode == CC_TERMINATED) {
-          return d_rate * (d_frame_size + d_k - 1);
+          return d_rate * (d_frame_size + d_k - 1) + d_padding;
         }
         else {
           return d_rate * d_frame_size;
@@ -365,7 +371,6 @@ namespace gr {
         d += tailsize * d_decision_t_size ; /* Look past tail */
         int retval;
         int dif = tailsize - (d_k - 1);
-        //printf("break, %d, %d\n", dif, (nbits+dif)%d_frame_size);
         decision_t dec;
         while(nbits-- > d_frame_size - (d_k - 1)) {
           int k;
@@ -373,8 +378,6 @@ namespace gr {
           k = (dec.w[(endstate>>d_ADDSHIFT)/32] >> ((endstate>>d_ADDSHIFT)%32)) & 1;
 
           endstate = (endstate >> 1) | (k << (d_k-2+d_ADDSHIFT));
-          //data[((nbits+dif)%nbits)>>3] = endstate>>d_SUBSHIFT;
-          //printf("%d, %d\n", k, (nbits+dif)%d_frame_size);
           data[((nbits+dif)%d_frame_size)] = k;
 
           retval = endstate;
@@ -400,7 +403,7 @@ namespace gr {
       {
         bool ret = true;
         if(frame_size > d_max_frame_size) {
-          GR_LOG_INFO(d_logger, boost::format("tried to set frame to %1%; max possible is %2%") \
+          GR_LOG_INFO(d_logger, boost::format("cc_decoder: tried to set frame to %1%; max possible is %2%") \
                       % frame_size % d_max_frame_size);
           frame_size = d_max_frame_size;
           ret = false;
@@ -412,7 +415,7 @@ namespace gr {
         case(CC_TAILBITING):
           d_veclen = d_frame_size + (6 * (d_k - 1));
           if(d_veclen * d_rate > d_managed_in_size) {
-            throw std::runtime_error("attempt to resize beyond d_managed_in buffer size!\n");
+            throw std::runtime_error("cc_decoder: attempt to resize beyond d_managed_in buffer size!\n");
           }
           break;
 
@@ -421,7 +424,13 @@ namespace gr {
           break;
 
         case(CC_STREAMING):
+          d_veclen = d_frame_size + d_k - 1;
+          break;
+
         case(CC_TERMINATED):
+          // If the input is being padded out to a byte, we know the
+          // real frame size is without the padding.
+          d_frame_size -= d_padding * d_rate;
           d_veclen = d_frame_size + d_k - 1;
           break;
 
diff --git a/gr-fec/lib/cc_decoder_impl.h b/gr-fec/lib/cc_decoder_impl.h
index d0b1af35a3..33ced0250c 100644
--- a/gr-fec/lib/cc_decoder_impl.h
+++ b/gr-fec/lib/cc_decoder_impl.h
@@ -67,6 +67,7 @@ namespace gr {
         unsigned int d_partial_rate;
         std::vector<int> d_polys;
         cc_mode_t d_mode;
+        int d_padding;
 
         struct v* d_vp;
         unsigned char* d_managed_in;
@@ -90,7 +91,7 @@ namespace gr {
         cc_decoder_impl(int frame_size, int k,
                         int rate, std::vector<int> polys,
                         int start_state = 0, int end_state = -1,
-                        cc_mode_t mode=CC_STREAMING);
+                        cc_mode_t mode=CC_STREAMING, bool padded=false);
         ~cc_decoder_impl();
 
         void generic_work(void *inbuffer, void *outbuffer);
diff --git a/gr-fec/lib/cc_encoder_impl.cc b/gr-fec/lib/cc_encoder_impl.cc
index abbf1a8f1b..90d2ee4c1c 100644
--- a/gr-fec/lib/cc_encoder_impl.cc
+++ b/gr-fec/lib/cc_encoder_impl.cc
@@ -42,21 +42,21 @@ namespace gr {
       generic_encoder::sptr
       cc_encoder::make(int frame_size, int k, int rate,
                        std::vector<int> polys, int start_state,
-                        cc_mode_t mode)
+                       cc_mode_t mode, bool padded)
       {
         return generic_encoder::sptr
           (new cc_encoder_impl(frame_size, k, rate,
                                polys, start_state,
-                               mode));
+                               mode, padded));
       }
 
       cc_encoder_impl::cc_encoder_impl(int frame_size, int k, int rate,
                                        std::vector<int> polys, int start_state,
-                                       cc_mode_t mode)
+                                       cc_mode_t mode, bool padded)
         : generic_encoder("cc_encoder"),
           d_rate(rate), d_k(k), d_polys(polys),
           d_start_state(start_state),
-          d_mode(mode)
+          d_mode(mode), d_padding(0)
       {
         if(static_cast<size_t>(d_rate) != d_polys.size()) {
           throw std::runtime_error("cc_encoder: Number of polynomials must be the same as the value of rate");
@@ -64,6 +64,12 @@ namespace gr {
 
         partab_init();
 
+        // set up a padding factor. If padding, extends the encoding
+        // by this many bits to fit into a full byte.
+        if(padded && (mode == CC_TERMINATED)) {
+          d_padding = static_cast<int>(8.0f*ceilf(d_rate*(d_k-1)/8.0f) - (d_rate*(d_k-1)));
+        }
+
         d_max_frame_size = frame_size;
         set_frame_size(frame_size);
       }
@@ -98,7 +104,7 @@ namespace gr {
         d_frame_size = frame_size;
 
         if(d_mode == CC_TERMINATED) {
-          d_output_size = d_rate * (d_frame_size + d_k - 1);
+          d_output_size = d_rate * (d_frame_size + d_k - 1) + d_padding;
         }
         /*
         else if(d_trunc_intrinsic) {
diff --git a/gr-fec/lib/cc_encoder_impl.h b/gr-fec/lib/cc_encoder_impl.h
index 008887559b..77d5f42462 100644
--- a/gr-fec/lib/cc_encoder_impl.h
+++ b/gr-fec/lib/cc_encoder_impl.h
@@ -51,6 +51,7 @@ namespace gr {
         int d_decision_t_size;
         int d_start_state;
         cc_mode_t d_mode;
+        int d_padding;
         int d_output_size;
 
         int parity(int x);
@@ -60,7 +61,7 @@ namespace gr {
       public:
         cc_encoder_impl(int frame_size, int k, int rate,
                         std::vector<int> polys, int start_state = 0,
-                        cc_mode_t mode=CC_STREAMING);
+                        cc_mode_t mode=CC_STREAMING, bool padded=false);
         ~cc_encoder_impl();
 
         bool set_frame_size(unsigned int frame_size);
diff --git a/gr-fec/lib/tagged_decoder_impl.cc b/gr-fec/lib/tagged_decoder_impl.cc
index bccf5147ff..2841b5f57f 100644
--- a/gr-fec/lib/tagged_decoder_impl.cc
+++ b/gr-fec/lib/tagged_decoder_impl.cc
@@ -85,9 +85,6 @@ namespace gr {
 
       d_decoder->generic_work((void*)in, (void*)out);
 
-      add_item_tag(0, nitems_written(0) + d_decoder->get_output_size()*d_output_item_size,
-                   pmt::intern(d_decoder->alias()), pmt::PMT_T, pmt::intern(alias()));
-
       return d_decoder->get_output_size();
     }
 
diff --git a/gr-fec/lib/tagged_encoder_impl.cc b/gr-fec/lib/tagged_encoder_impl.cc
index 4d19e4c668..8461a56ef7 100644
--- a/gr-fec/lib/tagged_encoder_impl.cc
+++ b/gr-fec/lib/tagged_encoder_impl.cc
@@ -86,9 +86,6 @@ namespace gr {
 
       d_encoder->generic_work((void*)(inbuffer), (void*)(outbuffer));
 
-      add_item_tag(0, nitems_written(0) + (d_encoder->get_output_size()*d_output_item_size),
-                   pmt::intern(d_encoder->alias()), pmt::PMT_T, pmt::intern(alias()));
-
       return d_encoder->get_output_size();
     }