7 files changed, 62 insertions, 94 deletions
diff --git a/gr-fec/lib/cc_decoder_impl.cc b/gr-fec/lib/cc_decoder_impl.cc
index 2ff08e018d..21062e4f41 100644
--- a/gr-fec/lib/cc_decoder_impl.cc
+++ b/gr-fec/lib/cc_decoder_impl.cc
@@ -98,26 +98,13 @@ cc_decoder_impl::cc_decoder_impl(int frame_size,
         throw std::runtime_error("cc_decoder: mode not recognized");
     }
 
-    d_vp.metrics = (unsigned char*)volk_malloc(2 * sizeof(unsigned char) * d_numstates,
-                                               volk_get_alignment());
-    if (d_vp.metrics == NULL) {
-        throw std::runtime_error("bad alloc for d_vp.metrics!");
-    }
-
-    d_vp.metrics1.t = d_vp.metrics;
-    d_vp.metrics2.t = d_vp.metrics + d_numstates;
+    d_vp.metrics.resize(2 * d_numstates);
+    d_vp.metrics1.t = d_vp.metrics.data();
+    d_vp.metrics2.t = d_vp.metrics.data() + d_numstates;
 
-    d_vp.decisions = (unsigned char*)volk_malloc(
-        sizeof(unsigned char) * d_veclen * d_decision_t_size, volk_get_alignment());
-    if (d_vp.decisions == NULL) {
-        throw std::runtime_error("bad alloc for d_vp.decisions!");
-    }
+    d_vp.decisions.resize(d_veclen * d_decision_t_size);
 
-    Branchtab = (unsigned char*)volk_malloc(
-        sizeof(unsigned char) * d_numstates / 2 * rate, volk_get_alignment());
-    if (Branchtab == NULL) {
-        throw std::runtime_error("bad alloc for d_vp.decisions!");
-    }
+    d_branchtab.resize(d_numstates / 2 * rate);
 
     create_viterbi();
 
@@ -147,12 +134,7 @@ cc_decoder_impl::cc_decoder_impl(int frame_size,
     }
 }
 
-cc_decoder_impl::~cc_decoder_impl()
-{
-    volk_free(d_vp.decisions);
-    volk_free(Branchtab);
-    volk_free(d_vp.metrics);
-}
+cc_decoder_impl::~cc_decoder_impl() {}
 
 int cc_decoder_impl::get_output_size()
 {
@@ -191,7 +173,7 @@ void cc_decoder_impl::create_viterbi()
     partab_init();
     for (state = 0; state < d_numstates / 2; state++) {
         for (i = 0; i < d_rate; i++) {
-            Branchtab[i * d_numstates / 2 + state] =
+            d_branchtab[i * d_numstates / 2 + state] =
                 (d_polys[i] < 0) ^ parity((2 * state) & abs(d_polys[i])) ? 255 : 0;
         }
     }
@@ -297,9 +279,7 @@ int cc_decoder_impl::find_endstate()
 
 int cc_decoder_impl::update_viterbi_blk(unsigned char* syms, int nbits)
 {
-    unsigned char* d;
-
-    d = d_vp.decisions;
+    unsigned char* d = d_vp.decisions.data();
 
     memset(d, 0, d_decision_t_size * nbits);
 
@@ -309,7 +289,7 @@ int cc_decoder_impl::update_viterbi_blk(unsigned char* syms, int nbits)
              d,
              nbits - (d_k - 1),
              d_k - 1,
-             Branchtab);
+             d_branchtab.data());
 
     return 0;
 }
@@ -319,10 +299,8 @@ int cc_decoder_impl::chainback_viterbi(unsigned char* data,
                                        unsigned int endstate,
                                        unsigned int tailsize)
 {
-    unsigned char* d;
-
     /* ADDSHIFT and SUBSHIFT make sure that the thing returned is a byte. */
-    d = d_vp.decisions;
+    unsigned char* d = d_vp.decisions.data();
     /* Make room beyond the end of the encoder register so we can
      * accumulate a full byte of decoded data
      */
diff --git a/gr-fec/lib/cc_decoder_impl.h b/gr-fec/lib/cc_decoder_impl.h
index e39cd9846a..d7d236da21 100644
--- a/gr-fec/lib/cc_decoder_impl.h
+++ b/gr-fec/lib/cc_decoder_impl.h
@@ -43,7 +43,7 @@ private:
                           unsigned int tailsize);
     int find_endstate();
 
-    unsigned char* Branchtab;
+    volk::vector<unsigned char> d_branchtab;
     unsigned char Partab[256];
 
 
@@ -85,6 +85,10 @@ public:
                     bool padded = false);
     ~cc_decoder_impl();
 
+    // Disable copy because of the raw pointers.
+    cc_decoder_impl(const cc_decoder_impl&) = delete;
+    cc_decoder_impl& operator=(const cc_decoder_impl&) = delete;
+
     void generic_work(void* inbuffer, void* outbuffer);
     bool set_frame_size(unsigned int frame_size);
     double rate();
diff --git a/gr-fec/lib/polar_decoder_sc.cc b/gr-fec/lib/polar_decoder_sc.cc
index 9d694bf3bb..eee78fabf8 100644
--- a/gr-fec/lib/polar_decoder_sc.cc
+++ b/gr-fec/lib/polar_decoder_sc.cc
@@ -37,30 +37,22 @@ polar_decoder_sc::polar_decoder_sc(int block_size,
                                    std::vector<int> frozen_bit_positions,
                                    std::vector<uint8_t> frozen_bit_values)
     : polar_decoder_common(
-          block_size, num_info_bits, frozen_bit_positions, frozen_bit_values)
+          block_size, num_info_bits, frozen_bit_positions, frozen_bit_values),
+      d_llr_vec(block_size * (block_power() + 1)),
+      d_u_hat_vec(block_size * (block_power() + 1))
 {
-    d_llr_vec = (float*)volk_malloc(sizeof(float) * block_size * (block_power() + 1),
-                                    volk_get_alignment());
-    memset(d_llr_vec, 0, sizeof(float) * block_size * (block_power() + 1));
-    d_u_hat_vec = (unsigned char*)volk_malloc(block_size * (block_power() + 1),
-                                              volk_get_alignment());
-    memset(d_u_hat_vec, 0, sizeof(unsigned char) * block_size * (block_power() + 1));
 }
 
-polar_decoder_sc::~polar_decoder_sc()
-{
-    volk_free(d_llr_vec);
-    volk_free(d_u_hat_vec);
-}
+polar_decoder_sc::~polar_decoder_sc() {}
 
 void polar_decoder_sc::generic_work(void* in_buffer, void* out_buffer)
 {
     const float* in = (const float*)in_buffer;
     unsigned char* out = (unsigned char*)out_buffer;
 
-    initialize_decoder(d_u_hat_vec, d_llr_vec, in);
-    sc_decode(d_llr_vec, d_u_hat_vec);
-    extract_info_bits(out, d_u_hat_vec);
+    initialize_decoder(d_u_hat_vec.data(), d_llr_vec.data(), in);
+    sc_decode(d_llr_vec.data(), d_u_hat_vec.data());
+    extract_info_bits(out, d_u_hat_vec.data());
 }
 
 void polar_decoder_sc::sc_decode(float* llrs, unsigned char* u)
diff --git a/gr-fec/lib/polar_decoder_sc_systematic.cc b/gr-fec/lib/polar_decoder_sc_systematic.cc
index 20fbad2d38..cd8f3db586 100644
--- a/gr-fec/lib/polar_decoder_sc_systematic.cc
+++ b/gr-fec/lib/polar_decoder_sc_systematic.cc
@@ -30,34 +30,24 @@ generic_decoder::sptr polar_decoder_sc_systematic::make(
 polar_decoder_sc_systematic::polar_decoder_sc_systematic(
     int block_size, int num_info_bits, std::vector<int> frozen_bit_positions)
     : polar_decoder_common(
-          block_size, num_info_bits, frozen_bit_positions, std::vector<uint8_t>())
+          block_size, num_info_bits, frozen_bit_positions, std::vector<uint8_t>()),
+      d_llr_vec(block_size * (block_power() + 1)),
+      d_u_hat_vec(block_size * (block_power() + 1)),
+      d_frame_vec(block_size)
 {
-    d_llr_vec = (float*)volk_malloc(sizeof(float) * block_size * (block_power() + 1),
-                                    volk_get_alignment());
-    memset(d_llr_vec, 0, sizeof(float) * block_size * (block_power() + 1));
-    d_u_hat_vec = (unsigned char*)volk_malloc(block_size * (block_power() + 1),
-                                              volk_get_alignment());
-    memset(d_u_hat_vec, 0, sizeof(unsigned char) * block_size * (block_power() + 1));
-    d_frame_vec = (unsigned char*)volk_malloc(block_size, volk_get_alignment());
-    memset(d_frame_vec, 0, sizeof(unsigned char) * block_size);
 }
 
-polar_decoder_sc_systematic::~polar_decoder_sc_systematic()
-{
-    volk_free(d_llr_vec);
-    volk_free(d_u_hat_vec);
-    volk_free(d_frame_vec);
-}
+polar_decoder_sc_systematic::~polar_decoder_sc_systematic() {}
 
 void polar_decoder_sc_systematic::generic_work(void* in_buffer, void* out_buffer)
 {
     const float* in = (const float*)in_buffer;
     unsigned char* out = (unsigned char*)out_buffer;
 
-    initialize_decoder(d_u_hat_vec, d_llr_vec, in);
-    sc_decode(d_llr_vec, d_u_hat_vec);
-    volk_encode_block(d_frame_vec, d_u_hat_vec);
-    extract_info_bits_reversed(out, d_frame_vec);
+    initialize_decoder(d_u_hat_vec.data(), d_llr_vec.data(), in);
+    sc_decode(d_llr_vec.data(), d_u_hat_vec.data());
+    volk_encode_block(d_frame_vec.data(), d_u_hat_vec.data());
+    extract_info_bits_reversed(out, d_frame_vec.data());
 }
 
 void polar_decoder_sc_systematic::sc_decode(float* llrs, unsigned char* u)
diff --git a/gr-fec/lib/polar_encoder.cc b/gr-fec/lib/polar_encoder.cc
index 568a0b8e5e..84633ec893 100644
--- a/gr-fec/lib/polar_encoder.cc
+++ b/gr-fec/lib/polar_encoder.cc
@@ -25,6 +25,19 @@ namespace gr {
 namespace fec {
 namespace code {
 
+volk::vector<unsigned char> polar_encoder::make_prototype() const
+{
+    volk::vector<unsigned char> proto(block_size() >> 3);
+
+    for (unsigned int i = 0; i < d_frozen_bit_positions.size(); i++) {
+        int rev_pos = (int)bit_reverse((long)d_frozen_bit_positions.at(i), block_power());
+        unsigned char frozen_bit = (unsigned char)d_frozen_bit_values.at(i);
+        insert_unpacked_bit_into_packed_array_at_position(
+            proto.data(), frozen_bit, rev_pos);
+    }
+    return proto;
+}
+
 generic_encoder::sptr polar_encoder::make(int block_size,
                                           int num_info_bits,
                                           std::vector<int> frozen_bit_positions,
@@ -41,26 +54,12 @@ polar_encoder::polar_encoder(int block_size,
                              std::vector<uint8_t>& frozen_bit_values,
                              bool is_packed)
     : polar_common(block_size, num_info_bits, frozen_bit_positions, frozen_bit_values),
-      d_is_packed(is_packed)
+      d_is_packed(is_packed),
+      d_frozen_bit_prototype(make_prototype())
 {
-    setup_frozen_bit_inserter();
-}
-
-void polar_encoder::setup_frozen_bit_inserter()
-{
-    d_frozen_bit_prototype =
-        (unsigned char*)volk_malloc(block_size() >> 3, volk_get_alignment());
-    memset(d_frozen_bit_prototype, 0, block_size() >> 3);
-
-    for (unsigned int i = 0; i < d_frozen_bit_positions.size(); i++) {
-        int rev_pos = (int)bit_reverse((long)d_frozen_bit_positions.at(i), block_power());
-        unsigned char frozen_bit = (unsigned char)d_frozen_bit_values.at(i);
-        insert_unpacked_bit_into_packed_array_at_position(
-            d_frozen_bit_prototype, frozen_bit, rev_pos);
-    }
 }
 
-polar_encoder::~polar_encoder() { volk_free(d_frozen_bit_prototype); }
+polar_encoder::~polar_encoder() {}
 
 void polar_encoder::generic_work(void* in_buffer, void* out_buffer)
 {
@@ -129,7 +128,8 @@ void polar_encoder::encode_vector_packed_interbyte(unsigned char* target) const
 void polar_encoder::insert_packed_frozen_bits_and_reverse(
     unsigned char* target, const unsigned char* input) const
 {
-    memcpy(target, d_frozen_bit_prototype, block_size() >> 3);
+    std::copy(
+        std::begin(d_frozen_bit_prototype), std::end(d_frozen_bit_prototype), target);
     const int* info_bit_reversed_positions_ptr = &d_info_bit_positions_reversed[0];
     int bit_num = 0;
     unsigned char byte = *input;
diff --git a/gr-fec/lib/polar_encoder_systematic.cc b/gr-fec/lib/polar_encoder_systematic.cc
index b77f5e0730..ddf898d8b0 100644
--- a/gr-fec/lib/polar_encoder_systematic.cc
+++ b/gr-fec/lib/polar_encoder_systematic.cc
@@ -31,16 +31,12 @@ polar_encoder_systematic::polar_encoder_systematic(int block_size,
                                                    int num_info_bits,
                                                    std::vector<int> frozen_bit_positions)
     : polar_common(
-          block_size, num_info_bits, frozen_bit_positions, std::vector<uint8_t>())
+          block_size, num_info_bits, frozen_bit_positions, std::vector<uint8_t>()),
+      d_volk_syst_intermediate(block_size)
 {
-    d_volk_syst_intermediate = (unsigned char*)volk_malloc(
-        sizeof(unsigned char) * block_size, volk_get_alignment());
 }
 
-polar_encoder_systematic::~polar_encoder_systematic()
-{
-    volk_free(d_volk_syst_intermediate);
-}
+polar_encoder_systematic::~polar_encoder_systematic() {}
 
 void polar_encoder_systematic::generic_work(void* in_buffer, void* out_buffer)
 {
@@ -48,8 +44,8 @@ void polar_encoder_systematic::generic_work(void* in_buffer, void* out_buffer)
     unsigned char* out = (unsigned char*)out_buffer;
 
     volk_encode(out, in);
-    bit_reverse_and_reset_frozen_bits(d_volk_syst_intermediate, out);
-    volk_encode_block(out, d_volk_syst_intermediate);
+    bit_reverse_and_reset_frozen_bits(d_volk_syst_intermediate.data(), out);
+    volk_encode_block(out, d_volk_syst_intermediate.data());
 }
 
 void polar_encoder_systematic::bit_reverse_and_reset_frozen_bits(
diff --git a/gr-fec/lib/scl_list.h b/gr-fec/lib/scl_list.h
index db60b570bc..75eb2fa57f 100644
--- a/gr-fec/lib/scl_list.h
+++ b/gr-fec/lib/scl_list.h
@@ -20,6 +20,9 @@ namespace polar {
 
 struct path {
     path();
+    // Disable copy because of raw pointers.
+    path(const path&) = delete;
+    path& operator=(const path&) = delete;
     ~path();
     float path_metric;
     bool owns_vectors;
@@ -56,6 +59,11 @@ public:
     scl_list(const unsigned int list_size,
              const unsigned int block_size,
              const unsigned int block_power);
+
+    // Disable copy because of raw pointers.
+    scl_list(const scl_list&) = delete;
+    scl_list& operator=(const scl_list&) = delete;
+
     virtual ~scl_list();
     const unsigned int size() const { return d_list_size; };
     const unsigned int active_size() const { return d_active_path_counter; };