1 files changed, 221 insertions, 213 deletions
diff --git a/gr-dtv/lib/dvbt/dvbt_inner_coder_impl.cc b/gr-dtv/lib/dvbt/dvbt_inner_coder_impl.cc
index 19eec4e350..1b2129b1f2 100644
--- a/gr-dtv/lib/dvbt/dvbt_inner_coder_impl.cc
+++ b/gr-dtv/lib/dvbt/dvbt_inner_coder_impl.cc
@@ -1,22 +1,22 @@
 /* -*- c++ -*- */
-/* 
+/*
  * Copyright 2015,2016,2019 Free Software Foundation, Inc.
- * 
+ *
  * This 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.
- * 
+ *
  * This software 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 this software; 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"
@@ -27,239 +27,247 @@
 #include <assert.h>
 
 namespace gr {
-  namespace dtv {
-
-    inline void
-    dvbt_inner_coder_impl::generate_codeword(unsigned char in, int &x, int &y)
-    {
-      //insert input bit
-      d_reg |= ((in & 0x1) << 7);
-
-      d_reg = d_reg >> 1;
-
-      x = d_lookup_171[d_reg];
-      y = d_lookup_133[d_reg];
-    }
-
-    //TODO - do this based on puncturing matrix
-    /*
-     * Input e.g rate 2/3:
-     * 000000x0x1
-     * Output e.g. rate 2/3
-     * 00000c0c1c2
-     */
-
-    inline void
-    dvbt_inner_coder_impl::generate_punctured_code(dvb_code_rate_t coderate, unsigned char * in, unsigned char * out)
-    {
-      int x, y;
-
-      switch(coderate) {
-        //X1Y1
-        case C1_2:
-          generate_codeword(in[0], x, y);
-          out[0] = x; out[1] = y;
-          break;
-        //X1Y1Y2
-        case C2_3:
-          generate_codeword(in[0], x, y);
-          out[0] = x; out[1] = y;
-          generate_codeword(in[1], x, y);
-          out[2] = y;
-          break;
-        //X1Y1Y2X3
-        case C3_4:
-          generate_codeword(in[0], x, y);
-          out[0] = x; out[1] = y;
-          generate_codeword(in[1], x, y);
-          out[2] = y;
-          generate_codeword(in[2], x, y);
-          out[3] = x;
-          break;
-        //X1Y1Y2X3Y4X5
-        case C5_6:
-          generate_codeword(in[0], x, y);
-          out[0] = x; out[1] = y;
-          generate_codeword(in[1], x, y);
-          out[2] = y;
-          generate_codeword(in[2], x, y);
-          out[3] = x;
-          generate_codeword(in[3], x, y);
-          out[4] = y;
-          generate_codeword(in[4], x, y);
-          out[5] = x;
-          break;
-        //X1Y1Y2X3Y4X5Y6X7
-        case C7_8:
-          generate_codeword(in[0], x, y);
-          out[0] = x; out[1] = y;
-          generate_codeword(in[1], x, y);
-          out[2] = y;
-          generate_codeword(in[2], x, y);
-          out[3] = y;
-          generate_codeword(in[3], x, y);
-          out[4] = y;
-          generate_codeword(in[4], x, y);
-          out[5] = x;
-          generate_codeword(in[5], x, y);
-          out[6] = y;
-          generate_codeword(in[6], x, y);
-          out[7] = x;
-          break;
-        default:
-          generate_codeword(in[0], x, y);
-          out[0] = x; out[1] = y;
-          break;
-      }
+namespace dtv {
+
+inline void dvbt_inner_coder_impl::generate_codeword(unsigned char in, int& x, int& y)
+{
+    // insert input bit
+    d_reg |= ((in & 0x1) << 7);
+
+    d_reg = d_reg >> 1;
+
+    x = d_lookup_171[d_reg];
+    y = d_lookup_133[d_reg];
+}
+
+// TODO - do this based on puncturing matrix
+/*
+ * Input e.g rate 2/3:
+ * 000000x0x1
+ * Output e.g. rate 2/3
+ * 00000c0c1c2
+ */
+
+inline void dvbt_inner_coder_impl::generate_punctured_code(dvb_code_rate_t coderate,
+                                                           unsigned char* in,
+                                                           unsigned char* out)
+{
+    int x, y;
+
+    switch (coderate) {
+    // X1Y1
+    case C1_2:
+        generate_codeword(in[0], x, y);
+        out[0] = x;
+        out[1] = y;
+        break;
+    // X1Y1Y2
+    case C2_3:
+        generate_codeword(in[0], x, y);
+        out[0] = x;
+        out[1] = y;
+        generate_codeword(in[1], x, y);
+        out[2] = y;
+        break;
+    // X1Y1Y2X3
+    case C3_4:
+        generate_codeword(in[0], x, y);
+        out[0] = x;
+        out[1] = y;
+        generate_codeword(in[1], x, y);
+        out[2] = y;
+        generate_codeword(in[2], x, y);
+        out[3] = x;
+        break;
+    // X1Y1Y2X3Y4X5
+    case C5_6:
+        generate_codeword(in[0], x, y);
+        out[0] = x;
+        out[1] = y;
+        generate_codeword(in[1], x, y);
+        out[2] = y;
+        generate_codeword(in[2], x, y);
+        out[3] = x;
+        generate_codeword(in[3], x, y);
+        out[4] = y;
+        generate_codeword(in[4], x, y);
+        out[5] = x;
+        break;
+    // X1Y1Y2X3Y4X5Y6X7
+    case C7_8:
+        generate_codeword(in[0], x, y);
+        out[0] = x;
+        out[1] = y;
+        generate_codeword(in[1], x, y);
+        out[2] = y;
+        generate_codeword(in[2], x, y);
+        out[3] = y;
+        generate_codeword(in[3], x, y);
+        out[4] = y;
+        generate_codeword(in[4], x, y);
+        out[5] = x;
+        generate_codeword(in[5], x, y);
+        out[6] = y;
+        generate_codeword(in[6], x, y);
+        out[7] = x;
+        break;
+    default:
+        generate_codeword(in[0], x, y);
+        out[0] = x;
+        out[1] = y;
+        break;
     }
-
-    dvbt_inner_coder::sptr
-    dvbt_inner_coder::make(int ninput, int noutput, dvb_constellation_t constellation, \
-        dvbt_hierarchy_t hierarchy, dvb_code_rate_t coderate)
-    {
-      return gnuradio::get_initial_sptr
-        (new dvbt_inner_coder_impl(ninput, noutput, constellation, hierarchy, coderate));
-    }
-
-    /*
-     * The private constructor
-     */
-    dvbt_inner_coder_impl::dvbt_inner_coder_impl(int ninput, int noutput, dvb_constellation_t constellation, \
-        dvbt_hierarchy_t hierarchy, dvb_code_rate_t coderate)
-      : block("dvbt_inner_coder",
-          io_signature::make(1, 1, sizeof (unsigned char)),
-          io_signature::make(1, 1, sizeof (unsigned char) * noutput)),
+}
+
+dvbt_inner_coder::sptr dvbt_inner_coder::make(int ninput,
+                                              int noutput,
+                                              dvb_constellation_t constellation,
+                                              dvbt_hierarchy_t hierarchy,
+                                              dvb_code_rate_t coderate)
+{
+    return gnuradio::get_initial_sptr(
+        new dvbt_inner_coder_impl(ninput, noutput, constellation, hierarchy, coderate));
+}
+
+/*
+ * The private constructor
+ */
+dvbt_inner_coder_impl::dvbt_inner_coder_impl(int ninput,
+                                             int noutput,
+                                             dvb_constellation_t constellation,
+                                             dvbt_hierarchy_t hierarchy,
+                                             dvb_code_rate_t coderate)
+    : block("dvbt_inner_coder",
+            io_signature::make(1, 1, sizeof(unsigned char)),
+            io_signature::make(1, 1, sizeof(unsigned char) * noutput)),
       config(constellation, hierarchy, coderate, coderate),
-      d_ninput(ninput), d_noutput(noutput),
+      d_ninput(ninput),
+      d_noutput(noutput),
       d_reg(0)
-    {
-      //Determine k - input of encoder
-      d_k = config.d_cr_k;
-      //Determine n - output of encoder
-      d_n = config.d_cr_n;
-      //Determine m - constellation symbol size
-      d_m = config.d_m;
-
-      // In order to accommodate all constalations (m=2,4,6)
-      // and rates (1/2, 2/3, 3/4, 5/6, 7/8)
-      // We need the following things to happen:
-      // - output item size multiple of 1512bytes
-      // - noutput_items multiple of 4
-      // - in block size 4*(k*m/8)
-      // - out block size 4*n
-      //
-      // Rate calculation follows:
-      // We process km input bits(km/8 Bytes)
-      // We output nm bits
-      // We output one byte for a symbol of m bits
-      // The out/in rate in bytes is: 8n/km (Bytes)
-
-      assert(d_noutput % 1512 == 0);
-
-      // Set output items multiple of 4
-      set_output_multiple(4);
-
-      // calculate in and out block sizes
-      d_in_bs = (d_k * d_m) / 2;
-      d_out_bs = 4 * d_n;
-
-      // allocate bit buffers
-      d_in_buff = new (std::nothrow) unsigned char[8 * d_in_bs];
-      if (d_in_buff == NULL) {
+{
+    // Determine k - input of encoder
+    d_k = config.d_cr_k;
+    // Determine n - output of encoder
+    d_n = config.d_cr_n;
+    // Determine m - constellation symbol size
+    d_m = config.d_m;
+
+    // In order to accommodate all constalations (m=2,4,6)
+    // and rates (1/2, 2/3, 3/4, 5/6, 7/8)
+    // We need the following things to happen:
+    // - output item size multiple of 1512bytes
+    // - noutput_items multiple of 4
+    // - in block size 4*(k*m/8)
+    // - out block size 4*n
+    //
+    // Rate calculation follows:
+    // We process km input bits(km/8 Bytes)
+    // We output nm bits
+    // We output one byte for a symbol of m bits
+    // The out/in rate in bytes is: 8n/km (Bytes)
+
+    assert(d_noutput % 1512 == 0);
+
+    // Set output items multiple of 4
+    set_output_multiple(4);
+
+    // calculate in and out block sizes
+    d_in_bs = (d_k * d_m) / 2;
+    d_out_bs = 4 * d_n;
+
+    // allocate bit buffers
+    d_in_buff = new (std::nothrow) unsigned char[8 * d_in_bs];
+    if (d_in_buff == NULL) {
         GR_LOG_FATAL(d_logger, "Inner Coder, cannot allocate memory for d_in_buff.");
         throw std::bad_alloc();
-      }
+    }
 
-      d_out_buff = new (std::nothrow) unsigned char[8 * d_in_bs * d_n / d_k];
-      if (d_out_buff == NULL) {
+    d_out_buff = new (std::nothrow) unsigned char[8 * d_in_bs * d_n / d_k];
+    if (d_out_buff == NULL) {
         GR_LOG_FATAL(d_logger, "Inner Coder, cannot allocate memory for d_out_buff.");
-        delete [] d_in_buff;
+        delete[] d_in_buff;
         throw std::bad_alloc();
-      }
     }
-
-    /*
-     * Our virtual destructor.
-     */
-    dvbt_inner_coder_impl::~dvbt_inner_coder_impl()
-    {
-      delete [] d_out_buff;
-      delete [] d_in_buff;
-    }
-
-    void
-    dvbt_inner_coder_impl::forecast (int noutput_items, gr_vector_int &ninput_items_required)
-    {
-      int input_required = noutput_items * d_noutput * d_k * d_m / (d_ninput * 8 * d_n);
-
-      unsigned ninputs = ninput_items_required.size();
-      for (unsigned int i = 0; i < ninputs; i++) {
+}
+
+/*
+ * Our virtual destructor.
+ */
+dvbt_inner_coder_impl::~dvbt_inner_coder_impl()
+{
+    delete[] d_out_buff;
+    delete[] d_in_buff;
+}
+
+void dvbt_inner_coder_impl::forecast(int noutput_items,
+                                     gr_vector_int& ninput_items_required)
+{
+    int input_required = noutput_items * d_noutput * d_k * d_m / (d_ninput * 8 * d_n);
+
+    unsigned ninputs = ninput_items_required.size();
+    for (unsigned int i = 0; i < ninputs; i++) {
         ninput_items_required[i] = input_required;
-      }
     }
+}
 
-    int
-    dvbt_inner_coder_impl::general_work (int noutput_items,
-                       gr_vector_int &ninput_items,
-                       gr_vector_const_void_star &input_items,
-                       gr_vector_void_star &output_items)
-    {
-      const unsigned char *in = (const unsigned char *) input_items[0];
-      unsigned char *out = (unsigned char *) output_items[0];
+int dvbt_inner_coder_impl::general_work(int noutput_items,
+                                        gr_vector_int& ninput_items,
+                                        gr_vector_const_void_star& input_items,
+                                        gr_vector_void_star& output_items)
+{
+    const unsigned char* in = (const unsigned char*)input_items[0];
+    unsigned char* out = (unsigned char*)output_items[0];
 
-      for (int k = 0; k < (noutput_items * d_noutput / d_out_bs); k++) {
+    for (int k = 0; k < (noutput_items * d_noutput / d_out_bs); k++) {
         // Unpack input to bits
         for (int i = 0; i < d_in_bs; i++) {
-          for (int j = 0; j < 8; j++) {
-            d_in_buff[8*i + j] = (in[k*d_in_bs + i] >> (7 - j)) & 1;
-          }
+            for (int j = 0; j < 8; j++) {
+                d_in_buff[8 * i + j] = (in[k * d_in_bs + i] >> (7 - j)) & 1;
+            }
         }
 
         // Encode the data
-        for (int in_bit = 0, out_bit = 0; in_bit < (8 * d_in_bs); in_bit += d_k, out_bit += d_n) {
-          generate_punctured_code(config.d_code_rate_HP, &d_in_buff[in_bit], &d_out_buff[out_bit]);
+        for (int in_bit = 0, out_bit = 0; in_bit < (8 * d_in_bs);
+             in_bit += d_k, out_bit += d_n) {
+            generate_punctured_code(
+                config.d_code_rate_HP, &d_in_buff[in_bit], &d_out_buff[out_bit]);
         }
 
         // Pack d_m bit in one output byte
         for (int i = 0; i < d_out_bs; i++) {
-          unsigned char c = 0;
+            unsigned char c = 0;
 
-          for (int j = 0; j < d_m; j++) {
-            c |= d_out_buff[d_m*i + j] << (d_m - 1 - j);
-          }
+            for (int j = 0; j < d_m; j++) {
+                c |= d_out_buff[d_m * i + j] << (d_m - 1 - j);
+            }
 
-          out[k*d_out_bs + i] = c;
+            out[k * d_out_bs + i] = c;
         }
-      }
-
-      // Tell runtime system how many input items we consumed on
-      // each input stream.
-      consume_each(noutput_items * d_noutput * d_k * d_m / (d_ninput * 8 * d_n));
-
-      // Tell runtime system how many output items we produced.
-      return noutput_items;
     }
 
-    const int dvbt_inner_coder_impl::d_lookup_171[128] = 
-    {0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0,
-     1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1,
-     1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1,
-     0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0,
-     1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1,
-     0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0,
-     0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0,
-     1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1};
-
-    const int dvbt_inner_coder_impl::d_lookup_133[128] =
-    {0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1,
-     1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0,
-     0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1,
-     1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0,
-     1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0,
-     0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1,
-     1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0,
-     0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1};
-
-  } /* namespace dtv */
+    // Tell runtime system how many input items we consumed on
+    // each input stream.
+    consume_each(noutput_items * d_noutput * d_k * d_m / (d_ninput * 8 * d_n));
+
+    // Tell runtime system how many output items we produced.
+    return noutput_items;
+}
+
+const int dvbt_inner_coder_impl::d_lookup_171[128] = {
+    0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1,
+    0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,
+    0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1,
+    0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1,
+    1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1
+};
+
+const int dvbt_inner_coder_impl::d_lookup_133[128] = {
+    0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1,
+    1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1,
+    1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1,
+    1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1,
+    0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1
+};
+
+} /* namespace dtv */
 } /* namespace gr */
-