5g-team
/
srsRAN_4G
mirror of https://github.com/pvnis/srsRAN_4G.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Changed until precoding.h

Browse Source
master
ismagom 10 years ago
parent 7eecf5be3b
commit 0d71c911fe
102 changed files with 1096 additions and 988 deletions
Show Stats Download Patch File Download Diff File

2
matlab/tests/rm_turbo_rx_test.m
Unescape Escape View File

@ -26,7 +26,7 @@ for i=1:length(trBlkLenVec)
mat2 = reshape(reshape(mat{1},[],3)',[],1); mat2 = reshape(reshape(mat{1},[],3)',[],1);
out = lteTurboDecode(mat{1}); out = lteTurboDecode(mat{1});
lib=liblte_rm_turbo_rx(double(codeword),trBlkLen,RV); lib=liblte_srslte_rm_turbo_rx(double(codeword),trBlkLen,RV);
[outLib] = liblte_turbodecoder(lib); [outLib] = liblte_turbodecoder(lib);
if (length(trBlkLenVec) == 1) if (length(trBlkLenVec) == 1)

2
scripts/xml2aloe/template/test/test_generate.c
Unescape Escape View File

@ -71,7 +71,7 @@ int generate_input_signal(void *in, int *lengths)
lengths[0] = block_length; lengths[0] = block_length;
for (i=0;i<block_length;i++) { for (i=0;i<block_length;i++) {
#ifdef GENERATE_COMPLEX #ifdef GENESRSLTE_TCOD_RATE_COMPLEX
__real__ input[i] = (float) ((i+offset)%(block_length)); __real__ input[i] = (float) ((i+offset)%(block_length));
__imag__ input[i] = (float) ((block_length-i-1+offset)%(block_length)); __imag__ input[i] = (float) ((block_length-i-1+offset)%(block_length));
#else #else

2
srslte/examples/cell_measurement.c
Unescape Escape View File

@ -120,7 +120,7 @@ int parse_args(prog_args_t *args, int argc, char **argv) {
/* TODO: Do something with the output data */ /* TODO: Do something with the output data */
uint8_t data[10000], data_unpacked[1000]; uint8_t data[10000], data_unpacked[1000];
int cuhd_recv_wrapper(void *h, void *data, uint32_t nsamples, timestamp_t *q) { int cuhd_recv_wrapper(void *h, void *data, uint32_t nsamples, srslte_timestamp_t *q) {
DEBUG(" ---- Receive %d samples ---- \n", nsamples); DEBUG(" ---- Receive %d samples ---- \n", nsamples);
return cuhd_recv(h, data, nsamples, 1); return cuhd_recv(h, data, nsamples, 1);
} }

2
srslte/examples/cell_search.c
Unescape Escape View File

@ -111,7 +111,7 @@ void parse_args(int argc, char **argv) {
} }
} }
int cuhd_recv_wrapper(void *h, void *data, uint32_t nsamples, timestamp_t *t) { int cuhd_recv_wrapper(void *h, void *data, uint32_t nsamples, srslte_timestamp_t *t) {
DEBUG(" ---- Receive %d samples ---- \n", nsamples); DEBUG(" ---- Receive %d samples ---- \n", nsamples);
return cuhd_recv(h, data, nsamples, 1); return cuhd_recv(h, data, nsamples, 1);
} }

2
srslte/examples/cuhd_utils.c
Unescape Escape View File

@ -43,7 +43,7 @@
#ifndef DISABLE_UHD #ifndef DISABLE_UHD
#include "srslte/cuhd/cuhd.h" #include "srslte/cuhd/cuhd.h"
int cuhd_recv_wrapper_cs(void *h, void *data, uint32_t nsamples, timestamp_t *t) { int cuhd_recv_wrapper_cs(void *h, void *data, uint32_t nsamples, srslte_timestamp_t *t) {
DEBUG(" ---- Receive %d samples ---- \n", nsamples); DEBUG(" ---- Receive %d samples ---- \n", nsamples);
return cuhd_recv(h, data, nsamples, 1); return cuhd_recv(h, data, nsamples, 1);
} }

6
srslte/examples/hl_example.c
Unescape Escape View File

@ -38,7 +38,7 @@ void usage(char *arg) {
} }
int main(int argc, char **argv) { int main(int argc, char **argv) {
binsource_hl bs; srslte_binsource_hl bs;
mod_hl mod; mod_hl mod;
srslte_ch_awgn_hl ch; srslte_ch_awgn_hl ch;
demod_soft_hl demod_s; demod_soft_hl demod_s;
@ -86,7 +86,7 @@ int main(int argc, char **argv) {
demod_s.ctrl_in.alg_type = APPROX; demod_s.ctrl_in.alg_type = APPROX;
demod_s.ctrl_in.sigma = var; demod_s.ctrl_in.sigma = var;
if ( binsource_initialize(&bs) || if ( srslte_binsource_initialize(&bs) ||
mod_initialize(&mod) || mod_initialize(&mod) ||
srslte_ch_awgn_initialize(&ch) || srslte_ch_awgn_initialize(&ch) ||
demod_hard_initialize(&demod_h) || demod_hard_initialize(&demod_h) ||
@ -96,7 +96,7 @@ int main(int argc, char **argv) {
exit(-1); exit(-1);
} }
binsource_work(&bs); srslte_binsource_work(&bs);
mod_work(&mod); mod_work(&mod);
srslte_ch_awgn_work(&ch); srslte_ch_awgn_work(&ch);
demod_hard_work(&demod_h); demod_hard_work(&demod_h);

8
srslte/examples/ll_example.c
Unescape Escape View File

@ -32,15 +32,15 @@
#include "srslte/srslte.h" #include "srslte/srslte.h"
int main(int argc, char **argv) { int main(int argc, char **argv) {
binsource_t bs; srslte_binsource_t bs;
uint8_t* output; uint8_t* output;
binsource_init(&bs); srslte_binsource_init(&bs);
binsource_seed_time(&bs); srslte_binsource_seed_time(&bs);
output = malloc(100); output = malloc(100);
if (binsource_generate(&bs,output,100)) { if (srslte_binsource_generate(&bs,output,100)) {
printf("Error generating bits\n"); printf("Error generating bits\n");
exit(-1); exit(-1);
} }

22
srslte/examples/pdsch_enodeb.c
Unescape Escape View File

@ -68,7 +68,7 @@ char *uhd_args = "";
float uhd_amp = 0.03, uhd_gain = 70.0, uhd_freq = 2400000000; float uhd_amp = 0.03, uhd_gain = 70.0, uhd_freq = 2400000000;
bool null_file_sink=false; bool null_file_sink=false;
filesink_t fsink; srslte_filesink_t fsink;
srslte_fft_t ifft; srslte_fft_t ifft;
pbch_t pbch; pbch_t pbch;
pcfich_t pcfich; pcfich_t pcfich;
@ -86,8 +86,8 @@ pthread_t net_thread;
void *net_thread_fnc(void *arg); void *net_thread_fnc(void *arg);
sem_t net_sem; sem_t net_sem;
bool net_packet_ready = false; bool net_packet_ready = false;
netsource_t net_source; srslte_netsource_t net_source;
netsink_t net_sink; srslte_netsink_t net_sink;
int prbset_num = 1, last_prbset_num = 1; int prbset_num = 1, last_prbset_num = 1;
int prbset_orig = 0; int prbset_orig = 0;
@ -177,7 +177,7 @@ void base_init() {
/* open file or USRP */ /* open file or USRP */
if (output_file_name) { if (output_file_name) {
if (strcmp(output_file_name, "NULL")) { if (strcmp(output_file_name, "NULL")) {
if (filesink_init(&fsink, output_file_name, COMPLEX_FLOAT_BIN)) { if (srslte_filesink_init(&fsink, output_file_name, SRSLTE_COMPLEX_FLOAT_BIN)) {
fprintf(stderr, "Error opening file %s\n", output_file_name); fprintf(stderr, "Error opening file %s\n", output_file_name);
exit(-1); exit(-1);
} }
@ -199,12 +199,12 @@ void base_init() {
} }
if (net_port > 0) { if (net_port > 0) {
if (netsource_init(&net_source, "0.0.0.0", net_port, NETSOURCE_TCP)) { if (srslte_netsource_init(&net_source, "0.0.0.0", net_port, SRSLTE_NETSOURCE_TCP)) {
fprintf(stderr, "Error creating input UDP socket at port %d\n", net_port); fprintf(stderr, "Error creating input UDP socket at port %d\n", net_port);
exit(-1); exit(-1);
} }
if (null_file_sink) { if (null_file_sink) {
if (netsink_init(&net_sink, "127.0.0.1", net_port+1, NETSINK_TCP)) { if (srslte_netsink_init(&net_sink, "127.0.0.1", net_port+1, SRSLTE_NETSINK_TCP)) {
fprintf(stderr, "Error sink\n"); fprintf(stderr, "Error sink\n");
exit(-1); exit(-1);
} }
@ -277,7 +277,7 @@ void base_free() {
} }
if (output_file_name) { if (output_file_name) {
if (!null_file_sink) { if (!null_file_sink) {
filesink_free(&fsink); srslte_filesink_free(&fsink);
} }
} else { } else {
#ifndef DISABLE_UHD #ifndef DISABLE_UHD
@ -286,7 +286,7 @@ void base_free() {
} }
if (net_port > 0) { if (net_port > 0) {
netsource_free(&net_source); srslte_netsource_free(&net_source);
sem_close(&net_sem); sem_close(&net_sem);
} }
} }
@ -408,7 +408,7 @@ void *net_thread_fnc(void *arg) {
int rpm = 0, wpm=0; int rpm = 0, wpm=0;
do { do {
n = netsource_read(&net_source, &data_unpacked[rpm], DATA_BUFF_SZ-rpm); n = srslte_netsource_read(&net_source, &data_unpacked[rpm], DATA_BUFF_SZ-rpm);
if (n > 0) { if (n > 0) {
int nbytes = 1+(ra_dl.mcs.tbs-1)/8; int nbytes = 1+(ra_dl.mcs.tbs-1)/8;
rpm += n; rpm += n;
@ -578,7 +578,7 @@ int main(int argc, char **argv) {
if (net_port > 0 && net_packet_ready) { if (net_port > 0 && net_packet_ready) {
if (null_file_sink) { if (null_file_sink) {
bit_unpack_vector(data, data_tmp, ra_dl.mcs.tbs); bit_unpack_vector(data, data_tmp, ra_dl.mcs.tbs);
if (netsink_write(&net_sink, data_tmp, 1+(ra_dl.mcs.tbs-1)/8) < 0) { if (srslte_netsink_write(&net_sink, data_tmp, 1+(ra_dl.mcs.tbs-1)/8) < 0) {
fprintf(stderr, "Error sending data through UDP socket\n"); fprintf(stderr, "Error sending data through UDP socket\n");
} }
} }
@ -596,7 +596,7 @@ int main(int argc, char **argv) {
/* send to file or usrp */ /* send to file or usrp */
if (output_file_name) { if (output_file_name) {
if (!null_file_sink) { if (!null_file_sink) {
filesink_write(&fsink, output_buffer, sf_n_samples); srslte_filesink_write(&fsink, output_buffer, sf_n_samples);
} }
usleep(1000); usleep(1000);
} else { } else {

16
srslte/examples/pdsch_ue.c
Unescape Escape View File

@ -208,7 +208,7 @@ void sig_int_handler(int signo)
} }
#ifndef DISABLE_UHD #ifndef DISABLE_UHD
int cuhd_recv_wrapper(void *h, void *data, uint32_t nsamples, timestamp_t *t) { int cuhd_recv_wrapper(void *h, void *data, uint32_t nsamples, srslte_timestamp_t *t) {
DEBUG(" ---- Receive %d samples ---- \n", nsamples); DEBUG(" ---- Receive %d samples ---- \n", nsamples);
return cuhd_recv(h, data, nsamples, 1); return cuhd_recv(h, data, nsamples, 1);
} }
@ -224,7 +224,7 @@ prog_args_t prog_args;
uint32_t sfn = 0; // system frame number uint32_t sfn = 0; // system frame number
cf_t *sf_buffer = NULL; cf_t *sf_buffer = NULL;
netsink_t net_sink, net_sink_signal; srslte_netsink_t net_sink, net_sink_signal;
int main(int argc, char **argv) { int main(int argc, char **argv) {
int ret; int ret;
@ -242,18 +242,18 @@ int main(int argc, char **argv) {
parse_args(&prog_args, argc, argv); parse_args(&prog_args, argc, argv);
if (prog_args.net_port > 0) { if (prog_args.net_port > 0) {
if (netsink_init(&net_sink, prog_args.net_address, prog_args.net_port, NETSINK_TCP)) { if (srslte_netsink_init(&net_sink, prog_args.net_address, prog_args.net_port, SRSLTE_NETSINK_TCP)) {
fprintf(stderr, "Error initiating UDP socket to %s:%d\n", prog_args.net_address, prog_args.net_port); fprintf(stderr, "Error initiating UDP socket to %s:%d\n", prog_args.net_address, prog_args.net_port);
exit(-1); exit(-1);
} }
netsink_set_nonblocking(&net_sink); srslte_netsink_set_nonblocking(&net_sink);
} }
if (prog_args.net_port_signal > 0) { if (prog_args.net_port_signal > 0) {
if (netsink_init(&net_sink_signal, prog_args.net_address_signal, prog_args.net_port_signal, NETSINK_UDP)) { if (srslte_netsink_init(&net_sink_signal, prog_args.net_address_signal, prog_args.net_port_signal, SRSLTE_NETSINK_UDP)) {
fprintf(stderr, "Error initiating UDP socket to %s:%d\n", prog_args.net_address_signal, prog_args.net_port_signal); fprintf(stderr, "Error initiating UDP socket to %s:%d\n", prog_args.net_address_signal, prog_args.net_port_signal);
exit(-1); exit(-1);
} }
netsink_set_nonblocking(&net_sink_signal); srslte_netsink_set_nonblocking(&net_sink_signal);
} }
#ifndef DISABLE_UHD #ifndef DISABLE_UHD
@ -409,7 +409,7 @@ int main(int argc, char **argv) {
/* Send data if socket active */ /* Send data if socket active */
if (prog_args.net_port > 0) { if (prog_args.net_port > 0) {
bit_unpack_vector(data_packed, data, n); bit_unpack_vector(data_packed, data, n);
netsink_write(&net_sink, data, 1+(n-1)/8); srslte_netsink_write(&net_sink, data, 1+(n-1)/8);
} }
} }
nof_trials++; nof_trials++;
@ -563,7 +563,7 @@ void *plot_thread_run(void *arg) {
if (plot_sf_idx == 1) { if (plot_sf_idx == 1) {
if (prog_args.net_port_signal > 0) { if (prog_args.net_port_signal > 0) {
netsink_write(&net_sink_signal, &sf_buffer[ue_sync_sf_len(&ue_sync)/7], srslte_netsink_write(&net_sink_signal, &sf_buffer[ue_sync_sf_len(&ue_sync)/7],
ue_sync_sf_len(&ue_sync)); ue_sync_sf_len(&ue_sync));
} }
} }

32
srslte/examples/prach_ue.c
Unescape Escape View File

@ -173,7 +173,7 @@ void sig_int_handler(int signo)
} }
} }
int cuhd_recv_wrapper_timed(void *h, void *data, uint32_t nsamples, timestamp_t *uhd_time) { int cuhd_recv_wrapper_timed(void *h, void *data, uint32_t nsamples, srslte_timestamp_t *uhd_time) {
DEBUG(" ---- Receive %d samples ---- \n", nsamples); DEBUG(" ---- Receive %d samples ---- \n", nsamples);
return cuhd_recv_with_time(h, data, nsamples, true, &uhd_time->full_secs, &uhd_time->frac_secs); return cuhd_recv_with_time(h, data, nsamples, true, &uhd_time->full_secs, &uhd_time->frac_secs);
} }
@ -301,8 +301,8 @@ int main(int argc, char **argv) {
rar_msg_t rar_msg; rar_msg_t rar_msg;
ra_pusch_t ra_pusch; ra_pusch_t ra_pusch;
uint32_t rar_window_start = 0, rar_trials = 0, rar_window_stop = 0; uint32_t rar_window_start = 0, rar_trials = 0, rar_window_stop = 0;
timestamp_t uhd_time; srslte_timestamp_t uhd_time;
timestamp_t next_tx_time; srslte_timestamp_t next_tx_time;
const uint8_t conn_request_msg[] = {0x20, 0x06, 0x1F, 0x5C, 0x2C, 0x04, 0xB2, 0xAC, 0xF6, 0x00, 0x00, 0x00}; const uint8_t conn_request_msg[] = {0x20, 0x06, 0x1F, 0x5C, 0x2C, 0x04, 0xB2, 0xAC, 0xF6, 0x00, 0x00, 0x00};
uint8_t data[1000]; uint8_t data[1000];
cf_t *prach_buffer; cf_t *prach_buffer;
@ -399,7 +399,7 @@ int main(int argc, char **argv) {
bzero(&drms_cfg, sizeof(srslte_refsignal_drms_pusch_cfg_t)); bzero(&drms_cfg, sizeof(srslte_refsignal_drms_pusch_cfg_t));
drms_cfg.beta_pusch = 1.0; drms_cfg.beta_pusch = 1.0;
drms_cfg.group_hopping_en = false; drms_cfg.group_hopping_en = false;
drms_cfg.sequence_hopping_en = false; drms_cfg.srslte_sequence_hopping_en = false;
drms_cfg.delta_ss = 0; drms_cfg.delta_ss = 0;
drms_cfg.cyclic_shift = 0; drms_cfg.cyclic_shift = 0;
drms_cfg.cyclic_shift_for_drms = 0; drms_cfg.cyclic_shift_for_drms = 0;
@ -451,7 +451,7 @@ int main(int argc, char **argv) {
} }
#else #else
ret = 1; ret = 1;
timestamp_t rx_time, tx_time; srslte_timestamp_t rx_time, tx_time;
cf_t dummy[4]; cf_t dummy[4];
#endif #endif
@ -490,10 +490,10 @@ int main(int argc, char **argv) {
if (((sfn%2) == 1) && (ue_sync_get_sfidx(&ue_sync) == 1)) { if (((sfn%2) == 1) && (ue_sync_get_sfidx(&ue_sync) == 1)) {
ue_sync_get_last_timestamp(&ue_sync, &uhd_time); ue_sync_get_last_timestamp(&ue_sync, &uhd_time);
timestamp_copy(&next_tx_time, &uhd_time); srslte_timestamp_copy(&next_tx_time, &uhd_time);
timestamp_add(&next_tx_time, 0, 0.01); // send next frame (10 ms) srslte_timestamp_add(&next_tx_time, 0, 0.01); // send next frame (10 ms)
printf("Send prach sfn: %d. Last frame time = %.6f, send prach time = %.6f\n", printf("Send prach sfn: %d. Last frame time = %.6f, send prach time = %.6f\n",
sfn, timestamp_real(&uhd_time), timestamp_real(&next_tx_time)); sfn, srslte_timestamp_real(&uhd_time), srslte_timestamp_real(&next_tx_time));
cuhd_send_timed(uhd, prach_buffer, prach_buffer_len, cuhd_send_timed(uhd, prach_buffer, prach_buffer_len,
next_tx_time.full_secs, next_tx_time.frac_secs); next_tx_time.full_secs, next_tx_time.frac_secs);
@ -506,11 +506,11 @@ int main(int argc, char **argv) {
#else #else
cuhd_recv_with_time(uhd, dummy, 4, 1, &rx_time.full_secs, &rx_time.frac_secs); cuhd_recv_with_time(uhd, dummy, 4, 1, &rx_time.full_secs, &rx_time.frac_secs);
timestamp_copy(&tx_time, &rx_time); srslte_timestamp_copy(&tx_time, &rx_time);
printf("Transmitting PRACH...\n"); printf("Transmitting PRACH...\n");
vec_save_file("prach_tx", prach_buffers[7], prach_buffer_len*sizeof(cf_t)); vec_save_file("prach_tx", prach_buffers[7], prach_buffer_len*sizeof(cf_t));
while(1) { while(1) {
timestamp_add(&tx_time, 0, 0.001); // send every (10 ms) srslte_timestamp_add(&tx_time, 0, 0.001); // send every (10 ms)
cuhd_send_timed(uhd, prach_buffers[7], prach_buffer_len, cuhd_send_timed(uhd, prach_buffers[7], prach_buffer_len,
tx_time.full_secs, tx_time.frac_secs); tx_time.full_secs, tx_time.frac_secs);
@ -564,13 +564,13 @@ int main(int argc, char **argv) {
vec_sc_prod_cfc(ul_signal, prog_args.beta_pusch, ul_signal, SRSLTE_SF_LEN_PRB(cell.nof_prb)); vec_sc_prod_cfc(ul_signal, prog_args.beta_pusch, ul_signal, SRSLTE_SF_LEN_PRB(cell.nof_prb));
timestamp_copy(&next_tx_time, &uhd_time); srslte_timestamp_copy(&next_tx_time, &uhd_time);
timestamp_add(&next_tx_time, 0, 0.006 + i*0.008 - time_adv_sec); // send after 6 sub-frames (6 ms) srslte_timestamp_add(&next_tx_time, 0, 0.006 + i*0.008 - time_adv_sec); // send after 6 sub-frames (6 ms)
printf("Send %d samples PUSCH sfn: %d. RV_idx=%d, Last frame time = %.6f " printf("Send %d samples PUSCH sfn: %d. RV_idx=%d, Last frame time = %.6f "
"send PUSCH time = %.6f TA: %.1f us\n", "send PUSCH time = %.6f TA: %.1f us\n",
SRSLTE_SF_LEN_PRB(cell.nof_prb), sfn, ra_pusch.rv_idx, SRSLTE_SF_LEN_PRB(cell.nof_prb), sfn, ra_pusch.rv_idx,
timestamp_real(&uhd_time), srslte_timestamp_real(&uhd_time),
timestamp_real(&next_tx_time), time_adv_sec*1000000); srslte_timestamp_real(&next_tx_time), time_adv_sec*1000000);
cuhd_send_timed(uhd, ul_signal, SRSLTE_SF_LEN_PRB(cell.nof_prb), cuhd_send_timed(uhd, ul_signal, SRSLTE_SF_LEN_PRB(cell.nof_prb),
next_tx_time.full_secs, next_tx_time.frac_secs); next_tx_time.full_secs, next_tx_time.frac_secs);
@ -615,9 +615,9 @@ int main(int argc, char **argv) {
#ifdef use_usrp #ifdef use_usrp
cuhd_recv_with_time(uhd, dummy, 4, 1, &uhd_time.full_secs, &uhd_time.frac_secs); cuhd_recv_with_time(uhd, dummy, 4, 1, &uhd_time.full_secs, &uhd_time.frac_secs);
timestamp_copy(&next_tx_time, &uhd_time); srslte_timestamp_copy(&next_tx_time, &uhd_time);
while(1) { while(1) {
timestamp_add(&next_tx_time, 0, 0.002); // send every 2 ms srslte_timestamp_add(&next_tx_time, 0, 0.002); // send every 2 ms
cuhd_send_timed(uhd, ul_signal, SRSLTE_SF_LEN_PRB(cell.nof_prb), cuhd_send_timed(uhd, ul_signal, SRSLTE_SF_LEN_PRB(cell.nof_prb),
next_tx_time.full_secs, next_tx_time.frac_secs); next_tx_time.full_secs, next_tx_time.frac_secs);
} }

14
srslte/examples/synch_file.c
Unescape Escape View File

@ -101,8 +101,8 @@ void parse_args(int argc, char **argv) {
} }
int main(int argc, char **argv) { int main(int argc, char **argv) {
filesource_t fsrc; srslte_filesource_t fsrc;
filesink_t fsink; srslte_filesink_t fsink;
pss_synch_t pss[3]; // One for each N_id_2 pss_synch_t pss[3]; // One for each N_id_2
sss_synch_t sss[3]; // One for each N_id_2 sss_synch_t sss[3]; // One for each N_id_2
cfo_t cfocorr; cfo_t cfocorr;
@ -128,11 +128,11 @@ int main(int argc, char **argv) {
gettimeofday(&tdata[1], NULL); gettimeofday(&tdata[1], NULL);
printf("Initializing...");fflush(stdout); printf("Initializing...");fflush(stdout);
if (filesource_init(&fsrc, input_file_name, COMPLEX_FLOAT_BIN)) { if (srslte_filesource_init(&fsrc, input_file_name, SRSLTE_COMPLEX_FLOAT_BIN)) {
fprintf(stderr, "Error opening file %s\n", input_file_name); fprintf(stderr, "Error opening file %s\n", input_file_name);
exit(-1); exit(-1);
} }
if (filesink_init(&fsink, output_file_name, COMPLEX_FLOAT_BIN)) { if (srslte_filesink_init(&fsink, output_file_name, SRSLTE_COMPLEX_FLOAT_BIN)) {
fprintf(stderr, "Error opening file %s\n", output_file_name); fprintf(stderr, "Error opening file %s\n", output_file_name);
exit(-1); exit(-1);
} }
@ -190,7 +190,7 @@ int main(int argc, char **argv) {
/* read all file or nof_frames */ /* read all file or nof_frames */
frame_cnt = 0; frame_cnt = 0;
while (frame_length == filesource_read(&fsrc, input, frame_length) while (frame_length == srslte_filesource_read(&fsrc, input, frame_length)
&& frame_cnt < nof_frames) { && frame_cnt < nof_frames) {
gettimeofday(&tdata[1], NULL); gettimeofday(&tdata[1], NULL);
@ -259,8 +259,8 @@ int main(int argc, char **argv) {
sss_synch_free(&sss[N_id_2]); sss_synch_free(&sss[N_id_2]);
} }
filesource_free(&fsrc); srslte_filesource_free(&fsrc);
filesink_free(&fsink); srslte_filesink_free(&fsink);
free(input); free(input);
free(cfo); free(cfo);

2
srslte/include/srslte/ch_estimation/refsignal_ul.h
Unescape Escape View File

@ -50,7 +50,7 @@ typedef struct SRSLTE_API {
bool en_drms_2; bool en_drms_2;
float beta_pusch; float beta_pusch;
bool group_hopping_en; bool group_hopping_en;
bool sequence_hopping_en; bool srslte_sequence_hopping_en;
}srslte_refsignal_drms_pusch_cfg_t; }srslte_refsignal_drms_pusch_cfg_t;
typedef struct SRSLTE_API { typedef struct SRSLTE_API {

64
srslte/include/srslte/common/sequence.h
Unescape Escape View File

@ -34,47 +34,47 @@
typedef struct SRSLTE_API { typedef struct SRSLTE_API {
uint8_t *c; uint8_t *c;
uint32_t len; uint32_t len;
} sequence_t; } srslte_sequence_t;
SRSLTE_API int sequence_init(sequence_t *q, uint32_t len); SRSLTE_API int srslte_sequence_init(srslte_sequence_t *q, uint32_t len);
SRSLTE_API void sequence_free(sequence_t *q); SRSLTE_API void srslte_sequence_free(srslte_sequence_t *q);
SRSLTE_API int sequence_LTE_pr(sequence_t *q, SRSLTE_API int srslte_sequence_LTE_pr(srslte_sequence_t *q,
uint32_t len, uint32_t len,
uint32_t seed); uint32_t seed);
SRSLTE_API void sequence_set_LTE_pr(sequence_t *q, SRSLTE_API void srslte_sequence_set_LTE_pr(srslte_sequence_t *q,
uint32_t seed); uint32_t seed);
SRSLTE_API int sequence_pbch(sequence_t *seq, SRSLTE_API int srslte_sequence_pbch(srslte_sequence_t *seq,
srslte_cp_t cp, srslte_cp_t cp,
uint32_t cell_id); uint32_t cell_id);
SRSLTE_API int sequence_pcfich(sequence_t *seq, SRSLTE_API int srslte_sequence_pcfich(srslte_sequence_t *seq,
uint32_t nslot, uint32_t nslot,
uint32_t cell_id); uint32_t cell_id);
SRSLTE_API int sequence_phich(sequence_t *seq, SRSLTE_API int srslte_sequence_phich(srslte_sequence_t *seq,
uint32_t nslot, uint32_t nslot,
uint32_t cell_id); uint32_t cell_id);
SRSLTE_API int sequence_pdcch(sequence_t *seq, SRSLTE_API int srslte_sequence_pdcch(srslte_sequence_t *seq,
uint32_t nslot, uint32_t nslot,
uint32_t cell_id, uint32_t cell_id,
uint32_t len); uint32_t len);
SRSLTE_API int sequence_pdsch(sequence_t *seq, SRSLTE_API int srslte_sequence_pdsch(srslte_sequence_t *seq,
unsigned short rnti, uint16_t rnti,
int q, int q,
uint32_t nslot, uint32_t nslot,
uint32_t cell_id, uint32_t cell_id,
uint32_t len); uint32_t len);
SRSLTE_API int sequence_pusch(sequence_t *seq, SRSLTE_API int srslte_sequence_pusch(srslte_sequence_t *seq,
unsigned short rnti, uint16_t rnti,
uint32_t nslot, uint32_t nslot,
uint32_t cell_id, uint32_t cell_id,
uint32_t len); uint32_t len);
#endif #endif

23
srslte/include/srslte/common/timestamp.h
Unescape Escape View File

@ -42,12 +42,23 @@
typedef struct SRSLTE_API{ typedef struct SRSLTE_API{
time_t full_secs; time_t full_secs;
double frac_secs; double frac_secs;
}timestamp_t; }srslte_timestamp_t;
SRSLTE_API int timestamp_init(timestamp_t *t, time_t full_secs, double frac_secs); SRSLTE_API int srslte_timestamp_init(srslte_timestamp_t *t,
SRSLTE_API int timestamp_copy(timestamp_t *dest, timestamp_t *src); time_t full_secs,
SRSLTE_API int timestamp_add(timestamp_t *t, time_t full_secs, double frac_secs); double frac_secs);
SRSLTE_API int timestamp_sub(timestamp_t *t, time_t full_secs, double frac_secs);
SRSLTE_API double timestamp_real(timestamp_t *t); SRSLTE_API int srslte_timestamp_copy(srslte_timestamp_t *dest,
srslte_timestamp_t *src);
SRSLTE_API int srslte_timestamp_add(srslte_timestamp_t *t,
time_t full_secs,
double frac_secs);
SRSLTE_API int srslte_timestamp_sub(srslte_timestamp_t *t,
time_t full_secs,
double frac_secs);
SRSLTE_API double srslte_timestamp_real(srslte_timestamp_t *t);
#endif // TIMESTAMP_ #endif // TIMESTAMP_

19
srslte/include/srslte/fec/convcoder.h
Unescape Escape View File

@ -38,15 +38,18 @@ typedef struct SRSLTE_API {
uint32_t K; uint32_t K;
uint32_t poly[3]; uint32_t poly[3];
bool tail_biting; bool tail_biting;
}convcoder_t; }srslte_convcoder_t;
SRSLTE_API int convcoder_encode(convcoder_t *q, uint8_t *input, uint8_t *output, uint32_t frame_length); SRSLTE_API int srslte_convcoder_encode(srslte_convcoder_t *q,
uint8_t *input,
uint8_t *output,
uint32_t frame_length);
/* High-level API */ /* High-level API */
typedef struct SRSLTE_API { typedef struct SRSLTE_API {
convcoder_t obj; srslte_convcoder_t obj;
struct convcoder_ctrl_in { struct srslte_convcoder_ctrl_in {
int rate; int rate;
int constraint_length; int constraint_length;
int tail_bitting; int tail_bitting;
@ -59,10 +62,10 @@ typedef struct SRSLTE_API {
int in_len; int in_len;
uint8_t *output; uint8_t *output;
int out_len; int out_len;
}convcoder_hl; }srslte_convcoder_hl;
SRSLTE_API int convcoder_initialize(convcoder_hl* h); SRSLTE_API int srslte_convcoder_initialize(srslte_convcoder_hl* h);
SRSLTE_API int convcoder_work(convcoder_hl* hl); SRSLTE_API int srslte_convcoder_work(srslte_convcoder_hl* hl);
SRSLTE_API int convcoder_stop(convcoder_hl* h); SRSLTE_API int srslte_convcoder_stop(srslte_convcoder_hl* h);
#endif #endif

22
srslte/include/srslte/fec/crc.h
Unescape Escape View File

@ -40,12 +40,22 @@ typedef struct SRSLTE_API {
unsigned long crcinit; unsigned long crcinit;
unsigned long crcmask; unsigned long crcmask;
unsigned long crchighbit; unsigned long crchighbit;
uint32_t crc_out; uint32_t srslte_crc_out;
} crc_t; } srslte_crc_t;
SRSLTE_API int crc_init(crc_t *h, uint32_t crc_poly, int crc_order); SRSLTE_API int srslte_crc_init(srslte_crc_t *h,
SRSLTE_API int crc_set_init(crc_t *h, unsigned long crc_init_value); uint32_t srslte_crc_poly,
SRSLTE_API void crc_attach(crc_t *h, uint8_t *data, int len); int srslte_crc_order);
SRSLTE_API uint32_t crc_checksum(crc_t *h, uint8_t *data, int len);
SRSLTE_API int srslte_crc_set_init(srslte_crc_t *h,
unsigned long srslte_crc_init_value);
SRSLTE_API void srslte_crc_attach(srslte_crc_t *h,
uint8_t *data,
int len);
SRSLTE_API uint32_t srslte_crc_checksum(srslte_crc_t *h,
uint8_t *data,
int len);
#endif #endif

38
srslte/include/srslte/fec/rm_conv.h
Unescape Escape View File

@ -30,41 +30,43 @@
#include "srslte/config.h" #include "srslte/config.h"
#ifndef RX_NULL #ifndef SRSLTE_RX_NULL
#define RX_NULL 10000 #define SRSLTE_RX_NULL 10000
#endif #endif
#ifndef TX_NULL #ifndef SRSLTE_TX_NULL
#define TX_NULL 100 #define SRSLTE_TX_NULL 100
#endif #endif
SRSLTE_API int rm_conv_tx(uint8_t *input, SRSLTE_API int srslte_rm_conv_tx(uint8_t *input,
uint32_t in_len, uint32_t in_len,
uint8_t *output, uint8_t *output,
uint32_t out_len); uint32_t out_len);
SRSLTE_API int rm_conv_rx(float *input, SRSLTE_API int srslte_rm_conv_rx(float *input,
uint32_t in_len, uint32_t in_len,
float *output, float *output,
uint32_t out_len); uint32_t out_len);
/* High-level API */ /* High-level API */
typedef struct typedef struct
SRSLTE_API { SRSLTE_API {
struct rm_conv_init { struct srslte_rm_conv_init {
int direction; int direction;
} init; } init;
void *input; // input type may be uint8_t or float depending on hard void *input; // input type may be uint8_t or float depending on hard
int in_len; int in_len;
struct rm_conv_ctrl_in { struct srslte_rm_conv_ctrl_in {
int E; int E;
int S; int S;
} ctrl_in; } ctrl_in;
void *output; void *output;
int out_len; int out_len;
} rm_conv_hl; } srslte_rm_conv_hl;
SRSLTE_API int rm_conv_initialize(rm_conv_hl* h); SRSLTE_API int srslte_rm_conv_initialize(srslte_rm_conv_hl* h);
SRSLTE_API int rm_conv_work(rm_conv_hl* hl);
SRSLTE_API int rm_conv_stop(rm_conv_hl* hl); SRSLTE_API int srslte_rm_conv_work(srslte_rm_conv_hl* hl);
SRSLTE_API int srslte_rm_conv_stop(srslte_rm_conv_hl* hl);
#endif #endif

50
srslte/include/srslte/fec/rm_turbo.h
Unescape Escape View File

@ -30,53 +30,53 @@
#include "srslte/config.h" #include "srslte/config.h"
#ifndef RX_NULL #ifndef SRSLTE_RX_NULL
#define RX_NULL 10000 #define SRSLTE_RX_NULL 10000
#endif #endif
#ifndef TX_NULL #ifndef SRSLTE_TX_NULL
#define TX_NULL 100 #define SRSLTE_TX_NULL 100
#endif #endif
#include "srslte/config.h" #include "srslte/config.h"
SRSLTE_API int rm_turbo_tx(uint8_t *w_buff, SRSLTE_API int srslte_rm_turbo_tx(uint8_t *w_buff,
uint32_t buff_len, uint32_t buff_len,
uint8_t *input, uint8_t *input,
uint32_t in_len, uint32_t in_len,
uint8_t *output, uint8_t *output,
uint32_t out_len, uint32_t out_len,
uint32_t rv_idx); uint32_t rv_idx);
SRSLTE_API int rm_turbo_rx(float *w_buff, SRSLTE_API int srslte_rm_turbo_rx(float *w_buff,
uint32_t buff_len, uint32_t buff_len,
float *input, float *input,
uint32_t in_len, uint32_t in_len,
float *output, float *output,
uint32_t out_len, uint32_t out_len,
uint32_t rv_idx, uint32_t rv_idx,
uint32_t nof_filler_bits); uint32_t nof_filler_bits);
/* High-level API */ /* High-level API */
typedef struct SRSLTE_API { typedef struct SRSLTE_API {
struct rm_turbo_init { struct srslte_rm_turbo_init {
int direction; int direction;
} init; } init;
void *input; // input type may be uint8_t or float depending on hard void *input; // input type may be uint8_t or float depending on hard
int in_len; int in_len;
struct rm_turbo_ctrl_in { struct srslte_rm_turbo_ctrl_in {
int E; int E;
int S; int S;
int rv_idx; int rv_idx;
} ctrl_in; } ctrl_in;
void *output; void *output;
int out_len; int out_len;
} rm_turbo_hl; } srslte_rm_turbo_hl;
SRSLTE_API int rm_turbo_initialize(rm_turbo_hl* h); SRSLTE_API int srslte_rm_turbo_initialize(srslte_rm_turbo_hl* h);
SRSLTE_API int rm_turbo_work(rm_turbo_hl* hl); SRSLTE_API int srslte_rm_turbo_work(srslte_rm_turbo_hl* hl);
SRSLTE_API int rm_turbo_stop(rm_turbo_hl* hl); SRSLTE_API int srslte_rm_turbo_stop(srslte_rm_turbo_hl* hl);
#endif #endif

15
srslte/include/srslte/fec/tc_interl.h
Unescape Escape View File

@ -34,12 +34,17 @@ typedef struct SRSLTE_API {
uint32_t *forward; uint32_t *forward;
uint32_t *reverse; uint32_t *reverse;
uint32_t max_long_cb; uint32_t max_long_cb;
} tc_interl_t; } srs_tc_interl_t;
SRSLTE_API int tc_interl_LTE_gen(tc_interl_t *h, uint32_t long_cb); SRSLTE_API int srs_tc_interl_LTE_gen(srs_tc_interl_t *h,
SRSLTE_API int tc_interl_UMTS_gen(tc_interl_t *h, uint32_t long_cb); uint32_t long_cb);
SRSLTE_API int tc_interl_init(tc_interl_t *h, uint32_t max_long_cb); SRSLTE_API int srs_tc_interl_UMTS_gen(srs_tc_interl_t *h,
SRSLTE_API void tc_interl_free(tc_interl_t *h); uint32_t long_cb);
SRSLTE_API int srs_tc_interl_init(srs_tc_interl_t *h,
uint32_t max_long_cb);
SRSLTE_API void srs_tc_interl_free(srs_tc_interl_t *h);
#endif #endif

24
srslte/include/srslte/fec/turbocoder.h
Unescape Escape View File

@ -31,23 +31,25 @@
#include "srslte/config.h" #include "srslte/config.h"
#include "srslte/fec/tc_interl.h" #include "srslte/fec/tc_interl.h"
#define NUMREGS 3
#define RATE 3 #ifndef SRSLTE_TX_NULL
#define TOTALTAIL 12 #define SRSLTE_TX_NULL 100
#ifndef TX_NULL
#define TX_NULL 100
#endif #endif
typedef struct SRSLTE_API { typedef struct SRSLTE_API {
uint32_t max_long_cb; uint32_t max_long_cb;
tc_interl_t interl; srs_tc_interl_t interl;
} tcod_t; } srslte_tcod_t;
SRSLTE_API int srslte_tcod_init(srslte_tcod_t *h,
uint32_t max_long_cb);
SRSLTE_API void srslte_tcod_free(srslte_tcod_t *h);
SRSLTE_API int tcod_init(tcod_t *h, uint32_t max_long_cb); SRSLTE_API int srslte_tcod_encode(srslte_tcod_t *h,
SRSLTE_API void tcod_free(tcod_t *h); uint8_t *input,
SRSLTE_API int tcod_encode(tcod_t *h, uint8_t *input, uint8_t *output, uint32_t long_cb); uint8_t *output,
uint32_t long_cb);
#endif #endif

68
srslte/include/srslte/fec/turbodecoder.h
Unescape Escape View File

@ -31,62 +31,52 @@
#include "srslte/config.h" #include "srslte/config.h"
#include "srslte/fec/tc_interl.h" #include "srslte/fec/tc_interl.h"
#define RATE 3 #define SRSLTE_TCOD_RATE 3
#define TOTALTAIL 12 #define SRSLTE_TCOD_TOTALTAIL 12
#define LOG18 -2.07944
#define NUMSTATES 8
#define NINPUTS 2
#define TAIL 3
#define TOTALTAIL 12
#define INF 9e4
#define ZERO 9e-4
#define MAX_LONG_CB 6144 #define MAX_LONG_CB 6144
#define MAX_LONG_CODED (RATE*MAX_LONG_CB+TOTALTAIL) #define MAX_LONG_CODED (SRSLTE_TCOD_RATE*MAX_LONG_CB+SRSLTE_TCOD_TOTALTAIL)
typedef float llr_t; typedef float srslte_llr_t;
typedef struct SRSLTE_API { typedef struct SRSLTE_API {
int max_long_cb; int max_long_cb;
llr_t *beta; srslte_llr_t *beta;
} map_gen_t; } srslte_map_gen_t;
typedef struct SRSLTE_API { typedef struct SRSLTE_API {
int max_long_cb; int max_long_cb;
map_gen_t dec; srslte_map_gen_t dec;
llr_t *llr1; srslte_llr_t *llr1;
llr_t *llr2; srslte_llr_t *llr2;
llr_t *w; srslte_llr_t *w;
llr_t *syst; srslte_llr_t *syst;
llr_t *parity; srslte_llr_t *parity;
tc_interl_t interleaver; srs_tc_interl_t interleaver;
} tdec_t; } srslte_tdec_t;
SRSLTE_API int tdec_init(tdec_t * h, SRSLTE_API int srslte_tdec_init(srslte_tdec_t * h,
uint32_t max_long_cb); uint32_t max_long_cb);
SRSLTE_API void tdec_free(tdec_t * h); SRSLTE_API void srslte_tdec_free(srslte_tdec_t * h);
SRSLTE_API int tdec_reset(tdec_t * h, uint32_t long_cb); SRSLTE_API int srslte_tdec_reset(srslte_tdec_t * h, uint32_t long_cb);
SRSLTE_API void tdec_iteration(tdec_t * h, SRSLTE_API void srslte_tdec_iteration(srslte_tdec_t * h,
llr_t * input, srslte_llr_t * input,
uint32_t long_cb); uint32_t long_cb);
SRSLTE_API void tdec_decision(tdec_t * h, SRSLTE_API void srslte_tdec_decision(srslte_tdec_t * h,
uint8_t *output, uint8_t *output,
uint32_t long_cb); uint32_t long_cb);
SRSLTE_API int tdec_run_all(tdec_t * h, SRSLTE_API int srslte_tdec_run_all(srslte_tdec_t * h,
llr_t * input, srslte_llr_t * input,
uint8_t *output, uint8_t *output,
uint32_t nof_iterations, uint32_t nof_iterations,
uint32_t long_cb); uint32_t long_cb);
#endif #endif

53
srslte/include/srslte/fec/viterbi.h
Unescape Escape View File

@ -33,8 +33,11 @@
#include "srslte/config.h" #include "srslte/config.h"
typedef enum { typedef enum {
viterbi_27, viterbi_29, viterbi_37, viterbi_39 SRSLTE_VITERBI_27 = 0,
}viterbi_type_t; SRSLTE_VITERBI_29,
SRSLTE_VITERBI_37,
SRSLTE_VITERBI_39
}srslte_viterbi_type_t;
typedef struct SRSLTE_API{ typedef struct SRSLTE_API{
void *ptr; void *ptr;
@ -49,34 +52,34 @@ typedef struct SRSLTE_API{
void (*free) (void*); void (*free) (void*);
uint8_t *tmp; uint8_t *tmp;
uint8_t *symbols_uc; uint8_t *symbols_uc;
}viterbi_t; }srslte_viterbi_t;
SRSLTE_API int viterbi_init(viterbi_t *q, SRSLTE_API int srslte_viterbi_init(srslte_viterbi_t *q,
viterbi_type_t type, srslte_viterbi_type_t type,
uint32_t poly[3], uint32_t poly[3],
uint32_t max_frame_length, uint32_t max_frame_length,
bool tail_bitting); bool tail_bitting);
SRSLTE_API void viterbi_set_gain_quant(viterbi_t *q, SRSLTE_API void srslte_viterbi_set_gain_quant(srslte_viterbi_t *q,
float gain_quant); float gain_quant);
SRSLTE_API void viterbi_free(viterbi_t *q); SRSLTE_API void srslte_viterbi_free(srslte_viterbi_t *q);
SRSLTE_API int viterbi_decode_f(viterbi_t *q, SRSLTE_API int srslte_viterbi_decode_f(srslte_viterbi_t *q,
float *symbols, float *symbols,
uint8_t *data, uint8_t *data,
uint32_t frame_length); uint32_t frame_length);
SRSLTE_API int viterbi_decode_uc(viterbi_t *q, SRSLTE_API int srslte_viterbi_decode_uc(srslte_viterbi_t *q,
uint8_t *symbols, uint8_t *symbols,
uint8_t *data, uint8_t *data,
uint32_t frame_length); uint32_t frame_length);
/* High-level API */ /* High-level API */
typedef struct SRSLTE_API{ typedef struct SRSLTE_API{
viterbi_t obj; srslte_viterbi_t obj;
struct viterbi_init { struct srslte_viterbi_init {
int rate; int rate;
int constraint_length; int constraint_length;
int tail_bitting; int tail_bitting;
@ -89,10 +92,10 @@ typedef struct SRSLTE_API{
int in_len; int in_len;
uint8_t *output; uint8_t *output;
int out_len; int out_len;
}viterbi_hl; }srslte_viterbi_hl;
SRSLTE_API int viterbi_initialize(viterbi_hl* h); SRSLTE_API int srslte_viterbi_initialize(srslte_viterbi_hl* h);
SRSLTE_API int viterbi_work(viterbi_hl* hl); SRSLTE_API int srslte_viterbi_work(srslte_viterbi_hl* hl);
SRSLTE_API int viterbi_stop(viterbi_hl* h); SRSLTE_API int srslte_viterbi_stop(srslte_viterbi_hl* h);
#endif #endif

30
srslte/include/srslte/filter/dft_precoding.h
Unescape Escape View File

@ -42,25 +42,25 @@ typedef struct SRSLTE_API {
srslte_dft_plan_t dft_plan[SRSLTE_MAX_PRB]; srslte_dft_plan_t dft_plan[SRSLTE_MAX_PRB];
srslte_dft_plan_t idft_plan[SRSLTE_MAX_PRB]; srslte_dft_plan_t idft_plan[SRSLTE_MAX_PRB];
}dft_precoding_t; }srslte_srslte_dft_precoding_t;
SRSLTE_API int dft_precoding_init(dft_precoding_t *q, SRSLTE_API int srslte_srslte_dft_precoding_init(srslte_srslte_dft_precoding_t *q,
uint32_t max_prb); uint32_t max_prb);
SRSLTE_API void dft_precoding_free(dft_precoding_t *q); SRSLTE_API void srslte_srslte_dft_precoding_free(srslte_srslte_dft_precoding_t *q);
SRSLTE_API bool dft_precoding_valid_prb(uint32_t nof_prb); SRSLTE_API bool srslte_srslte_dft_precoding_valid_prb(uint32_t nof_prb);
SRSLTE_API int dft_precoding(dft_precoding_t *q, SRSLTE_API int srslte_dft_precoding(srslte_srslte_dft_precoding_t *q,
cf_t *input, cf_t *input,
cf_t *output, cf_t *output,
uint32_t nof_prb, uint32_t nof_prb,
uint32_t nof_symbols); uint32_t nof_symbols);
SRSLTE_API int dft_predecoding(dft_precoding_t *q, SRSLTE_API int srslte_dft_predecoding(srslte_srslte_dft_precoding_t *q,
cf_t *input, cf_t *input,
cf_t *output, cf_t *output,
uint32_t nof_prb, uint32_t nof_prb,
uint32_t nof_symbols); uint32_t nof_symbols);
#endif #endif

18
srslte/include/srslte/filter/filter2d.h
Unescape Escape View File

@ -46,35 +46,35 @@ typedef struct SRSLTE_API{
float **taps; // 2-D filter coefficients float **taps; // 2-D filter coefficients
float norm; //normalization factor float norm; //normalization factor
cf_t *output; // Output signal cf_t *output; // Output signal
} filter2d_t; } srslte_filter2d_t;
SRSLTE_API int filter2d_init (filter2d_t* q, SRSLTE_API int srslte_filter2d_init (srslte_filter2d_t* q,
float **taps, float **taps,
uint32_t ntime, uint32_t ntime,
uint32_t nfreq, uint32_t nfreq,
uint32_t sztime, uint32_t sztime,
uint32_t szfreq); uint32_t szfreq);
SRSLTE_API int filter2d_init_ones (filter2d_t* q, SRSLTE_API int srslte_filter2d_init_ones (srslte_filter2d_t* q,
uint32_t ntime, uint32_t ntime,
uint32_t nfreq, uint32_t nfreq,
uint32_t sztime, uint32_t sztime,
uint32_t szfreq); uint32_t szfreq);
SRSLTE_API void filter2d_free(filter2d_t *q); SRSLTE_API void srslte_filter2d_free(srslte_filter2d_t *q);
SRSLTE_API void filter2d_step(filter2d_t *q); SRSLTE_API void srslte_filter2d_step(srslte_filter2d_t *q);
SRSLTE_API void filter2d_reset(filter2d_t *q); SRSLTE_API void srslte_filter2d_reset(srslte_filter2d_t *q);
SRSLTE_API void filter2d_add(filter2d_t *q, SRSLTE_API void srslte_filter2d_add(srslte_filter2d_t *q,
cf_t h, cf_t h,
uint32_t time_idx, uint32_t time_idx,
uint32_t freq_idx); uint32_t freq_idx);
SRSLTE_API void filter2d_add_out(filter2d_t *q, cf_t x, int time_idx, int freq_idx); SRSLTE_API void srslte_filter2d_add_out(srslte_filter2d_t *q, cf_t x, int time_idx, int freq_idx);
SRSLTE_API void filter2d_get_symbol(filter2d_t *q, SRSLTE_API void srslte_filter2d_get_symbol(srslte_filter2d_t *q,
uint32_t nsymbol, uint32_t nsymbol,
cf_t *output); cf_t *output);
#endif // FILTER2D_ #endif // FILTER2D_

42
srslte/include/srslte/io/binsource.h
Unescape Escape View File

@ -40,32 +40,44 @@ typedef struct SRSLTE_API{
int seq_buff_nwords; int seq_buff_nwords;
int seq_cache_nbits; int seq_cache_nbits;
int seq_cache_rp; int seq_cache_rp;
}binsource_t; }srslte_binsource_t;
SRSLTE_API void binsource_init(binsource_t* q); SRSLTE_API void srslte_binsource_init(srslte_binsource_t* q);
SRSLTE_API void binsource_free(binsource_t* q);
SRSLTE_API void binsource_seed_set(binsource_t* q, uint32_t seed); SRSLTE_API void srslte_binsource_free(srslte_binsource_t* q);
SRSLTE_API void binsource_seed_time(binsource_t *q);
SRSLTE_API int binsource_cache_gen(binsource_t* q, int nbits); SRSLTE_API void srslte_binsource_seed_set(srslte_binsource_t* q,
SRSLTE_API void binsource_cache_cpy(binsource_t* q, uint8_t *bits, int nbits); uint32_t seed);
SRSLTE_API int binsource_generate(binsource_t* q, uint8_t *bits, int nbits);
SRSLTE_API void srslte_binsource_seed_time(srslte_binsource_t *q);
SRSLTE_API int srslte_binsource_cache_gen(srslte_binsource_t* q,
int nbits);
SRSLTE_API void srslte_binsource_cache_cpy(srslte_binsource_t* q,
uint8_t *bits,
int nbits);
SRSLTE_API int srslte_binsource_generate(srslte_binsource_t* q,
uint8_t *bits,
int nbits);
/* High-level API */ /* High-level API */
typedef struct SRSLTE_API { typedef struct SRSLTE_API {
binsource_t obj; srslte_binsource_t obj;
struct binsource_init { struct srslte_binsource_init {
int cache_seq_nbits; // If non-zero, generates random bits on init int cache_seq_nbits; // If non-zero, generates random bits on init
uint32_t seed; // If non-zero, uses as random seed, otherwise local time is used. uint32_t seed; // If non-zero, uses as random seed, otherwise local time is used.
} init; } init;
struct binsource_ctrl_in { struct srslte_binsource_ctrl_in {
int nbits; // Number of bits to generate int nbits; // Number of bits to generate
} ctrl_in; } ctrl_in;
uint8_t* output; uint8_t* output;
int out_len; int out_len;
}binsource_hl; }srslte_binsource_hl;
SRSLTE_API int binsource_initialize(binsource_hl* h); SRSLTE_API int srslte_binsource_initialize(srslte_binsource_hl* h);
SRSLTE_API int binsource_work( binsource_hl* hl); SRSLTE_API int srslte_binsource_work( srslte_binsource_hl* hl);
SRSLTE_API int binsource_stop(binsource_hl* hl); SRSLTE_API int srslte_binsource_stop(srslte_binsource_hl* hl);
#endif // BINSOURCE_ #endif // BINSOURCE_

27
srslte/include/srslte/io/filesink.h
Unescape Escape View File

@ -38,29 +38,34 @@
/* Low-level API */ /* Low-level API */
typedef struct SRSLTE_API { typedef struct SRSLTE_API {
FILE *f; FILE *f;
data_type_t type; srslte_datatype_t type;
}filesink_t; } srslte_filesink_t;
SRSLTE_API int filesink_init(filesink_t *q, char *filename, data_type_t type); SRSLTE_API int srslte_filesink_init(srslte_filesink_t *q,
SRSLTE_API void filesink_free(filesink_t *q); char *filename,
srslte_datatype_t type);
SRSLTE_API int filesink_write(filesink_t *q, void *buffer, int nsamples); SRSLTE_API void srslte_filesink_free(srslte_filesink_t *q);
SRSLTE_API int srslte_filesink_write(srslte_filesink_t *q,
void *buffer,
int nsamples);
/* High-level API */ /* High-level API */
typedef struct SRSLTE_API { typedef struct SRSLTE_API {
filesink_t obj; srslte_filesink_t obj;
struct filesink_init { struct srslte_filesink_init {
char *file_name; char *file_name;
int block_length; int block_length;
int data_type; int data_type;
} init; } init;
void* input; void* input;
int in_len; int in_len;
}filesink_hl; }srslte_filesink_hl;
SRSLTE_API int filesink_initialize(filesink_hl* h); SRSLTE_API int srslte_filesink_initialize(srslte_filesink_hl* h);
SRSLTE_API int filesink_work( filesink_hl* hl); SRSLTE_API int srslte_filesink_work( srslte_filesink_hl* hl);
SRSLTE_API int filesink_stop(filesink_hl* h); SRSLTE_API int srslte_filesink_stop(srslte_filesink_hl* h);
#endif // FILESINK_ #endif // FILESINK_

33
srslte/include/srslte/io/filesource.h
Unescape Escape View File

@ -38,33 +38,40 @@
/* Low-level API */ /* Low-level API */
typedef struct SRSLTE_API { typedef struct SRSLTE_API {
FILE *f; FILE *f;
data_type_t type; srslte_datatype_t type;
}filesource_t; } srslte_filesource_t;
SRSLTE_API int filesource_init(filesource_t *q, char *filename, data_type_t type); SRSLTE_API int srslte_filesource_init(srslte_filesource_t *q,
SRSLTE_API void filesource_free(filesource_t *q); char *filename,
srslte_datatype_t type);
SRSLTE_API void filesource_seek(filesource_t *q, int pos); SRSLTE_API void srslte_filesource_free(srslte_filesource_t *q);
SRSLTE_API int filesource_read(filesource_t *q, void *buffer, int nsamples);
SRSLTE_API void srslte_filesource_seek(srslte_filesource_t *q,
int pos);
SRSLTE_API int srslte_filesource_read(srslte_filesource_t *q,
void *buffer,
int nsamples);
/* High-level API */ /* High-level API */
typedef struct SRSLTE_API { typedef struct SRSLTE_API {
filesource_t obj; srslte_filesource_t obj;
struct filesource_init { struct srslte_filesource_init {
char *file_name; char *file_name;
int block_length; int block_length;
int data_type; int data_type;
} init; } init;
struct filesource_ctrl_in { struct srslte_filesource_ctrl_in {
int nsamples; // Number of samples to read int nsamples; // Number of samples to read
} ctrl_in; } ctrl_in;
void* output; void* output;
int out_len; int out_len;
}filesource_hl; }srslte_filesource_hl;
SRSLTE_API int filesource_initialize(filesource_hl* h); SRSLTE_API int srslte_filesource_initialize(srslte_filesource_hl* h);
SRSLTE_API int filesource_work( filesource_hl* hl); SRSLTE_API int srslte_filesource_work( srslte_filesource_hl* hl);
SRSLTE_API int filesource_stop(filesource_hl* h); SRSLTE_API int srslte_filesource_stop(srslte_filesource_hl* h);
#endif // FILESOURCE_ #endif // FILESOURCE_

9
srslte/include/srslte/io/format.h
Unescape Escape View File

@ -29,6 +29,13 @@
#ifndef FORMAT_ #ifndef FORMAT_
#define FORMAT_ #define FORMAT_
typedef enum { FLOAT, COMPLEX_FLOAT, COMPLEX_SHORT, FLOAT_BIN, COMPLEX_FLOAT_BIN, COMPLEX_SHORT_BIN} data_type_t; typedef enum {
SRSLTE_FLOAT,
SRSLTE_COMPLEX_FLOAT,
SRSLTE_COMPLEX_SHORT,
SRSLTE_FLOAT_BIN,
SRSLTE_COMPLEX_FLOAT_BIN,
SRSLTE_COMPLEX_SHORT_BIN
} srslte_datatype_t;
#endif // FORMAT_ #endif // FORMAT_

39
srslte/include/srslte/io/netsink.h
Unescape Escape View File

@ -38,34 +38,37 @@
#include "srslte/config.h" #include "srslte/config.h"
typedef enum {NETSINK_UDP, NETSINK_TCP} netsink_type_t; typedef enum {
SRSLTE_NETSINK_UDP,
SRSLTE_NETSINK_TCP
} srslte_netsink_type_t;
/* Low-level API */ /* Low-level API */
typedef struct SRSLTE_API { typedef struct SRSLTE_API {
int sockfd; int sockfd;
bool connected; bool connected;
netsink_type_t type; srslte_netsink_type_t type;
struct sockaddr_in servaddr; struct sockaddr_in servaddr;
}netsink_t; }srslte_netsink_t;
SRSLTE_API int netsink_init(netsink_t *q, SRSLTE_API int srslte_netsink_init(srslte_netsink_t *q,
char *address, char *address,
int port, int port,
netsink_type_t type); srslte_netsink_type_t type);
SRSLTE_API void netsink_free(netsink_t *q); SRSLTE_API void srslte_netsink_free(srslte_netsink_t *q);
SRSLTE_API int netsink_write(netsink_t *q, SRSLTE_API int srslte_netsink_write(srslte_netsink_t *q,
void *buffer, void *buffer,
int nof_bytes); int nof_bytes);
SRSLTE_API int netsink_set_nonblocking(netsink_t *q); SRSLTE_API int srslte_netsink_set_nonblocking(srslte_netsink_t *q);
/* High-level API */ /* High-level API */
typedef struct SRSLTE_API { typedef struct SRSLTE_API {
netsink_t obj; srslte_netsink_t obj;
struct netsink_init { struct srslte_netsink_init {
char *address; char *address;
int port; int port;
int block_length; int block_length;
@ -73,10 +76,10 @@ typedef struct SRSLTE_API {
} init; } init;
void* input; void* input;
int in_len; int in_len;
}netsink_hl; }srslte_netsink_hl;
SRSLTE_API int netsink_initialize(netsink_hl* h); SRSLTE_API int srslte_netsink_initialize(srslte_netsink_hl* h);
SRSLTE_API int netsink_work( netsink_hl* hl); SRSLTE_API int srslte_netsink_work( srslte_netsink_hl* hl);
SRSLTE_API int netsink_stop(netsink_hl* h); SRSLTE_API int srslte_netsink_stop(srslte_netsink_hl* h);
#endif // UDPSINK_ #endif // UDPSINK_

45
srslte/include/srslte/io/netsource.h
Unescape Escape View File

@ -38,51 +38,54 @@
#include "srslte/config.h" #include "srslte/config.h"
typedef enum {NETSOURCE_UDP, NETSOURCE_TCP} netsource_type_t; typedef enum {
SRSLTE_NETSOURCE_UDP,
SRSLTE_NETSOURCE_TCP
} srslte_netsource_type_t;
/* Low-level API */ /* Low-level API */
typedef struct SRSLTE_API { typedef struct SRSLTE_API {
int sockfd; int sockfd;
int connfd; int connfd;
struct sockaddr_in servaddr; struct sockaddr_in servaddr;
netsource_type_t type; srslte_netsource_type_t type;
struct sockaddr_in cliaddr; struct sockaddr_in cliaddr;
}netsource_t; }srslte_netsource_t;
SRSLTE_API int netsource_init(netsource_t *q, SRSLTE_API int srslte_netsource_init(srslte_netsource_t *q,
char *address, char *address,
int port, int port,
netsource_type_t type); srslte_netsource_type_t type);
SRSLTE_API void netsource_free(netsource_t *q); SRSLTE_API void srslte_netsource_free(srslte_netsource_t *q);
SRSLTE_API int netsource_set_nonblocking(netsource_t *q); SRSLTE_API int srslte_netsource_set_nonblocking(srslte_netsource_t *q);
SRSLTE_API int netsource_read(netsource_t *q, SRSLTE_API int srslte_netsource_read(srslte_netsource_t *q,
void *buffer, void *buffer,
int nof_bytes); int nof_bytes);
SRSLTE_API int netsource_set_timeout(netsource_t *q, SRSLTE_API int srslte_netsource_set_timeout(srslte_netsource_t *q,
uint32_t microseconds); uint32_t microseconds);
/* High-level API */ /* High-level API */
typedef struct SRSLTE_API { typedef struct SRSLTE_API {
netsource_t obj; srslte_netsource_t obj;
struct netsource_init { struct srslte_netsource_init {
char *address; char *address;
int port; int port;
int data_type; int data_type;
} init; } init;
struct netsource_ctrl_in { struct srslte_netsource_ctrl_in {
int nsamples; // Number of samples to read int nsamples; // Number of samples to read
} ctrl_in; } ctrl_in;
void* output; void* output;
int out_len; int out_len;
}netsource_hl; }srslte_netsource_hl;
SRSLTE_API int netsource_initialize(netsource_hl* h); SRSLTE_API int srslte_netsource_initialize(srslte_netsource_hl* h);
SRSLTE_API int netsource_work( netsource_hl* hl); SRSLTE_API int srslte_netsource_work( srslte_netsource_hl* hl);
SRSLTE_API int netsource_stop(netsource_hl* h); SRSLTE_API int srslte_netsource_stop(srslte_netsource_hl* h);
#endif // UDPSOURCE_ #endif // UDPSOURCE_

57
srslte/include/srslte/mimo/layermap.h
Unescape Escape View File

@ -30,26 +30,59 @@
#define LAYERMAP_H_ #define LAYERMAP_H_
#include "srslte/config.h" #include "srslte/config.h"
#include "srslte/common/phy_common.h"
typedef _Complex float cf_t; typedef _Complex float cf_t;
/* Generates the vector of layer-mapped symbols "x" based on the vector of data symbols "d" /* Generates the vector of layer-mapped symbols "x" based on the vector of data symbols "d"
*/ */
SRSLTE_API int layermap_single(cf_t *d, cf_t *x, int nof_symbols); SRSLTE_API int srslte_layermap_single(cf_t *d,
SRSLTE_API int layermap_diversity(cf_t *d, cf_t *x[SRSLTE_MAX_LAYERS], int nof_layers, int nof_symbols); cf_t *x,
SRSLTE_API int layermap_multiplex(cf_t *d[SRSLTE_MAX_CODEWORDS], cf_t *x[SRSLTE_MAX_LAYERS], int nof_cw, int nof_layers, int nof_symbols);
int nof_symbols[SRSLTE_MAX_CODEWORDS]);
SRSLTE_API int layermap_type(cf_t *d[SRSLTE_MAX_CODEWORDS], cf_t *x[SRSLTE_MAX_LAYERS], int nof_cw, int nof_layers, SRSLTE_API int srslte_layermap_diversity(cf_t *d,
int nof_symbols[SRSLTE_MAX_CODEWORDS], srslte_mimo_type_t type); cf_t *x[SRSLTE_MAX_LAYERS],
int nof_layers,
int nof_symbols);
SRSLTE_API int srslte_layermap_multiplex(cf_t *d[SRSLTE_MAX_CODEWORDS],
cf_t *x[SRSLTE_MAX_LAYERS],
int nof_cw,
int nof_layers,
int nof_symbols[SRSLTE_MAX_CODEWORDS]);
SRSLTE_API int srslte_layermap_type(cf_t *d[SRSLTE_MAX_CODEWORDS],
cf_t *x[SRSLTE_MAX_LAYERS],
int nof_cw,
int nof_layers,
int nof_symbols[SRSLTE_MAX_CODEWORDS],
srslte_mimo_type_t type);
/* Generates the vector of data symbols "d" based on the vector of layer-mapped symbols "x" /* Generates the vector of data symbols "d" based on the vector of layer-mapped symbols "x"
*/ */
SRSLTE_API int layerdemap_single(cf_t *x, cf_t *d, int nof_symbols); SRSLTE_API int srslte_layerdemap_single(cf_t *x,
SRSLTE_API int layerdemap_diversity(cf_t *x[SRSLTE_MAX_LAYERS], cf_t *d, int nof_layers, int nof_layer_symbols); cf_t *d,
SRSLTE_API int layerdemap_multiplex(cf_t *x[SRSLTE_MAX_LAYERS], cf_t *d[SRSLTE_MAX_CODEWORDS], int nof_layers, int nof_cw, int nof_symbols);
int nof_layer_symbols, int nof_symbols[SRSLTE_MAX_CODEWORDS]);
SRSLTE_API int layerdemap_type(cf_t *x[SRSLTE_MAX_LAYERS], cf_t *d[SRSLTE_MAX_CODEWORDS], int nof_layers, int nof_cw, SRSLTE_API int srslte_layerdemap_diversity(cf_t *x[SRSLTE_MAX_LAYERS],
int nof_layer_symbols, int nof_symbols[SRSLTE_MAX_CODEWORDS], srslte_mimo_type_t type); cf_t *d,
int nof_layers,
int nof_layer_symbols);
SRSLTE_API int srslte_layerdemap_multiplex(cf_t *x[SRSLTE_MAX_LAYERS],
cf_t *d[SRSLTE_MAX_CODEWORDS],
int nof_layers,
int nof_cw,
int nof_layer_symbols,
int nof_symbols[SRSLTE_MAX_CODEWORDS]);
SRSLTE_API int srslte_layerdemap_type(cf_t *x[SRSLTE_MAX_LAYERS],
cf_t *d[SRSLTE_MAX_CODEWORDS],
int nof_layers,
int nof_cw,
int nof_layer_symbols,
int nof_symbols[SRSLTE_MAX_CODEWORDS],
srslte_mimo_type_t type);
#endif // LAYERMAP_H_ #endif // LAYERMAP_H_

4
srslte/include/srslte/phch/dci.h
Unescape Escape View File

@ -123,12 +123,12 @@ SRSLTE_API int dci_msg_pack_pdsch(ra_pdsch_t *data,
dci_msg_t *msg, dci_msg_t *msg,
dci_format_t format, dci_format_t format,
uint32_t nof_prb, uint32_t nof_prb,
bool crc_is_crnti); bool srslte_crc_is_crnti);
SRSLTE_API int dci_msg_unpack_pdsch(dci_msg_t *msg, SRSLTE_API int dci_msg_unpack_pdsch(dci_msg_t *msg,
ra_pdsch_t *data, ra_pdsch_t *data,
uint32_t nof_prb, uint32_t nof_prb,
bool crc_is_crnti); bool srslte_crc_is_crnti);
SRSLTE_API uint32_t dci_format_sizeof(dci_format_t format, SRSLTE_API uint32_t dci_format_sizeof(dci_format_t format,
uint32_t nof_prb); uint32_t nof_prb);

8
srslte/include/srslte/phch/pbch.h
Unescape Escape View File

@ -73,10 +73,10 @@ typedef struct SRSLTE_API {
/* tx & rx objects */ /* tx & rx objects */
modem_table_t mod; modem_table_t mod;
demod_soft_t demod; demod_soft_t demod;
sequence_t seq_pbch; srslte_sequence_t seq_pbch;
viterbi_t decoder; srslte_viterbi_t decoder;
crc_t crc; srslte_crc_t crc;
convcoder_t encoder; srslte_convcoder_t encoder;
precoding_t precoding; precoding_t precoding;
} pbch_t; } pbch_t;

2
srslte/include/srslte/phch/pcfich.h
Unescape Escape View File

@ -68,7 +68,7 @@ typedef struct SRSLTE_API {
/* tx & rx objects */ /* tx & rx objects */
modem_table_t mod; modem_table_t mod;
demod_soft_t demod; demod_soft_t demod;
sequence_t seq_pcfich[SRSLTE_NSUBFRAMES_X_FRAME]; srslte_sequence_t seq_pcfich[SRSLTE_NSUBFRAMES_X_FRAME];
precoding_t precoding; precoding_t precoding;
} pcfich_t; } pcfich_t;

8
srslte/include/srslte/phch/pdcch.h
Unescape Escape View File

@ -71,9 +71,9 @@ typedef struct SRSLTE_API {
/* tx & rx objects */ /* tx & rx objects */
modem_table_t mod; modem_table_t mod;
demod_soft_t demod; demod_soft_t demod;
sequence_t seq_pdcch[SRSLTE_NSUBFRAMES_X_FRAME]; srslte_sequence_t seq_pdcch[SRSLTE_NSUBFRAMES_X_FRAME];
viterbi_t decoder; srslte_viterbi_t decoder;
crc_t crc; srslte_crc_t crc;
precoding_t precoding; precoding_t precoding;
} pdcch_t; } pdcch_t;
@ -107,7 +107,7 @@ SRSLTE_API int pdcch_decode_msg(pdcch_t *q,
dci_msg_t *msg, dci_msg_t *msg,
dci_location_t *location, dci_location_t *location,
dci_format_t format, dci_format_t format,
uint16_t *crc_rem); uint16_t *srslte_crc_rem);
/* Function for generation of UE-specific search space DCI locations */ /* Function for generation of UE-specific search space DCI locations */
SRSLTE_API uint32_t pdcch_ue_locations(pdcch_t *q, SRSLTE_API uint32_t pdcch_ue_locations(pdcch_t *q,

2
srslte/include/srslte/phch/pdsch.h
Unescape Escape View File

@ -64,7 +64,7 @@ typedef struct SRSLTE_API {
/* tx & rx objects */ /* tx & rx objects */
modem_table_t mod[4]; modem_table_t mod[4];
demod_soft_t demod; demod_soft_t demod;
sequence_t seq_pdsch[SRSLTE_NSUBFRAMES_X_FRAME]; srslte_sequence_t seq_pdsch[SRSLTE_NSUBFRAMES_X_FRAME];
precoding_t precoding; precoding_t precoding;
sch_t dl_sch; sch_t dl_sch;

2
srslte/include/srslte/phch/phich.h
Unescape Escape View File

@ -74,7 +74,7 @@ typedef struct SRSLTE_API {
/* tx & rx objects */ /* tx & rx objects */
modem_table_t mod; modem_table_t mod;
demod_hard_t demod; demod_hard_t demod;
sequence_t seq_phich[SRSLTE_NSUBFRAMES_X_FRAME]; srslte_sequence_t seq_phich[SRSLTE_NSUBFRAMES_X_FRAME];
precoding_t precoding; precoding_t precoding;
}phich_t; }phich_t;

6
srslte/include/srslte/phch/pusch.h
Unescape Escape View File

@ -67,7 +67,7 @@ typedef struct SRSLTE_API {
bool rnti_is_set; bool rnti_is_set;
uint16_t rnti; uint16_t rnti;
dft_precoding_t dft_precoding; srslte_srslte_dft_precoding_t srslte_dft_precoding;
precoding_t equalizer; precoding_t equalizer;
@ -83,8 +83,8 @@ typedef struct SRSLTE_API {
/* tx & rx objects */ /* tx & rx objects */
modem_table_t mod[4]; modem_table_t mod[4];
demod_soft_t demod; demod_soft_t demod;
sequence_t seq_pusch[SRSLTE_NSUBFRAMES_X_FRAME]; srslte_sequence_t seq_pusch[SRSLTE_NSUBFRAMES_X_FRAME];
sequence_t seq_type2_fo; srslte_sequence_t seq_type2_fo;
sch_t dl_sch; sch_t dl_sch;

16
srslte/include/srslte/phch/sch.h
Unescape Escape View File

@ -41,12 +41,12 @@
#define TDEC_MAX_ITERATIONS 5 #define TDEC_MAX_ITERATIONS 5
#ifndef RX_NULL #ifndef SRSLTE_RX_NULL
#define RX_NULL 10000 #define SRSLTE_RX_NULL 10000
#endif #endif
#ifndef TX_NULL #ifndef SRSLTE_TX_NULL
#define TX_NULL 100 #define SRSLTE_TX_NULL 100
#endif #endif
/* DL-SCH AND UL-SCH common functions */ /* DL-SCH AND UL-SCH common functions */
@ -60,10 +60,10 @@ typedef struct SRSLTE_API {
void *cb_out; void *cb_out;
void *pdsch_e; void *pdsch_e;
tcod_t encoder; srslte_tcod_t encoder;
tdec_t decoder; srslte_tdec_t decoder;
crc_t crc_tb; srslte_crc_t srslte_crc_tb;
crc_t crc_cb; srslte_crc_t srslte_crc_cb;
uci_cqi_pusch_t uci_cqi; uci_cqi_pusch_t uci_cqi;

2
srslte/include/srslte/phch/uci.h
Unescape Escape View File

@ -40,7 +40,7 @@
typedef struct SRSLTE_API { typedef struct SRSLTE_API {
crc_t crc; srslte_crc_t crc;
uint8_t tmp_cqi[MAX_CQI_LEN_PUSCH]; uint8_t tmp_cqi[MAX_CQI_LEN_PUSCH];
uint8_t encoded_cqi[3*MAX_CQI_LEN_PUSCH]; uint8_t encoded_cqi[3*MAX_CQI_LEN_PUSCH];
} uci_cqi_pusch_t; } uci_cqi_pusch_t;

16
srslte/include/srslte/scrambling/scrambling.h
Unescape Escape View File

@ -36,31 +36,31 @@
typedef _Complex float cf_t; typedef _Complex float cf_t;
/* Scrambling has no state */ /* Scrambling has no state */
SRSLTE_API void scrambling_b(sequence_t *s, SRSLTE_API void scrambling_b(srslte_sequence_t *s,
uint8_t *data); uint8_t *data);
SRSLTE_API void scrambling_b_offset(sequence_t *s, SRSLTE_API void scrambling_b_offset(srslte_sequence_t *s,
uint8_t *data, uint8_t *data,
int offset, int offset,
int len); int len);
SRSLTE_API void scrambling_b_offset_pusch(sequence_t *s, SRSLTE_API void scrambling_b_offset_pusch(srslte_sequence_t *s,
uint8_t *data, uint8_t *data,
int offset, int offset,
int len); int len);
SRSLTE_API void scrambling_f(sequence_t *s, SRSLTE_API void scrambling_f(srslte_sequence_t *s,
float *data); float *data);
SRSLTE_API void scrambling_f_offset(sequence_t *s, SRSLTE_API void scrambling_f_offset(srslte_sequence_t *s,
float *data, float *data,
int offset, int offset,
int len); int len);
SRSLTE_API void scrambling_c(sequence_t *s, SRSLTE_API void scrambling_c(srslte_sequence_t *s,
cf_t *data); cf_t *data);
SRSLTE_API void scrambling_c_offset(sequence_t *s, SRSLTE_API void scrambling_c_offset(srslte_sequence_t *s,
cf_t *data, cf_t *data,
int offset, int offset,
int len); int len);
@ -77,7 +77,7 @@ SRSLTE_API void scrambling_c_offset(sequence_t *s,
#define SCRAMBLING_PUCCH 5 #define SCRAMBLING_PUCCH 5
typedef struct SRSLTE_API { typedef struct SRSLTE_API {
sequence_t seq[SRSLTE_NSUBFRAMES_X_FRAME]; srslte_sequence_t seq[SRSLTE_NSUBFRAMES_X_FRAME];
}scrambling_t; }scrambling_t;
typedef struct SRSLTE_API { typedef struct SRSLTE_API {

4
srslte/include/srslte/ue/ue_cell_search.h
Unescape Escape View File

@ -86,12 +86,12 @@ typedef struct SRSLTE_API {
SRSLTE_API int ue_cell_search_init(ue_cell_search_t *q, SRSLTE_API int ue_cell_search_init(ue_cell_search_t *q,
int (recv_callback)(void*, void*, uint32_t,timestamp_t*), int (recv_callback)(void*, void*, uint32_t,srslte_timestamp_t*),
void *stream_handler); void *stream_handler);
SRSLTE_API int ue_cell_search_init_max(ue_cell_search_t *q, SRSLTE_API int ue_cell_search_init_max(ue_cell_search_t *q,
uint32_t max_frames_total, uint32_t max_frames_total,
int (recv_callback)(void*, void*, uint32_t,timestamp_t*), int (recv_callback)(void*, void*, uint32_t,srslte_timestamp_t*),
void *stream_handler); void *stream_handler);
SRSLTE_API void ue_cell_search_free(ue_cell_search_t *q); SRSLTE_API void ue_cell_search_free(ue_cell_search_t *q);

2
srslte/include/srslte/ue/ue_mib.h
Unescape Escape View File

@ -104,7 +104,7 @@ typedef struct {
SRSLTE_API int ue_mib_sync_init(ue_mib_sync_t *q, SRSLTE_API int ue_mib_sync_init(ue_mib_sync_t *q,
uint32_t cell_id, uint32_t cell_id,
srslte_cp_t cp, srslte_cp_t cp,
int (recv_callback)(void*, void*, uint32_t, timestamp_t *), int (recv_callback)(void*, void*, uint32_t, srslte_timestamp_t *),
void *stream_handler); void *stream_handler);
SRSLTE_API void ue_mib_sync_free(ue_mib_sync_t *q); SRSLTE_API void ue_mib_sync_free(ue_mib_sync_t *q);

4
srslte/include/srslte/ue/ue_phy.h
Unescape Escape View File

@ -118,12 +118,12 @@ public:
public: public:
dl_tb(uint32_t max_dlsch_bits); dl_tb(uint32_t max_dlsch_bits);
uint16_t get_rnti(); uint16_t get_rnti();
bool is_crc_valid(); bool is_srslte_crc_valid();
uint8_t* get_dlsch_payload(); uint8_t* get_dlsch_payload();
private: private:
uint8_t* dlsch_buffer; uint8_t* dlsch_buffer;
uint16_t rnti; uint16_t rnti;
bool crc_result; bool srslte_crc_result;
}; };
class dl_grant : public queue::element { class dl_grant : public queue::element {

10
srslte/include/srslte/ue/ue_sync.h
Unescape Escape View File

@ -65,10 +65,10 @@ typedef struct SRSLTE_API {
sync_t strack; sync_t strack;
void *stream; void *stream;
int (*recv_callback)(void*, void*, uint32_t, timestamp_t*); int (*recv_callback)(void*, void*, uint32_t, srslte_timestamp_t*);
timestamp_t last_timestamp; srslte_timestamp_t last_timestamp;
filesource_t file_source; srslte_filesource_t file_source;
bool file_mode; bool file_mode;
ue_sync_state_t state; ue_sync_state_t state;
@ -107,7 +107,7 @@ typedef struct SRSLTE_API {
SRSLTE_API int ue_sync_init(ue_sync_t *q, SRSLTE_API int ue_sync_init(ue_sync_t *q,
srslte_cell_t cell, srslte_cell_t cell,
int (recv_callback)(void*, void*, uint32_t, timestamp_t*), int (recv_callback)(void*, void*, uint32_t, srslte_timestamp_t*),
void *stream_handler); void *stream_handler);
SRSLTE_API int ue_sync_init_file(ue_sync_t *q, SRSLTE_API int ue_sync_init_file(ue_sync_t *q,
@ -138,7 +138,7 @@ SRSLTE_API float ue_sync_get_cfo(ue_sync_t *q);
SRSLTE_API float ue_sync_get_sfo(ue_sync_t *q); SRSLTE_API float ue_sync_get_sfo(ue_sync_t *q);
SRSLTE_API void ue_sync_get_last_timestamp(ue_sync_t *q, SRSLTE_API void ue_sync_get_last_timestamp(ue_sync_t *q,
timestamp_t *timestamp); srslte_timestamp_t *timestamp);

12
srslte/lib/ch_estimation/src/refsignal_dl.c
Unescape Escape View File

@ -109,7 +109,7 @@ int srslte_refsignal_cs_init(srslte_refsignal_cs_t * q, srslte_cell_t cell)
uint32_t c_init; uint32_t c_init;
uint32_t i, ns, l, p; uint32_t i, ns, l, p;
uint32_t N_cp, mp; uint32_t N_cp, mp;
sequence_t seq; srslte_sequence_t seq;
int ret = SRSLTE_ERROR_INVALID_INPUTS; int ret = SRSLTE_ERROR_INVALID_INPUTS;
if (q != NULL && if (q != NULL &&
@ -118,8 +118,8 @@ int srslte_refsignal_cs_init(srslte_refsignal_cs_t * q, srslte_cell_t cell)
ret = SRSLTE_ERROR; ret = SRSLTE_ERROR;
bzero(q, sizeof(srslte_refsignal_cs_t)); bzero(q, sizeof(srslte_refsignal_cs_t));
bzero(&seq, sizeof(sequence_t)); bzero(&seq, sizeof(srslte_sequence_t));
if (sequence_init(&seq, 2 * 2 * SRSLTE_MAX_PRB)) { if (srslte_sequence_init(&seq, 2 * 2 * SRSLTE_MAX_PRB)) {
goto free_and_exit; goto free_and_exit;
} }
@ -151,7 +151,7 @@ int srslte_refsignal_cs_init(srslte_refsignal_cs_t * q, srslte_cell_t cell)
+ 2 * cell.id + N_cp; + 2 * cell.id + N_cp;
/* generate sequence for this symbol and slot */ /* generate sequence for this symbol and slot */
sequence_set_LTE_pr(&seq, c_init); srslte_sequence_set_LTE_pr(&seq, c_init);
/* Compute signal */ /* Compute signal */
for (i = 0; i < 2*q->cell.nof_prb; i++) { for (i = 0; i < 2*q->cell.nof_prb; i++) {
@ -165,12 +165,12 @@ int srslte_refsignal_cs_init(srslte_refsignal_cs_t * q, srslte_cell_t cell)
} }
} }
sequence_free(&seq); srslte_sequence_free(&seq);
ret = SRSLTE_SUCCESS; ret = SRSLTE_SUCCESS;
} }
free_and_exit: free_and_exit:
if (ret == SRSLTE_ERROR) { if (ret == SRSLTE_ERROR) {
sequence_free(&seq); srslte_sequence_free(&seq);
srslte_refsignal_cs_free(q); srslte_refsignal_cs_free(q);
} }
return ret; return ret;

30
srslte/lib/ch_estimation/src/refsignal_ul.c
Unescape Escape View File

@ -68,12 +68,12 @@ static int generate_n_prs(srslte_refsignal_ul_t * q) {
/* Calculate n_prs */ /* Calculate n_prs */
uint32_t c_init; uint32_t c_init;
sequence_t seq; srslte_sequence_t seq;
bzero(&seq, sizeof(sequence_t)); bzero(&seq, sizeof(srslte_sequence_t));
for (uint32_t delta_ss=0;delta_ss<SRSLTE_NOF_DELTA_SS;delta_ss++) { for (uint32_t delta_ss=0;delta_ss<SRSLTE_NOF_DELTA_SS;delta_ss++) {
c_init = ((q->cell.id / 30) << 5) + (((q->cell.id % 30) + delta_ss) % 30); c_init = ((q->cell.id / 30) << 5) + (((q->cell.id % 30) + delta_ss) % 30);
if (sequence_LTE_pr(&seq, 8 * SRSLTE_CP_NSYMB(q->cell.cp) * 20, c_init)) { if (srslte_sequence_LTE_pr(&seq, 8 * SRSLTE_CP_NSYMB(q->cell.cp) * 20, c_init)) {
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
for (uint32_t ns=0;ns<SRSLTE_NSLOTS_X_FRAME;ns++) { for (uint32_t ns=0;ns<SRSLTE_NSLOTS_X_FRAME;ns++) {
@ -85,16 +85,16 @@ static int generate_n_prs(srslte_refsignal_ul_t * q) {
} }
} }
sequence_free(&seq); srslte_sequence_free(&seq);
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;
} }
/** Computes sequence-group pattern f_gh according to 5.5.1.3 of 36.211 */ /** Computes sequence-group pattern f_gh according to 5.5.1.3 of 36.211 */
static int generate_group_hopping_f_gh(srslte_refsignal_ul_t *q) { static int generate_group_hopping_f_gh(srslte_refsignal_ul_t *q) {
sequence_t seq; srslte_sequence_t seq;
bzero(&seq, sizeof(sequence_t)); bzero(&seq, sizeof(srslte_sequence_t));
if (sequence_LTE_pr(&seq, 160, q->cell.id / 30)) { if (srslte_sequence_LTE_pr(&seq, 160, q->cell.id / 30)) {
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
@ -106,23 +106,23 @@ static int generate_group_hopping_f_gh(srslte_refsignal_ul_t *q) {
q->f_gh[ns] = f_gh; q->f_gh[ns] = f_gh;
} }
sequence_free(&seq); srslte_sequence_free(&seq);
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;
} }
static int generate_sequence_hopping_v(srslte_refsignal_ul_t *q) { static int generate_srslte_sequence_hopping_v(srslte_refsignal_ul_t *q) {
sequence_t seq; srslte_sequence_t seq;
bzero(&seq, sizeof(sequence_t)); bzero(&seq, sizeof(srslte_sequence_t));
for (uint32_t ns=0;ns<SRSLTE_NSLOTS_X_FRAME;ns++) { for (uint32_t ns=0;ns<SRSLTE_NSLOTS_X_FRAME;ns++) {
for (uint32_t delta_ss=0;delta_ss<SRSLTE_NOF_DELTA_SS;delta_ss++) { for (uint32_t delta_ss=0;delta_ss<SRSLTE_NOF_DELTA_SS;delta_ss++) {
if (sequence_LTE_pr(&seq, 20, ((q->cell.id / 30) << 5) + ((q->cell.id%30)+delta_ss)%30)) { if (srslte_sequence_LTE_pr(&seq, 20, ((q->cell.id / 30) << 5) + ((q->cell.id%30)+delta_ss)%30)) {
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
q->v_pusch[ns][delta_ss] = seq.c[ns]; q->v_pusch[ns][delta_ss] = seq.c[ns];
} }
} }
sequence_free(&seq); srslte_sequence_free(&seq);
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;
} }
@ -158,7 +158,7 @@ int srslte_refsignal_ul_init(srslte_refsignal_ul_t * q, srslte_cell_t cell)
} }
// Precompute sequence hopping values v. Uses f_ss_pusch // Precompute sequence hopping values v. Uses f_ss_pusch
if (generate_sequence_hopping_v(q)) { if (generate_srslte_sequence_hopping_v(q)) {
goto free_and_exit; goto free_and_exit;
} }
@ -297,7 +297,7 @@ int srslte_refsignal_dmrs_pusch_gen(srslte_refsignal_ul_t *q, srslte_refsignal_d
// Get sequence hopping number v // Get sequence hopping number v
uint32_t v = 0; uint32_t v = 0;
if (nof_prb >= 6 && cfg->sequence_hopping_en) { if (nof_prb >= 6 && cfg->srslte_sequence_hopping_en) {
v = q->v_pusch[ns][cfg->delta_ss]; v = q->v_pusch[ns][cfg->delta_ss];
} }

2
srslte/lib/ch_estimation/test/chest_test_dl_mex.c
Unescape Escape View File

@ -204,7 +204,7 @@ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
predecoding_single(&cheq, input_signal, ce[0], output_signal2, nof_re, srslte_chest_dl_get_noise_estimate(&chest)); predecoding_single(&cheq, input_signal, ce[0], output_signal2, nof_re, srslte_chest_dl_get_noise_estimate(&chest));
} else { } else {
predecoding_diversity(&cheq, input_signal, ce, output_signal, cell.nof_ports, nof_re, srslte_chest_dl_get_noise_estimate(&chest)); predecoding_diversity(&cheq, input_signal, ce, output_signal, cell.nof_ports, nof_re, srslte_chest_dl_get_noise_estimate(&chest));
layerdemap_diversity(output_signal, output_signal2, cell.nof_ports, nof_re/cell.nof_ports); srslte_layerdemap_diversity(output_signal, output_signal2, cell.nof_ports, nof_re/cell.nof_ports);
} }
if (nlhs >= 1) { if (nlhs >= 1) {

4
srslte/lib/ch_estimation/test/refsignal_pusch_mex.c
Unescape Escape View File

@ -77,13 +77,13 @@ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
pusch_cfg.group_hopping_en = false; pusch_cfg.group_hopping_en = false;
pusch_cfg.sequence_hopping_en = false; pusch_cfg.srslte_sequence_hopping_en = false;
char *tmp = mexutils_get_char_struct(UECFG, "Hopping"); char *tmp = mexutils_get_char_struct(UECFG, "Hopping");
if (tmp) { if (tmp) {
if (!strcmp(tmp, "Group")) { if (!strcmp(tmp, "Group")) {
pusch_cfg.group_hopping_en = true; pusch_cfg.group_hopping_en = true;
} else if (!strcmp(tmp, "Sequence")) { } else if (!strcmp(tmp, "Sequence")) {
pusch_cfg.sequence_hopping_en = true; pusch_cfg.srslte_sequence_hopping_en = true;
} }
mxFree(tmp); mxFree(tmp);
} }

6
srslte/lib/ch_estimation/test/refsignal_ul_test.c
Unescape Escape View File

@ -108,13 +108,13 @@ int main(int argc, char **argv) {
pusch_cfg.delta_ss = delta_ss; pusch_cfg.delta_ss = delta_ss;
if (!h) { if (!h) {
pusch_cfg.group_hopping_en = false; pusch_cfg.group_hopping_en = false;
pusch_cfg.sequence_hopping_en = false; pusch_cfg.srslte_sequence_hopping_en = false;
} else if (h == 1) { } else if (h == 1) {
pusch_cfg.group_hopping_en = false; pusch_cfg.group_hopping_en = false;
pusch_cfg.sequence_hopping_en = true; pusch_cfg.srslte_sequence_hopping_en = true;
} else if (h == 2) { } else if (h == 2) {
pusch_cfg.group_hopping_en = true; pusch_cfg.group_hopping_en = true;
pusch_cfg.sequence_hopping_en = false; pusch_cfg.srslte_sequence_hopping_en = false;
} }
pusch_cfg.en_drms_2 = true; pusch_cfg.en_drms_2 = true;
printf("Beta: %f, ",pusch_cfg.beta_pusch); printf("Beta: %f, ",pusch_cfg.beta_pusch);

14
srslte/lib/common/src/sequence.c
Unescape Escape View File

@ -40,7 +40,7 @@
* It follows the 3GPP Release 8 (LTE) 36.211 * It follows the 3GPP Release 8 (LTE) 36.211
* Section 7.2 * Section 7.2
*/ */
void sequence_set_LTE_pr(sequence_t *q, uint32_t seed) { void srslte_sequence_set_LTE_pr(srslte_sequence_t *q, uint32_t seed) {
int n; int n;
uint32_t *x1, *x2; uint32_t *x1, *x2;
@ -74,16 +74,16 @@ void sequence_set_LTE_pr(sequence_t *q, uint32_t seed) {
free(x2); free(x2);
} }
int sequence_LTE_pr(sequence_t *q, uint32_t len, uint32_t seed) { int srslte_sequence_LTE_pr(srslte_sequence_t *q, uint32_t len, uint32_t seed) {
if (sequence_init(q, len)) { if (srslte_sequence_init(q, len)) {
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
q->len = len; q->len = len;
sequence_set_LTE_pr(q, seed); srslte_sequence_set_LTE_pr(q, seed);
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;
} }
int sequence_init(sequence_t *q, uint32_t len) { int srslte_sequence_init(srslte_sequence_t *q, uint32_t len) {
if (q->c && (q->len != len)) { if (q->c && (q->len != len)) {
free(q->c); free(q->c);
} }
@ -97,11 +97,11 @@ int sequence_init(sequence_t *q, uint32_t len) {
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;
} }
void sequence_free(sequence_t *q) { void srslte_sequence_free(srslte_sequence_t *q) {
if (q->c) { if (q->c) {
free(q->c); free(q->c);
} }
bzero(q, sizeof(sequence_t)); bzero(q, sizeof(srslte_sequence_t));
} }

10
srslte/lib/common/src/timestamp.c
Unescape Escape View File

@ -28,7 +28,7 @@
#include "srslte/common/timestamp.h" #include "srslte/common/timestamp.h"
#include "math.h" #include "math.h"
int timestamp_init(timestamp_t *t, time_t full_secs, double frac_secs){ int srslte_timestamp_init(srslte_timestamp_t *t, time_t full_secs, double frac_secs){
int ret = SRSLTE_ERROR; int ret = SRSLTE_ERROR;
if(t != NULL && frac_secs >= 0.0){ if(t != NULL && frac_secs >= 0.0){
t->full_secs = full_secs; t->full_secs = full_secs;
@ -38,7 +38,7 @@ int timestamp_init(timestamp_t *t, time_t full_secs, double frac_secs){
return ret; return ret;
} }
int timestamp_copy(timestamp_t *dest, timestamp_t *src){ int srslte_timestamp_copy(srslte_timestamp_t *dest, srslte_timestamp_t *src){
int ret = SRSLTE_ERROR; int ret = SRSLTE_ERROR;
if(dest != NULL && src != NULL){ if(dest != NULL && src != NULL){
dest->full_secs = src->full_secs; dest->full_secs = src->full_secs;
@ -48,7 +48,7 @@ int timestamp_copy(timestamp_t *dest, timestamp_t *src){
return ret; return ret;
} }
int timestamp_add(timestamp_t *t, time_t full_secs, double frac_secs){ int srslte_timestamp_add(srslte_timestamp_t *t, time_t full_secs, double frac_secs){
int ret = SRSLTE_ERROR; int ret = SRSLTE_ERROR;
if(t != NULL && frac_secs >= 0.0){ if(t != NULL && frac_secs >= 0.0){
t->frac_secs += frac_secs; t->frac_secs += frac_secs;
@ -61,7 +61,7 @@ int timestamp_add(timestamp_t *t, time_t full_secs, double frac_secs){
return ret; return ret;
} }
int timestamp_sub(timestamp_t *t, time_t full_secs, double frac_secs){ int srslte_timestamp_sub(srslte_timestamp_t *t, time_t full_secs, double frac_secs){
int ret = SRSLTE_ERROR; int ret = SRSLTE_ERROR;
if(t != NULL && frac_secs >= 0.0){ if(t != NULL && frac_secs >= 0.0){
t->frac_secs -= frac_secs; t->frac_secs -= frac_secs;
@ -77,6 +77,6 @@ int timestamp_sub(timestamp_t *t, time_t full_secs, double frac_secs){
return ret; return ret;
} }
double timestamp_real(timestamp_t *t){ double srslte_timestamp_real(srslte_timestamp_t *t){
return t->frac_secs + t->full_secs; return t->frac_secs + t->full_secs;
} }

10
srslte/lib/fec/src/convcoder.c
Unescape Escape View File

@ -34,7 +34,7 @@
#include "srslte/fec/convcoder.h" #include "srslte/fec/convcoder.h"
#include "parity.h" #include "parity.h"
int convcoder_encode(convcoder_t *q, uint8_t *input, uint8_t *output, uint32_t frame_length) { int srslte_convcoder_encode(srslte_convcoder_t *q, uint8_t *input, uint8_t *output, uint32_t frame_length) {
uint32_t sr; uint32_t sr;
uint32_t i,j; uint32_t i,j;
uint32_t len = q->tail_biting ? frame_length : (frame_length + q->K - 1); uint32_t len = q->tail_biting ? frame_length : (frame_length + q->K - 1);
@ -67,11 +67,11 @@ int convcoder_encode(convcoder_t *q, uint8_t *input, uint8_t *output, uint32_t f
int convcoder_initialize(convcoder_hl* h) { int srslte_convcoder_initialize(srslte_convcoder_hl* h) {
return 0; return 0;
} }
int convcoder_work(convcoder_hl* hl) { int srslte_convcoder_work(srslte_convcoder_hl* hl) {
hl->obj.K = hl->ctrl_in.constraint_length; hl->obj.K = hl->ctrl_in.constraint_length;
hl->obj.R = hl->ctrl_in.rate; hl->obj.R = hl->ctrl_in.rate;
@ -79,10 +79,10 @@ int convcoder_work(convcoder_hl* hl) {
hl->obj.poly[1] = hl->ctrl_in.generator_1; hl->obj.poly[1] = hl->ctrl_in.generator_1;
hl->obj.poly[2] = hl->ctrl_in.generator_2; hl->obj.poly[2] = hl->ctrl_in.generator_2;
hl->obj.tail_biting = hl->ctrl_in.tail_bitting?true:false; hl->obj.tail_biting = hl->ctrl_in.tail_bitting?true:false;
hl->out_len = convcoder_encode(&hl->obj, hl->input, hl->output, hl->in_len); hl->out_len = srslte_convcoder_encode(&hl->obj, hl->input, hl->output, hl->in_len);
return 0; return 0;
} }
int convcoder_stop(convcoder_hl* h) { int srslte_convcoder_stop(srslte_convcoder_hl* h) {
return 0; return 0;
} }

36
srslte/lib/fec/src/crc.c
Unescape Escape View File

@ -32,7 +32,7 @@
#include "srslte/utils/pack.h" #include "srslte/utils/pack.h"
#include "srslte/fec/crc.h" #include "srslte/fec/crc.h"
void gen_crc_table(crc_t *h) { void gen_srslte_crc_table(srslte_crc_t *h) {
int i, j, ord = (h->order - 8); int i, j, ord = (h->order - 8);
unsigned long bit, crc; unsigned long bit, crc;
@ -49,7 +49,7 @@ void gen_crc_table(crc_t *h) {
} }
} }
unsigned long crctable(crc_t *h) { unsigned long crctable(srslte_crc_t *h) {
// Polynom order 8, 16, 24 or 32 only. // Polynom order 8, 16, 24 or 32 only.
int ord = h->order - 8; int ord = h->order - 8;
@ -61,7 +61,7 @@ unsigned long crctable(crc_t *h) {
return (crc & h->crcmask); return (crc & h->crcmask);
} }
unsigned long reversecrcbit(uint32_t crc, int nbits, crc_t *h) { unsigned long reversecrcbit(uint32_t crc, int nbits, srslte_crc_t *h) {
unsigned long m, rmask = 0x1; unsigned long m, rmask = 0x1;
@ -74,21 +74,21 @@ unsigned long reversecrcbit(uint32_t crc, int nbits, crc_t *h) {
return (crc & h->crcmask); return (crc & h->crcmask);
} }
int crc_set_init(crc_t *crc_par, unsigned long crc_init_value) { int srslte_crc_set_init(srslte_crc_t *srslte_crc_par, unsigned long srslte_crc_init_value) {
crc_par->crcinit = crc_init_value; srslte_crc_par->crcinit = srslte_crc_init_value;
if (crc_par->crcinit != (crc_par->crcinit & crc_par->crcmask)) { if (srslte_crc_par->crcinit != (srslte_crc_par->crcinit & srslte_crc_par->crcmask)) {
printf("ERROR, invalid crcinit in crc_set_init().\n"); printf("ERROR, invalid crcinit in srslte_crc_set_init().\n");
return -1; return -1;
} }
return 0; return 0;
} }
int crc_init(crc_t *h, uint32_t crc_poly, int crc_order) { int srslte_crc_init(srslte_crc_t *h, uint32_t srslte_crc_poly, int srslte_crc_order) {
// Set crc working default parameters // Set crc working default parameters
h->polynom = crc_poly; h->polynom = srslte_crc_poly;
h->order = crc_order; h->order = srslte_crc_order;
h->crcinit = 0x00000000; h->crcinit = 0x00000000;
// Compute bit masks for whole CRC and CRC high bit // Compute bit masks for whole CRC and CRC high bit
@ -103,23 +103,23 @@ int crc_init(crc_t *h, uint32_t crc_poly, int crc_order) {
return -1; return -1;
} }
if (crc_set_init(h, h->crcinit)) { if (srslte_crc_set_init(h, h->crcinit)) {
fprintf(stderr, "Error setting CRC init word\n"); fprintf(stderr, "Error setting CRC init word\n");
return -1; return -1;
} }
// generate lookup table // generate lookup table
gen_crc_table(h); gen_srslte_crc_table(h);
return 0; return 0;
} }
uint32_t crc_checksum(crc_t *h, uint8_t *data, int len) { uint32_t srslte_crc_checksum(srslte_crc_t *h, uint8_t *data, int len) {
int i, k, len8, res8, a = 0; int i, k, len8, res8, a = 0;
uint32_t crc = 0; uint32_t crc = 0;
uint8_t *pter; uint8_t *pter;
crc_set_init(h, 0); srslte_crc_set_init(h, 0);
// Pack bits into bytes // Pack bits into bytes
len8 = (len >> 3); len8 = (len >> 3);
@ -152,11 +152,11 @@ uint32_t crc_checksum(crc_t *h, uint8_t *data, int len) {
} }
/** Appends crc_order checksum bits to the buffer data. /** Appends srslte_crc_order checksum bits to the buffer data.
* The buffer data must be len + crc_order bytes * The buffer data must be len + srslte_crc_order bytes
*/ */
void crc_attach(crc_t *h, uint8_t *data, int len) { void srslte_crc_attach(srslte_crc_t *h, uint8_t *data, int len) {
uint32_t checksum = crc_checksum(h, data, len); uint32_t checksum = srslte_crc_checksum(h, data, len);
// Add CRC // Add CRC
uint8_t *ptr = &data[len]; uint8_t *ptr = &data[len];

26
srslte/lib/fec/src/rm_conv.c
Unescape Escape View File

@ -40,7 +40,7 @@ uint8_t RM_PERM_CC_INV[NCOLS] =
{ 16, 0, 24, 8, 20, 4, 28, 12, 18, 2, 26, 10, 22, 6, 30, 14, 17, 1, 25, 9, { 16, 0, 24, 8, 20, 4, 28, 12, 18, 2, 26, 10, 22, 6, 30, 14, 17, 1, 25, 9,
21, 5, 29, 13, 19, 3, 27, 11, 23, 7, 31, 15 }; 21, 5, 29, 13, 19, 3, 27, 11, 23, 7, 31, 15 };
int rm_conv_tx(uint8_t *input, uint32_t in_len, uint8_t *output, uint32_t out_len) { int srslte_rm_conv_tx(uint8_t *input, uint32_t in_len, uint8_t *output, uint32_t out_len) {
uint8_t tmp[3 * NCOLS * NROWS_MAX]; uint8_t tmp[3 * NCOLS * NROWS_MAX];
int nrows, ndummy, K_p; int nrows, ndummy, K_p;
@ -64,7 +64,7 @@ int rm_conv_tx(uint8_t *input, uint32_t in_len, uint8_t *output, uint32_t out_le
for (j = 0; j < NCOLS; j++) { for (j = 0; j < NCOLS; j++) {
for (i = 0; i < nrows; i++) { for (i = 0; i < nrows; i++) {
if (i * NCOLS + RM_PERM_CC[j] < ndummy) { if (i * NCOLS + RM_PERM_CC[j] < ndummy) {
tmp[k] = TX_NULL; tmp[k] = SRSLTE_TX_NULL;
} else { } else {
tmp[k] = input[(i * NCOLS + RM_PERM_CC[j] - ndummy) * 3 + s]; tmp[k] = input[(i * NCOLS + RM_PERM_CC[j] - ndummy) * 3 + s];
} }
@ -76,7 +76,7 @@ int rm_conv_tx(uint8_t *input, uint32_t in_len, uint8_t *output, uint32_t out_le
k = 0; k = 0;
j = 0; j = 0;
while (k < out_len) { while (k < out_len) {
if (tmp[j] != TX_NULL) { if (tmp[j] != SRSLTE_TX_NULL) {
output[k] = tmp[j]; output[k] = tmp[j];
k++; k++;
} }
@ -91,7 +91,7 @@ int rm_conv_tx(uint8_t *input, uint32_t in_len, uint8_t *output, uint32_t out_le
/* Undoes Convolutional Code Rate Matching. /* Undoes Convolutional Code Rate Matching.
* 3GPP TS 36.212 v10.1.0 section 5.1.4.2 * 3GPP TS 36.212 v10.1.0 section 5.1.4.2
*/ */
int rm_conv_rx(float *input, uint32_t in_len, float *output, uint32_t out_len) { int srslte_rm_conv_rx(float *input, uint32_t in_len, float *output, uint32_t out_len) {
int nrows, ndummy, K_p; int nrows, ndummy, K_p;
int i, j, k; int i, j, k;
@ -113,7 +113,7 @@ int rm_conv_rx(float *input, uint32_t in_len, float *output, uint32_t out_len) {
} }
for (i = 0; i < 3 * K_p; i++) { for (i = 0; i < 3 * K_p; i++) {
tmp[i] = RX_NULL; tmp[i] = SRSLTE_RX_NULL;
} }
/* Undo bit collection. Account for dummy bits */ /* Undo bit collection. Account for dummy bits */
@ -124,9 +124,9 @@ int rm_conv_rx(float *input, uint32_t in_len, float *output, uint32_t out_len) {
d_j = (j % K_p) % nrows; d_j = (j % K_p) % nrows;
if (d_j * NCOLS + RM_PERM_CC[d_i] >= ndummy) { if (d_j * NCOLS + RM_PERM_CC[d_i] >= ndummy) {
if (tmp[j] == RX_NULL) { if (tmp[j] == SRSLTE_RX_NULL) {
tmp[j] = input[k]; tmp[j] = input[k];
} else if (input[k] != RX_NULL) { } else if (input[k] != SRSLTE_RX_NULL) {
tmp[j] += input[k]; /* soft combine LLRs */ tmp[j] += input[k]; /* soft combine LLRs */
} }
k++; k++;
@ -143,7 +143,7 @@ int rm_conv_rx(float *input, uint32_t in_len, float *output, uint32_t out_len) {
d_j = (i + ndummy) % NCOLS; d_j = (i + ndummy) % NCOLS;
for (j = 0; j < 3; j++) { for (j = 0; j < 3; j++) {
float o = tmp[K_p * j + RM_PERM_CC_INV[d_j] * nrows + d_i]; float o = tmp[K_p * j + RM_PERM_CC_INV[d_j] * nrows + d_i];
if (o != RX_NULL) { if (o != SRSLTE_RX_NULL) {
output[i * 3 + j] = o; output[i * 3 + j] = o;
} else { } else {
output[i * 3 + j] = 0; output[i * 3 + j] = 0;
@ -155,24 +155,24 @@ int rm_conv_rx(float *input, uint32_t in_len, float *output, uint32_t out_len) {
/** High-level API */ /** High-level API */
int rm_conv_initialize(rm_conv_hl* h) { int srslte_rm_conv_initialize(srslte_rm_conv_hl* h) {
return 0; return 0;
} }
/** This function can be called in a subframe (1ms) basis */ /** This function can be called in a subframe (1ms) basis */
int rm_conv_work(rm_conv_hl* hl) { int srslte_rm_conv_work(srslte_rm_conv_hl* hl) {
if (hl->init.direction) { if (hl->init.direction) {
rm_conv_tx(hl->input, hl->in_len, hl->output, hl->ctrl_in.E); srslte_rm_conv_tx(hl->input, hl->in_len, hl->output, hl->ctrl_in.E);
hl->out_len = hl->ctrl_in.E; hl->out_len = hl->ctrl_in.E;
} else { } else {
rm_conv_rx(hl->input, hl->in_len, hl->output, hl->ctrl_in.S); srslte_rm_conv_rx(hl->input, hl->in_len, hl->output, hl->ctrl_in.S);
hl->out_len = hl->ctrl_in.S; hl->out_len = hl->ctrl_in.S;
} }
return 0; return 0;
} }
int rm_conv_stop(rm_conv_hl* hl) { int srslte_rm_conv_stop(srslte_rm_conv_hl* hl) {
return 0; return 0;
} }

24
srslte/lib/fec/src/rm_turbo.c
Unescape Escape View File

@ -53,7 +53,7 @@ uint8_t RM_PERM_TC[NCOLS] = { 0, 16, 8, 24, 4, 20, 12, 28, 2, 18, 10, 26,
* *
* TODO: Soft buffer size limitation according to UE category * TODO: Soft buffer size limitation according to UE category
*/ */
int rm_turbo_tx(uint8_t *w_buff, uint32_t w_buff_len, uint8_t *input, uint32_t in_len, uint8_t *output, int srslte_rm_turbo_tx(uint8_t *w_buff, uint32_t w_buff_len, uint8_t *input, uint32_t in_len, uint8_t *output,
uint32_t out_len, uint32_t rv_idx) { uint32_t out_len, uint32_t rv_idx) {
int ndummy, kidx; int ndummy, kidx;
@ -92,7 +92,7 @@ int rm_turbo_tx(uint8_t *w_buff, uint32_t w_buff_len, uint8_t *input, uint32_t i
kidx = K_p + 2 * (k % K_p); kidx = K_p + 2 * (k % K_p);
} }
if (i * NCOLS + RM_PERM_TC[j] < ndummy) { if (i * NCOLS + RM_PERM_TC[j] < ndummy) {
w_buff[kidx] = TX_NULL; w_buff[kidx] = SRSLTE_TX_NULL;
} else { } else {
w_buff[kidx] = input[(i * NCOLS + RM_PERM_TC[j] - ndummy) * 3 + s]; w_buff[kidx] = input[(i * NCOLS + RM_PERM_TC[j] - ndummy) * 3 + s];
} }
@ -105,7 +105,7 @@ int rm_turbo_tx(uint8_t *w_buff, uint32_t w_buff_len, uint8_t *input, uint32_t i
for (k = 0; k < K_p; k++) { for (k = 0; k < K_p; k++) {
kidx = (RM_PERM_TC[k / nrows] + NCOLS * (k % nrows) + 1) % K_p; kidx = (RM_PERM_TC[k / nrows] + NCOLS * (k % nrows) + 1) % K_p;
if ((kidx - ndummy) < 0) { if ((kidx - ndummy) < 0) {
w_buff[K_p + 2 * k + 1] = TX_NULL; w_buff[K_p + 2 * k + 1] = SRSLTE_TX_NULL;
} else { } else {
w_buff[K_p + 2 * k + 1] = input[3 * (kidx - ndummy) + 2]; w_buff[K_p + 2 * k + 1] = input[3 * (kidx - ndummy) + 2];
} }
@ -121,7 +121,7 @@ int rm_turbo_tx(uint8_t *w_buff, uint32_t w_buff_len, uint8_t *input, uint32_t i
j = 0; j = 0;
while (k < out_len) { while (k < out_len) {
if (w_buff[(k0 + j) % N_cb] != TX_NULL) { if (w_buff[(k0 + j) % N_cb] != SRSLTE_TX_NULL) {
output[k] = w_buff[(k0 + j) % N_cb]; output[k] = w_buff[(k0 + j) % N_cb];
k++; k++;
} }
@ -136,7 +136,7 @@ int rm_turbo_tx(uint8_t *w_buff, uint32_t w_buff_len, uint8_t *input, uint32_t i
* If rv_idx==0, the w_buff circular buffer is initialized. Every subsequent call * If rv_idx==0, the w_buff circular buffer is initialized. Every subsequent call
* with rv_idx!=0 will soft-combine the LLRs from input with w_buff * with rv_idx!=0 will soft-combine the LLRs from input with w_buff
*/ */
int rm_turbo_rx(float *w_buff, uint32_t w_buff_len, float *input, uint32_t in_len, float *output, int srslte_rm_turbo_rx(float *w_buff, uint32_t w_buff_len, float *input, uint32_t in_len, float *output,
uint32_t out_len, uint32_t rv_idx, uint32_t nof_filler_bits) { uint32_t out_len, uint32_t rv_idx, uint32_t nof_filler_bits) {
int nrows, ndummy, K_p, k0, N_cb, jp, kidx; int nrows, ndummy, K_p, k0, N_cb, jp, kidx;
@ -166,7 +166,7 @@ int rm_turbo_rx(float *w_buff, uint32_t w_buff_len, float *input, uint32_t in_le
if (rv_idx == 0) { if (rv_idx == 0) {
for (i = 0; i < 3 * K_p; i++) { for (i = 0; i < 3 * K_p; i++) {
w_buff[i] = RX_NULL; w_buff[i] = SRSLTE_RX_NULL;
} }
} }
@ -208,9 +208,9 @@ int rm_turbo_rx(float *w_buff, uint32_t w_buff_len, float *input, uint32_t in_le
} }
if (!isdummy) { if (!isdummy) {
if (w_buff[jp] == RX_NULL) { if (w_buff[jp] == SRSLTE_RX_NULL) {
w_buff[jp] = input[k]; w_buff[jp] = input[k];
} else if (input[k] != RX_NULL) { } else if (input[k] != SRSLTE_RX_NULL) {
w_buff[jp] += input[k]; /* soft combine LLRs */ w_buff[jp] += input[k]; /* soft combine LLRs */
} }
k++; k++;
@ -232,7 +232,7 @@ int rm_turbo_rx(float *w_buff, uint32_t w_buff_len, float *input, uint32_t in_le
kidx = (k / NCOLS + nrows * RM_PERM_TC[k % NCOLS]) % K_p; kidx = (k / NCOLS + nrows * RM_PERM_TC[k % NCOLS]) % K_p;
kidx = 2 * kidx + K_p + 1; kidx = 2 * kidx + K_p + 1;
} }
if (w_buff[kidx] != RX_NULL) { if (w_buff[kidx] != SRSLTE_RX_NULL) {
output[i * 3 + j] = w_buff[kidx]; output[i * 3 + j] = w_buff[kidx];
} else { } else {
output[i * 3 + j] = 0; output[i * 3 + j] = 0;
@ -244,16 +244,16 @@ int rm_turbo_rx(float *w_buff, uint32_t w_buff_len, float *input, uint32_t in_le
/** High-level API */ /** High-level API */
int rm_turbo_initialize(rm_turbo_hl* h) { int srslte_rm_turbo_initialize(srslte_rm_turbo_hl* h) {
return 0; return 0;
} }
/** This function can be called in a subframe (1ms) basis */ /** This function can be called in a subframe (1ms) basis */
int rm_turbo_work(rm_turbo_hl* hl) { int srslte_rm_turbo_work(srslte_rm_turbo_hl* hl) {
return 0; return 0;
} }
int rm_turbo_stop(rm_turbo_hl* hl) { int srslte_rm_turbo_stop(srslte_rm_turbo_hl* hl) {
return 0; return 0;
} }

2
srslte/lib/fec/src/tc_interl_lte.c
Unescape Escape View File

@ -66,7 +66,7 @@ const uint32_t f2_list[SRSLTE_NOF_TC_CB_SIZES] = { 10, 12, 42, 16, 18, 20, 22, 2
280, 142, 480, 146, 444, 120, 152, 462, 234, 158, 80, 96, 902, 166, 336, 280, 142, 480, 146, 444, 120, 152, 462, 234, 158, 80, 96, 902, 166, 336,
170, 86, 174, 176, 178, 120, 182, 184, 186, 94, 190, 480 }; 170, 86, 174, 176, 178, 120, 182, 184, 186, 94, 190, 480 };
int tc_interl_LTE_gen(tc_interl_t *h, uint32_t long_cb) { int srs_tc_interl_LTE_gen(srs_tc_interl_t *h, uint32_t long_cb) {
uint32_t cb_table_idx, f1, f2; uint32_t cb_table_idx, f1, f2;
uint64_t i, j; uint64_t i, j;

12
srslte/lib/fec/src/tc_interl_umts.c
Unescape Escape View File

@ -33,7 +33,7 @@
#include "srslte/fec/tc_interl.h" #include "srslte/fec/tc_interl.h"
#include "srslte/fec/turbocoder.h" #include "srslte/fec/turbocoder.h"
#define TURBO_RATE 3 #define TURBO_SRSLTE_TCOD_RATE 3
uint32_t mcd(uint32_t x, uint32_t y); uint32_t mcd(uint32_t x, uint32_t y);
@ -54,7 +54,7 @@ const uint8_t table_v[52] = { 3, 2, 2, 3, 2, 5, 2, 3, 2, 6, 3, 5, 2, 2, 2,
2, 7, 5, 3, 2, 3, 5, 2, 5, 2, 6, 3, 3, 2, 3, 2, 2, 6, 5, 2, 5, 2, 2, 2, 19, 2, 7, 5, 3, 2, 3, 5, 2, 5, 2, 6, 3, 3, 2, 3, 2, 2, 6, 5, 2, 5, 2, 2, 2, 19,
5, 2, 3, 2, 3, 2, 6, 3, 7, 7, 6, 3 }; 5, 2, 3, 2, 3, 2, 6, 3, 7, 7, 6, 3 };
int tc_interl_init(tc_interl_t *h, uint32_t max_long_cb) { int srs_tc_interl_init(srs_tc_interl_t *h, uint32_t max_long_cb) {
int ret = -1; int ret = -1;
h->forward = malloc(sizeof(uint32_t) * max_long_cb); h->forward = malloc(sizeof(uint32_t) * max_long_cb);
if (!h->forward) { if (!h->forward) {
@ -69,22 +69,22 @@ int tc_interl_init(tc_interl_t *h, uint32_t max_long_cb) {
h->max_long_cb = max_long_cb; h->max_long_cb = max_long_cb;
ret = 0; ret = 0;
clean_exit: if (ret == -1) { clean_exit: if (ret == -1) {
tc_interl_free(h); srs_tc_interl_free(h);
} }
return ret; return ret;
} }
void tc_interl_free(tc_interl_t *h) { void srs_tc_interl_free(srs_tc_interl_t *h) {
if (h->forward) { if (h->forward) {
free(h->forward); free(h->forward);
} }
if (h->reverse) { if (h->reverse) {
free(h->reverse); free(h->reverse);
} }
bzero(h, sizeof(tc_interl_t)); bzero(h, sizeof(srs_tc_interl_t));
} }
int tc_interl_UMTS_gen(tc_interl_t *h, uint32_t long_cb) { int srs_tc_interl_UMTS_gen(srs_tc_interl_t *h, uint32_t long_cb) {
uint32_t i, j; uint32_t i, j;
uint32_t res, prim, aux; uint32_t res, prim, aux;

24
srslte/lib/fec/src/turbocoder.c
Unescape Escape View File

@ -33,21 +33,25 @@
#define NOF_REGS 3 #define NOF_REGS 3
int tcod_init(tcod_t *h, uint32_t max_long_cb) { #define RATE 3
#define TOTALTAIL 12
if (tc_interl_init(&h->interl, max_long_cb)) {
int srslte_tcod_init(srslte_tcod_t *h, uint32_t max_long_cb) {
if (srs_tc_interl_init(&h->interl, max_long_cb)) {
return -1; return -1;
} }
h->max_long_cb = max_long_cb; h->max_long_cb = max_long_cb;
return 0; return 0;
} }
void tcod_free(tcod_t *h) { void srslte_tcod_free(srslte_tcod_t *h) {
tc_interl_free(&h->interl); srs_tc_interl_free(&h->interl);
h->max_long_cb = 0; h->max_long_cb = 0;
} }
int tcod_encode(tcod_t *h, uint8_t *input, uint8_t *output, uint32_t long_cb) { int srslte_tcod_encode(srslte_tcod_t *h, uint8_t *input, uint8_t *output, uint32_t long_cb) {
uint8_t reg1_0, reg1_1, reg1_2, reg2_0, reg2_1, reg2_2; uint8_t reg1_0, reg1_1, reg1_2, reg2_0, reg2_1, reg2_2;
uint32_t i, k = 0, j; uint32_t i, k = 0, j;
@ -61,7 +65,7 @@ int tcod_encode(tcod_t *h, uint8_t *input, uint8_t *output, uint32_t long_cb) {
return -1; return -1;
} }
if (tc_interl_LTE_gen(&h->interl, long_cb)) { if (srs_tc_interl_LTE_gen(&h->interl, long_cb)) {
fprintf(stderr, "Error initiating TC interleaver\n"); fprintf(stderr, "Error initiating TC interleaver\n");
return -1; return -1;
} }
@ -78,7 +82,7 @@ int tcod_encode(tcod_t *h, uint8_t *input, uint8_t *output, uint32_t long_cb) {
k = 0; k = 0;
for (i = 0; i < long_cb; i++) { for (i = 0; i < long_cb; i++) {
if (input[i] == TX_NULL) { if (input[i] == SRSLTE_TX_NULL) {
bit = 0; bit = 0;
} else { } else {
bit = input[i]; bit = input[i];
@ -94,15 +98,15 @@ int tcod_encode(tcod_t *h, uint8_t *input, uint8_t *output, uint32_t long_cb) {
reg1_1 = reg1_0; reg1_1 = reg1_0;
reg1_0 = in; reg1_0 = in;
if (input[i] == TX_NULL) { if (input[i] == SRSLTE_TX_NULL) {
output[k] = TX_NULL; output[k] = SRSLTE_TX_NULL;
} else { } else {
output[k] = out; output[k] = out;
} }
k++; k++;
bit = input[per[i]]; bit = input[per[i]];
if (bit == TX_NULL) { if (bit == SRSLTE_TX_NULL) {
bit = 0; bit = 0;
} }

116
srslte/lib/fec/src/turbodecoder.c
Unescape Escape View File

@ -35,20 +35,28 @@
#include "srslte/fec/turbodecoder.h" #include "srslte/fec/turbodecoder.h"
#include "srslte/utils/vector.h" #include "srslte/utils/vector.h"
#define NUMSTATES 8
#define NINPUTS 2
#define TAIL 3
#define TOTALTAIL 12
#define INF 9e4
#define ZERO 9e-4
/************************************************ /************************************************
* *
* MAP_GEN is the MAX-LOG-MAP generic implementation of the * MAP_GEN is the MAX-LOG-MAP generic implementation of the
* Decoder * Decoder
* *
************************************************/ ************************************************/
void map_gen_beta(map_gen_t * s, llr_t * input, llr_t * parity, void srslte_map_gen_beta(srslte_map_gen_t * s, srslte_llr_t * input, srslte_llr_t * parity,
uint32_t long_cb) uint32_t long_cb)
{ {
llr_t m_b[8], new[8], old[8]; srslte_llr_t m_b[8], new[8], old[8];
llr_t x, y, xy; srslte_llr_t x, y, xy;
int k; int k;
uint32_t end = long_cb + RATE; uint32_t end = long_cb + SRSLTE_TCOD_RATE;
llr_t *beta = s->beta; srslte_llr_t *beta = s->beta;
uint32_t i; uint32_t i;
for (i = 0; i < 8; i++) { for (i = 0; i < 8; i++) {
@ -88,16 +96,16 @@ void map_gen_beta(map_gen_t * s, llr_t * input, llr_t * parity,
} }
} }
void map_gen_alpha(map_gen_t * s, llr_t * input, llr_t * parity, llr_t * output, void srslte_map_gen_alpha(srslte_map_gen_t * s, srslte_llr_t * input, srslte_llr_t * parity, srslte_llr_t * output,
uint32_t long_cb) uint32_t long_cb)
{ {
llr_t m_b[8], new[8], old[8], max1[8], max0[8]; srslte_llr_t m_b[8], new[8], old[8], max1[8], max0[8];
llr_t m1, m0; srslte_llr_t m1, m0;
llr_t x, y, xy; srslte_llr_t x, y, xy;
llr_t out; srslte_llr_t out;
uint32_t k; uint32_t k;
uint32_t end = long_cb; uint32_t end = long_cb;
llr_t *beta = s->beta; srslte_llr_t *beta = s->beta;
uint32_t i; uint32_t i;
old[0] = 0; old[0] = 0;
@ -155,10 +163,10 @@ void map_gen_alpha(map_gen_t * s, llr_t * input, llr_t * parity, llr_t * output,
} }
} }
int map_gen_init(map_gen_t * h, int max_long_cb) int srslte_map_gen_init(srslte_map_gen_t * h, int max_long_cb)
{ {
bzero(h, sizeof(map_gen_t)); bzero(h, sizeof(srslte_map_gen_t));
h->beta = vec_malloc(sizeof(llr_t) * (max_long_cb + TOTALTAIL + 1) * NUMSTATES); h->beta = vec_malloc(sizeof(srslte_llr_t) * (max_long_cb + SRSLTE_TCOD_TOTALTAIL + 1) * NUMSTATES);
if (!h->beta) { if (!h->beta) {
perror("vec_malloc"); perror("vec_malloc");
return -1; return -1;
@ -167,15 +175,15 @@ int map_gen_init(map_gen_t * h, int max_long_cb)
return 0; return 0;
} }
void map_gen_free(map_gen_t * h) void srslte_map_gen_free(srslte_map_gen_t * h)
{ {
if (h->beta) { if (h->beta) {
free(h->beta); free(h->beta);
} }
bzero(h, sizeof(map_gen_t)); bzero(h, sizeof(srslte_map_gen_t));
} }
void map_gen_dec(map_gen_t * h, llr_t * input, llr_t * parity, llr_t * output, void srslte_map_gen_dec(srslte_map_gen_t * h, srslte_llr_t * input, srslte_llr_t * parity, srslte_llr_t * output,
uint32_t long_cb) uint32_t long_cb)
{ {
uint32_t k; uint32_t k;
@ -184,8 +192,8 @@ void map_gen_dec(map_gen_t * h, llr_t * input, llr_t * parity, llr_t * output,
for (k = 1; k < NUMSTATES; k++) for (k = 1; k < NUMSTATES; k++)
h->beta[(long_cb + TAIL) * NUMSTATES + k] = -INF; h->beta[(long_cb + TAIL) * NUMSTATES + k] = -INF;
map_gen_beta(h, input, parity, long_cb); srslte_map_gen_beta(h, input, parity, long_cb);
map_gen_alpha(h, input, parity, output, long_cb); srslte_map_gen_alpha(h, input, parity, output, long_cb);
} }
/************************************************ /************************************************
@ -193,56 +201,56 @@ void map_gen_dec(map_gen_t * h, llr_t * input, llr_t * parity, llr_t * output,
* TURBO DECODER INTERFACE * TURBO DECODER INTERFACE
* *
************************************************/ ************************************************/
int tdec_init(tdec_t * h, uint32_t max_long_cb) int srslte_tdec_init(srslte_tdec_t * h, uint32_t max_long_cb)
{ {
int ret = -1; int ret = -1;
bzero(h, sizeof(tdec_t)); bzero(h, sizeof(srslte_tdec_t));
uint32_t len = max_long_cb + TOTALTAIL; uint32_t len = max_long_cb + SRSLTE_TCOD_TOTALTAIL;
h->max_long_cb = max_long_cb; h->max_long_cb = max_long_cb;
h->llr1 = vec_malloc(sizeof(llr_t) * len); h->llr1 = vec_malloc(sizeof(srslte_llr_t) * len);
if (!h->llr1) { if (!h->llr1) {
perror("vec_malloc"); perror("vec_malloc");
goto clean_and_exit; goto clean_and_exit;
} }
h->llr2 = vec_malloc(sizeof(llr_t) * len); h->llr2 = vec_malloc(sizeof(srslte_llr_t) * len);
if (!h->llr2) { if (!h->llr2) {
perror("vec_malloc"); perror("vec_malloc");
goto clean_and_exit; goto clean_and_exit;
} }
h->w = vec_malloc(sizeof(llr_t) * len); h->w = vec_malloc(sizeof(srslte_llr_t) * len);
if (!h->w) { if (!h->w) {
perror("vec_malloc"); perror("vec_malloc");
goto clean_and_exit; goto clean_and_exit;
} }
h->syst = vec_malloc(sizeof(llr_t) * len); h->syst = vec_malloc(sizeof(srslte_llr_t) * len);
if (!h->syst) { if (!h->syst) {
perror("vec_malloc"); perror("vec_malloc");
goto clean_and_exit; goto clean_and_exit;
} }
h->parity = vec_malloc(sizeof(llr_t) * len); h->parity = vec_malloc(sizeof(srslte_llr_t) * len);
if (!h->parity) { if (!h->parity) {
perror("vec_malloc"); perror("vec_malloc");
goto clean_and_exit; goto clean_and_exit;
} }
if (map_gen_init(&h->dec, h->max_long_cb)) { if (srslte_map_gen_init(&h->dec, h->max_long_cb)) {
goto clean_and_exit; goto clean_and_exit;
} }
if (tc_interl_init(&h->interleaver, h->max_long_cb) < 0) { if (srs_tc_interl_init(&h->interleaver, h->max_long_cb) < 0) {
goto clean_and_exit; goto clean_and_exit;
} }
ret = 0; ret = 0;
clean_and_exit:if (ret == -1) { clean_and_exit:if (ret == -1) {
tdec_free(h); srslte_tdec_free(h);
} }
return ret; return ret;
} }
void tdec_free(tdec_t * h) void srslte_tdec_free(srslte_tdec_t * h)
{ {
if (h->llr1) { if (h->llr1) {
free(h->llr1); free(h->llr1);
@ -260,45 +268,45 @@ void tdec_free(tdec_t * h)
free(h->parity); free(h->parity);
} }
map_gen_free(&h->dec); srslte_map_gen_free(&h->dec);
tc_interl_free(&h->interleaver); srs_tc_interl_free(&h->interleaver);
bzero(h, sizeof(tdec_t)); bzero(h, sizeof(srslte_tdec_t));
} }
void tdec_iteration(tdec_t * h, llr_t * input, uint32_t long_cb) void srslte_tdec_iteration(srslte_tdec_t * h, srslte_llr_t * input, uint32_t long_cb)
{ {
uint32_t i; uint32_t i;
// Prepare systematic and parity bits for MAP DEC #1 // Prepare systematic and parity bits for MAP DEC #1
for (i = 0; i < long_cb; i++) { for (i = 0; i < long_cb; i++) {
h->syst[i] = input[RATE * i] + h->w[i]; h->syst[i] = input[SRSLTE_TCOD_RATE * i] + h->w[i];
h->parity[i] = input[RATE * i + 1]; h->parity[i] = input[SRSLTE_TCOD_RATE * i + 1];
} }
for (i = long_cb; i < long_cb + RATE; i++) { for (i = long_cb; i < long_cb + SRSLTE_TCOD_RATE; i++) {
h->syst[i] = input[RATE * long_cb + NINPUTS * (i - long_cb)]; h->syst[i] = input[SRSLTE_TCOD_RATE * long_cb + NINPUTS * (i - long_cb)];
h->parity[i] = input[RATE * long_cb + NINPUTS * (i - long_cb) + 1]; h->parity[i] = input[SRSLTE_TCOD_RATE * long_cb + NINPUTS * (i - long_cb) + 1];
} }
// Run MAP DEC #1 // Run MAP DEC #1
map_gen_dec(&h->dec, h->syst, h->parity, h->llr1, long_cb); srslte_map_gen_dec(&h->dec, h->syst, h->parity, h->llr1, long_cb);
// Prepare systematic and parity bits for MAP DEC #1 // Prepare systematic and parity bits for MAP DEC #1
for (i = 0; i < long_cb; i++) { for (i = 0; i < long_cb; i++) {
h->syst[i] = h->llr1[h->interleaver.forward[i]] h->syst[i] = h->llr1[h->interleaver.forward[i]]
- h->w[h->interleaver.forward[i]]; - h->w[h->interleaver.forward[i]];
h->parity[i] = input[RATE * i + 2]; h->parity[i] = input[SRSLTE_TCOD_RATE * i + 2];
} }
for (i = long_cb; i < long_cb + RATE; i++) { for (i = long_cb; i < long_cb + SRSLTE_TCOD_RATE; i++) {
h->syst[i] = h->syst[i] =
input[RATE * long_cb + NINPUTS * RATE + NINPUTS * (i - long_cb)]; input[SRSLTE_TCOD_RATE * long_cb + NINPUTS * SRSLTE_TCOD_RATE + NINPUTS * (i - long_cb)];
h->parity[i] = input[RATE * long_cb + NINPUTS * RATE h->parity[i] = input[SRSLTE_TCOD_RATE * long_cb + NINPUTS * SRSLTE_TCOD_RATE
+ NINPUTS * (i - long_cb) + 1]; + NINPUTS * (i - long_cb) + 1];
} }
// Run MAP DEC #1 // Run MAP DEC #1
map_gen_dec(&h->dec, h->syst, h->parity, h->llr2, long_cb); srslte_map_gen_dec(&h->dec, h->syst, h->parity, h->llr2, long_cb);
// Update a-priori LLR from the last iteration // Update a-priori LLR from the last iteration
for (i = 0; i < long_cb; i++) { for (i = 0; i < long_cb; i++) {
@ -307,18 +315,18 @@ void tdec_iteration(tdec_t * h, llr_t * input, uint32_t long_cb)
} }
int tdec_reset(tdec_t * h, uint32_t long_cb) int srslte_tdec_reset(srslte_tdec_t * h, uint32_t long_cb)
{ {
if (long_cb > h->max_long_cb) { if (long_cb > h->max_long_cb) {
fprintf(stderr, "TDEC was initialized for max_long_cb=%d\n", fprintf(stderr, "TDEC was initialized for max_long_cb=%d\n",
h->max_long_cb); h->max_long_cb);
return -1; return -1;
} }
memset(h->w, 0, sizeof(llr_t) * long_cb); memset(h->w, 0, sizeof(srslte_llr_t) * long_cb);
return tc_interl_LTE_gen(&h->interleaver, long_cb); return srs_tc_interl_LTE_gen(&h->interleaver, long_cb);
} }
void tdec_decision(tdec_t * h, uint8_t *output, uint32_t long_cb) void srslte_tdec_decision(srslte_tdec_t * h, uint8_t *output, uint32_t long_cb)
{ {
uint32_t i; uint32_t i;
for (i = 0; i < long_cb; i++) { for (i = 0; i < long_cb; i++) {
@ -326,21 +334,21 @@ void tdec_decision(tdec_t * h, uint8_t *output, uint32_t long_cb)
} }
} }
int tdec_run_all(tdec_t * h, llr_t * input, uint8_t *output, int srslte_tdec_run_all(srslte_tdec_t * h, srslte_llr_t * input, uint8_t *output,
uint32_t nof_iterations, uint32_t long_cb) uint32_t nof_iterations, uint32_t long_cb)
{ {
uint32_t iter = 0; uint32_t iter = 0;
if (tdec_reset(h, long_cb)) { if (srslte_tdec_reset(h, long_cb)) {
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
do { do {
tdec_iteration(h, input, long_cb); srslte_tdec_iteration(h, input, long_cb);
iter++; iter++;
} while (iter < nof_iterations); } while (iter < nof_iterations);
tdec_decision(h, output, long_cb); srslte_tdec_decision(h, output, long_cb);
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;
} }

50
srslte/lib/fec/src/viterbi.c
Unescape Escape View File

@ -41,7 +41,7 @@
#define DEB 0 #define DEB 0
int decode37(void *o, uint8_t *symbols, uint8_t *data, uint32_t frame_length) { int decode37(void *o, uint8_t *symbols, uint8_t *data, uint32_t frame_length) {
viterbi_t *q = o; srslte_viterbi_t *q = o;
uint32_t i; uint32_t i;
uint32_t best_state; uint32_t best_state;
@ -76,7 +76,7 @@ int decode37(void *o, uint8_t *symbols, uint8_t *data, uint32_t frame_length) {
} }
int decode39(void *o, uint8_t *symbols, uint8_t *data, uint32_t frame_length) { int decode39(void *o, uint8_t *symbols, uint8_t *data, uint32_t frame_length) {
viterbi_t *q = o; srslte_viterbi_t *q = o;
if (frame_length > q->framebits) { if (frame_length > q->framebits) {
fprintf(stderr, "Initialized decoder for max frame length %d bits\n", fprintf(stderr, "Initialized decoder for max frame length %d bits\n",
@ -98,7 +98,7 @@ int decode39(void *o, uint8_t *symbols, uint8_t *data, uint32_t frame_length) {
void free37(void *o) { void free37(void *o) {
viterbi_t *q = o; srslte_viterbi_t *q = o;
if (q->symbols_uc) { if (q->symbols_uc) {
free(q->symbols_uc); free(q->symbols_uc);
} }
@ -109,14 +109,14 @@ void free37(void *o) {
} }
void free39(void *o) { void free39(void *o) {
viterbi_t *q = o; srslte_viterbi_t *q = o;
if (q->symbols_uc) { if (q->symbols_uc) {
free(q->symbols_uc); free(q->symbols_uc);
} }
delete_viterbi39_port(q->ptr); delete_viterbi39_port(q->ptr);
} }
int init37(viterbi_t *q, uint32_t poly[3], uint32_t framebits, bool tail_biting) { int init37(srslte_viterbi_t *q, uint32_t poly[3], uint32_t framebits, bool tail_biting) {
q->K = 7; q->K = 7;
q->R = 3; q->R = 3;
q->framebits = framebits; q->framebits = framebits;
@ -150,7 +150,7 @@ int init37(viterbi_t *q, uint32_t poly[3], uint32_t framebits, bool tail_biting)
} }
} }
int init39(viterbi_t *q, uint32_t poly[3], uint32_t framebits, bool tail_biting) { int init39(srslte_viterbi_t *q, uint32_t poly[3], uint32_t framebits, bool tail_biting) {
q->K = 9; q->K = 9;
q->R = 3; q->R = 3;
q->framebits = framebits; q->framebits = framebits;
@ -180,16 +180,16 @@ int init39(viterbi_t *q, uint32_t poly[3], uint32_t framebits, bool tail_biting)
void viterbi_set_gain_quant(viterbi_t *q, float gain_quant) { void srslte_viterbi_set_gain_quant(srslte_viterbi_t *q, float gain_quant) {
q->gain_quant = gain_quant; q->gain_quant = gain_quant;
} }
int viterbi_init(viterbi_t *q, viterbi_type_t type, uint32_t poly[3], int srslte_viterbi_init(srslte_viterbi_t *q, srslte_viterbi_type_t type, uint32_t poly[3],
uint32_t max_frame_length, bool tail_bitting) { uint32_t max_frame_length, bool tail_bitting) {
switch (type) { switch (type) {
case viterbi_37: case SRSLTE_VITERBI_37:
return init37(q, poly, max_frame_length, tail_bitting); return init37(q, poly, max_frame_length, tail_bitting);
case viterbi_39: case SRSLTE_VITERBI_39:
return init39(q, poly, max_frame_length, tail_bitting); return init39(q, poly, max_frame_length, tail_bitting);
default: default:
fprintf(stderr, "Decoder not implemented\n"); fprintf(stderr, "Decoder not implemented\n");
@ -197,15 +197,15 @@ int viterbi_init(viterbi_t *q, viterbi_type_t type, uint32_t poly[3],
} }
} }
void viterbi_free(viterbi_t *q) { void srslte_viterbi_free(srslte_viterbi_t *q) {
if (q->free) { if (q->free) {
q->free(q); q->free(q);
} }
bzero(q, sizeof(viterbi_t)); bzero(q, sizeof(srslte_viterbi_t));
} }
/* symbols are real-valued */ /* symbols are real-valued */
int viterbi_decode_f(viterbi_t *q, float *symbols, uint8_t *data, uint32_t frame_length) { int srslte_viterbi_decode_f(srslte_viterbi_t *q, float *symbols, uint8_t *data, uint32_t frame_length) {
uint32_t len; uint32_t len;
if (frame_length > q->framebits) { if (frame_length > q->framebits) {
fprintf(stderr, "Initialized decoder for max frame length %d bits\n", fprintf(stderr, "Initialized decoder for max frame length %d bits\n",
@ -227,19 +227,19 @@ int viterbi_decode_f(viterbi_t *q, float *symbols, uint8_t *data, uint32_t frame
} }
int viterbi_decode_uc(viterbi_t *q, uint8_t *symbols, uint8_t *data, int srslte_viterbi_decode_uc(srslte_viterbi_t *q, uint8_t *symbols, uint8_t *data,
uint32_t frame_length) { uint32_t frame_length) {
return q->decode(q, symbols, data, frame_length); return q->decode(q, symbols, data, frame_length);
} }
int viterbi_initialize(viterbi_hl* h) { int srslte_viterbi_initialize(srslte_viterbi_hl* h) {
uint32_t poly[3]; uint32_t poly[3];
viterbi_type_t type; srslte_viterbi_type_t type;
if (h->init.rate == 2) { if (h->init.rate == 2) {
if (h->init.constraint_length == 7) { if (h->init.constraint_length == 7) {
type = viterbi_27; type = SRSLTE_VITERBI_27;
} else if (h->init.constraint_length == 9) { } else if (h->init.constraint_length == 9) {
type = viterbi_29; type = SRSLTE_VITERBI_29;
} else { } else {
fprintf(stderr, "Unsupported decoder %d/%d\n", h->init.rate, fprintf(stderr, "Unsupported decoder %d/%d\n", h->init.rate,
h->init.constraint_length); h->init.constraint_length);
@ -247,9 +247,9 @@ int viterbi_initialize(viterbi_hl* h) {
} }
} else if (h->init.rate == 3) { } else if (h->init.rate == 3) {
if (h->init.constraint_length == 7) { if (h->init.constraint_length == 7) {
type = viterbi_37; type = SRSLTE_VITERBI_37;
} else if (h->init.constraint_length == 9) { } else if (h->init.constraint_length == 9) {
type = viterbi_39; type = SRSLTE_VITERBI_39;
} else { } else {
fprintf(stderr, "Unsupported decoder %d/%d\n", h->init.rate, fprintf(stderr, "Unsupported decoder %d/%d\n", h->init.rate,
h->init.constraint_length); h->init.constraint_length);
@ -263,20 +263,20 @@ int viterbi_initialize(viterbi_hl* h) {
poly[0] = h->init.generator_0; poly[0] = h->init.generator_0;
poly[1] = h->init.generator_1; poly[1] = h->init.generator_1;
poly[2] = h->init.generator_2; poly[2] = h->init.generator_2;
return viterbi_init(&h->obj, type, poly, (uint32_t) h->init.frame_length, return srslte_viterbi_init(&h->obj, type, poly, (uint32_t) h->init.frame_length,
h->init.tail_bitting ? true : false); h->init.tail_bitting ? true : false);
} }
int viterbi_work(viterbi_hl* hl) { int srslte_viterbi_work(srslte_viterbi_hl* hl) {
if (hl->in_len != hl->init.frame_length) { if (hl->in_len != hl->init.frame_length) {
fprintf(stderr, "Expected input length %d but got %d\n", fprintf(stderr, "Expected input length %d but got %d\n",
hl->init.frame_length, hl->in_len); hl->init.frame_length, hl->in_len);
return -1; return -1;
} }
return viterbi_decode_f(&hl->obj, hl->input, hl->output, hl->init.frame_length); return srslte_viterbi_decode_f(&hl->obj, hl->input, hl->output, hl->init.frame_length);
} }
int viterbi_stop(viterbi_hl* h) { int srslte_viterbi_stop(srslte_viterbi_hl* h) {
viterbi_free(&h->obj); srslte_viterbi_free(&h->obj);
return 0; return 0;
} }

26
srslte/lib/fec/test/crc_test.c
Unescape Escape View File

@ -36,15 +36,15 @@
#include "srslte/srslte.h" #include "srslte/srslte.h"
#include "crc_test.h" #include "crc_test.h"
int num_bits = 5001, crc_length = 24; int num_bits = 5001, srslte_crc_length = 24;
uint32_t crc_poly = 0x1864CFB; uint32_t srslte_crc_poly = 0x1864CFB;
uint32_t seed = 1; uint32_t seed = 1;
void usage(char *prog) { void usage(char *prog) {
printf("Usage: %s [nlps]\n", prog); printf("Usage: %s [nlps]\n", prog);
printf("\t-n num_bits [Default %d]\n", num_bits); printf("\t-n num_bits [Default %d]\n", num_bits);
printf("\t-l crc_length [Default %d]\n", crc_length); printf("\t-l srslte_crc_length [Default %d]\n", srslte_crc_length);
printf("\t-p crc_poly (Hex) [Default 0x%x]\n", crc_poly); printf("\t-p srslte_crc_poly (Hex) [Default 0x%x]\n", srslte_crc_poly);
printf("\t-s seed [Default 0=time]\n"); printf("\t-s seed [Default 0=time]\n");
} }
@ -56,10 +56,10 @@ void parse_args(int argc, char **argv) {
num_bits = atoi(argv[optind]); num_bits = atoi(argv[optind]);
break; break;
case 'l': case 'l':
crc_length = atoi(argv[optind]); srslte_crc_length = atoi(argv[optind]);
break; break;
case 'p': case 'p':
crc_poly = (uint32_t) strtoul(argv[optind], NULL, 16); srslte_crc_poly = (uint32_t) strtoul(argv[optind], NULL, 16);
break; break;
case 's': case 's':
seed = (uint32_t) strtoul(argv[optind], NULL, 0); seed = (uint32_t) strtoul(argv[optind], NULL, 0);
@ -74,12 +74,12 @@ void parse_args(int argc, char **argv) {
int main(int argc, char **argv) { int main(int argc, char **argv) {
int i; int i;
uint8_t *data; uint8_t *data;
uint32_t crc_word, expected_word; uint32_t srslte_crc_word, expected_word;
crc_t crc_p; srslte_crc_t srslte_crc_p;
parse_args(argc, argv); parse_args(argc, argv);
data = malloc(sizeof(uint8_t) * (num_bits + crc_length * 2)); data = malloc(sizeof(uint8_t) * (num_bits + srslte_crc_length * 2));
if (!data) { if (!data) {
perror("malloc"); perror("malloc");
exit(-1); exit(-1);
@ -96,20 +96,20 @@ int main(int argc, char **argv) {
} }
//Initialize CRC params and tables //Initialize CRC params and tables
if (crc_init(&crc_p, crc_poly, crc_length)) { if (srslte_crc_init(&srslte_crc_p, srslte_crc_poly, srslte_crc_length)) {
exit(-1); exit(-1);
} }
// generate CRC word // generate CRC word
crc_word = crc_checksum(&crc_p, data, num_bits); srslte_crc_word = srslte_crc_checksum(&srslte_crc_p, data, num_bits);
free(data); free(data);
// check if generated word is as expected // check if generated word is as expected
if (get_expected_word(num_bits, crc_length, crc_poly, seed, if (get_expected_word(num_bits, srslte_crc_length, srslte_crc_poly, seed,
&expected_word)) { &expected_word)) {
fprintf(stderr, "Test parameters not defined in test_results.h\n"); fprintf(stderr, "Test parameters not defined in test_results.h\n");
exit(-1); exit(-1);
} }
exit(expected_word != crc_word); exit(expected_word != srslte_crc_word);
} }

4
srslte/lib/fec/test/rm_conv_test.c
Unescape Escape View File

@ -100,7 +100,7 @@ int main(int argc, char **argv) {
bits[i] = rand()%2; bits[i] = rand()%2;
} }
if (rm_conv_tx(bits, nof_tx_bits, rm_bits, nof_rx_bits)) { if (srslte_rm_conv_tx(bits, nof_tx_bits, rm_bits, nof_rx_bits)) {
exit(-1); exit(-1);
} }
@ -108,7 +108,7 @@ int main(int argc, char **argv) {
rm_symbols[i] = rm_bits[i]?1:-1; rm_symbols[i] = rm_bits[i]?1:-1;
} }
if (rm_conv_rx(rm_symbols, nof_rx_bits, unrm_symbols, nof_tx_bits)) { if (srslte_rm_conv_rx(rm_symbols, nof_rx_bits, unrm_symbols, nof_tx_bits)) {
exit(-1); exit(-1);
} }

4
srslte/lib/fec/test/rm_turbo_rx_mex.c
Unescape Escape View File

@ -41,7 +41,7 @@
void help() void help()
{ {
mexErrMsgTxt mexErrMsgTxt
("[out] = srslte_rm_turbo_rx(in, trblkin, rv)\n\n"); ("[out] = srslte_srslte_rm_turbo_rx(in, trblkin, rv)\n\n");
} }
/* the gateway function */ /* the gateway function */
@ -81,7 +81,7 @@ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
// allocate memory for output bits // allocate memory for output bits
output = vec_malloc(cblen * sizeof(float)); output = vec_malloc(cblen * sizeof(float));
rm_turbo_rx(w_buff_f, cblen * 10, input, in_len, output, cblen, srslte_rm_turbo_rx(w_buff_f, cblen * 10, input, in_len, output, cblen,
rvidx,cbsegm.F); rvidx,cbsegm.F);
if (nlhs >= 1) { if (nlhs >= 1) {

8
srslte/lib/fec/test/rm_turbo_test.c
Unescape Escape View File

@ -124,14 +124,14 @@ int main(int argc, char **argv) {
} }
for (i=0;i<nof_filler_bits;i++) { for (i=0;i<nof_filler_bits;i++) {
bits[3*i+0] = TX_NULL; bits[3*i+0] = SRSLTE_TX_NULL;
bits[3*i+1] = TX_NULL; bits[3*i+1] = SRSLTE_TX_NULL;
} }
printf("BITS: "); printf("BITS: ");
vec_fprint_b(stdout, bits, nof_tx_bits); vec_fprint_b(stdout, bits, nof_tx_bits);
rm_turbo_tx(w_buff_c, nof_tx_bits * 10, bits, nof_tx_bits, rm_bits, nof_rx_bits, rv_idx); srslte_rm_turbo_tx(w_buff_c, nof_tx_bits * 10, bits, nof_tx_bits, rm_bits, nof_rx_bits, rv_idx);
printf("RM: "); printf("RM: ");
vec_fprint_b(stdout, rm_bits, nof_rx_bits); vec_fprint_b(stdout, rm_bits, nof_rx_bits);
@ -140,7 +140,7 @@ int main(int argc, char **argv) {
rm_symbols[i] = (float) rm_bits[i] ? 1 : -1; rm_symbols[i] = (float) rm_bits[i] ? 1 : -1;
} }
rm_turbo_rx(w_buff_f, nof_rx_bits * 10, rm_symbols, nof_rx_bits, unrm_symbols, nof_tx_bits, srslte_rm_turbo_rx(w_buff_f, nof_rx_bits * 10, rm_symbols, nof_rx_bits, unrm_symbols, nof_tx_bits,
rv_idx, nof_filler_bits); rv_idx, nof_filler_bits);
printf("UMRM: "); printf("UMRM: ");

22
srslte/lib/fec/test/turbodecoder_test.c
Unescape Escape View File

@ -139,8 +139,8 @@ int main(int argc, char **argv) {
uint32_t coded_length; uint32_t coded_length;
struct timeval tdata[3]; struct timeval tdata[3];
float mean_usec; float mean_usec;
tdec_t tdec; srslte_tdec_t tdec;
tcod_t tcod; srslte_tcod_t tcod;
parse_args(argc, argv); parse_args(argc, argv);
@ -155,7 +155,7 @@ int main(int argc, char **argv) {
frame_length = srslte_cb_size(srslte_find_cb_index(frame_length)); frame_length = srslte_cb_size(srslte_find_cb_index(frame_length));
} }
coded_length = 3 * (frame_length) + TOTALTAIL; coded_length = 3 * (frame_length) + SRSLTE_TCOD_TOTALTAIL;
printf(" Frame length: %d\n", frame_length); printf(" Frame length: %d\n", frame_length);
if (ebno_db < 100.0) { if (ebno_db < 100.0) {
@ -190,12 +190,12 @@ int main(int argc, char **argv) {
exit(-1); exit(-1);
} }
if (tcod_init(&tcod, frame_length)) { if (srslte_tcod_init(&tcod, frame_length)) {
fprintf(stderr, "Error initiating Turbo coder\n"); fprintf(stderr, "Error initiating Turbo coder\n");
exit(-1); exit(-1);
} }
if (tdec_init(&tdec, frame_length)) { if (srslte_tdec_init(&tdec, frame_length)) {
fprintf(stderr, "Error initiating Turbo decoder\n"); fprintf(stderr, "Error initiating Turbo decoder\n");
exit(-1); exit(-1);
} }
@ -235,7 +235,7 @@ int main(int argc, char **argv) {
symbols[j] = known_data_encoded[j]; symbols[j] = known_data_encoded[j];
} }
} else { } else {
tcod_encode(&tcod, data_tx, symbols, frame_length); srslte_tcod_encode(&tcod, data_tx, symbols, frame_length);
} }
for (j = 0; j < coded_length; j++) { for (j = 0; j < coded_length; j++) {
@ -245,7 +245,7 @@ int main(int argc, char **argv) {
srslte_ch_awgn_f(llr, llr, var[i], coded_length); srslte_ch_awgn_f(llr, llr, var[i], coded_length);
/* decoder */ /* decoder */
tdec_reset(&tdec, frame_length); srslte_tdec_reset(&tdec, frame_length);
uint32_t t; uint32_t t;
if (nof_iterations == -1) { if (nof_iterations == -1) {
@ -257,8 +257,8 @@ int main(int argc, char **argv) {
if (!j) if (!j)
gettimeofday(&tdata[1], NULL); // Only measure 1 iteration gettimeofday(&tdata[1], NULL); // Only measure 1 iteration
tdec_iteration(&tdec, llr, frame_length); srslte_tdec_iteration(&tdec, llr, frame_length);
tdec_decision(&tdec, data_rx, frame_length); srslte_tdec_decision(&tdec, data_rx, frame_length);
if (!j) if (!j)
gettimeofday(&tdata[2], NULL); gettimeofday(&tdata[2], NULL);
if (!j) if (!j)
@ -322,8 +322,8 @@ int main(int argc, char **argv) {
free(llr_c); free(llr_c);
free(data_rx); free(data_rx);
tdec_free(&tdec); srslte_tdec_free(&tdec);
tcod_free(&tcod); srslte_tcod_free(&tcod);
printf("\n"); printf("\n");
output_matlab(ber, snr_points); output_matlab(ber, snr_points);

8
srslte/lib/fec/test/turbodecoder_test_mex.c
Unescape Escape View File

@ -47,7 +47,7 @@ void help()
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{ {
tdec_t tdec; srslte_tdec_t tdec;
float *input_llr; float *input_llr;
uint8_t *output_data; uint8_t *output_data;
uint32_t nof_bits; uint32_t nof_bits;
@ -86,18 +86,18 @@ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
// allocate memory for output bits // allocate memory for output bits
output_data = vec_malloc(nof_bits * sizeof(uint8_t)); output_data = vec_malloc(nof_bits * sizeof(uint8_t));
if (tdec_init(&tdec, nof_bits)) { if (srslte_tdec_init(&tdec, nof_bits)) {
mexErrMsgTxt("Error initiating Turbo decoder\n"); mexErrMsgTxt("Error initiating Turbo decoder\n");
return; return;
} }
tdec_run_all(&tdec, input_llr, output_data, nof_iterations, nof_bits); srslte_tdec_run_all(&tdec, input_llr, output_data, nof_iterations, nof_bits);
if (nlhs >= 1) { if (nlhs >= 1) {
mexutils_write_uint8(output_data, &plhs[0], nof_bits, 1); mexutils_write_uint8(output_data, &plhs[0], nof_bits, 1);
} }
tdec_free(&tdec); srslte_tdec_free(&tdec);
free(input_llr); free(input_llr);
free(output_data); free(output_data);

28
srslte/lib/fec/test/viterbi_test.c
Unescape Escape View File

@ -92,9 +92,9 @@ void parse_args(int argc, char **argv) {
} }
void output_matlab(float ber[NTYPES][SNR_POINTS], int snr_points, void output_matlab(float ber[NTYPES][SNR_POINTS], int snr_points,
convcoder_t cod[NCODS], int ncods) { srslte_convcoder_t cod[NCODS], int ncods) {
int i, j, n; int i, j, n;
FILE *f = fopen("viterbi_snr.m", "w"); FILE *f = fopen("srslte_viterbi_snr.m", "w");
if (!f) { if (!f) {
perror("fopen"); perror("fopen");
exit(-1); exit(-1);
@ -129,9 +129,9 @@ int main(int argc, char **argv) {
int snr_points; int snr_points;
float ber[NTYPES][SNR_POINTS]; float ber[NTYPES][SNR_POINTS];
uint32_t errors[NTYPES]; uint32_t errors[NTYPES];
viterbi_type_t viterbi_type[NCODS]; srslte_viterbi_type_t srslte_viterbi_type[NCODS];
viterbi_t dec[NCODS]; srslte_viterbi_t dec[NCODS];
convcoder_t cod[NCODS]; srslte_convcoder_t cod[NCODS];
int coded_length[NCODS]; int coded_length[NCODS];
int n, ncods, max_coded_length; int n, ncods, max_coded_length;
@ -150,7 +150,7 @@ int main(int argc, char **argv) {
cod[0].poly[2] = 0x127; cod[0].poly[2] = 0x127;
cod[0].tail_biting = false; cod[0].tail_biting = false;
cod[0].K = 9; cod[0].K = 9;
viterbi_type[0] = viterbi_39; srslte_viterbi_type[0] = SRSLTE_VITERBI_39;
ncods=1; ncods=1;
break; break;
case 7: case 7:
@ -159,7 +159,7 @@ int main(int argc, char **argv) {
cod[0].poly[2] = 0x57; cod[0].poly[2] = 0x57;
cod[0].K = 7; cod[0].K = 7;
cod[0].tail_biting = tail_biting; cod[0].tail_biting = tail_biting;
viterbi_type[0] = viterbi_37; srslte_viterbi_type[0] = SRSLTE_VITERBI_37;
ncods=1; ncods=1;
break; break;
default: default:
@ -168,19 +168,19 @@ int main(int argc, char **argv) {
cod[0].poly[2] = 0x127; cod[0].poly[2] = 0x127;
cod[0].tail_biting = false; cod[0].tail_biting = false;
cod[0].K = 9; cod[0].K = 9;
viterbi_type[0] = viterbi_39; srslte_viterbi_type[0] = SRSLTE_VITERBI_39;
cod[1].poly[0] = 0x6D; cod[1].poly[0] = 0x6D;
cod[1].poly[1] = 0x4F; cod[1].poly[1] = 0x4F;
cod[1].poly[2] = 0x57; cod[1].poly[2] = 0x57;
cod[1].tail_biting = false; cod[1].tail_biting = false;
cod[1].K = 7; cod[1].K = 7;
viterbi_type[1] = viterbi_37; srslte_viterbi_type[1] = SRSLTE_VITERBI_37;
cod[2].poly[0] = 0x6D; cod[2].poly[0] = 0x6D;
cod[2].poly[1] = 0x4F; cod[2].poly[1] = 0x4F;
cod[2].poly[2] = 0x57; cod[2].poly[2] = 0x57;
cod[2].tail_biting = true; cod[2].tail_biting = true;
cod[2].K = 7; cod[2].K = 7;
viterbi_type[2] = viterbi_37; srslte_viterbi_type[2] = SRSLTE_VITERBI_37;
ncods=3; ncods=3;
} }
@ -191,7 +191,7 @@ int main(int argc, char **argv) {
if (coded_length[i] > max_coded_length) { if (coded_length[i] > max_coded_length) {
max_coded_length = coded_length[i]; max_coded_length = coded_length[i];
} }
viterbi_init(&dec[i], viterbi_type[i], cod[i].poly, frame_length, cod[i].tail_biting); srslte_viterbi_init(&dec[i], srslte_viterbi_type[i], cod[i].poly, frame_length, cod[i].tail_biting);
printf("Convolutional Code 1/3 K=%d Tail bitting: %s\n", cod[i].K, cod[i].tail_biting ? "yes" : "no"); printf("Convolutional Code 1/3 K=%d Tail bitting: %s\n", cod[i].K, cod[i].tail_biting ? "yes" : "no");
} }
@ -272,7 +272,7 @@ int main(int argc, char **argv) {
/* coded BER */ /* coded BER */
for (n=0;n<ncods;n++) { for (n=0;n<ncods;n++) {
convcoder_encode(&cod[n], data_tx, symbols, frame_length); srslte_convcoder_encode(&cod[n], data_tx, symbols, frame_length);
for (j = 0; j < coded_length[n]; j++) { for (j = 0; j < coded_length[n]; j++) {
llr[j] = symbols[j] ? sqrt(2) : -sqrt(2); llr[j] = symbols[j] ? sqrt(2) : -sqrt(2);
@ -282,7 +282,7 @@ int main(int argc, char **argv) {
vec_quant_fuc(llr, llr_c, Gain, 127.5, 255, coded_length[n]); vec_quant_fuc(llr, llr_c, Gain, 127.5, 255, coded_length[n]);
/* decoder 1 */ /* decoder 1 */
viterbi_decode_uc(&dec[n], llr_c, data_rx[1+n], frame_length); srslte_viterbi_decode_uc(&dec[n], llr_c, data_rx[1+n], frame_length);
} }
/* check errors */ /* check errors */
@ -312,7 +312,7 @@ int main(int argc, char **argv) {
} }
} }
for (n=0;n<ncods;n++) { for (n=0;n<ncods;n++) {
viterbi_free(&dec[n]); srslte_viterbi_free(&dec[n]);
} }
free(data_tx); free(data_tx);

10
srslte/lib/fec/test/viterbi_test_mex.c
Unescape Escape View File

@ -46,7 +46,7 @@ void help()
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{ {
viterbi_t viterbi; srslte_viterbi_t viterbi;
float *input_llr; float *input_llr;
uint8_t *output_data; uint8_t *output_data;
int nof_bits; int nof_bits;
@ -62,16 +62,16 @@ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
output_data = vec_malloc(nof_bits * sizeof(uint8_t)); output_data = vec_malloc(nof_bits * sizeof(uint8_t));
uint32_t poly[3] = { 0x6D, 0x4F, 0x57 }; uint32_t poly[3] = { 0x6D, 0x4F, 0x57 };
if (viterbi_init(&viterbi, viterbi_37, poly, nof_bits/3, true)) { if (srslte_viterbi_init(&viterbi, SRSLTE_VITERBI_37, poly, nof_bits/3, true)) {
return; return;
} }
if (nrhs >= 2) { if (nrhs >= 2) {
float gain_quant = mxGetScalar(prhs[1]); float gain_quant = mxGetScalar(prhs[1]);
viterbi_set_gain_quant(&viterbi, gain_quant); srslte_viterbi_set_gain_quant(&viterbi, gain_quant);
} }
viterbi_decode_f(&viterbi, input_llr, output_data, nof_bits/3); srslte_viterbi_decode_f(&viterbi, input_llr, output_data, nof_bits/3);
if (nlhs >= 1) { if (nlhs >= 1) {
mexutils_write_uint8(output_data, &plhs[0], nof_bits/3, 1); mexutils_write_uint8(output_data, &plhs[0], nof_bits/3, 1);
@ -80,7 +80,7 @@ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
mexutils_write_uint8(viterbi.symbols_uc, &plhs[1], nof_bits/3, 1); mexutils_write_uint8(viterbi.symbols_uc, &plhs[1], nof_bits/3, 1);
} }
viterbi_free(&viterbi); srslte_viterbi_free(&viterbi);
free(input_llr); free(input_llr);
free(output_data); free(output_data);

24
srslte/lib/filter/src/dft_precoding.c
Unescape Escape View File

@ -41,15 +41,15 @@
#include "srslte/filter/dft_precoding.h" #include "srslte/filter/dft_precoding.h"
/* Create DFT plans for transform precoding */ /* Create DFT plans for transform precoding */
int dft_precoding_init(dft_precoding_t *q, uint32_t max_prb) int srslte_srslte_dft_precoding_init(srslte_srslte_dft_precoding_t *q, uint32_t max_prb)
{ {
int ret = SRSLTE_ERROR_INVALID_INPUTS; int ret = SRSLTE_ERROR_INVALID_INPUTS;
bzero(q, sizeof(dft_precoding_t)); bzero(q, sizeof(srslte_srslte_dft_precoding_t));
if (max_prb <= SRSLTE_MAX_PRB) { if (max_prb <= SRSLTE_MAX_PRB) {
ret = SRSLTE_ERROR; ret = SRSLTE_ERROR;
for (uint32_t i=1;i<max_prb;i++) { for (uint32_t i=1;i<max_prb;i++) {
if(dft_precoding_valid_prb(i)) { if(srslte_srslte_dft_precoding_valid_prb(i)) {
DEBUG("Initiating DFT precoding plan for %d PRBs\n", i); DEBUG("Initiating DFT precoding plan for %d PRBs\n", i);
if (dft_plan_c(&q->dft_plan[i], i*SRSLTE_NRE, FORWARD)) { if (dft_plan_c(&q->dft_plan[i], i*SRSLTE_NRE, FORWARD)) {
fprintf(stderr, "Error: Creating DFT plan %d\n",i); fprintf(stderr, "Error: Creating DFT plan %d\n",i);
@ -69,25 +69,25 @@ int dft_precoding_init(dft_precoding_t *q, uint32_t max_prb)
clean_exit: clean_exit:
if (ret == SRSLTE_ERROR) { if (ret == SRSLTE_ERROR) {
dft_precoding_free(q); srslte_srslte_dft_precoding_free(q);
} }
return ret; return ret;
} }
/* Free DFT plans for transform precoding */ /* Free DFT plans for transform precoding */
void dft_precoding_free(dft_precoding_t *q) void srslte_srslte_dft_precoding_free(srslte_srslte_dft_precoding_t *q)
{ {
for (uint32_t i=1;i<q->max_prb;i++) { for (uint32_t i=1;i<q->max_prb;i++) {
if(dft_precoding_valid_prb(i)) { if(srslte_srslte_dft_precoding_valid_prb(i)) {
DEBUG("Freeing DFT precoding plan for %d PRBs\n", i); DEBUG("Freeing DFT precoding plan for %d PRBs\n", i);
dft_plan_free(&q->dft_plan[i]); dft_plan_free(&q->dft_plan[i]);
dft_plan_free(&q->idft_plan[i]); dft_plan_free(&q->idft_plan[i]);
} }
} }
bzero(q, sizeof(dft_precoding_t)); bzero(q, sizeof(srslte_srslte_dft_precoding_t));
} }
bool dft_precoding_valid_prb(uint32_t nof_prb) { bool srslte_srslte_dft_precoding_valid_prb(uint32_t nof_prb) {
if (nof_prb == 1 || (nof_prb%2) == 0 || (nof_prb%3) == 0 || (nof_prb%5) == 0) { if (nof_prb == 1 || (nof_prb%2) == 0 || (nof_prb%3) == 0 || (nof_prb%5) == 0) {
return true; return true;
} else { } else {
@ -95,11 +95,11 @@ bool dft_precoding_valid_prb(uint32_t nof_prb) {
} }
} }
int dft_precoding(dft_precoding_t *q, cf_t *input, cf_t *output, int srslte_dft_precoding(srslte_srslte_dft_precoding_t *q, cf_t *input, cf_t *output,
uint32_t nof_prb, uint32_t nof_symbols) uint32_t nof_prb, uint32_t nof_symbols)
{ {
if (!dft_precoding_valid_prb(nof_prb)) { if (!srslte_srslte_dft_precoding_valid_prb(nof_prb)) {
fprintf(stderr, "Error invalid number of PRB (%d)\n", nof_prb); fprintf(stderr, "Error invalid number of PRB (%d)\n", nof_prb);
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
@ -111,10 +111,10 @@ int dft_precoding(dft_precoding_t *q, cf_t *input, cf_t *output,
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;
} }
int dft_predecoding(dft_precoding_t *q, cf_t *input, cf_t *output, int srslte_dft_predecoding(srslte_srslte_dft_precoding_t *q, cf_t *input, cf_t *output,
uint32_t nof_prb, uint32_t nof_symbols) uint32_t nof_prb, uint32_t nof_symbols)
{ {
if (!dft_precoding_valid_prb(nof_prb)) { if (!srslte_srslte_dft_precoding_valid_prb(nof_prb)) {
fprintf(stderr, "Error invalid number of PRB (%d)\n", nof_prb); fprintf(stderr, "Error invalid number of PRB (%d)\n", nof_prb);
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }

24
srslte/lib/filter/src/filter2d.c
Unescape Escape View File

@ -43,11 +43,11 @@
#define idx(a, b) ((a)*(q->szfreq+q->nfreq)+b) #define idx(a, b) ((a)*(q->szfreq+q->nfreq)+b)
int filter2d_init(filter2d_t* q, float **taps, uint32_t ntime, uint32_t nfreq, uint32_t sztime, int srslte_filter2d_init(srslte_filter2d_t* q, float **taps, uint32_t ntime, uint32_t nfreq, uint32_t sztime,
uint32_t szfreq) { uint32_t szfreq) {
int ret = -1; int ret = -1;
bzero(q, sizeof(filter2d_t)); bzero(q, sizeof(srslte_filter2d_t));
if (matrix_init((void***)&q->taps, ntime, nfreq, sizeof(float))) { if (matrix_init((void***)&q->taps, ntime, nfreq, sizeof(float))) {
goto free_and_exit; goto free_and_exit;
@ -76,21 +76,21 @@ int filter2d_init(filter2d_t* q, float **taps, uint32_t ntime, uint32_t nfreq, u
ret = 0; ret = 0;
free_and_exit: if (ret == -1) { free_and_exit: if (ret == -1) {
filter2d_free(q); srslte_filter2d_free(q);
} }
return ret; return ret;
} }
void filter2d_free(filter2d_t *q) { void srslte_filter2d_free(srslte_filter2d_t *q) {
matrix_free((void**) q->taps, q->ntime); matrix_free((void**) q->taps, q->ntime);
if (q->output) { if (q->output) {
free(q->output); free(q->output);
} }
bzero(q, sizeof(filter2d_t)); bzero(q, sizeof(srslte_filter2d_t));
} }
int filter2d_init_ones(filter2d_t* q, uint32_t ntime, uint32_t nfreq, uint32_t sztime, int srslte_filter2d_init_ones(srslte_filter2d_t* q, uint32_t ntime, uint32_t nfreq, uint32_t sztime,
uint32_t szfreq) uint32_t szfreq)
{ {
@ -113,7 +113,7 @@ int filter2d_init_ones(filter2d_t* q, uint32_t ntime, uint32_t nfreq, uint32_t s
matrix_fprintf_f(stdout, taps, ntime, nfreq); matrix_fprintf_f(stdout, taps, ntime, nfreq);
} }
if (filter2d_init(q, taps, ntime, nfreq, sztime, szfreq)) { if (srslte_filter2d_init(q, taps, ntime, nfreq, sztime, szfreq)) {
goto free_and_exit; goto free_and_exit;
} }
@ -126,7 +126,7 @@ free_and_exit:
/* Moves the last ntime symbols to the start and clears the remaining of the output. /* Moves the last ntime symbols to the start and clears the remaining of the output.
* Should be called, for instance, before filtering each OFDM frame. * Should be called, for instance, before filtering each OFDM frame.
*/ */
void filter2d_step(filter2d_t *q) { void srslte_filter2d_step(srslte_filter2d_t *q) {
int i; int i;
for (i = 0; i < q->ntime; i++) { for (i = 0; i < q->ntime; i++) {
@ -139,14 +139,14 @@ void filter2d_step(filter2d_t *q) {
} }
} }
void filter2d_reset(filter2d_t *q) { void srslte_filter2d_reset(srslte_filter2d_t *q) {
bzero(q->output, (q->ntime+q->sztime)*(q->szfreq+q->nfreq)*sizeof(cf_t)); bzero(q->output, (q->ntime+q->sztime)*(q->szfreq+q->nfreq)*sizeof(cf_t));
} }
/** Adds samples x to the from the given time/freq indexes to the filter /** Adds samples x to the from the given time/freq indexes to the filter
* and computes the output. * and computes the output.
*/ */
void filter2d_add(filter2d_t *q, cf_t x, uint32_t time_idx, uint32_t freq_idx) { void srslte_filter2d_add(srslte_filter2d_t *q, cf_t x, uint32_t time_idx, uint32_t freq_idx) {
int i, j; int i, j;
uint32_t ntime = q->ntime; uint32_t ntime = q->ntime;
@ -163,7 +163,7 @@ void filter2d_add(filter2d_t *q, cf_t x, uint32_t time_idx, uint32_t freq_idx) {
} }
} }
void filter2d_add_out(filter2d_t *q, cf_t x, int time_idx, int freq_idx) { void srslte_filter2d_add_out(srslte_filter2d_t *q, cf_t x, int time_idx, int freq_idx) {
int i, j; int i, j;
uint32_t ntime = q->ntime; uint32_t ntime = q->ntime;
@ -189,6 +189,6 @@ void filter2d_add_out(filter2d_t *q, cf_t x, int time_idx, int freq_idx) {
} }
} }
void filter2d_get_symbol(filter2d_t *q, uint32_t nsymbol, cf_t *output) { void srslte_filter2d_get_symbol(srslte_filter2d_t *q, uint32_t nsymbol, cf_t *output) {
memcpy(output, &q->output[idx(nsymbol,q->nfreq/2)], sizeof(cf_t) * (q->szfreq)); memcpy(output, &q->output[idx(nsymbol,q->nfreq/2)], sizeof(cf_t) * (q->szfreq));
} }

44
srslte/lib/io/src/binsource.c
Unescape Escape View File

@ -37,7 +37,7 @@
/* Internal functions */ /* Internal functions */
static int gen_seq_buff(binsource_t* q, int nwords) { static int gen_seq_buff(srslte_binsource_t* q, int nwords) {
if (q->seq_buff_nwords != nwords) { if (q->seq_buff_nwords != nwords) {
free(q->seq_buff); free(q->seq_buff);
q->seq_buff_nwords = 0; q->seq_buff_nwords = 0;
@ -60,31 +60,31 @@ static int gen_seq_buff(binsource_t* q, int nwords) {
/** /**
* Initializes the binsource object. * Initializes the binsource object.
*/ */
void binsource_init(binsource_t* q) { void srslte_binsource_init(srslte_binsource_t* q) {
bzero((void*) q,sizeof(binsource_t)); bzero((void*) q,sizeof(srslte_binsource_t));
} }
/** /**
* Destroys binsource object * Destroys binsource object
*/ */
void binsource_free(binsource_t* q) { void srslte_binsource_free(srslte_binsource_t* q) {
if (q->seq_buff) { if (q->seq_buff) {
free(q->seq_buff); free(q->seq_buff);
} }
bzero(q, sizeof(binsource_t)); bzero(q, sizeof(srslte_binsource_t));
} }
/** /**
* Sets a new seed * Sets a new seed
*/ */
void binsource_seed_set(binsource_t* q, uint32_t seed) { void srslte_binsource_seed_set(srslte_binsource_t* q, uint32_t seed) {
q->seed = seed; q->seed = seed;
} }
/** /**
* Sets local time as seed. * Sets local time as seed.
*/ */
void binsource_seed_time(binsource_t *q) { void srslte_binsource_seed_time(srslte_binsource_t *q) {
struct timeval t1; struct timeval t1;
gettimeofday(&t1, NULL); gettimeofday(&t1, NULL);
q->seed = t1.tv_usec * t1.tv_sec; q->seed = t1.tv_usec * t1.tv_sec;
@ -93,7 +93,7 @@ void binsource_seed_time(binsource_t *q) {
/** /**
* Generates a sequence of nbits random bits * Generates a sequence of nbits random bits
*/ */
int binsource_cache_gen(binsource_t* q, int nbits) { int srslte_binsource_cache_gen(srslte_binsource_t* q, int nbits) {
if (gen_seq_buff(q,DIV(nbits,32))) { if (gen_seq_buff(q,DIV(nbits,32))) {
return -1; return -1;
} }
@ -113,17 +113,17 @@ static int int_2_bits(uint32_t* src, uint8_t* dst, int nbits) {
} }
/** /**
* Copies the next random bits to the buffer bits from the array generated by binsource_cache_gen * Copies the next random bits to the buffer bits from the array generated by srslte_binsource_cache_gen
*/ */
void binsource_cache_cpy(binsource_t* q, uint8_t *bits, int nbits) { void srslte_binsource_cache_cpy(srslte_binsource_t* q, uint8_t *bits, int nbits) {
q->seq_cache_rp += int_2_bits(&q->seq_buff[q->seq_cache_rp],bits,nbits); q->seq_cache_rp += int_2_bits(&q->seq_buff[q->seq_cache_rp],bits,nbits);
} }
/** /**
* Stores in the bits buffer a sequence of nbits pseudo-random bits. * Stores in the bits buffer a sequence of nbits pseudo-random bits.
* Overwrites the bits generated using binsource_cache_gen. * Overwrites the bits generated using srslte_binsource_cache_gen.
*/ */
int binsource_generate(binsource_t* q, uint8_t *bits, int nbits) { int srslte_binsource_generate(srslte_binsource_t* q, uint8_t *bits, int nbits) {
if (gen_seq_buff(q,DIV(nbits,32))) { if (gen_seq_buff(q,DIV(nbits,32))) {
return -1; return -1;
@ -137,17 +137,17 @@ int binsource_generate(binsource_t* q, uint8_t *bits, int nbits) {
/* High-Level API */ /* High-Level API */
int binsource_initialize(binsource_hl* hl) { int srslte_binsource_initialize(srslte_binsource_hl* hl) {
binsource_init(&hl->obj); srslte_binsource_init(&hl->obj);
if (hl->init.seed) { if (hl->init.seed) {
binsource_seed_set(&hl->obj,hl->init.seed); srslte_binsource_seed_set(&hl->obj,hl->init.seed);
} else { } else {
binsource_seed_time(&hl->obj); srslte_binsource_seed_time(&hl->obj);
} }
if (hl->init.cache_seq_nbits) { if (hl->init.cache_seq_nbits) {
if (binsource_cache_gen(&hl->obj,hl->init.cache_seq_nbits)) { if (srslte_binsource_cache_gen(&hl->obj,hl->init.cache_seq_nbits)) {
return -1; return -1;
} }
} }
@ -156,14 +156,14 @@ int binsource_initialize(binsource_hl* hl) {
} }
int binsource_work(binsource_hl* hl) { int srslte_binsource_work(srslte_binsource_hl* hl) {
int ret = -1; int ret = -1;
if (hl->init.cache_seq_nbits) { if (hl->init.cache_seq_nbits) {
binsource_cache_cpy(&hl->obj,hl->output,hl->ctrl_in.nbits); srslte_binsource_cache_cpy(&hl->obj,hl->output,hl->ctrl_in.nbits);
ret = 0; ret = 0;
} else { } else {
ret = binsource_generate(&hl->obj,hl->output,hl->ctrl_in.nbits); ret = srslte_binsource_generate(&hl->obj,hl->output,hl->ctrl_in.nbits);
} }
if (!ret) { if (!ret) {
hl->out_len = hl->ctrl_in.nbits; hl->out_len = hl->ctrl_in.nbits;
@ -173,8 +173,8 @@ int binsource_work(binsource_hl* hl) {
return ret; return ret;
} }
int binsource_stop(binsource_hl* hl) { int srslte_binsource_stop(srslte_binsource_hl* hl) {
binsource_free(&hl->obj); srslte_binsource_free(&hl->obj);
return 0; return 0;
} }

40
srslte/lib/io/src/filesink.c
Unescape Escape View File

@ -34,8 +34,8 @@
#include "srslte/io/filesink.h" #include "srslte/io/filesink.h"
int filesink_init(filesink_t *q, char *filename, data_type_t type) { int srslte_filesink_init(srslte_filesink_t *q, char *filename, srslte_datatype_t type) {
bzero(q, sizeof(filesink_t)); bzero(q, sizeof(srslte_filesink_t));
q->f = fopen(filename, "w"); q->f = fopen(filename, "w");
if (!q->f) { if (!q->f) {
perror("fopen"); perror("fopen");
@ -45,14 +45,14 @@ int filesink_init(filesink_t *q, char *filename, data_type_t type) {
return 0; return 0;
} }
void filesink_free(filesink_t *q) { void srslte_filesink_free(srslte_filesink_t *q) {
if (q->f) { if (q->f) {
fclose(q->f); fclose(q->f);
} }
bzero(q, sizeof(filesink_t)); bzero(q, sizeof(srslte_filesink_t));
} }
int filesink_write(filesink_t *q, void *buffer, int nsamples) { int srslte_filesink_write(srslte_filesink_t *q, void *buffer, int nsamples) {
int i; int i;
float *fbuf = (float*) buffer; float *fbuf = (float*) buffer;
_Complex float *cbuf = (_Complex float*) buffer; _Complex float *cbuf = (_Complex float*) buffer;
@ -60,12 +60,12 @@ int filesink_write(filesink_t *q, void *buffer, int nsamples) {
int size; int size;
switch(q->type) { switch(q->type) {
case FLOAT: case SRSLTE_FLOAT:
for (i=0;i<nsamples;i++) { for (i=0;i<nsamples;i++) {
fprintf(q->f,"%g\n",fbuf[i]); fprintf(q->f,"%g\n",fbuf[i]);
} }
break; break;
case COMPLEX_FLOAT: case SRSLTE_COMPLEX_FLOAT:
for (i=0;i<nsamples;i++) { for (i=0;i<nsamples;i++) {
if (__imag__ cbuf[i] >= 0) if (__imag__ cbuf[i] >= 0)
fprintf(q->f,"%g+%gi\n",__real__ cbuf[i],__imag__ cbuf[i]); fprintf(q->f,"%g+%gi\n",__real__ cbuf[i],__imag__ cbuf[i]);
@ -73,7 +73,7 @@ int filesink_write(filesink_t *q, void *buffer, int nsamples) {
fprintf(q->f,"%g-%gi\n",__real__ cbuf[i],fabsf(__imag__ cbuf[i])); fprintf(q->f,"%g-%gi\n",__real__ cbuf[i],fabsf(__imag__ cbuf[i]));
} }
break; break;
case COMPLEX_SHORT: case SRSLTE_COMPLEX_SHORT:
for (i=0;i<nsamples;i++) { for (i=0;i<nsamples;i++) {
if (__imag__ sbuf[i] >= 0) if (__imag__ sbuf[i] >= 0)
fprintf(q->f,"%hd+%hdi\n",__real__ sbuf[i],__imag__ sbuf[i]); fprintf(q->f,"%hd+%hdi\n",__real__ sbuf[i],__imag__ sbuf[i]);
@ -81,14 +81,14 @@ int filesink_write(filesink_t *q, void *buffer, int nsamples) {
fprintf(q->f,"%hd-%hdi\n",__real__ sbuf[i],(short) abs(__imag__ sbuf[i])); fprintf(q->f,"%hd-%hdi\n",__real__ sbuf[i],(short) abs(__imag__ sbuf[i]));
} }
break; break;
case FLOAT_BIN: case SRSLTE_FLOAT_BIN:
case COMPLEX_FLOAT_BIN: case SRSLTE_COMPLEX_FLOAT_BIN:
case COMPLEX_SHORT_BIN: case SRSLTE_COMPLEX_SHORT_BIN:
if (q->type == FLOAT_BIN) { if (q->type == SRSLTE_FLOAT_BIN) {
size = sizeof(float); size = sizeof(float);
} else if (q->type == COMPLEX_FLOAT_BIN) { } else if (q->type == SRSLTE_COMPLEX_FLOAT_BIN) {
size = sizeof(_Complex float); size = sizeof(_Complex float);
} else if (q->type == COMPLEX_SHORT_BIN) { } else if (q->type == SRSLTE_COMPLEX_SHORT_BIN) {
size = sizeof(_Complex short); size = sizeof(_Complex short);
} }
return fwrite(buffer, size, nsamples, q->f); return fwrite(buffer, size, nsamples, q->f);
@ -102,18 +102,18 @@ int filesink_write(filesink_t *q, void *buffer, int nsamples) {
int filesink_initialize(filesink_hl* h) { int srslte_filesink_initialize(srslte_filesink_hl* h) {
return filesink_init(&h->obj, h->init.file_name, h->init.data_type); return srslte_filesink_init(&h->obj, h->init.file_name, h->init.data_type);
} }
int filesink_work(filesink_hl* h) { int srslte_filesink_work(srslte_filesink_hl* h) {
if (filesink_write(&h->obj, h->input, h->in_len)<0) { if (srslte_filesink_write(&h->obj, h->input, h->in_len)<0) {
return -1; return -1;
} }
return 0; return 0;
} }
int filesink_stop(filesink_hl* h) { int srslte_filesink_stop(srslte_filesink_hl* h) {
filesink_free(&h->obj); srslte_filesink_free(&h->obj);
return 0; return 0;
} }

42
srslte/lib/io/src/filesource.c
Unescape Escape View File

@ -32,8 +32,8 @@
#include "srslte/io/filesource.h" #include "srslte/io/filesource.h"
int filesource_init(filesource_t *q, char *filename, data_type_t type) { int srslte_filesource_init(srslte_filesource_t *q, char *filename, srslte_datatype_t type) {
bzero(q, sizeof(filesource_t)); bzero(q, sizeof(srslte_filesource_t));
q->f = fopen(filename, "r"); q->f = fopen(filename, "r");
if (!q->f) { if (!q->f) {
perror("fopen"); perror("fopen");
@ -43,14 +43,14 @@ int filesource_init(filesource_t *q, char *filename, data_type_t type) {
return 0; return 0;
} }
void filesource_free(filesource_t *q) { void srslte_filesource_free(srslte_filesource_t *q) {
if (q->f) { if (q->f) {
fclose(q->f); fclose(q->f);
} }
bzero(q, sizeof(filesource_t)); bzero(q, sizeof(srslte_filesource_t));
} }
void filesource_seek(filesource_t *q, int pos) { void srslte_filesource_seek(srslte_filesource_t *q, int pos) {
fseek(q->f, pos, SEEK_SET); fseek(q->f, pos, SEEK_SET);
} }
@ -71,7 +71,7 @@ int read_complex_f(FILE *f, _Complex float *y) {
} }
} }
int filesource_read(filesource_t *q, void *buffer, int nsamples) { int srslte_filesource_read(srslte_filesource_t *q, void *buffer, int nsamples) {
int i; int i;
float *fbuf = (float*) buffer; float *fbuf = (float*) buffer;
_Complex float *cbuf = (_Complex float*) buffer; _Complex float *cbuf = (_Complex float*) buffer;
@ -79,33 +79,33 @@ int filesource_read(filesource_t *q, void *buffer, int nsamples) {
int size; int size;
switch(q->type) { switch(q->type) {
case FLOAT: case SRSLTE_FLOAT:
for (i=0;i<nsamples;i++) { for (i=0;i<nsamples;i++) {
if (EOF == fscanf(q->f,"%g\n",&fbuf[i])) if (EOF == fscanf(q->f,"%g\n",&fbuf[i]))
break; break;
} }
break; break;
case COMPLEX_FLOAT: case SRSLTE_COMPLEX_FLOAT:
for (i=0;i<nsamples;i++) { for (i=0;i<nsamples;i++) {
if (read_complex_f(q->f, &cbuf[i])) { if (read_complex_f(q->f, &cbuf[i])) {
break; break;
} }
} }
break; break;
case COMPLEX_SHORT: case SRSLTE_COMPLEX_SHORT:
for (i=0;i<nsamples;i++) { for (i=0;i<nsamples;i++) {
if (EOF == fscanf(q->f,"%hd%hdi\n",&(__real__ sbuf[i]),&(__imag__ sbuf[i]))) if (EOF == fscanf(q->f,"%hd%hdi\n",&(__real__ sbuf[i]),&(__imag__ sbuf[i])))
break; break;
} }
break; break;
case FLOAT_BIN: case SRSLTE_FLOAT_BIN:
case COMPLEX_FLOAT_BIN: case SRSLTE_COMPLEX_FLOAT_BIN:
case COMPLEX_SHORT_BIN: case SRSLTE_COMPLEX_SHORT_BIN:
if (q->type == FLOAT_BIN) { if (q->type == SRSLTE_FLOAT_BIN) {
size = sizeof(float); size = sizeof(float);
} else if (q->type == COMPLEX_FLOAT_BIN) { } else if (q->type == SRSLTE_COMPLEX_FLOAT_BIN) {
size = sizeof(_Complex float); size = sizeof(_Complex float);
} else if (q->type == COMPLEX_SHORT_BIN) { } else if (q->type == SRSLTE_COMPLEX_SHORT_BIN) {
size = sizeof(_Complex short); size = sizeof(_Complex short);
} }
return fread(buffer, size, nsamples, q->f); return fread(buffer, size, nsamples, q->f);
@ -118,19 +118,19 @@ int filesource_read(filesource_t *q, void *buffer, int nsamples) {
} }
int filesource_initialize(filesource_hl* h) { int srslte_filesource_initialize(srslte_filesource_hl* h) {
return filesource_init(&h->obj, h->init.file_name, h->init.data_type); return srslte_filesource_init(&h->obj, h->init.file_name, h->init.data_type);
} }
int filesource_work(filesource_hl* h) { int srslte_filesource_work(srslte_filesource_hl* h) {
h->out_len = filesource_read(&h->obj, h->output, h->ctrl_in.nsamples); h->out_len = srslte_filesource_read(&h->obj, h->output, h->ctrl_in.nsamples);
if (h->out_len < 0) { if (h->out_len < 0) {
return -1; return -1;
} }
return 0; return 0;
} }
int filesource_stop(filesource_hl* h) { int srslte_filesource_stop(srslte_filesource_hl* h) {
filesource_free(&h->obj); srslte_filesource_free(&h->obj);
return 0; return 0;
} }

28
srslte/lib/io/src/netsink.c
Unescape Escape View File

@ -39,10 +39,10 @@
#include "srslte/io/netsink.h" #include "srslte/io/netsink.h"
int netsink_init(netsink_t *q, char *address, int port, netsink_type_t type) { int srslte_netsink_init(srslte_netsink_t *q, char *address, int port, srslte_netsink_type_t type) {
bzero(q, sizeof(netsink_t)); bzero(q, sizeof(srslte_netsink_t));
q->sockfd=socket(AF_INET, type==NETSINK_TCP?SOCK_STREAM:SOCK_DGRAM,0); q->sockfd=socket(AF_INET, type==SRSLTE_NETSINK_TCP?SOCK_STREAM:SOCK_DGRAM,0);
if (q->sockfd < 0) { if (q->sockfd < 0) {
perror("socket"); perror("socket");
return -1; return -1;
@ -57,14 +57,14 @@ int netsink_init(netsink_t *q, char *address, int port, netsink_type_t type) {
return 0; return 0;
} }
void netsink_free(netsink_t *q) { void srslte_netsink_free(srslte_netsink_t *q) {
if (q->sockfd) { if (q->sockfd) {
close(q->sockfd); close(q->sockfd);
} }
bzero(q, sizeof(netsink_t)); bzero(q, sizeof(srslte_netsink_t));
} }
int netsink_set_nonblocking(netsink_t *q) { int srslte_netsink_set_nonblocking(srslte_netsink_t *q) {
if (fcntl(q->sockfd, F_SETFL, O_NONBLOCK)) { if (fcntl(q->sockfd, F_SETFL, O_NONBLOCK)) {
perror("fcntl"); perror("fcntl");
return -1; return -1;
@ -72,7 +72,7 @@ int netsink_set_nonblocking(netsink_t *q) {
return 0; return 0;
} }
int netsink_write(netsink_t *q, void *buffer, int nof_bytes) { int srslte_netsink_write(srslte_netsink_t *q, void *buffer, int nof_bytes) {
if (!q->connected) { if (!q->connected) {
if (connect(q->sockfd,&q->servaddr,sizeof(q->servaddr)) < 0) { if (connect(q->sockfd,&q->servaddr,sizeof(q->servaddr)) < 0) {
if (errno == ECONNREFUSED || errno == EINPROGRESS) { if (errno == ECONNREFUSED || errno == EINPROGRESS) {
@ -92,7 +92,7 @@ int netsink_write(netsink_t *q, void *buffer, int nof_bytes) {
if (n < 0) { if (n < 0) {
if (errno == ECONNRESET) { if (errno == ECONNRESET) {
close(q->sockfd); close(q->sockfd);
q->sockfd=socket(AF_INET, q->type==NETSINK_TCP?SOCK_STREAM:SOCK_DGRAM,0); q->sockfd=socket(AF_INET, q->type==SRSLTE_NETSINK_TCP?SOCK_STREAM:SOCK_DGRAM,0);
if (q->sockfd < 0) { if (q->sockfd < 0) {
perror("socket"); perror("socket");
return -1; return -1;
@ -107,18 +107,18 @@ int netsink_write(netsink_t *q, void *buffer, int nof_bytes) {
int netsink_initialize(netsink_hl* h) { int srslte_netsink_initialize(srslte_netsink_hl* h) {
return netsink_init(&h->obj, h->init.address, h->init.port, NETSINK_UDP); return srslte_netsink_init(&h->obj, h->init.address, h->init.port, SRSLTE_NETSINK_UDP);
} }
int netsink_work(netsink_hl* h) { int srslte_netsink_work(srslte_netsink_hl* h) {
if (netsink_write(&h->obj, h->input, h->in_len)<0) { if (srslte_netsink_write(&h->obj, h->input, h->in_len)<0) {
return -1; return -1;
} }
return 0; return 0;
} }
int netsink_stop(netsink_hl* h) { int srslte_netsink_stop(srslte_netsink_hl* h) {
netsink_free(&h->obj); srslte_netsink_free(&h->obj);
return 0; return 0;
} }

30
srslte/lib/io/src/netsource.c
Unescape Escape View File

@ -37,10 +37,10 @@
#include "srslte/io/netsource.h" #include "srslte/io/netsource.h"
int netsource_init(netsource_t *q, char *address, int port, netsource_type_t type) { int srslte_netsource_init(srslte_netsource_t *q, char *address, int port, srslte_netsource_type_t type) {
bzero(q, sizeof(netsource_t)); bzero(q, sizeof(srslte_netsource_t));
q->sockfd=socket(AF_INET,type==NETSOURCE_TCP?SOCK_STREAM:SOCK_DGRAM,0); q->sockfd=socket(AF_INET,type==SRSLTE_NETSOURCE_TCP?SOCK_STREAM:SOCK_DGRAM,0);
if (q->sockfd < 0) { if (q->sockfd < 0) {
perror("socket"); perror("socket");
@ -61,15 +61,15 @@ int netsource_init(netsource_t *q, char *address, int port, netsource_type_t typ
return 0; return 0;
} }
void netsource_free(netsource_t *q) { void srslte_netsource_free(srslte_netsource_t *q) {
if (q->sockfd) { if (q->sockfd) {
close(q->sockfd); close(q->sockfd);
} }
bzero(q, sizeof(netsource_t)); bzero(q, sizeof(srslte_netsource_t));
} }
int netsource_read(netsource_t *q, void *buffer, int nbytes) { int srslte_netsource_read(srslte_netsource_t *q, void *buffer, int nbytes) {
if (q->type == NETSOURCE_UDP) { if (q->type == SRSLTE_NETSOURCE_UDP) {
int n = recv(q->sockfd, buffer, nbytes, 0); int n = recv(q->sockfd, buffer, nbytes, 0);
if (n == -1) { if (n == -1) {
@ -106,7 +106,7 @@ int netsource_read(netsource_t *q, void *buffer, int nbytes) {
} }
} }
int netsource_set_nonblocking(netsource_t *q) { int srslte_netsource_set_nonblocking(srslte_netsource_t *q) {
if (fcntl(q->sockfd, F_SETFL, O_NONBLOCK)) { if (fcntl(q->sockfd, F_SETFL, O_NONBLOCK)) {
perror("fcntl"); perror("fcntl");
return -1; return -1;
@ -114,7 +114,7 @@ int netsource_set_nonblocking(netsource_t *q) {
return 0; return 0;
} }
int netsource_set_timeout(netsource_t *q, uint32_t microseconds) { int srslte_netsource_set_timeout(srslte_netsource_t *q, uint32_t microseconds) {
struct timeval t; struct timeval t;
t.tv_sec = 0; t.tv_sec = 0;
t.tv_usec = microseconds; t.tv_usec = microseconds;
@ -125,19 +125,19 @@ int netsource_set_timeout(netsource_t *q, uint32_t microseconds) {
return 0; return 0;
} }
int netsource_initialize(netsource_hl* h) { int srslte_netsource_initialize(srslte_netsource_hl* h) {
return netsource_init(&h->obj, h->init.address, h->init.port, NETSOURCE_UDP); return srslte_netsource_init(&h->obj, h->init.address, h->init.port, SRSLTE_NETSOURCE_UDP);
} }
int netsource_work(netsource_hl* h) { int srslte_netsource_work(srslte_netsource_hl* h) {
h->out_len = netsource_read(&h->obj, h->output, h->ctrl_in.nsamples); h->out_len = srslte_netsource_read(&h->obj, h->output, h->ctrl_in.nsamples);
if (h->out_len < 0) { if (h->out_len < 0) {
return -1; return -1;
} }
return 0; return 0;
} }
int netsource_stop(netsource_hl* h) { int srslte_netsource_stop(srslte_netsource_hl* h) {
netsource_free(&h->obj); srslte_netsource_free(&h->obj);
return 0; return 0;
} }

40
srslte/lib/mimo/src/layermap.c
Unescape Escape View File

@ -35,12 +35,12 @@
int layermap_single(cf_t *d, cf_t *x, int nof_symbols) { int srslte_layermap_single(cf_t *d, cf_t *x, int nof_symbols) {
memcpy(x, d, sizeof(cf_t) * nof_symbols); memcpy(x, d, sizeof(cf_t) * nof_symbols);
return nof_symbols; return nof_symbols;
} }
int layermap_diversity(cf_t *d, cf_t *x[SRSLTE_MAX_LAYERS], int nof_layers, int nof_symbols) { int srslte_layermap_diversity(cf_t *d, cf_t *x[SRSLTE_MAX_LAYERS], int nof_layers, int nof_symbols) {
int i, j; int i, j;
for (i=0;i<nof_symbols/nof_layers;i++) { for (i=0;i<nof_symbols/nof_layers;i++) {
for (j=0;j<nof_layers;j++) { for (j=0;j<nof_layers;j++) {
@ -50,18 +50,18 @@ int layermap_diversity(cf_t *d, cf_t *x[SRSLTE_MAX_LAYERS], int nof_layers, int
return i; return i;
} }
int layermap_multiplex(cf_t *d[SRSLTE_MAX_CODEWORDS], cf_t *x[SRSLTE_MAX_LAYERS], int nof_cw, int nof_layers, int srslte_layermap_multiplex(cf_t *d[SRSLTE_MAX_CODEWORDS], cf_t *x[SRSLTE_MAX_LAYERS], int nof_cw, int nof_layers,
int nof_symbols[SRSLTE_MAX_CODEWORDS]) { int nof_symbols[SRSLTE_MAX_CODEWORDS]) {
if (nof_cw == 1) { if (nof_cw == 1) {
return layermap_diversity(d[0], x, nof_layers, nof_symbols[0]); return srslte_layermap_diversity(d[0], x, nof_layers, nof_symbols[0]);
} else { } else {
int n[2]; int n[2];
n[0] = nof_layers / nof_cw; n[0] = nof_layers / nof_cw;
n[1] = nof_layers - n[0]; n[1] = nof_layers - n[0];
if (nof_symbols[0] / n[0] == nof_symbols[1] / n[1]) { if (nof_symbols[0] / n[0] == nof_symbols[1] / n[1]) {
layermap_diversity(d[0], x, n[0], nof_symbols[0]); srslte_layermap_diversity(d[0], x, n[0], nof_symbols[0]);
layermap_diversity(d[1], &x[n[0]], n[1], nof_symbols[1]); srslte_layermap_diversity(d[1], &x[n[0]], n[1], nof_symbols[1]);
return nof_symbols[0] / n[0]; return nof_symbols[0] / n[0];
} else { } else {
@ -77,7 +77,7 @@ int layermap_multiplex(cf_t *d[SRSLTE_MAX_CODEWORDS], cf_t *x[SRSLTE_MAX_LAYERS]
* Based on 36.211 6.3.3 * Based on 36.211 6.3.3
* Returns the number of symbols per layer (M_symb^layer in the specs) * Returns the number of symbols per layer (M_symb^layer in the specs)
*/ */
int layermap_type(cf_t *d[SRSLTE_MAX_CODEWORDS], cf_t *x[SRSLTE_MAX_LAYERS], int nof_cw, int nof_layers, int srslte_layermap_type(cf_t *d[SRSLTE_MAX_CODEWORDS], cf_t *x[SRSLTE_MAX_LAYERS], int nof_cw, int nof_layers,
int nof_symbols[SRSLTE_MAX_CODEWORDS], srslte_mimo_type_t type) { int nof_symbols[SRSLTE_MAX_CODEWORDS], srslte_mimo_type_t type) {
if (nof_cw > SRSLTE_MAX_CODEWORDS) { if (nof_cw > SRSLTE_MAX_CODEWORDS) {
@ -96,7 +96,7 @@ int layermap_type(cf_t *d[SRSLTE_MAX_CODEWORDS], cf_t *x[SRSLTE_MAX_LAYERS], int
switch(type) { switch(type) {
case SINGLE_ANTENNA: case SINGLE_ANTENNA:
if (nof_cw == 1 && nof_layers == 1) { if (nof_cw == 1 && nof_layers == 1) {
return layermap_single(x[0], d[0], nof_symbols[0]); return srslte_layermap_single(x[0], d[0], nof_symbols[0]);
} else { } else {
fprintf(stderr, "Number of codewords and layers must be 1 for transmission on single antenna ports\n"); fprintf(stderr, "Number of codewords and layers must be 1 for transmission on single antenna ports\n");
return -1; return -1;
@ -105,7 +105,7 @@ int layermap_type(cf_t *d[SRSLTE_MAX_CODEWORDS], cf_t *x[SRSLTE_MAX_LAYERS], int
case TX_DIVERSITY: case TX_DIVERSITY:
if (nof_cw == 1) { if (nof_cw == 1) {
if (nof_layers == 2 || nof_layers == 4) { if (nof_layers == 2 || nof_layers == 4) {
return layermap_diversity(d[0], x, nof_layers, nof_symbols[0]); return srslte_layermap_diversity(d[0], x, nof_layers, nof_symbols[0]);
} else { } else {
fprintf(stderr, "Number of layers must be 2 or 4 for transmit diversity\n"); fprintf(stderr, "Number of layers must be 2 or 4 for transmit diversity\n");
return -1; return -1;
@ -116,7 +116,7 @@ int layermap_type(cf_t *d[SRSLTE_MAX_CODEWORDS], cf_t *x[SRSLTE_MAX_LAYERS], int
} }
break; break;
case SPATIAL_MULTIPLEX: case SPATIAL_MULTIPLEX:
return layermap_multiplex(d, x, nof_cw, nof_layers, nof_symbols); return srslte_layermap_multiplex(d, x, nof_cw, nof_layers, nof_symbols);
break; break;
} }
return 0; return 0;
@ -130,11 +130,11 @@ int layermap_type(cf_t *d[SRSLTE_MAX_CODEWORDS], cf_t *x[SRSLTE_MAX_LAYERS], int
int layerdemap_single(cf_t *x, cf_t *d, int nof_symbols) { int srslte_layerdemap_single(cf_t *x, cf_t *d, int nof_symbols) {
memcpy(d, x, sizeof(cf_t) * nof_symbols); memcpy(d, x, sizeof(cf_t) * nof_symbols);
return nof_symbols; return nof_symbols;
} }
int layerdemap_diversity(cf_t *x[SRSLTE_MAX_LAYERS], cf_t *d, int nof_layers, int nof_layer_symbols) { int srslte_layerdemap_diversity(cf_t *x[SRSLTE_MAX_LAYERS], cf_t *d, int nof_layers, int nof_layer_symbols) {
int i, j; int i, j;
for (i=0;i<nof_layer_symbols;i++) { for (i=0;i<nof_layer_symbols;i++) {
for (j=0;j<nof_layers;j++) { for (j=0;j<nof_layers;j++) {
@ -144,10 +144,10 @@ int layerdemap_diversity(cf_t *x[SRSLTE_MAX_LAYERS], cf_t *d, int nof_layers, in
return nof_layer_symbols * nof_layers; return nof_layer_symbols * nof_layers;
} }
int layerdemap_multiplex(cf_t *x[SRSLTE_MAX_LAYERS], cf_t *d[SRSLTE_MAX_CODEWORDS], int nof_layers, int nof_cw, int srslte_layerdemap_multiplex(cf_t *x[SRSLTE_MAX_LAYERS], cf_t *d[SRSLTE_MAX_CODEWORDS], int nof_layers, int nof_cw,
int nof_layer_symbols, int nof_symbols[SRSLTE_MAX_CODEWORDS]) { int nof_layer_symbols, int nof_symbols[SRSLTE_MAX_CODEWORDS]) {
if (nof_cw == 1) { if (nof_cw == 1) {
return layerdemap_diversity(x, d[0], nof_layers, nof_layer_symbols); return srslte_layerdemap_diversity(x, d[0], nof_layers, nof_layer_symbols);
} else { } else {
int n[2]; int n[2];
n[0] = nof_layers / nof_cw; n[0] = nof_layers / nof_cw;
@ -155,8 +155,8 @@ int layerdemap_multiplex(cf_t *x[SRSLTE_MAX_LAYERS], cf_t *d[SRSLTE_MAX_CODEWORD
nof_symbols[0] = n[0] * nof_layer_symbols; nof_symbols[0] = n[0] * nof_layer_symbols;
nof_symbols[1] = n[1] * nof_layer_symbols; nof_symbols[1] = n[1] * nof_layer_symbols;
nof_symbols[0] = layerdemap_diversity(x, d[0], n[0], nof_layer_symbols); nof_symbols[0] = srslte_layerdemap_diversity(x, d[0], n[0], nof_layer_symbols);
nof_symbols[1] = layerdemap_diversity(&x[n[0]], d[1], n[1], nof_layer_symbols); nof_symbols[1] = srslte_layerdemap_diversity(&x[n[0]], d[1], n[1], nof_layer_symbols);
} }
return 0; return 0;
} }
@ -166,7 +166,7 @@ int layerdemap_multiplex(cf_t *x[SRSLTE_MAX_LAYERS], cf_t *d[SRSLTE_MAX_CODEWORD
* Returns 0 on ok and saves the number of symbols per codeword (M_symb^(q) in the specs) in * Returns 0 on ok and saves the number of symbols per codeword (M_symb^(q) in the specs) in
* nof_symbols. Returns -1 on error * nof_symbols. Returns -1 on error
*/ */
int layerdemap_type(cf_t *x[SRSLTE_MAX_LAYERS], cf_t *d[SRSLTE_MAX_CODEWORDS], int nof_layers, int nof_cw, int srslte_layerdemap_type(cf_t *x[SRSLTE_MAX_LAYERS], cf_t *d[SRSLTE_MAX_CODEWORDS], int nof_layers, int nof_cw,
int nof_layer_symbols, int nof_symbols[SRSLTE_MAX_CODEWORDS], srslte_mimo_type_t type) { int nof_layer_symbols, int nof_symbols[SRSLTE_MAX_CODEWORDS], srslte_mimo_type_t type) {
if (nof_cw > SRSLTE_MAX_CODEWORDS) { if (nof_cw > SRSLTE_MAX_CODEWORDS) {
@ -185,7 +185,7 @@ int layerdemap_type(cf_t *x[SRSLTE_MAX_LAYERS], cf_t *d[SRSLTE_MAX_CODEWORDS], i
switch(type) { switch(type) {
case SINGLE_ANTENNA: case SINGLE_ANTENNA:
if (nof_cw == 1 && nof_layers == 1) { if (nof_cw == 1 && nof_layers == 1) {
nof_symbols[0] = layerdemap_single(x[0], d[0], nof_layer_symbols); nof_symbols[0] = srslte_layerdemap_single(x[0], d[0], nof_layer_symbols);
nof_symbols[1] = 0; nof_symbols[1] = 0;
} else { } else {
fprintf(stderr, "Number of codewords and layers must be 1 for transmission on single antenna ports\n"); fprintf(stderr, "Number of codewords and layers must be 1 for transmission on single antenna ports\n");
@ -195,7 +195,7 @@ int layerdemap_type(cf_t *x[SRSLTE_MAX_LAYERS], cf_t *d[SRSLTE_MAX_CODEWORDS], i
case TX_DIVERSITY: case TX_DIVERSITY:
if (nof_cw == 1) { if (nof_cw == 1) {
if (nof_layers == 2 || nof_layers == 4) { if (nof_layers == 2 || nof_layers == 4) {
nof_symbols[0] = layerdemap_diversity(x, d[0], nof_layers, nof_layer_symbols); nof_symbols[0] = srslte_layerdemap_diversity(x, d[0], nof_layers, nof_layer_symbols);
nof_symbols[1] = 0; nof_symbols[1] = 0;
} else { } else {
fprintf(stderr, "Number of layers must be 2 or 4 for transmit diversity\n"); fprintf(stderr, "Number of layers must be 2 or 4 for transmit diversity\n");
@ -207,7 +207,7 @@ int layerdemap_type(cf_t *x[SRSLTE_MAX_LAYERS], cf_t *d[SRSLTE_MAX_CODEWORDS], i
} }
break; break;
case SPATIAL_MULTIPLEX: case SPATIAL_MULTIPLEX:
return layerdemap_multiplex(x, d, nof_layers, nof_cw, nof_layer_symbols, nof_symbols); return srslte_layerdemap_multiplex(x, d, nof_layers, nof_cw, nof_layer_symbols, nof_symbols);
break; break;
} }
return 0; return 0;

4
srslte/lib/mimo/test/layermap_test.c
Unescape Escape View File

@ -124,13 +124,13 @@ int main(int argc, char **argv) {
} }
/* layer mapping */ /* layer mapping */
if ((symbols_layer = layermap_type(d, x, nof_cw, nof_layers, nof_symb_cw, type)) < 0) { if ((symbols_layer = srslte_layermap_type(d, x, nof_cw, nof_layers, nof_symb_cw, type)) < 0) {
fprintf(stderr, "Error layer mapper encoder\n"); fprintf(stderr, "Error layer mapper encoder\n");
exit(-1); exit(-1);
} }
/* layer de-mapping */ /* layer de-mapping */
if (layerdemap_type(x, dp, nof_layers, nof_cw, nof_symbols/nof_layers, nof_symb_cw, type) < 0) { if (srslte_layerdemap_type(x, dp, nof_layers, nof_cw, nof_symbols/nof_layers, nof_symb_cw, type) < 0) {
fprintf(stderr, "Error layer mapper encoder\n"); fprintf(stderr, "Error layer mapper encoder\n");
exit(-1); exit(-1);
} }

34
srslte/lib/phch/src/dci.c
Unescape Escape View File

@ -70,11 +70,11 @@ int dci_msg_to_ra_dl(dci_msg_t *msg, uint16_t msg_rnti,
if (type.type == PDSCH_SCHED) { if (type.type == PDSCH_SCHED) {
bzero(ra_dl, sizeof(ra_pdsch_t)); bzero(ra_dl, sizeof(ra_pdsch_t));
bool crc_is_crnti = false; bool srslte_crc_is_crnti = false;
if (msg_rnti >= SRSLTE_CRNTI_START && msg_rnti <= SRSLTE_CRNTI_END) { if (msg_rnti >= SRSLTE_CRNTI_START && msg_rnti <= SRSLTE_CRNTI_END) {
crc_is_crnti = true; srslte_crc_is_crnti = true;
} }
if (dci_msg_unpack_pdsch(msg, ra_dl, cell.nof_prb, crc_is_crnti)) { if (dci_msg_unpack_pdsch(msg, ra_dl, cell.nof_prb, srslte_crc_is_crnti)) {
fprintf(stderr, "Can't unpack PDSCH message\n"); fprintf(stderr, "Can't unpack PDSCH message\n");
return ret; return ret;
} }
@ -516,7 +516,7 @@ int dci_format1_unpack(dci_msg_t *msg, ra_pdsch_t *data, uint32_t nof_prb) {
* TODO: RA procedure initiated by PDCCH, TPC commands * TODO: RA procedure initiated by PDCCH, TPC commands
*/ */
int dci_format1As_pack(ra_pdsch_t *data, dci_msg_t *msg, uint32_t nof_prb, int dci_format1As_pack(ra_pdsch_t *data, dci_msg_t *msg, uint32_t nof_prb,
bool crc_is_crnti) { bool srslte_crc_is_crnti) {
/* pack bits */ /* pack bits */
uint8_t *y = msg->data; uint8_t *y = msg->data;
@ -538,7 +538,7 @@ int dci_format1As_pack(ra_pdsch_t *data, dci_msg_t *msg, uint32_t nof_prb,
} }
} else { } else {
uint32_t n_vrb_dl; uint32_t n_vrb_dl;
if (crc_is_crnti && nof_prb > 50) { if (srslte_crc_is_crnti && nof_prb > 50) {
n_vrb_dl = 16; n_vrb_dl = 16;
} else { } else {
n_vrb_dl = ra_type2_n_vrb_dl(nof_prb, data->type2_alloc.n_gap == t2_ng1); n_vrb_dl = ra_type2_n_vrb_dl(nof_prb, data->type2_alloc.n_gap == t2_ng1);
@ -559,7 +559,7 @@ int dci_format1As_pack(ra_pdsch_t *data, dci_msg_t *msg, uint32_t nof_prb,
riv = data->type2_alloc.riv; riv = data->type2_alloc.riv;
} }
uint32_t nb_gap = 0; uint32_t nb_gap = 0;
if (crc_is_crnti && data->type2_alloc.mode == t2_dist && nof_prb >= 50) { if (srslte_crc_is_crnti && data->type2_alloc.mode == t2_dist && nof_prb >= 50) {
nb_gap = 1; nb_gap = 1;
*y++ = data->type2_alloc.n_gap; *y++ = data->type2_alloc.n_gap;
} }
@ -570,7 +570,7 @@ int dci_format1As_pack(ra_pdsch_t *data, dci_msg_t *msg, uint32_t nof_prb,
bit_pack(data->harq_process, &y, 3); bit_pack(data->harq_process, &y, 3);
if (!crc_is_crnti && nof_prb >= 50 && data->type2_alloc.mode == t2_dist) { if (!srslte_crc_is_crnti && nof_prb >= 50 && data->type2_alloc.mode == t2_dist) {
*y++ = data->type2_alloc.n_gap; *y++ = data->type2_alloc.n_gap;
} else { } else {
y++; // bit reserved y++; // bit reserved
@ -579,7 +579,7 @@ int dci_format1As_pack(ra_pdsch_t *data, dci_msg_t *msg, uint32_t nof_prb,
// rv version // rv version
bit_pack(data->rv_idx, &y, 2); bit_pack(data->rv_idx, &y, 2);
if (crc_is_crnti) { if (srslte_crc_is_crnti) {
// TPC not implemented // TPC not implemented
*y++ = 0; *y++ = 0;
*y++ = 0; *y++ = 0;
@ -602,7 +602,7 @@ int dci_format1As_pack(ra_pdsch_t *data, dci_msg_t *msg, uint32_t nof_prb,
* *
*/ */
int dci_format1As_unpack(dci_msg_t *msg, ra_pdsch_t *data, uint32_t nof_prb, int dci_format1As_unpack(dci_msg_t *msg, ra_pdsch_t *data, uint32_t nof_prb,
bool crc_is_crnti) { bool srslte_crc_is_crnti) {
/* pack bits */ /* pack bits */
uint8_t *y = msg->data; uint8_t *y = msg->data;
@ -626,7 +626,7 @@ int dci_format1As_unpack(dci_msg_t *msg, ra_pdsch_t *data, uint32_t nof_prb,
/* unpack RIV according to 7.1.6.3 of 36.213 */ /* unpack RIV according to 7.1.6.3 of 36.213 */
uint32_t nb_gap = 0; uint32_t nb_gap = 0;
if (crc_is_crnti && data->type2_alloc.mode == t2_dist && nof_prb >= 50) { if (srslte_crc_is_crnti && data->type2_alloc.mode == t2_dist && nof_prb >= 50) {
nb_gap = 1; nb_gap = 1;
data->type2_alloc.n_gap = *y++; data->type2_alloc.n_gap = *y++;
} }
@ -646,7 +646,7 @@ int dci_format1As_unpack(dci_msg_t *msg, ra_pdsch_t *data, uint32_t nof_prb,
data->harq_process = bit_unpack(&y, 3); data->harq_process = bit_unpack(&y, 3);
if (!crc_is_crnti && nof_prb >= 50 && data->type2_alloc.mode == t2_dist) { if (!srslte_crc_is_crnti && nof_prb >= 50 && data->type2_alloc.mode == t2_dist) {
data->type2_alloc.n_gap = *y++; data->type2_alloc.n_gap = *y++;
} else { } else {
y++; // bit reserved y++; // bit reserved
@ -655,7 +655,7 @@ int dci_format1As_unpack(dci_msg_t *msg, ra_pdsch_t *data, uint32_t nof_prb,
// rv version // rv version
bit_pack(data->rv_idx, &y, 2); bit_pack(data->rv_idx, &y, 2);
if (crc_is_crnti) { if (srslte_crc_is_crnti) {
// TPC not implemented // TPC not implemented
y++; y++;
y++; y++;
@ -665,7 +665,7 @@ int dci_format1As_unpack(dci_msg_t *msg, ra_pdsch_t *data, uint32_t nof_prb,
} }
uint32_t n_prb; uint32_t n_prb;
if (crc_is_crnti) { if (srslte_crc_is_crnti) {
n_prb = ra_nprb_dl(data, nof_prb); n_prb = ra_nprb_dl(data, nof_prb);
} else { } else {
n_prb = data->type2_alloc.n_prb1a == nprb1a_2 ? 2 : 3; n_prb = data->type2_alloc.n_prb1a == nprb1a_2 ? 2 : 3;
@ -765,12 +765,12 @@ int dci_format1Cs_unpack(dci_msg_t *msg, ra_pdsch_t *data, uint32_t nof_prb) {
} }
int dci_msg_pack_pdsch(ra_pdsch_t *data, dci_msg_t *msg, dci_format_t format, int dci_msg_pack_pdsch(ra_pdsch_t *data, dci_msg_t *msg, dci_format_t format,
uint32_t nof_prb, bool crc_is_crnti) { uint32_t nof_prb, bool srslte_crc_is_crnti) {
switch (format) { switch (format) {
case Format1: case Format1:
return dci_format1_pack(data, msg, nof_prb); return dci_format1_pack(data, msg, nof_prb);
case Format1A: case Format1A:
return dci_format1As_pack(data, msg, nof_prb, crc_is_crnti); return dci_format1As_pack(data, msg, nof_prb, srslte_crc_is_crnti);
case Format1C: case Format1C:
return dci_format1Cs_pack(data, msg, nof_prb); return dci_format1Cs_pack(data, msg, nof_prb);
default: default:
@ -781,11 +781,11 @@ int dci_msg_pack_pdsch(ra_pdsch_t *data, dci_msg_t *msg, dci_format_t format,
} }
int dci_msg_unpack_pdsch(dci_msg_t *msg, ra_pdsch_t *data, uint32_t nof_prb, int dci_msg_unpack_pdsch(dci_msg_t *msg, ra_pdsch_t *data, uint32_t nof_prb,
bool crc_is_crnti) { bool srslte_crc_is_crnti) {
if (msg->nof_bits == dci_format_sizeof(Format1, nof_prb)) { if (msg->nof_bits == dci_format_sizeof(Format1, nof_prb)) {
return dci_format1_unpack(msg, data, nof_prb); return dci_format1_unpack(msg, data, nof_prb);
} else if (msg->nof_bits == dci_format_sizeof(Format1A, nof_prb)) { } else if (msg->nof_bits == dci_format_sizeof(Format1A, nof_prb)) {
return dci_format1As_unpack(msg, data, nof_prb, crc_is_crnti); return dci_format1As_unpack(msg, data, nof_prb, srslte_crc_is_crnti);
} else if (msg->nof_bits == dci_format_sizeof(Format1C, nof_prb)) { } else if (msg->nof_bits == dci_format_sizeof(Format1C, nof_prb)) {
return dci_format1Cs_unpack(msg, data, nof_prb); return dci_format1Cs_unpack(msg, data, nof_prb);
} else { } else {

44
srslte/lib/phch/src/pbch.c
Unescape Escape View File

@ -41,7 +41,7 @@
#include "srslte/utils/vector.h" #include "srslte/utils/vector.h"
#include "srslte/utils/debug.h" #include "srslte/utils/debug.h"
const uint8_t crc_mask[4][16] = { const uint8_t srslte_crc_mask[4][16] = {
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
@ -151,15 +151,15 @@ int pbch_init(pbch_t *q, srslte_cell_t cell) {
demod_soft_table_set(&q->demod, &q->mod); demod_soft_table_set(&q->demod, &q->mod);
demod_soft_alg_set(&q->demod, APPROX); demod_soft_alg_set(&q->demod, APPROX);
if (sequence_pbch(&q->seq_pbch, q->cell.cp, q->cell.id)) { if (srslte_sequence_pbch(&q->seq_pbch, q->cell.cp, q->cell.id)) {
goto clean; goto clean;
} }
uint32_t poly[3] = { 0x6D, 0x4F, 0x57 }; uint32_t poly[3] = { 0x6D, 0x4F, 0x57 };
if (viterbi_init(&q->decoder, viterbi_37, poly, 40, true)) { if (srslte_viterbi_init(&q->decoder, SRSLTE_VITERBI_37, poly, 40, true)) {
goto clean; goto clean;
} }
if (crc_init(&q->crc, SRSLTE_LTE_CRC16, 16)) { if (srslte_crc_init(&q->crc, SRSLTE_LTE_CRC16, 16)) {
goto clean; goto clean;
} }
q->encoder.K = 7; q->encoder.K = 7;
@ -233,9 +233,9 @@ void pbch_free(pbch_t *q) {
free(q->pbch_rm_b); free(q->pbch_rm_b);
} }
precoding_free(&q->precoding); precoding_free(&q->precoding);
sequence_free(&q->seq_pbch); srslte_sequence_free(&q->seq_pbch);
modem_table_free(&q->mod); modem_table_free(&q->mod);
viterbi_free(&q->decoder); srslte_viterbi_free(&q->decoder);
demod_soft_free(&q->demod); demod_soft_free(&q->demod);
bzero(q, sizeof(pbch_t)); bzero(q, sizeof(pbch_t));
@ -356,10 +356,10 @@ void pbch_decode_reset(pbch_t *q) {
q->frame_idx = 0; q->frame_idx = 0;
} }
void crc_set_mask(uint8_t *data, int nof_ports) { void srslte_crc_set_mask(uint8_t *data, int nof_ports) {
int i; int i;
for (i = 0; i < 16; i++) { for (i = 0; i < 16; i++) {
data[BCH_PAYLOAD_LEN + i] = (data[BCH_PAYLOAD_LEN + i] + crc_mask[nof_ports - 1][i]) % 2; data[BCH_PAYLOAD_LEN + i] = (data[BCH_PAYLOAD_LEN + i] + srslte_crc_mask[nof_ports - 1][i]) % 2;
} }
} }
@ -370,11 +370,11 @@ void crc_set_mask(uint8_t *data, int nof_ports) {
* *
* Returns 0 if the data is correct, -1 otherwise * Returns 0 if the data is correct, -1 otherwise
*/ */
uint32_t pbch_crc_check(pbch_t *q, uint8_t *bits, uint32_t nof_ports) { uint32_t pbch_srslte_crc_check(pbch_t *q, uint8_t *bits, uint32_t nof_ports) {
uint8_t data[BCH_PAYLOADCRC_LEN]; uint8_t data[BCH_PAYLOADCRC_LEN];
memcpy(data, bits, BCH_PAYLOADCRC_LEN * sizeof(uint8_t)); memcpy(data, bits, BCH_PAYLOADCRC_LEN * sizeof(uint8_t));
crc_set_mask(data, nof_ports); srslte_crc_set_mask(data, nof_ports);
int ret = crc_checksum(&q->crc, data, BCH_PAYLOADCRC_LEN); int ret = srslte_crc_checksum(&q->crc, data, BCH_PAYLOADCRC_LEN);
if (ret == 0) { if (ret == 0) {
uint32_t chkzeros=0; uint32_t chkzeros=0;
for (int i=0;i<BCH_PAYLOAD_LEN;i++) { for (int i=0;i<BCH_PAYLOAD_LEN;i++) {
@ -404,19 +404,19 @@ int pbch_decode_frame(pbch_t *q, uint32_t src, uint32_t dst, uint32_t n,
n * nof_bits); n * nof_bits);
for (j = 0; j < dst * nof_bits; j++) { for (j = 0; j < dst * nof_bits; j++) {
q->temp[j] = RX_NULL; q->temp[j] = SRSLTE_RX_NULL;
} }
for (j = (dst + n) * nof_bits; j < 4 * nof_bits; j++) { for (j = (dst + n) * nof_bits; j < 4 * nof_bits; j++) {
q->temp[j] = RX_NULL; q->temp[j] = SRSLTE_RX_NULL;
} }
/* unrate matching */ /* unrate matching */
rm_conv_rx(q->temp, 4 * nof_bits, q->pbch_rm_f, BCH_ENCODED_LEN); srslte_rm_conv_rx(q->temp, 4 * nof_bits, q->pbch_rm_f, BCH_ENCODED_LEN);
/* decode */ /* decode */
viterbi_decode_f(&q->decoder, q->pbch_rm_f, q->data, BCH_PAYLOADCRC_LEN); srslte_viterbi_decode_f(&q->decoder, q->pbch_rm_f, q->data, BCH_PAYLOADCRC_LEN);
if (!pbch_crc_check(q, q->data, nof_ports)) { if (!pbch_srslte_crc_check(q, q->data, nof_ports)) {
return 1; return 1;
} else { } else {
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;
@ -490,7 +490,7 @@ int pbch_decode(pbch_t *q, cf_t *slot1_symbols, cf_t *ce_slot1[SRSLTE_MAX_PORTS]
} else { } else {
predecoding_diversity(&q->precoding, q->pbch_symbols[0], q->ce, x, nant, predecoding_diversity(&q->precoding, q->pbch_symbols[0], q->ce, x, nant,
q->nof_symbols, noise_estimate); q->nof_symbols, noise_estimate);
layerdemap_diversity(x, q->pbch_d, nant, q->nof_symbols / nant); srslte_layerdemap_diversity(x, q->pbch_d, nant, q->nof_symbols / nant);
} }
/* demodulate symbols */ /* demodulate symbols */
@ -563,12 +563,12 @@ int pbch_encode(pbch_t *q, uint8_t bch_payload[BCH_PAYLOAD_LEN], cf_t *slot1_sym
memcpy(q->data, bch_payload, sizeof(uint8_t) * BCH_PAYLOAD_LEN); memcpy(q->data, bch_payload, sizeof(uint8_t) * BCH_PAYLOAD_LEN);
/* encode & modulate */ /* encode & modulate */
crc_attach(&q->crc, q->data, BCH_PAYLOAD_LEN); srslte_crc_attach(&q->crc, q->data, BCH_PAYLOAD_LEN);
crc_set_mask(q->data, q->cell.nof_ports); srslte_crc_set_mask(q->data, q->cell.nof_ports);
convcoder_encode(&q->encoder, q->data, q->data_enc, BCH_PAYLOADCRC_LEN); srslte_convcoder_encode(&q->encoder, q->data, q->data_enc, BCH_PAYLOADCRC_LEN);
rm_conv_tx(q->data_enc, BCH_ENCODED_LEN, q->pbch_rm_b, 4 * nof_bits); srslte_rm_conv_tx(q->data_enc, BCH_ENCODED_LEN, q->pbch_rm_b, 4 * nof_bits);
} }
@ -579,7 +579,7 @@ int pbch_encode(pbch_t *q, uint8_t bch_payload[BCH_PAYLOAD_LEN], cf_t *slot1_sym
/* layer mapping & precoding */ /* layer mapping & precoding */
if (q->cell.nof_ports > 1) { if (q->cell.nof_ports > 1) {
layermap_diversity(q->pbch_d, x, q->cell.nof_ports, q->nof_symbols); srslte_layermap_diversity(q->pbch_d, x, q->cell.nof_ports, q->nof_symbols);
precoding_diversity(&q->precoding, x, q->pbch_symbols, q->cell.nof_ports, precoding_diversity(&q->precoding, x, q->pbch_symbols, q->cell.nof_ports,
q->nof_symbols / q->cell.nof_ports); q->nof_symbols / q->cell.nof_ports);
} else { } else {

8
srslte/lib/phch/src/pcfich.c
Unescape Escape View File

@ -88,7 +88,7 @@ int pcfich_init(pcfich_t *q, regs_t *regs, srslte_cell_t cell) {
demod_soft_alg_set(&q->demod, APPROX); demod_soft_alg_set(&q->demod, APPROX);
for (int nsf = 0; nsf < SRSLTE_NSUBFRAMES_X_FRAME; nsf++) { for (int nsf = 0; nsf < SRSLTE_NSUBFRAMES_X_FRAME; nsf++) {
if (sequence_pcfich(&q->seq_pcfich[nsf], 2 * nsf, q->cell.id)) { if (srslte_sequence_pcfich(&q->seq_pcfich[nsf], 2 * nsf, q->cell.id)) {
goto clean; goto clean;
} }
} }
@ -112,7 +112,7 @@ int pcfich_init(pcfich_t *q, regs_t *regs, srslte_cell_t cell) {
void pcfich_free(pcfich_t *q) { void pcfich_free(pcfich_t *q) {
for (int ns = 0; ns < SRSLTE_NSUBFRAMES_X_FRAME; ns++) { for (int ns = 0; ns < SRSLTE_NSUBFRAMES_X_FRAME; ns++) {
sequence_free(&q->seq_pcfich[ns]); srslte_sequence_free(&q->seq_pcfich[ns]);
} }
modem_table_free(&q->mod); modem_table_free(&q->mod);
precoding_free(&q->precoding); precoding_free(&q->precoding);
@ -203,7 +203,7 @@ int pcfich_decode(pcfich_t *q, cf_t *slot_symbols, cf_t *ce[SRSLTE_MAX_PORTS], f
} else { } else {
predecoding_diversity(&q->precoding, q->pcfich_symbols[0], ce_precoding, x, predecoding_diversity(&q->precoding, q->pcfich_symbols[0], ce_precoding, x,
q->cell.nof_ports, q->nof_symbols, noise_estimate); q->cell.nof_ports, q->nof_symbols, noise_estimate);
layerdemap_diversity(x, q->pcfich_d, q->cell.nof_ports, srslte_layerdemap_diversity(x, q->pcfich_d, q->cell.nof_ports,
q->nof_symbols / q->cell.nof_ports); q->nof_symbols / q->cell.nof_ports);
} }
@ -260,7 +260,7 @@ int pcfich_encode(pcfich_t *q, uint32_t cfi, cf_t *slot_symbols[SRSLTE_MAX_PORTS
/* layer mapping & precoding */ /* layer mapping & precoding */
if (q->cell.nof_ports > 1) { if (q->cell.nof_ports > 1) {
layermap_diversity(q->pcfich_d, x, q->cell.nof_ports, q->nof_symbols); srslte_layermap_diversity(q->pcfich_d, x, q->cell.nof_ports, q->nof_symbols);
precoding_diversity(&q->precoding, x, symbols_precoding, q->cell.nof_ports, precoding_diversity(&q->precoding, x, symbols_precoding, q->cell.nof_ports,
q->nof_symbols / q->cell.nof_ports); q->nof_symbols / q->cell.nof_ports);
} else { } else {

48
srslte/lib/phch/src/pdcch.c
Unescape Escape View File

@ -81,7 +81,7 @@ int pdcch_init(pdcch_t *q, regs_t *regs, srslte_cell_t cell) {
if (modem_table_lte(&q->mod, LTE_QPSK, true)) { if (modem_table_lte(&q->mod, LTE_QPSK, true)) {
goto clean; goto clean;
} }
if (crc_init(&q->crc, SRSLTE_LTE_CRC16, 16)) { if (srslte_crc_init(&q->crc, SRSLTE_LTE_CRC16, 16)) {
goto clean; goto clean;
} }
@ -92,13 +92,13 @@ int pdcch_init(pdcch_t *q, regs_t *regs, srslte_cell_t cell) {
for (i = 0; i < SRSLTE_NSUBFRAMES_X_FRAME; i++) { for (i = 0; i < SRSLTE_NSUBFRAMES_X_FRAME; i++) {
// we need to pregenerate the sequence for the maximum number of bits, which is 8 times // we need to pregenerate the sequence for the maximum number of bits, which is 8 times
// the maximum number of REGs (for CFI=3) // the maximum number of REGs (for CFI=3)
if (sequence_pdcch(&q->seq_pdcch[i], 2 * i, q->cell.id, 8*regs_pdcch_nregs(q->regs, 3))) { if (srslte_sequence_pdcch(&q->seq_pdcch[i], 2 * i, q->cell.id, 8*regs_pdcch_nregs(q->regs, 3))) {
goto clean; goto clean;
} }
} }
uint32_t poly[3] = { 0x6D, 0x4F, 0x57 }; uint32_t poly[3] = { 0x6D, 0x4F, 0x57 };
if (viterbi_init(&q->decoder, viterbi_37, poly, DCI_MAX_BITS + 16, true)) { if (srslte_viterbi_init(&q->decoder, SRSLTE_VITERBI_37, poly, DCI_MAX_BITS + 16, true)) {
goto clean; goto clean;
} }
@ -168,14 +168,14 @@ void pdcch_free(pdcch_t *q) {
} }
for (i = 0; i < SRSLTE_NSUBFRAMES_X_FRAME; i++) { for (i = 0; i < SRSLTE_NSUBFRAMES_X_FRAME; i++) {
sequence_free(&q->seq_pdcch[i]); srslte_sequence_free(&q->seq_pdcch[i]);
} }
demod_soft_free(&q->demod); demod_soft_free(&q->demod);
precoding_free(&q->precoding); precoding_free(&q->precoding);
modem_table_free(&q->mod); modem_table_free(&q->mod);
viterbi_free(&q->decoder); srslte_viterbi_free(&q->decoder);
bzero(q, sizeof(pdcch_t)); bzero(q, sizeof(pdcch_t));
@ -275,7 +275,7 @@ uint32_t pdcch_common_locations(pdcch_t *q, dci_location_t *c, uint32_t max_cand
*/ */
static int dci_decode(pdcch_t *q, float *e, uint8_t *data, uint32_t E, uint32_t nof_bits, uint16_t *crc) { static int dci_decode(pdcch_t *q, float *e, uint8_t *data, uint32_t E, uint32_t nof_bits, uint16_t *crc) {
uint16_t p_bits, crc_res; uint16_t p_bits, srslte_crc_res;
uint8_t *x; uint8_t *x;
if (q != NULL && if (q != NULL &&
@ -290,7 +290,7 @@ static int dci_decode(pdcch_t *q, float *e, uint8_t *data, uint32_t E, uint32_t
} }
/* unrate matching */ /* unrate matching */
rm_conv_rx(e, E, q->pdcch_rm_f, 3 * (nof_bits + 16)); srslte_rm_conv_rx(e, E, q->pdcch_rm_f, 3 * (nof_bits + 16));
DEBUG("Viterbi input: ", 0); DEBUG("Viterbi input: ", 0);
if (VERBOSE_ISDEBUG()) { if (VERBOSE_ISDEBUG()) {
@ -298,7 +298,7 @@ static int dci_decode(pdcch_t *q, float *e, uint8_t *data, uint32_t E, uint32_t
} }
/* viterbi decoder */ /* viterbi decoder */
viterbi_decode_f(&q->decoder, q->pdcch_rm_f, data, nof_bits + 16); srslte_viterbi_decode_f(&q->decoder, q->pdcch_rm_f, data, nof_bits + 16);
if (VERBOSE_ISDEBUG()) { if (VERBOSE_ISDEBUG()) {
bit_fprint(stdout, data, nof_bits + 16); bit_fprint(stdout, data, nof_bits + 16);
@ -306,12 +306,12 @@ static int dci_decode(pdcch_t *q, float *e, uint8_t *data, uint32_t E, uint32_t
x = &data[nof_bits]; x = &data[nof_bits];
p_bits = (uint16_t) bit_unpack(&x, 16); p_bits = (uint16_t) bit_unpack(&x, 16);
crc_res = ((uint16_t) crc_checksum(&q->crc, data, nof_bits) & 0xffff); srslte_crc_res = ((uint16_t) srslte_crc_checksum(&q->crc, data, nof_bits) & 0xffff);
INFO("p_bits: 0x%x, crc_checksum: 0x%x, crc_rem: 0x%x\n", p_bits, crc_res, INFO("p_bits: 0x%x, srslte_crc_checksum: 0x%x, srslte_crc_rem: 0x%x\n", p_bits, srslte_crc_res,
p_bits ^ crc_res); p_bits ^ srslte_crc_res);
if (crc) { if (crc) {
*crc = p_bits ^ crc_res; *crc = p_bits ^ srslte_crc_res;
} }
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;
} else { } else {
@ -322,16 +322,16 @@ static int dci_decode(pdcch_t *q, float *e, uint8_t *data, uint32_t E, uint32_t
/** Tries to decode a DCI message from the LLRs stored in the pdcch_t structure by the function /** Tries to decode a DCI message from the LLRs stored in the pdcch_t structure by the function
* pdcch_extract_llr(). This function can be called multiple times. * pdcch_extract_llr(). This function can be called multiple times.
* The decoded message is stored in msg and the CRC remainder in crc_rem pointer * The decoded message is stored in msg and the CRC remainder in srslte_crc_rem pointer
* *
*/ */
int pdcch_decode_msg(pdcch_t *q, dci_msg_t *msg, dci_location_t *location, dci_format_t format, uint16_t *crc_rem) int pdcch_decode_msg(pdcch_t *q, dci_msg_t *msg, dci_location_t *location, dci_format_t format, uint16_t *srslte_crc_rem)
{ {
int ret = SRSLTE_ERROR_INVALID_INPUTS; int ret = SRSLTE_ERROR_INVALID_INPUTS;
if (q != NULL && if (q != NULL &&
msg != NULL && msg != NULL &&
dci_location_isvalid(location) && dci_location_isvalid(location) &&
crc_rem != NULL) srslte_crc_rem != NULL)
{ {
if (location->ncce * 72 + PDCCH_FORMAT_NOF_BITS(location->L) > if (location->ncce * 72 + PDCCH_FORMAT_NOF_BITS(location->L) >
q->nof_cce*72) { q->nof_cce*72) {
@ -345,7 +345,7 @@ int pdcch_decode_msg(pdcch_t *q, dci_msg_t *msg, dci_location_t *location, dci_f
location->ncce * 72, e_bits, nof_bits, location->ncce, location->L); location->ncce * 72, e_bits, nof_bits, location->ncce, location->L);
ret = dci_decode(q, &q->pdcch_llr[location->ncce * 72], ret = dci_decode(q, &q->pdcch_llr[location->ncce * 72],
msg->data, e_bits, nof_bits, crc_rem); msg->data, e_bits, nof_bits, srslte_crc_rem);
if (ret == SRSLTE_SUCCESS) { if (ret == SRSLTE_SUCCESS) {
msg->nof_bits = nof_bits; msg->nof_bits = nof_bits;
} }
@ -410,7 +410,7 @@ int pdcch_extract_llr(pdcch_t *q, cf_t *sf_symbols, cf_t *ce[SRSLTE_MAX_PORTS],
predecoding_single(&q->precoding, q->pdcch_symbols[0], q->ce[0], q->pdcch_d, nof_symbols, noise_estimate); predecoding_single(&q->precoding, q->pdcch_symbols[0], q->ce[0], q->pdcch_d, nof_symbols, noise_estimate);
} else { } else {
predecoding_diversity(&q->precoding, q->pdcch_symbols[0], q->ce, x, q->cell.nof_ports, nof_symbols, noise_estimate); predecoding_diversity(&q->precoding, q->pdcch_symbols[0], q->ce, x, q->cell.nof_ports, nof_symbols, noise_estimate);
layerdemap_diversity(x, q->pdcch_d, q->cell.nof_ports, nof_symbols / q->cell.nof_ports); srslte_layerdemap_diversity(x, q->pdcch_d, q->cell.nof_ports, nof_symbols / q->cell.nof_ports);
} }
DEBUG("pdcch d symbols: ", 0); DEBUG("pdcch d symbols: ", 0);
@ -437,7 +437,7 @@ int pdcch_extract_llr(pdcch_t *q, cf_t *sf_symbols, cf_t *ce[SRSLTE_MAX_PORTS],
static void crc_set_mask_rnti(uint8_t *crc, uint16_t rnti) { static void srslte_crc_set_mask_rnti(uint8_t *crc, uint16_t rnti) {
uint32_t i; uint32_t i;
uint8_t mask[16]; uint8_t mask[16];
uint8_t *r = mask; uint8_t *r = mask;
@ -455,7 +455,7 @@ static void crc_set_mask_rnti(uint8_t *crc, uint16_t rnti) {
*/ */
static int dci_encode(pdcch_t *q, uint8_t *data, uint8_t *e, uint32_t nof_bits, uint32_t E, static int dci_encode(pdcch_t *q, uint8_t *data, uint8_t *e, uint32_t nof_bits, uint32_t E,
uint16_t rnti) { uint16_t rnti) {
convcoder_t encoder; srslte_convcoder_t encoder;
uint8_t tmp[3 * (DCI_MAX_BITS + 16)]; uint8_t tmp[3 * (DCI_MAX_BITS + 16)];
if (q != NULL && if (q != NULL &&
@ -471,17 +471,17 @@ static int dci_encode(pdcch_t *q, uint8_t *data, uint8_t *e, uint32_t nof_bits,
encoder.tail_biting = true; encoder.tail_biting = true;
memcpy(encoder.poly, poly, 3 * sizeof(int)); memcpy(encoder.poly, poly, 3 * sizeof(int));
crc_attach(&q->crc, data, nof_bits); srslte_crc_attach(&q->crc, data, nof_bits);
crc_set_mask_rnti(&data[nof_bits], rnti); srslte_crc_set_mask_rnti(&data[nof_bits], rnti);
convcoder_encode(&encoder, data, tmp, nof_bits + 16); srslte_convcoder_encode(&encoder, data, tmp, nof_bits + 16);
DEBUG("CConv output: ", 0); DEBUG("CConv output: ", 0);
if (VERBOSE_ISDEBUG()) { if (VERBOSE_ISDEBUG()) {
vec_fprint_b(stdout, tmp, 3 * (nof_bits + 16)); vec_fprint_b(stdout, tmp, 3 * (nof_bits + 16));
} }
rm_conv_tx(tmp, 3 * (nof_bits + 16), e, E); srslte_rm_conv_tx(tmp, 3 * (nof_bits + 16), e, E);
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;
} else { } else {
@ -544,7 +544,7 @@ int pdcch_encode(pdcch_t *q, dci_msg_t *msg, dci_location_t location, uint16_t r
/* layer mapping & precoding */ /* layer mapping & precoding */
if (q->cell.nof_ports > 1) { if (q->cell.nof_ports > 1) {
layermap_diversity(q->pdcch_d, x, q->cell.nof_ports, nof_symbols); srslte_layermap_diversity(q->pdcch_d, x, q->cell.nof_ports, nof_symbols);
precoding_diversity(&q->precoding, x, q->pdcch_symbols, q->cell.nof_ports, nof_symbols / q->cell.nof_ports); precoding_diversity(&q->precoding, x, q->pdcch_symbols, q->cell.nof_ports, nof_symbols / q->cell.nof_ports);
} else { } else {
memcpy(q->pdcch_symbols[0], q->pdcch_d, nof_symbols * sizeof(cf_t)); memcpy(q->pdcch_symbols[0], q->pdcch_d, nof_symbols * sizeof(cf_t));

20
srslte/lib/phch/src/pdsch.c
Unescape Escape View File

@ -288,7 +288,7 @@ void pdsch_free(pdsch_t *q) {
} }
for (i = 0; i < SRSLTE_NSUBFRAMES_X_FRAME; i++) { for (i = 0; i < SRSLTE_NSUBFRAMES_X_FRAME; i++) {
sequence_free(&q->seq_pdsch[i]); srslte_sequence_free(&q->seq_pdsch[i]);
} }
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
@ -309,7 +309,7 @@ void pdsch_free(pdsch_t *q) {
int pdsch_set_rnti(pdsch_t *q, uint16_t rnti) { int pdsch_set_rnti(pdsch_t *q, uint16_t rnti) {
uint32_t i; uint32_t i;
for (i = 0; i < SRSLTE_NSUBFRAMES_X_FRAME; i++) { for (i = 0; i < SRSLTE_NSUBFRAMES_X_FRAME; i++) {
if (sequence_pdsch(&q->seq_pdsch[i], rnti, 0, 2 * i, q->cell.id, if (srslte_sequence_pdsch(&q->seq_pdsch[i], rnti, 0, 2 * i, q->cell.id,
q->max_re * srslte_mod_bits_x_symbol(LTE_QAM64))) { q->max_re * srslte_mod_bits_x_symbol(LTE_QAM64))) {
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
@ -385,7 +385,7 @@ int pdsch_decode_rnti(pdsch_t *q, harq_t *harq, cf_t *sf_symbols, cf_t *ce[SRSLT
} else { } else {
predecoding_diversity(&q->precoding, q->pdsch_symbols[0], q->ce, x, q->cell.nof_ports, predecoding_diversity(&q->precoding, q->pdsch_symbols[0], q->ce, x, q->cell.nof_ports,
harq->nof_re, noise_estimate); harq->nof_re, noise_estimate);
layerdemap_diversity(x, q->pdsch_d, q->cell.nof_ports, srslte_layerdemap_diversity(x, q->pdsch_d, q->cell.nof_ports,
harq->nof_re / q->cell.nof_ports); harq->nof_re / q->cell.nof_ports);
} }
@ -399,12 +399,12 @@ int pdsch_decode_rnti(pdsch_t *q, harq_t *harq, cf_t *sf_symbols, cf_t *ce[SRSLT
/* descramble */ /* descramble */
if (rnti != q->rnti) { if (rnti != q->rnti) {
sequence_t seq; srslte_sequence_t seq;
if (sequence_pdsch(&seq, rnti, 0, 2 * harq->sf_idx, q->cell.id, harq->nof_bits)) { if (srslte_sequence_pdsch(&seq, rnti, 0, 2 * harq->sf_idx, q->cell.id, harq->nof_bits)) {
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
scrambling_f_offset(&seq, q->pdsch_e, 0, harq->nof_bits); scrambling_f_offset(&seq, q->pdsch_e, 0, harq->nof_bits);
sequence_free(&seq); srslte_sequence_free(&seq);
} else { } else {
scrambling_f_offset(&q->seq_pdsch[harq->sf_idx], q->pdsch_e, 0, harq->nof_bits); scrambling_f_offset(&q->seq_pdsch[harq->sf_idx], q->pdsch_e, 0, harq->nof_bits);
} }
@ -484,12 +484,12 @@ int pdsch_encode_rnti(pdsch_t *q, harq_t *harq, uint8_t *data, uint16_t rnti, cf
} }
if (rnti != q->rnti) { if (rnti != q->rnti) {
sequence_t seq; srslte_sequence_t seq;
if (sequence_pdsch(&seq, rnti, 0, 2 * harq->sf_idx, q->cell.id, harq->nof_bits)) { if (srslte_sequence_pdsch(&seq, rnti, 0, 2 * harq->sf_idx, q->cell.id, harq->nof_bits)) {
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
scrambling_b_offset(&seq, (uint8_t*) q->pdsch_e, 0, harq->nof_bits); scrambling_b_offset(&seq, (uint8_t*) q->pdsch_e, 0, harq->nof_bits);
sequence_free(&seq); srslte_sequence_free(&seq);
} else { } else {
scrambling_b_offset(&q->seq_pdsch[harq->sf_idx], (uint8_t*) q->pdsch_e, 0, harq->nof_bits); scrambling_b_offset(&q->seq_pdsch[harq->sf_idx], (uint8_t*) q->pdsch_e, 0, harq->nof_bits);
} }
@ -498,7 +498,7 @@ int pdsch_encode_rnti(pdsch_t *q, harq_t *harq, uint8_t *data, uint16_t rnti, cf
/* TODO: only diversity supported */ /* TODO: only diversity supported */
if (q->cell.nof_ports > 1) { if (q->cell.nof_ports > 1) {
layermap_diversity(q->pdsch_d, x, q->cell.nof_ports, harq->nof_re); srslte_layermap_diversity(q->pdsch_d, x, q->cell.nof_ports, harq->nof_re);
precoding_diversity(&q->precoding, x, q->pdsch_symbols, q->cell.nof_ports, precoding_diversity(&q->precoding, x, q->pdsch_symbols, q->cell.nof_ports,
harq->nof_re / q->cell.nof_ports); harq->nof_re / q->cell.nof_ports);
} else { } else {

8
srslte/lib/phch/src/phich.c
Unescape Escape View File

@ -87,7 +87,7 @@ int phich_init(phich_t *q, regs_t *regs, srslte_cell_t cell) {
demod_hard_table_set(&q->demod, LTE_BPSK); demod_hard_table_set(&q->demod, LTE_BPSK);
for (int nsf = 0; nsf < SRSLTE_NSUBFRAMES_X_FRAME; nsf++) { for (int nsf = 0; nsf < SRSLTE_NSUBFRAMES_X_FRAME; nsf++) {
if (sequence_phich(&q->seq_phich[nsf], 2 * nsf, q->cell.id)) { if (srslte_sequence_phich(&q->seq_phich[nsf], 2 * nsf, q->cell.id)) {
goto clean; goto clean;
} }
} }
@ -102,7 +102,7 @@ int phich_init(phich_t *q, regs_t *regs, srslte_cell_t cell) {
void phich_free(phich_t *q) { void phich_free(phich_t *q) {
for (int ns = 0; ns < SRSLTE_NSUBFRAMES_X_FRAME; ns++) { for (int ns = 0; ns < SRSLTE_NSUBFRAMES_X_FRAME; ns++) {
sequence_free(&q->seq_phich[ns]); srslte_sequence_free(&q->seq_phich[ns]);
} }
modem_table_free(&q->mod); modem_table_free(&q->mod);
precoding_free(&q->precoding); precoding_free(&q->precoding);
@ -212,7 +212,7 @@ int phich_decode(phich_t *q, cf_t *slot_symbols, cf_t *ce[SRSLTE_MAX_PORTS], flo
} else { } else {
predecoding_diversity(&q->precoding, q->phich_symbols[0], ce_precoding, x, predecoding_diversity(&q->precoding, q->phich_symbols[0], ce_precoding, x,
q->cell.nof_ports, PHICH_SRSLTE_MAX_NSYMB, noise_estimate); q->cell.nof_ports, PHICH_SRSLTE_MAX_NSYMB, noise_estimate);
layerdemap_diversity(x, q->phich_d0, q->cell.nof_ports, srslte_layerdemap_diversity(x, q->phich_d0, q->cell.nof_ports,
PHICH_SRSLTE_MAX_NSYMB / q->cell.nof_ports); PHICH_SRSLTE_MAX_NSYMB / q->cell.nof_ports);
} }
DEBUG("Recv!!: \n", 0); DEBUG("Recv!!: \n", 0);
@ -374,7 +374,7 @@ int phich_encode(phich_t *q, uint8_t ack, uint32_t ngroup, uint32_t nseq, uint32
/* layer mapping & precoding */ /* layer mapping & precoding */
if (q->cell.nof_ports > 1) { if (q->cell.nof_ports > 1) {
layermap_diversity(q->phich_d0, x, q->cell.nof_ports, PHICH_SRSLTE_MAX_NSYMB); srslte_layermap_diversity(q->phich_d0, x, q->cell.nof_ports, PHICH_SRSLTE_MAX_NSYMB);
precoding_diversity(&q->precoding, x, symbols_precoding, q->cell.nof_ports, precoding_diversity(&q->precoding, x, symbols_precoding, q->cell.nof_ports,
PHICH_SRSLTE_MAX_NSYMB / q->cell.nof_ports); PHICH_SRSLTE_MAX_NSYMB / q->cell.nof_ports);
/**FIXME: According to 6.9.2, Precoding for 4 tx ports is different! */ /**FIXME: According to 6.9.2, Precoding for 4 tx ports is different! */

8
srslte/lib/phch/src/pucch.c
Unescape Escape View File

@ -52,10 +52,10 @@ bool pucch_cfg_isvalid(pucch_cfg_t *cfg) {
/* Generates n_cs_cell according to Sec 5.4 of 36.211 */ /* Generates n_cs_cell according to Sec 5.4 of 36.211 */
int generate_n_cs_cell(srslte_cell_t cell, uint32_t n_cs_cell[SRSLTE_NSLOTS_X_FRAME][SRSLTE_SRSLTE_SRSLTE_CP_NORM_NSYMB]) int generate_n_cs_cell(srslte_cell_t cell, uint32_t n_cs_cell[SRSLTE_NSLOTS_X_FRAME][SRSLTE_SRSLTE_SRSLTE_CP_NORM_NSYMB])
{ {
sequence_t seq; srslte_sequence_t seq;
bzero(&seq, sizeof(sequence_t)); bzero(&seq, sizeof(srslte_sequence_t));
sequence_LTE_pr(&seq, 8*SRSLTE_CP_NSYMB(cell.cp)*SRSLTE_NSLOTS_X_FRAME, cell.id); srslte_sequence_LTE_pr(&seq, 8*SRSLTE_CP_NSYMB(cell.cp)*SRSLTE_NSLOTS_X_FRAME, cell.id);
for (uint32_t ns=0;ns<SRSLTE_NSLOTS_X_FRAME;ns++) { for (uint32_t ns=0;ns<SRSLTE_NSLOTS_X_FRAME;ns++) {
for (uint32_t l=0;l<SRSLTE_CP_NSYMB(cell.cp);l++) { for (uint32_t l=0;l<SRSLTE_CP_NSYMB(cell.cp);l++) {
@ -65,7 +65,7 @@ int generate_n_cs_cell(srslte_cell_t cell, uint32_t n_cs_cell[SRSLTE_NSLOTS_X_FR
} }
} }
} }
sequence_free(&seq); srslte_sequence_free(&seq);
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;
} }

20
srslte/lib/phch/src/pusch.c
Unescape Escape View File

@ -186,7 +186,7 @@ int pusch_init(pusch_t *q, srslte_cell_t cell) {
} }
/* Precompute sequence for type2 frequency hopping */ /* Precompute sequence for type2 frequency hopping */
if (sequence_LTE_pr(&q->seq_type2_fo, 210, q->cell.id)) { if (srslte_sequence_LTE_pr(&q->seq_type2_fo, 210, q->cell.id)) {
fprintf(stderr, "Error initiating type2 frequency hopping sequence\n"); fprintf(stderr, "Error initiating type2 frequency hopping sequence\n");
goto clean; goto clean;
} }
@ -196,7 +196,7 @@ int pusch_init(pusch_t *q, srslte_cell_t cell) {
sch_init(&q->dl_sch); sch_init(&q->dl_sch);
if (dft_precoding_init(&q->dft_precoding, cell.nof_prb)) { if (srslte_srslte_dft_precoding_init(&q->srslte_dft_precoding, cell.nof_prb)) {
fprintf(stderr, "Error initiating DFT transform precoding\n"); fprintf(stderr, "Error initiating DFT transform precoding\n");
goto clean; goto clean;
} }
@ -262,12 +262,12 @@ void pusch_free(pusch_t *q) {
free(q->pusch_z); free(q->pusch_z);
} }
dft_precoding_free(&q->dft_precoding); srslte_srslte_dft_precoding_free(&q->srslte_dft_precoding);
precoding_free(&q->equalizer); precoding_free(&q->equalizer);
for (i = 0; i < SRSLTE_NSUBFRAMES_X_FRAME; i++) { for (i = 0; i < SRSLTE_NSUBFRAMES_X_FRAME; i++) {
sequence_free(&q->seq_pusch[i]); srslte_sequence_free(&q->seq_pusch[i]);
} }
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
@ -292,7 +292,7 @@ int pusch_set_rnti(pusch_t *q, uint16_t rnti) {
uint32_t i; uint32_t i;
for (i = 0; i < SRSLTE_NSUBFRAMES_X_FRAME; i++) { for (i = 0; i < SRSLTE_NSUBFRAMES_X_FRAME; i++) {
if (sequence_pusch(&q->seq_pusch[i], rnti, 2 * i, q->cell.id, if (srslte_sequence_pusch(&q->seq_pusch[i], rnti, 2 * i, q->cell.id,
q->max_re * srslte_mod_bits_x_symbol(LTE_QAM64))) { q->max_re * srslte_mod_bits_x_symbol(LTE_QAM64))) {
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
@ -336,7 +336,7 @@ int pusch_decode(pusch_t *q, harq_t *harq, cf_t *sf_symbols, cf_t *ce, float noi
predecoding_single(&q->equalizer, q->pusch_d, q->ce, q->pusch_z, predecoding_single(&q->equalizer, q->pusch_d, q->ce, q->pusch_z,
harq->nof_re, noise_estimate); harq->nof_re, noise_estimate);
dft_predecoding(&q->dft_precoding, q->pusch_z, q->pusch_d, srslte_dft_predecoding(&q->srslte_dft_precoding, q->pusch_z, q->pusch_d,
harq->ul_alloc.L_prb, harq->nof_symb); harq->ul_alloc.L_prb, harq->nof_symb);
/* demodulate symbols /* demodulate symbols
@ -420,19 +420,19 @@ int pusch_uci_encode_rnti(pusch_t *q, harq_t *harq, uint8_t *data, uci_data_t uc
} }
if (rnti != q->rnti) { if (rnti != q->rnti) {
sequence_t seq; srslte_sequence_t seq;
if (sequence_pusch(&seq, rnti, 2 * harq->sf_idx, q->cell.id, harq->nof_bits)) { if (srslte_sequence_pusch(&seq, rnti, 2 * harq->sf_idx, q->cell.id, harq->nof_bits)) {
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
scrambling_b_offset_pusch(&seq, (uint8_t*) q->pusch_q, 0, harq->nof_bits); scrambling_b_offset_pusch(&seq, (uint8_t*) q->pusch_q, 0, harq->nof_bits);
sequence_free(&seq); srslte_sequence_free(&seq);
} else { } else {
scrambling_b_offset_pusch(&q->seq_pusch[harq->sf_idx], (uint8_t*) q->pusch_q, 0, harq->nof_bits); scrambling_b_offset_pusch(&q->seq_pusch[harq->sf_idx], (uint8_t*) q->pusch_q, 0, harq->nof_bits);
} }
mod_modulate(&q->mod[harq->mcs.mod], (uint8_t*) q->pusch_q, q->pusch_d, harq->nof_bits); mod_modulate(&q->mod[harq->mcs.mod], (uint8_t*) q->pusch_q, q->pusch_d, harq->nof_bits);
dft_precoding(&q->dft_precoding, q->pusch_d, q->pusch_z, srslte_dft_precoding(&q->srslte_dft_precoding, q->pusch_d, q->pusch_z,
harq->ul_alloc.L_prb, harq->nof_symb); harq->ul_alloc.L_prb, harq->nof_symb);
/* mapping to resource elements */ /* mapping to resource elements */

40
srslte/lib/phch/src/sch.c
Unescape Escape View File

@ -48,20 +48,20 @@ int sch_init(sch_t *q) {
if (q) { if (q) {
bzero(q, sizeof(sch_t)); bzero(q, sizeof(sch_t));
if (crc_init(&q->crc_tb, SRSLTE_LTE_CRC24A, 24)) { if (srslte_crc_init(&q->srslte_crc_tb, SRSLTE_LTE_CRC24A, 24)) {
fprintf(stderr, "Error initiating CRC\n"); fprintf(stderr, "Error initiating CRC\n");
goto clean; goto clean;
} }
if (crc_init(&q->crc_cb, SRSLTE_LTE_CRC24B, 24)) { if (srslte_crc_init(&q->srslte_crc_cb, SRSLTE_LTE_CRC24B, 24)) {
fprintf(stderr, "Error initiating CRC\n"); fprintf(stderr, "Error initiating CRC\n");
goto clean; goto clean;
} }
if (tcod_init(&q->encoder, MAX_LONG_CB)) { if (srslte_tcod_init(&q->encoder, MAX_LONG_CB)) {
fprintf(stderr, "Error initiating Turbo Coder\n"); fprintf(stderr, "Error initiating Turbo Coder\n");
goto clean; goto clean;
} }
if (tdec_init(&q->decoder, MAX_LONG_CB)) { if (srslte_tdec_init(&q->decoder, MAX_LONG_CB)) {
fprintf(stderr, "Error initiating Turbo Decoder\n"); fprintf(stderr, "Error initiating Turbo Decoder\n");
goto clean; goto clean;
} }
@ -96,8 +96,8 @@ void sch_free(sch_t *q) {
if (q->cb_out) { if (q->cb_out) {
free(q->cb_out); free(q->cb_out);
} }
tdec_free(&q->decoder); srslte_tdec_free(&q->decoder);
tcod_free(&q->encoder); srslte_tcod_free(&q->encoder);
uci_cqi_free(&q->uci_cqi); uci_cqi_free(&q->uci_cqi);
bzero(q, sizeof(sch_t)); bzero(q, sizeof(sch_t));
} }
@ -140,7 +140,7 @@ static int encode_tb(sch_t *q, harq_t *harq, uint8_t *data, uint8_t *e_bits, uin
if (harq->rv == 0) { if (harq->rv == 0) {
/* Compute transport block CRC */ /* Compute transport block CRC */
par = crc_checksum(&q->crc_tb, data, harq->mcs.tbs); par = srslte_crc_checksum(&q->srslte_crc_tb, data, harq->mcs.tbs);
/* parity bits will be appended later */ /* parity bits will be appended later */
bit_pack(par, &p_parity, 24); bit_pack(par, &p_parity, 24);
@ -201,11 +201,11 @@ static int encode_tb(sch_t *q, harq_t *harq, uint8_t *data, uint8_t *e_bits, uin
} }
/* Attach Codeblock CRC */ /* Attach Codeblock CRC */
if (harq->cb_segm.C > 1) { if (harq->cb_segm.C > 1) {
crc_attach(&q->crc_cb, q->cb_in, rlen); srslte_crc_attach(&q->srslte_crc_cb, q->cb_in, rlen);
} }
/* Set the filler bits to <NULL> */ /* Set the filler bits to <NULL> */
for (int j = 0; j < F; j++) { for (int j = 0; j < F; j++) {
q->cb_in[j] = TX_NULL; q->cb_in[j] = SRSLTE_TX_NULL;
} }
if (VERBOSE_ISDEBUG()) { if (VERBOSE_ISDEBUG()) {
DEBUG("CB#%d: ", i); DEBUG("CB#%d: ", i);
@ -213,11 +213,11 @@ static int encode_tb(sch_t *q, harq_t *harq, uint8_t *data, uint8_t *e_bits, uin
} }
/* Turbo Encoding */ /* Turbo Encoding */
tcod_encode(&q->encoder, q->cb_in, (uint8_t*) q->cb_out, cb_len); srslte_tcod_encode(&q->encoder, q->cb_in, (uint8_t*) q->cb_out, cb_len);
} }
/* Rate matching */ /* Rate matching */
if (rm_turbo_tx(harq->pdsch_w_buff_c[i], harq->w_buff_size, if (srslte_rm_turbo_tx(harq->pdsch_w_buff_c[i], harq->w_buff_size,
(uint8_t*) q->cb_out, 3 * cb_len + 12, (uint8_t*) q->cb_out, 3 * cb_len + 12,
&e_bits[wp], n_e, harq->rv)) &e_bits[wp], n_e, harq->rv))
{ {
@ -297,7 +297,7 @@ static int decode_tb(sch_t *q, harq_t *harq, float *e_bits, uint8_t *data, uint3
cb_len, rlen - F, wp, rp, F, n_e); cb_len, rlen - F, wp, rp, F, n_e);
/* Rate Unmatching */ /* Rate Unmatching */
if (rm_turbo_rx(harq->pdsch_w_buff_f[i], harq->w_buff_size, if (srslte_rm_turbo_rx(harq->pdsch_w_buff_f[i], harq->w_buff_size,
&e_bits[rp], n_e, &e_bits[rp], n_e,
(float*) q->cb_out, 3 * cb_len + 12, harq->rv, F)) { (float*) q->cb_out, 3 * cb_len + 12, harq->rv, F)) {
fprintf(stderr, "Error in rate matching\n"); fprintf(stderr, "Error in rate matching\n");
@ -313,29 +313,29 @@ static int decode_tb(sch_t *q, harq_t *harq, float *e_bits, uint8_t *data, uint3
q->nof_iterations = 0; q->nof_iterations = 0;
uint32_t len_crc; uint32_t len_crc;
uint8_t *cb_in_ptr; uint8_t *cb_in_ptr;
crc_t *crc_ptr; srslte_crc_t *srslte_crc_ptr;
early_stop = false; early_stop = false;
tdec_reset(&q->decoder, cb_len); srslte_tdec_reset(&q->decoder, cb_len);
do { do {
tdec_iteration(&q->decoder, (float*) q->cb_out, cb_len); srslte_tdec_iteration(&q->decoder, (float*) q->cb_out, cb_len);
q->nof_iterations++; q->nof_iterations++;
if (harq->cb_segm.C > 1) { if (harq->cb_segm.C > 1) {
len_crc = cb_len; len_crc = cb_len;
cb_in_ptr = q->cb_in; cb_in_ptr = q->cb_in;
crc_ptr = &q->crc_cb; srslte_crc_ptr = &q->srslte_crc_cb;
} else { } else {
len_crc = harq->mcs.tbs+24; len_crc = harq->mcs.tbs+24;
cb_in_ptr = &q->cb_in[F]; cb_in_ptr = &q->cb_in[F];
crc_ptr = &q->crc_tb; srslte_crc_ptr = &q->srslte_crc_tb;
} }
tdec_decision(&q->decoder, q->cb_in, cb_len); srslte_tdec_decision(&q->decoder, q->cb_in, cb_len);
/* Check Codeblock CRC and stop early if incorrect */ /* Check Codeblock CRC and stop early if incorrect */
if (!crc_checksum(crc_ptr, cb_in_ptr, len_crc)) { if (!srslte_crc_checksum(srslte_crc_ptr, cb_in_ptr, len_crc)) {
early_stop = true; early_stop = true;
} }
@ -373,7 +373,7 @@ static int decode_tb(sch_t *q, harq_t *harq, float *e_bits, uint8_t *data, uint3
INFO("END CB#%d: wp: %d, rp: %d\n", i, wp, rp); INFO("END CB#%d: wp: %d, rp: %d\n", i, wp, rp);
// Compute transport block CRC // Compute transport block CRC
par_rx = crc_checksum(&q->crc_tb, data, harq->mcs.tbs); par_rx = srslte_crc_checksum(&q->srslte_crc_tb, data, harq->mcs.tbs);
// check parity bits // check parity bits
par_tx = bit_unpack(&p_parity, 24); par_tx = bit_unpack(&p_parity, 24);

36
srslte/lib/phch/src/sequences.c
Unescape Escape View File

@ -33,48 +33,48 @@
/** /**
* 36.211 6.6.1 * 36.211 6.6.1
*/ */
int sequence_pbch(sequence_t *seq, srslte_cp_t cp, uint32_t cell_id) { int srslte_sequence_pbch(srslte_sequence_t *seq, srslte_cp_t cp, uint32_t cell_id) {
bzero(seq, sizeof(sequence_t)); bzero(seq, sizeof(srslte_sequence_t));
return sequence_LTE_pr(seq, SRSLTE_CP_ISNORM(cp)?1920:1728, cell_id); return srslte_sequence_LTE_pr(seq, SRSLTE_CP_ISNORM(cp)?1920:1728, cell_id);
} }
/** /**
* 36.211 6.7.1 * 36.211 6.7.1
*/ */
int sequence_pcfich(sequence_t *seq, uint32_t nslot, uint32_t cell_id) { int srslte_sequence_pcfich(srslte_sequence_t *seq, uint32_t nslot, uint32_t cell_id) {
bzero(seq, sizeof(sequence_t)); bzero(seq, sizeof(srslte_sequence_t));
return sequence_LTE_pr(seq, 32, (nslot/2+1) * (2*cell_id + 1) * 512 + cell_id); return srslte_sequence_LTE_pr(seq, 32, (nslot/2+1) * (2*cell_id + 1) * 512 + cell_id);
} }
/** /**
* 36.211 6.9.1 * 36.211 6.9.1
*/ */
int sequence_phich(sequence_t *seq, uint32_t nslot, uint32_t cell_id) { int srslte_sequence_phich(srslte_sequence_t *seq, uint32_t nslot, uint32_t cell_id) {
bzero(seq, sizeof(sequence_t)); bzero(seq, sizeof(srslte_sequence_t));
return sequence_LTE_pr(seq, 12, (nslot/2+1) * (2*cell_id + 1) * 512 + cell_id); return srslte_sequence_LTE_pr(seq, 12, (nslot/2+1) * (2*cell_id + 1) * 512 + cell_id);
} }
/** /**
* 36.211 6.8.2 * 36.211 6.8.2
*/ */
int sequence_pdcch(sequence_t *seq, uint32_t nslot, uint32_t cell_id, uint32_t len) { int srslte_sequence_pdcch(srslte_sequence_t *seq, uint32_t nslot, uint32_t cell_id, uint32_t len) {
bzero(seq, sizeof(sequence_t)); bzero(seq, sizeof(srslte_sequence_t));
return sequence_LTE_pr(seq, len, (nslot/2) * 512 + cell_id); return srslte_sequence_LTE_pr(seq, len, (nslot/2) * 512 + cell_id);
} }
/** /**
* 36.211 6.3.1 * 36.211 6.3.1
*/ */
int sequence_pdsch(sequence_t *seq, unsigned short rnti, int q, uint32_t nslot, uint32_t cell_id, uint32_t len) { int srslte_sequence_pdsch(srslte_sequence_t *seq, unsigned short rnti, int q, uint32_t nslot, uint32_t cell_id, uint32_t len) {
bzero(seq, sizeof(sequence_t)); bzero(seq, sizeof(srslte_sequence_t));
return sequence_LTE_pr(seq, len, (rnti<<14) + (q<<13) + ((nslot/2)<<9) + cell_id); return srslte_sequence_LTE_pr(seq, len, (rnti<<14) + (q<<13) + ((nslot/2)<<9) + cell_id);
} }
/** /**
* 36.211 5.3.1 * 36.211 5.3.1
*/ */
int sequence_pusch(sequence_t *seq, unsigned short rnti, uint32_t nslot, uint32_t cell_id, uint32_t len) { int srslte_sequence_pusch(srslte_sequence_t *seq, unsigned short rnti, uint32_t nslot, uint32_t cell_id, uint32_t len) {
bzero(seq, sizeof(sequence_t)); bzero(seq, sizeof(srslte_sequence_t));
return sequence_LTE_pr(seq, len, (rnti<<14) + ((nslot/2)<<9) + cell_id); return srslte_sequence_LTE_pr(seq, len, (rnti<<14) + ((nslot/2)<<9) + cell_id);
} }

10
srslte/lib/phch/src/uci.c
Unescape Escape View File

@ -104,7 +104,7 @@ static uint8_t M_basis_seq_pucch[20][13]={
}; };
int uci_cqi_init(uci_cqi_pusch_t *q) { int uci_cqi_init(uci_cqi_pusch_t *q) {
if (crc_init(&q->crc, SRSLTE_LTE_CRC8, 8)) { if (srslte_crc_init(&q->crc, SRSLTE_LTE_CRC8, 8)) {
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;
@ -163,7 +163,7 @@ int encode_cqi_short(uci_cqi_pusch_t *q, uint8_t *data, uint32_t nof_bits, uint8
*/ */
int encode_cqi_long(uci_cqi_pusch_t *q, uint8_t *data, uint32_t nof_bits, uint8_t *q_bits, uint32_t Q) int encode_cqi_long(uci_cqi_pusch_t *q, uint8_t *data, uint32_t nof_bits, uint8_t *q_bits, uint32_t Q)
{ {
convcoder_t encoder; srslte_convcoder_t encoder;
if (nof_bits + 8 < MAX_CQI_LEN_PUSCH && if (nof_bits + 8 < MAX_CQI_LEN_PUSCH &&
q != NULL && q != NULL &&
@ -179,9 +179,9 @@ int encode_cqi_long(uci_cqi_pusch_t *q, uint8_t *data, uint32_t nof_bits, uint8_
memcpy(encoder.poly, poly, 3 * sizeof(int)); memcpy(encoder.poly, poly, 3 * sizeof(int));
memcpy(q->tmp_cqi, data, sizeof(uint8_t) * nof_bits); memcpy(q->tmp_cqi, data, sizeof(uint8_t) * nof_bits);
crc_attach(&q->crc, q->tmp_cqi, nof_bits); srslte_crc_attach(&q->crc, q->tmp_cqi, nof_bits);
convcoder_encode(&encoder, q->tmp_cqi, q->encoded_cqi, nof_bits + 8); srslte_convcoder_encode(&encoder, q->tmp_cqi, q->encoded_cqi, nof_bits + 8);
DEBUG("CConv output: ", 0); DEBUG("CConv output: ", 0);
@ -189,7 +189,7 @@ int encode_cqi_long(uci_cqi_pusch_t *q, uint8_t *data, uint32_t nof_bits, uint8_
vec_fprint_b(stdout, q->encoded_cqi, 3 * (nof_bits + 8)); vec_fprint_b(stdout, q->encoded_cqi, 3 * (nof_bits + 8));
} }
rm_conv_tx(q->encoded_cqi, 3 * (nof_bits + 8), q_bits, Q); srslte_rm_conv_tx(q->encoded_cqi, 3 * (nof_bits + 8), q_bits, Q);
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;
} else { } else {

10
srslte/lib/phch/test/pbch_file_test.c
Unescape Escape View File

@ -50,7 +50,7 @@ uint8_t bch_payload_file[BCH_PAYLOAD_LEN] = {0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1,
#define FLEN (10*SRSLTE_SF_LEN(srslte_symbol_sz(cell.nof_prb))) #define FLEN (10*SRSLTE_SF_LEN(srslte_symbol_sz(cell.nof_prb)))
filesource_t fsrc; srslte_filesource_t fsrc;
cf_t *input_buffer, *fft_buffer, *ce[SRSLTE_MAX_PORTS]; cf_t *input_buffer, *fft_buffer, *ce[SRSLTE_MAX_PORTS];
pbch_t pbch; pbch_t pbch;
srslte_fft_t fft; srslte_fft_t fft;
@ -102,7 +102,7 @@ void parse_args(int argc, char **argv) {
int base_init() { int base_init() {
int i; int i;
if (filesource_init(&fsrc, input_file_name, COMPLEX_FLOAT_BIN)) { if (srslte_filesource_init(&fsrc, input_file_name, SRSLTE_COMPLEX_FLOAT_BIN)) {
fprintf(stderr, "Error opening file %s\n", input_file_name); fprintf(stderr, "Error opening file %s\n", input_file_name);
exit(-1); exit(-1);
} }
@ -154,12 +154,12 @@ int base_init() {
void base_free() { void base_free() {
int i; int i;
filesource_free(&fsrc); srslte_filesource_free(&fsrc);
free(input_buffer); free(input_buffer);
free(fft_buffer); free(fft_buffer);
filesource_free(&fsrc); srslte_filesource_free(&fsrc);
for (i=0;i<cell.nof_ports;i++) { for (i=0;i<cell.nof_ports;i++) {
free(ce[i]); free(ce[i]);
} }
@ -191,7 +191,7 @@ int main(int argc, char **argv) {
int nof_decoded_mibs = 0; int nof_decoded_mibs = 0;
int nread = 0; int nread = 0;
do { do {
nread = filesource_read(&fsrc, input_buffer, FLEN); nread = srslte_filesource_read(&fsrc, input_buffer, FLEN);
if (nread > 0) { if (nread > 0) {
// process 1st subframe only // process 1st subframe only

10
srslte/lib/phch/test/pcfich_file_test.c
Unescape Escape View File

@ -50,7 +50,7 @@ int flen;
FILE *fmatlab = NULL; FILE *fmatlab = NULL;
filesource_t fsrc; srslte_filesource_t fsrc;
cf_t *input_buffer, *fft_buffer, *ce[SRSLTE_MAX_PORTS]; cf_t *input_buffer, *fft_buffer, *ce[SRSLTE_MAX_PORTS];
pcfich_t pcfich; pcfich_t pcfich;
regs_t regs; regs_t regs;
@ -106,7 +106,7 @@ void parse_args(int argc, char **argv) {
int base_init() { int base_init() {
int i; int i;
if (filesource_init(&fsrc, input_file_name, COMPLEX_FLOAT_BIN)) { if (srslte_filesource_init(&fsrc, input_file_name, SRSLTE_COMPLEX_FLOAT_BIN)) {
fprintf(stderr, "Error opening file %s\n", input_file_name); fprintf(stderr, "Error opening file %s\n", input_file_name);
exit(-1); exit(-1);
} }
@ -170,7 +170,7 @@ int base_init() {
void base_free() { void base_free() {
int i; int i;
filesource_free(&fsrc); srslte_filesource_free(&fsrc);
if (fmatlab) { if (fmatlab) {
fclose(fmatlab); fclose(fmatlab);
} }
@ -178,7 +178,7 @@ void base_free() {
free(input_buffer); free(input_buffer);
free(fft_buffer); free(fft_buffer);
filesource_free(&fsrc); srslte_filesource_free(&fsrc);
for (i=0;i<SRSLTE_MAX_PORTS;i++) { for (i=0;i<SRSLTE_MAX_PORTS;i++) {
free(ce[i]); free(ce[i]);
} }
@ -206,7 +206,7 @@ int main(int argc, char **argv) {
exit(-1); exit(-1);
} }
n = filesource_read(&fsrc, input_buffer, flen); n = srslte_filesource_read(&fsrc, input_buffer, flen);
srslte_fft_run_sf(&fft, input_buffer, fft_buffer); srslte_fft_run_sf(&fft, input_buffer, fft_buffer);

18
srslte/lib/phch/test/pdcch_file_test.c
Unescape Escape View File

@ -52,7 +52,7 @@ uint16_t rnti = SRSLTE_SIRNTI;
int max_frames = 10; int max_frames = 10;
dci_format_t dci_format = Format1A; dci_format_t dci_format = Format1A;
filesource_t fsrc; srslte_filesource_t fsrc;
pdcch_t pdcch; pdcch_t pdcch;
cf_t *input_buffer, *fft_buffer, *ce[SRSLTE_MAX_PORTS]; cf_t *input_buffer, *fft_buffer, *ce[SRSLTE_MAX_PORTS];
regs_t regs; regs_t regs;
@ -124,7 +124,7 @@ void parse_args(int argc, char **argv) {
int base_init() { int base_init() {
int i; int i;
if (filesource_init(&fsrc, input_file_name, COMPLEX_FLOAT_BIN)) { if (srslte_filesource_init(&fsrc, input_file_name, SRSLTE_COMPLEX_FLOAT_BIN)) {
fprintf(stderr, "Error opening file %s\n", input_file_name); fprintf(stderr, "Error opening file %s\n", input_file_name);
exit(-1); exit(-1);
} }
@ -182,12 +182,12 @@ int base_init() {
void base_free() { void base_free() {
int i; int i;
filesource_free(&fsrc); srslte_filesource_free(&fsrc);
free(input_buffer); free(input_buffer);
free(fft_buffer); free(fft_buffer);
filesource_free(&fsrc); srslte_filesource_free(&fsrc);
for (i=0;i<SRSLTE_MAX_PORTS;i++) { for (i=0;i<SRSLTE_MAX_PORTS;i++) {
free(ce[i]); free(ce[i]);
} }
@ -222,7 +222,7 @@ int main(int argc, char **argv) {
ret = -1; ret = -1;
frame_cnt = 0; frame_cnt = 0;
do { do {
filesource_read(&fsrc, input_buffer, flen); srslte_filesource_read(&fsrc, input_buffer, flen);
INFO("Reading %d samples sub-frame %d\n", flen, frame_cnt); INFO("Reading %d samples sub-frame %d\n", flen, frame_cnt);
@ -231,7 +231,7 @@ int main(int argc, char **argv) {
/* Get channel estimates for each port */ /* Get channel estimates for each port */
srslte_chest_dl_estimate(&chest, fft_buffer, ce, frame_cnt %10); srslte_chest_dl_estimate(&chest, fft_buffer, ce, frame_cnt %10);
uint16_t crc_rem = 0; uint16_t srslte_crc_rem = 0;
if (pdcch_extract_llr(&pdcch, fft_buffer, if (pdcch_extract_llr(&pdcch, fft_buffer,
ce, srslte_chest_dl_get_noise_estimate(&chest), ce, srslte_chest_dl_get_noise_estimate(&chest),
frame_cnt %10, cfi)) { frame_cnt %10, cfi)) {
@ -246,14 +246,14 @@ int main(int argc, char **argv) {
nof_locations = pdcch_ue_locations(&pdcch, locations, MAX_CANDIDATES, frame_cnt %10, cfi, rnti); nof_locations = pdcch_ue_locations(&pdcch, locations, MAX_CANDIDATES, frame_cnt %10, cfi, rnti);
} }
for (i=0;i<nof_locations && crc_rem != rnti;i++) { for (i=0;i<nof_locations && srslte_crc_rem != rnti;i++) {
if (pdcch_decode_msg(&pdcch, &dci_msg, &locations[i], dci_format, &crc_rem)) { if (pdcch_decode_msg(&pdcch, &dci_msg, &locations[i], dci_format, &srslte_crc_rem)) {
fprintf(stderr, "Error decoding DCI msg\n"); fprintf(stderr, "Error decoding DCI msg\n");
return -1; return -1;
} }
} }
if (crc_rem == rnti) { if (srslte_crc_rem == rnti) {
dci_msg_type_t type; dci_msg_type_t type;
if (dci_msg_get_type(&dci_msg, &type, cell.nof_prb, rnti)) { if (dci_msg_get_type(&dci_msg, &type, cell.nof_prb, rnti)) {
fprintf(stderr, "Can't get DCI message type\n"); fprintf(stderr, "Can't get DCI message type\n");

12
srslte/lib/phch/test/pdcch_test.c
Unescape Escape View File

@ -195,16 +195,16 @@ int main(int argc, char **argv) {
fprintf(stderr, "Error extracting LLRs\n"); fprintf(stderr, "Error extracting LLRs\n");
goto quit; goto quit;
} }
uint16_t crc_rem; uint16_t srslte_crc_rem;
if (pdcch_decode_msg(&pdcch, &dci_tmp, &dci_locations[i], Format1, &crc_rem)) { if (pdcch_decode_msg(&pdcch, &dci_tmp, &dci_locations[i], Format1, &srslte_crc_rem)) {
fprintf(stderr, "Error decoding DCI message\n"); fprintf(stderr, "Error decoding DCI message\n");
goto quit; goto quit;
} }
if (crc_rem >= 1234 && crc_rem < 1234 + nof_dcis) { if (srslte_crc_rem >= 1234 && srslte_crc_rem < 1234 + nof_dcis) {
crc_rem -= 1234; srslte_crc_rem -= 1234;
memcpy(&dci_rx[crc_rem], &dci_tmp, sizeof(dci_msg_t)); memcpy(&dci_rx[srslte_crc_rem], &dci_tmp, sizeof(dci_msg_t));
} else { } else {
printf("Received invalid DCI CRC 0x%x\n", crc_rem); printf("Received invalid DCI CRC 0x%x\n", srslte_crc_rem);
goto quit; goto quit;
} }
} }

8
srslte/lib/phch/test/pdcch_test_mex.c
Unescape Escape View File

@ -162,13 +162,13 @@ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
formats = ue_formats; formats = ue_formats;
nof_formats = nof_ue_formats; nof_formats = nof_ue_formats;
} }
uint16_t crc_rem=0; uint16_t srslte_crc_rem=0;
dci_msg_t dci_msg; dci_msg_t dci_msg;
bzero(&dci_msg, sizeof(dci_msg_t)); bzero(&dci_msg, sizeof(dci_msg_t));
for (int f=0;f<nof_formats;f++) { for (int f=0;f<nof_formats;f++) {
for (i=0;i<nof_locations && crc_rem != rnti;i++) { for (i=0;i<nof_locations && srslte_crc_rem != rnti;i++) {
if (pdcch_decode_msg(&pdcch, &dci_msg, &locations[i], formats[f], &crc_rem)) { if (pdcch_decode_msg(&pdcch, &dci_msg, &locations[i], formats[f], &srslte_crc_rem)) {
fprintf(stderr, "Error decoding DCI msg\n"); fprintf(stderr, "Error decoding DCI msg\n");
return; return;
} }
@ -176,7 +176,7 @@ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
} }
if (nlhs >= 1) { if (nlhs >= 1) {
plhs[0] = mxCreateLogicalScalar(crc_rem == rnti); plhs[0] = mxCreateLogicalScalar(srslte_crc_rem == rnti);
} }
int nof_bits = (regs_pdcch_nregs(&regs, cfi) / 9) * 72; int nof_bits = (regs_pdcch_nregs(&regs, cfi) / 9) * 72;
if (nlhs >= 2) { if (nlhs >= 2) {

18
srslte/lib/phch/test/pdsch_file_test.c
Unescape Escape View File

@ -55,7 +55,7 @@ int max_frames = 10;
uint32_t sf_idx = 0; uint32_t sf_idx = 0;
dci_format_t dci_format = Format1A; dci_format_t dci_format = Format1A;
filesource_t fsrc; srslte_filesource_t fsrc;
pdcch_t pdcch; pdcch_t pdcch;
pdsch_t pdsch; pdsch_t pdsch;
harq_t harq_process; harq_t harq_process;
@ -133,7 +133,7 @@ void parse_args(int argc, char **argv) {
int base_init() { int base_init() {
int i; int i;
if (filesource_init(&fsrc, input_file_name, COMPLEX_FLOAT_BIN)) { if (srslte_filesource_init(&fsrc, input_file_name, SRSLTE_COMPLEX_FLOAT_BIN)) {
fprintf(stderr, "Error opening file %s\n", input_file_name); fprintf(stderr, "Error opening file %s\n", input_file_name);
exit(-1); exit(-1);
} }
@ -203,12 +203,12 @@ int base_init() {
void base_free() { void base_free() {
int i; int i;
filesource_free(&fsrc); srslte_filesource_free(&fsrc);
free(input_buffer); free(input_buffer);
free(fft_buffer); free(fft_buffer);
filesource_free(&fsrc); srslte_filesource_free(&fsrc);
for (i=0;i<SRSLTE_MAX_PORTS;i++) { for (i=0;i<SRSLTE_MAX_PORTS;i++) {
free(ce[i]); free(ce[i]);
} }
@ -253,7 +253,7 @@ int main(int argc, char **argv) {
ret = -1; ret = -1;
nof_frames = 0; nof_frames = 0;
do { do {
filesource_read(&fsrc, input_buffer, flen); srslte_filesource_read(&fsrc, input_buffer, flen);
INFO("Reading %d samples sub-frame %d\n", flen, sf_idx); INFO("Reading %d samples sub-frame %d\n", flen, sf_idx);
srslte_fft_run_sf(&fft, input_buffer, fft_buffer); srslte_fft_run_sf(&fft, input_buffer, fft_buffer);
@ -266,19 +266,19 @@ int main(int argc, char **argv) {
nof_locations = pdcch_ue_locations(&pdcch, locations, MAX_CANDIDATES, sf_idx, cfi, rnti); nof_locations = pdcch_ue_locations(&pdcch, locations, MAX_CANDIDATES, sf_idx, cfi, rnti);
} }
uint16_t crc_rem = 0; uint16_t srslte_crc_rem = 0;
if (pdcch_extract_llr(&pdcch, fft_buffer, ce, srslte_chest_dl_get_noise_estimate(&chest), sf_idx, cfi)) { if (pdcch_extract_llr(&pdcch, fft_buffer, ce, srslte_chest_dl_get_noise_estimate(&chest), sf_idx, cfi)) {
fprintf(stderr, "Error extracting LLRs\n"); fprintf(stderr, "Error extracting LLRs\n");
return -1; return -1;
} }
for (i=0;i<nof_locations && crc_rem != rnti;i++) { for (i=0;i<nof_locations && srslte_crc_rem != rnti;i++) {
if (pdcch_decode_msg(&pdcch, &dci_msg, &locations[i], dci_format, &crc_rem)) { if (pdcch_decode_msg(&pdcch, &dci_msg, &locations[i], dci_format, &srslte_crc_rem)) {
fprintf(stderr, "Error decoding DCI msg\n"); fprintf(stderr, "Error decoding DCI msg\n");
return -1; return -1;
} }
} }
if (crc_rem == rnti) { if (srslte_crc_rem == rnti) {
if (dci_msg_to_ra_dl(&dci_msg, rnti, cell, cfi, &ra_dl)) { if (dci_msg_to_ra_dl(&dci_msg, rnti, cell, cfi, &ra_dl)) {
fprintf(stderr, "Error unpacking PDSCH scheduling DCI message\n"); fprintf(stderr, "Error unpacking PDSCH scheduling DCI message\n");
goto goout; goto goout;

10
srslte/lib/phch/test/phich_file_test.c
Unescape Escape View File

@ -51,7 +51,7 @@ int numsubframe = 0;
FILE *fmatlab = NULL; FILE *fmatlab = NULL;
filesource_t fsrc; srslte_filesource_t fsrc;
cf_t *input_buffer, *fft_buffer, *ce[SRSLTE_MAX_PORTS]; cf_t *input_buffer, *fft_buffer, *ce[SRSLTE_MAX_PORTS];
phich_t phich; phich_t phich;
regs_t regs; regs_t regs;
@ -129,7 +129,7 @@ void parse_args(int argc, char **argv) {
int base_init() { int base_init() {
int i; int i;
if (filesource_init(&fsrc, input_file_name, COMPLEX_FLOAT_BIN)) { if (srslte_filesource_init(&fsrc, input_file_name, SRSLTE_COMPLEX_FLOAT_BIN)) {
fprintf(stderr, "Error opening file %s\n", input_file_name); fprintf(stderr, "Error opening file %s\n", input_file_name);
exit(-1); exit(-1);
} }
@ -193,7 +193,7 @@ int base_init() {
void base_free() { void base_free() {
int i; int i;
filesource_free(&fsrc); srslte_filesource_free(&fsrc);
if (fmatlab) { if (fmatlab) {
fclose(fmatlab); fclose(fmatlab);
} }
@ -201,7 +201,7 @@ void base_free() {
free(input_buffer); free(input_buffer);
free(fft_buffer); free(fft_buffer);
filesource_free(&fsrc); srslte_filesource_free(&fsrc);
for (i=0;i<SRSLTE_MAX_PORTS;i++) { for (i=0;i<SRSLTE_MAX_PORTS;i++) {
free(ce[i]); free(ce[i]);
} }
@ -232,7 +232,7 @@ int main(int argc, char **argv) {
exit(-1); exit(-1);
} }
n = filesource_read(&fsrc, input_buffer, flen); n = srslte_filesource_read(&fsrc, input_buffer, flen);
srslte_fft_run_sf(&fft, input_buffer, fft_buffer); srslte_fft_run_sf(&fft, input_buffer, fft_buffer);

26
srslte/lib/scrambling/src/scrambling.c
Unescape Escape View File

@ -31,11 +31,11 @@
#include <assert.h> #include <assert.h>
#include "srslte/scrambling/scrambling.h" #include "srslte/scrambling/scrambling.h"
void scrambling_f(sequence_t *s, float *data) { void scrambling_f(srslte_sequence_t *s, float *data) {
scrambling_f_offset(s, data, 0, s->len); scrambling_f_offset(s, data, 0, s->len);
} }
void scrambling_f_offset(sequence_t *s, float *data, int offset, int len) { void scrambling_f_offset(srslte_sequence_t *s, float *data, int offset, int len) {
int i; int i;
assert (len + offset <= s->len); assert (len + offset <= s->len);
@ -44,11 +44,11 @@ void scrambling_f_offset(sequence_t *s, float *data, int offset, int len) {
} }
} }
void scrambling_c(sequence_t *s, cf_t *data) { void scrambling_c(srslte_sequence_t *s, cf_t *data) {
scrambling_c_offset(s, data, 0, s->len); scrambling_c_offset(s, data, 0, s->len);
} }
void scrambling_c_offset(sequence_t *s, cf_t *data, int offset, int len) { void scrambling_c_offset(srslte_sequence_t *s, cf_t *data, int offset, int len) {
int i; int i;
assert (len + offset <= s->len); assert (len + offset <= s->len);
@ -57,7 +57,7 @@ void scrambling_c_offset(sequence_t *s, cf_t *data, int offset, int len) {
} }
} }
void scrambling_b(sequence_t *s, uint8_t *data) { void scrambling_b(srslte_sequence_t *s, uint8_t *data) {
int i; int i;
for (i = 0; i < s->len; i++) { for (i = 0; i < s->len; i++) {
@ -65,7 +65,7 @@ void scrambling_b(sequence_t *s, uint8_t *data) {
} }
} }
void scrambling_b_offset(sequence_t *s, uint8_t *data, int offset, int len) { void scrambling_b_offset(srslte_sequence_t *s, uint8_t *data, int offset, int len) {
int i; int i;
assert (len + offset <= s->len); assert (len + offset <= s->len);
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
@ -74,7 +74,7 @@ void scrambling_b_offset(sequence_t *s, uint8_t *data, int offset, int len) {
} }
/* As defined in 36.211 5.3.1 */ /* As defined in 36.211 5.3.1 */
void scrambling_b_offset_pusch(sequence_t *s, uint8_t *data, int offset, int len) { void scrambling_b_offset_pusch(srslte_sequence_t *s, uint8_t *data, int offset, int len) {
int i; int i;
assert (len + offset <= s->len); assert (len + offset <= s->len);
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
@ -96,22 +96,22 @@ int compute_sequences(scrambling_hl* h) {
switch (h->init.channel) { switch (h->init.channel) {
case SCRAMBLING_PBCH: case SCRAMBLING_PBCH:
return sequence_pbch(&h->obj.seq[0], return srslte_sequence_pbch(&h->obj.seq[0],
h->init.nof_symbols == SRSLTE_SRSLTE_SRSLTE_CP_NORM_NSYMB ? SRSLTE_SRSLTE_CP_NORM : SRSLTE_SRSLTE_CP_EXT, h->init.cell_id); h->init.nof_symbols == SRSLTE_SRSLTE_SRSLTE_CP_NORM_NSYMB ? SRSLTE_SRSLTE_CP_NORM : SRSLTE_SRSLTE_CP_EXT, h->init.cell_id);
case SCRAMBLING_PDSCH: case SCRAMBLING_PDSCH:
for (int ns = 0; ns < SRSLTE_NSUBFRAMES_X_FRAME; ns++) { for (int ns = 0; ns < SRSLTE_NSUBFRAMES_X_FRAME; ns++) {
sequence_pdsch(&h->obj.seq[ns], h->init.nrnti, 0, 2 * ns, h->init.cell_id, srslte_sequence_pdsch(&h->obj.seq[ns], h->init.nrnti, 0, 2 * ns, h->init.cell_id,
SRSLTE_NSOFT_BITS); SRSLTE_NSOFT_BITS);
} }
return 0; return 0;
case SCRAMBLING_PCFICH: case SCRAMBLING_PCFICH:
for (int ns = 0; ns < SRSLTE_NSUBFRAMES_X_FRAME; ns++) { for (int ns = 0; ns < SRSLTE_NSUBFRAMES_X_FRAME; ns++) {
sequence_pcfich(&h->obj.seq[ns], 2 * ns, h->init.cell_id); srslte_sequence_pcfich(&h->obj.seq[ns], 2 * ns, h->init.cell_id);
} }
return 0; return 0;
case SCRAMBLING_PDCCH: case SCRAMBLING_PDCCH:
for (int ns = 0; ns < SRSLTE_NSUBFRAMES_X_FRAME; ns++) { for (int ns = 0; ns < SRSLTE_NSUBFRAMES_X_FRAME; ns++) {
sequence_pdcch(&h->obj.seq[ns], 2 * ns, h->init.cell_id, SRSLTE_NSOFT_BITS); srslte_sequence_pdcch(&h->obj.seq[ns], 2 * ns, h->init.cell_id, SRSLTE_NSOFT_BITS);
} }
return 0; return 0;
case SCRAMBLING_PMCH: case SCRAMBLING_PMCH:
@ -139,7 +139,7 @@ int scrambling_work(scrambling_hl* hl) {
} else { } else {
sf = hl->ctrl_in.subframe; sf = hl->ctrl_in.subframe;
} }
sequence_t *seq = &hl->obj.seq[sf]; srslte_sequence_t *seq = &hl->obj.seq[sf];
if (hl->init.hard) { if (hl->init.hard) {
memcpy(hl->output, hl->input, sizeof(uint8_t) * hl->in_len); memcpy(hl->output, hl->input, sizeof(uint8_t) * hl->in_len);
@ -155,7 +155,7 @@ int scrambling_work(scrambling_hl* hl) {
int scrambling_stop(scrambling_hl* hl) { int scrambling_stop(scrambling_hl* hl) {
int i; int i;
for (i = 0; i < SRSLTE_NSUBFRAMES_X_FRAME; i++) { for (i = 0; i < SRSLTE_NSUBFRAMES_X_FRAME; i++) {
sequence_free(&hl->obj.seq[i]); srslte_sequence_free(&hl->obj.seq[i]);
} }
return 0; return 0;
} }

18
srslte/lib/scrambling/test/scrambling_test.c
Unescape Escape View File

@ -36,7 +36,7 @@
#include "srslte/srslte.h" #include "srslte/srslte.h"
char *sequence_name = NULL; char *srslte_sequence_name = NULL;
bool do_floats = false; bool do_floats = false;
srslte_cp_t cp = SRSLTE_SRSLTE_CP_NORM; srslte_cp_t cp = SRSLTE_SRSLTE_CP_NORM;
int cell_id = -1; int cell_id = -1;
@ -61,7 +61,7 @@ void parse_args(int argc, char **argv) {
do_floats = true; do_floats = true;
break; break;
case 's': case 's':
sequence_name = argv[optind]; srslte_sequence_name = argv[optind];
break; break;
default: default:
usage(argv[0]); usage(argv[0]);
@ -72,15 +72,15 @@ void parse_args(int argc, char **argv) {
usage(argv[0]); usage(argv[0]);
exit(-1); exit(-1);
} }
if (!sequence_name) { if (!srslte_sequence_name) {
usage(argv[0]); usage(argv[0]);
exit(-1); exit(-1);
} }
} }
int init_sequence(sequence_t *seq, char *name) { int init_sequence(srslte_sequence_t *seq, char *name) {
if (!strcmp(name, "PBCH")) { if (!strcmp(name, "PBCH")) {
return sequence_pbch(seq, cp, cell_id); return srslte_sequence_pbch(seq, cp, cell_id);
} else { } else {
fprintf(stderr, "Unsupported sequence name %s\n", name); fprintf(stderr, "Unsupported sequence name %s\n", name);
return -1; return -1;
@ -90,14 +90,14 @@ int init_sequence(sequence_t *seq, char *name) {
int main(int argc, char **argv) { int main(int argc, char **argv) {
int i; int i;
sequence_t seq; srslte_sequence_t seq;
uint8_t *input_b, *scrambled_b; uint8_t *input_b, *scrambled_b;
float *input_f, *scrambled_f; float *input_f, *scrambled_f;
parse_args(argc, argv); parse_args(argc, argv);
if (init_sequence(&seq, sequence_name) == -1) { if (init_sequence(&seq, srslte_sequence_name) == -1) {
fprintf(stderr, "Error initiating sequence %s\n", sequence_name); fprintf(stderr, "Error initiating sequence %s\n", srslte_sequence_name);
exit(-1); exit(-1);
} }
@ -160,6 +160,6 @@ int main(int argc, char **argv) {
free(scrambled_f); free(scrambled_f);
} }
printf("Ok\n"); printf("Ok\n");
sequence_free(&seq); srslte_sequence_free(&seq);
exit(0); exit(0);
} }

4
srslte/lib/ue/src/ue_cell_search.c
Unescape Escape View File

@ -39,13 +39,13 @@
float tmp_pss_corr[32*10000]; float tmp_pss_corr[32*10000];
float tmp_sss_corr[31*10000]; float tmp_sss_corr[31*10000];
int ue_cell_search_init(ue_cell_search_t * q, int (recv_callback)(void*, void*, uint32_t,timestamp_t*), void *stream_handler) int ue_cell_search_init(ue_cell_search_t * q, int (recv_callback)(void*, void*, uint32_t,srslte_timestamp_t*), void *stream_handler)
{ {
return ue_cell_search_init_max(q, CS_DEFAULT_MAXFRAMES_TOTAL, recv_callback, stream_handler); return ue_cell_search_init_max(q, CS_DEFAULT_MAXFRAMES_TOTAL, recv_callback, stream_handler);
} }
int ue_cell_search_init_max(ue_cell_search_t * q, uint32_t max_frames, int ue_cell_search_init_max(ue_cell_search_t * q, uint32_t max_frames,
int (recv_callback)(void*, void*, uint32_t,timestamp_t*), void *stream_handler) int (recv_callback)(void*, void*, uint32_t,srslte_timestamp_t*), void *stream_handler)
{ {
int ret = SRSLTE_ERROR_INVALID_INPUTS; int ret = SRSLTE_ERROR_INVALID_INPUTS;

20
srslte/lib/ue/src/ue_dl.c
Unescape Escape View File

@ -249,15 +249,15 @@ int ue_dl_find_ul_dci(ue_dl_t *q, dci_msg_t *dci_msg, uint32_t cfi, uint32_t sf_
{ {
dci_location_t locations[MAX_CANDIDATES]; dci_location_t locations[MAX_CANDIDATES];
uint32_t nof_locations = pdcch_ue_locations(&q->pdcch, locations, MAX_CANDIDATES, sf_idx, cfi, rnti); uint32_t nof_locations = pdcch_ue_locations(&q->pdcch, locations, MAX_CANDIDATES, sf_idx, cfi, rnti);
uint16_t crc_rem = 0; uint16_t srslte_crc_rem = 0;
for (uint32_t i=0;i<nof_locations && crc_rem != rnti;i++) { for (uint32_t i=0;i<nof_locations && srslte_crc_rem != rnti;i++) {
if (pdcch_decode_msg(&q->pdcch, dci_msg, &locations[i], Format0, &crc_rem)) { if (pdcch_decode_msg(&q->pdcch, dci_msg, &locations[i], Format0, &srslte_crc_rem)) {
fprintf(stderr, "Error decoding DCI msg\n"); fprintf(stderr, "Error decoding DCI msg\n");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
INFO("Decoded DCI message RNTI: 0x%x\n", crc_rem); INFO("Decoded DCI message RNTI: 0x%x\n", srslte_crc_rem);
} }
return crc_rem == rnti; return srslte_crc_rem == rnti;
} }
int ue_dl_decode_rnti_rv(ue_dl_t *q, cf_t *input, uint8_t *data, uint32_t sf_idx, uint16_t rnti, uint32_t rvidx) int ue_dl_decode_rnti_rv(ue_dl_t *q, cf_t *input, uint8_t *data, uint32_t sf_idx, uint16_t rnti, uint32_t rvidx)
@ -266,7 +266,7 @@ int ue_dl_decode_rnti_rv(ue_dl_t *q, cf_t *input, uint8_t *data, uint32_t sf_idx
dci_msg_t dci_msg; dci_msg_t dci_msg;
dci_location_t locations[MAX_CANDIDATES]; dci_location_t locations[MAX_CANDIDATES];
uint32_t nof_locations; uint32_t nof_locations;
uint16_t crc_rem; uint16_t srslte_crc_rem;
int ret = SRSLTE_ERROR; int ret = SRSLTE_ERROR;
uint32_t nof_formats; uint32_t nof_formats;
dci_format_t *formats = NULL; dci_format_t *formats = NULL;
@ -287,18 +287,18 @@ int ue_dl_decode_rnti_rv(ue_dl_t *q, cf_t *input, uint8_t *data, uint32_t sf_idx
} }
/* For all possible locations, try to decode a DCI message */ /* For all possible locations, try to decode a DCI message */
crc_rem = 0; srslte_crc_rem = 0;
uint32_t found_dci = 0; uint32_t found_dci = 0;
for (int f=0;f<nof_formats && !found_dci;f++) { for (int f=0;f<nof_formats && !found_dci;f++) {
INFO("Trying format %s\n", dci_format_string(formats[f])); INFO("Trying format %s\n", dci_format_string(formats[f]));
for (i=0;i<nof_locations && !found_dci;i++) { for (i=0;i<nof_locations && !found_dci;i++) {
if (pdcch_decode_msg(&q->pdcch, &dci_msg, &locations[i], formats[f], &crc_rem)) { if (pdcch_decode_msg(&q->pdcch, &dci_msg, &locations[i], formats[f], &srslte_crc_rem)) {
fprintf(stderr, "Error decoding DCI msg\n"); fprintf(stderr, "Error decoding DCI msg\n");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
INFO("Decoded DCI message RNTI: 0x%x\n", crc_rem); INFO("Decoded DCI message RNTI: 0x%x\n", srslte_crc_rem);
if (crc_rem == rnti) { if (srslte_crc_rem == rnti) {
found_dci++; found_dci++;
ret = ue_dl_decode_rnti_rv_packet(q, &dci_msg, data, cfi, sf_idx, rnti, rvidx); ret = ue_dl_decode_rnti_rv_packet(q, &dci_msg, data, cfi, sf_idx, rnti, rvidx);
} }

Some files were not shown because too many files have changed in this diff Show More

Write Preview
Loading…
Cancel
Save