1 files changed, 39 insertions, 33 deletions
diff --git a/gr-fec/lib/polar_decoder_sc_list.cc b/gr-fec/lib/polar_decoder_sc_list.cc
index 67b20f216d..1095e9a743 100644
--- a/gr-fec/lib/polar_decoder_sc_list.cc
+++ b/gr-fec/lib/polar_decoder_sc_list.cc
@@ -40,20 +40,18 @@ namespace gr
     generic_decoder::sptr
     polar_decoder_sc_list::make(int max_list_size, int block_size, int num_info_bits,
                                 std::vector<int> frozen_bit_positions,
-                                std::vector<char> frozen_bit_values, bool is_packed)
+                                std::vector<char> frozen_bit_values)
     {
       return generic_decoder::sptr(
           new polar_decoder_sc_list(max_list_size, block_size, num_info_bits, frozen_bit_positions,
-                                    frozen_bit_values, is_packed));
+                                    frozen_bit_values));
     }
 
     polar_decoder_sc_list::polar_decoder_sc_list(int max_list_size, int block_size,
                                                  int num_info_bits,
                                                  std::vector<int> frozen_bit_positions,
-                                                 std::vector<char> frozen_bit_values,
-                                                 bool is_packed) :
-            polar_decoder_common(block_size, num_info_bits, frozen_bit_positions, frozen_bit_values,
-                                 is_packed), d_max_list_size(max_list_size), d_frozen_bit_counter(0)
+                                                 std::vector<char> frozen_bit_values) :
+            polar_decoder_common(block_size, num_info_bits, frozen_bit_positions, frozen_bit_values)
     {
       d_scl = new polar::scl_list(max_list_size, block_size, block_power());
     }
@@ -68,54 +66,62 @@ namespace gr
     {
       const float *in = (const float*) in_buffer;
       unsigned char *out = (unsigned char*) out_buffer;
-      polar::path* init_path = d_scl->initial_path();
-      initialize_llr_vector(init_path->llr_vec, in);
-      memset(init_path->u_vec, 0, sizeof(unsigned char) * block_size() * (block_power() + 1));
-      decode_list();
-      const polar::path* temp = d_scl->optimal_path();
-      extract_info_bits(out, temp->u_vec);
+
+      initialize_list(in);
+      const unsigned char* temp = decode_list();
+      extract_info_bits(out, temp);
     }
 
     void
+    polar_decoder_sc_list::initialize_list(const float* in_buf)
+    {
+      polar::path* init_path = d_scl->initial_path();
+      initialize_decoder(init_path->u_vec, init_path->llr_vec, in_buf);
+    }
+
+    const unsigned char*
     polar_decoder_sc_list::decode_list()
     {
-      d_frozen_bit_counter = 0;
-      for(int i = 0; i < block_size(); i++){
-        calculate_next_llr_in_paths(i);
+      for(int u_num = 0; u_num < block_size(); u_num++){
+        decode_bit(u_num);
       }
-
+      return d_scl->optimal_path()->u_vec;
     }
 
     void
-    polar_decoder_sc_list::calculate_next_llr_in_paths(int u_num)
+    polar_decoder_sc_list::decode_bit(const int u_num)
     {
-      for(unsigned int i = 0; i < d_scl->active_size(); i++){
-        polar::path* current_path = d_scl->next_active_path();
-        calculate_next_llr(current_path, u_num);
-      }
-
-      // 1. if frozen bit, update with known value
-      if(d_frozen_bit_counter < d_frozen_bit_positions.size() && u_num == d_frozen_bit_positions.at(d_frozen_bit_counter)){
-        update_with_frozenbit(u_num);
+      if(u_num % 2 && is_frozen_bit(u_num)){ // LLR value is obsolete. save some time.
+        const unsigned char frozen_bit = next_frozen_bit();
+        d_scl->set_frozen_bit(frozen_bit, u_num);
       }
-      // 2. info bit
       else{
-        d_scl->set_info_bit(u_num);
+        calculate_llrs_for_list(u_num);
+        set_bit_in_list(u_num);
       }
     }
 
     void
-    polar_decoder_sc_list::update_with_frozenbit(const int u_num)
+    polar_decoder_sc_list::calculate_llrs_for_list(const int u_num)
     {
-      unsigned char frozen_bit = d_frozen_bit_values[d_frozen_bit_counter];
-      d_scl->set_frozen_bit(frozen_bit, u_num);
-      d_frozen_bit_counter++;
+      for(unsigned int i = 0; i < d_scl->active_size(); i++){
+        polar::path* current_path = d_scl->next_active_path();
+        butterfly(current_path->llr_vec, current_path->u_vec, 0, u_num, u_num);
+      }
     }
 
     void
-    polar_decoder_sc_list::calculate_next_llr(polar::path* current_path, int u_num)
+    polar_decoder_sc_list::set_bit_in_list(const int u_num)
     {
-      butterfly(current_path->llr_vec, current_path->u_vec, 0, u_num, u_num);
+      // 1. if frozen bit, update with known value
+      if(is_frozen_bit(u_num)){
+        const unsigned char frozen_bit = next_frozen_bit();
+        d_scl->set_frozen_bit(frozen_bit, u_num);
+      }
+      // 2. info bit
+      else{
+        d_scl->set_info_bit(u_num);
+      }
     }
   } /* namespace fec */
 } /* namespace gr */