Merge branch 'pdsch_pusch_bytes' into new_arch

Conflicts:
	srsapps/ue/phy/src/phch_worker.cc

srsapps/ue/mac/src/mux.cc

@@ -211,8 +211,6 @@ uint8_t* mux::pdu_get(uint8_t *payload, uint32_t pdu_sz)
     while (allocate_sdu(lchid_sorted[i], &pdu_msg));   
   }
 
-  pthread_mutex_unlock(&mutex);
-
   bool send_bsr = bsr_procedure->generate_bsr_on_ul_grant(pdu_msg.rem_size(), &bsr);
   // Insert Padding BSR if not inserted Regular/Periodic BSR 
   if (!bsr_payload_sz && send_bsr) {
@@ -232,6 +230,7 @@ uint8_t* mux::pdu_get(uint8_t *payload, uint32_t pdu_sz)
   /* Generate MAC PDU and save to buffer */
   uint8_t *ret = pdu_msg.write_packet();   
   
+  pthread_mutex_unlock(&mutex);
 
   return ret; 
 }
@@ -277,6 +276,18 @@ bool mux::allocate_sdu(uint32_t lcid, sch_pdu *pdu_msg, int max_sdu_sz, uint32_t
           }
                     
           Info("Allocated SDU lcid=%d nbytes=%d, buffer_state=%d\n", lcid, sdu_len, buffer_state);
+          /*
+          char str[64];
+          int len = 10; 
+          if (len > sdu_len) {
+            len = sdu_len; 
+          }
+          uint8_t *x=pdu_msg->get()->get_sdu_ptr();
+          for (int i=0;i<len;i++) {
+            sprintf(str, "0x%x, ", x[i]);
+          }
+          Info("Payload: %s\n", str);
+          */
           return true;               
         } else {
           Info("Could not add SDU rem_size=%d, sdu_len=%d\n", pdu_msg->rem_size(), sdu_len2);

srsapps/ue/phy/include/srsapps/ue/phy/phch_worker.h

@@ -114,9 +114,6 @@ private:
   srslte_timestamp_t tx_time; 
   srslte_uci_data_t  uci_data; 
   uint16_t           ul_rnti;
-
-  // FIXME: THIS IS TEMPORAL. Need to change srslte to accept bits for payload
-  uint8_t payload_bits[64*1024];
   
   // UL configuration parameters 
   srslte_refsignal_srs_cfg_t        srs_cfg;           

srsapps/ue/phy/src/phch_worker.cc

@@ -153,7 +153,8 @@ void phch_worker::work_imp()
       /* Decode PDSCH if instructed to do so */
       dl_ack = dl_action.default_ack; 
       if (dl_action.decode_enabled) {
-        dl_ack = decode_pdsch(&dl_action.phy_grant.dl, dl_action.payload_ptr, dl_action.softbuffer, dl_action.rv, dl_action.rnti);      
+        dl_ack = decode_pdsch(&dl_action.phy_grant.dl, dl_action.payload_ptr, 
+                              dl_action.softbuffer, dl_action.rv, dl_action.rnti);      
       }
       if (dl_action.generate_ack_callback && dl_action.decode_enabled) {
         phy->mac->tb_decoded(dl_ack, dl_mac_grant.rnti_type, dl_mac_grant.pid);
@@ -303,10 +304,8 @@ bool phch_worker::decode_pdsch(srslte_ra_dl_grant_t *grant, uint8_t *payload,
     if (ue_dl.pdsch_cfg.grant.mcs.mod > 0 && ue_dl.pdsch_cfg.grant.mcs.tbs >= 0) {
       
       if (srslte_pdsch_decode_rnti(&ue_dl.pdsch, &ue_dl.pdsch_cfg, softbuffer, ue_dl.sf_symbols, 
-                                    ue_dl.ce, 0, rnti, payload_bits) == 0) 
+                                    ue_dl.ce, 0, rnti, payload) == 0) 
       {
-        // FIXME: TEMPORAL
-        srslte_bit_unpack_vector(payload_bits, payload, grant->mcs.tbs);
         Debug("TB decoded OK\n");
         return true; 
       } else {
@@ -465,11 +464,8 @@ void phch_worker::encode_pusch(srslte_ra_ul_grant_t *grant, uint8_t *payload, ui
     Error("Configuring UL grant\n");
   }
     
-  // FIXME: TEMPORAL
-  srslte_bit_pack_vector(payload, payload_bits, grant->mcs.tbs);
-    
   if (srslte_ue_ul_pusch_encode_rnti_softbuffer(&ue_ul, 
-                                                payload_bits, uci_data, 
+                                                payload, uci_data, 
                                                 softbuffer,
                                                 rnti, 
                                                 signal_buffer)) 

srsapps/ue/phy/test/ue_itf_test_prach.cc

@@ -190,7 +190,7 @@ void config_phy() {
   my_phy.set_param(srslte::ue::phy_interface_params::PUCCH_N_RB_2, 2);
 
   my_phy.configure_ul_params();
-
+  my_phy.configure_prach_params();
 }
 
 srslte_softbuffer_rx_t softbuffer_rx; 

srslte/examples/pdsch_ue.c

@@ -223,7 +223,7 @@ void parse_args(prog_args_t *args, int argc, char **argv) {
 /**********************************************************************/
 
 /* TODO: Do something with the output data */
-uint8_t data[20000], data_packed[20000];
+uint8_t data[20000];
 
 bool go_exit = false; 
 
@@ -458,9 +458,10 @@ int main(int argc, char **argv) {
           }
           if (decode_pdsch) {
             if (prog_args.rnti != SRSLTE_SIRNTI) {
-              n = srslte_ue_dl_decode(&ue_dl, &sf_buffer[prog_args.time_offset], data_packed, srslte_ue_sync_get_sfidx(&ue_sync));
+              n = srslte_ue_dl_decode(&ue_dl, &sf_buffer[prog_args.time_offset], data, srslte_ue_sync_get_sfidx(&ue_sync));
             } else {
-              n = srslte_ue_dl_decode_rnti_rv(&ue_dl, &sf_buffer[prog_args.time_offset], data_packed, srslte_ue_sync_get_sfidx(&ue_sync), 
+              n = srslte_ue_dl_decode_rnti_rv(&ue_dl, &sf_buffer[prog_args.time_offset], data, 
+                                              srslte_ue_sync_get_sfidx(&ue_sync), 
                                               SRSLTE_SIRNTI, ((int) ceilf((float)3*(((sfn)/2)%4)/2))%4);             
             }
             if (n < 0) {
@@ -468,7 +469,6 @@ int main(int argc, char **argv) {
             } else if (n > 0) {
               /* Send data if socket active */
               if (prog_args.net_port > 0) {
-                srslte_bit_unpack_vector(data_packed, data, n);
                 srslte_netsink_write(&net_sink, data, 1+(n-1)/8);
               }
               

srslte/include/srslte/fec/crc.h

@@ -42,13 +42,12 @@
 #include <stdint.h>
 
 typedef struct SRSLTE_API {
-  unsigned long table[256];
+  uint64_t table[256];
-  uint8_t byte;
   int polynom;
   int order;
-  unsigned long crcinit; 
+  uint64_t crcinit; 
-  unsigned long crcmask;
+  uint64_t crcmask;
-  unsigned long crchighbit;
+  uint64_t crchighbit;
   uint32_t srslte_crc_out;
 } srslte_crc_t;
 
@@ -57,11 +56,19 @@ SRSLTE_API int srslte_crc_init(srslte_crc_t *h,
                                int srslte_crc_order);
 
 SRSLTE_API int srslte_crc_set_init(srslte_crc_t *h, 
-                                   unsigned long srslte_crc_init_value);
+                                   uint64_t srslte_crc_init_value);
 
-SRSLTE_API void srslte_crc_attach(srslte_crc_t *h, 
+SRSLTE_API uint32_t srslte_crc_attach(srslte_crc_t *h, 
-                                  uint8_t *data, 
+                                      uint8_t *data, 
-                                  int len);
+                                      int len);
+
+SRSLTE_API uint32_t srslte_crc_attach_byte(srslte_crc_t *h, 
+                                           uint8_t *data, 
+                                           int len); 
+
+SRSLTE_API uint32_t srslte_crc_checksum_byte(srslte_crc_t *h, 
+                                             uint8_t *data, 
+                                             int len); 
 
 SRSLTE_API uint32_t srslte_crc_checksum(srslte_crc_t *h, 
                                         uint8_t *data, 

srslte/include/srslte/fec/turbodecoder.h

@@ -85,6 +85,10 @@ SRSLTE_API void srslte_tdec_decision(srslte_tdec_t * h,
                                      uint8_t *output, 
                                      uint32_t long_cb);
 
+SRSLTE_API void srslte_tdec_decision_byte(srslte_tdec_t * h, 
+                                          uint8_t *output, 
+                                          uint32_t long_cb); 
+
 SRSLTE_API int srslte_tdec_run_all(srslte_tdec_t * h, 
                                    srslte_llr_t * input, 
                                    uint8_t *output,

srslte/include/srslte/phch/sch.h

@@ -65,6 +65,7 @@ typedef struct SRSLTE_API {
   
   /* buffers */
   uint8_t *cb_in; 
+  uint8_t *cb_temp; 
   void *cb_out;  
   void *e;
   

srslte/lib/common/src/sequence.c

@@ -31,6 +31,7 @@
 #include <assert.h>
 
 #include "srslte/common/sequence.h"
+#include "srslte/utils/vector.h"
 
 #define Nc 1600
 
@@ -88,7 +89,7 @@ int srslte_sequence_init(srslte_sequence_t *q, uint32_t len) {
     free(q->c);
   }
   if (!q->c) {
-    q->c = malloc(len * sizeof(uint8_t));
+    q->c = srslte_vec_malloc(len * sizeof(uint8_t));
     if (!q->c) {
       return SRSLTE_ERROR;
     }

srslte/lib/fec/src/crc.c

@@ -35,10 +35,10 @@
 void gen_crc_table(srslte_crc_t *h) {
 
   int i, j, ord = (h->order - 8);
-  unsigned long bit, crc;
+  uint64_t bit, crc;
 
   for (i = 0; i < 256; i++) {
-    crc = ((unsigned long) i) << ord;
+    crc = ((uint64_t) i) << ord;
     for (j = 0; j < 8; j++) {
       bit = crc & h->crchighbit;
       crc <<= 1;
@@ -49,21 +49,20 @@ void gen_crc_table(srslte_crc_t *h) {
   }
 }
 
-unsigned long crctable(srslte_crc_t *h) {
+uint64_t crctable(srslte_crc_t *h, uint8_t byte) {
 
   // Polynom order 8, 16, 24 or 32 only.
   int ord = h->order - 8;
-  unsigned long crc = h->crcinit;
+  uint64_t crc = h->crcinit;
-  uint8_t byte = h->byte;
 
   crc = (crc << 8) ^ h->table[((crc >> (ord)) & 0xff) ^ byte];
   h->crcinit = crc;
   return (crc  & h->crcmask);
 }
 
-unsigned long reversecrcbit(uint32_t crc, int nbits, srslte_crc_t *h) {
+uint64_t reversecrcbit(uint32_t crc, int nbits, srslte_crc_t *h) {
 
-  unsigned long m, rmask = 0x1;
+  uint64_t m, rmask = 0x1;
 
   for (m = 0; m < nbits; m++) {
     if ((rmask & crc) == 0x01)
@@ -74,7 +73,7 @@ unsigned long reversecrcbit(uint32_t crc, int nbits, srslte_crc_t *h) {
   return (crc & h->crcmask);
 }
 
-int srslte_crc_set_init(srslte_crc_t *crc_par, unsigned long crc_init_value) {
+int srslte_crc_set_init(srslte_crc_t *crc_par, uint64_t crc_init_value) {
 
   crc_par->crcinit = crc_init_value;
   if (crc_par->crcinit != (crc_par->crcinit & crc_par->crcmask)) {
@@ -92,9 +91,8 @@ int srslte_crc_init(srslte_crc_t *h, uint32_t crc_poly, int crc_order) {
   h->crcinit = 0x00000000;
 
   // Compute bit masks for whole CRC and CRC high bit
-  h->crcmask = ((((unsigned long) 1 << (h->order - 1)) - 1) << 1)
+  h->crcmask = ((((uint64_t) 1 << (h->order - 1)) - 1) << 1) | 1;
-      | 1;
+  h->crchighbit = (uint64_t) 1 << (h->order - 1);
-  h->crchighbit = (unsigned long) 1 << (h->order - 1);
 
   // check parameters
   if (h->order % 8 != 0) {
@@ -131,15 +129,16 @@ uint32_t srslte_crc_checksum(srslte_crc_t *h, uint8_t *data, int len) {
   // Calculate CRC
   for (i = 0; i < len8 + a; i++) {
     pter = (uint8_t *) (data + 8 * i);
+    uint8_t byte;
     if (i == len8) {
-      h->byte = 0x00;
+      byte = 0x00;
       for (k = 0; k < res8; k++) {
-        h->byte |= ((uint8_t) *(pter + k)) << (7 - k);
+        byte |= ((uint8_t) *(pter + k)) << (7 - k);
       }
     } else {
-      h->byte = (uint8_t) (srslte_bit_unpack(&pter, 8) & 0xFF);
+      byte = (uint8_t) (srslte_bit_unpack(&pter, 8) & 0xFF);
     }
-    crc = crctable(h);
+    crc = crctable(h, byte);
   }
 
   // Reverse CRC res8 positions
@@ -152,14 +151,41 @@ uint32_t srslte_crc_checksum(srslte_crc_t *h, uint8_t *data, int len) {
 
 }
 
+// len is multiple of 8
+uint32_t srslte_crc_checksum_byte(srslte_crc_t *h, uint8_t *data, int len) {
+  int i;
+  uint32_t crc = 0;
+
+  srslte_crc_set_init(h, 0);
+
+  // Calculate CRC
+  for (i = 0; i < len/8; i++) {
+    crc = crctable(h, data[i]);
+  }
+
+  return crc;
+
+}
+
+uint32_t srslte_crc_attach_byte(srslte_crc_t *h, uint8_t *data, int len) {
+  uint32_t checksum = srslte_crc_checksum_byte(h, data, len);
+
+  // Add CRC
+  for (int i=0;i<h->order/8;i++) {
+    data[len/8+(h->order/8-i-1)] = (checksum&(0xff<<(8*i)))>>(8*i);
+  }
+  return checksum;
+}
+
 /** Appends crc_order checksum bits to the buffer data.
  * The buffer data must be len + crc_order bytes
  */
-void srslte_crc_attach(srslte_crc_t *h, uint8_t *data, int len) {
+uint32_t srslte_crc_attach(srslte_crc_t *h, uint8_t *data, int len) {
   uint32_t checksum = srslte_crc_checksum(h, data, len);
 
   // Add CRC
   uint8_t *ptr = &data[len];
   srslte_bit_pack(checksum, &ptr, h->order);
+  return checksum;
 }
 

srslte/lib/fec/src/rm_turbo.c

@@ -70,8 +70,8 @@ int srslte_rm_turbo_tx(uint8_t *w_buff, uint32_t w_buff_len, uint8_t *input, uin
   K_p = nrows * NCOLS;
   if (3 * K_p > w_buff_len) {
     fprintf(stderr,
-        "Input too large. Max input length including dummy bits is %d (3x%dx32, in_len %d)\n",
+        "Input too large. Max input length including dummy bits is %d (3x%dx32, in_len %d, Kp=%d)\n",
-        w_buff_len, nrows, in_len);
+        w_buff_len, nrows, in_len, K_p);
     return -1;
   }
 

srslte/lib/fec/src/softbuffer.c

@@ -63,7 +63,7 @@ int srslte_softbuffer_rx_init(srslte_softbuffer_rx_t *q, uint32_t nof_prb) {
       }
       
       // FIXME: Use HARQ buffer limitation based on UE category
-      q->buff_size = 3 * (SRSLTE_TCOD_MAX_LEN_CB+24);
+      q->buff_size = 18600;
       for (uint32_t i=0;i<q->max_cb;i++) {
         q->buffer_f[i] = srslte_vec_malloc(sizeof(float) * q->buff_size);
         if (!q->buffer_f[i]) {
@@ -137,7 +137,7 @@ int srslte_softbuffer_tx_init(srslte_softbuffer_tx_t *q, uint32_t nof_prb) {
       }
      
       // FIXME: Use HARQ buffer limitation based on UE category
-      q->buff_size = 3 * SRSLTE_TCOD_MAX_LEN_CB;
+      q->buff_size = 18600;
       for (uint32_t i=0;i<q->max_cb;i++) {
         q->buffer_b[i] = srslte_vec_malloc(sizeof(float) * q->buff_size);
         if (!q->buffer_b[i]) {

srslte/lib/fec/src/turbodecoder.c

@@ -334,6 +334,20 @@ void srslte_tdec_decision(srslte_tdec_t * h, uint8_t *output, uint32_t long_cb)
   }
 }
 
+void srslte_tdec_decision_byte(srslte_tdec_t * h, uint8_t *output, uint32_t long_cb)
+{
+  uint32_t i, j;
+  // long_cb is always byte aligned
+  for (i = 0; i < long_cb/8; i++) {
+    output[i] = 0; 
+    for (j=0;j<8;j++) {
+      if (h->llr2[h->interleaver.reverse[8*i+j]] > 0) {
+        output[i] |= 1<<(7-j);
+      }
+    }
+  }
+}
+
 int srslte_tdec_run_all(srslte_tdec_t * h, srslte_llr_t * input, uint8_t *output,
                   uint32_t nof_iterations, uint32_t long_cb)
 {

srslte/lib/phch/src/dci.c

@@ -179,7 +179,7 @@ int srslte_dci_msg_to_ul_grant(srslte_dci_msg_t *msg, uint32_t nof_prb,
     if (srslte_dci_msg_unpack_pusch(msg, ul_dci, nof_prb)) {
       return ret;
     } 
-    
+
     if (srslte_ra_ul_dci_to_grant(ul_dci, nof_prb, n_rb_ho, grant)) {
       fprintf(stderr, "Error computing resource allocation\n");
       return ret;
@@ -340,6 +340,7 @@ int dci_format0_pack(srslte_ra_ul_dci_t *data, srslte_dci_msg_t *msg, uint32_t n
   } else {
     riv = data->type2_alloc.riv;
   }
+
   srslte_bit_pack(riv, &y, riv_nbits(nof_prb) - n_ul_hop);
 
   /* pack MCS according to 8.6.1 of 36.213 */

srslte/lib/phch/src/sch.c

@@ -111,6 +111,10 @@ int srslte_sch_init(srslte_sch_t *q) {
     if (!q->cb_in) {
       goto clean;
     }
+    q->cb_temp = srslte_vec_malloc(sizeof(uint8_t) * SRSLTE_TCOD_MAX_LEN_CB);
+    if (!q->cb_temp) {
+      goto clean;
+    }
     
     q->cb_out = srslte_vec_malloc(sizeof(float) * (3 * SRSLTE_TCOD_MAX_LEN_CB + 12));
     if (!q->cb_out) {
@@ -133,6 +137,9 @@ void srslte_sch_free(srslte_sch_t *q) {
   if (q->cb_in) {
     free(q->cb_in);
   }
+  if (q->cb_temp) {
+    free(q->cb_temp);
+  }
   if (q->cb_out) {
     free(q->cb_out);
   }
@@ -161,8 +168,7 @@ static int encode_tb(srslte_sch_t *q,
                      uint32_t Qm, uint32_t rv, uint32_t nof_e_bits,  
                      uint8_t *data, uint8_t *e_bits) 
 {
-  uint8_t parity[24];
+  uint8_t parity[3] = {0, 0, 0};
-  uint8_t *p_parity = parity;
   uint32_t par;
   uint32_t i;
   uint32_t cb_len, rp, wp, rlen, F, n_e;
@@ -182,17 +188,20 @@ static int encode_tb(srslte_sch_t *q,
     }
 
     if (data) {
+
       /* Compute transport block CRC */
-      par = srslte_crc_checksum(&q->crc_tb, data, cb_segm->tbs);
+      par = srslte_crc_checksum_byte(&q->crc_tb, data, cb_segm->tbs);
 
       /* parity bits will be appended later */
-      srslte_bit_pack(par, &p_parity, 24);
+      parity[0] = (par&(0xff<<16))>>16;
+      parity[1] = (par&(0xff<<8))>>8;
+      parity[2] = par&0xff;
 
       if (SRSLTE_VERBOSE_ISDEBUG()) {
         DEBUG("DATA: ", 0);
-        srslte_vec_fprint_b(stdout, data, cb_segm->tbs);
+        srslte_vec_fprint_byte(stdout, data, cb_segm->tbs/8);
         DEBUG("PARITY: ", 0);
-        srslte_vec_fprint_b(stdout, parity, 24);
+        srslte_vec_fprint_byte(stdout, parity, 3);
       }      
     }
     
@@ -230,33 +239,41 @@ static int encode_tb(srslte_sch_t *q,
         /* Copy data to another buffer, making space for the Codeblock CRC */
         if (i < cb_segm->C - 1) {
           // Copy data 
-          memcpy(&q->cb_in[F], &data[rp], (rlen - F) * sizeof(uint8_t));
+          memcpy(&q->cb_in[F/8], &data[rp/8], (rlen - F) * sizeof(uint8_t)/8);
         } else {
           INFO("Last CB, appending parity: %d from %d and 24 to %d\n",
               rlen - F - 24, rp, rlen - 24);
+          
           /* Append Transport Block parity bits to the last CB */
-          memcpy(&q->cb_in[F], &data[rp], (rlen - 24 - F) * sizeof(uint8_t));
+          memcpy(&q->cb_in[F/8], &data[rp/8], (rlen - 24 - F) * sizeof(uint8_t)/8);
-          memcpy(&q->cb_in[rlen - 24], parity, 24 * sizeof(uint8_t));
+          memcpy(&q->cb_in[(rlen - 24)/8], parity, 3 * sizeof(uint8_t));
         }        
+        
         /* Filler bits are treated like zeros for the CB CRC calculation */
-        for (int j = 0; j < F; j++) {
+        for (int j = 0; j < F/8; j++) {
           q->cb_in[j] = 0;
         }
+        
         /* Attach Codeblock CRC */
         if (cb_segm->C > 1) {
-          srslte_crc_attach(&q->crc_cb, q->cb_in, rlen);
+          srslte_crc_attach_byte(&q->crc_cb, q->cb_in, rlen);
         }
+        
+        /* pack bits to temporal buffer for encoding */
+        srslte_bit_pack_vector(q->cb_in, q->cb_temp, cb_len);
+
         /* Set the filler bits to <NULL> */
         for (int j = 0; j < F; j++) {
-          q->cb_in[j] = SRSLTE_TX_NULL;
+          q->cb_temp[j] = SRSLTE_TX_NULL;
         }
+        
         if (SRSLTE_VERBOSE_ISDEBUG()) {
           DEBUG("CB#%d: ", i);
-          srslte_vec_fprint_b(stdout, q->cb_in, cb_len);
+          srslte_vec_fprint_hex(stdout, q->cb_temp, cb_len);
         }
-
+        
         /* Turbo Encoding */
-        srslte_tcod_encode(&q->encoder, q->cb_in, (uint8_t*) q->cb_out, cb_len);
+        srslte_tcod_encode(&q->encoder, q->cb_temp, (uint8_t*) q->cb_out, cb_len);
         if (SRSLTE_VERBOSE_ISDEBUG()) {
           DEBUG("CB#%d encoded: ", i);
           srslte_vec_fprint_b(stdout, q->cb_out, cb_len);
@@ -291,8 +308,7 @@ static int decode_tb(srslte_sch_t *q,
                      uint32_t Qm, uint32_t rv, uint32_t nof_e_bits, 
                      float *e_bits, uint8_t *data) 
 {
-  uint8_t parity[24];
+  uint8_t parity[3] = {0, 0, 0};
-  uint8_t *p_parity = parity;
   uint32_t par_rx, par_tx;
   uint32_t i;
   uint32_t cb_len, rp, wp, rlen, F, n_e;
@@ -379,14 +395,14 @@ static int decode_tb(srslte_sch_t *q,
           crc_ptr = &q->crc_cb; 
         } else {
           len_crc = cb_segm->tbs+24; 
-          cb_in_ptr = &q->cb_in[F];
+          cb_in_ptr = &q->cb_in[F/8];
           crc_ptr = &q->crc_tb; 
         }
 
-        srslte_tdec_decision(&q->decoder, q->cb_in, cb_len);
+        srslte_tdec_decision_byte(&q->decoder, q->cb_in, cb_len);
-  
+                  
         /* Check Codeblock CRC and stop early if incorrect */
-        if (!srslte_crc_checksum(crc_ptr, cb_in_ptr, len_crc)) {
+        if (!srslte_crc_checksum_byte(crc_ptr, cb_in_ptr, len_crc)) {
           early_stop = true;           
         }
         
@@ -395,21 +411,25 @@ static int decode_tb(srslte_sch_t *q,
 
       if (SRSLTE_VERBOSE_ISDEBUG()) {
         DEBUG("CB#%d IN: ", i);
-        srslte_vec_fprint_b(stdout, q->cb_in, cb_len);
+        srslte_vec_fprint_byte(stdout, q->cb_in, cb_len/8);
       }
             
       // If CB CRC is not correct, early_stop will be false and wont continue with rest of CBs
 
+      if (F%8) {
+        fprintf(stderr, "Fatal Error: Number of filler bits %d is not byte aligned\n", F);
+      }
+      
       /* Copy data to another buffer, removing the Codeblock CRC */
       if (i < cb_segm->C - 1) {
-        memcpy(&data[wp], &q->cb_in[F], (rlen - F) * sizeof(uint8_t));
+        memcpy(&data[wp/8], &q->cb_in[F/8], (rlen - F) * sizeof(uint8_t)/8);
       } else {
         DEBUG("Last CB, appending parity: %d to %d from %d and 24 from %d\n",
             rlen - F - 24, wp, F, rlen - 24);
         
         /* Append Transport Block parity bits to the last CB */
-        memcpy(&data[wp], &q->cb_in[F], (rlen - F - 24) * sizeof(uint8_t));
+        memcpy(&data[wp/8], &q->cb_in[F/8], (rlen - F - 24) * sizeof(uint8_t)/8);
-        memcpy(parity, &q->cb_in[rlen - 24], 24 * sizeof(uint8_t));
+        memcpy(parity, &q->cb_in[(rlen - 24)/8], 24 * sizeof(uint8_t)/8);
       }
 
       /* Set read/write pointers */
@@ -418,17 +438,17 @@ static int decode_tb(srslte_sch_t *q,
     }
 
     if (!early_stop) {
-      INFO("CB %d failed. TB is erroneous.\n",i-1);
+      printf("CB %d failed. TB is erroneous.\n",i-1);
       return SRSLTE_ERROR; 
     } else {
       INFO("END CB#%d: wp: %d, rp: %d\n", i, wp, rp);
 
       // Compute transport block CRC
-      par_rx = srslte_crc_checksum(&q->crc_tb, data, cb_segm->tbs);
+      par_rx = srslte_crc_checksum_byte(&q->crc_tb, data, cb_segm->tbs);
 
       // check parity bits
-      par_tx = srslte_bit_unpack(&p_parity, 24);
+      par_tx = ((uint32_t) parity[0])<<16 | ((uint32_t) parity[1])<<8 | ((uint32_t) parity[2]);
-
+      
       if (!par_rx) {
         INFO("\n\tCAUTION!! Received all-zero transport block\n\n", 0);
       }
@@ -437,7 +457,7 @@ static int decode_tb(srslte_sch_t *q,
         INFO("TB decoded OK\n",i);
         return SRSLTE_SUCCESS;
       } else {
-        INFO("Error in TB parity\n",i);
+        INFO("Error in TB parity: par_tx=0x%x, par_rx=0x%x\n", par_tx, par_rx);
         return SRSLTE_ERROR;
       }
       

srslte/lib/phch/test/CMakeLists.txt

@@ -93,7 +93,7 @@ BuildMex(MEXNAME pdcch SOURCES pdcch_test_mex.c LIBRARIES srslte srslte_mex)
 ADD_EXECUTABLE(pdsch_test pdsch_test.c)
 TARGET_LINK_LIBRARIES(pdsch_test srslte)
 
-ADD_TEST(pdsch_test_bpsk pdsch_test -l 500 -m 1 -n 50 -r 2)
+ADD_TEST(pdsch_test_bpsk pdsch_test -l 504 -m 1 -n 50 -r 2)
 ADD_TEST(pdsch_test_qpsk pdsch_test -l 1000 -m 2 -n 50 -r 1)
 ADD_TEST(pdsch_test_qam16 pdsch_test -l 50000 -m 4 -n 100)
 ADD_TEST(pdsch_test_qam64 pdsch_test -l 61664 -m 6 -n 100 -r 0)

srslte/lib/phch/test/pdsch_test.c

@@ -170,7 +170,7 @@ int main(int argc, char **argv) {
     }
   }
   
-  data = malloc(sizeof(uint8_t) * tbs);
+  data = malloc(sizeof(uint8_t) * tbs/8);
   if (!data) {
     perror("malloc");
     goto quit;
@@ -196,8 +196,8 @@ int main(int argc, char **argv) {
   if (SRSLTE_VERBOSE_ISNONE()) {
     printf("Decoding TBS: %d\r",grant.mcs.tbs);
   }
-  for (i=0;i<grant.mcs.tbs;i++) {
+  for (i=0;i<grant.mcs.tbs/8;i++) {
-    data[i] = rand()%2;
+    data[i] = rand()%256;
   }
 
   for (rv=0;rv<=rv_idx;rv++) {
@@ -228,7 +228,8 @@ int main(int argc, char **argv) {
       ret = -1;
       goto quit;
     } else {
-      printf("DECODED OK in %d:%d (%.2f Mbps)\n", (int) t[0].tv_sec, (int) t[0].tv_usec, (float) grant.mcs.tbs/t[0].tv_usec);                
+      printf("DECODED OK in %d:%d (%.2f Mbps)\n", 
+             (int) t[0].tv_sec, (int) t[0].tv_usec, (float) grant.mcs.tbs/t[0].tv_usec);                
     }
   } 
   ret = 0;

srslte/lib/phch/test/pusch_test.c

@@ -129,17 +129,16 @@ int main(int argc, char **argv) {
     dci.type2_alloc.L_crb = L_prb; 
     dci.type2_alloc.RB_start = n_prb;    
   } else {
-    srslte_ra_type2_from_riv((uint32_t) riv, &dci.type2_alloc.L_crb, &dci.type2_alloc.RB_start, cell.nof_prb, cell.nof_prb);
+    dci.type2_alloc.riv = riv;
   }
   dci.mcs_idx = mcs_idx;
-  srslte_dci_msg_t dci_msg; 
+  
-  srslte_dci_msg_pack_pusch(&dci, &dci_msg, cell.nof_prb);
-
   srslte_ra_ul_grant_t grant; 
-  if (srslte_dci_msg_to_ul_grant(&dci_msg, cell.nof_prb, 0, &dci, &grant)) {
+  if (srslte_ra_ul_dci_to_grant(&dci, cell.nof_prb, 0, &grant)) {
-    return false;   
+    fprintf(stderr, "Error computing resource allocation\n");
+    return ret;
   }
-
+      
   srslte_pusch_hopping_cfg_t ul_hopping; 
   ul_hopping.n_sb = 1; 
   ul_hopping.hopping_offset = 0;
@@ -196,7 +195,7 @@ int main(int argc, char **argv) {
   srslte_ofdm_tx_init(&fft, SRSLTE_CP_NORM, cell.nof_prb);
   srslte_ofdm_set_freq_shift(&fft, 0.5);
   
-  data = malloc(sizeof(uint8_t) * cfg.grant.mcs.tbs);
+  data = srslte_vec_malloc(sizeof(uint8_t) * cfg.grant.mcs.tbs);
   if (!data) {
     perror("malloc");
     goto quit;
@@ -207,7 +206,7 @@ int main(int argc, char **argv) {
   }
 
   gettimeofday(&t[1], NULL);
-  if (srslte_softbuffer_tx_init(&softbuffer, cell.nof_prb)) {
+  if (srslte_softbuffer_tx_init(&softbuffer, 4*cell.nof_prb)) {
     fprintf(stderr, "Error initiating soft buffer\n");
     goto quit;
   }
@@ -235,7 +234,10 @@ int main(int argc, char **argv) {
     ret = -1;
     goto quit;
   } else {
-    printf("ENCODED OK in %d:%d (%.2f Mbps)\n", (int) t[0].tv_sec, (int) t[0].tv_usec, 
+    printf("ENCODED OK in %d:%d (TBS: %d bits, TX: %.2f Mbps, Processing: %.2f Mbps)\n", (int) t[0].tv_sec, 
+           (int) t[0].tv_usec, 
+           cfg.grant.mcs.tbs,
+           (float) cfg.grant.mcs.tbs/1000,
            (float) cfg.grant.mcs.tbs/t[0].tv_usec);
   }
   

srslte/lib/scrambling/src/scrambling.c

@@ -29,6 +29,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
+#include "srslte/utils/vector.h"
 #include "srslte/scrambling/scrambling.h"
 
 void srslte_scrambling_f(srslte_sequence_t *s, float *data) {
@@ -40,7 +41,7 @@ void srslte_scrambling_f_offset(srslte_sequence_t *s, float *data, int offset, i
   assert (len + offset <= s->len);
 
   for (i = 0; i < len; i++) {
-    data[i] = data[i] * (1 - 2 * s->c[i + offset]);
+    data[i] = data[i] * (1-2*s->c[i + offset]);
   }
 }
 
@@ -58,18 +59,35 @@ void srslte_scrambling_c_offset(srslte_sequence_t *s, cf_t *data, int offset, in
 }
 
 void srslte_scrambling_b(srslte_sequence_t *s, uint8_t *data) {
-  int i;
+  srslte_scrambling_b_offset(s, data, 0, s->len);  
-
-  for (i = 0; i < s->len; i++) {
-    data[i] = (data[i] + s->c[i]) % 2;
-  }
 }
 
 void srslte_scrambling_b_offset(srslte_sequence_t *s, uint8_t *data, int offset, int len) {
   int i;
   assert (len + offset <= s->len);
-  for (i = 0; i < len; i++) {
+  // Do XOR on a word basis
-    data[i] = (data[i] + s->c[i + offset]) % 2;
+  if (!(len%8)) {
+    uint64_t *x = (uint64_t*) data; 
+    uint64_t *y = (uint64_t*) &s->c[offset];
+    for (int i=0;i<len/8;i++) {
+      x[i] = (x[i] ^ y[i]);
+    }
+  } else if (!(len%4)) {
+    uint32_t *x = (uint32_t*) data; 
+    uint32_t *y = (uint32_t*) &s->c[offset];
+    for (int i=0;i<len/8;i++) {
+      x[i] = (x[i] ^ y[i]);
+    }
+  } else if (!(len%2)) {
+    uint16_t *x = (uint16_t*) data; 
+    uint16_t *y = (uint16_t*) &s->c[offset];
+    for (int i=0;i<len/8;i++) {
+      x[i] = (x[i] ^ y[i]);
+    }
+  } else {
+    for (i = 0; i < len; i++) {
+      data[i] = (data[i] + s->c[i + offset]) % 2;
+    }
   }
 }
 

srslte/lib/scrambling/test/scrambling_test.c

@@ -40,20 +40,25 @@ char *srslte_sequence_name = NULL;
 bool do_floats = false;
 srslte_cp_t cp = SRSLTE_CP_NORM;
 int cell_id = -1;
+int nof_bits = 100; 
 
 void usage(char *prog) {
   printf("Usage: %s [ef] -c cell_id -s [PBCH, PDSCH, PDCCH, PMCH, PUCCH]\n", prog);
+  printf("\t -l nof_bits [Default %d]\n", nof_bits);
   printf("\t -e CP extended [Default CP Normal]\n");
   printf("\t -f scramble floats [Default bits]\n");
 }
 
 void parse_args(int argc, char **argv) {
   int opt;
-  while ((opt = getopt(argc, argv, "csef")) != -1) {
+  while ((opt = getopt(argc, argv, "csefl")) != -1) {
     switch (opt) {
     case 'c':
       cell_id = atoi(argv[optind]);
       break;
+    case 'l':
+      nof_bits = atoi(argv[optind]);
+      break;
     case 'e':
       cp = SRSLTE_CP_EXT;
       break;
@@ -81,6 +86,8 @@ void parse_args(int argc, char **argv) {
 int init_sequence(srslte_sequence_t *seq, char *name) {
   if (!strcmp(name, "PBCH")) {
     return srslte_sequence_pbch(seq, cp, cell_id);
+  } else if (!strcmp(name, "PDSCH")) {
+    return srslte_sequence_pdsch(seq, 1234, 0, 0, cell_id, nof_bits);
   } else {
     fprintf(stderr, "Unsupported sequence name %s\n", name);
     return -1;
@@ -93,7 +100,8 @@ int main(int argc, char **argv) {
   srslte_sequence_t seq;
   uint8_t *input_b, *scrambled_b;
   float *input_f, *scrambled_f;
-
+  struct timeval t[3];
+  
   parse_args(argc, argv);
 
   if (init_sequence(&seq, srslte_sequence_name) == -1) {
@@ -118,9 +126,14 @@ int main(int argc, char **argv) {
       scrambled_b[i] = input_b[i];
     }
 
+    gettimeofday(&t[1], NULL);
     srslte_scrambling_b(&seq, scrambled_b);
+    gettimeofday(&t[2], NULL);
     srslte_scrambling_b(&seq, scrambled_b);
 
+    get_time_interval(t);
+    printf("Texec=%d us for %d bits\n", t[0].tv_usec, seq.len);
+    
     for (i=0;i<seq.len;i++) {
       if (scrambled_b[i] != input_b[i]) {
         printf("Error in %d\n", i);
@@ -146,9 +159,14 @@ int main(int argc, char **argv) {
       scrambled_f[i] = input_f[i];
     }
 
+    gettimeofday(&t[1], NULL);
     srslte_scrambling_f(&seq, scrambled_f);
+    gettimeofday(&t[2], NULL);
     srslte_scrambling_f(&seq, scrambled_f);
 
+    get_time_interval(t);
+    printf("Texec=%d us for %d bits\n", t[0].tv_usec, seq.len);
+
     for (i=0;i<seq.len;i++) {
       if (scrambled_f[i] != input_f[i]) {
         printf("Error in %d\n", i);